pi-pier 0.4.1 → 0.4.2

package/src/plugins/todo.ts

@@ -15,7 +15,7 @@ import { makeProgressUpdate } from '../subagent-core.ts';
 import { TODO_DETAILS_KEY, TODO_STATUSES, TODO_TOOL_NAME, formatTodoConfirmation, type TodoItem } from '../vocab.ts';
 import { toolError } from '../tool-error.ts';
 import { formatAge, isArchived } from '../stale-core.ts';
-import { TODO_EDIT_CUSTOM_TYPE, completionTransitions, fuzzyFind, listsEqual, makeSnapshot, normalizeStrict, revertedCompleted, validateTodos, type TodoEditOp } from '../todo-core.ts';
+import { TODO_ARCHIVE_WINDOW_CUSTOM_TYPE, TODO_EDIT_CUSTOM_TYPE, completionTransitions, fuzzyFind, listsEqual, makeSnapshot, normalizeStrict, revertedCompleted, todoListHash, validateTodos, type TodoEditOp } from '../todo-core.ts';
 import { formatTodoSummary, renderTodoGroups } from '../todo-window.ts';
 import { unifiedWidgetLines, type WorkerWidgetRow } from '../tree-view.ts';
 import { swallow } from '../swallow.ts';
@@ -52,13 +52,10 @@ export interface TodoDeps {
 }
 
 const TOOL_DESCRIPTION = [
-  'Record and update the complete task list for the current work. Every call REPLACES the entire list (last write wins), so always resend the full list.',
-  'Entries: `content` (non-empty, unique; short imperative, what-not-how; no numbering prefixes), `status` (pending | in_progress | completed | blocked | abandoned), optional `blocker` (only when blocked: what it is waiting for), optional `phase` (group name for multi-stage plans; omit for a flat list).',
-  'Keep the list short (at most 15 entries): one entry per meaningful unit of work, not per micro-step.',
-  'Mark tasks you are actively working on as in_progress; several may be in_progress when work genuinely runs in parallel.',
-  'Before stopping, reconcile open entries: anything waiting on a human (decision, approval, or an ops action you cannot perform) must be marked blocked with a blocker note — never left pending, and never executed just to clear the list; finished or obsolete entries must be completed or removed.',
-  'Do not make todo_write the only tool call of a turn — batch it together with real work.',
-  'Delegated work belongs on this list too. When you hand an entry to a subagent, append ` <sub>` to its content (the subagent is doing it, not you); when the subagent settles, a matching entry is auto-completed — you will see "Reconciled:" in the settlement note. If no auto-match fired, update the entry yourself.',
+  'Record the complete task list for the current work. Every call REPLACES the whole list, so always resend it in full.',
+  'Entries: `content` (unique short imperative, no numbering), `status`, `blocker` (only when blocked: what it waits for), optional `phase` (group for a multi-stage plan). At most 15 entries, one per meaningful unit of work; several may be in_progress when work truly runs in parallel.',
+  'Do not make todo_write the only tool call of a turn — batch it with real work.',
+  'When you hand an entry to a subagent, append ` <sub>` to its content; it auto-completes when the subagent settles ("Reconciled:" in the note), otherwise update it yourself.',
 ].join(' ');
 
 
@@ -126,7 +123,7 @@ export default function todoPlugin(ctx: Context): void {
     staleNotices = 0;
   });
 
