pi-pier 0.4.1 → 0.4.3

package/src/subagent-spawn.ts

@@ -27,6 +27,7 @@ import {
   buildLaunchLine,
   buildLaunchParts,
   classifyWorktreeZone,
+  formatIsolateLocation,
   formatSubagentResult,
   formatWorktreeStat,
   isAlive,
@@ -592,7 +593,7 @@ export function createSpawnAction(h: SpawnActionHost) {
       delegationEnvPatch = delegationEnv({
         parentPaneId: env?.paneId ?? '',
         parentSessionId: bareSessionId(h.getSessionId()),
-        // Phase 2: the master's own pipe so the worker's report_progress can dial home (D49).
+        // The master's own pipe so the worker's todo_sync push can dial home (D49).
         parentPipe: pipeNameFor(masterCwd, env?.paneId ?? ''),
         taskId,
         description: spec.description,
@@ -733,7 +734,7 @@ export function createSpawnAction(h: SpawnActionHost) {
       if (background) {
         handToPoller(`prompt-${taskId}`);
         return {
-          content: [{ type: 'text', text: `started subagent ${subRef(entry)} (task ${taskId})` }],
+          content: [{ type: 'text', text: `started subagent ${subRef(entry)} (task ${taskId})${formatIsolateLocation(isolateMeta)}` }],
           details: { paneId, taskId, background: true, role: kind, slug },
         };
       }
@@ -752,7 +753,7 @@ export function createSpawnAction(h: SpawnActionHost) {
           const question = await readAskFlag(paneId);
           handToPoller(`prompt-${taskId}`);
           return {
-            content: [{ type: 'text', text: buildBlockedGateNotice({ paneId, description: spec.description, question }) }],
+            content: [{ type: 'text', text: `${buildBlockedGateNotice({ paneId, description: spec.description, question })}${formatIsolateLocation(isolateMeta)}` }],
             details: { paneId, taskId, background: true, blocked: true, role: kind },
           };
         }
@@ -776,7 +777,7 @@ export function createSpawnAction(h: SpawnActionHost) {
         if (isAlive(probe, Date.now())) {
           handToPoller(`prompt-${taskId}`);
           return {
-            content: [{ type: 'text', text: buildAliveNotice({ paneId, description: spec.description, scenario: 'moved-to-bg', probe }, Date.now()) }],
+            content: [{ type: 'text', text: `${buildAliveNotice({ paneId, description: spec.description, scenario: 'moved-to-bg', probe }, Date.now())}${formatIsolateLocation(isolateMeta)}` }],
             details: { paneId, taskId, background: true, movedToBackground: true, role: kind },
           };
         }
@@ -791,7 +792,7 @@ export function createSpawnAction(h: SpawnActionHost) {
       h.persistSubs();
       h.writeHistory(entry, { outcome: outcome.kind === 'completed' ? text : null }, 'fg-settle');
       return {
-        content: [{ type: 'text', text: formatSubagentResult(outcome, spec.description) }],
+        content: [{ type: 'text', text: `${formatSubagentResult(outcome, spec.description)}${formatIsolateLocation(isolateMeta)}` }],
         details: { paneId, taskId, background, role: kind },
       };
     } catch (err) {

package/src/terminal-core.ts

@@ -78,7 +78,8 @@ export interface TerminalEntry {
   readRevision?: number | null;
   readLen?: number;
   readTail?: string;
-  readEoTail?: string;
+  readTextLen?: number;
+  readTextHash?: number;
   initialized?: boolean;
 }
 
@@ -132,7 +133,8 @@ export function registerTerminal(
     readRevision: null,
     readLen: 0,
     readTail: '',
-    readEoTail: '',
+    readTextLen: 0,
+    readTextHash: 0,
   };
   return { ok: true, entries: [...entries, entry], entry };
 }
@@ -203,12 +205,61 @@ export function validateSignal(key: string): { ok: true; key: SignalKey } | { ok
   return { ok: true, key: k };
 }
 
+/** Compile a wait pattern with line semantics: herdr matches per line, so `^`/`$` anchors must bind
+ *  to line starts/ends, not only the start/end of the whole pane buffer. */
+export function compilePattern(pattern: string): RegExp {
+  return new RegExp(pattern, 'm');
+}
+
+/** The literal prefix of a regex source (leading `^` ignored, stops at the first metacharacter).
+ *  Lets the echo guard notice `DONE_[0-9]` in a command that echoes `DONE_$?`, which the full regex
+ *  cannot match even though the sentinel is plainly present in the typed text. */
+export function regexLiteralPrefix(pattern: string): string {
+  let prefix = '';
+  for (let i = 0; i < pattern.length; i += 1) {
+    const ch = pattern[i]!;
+    if (ch === '^' && prefix.length === 0) continue;
+    if (ch === '\\') {
+      const next = pattern[i + 1];
+      if (next == null || /[dDwWsSbBAZzG]/.test(next)) break;
+      prefix += next;
+      i += 1;
+      continue;
+    }
+    if ('.*+?^${}()|[]'.includes(ch)) break;
+    prefix += ch;
+  }
+  return prefix;
+}
+
+/** A concrete, echo-safe wait pattern derived from the literal prefix: anchored at a line start and
+ *  expecting the numeric sentinel suffix (`APN_BUILD2_EXIT_$?` → `^APN_BUILD2_EXIT_[0-9]`). Trailing
+ *  digits after a separator are dropped so a literal `..._0` still derives `..._[0-9]`; digits glued
+ *  to a name (`step2`) stay, because they are part of the marker. */
+export function echoSafeWaitSuggestion(literal: string): string | null {
+  const base = literal.replace(/([^A-Za-z0-9])\d+$/, '$1');
+  if (!base) return null;
+  return `^${base.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}[0-9]`;
+}
+
+/**
+ * A `cmd; echo RUN_EXIT_$? >> /tmp/run.log` sentinel lands in the log file, never in the pane a
+ * plain wait watches: one session slept 240-420 s at a time polling such a log with bash. Returns
+ * the sentinel's literal prefix and the file it is redirected into, or null.
+ */
+export function redirectedSentinel(text: string): { prefix: string; file: string } | null {
+  const m = /\becho\s+["']?([A-Za-z][A-Za-z0-9_]*?)\$\?["']?\s*>>?\s*(["']?)([^\s;&|"']+)\2/.exec(text);
+  return m ? { prefix: m[1]!, file: m[3]! } : null;
+}
+
 /**
  * Whether a wait pattern would match the terminal's own echoed input: the shell echoes typed
  * commands into the pane, so a pattern contained in the last sent text (`…; echo TERM_DONE_$?`
  * waited on as literal `TERM_DONE_`) matches its own echo and returns "matched" before the job
- * has produced anything. Detection is per terminal and best-effort: no send in this process
- * lifetime → no hazard known → the wait proceeds unchanged.
+ * has produced anything. A regex whose literal prefix occurs in the echo is also a hazard: the
+ * sentinel `DONE_$?` becomes `DONE_<status>` only after the command runs.
+ * Detection is per terminal and best-effort: no send in this process lifetime → no hazard known →
+ * the wait proceeds unchanged.
  */
 export function sentinelEchoHazard(opts: {
   pattern: string;
@@ -219,7 +270,13 @@ export function sentinelEchoHazard(opts: {
   if (!sent) return false;
   if (opts.regex) {
     try {
-      return new RegExp(opts.pattern).test(sent);
+      const re = compilePattern(opts.pattern);
+      if (re.test(sent)) return true;
+      // An anchored pattern is already safe when the echo cannot start a line with its literal
+      // prefix (`^DONE_[0-9]` vs `cmd; echo DONE_$?`); only unanchored patterns need the substring check.
+      const prefix = regexLiteralPrefix(opts.pattern);
+      if (!opts.pattern.startsWith('^') && prefix.length >= 3 && sent.includes(prefix)) return true;
+      return sent.includes('$?') && re.test(sent.replace(/\$\?/g, '0'));
     } catch {
       return false; // invalid regex is rejected by the caller before this runs
     }
@@ -242,11 +299,29 @@ export function stripAnsi(raw: string): string {
     .replace(/[\x00-\x08\x0b-\x1f\x7f]/g, '');
 }
 
+/** Secondary prompts (`dquote>`, `heredoc>`, `cmdand>`, …) mean the shell is still collecting input:
+ *  the command was incomplete (unbalanced quote, open block, …) and every later line types into it.
+ *  Only the last non-empty line is inspected, so `>` in ordinary output cannot trip the check. */
+const CONTINUATION_PROMPT_RE = /^(?:quote|dquote|bquote|heredoc|cmdand|cmdor|cmdsubst|subsh|then|else|elif|do|done|for|while|if|fi|case|esac|select|repeat|function|math|brace|foreach|cond)>$/i;
+
+export function detectContinuationPrompt(text: string): string | null {
+  const lines = text.split('\n');
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    const line = lines[i]!.trim();
+    if (!line) continue;
+    return CONTINUATION_PROMPT_RE.test(line) ? line : null;
+  }
+  return null;
+}
+
 export interface ReadCursor {
   revision: number;
   len: number;
   tail: string;
-  eoTail: string;
+  /** Full pane-text length and FNV-1a hash: herdr's screen window can rewrite earlier lines while
+   *  the last characters stay identical, so a tail comparison alone is not a change detector. */
+  textLen: number;
+  textHash: number;
 }
 
 export interface ReadIncrement {
@@ -258,24 +333,36 @@ export interface ReadIncrement {
 
 const CURSOR_TAIL_CHARS = 64;
 
+/** FNV-1a 32-bit: change detection for the read cursor, not a security primitive. */
+export function hashPaneText(text: string): number {
+  let hash = 0x811c9dc5;
+  for (let i = 0; i < text.length; i += 1) {
+    hash ^= text.charCodeAt(i);
+    hash = Math.imul(hash, 0x01000193);
+  }
+  return hash >>> 0;
+}
+
 export function computeIncrement(
   prev: ReadCursor | null,
   next: { text: string; revision: number },
   maxChars: number,
 ): ReadIncrement {
   const stableLen = next.text.lastIndexOf('\n') + 1;
+  const textHash = hashPaneText(next.text);
   const cursor: ReadCursor = {
     revision: next.revision,
     len: stableLen,
     tail: next.text.slice(Math.max(0, stableLen - CURSOR_TAIL_CHARS), stableLen),
-    eoTail: next.text.slice(-CURSOR_TAIL_CHARS).trimEnd(),
+    textLen: next.text.length,
+    textHash,
   };
-  if (prev && next.text.slice(-CURSOR_TAIL_CHARS).trimEnd() === prev.eoTail) {
+  if (prev && prev.textLen === next.text.length && prev.textHash === textHash) {
     return { mode: 'none', text: '', cursor: prev, hardCapped: false };
   }
   if (
     prev &&
-    next.text.length >= prev.len &&
+    next.text.length > prev.textLen &&
     next.text.slice(Math.max(0, prev.len - prev.tail.length), prev.len).trimEnd() === prev.tail.trimEnd()
   ) {
     const suffix = next.text.slice(prev.len);
@@ -293,7 +380,7 @@ export function excerptAroundMatch(text: string, pattern: string, regex: boolean
   let index = -1;
   let hitLen = pattern.length;
   if (regex) {
-    const found = new RegExp(pattern).exec(text);
+    const found = compilePattern(pattern).exec(text);
     index = found?.index ?? -1;
     hitLen = found?.[0].length ?? pattern.length;
   } else {
@@ -315,7 +402,7 @@ export function classifyWaitMatch(
   pattern: string,
   regex: boolean,
 ): { kind: 'fresh'; excerpt: string } | { kind: 'stale' } | { kind: 'absent' } {
-  const match = (text: string) => regex ? new RegExp(pattern).test(text) : text.includes(pattern);
+  const match = (text: string) => regex ? compilePattern(pattern).test(text) : text.includes(pattern);
   const inc = computeIncrement(prev, { text: paneText, revision: prev?.revision ?? 0 }, paneText.length + 1);
   const unread = inc.mode === 'append' ? inc.text : inc.mode === 'reset' ? paneText : '';
   if (match(unread)) return { kind: 'fresh', excerpt: excerptAroundMatch(unread, pattern, regex) };
@@ -378,10 +465,15 @@ export interface ShellInitPlan {
   readonly command: string | null;
 }
 
+/** History expansion off in both managed shells: bash honours `set +H`, zsh requires
+ *  `setopt NO_BANG_HIST` (`set +H` leaves `!` expansion on and an unbalanced `"…$!"` wedges the
+ *  shell at `dquote>`). Both shells parse this one-liner; only the matching branch runs. */
+export const SHELL_INIT_COMMAND = 'if [ -n "$ZSH_VERSION" ]; then setopt NO_BANG_HIST; else set +H; fi';
+
 /**
- * Plan the shell init command: `set +H` disables history expansion in managed bash/zsh shells, where `!`
- * in ordinary commands (`!|`, `if [ ! -f ... ]`, `!$`) otherwise triggers `zsh: event not found: \|` and
- * wedges the shell. PowerShell rejects the syntax and has no `!` history expansion, so it is skipped.
+ * Plan the shell init command: disable history expansion, where `!` in ordinary commands (`!|`,
+ * `if [ ! -f ... ]`, `!$`) otherwise triggers `zsh: event not found: \|` and wedges the shell.
+ * PowerShell rejects the syntax and has no `!` history expansion, so it is skipped.
  * Limit: the top-level shell only — a nested `bash -i` re-enables its own defaults; init is only worth
  * sending once the shell is at its prompt and has not been initialized yet.
  */
@@ -395,7 +487,7 @@ export function planShellInit(opts: {
   if (opts.readiness !== undefined && opts.readiness !== 'prompt') {
     return { shouldInit: false, command: null };
   }
-  return { shouldInit: true, command: 'set +H' };
+  return { shouldInit: true, command: SHELL_INIT_COMMAND };
 }
 
 export function foldTerminalsRegistry(
@@ -425,7 +517,8 @@ export function foldTerminalsRegistry(
         readRevision: typeof t.readRevision === 'number' ? t.readRevision : null,
         readLen: typeof t.readLen === 'number' ? t.readLen : 0,
         readTail: typeof t.readTail === 'string' ? t.readTail : '',
-        readEoTail: typeof t.readEoTail === 'string' ? t.readEoTail : '',
+        readTextLen: typeof t.readTextLen === 'number' ? t.readTextLen : 0,
+        readTextHash: typeof t.readTextHash === 'number' ? t.readTextHash : 0,
         initialized: t.initialized === true,
       }));
   }
@@ -470,7 +563,8 @@ export interface TerminalNudgeInput {
 export interface TerminalReminderPlan {
   due: boolean;
   content: string | null;
-  /** Terminals covered by this notice; the caller bumps each one's `nudges` at schedule time. */
+  /** Terminals covered by this notice; the caller bumps each one's `nudges` when the notice is
+   *  actually delivered (a cancelled grace timer must not consume a nudge). */
   ids: string[];
 }
 

package/src/todo-core.ts

@@ -9,6 +9,17 @@ const PHASE_MAX_LEN = 30;
 /** Session entry type for human/automated edits, replayed during branch rebuild (D38). */
 export const TODO_EDIT_CUSTOM_TYPE = 'pi-herdr.todo-edit';
 
+/** Session entry type recording that the near-archive rewrite window was already offered for one
+ *  list; folded on rebuild so a resumed session proceeds to the terminal clear instead of re-warning. */
+export const TODO_ARCHIVE_WINDOW_CUSTOM_TYPE = 'pi-herdr.todo-archive-window';
+
+export interface ArchiveWindowMarker {
+  version: 1;
+  /** Ordered list identity at offer time. The marker only applies after the last snapshot, so any
+   *  rewrite (new snapshot) or edit (list mutation) invalidates it without a timestamp comparison. */
+  itemsHash: string;
+}
+
 export type TodoEditOp = 'done' | 'drop' | 'rm' | 'unblock';
 
 export interface TodoEdit {
@@ -115,6 +126,20 @@ export function listsEqual(a: readonly TodoItem[], b: readonly TodoItem[]): bool
   return true;
 }
 
+/** Stable list identity (FNV-1a over content/status/blocker/phase): keys the archive-window marker
+ *  so it never applies to a list that was edited after the window was offered. */
+export function todoListHash(items: readonly TodoItem[]): string {
+  let hash = 0x811c9dc5;
+  for (const it of items) {
+    const text = `${it.content}\u0000${it.status}\u0000${it.blocker ?? ''}\u0000${it.phase ?? ''}\u0001`;
+    for (let i = 0; i < text.length; i++) {
+      hash ^= text.charCodeAt(i);
+      hash = Math.imul(hash, 0x01000193);
+    }
+  }
+  return (hash >>> 0).toString(16).padStart(8, '0');
+}
+
 /** Items completed by this write (D36: surfaced back to the caller). */
 export function completionTransitions(prev: readonly TodoItem[], next: readonly TodoItem[]): string[] {
   const prevMap = new Map(prev.map((it) => [it.content, it.status]));
@@ -123,8 +148,11 @@ export function completionTransitions(prev: readonly TodoItem[], next: readonly
     .map((it) => it.content);
 }
 
-/** Completed items pushed back to open by this write (D37: reversible, but warn). */
+/** Completed items pushed back to open by this write (D37: reversible, but warn). A previous list
+ *  with no open item was a finished plan, and a new plan legitimately reuses generic task names, so
+ *  content-keyed reversion is meaningless there: warn only while the same plan is still in flight. */
 export function revertedCompleted(prev: readonly TodoItem[], next: readonly TodoItem[]): string[] {
+  if (!prev.some((it) => it.status === 'pending' || it.status === 'in_progress')) return [];
   const nextMap = new Map(next.map((it) => [it.content, it.status]));
   return prev
     .filter((it) => {
@@ -206,6 +234,15 @@ export interface FoldedTodos {
   items: TodoItem[];
   /** Timestamp of the last write that shaped these items; null when the entry carried none. */
   writtenAt: number | null;
+  /** True when the anti-freeze rewrite window was already offered for exactly this untouched list. */
+  archiveWindowOffered: boolean;
+}
+
+function extractArchiveWindowMarker(data: unknown): ArchiveWindowMarker | null {
+  if (typeof data !== 'object' || data === null) return null;
+  const raw = data as Partial<ArchiveWindowMarker>;
+  if (raw.version !== 1 || typeof raw.itemsHash !== 'string') return null;
+  return { version: 1, itemsHash: raw.itemsHash };
 }
 
 function entryTimestamp(entry: BranchEntryLike): number | null {
@@ -222,6 +259,9 @@ function entryTimestamp(entry: BranchEntryLike): number | null {
 export function foldLatestTodosMeta(entries: readonly BranchEntryLike[]): FoldedTodos | null {
   let found: TodoItem[] | null = null;
   let writtenAt: number | null = null;
+  // The marker applies only when it follows the last snapshot; a later snapshot resets it, and any
+  // edit that actually changes the list makes the hash mismatch (a no-op edit leaves it untouched).
+  let windowMarker: ArchiveWindowMarker | null = null;
   for (const entry of entries) {
     if (entry.type === 'message') {
       const msg = entry.message as { role?: unknown; toolName?: unknown; details?: unknown } | null | undefined;
@@ -231,6 +271,7 @@ export function foldLatestTodosMeta(entries: readonly BranchEntryLike[]): Folded
       if (snapshot) {
         found = snapshot.items.map((it) => ({ ...it }));
         writtenAt = entryTimestamp(entry);
+        windowMarker = null;
       }
     } else if (entry.type === 'custom' && entry.customType === TODO_EDIT_CUSTOM_TYPE) {
       const payload = extractEditPayload(entry.data);
@@ -238,9 +279,13 @@ export function foldLatestTodosMeta(entries: readonly BranchEntryLike[]): Folded
         found = applyTodoEdits(found, payload.edits);
         writtenAt = entryTimestamp(entry) ?? (payload.ts > 0 ? payload.ts : writtenAt);
       }
+    } else if (entry.type === 'custom' && entry.customType === TODO_ARCHIVE_WINDOW_CUSTOM_TYPE && found) {
+      windowMarker = extractArchiveWindowMarker(entry.data);
     }
   }
-  return found ? { items: found, writtenAt } : null;
+  if (!found) return null;
+  const archiveWindowOffered = windowMarker != null && windowMarker.itemsHash === todoListHash(found);
+  return { items: found, writtenAt, archiveWindowOffered };
 }
 
 function extractSnapshotFromDetails(details: unknown): TodoSnapshot | null {

package/src/todo-read-hook.ts

@@ -1,15 +1,15 @@
 /**
  * Plan the todo read hook (before_agent_start + display:false). Stale-core keeps a fully completed list
  * from being recited forever: stale (turn-based) warns with the old entries as rewrite references,
- * rate-limited and capped; archived (wall-clock) treats the list as absent, sharing the guard cadence
- * with empty lists.
+ * rate-limited and capped; archived (wall-clock) treats the list as absent — one rewrite window (its
+ * offer persisted per list identity so a resume skips it), then the terminal clear on the next run.
  */
 import { boundedView, currentActivity, type TodoItem } from './todo-core.ts';
 import { countTodos } from './vocab.ts';
 import { STALE_NOTICE_MAX, evaluateStaleness, formatAge } from './stale-core.ts';
-import { todoMark } from './todo-window.ts';
+import { todoLine } from './todo-window.ts';
 
-/** Cadence shared by empty-list guards, stale warnings, and archive notices. */
+/** Cadence shared by empty-list guards, stale warnings, and the archive rewrite window. */
 const EMPTY_GUARD_EVERY_N = 4;
 const TODO_READ_CUSTOM_TYPE = 'pi-herdr.todo-read';
 
@@ -51,6 +51,8 @@ interface TodoReadPlan {
   /** Clear the in-memory list when injecting the archive notice (the caller persists the empty JSONL);
    * a kept dead list would suppress the empty guard that resumes tracking after an idle gap. */
   clearArchived: boolean;
+  /** This injection is the one-window rewrite offer; the caller persists the marker so a resume skips it. */
+  offerArchiveWindow: boolean;
   message: {
     customType: string;
     content: string;
@@ -68,6 +70,9 @@ export function planTodoReadHook(opts: {
   now: number;
   staleNotices: number;
   lastStaleGuardTurn: number | null;
+  /** Whether the near-archive rewrite window was already offered for this exact list (in-process or
+   *  folded from the persisted marker). The terminal clear no longer waits for the shared cadence. */
+  archiveWindowOffered: boolean;
 }): TodoReadPlan {
   const msg = (content: string) => ({
     customType: TODO_READ_CUSTOM_TYPE,
@@ -83,6 +88,7 @@ export function planTodoReadHook(opts: {
       effect: 'empty-guard',
       clearArchived: false,
       archived: false,
+      offerArchiveWindow: false,
       message: msg(
         guardDue
           ? 'Your todo list is empty. If the current work needs tracking, call todo_write before stopping.'
@@ -102,30 +108,36 @@ export function planTodoReadHook(opts: {
     const c = countTodos(opts.items);
     const age = st.ageMs == null ? '' : ` ${formatAge(st.ageMs)} ago`;
     // Idle periods do not consume turns, so give one rewrite window with the old entries as reference
-    // before the terminal notice.
-    if (opts.staleNotices === 0 && guardDue) {
-      const lines = opts.items.map((it) => `  ${todoMark(it.status)} ${it.content}`);
+    // before the terminal notice. The offer is keyed to the list identity and persisted (in-process it
+    // rides TodosService.archiveWindowOffered), so a resumed session goes straight to the clear.
+    if (!opts.archiveWindowOffered) {
+      if (!guardDue) {
+        return { inject: false, effect: 'none', archived: true, clearArchived: false, offerArchiveWindow: false, message: msg('') };
+      }
+      const lines = opts.items.map((it) => `  ${todoLine(it)}`);
       const head = `todos ✓${c.completed} (all completed, last updated${age}) — about to be archived`;
-      const warn = 'One rewrite window before archiving: if the work you are doing now is multi-step, rewrite the full list with todo_write to track it (old entries below as reference — reuse what still applies). Single-step Q&A may skip tracking. If the list stays untouched, it will be archived and cleared on the next reminder.';
+      const warn = 'One rewrite window before archiving: if the work you are doing now is multi-step, rewrite the full list with todo_write to track it (old entries below as reference — reuse what still applies). Single-step Q&A may skip tracking. If the list stays untouched, it will be archived and cleared on your next message.';
       return {
         inject: true,
         effect: 'stale-notice',
         archived: true,
         clearArchived: false,
+        offerArchiveWindow: true,
         message: msg([head, ...lines, warn].join('\n')),
       };
     }
     // The terminal notice carries no details and no "skip tracking" escape hatch — multi-step work
-    // must get a fresh list, single-step Q&A may proceed untracked.
+    // must get a fresh list, single-step Q&A may proceed untracked. It fires on the very next run:
+    // the near-archive already consumed the shared cadence tick, and waiting 4 more runs leaves the
+    // dead list authoritative with no todo guidance at all.
     return {
-      inject: guardDue,
+      inject: true,
       effect: 'archive-notice',
       archived: true,
-      clearArchived: guardDue,
+      clearArchived: true,
+      offerArchiveWindow: false,
       message: msg(
-        guardDue
-          ? `Your previous todo list (${c.completed} completed entries, last updated${age}) has been archived and cleared from tracking; the list is now empty. If the current work is multi-step, call todo_write with a fresh list now — multi-step work must be tracked. Single-step answers may proceed without a list.`
-          : '',
+        `Your previous todo list (${c.completed} completed entries, last updated${age}) has been archived and cleared from tracking; the list is now empty. If the current work is multi-step, call todo_write with a fresh list now — multi-step work must be tracked. Single-step answers may proceed without a list.`,
       ),
     };
   }
@@ -134,18 +146,19 @@ export function planTodoReadHook(opts: {
     const staleDue = opts.lastStaleGuardTurn == null
       || opts.turn - opts.lastStaleGuardTurn >= EMPTY_GUARD_EVERY_N;
     if (!staleDue || opts.staleNotices >= STALE_NOTICE_MAX) {
-      return { inject: false, effect: 'none', archived: false, clearArchived: false, message: msg('') };
+      return { inject: false, effect: 'none', archived: false, clearArchived: false, offerArchiveWindow: false, message: msg('') };
     }
     const c = countTodos(opts.items);
     const head = `todos ▶${c.inProgress} ○${c.pending} ■${c.blocked} ✓${c.completed}`
       + ` · unchanged for ${opts.turnsSinceWrite} turns, nothing open`;
-    const lines = opts.items.map((it) => `  ${todoMark(it.status)} ${it.content}`);
+    const lines = opts.items.map((it) => `  ${todoLine(it)}`);
     const warn = 'This list no longer reflects the work you are doing. Rewrite the full list with todo_write to match current work, or send [] to clear it.';
     return {
       inject: true,
       effect: 'stale-notice',
       clearArchived: false,
       archived: false,
+      offerArchiveWindow: false,
       message: msg([head, ...lines, warn].join('\n')),
     };
   }
@@ -153,7 +166,7 @@ export function planTodoReadHook(opts: {
   // Fresh lists are recited every turn to keep current work visible.
   const c = countTodos(opts.items);
   const view = boundedView(opts.items, 6);
-  const lines = view.visible.map((it) => `${todoMark(it.status)} ${it.content}`);
+  const lines = view.visible.map((it) => todoLine(it));
   const activity = currentActivity(opts.items);
   const head = `todos ▶${c.inProgress} ○${c.pending} ■${c.blocked} ✓${c.completed}`
     + (activity ? ` · ${activity}` : '');
@@ -162,6 +175,7 @@ export function planTodoReadHook(opts: {
     effect: 'recite',
     clearArchived: false,
     archived: false,
+    offerArchiveWindow: false,
     message: msg([head, ...lines].join('\n')),
   };
 }

package/src/todo-reminder-core.ts

@@ -1,10 +1,10 @@
 /**
  * Reminders about unfinished todos when stopping go out as sendMessage(custom) and ask for
  * reconciliation rather than continuation, so human-blocked items are a first-class outcome. Guards:
- * suppress on abort, cap reminders, skip while a subagent runs, a human gate is blocked, or no open
- * item remains.
+ * suppress on abort or provider error, cap reminders, skip while a subagent runs, a human gate is
+ * blocked, or no open item remains.
  */
-import { ABORT_STOP_REASON } from './settle-wake-core.ts';
+import { ABORT_STOP_REASON, ERROR_STOP_REASON } from './settle-wake-core.ts';
 import { pierOption } from './pier-options.ts';
 
 /** Cap reminders for the lifetime of the process. */
@@ -25,6 +25,8 @@ export function todoReminderGraceMs(): number {
 interface TodoReminderInput {
   /** Stop reason of the last assistant turn (null = natural completion). */
   lastStopReason: string | null;
+  /** agent_settled.aborted: authoritative for ESC mid-tool, where no final assistant message set the reason. */
+  aborted?: boolean;
   intentionalAbort?: boolean;
   compactionInFlight?: boolean;
   reminders: number;
@@ -48,8 +50,10 @@ interface TodoReminderPlan {
  */
 export function planStopTodoReminder(input: TodoReminderInput): TodoReminderPlan {
   const noInject: TodoReminderPlan = { due: false, content: null, nextReminders: input.reminders };
-  if (input.intentionalAbort || input.compactionInFlight) return noInject;
-  if (input.lastStopReason === ABORT_STOP_REASON) return noInject;
+  if (input.intentionalAbort || input.compactionInFlight || input.aborted) return noInject;
+  // An error stop is an upstream/provider failure that pi retries; the reminder's triggerTurn would
+  // fire another request into the failing window (observed: 3 reminders during one outage).
+  if (input.lastStopReason === ABORT_STOP_REASON || input.lastStopReason === ERROR_STOP_REASON) return noInject;
   if (input.reminders >= REMINDERS_MAX) return noInject;
   if (input.runningSubs > 0) return noInject;
   if (input.blockedDepth > 0) return noInject;

package/src/todo-window.ts

@@ -20,6 +20,13 @@ export function formatTodoSummary(items: readonly TodoItem[]): string {
   return `todo: ${c.inProgress}▶ ${c.pending}○ ${c.blocked}■ ${c.completed}✓`;
 }
 
+/** One item line shared by the widget/tree renderer and the read-hook recitation: the blocker text is
+ *  part of the item (D43), not a widget-only decoration, so a resumed model keeps the reason. */
+export function todoLine(it: TodoItem): string {
+  const suffix = it.status === 'blocked' && it.blocker ? ` — ${it.blocker}` : '';
+  return `${todoMark(it.status)} ${it.content}${suffix}`;
+}
+
 /** Shared phase rendering so widget and overlay order entries identically. */
 export function renderTodoGroups(items: readonly TodoItem[]): string[] {
   const groups = new Map<string, TodoItem[]>();
@@ -32,10 +39,7 @@ export function renderTodoGroups(items: readonly TodoItem[]): string[] {
   const lines: string[] = [];
   for (const [phase, list] of groups) {
     if (phase) lines.push(`  [${phase}]`);
-    for (const it of list) {
-      const suffix = it.status === 'blocked' && it.blocker ? ` — ${it.blocker}` : '';
-      lines.push(`  ${todoMark(it.status)} ${it.content}${suffix}`);
-    }
+    for (const it of list) lines.push(`  ${todoLine(it)}`);
   }
   return lines;
 }

package/src/todos-service.ts

@@ -18,6 +18,15 @@ export class TodosService extends EventEmitter {
   }
   /** Clock anchor for staleness/archiving; null until the first write. */
   lastWriteAt: number | null = null;
+  /** True when the anti-freeze rewrite window was offered for the current list (reached through the
+   *  persisted marker on rebuild, so a resumed session skips straight to the terminal clear). */
+  private _archiveWindowOffered = false;
+  get archiveWindowOffered(): boolean {
+    return this._archiveWindowOffered;
+  }
+  markArchiveWindowOffered(): void {
+    this._archiveWindowOffered = true;
+  }
   readonly config: TodosConfig;
 
   constructor(config: TodosConfig) {
@@ -40,6 +49,7 @@ export class TodosService extends EventEmitter {
     if (listsEqual(this._items, next)) return { changed: false };
     const before = this._items;
     this._items = next;
+    this._archiveWindowOffered = false;
     this.lastWriteAt = Date.now();
     this.emitCompletedTransitions(before, this._items, opts?.source ?? 'tool');
     this.emit('todo.updated', { items: this._items });
@@ -51,6 +61,7 @@ export class TodosService extends EventEmitter {
     const next = applyTodoEdits(this._items, edits);
     if (listsEqual(before, next)) return { changed: false };
     this._items = next;
+    this._archiveWindowOffered = false;
     this.lastWriteAt = Date.now();
     this.emitCompletedTransitions(before, this._items, opts?.source ?? 'reconcile');
     this.emit('todo.edited', { edits, items: this._items });
@@ -74,6 +85,7 @@ export class TodosService extends EventEmitter {
     const folded = foldLatestTodosMeta(entries as Parameters<typeof foldLatestTodosMeta>[0]);
     this._items = folded ? folded.items : [];
     this.lastWriteAt = folded ? folded.writtenAt : null;
+    this._archiveWindowOffered = folded ? folded.archiveWindowOffered : false;
     this.emit('todo.updated', { items: this._items, reason: 'rebuild' });
   }
 }