pi-goal-list-loop-audit 0.38.22 → 0.38.25

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## 0.38.25 — post-objective summary: canonical approval render, persist + replay, audit-goal counts (2026-09-07)
+
+### Fixed
+- Field failure: goal `20260907131550-12ddoy` completed with a perfect six-label archive record, but the approval chat lines fired into a dead context (auditor verdict landed with no live turn) — record perfect, delivery silent. Cross-harness survey (`audit/POST-OBJECTIVE-SUMMARY-2026-09-07.md`): Codex CLI 0.147.0 and Claude Code both leave the final message to the agent and standardize only usage/session-persistence/resume; pi-goal-x (in-repo v0.26.1 source) fixes the report order (verdict → complete → task summary → detail) — validating the outcome-first shape. Nobody persists the render; GLLA now does.
+- ONE canonical builder: `buildTerminalApprovalRender` (outcome + ≤2 details + approval + counts + record) feeds chat, transcript, external, and the persisted render on all three approval paths (detached auditor, manual verify, Esc-without-audit). `buildApprovalChatLines` gains an optional `counts` slot (backward compatible); the stale pre-verdict `Next:` stays stripped everywhere.
+- Audit-goal counts line rides every render, built from durable state only: `— run: 42 turns · 17 file writes · 23 bash calls · auditor approved (1 verdict).` Absent facts are named as absent; the no-audit path says so honestly.
+- Persist + replay: renders persist to `.pi-glla/pending-approval-renders.json` at archive time with `delivered: !isIdle()` (the probe fails toward undelivered — a duplicate beats a loss). All five command handlers (`/goal /glla /review /list /loop`) replay undelivered renders on live contact, fire-once fenced via `deliveredAt`, ledgered (`terminal_approval_render_persisted/_replayed`), corrupt-store safe. Coverage: 7 new behavioral pins + updated source-grep contract.
+
+## 0.38.24 — audit pass: abort-latch send guards, ownership compare-and-swap, auditor inherit parity (2026-09-07)
+
+### Fixed
+- Full display/lifecycle/settings audit pass (goal `20260907131550-12ddoy`, three parallel read-only scouts): 44 findings → 0 open. Display decisions (user-grilled): head owns liveness (status drops the `LIVE` capsule/tails, keeps `[WORKING]` + counts), exceptions-only `quiet` default (troubled rows + count line; healthy fan-out lives on the fleet panel), `active {age}` / `quiet {age}` worker labels.
+- Lifecycle HIGH: `sendContinuation` / `sendStallEscalation` / `sendLengthContinue` refuse on `flags.abortedStandDown`; terminal-notice refusal scoped to the abort latch so transcript closure still wins; zombie retry routes on the abort-closure owner (loop abort no longer stranded by a goal started mid-delay); cycle-reset consumes budget (`attempts+1`) and honors the 24h horizon while the probe turn stays prompt per the v0.34.132 contract.
+- Lifecycle MED/LOW: fallback `agent_start`/`turn_start` acks refuse on intervening user messages; successor absorb + self-heal share `clearDeadGenerationDispatch` (no more idle behind a "re-armed" lie); ownership refresh is compare-and-swap (live foreign claims never clobbered; dead records still refresh for heartbeat reclaim); command entry forces a fresh ownership read past the background throttle; length-continue lost its stale-classifier exemption.
+- Settings: `stallShortWords: 0` (= off) survives normalization; auditor thinking gains the drafter's `session — inherit` row + non-reasoning picks clear stale overrides; bare `/glla fallbacks` reads on stale handles (only `clear/off/unset/none` mutates); typing `auto` in the notify editor round-trips to unset; v0.38.23 comment/doc drift swept (richness/quiet copy, reviewer write→migrate lifecycle, DESIGN one-line rows, SETTINGS wedge vs aggressive default). Full audit: `audit/AUDIT-PASS-2026-09-07.md`. Coverage: `release:check` 1979 pass / 0 fail.
+
+## 0.38.23 — below-chat widget: forced placement, single-line rows, evidence lifesign (2026-09-07)
+
+### Fixed
+- Below-chat pinning (field: GLLA card vs fleet visibly swapping slots across ticks, 2026-09-06 screenshots). The `pi-glla` widget now passes `{ placement: "belowEditor" }` — the same zone the native fleet defaults to — so both surfaces stop trading places. Forced, not a setting: one stable layout for everyone, no new settings row or drift pin.
+- Extension-meta footers deleted. The orphan-worker `└─ /glla agents for full worker detail`, the card `└─ /goal status · /glla` / `└─ /list · /glla` hints, and the `… N more agents · /glla agents` overflow pointer all named our extension, not the user's task — pure noise once `/glla` is known. Queue depth survives as task info (`└─ N queued`); empty queue means no footer at all.
+- Option-2 worker rows: one glyph-first line per tracked child (`▶ scout · ui-fixes · silent 2m`, `⚠ worker · art-batch · silent 31m`), age before any suffix so narrow-terminal truncation cuts the least important field first. The `→ <objective>` task-linkage header is gone (the card head already names the objective — it repeated it verbatim), ids stay in the `/glla agents` table, overflow names its count only. `/glla agents` full table untouched (`└ blocks:`, Recent hangs, abort guidance all intact).
+- Evidence lifesign on active-clear heads: freshest-worker-evidence readout as the last head segment (`· stream 8s`), breathing glyph derived from evidence counters (`Σ toolUses + outputTokens mod 4` over `●→◉→○→◉`) — never from wall-clock, so the widget key stays stable between evidence and the v0.37.1 re-layout cannot return. Fresh (<5m) breathes, aging (5–30m) freezes the ring, stale (30m+) hollows it, a hung child triangles the head. Non-active statuses (⏸/⟡/⚠/⏳) keep their own glyph language; no rows means no readout invented.
+- Semantic color ramp on head glyph + age text + row glyphs only (success <5m, warning to 30m, error past it; queued caps at amber — waiting is not broken; meter stays progress-colored, fleet line untouched). Color never rides alone: glyph shape (▶/◉/⚠) plus the silence number carry the same meaning unpainted, and a no-theme render contains zero ANSI. Coverage: `tests/lifesign.test.ts` (7 tests: bands incl. queued cap, empty-invents-nothing, counter-derived breath, head readout/triangle/pause/bare, row color + unpainted shape+number, 80-col fit + bucket key-stability) plus reshaped pins in `display`/`agents-panel`/`subagent-display-richness`.
+
 ## 0.38.22 — subagent display unification: richness ladder + upstream triple-render report (2026-09-05)
 
 ### Fixed

