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

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.38.26 — approval-render store: spillway cap keeps undelivered renders (2026-09-08)
+
+### Fixed
+- Post-tag review of the v0.38.25 store: the sidecar cap could trim undelivered renders past 20 entries (non-positive slice budget). The cap now applies to delivered history only — undelivered renders are never dropped (self-draining: any user command replays them). Same 7 behavioral pins green; full gate 1986 pass / 0 fail.
+
+## 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

package/docs/INDEX.md

@@ -18,7 +18,7 @@ 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.24 continue through the supervisor freeze (`/glla pause`),
+  v0.35.14–v0.38.26 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
@@ -27,7 +27,8 @@ For shipped docs, the relevant entry points are:
   extensions, bounded zero-stream retry containment, crash-safe persistence,
   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) — see CHANGELOG.md for the full trail.
+  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

package/extensions/approval-render-store.ts

@@ -0,0 +1,162 @@
+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[] {
+  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 } : {}),
+  };
+  // The cap trims DELIVERED history only: undelivered renders are never
+  // dropped (each is ~1KB and any user command replays them, so the
+  // undelivered tail is self-draining in practice).
+  const undelivered = existing.filter((e) => !e.deliveredAt);
+  const delivered = [...existing.filter((e) => e.deliveredAt), ...(render.delivered ? [entry] : [])];
+  const deliveredBudget = Math.max(0, MAX_STORED_RENDERS - undelivered.length - (render.delivered ? 0 : 1));
+  const next = [...undelivered, ...(render.delivered ? [] : [entry]), ...delivered.slice(-deliveredBudget)];
+  if (!writeRenders(cwd, next)) 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.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/completion-summary.ts

@@ -173,21 +173,113 @@ 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

package/extensions/loops/goal-activation.ts

@@ -124,6 +124,7 @@ isGoalRevisionCurrent,
   type ModelSwitchRecord,
   type ListItem,
 } from "../goal-loop-core.js";
+import { replayUndeliveredApprovalRenders } from "../approval-render-store.js";
 import {
   createContinuationDispatch,
   dispatchMatchesOwner,
@@ -778,12 +779,18 @@ export function registerGoalRuntime(pi: ExtensionAPI): void {
     handler: (args: string, ctx: ExtensionContext) => {
       rememberCtx(ctx);
       if (refuseForeignCommand(ctx)) return Promise.resolve();
+      // v0.38.25: live contact — replay any approval render that landed
+      // with no live turn (persist-first, never silent).
+      replayUndeliveredApprovalRenders(ctx);
       return cmdGoal(args, ctx);
     },
   });
   const settingsHandler = (args: string, ctx: ExtensionContext) => {
     rememberCtx(ctx);
     if (refuseForeignCommand(ctx)) return Promise.resolve();
+    // v0.38.25: live contact — replay any approval render that landed
+    // with no live turn (persist-first, never silent).
+    replayUndeliveredApprovalRenders(ctx);
     return cmdSettings(args, ctx);
   };
   pi.registerCommand("glla", {
@@ -812,6 +819,9 @@ export function registerGoalRuntime(pi: ExtensionAPI): void {
     handler: (args: string, ctx: ExtensionContext) => {
       rememberCtx(ctx);
       if (refuseForeignCommand(ctx)) return Promise.resolve();
+      // v0.38.25: live contact — replay any approval render that landed
+      // with no live turn (persist-first, never silent).
+      replayUndeliveredApprovalRenders(ctx);
       return cmdReview(args, ctx);
     },
   });
@@ -838,6 +848,9 @@ export function registerGoalRuntime(pi: ExtensionAPI): void {
     handler: (args: string, ctx: ExtensionContext) => {
       rememberCtx(ctx);
       if (refuseForeignCommand(ctx)) return Promise.resolve();
+      // v0.38.25: live contact — replay any approval render that landed
+      // with no live turn (persist-first, never silent).
+      replayUndeliveredApprovalRenders(ctx);
       return cmdList(args, ctx);
     },
   });
@@ -859,6 +872,9 @@ export function registerGoalRuntime(pi: ExtensionAPI): void {
     handler: (args: string, ctx: ExtensionContext) => {
       rememberCtx(ctx);
       if (refuseForeignCommand(ctx)) return Promise.resolve();
+      // v0.38.25: live contact — replay any approval render that landed
+      // with no live turn (persist-first, never silent).
+      replayUndeliveredApprovalRenders(ctx);
       return cmdLoop(args, ctx);
     },
   });

package/extensions/loops/goal-auditor-hooks.ts

@@ -242,7 +242,8 @@ import {
   pushCapped as pushRepetitionCapped,
 } from "../goal-loop-repetition.js";
 import { buildStatusText, buildWidgetLines, type AuditDisplayProgress } from "../goal-loop-display.js";
