pi-goal-list-loop-audit 0.38.21 → 0.38.24

package/extensions/goal-agents-panel.ts

@@ -11,7 +11,8 @@
 // in tailChildTranscript through an injected reader so tests stay hermetic.
 
 import * as path from "node:path";
-import { sanitizeDisplayText } from "./goal-loop-core.js";
+import { paint, truncateCells, type DisplayTheme } from "./goal-loop-display.js";
+import { bucketSilentMs, fmtDuration, lifesignBandFor, sanitizeDisplayText } from "./goal-loop-core.js";
 
 /** v0.35.45 (audit finding): the candidate scan reads a bounded TAIL of each
  * transcript, not the whole file — up to 25 files were previously read in
@@ -43,6 +44,10 @@ export interface AgentsPanelRow {
   outputTokens: number;
   silentMs: number;
   evidence: "record-frozen" | "event-only" | "live";
+  /** In-flight parent tool wait this live child holds (audit 2026-09-06:
+   * the doc-promised `└ blocks:` row). Set only from observed
+   * in-flight subagent-wait tool calls — never inferred. */
+  blockedBy?: string;
   action?: "abort-requested" | "unavailable" | "failed";
   endedOk?: boolean;
   endedAt?: number;
@@ -90,21 +95,24 @@ function rowStateWord(row: AgentsPanelRow, now: number): string {
 }
 
 export function truncate(text: string, max: number): string {
-  return text.length <= max ? text : text.slice(0, Math.max(1, max - 1)) + "…";
-}
-
-function fmtDuration(ms: number): string {
-  const totalSec = Math.max(0, Math.round(ms / 1000));
-  const min = Math.floor(totalSec / 60);
-  const sec = totalSec % 60;
-  if (min >= 60) return `${Math.floor(min / 60)}h${String(min % 60).padStart(2, "0")}m`;
-  if (min > 0) return `${min}m${String(sec).padStart(2, "0")}s`;
-  return `${sec}s`;
+  // Audit 2026-09-06: cell-aware shared helper — the char slice overran on
+  // wide glyphs and could split surrogate pairs. ASCII contract unchanged.
+  return truncateCells(text, max);
 }
 
 const PANEL_ROW_CAP = 20;
 export const WIDGET_AGENT_ROW_CAP = 8;
 
