infinity-harness 2.2.1 → 2.3.1

package/src/loop.ts

@@ -39,6 +39,13 @@ import {
   type EscalationState,
 } from "./escalate.ts";
 import { loadGoal, recordPipelinePass, viewOf } from "./goal.ts";
+import {
+  needsApproval,
+  requestApproval,
+  describeApproval,
+  renderApprovalRequest,
+  rejectionStandsFor,
+} from "./approval.ts";
 
 export const LOOP_STATE_FILE = "loop-state.json";
 export const STOP_FILE = "STOP";
@@ -89,7 +96,13 @@ export type LoopDecision =
   | { action: "continue"; message: string; reason: string }
   | { action: "advanced"; toPhase: Phase; message: string; reason: string }
   | { action: "stop"; reason: string; detail: string }
-  | { action: "wait"; reason: string; detail: string };
+  | { action: "wait"; reason: string; detail: string }
+  /**
+   * The gate passed, but this phase decides *what gets built* and the human
+   * asked to sign it. The run parks here until they answer; it does not
+   * advance, and it does not count as being stuck.
+   */
+  | { action: "approve"; phase: Phase; message: string; detail: string; reason: string };
 
 export function loopStatePath(targetDir: string): string {
   return resolve(harnessDir(targetDir), LOOP_STATE_FILE);
@@ -232,6 +245,15 @@ export async function decideNext(options: DecideOptions): Promise<{ decision: Lo
       detail: "The pipeline is paused. Unpause to continue.",
     });
   }
+  if (config.awaitingApproval) {
+    return finish({
+      action: "wait",
+      reason: "awaiting-approval",
+      detail:
+        `${config.awaitingApproval.toUpperCase()} is waiting for your approval. ` +
+        "`/infinity:approve` continues; `/infinity:approve <what is wrong>` sends it back.",
+    });
+  }
 
   state.lastPhase = config.currentPhase;
 
