pi-pier 0.4.1 → 0.4.3

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/role-loader.ts

@@ -98,7 +98,7 @@ export function listRoleNames(baseDir?: string, userDir?: string): string[] {
 
 export function loadRoleConfig(name: string, opts?: LoadRoleOptions): RoleManifest {
   if (typeof name !== 'string' || !ROLE_NAME_RE.test(name)) {
-    throw new RoleLoaderError('ROLE_NOT_FOUND', `role 不存在或名字非法（[a-z0-9-]+）: ${JSON.stringify(name)}`);
+    throw new RoleLoaderError('ROLE_NOT_FOUND', `role not found or invalid name ([a-z0-9-]+): ${JSON.stringify(name)}`);
   }
   const fileName = `${name}.json`;
 
@@ -108,7 +108,7 @@ export function loadRoleConfig(name: string, opts?: LoadRoleOptions): RoleManife
       text = opts.read(fileName);
     } catch (err) {
       const code = (err as { code?: unknown })?.code;
-      throw new RoleLoaderError('ROLE_NOT_FOUND', `role "${name}" 不存在（读 ${fileName} 失败: ${typeof code === 'string' ? code : 'error'}）`);
+      throw new RoleLoaderError('ROLE_NOT_FOUND', `role "${name}" not found (failed to read ${fileName}: ${typeof code === 'string' ? code : 'error'})`);
     }
     return parseAndValidate(name, fileName, text, 'builtin (src/roles/)');
   }
@@ -123,7 +123,7 @@ export function loadRoleConfig(name: string, opts?: LoadRoleOptions): RoleManife
       if (layerRead(layer.dir, fileName) != null) {
         throw new RoleLoaderError(
           'ROLE_RESERVED',
-          `role "${name}" 是内置保留名，不能在 ${layer.label} 层定义（内置档案优先；请删除该档案或改名）`,
+          `role "${name}" is a reserved built-in name and cannot be defined in the ${layer.label} layer (built-in manifests take precedence; delete that file or rename it)`,
         );
       }
     }
@@ -136,7 +136,7 @@ export function loadRoleConfig(name: string, opts?: LoadRoleOptions): RoleManife
   }
   throw new RoleLoaderError(
     'ROLE_NOT_FOUND',
-    `role "${name}" 不存在（查找层：${layers.map((l) => l.label).join(' → ')}）`,
+    `role "${name}" not found (searched layers: ${layers.map((l) => l.label).join(' → ')})`,
   );
 }
 