+/** Audit 2026-09-07 (field screenshots): the age label never says "silent" — that
+ * noun reads as a state claim ("this child is silent") while the child is
+ * visibly working. Fresh bands read `active {age}`, everything else
+ * `quiet {age}`: both are time-since-last-evidence, matching the band
+ * colors. Exported for the count line + panel detail sharing. */
+export function activeAgeLabel(row: AgentsPanelRow): string {
+  const d = fmtDuration(bucketSilentMs(row.silentMs));
+  return lifesignBandFor(row) === "fresh" ? `active ${d}` : `quiet ${d}`;
+}
+
 function rowRank(row: AgentsPanelRow): number {
   if (row.status === "hung") return 0;
   if (row.status === "running") return 1;
@@ -116,9 +124,17 @@ function orderedRows(rows: AgentsPanelRow[]): AgentsPanelRow[] {
   return [...rows].sort((a, b) => rowRank(a) - rowRank(b) || b.silentMs - a.silentMs);
 }
 
+/** Compose the `└ blocks:` label from observed in-flight parent waits.
+ * Pure helper so the snapshot assembly and tests share the wording. */
+export function blockedByLabel(waitNames: string[]): string | undefined {
+  const names = [...new Set(waitNames.filter(Boolean))];
+  if (names.length === 0) return undefined;
+  return `parent subagent wait (${names.join("/")})`;
+}
+
 /** Render the /glla agents table. Hung/running/queued first, then ended;
  * capped at PANEL_ROW_CAP rows with an explicit truncation notice. */
-export function renderAgentsPanel(rows: AgentsPanelRow[], now: number, managerAvailable: boolean): string[] {
+export function renderAgentsPanel(rows: AgentsPanelRow[], now: number, managerAvailable: boolean, recentHangs: string[] = []): string[] {
   if (rows.length === 0) {
     return ["No subagents tracked yet — spawn one via the `subagent` tool and it appears here.", "(evidence: glla's event probes" + (managerAvailable ? " + pi-subagents manager records" : "") + ")"];
   }
@@ -128,7 +144,7 @@ export function renderAgentsPanel(rows: AgentsPanelRow[], now: number, managerAv
   for (const row of shown) {
     const glyph = row.status === "ended" ? "✓" : row.status === "hung" ? "⚠" : "●";
     lines.push(`${glyph} ${rowLabel(row)}  ${rowStateWord(row, now)}`);
-    lines.push(`  id ${cleanField(row.recordId, 18)} · silent ${fmtDuration(row.silentMs)} · tools ${row.toolUses} · out ${row.outputTokens >= 1000 ? `${(row.outputTokens / 1000).toFixed(1)}k` : row.outputTokens}${row.evidence !== "live" ? ` · ${row.evidence}` : ""}`);
+    lines.push(`  id ${cleanField(row.recordId, 18)} · ${activeAgeLabel(row)} · tools ${row.toolUses} · out ${row.outputTokens >= 1000 ? `${(row.outputTokens / 1000).toFixed(1)}k` : row.outputTokens}${row.evidence !== "live" ? ` · ${row.evidence}` : ""}`);
     if (row.action === "abort-requested") {
       lines.push("  └ child-specific abort requested; partial output remains available while it settles");
     } else if (row.action === "unavailable") {
@@ -138,33 +154,106 @@ export function renderAgentsPanel(rows: AgentsPanelRow[], now: number, managerAv
     } else if (row.status === "hung") {
       lines.push("  └ check the Agents panel: a child whose counters stopped moving is hung, not thinking");
     }
+    // Audit 2026-09-06: the doc-promised `└ blocks:` row — only rendered
+    // from an observed in-flight wait (blockedBy set at snapshot time).
+    if (row.blockedBy && row.status !== "ended") {
+      lines.push(`  └ blocks: ${truncate(row.blockedBy, 80)} (zombie stand-down active)`);
+    }
   }
   if (ordered.length > shown.length) {
     lines.push(`… ${ordered.length - shown.length} more (oldest ended trimmed — cap ${PANEL_ROW_CAP})`);
   }
+  // Audit 2026-09-06: the doc-promised "Recent hangs" footer, fed from
+  // the durable subagent_hang_detected ledger by the caller. Absent when
+  // there is nothing to show — never a placeholder row.
+  const hangs = recentHangs.filter(Boolean).slice(-3);
+  if (hangs.length > 0) {
+    lines.push(`Recent hangs: ${hangs.map((h) => truncate(h, 60)).join(" · ")}`);
+  }
   return lines;
 }
 
-/** Detailed worker rows for the above-editor widget. The widget receives every
- * active row up to a bounded display cap; the remainder has an explicit
- * /glla agents escape hatch rather than disappearing silently. */
-export function renderAgentsWidgetLines(rows: AgentsPanelRow[], now = Date.now(), maxRows = WIDGET_AGENT_ROW_CAP): string[] {
+/** Single-line glyph-first worker rows for the below-chat widget (v0.38.23
+ * Option-2 shape). One row per tracked child: state reads from the leading
+ * glyph (▶ running, ◉ abort in flight, ⚠ hung/unavailable/failed) so no
+ * state word is needed for the healthy case; the silence age sits before
+ * any trailing suffix so narrow-terminal truncation cuts the least
+ * important field first. Ids live in the /glla agents table, not here.
+ * Overflow names its count without a command hint (v0.38.23: extension
+ * meta is noise). Silence ages stay bucketed — raw per-second values
+ * churn the widget key and re-layout the editor every tick (v0.37.1).
+ * v0.38.23 lifesign: the glyph also takes the semantic band color
+ * (success <5m, warning to 30m, error past it) — color never rides alone,
+ * the shape plus the silence number carry the same meaning unpainted. */
+export function renderAgentsWidgetLines(rows: AgentsPanelRow[], now = Date.now(), maxRows = WIDGET_AGENT_ROW_CAP, theme?: DisplayTheme): string[] {
   const active = orderedRows(rows.filter((r) => r.status !== "ended"));
   const shown = active.slice(0, Math.max(1, maxRows));
   const lines: string[] = [];
   for (const row of shown) {
-    // Keep identity/purpose and liveness fields on separate short lines so a
-    // narrow terminal does not truncate the silence age—the field that tells
-    // the user whether a worker is actually making progress.
-    lines.push(`${rowLabel(row)} · id ${cleanField(row.recordId, 10)}`);
+    const glyph = row.status === "hung" ? "⚠"
+      : row.action === "abort-requested" ? "◉"
+      : (row.action === "unavailable" || row.action === "failed") ? "⚠"
+      : "▶";
+    const band = lifesignBandFor(row);
+    const color = band === "fresh" ? "success" : band === "aging" ? "warning" : "error";
+    const action = row.action === "abort-requested" ? " · aborting"
+      : row.action === "unavailable" ? " · abort unavailable"
+      : row.action === "failed" ? " · abort failed" : "";
     const evidence = row.evidence !== "live" ? ` · ${row.evidence}` : "";
-    const action = row.action === "abort-requested" ? " · aborting" : row.action === "unavailable" ? " · abort unavailable" : row.action === "failed" ? " · abort failed" : "";
-    lines.push(`  ${rowStateWord(row, now)} · silent ${fmtDuration(row.silentMs)}${evidence}${action}`);
+    lines.push(`${paint(theme, color, glyph)} ${rowLabel(row)} · ${activeAgeLabel(row)}${action}${evidence}`);
   }
-  if (active.length > shown.length) lines.push(`… ${active.length - shown.length} more agents · /glla agents`);
+  if (active.length > shown.length) lines.push(`… ${active.length - shown.length} more agents`);
   return lines;
 }
 
+/** Safety invariant for the richness ladder — HUNG/aborting/failed
+ * workers are never silent, so `quiet` still surfaces them. Audit
+ * 2026-09-07: also covers action failed/unavailable, matching the
+ * lifesignBandFor hung classification and the red rows — the count line
+ * and the rows can never disagree about trouble. */
+export function hasHungWorker(rows: AgentsPanelRow[]): boolean {
+  return rows.some((r) => r.status !== "ended"
+    && (r.status === "hung"
+      || r.action === "abort-requested"
+      || r.action === "failed"
+      || r.action === "unavailable"));
+}
+
+export type AgentsExtras = { line: string; lines: string[] };
+
+/** v0.38.22 (display unification): the pure richness switch behind the
+ * widget/status worker presence. Rich restores detailed single-line rows
+ * (capped, bucketed — the widget key only moves on genuine state
+ * transitions); compact keeps the count line; quiet surfaces
+ * hung/aborting workers only. Pure and hermetic for tests; the caller
+ * supplies rows + richness. v0.38.23: the task-linkage header is gone —
+ * the card head already names the objective, so `→ <objective>` only
+ * repeated it verbatim on the next row. */
+export function assembleAgentsExtras(
+  rows: AgentsPanelRow[],
+  richness: "rich" | "compact" | "quiet",
+  now = Date.now(),
+  theme?: DisplayTheme,
+): AgentsExtras | undefined {
+  const line = renderAgentsWidgetLine(rows);
+  if (!line) return undefined;
+  // Audit 2026-09-06 (DECIDED: show count line): quiet hides only when
+  // zero are tracked (line undefined above). Tracked-but-healthy keeps
+  // the compact count line — hiding healthy fan-out entirely cost ambient
+  // awareness. HUNG still surfaces via the ⚠ in the line itself.
+  // Audit 2026-09-07 (DECIDED: exceptions-only by default): quiet renders
+  // troubled (non-fresh-band) rows only — healthy fan-out lives on the
+  // native fleet panel, which shows it in more detail. The count line
+  // stays at every level (2026-09-06 ambient-awareness decision); HUNG is
+  // never silent at any level.
+  if (richness === "compact") return { line, lines: [] };
+  if (richness === "quiet") {
+    const troubled = rows.filter((r) => lifesignBandFor(r) !== "fresh");
+    return { line, lines: renderAgentsWidgetLines(troubled, now, WIDGET_AGENT_ROW_CAP, theme) };
+  }
+  return { line, lines: renderAgentsWidgetLines(rows, now, WIDGET_AGENT_ROW_CAP, theme) };
+}
+
 /** The compact footer summary: count + the least-live child.
  * v0.37.1 (ui-jitter fix): bucket the silent age so the status/widget
  * text stays stable between ticks — a per-second change made the footer
@@ -174,22 +263,19 @@ export function renderAgentsWidgetLine(rows: AgentsPanelRow[]): string | undefin
   const active = rows.filter((r) => r.status !== "ended");
   if (active.length === 0) return undefined;
   const busiest = [...active].sort((a, b) => b.silentMs - a.silentMs)[0]!;
-  const hung = busiest.action === "abort-requested"
+  // Audit 2026-09-07 (HIGH): the trouble flag scans ALL live children.
+  // Checking only the stalest hid a hung/aborting child behind a healthy
+  // stalest sibling — HUNG-never-silent means any troubled child flags
+  // the line, while the name/age still describe the stalest child.
+  const hung = active.some((r) => r.action === "abort-requested")
     ? " ⚠ aborting"
-    : busiest.status === "hung"
+    : hasHungWorker(active)
       ? " ⚠"
       : "";
-  return `● ${active.length} agent${active.length === 1 ? "" : "s"} · ${cleanField(busiest.agentType ?? "subagent", 18)} silent ${fmtDuration(bucketSilentMs(busiest.silentMs))}${hung}`;
+  return `● ${active.length} agent${active.length === 1 ? "" : "s"} · ${cleanField(busiest.agentType ?? "subagent", 18)} ${activeAgeLabel(busiest)}${hung}`;
 }
 
-/** Bucket silentMs to coarser granularity for display stability:
- * <1m → 5s buckets, <5m → 15s, otherwise 30s. The underlying
- * hung classification still uses the exact value. */
-function bucketSilentMs(ms: number): number {
-  if (ms < 60_000) return Math.floor(ms / 5000) * 5000;
-  if (ms < 300_000) return Math.floor(ms / 15_000) * 15_000;
-  return Math.floor(ms / 30_000) * 30_000;
-}
+
 
 export interface TranscriptTailResult {
   ok: boolean;

package/extensions/goal-commands.ts

@@ -1815,7 +1815,9 @@ function parseToolOverrideValue(s: string): unknown {
 /** v0.27.5: /glla reviewer | postaudit — the post-completion audit config menu
  * (project-scoped). Reads the dual-write settings (postaudit wins over the
  * legacy reviewer key), and writes back to whichever key was read first —
- * so we don't drift two parallel config blocks. */
+ * so we don't drift two parallel config blocks. Writes to the legacy key
+ * don't stick: load-migration consolidates them into postaudit on the
+ * next read (audit 2026-09-07, finding 395). */
 async function cmdReviewerSettings(ctx: ExtensionContext): Promise<void> {
   const settings = loadSettings(ctx.cwd);
   const block = (settings.postaudit ?? settings.reviewer) as Partial<ReviewerConfig> | undefined;
@@ -2459,11 +2461,19 @@ function cmdAgents(args: string, ctx: ExtensionContext): void {
   const tailMatch = args.match(/--tail\s+(\S+)/);
   if (tailMatch) {
     const id = tailMatch[1]!;
-    const row = agents.find((a) => a.recordId === id || a.recordId.startsWith(id));
-    if (!row) {
+    // Audit 2026-09-06: an ambiguous prefix used to silently pick the
+    // first match — name every candidate and let the user disambiguate.
+    const exact = agents.find((a) => a.recordId === id);
+    const cands = exact ? [exact] : agents.filter((a) => a.recordId.startsWith(id));
+    if (cands.length === 0) {
       ctx.ui.notify(`No tracked subagent matches "${id}". /glla agents lists the current ids.`, "warning");
       return;
     }
+    if (cands.length > 1) {
+      ctx.ui.notify(`"${id}" matches ${cands.length} tracked subagents — be more specific:\n${cands.map((a) => `  ${a.recordId} (${a.agentType ?? "subagent"}, ${a.status})`).join("\n")}`, "warning");
+      return;
+    }
+    const row = cands[0]!;
     const linesMatch = args.match(/--lines\s+(\d+)/);
     // v0.35.45 (audit finding): the candidate scan reads a bounded TAIL of
     // each transcript instead of up to 25 FULL files synchronously on the
@@ -2499,7 +2509,24 @@ function cmdAgents(args: string, ctx: ExtensionContext): void {
     ctx.ui.notify([header, ...result.lines, ...(result.ok ? [] : [result.detail])].join("\n"), result.ok ? "info" : "warning");
     return;
   }
-  ctx.ui.notify(`glla agents${managerAvailable ? "" : " (pi-subagents manager registry not present — event evidence only)"}\n${renderAgentsPanel(agents, Date.now(), managerAvailable).join("\n")}`, "info");
+  // Audit 2026-09-06: the doc-promised "Recent hangs" footer — last 3
+  // durable subagent_hang_detected events. Best-effort: a missing ledger
+  // yields no footer, never an error row.
+  let recentHangs: string[] = [];
+  try {
+    const now = Date.now();
+    recentHangs = readLedgerTail(ctx.cwd, 25, (e) => e.type === "subagent_hang_detected")
+      .slice(-3)
+      .map((e) => {
+        const v = (e.value ?? {}) as { agentType?: string; recordId?: string; at?: string };
+        const ms = e.at ? now - Date.parse(e.at) : Number.NaN;
+        const age = Number.isFinite(ms) && ms >= 0
+          ? ms < 3_600_000 ? `${Math.max(0, Math.round(ms / 60_000))}m` : `${Math.floor(ms / 3_600_000)}h${String(Math.floor(ms / 60_000) % 60).padStart(2, "0")}m`
+          : "?";
+        return `${v.agentType ?? "subagent"} ${age} ago`;
+      });
+  } catch { recentHangs = []; }
+  ctx.ui.notify(`glla agents${managerAvailable ? "" : " (pi-subagents manager registry not present — event evidence only)"}\n${renderAgentsPanel(agents, Date.now(), managerAvailable, recentHangs).join("\n")}`, "info");
 }
 
 // v0.29.8: /glla status — the unified "what's running" surface (user: "we
@@ -2555,7 +2582,12 @@ async function cmdSettings(args: string, ctx: ExtensionContext): Promise<void> {
   // rather than through noisy inline assignments.
   const trimmed = args.trim();
   const verb = trimmed ? trimmed.split(/\s+/)[0]!.toLowerCase() : "ui";
-  if (staleEntry && (verb === "ui" || SETTINGS_MUTATING_ACTIONS.has(verb))) {
+  // Audit 2026-09-07 (LOW, finding 399): bare `/glla fallbacks` only
+  // displays the chain — only clear/off/unset/none mutates. Refusing the
+  // read-only display on a stale handle blocks inspection for no safety.
+  const fallbacksRest = verb === "fallbacks" ? trimmed.slice("fallbacks".length).trim().toLowerCase() : "";
+  const fallbacksReadOnly = verb === "fallbacks" && !/^(clear|off|unset|none)(\s|$)/.test(fallbacksRest);
+  if (staleEntry && (verb === "ui" || (!fallbacksReadOnly && SETTINGS_MUTATING_ACTIONS.has(verb)))) {
     appendLedger(ctx.cwd, "settings_mutation_refused_stale", { sub: verb });
     return;
   }
@@ -2706,6 +2738,11 @@ async function cmdSettings(args: string, ctx: ExtensionContext): Promise<void> {
       fmt("visionAssist", "visionAssist"),
       fmt("auditorModel", "auditorModel"),
       fmt("auditorThinkingLevel", "thinking"),
+      // Audit 2026-09-06: the headless fallback omitted these — headless
+      // operators could not see the compactor chain or display richness.
+      fmt("compactorModel", "compactorModel"),
+      `compactorModelFallbacks: ${formatMainModelFallbacks(effectiveSettings.compactorModelFallbacks)}  [${prov.compactorModelFallbacks?.source ?? "default"}]`,
+      fmt("subagentDisplayRichness", "subagentDisplayRichness"),
       fmt("notifyCmd", "notify"),
       fmt("tokenLimit", "tokenLimit"),
       fmt("autoResume", "autoResume"),

package/extensions/goal-compactor.ts

@@ -33,6 +33,9 @@ export const COMPACTOR_BRIEF_MAX_CHARS = 2000;
 export const COMPACTOR_PACKET_MAX_CHARS = 6000;
 /** Worker wall clock: a brief is one completion, not an agentic loop. */
 export const COMPACTOR_TIMEOUT_MS = 180_000;
+/** Audit 2026-09-06: grace between SIGTERM and SIGKILL when the worker
+ * overruns its timeout — SIGTERM alone can leave a stuck child alive. */
+export const COMPACTOR_KILL_GRACE_MS = 5_000;
 /** The compactor reasons as little as possible: compression, not judgment. */
 export const COMPACTOR_THINKING = "minimal";
 
@@ -149,7 +152,19 @@ function defaultSpawnWorker(script: string, jobDir: string, request: Record<stri
     }
     const child = nodeSpawn(process.execPath, [script, "--job-dir", jobDir], { stdio: "ignore" });
     const timer = setTimeout(() => {
-      try { child.kill("SIGTERM"); } catch {}
+      // Audit 2026-09-06: SIGTERM first, SIGKILL fallback — a stuck worker
+      // must not survive the timeout as a zombie holding the job dir.
+      try {
+        if (child.exitCode === null && child.signalCode === null) {
+          child.kill("SIGTERM");
+          const killTimer = setTimeout(() => {
+            try {
+              if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
+            } catch { /* already gone */ }
+          }, COMPACTOR_KILL_GRACE_MS);
+          killTimer.unref?.();
+        }
+      } catch { /* already gone */ }
       done({ ok: false, error: "compactor worker timed out" });
     }, (typeof request.timeoutMs === "number" && request.timeoutMs > 0 ? request.timeoutMs : COMPACTOR_TIMEOUT_MS) + 15_000);
     timer.unref?.();
@@ -192,12 +207,37 @@ function pruneOldJobDirs(cwd: string, now = Date.now()): void {
  * model (chain → plan B → skip), persists the brief, notifies + pages.
  * Fire-and-forget safe: never throws.
  */
+/** Durable one-shot marker — audit 2026-09-06: the in-memory refuse
+ * transition is process-local, so a restart mid-episode would re-fire the
+ * brief + page. The marker survives restarts; recovery (shouldRefuse=false)
+ * removes it to re-arm the next episode. */
+export function compactorFiredMarkerPath(cwd: string): string {
+  return path.join(piGlaDir(cwd), "compactor-fired.json");
+}
+
 export async function runEmergencyCompactorIfDue(
   ctx: Pick<ExtensionContext, "cwd" | "model" | "modelRegistry" | "getContextUsage">,
   shouldRefuseNow: boolean,
   deps: CompactorDeps = {},
 ): Promise<{ fired: boolean; briefChars?: number; via?: string }> {
-  if (!claimCompactorRefuseTransition(shouldRefuseNow)) return { fired: false };
+  if (!shouldRefuseNow) {
+    claimCompactorRefuseTransition(false);
+    try { fs.rmSync(compactorFiredMarkerPath(ctx.cwd), { force: true }); } catch { /* re-arm best effort */ }
+    return { fired: false };
+  }
+  // Restart mid-episode: the marker says this episode already fired.
+  // Converge the in-memory transition (claim it) and stay silent.
+  let alreadyFired = false;
+  try { alreadyFired = fs.existsSync(compactorFiredMarkerPath(ctx.cwd)); } catch { alreadyFired = false; }
+  if (alreadyFired) {
+    claimCompactorRefuseTransition(true);
+    return { fired: false };
+  }
+  if (!claimCompactorRefuseTransition(true)) return { fired: false };
+  try {
+    fs.mkdirSync(piGlaDir(ctx.cwd), { recursive: true });
+    fs.writeFileSync(compactorFiredMarkerPath(ctx.cwd), JSON.stringify({ at: new Date().toISOString() }) + "\n");
+  } catch { /* marker write is best effort; in-memory one-shot still holds this process */ }
   try {
     return await runEmergencyCompactor(ctx, deps);
   } catch (error) {

package/extensions/goal-continuation.ts

@@ -34,6 +34,7 @@ import {
   readLedgerTail,
   nowIso,
   newGoalId,
+  archiveDir,
   archivedGoalPath,
   goalMdPath,
   writeGoalMd,
@@ -257,6 +258,20 @@ let continuationScheduledFor: string | null = null;
 
 let lastContinuationSentAt = 0;
 
+// Audit 2026-09-07 (MEDIUM): wall-clock of the last genuine user-role
+// message observed via message_start. A user message arriving after a
+// dispatch was sent means the next agent_start/turn_start belongs to the
+// user's manual turn, not the continuation — the fallback ack must refuse
+// it so a manual turn can't hide a genuine no-start. Our own continuations
+// send as customType (never role user) and our injected draft seed is
+// skipped by the caller, so only real user turns stamp this.
+let lastUserMessageAt = 0;
+
+/** Record a genuine user message (message_start, role user, not our seed). */
+export function noteUserMessageForDispatch(): void {
+  lastUserMessageAt = Date.now();
+}
+
 let queueStuckProbe: ReturnType<typeof setTimeout> | null = null;
 
 // v0.28.5 (E3): send-retry re-arm accounting. The 50ms BACKOFF_IDLE_RETRY
@@ -653,7 +668,19 @@ export function dispatchStartAcknowledged(ctx: ExtensionContext, source: string,
   if (source === "before_agent_start") {
     if (!dispatchPromptMatches(record, prompt)) return false;
   } else if (source === "agent_start" || source === "turn_start") {
-    // fallback — no prompt to match
+    // fallback — no prompt to match. But a user message after the send
+    // means this turn is the user's manual turn, not the continuation:
+    // refuse so the watchdog keeps watching the genuine no-start.
+    // before_agent_start with the marker still acks (strongest proof).
+    if (lastUserMessageAt > record.sentAt) {
+      appendLedger(ctx.cwd, "continuation_start_ack_refused_user_turn", {
+        dispatchId: record.id,
+        source,
+        sentAt: record.sentAt,
+        lastUserMessageAt,
+      });
+      return false;
+    }
   } else {
     // message_update / agent_end / other liveness signals cannot settle
     // without an existing proof, and pending.phase !== "accepted" already
@@ -934,9 +961,21 @@ export function guardGoalBeforeContinuation(
   if (goal.status === "auditing" && !allowAuditing) return false;
   if (goal.status !== "active" && goal.status !== "paused" && goal.status !== "auditing") return false;
 
-  const storedArchive = goal.archivedPath
-    ? (path.isAbsolute(goal.archivedPath) ? goal.archivedPath : path.resolve(ctx.cwd, goal.archivedPath))
-    : archivedGoalPath(ctx.cwd, goal.id);
+  // Audit 2026-09-06: archivedPath is durable state and may be corrupted —
+  // the old code existsSync-probed ANY absolute path it named (arbitrary
+  // filesystem existence oracle) and then nulled the live goal on a hit.
+  // Only honor it inside the archive dir; anything else is an anomaly that
+  // falls back to the canonical location.
+  let storedArchive = archivedGoalPath(ctx.cwd, goal.id);
+  if (goal.archivedPath) {
+    const candidate = path.isAbsolute(goal.archivedPath) ? goal.archivedPath : path.resolve(ctx.cwd, goal.archivedPath);
+    const rel = path.relative(archiveDir(ctx.cwd), candidate);
+    if (rel && !rel.startsWith("..") && !path.isAbsolute(rel)) {
+      storedArchive = candidate;
+    } else {
+      appendLedger(ctx.cwd, "faulty_objective_archive_path_anomaly", { goalId: goal.id, where, archivedPath: String(goal.archivedPath).slice(0, 200) });
+    }
+  }
   if (fs.existsSync(storedArchive)) {
     appendLedger(ctx.cwd, "faulty_objective_archive_fence", { goalId: goal.id, where, archive: storedArchive });
     try { fs.rmSync(goalMdPath(ctx.cwd, goal.id), { force: true }); } catch { /* best effort */ }
@@ -1061,10 +1100,13 @@ export function scheduleContinuation(ctx: ExtensionContext, force = false, delay
   if (pendingContinuationDispatch) return;
   if (continuationDispatchStoodDown && !force) return;
   if (force) releaseContinuationDispatchStandDown();
-  flags.abortedStandDown = false; // v0.29.5: any explicit schedule ends the stand-down
   if (!isActionableGoal()) return;
   if (!guardGoalBeforeContinuation(ctx, "schedule")) return;
   if (!isActionableGoal()) return;
+  // v0.29.5: an explicit schedule ends the stand-down — audit 2026-09-06:
+  // only a schedule that actually arms clears it. Clearing before the
+  // gates let no-op schedules discharge the user's abort latch.
+  flags.abortedStandDown = false;
   rememberCtx(ctx);
   const goalId = state.goal!.id;
   if (!force && continuationScheduledFor === goalId) return;
@@ -1102,6 +1144,10 @@ export interface TerminalCompletionNotice {
   goalId: string;
   outcome: string;
   details: string[];
+  /** Audit 2026-09-06: the session generation that produced the verdict.
+   * A stale generation (verdict applied after handoff/reload) must not
+   * fire a `✓ done` turn into the successor session's unrelated work. */
+  generation?: number;
 }
 
 /** v0.38.18 (track 3: junk-runner stale waiting-verdict): the detached
@@ -1118,8 +1164,26 @@ export function sendTerminalCompletionNotice(ctx: ExtensionContext, notice: Term
   if (supervisorPaused(state)) return false;
   if (mainModelRecoveryActive()) return false;
   if (flags.sessionHandoffPending || flags.initialSessionLoadPending || flags.extensionApiStale || flags.staleTerminalDone || flags.zombieStoodDown) return false;
+  // Audit 2026-09-07 (HIGH, scoped): refuse while the user-abort latch
+  // stands — a `✓ done` turn firing under the user's hands after Esc/zombie
+  // abort violates the stand-down promise. Deliberately NOT gated on
+  // stoodDown/pending: closure wins there (a pending dispatch fences itself
+  // on the archived goal), and dropping the notice would lose transcript
+  // closure with no retry path.
+  if (flags.abortedStandDown) {
+    appendLedger(ctx.cwd, "terminal_completion_notice_refused_stood_down", { goalId: notice.goalId });
+    return false;
+  }
   if (!flags.extensionApi) return false;
   if (isForeignCtx(ctx)) return false;
+  if (typeof notice.generation === "number" && notice.generation !== flags.sessionGeneration) {
+    appendLedger(ctx.cwd, "terminal_completion_notice_stale_generation", {
+      goalId: notice.goalId,
+      noticeGeneration: notice.generation,
+      currentGeneration: flags.sessionGeneration,
+    });
+    return false;
+  }
   try {
     const already = readLedgerTail(ctx.cwd, 400, (entry) =>
       entry.type === "terminal_completion_notice_sent" &&
@@ -1201,7 +1265,11 @@ export function sendContinuation(goalId: string): void {
   // refuses new schedules; this closes the armed-timer race.
   if (supervisorPaused(state)) return;
   if (mainModelRecoveryActive()) return;
-  if (flags.sessionHandoffPending || flags.initialSessionLoadPending || flags.extensionApiStale || flags.staleTerminalDone || flags.zombieStoodDown || continuationDispatchStoodDown || pendingContinuationDispatch) return;
+  // Audit 2026-09-07 (HIGH): an armed timer must not fire after a user-Esc
+  // or zombie abort. continuationDispatchStoodDown alone is insufficient —
+  // explicit resume paths release it while flags.abortedStandDown stays set
+  // until a schedule actually arms, so check the abort latch here too.
+  if (flags.sessionHandoffPending || flags.initialSessionLoadPending || flags.extensionApiStale || flags.staleTerminalDone || flags.zombieStoodDown || continuationDispatchStoodDown || pendingContinuationDispatch || flags.abortedStandDown) return;
   continuationTimer = null;
   continuationScheduledFor = null;
   if (!state.goal || state.goal.id !== goalId) {
@@ -1341,7 +1409,9 @@ export function sendContinuation(goalId: string): void {
 // call otherwise. display: true — the user should see the warning too.
 export function sendStallEscalation(ctx: ExtensionContext, nudges: number): void {
   if (supervisorPaused(state)) return;
-  if (flags.sessionHandoffPending || flags.initialSessionLoadPending || !flags.extensionApi || flags.extensionApiStale || continuationDispatchStoodDown || pendingContinuationDispatch) return;
+  // Audit 2026-09-07 (HIGH): a stall nudge must not resurrect a stood-down
+  // chain — same abort-latch reasoning as sendContinuation.
+  if (flags.sessionHandoffPending || flags.initialSessionLoadPending || !flags.extensionApi || flags.extensionApiStale || continuationDispatchStoodDown || pendingContinuationDispatch || flags.abortedStandDown) return;
   if (!state.goal || !guardGoalBeforeContinuation(ctx, "stall-escalation")) return;
   const remaining = HEARTBEAT_MAX_NUDGES - nudges;
   const text = [
@@ -1383,7 +1453,9 @@ export function sendStallEscalation(ctx: ExtensionContext, nudges: number): void
 // plain sessions truncate too.
 export function sendLengthContinue(ctx: ExtensionContext, consecutive: number): void {
   if (supervisorPaused(state)) return;
-  if (flags.sessionHandoffPending || flags.initialSessionLoadPending || !flags.extensionApi || flags.extensionApiStale || continuationDispatchStoodDown || pendingContinuationDispatch) return;
+  // Audit 2026-09-07 (HIGH): a length nudge must not resurrect a stood-down
+  // chain — same abort-latch reasoning as sendContinuation.
+  if (flags.sessionHandoffPending || flags.initialSessionLoadPending || !flags.extensionApi || flags.extensionApiStale || continuationDispatchStoodDown || pendingContinuationDispatch || flags.abortedStandDown) return;
   if (state.goal && !guardGoalBeforeContinuation(ctx, "length-continuation")) return;
   const attempt = dispatchPrepare(ctx, {
     generation: flags.sessionGeneration,

package/extensions/goal-heartbeat.ts

@@ -45,6 +45,7 @@ import { isLoopActive, loopTimerPending, scheduleLoopTick } from "./goal-loop.js
 import { mainModelRecoveryActive, markCompletionAuditRecoveryPending, probeMainModelRecovery } from "./goal-recovery.js";
 import type { ContinuationDispatch } from "./goal-loop-dispatch.js";
 import type { AgentPhase, AgentStatus } from "./goal-agents-panel.js";
+import { blockedByLabel } from "./goal-agents-panel.js";
 import { ContinuousSupervisor, SUPERVISION_MAX_POLL_MS, type SupervisionSignal } from "./continuous-supervision.js";
 
 /** goal.ts-owned module lets the heartbeat reads/writes through this accessor.
@@ -1661,6 +1662,8 @@ export interface SubagentAgentView {
   /** ms since the last NEW progress (tool use / output tokens). */
   silentMs: number;
   evidence: "record-frozen" | "event-only" | "live";
+  /** Observed in-flight parent subagent wait (audit 2026-09-06 `└ blocks:`). */
+  blockedBy?: string;
   hangAlertedAt?: number;
   action?: "abort-requested" | "unavailable" | "failed";
   endedAt?: number;
@@ -1671,6 +1674,14 @@ function finiteNonNegative(value: unknown): number | undefined {
 }
 
 export function getSubagentAgentsSnapshot(now = Date.now()): { agents: SubagentAgentView[]; managerAvailable: boolean } {
+  // Audit 2026-09-06: the doc-promised `└ blocks:` row — label live rows
+  // with the OBSERVED in-flight parent wait (tool args carry no run id, so
+  // per-row correlation is impossible; the name is named, never inferred).
+  let blockedBy: string | undefined;
+  try {
+    const waits = [...flags.inFlightToolCalls.values()].filter(isSubagentWaitCall).map((t) => t.name ?? "");
+    blockedBy = blockedByLabel(waits);
+  } catch { blockedBy = undefined; }
   const poll = subagentManagerPoller();
   const managerAvailable = typeof poll.getRecord === "function";
   const agents: SubagentAgentView[] = [];
@@ -1726,6 +1737,7 @@ export function getSubagentAgentsSnapshot(now = Date.now()): { agents: SubagentA
         outputTokens,
         silentMs,
         evidence,
+        ...(blockedBy && status !== "ended" ? { blockedBy } : {}),
         ...(probe.hangAlertedAt !== undefined ? { hangAlertedAt: probe.hangAlertedAt } : {}),
         ...(probe.hangAction !== undefined ? { action: probe.hangAction } : {}),
         ...(probe.endedAt !== undefined ? { endedAt: probe.endedAt } : {}),