-import { buildApprovalChatLines, compactCompletionSummary, compactTerminalCompletionSummary, isGenericCompletionSummary, missingCompletionSummaryLabels, terminalHumanBrief, withoutStaleNext } from "../completion-summary.js";
+import { buildTerminalApprovalRender, compactCompletionSummary, isGenericCompletionSummary, missingCompletionSummaryLabels } from "../completion-summary.js";
+import { isApprovalContextIdle, persistApprovalRender } from "../approval-render-store.js";
 import {
   defaultAgentDir,
   resolveEffectiveSubagentModel,
@@ -1420,23 +1421,29 @@ async function retryStoredCompletionAudit(origin: CompletionAuditOrigin = "provi
     // is the agent's completionSummary when captured; the objective is the
     // fallback for legacy/aborted goals.
     const terminalReason = `auditor ${result.model} approved (${origin})`;
-    const recap = compactTerminalCompletionSummary({
-      goal: state.goal,
-      status: "complete",
-      stopReason: terminalReason,
-      archivePath: path.relative(liveCtx.cwd, archivedGoalPath(liveCtx.cwd, state.goal.id)) || archivedGoalPath(liveCtx.cwd, state.goal.id),
-    }, state.goal.completionSummary);
-    // Computed pre-archive: archiveCurrentGoal clears state.goal.
-    const brief = terminalHumanBrief({
-      goal: state.goal,
-      status: "complete",
-      stopReason: terminalReason,
-      archivePath: path.relative(liveCtx.cwd, archivedGoalPath(liveCtx.cwd, state.goal.id)) || archivedGoalPath(liveCtx.cwd, state.goal.id),
-    }, state.goal.completionSummary);
     const approvalVia = `${origin === "manual" ? " on /goal verify" : origin === "session-recovery" ? " after session recovery" : " on the provider retry"}${fallbackUsed ? " after an auditor-model fallback" : ""}`;
     // v0.38.20: the chat record pointer. Computed pre-archive like the
-    // recap/brief above (archiveCurrentGoal clears state.goal).
+    // render below (archiveCurrentGoal clears state.goal).
     const approvalRecord = `— record: ${path.relative(liveCtx.cwd, archivedGoalPath(liveCtx.cwd, state.goal.id)) || archivedGoalPath(liveCtx.cwd, state.goal.id)}`;
+    const approvalArchivePath = path.relative(liveCtx.cwd, archivedGoalPath(liveCtx.cwd, state.goal.id)) || archivedGoalPath(liveCtx.cwd, state.goal.id);
+    // v0.38.25: ONE canonical render for every approval surface (chat,
+    // transcript, external, persisted). Computed pre-archive — the fence
+    // clears state.goal — and persisted after the archive lands so a
+    // verdict that lands with no live turn is replayed on the next live
+    // contact instead of going silent (field 2026-09-07).
+    const approvalRender = buildTerminalApprovalRender({
+      goal: state.goal,
+      status: "complete",
+      stopReason: terminalReason,
+      archivePath: approvalArchivePath,
+      completionSummary: state.goal.completionSummary,
+      approval: `— auditor ${result.model} approved${approvalVia}.`,
+      record: approvalRecord,
+      extras: inspectionSessionPath
+        ? [`Auditor session kept for review: pi --session ${inspectionSessionPath} (or pi --fork ${inspectionSessionPath}).`]
+        : [],
+    });
+    const approvalObjective = state.goal.objective;
     const archived = archiveCurrentGoal(liveCtx, "complete", `auditor ${result.model} approved (${origin})`);
     if (!archived) {
       // archiveCurrentGoal already preserved the live record and warned the
@@ -1460,17 +1467,14 @@ async function retryStoredCompletionAudit(origin: CompletionAuditOrigin = "provi
     // PR #43: live inspection — the auditor's pi persisted a resumable
     // session pinned inside the job dir. Point the user at it AFTER the
     // audit (interactive attach only now; while running it was read-only).
-    liveCtx.ui.notify([...buildApprovalChatLines({
-      outcome: brief.outcome,
-      details: brief.details,
-      approval: `— auditor ${result.model} approved${approvalVia}.`,
-      record: approvalRecord,
-    }),
-      ...(inspectionSessionPath
-        ? [`Auditor session kept for review: pi --session ${inspectionSessionPath} (or pi --fork ${inspectionSessionPath}).`]
-        : []),
-    ].join("\n"), "info");
-    notifyExternal(liveCtx, `Goal complete (auditor approved, ${origin}): ${recap}`);
+    liveCtx.ui.notify(approvalRender.chatLines.join("\n"), "info");
+    notifyExternal(liveCtx, `Goal complete (auditor approved, ${origin}): ${approvalRender.recap}`);
+    persistApprovalRender(liveCtx.cwd, {
+      goalId,
+      objective: approvalObjective,
+      chatLines: approvalRender.chatLines,
+      delivered: !isApprovalContextIdle(liveCtx),
+    });
     // v0.38.18 (track 3): the toast above is ephemeral — without a
     // transcript entry the session keeps narrating "waiting on the
     // auditor's verdict" after the archive (junk-runner field). Deliver
@@ -1481,10 +1485,10 @@ async function retryStoredCompletionAudit(origin: CompletionAuditOrigin = "provi
       sendTerminalCompletionNotice(liveCtx, {
         goalId,
         generation,
-        outcome: brief.outcome,
+        outcome: approvalRender.outcome,
         // v0.38.20: the transcript keeps the informing details, but the
         // stale pre-verdict `Next:` is stripped here too.
-        details: [...withoutStaleNext(brief.details), `— auditor ${result.model} approved${approvalVia}.`],
+        details: approvalRender.transcriptLines,
       });
     }
     return;

package/extensions/loops/goal-tools.ts

@@ -253,7 +253,8 @@ import {
   pushCapped as pushRepetitionCapped,
 } from "../goal-loop-repetition.js";
 import { buildStatusText, buildWidgetLines, type AuditDisplayProgress } from "../goal-loop-display.js";
-import { buildApprovalChatLines, compactCompletionSummary, compactTerminalCompletionSummary, resolveCompletionSummary, terminalHumanBrief, withoutStaleNext } from "../completion-summary.js";
+import { buildTerminalApprovalRender, compactCompletionSummary, compactTerminalCompletionSummary } from "../completion-summary.js";
+import { isApprovalContextIdle, persistApprovalRender } from "../approval-render-store.js";
 import {
   defaultAgentDir,
   resolveEffectiveSubagentModel,
@@ -1217,11 +1218,18 @@ function registerAgentTools(pi: any): void {
           const terminalGoal = state.goal;
           if (!terminalGoal) return staleToolResult();
           const terminalReason = "completed without audit (user choice after Esc)";
-          const recap = compactTerminalCompletionSummary({
+          const escArchivePath = path.relative(ctx.cwd, archivedGoalPath(ctx.cwd, terminalGoal.id)) || archivedGoalPath(ctx.cwd, terminalGoal.id);
+          // v0.38.25: canonical render (same voice as every approval path).
+          // Built from the terminalGoal local, which survives the archive
+          // fence clearing state.goal.
+          const escRender = buildTerminalApprovalRender({
             goal: terminalGoal,
             status: "complete",
             stopReason: terminalReason,
-            archivePath: path.relative(ctx.cwd, archivedGoalPath(ctx.cwd, terminalGoal.id)) || archivedGoalPath(ctx.cwd, terminalGoal.id),
+            archivePath: escArchivePath,
+            approval: `— completed without audit (your choice).`,
+            record: `— record: ${escArchivePath}`,
+            auditNote: "completed without audit (your choice)",
           });
           if (!archiveCurrentGoal(ctx, "complete", terminalReason)) {
             return {
@@ -1229,23 +1237,18 @@ function registerAgentTools(pi: any): void {
               details: {},
             };
           }
-          const brief = terminalHumanBrief({
-            goal: terminalGoal,
-            status: "complete",
-            stopReason: terminalReason,
-            archivePath: path.relative(ctx.cwd, archivedGoalPath(ctx.cwd, terminalGoal.id)) || archivedGoalPath(ctx.cwd, terminalGoal.id),
-          });
           // v0.38.20: the command output keeps the informing details (stale
           // `Next:` stripped); the chat notify is outcome + approval +
           // record pointer like every other approval path.
-          const briefBlock = [...withoutStaleNext(brief.details), `— completed without audit (your choice).`].join("\n");
-          ctx.ui.notify(buildApprovalChatLines({
-            outcome: brief.outcome,
-            details: brief.details,
-            approval: `— completed without audit (your choice).`,
-            record: `— record: ${path.relative(ctx.cwd, archivedGoalPath(ctx.cwd, terminalGoal.id)) || archivedGoalPath(ctx.cwd, terminalGoal.id)}`,
-          }).join("\n"), "info");
-          notifyExternal(ctx, `Goal complete without audit (user choice): ${recap}`);
+          const briefBlock = escRender.transcriptLines.join("\n");
+          ctx.ui.notify(escRender.chatLines.join("\n"), "info");
+          notifyExternal(ctx, `Goal complete without audit (user choice): ${escRender.recap}`);
+          persistApprovalRender(ctx.cwd, {
+            goalId: terminalGoal.id,
+            objective: terminalGoal.objective,
+            chatLines: escRender.chatLines,
+            delivered: !isApprovalContextIdle(ctx),
+          });
           return { content: [{ type: "text", text: `Goal marked complete without audit (user choice).\n\n${briefBlock}` }], details: {} };
         }
         scheduleContinuation(ctx, true);
@@ -1265,22 +1268,25 @@ function registerAgentTools(pi: any): void {
         // saying "auditor approved" — pure process, no information
         // (Screenshot_20260808_012905/013220/013515).
         const terminalReason = `auditor ${result.model} approved`;
-        const recap = compactTerminalCompletionSummary({
-          goal: state.goal,
-          status: "complete",
-          stopReason: terminalReason,
-          archivePath: path.relative(ctx.cwd, archivedGoalPath(ctx.cwd, state.goal.id)) || archivedGoalPath(ctx.cwd, state.goal.id),
-        }, state.goal.completionSummary);
-        // Computed pre-archive: archiveCurrentGoal clears state.goal.
-        const brief = terminalHumanBrief({
+        const manualArchivePath = path.relative(ctx.cwd, archivedGoalPath(ctx.cwd, state.goal.id)) || archivedGoalPath(ctx.cwd, state.goal.id);
+        // v0.38.20: captured pre-archive — archiveCurrentGoal clears
+        // state.goal, so the record pointer must be computed here.
+        const manualArchiveRecord = `— record: ${manualArchivePath}`;
+        // v0.38.25: canonical render — same voice as the detached path.
+        const manualRender = buildTerminalApprovalRender({
           goal: state.goal,
           status: "complete",
           stopReason: terminalReason,
-          archivePath: path.relative(ctx.cwd, archivedGoalPath(ctx.cwd, state.goal.id)) || archivedGoalPath(ctx.cwd, state.goal.id),
-        }, state.goal.completionSummary);
-        // v0.38.20: captured pre-archive — archiveCurrentGoal clears
-        // state.goal, so the record pointer must be computed here.
-        const manualArchiveRecord = `— record: ${path.relative(ctx.cwd, archivedGoalPath(ctx.cwd, state.goal.id)) || archivedGoalPath(ctx.cwd, state.goal.id)}`;
+          archivePath: manualArchivePath,
+          completionSummary: state.goal.completionSummary,
+          approval: `— auditor ${result.model} approved.`,
+          record: manualArchiveRecord,
+          extras: inspectionSessionPath
+            ? [`Auditor session kept for review: pi --session ${inspectionSessionPath} (or pi --fork ${inspectionSessionPath}).`]
+            : [],
+        });
+        const manualObjective = state.goal.objective;
+        const manualGoalId = state.goal.id;
         const archived = archiveCurrentGoal(ctx, "complete", terminalReason);
         if (!archived) {
           // The archive helper preserves the live objective and emits the
@@ -1299,17 +1305,14 @@ function registerAgentTools(pi: any): void {
         // v0.38.20: same approval voice as the detached path — the stale
         // pre-verdict `Next:` never reaches the chat.
         // PR #43: append the kept inspection-session pointer when present.
-        ctx.ui.notify([...buildApprovalChatLines({
-          outcome: brief.outcome,
-          details: brief.details,
-          approval: `— auditor ${result.model} approved.`,
-          record: manualArchiveRecord,
-        }),
-          ...(inspectionSessionPath
-            ? [`Auditor session kept for review: pi --session ${inspectionSessionPath} (or pi --fork ${inspectionSessionPath}).`]
-            : []),
-        ].join("\n"), "info");
-        notifyExternal(ctx, `Goal complete (auditor approved): ${recap}`);
+        ctx.ui.notify(manualRender.chatLines.join("\n"), "info");
+        notifyExternal(ctx, `Goal complete (auditor approved): ${manualRender.recap}`);
+        persistApprovalRender(ctx.cwd, {
+          goalId: manualGoalId,
+          objective: manualObjective,
+          chatLines: manualRender.chatLines,
+          delivered: !isApprovalContextIdle(ctx),
+        });
         return { content: [{ type: "text", text: `Goal approved by auditor ${result.model}.` }], details: {} };
       }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goal-list-loop-audit",
-  "version": "0.38.24",
+  "version": "0.38.26",
   "description": "Mission control for autonomous pi: interview-drafted goals, an audited task queue, and forever-loops (metric, spec, project-audit) that run for hours. A detached extension-less auditor process re-verifies every completion with raw evidence without holding the main pi turn; confirmed drafts, decision pauses and consent gates keep you in charge.",
   "license": "AGPL-3.0-only",
   "author": "dracon",