Move run completion summary from Linear to the cockpit

The per-run completion/blocked summary (outcome, AC evidence, debug bundle
link) was posted as a Linear comment on every run. Move it to the cockpit so
Linear stays a clean control plane: state transitions only, with the "why"
living in the cockpit ticket detail.

- New Cockpit.RunSummaryStore: one markdown per issue under
  /opt/symphony/state/run-summaries (SYMPHONY_COCKPIT_SUMMARY_DIR), separate
  root from the QA evidence store so the two completion-time writers never race.
- CompletionSummary.publish writes to the store instead of Tracker; build_comment
  drops the debug-bundle plumbing. publish_async signature unchanged, so the
  WorkpadPrSync caller is untouched.
- DebugBundle deleted: CompletionSummary was its only caller, and the bundle
  only existed to attach to the Linear comment. Removed rather than left dead.
- Board reads each issue's summary (local disk, bounded by the board cache) and
  exposes it as ticket.summary; cockpit detail renders a "Run summary" section.
- Test stores point at tmp via test_helper so the suite never writes to
  /opt/symphony; integration tests assert routing, summary content is unit-tested.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: viniciuscffreitas

dashboard/src/features/board/components/ticket-detail.test.tsx

@@ -30,6 +30,15 @@ describe("TicketDetail", () => {
     expect(screen.getByText(/no loading flicker \| PASS/)).toBeInTheDocument();
   });
 
