@cleocode/goal 0.0.0-stage → 0.9.2

package/src/summary/build.ts

@@ -0,0 +1,314 @@
+// T045 — the post-goal summary. One pure builder turning what the run
+// already has (contract, run state, ledger) into a summary the owner and the
+// agent both see on terminal transitions: per-criterion outcomes WITH
+// provenance — owner-approved and fallback-passed criteria carry explicit
+// caveats, never silently equal to host-proven — the scope audit flags
+// (T046), restated non-goals, mid-run findings from the ledger, and
+// follow-up prompts including the CLEO-install suggestion when the project
+// has no .cleo workspace. Rendered by the TUI dialog, a one-line
+// goal.summary notice and a persisted evidence file.
+import type { Contract } from "../contract/types"
+import type { RunState } from "../engine/state"
+
+export type Provenance = "host" | "verifier" | "verifier-fallback" | "human"
+
+export type SummaryCriterion = {
+  id: string
+  statement: string
+  status: "pass" | "fail" | "unknown"
+  by?: Provenance
+  detail?: string
+  caveat?: string
+}
+
+export type ScopeAuditFlag = {
+  /** what was discussed but left unproven: a plan step or a scope.in item */
+  kind: "step" | "scope"
+  id: string
+  title: string
+  why: string
+}
+
+export type SummaryFinding = { kind: string; text: string; at?: number }
+
+export type PostGoalSummary = {
+  slug: string
+  title: string
+  status: string
+  turns: number
+  headline: string
+  /** One line saying what this run actually finished, for a 3-second read. */
+  completed: string
+  /** What went right, most load-bearing first. */
+  wentRight: string[]
+  /** What went wrong (failures, flags, blockers, verifier trouble). */
+  wentWrong: string[]
+  /** What still needs a fix or an owner decision. Empty ⇒ nothing blocking. */
+  stillOpen: string[]
+  /** Linked CLEO tasks and follow-ups the run logged. */
+  tasks: string[]
+  /** Concrete suggested next actions. */
+  nextSteps: string[]
+  /** A screen-fit digest (≤14 lines) for the dialog; `text` is the full report. */
+  digest: string
+  criteria: SummaryCriterion[]
+  caveats: string[]
+  scopeAudit: ScopeAuditFlag[]
+  nonGoals: string[]
+  findings: SummaryFinding[]
+  followUps: string[]
+  text: string
+}
+
+const countBy = (criteria: SummaryCriterion[], by: Provenance) => criteria.filter((c) => c.status === "pass" && c.by === by).length
+
+/** The provenance split on one line, e.g. "host 6 · verifier 2 · owner 1". */
+export function provenanceSplit(criteria: SummaryCriterion[]): string | undefined {
+  const parts = [
+    ["host", countBy(criteria, "host")],
+    ["verifier", countBy(criteria, "verifier")],
+    ["owner", countBy(criteria, "human")],
+    ["fallback", countBy(criteria, "verifier-fallback")],
+  ].filter(([, n]) => Number(n) > 0) as Array<[string, number]>
+  return parts.length ? parts.map(([k, n]) => `${k} ${n}`).join(" · ") : undefined
+}
+
+/** The screen-fit digest: what a human needs in 3–5 seconds, then the three
+ *  things they act on. Hard-capped at 14 lines so it never overflows a
+ *  dialog — the full report (criteria, non-goals, findings) stays in `text`. */
+export function buildDigest(s: Omit<PostGoalSummary, "digest" | "text">): string {
+  const lines: string[] = []
+  const icon = s.status === "complete" ? "✓" : s.status === "failed" ? "✗" : s.status === "budget_limited" ? "⊘" : "⚑"
+  const proven = s.criteria.filter((c) => c.status === "pass").length
+  const terminal = new Set(["complete", "failed", "aborted", "needs_review", "budget_limited"])
+  const stopped = terminal.has(s.status) ? "loop stopped" : "loop running"
+  lines.push(`${icon} ${s.status.replace(/_/g, " ")} · ${proven}/${s.criteria.length} proven · ${s.turns} turn${s.turns === 1 ? "" : "s"} · ${stopped}`)
+  lines.push(s.completed)
+  if (s.tasks.length) lines.push(`TASKS  ${s.tasks.slice(0, 2).join(" · ")}${s.tasks.length > 2 ? ` · +${s.tasks.length - 2}` : ""}`)
+  const section = (title: string, items: string[], mark: string, cap: number, overflow = true) => {
+    lines.push(title)
+    for (const item of items.slice(0, cap)) lines.push(`  ${mark} ${item}`)
+    if (overflow && items.length > cap) lines.push(`  … +${items.length - cap} more — F9 for all`)
+  }
+  section("WENT RIGHT", s.wentRight.length ? s.wentRight : ["nothing recorded"], "+", 2)
+  section("WENT WRONG", s.wentWrong.length ? s.wentWrong : ["nothing — no failed checks"], "−", 2)
+  section("STILL OPEN", s.stillOpen.length ? s.stillOpen : ["nothing blocking"], "·", 1)
+  section("NEXT", s.nextSteps.length ? s.nextSteps : ["/goal status"], "→", 2, false)
+  return lines.slice(0, 14).join("\n")
+}
+
+/** The caveat a provenance carries. Owner approvals and fenced-json
+ *  fallbacks are real evidence but weaker than host/verifier proof — the
+ *  summary says so instead of laundering them as equivalent. */
+export function provenanceCaveat(by: Provenance | undefined): string | undefined {
+  if (by === "human") return "approved by the owner — final; not independently re-checked"
+  if (by === "verifier-fallback") return "parsed from the verifier's prose fallback (fenced json, not a tool call); quotes were re-read by the host"
+  return undefined
+}
+
+const label = (status: string) => (status === "pass" ? "✓ pass" : status === "fail" ? "✗ fail" : "· unknown")
+
+/** Mid-run findings worth surfacing at the end, from the run's ledger:
+ *  criterion flags, blocker keys, empty verifier rounds, fallback parses,
+ *  amendments and budget stops. Unknown types are ignored. */
+export function findingsFromLedger(events: Array<Record<string, unknown>>): SummaryFinding[] {
+  const out: SummaryFinding[] = []
+  for (const e of events) {
+    const at = typeof e.at === "number" ? e.at : typeof e.turn === "number" ? e.turn : undefined
+    if (e.type === "flag") out.push({ kind: "flag", text: `${e.criterion ? `${e.criterion}: ` : ""}${String(e.reason ?? e.kind ?? "flagged")}`, at })
+    else if (e.type === "blocked") {
+      const blocker = (e.blocker ?? {}) as { key?: string; reason?: string; count?: number }
+      out.push({ kind: "blocked", text: `${blocker.key ?? "blocker"} — ${blocker.reason ?? "owner decision needed"}${blocker.count ? ` (raised ${blocker.count}×)` : ""}`, at })
+    } else if (e.type === "verifier-empty") out.push({ kind: "verifier-empty", text: `verifier round ${e.round} returned an empty exchange (retried/recorded)`, at })
+    else if (e.type === "verifier-fallback") out.push({ kind: "verifier-fallback", text: `${e.count} verdict(s) parsed from a prose-answering verifier`, at })
+    else if (e.type === "amended") out.push({ kind: "amended", text: `contract amended (generation ${e.generation ?? "?"}): ${e.summary ?? ""}`, at })
+    else if (e.type === "amend-proposed") out.push({ kind: "amend-proposed", text: `amendment proposed: ${e.summary ?? ""}`, at })
+    else if (e.type === "budget_limited") out.push({ kind: "budget_limited", text: "the run hit its budget", at })
+  }
+  return out
+}
+
+export type SummaryInput = {
+  contract: Contract
+  state: RunState
+  ledgerEvents?: Array<Record<string, unknown>>
+  /** the project's cleo-linkage probe result; absent → install suggestion */
+  cleo?: { source: string } | undefined
+  /** T046: flagged unproven plan steps / scope.in items; empty until wired */
+  scopeAudit?: ScopeAuditFlag[]
+  /** v0.8.0 C4: the loop started the next ready item, so it did not stop. */
+  continued?: boolean
+}
+
+export function buildPostGoalSummary(input: SummaryInput): PostGoalSummary {
+  const { contract, state } = input
+  const criteria: SummaryCriterion[] = [...contract.criteria, ...contract.invariants].map((c) => {
+    const s = state.criteria[c.id]
+    const status = s?.status === "pass" ? ("pass" as const) : s?.status === "fail" ? ("fail" as const) : ("unknown" as const)
+    const by = (s?.by as Provenance | undefined) ?? undefined
+    return { id: c.id, statement: c.statement, status, by, detail: s?.detail, caveat: status === "pass" ? provenanceCaveat(by) : undefined }
+  })
+  const caveats = criteria.filter((c) => c.caveat).map((c) => `${c.id} — ${c.caveat}`)
+  const scopeAudit = input.scopeAudit ?? []
+  const findings = findingsFromLedger(input.ledgerEvents ?? [])
+  const proven = criteria.filter((c) => c.status === "pass").length
+
+  const followUps: string[] = []
+  if (state.status === "complete") {
+    followUps.push(input.continued
+      ? "The loop kept going: the next ready item was started by itself. Inspect it in the Goal manager (/goal list)."
+      : "Start the next goal: /goal new <what you want done> — the non-goals below are the ready-made backlog.")
+  } else if (state.status === "needs_review") {
+    followUps.push("Resolve the review: /goal approve <C#> (final) or /goal reject <C#> <why>, then /goal verify.")
+  } else if (state.status === "budget_limited") {
+    followUps.push("Raise the budget in goal.yaml and start a new run, or wrap up: /goal archive after aborting.")
+  }
+  if (scopeAudit.length) followUps.push("Break the discussed-but-unproven items out into a follow-up goal so they stop riding on this one.")
+  followUps.push("Decompose long-running work with CLEO" + (input.cleo ? " (this project is already linked; keep tasks completing with evidence)." : ": this project has no .cleo workspace — installing it gives goals a task board that outlives any single run (the link stays optional and CLI-only)."))
+
+  const headline =
+    state.status === "complete"
+      ? `goal complete — ${proven}/${criteria.length} criteria proven${caveats.length ? `, ${caveats.length} with provenance caveats` : ""}`
+      : `goal ${state.status} — ${proven}/${criteria.length} criteria proven, ${criteria.length - proven} not yet`
+
+  // What actually finished, in one sentence a human can scan. The contract's
+  // outcome is the end state; the linked CLEO tasks are the durable record.
+  const cleoTasks = (contract.cleo?.tasks ?? []).map((t) => t.id)
+  const completed = state.status === "complete"
+    ? `${contract.outcome}${cleoTasks.length ? ` — ${cleoTasks.join(", ")} closed` : ""}`
+    : `${contract.outcome} — ${proven}/${criteria.length} proven, ${criteria.length - proven} still open`
+
+  // What went right: proof first, then the run's own clean facts.
+  const wentRight: string[] = []
+  const split = provenanceSplit(criteria)
+  const rejections = Object.values(state.criteria).reduce((n, c) => n + (c.rejections ?? 0), 0)
+  wentRight.push(`${proven}/${criteria.length} criteria proven${split ? ` (${split})` : ""}`)
+  if (!criteria.some((c) => c.status === "fail")) wentRight.push(rejections === 0 ? "no failed checks and no rejected claims" : "no failed criteria at the end")
+  const acceptedAmendments = state.amendments.filter((a) => a.status === "accepted").length
+  if (acceptedAmendments) wentRight.push(`${acceptedAmendments} amendment${acceptedAmendments === 1 ? "" : "s"} accepted and re-locked`)
+
+  // What went wrong: failures, then the ledger findings that cost time.
+  const wentWrong: string[] = []
+  for (const c of criteria.filter((c) => c.status === "fail")) {
+    wentWrong.push(`${c.id} ${c.statement} — ${(c.detail ?? "failed").split("\n")[0]}`)
+  }
+  for (const f of findings) {
+    if (f.kind === "amended" || f.kind === "amend-proposed") continue
+    wentWrong.push(f.text)
+  }
+  if (rejections) wentWrong.push(`${rejections} rejected claim${rejections === 1 ? "" : "s"} before the final pass`)
+
+  // What still needs a fix or an owner decision. Empty is a success state.
+  const stillOpen: string[] = []
+  for (const c of criteria.filter((c) => c.status !== "pass")) stillOpen.push(`${c.id} ${c.statement} — ${c.status}`)
+  for (const f of scopeAudit) stillOpen.push(`${f.kind === "step" ? `plan step ${f.id}` : `scope.in ${f.id}`} ${f.title} — discussed but unproven`)
+  if (state.blocker) stillOpen.push(`${state.blocker.key} — ${state.blocker.reason}`)
+  if (state.status === "needs_review") stillOpen.push("owner review is waiting")
+
+  // Tasks the run logged: linked CLEO tasks and peer candidates (follow-up
+  // prompts are separate, so the digest can stay one short line).
+  const tasks: string[] = []
+  if (cleoTasks.length) tasks.push(`CLEO ${cleoTasks.join(", ")}`)
+  for (const candidate of state.peer?.candidates ?? []) tasks.push(`peer ${candidate.from ?? candidate.project}: ${candidate.title}${candidate.taskId ? ` (${candidate.taskId})` : ""}`)
+
+  // Suggested next actions, shortest path first.
+  const nextSteps: string[] = []
+  if (state.status === "complete") {
+    nextSteps.push(input.continued ? "Inspect the goal that started by itself — /goal list" : "Start the next goal — /goal new <what you want done>")
+    nextSteps.push(`Break this into tasks — /goal decompose ${state.slug}`)
+    nextSteps.push("Close it out — /goal archive")
+  } else if (state.status === "needs_review") {
+    nextSteps.push("Answer the review — /goal approve <C#> or /goal reject <C#> <why>")
+    nextSteps.push("Re-run the checks — /goal verify")
+  } else if (state.status === "budget_limited") {
+    nextSteps.push("Raise the budget in goal.yaml, then start a new run")
+    nextSteps.push("Or wrap up — /goal archive")
+  } else {
+    nextSteps.push("Inspect the goal — /goal status")
+    nextSteps.push("Start a goal yourself — /goal new <what you want done>")
+  }
+
+  const lines: string[] = []
+  lines.push(`# Post-goal summary — ${contract.title}`)
+  lines.push(`${headline} · ${state.turn} turn(s)`)
+  lines.push("")
+  // T071: completion silence read as broken — the summary states plainly
+  // what stopped. v0.8.0 C4: when the loop took the next item, this goal is
+  // still finished but the loop is not.
+  lines.push(input.continued
+    ? `This goal has stopped (${state.status}); the loop started the next ready item and kept going. This goal itself no longer runs, verifies, or spends.`
+    : `The loop has stopped (${state.status}). Nothing further runs, verifies, or spends on its own.`)
+  lines.push(`Follow-ups live here: the list below, the Goal panel (F9), and .opencode/goals/${state.slug}/ (ledger, evidence, this summary).`)
+  lines.push("")
+  lines.push("## The short version")
+  lines.push(completed)
+  lines.push("")
+  lines.push("## What went right")
+  for (const item of wentRight) lines.push(`- ${item}`)
+  lines.push("")
+  lines.push("## What went wrong")
+  for (const item of wentWrong.length ? wentWrong : ["nothing — no failed checks, flags, or blockers"]) lines.push(`- ${item}`)
+  lines.push("")
+  lines.push("## Still needs fixing")
+  for (const item of stillOpen.length ? stillOpen : ["nothing — every contracted criterion is proven"]) lines.push(`- ${item}`)
+  if (tasks.length) {
+    lines.push("")
+    lines.push("## Tasks")
+    for (const item of tasks) lines.push(`- ${item}`)
+  }
+  lines.push("")
+  lines.push("## Next steps")
+  nextSteps.forEach((item, i) => lines.push(`${i + 1}. ${item}`))
+  lines.push("")
+  lines.push(`Outcome (as contracted): ${contract.outcome}`)
+  lines.push("")
+  lines.push("## Criteria")
+  for (const c of criteria) {
+    lines.push(`- ${label(c.status)} ${c.id} [${c.by ?? "unattributed"}] ${c.statement}${c.caveat ? `\n    caveat: ${c.caveat}` : ""}${c.status !== "pass" && c.detail ? `\n    ${c.detail.split("\n")[0]}` : ""}`)
+  }
+  if (scopeAudit.length) {
+    lines.push("")
+    lines.push("## Scope audit — discussed but unproven (flagged, not blocking)")
+    for (const f of scopeAudit) lines.push(`- ${f.kind === "step" ? `plan step ${f.id}` : `scope.in ${f.id}`} — ${f.title}: ${f.why}`)
+  }
+  if (contract.non_goals.length) {
+    lines.push("")
+    lines.push("## Non-goals (deliberately not done)")
+    for (const ng of contract.non_goals) lines.push(`- ${ng}`)
+  }
+  if (findings.length) {
+    lines.push("")
+    lines.push("## Mid-run findings")
+    for (const f of findings) lines.push(`- ${f.kind}: ${f.text}`)
+  }
+  if (caveats.length) {
+    lines.push("")
+    lines.push("## Provenance caveats")
+    for (const c of caveats) lines.push(`- ${c}`)
+  }
+  lines.push("")
+  lines.push("## Follow-ups")
+  for (const f of followUps) lines.push(`- ${f}`)
+
+  const base = {
+    slug: state.slug,
+    title: state.title,
+    status: state.status,
+    turns: state.turn,
+    headline,
+    completed,
+    wentRight,
+    wentWrong,
+    stillOpen,
+    tasks,
+    nextSteps,
+    criteria,
+    caveats,
+    scopeAudit,
+    nonGoals: contract.non_goals,
+    findings,
+    followUps,
+  }
+  return { ...base, digest: buildDigest(base), text: lines.join("\n") }
+}
+

