fix(orchestrator): the run headline could be raw planner JSON

pl.Summary is model-authored, and a model that was asked for JSON sometimes
puts JSON there. Measured on a run that had otherwise gone perfectly:

  ✔ "assumptions": [ "The REST API will support basic CRUD operations for tasks with — 5/5 tasks done

The counts and the gate verdict on that line were correct, so the run looked
broken while being fine — the worst way for a summary to be wrong.

The headline now refuses a serialized object and falls back to the board query,
which is the request in the operator own words and always a truthful
description of what the run was for. The last-resort string is the one
firstSentence already uses, so the two paths cannot print a different
"nothing to say".

Author: piotrlaczkowski

pkg/orchestrator/headline_test.go

@@ -0,0 +1,69 @@
+package orchestrator
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/UnicoLab/slmcode/pkg/plan"
+)
+
+// Measured on a finished run:
+//
+//	✔ "assumptions": [ "The REST API will support basic CRUD operations for tasks with — 5/5 tasks done
+//
+// The counts and the gate verdict on that line were correct, so the run looked
+// broken while being fine — the worst way for a summary to be wrong.
+func TestHeadlineRejectsRawPlannerJSON(t *testing.T) {
+	board := &plan.Board{Query: "Build a Go REST backend in cmd/server/main.go"}
+	for _, summary := range []string{
+		`"assumptions": [ "The REST API will support basic CRUD operations for tasks with`,
+		`{"summary":"build the thing","steps":[]}`,
+		`[{"id":"T1"}]`,
+	} {
+		got := runHeadline(plan.Plan{Summary: summary}, board)
+		if looksLikeRawJSON(got) {
+			t.Errorf("headline is still JSON: %q", got)
+		}
+		if !strings.Contains(got, "Build a Go REST backend") {
+			t.Errorf("did not fall back to the request: %q", got)
+		}
+	}
+}
+
+// A real summary is used verbatim — the guard must not eat good output.
+func TestHeadlineKeepsARealSummary(t *testing.T) {
+	board := &plan.Board{Query: "the raw request"}
+	got := runHeadline(plan.Plan{Summary: "Add a task store and wire the server to it."}, board)
+	if !strings.HasPrefix(got, "Add a task store") {
+		t.Errorf("got %q, want the plan's own summary", got)
+	}
+}
+
+// With neither a usable summary nor a query, say something true rather than
+// printing an empty leading dash.
+func TestHeadlineFallsBackLast(t *testing.T) {
+	if got := runHeadline(plan.Plan{}, &plan.Board{}); got != "Run complete" {
+		t.Errorf("got %q, want a truthful fallback", got)
+	}
+	if got := runHeadline(plan.Plan{Summary: `{"a":1}`}, nil); got != "Run complete" {
+		t.Errorf("nil board: got %q", got)
+	}
+}
+
+func TestLooksLikeRawJSON(t *testing.T) {
+	for _, tc := range []struct {
+		in   string
+		want bool
+	}{
+		{`{"summary":"x"}`, true},
+		{`[{"id":"T1"}]`, true},
+		{`"assumptions": [ "the api`, true},
+		{"Add a task store and wire the server to it.", false},
+		{"Fix the failing test in stats.go", false},
+		{"", false},
+	} {
+		if got := looksLikeRawJSON(tc.in); got != tc.want {
+			t.Errorf("looksLikeRawJSON(%q) = %v, want %v", tc.in, got, tc.want)
+		}
+	}
+}

pkg/orchestrator/orchestrator.go

@@ -2543,7 +2543,7 @@ func summarizeWithRepairs(board *plan.Board, pl plan.Plan, repairs *repairLedger
 		}
 	}
 	out := fmt.Sprintf("%s — %d/%d tasks done, %d failed",
-		firstSentence(pl.Summary), done, total, board.FailedCount())
+		runHeadline(pl, board), done, total, board.FailedCount())
 	if line := repairs.line(); line != "" {
 		out += " · " + line
 	}
@@ -2835,3 +2835,49 @@ func truncate(s string, n int) string {
 	}
 	return s[:n] + "\n...[truncated]"
 }
+
+// runHeadline is the one clean sentence a finished run leads with.
+//
+// pl.Summary is model-authored, and a model that was asked for JSON sometimes
+// puts JSON there. Measured: a run finished with
+//
+//	✔ "assumptions": [ "The REST API will support basic CRUD operations for tasks with — 5/5 tasks done
+//
+// which is the planner's raw object bleeding into the headline. The rest of the
+// line — the counts, the gate verdict — was correct, so the run looked broken
+// while being fine, which is the worst way for a summary to be wrong.
+//
+// Falls back to the board's own query, which is the request in the operator's
+// words and always a truthful description of what the run was for.
+func runHeadline(pl plan.Plan, board *plan.Board) string {
+	summary := strings.TrimSpace(pl.Summary)
+	if summary != "" && !looksLikeRawJSON(summary) {
+		if s := strings.TrimSpace(firstSentence(summary)); s != "" && !looksLikeRawJSON(s) {
+			return s
+		}
+	}
+	if board != nil {
+		if q := strings.TrimSpace(firstSentence(board.Query)); q != "" && !looksLikeRawJSON(q) {
+			return q
+		}
+	}
+	// Same words firstSentence falls back to, so the two paths cannot print a
+	// different "nothing to say".
+	return "Run complete"
+}
+
+// looksLikeRawJSON reports whether a string is a serialized object rather than
+// prose. Deliberately shallow: it only has to catch a model echoing its own
+// contract, not validate JSON.
+func looksLikeRawJSON(s string) bool {
+	s = strings.TrimSpace(s)
+	if s == "" {
+		return false
+	}
+	if strings.HasPrefix(s, "{") || strings.HasPrefix(s, "[") {
+		return true
+	}
+	// A quoted key followed by a colon — `"assumptions": [` — is the shape that
+	// survives a first-sentence cut of a pretty-printed object.
+	return strings.Contains(s, `":`) || strings.Contains(s, `" :`)
+}