package/docs/DESIGN-subagent-visibility.md

@@ -29,15 +29,29 @@ holds (no new instrumentation):
 - Ledger history of `subagent_hang_detected` for the "Recent hangs" footer
   of the panel.
 
-Row shape:
+Row shape (shipped one-glyph-line since v0.38.23: age-first single lines
+replace the v0.38.22 two-line shape — footers deleted, ids live in
+`/glla agents`; audit 2026-09-07 verified this against the doc and kept
+the code — the doc, not the pins, was stale):
 
 ```
-● explore   map-model-picker   RUNNING 4m12s   tools 18 · out 2.1k · silent 0m
-● plan      audit-contract     HUNG? 31m       tools 6 → frozen · out 890 · silent 26m
-  └ blocks: foreground subagent call (zombie stand-down active)
-✓ explore   schema-check       ENDED ok 3m44s
+▶ explore · map-model-picker · active 8s
+▶ plan · audit-contract · quiet 26m
+⚠ plan · stuck-render · HUNG · quiet 31m · id e5f6…
 ```
 
+Troubled rows append the short id; healthy rows stay self-contained
+without the fleet panel (the v0.38.22 `└ check the Agents panel` footer
+is gone — the row itself says what is wrong). `/glla agents` keeps the
+full detail view (recent hangs read the durable `subagent_hang_detected`
+ledger, absent when empty — never a placeholder).
+
+The `└ blocks:` row renders only from an OBSERVED in-flight parent
+subagent wait (tool args carry no run id, so per-row correlation is
+impossible — the wait NAME is named, never inferred). The "Recent hangs"
+footer reads the durable `subagent_hang_detected` ledger (last 3, absent
+when empty — never a placeholder).
+
 Hung classification reuses `classifyHungSubagents` semantics (record-frozen
 vs event-only evidence). Cap display at ~20 rows; prune ended probes per
 the existing SUBAGENT_HANG_PRUNE_MS rule.