+  it("renders the run summary when present", async () => {
+    render(<TicketDetail ticket={running} onClose={() => {}} />);
+    await screen.findByText("Timeline");
+    expect(screen.getByText("Run summary")).toBeInTheDocument();
+    expect(
+      screen.getByText(/Moved to `In Code Review` after PR checks and Symphony gates passed/)
+    ).toBeInTheDocument();
+  });
+
   it("exposes Linear, GitHub PR and Langfuse trace as new-tab links", async () => {
     render(<TicketDetail ticket={running} onClose={() => {}} />);
     await screen.findByText("Timeline");

dashboard/src/features/board/components/ticket-detail.tsx

@@ -141,19 +141,32 @@ function Body({ ticket }: { ticket: Ticket }) {
           </section>
         </div>
 
+        {ticket.summary && (
+          <section>
+            <SectionLabel>Run summary</SectionLabel>
+            <MarkdownBlock>{ticket.summary}</MarkdownBlock>
+          </section>
+        )}
+
         {ticket.report && (
           <section>
             <SectionLabel>QA report</SectionLabel>
-            <pre className="overflow-x-auto whitespace-pre-wrap rounded-md border bg-muted/40 p-3 font-mono text-xs leading-relaxed">
-              {ticket.report.trim()}
-            </pre>
+            <MarkdownBlock>{ticket.report}</MarkdownBlock>
           </section>
         )}
       </div>
     </>
   );
 }
 
+function MarkdownBlock({ children }: { children: string }) {
+  return (
+    <pre className="overflow-x-auto whitespace-pre-wrap rounded-md border bg-muted/40 p-3 font-mono text-xs leading-relaxed">
+      {children.trim()}
+    </pre>
+  );
+}
+
 function SectionLabel({ children }: { children: React.ReactNode }) {
   return (
     <h3 className="mb-3 text-xs font-medium uppercase tracking-wide text-muted-foreground">

dashboard/src/features/board/contract.ts

@@ -46,6 +46,7 @@ export const Ticket = z.object({
   pr: Pr.nullable(),
   evidence: z.array(Evidence),
   report: z.string().nullable().optional(), // QA self-review report (markdown), from the evidence store
+  summary: z.string().nullable().optional(), // run completion summary (markdown), from the run summary store
   timeline: z.array(TimelineStep).optional(),
   url: z.string().url().nullable().optional(), // Linear issue link
   traceUrl: z.string().url().nullable().optional(), // Langfuse trace link

dashboard/src/features/board/fixtures.ts

@@ -51,6 +51,8 @@ export const MOCK_BOARD: BoardPayload = {
       ],
       report:
         "- Result: PASS\n\n| Check | Result |\n| --- | --- |\n| debounce fires one request | PASS |\n| no loading flicker | PASS |\n",
+      summary:
+        "## Ready for review\n\n**Outcome:** Moved to `In Code Review` after PR checks and Symphony gates passed.\n**PR:** https://github.com/schoolsoutapp/fe-next-app/pull/642\n",
       timeline: [
         { label: "Read issue and extracted acceptance criteria", turn: 1, status: "done" },
         { label: "Implemented debounce in SearchInput", turn: 2, status: "done" },

elixir/lib/symphony_elixir/cockpit/api.ex

@@ -11,7 +11,7 @@ defmodule SymphonyElixir.Cockpit.Api do
 
   use Plug.Router
 
-  alias SymphonyElixir.Cockpit.{BoardCache, BoardView, Checks, EvidenceStore}
+  alias SymphonyElixir.Cockpit.{BoardCache, BoardView, Checks, EvidenceStore, RunSummaryStore}
   alias SymphonyElixir.Config
   alias SymphonyElixir.RunLedger.Report
   alias SymphonyElixir.Tracker
@@ -55,7 +55,8 @@ defmodule SymphonyElixir.Cockpit.Api do
     BoardView.assemble(issues, read_runs(), tracker,
       running: read_running(),
       ci: ci_map(issues),
-      evidence: evidence_map(issues)
+      evidence: evidence_map(issues),
+      summary: summary_map(issues)
     )
   end
 
@@ -65,6 +66,11 @@ defmodule SymphonyElixir.Cockpit.Api do
     Map.new(issues, fn issue -> {issue.id, EvidenceStore.read(issue.id)} end)
   end
 
+  # Completion summary markdown per issue, read from the local cockpit store.
+  defp summary_map(issues) do
+    Map.new(issues, fn issue -> {issue.id, RunSummaryStore.read(issue.id)} end)
+  end
+
   # CI status per PR url, fetched once per board build (bounded by BoardCache).
   defp ci_map(issues) do
     issues

elixir/lib/symphony_elixir/cockpit/board_view.ex

@@ -49,6 +49,8 @@ defmodule SymphonyElixir.Cockpit.BoardView do
     ci = Map.new(Keyword.get(opts, :ci, []))
     # QA evidence manifests keyed by internal issue id (cockpit evidence store).
     evidence = Map.new(Keyword.get(opts, :evidence, []))
+    # Completion summary markdown keyed by internal issue id (run summary store).
+    summary = Map.new(Keyword.get(opts, :summary, []))
 
     %{
       "states" => %{
@@ -60,11 +62,11 @@ defmodule SymphonyElixir.Cockpit.BoardView do
         "onReject" => tracker.on_reject_state,
         "terminal" => list(tracker.terminal_states)
       },
-      "tickets" => Enum.map(issues, &ticket(&1, runs_by_ticket, trace_base, running, ci, evidence))
+      "tickets" => Enum.map(issues, &ticket(&1, runs_by_ticket, trace_base, running, ci, evidence, summary))
     }
   end
 
-  defp ticket(%Issue{} = issue, runs_by_ticket, trace_base, running, ci, evidence) do
+  defp ticket(%Issue{} = issue, runs_by_ticket, trace_base, running, ci, evidence, summary) do
     run = Map.get(runs_by_ticket, issue.identifier)
     status = if MapSet.member?(running, issue.id), do: "running", else: "idle"
     manifest = Map.get(evidence, issue.id, %{})
@@ -83,6 +85,7 @@ defmodule SymphonyElixir.Cockpit.BoardView do
       "pr" => pr(issue, ci),
       "evidence" => evidence_items(issue.id, manifest),
       "report" => Map.get(manifest, "report"),
+      "summary" => Map.get(summary, issue.id),
       "url" => issue.url,
       "traceUrl" => trace_url(run, trace_base),
       "updatedAt" => issue.updated_at || ""

elixir/lib/symphony_elixir/cockpit/run_summary_store.ex

@@ -0,0 +1,40 @@
+defmodule SymphonyElixir.Cockpit.RunSummaryStore do
+  @moduledoc """
+  On-box store for a run's completion summary, shown in the cockpit ticket
+  detail instead of posted as a tracker comment. One markdown file per issue
+  (keyed by the orchestrator's internal issue id), overwritten each completion.
+
+  Root is `SYMPHONY_COCKPIT_SUMMARY_DIR` (default
+  `/opt/symphony/state/run-summaries`). Deliberately separate from the QA
+  evidence store: both writers fire at completion time as concurrent tasks, so
+  keeping them in different directories means they never race on the same path.
+  """
+
+  require Logger
+
+  @default_dir "/opt/symphony/state/run-summaries"
+
+  @spec dir() :: String.t()
+  def dir, do: System.get_env("SYMPHONY_COCKPIT_SUMMARY_DIR") || @default_dir
+
+  @doc "Write (overwrite) the per-issue completion summary markdown."
+  @spec put(String.t(), String.t()) :: :ok
+  def put(issue_id, markdown) when is_binary(issue_id) and is_binary(markdown) do
+    File.mkdir_p!(dir())
+    File.write!(file(issue_id), markdown)
+    :ok
+  end
+
+  @doc "The per-issue completion summary markdown, or `nil` when none is stored."
+  @spec read(String.t()) :: String.t() | nil
+  def read(issue_id) when is_binary(issue_id) do
+    case File.read(file(issue_id)) do
+      {:ok, content} -> content
+      _ -> nil
+    end
+  end
+
+  defp file(issue_id), do: Path.join(dir(), sanitize(issue_id) <> ".md")
+
+  defp sanitize(issue_id), do: String.replace(issue_id, ~r/[^A-Za-z0-9._-]/, "_")
+end

elixir/lib/symphony_elixir/orchestrator/completion_summary.ex

@@ -1,15 +1,16 @@
 defmodule SymphonyElixir.Orchestrator.CompletionSummary do
   @moduledoc """
-  Posts the single human-facing completion/blocked comment for a run.
+  Writes the single human-facing completion/blocked summary for a run.
 
-  Detailed internal artifacts are uploaded as one debug zip and linked from
-  this comment instead of being scattered through the Linear thread.
+  The summary used to be a tracker comment; it now goes to the cockpit run
+  summary store (`SymphonyElixir.Cockpit.RunSummaryStore`) and surfaces in the
+  cockpit ticket detail, keeping the tracker a clean control plane. One markdown
+  per issue, overwritten each completion.
   """
 
   require Logger
 
-  alias SymphonyElixir.Orchestrator.DebugBundle
-  alias SymphonyElixir.Tracker
+  alias SymphonyElixir.Cockpit.RunSummaryStore
 
   @max_ac_evidence_chars 3_000
 
@@ -23,38 +24,35 @@ defmodule SymphonyElixir.Orchestrator.CompletionSummary do
     :ok
   end
 
+  # `parent_comment_id` is a tracker-thread leftover, now ignored — the summary
+  # no longer posts to Linear.
   @doc false
   @spec publish(map(), String.t() | nil, map(), term(), String.t() | nil) :: :ok
-  def publish(issue, target_state, running_entry, reason, parent_comment_id) do
-    bundle_result = DebugBundle.create_and_upload(issue, running_entry, reason)
-    body = build_comment(issue, target_state, running_entry, reason, bundle_result)
-    issue_id = Map.get(issue, :id)
-    opts = if is_binary(parent_comment_id), do: [parent_id: parent_comment_id], else: []
-
-    case Tracker.create_comment(issue_id, body, opts) do
-      {:ok, comment_id} ->
-        Logger.info("Completion summary posted issue=#{identifier(issue, running_entry)} comment=#{comment_id}")
-
-      {:error, reason} ->
-        Logger.warning("Completion summary failed issue=#{identifier(issue, running_entry)} reason=#{inspect(reason)}")
+  def publish(issue, target_state, running_entry, reason, _parent_comment_id) do
+    body = build_comment(issue, target_state, running_entry, reason)
+
+    case Map.get(issue, :id) do
+      issue_id when is_binary(issue_id) ->
+        RunSummaryStore.put(issue_id, body)
+        Logger.info("Completion summary stored issue=#{identifier(issue, running_entry)}")
+
+      _ ->
+        Logger.warning("Completion summary skipped (missing issue id) issue=#{identifier(issue, running_entry)}")
     end
 
     :ok
   end
 
   @doc false
-  @spec build_comment(map(), String.t() | nil, map(), term(), {:ok, String.t()} | {:error, term()}) :: String.t()
-  def build_comment(issue, target_state, running_entry, reason, bundle_result) do
+  @spec build_comment(map(), String.t() | nil, map(), term()) :: String.t()
+  def build_comment(issue, target_state, running_entry, reason) do
     [
       heading(reason),
       "",
       "**Outcome:** #{outcome(reason, target_state)}",
       pr_line(issue),
       ac_evidence_block(running_entry),
-      qa_line(reason),
-      debug_bundle_line(bundle_result),
-      "",
-      "_Posted by Symphony. Detailed agent artifacts are in the debug bundle._"
+      qa_line(reason)
     ]
     |> Enum.reject(&is_nil/1)
     |> Enum.join("\n")
@@ -123,22 +121,19 @@ defmodule SymphonyElixir.Orchestrator.CompletionSummary do
         |> String.trim()
         |> String.slice(0, @max_ac_evidence_chars)
 
-      suffix = if String.length(text) > @max_ac_evidence_chars, do: "\n\n_(truncated; full text in debug bundle)_", else: ""
+      suffix = if String.length(text) > @max_ac_evidence_chars, do: "\n\n_(truncated)_", else: ""
       "### AC evidence\n\n#{trimmed}#{suffix}"
     else
-      "**AC evidence:** not captured in the final agent text; see debug bundle for the last message."
+      "**AC evidence:** not captured in the final agent text."
     end
   end
 
   defp qa_line(:qa_artifact_missing), do: "**QA evidence:** missing; visual QA was required."
 
   defp qa_line(_reason) do
-    "**QA evidence:** screenshots/video/trace are published separately when present; raw files are also in the debug bundle."
+    "**QA evidence:** screenshots/video are published to the cockpit when present."
   end
 
-  defp debug_bundle_line({:ok, url}), do: "**Debug bundle:** [agent-debug.zip](#{url})"
-  defp debug_bundle_line({:error, reason}), do: "**Debug bundle:** unavailable (#{inspect(reason)})."
-
   defp inline_list(items) when is_list(items) do
     Enum.map_join(items, ", ", &"`#{&1}`")
   end