package/src/tui/dashboard.ts

@@ -0,0 +1,322 @@
+// T056 — the dashboard rework. The v0.2 panel streamed raw ledger actions:
+// a wall of text, programmatic, not designed for human use — and the sidebar
+// was completely overtaken. Everything here is PURE: the compact card is
+// capped at 12 lines, the panel is organized into Now / Progress / Decisions
+// / Goals tabs with plain-language criteria and a C/I/S legend footer, and
+// actionable rows become keyboard-selectable models the TUI renders as
+// native Select components. The raw ledger timeline is gone from the UI (it
+// stays in the file).
+import type { GoalSummary, GoalView, TimelineEntry } from "../rpc"
+import { bar, elapsed, endStateCopy, fit, fmtTokens, type Line, type Tone } from "./format"
+import { tracerLines } from "./tracer"
+
+
+export type DashboardTab = "now" | "progress" | "decisions" | "goals"
+export const DASHBOARD_TABS: DashboardTab[] = ["now", "progress", "decisions", "goals"]
+
+const STATUS: Record<string, { icon: string; label: string; tone: Tone }> = {
+  running: { icon: "▶", label: "running", tone: "success" },
+  waiting: { icon: "◷", label: "waiting", tone: "info" },
+  verifying: { icon: "◐", label: "verifying", tone: "info" },
+  paused: { icon: "⏸", label: "paused", tone: "warning" },
+  blocked: { icon: "⛔", label: "blocked", tone: "error" },
+  needs_review: { icon: "⚑", label: "needs review", tone: "warning" },
+  budget_limited: { icon: "⊘", label: "budget used", tone: "warning" },
+  complete: { icon: "✓", label: "complete", tone: "success" },
+  failed: { icon: "✗", label: "failed", tone: "error" },
+  aborted: { icon: "■", label: "aborted", tone: "muted" },
+  superseded: { icon: "⇢", label: "superseded", tone: "muted" },
+}
+const statusOf = (s: string) => STATUS[s] ?? { icon: "·", label: s, tone: "muted" as Tone }
+
+const provenCount = (view: GoalView) => view.criteria.filter((c) => c.status === "pass").length
+
+/** (A) The sidebar card: hard-capped at 12 lines. Status, one progress bar,
+ *  the current step, the next action, ONE action-required line — never a
+ *  timeline. T073: rows that the width truncates carry a `tab` hint naming
+ *  the panel tab that holds their full text, and the card always ends with
+ *  an explicit expand affordance (F9 opens it). */
+export function cardCompactLines(view: GoalView, now: number, width = 40): Line[] {
+  const st = statusOf(view.status)
+  const lines: Line[] = []
+  const head = "◎ Goal"
+  const right = `${st.icon} ${st.label}`
+  lines.push({ text: `${head}${" ".repeat(Math.max(1, width - head.length - right.length))}${right}`, tone: st.tone, bold: true })
+  if (view.actionRequired) lines.push({ text: fit(`⚑ ${view.actionRequired}`, width), tone: "error", bold: true, tab: "decisions" })
+  lines.push({ text: fit(view.title, width), tone: "base", bold: true, tab: "now" })
+  const total = view.criteria.length
+  lines.push({ text: `criteria ${bar(provenCount(view), total)} ${provenCount(view)}/${total}`, tone: provenCount(view) === total && total ? "success" : "muted" })
+  // the three criteria that need eyes: failing first, then unproven, then proven
+  const focus = [...view.criteria].sort((a, b) => (a.status === "fail" ? -1 : b.status === "fail" ? 1 : a.status === "pass" ? 1 : b.status === "pass" ? -1 : 0)).slice(0, 3)
+  for (const c of focus) {
+    const mark = c.status === "pass" ? "✓" : c.status === "fail" ? "✗" : "·"
+    const tone: Tone = c.status === "pass" ? "success" : c.status === "fail" ? "error" : "muted"
+    lines.push({ text: fit(`${mark} ${c.id} ${c.statement}`, width), tone, tab: "progress" })
+  }
+  if (view.steps.length) {
+    const current = view.steps.find((s) => s.status === "active") ?? view.steps.find((s) => s.status !== "done")
+    if (current) lines.push({ text: fit(`▸ ${current.id} ${current.title}`, width), tone: "base", tab: "now" })
+  }
+  const tokens = view.usage.tokens ? ` · ${fmtTokens(view.usage.tokens)} tok` : ""
+  lines.push({ text: fit(`turn ${view.turn}${tokens}`, width), tone: view.budgetRatio >= 0.8 ? "warning" : "muted" })
+  // T071: at a terminal state the card says the loop stopped and where the
+  // follow-ups live (the progress note is moot then). Compact form: the slug
+  // path fits the sidebar; the full line lives in the banner and the panel.
+  const stopped = endStateCopy(view.status, view.slug)
+  if (stopped) lines.push({ text: fit(`■ loop stopped — follow-ups: .opencode/goals/${view.slug}/`, width), tone: stopped.tone })
+  else if (view.progress) lines.push({ text: fit(`↻ ${view.progress.note}`, width), tone: "muted", tab: "now" })
+  // T073: the expand affordance always occupies the card's last line — the
+  // cap stays 12; the sections the width truncated name their panel tab so
+  // the affordance is a click-through, not a dead hint. Short enough to stay
+  // readable at the narrowest sidebar.
+  const tabs = [...new Set(lines.filter((l) => l.tab && l.text.includes("…")).map((l) => l.tab!))]
+  const affordance = tabs.length
+    ? `↳ F9 → ${TAB_LABEL[tabs[0] as DashboardTab]}${tabs.length > 1 ? ` (+${tabs.length - 1})` : ""}`
+    : "↳ full card — F9"
+  lines.push({ text: fit(affordance, width), tone: "info" })
+  return lines.slice(0, 12)
+}
+
+/** (T073) The expanded card: the same shape as the compact card but EVERY
+ *  row rendered fully — statements wrap to the width instead of truncating
+ *  with `…`, and nothing is dropped for line count. Rendered in the panel
+ *  (the compact card's affordance opens it at the matching tab); pure and
+ *  snapshot-tested alongside the compact card. */
+export function cardExpandedLines(view: GoalView, now: number, width = 46): Line[] {
+  const st = statusOf(view.status)
+  const lines: Line[] = []
+  const emit = (text: string, tone: Tone, opts: { bold?: boolean; tab?: DashboardTab } = {}) => {
+    const [first, ...rest] = wrap(text, width)
+    if (first === undefined) return
+    lines.push({ text: first, tone, ...(opts.bold ? { bold: true } : {}), ...(opts.tab ? { tab: opts.tab } : {}) })
+    for (const r of rest) lines.push({ text: r, tone })
+  }
+  emit(`◎ GOAL ${st.icon} ${st.label}${view.reason ? ` — ${view.reason}` : ""}`, st.tone, { bold: true })
+  const stopped = endStateCopy(view.status, view.slug)
+  if (stopped) emit(stopped.text, stopped.tone)
+  emit(view.title, "base", { bold: true, tab: "now" })
+  if (view.actionRequired) emit(`⚑ ${view.actionRequired}`, "error", { bold: true, tab: "decisions" })
+  lines.push({ text: `criteria ${bar(provenCount(view), view.criteria.length)} ${provenCount(view)}/${view.criteria.length}`, tone: provenCount(view) === view.criteria.length && view.criteria.length ? "success" : "muted", tab: "progress" })
+  // every criterion, failing first — the compact card's 3-row focus set
+  // fully expanded here
+  const ordered = [...view.criteria].sort((a, b) => (a.status === "fail" ? -1 : b.status === "fail" ? 1 : 0))
+  for (const c of ordered) {
+    const mark = c.status === "pass" ? "✓" : c.status === "fail" ? "✗" : c.status === "claimed" ? "◐" : "·"
+    const tone: Tone = c.status === "pass" ? "success" : c.status === "fail" ? "error" : "muted"
+    emit(`${mark} ${c.invariant ? "I" : "C"} ${c.id} — ${c.statement}`, tone, { tab: "progress" })
+    if (c.detail && c.status !== "pass") emit(`  ${c.detail}`, tone)
+  }
+  if (view.steps.length) {
+    lines.push({ text: "plan", tone: "base", bold: true })
+    for (const s of view.steps) emit(`S ${s.id} ${s.status === "done" ? "✓" : s.status === "active" ? "▸" : "·"} ${s.title}`, s.status === "active" ? "info" : s.status === "done" ? "success" : "muted", { tab: "now" })
+  }
+  const elapsedMs = elapsed(view, now)
+  const tokens = view.usage.tokens ? ` · ${fmtTokens(view.usage.tokens)} tok` : ""
+  const spend = view.usage.cost ? ` · $${view.usage.cost.toFixed(2)}` : ""
+  lines.push({ text: `turn ${view.turn} · ${Math.floor(elapsedMs / 60000)}m${tokens}${spend}`, tone: view.budgetRatio >= 0.8 ? "warning" : "muted" })
+  if (view.progress) emit(`↻ ${view.progress.note}${view.progress.next ? ` → ${view.progress.next}` : ""}`, "muted", { tab: "now" })
+  if (view.verdict) {
+    lines.push({ text: `last verdict — ${view.verdict.passed ? "passed" : "failed"}`, tone: view.verdict.passed ? "success" : "warning", bold: true })
+    for (const l of view.verdict.lines.slice(0, 5)) emit(`  ${l.split("\n")[0]}`, view.verdict.passed ? "success" : "warning")
+  }
+  return lines
+}
+
+/** Word-wrap text to width: the expanded view's "every row fully" guarantee —
+ *  long statements become multiple lines, never `…`. */
+export const wrap = (text: string, width: number): string[] => {
+  const flat = text.replace(/\s+/g, " ").trim()
+  if (!flat) return []
+  if (flat.length <= width) return [flat]
+  const out: string[] = []
+  let line = ""
+  for (const word of flat.split(" ")) {
+    if (!line.length) line = word
+    else if (line.length + 1 + word.length <= width) line += ` ${word}`
+    else {
+      out.push(line)
+      line = word
+    }
+  }
+  if (line.length) out.push(line)
+  // a single word longer than the width still has to land somewhere
+  return out.flatMap((l) => (l.length <= width ? [l] : (l.match(new RegExp(`.{1,${width}}`, "g")) ?? [l])))
+}
+
+const TAB_LABEL: Record<DashboardTab, string> = { now: "Now", progress: "Progress", decisions: "Decisions", goals: "Goals" }
+
+/** T073: the panel tab the compact card's expand affordance opens on — the
+ *  highest-priority section the sidebar width truncated (decisions first,
+ *  then criteria, then step/progress). Undefined when nothing truncated:
+ *  F9 opens the panel where it was. */
+export function cardAffordanceTab(view: GoalView, now: number, width = 40): DashboardTab | undefined {
+  const order: DashboardTab[] = ["decisions", "progress", "now"]
+  const truncated = new Set(cardCompactLines(view, now, width).filter((l) => l.tab && l.text.includes("…")).map((l) => l.tab!))
+  return order.find((t) => truncated.has(t))
+}
+
+const humanKinds = new Set(["verdict", "approve", "reject", "amend-proposed", "amended", "blocked", "complete", "summary", "flag", "attached", "paused", "resumed", "aborted", "budget_limited", "superseded-by", "approve ", "reject "])
+
+/** (T074 sign-off fix) Quick acts: owner actions that ALWAYS make sense for
+ *  the goal's current state — the Decisions tab is interactive even when no
+ *  decision is open (the owner's "nothing to select" defect: a wall of text
+ *  whenever the run is quiet). */
+export function quickActRows(view: GoalView): ActionRow[] {
+  const rows: ActionRow[] = []
+  if (["running", "waiting", "verifying"].includes(view.status)) {
+    rows.push({ label: "Pause the goal", description: "stop the loop; /goal resume picks it up", act: "pause" })
+    rows.push({ label: "Verify now", description: "run the host checks + verifier immediately", act: "verify" })
+  } else if (view.status === "paused") {
+    rows.push({ label: "Resume the goal", description: view.reason ?? "continue the loop", act: "resume" })
+    rows.push({ label: "Verify now", description: "run the host checks + verifier immediately", act: "verify" })
+  } else if (view.status === "blocked") {
+    rows.push({ label: "Resolved — resume", description: view.blocker?.reason ?? "the blocker is fixed", act: "resume" })
+    rows.push({ label: "Abort the goal", description: "stop for good; history stays", act: "abort" })
+  } else if (view.status === "needs_review") {
+    const unproven = view.criteria.filter((c) => !c.invariant && c.status !== "pass")
+    for (const c of unproven.slice(0, 3)) rows.push({ label: `Approve ${c.id} (final)`, description: c.statement, act: "approve", arg: c.id })
+    rows.push({ label: "Verify now", description: "run the host checks + verifier immediately", act: "verify" })
+  } else if (view.status === "budget_limited") {
+    rows.push({ label: "Abort the goal", description: "stop at the budget", act: "abort" })
+  } else if (isTerminalStatus(view.status)) {
+    rows.push({ label: "Archive the goal", description: "demote to goals-archive/ (history intact)", act: "archive" })
+    rows.push({ label: "Start the next goal", description: "open the write-goal interview", act: "start-next" })
+  }
+  rows.push({ label: "Pause/Resume/Verify are also one keystroke away", description: "/goal pause · /goal resume · /goal verify — or the palette (ctrl+p → Goal)" })
+  return rows
+}
+
+const TERMINAL_STATUSES = new Set(["complete", "failed", "aborted", "superseded"])
+const isTerminalStatus = (s: string) => TERMINAL_STATUSES.has(s)
+
+/** (E) only human-relevant events surface in the UI — raw turn/admit noise stays in the ledger file. */
+export const humanizedEvents = (view: GoalView, n: number): TimelineEntry[] => {
+  const relevant = view.timeline.filter((e) => humanKinds.has(e.kind) || /^(owner|verdict|goal complete|summary|blocked|amended|flag)/i.test(e.text))
+  return relevant.slice(-n).reverse()
+}
+
+/** (C) actionable rows: keyboard-selectable models dispatching rpc.act. */
+export type ActionRow = { label: string; description: string; act?: string; arg?: string }
+
+export function decisionRows(view: GoalView): ActionRow[] {
+  const rows: ActionRow[] = []
+  if (view.actionRequired) {
+    if (view.status === "needs_review") {
+      const unproven = view.criteria.filter((c) => !c.invariant && c.status !== "pass")
+      for (const c of unproven) rows.push({ label: `Approve ${c.id} (final)`, description: c.statement, act: "approve", arg: c.id })
+      rows.push({ label: "Reject a criterion", description: "/goal reject <C#> <why>", act: "reject" })
+    } else if (view.status === "blocked") {
+      rows.push({ label: "Resolved — resume", description: view.blocker?.reason ?? "the blocker is fixed", act: "resume" })
+      rows.push({ label: "Abort the goal", description: "stop for good; history stays", act: "abort" })
+    } else if (view.status === "budget_limited") {
+      rows.push({ label: "Raise budget and amend", description: "Describe the budget change in the Composer; review the agent's staged diff" })
+      rows.push({ label: "Abort the goal", description: "stop at the budget", act: "abort" })
+    }
+  }
+  if (view.status === "paused") rows.push({ label: "Resume the goal", description: view.reason ?? "", act: "resume" })
+  if (view.status === "complete") rows.push({ label: "Archive the goal", description: "demote to goals-archive/ (history intact)", act: "archive" })
+  if (view.amendments) rows.push({ label: "Confirm proposed amendment", description: "/goal amend confirm", act: "amend", arg: "confirm" })
+  return rows
+}
+
+/** (T065) Dialogs are not scrollable on the real TUI: a full post-goal
+ *  summary (~50 lines) overflowed off the owner's screen. Everything shown
+ *  in a dialog goes through this digest: headline, the first lines, and a
+ *  pointer to where the rest lives. */
+export function dialogDigest(title: string, text: string, maxLines = 14, maxCols = 100): string {
+  const lines = text.split("\n").map((l) => (l.length > maxCols ? `${l.slice(0, maxCols - 1)}…` : l))
+  const head = lines.slice(0, maxLines)
+  const rest = lines.length - head.length
+  return [title, ...head, ...(rest > 0 ? [`… +${rest} more lines — full text: the Goal panel (F9) or .opencode/goals/ evidence` ] : [])].join("\n")
+}
+
+/** (B) the tabbed panel body. Pure; snapshot-tested. T073: the panel is the
+ *  expanded view of the compact card — every row wraps to the width instead
+ *  of truncating with `…`, so nothing the card cut off is unreadable here at
+ *  any width (the TUI passes the panel's real width). T074 sign-off fixes:
+ *  the ACTIVE tab is bracketed (visual structure beyond a wall of text),
+ *  section headers carry rules, and the Decisions tab ALWAYS renders a
+ *  keyboard-selectable act list (open decisions first, then quick acts). */
+export function dashboardLines(view: GoalView, tab: DashboardTab, now: number, width = 46, goals: GoalSummary[] = []): Line[] {
+  const st = statusOf(view.status)
+  const lines: Line[] = []
+  const emit = (text: string, tone: Tone, bold = false) => {
+    for (const part of wrap(text, width)) lines.push({ text: part, tone, ...(bold ? { bold: true } : {}) })
+  }
+  const rule = () => lines.push({ text: "─".repeat(Math.max(8, Math.min(width, 40))), tone: "muted" })
+  const tabsHeader = DASHBOARD_TABS.map((t) => (t === tab ? `[${TAB_LABEL[t]}]` : ` ${TAB_LABEL[t]} `)).join("")
+  lines.push({ text: fit(`◎ GOAL ${st.icon} ${st.label}`, width), tone: st.tone, bold: true })
+  lines.push({ text: fit(tabsHeader, width), tone: "base", bold: true })
+  rule()
+  lines.push({ text: "", tone: "base" })
+
+  if (tab === "now") {
+    emit(view.title, "base", true)
+    emit(view.outcome, "muted")
+    lines.push(...tracerLines(view, now, width))
+    const current = view.steps.find((s) => s.status === "active") ?? view.steps.find((s) => s.status !== "done")
+    if (current) emit(`▸ step ${current.id} ${current.title}`, "base")
+    if (view.progress?.next) emit(`next: ${view.progress.next}`, "muted")
+    if (view.actionRequired) emit(`⚑ ${view.actionRequired}`, "error", true)
+    else if (["running", "waiting", "verifying"].includes(view.status)) emit("✓ nothing needed from you — the loop is working", "success")
+    const events = humanizedEvents(view, 3)
+    if (events.length) {
+      lines.push({ text: "recent", tone: "base", bold: true })
+      rule()
+      for (const e of events) emit(`· ${e.text}`, "muted")
+    }
+  } else if (tab === "progress") {
+    const groups: Array<[string, typeof view.criteria, Tone]> = [
+      ["Failed", view.criteria.filter((c) => c.status === "fail"), "error"],
+      ["In progress", view.criteria.filter((c) => c.status !== "pass" && c.status !== "fail"), "muted"],
+      ["Proven", view.criteria.filter((c) => c.status === "pass"), "success"],
+    ]
+    emit(`criteria ${bar(provenCount(view), view.criteria.length)} ${provenCount(view)}/${view.criteria.length}`, "base", true)
+    for (const [label, items, tone] of groups) {
+      if (!items.length) continue
+      lines.push({ text: label, tone, bold: true })
+      rule()
+      for (const c of items) emit(`${c.invariant ? "I" : "C"} ${c.id} — ${c.statement}${c.by ? ` (${c.by})` : ""}`, tone)
+    }
+    if (view.steps.length) {
+      lines.push({ text: "plan", tone: "base", bold: true })
+      rule()
+      for (const s of view.steps) emit(`S ${s.id} ${s.status === "done" ? "✓" : s.status === "active" ? "▸" : "·"} ${s.title}`, s.status === "active" ? "info" : s.status === "done" ? "success" : "muted")
+    }
+    if (view.verdict) {
+      lines.push({ text: `last verdict — ${view.verdict.passed ? "passed" : "failed"}`, tone: view.verdict.passed ? "success" : "warning", bold: true })
+      for (const l of view.verdict.lines.slice(0, 3)) emit(l.split("\n")[0]!, view.verdict.passed ? "success" : "warning")
+    }
+  } else if (tab === "decisions") {
+    lines.push({ text: "act on a row (↑↓ · enter)", tone: "base", bold: true })
+    lines.push({ text: "", tone: "base" })
+    // the interactive rows render as the Select component in the TUI —
+    // these lines are the readable mirror of the same list
+    const history = humanizedEvents(view, 6)
+    if (history.length) {
+      lines.push({ text: "history", tone: "base", bold: true })
+      rule()
+      for (const e of history) emit(`· ${e.text}`, "muted")
+    }
+  } else {
+    const others = goals.filter((g) => g.slug !== view.slug)
+    emit(`this goal: ${view.title} (${st.label})`, "base", true)
+    if (others.length) {
+      lines.push({ text: "other goals", tone: "base", bold: true })
+      rule()
+      for (const g of others) emit(`· ${g.slug} — ${g.title} (${g.status})${g.attachable ? " · attachable" : ""}`, g.terminal ? "muted" : "info")
+    } else lines.push({ text: "no other goals in this project", tone: "muted" })
+    if (view.steps.length) {
+      lines.push({ text: "upcoming steps", tone: "base", bold: true })
+      rule()
+      for (const s of view.steps.filter((s) => s.status !== "done")) emit(`S ${s.id} · ${s.title}`, "muted")
+    }
+  }
+
+  lines.push({ text: "", tone: "base" })
+  // T073: the legend wraps to two short lines so it never truncates at the
+  // panel's narrowest width
+  lines.push({ text: fit("C criterion · I invariant · S plan step", width), tone: "muted" })
+  lines.push({ text: fit("↑↓/tab/enter to act", width), tone: "muted" })
+  return lines
+}

package/src/tui/decision-form.ts

@@ -0,0 +1,12 @@
+/** Forward an actual owner dialog choice into the exact native question.
+ * Never match on a label alone or interpret free commentary as a choice. */
+export function decisionFormAnswer(forms: readonly any[], question: string, label: string): { formID: string; answer: Record<string, string> } | undefined {
+  for (const form of forms) {
+    if (form.state?.status && form.state.status !== "pending") continue
+    if (form.fields?.length !== 1) continue
+    const field = form.fields[0]
+    if (!field.key || field.title !== question && field.description !== question) continue
+    const option = field.options?.find((o: any) => o.label === label && typeof o.value === "string")
+    if (option) return { formID: form.id, answer: { [field.key]: option.value } }
+  }
+}