pi-goal-list-loop-audit 0.38.17 → 0.38.19

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 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
+- Track 1 (pipe-syntax): the mechanical pre-audit checker runs narrow `cmd 2>&1 | tail/head/grep` pipelines shell-free with pipefail-head semantics instead of 126-rejecting finished work (`parseMechanicalPipeline`, `runMechanicalPipeline`; `tee`/grep-file-flags still refused).
+- Track 2 (post-answer stall): a turn that never streamed parks on the first abort with no hot retry (`zombie_auto_retry_refused_never_streamed`, honest park copy), and the rearm milestone names an open-but-silent turn instead of claiming "no turn started".
+- Track 3 (stale waiting-verdict): the detached-approval branch delivers the `✓ done` brief into the conversation as a fire-once followUp turn (`sendTerminalCompletionNotice`), so the transcript records the archive instead of narrating "waiting" forever. Skipped for manual `/goal verify` (in-turn closure already exists).
+
 ## 0.38.17 — release-contract docs trail (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.17 continue through the supervisor freeze (`/glla pause`),
+  v0.35.14–v0.38.19 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/goal-continuation.ts

@@ -31,6 +31,7 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import { state, replaceState } from "./goal-state.js";
 import {
   appendLedger,
+  readLedgerTail,
   nowIso,
   newGoalId,
   archivedGoalPath,
@@ -267,6 +268,12 @@ let continuationRearmSince = 0;
 // (rearm storm fires with no accepted dispatch — the user's "pi did not
 // start a turn" state under a recovery park).
 let lastNoTurnStartedNotifiedAt = 0;
+// v0.38.18 (track 2): the wall clock of the last turn/agent begin-marker
+// observed by dispatchStartAcknowledged, regardless of pending dispatch.
+// Lets the milestone notify distinguish "no turn started" from "a turn is
+// open but never picked up the dispatch" (neonbreak: creation turn open
+// and silent since 12:57 while the storm reported "no turn started").
+let lastObservedTurnStartAt = 0;
 let continuationRearmMilestone = 0;
 // v0.34.57: per-record counter capping the compaction-paused re-arm loop.
 // A stuck session that never produces a new compaction event must not
@@ -323,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) {
@@ -348,10 +375,18 @@ export function accountSendRearm(ctx: ExtensionContext, kind: "continuation" | "
       const noDispatchAccepted = lastContinuationSentAt === 0 || lastContinuationSentAt < continuationRearmSince;
       if (noDispatchAccepted && lastNoTurnStartedNotifiedAt + SEND_REARM_LEDGER_MILESTONES_MS[0]! <= Date.now()) {
         lastNoTurnStartedNotifiedAt = Date.now();
-        appendLedger(ctx.cwd, "rearm_no_turn_started", { streak, minutes: Math.round(elapsed / 60000) });
+        // v0.38.18 (track 2): a turn that began after the storm started is
+        // open — reporting "no turn started" then is false and sends the
+        // user down the wrong path (resume a queue that is not stuck vs
+        // interrupt a hung turn). Say which is true.
+        const turnOpen = lastObservedTurnStartAt >= since && lastObservedTurnStartAt > 0;
+        const turnOpenMinutes = turnOpen ? Math.max(1, Math.round((Date.now() - lastObservedTurnStartAt) / 60000)) : 0;
+        appendLedger(ctx.cwd, "rearm_no_turn_started", { streak, minutes: Math.round(elapsed / 60000), turnOpen, turnOpenMinutes });
         const aggressive = resolveEffectiveAggressiveSettings(loadSettings(ctx.cwd)).aggressiveMode;
         const recoveryStop = aggressive ? "a state-based stop" : "the automatic horizon";
-        const msg = `glla: pi accepted no continuation for ${Math.round(elapsed / 60000)}m (${streak} re-arms, no turn started) — the send queue may be stuck. The generic recovery probe is retrying automatically; no action needed unless it reaches ${recoveryStop}.`;
+        const msg = turnOpen
+          ? `glla: a turn started ${turnOpenMinutes}m ago but no continuation was accepted since (${streak} re-arms) — the open turn has not picked up the queued dispatch. If its stream counters are frozen it is hung, not thinking; Esc interrupts it, then resume retries. No action needed unless this reaches ${recoveryStop}.`
+          : `glla: pi accepted no continuation for ${Math.round(elapsed / 60000)}m (${streak} re-arms, no turn started) — the send queue may be stuck. The generic recovery probe is retrying automatically; no action needed unless it reaches ${recoveryStop}.`;
         ctx.ui.notify(msg, "warning");
         notifyExternal(ctx, msg);
       }
@@ -569,6 +604,10 @@ export function dispatchFailed(ctx: ExtensionContext, record: ContinuationDispat
 }
 
 export function dispatchStartAcknowledged(ctx: ExtensionContext, source: string, prompt?: unknown): boolean {
+  // v0.38.18 (track 2): record every begin-marker even when no dispatch is
+  // pending — the rearm milestone uses it to tell an open-but-silent turn
+  // from a turn that never started.
+  if (source === "turn_start" || source === "agent_start") lastObservedTurnStartAt = Date.now();
   // v0.34.104 ([Image-#1]): any real agent activity during the
   // post-list-completion settle window means pi woke up on its own — the
   // deferred continuation must be cancelled so we don't double-dispatch.
@@ -1058,6 +1097,57 @@ export function scheduleContinuation(ctx: ExtensionContext, force = false, delay
   continuationTimer = scheduleSessionTimeout(() => sendContinuation(goalId), delay);
 }
 
+export interface TerminalCompletionNotice {
+  goalId: string;
+  outcome: string;
+  details: string[];
+}
+
+/** v0.38.18 (track 3: junk-runner stale waiting-verdict): the detached
+ * verifier settles asynchronously — the transcript's last word is "the
+ * verdict will be applied asynchronously", and a toast is the only
+ * closure. A later "how are we looking" then truthfully re-reports the
+ * stale transcript as still-waiting even though the goal is archived.
+ * This delivers the `✓ done` brief INTO the conversation as a followUp
+ * turn so the transcript records the completion. Goal-null-safe (the goal
+ * is already archived when this fires), fire-once per goal via a durable
+ * ledger fence, and fenced like every other automatic send. Returns true
+ * when the notice was dispatched. */
+export function sendTerminalCompletionNotice(ctx: ExtensionContext, notice: TerminalCompletionNotice): boolean {
+  if (supervisorPaused(state)) return false;
+  if (mainModelRecoveryActive()) return false;
+  if (flags.sessionHandoffPending || flags.initialSessionLoadPending || flags.extensionApiStale || flags.staleTerminalDone || flags.zombieStoodDown) return false;
+  if (!flags.extensionApi) return false;
+  if (isForeignCtx(ctx)) return false;
+  try {
+    const already = readLedgerTail(ctx.cwd, 400, (entry) =>
+      entry.type === "terminal_completion_notice_sent" &&
+      typeof (entry.value as { goalId?: unknown } | null)?.goalId === "string" &&
+      (entry.value as { goalId: string }).goalId === notice.goalId,
+    );
+    if (already.length > 0) return false;
+  } catch {
+    return false;
+  }
+  const content = [
+    `✓ done — ${notice.outcome}`,
+    ...notice.details,
+    "— goal archived; nothing further is owed. Acknowledge briefly; start follow-up work only if asked.",
+  ].join("\n");
+  try {
+    flags.extensionApi.sendMessage({
+      customType: GOAL_EVENT_ENTRY,
+      content,
+      display: false,
+    }, { triggerTurn: true, deliverAs: "followUp" });
+  } catch {
+    appendLedger(ctx.cwd, "terminal_completion_notice_unsent", { goalId: notice.goalId });
+    return false;
+  }
+  appendLedger(ctx.cwd, "terminal_completion_notice_sent", { goalId: notice.goalId, payloadChars: content.length });
+  return true;
+}
+
 export function buildMarkerContent(goalId: string): string {
   return `[GOAL CHECKPOINT goalId=${goalId}]`;
 }
@@ -1155,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 {
@@ -1194,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
@@ -1504,6 +1617,11 @@ export function clearQueueStuckProbe(): void {
 export function setContinuationRearmStreak(v: number): void {
   continuationRearmStreak = v;
 }
+
+/** Test-only: pretend a turn begin-marker was observed at the given clock. */
+export function __testOnlySetObservedTurnStartAt(v: number): void {
+  lastObservedTurnStartAt = v;
+}
 export function setContinuationRearmSince(v: number): void {
   continuationRearmSince = v;
 }
@@ -1521,6 +1639,7 @@ export function resetContinuationDispatchState(cwd: string): boolean {
   continuationRearmSince = 0;
   continuationRearmMilestone = 0;
   lastNoTurnStartedNotifiedAt = 0;
+  lastObservedTurnStartAt = 0;
   continuationStartCompactionRearms.clear();
   continuationStartRecoveryRearms.clear();
   return clearDispatchRecord(cwd);

package/extensions/goal-loop-backoff.ts

@@ -277,7 +277,15 @@ export function zombieRetryDecision(
   key: string,
   prev: ZombieRetryStreak,
   maxAttempts = DEFAULT_ZOMBIE_RETRY_MAX_ATTEMPTS,
-): { retry: boolean; streak: ZombieRetryStreak } {
+  // v0.38.18 (track 2: neonbreak never-streamed hot loop): the stream clock
+  // observed when the aborted turn STARTED. When the abort's observation
+  // point never advanced past it, the turn produced zero stream activity in
+  // its whole life — an immediate retry replays the same silence (field:
+  // 3 abort cycles in 5m, same frozen clock, 23k full payload each). Refuse
+  // at once and park for an explicit resume instead of burning the budget.
+  // 0/unknown preserves the legacy behavior (retry within budget).
+  turnStartAt = 0,
+): { retry: boolean; streak: ZombieRetryStreak; neverStreamed?: boolean } {
   const limit = Number.isInteger(maxAttempts) && maxAttempts >= 0
     ? Math.min(maxAttempts, MAX_ZOMBIE_RETRY_ATTEMPTS)
     : DEFAULT_ZOMBIE_RETRY_MAX_ATTEMPTS;
@@ -287,6 +295,9 @@ export function zombieRetryDecision(
   const streak: ZombieRetryStreak = sameEpisode
     ? { key, count: Math.min(prev.count + 1, MAX_ZOMBIE_RETRY_ATTEMPTS + 1), lastAbortStreamAt: observedStreamAt }
     : { key, count: 1, lastAbortStreamAt: observedStreamAt };
+  if (turnStartAt > 0 && observedStreamAt <= turnStartAt) {
+    return { retry: false, streak, neverStreamed: true };
+  }
   return { retry: streak.count <= limit, streak };
 }
 

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/goal-loop-shield.ts

@@ -246,6 +246,168 @@ function safeFileMarkerCompound(command: string): string[] | null {
   return [`test -${flag} ${testPath}`, `grep -q ${marker} ${grepPath}`];
 }
 
+/**
+ * v0.38.18 (track 1: endless-td pipe-syntax wedge): a narrow pipeline form.
+ * Contracts legitimately truncate noisy suites (`bun test 2>&1 | tail -n 4`);
+ * rejecting the `|` deterministically fast-failed finished work with no
+ * agent-side remedy. A pipeline is accepted only when EVERY segment is
+ * independently safe: the head is an ordinary safe command (resolved through
+ * the canonical runner exactly like a bare command) and each tail segment is
+ * an allowlisted text filter. Execution never touches a shell — the head
+ * runs through runMechanicalCommand and each filter is spawned with piped
+ * stdio. The pipeline passes iff the HEAD exits 0 (pipefail-head semantics:
+ * `tail` exits 0 even when the suite is red, so the tail's status is
+ * meaningless); filters only truncate evidence. `2>&1` on the head is
+ * accepted and ignored — head output already merges stderr. Every other
+ * redirect, substitution, quote, or second program stays exit-126 rejected.
+ */
+const MECHANICAL_HEAD_REDIRECT = /\s*2>&1\s*$/;
+const MECHANICAL_TAIL_FILTER = /^(?:tail|head)\s+-[nc]\s+\d{1,6}$/;
+const MECHANICAL_GREP_FILTER = /^grep\s+(?:-[a-z]+\s+)?[A-Za-z0-9_./:@=+,%-]+$/;
+
+function isAllowlistedMechanicalFilter(segment: string): boolean {
+  return MECHANICAL_TAIL_FILTER.test(segment) || MECHANICAL_GREP_FILTER.test(segment);
+}
+
+interface MechanicalPipeline {
+  head: string;
+  filters: string[];
+}
+
+/** Split a `head | filter | ...` command, or return null when any segment
+ * is outside the narrow allowed shape (callers fall through to the 126
+ * unsafe rejection). Naive `|` splitting is safe here: quotes and
+ * escapes are rejected characters, so a `|` is always a real pipe. */
+export function parseMechanicalPipeline(command: string): MechanicalPipeline | null {
+  if (!command.includes("|")) return null;
+  const segments = command.split("|").map((s) => s.trim());
+  if (segments.length < 2 || segments.some((s) => !s)) return null;
+  let head = segments[0]!.replace(MECHANICAL_HEAD_REDIRECT, "").trim();
+  if (!head) return null;
+  if (!isSafeMechanicalCommand(head)) return null;
+  const filters = segments.slice(1);
+  if (!filters.every(isAllowlistedMechanicalFilter)) return null;
+  return { head, filters };
+}
+
+const MECHANICAL_FILTER_STAGE_TIMEOUT_MS = 30_000;
+
+function runMechanicalFilterStage(
+  input: string,
+  filter: string,
+  timeoutMs: number,
+): Promise<{ output: string; exitCode: number; timedOut: boolean; launchError?: string }> {
+  return new Promise((resolve) => {
+    const [program = "", ...args] = filter.split(/[ \t]+/);
+    let child: ChildProcess;
+    try {
+      child = spawn(program, args, {
+        detached: process.platform !== "win32",
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+    } catch (error) {
+      resolve({ output: "", exitCode: 1, timedOut: false, launchError: error instanceof Error ? error.message : String(error) });
+      return;
+    }
+    let output = "";
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      try { child.kill("SIGKILL"); } catch { /* already gone */ }
+      resolve({ output: output.slice(-MECHANICAL_OUTPUT_TAIL_CHARS), exitCode: 1, timedOut: true });
+    }, timeoutMs);
+    child.stdout?.on("data", (chunk: Buffer) => {
+      output += chunk.toString("utf8");
+      if (output.length > MECHANICAL_OUTPUT_TAIL_CHARS * 2) {
+        output = output.slice(-MECHANICAL_OUTPUT_TAIL_CHARS);
+      }
+    });
+    child.stderr?.on("data", () => { /* filter diagnostics never enter evidence */ });
+    child.on("error", (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve({ output: "", exitCode: 1, timedOut: false, launchError: error.message });
+    });
+    child.on("close", (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve({ output: output.slice(-MECHANICAL_OUTPUT_TAIL_CHARS), exitCode: code ?? 1, timedOut: false });
+    });
+    try {
+      child.stdin?.write(input);
+      child.stdin?.end();
+    } catch { /* stdin already closed */ }
+  });
+}
+
+async function runMechanicalPipeline(
+  cwd: string,
+  pipeline: MechanicalPipeline,
+  rawCommand: string,
+  scripts: Record<string, string>,
+  effectiveTimeoutMs: number,
+  signal: AbortSignal | undefined,
+  effectiveProcessGroupSize: number,
+): Promise<MechanicalCheckResult> {
+  if (process.platform === "win32") {
+    return {
+      passed: false,
+      failedCommand: rawCommand,
+      output: "Mechanical pipelines need POSIX coreutils (tail/head/grep) and are not supported on Windows; reword the contract line to a bare runner invocation.",
+      exitCode: 126,
+    };
+  }
+  const { program, args } = resolveCanonicalRunnerCommand(pipeline.head, scripts);
+  if (!program) {
+    return { passed: false, failedCommand: rawCommand, output: "Empty mechanical command.", exitCode: 126 };
+  }
+  // ONE bounded automatic retry for the whole pipeline on a plain head
+  // failure (mirrors the single-command v0.35.20 retry); containment
+  // events fail immediately without a second untrusted process tree.
+  let firstFailure: { output: string; exitCode: number } | null = null;
+  for (let attempt = 1; attempt <= 2; attempt++) {
+    const head = await runMechanicalCommand(cwd, program, args, effectiveTimeoutMs, signal, effectiveProcessGroupSize);
+    if (head.timedOut || head.aborted || head.outputLimit || head.processGroupLimit) {
+      return { passed: false, failedCommand: rawCommand, ...formatMechanicalFailure(head, effectiveTimeoutMs) };
+    }
+    let stageInput = head.output;
+    let stageFailed: { output: string; exitCode: number } | null = null;
+    for (const filter of pipeline.filters) {
+      const stage = await runMechanicalFilterStage(stageInput, filter, MECHANICAL_FILTER_STAGE_TIMEOUT_MS);
+      if (stage.timedOut || stage.launchError) {
+        stageFailed = {
+          output: `[pipeline filter '${filter}' did not complete: ${stage.timedOut ? "timed out" : stage.launchError}]`,
+          exitCode: 1,
+        };
+        break;
+      }
+      stageInput = stage.output;
+    }
+    if (stageFailed) {
+      return { passed: false, failedCommand: rawCommand, ...stageFailed };
+    }
+    if (head.exitCode === 0) {
+      return { passed: true };
+    }
+    const evidence = [`[pipeline head exited ${head.exitCode}]`, stageInput || "(no output survived the filters)"]
+      .join("\n")
+      .slice(-MECHANICAL_OUTPUT_TAIL_CHARS);
+    if (attempt === 1) {
+      firstFailure = { output: evidence, exitCode: head.exitCode };
+    } else {
+      return {
+        passed: false,
+        failedCommand: rawCommand,
+        output: `[mechanical pipeline retried once after a failed first attempt (head exit ${firstFailure!.exitCode}); second attempt also failed — output tail below]\n` + evidence,
+      };
+    }
+  }
+  return { passed: false, failedCommand: rawCommand, output: firstFailure?.output ?? "", exitCode: firstFailure?.exitCode ?? 1 };
+}
+
 const DEFAULT_MECHANICAL_CHECK_TIMEOUT_MS = 600_000;
 const MECHANICAL_MAX_OUTPUT_BYTES = 64 * 1024 * 1024;
 const MECHANICAL_OUTPUT_TAIL_CHARS = 64 * 1024;
@@ -590,6 +752,11 @@ export async function runMechanicalPreAuditChecks(
     : DEFAULT_MECHANICAL_CHECK_TIMEOUT_MS;
   const effectiveProcessGroupSize = normalizeMechanicalProcessGroupLimit(maxProcessGroupSize);
   const recoveredRetries: string[] = [];
+  let scripts: Record<string, string> = {};
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(cwd, "package.json"), "utf8"));
+    if (pkg && typeof pkg.scripts === "object" && pkg.scripts) scripts = pkg.scripts;
+  } catch { /* no package.json — nothing to resolve */ }
   for (const rawCommand of commands) {
     const cmd = rawCommand.trim();
     const compound = safeFileMarkerCompound(cmd);
@@ -603,11 +770,21 @@ export async function runMechanicalPreAuditChecks(
       }
       continue;
     }
+    // v0.38.18 (track 1): narrow `head | tail/head/grep` pipelines run
+    // shell-free before the single-command gate below.
+    const pipeline = parseMechanicalPipeline(cmd);
+    if (pipeline) {
+      const pipelineResult = await runMechanicalPipeline(cwd, pipeline, rawCommand, scripts, effectiveTimeoutMs, signal, effectiveProcessGroupSize);
+      if (!pipelineResult.passed) return pipelineResult;
+      continue;
+    }
     if (!isSafeMechanicalCommand(cmd)) {
       return {
         passed: false,
         failedCommand: rawCommand,
-        output: "Rejected unsafe mechanical command syntax; only a single executable followed by literal arguments is allowed.",
+        output: cmd.includes("|")
+          ? "Rejected unsafe mechanical pipeline syntax; only `command | tail -n N`, `command | head -n N`, and `command | grep <literal>` are allowed (no redirects except a trailing 2>&1, no second program)."
+          : "Rejected unsafe mechanical command syntax; only a single executable followed by literal arguments is allowed.",
         exitCode: 126,
       };
     }
@@ -617,11 +794,7 @@ export async function runMechanicalPreAuditChecks(
     // flags the suite requires (serialization/isolation/timeouts). Running
     // the bare runner ignores that configuration and fails spuriously while
     // the real gate is green (field: fourth audit round, 2026-08-21).
-    let scripts: Record<string, string> = {};
-    try {
-      const pkg = JSON.parse(fs.readFileSync(path.join(cwd, "package.json"), "utf8"));
-      if (pkg && typeof pkg.scripts === "object" && pkg.scripts) scripts = pkg.scripts;
-    } catch { /* no package.json — nothing to resolve */ }
+    // (scripts are loaded once above the loop so the pipeline path shares them.)
     const { program, args } = resolveCanonicalRunnerCommand(cmd, scripts);
     if (!program) {
       return { passed: false, failedCommand: rawCommand, output: "Empty mechanical command.", exitCode: 126 };

package/extensions/loops/goal-activation.ts

@@ -460,6 +460,13 @@ const ZOMBIE_PAUSE_REASON = "automatic zero-stream abort — no provider activit
 // the park standing for manual resume — an honest degradation.
 let zombieRetryStreak: ZombieRetryStreak = { key: "", count: 0, lastAbortStreamAt: 0 };
 let zombieRetryTimer: NodeJS.Timeout | null = null;
+// v0.38.18 (track 2): the stream clock when the current turn's begin-marker
+// was last observed. Compared against the abort's observation point to tell
+// "wedged after streaming" (deserves budget retries) from "never streamed
+// since birth" (an immediate retry replays the silence — park at once).
+// 0 means no begin-marker observed (extension loaded mid-turn): unknown, and
+// unknown preserves the legacy retry-within-budget behavior.
+let lastTurnStartAt = 0;
 // An in-band provider pane is observed during tool_result and consumed at the
 // matching agent_end. Keep the raw text only in memory; the durable ledger
 // records the bounded classification, never the provider payload.
@@ -477,15 +484,15 @@ function scheduleZombieAutoRetry(
   goalId: string | undefined,
   observedStreamAt: number,
   silentMinutes: number,
-): { scheduled: boolean; attempt: number; maxAttempts: number } {
+): { scheduled: boolean; attempt: number; maxAttempts: number; reason?: "never-streamed" | "budget-exhausted" } {
   const key = goalId ?? "loop";
   const maxAttempts = zombieRetryMaxAttemptsOverride
     ?? loadSettings(ctx.cwd).zombieRetryMaxAttempts
     ?? DEFAULT_ZOMBIE_RETRY_MAX_ATTEMPTS;
-  const { retry, streak } = zombieRetryDecision(observedStreamAt, key, zombieRetryStreak, maxAttempts);
+  const { retry, streak, neverStreamed } = zombieRetryDecision(observedStreamAt, key, zombieRetryStreak, maxAttempts, lastTurnStartAt);
   zombieRetryStreak = streak;
-  const plan = { scheduled: retry, attempt: streak.count, maxAttempts };
-  appendLedger(ctx.cwd, retry ? "zombie_auto_retry_scheduled" : "zombie_auto_retry_refused_streak", {
+  const plan = { scheduled: retry, attempt: streak.count, maxAttempts, reason: neverStreamed ? "never-streamed" as const : retry ? undefined : "budget-exhausted" as const };
+  appendLedger(ctx.cwd, retry ? "zombie_auto_retry_scheduled" : neverStreamed ? "zombie_auto_retry_refused_never_streamed" : "zombie_auto_retry_refused_streak", {
     goalId,
     streakCount: streak.count,
     maxAttempts,
@@ -566,6 +573,12 @@ export function __testOnlyResetZombieAutoRetry(): void {
   }
   zombieRetryStreak = { key: "", count: 0, lastAbortStreamAt: 0 };
   zombieRetryMaxAttemptsOverride = null;
+  lastTurnStartAt = 0;
+}
+
+/** Test-only: pretend a turn begin-marker was observed at the given clock. */
+export function __testOnlySetTurnStartAt(at: number): void {
+  lastTurnStartAt = at;
 }
 
 let zombieRetryDelayOverride: number | null = null;
@@ -621,7 +634,7 @@ export function abortZombieRun(
       status: "paused",
       pauseKind: "error",
       pauseReason: reason,
-      pauseSuggestedAction: `The stalled ${noun} turn was aborted safely and the work is saved. Automatic retries use the configured zero-stream budget; ${activeGoalSurfaceCommand("resume")} retries immediately and ${activeGoalSurfaceCommand("cancel")} discards it.`,
+      pauseSuggestedAction: `The stalled ${noun} turn was aborted safely and the work is saved. ${lastTurnStartAt > 0 && observedStreamAt <= lastTurnStartAt ? `The turn never produced stream activity, so no automatic retry was scheduled; ${activeGoalSurfaceCommand("resume")} retries immediately and ${activeGoalSurfaceCommand("cancel")} discards it.` : `Automatic retries use the configured zero-stream budget; ${activeGoalSurfaceCommand("resume")} retries immediately and ${activeGoalSurfaceCommand("cancel")} discards it.`}`,
     }, current);
   } else if (loop) {
     clearLoopTimer();
@@ -649,6 +662,9 @@ export function abortZombieRun(
   // v0.35.x: keep the park as a bounded waystation for repeated
   // zero-stream attempts. Once the configured budget is exhausted the
   // refusal remains manual and durable.
+  // v0.38.18 (track 2): a turn that never streamed gets no hot retry — say
+  // so in the park copy instead of promising budget retries that never come.
+  const neverStreamed = lastTurnStartAt > 0 && observedStreamAt <= lastTurnStartAt;
   const retryPlan = scheduleZombieAutoRetry(current, generation, goal?.id, observedStreamAt, silentMinutes);
   const loopRecap = loop
     ? compactLoopCompletionSummary({ ...loop, historyLength: loop.history.length })
@@ -656,7 +672,9 @@ export function abortZombieRun(
   const message = `${goal ? goal.policy === "list" ? "List item" : "Goal" : "Loop"} paused after ${silentMinutes}m with zero stream activity; the zombie turn was aborted and queued retries were stopped. Work is saved. ${
     retryPlan.scheduled
       ? `Automatic retry ${retryPlan.attempt}/${retryPlan.maxAttempts} starts in ~90s; ${resume} retries immediately instead.`
-      : `${resume} retries it, or ${cancel} discards/stops it; the automatic retry budget is exhausted.`
+      : retryPlan.reason === "never-streamed"
+        ? `The turn never produced stream activity, so no automatic retry was scheduled — a retry would replay the same silence. ${resume} retries it, or ${cancel} discards/stops it.`
+        : `${resume} retries it, or ${cancel} discards/stops it; the automatic retry budget is exhausted.`
   }${loopRecap ? `\nRecap: ${loopRecap}` : ""}`;
   current.ui.notify(message, abortError ? "warning" : "info");
   notifyExternal(current, message);
@@ -2590,6 +2608,7 @@ export function registerGoalRuntime(pi: ExtensionAPI): void {
     if (sessionHandoffPending || extensionApiStale || staleTerminalDone || zombieStoodDown || isForeignCtx(ctx)) return;
     ensureAgentToolsReady(ctx, true);
     lastStreamActivityAt = Date.now();
+    lastTurnStartAt = lastStreamActivityAt;
     streamActivityObserved = true;
     // v0.32.1: a real turn started — the post-compaction resume debt is
     // discharged (the heartbeat stops retrying it).
@@ -2605,6 +2624,7 @@ export function registerGoalRuntime(pi: ExtensionAPI): void {
     if (sessionHandoffPending || extensionApiStale || staleTerminalDone || zombieStoodDown || isForeignCtx(ctx)) return;
     ensureAgentToolsReady(ctx, true);
     lastStreamActivityAt = Date.now();
+    lastTurnStartAt = lastStreamActivityAt;
     streamActivityObserved = true;
     dispatchStartAcknowledged(ctx, "turn_start");
   });

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

@@ -165,6 +165,7 @@ import {
   setLastContinuationSentPayloadRef,
   setContinuationRearmStreak,
   setContinuationRearmSince,
+  sendTerminalCompletionNotice,
   type ContinuationFlags,
   type ContinuationDeps,
 } from "../goal-continuation.js";
@@ -1443,6 +1444,19 @@ async function retryStoredCompletionAudit(origin: CompletionAuditOrigin = "provi
     // single line (pager/sound safe).
     liveCtx.ui.notify(`✓ done — ${brief.outcome}\n${[...brief.details, `— auditor ${result.model} approved${approvalVia}.`].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
+    // auditor's verdict" after the archive (junk-runner field). Deliver
+    // the brief into the conversation. Skipped for manual /goal verify:
+    // that runs inside a turn whose command output already closes the
+    // transcript. Fire-once fenced inside the sender.
+    if (origin !== "manual") {
+      sendTerminalCompletionNotice(liveCtx, {
+        goalId,
+        outcome: brief.outcome,
+        details: [...brief.details, `— auditor ${result.model} approved${approvalVia}.`],
+      });
+    }
     return;
   }
 

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.17",
+  "version": "0.38.19",
   "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",