pi-goal-list-loop-audit 0.38.18 → 0.38.20

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.38.20 — approval-notify cleanup (2026-09-04)
+
+### Fixed
+- Approval chat notify no longer reprints the agent's pre-verdict recap verbatim: the stale `Next: <verdict pending>` line (which read as complete-before-verify next to the approval trailer) is stripped on every approval surface, and the chat notify is outcome + at most two informing details + approval trailer + archive record pointer (`buildApprovalChatLines`, `withoutStaleNext`). The transcript notice keeps the informing details minus the stale Next. Applied to all three `✓ done` paths (detached approval, manual-verify approval, no-audit complete).
+- Field note: the 19:20 `...` cuts were v0.38.13 word-boundary `…` clips working as designed (every cut lands on a word boundary), not mid-word mangling — but five 120-char label lines still scan as soup, which the cap above addresses. The same session showed zero `terminal_completion_notice_*` events because the tab runs pre-v0.38.18 loaded code — `/reload` to pick up the notice path.
+
+## 0.38.19 — disapproval response: dispatch stall root-cause + state clear (2026-09-04)
+
+### Fixed
+- Track 2 root cause (post-answer stall): the wait-for-idle send gate deferred an owed continuation forever when the session went phantom-busy — busy, nothing pending, zero stream (neonbreak: 35 re-arms, zero sends, 45m to the zombie abort). A busy session with nothing pending and no real stream for `GLLA_BUSY_SILENT_SEND_MS` (default 5m) is wedged, not working: the marker is now sent into pi's followUp queue instead (`goal_continuation_send_busy_bypass`, `busyBypass` on the sent event). Genuinely working sessions and loaded queues keep the old wait path.
+- Track 3 state clear (stale waiting-verdict): `auditorDisplayPhase` projects `awaiting-verdict` only while the goal is still `auditing`. Closed goals (complete/aborted) and pre-archive snapshots carrying a stale running claim fall through to the quiet gate — no stale progress object can resurrect the wait after `goal_archived`.
+- Both fixes carry behavioral MockPi regression tests with empirical fail-before (old code fails the new assertions, guards pass throughout): `tests/answered-question-dispatch.test.ts` (3), `tests/closed-goal-clears-waiting.test.ts` (2).
+
 ## 0.38.18 — completion/lifecycle field trilogy (2026-09-04)
 
 ### 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.18 continue through the supervisor freeze (`/glla pause`),
+  v0.35.14–v0.38.20 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

package/extensions/completion-summary.ts

@@ -159,6 +159,34 @@ export function humanCompletionBrief(
   return { outcome, details };
 }
 