@@ -294,10 +316,40 @@ export async function decideNext(options: DecideOptions): Promise<{ decision: Lo
 
   const gate = options.skipGate ? null : await runChecks(targetDir, phase, { record: true });
 
-  if (gate && gate.overall) {
+  // A phase the human already sent back, on a project that has not moved
+  // since, is not ready to be asked about again. The gate is deterministic:
+  // without this it passes on the very next tick and the human is asked the
+  // identical question about the identical artefact, forever.
+  //
+  // Crucially this is treated as a *failure*, not as its own early return. An
+  // early return skipped the no-progress detector entirely — so an agent that
+  // ignored the rejection re-briefed itself without limit, which is the one
+  // thing an unattended loop must never do. Falling through means the same
+  // budgets, the same strikes and the same escalation ladder apply.
+  const standingRejection =
+    gate && gate.overall && needsApproval(config, phase) && config.awaitingApproval !== phase
+      ? rejectionStandsFor(config, phase, await fingerprint(targetDir))
+      : null;
+
+  if (gate && gate.overall && !standingRejection) {
     state.noProgressStreak = 0;
     state.lastFingerprint = await fingerprint(targetDir);
 
+    // A passed gate on an approvable phase is not permission to continue — it
+    // is permission to *ask*. The gate proves the phase produced what it was
+    // supposed to produce; only the human can say it produced the right thing.
+    if (needsApproval(config, phase) && config.awaitingApproval !== phase) {
+      requestApproval(targetDir, phase);
+      const request = describeApproval(phase);
+      return finish({
+        action: "approve",
+        reason: "awaiting-approval",
+        phase,
+        message: renderApprovalRequest(request),
+        detail: `${phase.toUpperCase()} is waiting for your approval.`,
+      });
+    }
+
     const upcoming = nextPhase(phase, config.phases?.enabled);
     if (upcoming === null) {
       return finish({
@@ -316,6 +368,19 @@ export async function decideNext(options: DecideOptions): Promise<{ decision: Lo
       });
     }
 
+    // A new phase starts with no baseline.
+    //
+    // Without this the first failure of the new phase compares the tree
+    // against the fingerprint taken when the *previous* phase passed — which
+    // is of course identical, because nothing has happened yet — and is
+    // counted as a stall. The run then escalated on the first turn of every
+    // phase, spending `retry` and `reframe` on an agent that had not yet been
+    // given a chance to do anything. A stall means the agent produced nothing
+    // when asked; a fresh brief has not asked yet.
+    state.lastFingerprint = null;
+    state.noProgressStreak = 0;
+    state.escalation = { ...state.escalation, tried: [] };
+
     const brief = await buildBrief(targetDir);
     return finish({
       action: "advanced",
@@ -399,9 +464,12 @@ export async function decideNext(options: DecideOptions): Promise<{ decision: Lo
   if (state.noProgressStreak >= budget.noProgressLimit) {
     return finish({
       action: "stop",
-      reason: "no-progress",
-      detail:
-        `The gate has failed ${state.noProgressStreak} times in a row with no change to the working tree ` +
+      reason: standingRejection ? "rejection-unaddressed" : "no-progress",
+      detail: standingRejection
+        ? `You sent ${phase.toUpperCase()} back ${state.noProgressStreak} turns ago and nothing has ` +
+          `changed since. The agent is not acting on it: "${standingRejection.note}". ` +
+          `Stopping so you can take over.`
+        : `The gate has failed ${state.noProgressStreak} times in a row with no change to the working tree ` +
         `or the plan. The agent is looping without making progress` +
         (gate ? `: ${gate.failures.join(", ")}` : "") +
         `.` +
@@ -435,14 +503,22 @@ export async function decideNext(options: DecideOptions): Promise<{ decision: Lo
 
   // An escalation replaces the standard "fix these" nudge, because repeating
   // that nudge is exactly what the ladder exists to interrupt.
-  const head = escalation?.instruction
-    ? `${escalation.instruction}\n`
-    : `The ${phase.toUpperCase()} gate did not pass. Fix exactly these, then stop talking — ` +
-      `the harness will re-validate automatically.\n\n${failures}${focus}\n`;
+  const head = standingRejection
+    ? `A human reviewed ${phase.toUpperCase()} and sent it back. Nothing in the project has changed ` +
+      `since, so the run is still waiting on this and nothing else:\n\n  ${standingRejection.note}\n\n` +
+      `Fix that, then validate again.${focus}\n`
+    : escalation?.instruction
+      ? `${escalation.instruction}\n`
+      : `The ${phase.toUpperCase()} gate did not pass. Fix exactly these, then stop talking — ` +
+        `the harness will re-validate automatically.\n\n${failures}${focus}\n`;
 
   return finish({
     action: "continue",
-    reason: escalation?.strategy ? `escalated: ${describeEscalation(escalation)}` : "gate failed",
+    reason: standingRejection
+      ? "rejected, not yet addressed"
+      : escalation?.strategy
+        ? `escalated: ${describeEscalation(escalation)}`
+        : "gate failed",
     message: `${head}\n${renderBrief(brief, fresh.ok ? fresh.config : undefined)}`,
   });
 }
@@ -495,6 +571,8 @@ export function describeDecision(d: LoopDecision): string {
       return `advanced to ${d.toPhase}`;
     case "wait":
       return `waiting — ${d.detail}`;
+    case "approve":
+      return `waiting for your approval of ${d.phase}`;
     case "stop":
       return `stopped — ${d.detail}`;
   }

package/src/remote.ts

@@ -18,11 +18,12 @@ import { createServer, type Server } from "node:http";
 import type { AddressInfo } from "node:net";
 import { resolve } from "node:path";
 
-import type { FeatureList, Feature, Goal, GateResult, Phase } from "./core/types.ts";
+import type { FeatureList, Feature, Goal, GateResult, Phase, Sprint } from "./core/types.ts";
 import { loadFeatureList, computeProgress } from "./core/featureList.ts";
 import { loadConfig } from "./core/config.ts";
 import { modelRouterPath, reworkPath } from "./core/paths.ts";
 import { readJsonSafe } from "./core/fsx.ts";
+import { loadRunState } from "./runState.ts";
 import { renderDashboard, escapeHtml, type DashboardState } from "./ui/dashboard.ts";
 
 export { escapeHtml };
@@ -47,6 +48,12 @@ export interface RemoteState {
   timestamp: string;
   router: unknown;
   rework: unknown;
+  sprints: Sprint[];
+  /** A phase whose gate passed and which is waiting for a human signature. */
+  awaitingApproval: string | null;
+  /** pi sessions this run has spent — proof the handoff is doing its job. */
+  sessions: number | null;
+  goalPass: { current: number; max: number } | null;
 }
 
 export interface RemoteServer {
@@ -104,6 +111,13 @@ export function buildRemoteState(projectDir?: string): RemoteState {
     timestamp: new Date().toISOString(),
     router: readJsonSafe<unknown>(modelRouterPath(dir), null),
     rework: readJsonSafe<unknown>(reworkPath(dir), null),
+    awaitingApproval: config.awaitingApproval ?? null,
+    sessions: loadRunState(dir)?.sessions ?? null,
+    goalPass:
+      typeof config.goalPass === "number" && typeof config.goalMaxPasses === "number"
+        ? { current: config.goalPass, max: config.goalMaxPasses }
+        : null,
+    sprints: list.sprints ?? [],
   };
 }
 
@@ -119,6 +133,9 @@ function toDashboardState(s: RemoteState): DashboardState {
     retries: s.retries,
     router: s.router,
     rework: s.rework,
+    awaitingApproval: s.awaitingApproval,
+    sessions: s.sessions,
+    goalPass: s.goalPass,
   };
 }
 
@@ -138,6 +155,10 @@ export function buildApiPayload(state: RemoteState): Record<string, unknown> {
     gate: state.gate,
     router: state.router,
     rework: state.rework,
+    awaitingApproval: state.awaitingApproval,
+    sessions: state.sessions,
+    goalPass: state.goalPass,
+    sprints: state.sprints,
     features: state.features.map((f) => ({
       id: f.id,
       name: f.name,

package/src/runState.ts

@@ -0,0 +1,121 @@
+/**
+ * infinity-harness — is a continuous run armed, and which run is it?
+ *
+ * This used to be a `let loopEnabled = false` inside the extension closure,
+ * which meant the answer died with the pi session that held it. That was fine
+ * while the harness lived in exactly one session forever, and wrong the moment
+ * it did not:
+ *
+ *   - a fresh session per handoff (the whole point of `src/handoff.ts`) starts
+ *     a new extension instance, and the run it was continuing was over
+ *   - `/reload`, `/new`, `/resume` and a crash all did the same thing
+ *   - the run id was a `randomUUID()` per session, so `loadLoopState` saw a
+ *     different run each time and reset the iteration count, the wall-clock
+ *     budget, the no-progress streak and the escalation ladder — every budget
+ *     that exists to stop a runaway run
+ *
+ * A run is a property of the project, not of the terminal window that started
+ * it. It lives on disk.
+ */
+
+import { runStatePath } from "./core/paths.ts";
+import { readJsonSafe, writeJsonAtomic, removeFile } from "./core/fsx.ts";
+
+export type RunState = {
+  /** Whether the loop should keep driving. Read on every session start. */
+  armed: boolean;
+  /** Stable across every session this run spans. */
+  runId: string;
+  startedAt: string;
+  /** How many pi sessions this run has used. Shown in the widget. */
+  sessions: number;
+  /** Why the run last stopped, so a returning human is not left guessing. */
+  stoppedAt: string | null;
+  stopReason: string | null;
+};
+
+export function newRunState(runId: string, now = new Date()): RunState {
+  return {
+    armed: true,
+    runId,
+    startedAt: now.toISOString(),
+    sessions: 1,
+    stoppedAt: null,
+    stopReason: null,
+  };
+}
+
+export function loadRunState(targetDir: string): RunState | null {
+  const raw = readJsonSafe<Partial<RunState> | null>(runStatePath(targetDir), null);
+  if (!raw || typeof raw.runId !== "string" || !raw.runId) return null;
+  return {
+    armed: raw.armed === true,
+    runId: raw.runId,
+    startedAt: typeof raw.startedAt === "string" ? raw.startedAt : new Date(0).toISOString(),
+    sessions: typeof raw.sessions === "number" && raw.sessions > 0 ? raw.sessions : 1,
+    stoppedAt: typeof raw.stoppedAt === "string" ? raw.stoppedAt : null,
+    stopReason: typeof raw.stopReason === "string" ? raw.stopReason : null,
+  };
+}
+
+export function saveRunState(targetDir: string, state: RunState): void {
+  try {
+    writeJsonAtomic(runStatePath(targetDir), state);
+  } catch {
+    // Losing the file costs the run its cross-session budgets, which is bad,
+    // but throwing here would kill the session, which is worse.
+  }
+}
+
+/** Arm a run. Reuses the existing run id when one is already armed. */
+export function armRun(targetDir: string, runId: string, now = new Date()): RunState {
+  const existing = loadRunState(targetDir);
+  const state =
+    existing && existing.armed
+      ? { ...existing, stoppedAt: null, stopReason: null }
+      : newRunState(runId, now);
+  saveRunState(targetDir, state);
+  return state;
+}
+
+export function disarmRun(targetDir: string, reason: string, now = new Date()): RunState | null {
+  const existing = loadRunState(targetDir);
+  if (!existing) return null;
+  const state: RunState = {
+    ...existing,
+    armed: false,
+    stoppedAt: now.toISOString(),
+    stopReason: reason,
+  };
+  saveRunState(targetDir, state);
+  return state;
+}
+
+/** Count one more pi session against this run. Called from `session_start`. */
+export function countSession(targetDir: string): RunState | null {
+  const existing = loadRunState(targetDir);
+  if (!existing) return null;
+  const state = { ...existing, sessions: existing.sessions + 1 };
+  saveRunState(targetDir, state);
+  return state;
+}
+
+export function clearRunState(targetDir: string): void {
+  try {
+    removeFile(runStatePath(targetDir));
+  } catch {
+    /* nothing to clear */
+  }
+}
+
+/**
+ * The run id the loop should use.
+ *
+ * An armed run keeps its id so `loadLoopState` finds the same budgets after a
+ * handoff. With nothing armed, the caller's session id is the run id — an
+ * ad-hoc `/infinity:validate` should not inherit a finished run's strikes.
+ */
+export function runIdFor(targetDir: string, fallback: string): string {
+  const state = loadRunState(targetDir);
+  return state && state.armed ? state.runId : fallback;
+}

package/src/ui/dashboard.ts

@@ -38,6 +38,7 @@ import {
 import { getPhaseOrder } from "../core/phases.ts";
 import { statusGlyph } from "./widget.ts";
 import { UNICODE_GLYPHS } from "./theme.ts";
+import { groupPlan, type PlanGoalGroup, type PlanSprintGroup } from "./planTree.ts";
 
 export type DashboardState = {
   list: FeatureList;
@@ -52,6 +53,12 @@ export type DashboardState = {
   router?: unknown;
   /** Rework record. Opaque here — rendered as a badge, never interpreted. */
   rework?: unknown;
+  /** A phase whose gate passed and which is waiting for a human signature. */
+  awaitingApproval?: string | null;
+  /** How many pi sessions this run has spent, when handoff is on. */
+  sessions?: number | null;
+  /** Which goal pass this is, out of how many. */
+  goalPass?: { current: number; max: number } | null;
 };
 
 // ── escaping ────────────────────────────────────────────────────────────────
@@ -361,10 +368,30 @@ function renderAlerts(
   paused: boolean,
   retries: DashboardState["retries"],
   gate: GateResult | null,
+  extra: {
+    awaitingApproval?: string | null;
+    sessions?: number | null;
+    goalPass?: { current: number; max: number } | null;
+  } = {},
 ): string {
   const alerts: Alert[] = [];
 
   if (paused) alerts.push({ tone: "blocked", text: "run paused" });
+  // A run parked for a signature looks, from every other indicator, exactly
+  // like a run that has stopped. Saying so is the difference between someone
+  // coming back to a finished phase and someone coming back to a dead run.
+  if (extra.awaitingApproval) {
+    alerts.push({
+      tone: "active",
+      text: `${String(extra.awaitingApproval).toUpperCase()} is waiting for your approval`,
+    });
+  }
+  if (extra.goalPass && extra.goalPass.max > 1) {
+    alerts.push({
+      tone: extra.goalPass.current >= extra.goalPass.max ? "blocked" : "active",
+      text: `goal pass ${extra.goalPass.current} / ${extra.goalPass.max}`,
+    });
+  }
   if (counts.blocked > 0) {
     alerts.push({ tone: "blocked", text: `${counts.blocked} blocked ${counts.blocked === 1 ? "task" : "tasks"}` });
   }
@@ -378,6 +405,9 @@ function renderAlerts(
       text: `retry budget ${retries.task} / ${retries.max}${spent ? " — exhausted" : ""}`,
     });
   }
+  if (typeof extra.sessions === "number" && extra.sessions > 1) {
+    alerts.push({ tone: "quiet", text: `${extra.sessions} sessions this run` });
+  }
   if (gate && gate.overall === false) {
     const failures = Array.isArray(gate.failures) ? gate.failures : [];
     const head = failures.slice(0, 3).join(", ");
@@ -453,6 +483,15 @@ function depLabel(task: FlatTask, indexByKey: ReadonlyMap<string, number>): stri
   return `<span class="deps mono" title="depends on">${esc(GLYPHS.arrow)} ${refs.join(", ")}</span>`;
 }
 
+/**
+ * Every subtask, on every task.
+ *
+ * The terminal widget shows these only for the task being worked, because it
+ * has nine rows and a job to do with them. The dashboard has a whole page and
+ * a scrollbar: the reason to open it is precisely to see the detail the widget
+ * cannot fit, so hiding four of the five plan levels here made it a worse copy
+ * of the widget rather than the place you go for the full picture.
+ */
 function renderSubtasks(task: FlatTask): string {
   const subs = Array.isArray(task.subtasks) ? task.subtasks : [];
   if (subs.length === 0) return "";
@@ -470,8 +509,6 @@ function renderSubtasks(task: FlatTask): string {
 function renderTaskRow(task: FlatTask, indexByKey: ReadonlyMap<string, number>): string {
   const status = task.status;
   const cls = STATUS_CLASS[status];
-  // Subtasks are shown only for the task actually being worked on. Everywhere
-  // else they are detail nobody can act on, and they bury the active row.
   const isActive = status === "in_progress" || status === "rework";
   const difficulty =
     typeof task.difficulty === "string" ? `<span class="chip chip-quiet">${esc(task.difficulty)}</span>` : "";
@@ -487,7 +524,7 @@ function renderTaskRow(task: FlatTask, indexByKey: ReadonlyMap<string, number>):
         ${difficulty}
         ${depLabel(task, indexByKey)}
       </div>
-      ${isActive ? renderSubtasks(task) : ""}
+      ${renderSubtasks(task)}
     </td>
     <td class="cell-status"><span class="pill pill-${cls}">${esc(STATUS_LABEL[status])}</span></td>
   </tr>`;
@@ -536,6 +573,59 @@ function renderFeature(
 </section>`;
 }
 
+/**
+ * A goal, its sprints, and their features — one collapsible section per level.
+ *
+ * `<details open>` is deliberate: everything is visible on load, and a human
+ * reading a 60-task plan can fold away the parts they are not looking at
+ * without the page needing a line of state management.
+ */
+function renderGoalGroup(
+  group: PlanGoalGroup,
+  tasksByFeature: ReadonlyMap<string, FlatTask[]>,
+  indexByKey: ReadonlyMap<string, number>,
+  show: { showGoal: boolean; showSprints: boolean },
+): string {
+  const sprints = group.sprints
+    .map((sg) => renderSprintGroup(sg, tasksByFeature, indexByKey, show.showSprints))
+    .join("");
+
+  if (!show.showGoal || !group.goal) return sprints;
+
+  return `<details class="tier tier-goal" open>
+  <summary class="tier-head">
+    <span class="tier-kind">goal</span>
+    <span class="tier-name">${esc(group.goal.title ?? group.goal.id ?? "")}</span>
+    <span class="mono faint">${esc(group.goal.id ?? "")}</span>
+    <span class="tier-count mono">${esc(String(group.done))}/${esc(String(group.total))}</span>
+  </summary>
+  <div class="tier-body">${sprints}</div>
+</details>`;
+}
+
+function renderSprintGroup(
+  group: PlanSprintGroup,
+  tasksByFeature: ReadonlyMap<string, FlatTask[]>,
+  indexByKey: ReadonlyMap<string, number>,
+  showSprints: boolean,
+): string {
+  const features = group.features
+    .map((f) => renderFeature(f, tasksByFeature.get(f.id) ?? [], indexByKey, null, null))
+    .join("");
+
+  if (!showSprints || !group.sprint) return features;
+
+  return `<details class="tier tier-sprint" open>
+  <summary class="tier-head">
+    <span class="tier-kind">sprint</span>
+    <span class="tier-name">${esc(group.sprint.name ?? group.sprint.id ?? "")}</span>
+    <span class="mono faint">${esc(group.sprint.id ?? "")}</span>
+    <span class="tier-count mono">${esc(String(group.done))}/${esc(String(group.total))}</span>
+  </summary>
+  <div class="tier-body">${features}</div>
+</details>`;
+}
+
 function renderEmptyPlan(phase: Phase | null): string {
   const where = phase ? `The harness is in ${esc(phase)}.` : "The harness has not started a phase yet.";
   return `<section class="card empty">
@@ -766,6 +856,7 @@ body{
 .alert-blocked{color:var(--t-blocked);background:rgba(var(--rgb-blocked),.10);border-color:rgba(var(--rgb-blocked),.30)}
 .alert-rework{color:var(--t-rework);background:rgba(var(--rgb-rework),.10);border-color:rgba(var(--rgb-rework),.28)}
 .alert-active{color:var(--t-active);background:rgba(var(--rgb-active),.10);border-color:rgba(var(--rgb-active),.28)}
+.alert-quiet{color:var(--muted);background:var(--surface-2);border-color:var(--border)}
 
 /* -- gate ----------------------------------------------------------------- */
 .gate-head{display:flex;align-items:flex-start;justify-content:space-between;gap:12px}
@@ -857,6 +948,34 @@ table.tasks tr:last-child td{border-bottom:0}
   margin:26px 2px 2px;font-size:10.5px;text-transform:uppercase;letter-spacing:.09em;
   color:var(--faint);font-weight:600;
 }
+
+/* -- plan tiers: goal > sprint > feature ---------------------------------- */
+/* Depth is carried by a left rule rather than indentation, so a 60-task plan
+   does not walk off the right edge of a phone. */
+.tier{margin:18px 0 0}
+.tier-head{
+  display:flex;align-items:baseline;gap:9px;flex-wrap:wrap;cursor:pointer;
+  padding:7px 2px;list-style:none;border-radius:8px;
+}
+.tier-head::-webkit-details-marker{display:none}
+.tier-head:hover{background:var(--surface-2)}
+.tier-head:focus-visible{outline:2px solid var(--c-accent);outline-offset:2px}
+.tier-kind{
+  font-size:10px;text-transform:uppercase;letter-spacing:.1em;font-weight:700;
+  padding:2px 7px;border-radius:999px;border:1px solid var(--border);color:var(--faint);
+}
+.tier-goal>.tier-head .tier-kind{color:var(--t-brand);border-color:var(--c-brand)}
+.tier-sprint>.tier-head .tier-kind{color:var(--t-accent);border-color:var(--c-accent)}
+.tier-name{font-size:15px;font-weight:650;overflow-wrap:anywhere}
+.tier-goal>.tier-head .tier-name{font-size:17px}
+.tier-count{margin-left:auto;color:var(--muted);font-size:13px;flex:none}
+.tier-body{
+  margin-left:5px;padding-left:14px;border-left:2px solid var(--border);
+}
+.tier-goal>.tier-body{border-left-color:var(--c-brand)}
+.tier-sprint>.tier-body{border-left-color:var(--c-accent)}
+.tier[open]>.tier-head .tier-kind{opacity:.85}
+.tier:not([open])>.tier-head{opacity:.72}
 .foot{
   display:flex;flex-wrap:wrap;gap:6px 14px;justify-content:space-between;
   margin-top:22px;padding-top:14px;border-top:1px solid var(--border);
@@ -1009,19 +1128,20 @@ export function renderDashboard(state: DashboardState): string {
     (b): b is Badge => b !== null,
   );
 
+  // The plan is five levels deep, and it is drawn five levels deep: goals hold
+  // sprints hold features hold tasks hold subtasks. Rendering it flat — which
+  // is what this page used to do, with the goal and sprint reduced to two
+  // chips on a feature card — throws away the only structure that tells you
+  // whether the run is nearly done with something or scattered across
+  // everything.
+  const groups = groupPlan(list);
   const body = features.length
-    ? `<div class="section-label">Features (${esc(String(features.length))})</div>` +
-      features
-        .map((f: Feature) =>
-          renderFeature(
-            f,
-            tasksByFeature.get(f.id) ?? [],
-            indexByKey,
-            f.sprintId ? (sprintNames.get(f.sprintId) ?? null) : null,
-            // A goal chip only earns its place when there is more than one goal
-            // to tell apart.
-            goals.length > 1 && f.goalId ? (goalNames.get(f.goalId) ?? null) : null,
-          ),
+    ? groups
+        .map((group) =>
+          renderGoalGroup(group, tasksByFeature, indexByKey, {
+            showGoal: goals.length > 0,
+            showSprints: sprints.length > 0,
+          }),
         )
         .join("")
     : renderEmptyPlan(state.phase);
@@ -1050,7 +1170,11 @@ export function renderDashboard(state: DashboardState): string {
 ${renderMasthead(state.phase, paused, progress.percent, state.baseRevision, badges)}
 ${renderGoals(goals)}
 ${renderRail(state.phase, state.enabledPhases, paused)}
-${renderAlerts(counts, paused, state.retries, gate)}
+${renderAlerts(counts, paused, state.retries, gate, {
+  awaitingApproval: state.awaitingApproval ?? null,
+  sessions: state.sessions ?? null,
+  goalPass: state.goalPass ?? null,
+})}
 ${renderProgress(counts, progress.tasksTotal, progress.featuresDone, progress.featuresTotal)}
 ${renderGate(gate)}
 ${body}