pi-pier 0.3.1 → 0.4.2

package/src/plugins/todo.ts

@@ -7,16 +7,17 @@
  */
 import { Context } from '@deepseek-ai/cordis';
 import { Type } from 'typebox';
-import type { PiSurface } from '../pi-surface.ts';
+import { cordisGet } from '../cordis-services.ts';
 import type { TodosService } from '../todos-service.ts';
-import { planTodoReadHook } from '../todo-read-hook.ts';
+import { planTodoReadHook, shouldRunTodoRead } from '../todo-read-hook.ts';
 import { TODO_REMINDER_CUSTOM_TYPE, planStopTodoReminder, todoReminderGraceMs } from '../todo-reminder-core.ts';
 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 { anchorTodoRange, formatTodoSummary, renderTodoGroups } from '../todo-window.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';
 
 type ToolParams = Record<string, unknown> | undefined;
@@ -29,7 +30,7 @@ export interface TodoUiSlot {
   cancelReminder?: () => void;
 }
 
-interface TodoDeps {
+export interface TodoDeps {
   todos: TodosService;
   allowParallelInProgress: boolean;
   /** Warn above this size without rejecting otherwise valid plans. */
@@ -39,6 +40,8 @@ interface TodoDeps {
   state: TodoUiSlot;
   /** Human-gate depth (ask_user_question / herdr:blocked); >0 collapses the widget to one line. */
   getBlockedDepth?: () => number;
+  /** D113: running subagent rows for the unified widget; master mounts only. */
+  getWorkers?: () => readonly WorkerWidgetRow[];
   /** Master-only unfinished-todo reminder; omitted on worker panes. */
   stopReminder?: {
     getBlockedDepth: () => number;
@@ -49,17 +52,12 @@ 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(' ');
 
-/** pi interactive mode renders at most ten widget lines. */
-const WIDGET_MAX_LINES = 10;
 
 /** `/todos <op> <query>` verbs; the value is the user-facing past-tense feedback. */
 const OP_VERBS: Record<TodoEditOp, string> = {
@@ -69,48 +67,21 @@ const OP_VERBS: Record<TodoEditOp, string> = {
   rm: 'removed',
 };
 
-/**
- * Keep the active task visible within WIDGET_MAX_LINES rather than truncating to a fixed head or tail:
- * the window anchors on the first in-progress item, then the last open item, then recent completions.
- */
+/** D113 unified resident widget (see tree-view.ts for the line rules). */
 export function widgetLines(
   items: readonly TodoItem[],
-  opts?: { archivedAgeMs?: number | null; blockedDepth?: number | null },
+  opts?: { archivedAgeMs?: number | null; blockedDepth?: number | null; workers?: readonly WorkerWidgetRow[] },
 ): string[] {
-  if (items.length === 0) return [];
-  // Human gate open (ask_user_question waiting): the question and editor own the fixed area, so the widget
-  // collapses to one summary line — a 10-line widget plus a multi-line question would leave no scrollable transcript.
-  if ((opts?.blockedDepth ?? 0) > 0) {
-    return [`${formatTodoSummary(items)} · /todos 全量`];
-  }
-  // Collapse archived plans to two lines so stale work cannot monopolize the widget.
-  if (opts?.archivedAgeMs != null) {
-    return [
-      `${formatTodoSummary(items)} · archived ${formatAge(opts.archivedAgeMs)}`,
-      '  archived — /todos 全量',
-    ];
-  }
-
-  // Reserve summary and overflow lines; phase headers consume the budget too, hence the shrink loop.
-  const renderBudget = WIDGET_MAX_LINES - 2;
-  const [start, end] = anchorTodoRange(
-    items,
-    (s, e) => renderTodoGroups(items.slice(s, e)).length <= renderBudget,
-  );
-  const kept = items.slice(start, end);
-  const hidden = items.filter((_, i) => i < start || i >= end);
-  const lines = [formatTodoSummary(items), ...renderTodoGroups(kept)];
-  if (hidden.length > 0) {
-    const hiddenCompleted = hidden.filter((it) => it.status === 'completed').length;
-    lines.push(`   +${hidden.length} hidden (${hiddenCompleted}✓) · /todos 全量`);
-  }
-  return lines;
+  return unifiedWidgetLines(items, opts?.workers ?? [], {
+    archivedAgeMs: opts?.archivedAgeMs,
+    blockedDepth: opts?.blockedDepth,
+  });
 }
 
 export default function todoPlugin(ctx: Context): void {
-  const surface = ctx.get('pi-herdr.surface') as PiSurface<object>;
-  const { todos, allowParallelInProgress, maxItems, mirrorTodos, appendEntry, state, stopReminder, getBlockedDepth } =
-    ctx.get('pi-herdr.todo-deps') as TodoDeps;
+  const surface = cordisGet(ctx, 'pi-herdr.surface');
+  const { todos, allowParallelInProgress, maxItems, mirrorTodos, appendEntry, state, stopReminder, getBlockedDepth, getWorkers } =
+    cordisGet(ctx, 'pi-herdr.todo-deps');
   const scoped = surface.forModule(import.meta.url);
 
   /** Share one archive-age decision between the widget and /todos. */
@@ -129,6 +100,7 @@ export default function todoPlugin(ctx: Context): void {
       ui?.setWidget?.('todos', widgetLines(todos.items, {
         archivedAgeMs: archivedAgeMs(),
         blockedDepth: getBlockedDepth?.() ?? 0,
+        workers: getWorkers?.() ?? [],
       }));
     } catch {
       /* Older pi versions may omit widget support without disabling todo tracking. */
@@ -151,7 +123,10 @@ 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;
     const plan = planTodoReadHook({
       items: todos.items,
       turn: todoReadTurn,
@@ -161,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;
     }
@@ -181,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;
@@ -216,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,
@@ -258,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-core.ts

@@ -1,5 +1,6 @@
 /** D102 Evidence-Preserving Reducer core: diagnostic-command recognition, secret filtering, receipt
  * schema checking, byte-for-byte quote verification (storage I/O lives in efficiency-store.ts). */
+import { isPlainObject } from './guards.ts';
 
 import { createHash } from 'node:crypto';
 
@@ -104,9 +105,6 @@ function stripReceiptJsonFences(raw: string): string {
   return fenced?.[1]?.trim() ?? trimmed;
 }
 
-function isRecord(v: unknown): v is Record<string, unknown> {
-  return typeof v === 'object' && v !== null && !Array.isArray(v);
-}
 
 function lineNumberOf(body: string, quote: string): number | undefined {
   const index = body.indexOf(quote);
@@ -168,7 +166,7 @@ export function validateReceipt(
     return { ok: false, reason: 'invalid-json' };
   }
 
-  if (!isRecord(parsed)) {
+  if (!isPlainObject(parsed)) {
     return { ok: false, reason: 'schema-mismatch' };
   }
 
@@ -189,7 +187,7 @@ export function validateReceipt(
   const seen = new Set<string>();
 
   for (const item of parsed.evidence) {
-    if (!isRecord(item)) {
+    if (!isPlainObject(item)) {
       return { ok: false, reason: 'schema-mismatch' };
     }
     const kind = item.kind;

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,8 @@
  * needed and older pi builds degrade to "no renderer".
  */
 import { TODO_EDIT_CUSTOM_TYPE, type TodoEditPayload } from './todo-core.ts';
-import { SUBS_CUSTOM_TYPE, 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';
 
@@ -94,10 +95,31 @@ function subsLines(data: unknown, theme: RenderTheme, expanded: boolean): string
     label: 'subagents',
     unit: 'tracked',
     ...(running ? { badge: `${running} running` } : {}),
-    row: (sub) => `  ${sub.status === 'running' ? '●' : '○'} ${sub.paneId} · ${sub.status} · ${clip(String(sub.description ?? ''), 70)}`,
+    // Every registry row IS a delegated worker (↳ marks the delegation edge; status text carries state).
+    row: (sub) => `  ↳ ${subRef(sub)} · ${sub.status} · ${clip(String(sub.description ?? ''), 70)}`,
   });
 }
 
+/** First-frame delegation card in the worker's own transcript (RFC rfc-delegation-identity §2.3). */
+function delegationLines(data: unknown, theme: RenderTheme, expanded: boolean): string[] {
+  const rec = (data ?? {}) as {
+    parentPaneId?: unknown;
+    parentSessionId?: unknown;
+    taskId?: unknown;
+    description?: unknown;
+    role?: unknown;
+  };
+  const parent = typeof rec.parentPaneId === 'string' && rec.parentPaneId ? rec.parentPaneId : '?';
+  const head = `${theme.fg('accent', '⟵ delegated')} ${theme.fg('dim', `by master ${parent} · ${clip(String(rec.description ?? ''), 60)}`)}`;
+  if (!expanded) return [head];
+  const session = typeof rec.parentSessionId === 'string' && rec.parentSessionId ? rec.parentSessionId : '?';
+  const role = typeof rec.role === 'string' && rec.role ? rec.role : '?';
+  return [
+    head,
+    theme.fg('dim', `  task ${typeof rec.taskId === 'string' ? rec.taskId : '?'} · role ${role} · parent session ${session}`),
+  ];
+}
+
 function terminalsLines(data: unknown, theme: RenderTheme, expanded: boolean): string[] {
   const terminals = (data as TerminalsRegistry | undefined)?.terminals;
   return registryLines(Array.isArray(terminals) ? terminals : undefined, theme, expanded, {
@@ -179,6 +201,7 @@ export function installRenderers(pi: unknown): string[] {
   entry(TODO_EDIT_CUSTOM_TYPE, todoEditLines);
   entry(SUBS_CUSTOM_TYPE, subsLines);
   entry(TERMINALS_CUSTOM_TYPE, terminalsLines);
+  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(TODO_REMINDER_CUSTOM_TYPE, (msg, theme, expanded) => reminderLines(msg, theme, 'todo reminder', expanded));

package/src/role-manifest.ts

@@ -4,6 +4,8 @@
  * top-level keys are reported (a typo like "rulez" must not silently fail) and every issue is
  * collected in one pass so a manifest can be repaired in one go.
  */
+import { isPlainObject } from './guards.ts';
+
 export type PermissionAction = 'allow' | 'ask' | 'deny';
 export type TodosMode = 'serial' | 'parallel';
 /** D82: stance for unknown tools—visibility is a trust relationship (user→master via install; master→delegated via mirror). */
@@ -47,9 +49,6 @@ const SEMVER_RE = /^\d+\.\d+\.\d+$/;
 const TOOL_KEY_RE = /^[a-z0-9_*-]+$/;
 const ACTIONS: readonly PermissionAction[] = ['allow', 'ask', 'deny'];
 
-function isPlainObject(v: unknown): v is Record<string, unknown> {
-  return typeof v === 'object' && v !== null && !Array.isArray(v);
-}
 
 export function validateRoleManifest(input: unknown): ValidateResult {
   const issues: string[] = [];

package/src/roles/worker-default.json

@@ -1,7 +1,7 @@
 {
   "role": "worker-default",
-  "version": "1.4.0",
-  "description": "默认worker角色（D83 继承制）：镜像 master.tools 减 subagent/terminal（禁嵌套、资源归属）；排除族显式 deny——在 D82 unknownTools=allow 姿态下仍持禁令；todos serial。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": [

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;
 
@@ -15,6 +18,11 @@ export interface SettleWakeInput {
   lastStopReason: string | null;
   /** True when abort was triggered intentionally by internal mechanisms like OCC. */
   intentionalAbort?: boolean;
+  /**
+   * pi ≥ 1.1 carries `aborted` on agent_settled itself: authoritative for runs cancelled without a
+   * final assistant message (ESC mid-tool), where stopReason tracking sees a stale natural reason.
+   */
+  aborted?: boolean;
   running: ReadonlyArray<{ paneId: string }>;
   lastNoticeKey: string | null;
   lastNoticeAt: number;
@@ -50,7 +58,7 @@ export function planSettleWake(input: SettleWakeInput): SettleWakePlan {
       noticeAt: input.lastNoticeAt,
     };
   }
-  if (input.intentionalAbort || input.lastStopReason === ABORT_STOP_REASON) {
+  if (input.aborted === true || input.intentionalAbort || input.lastStopReason === ABORT_STOP_REASON) {
     return {
       wake: false,
       compact: input.intentionalAbort === true,
@@ -75,14 +83,20 @@ 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;
+  /** pi ≥ 1.1 agent_settled.aborted: the run was cancelled — the closing message may still come after a re-run. */
+  aborted?: boolean;
   compactionInFlight?: boolean;
   lastStopReason: string | null;
 }): boolean {
   return !input.intentionalAbort
+    && input.aborted !== true
     && !input.compactionInFlight
-    && input.lastStopReason !== ABORT_STOP_REASON;
+    && input.lastStopReason !== ABORT_STOP_REASON
+    && input.lastStopReason !== ERROR_STOP_REASON;
 }