+/** v0.38.20: the agent's `Next:` recap line goes stale the moment the
+ * verdict lands — reprinting it next to the approval trailer reads as
+ * complete-before-verify (field 2026-09-04: `Next: detached auditor
+ * verdict decides.` printed above `— auditor … approved.`). Every approval
+ * surface strips it; the full six-label record stays in the archive. */
+export function withoutStaleNext(details: string[] | undefined): string[] {
+  return (details ?? []).filter((d) => !/^\s*Next\s*:/i.test(d));
+}
+
+/** v0.38.20: the approval chat notify — outcome first, at most two
+ * 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. */
+export function buildApprovalChatLines(notice: {
+  outcome: string;
+  details: string[] | undefined;
+  approval: string;
+  record: string;
+}): string[] {
+  return [
+    `✓ done — ${notice.outcome}`,
+    ...withoutStaleNext(notice.details).slice(0, 2),
+    notice.approval,
+    notice.record,
+  ];
+}
+
 /** 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/goal-continuation.ts

@@ -330,6 +330,26 @@ export function sendRearmDelayMs(streak: number): number {
   return 30_000;
 }
 
+/** v0.38.19 (track 2): how long a busy session with an owed send may go
+ * without real stream output before the marker is sent into pi's followUp
+ * queue anyway. 5m matches SEND_REARM_ESCALATE_SILENT_MS's definition of
+ * wedged silence, far below the ~45m zombie abort that used to be the only
+ * exit from a phantom-busy session. */
+export function busySilentSendMs(): number {
+  const raw = Number(process.env.GLLA_BUSY_SILENT_SEND_MS ?? 5 * 60_000);
+  return Number.isFinite(raw) && raw >= 0 ? raw : 5 * 60_000;
+}
+
+/** v0.38.19 (track 2): true when the session's business is stale enough
+ * that waiting for idle is the stall, not patience. Requires observed
+ * stream history (lastRealActivityAt > 0): a session that never streamed
+ * in this process is ignorance, not evidence of wedging — it keeps the old
+ * wait path (storm → escalation → zombie abort). */
+export function busySilentBypassDue(): boolean {
+  if (flags.lastRealActivityAt <= 0) return false;
+  return Date.now() - flags.lastRealActivityAt >= busySilentSendMs();
+}
+
 export function accountSendRearm(ctx: ExtensionContext, kind: "continuation" | "loop"): void {
   const streak = kind === "continuation" ? ++continuationRearmStreak : ++flags.loopRearmStreak;
   if (streak === 1) {
@@ -1225,12 +1245,35 @@ export function sendContinuation(goalId: string): void {
   }
   if (!guardGoalBeforeContinuation(ctx, "dispatch", goalId)) return;
   if (!isActionableGoal()) return;
+  // v0.38.19 (track 2): set when the busy-but-silent bypass below fires so
+  // the sent ledger event carries the marker. The test hook for the stream
+  // clock lives in loops/goal-ui.ts (__testOnlySetLastRealActivityAt).
+  let busyBypass = false;
   if (!ctx.isIdle() || ctx.hasPendingMessages()) {
     accountSendRearm(ctx, "continuation");
-    continuationScheduledFor = goalId;
-    // v0.28.29: backing-off cadence (was flat 50ms — 6,000 spins in 5m).
-    continuationTimer = scheduleSessionTimeout(() => sendContinuation(goalId), sendRearmDelayMs(continuationRearmStreak));
-    return;
+    // v0.38.19 (track 2, auditor-required): busy-but-silent bypass. A
+    // session that is busy with nothing pending and zero real stream for
+    // busySilentSendMs is not doing work a followUp could corrupt — it is
+    // wedged (neonbreak: answer in, 45m of phantom-busy, zero sends because
+    // wait-for-idle never cleared). pi's followUp queue is the designed
+    // vehicle for exactly this: the marker queues behind the stuck turn
+    // instead of rearming into the void until the zombie abort. Genuinely
+    // working sessions (fresh stream) and loaded queues (pending messages)
+    // keep the old wait path.
+    if (!ctx.isIdle() && !ctx.hasPendingMessages() && busySilentBypassDue()) {
+      busyBypass = true;
+      appendLedger(ctx.cwd, "goal_continuation_send_busy_bypass", {
+        goalId,
+        generation: flags.sessionGeneration,
+        silentMs: Date.now() - flags.lastRealActivityAt,
+        rearmStreak: continuationRearmStreak,
+      });
+    } else {
+      continuationScheduledFor = goalId;
+      // v0.28.29: backing-off cadence (was flat 50ms — 6,000 spins in 5m).
+      continuationTimer = scheduleSessionTimeout(() => sendContinuation(goalId), sendRearmDelayMs(continuationRearmStreak));
+      return;
+    }
   }
   if (!flags.extensionApi || flags.extensionApiStale) return;
   try {
@@ -1264,7 +1307,7 @@ export function sendContinuation(goalId: string): void {
     lastContinuationSentPayload = { content, display: false }; // v0.34.88: verbatim retry payload
     if (!dispatchAccepted(ctx, attempt)) return;
     continuationRearmStreak = 0; continuationRearmSince = 0; // v0.28.5 (E3): an accepted dispatch clears the storm
-    appendLedger(ctx.cwd, "goal_continuation_sent", { goalId, attemptId: attempt.id, generation: attempt.generation, kind, payloadChars: content.length });
+    appendLedger(ctx.cwd, "goal_continuation_sent", { goalId, attemptId: attempt.id, generation: attempt.generation, kind, payloadChars: content.length, ...(busyBypass ? { busyBypass: true } : {}) });
     // v0.35.37 (audit finding): the welcome-back recovery notice must fire
     // EXACTLY ONCE per auto-resume. The payload above was built with the
     // notice in it; once the dispatch is ACCEPTED the message has landed in

package/extensions/goal-loop-display.ts

@@ -668,7 +668,15 @@ export function auditorDisplayPhase(g: Goal, audit: AuditDisplayProgress | null
   const label = audit?.label?.toLowerCase() ?? "";
   if (label === "queued") return "queued";
   if (/infra|error|failed|blocked|no verdict/.test(label)) return "blocked";
-  if (audit?.phase === "complete") return "awaiting-verdict";
+  // v0.38.19 (track 3, auditor-required): awaiting-verdict is a LIVE claim
+  // — a worker done, its verdict not yet applied. A closed goal (complete /
+  // aborted, or anything past auditing) can never be waiting: the verdict
+  // landed or the claim died with the archive. A stale progress object
+  // handed in for a closed goal must not resurrect the wait (junk-runner:
+  // session narrating "waiting on the auditor's verdict" after
+  // goal_archived complete). Stale timestamps fall through to the quiet
+  // gate below, which is true — no worker will ever speak again.
+  if (audit?.phase === "complete" && g.status === "auditing") return "awaiting-verdict";
   const age = auditorActivityAge(audit, now);
   if (age !== undefined && age > AUDITOR_QUIET_MS) {
     // v0.37.0: progress-aware quiet gate. A tool that is still running INSIDE
@@ -691,7 +699,12 @@ export function auditorDisplayPhase(g: Goal, audit: AuditDisplayProgress | null
       return "running";
     return "quiet";
   }
-  if (!audit && g.pendingCompletion?.phase === "running") return "awaiting-verdict";
+  // Same lifecycle scope as above: a stale goal snapshot that still
+  // carries a running pendingCompletion must not project a wait either.
+  // (The archive strips pendingCompletion; this guards pre-archive
+  // snapshots read after the close.)
+  if (!audit && g.status === "auditing" && g.pendingCompletion?.phase === "running") return "awaiting-verdict";
+  if (!audit && g.pendingCompletion?.phase === "running") return "quiet";
   return "running";
 }
 

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

@@ -241,7 +241,7 @@ import {
   pushCapped as pushRepetitionCapped,
 } from "../goal-loop-repetition.js";
 import { buildStatusText, buildWidgetLines, type AuditDisplayProgress } from "../goal-loop-display.js";
-import { compactCompletionSummary, compactTerminalCompletionSummary, isGenericCompletionSummary, missingCompletionSummaryLabels, terminalHumanBrief } from "../completion-summary.js";
+import { buildApprovalChatLines, compactCompletionSummary, compactTerminalCompletionSummary, isGenericCompletionSummary, missingCompletionSummaryLabels, terminalHumanBrief, withoutStaleNext } from "../completion-summary.js";
 import {
   defaultAgentDir,
   resolveEffectiveSubagentModel,
@@ -1424,6 +1424,9 @@ async function retryStoredCompletionAudit(origin: CompletionAuditOrigin = "provi
       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).
+    const approvalRecord = `— record: ${path.relative(liveCtx.cwd, archivedGoalPath(liveCtx.cwd, state.goal.id)) || archivedGoalPath(liveCtx.cwd, state.goal.id)}`;
     const archived = archiveCurrentGoal(liveCtx, "complete", `auditor ${result.model} approved (${origin})`);
     if (!archived) {
       // archiveCurrentGoal already preserved the live record and warned the
@@ -1441,8 +1444,15 @@ async function retryStoredCompletionAudit(origin: CompletionAuditOrigin = "provi
     }
     // v0.38.14: the chat notify is the human briefing — outcome first,
     // filler labels dropped — while the external notify keeps the compact
-    // single line (pager/sound safe).
-    liveCtx.ui.notify(`✓ done — ${brief.outcome}\n${[...brief.details, `— auditor ${result.model} approved${approvalVia}.`].join("\n")}`, "info");
+    // single line (pager/sound safe). v0.38.20: outcome + at most two
+    // details + approval + record pointer; the agent's pre-verdict `Next:`
+    // is stale the moment the verdict lands and never reaches the chat.
+    liveCtx.ui.notify(buildApprovalChatLines({
+      outcome: brief.outcome,
+      details: brief.details,
+      approval: `— auditor ${result.model} approved${approvalVia}.`,
+      record: approvalRecord,
+    }).join("\n"), "info");
     notifyExternal(liveCtx, `Goal complete (auditor approved, ${origin}): ${recap}`);
     // v0.38.18 (track 3): the toast above is ephemeral — without a
     // transcript entry the session keeps narrating "waiting on the
@@ -1454,7 +1464,9 @@ async function retryStoredCompletionAudit(origin: CompletionAuditOrigin = "provi
       sendTerminalCompletionNotice(liveCtx, {
         goalId,
         outcome: brief.outcome,
-        details: [...brief.details, `— auditor ${result.model} approved${approvalVia}.`],
+        // 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}.`],
       });
     }
     return;

package/extensions/loops/goal-tools.ts

@@ -252,7 +252,7 @@ import {
   pushCapped as pushRepetitionCapped,
 } from "../goal-loop-repetition.js";
 import { buildStatusText, buildWidgetLines, type AuditDisplayProgress } from "../goal-loop-display.js";
-import { compactCompletionSummary, compactTerminalCompletionSummary, resolveCompletionSummary, terminalHumanBrief } from "../completion-summary.js";
+import { buildApprovalChatLines, compactCompletionSummary, compactTerminalCompletionSummary, resolveCompletionSummary, terminalHumanBrief, withoutStaleNext } from "../completion-summary.js";
 import {
   defaultAgentDir,
   resolveEffectiveSubagentModel,
@@ -1224,8 +1224,16 @@ function registerAgentTools(pi: any): void {
             stopReason: terminalReason,
             archivePath: path.relative(ctx.cwd, archivedGoalPath(ctx.cwd, terminalGoal.id)) || archivedGoalPath(ctx.cwd, terminalGoal.id),
           });
-          const briefBlock = [...brief.details, `— completed without audit (your choice).`].join("\n");
-          ctx.ui.notify(`✓ done — ${brief.outcome}\n${briefBlock}`, "info");
+          // 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}`);
           return { content: [{ type: "text", text: `Goal marked complete without audit (user choice).\n\n${briefBlock}` }], details: {} };
         }
@@ -1259,6 +1267,9 @@ function registerAgentTools(pi: any): void {
           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)}`;
         const archived = archiveCurrentGoal(ctx, "complete", terminalReason);
         if (!archived) {
           // The archive helper preserves the live objective and emits the
@@ -1274,7 +1285,14 @@ function registerAgentTools(pi: any): void {
           appendLedger(ctx.cwd, "goal_archive_failed_after_approval", { goalId: state.goal?.id, origin: "manual-verify", model: result.model });
           return { content: [{ type: "text", text: "The auditor approved, but the terminal archive could not be persisted. The goal is paused; fix persistence, resume, and retry complete_goal." }], details: {} };
         }
-        ctx.ui.notify(`✓ done — ${brief.outcome}\n${[...brief.details, `— auditor ${result.model} approved.`].join("\n")}`, "info");
+        // v0.38.20: same approval voice as the detached path — the stale
+        // pre-verdict `Next:` never reaches the chat.
+        ctx.ui.notify(buildApprovalChatLines({
+          outcome: brief.outcome,
+          details: brief.details,
+          approval: `— auditor ${result.model} approved.`,
+          record: manualArchiveRecord,
+        }).join("\n"), "info");
         notifyExternal(ctx, `Goal complete (auditor approved): ${recap}`);
         return { content: [{ type: "text", text: `Goal approved by auditor ${result.model}.` }], details: {} };
       }

package/extensions/loops/goal-ui.ts

@@ -1044,6 +1044,12 @@ function isContextStarvedRefused(): boolean {
 export function __testOnlySetLastCompactionAt(at: number | null): void {
   lastCompactionAt = at ?? 0;
 }
+/** Test-only: set the real-stream clock directly so busy-silence scenarios
+ * (answered question, phantom-busy host, zero stream) are drivable without
+ * wall-clock waits. Exported through loops/goal.js like the other hooks. */
+export function __testOnlySetLastRealActivityAt(at: number): void {
+  lastRealActivityAt = at;
+}
 
 /** Test-only: expose the live activity projection without requiring a TUI
  * renderer. This drives the same scope/timestamp checks used by refreshUI. */

package/extensions/loops/goal.ts

@@ -74,7 +74,7 @@ export {
   __testOnlyResetOwnerSession,
   __testOnlyRunFanOutListAuditFindings,
 } from "./goal-session.js";
-export { __testOnlySetLastCompactionAt, __testOnlyLoadState, __testOnlyRegisterAgentTools, __testOnlyRememberCtx, __testOnlyDisplayActivityFor, __testOnlyResetToolActivity } from "./goal-ui.js";
+export { __testOnlySetLastCompactionAt, __testOnlyLoadState, __testOnlyRegisterAgentTools, __testOnlyRememberCtx, __testOnlyDisplayActivityFor, __testOnlyResetToolActivity, __testOnlySetLastRealActivityAt } from "./goal-ui.js";
 export { auditorRetryPlan, runDetachedCompletionWithFallback, __testOnlySetAuditorRecoveryRetryDelay, __testOnlyResetAuditorRecoveryRuntime, type AuditorModelCandidate } from "./goal-auditor-hooks.js";
 export { handleSettingChoice } from "./goal-settings-ui.js";
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goal-list-loop-audit",
-  "version": "0.38.18",
+  "version": "0.38.20",
   "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",