@@ -145,22 +145,22 @@ function parseAndValidate(name: string, fileName: string, text: string, layerLab
   try {
     parsed = JSON.parse(text);
   } catch (err) {
-    throw new RoleLoaderError('INVALID_ROLE_CONFIG', `role "${name}"（${layerLabel}）不是合法 JSON: ${(err as Error).message}`);
+    throw new RoleLoaderError('INVALID_ROLE_CONFIG', `role "${name}" (${layerLabel}) is not valid JSON: ${(err as Error).message}`);
   }
   const result = validateRoleManifest(parsed);
   // `ok === false` (instead of `!ok`) is required to narrow without strictNullChecks.
   if (result.ok === false) {
     throw new RoleLoaderError(
       'INVALID_ROLE_CONFIG',
-      `role "${name}"（${layerLabel}）校验失败:\n${result.issues.map((i) => `  - ${i}`).join('\n')}`,
+      `role "${name}" (${layerLabel}) failed validation:\n${result.issues.map((i) => `  - ${i}`).join('\n')}`,
       result.issues,
     );
   }
   if (result.value.role !== name) {
     throw new RoleLoaderError(
       'INVALID_ROLE_CONFIG',
-      `role 档案名不符：${layerLabel} 的 ${fileName} 内 role="${result.value.role}"`,
-      [`role 字段 "${result.value.role}" 与请求的 "${name}" 不一致`],
+      `role manifest name mismatch: role="${result.value.role}" in ${fileName} of ${layerLabel}`,
+      [`role field "${result.value.role}" does not match the requested "${name}"`],
     );
   }
   return result.value;

package/src/role-manifest.ts

@@ -53,79 +53,79 @@ const ACTIONS: readonly PermissionAction[] = ['allow', 'ask', 'deny'];
 export function validateRoleManifest(input: unknown): ValidateResult {
   const issues: string[] = [];
   if (!isPlainObject(input)) {
-    return { ok: false, code: 'INVALID_ROLE_CONFIG', issues: ['role 档案必须是 JSON 对象'] };
+    return { ok: false, code: 'INVALID_ROLE_CONFIG', issues: ['role manifest must be a JSON object'] };
   }
 
   const KNOWN_TOP = new Set(['role', 'version', 'model', 'description', 'guidelines', 'manifest', 'services']);
   for (const k of Object.keys(input)) {
-    if (!KNOWN_TOP.has(k)) issues.push(`未知顶层键 "${k}"（契约外字段，检查拼写）`);
+    if (!KNOWN_TOP.has(k)) issues.push(`unknown top-level key "${k}" (not in the contract; check spelling)`);
   }
 
   if (typeof input.role !== 'string' || !ROLE_NAME_RE.test(input.role)) {
-    issues.push(`role 必须是 [a-z0-9-]+ 字符串，收到 ${JSON.stringify(input.role)}`);
+    issues.push(`role must be a [a-z0-9-]+ string, got ${JSON.stringify(input.role)}`);
   }
 
   if (typeof input.version !== 'string' || !SEMVER_RE.test(input.version)) {
-    issues.push(`version 必须是 x.y.z 三段数字（如 1.0.0），收到 ${JSON.stringify(input.version)}`);
+    issues.push(`version must be three dot-separated numbers x.y.z (e.g. 1.0.0), got ${JSON.stringify(input.version)}`);
   }
 
   if (input.model !== undefined) {
     if (typeof input.model !== 'string' || !/^[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/.test(input.model)) {
-      issues.push(`model 必须是 provider/model 形态（如 opencode-go/muse-spark-1.2-contributor），收到 ${JSON.stringify(input.model)}`);
+      issues.push(`model must be in provider/model form (e.g. opencode-go/muse-spark-1.2-contributor), got ${JSON.stringify(input.model)}`);
     }
   }
 
   if (input.description !== undefined && typeof input.description !== 'string') {
-    issues.push('description 必须是字符串');
+    issues.push('description must be a string');
   }
 
   if (input.guidelines !== undefined) {
     if (!Array.isArray(input.guidelines)) {
-      issues.push('guidelines 必须是字符串数组');
+      issues.push('guidelines must be an array of strings');
     } else if (input.guidelines.length === 0) {
-      issues.push('guidelines 为空数组时请直接省略该字段');
+      issues.push('omit guidelines entirely instead of passing an empty array');
     } else if (!input.guidelines.every((g) => typeof g === 'string' && g.trim() !== '')) {
-      issues.push('guidelines 的每一项必须是非空字符串');
+      issues.push('every guidelines entry must be a non-empty string');
     } else if (input.guidelines.length > 20) {
-      issues.push('guidelines 最多 20 条（prompt 预算保护）');
+      issues.push('at most 20 guidelines (prompt budget protection)');
     }
   }
 
   const m = input.manifest;
   if (!isPlainObject(m)) {
-    issues.push('manifest 必须是对象');
+    issues.push('manifest must be an object');
   } else {
     const KNOWN_MANIFEST = new Set(['tools', 'rules', 'unknownTools']);
     for (const k of Object.keys(m)) {
-      if (!KNOWN_MANIFEST.has(k)) issues.push(`manifest 内未知键 "${k}"`);
+      if (!KNOWN_MANIFEST.has(k)) issues.push(`unknown key "${k}" in manifest`);
     }
 
     if (m.unknownTools !== undefined && m.unknownTools !== 'allow' && m.unknownTools !== 'deny') {
-      issues.push(`manifest.unknownTools 必须是 allow/deny，收到 ${JSON.stringify(m.unknownTools)}`);
+      issues.push(`manifest.unknownTools must be allow/deny, got ${JSON.stringify(m.unknownTools)}`);
     }
 
     const tools = m.tools;
     if (!Array.isArray(tools) || !tools.every((t) => typeof t === 'string' && TOOL_KEY_RE.test(t))) {
-      issues.push('manifest.tools 必须是非空字符串数组（工具名 [a-z0-9_-]）');
+      issues.push('manifest.tools must be a non-empty array of strings (tool names [a-z0-9_-])');
     } else {
       const seen = new Set<string>();
       for (const t of tools) {
-        if (seen.has(t)) issues.push(`manifest.tools 重复项 "${t}"`);
+        if (seen.has(t)) issues.push(`duplicate entry in manifest.tools "${t}"`);
         seen.add(t);
       }
       for (const need of COORDINATION_TOOLS) {
-        if (!seen.has(need)) issues.push(`基线非空约束：manifest.tools 必须包含 "${need}"（协调工具）`);
+        if (!seen.has(need)) issues.push(`non-empty baseline constraint: manifest.tools must include "${need}" (coordination tool)`);
       }
     }
 
     if (m.rules !== undefined) {
       if (!isPlainObject(m.rules)) {
-        issues.push('manifest.rules 必须是对象');
+        issues.push('manifest.rules must be an object');
       } else {
         for (const [k, v] of Object.entries(m.rules)) {
-          if (!TOOL_KEY_RE.test(k)) issues.push(`rules 键 "${k}" 不是合法工具名（[a-z0-9_-] 或 *）`);
+          if (!TOOL_KEY_RE.test(k)) issues.push(`rules key "${k}" is not a valid tool name ([a-z0-9_-] or *)`);
           if (!ACTIONS.includes(v as PermissionAction)) {
-            issues.push(`rules["${k}"] 必须是 ${ACTIONS.join('/')} 之一，收到 ${JSON.stringify(v)}`);
+            issues.push(`rules["${k}"] must be one of ${ACTIONS.join('/')}, got ${JSON.stringify(v)}`);
           }
         }
       }
@@ -134,14 +134,14 @@ export function validateRoleManifest(input: unknown): ValidateResult {
 
   if (input.services !== undefined) {
     if (!isPlainObject(input.services)) {
-      issues.push('services 必须是对象');
+      issues.push('services must be an object');
     } else if (input.services.todos !== undefined) {
       const t = input.services.todos;
       if (!isPlainObject(t)) {
-        issues.push('services.todos 必须是对象');
+        issues.push('services.todos must be an object');
       } else {
         if (t.mode !== undefined && t.mode !== 'serial' && t.mode !== 'parallel') {
-          issues.push(`services.todos.mode 必须是 serial/parallel，收到 ${JSON.stringify(t.mode)}`);
+          issues.push(`services.todos.mode must be serial/parallel, got ${JSON.stringify(t.mode)}`);
         }
       }
     }

package/src/roles/master.json

@@ -1,7 +1,7 @@
 {
   "role": "master",
   "version": "1.4.0",
-  "description": "主控角色（WS-D7 自应用；D83 镜像源）：核心工具（todos/协调/subagent/terminal）+ pi 内建 + web_search；D82 unknownTools=allow。v1.4.0: 工具合并 terminal 6→1, subagent 5→1",
+  "description": "Master role (WS-D7 self-application; D83 mirror source): core tools (todos/coordination/subagent/terminal) + pi built-ins + web_search; D82 unknownTools=allow. v1.4.0: tool consolidation terminal 6→1, subagent 5→1",
   "manifest": {
     "unknownTools": "allow",
     "tools": [

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": "Default worker role (D83 inheritance): mirrors master.tools minus subagent/terminal (no nesting, resource ownership); excluded families explicitly denied — still banned under the D82 unknownTools=allow stance; todos serial. v1.6.0: removed report_progress (0 calls in a week, D125); v1.5.0: Phase 2 explicitly allowed report_progress; v1.4.0: refreshed the deny list after tool consolidation",
   "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 {
     }