-  scoped.on('before_agent_start', async (eventCtx?: unknown) => {
+  scoped.on('before_agent_start', async (eventCtx?: unknown, ctx?: unknown) => {
     // pi 1.2+ also fires this for extension-triggered runs; skip the ones that would double-inject
     // or consume the guard cadence (stop reminder, config guide, third-party custom runs).
     if (!shouldRunTodoRead(eventCtx)) return;
@@ -139,12 +136,28 @@ export default function todoPlugin(ctx: Context): void {
       now: Date.now(),
       staleNotices,
       lastStaleGuardTurn,
+      archiveWindowOffered: todos.archiveWindowOffered,
     });
     if (plan.inject && plan.effect === 'stale-notice') {
       staleNotices += 1;
       lastStaleGuardTurn = todoReadTurn;
     }
-    // Empty, archive, and R2 rewrite notices share one cadence so adjacent notices do not each consume the grace window.
+    // Persist the one-window offer against this list identity: the plugin closure dies with the
+    // process, and on /resume the same dead list must reach the terminal clear instead of re-warning.
+    if (plan.inject && plan.offerArchiveWindow) {
+      try {
+        appendEntry(TODO_ARCHIVE_WINDOW_CUSTOM_TYPE, {
+          version: 1,
+          itemsHash: todoListHash(todos.items),
+        });
+      } catch (err) {
+        // The in-memory mark still advances escalation in this process.
+        swallow('todo.persist-archive-window', err);
+      }
+      todos.markArchiveWindowOffered();
+    }
+    // Empty-list guards and the archive rewrite window share one cadence so adjacent notices do not
+    // each consume the grace window; the terminal clear is immediate and only marks the tick.
     if (plan.inject && (plan.effect === 'empty-guard' || plan.archived)) {
       lastEmptyGuardTurn = todoReadTurn;
     }
@@ -159,6 +172,11 @@ export default function todoPlugin(ctx: Context): void {
         swallow('todo.persist-archive', err);
       }
       todos.replace([], { source: 'archive' });
+      // The clear is the one todo mutation outside the tool/human paths that must refresh the
+      // title, sidebar token and widget; the dead list would otherwise stay authoritative. The hook's
+      // first argument is the event (no ui), so render through the run ctx; tests pass a ui ctx first.
+      mirrorTodos();
+      renderWidget(ctx ?? eventCtx);
     }
     todoReadTurn += 1;
     if (!plan.inject) return;
@@ -194,11 +212,18 @@ export default function todoPlugin(ctx: Context): void {
       const { role, stopReason } = msg as { role?: unknown; stopReason?: unknown };
       if (role === 'assistant' && typeof stopReason === 'string') lastAssistantStopReason = stopReason;
     });
-    for (const ev of ['agent_start', 'session_shutdown']) scoped.on(ev, () => cancelTodoReminder());
-    scoped.on('agent_settled', async () => {
+    // A retry starts a fresh turn, not necessarily a fresh agent_start: cancel the pending reminder
+    // there too so a provider-error retry cannot be interrupted by a stale 30 s timer.
+    for (const ev of ['agent_start', 'turn_start', 'session_shutdown']) scoped.on(ev, () => cancelTodoReminder());
+    scoped.on('agent_settled', async (event: unknown) => {
       cancelTodoReminder();
+      // pi ≥ 1.1 carries `aborted` on agent_settled: authoritative for ESC mid-tool, where stopReason
+      // tracking sees a stale natural reason and would still schedule a reminder.
+      const aborted = event !== null && typeof event === 'object'
+        && 'aborted' in event && event.aborted === true;
       const plan = planStopTodoReminder({
         lastStopReason: lastAssistantStopReason,
+        aborted,
         intentionalAbort: stopReminder.isIntentionalAbort?.() ?? false,
         compactionInFlight: stopReminder.isCompactionInFlight?.() ?? false,
         reminders: todoReminders,
@@ -236,23 +261,20 @@ export default function todoPlugin(ctx: Context): void {
     label: 'Todo',
     description: TOOL_DESCRIPTION,
     promptGuidelines: [
-      'Before stopping with open todo_write entries, reconcile them: entries waiting on a human decision, approval, or ops action must be marked blocked with a blocker note — never left pending, and never executed just to clear the list.',
+      'Before stopping, reconcile open entries: anything waiting on a human (decision, approval, an ops action you cannot perform) is marked blocked with a blocker note — never left pending, never executed just to clear the list; finished or obsolete entries are completed or removed.',
     ],
     parameters: Type.Object({
       todos: Type.Array(
         Type.Object(
           {
-            content: Type.String({ description: 'What the task is — a short imperative line' }),
-            status: Type.Union(
-              TODO_STATUSES.map((status) => Type.Literal(status)),
-              { description: TODO_STATUSES.join(' | ') },
-            ),
-            blocker: Type.Optional(Type.String({ description: 'Only when status is "blocked": what it is waiting for. Omit the field entirely (never an empty string) for other statuses' })),
-            phase: Type.Optional(Type.String({ description: 'Optional group name (≤30 chars); omit for a flat list (never an empty string)' })),
+            content: Type.String({ description: 'Short imperative line' }),
+            status: Type.Union(TODO_STATUSES.map((status) => Type.Literal(status))),
+            blocker: Type.Optional(Type.String({ description: 'Only for blocked; omit otherwise (never an empty string)' })),
+            phase: Type.Optional(Type.String({ description: 'Group name (≤30 chars); omit for a flat list' })),
           },
           { additionalProperties: false },
         ),
-        { description: 'The COMPLETE task list; this call replaces the previous list' },
+        { description: 'The COMPLETE list; replaces the previous one' },
       ),
     }),
     async execute(toolCallId: string, params: ToolParams, signal: AbortSignal | undefined, onUpdate: ((update: unknown) => void) | undefined, eventCtx: unknown) {

package/src/reducer-invoker.ts

@@ -68,6 +68,8 @@ type ReducerModelOutput = {
   content?: readonly unknown[];
   text?: unknown;
   usage?: UsageLike;
+  stopReason?: string;
+  errorMessage?: string;
 };
 
 type ReducerModel = NonNullable<ExtensionContext['model']>;
@@ -139,23 +141,23 @@ function resolveCandidate(
 }
 
 /**
- * Step 6, jev first (RFC §3 P0-1): a confident jev rejection is authoritative even for regex-listed
- * commands; the regex list decides only when jev is absent, fails or answers below the confidence
- * gate (credential-shaped command lines stay local).
+ * Step 6, regex first: only regex-listed commands are candidates; jev may veto them (a confident
+ * rejection is authoritative) but never promotes an unlisted command. Asking jev about every result
+ * flipped 0 of 437 decisions over a week while blocking each tool result ~0.8s and uploading every
+ * command line (D122). Jev failures, low confidence and credential-shaped commands keep the regex hit.
  */
 async function isDiagnosticCandidate(
   command: string,
   gate: JevEprGateDependency | undefined,
   sessionId: string | undefined,
 ): Promise<boolean> {
-  const regexHit = isDiagnosticCommand(command);
-  if (!gate || containsLikelySecret(command)) return regexHit;
+  if (!isDiagnosticCommand(command)) return false;
+  if (!gate || containsLikelySecret(command)) return true;
   const result = await gate.ask(diagnosticGateRequest(command), {
     questionId: 'epr-diagnostic-gate',
     timeoutMs: 2500, // cold TLS hit 1002ms at 1s; at 1500ms a real session still saw 14/73 calls (19%) time out — 2.5s keeps the gate decisive without stalling reducers
     sessionId,
-    // regex_hit makes the flip observable: how often and in which direction jev overrides the regex list (jev.jsonl).
-    extra: { site: 'epr-gate', commandSha256: sha256Hex(command), regexHit },
+    extra: { site: 'epr-gate', commandSha256: sha256Hex(command) },
     enrich: ({ answers }) => {
       if (!answers) return {};
       const verdict = evaluateDiagnosticGate(answers, gate.getMinConfidence());
@@ -167,10 +169,9 @@ async function isDiagnosticCandidate(
       };
     },
   });
-  if (!result.ok) return regexHit;
+  if (!result.ok) return true;
   const verdict = evaluateDiagnosticGate(result.answers, gate.getMinConfidence());
-  if (verdict.hit) return true;
-  return isDiagnosticGateUnanswered(verdict) ? regexHit : false;
+  return verdict.hit || isDiagnosticGateUnanswered(verdict);
 }
 
 /** Step 7: the untruncated source; both failure modes write the same `truncated-source` evidence
@@ -317,7 +318,10 @@ export async function handleReducerToolResult(
   if (config.localOnly) return undefined; // Archival is the whole job in local-only mode.
 
   const reducer = resolveReducerModel(ctx, config);
-  if (!reducer) return undefined;
+  if (!reducer) {
+    await log({ sourceBytes, model: config.model ?? 'default', verificationOk: false, reason: 'no-reducer-model', action: 'fallback_full_text' });
+    return undefined;
+  }
   /** Evidence row for a fail-open exit taken after the reducer model was resolved. */
   const fallbackRow = (reason: string, durationMs: number, extra: Record<string, unknown> = {}): Promise<void> =>
     log({
@@ -354,7 +358,14 @@ export async function handleReducerToolResult(
     : typeof output.text === 'string'
       ? output.text
       : '';
-  if (!modelOutput.trim()) return undefined;
+  if (!modelOutput.trim()) {
+    // pi's complete() reports provider failures as an empty `error` message instead of throwing.
+    await fallbackRow(output.stopReason === 'error' ? 'invoke-failed' : 'empty-output', durationMs, {
+      ...(output.stopReason ? { stopReason: output.stopReason } : {}),
+      ...(output.errorMessage ? { error: output.errorMessage } : {}),
+    });
+    return undefined;
+  }
 
   const validated = validateReceipt(modelOutput, sourceHash, body, event.isError);
   if (!validated.ok) {
@@ -377,7 +388,10 @@ export async function handleReducerToolResult(
     totalTokens: output.usage?.totalTokens,
   });
   const receiptBytes = Buffer.byteLength(receipt, 'utf8');
-  if (receiptBytes >= sourceBytes) return undefined;
+  if (receiptBytes >= sourceBytes) {
+    await fallbackRow('receipt-not-smaller', durationMs, { receiptBytes });
+    return undefined;
+  }
 
   await log({
     sourceBytes,

package/src/renderers.ts

@@ -4,7 +4,7 @@
  * needed and older pi builds degrade to "no renderer".
  */
 import { TODO_EDIT_CUSTOM_TYPE, type TodoEditPayload } from './todo-core.ts';
-import { SUBS_CUSTOM_TYPE, PROGRESS_CUSTOM_TYPE, subRef, type SubsRegistry } from './subagent-core.ts';
+import { SUBS_CUSTOM_TYPE, subRef, type SubsRegistry } from './subagent-core.ts';
 import { DELEGATION_CUSTOM_TYPE } from './delegation-core.ts';
 import { TERMINALS_CUSTOM_TYPE, TERM_REMINDER_CUSTOM_TYPE, type TerminalsRegistry } from './terminal-core.ts';
 import { TODO_REMINDER_CUSTOM_TYPE } from './todo-reminder-core.ts';
@@ -159,17 +159,6 @@ function approvalLines(data: unknown, theme: RenderTheme): string[] {
   return [`${theme.fg('warning', '⚠ approval needed')} ${theme.fg('dim', `· ${tool} (${role})`)}`];
 }
 
-/** Phase 2: worker progress note (display-less custom message) as a one-line card — the sender
- * pane rides `details.paneId`; keep it recognizable without flooding the transcript. */
-function progressLines(message: unknown, theme: RenderTheme, expanded: boolean): string[] {
-  const rec = (message ?? {}) as { content?: unknown; details?: { paneId?: unknown } };
-  const from = typeof rec.details?.paneId === 'string' && rec.details.paneId ? rec.details.paneId : '?';
-  const content = typeof rec.content === 'string' ? rec.content : '';
-  const head = `${theme.fg('accent', '⤴ progress')} ${theme.fg('dim', `· ${from}: ${clip(content, 100)}`)}`;
-  if (!expanded) return [head];
-  return [head, ...content.split('\n').map((line) => theme.fg('dim', line))];
-}
-
 /** Reminder custom messages carry the full injected text; restyle without altering it. */
 function reminderLines(message: unknown, theme: RenderTheme, label: string, expanded: boolean): string[] {
   const content = typeof (message as { content?: unknown } | undefined)?.content === 'string'
@@ -215,7 +204,6 @@ export function installRenderers(pi: unknown): string[] {
   entry(DELEGATION_CUSTOM_TYPE, delegationLines);
   entry(ROLE_MANIFEST_CUSTOM_TYPE, (data, theme) => roleManifestLines(data, theme));
   entry(APPROVAL_NEEDED_CUSTOM_TYPE, (data, theme) => approvalLines(data, theme));
-  message(PROGRESS_CUSTOM_TYPE, progressLines);
   message(TODO_REMINDER_CUSTOM_TYPE, (msg, theme, expanded) => reminderLines(msg, theme, 'todo reminder', expanded));
   message(TERM_REMINDER_CUSTOM_TYPE, (msg, theme, expanded) => reminderLines(msg, theme, 'terminal nudge', expanded));
   return registered;

package/src/roles/worker-default.json

@@ -1,11 +1,11 @@
 {
   "role": "worker-default",
-  "version": "1.5.0",
-  "description": "默认worker角色（D83 继承制）：镜像 master.tools 减 subagent/terminal（禁嵌套、资源归属）；排除族显式 deny——在 D82 unknownTools=allow 姿态下仍持禁令；todos serial。v1.5.0: Phase 2 显式放行 report_progress（worker→master 检查点上报）；v1.4.0: 工具合并后更新 deny 列表",
+  "version": "1.6.0",
+  "description": "默认worker角色（D83 继承制）：镜像 master.tools 减 subagent/terminal（禁嵌套、资源归属）；排除族显式 deny——在 D82 unknownTools=allow 姿态下仍持禁令；todos serial。v1.6.0: 删除 report_progress（一周 0 调用，D125）；v1.5.0: Phase 2 显式放行 report_progress；v1.4.0: 工具合并后更新 deny 列表",
   "manifest": {
     "unknownTools": "allow",
     "tools": [
-      "todo_write", "ask_user_question", "report_progress",
+      "todo_write", "ask_user_question",
       "read", "grep", "glob", "bash", "pwsh", "edit", "write",
       "web_search"
     ],

package/src/settle-wake-core.ts

@@ -7,6 +7,9 @@
 
 export const ABORT_STOP_REASON = 'aborted';
 
+/** pi/provider failure stop. pi auto-retries these, so the run has not settled for the user. */
+export const ERROR_STOP_REASON = 'error';
+
 /** D96: cooldown before repeating a notice for the same running set. */
 export const D96_REPEAT_NOTICE_MS = 10 * 60_000;
 
@@ -80,7 +83,9 @@ export function planSettleWake(input: SettleWakeInput): SettleWakePlan {
  * coming: answering now reports "finished, no closing message" for live work and — worse —
  * consumes the one-shot request plus the parent's claim latch, so the real closing message can
  * never be delivered (observed: a worker mid-compaction announced finished; its final report
- * never reached the parent). A user abort ('aborted') likewise settles a run that may re-run.
+ * never reached the parent). A user abort ('aborted') likewise settles a run that may re-run, and
+ * an 'error' stop is an upstream failure pi retries — answering then consumes the latch for a
+ * parent's claim that the retry's closing message still has to satisfy.
  */
 export function shouldPushSettleReply(input: {
   intentionalAbort?: boolean;
@@ -92,5 +97,6 @@ export function shouldPushSettleReply(input: {
   return !input.intentionalAbort
     && input.aborted !== true
     && !input.compactionInFlight
-    && input.lastStopReason !== ABORT_STOP_REASON;
+    && input.lastStopReason !== ABORT_STOP_REASON
+    && input.lastStopReason !== ERROR_STOP_REASON;
 }

package/src/subagent-core.ts

@@ -114,7 +114,7 @@ export function buildResumeArgv(workerArgv: readonly string[], piBin = 'pi'): st
 export const SUBAGENT_OUTPUT_SCHEMA = Type.Object({
   action: Type.Union([
     Type.Literal('spawn'), Type.Literal('resume'), Type.Literal('list'),
-    Type.Literal('send'), Type.Literal('interrupt'), Type.Literal('output'), Type.Literal('role'),
+    Type.Literal('send'), Type.Literal('interrupt'), Type.Literal('output'), Type.Literal('role'), Type.Literal('help'),
   ]),
   paneId: Type.Optional(Type.String()),
   taskId: Type.Optional(Type.String()),
@@ -195,6 +195,14 @@ export interface AliveProbe {
   foregroundCwd?: string | null;
 }
 
+/** Trailing line for isolate spawn results: the branch (`pier/<slug>`) reads like a directory and
+ *  masters have cd'd into `<repo>/pier/<slug>`; only the worktree path is an actual directory. */
+export function formatIsolateLocation(
+  isolate: Pick<NonNullable<SubEntry['isolate']>, 'worktreePath' | 'branch'> | null | undefined,
+): string {
+  return isolate ? `\nWorktree: ${isolate.worktreePath} (branch ${isolate.branch})` : '';
+}
+
 /**
  * A subagent outlives its "no output" result: a working/blocked agent is alive regardless of session
  * age, otherwise recent session writes decide. `paneExists: false` is death — an unavailable probe is
@@ -224,7 +232,7 @@ export function buildAliveNotice(
     return [
       `Subagent "${description}" is still running in pane ${paneId} (agent_status=${status}${activity}).`,
       'The foreground wait has moved it to background so this call returns now.',
-      'Do NOT redo its work. When it settles you will receive a notification with its closing output.',
+      'Do NOT redo its work and do NOT sleep or poll: when it settles, its result is delivered automatically as a settlement notice at your next turn boundary.',
       'Use subagent(action: "list") to check its live state; subagent(action: "send") to give it follow-up work.',
     ].join(' ');
   }
@@ -274,6 +282,9 @@ export interface SubEntry {
   userTakeover?: boolean;
   observationStartedAt?: number | null;
   lastAgentStatus?: string | null;
+  /** The final report `subagent output` already returned (tail fingerprint + time): the settlement
+   *  notice then points at that delivery instead of repeating the report. Durable across resume. */
+  reportDelivered?: { fingerprint: string; at: number } | null;
   /** D98: isolate worktree metadata; `releasedAt` set once the worktree is removed. */
   isolate?: {
     worktreePath: string;
@@ -317,7 +328,30 @@ export function subRef(sub: { paneId: string; slug?: string }): string {
   return sub.slug ? `${sub.slug}@${sub.paneId}` : sub.paneId;
 }
 
-export const PROGRESS_CUSTOM_TYPE = 'pi-herdr.progress';
+/** Identity of a final report across the output action and the settlement notice: its tail. */
+export function reportFingerprint(report: string): string {
+  return report.slice(-64);
+}
+
+/** Shorter sleeps are ordinary polling of builds/logs; from a minute up, they were waits on workers. */
+const SLEEP_NOTE_MIN_SECONDS = 60;
+
+/**
+ * Note for a master bash call that sleeps ≥ SLEEP_NOTE_MIN_SECONDS while background workers run:
+ * masters slept 660-840 s per worker although the settlement notice arrives on its own. Worded so a
+ * sleep that waits on something else (a load test, a build) is left alone.
+ */
+export function sleepWhileSubsRunningNote(
+  command: string,
+  running: ReadonlyArray<{ paneId: string; slug?: string }>,
+): string | null {
+  if (running.length === 0) return null;
+  const longest = Math.max(0, ...[...command.matchAll(/\bsleep\s+(\d+)s?\b/g)].map((m) => Number(m[1])));
+  if (longest < SLEEP_NOTE_MIN_SECONDS) return null;
+  return `[pier] ${running.length} background subagent(s) running (${running.map(subRef).join(', ')}): their settlement `
+    + 'notice arrives automatically at your next tool boundary, so do not sleep to wait for them — keep working or end '
+    + 'your turn. Sleeping is only needed for other work (builds, logs).';
+}
 
 export interface SubsRegistry {
   version: 2;
@@ -372,6 +406,10 @@ export function foldSubsRegistry(entries: ReadonlyArray<{ type?: string; customT
             retainNotified: s.isolate.retainNotified === true,
           }
           : undefined,
+        reportDelivered: s.reportDelivered && typeof s.reportDelivered === 'object'
+          && typeof s.reportDelivered.fingerprint === 'string' && typeof s.reportDelivered.at === 'number'
+          ? { fingerprint: s.reportDelivered.fingerprint, at: s.reportDelivered.at }
+          : undefined,
       }));
     found = { version: 2, subs };
   }

package/src/subagent-poller.ts

@@ -10,7 +10,7 @@ import { runtimePolicy, type RuntimePolicy } from './runtime-policy.ts';
 import type { JevRuntime } from './jev-client.ts';
 import { evaluateSettleVerdict, settleAskIsSafe, settleVerdictRequest } from './jev-core.ts';
 import { formatSettlementNotice, type SettlementNullReason } from './vocab.ts';
-import { buildBlockedGateNotice, sleep, type SubEntry } from './subagent-core.ts';
+import { buildBlockedGateNotice, reportFingerprint, sleep, type SubEntry } from './subagent-core.ts';
 import type { SessionIo } from './subagent-session.ts';
 import type { GitIo } from './subagent-spawn.ts';
 
@@ -70,8 +70,17 @@ export function planObservationTick(input: {
   agentStatus: string | null;
   machineInjectAgoMs: number;
   machineInjectGraceMs: number;
+  /** The transcript already holds a finalized answer (stopReason 'stop', no pending tool call). */
+  finalized?: boolean;
 }): ObservationTickPlan {
-  if (!input.observationStartedAt) return { kind: 'start-observation' };
+  if (!input.observationStartedAt) {
+    // A finalized answer on a pane that is not working settles on the detecting tick: the window
+    // would only delay the result, and the transcript cannot grow under an idle pane. A working or
+    // blocked pane keeps the window path — that is the human-takeover guard.
+    const paneBusy = input.agentStatus === 'working' || input.agentStatus === 'blocked';
+    if (input.finalized && !paneBusy) return { kind: 'settle' };
+    return { kind: 'start-observation' };
+  }
   if (input.agentStatus === 'working') {
     if (input.machineInjectAgoMs > input.machineInjectGraceMs) return { kind: 'user-takeover' };
     return { kind: 'machine-inject-reset' };
@@ -118,8 +127,9 @@ export function buildSettlementNoticeText(
   closing: string | null,
   statLine: string | null,
   nullReason: SettlementNullReason = 'silent',
+  reportDeliveredAt: number | null = null,
 ): string {
-  const base = formatSettlementNotice(agentLabel, closing, nullReason);
+  const base = formatSettlementNotice(agentLabel, closing, nullReason, reportDeliveredAt);
   return statLine ? `${base}\n${statLine}` : base;
 }
 
@@ -183,7 +193,7 @@ export interface PollerHost {
   lastMachineInjectAt: Map<string, number>;
   session: SessionIo;
   git: GitIo;
-  injectNotice(content: string): Promise<void>;
+  injectNotice(content: string, paneId?: string): Promise<void>;
   reconcileOnSettlement(description: string, outcome: 'settled' | 'failed'): string[];
   withReconcileNotes(base: string, notes: readonly string[]): string;
   claimSettleNotice(key: string): boolean;
@@ -222,6 +232,9 @@ export function createPoller(h: PollerHost): Poller {
   ): Promise<void> {
     const startedAt = now();
     let lastActivityAt = now();
+    /** Claimed settle key: on a rejected injection the claim stays ours, so the next tick retries
+     *  the notice instead of suppressing it as someone else's. */
+    let claimedKey: string | null = null;
     /** Stop watching this pane: persist + ledger first, or a restart replays a ghost running row. */
     const consume = (outcome: string | null, via: string, at: number): void => {
       const row = h.subs.get(paneId);
@@ -323,13 +336,6 @@ export function createPoller(h: PollerHost): Poller {
 
           if (isSettlementCandidate(s)) {
             const closing = s.text;
-            if (!entry.observationStartedAt) {
-              entry.observationStartedAt = now();
-              entry.lastAgentStatus = 'idle';
-              h.persistSubs();
-              await doSleep(OBSERVATION_TICK_MS);
-              continue;
-            }
             let agentStatus: string | null = null;
             try {
               agentStatus = (await h.client.listAgents()).find((a) => a.paneId === paneId)?.status ?? null;
@@ -342,7 +348,15 @@ export function createPoller(h: PollerHost): Poller {
               agentStatus,
               machineInjectAgoMs: now() - (h.lastMachineInjectAt.get(paneId) ?? 0),
               machineInjectGraceMs,
+              finalized: closing != null && !s.pendingTool,
             });
+            if (obs.kind === 'start-observation') {
+              entry.observationStartedAt = now();
+              entry.lastAgentStatus = 'idle';
+              h.persistSubs();
+              await doSleep(OBSERVATION_TICK_MS);
+              continue;
+            }
             if (obs.kind === 'user-takeover') {
               entry.userTakeover = true;
               entry.observationStartedAt = now();
@@ -409,19 +423,39 @@ export function createPoller(h: PollerHost): Poller {
                 await h.session.resolveSessionFile(paneId, cwd, undefined, { minMtimeMs: current.injectTs - 2_000 }),
               );
             }
-            consume(closing, 'poll-settle', now());
+            // Claim before delivering: the pipe fast-path may already own this settlement's notice.
+            // The row is consumed only after the notice is accepted, and a claim we own is retried
+            // on the next tick — a rejected injection must not strand a finished worker as 'running'
+            // with no notice, nor consume the row while the result is still undelivered.
+            const claimKey = `${paneId}:${current.requestId}`;
+            if (claimedKey !== claimKey) {
+              if (!h.claimSettleNotice(claimKey)) {
+                consume(closing, 'poll-settle', now());
+                return;
+              }
+              claimedKey = claimKey;
+            }
             const notes = h.reconcileOnSettlement(current.description, 'settled');
             const statLine = await h.git.worktreeStatLine(entry);
+            // `subagent output` may already have returned this exact report: point there, don't repeat it.
+            const delivered = closing && entry.reportDelivered?.fingerprint === reportFingerprint(closing)
+              ? entry.reportDelivered.at
+              : null;
             const notice = h.withReconcileNotes(
-              buildSettlementNoticeText(`${paneId} (${current.description})`, closing, statLine, nullReason),
+              buildSettlementNoticeText(`${paneId} (${current.description})`, closing, statLine, nullReason, delivered),
               notes,
             );
-            if (h.claimSettleNotice(`${paneId}:${current.requestId}`)) {
-              try {
-                await h.injectNotice(notice);
-              } catch {
-              }
+            try {
+              // Tag the pane: a notice buffered during compaction must keep its row GC-exempt
+              // until the post-compaction flush actually delivers it.
+              await h.injectNotice(notice, paneId);
+            } catch {
+              // Notification refused (e.g. the master is compacting): leave the row running and
+              // re-detect the same closing text on the next tick.
+              await pace();
+              continue;
             }
+            consume(closing, 'poll-settle', now());
             return;
           }
         }

package/src/subagent-session.ts

@@ -16,7 +16,7 @@ import {
   type SessionEntryLike,
   type SubSessionState,
 } from './session-tail.ts';
-import { idParam, sleep, type AliveProbe, type SubEntry } from './subagent-core.ts';
+import { idParam, reportFingerprint, sleep, type AliveProbe, type SubEntry } from './subagent-core.ts';
 import { toolError } from './tool-error.ts';
 
 /* ── subagent output delta (pure) ───────────────────────────────── */
@@ -26,6 +26,61 @@ export const OUTPUT_HARD_CAP_CHARS = 16000;
 const OUTPUT_MIN_OVERLAP = 16;
 const OUTPUT_TAIL_CHARS = 500;
 
+const BOX_CHARS = '│┃║╭╮╰╯┌┐└┘├┤┬┴┼─━═╌╍';
+const FRAME_ONLY_LINE = new RegExp(`^[\\s${BOX_CHARS}]*[${BOX_CHARS}][\\s${BOX_CHARS}]*$`);
+const SIDE_BORDER = /^\s*[│┃║] ?|\s*[│┃║]\s*$/g;
+/** pi's status footer: `↑43k ↓13k R820k CH99.1% $0.017 …`, preceded by a `~/cwd (branch)` line. */
+const PI_FOOTER_LINE = /^↑[\d.]+[kKmM]?\s+↓[\d.]+[kKmM]?\s/;
+const PI_FOOTER_CWD_LINE = /^~?\/\S*( \([^)]*\))?$/;
+
+/**
+ * Strip TUI chrome from a worker pane read: frame-only box-drawing rows, side borders, right-padding,
+ * pi's footer, and blank-line runs. A real read was ~20% whitespace, box glyphs and footer. Applied
+ * before the delta, so the cursor tracks the same cleaned text on every call.
+ */
+export function cleanPaneChrome(text: string): string {
+  // Frame rows are judged before border stripping, which would otherwise leave them as blank lines.
+  const lines = text.split('\n')
+    .filter((line) => !FRAME_ONLY_LINE.test(line))
+    .map((line) => line.replace(SIDE_BORDER, '').trimEnd());
+  const kept: string[] = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]!;
+    if (PI_FOOTER_LINE.test(line)) continue;
+    if (PI_FOOTER_CWD_LINE.test(line) && PI_FOOTER_LINE.test(lines[i + 1] ?? '')) continue;
+    if (line === '' && kept[kept.length - 1] === '') continue;
+    kept.push(line);
+  }
+  return kept.join('\n');
+}
+
+/** Normalized-text length of the report opening that identifies the pane's rendered copy. */
+const REPORT_KEY_CHARS = 24;
+
+/**
+ * The pane shows the final report rendered (markdown stripped, long lines cut at pane width), so it
+ * is a lossy copy of the transcript text. When the transcript report is attached, cut the pane delta
+ * where the report's opening appears (whitespace and markdown markers ignored). Null: no copy found.
+ */
+export function cutPaneReportCopy(delta: string, report: string): string | null {
+  const isNoise = (ch: string): boolean => /[\s`*_#>]/.test(ch);
+  const key = [...report].filter((ch) => !isNoise(ch)).slice(0, REPORT_KEY_CHARS).join('');
+  if (key.length < REPORT_KEY_CHARS) return null;
+  let normalized = '';
+  const origin: number[] = [];
+  for (let i = 0; i < delta.length; i++) {
+    if (isNoise(delta[i]!)) continue;
+    normalized += delta[i];
+    origin.push(i);
+  }
+  const at = normalized.indexOf(key);
+  if (at < 0) return null;
+  const lineStart = delta.lastIndexOf('\n', origin[at]!) + 1;
+  const before = delta.slice(0, lineStart).trimEnd();
+  const marker = '(the pane\'s rendered copy of the final report is omitted — full text in the Subagent Report section below)';
+  return before ? `${before}\n${marker}` : marker;
+}
+
 export type SubagentStatus = 'running' | 'idle' | 'blocked' | 'settled';
 
 export interface SubagentOutputCursor {
@@ -440,6 +495,8 @@ export async function executeSubagentOutput(
     /** Last finalized assistant text from the worker's transcript: the pane read alone cannot
      * recover it when the fullscreen TUI shows only the status overlay. Optional for tests. */
     readFinalReport?: (paneId: string, entryCwd: string) => Promise<string | null>;
+    /** Persists `entry.reportDelivered` so the settlement notice can skip a report already shown. */
+    persistSubs?: () => void;
   },
 ) {
   const rawId = idParam(params, 'agentId', 'taskId');
@@ -472,8 +529,9 @@ export async function executeSubagentOutput(
   const maxChars = typeof params?.max_chars === 'number'
     ? params.max_chars
     : typeof params?.maxChars === 'number' ? params.maxChars : undefined;
-  const deltaResult = computeSubagentOutputDelta(prevCursor, rawRead.text, { maxChars });
-  deltaResult.nextCursor.reportTail ??= prevCursor?.reportTail;
+  const deltaResult = computeSubagentOutputDelta(prevCursor, cleanPaneChrome(rawRead.text), { maxChars });
+  // A resumed process has no cursor; the durable delivery record keeps the report from repeating.
+  deltaResult.nextCursor.reportTail ??= prevCursor?.reportTail ?? entry.reportDelivered?.fingerprint;
 
   // Transcript fallback: the terminal delta can be empty (or footer-only) while the finished
   // report exists only in the session file. Surface it once per distinct report.
@@ -481,11 +539,16 @@ export async function executeSubagentOutput(
   if ((status === 'settled' || status === 'idle') && deps.readFinalReport) {
     try {
       const report = await deps.readFinalReport(entry.paneId, entry.cwd);
-      const fingerprint = report ? report.slice(-64) : '';
+      const fingerprint = report ? reportFingerprint(report) : '';
       if (report && fingerprint && fingerprint !== deltaResult.nextCursor.reportTail) {
         const bounded = boundText(report, Math.max(1, Math.min(maxChars ?? OUTPUT_DEFAULT_MAX_CHARS, OUTPUT_HARD_CAP_CHARS)));
         reportSection = `[Subagent Report | latest finalized message from session transcript${bounded.truncated ? ' | truncated' : ''}]\n${bounded.text}`;
         deltaResult.nextCursor.reportTail = fingerprint;
+        deltaResult.delta = cutPaneReportCopy(deltaResult.delta, report) ?? deltaResult.delta;
+        if (!bounded.truncated) {
+          entry.reportDelivered = { fingerprint, at: Date.now() };
+          deps.persistSubs?.();
+        }
       }
     } catch {
     }