@@ -83,8 +97,13 @@ safety property by other means — `renderAgentsWidgetLines` buckets silence
 ages exactly like the compact line, so the widget key only moves on genuine
 state transitions — and restores rich ambient rows behind the
 `subagentDisplayRichness` ladder (`rich` default / `compact` / `quiet`, HUNG
-never silent), plus the task-linkage header (`→ <objective>`) only GLLA can
-show. Triplication/ordering against pi-subagents native panels is upstream
+never silent), plus — until v0.38.23 — the task-linkage header
+(`→ <objective>`) only GLLA can show. v0.38.23 removes the header (the
+card head already names the objective), collapses worker rows to one
+glyph-first line each, forces the card below the chat
+(`{ placement: "belowEditor" }`), and adds the evidence lifesign
+(counter-derived breathing glyph + `stream {age}` readout + semantic
+band colors on head and rows, queued capped at amber). Triplication/ordering against pi-subagents native panels is upstream
 (nicobailon/pi-subagents#1931, read-only); GLLA owns its slot only and
 documents the native escapes. Assembly is the pure `assembleAgentsExtras`
 (pinned in `tests/subagent-display-richness.test.ts`).

package/docs/INDEX.md

@@ -18,15 +18,17 @@ For shipped docs, the relevant entry points are:
   failback; v0.35.9 hardened cross-version npm tarball checks; v0.35.10
   handles multi-entry npm dry-run reports; v0.35.11 accepts both npm report
   shapes; v0.35.12 supports npm 12's keyed pack reports; v0.35.13 fixes stale-API recovery loops.
-  v0.35.14–v0.38.22 continue through the supervisor freeze (`/glla pause`),
+  v0.35.14–v0.38.25 continue through the supervisor freeze (`/glla pause`),
   load hold, auditor picker parity, Windows launch fix, zombie-watchdog
   subagent carve-out, due-wait backstop, the `/glla agents` visibility panel,
   durable state-root selection, blank-until-resume auditor context, frozen
   subagent recovery, bounded repair/replan recovery, production RPC child
   stopping, mandatory hermetic auditor-extension validation, optional provider
   extensions, bounded zero-stream retry containment, crash-safe persistence,
-  and packed-artifact release verification — see CHANGELOG.md for the full
-  trail.
+  packed-artifact release verification, and the 2026-09-07 display/lifecycle/
+  settings audit pass (abort-latch send guards, ownership compare-and-swap,
+  auditor inherit/clear parity) and the v0.38.25 post-objective summary
+  (canonical approval render, persist + replay, audit-goal counts line) — see CHANGELOG.md for the full trail.
 - `../README.md` — what the plugin is, install, quickstart, and the
   architectural guarantee (drafting + confirm + detached auditor).
 - `../INSTALL.md` — source install / local development setup; the recommended
@@ -35,6 +37,7 @@ For shipped docs, the relevant entry points are:
 
 ## Entry points
 - `../README.md` — what the plugin is, install, quickstart
+- `SETTINGS.md` — canonical settings reference (files, precedence, every key)
 - `../INSTALL.md` — source install / local development setup
 - `../CHANGELOG.md` — user-facing changelog; the first versioned heading is
   the current released package version (use `/glla version` to compare with

package/docs/SETTINGS.md

@@ -0,0 +1,85 @@
+# GLLA settings reference
+
+Canonical settings reference (audit 2026-09-06 — settings truth previously
+lived only in the menu/headless renderers and the changelog). The live
+views remain `/glla` (headless display with provenance) and the `/glla`
+settings menu; this file is the shipped, reviewable contract. A release-gate
+test pins that every `SETTINGS_KEYS` entry in `extensions/goal-settings.ts`
+appears here, so the table cannot silently drift.
+
+## Files and precedence
+
+- Global file: `~/.pi/agent/glla/settings.json` (machine/provider policy).
+- Project file: `<cwd>/.pi-glla/settings.json` (project artifact).
+- Effective value: project wins over global wins over built-in default.
+- `/glla` shows per-key provenance (`project` / `global` / `default`).
+- Hand-edited files are normalized on every load
+  (`normalizeLoadedSettings`): unknown enums fall back, out-of-range
+  numbers reset to unset (consumer `??` fallbacks apply), junk strings are
+  dropped, and legacy keys migrate (`reviewer` → `postaudit`,
+  `auditorModelFallback` → `auditorModelFallbacks`,
+  `hourlyQuotaProbe` → `hourlyRetryProbe`).
+
+## Global-only keys
+
+These describe machine/provider policy, not a project artifact. Project
+copies are ignored (the recovery runtime reads the global file):
+
+`stateRoot`, `mainModelFallbacks`, `mainModelRetryMinutes`,
+`mainModelFailback`, `mainModelPrimaryProbeMinutes`, `hourlyRetryProbe`,
+`autoResume`, `drafterModel`, `drafterThinkingLevel`,
+`drafterModelFallbacks`, `compactorModel`, `compactorModelFallbacks`,
+`auditorModelFallbacks`, `auditorToolTimeoutMs`, `auditorStallMs`,
+`auditJobRetentionMs`, `auditorInspection`.
+
+## Keys
+
+| Key | Default | Meaning |
+| --- | ------- | ------- |
+| `stateRoot` | `"workingDir"` | Where durable state lives; `"sessionDir"` is explicit opt-in. Global-only. |
+| `mainModelFallbacks` | `[]` | Ordered provider/model refs on main-model failure. Global-only. |
+| `drafterModel` | unset (session) | Drafting-only primary model. Global-only. |
+| `drafterThinkingLevel` | unset (inherit) | Thinking level for the drafting agent. Global-only. |
+| `drafterModelFallbacks` | `[]` | Ordered drafting fallbacks; session model is final. Global-only. |
+| `compactorModel` | unset (plan B) | Emergency-compactor primary; never the session model. Global-only. |
+| `compactorModelFallbacks` | `[]` | Ordered compactor fallbacks; no session last resort. Global-only. |
+| `mainModelRetryMinutes` | `15` | Base minutes before main-session recovery; doubles per attempt, caps 5h. Global-only. |
+| `mainModelFailback` | `"auto"` | `"auto"` re-probes the primary; `"sticky"` keeps the fallback. Global-only. |
+| `mainModelPrimaryProbeMinutes` | `15` | Minutes between preferred-primary health probes. Global-only. |
+| `forbiddenModels` | `[]` | Refs that must never be selected (case-insensitive substring). |
+| `blockForbiddenModelSwitches` | `true` | Revert forbidden switches (`false` = stand but ledger). |
+| `visionAssist` | `true` | Continuation prompts carry the prefer-native-vision directive. |
+| `auditorModel` | unset (session) | Detached auditor primary (`"provider/id"` or bare id). |
+| `auditorModelFallbacks` | `[]` | Ordered auditor fallbacks; session model is final. Global-only. |
+| `auditorAllowedExtensions` | `[]` | Extension specs the detached auditor may load; resolved fail-closed, `[]` = isolated. |
+| `auditorSameSessionSwap` | `true` | Walk the fallback chain when the auditor is the session model. |
+| `auditorThinkingLevel` | unset (inherit) | Detached auditor reasoning level; picked with the model. |
+| `auditorToolTimeoutMs` | `300000` | Base budget per auditor tool call (30s–6h). Global-only. |
+| `auditorStallMs` | `600000` | Base silence budget for the detached auditor (1m–24h). Global-only. |
+| `auditJobRetentionMs` | `900000` | How long proven-dead audit job dirs are kept (0–7d, 0 = reap now). Global-only. |
+| `auditorInspection` | `false` | Auditor runs as a persistent session you can tail/resume. Global-only. |
+| `notifyCmd` | unset | Shell command on goal complete / pause / loop stop; message is `$1`. |
+| `tokenLimit` | unset (off) | Per-goal token budget; crossing it pauses. `0` = off. |
+| `wedgeAlertMinutes` | unset (30, or off while aggressive mode is on — the default) | Busy-but-silent minutes before the wedge alert; `0` = off. The menu shows the effective value. |
+| `autoResume` | `false` | Restored goals/loops/lists auto-resume in fresh sessions. Global-only. |
+| `decisionPopup` | `true` | Decision pauses pop the picker (`false` = widget card only). |
+| `carryover` | `"pause"` | Stale carryover on new activation: `"pause"` / `"clear"` / `"resume"`. |
+| `autoAcceptDrafts` | `false` | Drafts activate without the Confirm dialog (unattended rigs). |
+| `auditCap` | `5` (10 aggressive) | Pause after N consecutive auditor disapprovals (`0` = unlimited). |
+| `auditFeedbackChars` | `0` (full) | Max auditor-report chars returned after disapproval (`0` = full). |
+| `auditorSilent` | `true` | Auditor report renders final-only, no word-by-word HUD. |
+| `auditorProgressSignals` | `true` | Silent audits show phase label + byte counter. |
+| `hourlyRetryProbe` | `true` | Extra blind retry at :00:30 every hour while parked. Global-only. |
+| `subagentModelStrategy` | `"inherit-parent"` | Default subagent model policy for new sessions. |
+| `subagentModelOverrides` | unset | Per-agent-type model pin; always wins over strategy. |
+| `subagentFallbacks` | unset | Per-role fallback chains (first eligible ref wins). |
+| `aggressiveMode` | `true` | Keep-going defaults (`false` = pause-first policy). |
+| `stuckMaxInterventions` | `5` (10 aggressive) | Consecutive stuck interventions before a loop stops. |
+| `subagentHangEscalationMinutes` | `30` | Confirmed no-progress minutes before child-specific abort (`0` = warn only). |
+| `stallEscalationRefires` | `5` | Heartbeat refires before pause/stop (`0` = never). |
+| `zombieRetryMaxAttempts` | `3` | Re-dispatches per busy/no-stream episode (`0` = manual; max 10). |
+| `stallShortWords` | `15` | Tool-less turn under this many words is a nudge. |
+| `stallSimilarityThreshold` | `0.6` | Trigram similarity above this (tool-less) is a nudge. |
+| `postaudit` | unset | Post-completion audit config (same shape as legacy `reviewer`). |
+| `toolOverrides` | unset | Per-tool allow/hide/per-tool-config overrides. |
+| `reviewer` | legacy | Deprecated alias for `postaudit`; migrated on load, `postaudit` wins. |

package/extensions/approval-render-store.ts

@@ -0,0 +1,159 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { appendLedger, ensureDirs, nowIso, piGlaDir, runPersistStep } from "./goal-loop-core.js";
+
+/**
+ * Persisted terminal-approval renders (v0.38.25, post-objective summary).
+ *
+ * Field failure 2026-09-07: goal `20260907131550-12ddoy` completed with a
+ * perfect six-label archive record, but the approval chat lines fired into a
+ * dead context (auditor verdict landed with no live turn) — record perfect,
+ * delivery silent. The archive keeps facts; this sidecar keeps the RENDER.
+ *
+ * Contract: every terminal approval persists its human-sees lines here at
+ * archive time. Renders persisted from a live turn are marked delivered at
+ * once; renders persisted while the host is idle (`ctx.isIdle()`) stay
+ * undelivered until `replayUndeliveredApprovalRenders` delivers them on the
+ * next live contact (any user-invoked /goal /glla /review /list /loop
+ * command) and marks them delivered. Late verdicts follow the same path:
+ * persist first, deliver-or-replay — never silent.
+ */
+
+export interface PendingApprovalRender {
+  goalId: string;
+  objective: string;
+  chatLines: string[];
+  createdAt: string;
+  deliveredAt?: string;
+}
+
+/** Cap: the sidecar is a spillway, not a log. Delivered renders are kept
+ * briefly for inspection; undelivered ones are never dropped by the cap. */
+const MAX_STORED_RENDERS = 20;
+const MAX_REPLAY_PER_CONTACT = 5;
+
+export function approvalRenderStorePath(cwd: string): string {
+  return path.join(piGlaDir(cwd), "pending-approval-renders.json");
+}
+
+function isValidRender(entry: unknown): entry is PendingApprovalRender {
+  if (typeof entry !== "object" || entry === null) return false;
+  const e = entry as Record<string, unknown>;
+  return typeof e.goalId === "string" && e.goalId.length > 0
+    && typeof e.objective === "string"
+    && Array.isArray(e.chatLines)
+    && e.chatLines.every((line) => typeof line === "string")
+    && typeof e.createdAt === "string"
+    && (e.deliveredAt === undefined || typeof e.deliveredAt === "string");
+}
+
+function readRenders(cwd: string): PendingApprovalRender[] | undefined {
+  let raw: string;
+  try {
+    raw = fs.readFileSync(approvalRenderStorePath(cwd), "utf-8");
+  } catch {
+    return [];
+  }
+  try {
+    const parsed: unknown = JSON.parse(raw);
+    if (!Array.isArray(parsed)) throw new Error("not an array");
+    const valid = parsed.filter(isValidRender);
+    if (valid.length !== parsed.length) {
+      appendLedger(cwd, "terminal_approval_render_store_invalid", {
+        dropped: parsed.length - valid.length,
+        kept: valid.length,
+      });
+    }
+    return valid;
+  } catch {
+    appendLedger(cwd, "terminal_approval_render_store_invalid", { dropped: "all", kept: 0 });
+    return [];
+  }
+}
+
+function writeRenders(cwd: string, renders: PendingApprovalRender[]): boolean {
+  const landed = runPersistStep("persistApprovalRender", () => {
+    ensureDirs(cwd);
+    fs.writeFileSync(approvalRenderStorePath(cwd), JSON.stringify(renders, null, 2), "utf-8");
+    return true;
+  });
+  return landed === true;
+}
+
+/** Persist the rendered human-sees lines at archive time. `delivered`
+ * must be true only when the render went out on a provably live turn
+ * (callers pass `!ctx.isIdle()`); idle-persisted renders stay queued for
+ * replay. Never throws into orchestrator handlers. */
+export function persistApprovalRender(cwd: string, render: {
+  goalId: string;
+  objective: string;
+  chatLines: string[];
+  delivered: boolean;
+}): boolean {
+  const at = nowIso();
+  const existing = readRenders(cwd) ?? [];
+  const entry: PendingApprovalRender = {
+    goalId: render.goalId,
+    objective: render.objective.slice(0, 300),
+    chatLines: render.chatLines,
+    createdAt: at,
+    ...(render.delivered ? { deliveredAt: at } : {}),
+  };
+  const undelivered = existing.filter((e) => !e.deliveredAt);
+  const delivered = [...existing.filter((e) => e.deliveredAt), ...(render.delivered ? [entry] : [])]
+    .slice(-(MAX_STORED_RENDERS - undelivered.length - (render.delivered ? 0 : 1)));
+  const next = [...undelivered, ...(render.delivered ? [] : [entry]), ...delivered];
+  if (!writeRenders(cwd, next.slice(-MAX_STORED_RENDERS))) return false;
+  appendLedger(cwd, "terminal_approval_render_persisted", {
+    goalId: render.goalId,
+    delivered: render.delivered,
+    lines: render.chatLines.length,
+  });
+  return true;
+}
+
+/** Deliver every undelivered render on a live contact, oldest first,
+ * fire-once fenced via deliveredAt. Callers are user-invoked command
+ * handlers — live by construction. Returns the replayed count; never
+ * throws. */
+export function replayUndeliveredApprovalRenders(ctx: { cwd: string; ui: { notify: (message: string, type?: "info" | "warning" | "error") => void } }): number {
+  const renders = readRenders(ctx.cwd);
+  if (!renders || renders.length === 0) return 0;
+  const pending = renders.filter((e) => !e.deliveredAt).slice(0, MAX_REPLAY_PER_CONTACT);
+  if (pending.length === 0) return 0;
+  const at = nowIso();
+  let replayed = 0;
+  for (const entry of pending) {
+    try {
+      ctx.ui.notify(entry.chatLines.join("\n"), "info");
+      entry.deliveredAt = at;
+      replayed += 1;
+      appendLedger(ctx.cwd, "terminal_approval_render_replayed", {
+        goalId: entry.goalId,
+        createdAt: entry.createdAt,
+      });
+    } catch {
+      // Leave undelivered for the next live contact; never break the
+      // command that triggered the replay.
+      break;
+    }
+  }
+  if (replayed > 0) writeRenders(ctx.cwd, renders);
+  return replayed;
+}
+
+/** Liveness probe for delivery marking. Unknown/throwing ⇒ idle ⇒
+ * undelivered ⇒ replayed on the next live contact. The safe direction is
+ * never-silent: a duplicate render on the next command beats a lost one. */
+export function isApprovalContextIdle(ctx: { isIdle?: () => boolean }): boolean {
+  try {
+    return ctx.isIdle?.() ?? true;
+  } catch {
+    return true;
+  }
+}
+
+/** Test-only reset for store isolation. */
+export function __testOnlyResetApprovalRenderStore(): void {
+  // No module-level cache — isolation is via cwd-scoped files.
+}

package/extensions/auditor-extensions.ts

@@ -185,7 +185,10 @@ export function resolveAuditorAllowedExtensions(
   return out;
 }
 
-/** Bounded, deterministic normalization of the allowlist value. */
+/** Bounded, deterministic normalization of the allowlist value.
+ * Audit 2026-09-06: dedup is case-insensitive like the model fallback
+ * chains (npm names cannot differ by case; a same-case pair is always the
+ * same intent). The first spelling wins; the original is preserved. */
 export function normalizeAuditorAllowedExtensions(value: unknown): string[] {
   if (!Array.isArray(value)) return [];
   const seen = new Set<string>();
@@ -193,9 +196,10 @@ export function normalizeAuditorAllowedExtensions(value: unknown): string[] {
   for (const entry of value) {
     if (typeof entry !== "string") continue;
     const spec = entry.trim();
-    if (!spec || seen.has(spec)) continue;
+    const key = spec.toLowerCase();
+    if (!spec || seen.has(key)) continue;
     if (out.length >= 32) break; // bounded: the request hash stays sane
-    seen.add(spec);
+    seen.add(key);
     out.push(spec);
   }
   return out;
@@ -294,10 +298,19 @@ export function discoverAuditorExtensions(home: string, cwd?: string): Discovere
 }
 
 /** Expand the allowlist into `pi` CLI args: ["--extension", spec, …].
- * Empty/absent list → [] (the worker keeps plain --no-extensions). */
-export function auditorExtensionArgs(allowed: string[] | undefined): string[] {
+ * Audit 2026-09-06: entries resolve fail-closed through
+ * resolveAuditorAllowedExtensions first — raw `npm:`/relative specs are
+ * never emitted (a raw npm: entry would trigger a fresh network install,
+ * or silently load nothing offline). Empty/absent list → [] (the worker
+ * keeps plain --no-extensions). */
+export function auditorExtensionArgs(
+  allowed: string[] | undefined,
+  home: string,
+  cwd?: string,
+  settingsBase?: string,
+): string[] {
   const args: string[] = [];
-  for (const spec of normalizeAuditorAllowedExtensions(allowed)) {
+  for (const spec of resolveAuditorAllowedExtensions(allowed, home, cwd, settingsBase)) {
     args.push("--extension", spec);
   }
   return args;

package/extensions/completion-summary.ts

@@ -1,4 +1,5 @@
 import type { Goal, Status } from "./goal-loop-core.js";
+import { truncateToWidth } from "@earendil-works/pi-tui";
 
 /**
  * The durable, user-facing terminal recap contract. Keep this as a small
@@ -172,26 +173,118 @@ export function withoutStaleNext(details: string[] | undefined): string[] {
  * informing details (the full record lives in the archive and the
  * transcript notice), then the approval trailer and the record pointer.
  * Five 120-char label lines scan as soup, not a summary (field
- * 2026-09-04); the stale Next never reaches the chat. */
+ * 2026-09-04); the stale Next never reaches the chat.
+ * v0.38.25: optional `counts` audit-goal counts line rides between the
+ * approval trailer and the record pointer (the pointer stays last). */
 export function buildApprovalChatLines(notice: {
   outcome: string;
   details: string[] | undefined;
   approval: string;
   record: string;
+  counts?: string;
 }): string[] {
   return [
     `✓ done — ${notice.outcome}`,
     ...withoutStaleNext(notice.details).slice(0, 2),
     notice.approval,
+    ...(notice.counts ? [notice.counts] : []),
     notice.record,
   ];
 }
 
+/** v0.38.25: the audit-goal counts line. Compact execution + audit proof
+ * built ONLY from durable goal state — turns/file-writes/bash from
+ * telemetry, verdict counts from auditHistory. Absent facts are named as
+ * absent, never invented (the recorded-facts honesty rule). */
+export function buildAuditCountsLine(goal: Goal, auditNote?: string): string {
+  const telemetry = goal.telemetry;
+  const run = telemetry
+    ? `${telemetry.turns} turns · ${telemetry.fileWrites} file writes · ${telemetry.bashCalls} bash calls`
+    : "no execution telemetry was recorded";
+  const history = goal.auditHistory ?? [];
+  const latest = history.length > 0 ? history[history.length - 1] : undefined;
+  const audit = auditNote ?? (latest === undefined
+    ? "no auditor verdict was recorded"
+    : (() => {
+      const verdict = latest.approved ? "approved" : latest.impossible ? "impossible" : latest.disapproved ? "disapproved" : "no verdict";
+      return `auditor ${verdict} (${history.length} verdict${history.length === 1 ? "" : "s"})`;
+    })());
+  return `— run: ${run} · ${audit}.`;
+}
+
+export interface TerminalApprovalRenderInput {
+  goal: Goal;
+  status: Status;
+  stopReason?: string;
+  archivePath?: string;
+  completionSummary?: string;
+  /** Path-specific voice, e.g. `— auditor X approved …` or `— completed without audit (your choice).` */
+  approval: string;
+  /** Path-specific record pointer, e.g. `— record: <path>`. */
+  record: string;
+  /** Extra trailing lines (inspection-session pointer, …). */
+  extras?: string[];
+  /** Override for the counts line (e.g. the no-audit path). */
+  countsLine?: string;
+  /** Override for the audit half of the counts line. */
+  auditNote?: string;
+}
+
+export interface TerminalApprovalRender {
+  /** The human-sees chat lines: outcome + ≤2 details + approval + counts + record (+ extras). */
+  chatLines: string[];
+  /** Compact single line for external notifies (pager/sound safe). */
+  recap: string;
+  /** Transcript-notice details: informing details (stale Next stripped) + approval. */
+  transcriptLines: string[];
+  /** The counts line riding the render. */
+  countsLine: string;
+  /** Brief outcome (chat line 1 without the `✓ done — ` prefix). */
+  outcome: string;
+  /** Approval trailer line (shared by chat + transcript surfaces). */
+  approval: string;
+}
+
+/** v0.38.25: ONE canonical builder for every terminal approval surface —
+ * chat notify, transcript notice, external notify, and the persisted
+ * archive render. All approval paths (detached auditor, manual verify,
+ * Esc-without-audit) build the same voice from the same resolved facts so
+ * the surfaces cannot drift and a render can be persisted + replayed. */
+export function buildTerminalApprovalRender(input: TerminalApprovalRenderInput): TerminalApprovalRender {
+  const facts: CompletionSummaryFacts = {
+    goal: input.goal,
+    status: input.status,
+    stopReason: input.stopReason,
+    archivePath: input.archivePath,
+  };
+  const candidate = input.completionSummary ?? input.goal.completionSummary;
+  const recap = compactTerminalCompletionSummary(facts, candidate);
+  const brief = terminalHumanBrief(facts, candidate);
+  const countsLine = input.countsLine ?? buildAuditCountsLine(input.goal, input.auditNote);
+  return {
+    chatLines: [
+      ...buildApprovalChatLines({
+        outcome: brief.outcome,
+        details: brief.details,
+        approval: input.approval,
+        record: input.record,
+        counts: countsLine,
+      }),
+      ...(input.extras ?? []),
+    ],
+    recap,
+    transcriptLines: [...withoutStaleNext(brief.details), input.approval],
+    countsLine,
+    outcome: brief.outcome,
+    approval: input.approval,
+  };
+}
+
 /** Multi-line projection: one `Label: value` line per label with generous
  * word-bounded values. This is the user-facing `✓ done` block — six short
  * facts that stay scannable in chat. The single-line projection remains
  * for width-bound surfaces (TUI widget card, external notifies). */
-export function completionSummaryLines(text: string | undefined, maxValueLength = 240): string[] {
+export function completionSummaryLines(text: string | undefined, maxValueLength = 240, lineWidth?: number): string[] {
   const source = completionSummaryBody(text ?? "").replace(/\s+/g, " ").trim();
   const lower = source.toLowerCase();
   const positions = COMPLETION_SUMMARY_LABELS
@@ -207,7 +300,10 @@ export function completionSummaryLines(text: string | undefined, maxValueLength
       .map((entry) => entry.start)
       .sort((a, b) => a - b)[0] ?? source.length;
     const rawValue = source.slice(valueStart, nextStart).trim();
-    return `${name}: ${clipSummaryValue(rawValue || "not recorded", maxValueLength)}`;
+    const line = `${name}: ${clipSummaryValue(rawValue || "not recorded", maxValueLength)}`;
+    // Audit 2026-09-06: optional width budget for width-bound surfaces —
+    // the default 240-char values previously had no width-conscious path.
+    return lineWidth && lineWidth > 0 ? truncateToWidth(line, lineWidth, "…") : line;
   });
 }
 
@@ -322,8 +418,9 @@ export function terminalCompletionSummaryLines(
   facts: CompletionSummaryFacts,
   candidate = facts.goal.completionSummary,
   maxValueLength = 240,
+  lineWidth?: number,
 ): string[] {
-  return completionSummaryLines(resolveCompletionSummary(facts, candidate).summary, maxValueLength);
+  return completionSummaryLines(resolveCompletionSummary(facts, candidate).summary, maxValueLength, lineWidth);
 }
 
 /**