pi-pier 0.3.0 → 0.4.1

package/src/index.ts

@@ -1,20 +1,16 @@
 /**
- * pi-herdr extension entry point (v1.1: closed-loop todos + interactive subagents,
- * DESIGN.md §12 option C).
+ * pi-herdr extension entry point and composition root.
  *
- * Installation: `pi package` (package.json's pi.extensions) or ~/.pi/agent/extensions/.
+ * Layout: index-runtime.ts picks the process mode (worker / bare pi / herdr master);
+ * index-roles.ts the role runtime, index-gates.ts human-gate reporting, index-pipe.ts the
+ * pipe protocol handler, index-notices.ts the notice buffer, index-locks.ts write locks;
+ * index-master.ts / index-worker.ts are the dynamic master / todo-only mounts.
  *
- * Capabilities:
- *  - `todo_write`: replace the complete todo list; the current pi session JSONL is authoritative,
- *    and branches automatically roll back in DSH-aligned semantics.
- *  - `subagent` / `terminal`: herdr-master only. Bare pi does not register them.
- *  - `/todos`, TUI widget, and herdr title projection with graceful degradation without herdr.
- *
- * pi 0.84.2 contract (validated):
- *  - onUpdate must have AgentToolResult shape; a string causes the TUI to crash and exit pi;
- *  - tool-result details persist in session JSONL, and getBranch() replay implements branch rollback.
+ * pi contract: onUpdate must have AgentToolResult shape (a string crashes the TUI); tool-result
+ * details persist in session JSONL and getBranch() replay implements branch rollback.
  */
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+import { Type } from 'typebox';
 import {
   ASK_PARAMETERS,
   ASK_PROMPT_GUIDELINES,
@@ -27,46 +23,49 @@ import {
   runAsk,
 } from './ask-user.ts';
 import { pipeNameFor, pipeRequest, startPipeServer } from './pipe-channel.ts';
-import {
-  TODO_EDIT_CUSTOM_TYPE,
-  currentActivity,
-} from './todo-core.ts';
-
-import { APPROVAL_NEEDED_CUSTOM_TYPE, ROLE_MANIFEST_CUSTOM_TYPE, installRenderers } from './renderers.ts';
+import { TODO_EDIT_CUSTOM_TYPE, currentActivity } from './todo-core.ts';
+import { installRenderers } from './renderers.ts';
 import { createHerdrClient } from './herdr-client.ts';
-// The subagent family moved to core/subagent.ts (loader entry, D78/D81); its history-store,
-// session-tail, and gc-core imports moved with it, leaving index.ts only the common readers.
-import { lastAssistantText, readSessionFile } from './session-tail.ts';
+import { bareSessionId, lastAssistantText, readSessionFile, resolveSessionFileValue } from './session-tail.ts';
 import { fileURLToPath } from 'node:url';
-import { TodosService } from './todos-service.ts';
+import { join } from 'node:path';
+import { mkdirSync, unlinkSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { platformPaths } from './platform-paths.ts';
+import { TodosService, type TodoCompletionSource } from './todos-service.ts';
 import { reconcileTodos } from './reconcile-core.ts';
-import type { TodoUiSlot } from './core/todo.ts';
-import {
-  estimateEta,
-  formatProgressSuffix,
-  planToolBadge,
-  progressOf,
-} from './progress-core.ts';
+import type { TodoUiSlot } from './plugins/todo.ts';
+import { estimateEta, formatProgressSuffix, planToolBadge, progressOf } from './progress-core.ts';
 import { WRITE_LOCK_ENV } from './lock-core.ts';
-import { ABORT_STOP_REASON, planSettleWake } from './settle-wake-core.ts';
-import { composeForRole } from './manifest-compose.ts';
-import { parseRuntimeManifest, planActiveTools, planToolGate, type RuntimeRoleManifest } from './tool-gate.ts';
-
+import { ABORT_STOP_REASON, planSettleWake, shouldPushSettleReply } from './settle-wake-core.ts';
+import { parseRuntimeManifest } from './tool-gate.ts';
 import { formatPaneTitle } from './pane-title.ts';
 import { registerSlimFrame, updateSlimFrame } from './slim-frame.ts';
-import { planIndexMode } from './index-runtime.ts';
-import { emptySubagentPortBox } from './subagent-port.ts';
+import { applyRestoredWorkerMode, planIndexMode } from './index-runtime.ts';
+import { buildResumeArgv, emptySubagentPortBox, PROGRESS_CUSTOM_TYPE } from './subagent-core.ts';
+import { hasWorkerMarker, writeWorkerMarker, readWorkerMarker } from './worker-marker.ts';
+import {
+  DELEGATION_CUSTOM_TYPE,
+  applyWorkerTag,
+  buildDelegationSection,
+  foldDelegation,
+  parseDelegationContext,
+  type DelegationContext,
+} from './delegation-core.ts';
+import { formatDelegationTree, type WorkerTodoSnapshot, type WorkerWidgetRow } from './tree-view.ts';
 import { createNoticeBuffer } from './index-notices.ts';
-import { handlePipeRequest } from './index-pipe.ts';
+import { handlePipeRequest, type MachineRequest } from './index-pipe.ts';
 import { installWriteLocks } from './index-locks.ts';
 import { installDashboardCommand } from './dashboard-command.ts';
-import { registerObservationPack, createCompactionBatchPackHook, type PickMiddleExcerpt } from './core/observation.ts';
+import { openPierPanel } from './panel-open.ts';
+import { registerObservationPack, createCompactionBatchPackHook, type PickMiddleExcerpt } from './plugins/observation.ts';
 import { createJevRuntime } from './jev-client.ts';
 import {
   NOTICE_RANK_MIN_CONFIDENCE,
   buildExcerptWindows,
   composeNoticeRanking,
   evaluateExcerptPick,
+  excerptAskIsSafe,
   excerptPickRequest,
   noticeRankRequest,
 } from './jev-core.ts';
@@ -74,93 +73,57 @@ import { completeLineExcerpt } from './observation-core.ts';
 import { installConfigCommand } from './config-command.ts';
 import { CompactCoordinator } from './compact-coordinator.ts';
 import { handleReducerToolResult, type ToolResultEventLike } from './reducer-invoker.ts';
-import {
-  pruneSessionObjects,
-  resolveSessionRoot,
-} from './efficiency-store.ts';
-import {
-  loadEfficiencyConfigFromDisk,
-  resolveEfficiencyConfig,
-  type EfficiencyConfig,
-} from './efficiency-config-core.ts';
-import {
-  resolveDefaultFocusPollMs,
-  parseFocusSample,
-  spawnReflow,
-  startFocusPoller,
-  type FocusPoller,
-} from './focus-poller.ts';
-
-/**
- * D-4: focus sampling cadence. `PIER_FOCUS_POLL_MS=0` disables the poller (heat layout then only
- * reacts to herdr events). Invalid values fall back to the version default: 1500ms on Herdr <0.9.1,
- * 0 (event-first) on 0.9.1+ where native pane.focused is authoritative.
- */
-function focusPollIntervalMs(env: NodeJS.ProcessEnv = process.env, herdrVersion?: string | null): number {
-  const defaultMs = resolveDefaultFocusPollMs(herdrVersion);
-  const raw = env.PIER_FOCUS_POLL_MS;
-  if (raw === undefined || raw.trim() === '') return defaultMs;
-  const ms = Number(raw);
-  return Number.isFinite(ms) && ms >= 0 ? ms : defaultMs;
+import { appendEfficiencyLog, efficiencyLogPath, pruneSessionObjects, resolveSessionRoot } from './efficiency-store.ts';
+import type { RoutingTelemetryRecord, RoutingTelemetryRow } from './routing-telemetry.ts';
+import { loadEfficiencyConfigFromDisk, resolveEfficiencyConfig, type EfficiencyConfig } from './efficiency-config-core.ts';
+import { composeMasterRuntime, createRoleRuntime } from './index-roles.ts';
+import { createGateRuntime } from './index-gates.ts';
+
+function agentSessionsDir(): string {
+  return process.env.PI_CODING_AGENT_DIR ? join(process.env.PI_CODING_AGENT_DIR, 'sessions') : platformPaths.sessionsDir;
 }
 
-/**
- * WS-D7: apply the master-pane manifest to itself through the same mandatory chain as subagents
- * (gate, visible layer, badge, and session record); the baseline includes our core plus inspect/execute tools.
- * Match only a herdr pane (HERDR_ENV=1) that is not a subagent and has no explicitly supplied manifest.
- * Standalone pi sessions without herdr remain full-featured for backward compatibility.
- * A malformed master.json fails open to no-role state, matching malformed env semantics.
- */
-function composeMasterRuntime(): RuntimeRoleManifest | null {
-  try {
-    // v1.1: read the built-in name directly so a workspace master.json decoy cannot affect self-application; the reserved-name check remains for loud spawn errors.
-    const { role, manifest } = composeForRole('master', [], { loadRoleOpts: { builtinDirect: true } });
-    return {
-      role: role.role,
-      version: role.version,
-      tools: manifest.tools,
-      permissions: manifest.permissions,
-      unknownTools: manifest.unknownTools,
-      services: role.services ?? {},
-    };
-  } catch (err) {
-    console.error(`[pi-herdr] master manifest invalid (fail-open): ${err instanceof Error ? err.message : String(err)}`);
-    return null;
-  }
-}
-// C3: cordis belongs only in the master process; subagent-scope includes @deepseek-ai/cordis.
-// Dynamically import it on the master branch so worker processes never load the module.
-// Subagent constants/helpers moved with the family to core/subagent.ts.
-
 export default async function (pi: ExtensionAPI) {
-  const mode = planIndexMode();
+  const mode = applyRestoredWorkerMode(planIndexMode(), process.env.PI_SESSION_FILE ?? null, hasWorkerMarker);
   const isSubagent = mode.isSubagent;
-  const runtimeManifest =
-    parseRuntimeManifest(process.env.PI_HERDR_ROLE_MANIFEST) ??
-    (mode.composeMaster ? composeMasterRuntime() : null);
-  const todos = new TodosService(TodosService.configFromRuntime(runtimeManifest, isSubagent));
-  const { client, env } = createHerdrClient();
+  const roleBase = process.env.PI_HERDR_ROLE_BASE || process.cwd();
+
+  let sessionId: string = process.env.PI_SESSION_FILE ?? process.env.PI_SESSION_ID ?? '';
+  let sessionRoot: string | null = null;
   let effConfig: EfficiencyConfig = resolveEfficiencyConfig();
   const coordinator = new CompactCoordinator();
-  let sessionRoot: string | null = null;
+  const { client, env } = createHerdrClient();
+  /** RFC rfc-delegation-identity §2.1: resolved env → marker → branch fold; worker panes only. */
+  let delegation: DelegationContext | null = parseDelegationContext(process.env.PI_HERDR_DELEGATION);
+  const initialManifest =
+    parseRuntimeManifest(process.env.PI_HERDR_ROLE_MANIFEST) ??
+    (mode.composeMaster ? composeMasterRuntime() : null);
+  const todos = new TodosService(TodosService.configFromRuntime(initialManifest, isSubagent));
+
+  /** Phase 0 routing telemetry (RFC docs/rfc-jev-role-routing.md §8): best-effort append; never gates anything. */
+  const appendRoutingLog = (row: RoutingTelemetryRecord): void => {
+    const root = sessionRoot;
+    if (!root) return;
+    const stamped: RoutingTelemetryRow = { ...row, sessionId: sessionId || 'unknown' };
+    void appendEfficiencyLog(efficiencyLogPath(root, 'routing'), stamped).catch(() => {});
+  };
 
-  /* ── Jev decision layer (RFC docs/rfc-jev-integration.md): direct HTTP, total-budget abort,
-   * fail-open at every site. Disabled or keyless => behavior is byte-identical to before. ── */
-  const jevRuntime = createJevRuntime(() => effConfig.jev, {
-    getSessionRoot: () => sessionRoot,
-  });
-  const jevMinConfidence = (): number => effConfig.jev.minConfidence;
+  const roles = createRoleRuntime({ pi, client, roleBase, initialManifest, isSubagent, todos, appendRoutingLog });
+
+  /* ── Jev decision layer (RFC docs/rfc-jev-integration.md): direct HTTP, total-budget
+   * abort, fail-open at every site. Disabled or keyless → behavior identical to before. ── */
+  const jevRuntime = createJevRuntime(() => effConfig.jev, { getSessionRoot: () => sessionRoot, getSessionId: () => sessionId || null });
   /** P0-3: candidate windows are generated in code; jev only picks (rerank pattern). */
   const pickMiddleExcerpt: PickMiddleExcerpt = async (text, excerptBudgetBytes) => {
     if (!jevRuntime.available) return null;
     const halfBudget = Math.floor(excerptBudgetBytes / 2);
     const windows = buildExcerptWindows(text, halfBudget);
-    if (windows.length === 0) return null; // no failure-signal lines -> keep halves, no API call
-    const request = excerptPickRequest(
-      windows,
-      completeLineExcerpt(text, halfBudget, false),
-      completeLineExcerpt(text, excerptBudgetBytes - halfBudget, true),
-    );
+    if (windows.length === 0) return null; // degenerate budget only
+    const headExcerpt = completeLineExcerpt(text, halfBudget, false);
+    const tailExcerpt = completeLineExcerpt(text, excerptBudgetBytes - halfBudget, true);
+    // Credential-shaped text never leaves the process (§8 privacy boundary).
+    if (!excerptAskIsSafe(windows, headExcerpt, tailExcerpt)) return null;
+    const request = excerptPickRequest(windows, headExcerpt, tailExcerpt);
     if (!request) return null;
     const result = await jevRuntime.ask(request, {
       questionId: 'obs-excerpt-window',
@@ -171,95 +134,148 @@ export default async function (pi: ExtensionAPI) {
       },
     });
     if (!result.ok) return null;
-    const picked = evaluateExcerptPick(result.answers, jevMinConfidence());
+    const picked = evaluateExcerptPick(result.answers, effConfig.jev.minConfidence);
     const window = picked === null ? undefined : windows.find((w) => w.id === picked);
     return window ? { text: window.text, label: window.label } : null;
   };
-  // Transcript polish for pier's own custom entries and reminder messages; display-only and
-  // best-effort (older pi builds without the renderer API simply keep the raw rows).
+
   const rendererTypes = installRenderers(pi);
   if (process.env.PI_HERDR_TRACE) {
     console.error(`[pi-herdr] transcript renderers: ${rendererTypes.length ? rendererTypes.join(', ') : 'none'}`);
   }
 
-  let sessionId: string = process.env.PI_SESSION_FILE ?? process.env.PI_SESSION_ID ?? '';
-  /** M16: completion timestamps used as rate-estimation input, appended with todo.completed events. */
+  let agentActive = false;
+  let lastStopReason: string | null = null;
+  let latestCtx: { abort?: () => void } | null = null;
   const completedStamps: number[] = [];
+  const subagentPort = emptySubagentPortBox();
+  let d96NoticeKey: string | null = null;
+  let d96NoticeAt = 0;
 
-  /* ── State reconstruction (branch correctness comes from the last todo_write snapshot on the branch) ── */
+  const todoUi: TodoUiSlot = { renderWidget: () => { /* filled after plugin mounting */ } };
+  const gates = createGateRuntime({
+    pi,
+    client,
+    rerenderWidget: () => todoUi.rerenderWidget?.(),
+    isAgentActive: () => agentActive,
+    idleMessage: () => roles.idleBadge(),
+    workingMessage: () => currentActivity(todos.items),
+  });
 
-  function rebuildFromBranch(ctx: unknown): void {
+  /** Session identity: sessionManager is authoritative (env may be unset in print/RPC mode). */
+  function resolveSessionId(ctx: unknown): string {
     try {
-      const entries = (ctx as { sessionManager?: { getBranch?: () => readonly unknown[] } })
-        ?.sessionManager?.getBranch?.() ?? [];
-      todos.rebuild(entries);
-      coordinator.rebuildFromBranch(entries);
+      const sm = (ctx as {
+        sessionManager?: { getSessionFile?: () => string | undefined; getSessionId?: () => string };
+      }).sessionManager;
+      return bareSessionId(
+        sm?.getSessionFile?.() ?? sm?.getSessionId?.() ?? process.env.PI_SESSION_FILE ?? process.env.PI_SESSION_ID ?? '',
+      );
     } catch {
-      // A reconstruction failure must not disrupt the main flow; the next todo_write re-anchors state.
+      return bareSessionId(process.env.PI_SESSION_FILE ?? '');
     }
   }
 
-  /* ── herdr reporting (zero cost for Noop; silent failures never affect pi's main flow) ── */
-
-  /** Tier 2: worker role badge parsed from the env manifest and kept visible while idle. */
-  let roleBadge: string | null = null;
-  /** Human-gate depth; ask_user_question and external herdr:blocked events share it. */
-  let blockedDepth = 0;
-
-  function reportAgent(state: 'working' | 'idle' | 'blocked', activity: string | null): void {
-    if (!client.available) return;
-    // While a human gate is open, never let tool-badge / turn_start / settle overwrite blocked.
-    // Needed when herdr:pi is absent (pi-herdr is the authority); no-op under full-lifecycle herdr:pi.
-    if (blockedDepth > 0 && state !== 'blocked') return;
-    const message = activity ?? (state === 'idle' ? roleBadge : null);
-    client.reportAgent(state, message).catch(() => {});
-  }
-
-  /** Session identity: sessionManager is authoritative (env may be unset in print/RPC mode), with env as fallback. */
-  function resolveSessionId(ctx: unknown): string {
+  /** Branch reconstruction: todos + OCC debt state (branch correctness from the last snapshot on the branch). */
+  function rebuildFromBranch(ctx: unknown): void {
     try {
-      const sm = (ctx as {
-        sessionManager?: {
-          getSessionFile?: () => string | undefined;
-          getSessionId?: () => string;
-        };
-      }).sessionManager;
-      return (
-        sm?.getSessionFile?.() ??
-        sm?.getSessionId?.() ??
-        process.env.PI_SESSION_FILE ??
-        process.env.PI_SESSION_ID ??
-        ''
-      );
+      const entries = (ctx as { sessionManager?: { getBranch?: () => readonly unknown[] } })
+        ?.sessionManager?.getBranch?.() ?? [];
+      todos.rebuild(entries);
+      coordinator.rebuildFromBranch(entries);
     } catch {
-      return process.env.PI_SESSION_FILE ?? '';
+      /* A reconstruction failure must not disrupt the main flow; the next todo_write re-anchors. */
     }
   }
 
   function mirrorTodos(): void {
     if (!client.available) return;
     const label = sessionId || (env ? `pane:${env.paneId}` : '');
-    // M16: progress badge (conservative N/M plus confidence ETA; fall back to a plain count when estimates are unreliable).
     const p = progressOf(todos.items);
     const eta = estimateEta({ completedAt: completedStamps, total: p.total, now: Date.now() });
     const suffix = formatProgressSuffix({ completed: p.completed, total: p.total, eta });
-    // Unfreeze by carrying lastWriteAt into the title-side archived check (pane-title).
-    const title = formatPaneTitle(todos.items, null, {
-      progressSuffix: suffix,
-      lastWriteAt: todos.lastWriteAt,
-    });
-    // D97: overlay content shares the todo snapshot; thinking tokens cannot reach it.
+    const title = applyWorkerTag(
+      formatPaneTitle(todos.items, null, { progressSuffix: suffix, lastWriteAt: todos.lastWriteAt }),
+      delegation?.description ?? null,
+    );
     updateSlimFrame({ title, items: todos.items, lastWriteAt: todos.lastWriteAt });
     client.reportMetadata({
       session: label,
       items: todos.items,
       progressSuffix: suffix,
       lastWriteAt: todos.lastWriteAt,
+      workerTag: delegation?.description ?? null,
     }).catch(() => {});
+    // D113: delegated workers also push the full list to the master's pipe so its resident widget
+    // and /pier-tree stay live without polling. Best effort — a lost push self-heals on the next write.
+    if (isSubagent && delegation?.parentPipe) {
+      void pipeRequest(delegation.parentPipe, {
+        type: 'todo_sync',
+        id: `tsync-${Date.now()}`,
+        paneId: env?.paneId ?? '',
+        items: todos.items.map((it) => ({ content: it.content, status: it.status, ...(it.blocker ? { blocker: it.blocker } : {}) })),
+        summary: title ?? delegation.description,
+      }, 3000).catch(() => {});
+    }
+  }
+
+  /** D113: per-worker todo cache (pipe pushes; summary fallback after a master resume). */
+  const workerTodos = new Map<string, WorkerTodoSnapshot>();
+  function applyWorkerTodos(workerPaneId: string, items: WorkerTodoSnapshot['items'], summary: string): void {
+    if (!workerPaneId) return;
+    workerTodos.set(workerPaneId, { items, summary, ts: Date.now() });
+    todoUi.rerenderWidget?.();
+    refreshTreeSnapshot();
+  }
+  /** Running rows joined with their cached todos — feeds the unified widget and /pier-tree. */
+  function widgetWorkers(): WorkerWidgetRow[] {
+    return (subagentPort.current?.listRunningSubs() ?? []).map((s) => ({
+      ...s,
+      todos: workerTodos.get(s.paneId) ?? null,
+    }));
   }
 
-  /* ── M17: automatic settlement reconciliation (pure planner + D38 authority; idempotent and safe to run through both paths) ── */
+  /* ── /pier-tree panel: the pi process owns the data, the popup/overlay owns the surface. ── */
+  /** Set while a panel is open; todo/worker updates republish the snapshot it polls. */
+  let treeSnapshot: { path: string } | null = null;
+
+  function renderTreeLines(): string[] {
+    const rows = subagentPort.current?.listRows() ?? [];
+    return formatDelegationTree({
+      selfItems: todos.items,
+      workers: widgetWorkers(),
+      settled: rows
+        .filter((r) => r.status === 'settled' || r.status === 'consumed')
+        .map((r) => ({ paneId: r.paneId, slug: r.slug, description: r.description, settledAt: r.settledAt })),
+      now: Date.now(),
+    });
+  }
 
+  function treeSnapshotPath(): string {
+    const id = (sessionId || (env ? `pane-${env.paneId}` : 'session')).replace(/[^A-Za-z0-9._-]/g, '_').slice(0, 80);
+    return join(tmpdir(), 'pier-tree', `${id}.txt`);
+  }
+
+  function publishTreeSnapshot(): string {
+    const path = treeSnapshotPath();
+    mkdirSync(join(tmpdir(), 'pier-tree'), { recursive: true });
+    writeFileSync(path, `${renderTreeLines().join('\n')}\n`);
+    treeSnapshot = { path };
+    return path;
+  }
+
+  function refreshTreeSnapshot(): void {
+    if (!treeSnapshot) return;
+    try {
+      writeFileSync(treeSnapshot.path, `${renderTreeLines().join('\n')}\n`);
+    } catch {
+      /* The panel may have been closed and its temp dir swept; the next command republishes. */
+    }
+  }
+
+  todos.on('todo.updated', () => refreshTreeSnapshot());
+
+  /** M17 settlement reconciliation: auto-complete settled todos / unblock on failure notes (idempotent). */
   function reconcileOnSettlement(description: string, outcome: 'settled' | 'failed'): string[] {
     if (!description) return [];
     try {
@@ -271,7 +287,6 @@ export default async function (pi: ExtensionAPI) {
             { version: 1, edits: plan.edits, ts: Date.now() },
           );
         } catch {
-          /* Best effort persistence; in-memory state still advances. */
         }
         todos.applyEdits(plan.edits, { source: 'reconcile' });
         mirrorTodos();
@@ -282,71 +297,200 @@ export default async function (pi: ExtensionAPI) {
     }
   }
 
-  /** M17: append reconciliation note lines to settlement notices; an empty list returns the original text. */
-  function withReconcileNotes(base: string, notes: readonly string[]): string {
-    return notes.length ? `${base}\n${notes.join('\n')}` : base;
-  }
-
-  /* ── M16: progress and tool badges (title suffix + report_agent.message; no new protocol) ── */
+  const withReconcileNotes = (base: string, notes: readonly string[]): string =>
+    notes.length ? `${base}\n${notes.join('\n')}` : base;
 
-  todos.on('todo.completed', (e: { count: number; at: number; source?: import('./todos-service.ts').TodoCompletionSource }) => {
+  todos.on('todo.completed', (e: { count: number; at: number; source?: TodoCompletionSource }) => {
     for (let i = 0; i < e.count; i++) completedStamps.push(e.at);
     coordinator.recordBoundaryCompleted(e.count, e.source);
     mirrorTodos();
   });
 
-  // Tool badge: parallel mode starts in source order and ends in completion order (pi docs contract); track in-flight calls in a Map.
+  /* ── tool badges: parallel calls start in source order, end in completion order ── */
   const runningTools = new Map<string, string>(); // toolCallId → toolName
   let lastToolBadge: string | null = null;
   function reportToolBadge(): void {
     const badge = planToolBadge([...new Set(runningTools.values())]);
-    if (badge === lastToolBadge) return; // Idempotent: report only changes (M13 rendering discipline).
+    if (badge === lastToolBadge) return; // report only changes (M13 rendering discipline)
     lastToolBadge = badge;
-    if (badge) reportAgent('working', badge);
-    else reportAgent(agentActive ? 'working' : 'idle', agentActive ? currentActivity(todos.items) : null);
+    if (badge) gates.report('working', badge);
+    else gates.report(agentActive ? 'working' : 'idle', agentActive ? currentActivity(todos.items) : null);
   }
-
   pi.on('tool_execution_start', async (event: { toolCallId?: string; toolName?: string }) => {
     if (typeof event?.toolCallId === 'string' && typeof event?.toolName === 'string') {
       runningTools.set(event.toolCallId, event.toolName);
       reportToolBadge();
     }
   });
-  pi.on('tool_execution_end', async (event: { toolCallId?: string }) => {
-    if (typeof event?.toolCallId === 'string') {
-      runningTools.delete(event.toolCallId);
-      reportToolBadge();
+  pi.on('tool_execution_end', async (event: { toolCallId?: string; toolName?: string; durationMs?: number }) => {
+    if (typeof event?.toolCallId !== 'string') return;
+    const tool = typeof event.toolName === 'string' ? event.toolName : runningTools.get(event.toolCallId) ?? null;
+    runningTools.delete(event.toolCallId);
+    reportToolBadge();
+    // pi ≥ 1.1 records the real execution time on the event; the tools ledger replaces wall-clock
+    // estimates in the efficiency trial with measured numbers. Absent on older pi — nothing logged.
+    if (typeof event.durationMs === 'number' && sessionRoot) {
+      try {
+        await appendEfficiencyLog(efficiencyLogPath(sessionRoot, 'tools'), {
+          sessionId: sessionId || 'unknown',
+          ts: Date.now(),
+          tool,
+          durationMs: event.durationMs,
+        });
+      } catch {
+        /* ledger is observability only */
+      }
     }
   });
 
-  /* ── D102: Evidence-Preserving Reducer (runs before append-handlers like write-locks) ── */
+  /* ── D102 evidence-preserving reducer (registered before append-handlers like write-locks) ── */
   pi.on('tool_result', async (event, ctx) => {
     if (!effConfig.evidencePreservingReducer.enabled) return;
     if (!event || typeof event !== 'object') return;
     return handleReducerToolResult(event as unknown as ToolResultEventLike, ctx, effConfig.evidencePreservingReducer, {
       epoch: coordinator.state.epoch,
-      jev: { ask: jevRuntime.ask, getMinConfidence: jevMinConfidence },
+      jev: { ask: jevRuntime.ask, getMinConfidence: () => effConfig.jev.minConfidence },
     });
   });
 
   let locksHandle = { getHeldLocks: () => [] as readonly string[] };
   if (env) {
-    locksHandle = installWriteLocks(pi, {
-      client,
-      env,
-      hard: process.env[WRITE_LOCK_ENV] === '1',
-    });
+    locksHandle = installWriteLocks(pi, { client, env, hard: process.env[WRITE_LOCK_ENV] === '1' });
   }
 
-  /* ── todo family slot (core/todo.ts fills the plugin hook; widget rendering moved with the family) ── */
-  const todoUi: TodoUiSlot = {
-    renderWidget: () => { /* No-op before plugin mounting; filled after mounting. */ },
+  /** pi's sendUserMessage is fire-and-forget (void); callers of this wrapper still get a promise. */
+  const sendUserMessageAs = (content: string, mode: 'steer' | 'followUp'): Promise<void> => {
+    (pi as unknown as { sendUserMessage?: (content: string, opts?: { deliverAs?: string; triggerTurn?: boolean }) => void })
+      .sendUserMessage?.(content, { deliverAs: mode, triggerTurn: true });
+    return Promise.resolve();
   };
 
-  /* ── Lifecycle ────────────────────────────────────────────────────── */
+  /** Phase 2 (RFC rfc-delegation-identity §3.2): a worker's progress note enters master context as
+   * a display-less custom message — no turn, no visible chat line; renderers.ts gives it a card. */
+  const deliverProgress = (workerPaneId: string, text: string): Promise<void> => {
+    (pi as unknown as {
+      sendMessage?: (msg: { customType: string; content: string; display: boolean; details?: Record<string, unknown> }, opts?: { triggerTurn?: boolean }) => void;
+    }).sendMessage?.(
+      { customType: PROGRESS_CUSTOM_TYPE, content: text.slice(0, 2000), display: false, details: { paneId: workerPaneId } },
+      { triggerTurn: false },
+    );
+    return Promise.resolve();
+  };
+  const notices = createNoticeBuffer({
+    isBusy: () => agentActive || lastStopReason === ABORT_STOP_REASON,
+    send: sendUserMessageAs,
+    // P0-2: rank collapsed batches by relevance to the master's in-progress work.
+    rank: async (contents) => {
+      if (!jevRuntime.available) return null;
+      const inProgressTodos = todos.items.filter((item) => item.status === 'in_progress').map((item) => item.content);
+      let rankedOrder: number[] | null | undefined;
+      const result = await jevRuntime.ask(
+        noticeRankRequest({ inProgressTodos, notices: [...contents] }),
+        {
+          questionId: 'notice-rank',
+          sessionId,
+          extra: { site: 'notice-rank', noticeCount: contents.length },
+          enrich: ({ answers }) => {
+            if (!answers) return {};
+            rankedOrder = composeNoticeRanking(
+              contents.length,
+              answers,
+              Math.max(effConfig.jev.minConfidence, NOTICE_RANK_MIN_CONFIDENCE),
+            );
+            const values = Array.from({ length: contents.length }, (_, i) => {
+              const rank = answers[`notice_${i}_rank`];
+              const fail = answers[`notice_${i}_fail`];
+              return rank !== undefined && fail !== undefined && rank.type === 'score' && fail.type === 'noul'
+                ? `${rank.score.toFixed(2)}:${rank.confidence.toFixed(2)}:${fail.noul.toFixed(2)}`
+                : '?';
+            });
+            return { order: rankedOrder === null ? 'fallback' : rankedOrder.join(','), values };
+          },
+        },
+      );
+      if (!result.ok) return null;
+      return rankedOrder === undefined || rankedOrder === null ? null : rankedOrder.map((index) => contents[index]!);
+    },
+  });
+  const deliverNotice = notices.deliverNotice;
+
+  /* ── pipe channel: this pane's NDJSON server + the settle fast-path push (D48/D49/D50) ── */
+  const pipeServerBox: { current: ReturnType<typeof startPipeServer> | null } = { current: null };
+  let pendingMachineRequest: MachineRequest | null = null;
+  /** Dedup latch for settle notices: one per paneId+request id per round. */
+  const settleNoticeLatch = new Set<string>();
+  function claimSettleNotice(key: string): boolean {
+    if (settleNoticeLatch.has(key)) return false;
+    settleNoticeLatch.add(key);
+    return true;
+  }
+
+  function startPipeServerFor(cwd: string): void {
+    const paneId = env?.paneId ?? '';
+    if (!paneId) return;
+    if (pipeServerBox.current) {
+      try { pipeServerBox.current.close(); } catch { /* Previous instance. */ }
+      pipeServerBox.current = null;
+    }
+    try {
+      pipeServerBox.current = startPipeServer(pipeNameFor(cwd, paneId), async (req) => handlePipeRequest(req, {
+        paneId,
+        port: subagentPort,
+        claimSettleNotice,
+        deliverNotice,
+        sendUserMessageIn: (content) => sendUserMessageAs(content, 'followUp'),
+        sendUserMessageAs,
+        abort: () => { latestCtx?.abort?.(); },
+        setPendingMachineRequest: (next) => { pendingMachineRequest = next; },
+        applyRoleSwitch: roles.applyRoleSwitch,
+        deliverProgress,
+        applyWorkerTodos,
+      }));
+    } catch {
+      /* Pipe name collision (rare): this session has no channel; callers report after ping timeout. */
+    }
+  }
+
+  async function pushSettleReply(aborted = false): Promise<void> {
+    const req = pendingMachineRequest;
+    if (!req || !req.push || !req.from) return;
+    // An aborted settle is not a settlement: OCC's abort means the continuation turn is coming, and
+    // answering now would burn the one-shot request + the parent's claim latch on a null-text reply
+    // ("left no closing message") — the real closing message then never gets delivered. Keep the
+    // request armed; the post-compaction settle pushes it (settle-wake-core.ts).
+    if (!shouldPushSettleReply({
+      intentionalAbort: coordinator.intentionalAbort,
+      aborted,
+      compactionInFlight: coordinator.compactionInFlight,
+      lastStopReason,
+    })) {
+      return;
+    }
+    pendingMachineRequest = null;
+    try {
+      const ownFile = sessionId ? resolveSessionFileValue(process.cwd(), agentSessionsDir(), sessionId) : null;
+      let text: string | null = null;
+      if (ownFile) {
+        const entries = readSessionFile(ownFile);
+        if (entries) text = lastAssistantText(entries, { sinceTs: req.sinceTs })?.text ?? null;
+      }
+      await pipeRequest(req.from, {
+        type: 'reply',
+        id: req.id,
+        paneId: env?.paneId ?? '',
+        text,
+        // Push the resolved PATH when readable; fall back to the bare id for the master-side mapping.
+        sessionFile: ownFile ?? (sessionId || null),
+      }, 5000);
+    } catch (err) {
+      /* The requester's pollLoop is the fallback; surface the dead letter for triage. */
+      console.error(`pier: settle reply push to ${req.from} failed: ${(err as Error)?.message ?? err}`);
+    }
+  }
 
   pi.on('session_start', async (event, ctx) => {
     sessionId = resolveSessionId(ctx);
+    latestCtx = ctx as { abort?: () => void } | null;
     const cwd = (ctx as { cwd?: string }).cwd ?? process.cwd();
     const isTrusted =
       typeof (ctx as { isProjectTrusted?: () => boolean }).isProjectTrusted === 'function'
@@ -357,117 +501,95 @@ export default async function (pi: ExtensionAPI) {
       (ctx as { sessionManager?: { getSessionDir?: () => string | undefined } })?.sessionManager?.getSessionDir?.(),
       sessionId,
     );
-    rebuildFromBranch(ctx);
-    // v1.3 M9 fix (observed): on resume pi restores widget state from the session;
-    // calling setWidget again breaks the TUI '/' command-panel route ('/' would be sent to the model as message text).
-    const reason = (event as { reason?: string } | undefined)?.reason;
-    if (reason !== 'resume') todoUi.renderWidget(ctx);
-    // D97: narrow-frame overlay is meaningful only inside herdr; covering an interactive narrow terminal is unsafe,
-    // and the heatmap amplification provides the exit path. Re-register on resume because session switching resets the overlay.
+    // On resume pi restores widget state from the session; calling setWidget again
+    // breaks the TUI '/' command-panel route (v1.3 M9).
+    if ((event as { reason?: string } | undefined)?.reason !== 'resume') todoUi.renderWidget(ctx);
+    // D97: narrow-frame overlay is meaningful only inside herdr; re-register (session switching resets it).
     if (env) registerSlimFrame(ctx);
+    // P2-5: resume folds todos/compaction state from the branch like session_tree; a fresh session folds nothing.
+    rebuildFromBranch(ctx);
     mirrorTodos();
-    // D-2: the session path is NOT reported here. herdr's own pi integration publishes it
-    // (agent.list/agent.pane show `session_source: "herdr:pi"` on every pi pane, incl. pier subagents),
-    // so pier's pane.report_agent_session was a pure duplicate write of the same field by a second source.
-    // D93: sidebar identity is the role name (display_agent takes precedence over detected agent, actions.rs:563 in 0.8.2).
-    // master → 'master'; worker → manifest.role (prettify worker-default as worker).
-    // A bare pi without a manifest does not report, so ordinary pi sessions remain undisturbed.
-    if (runtimeManifest) {
-      const roleDisplay = runtimeManifest.role === 'worker-default' ? 'worker' : runtimeManifest.role;
-      void client.reportDisplayAgent(roleDisplay);
-    }
-    // Tier 2: worker role manifest parsed at process start supplies the badge and authoritative session record.
-    // The custom entry mirrors D38 todo-edit and anchors execution-time replay.
-    if (runtimeManifest) {
-      roleBadge = `role ${runtimeManifest.role} v${runtimeManifest.version ?? '?'} (${runtimeManifest.tools.length} tools)`;
-      try {
-        (pi as { appendEntry?: (customType: string, data: unknown) => void }).appendEntry?.(
-          ROLE_MANIFEST_CUSTOM_TYPE,
-          { version: 1, role: runtimeManifest.role, manifestVersion: runtimeManifest.version, tools: runtimeManifest.tools, permissions: runtimeManifest.permissions, unknownTools: runtimeManifest.unknownTools ?? 'deny', ts: Date.now() },
-        );
-      } catch {
-        /* Best effort recording. */
-      }
-      // D77 visible layer: remove tools outside the manifest from the model's view after all plugins load at session_start.
-      // Intersection semantics prevent clearing everything; master without a manifest stays full. Missing APIs are skipped for old pi compatibility.
-      const piTools = pi as { getActiveTools?: () => string[]; setActiveTools?: (names: string[]) => void };
-      if (typeof piTools.getActiveTools === 'function' && typeof piTools.setActiveTools === 'function') {
+    roles.syncFromBranch(ctx);
+    if (mode.composeMaster && sessionRoot) roles.scanRoleUsage();
+    gates.report('idle', null);
+    // Self-healing: the ask marker lives in herdr with a 24h TTL; a session killed
+    // while a dialog was open must not keep the pane looking blocked forever.
+    void client.reportAskFlag(null).catch(() => {});
+    if (isSubagent) {
+      // herdr 0.9.2 restore identity: the marker re-derives worker mode for the resumed boot
+      // (resume_argv cannot carry spawn env), and the self-reported command replays this exact
+      // session — extension, role model, approve, fullscreen — instead of a bare `pi --resume`.
+      const sm = typeof ctx === 'object' && ctx !== null && 'sessionManager' in ctx ? ctx.sessionManager : undefined;
+      const sessionFile = (typeof sm?.getSessionFile === 'function' ? sm.getSessionFile() : undefined)
+        ?? process.env.PI_SESSION_FILE ?? null;
+      // RFC rfc-delegation-identity §2.1: env (spawn) > marker (herdr restart) > branch fold (/resume).
+      if (!delegation) delegation = readWorkerMarker(sessionFile)?.delegation ?? null;
+      const branchEntries = (ctx as { sessionManager?: { getBranch?: () => readonly unknown[] } })
+        ?.sessionManager?.getBranch?.() ?? [];
+      const folded = foldDelegation(branchEntries as Parameters<typeof foldDelegation>[0]);
+      if (!delegation && folded) delegation = folded;
+      if (delegation && !folded) {
+        // First-frame card: write once — the entry doubles as the /resume replay source.
         try {
-          const active = piTools.getActiveTools();
-          const vis = planActiveTools(runtimeManifest.tools, active, {
-            unknownTools: runtimeManifest.unknownTools,
-            permissions: runtimeManifest.permissions,
-          });
-          if (vis?.changed) {
-            piTools.setActiveTools?.(vis.next);
-            console.error(`[pi-herdr] D77 visible-layer: role ${runtimeManifest.role} tools ${active.length} → ${vis.next.length}`);
-          }
+          pi.appendEntry(DELEGATION_CUSTOM_TYPE, { version: 1, ...delegation, ts: Date.now() });
         } catch {
-          /* Best effort visible layer; the mandatory layer remains active. */
+          /* Best effort; the marker already carries the identity. */
         }
       }
-    }
-    reportAgent('idle', null);
-    // Self-healing: a gate does not survive a process restart, but the ask marker lives in herdr
-    // with a 24h TTL, so a session killed while a dialog was open would otherwise keep the pane
-    // looking blocked forever. Depth is 0 on session_start, so this cannot race a live gate.
-    void client.reportAskFlag(null).catch(() => {});
-  });
-
-  /* ── Tier 2 Weeks 4–5: worker execution enforcement (the manifest's final gate) ──
-   * deny / outside manifest → block (reason is given to the model); ask → v1 allows with stderr logging
-   * (V56 acceptance anchor). Master and label-only workers without a manifest remain open.
-   * Rate limiting was removed (WS-D6): we own the permission boundary; plugin integrators own resource quotas. */
-  pi.on('tool_call', async (event: { toolName?: string }) => {
-    if (!runtimeManifest) return;
-    const tool = typeof event?.toolName === 'string' ? event.toolName : '';
-    const gate = planToolGate(tool, runtimeManifest);
-    if (gate.kind === 'deny') {
-      // terminate (pi 0.84.1+) stops a batch whose results are all terminating without another
-      // model call, so a blocked worker tool no longer costs an extra round trip.
-      return { block: true, reason: gate.reason, terminate: true };
-    }
-    if (gate.kind === 'ask') {
-      console.error(`${gate.notice} (v1 soft-approval: allowed, hard gate lands in v2)`);
-      // Durable trace (V56 anchor): TUI redraw erases stderr, so the session custom entry is authoritative.
-      try {
-        (pi as { appendEntry?: (customType: string, data: unknown) => void }).appendEntry?.(
-          APPROVAL_NEEDED_CUSTOM_TYPE,
-          { role: runtimeManifest.role, tool, ts: Date.now() },
-        );
-      } catch {
-        /* Best effort. */
+      if (delegation) void client.reportDelegationTokens(delegation).catch(() => {});
+      if (sessionRoot) {
+        writeWorkerMarker(sessionFile, roles.state.manifest?.role, delegation ?? undefined);
+        const resumeArgv = buildResumeArgv(process.argv);
+        if (resumeArgv && client.available) {
+          void client.reportAgentSessionResume(sessionId, resumeArgv).catch(() => {});
+        }
       }
     }
+
+    // Focus heat is event-driven on herdr 0.9.5+: the workbench receives pane.focused directly,
+    // so no per-pane layout sampler is started here.
+    startPipeServerFor(cwd);
   });
 
+  /* RFC rfc-delegation-identity §2.2: worker identity + delivery contract ride the prompt
+   * sections each turn (same diff discipline as pier-role; removal cleans up). */
+  if (isSubagent) {
+    pi.on('before_agent_start', async (event) => {
+      const sections = event.systemPromptOptions?.sections;
+      if (!sections) return;
+      if (delegation) {
+        const text = buildDelegationSection(delegation, env?.paneId ?? '');
+        if (sections['pier-delegation'] !== text) sections['pier-delegation'] = text;
+      } else {
+        delete sections['pier-delegation'];
+      }
+    });
+  }
 
-  // Session-tree navigation (/tree, /fork): reconstruction preserves branch correctness.
   pi.on('session_tree', async (_event, ctx) => {
     sessionId = resolveSessionId(ctx);
     rebuildFromBranch(ctx);
+    // pi reverts the transcript loadout at the navigated branch point; the role
+    // runtime follows the same point (same-origin, RFC §4.3).
+    roles.syncFromBranch(ctx);
     todoUi.renderWidget(ctx);
     mirrorTodos();
   });
 
-  let agentActive = false;
-  const subagentPort = emptySubagentPortBox();
-  // D96 state, anchoring settle-wake-core deduplication and cooldown.
-  let d96NoticeKey: string | null = null;
-  let d96NoticeAt = 0;
-  // Prevent wake-up storms by tracking the last assistant turn's stopReason;
-  // 'aborted' means the user explicitly pressed ESC, so settlement must inject no wake-up message.
-  let lastStopReason: string | null = null;
+  /* pi 1.2 counts the run as busy from `before_agent_start`, not `turn_start`: a settlement
+   * notice arriving in that window must enter the D92 buffer instead of being sent immediately. */
+  pi.on('before_agent_start', async () => {
+    agentActive = true;
+  });
+
   pi.on('turn_start', async () => {
     agentActive = true;
-    // Why (A11): Reset lastStopReason on turn_start so a previous turn's abort
-    // does not taint subsequent turns or suppress settlement wake / notice flush.
+    // A11: reset so a previous turn's abort cannot taint this one.
     lastStopReason = null;
-    // Safety fallback: if previous compaction finished without clean callback settlement,
-    // ensure flags are reset. Pi core prohibits prompts while compaction is active, so this is safe.
+    // Safety fallback: pi core prohibits prompts while compaction is active.
     coordinator.compactionInFlight = false;
     coordinator.intentionalAbort = false;
-    reportAgent('working', currentActivity(todos.items));
+    gates.report('working', currentActivity(todos.items));
   });
 
   pi.on('before_provider_request', (_event: unknown, ctx: unknown) => {
@@ -486,29 +608,37 @@ export default async function (pi: ExtensionAPI) {
   pi.on('session_before_tree', () => (coordinator.compactionInFlight ? { cancel: true } : undefined));
 
   pi.on('turn_end', async (event: unknown, ctx) => {
-    if (event === null || typeof event !== 'object' || !('message' in event)) return;
-    const msg = (event as { message: unknown }).message; // 'message' in has been guarded.
-    if (msg === null || typeof msg !== 'object') return;
-    const { role, stopReason } = msg as { role?: unknown; stopReason?: unknown };
-    if (role === 'assistant' && typeof stopReason === 'string') {
-      lastStopReason = stopReason;
-    }
-    if (ctx && typeof ctx === 'object') {
-      coordinator.onTurnEnd({
-        ctx,
-        todos: todos.items,
-        config: effConfig.onlineContextCompact,
-        cancelReminder: todoUi.cancelReminder,
-      });
+    // Master registered this twice: the lifecycle handler skipped malformed events, the notice
+    // flush ran regardless. The merged handler keeps both semantics.
+    const msg = event !== null && typeof event === 'object' && 'message' in event ? (event as { message: unknown }).message : null;
+    if (msg !== null && typeof msg === 'object') {
+      const { role, stopReason } = msg as { role?: unknown; stopReason?: unknown };
+      if (role === 'assistant' && typeof stopReason === 'string') {
+        lastStopReason = stopReason;
+      }
+      if (ctx && typeof ctx === 'object') {
+        coordinator.onTurnEnd({
+          ctx,
+          todos: todos.items,
+          config: effConfig.onlineContextCompact,
+          cancelReminder: todoUi.cancelReminder,
+        });
+      }
     }
+    void notices.flush('steer');
   });
 
-  pi.on('agent_settled', async (_event: unknown, ctx) => {
+  pi.on('agent_settled', async (event: unknown, ctx) => {
     agentActive = false;
-    reportAgent('idle', null);
+    gates.report('idle', null);
+    // pi ≥ 1.1 stamps cancelled runs on the event itself; stopReason tracking misses ESC mid-tool
+    // (no final assistant message), so the event field is authoritative when present.
+    const aborted = event !== null && typeof event === 'object' && 'aborted' in event && event.aborted === true;
     const plan = planSettleWake({
       lastStopReason,
       intentionalAbort: coordinator.intentionalAbort,
+      aborted,
+      compactionPending: coordinator.selectedCompaction !== null || coordinator.compactionInFlight,
       running: subagentPort.current?.listRunningSubs() ?? [],
       lastNoticeKey: d96NoticeKey,
       lastNoticeAt: d96NoticeAt,
@@ -516,19 +646,14 @@ export default async function (pi: ExtensionAPI) {
     });
     d96NoticeKey = plan.noticeKey;
     d96NoticeAt = plan.noticeAt;
-    if (!plan.wake) {
-      // Stay silent after a user abort while retaining the settlement buffer (do not clear pendingSettleNotices);
-      // deliver it on the next natural run's turn_end steer or natural settlement.
-      return;
-    }
     // D96: master settled while background subagents still run → remind (worker port is unbound).
-    if (plan.notice && !isSubagent) {
+    if (plan.wake && plan.notice && !isSubagent) {
       const running = subagentPort.current?.listRunningSubs() ?? [];
       const brief = running.map((s) => `${s.paneId} (${s.description})`).join('、');
       const notice = `注意：仍有 ${running.length} 个后台 subagent 在运行：${brief}。若你的任务依赖它们，请等待其结算（subagent list 查看状态）；若不等待，请说明放弃原因。`;
-      void sendUserMessageIn(notice);
+      void sendUserMessageAs(notice, 'followUp');
     }
-    if (ctx && typeof ctx === 'object') {
+    if (plan.compact && ctx && typeof ctx === 'object') {
       void coordinator.onAgentSettled({
         ctx,
         todos: todos.items,
@@ -537,117 +662,21 @@ export default async function (pi: ExtensionAPI) {
         cancelReminder: todoUi.cancelReminder,
         onBeforeCompact: createCompactionBatchPackHook({
           getObsConfig: () => effConfig.observationPack,
-          getManifest: () => runtimeManifest,
+          getManifest: () => roles.state.manifest,
           getSessionId: () => sessionId,
           pickMiddleExcerpt,
         }),
       });
     }
+    if (lastStopReason !== ABORT_STOP_REASON && !aborted) void notices.flush('followUp');
+    void pushSettleReply(aborted);
   });
 
-  // Official herdr:pi is full-lifecycle authority when installed: it reports blocked
-  // only on the herdr:blocked event (pi core never emits it). Custom source=pi-herdr
-  // pane.report_agent is ignored while that authority is live
-  // (screen_detection_skip_reason=full_lifecycle_hook_authority). Emit the event so
-  // herdr:pi publishes blocked; keep report_agent as fallback when it is absent.
-  /**
-   * Open one human gate. Nested gates (pier's ask tool plus pi's own ctx.ui prompt, or an
-   * external herdr:blocked producer) are coalesced: only the 0→1 transition reports blocked,
-   * marks the ask flag and folds the widget. Returns true when this call opened the outer gate.
-   */
-  function enterBlocked(label: string | null): boolean {
-    blockedDepth += 1;
-    if (blockedDepth > 1) return false;
-    reportAgent('blocked', label);
-    // D95: human-gate marker lets the workbench heatmap distinguish ask from block.
-    if (label) void client.reportAskFlag(label).catch(() => {});
-    // Gate open collapses the todo widget to one line — the question owns the fixed area.
-    todoUi.rerenderWidget?.();
-    return true;
-  }
-  /** Close one gate; only the 1→0 transition restores the pre-gate state. Returns true when closed.
-   *  An unmatched release (no gate open) is ignored rather than reported, so a stray
-   *  ui_prompt_end cannot emit a false "no longer blocked" edge. */
-  function exitBlocked(): boolean {
-    if (blockedDepth === 0) return false;
-    blockedDepth -= 1;
-    // Gate closed → restore the full widget window.
-    todoUi.rerenderWidget?.();
-    if (blockedDepth > 0) return false;
-    reportAgent(agentActive ? 'working' : 'idle', agentActive ? currentActivity(todos.items) : null);
-    // D95: gate released → clear marker.
-    void client.reportAskFlag(null).catch(() => {});
-    return true;
-  }
-
-  // emit() is synchronous; this flag stops our own listener from double-counting depth.
-  let publishingHerdrBlocked = false;
-  /** Publish the herdr:blocked edge for pi-herdr's own gates; no-op re-entry is prevented by the flag. */
-  function emitHerdrBlocked(active: boolean, label: string | null): void {
-    publishingHerdrBlocked = true;
-    try {
-      pi.events.emit(
-        'herdr:blocked',
-        active ? { active: true, ...(label ? { label } : {}) } : { active: false },
-      );
-    } finally {
-      publishingHerdrBlocked = false;
-    }
-  }
-  function publishHerdrBlocked(active: boolean, label: string | null): void {
-    if (active) enterBlocked(label);
-    else exitBlocked();
-    emitHerdrBlocked(active, label);
-  }
-  pi.events.on('herdr:blocked', (data) => {
-    if (publishingHerdrBlocked) return;
-    if (!data || typeof data !== 'object') {
-      exitBlocked();
-      return;
-    }
-    if (!('active' in data) || data.active !== true) {
-      exitBlocked();
-      return;
-    }
-    enterBlocked('label' in data && typeof data.label === 'string' ? data.label : null);
-  });
-
-  /* ── Generic human-gate reporting (pi 0.84.4+) ─────────────────────────
-   * Why: `ui_prompt_start` / `ui_prompt_end` fire around blocking ctx.ui dialogs.
-   * Scope: only the inherently human-blocking kinds (select / confirm / input / editor).
-   * `custom` is deliberately excluded: pi routes both modals and *persistent overlays*
-   * through ctx.ui.custom, and pier itself registers a resident slim-frame overlay that
-   * never calls done() — treating it as a gate left the pane blocked (and the ask marker
-   * set) for the entire session while the agent kept working. Note that a resident overlay
-   * also holds pi's own prompt span open, so these events generally stop firing in herdr
-   * panes anyway; pier's ask tool opens its gate explicitly and is the reliable path there.
-   * Probed through a structural type because the events postdate our pinned pi devDependency. */
-  const uiPromptEvents = pi as unknown as {
-    on?: (name: 'ui_prompt_start' | 'ui_prompt_end', handler: (event: unknown) => void) => void;
-  };
-  const GATING_PROMPT_KINDS = new Set(['select', 'confirm', 'input', 'editor']);
-  uiPromptEvents.on?.('ui_prompt_start', (event) => {
-    const rec = (event ?? {}) as { kind?: unknown; title?: unknown };
-    const title = typeof rec.title === 'string' && rec.title.trim() ? rec.title.trim() : null;
-    const kind = typeof rec.kind === 'string' ? rec.kind : 'prompt';
-    if (!GATING_PROMPT_KINDS.has(kind)) return;
-    // Normalize once so the gate report and the published edge carry the same label.
-    const label = title ?? kind;
-    // The ask tool opens its own gate first, so this is usually a nested (no-op) transition;
-    // prompts from other extensions or pi core open the gate here.
-    if (enterBlocked(label)) emitHerdrBlocked(true, label);
-  });
-  uiPromptEvents.on?.('ui_prompt_end', () => {
-    if (exitBlocked()) emitHerdrBlocked(false, null);
-  });
-
-  /* ── Tool: ask_user_question (v1.3 M8 human gate, available to master and subagents) ── */
-
-  /* ── D101: ObservationPack (obs_recall tool & context projector) ── */
+  /* ── D101 ObservationPack (obs_recall tool & context projector) ── */
   registerObservationPack({
     pi,
     getConfig: () => effConfig,
-    getRuntimeManifest: () => runtimeManifest,
+    getRuntimeManifest: () => roles.state.manifest,
     pickMiddleExcerpt,
     getRemainingHorizon: () => {
       const usage = (latestCtx as { getContextUsage?: () => { contextWindow?: number } })?.getContextUsage?.();
@@ -655,10 +684,6 @@ export default async function (pi: ExtensionAPI) {
     },
   });
 
-  /* ── D104: /pier-config (read-only config guide + guided-change handoff) ──
-   * Supersedes the former /efficiency command: the index line reports OCC/OBS/EPR state and
-   * `show efficiency` lists every D100-D103 knob with its effective value and source. */
-
   installConfigCommand({ pi });
   installDashboardCommand({
     pi,
@@ -666,8 +691,10 @@ export default async function (pi: ExtensionAPI) {
     env,
     getTodoItems: () => todos.items,
     getHeldLocks: () => locksHandle.getHeldLocks(),
+    prepareTree: () => publishTreeSnapshot(),
   });
 
+  /* ── ask_user_question (v1.3 M8 human gate; master and subagents) ── */
   pi.registerTool({
     name: ASK_TOOL_NAME,
     label: 'Ask User',
@@ -679,184 +706,85 @@ export default async function (pi: ExtensionAPI) {
       if (!prepared.ok) return prepared.result;
       const ui = ctx && typeof ctx === 'object' && 'ui' in ctx ? ctx.ui : undefined;
       if (!hasAskUi(ui)) return noUiResult();
-      const label = gateLabel(prepared.spec);
-      publishHerdrBlocked(true, label);
-      // The gate stays reported for the whole wait: reportAgent() drops working/idle reports while
-      // blockedDepth > 0, and pi's ui_prompt_start/end events keep the depth honest for prompts
-      // that do not come from this tool. (The old 5s refresh interval is obsolete.)
+      gates.publish(true, gateLabel(prepared.spec));
+      // The gate stays reported for the whole wait: gates.report drops
+      // working/idle while blocked, and pi's ui_prompt events keep the depth honest.
       try {
         return await runAsk(prepared.spec, ui, signal instanceof AbortSignal ? signal : undefined);
       } finally {
-        publishHerdrBlocked(false, null);
+        gates.publish(false, null);
       }
     },
   });
 
+  /* ── report_progress (Phase 2, RFC rfc-delegation-identity §3.2): worker → master checkpoint ── */
+  if (isSubagent) {
+    pi.registerTool({
+      name: 'report_progress',
+      label: 'Report Progress',
+      description:
+        'Send the delegating master a short progress update without finishing the task. Use at meaningful checkpoints (a module done, a test went green, a blocker found) — the master sees it in its context but is not interrupted.',
+      promptSnippet: 'report_progress: mid-task checkpoint to the delegating master (does not end the task).',
+      promptGuidelines: [
+        'Call at meaningful checkpoints only — a milestone reached, a risk discovered, a decision the master should know early — not after every tool call.',
+        'One or two sentences per call; the final answer still goes in your normal closing message when the task finishes.',
+      ],
+      parameters: Type.Object({
+        message: Type.String({ description: 'Short checkpoint update for the delegating master.' }),
+      }),
+      async execute(_tc, params) {
+        const parentPipe = delegation?.parentPipe;
+        const message = typeof (params as { message?: unknown })?.message === 'string'
+          ? (params as { message: string }).message.trim()
+          : '';
+        if (!message) {
+          return { content: [{ type: 'text', text: 'Error: `message` is required (one or two sentences).' }], details: {} };
+        }
+        if (!parentPipe) {
+          return { content: [{ type: 'text', text: 'Error: no delegating master pipe is known to this session; progress cannot be delivered.' }], details: {} };
+        }
+        try {
+          const res = await pipeRequest(parentPipe, {
+            type: 'progress',
+            id: `prog-${Date.now()}`,
+            paneId: env?.paneId ?? '',
+            text: message,
+          }, 5000);
+          return res.type === 'ok'
+            ? { content: [{ type: 'text', text: 'Progress delivered to the master (visible in its context, no interruption).' }], details: {} }
+            : { content: [{ type: 'text', text: `Error: master rejected progress report: ${res.message}` }], details: {} };
+        } catch (err) {
+          return { content: [{ type: 'text', text: `Error: could not reach the master pipe: ${(err as Error)?.message ?? err}` }], details: {} };
+        }
+      },
+    });
+  }
+
   pi.on('session_shutdown', async () => {
     coordinator.compactionInFlight = false;
     coordinator.intentionalAbort = false;
+    if (pipeServerBox.current) {
+      try { pipeServerBox.current.close(); } catch { /* Already closed. */ }
+      pipeServerBox.current = null;
+    }
     if (sessionRoot) {
       try {
         await pruneSessionObjects(sessionRoot);
       } catch {
-        /* ignore shutdown pruning errors */
       }
     }
-    client.close();
-  });
-
-  /* ── M12: bidirectional message channel (D49/D50/D48; every pane listens on its own name, with no controller/child assumption) ── */
-
-  const settleNoticeLatch = new Set<string>();
-  /** Deduplicate settlement notices: choose push fast path or pollLoop fallback; one notice per paneId+request ID per round. */
-  function claimSettleNotice(key: string): boolean {
-    if (settleNoticeLatch.has(key)) return false;
-    settleNoticeLatch.add(key);
-    return true;
-  }
-  const pipeServerBox: { current: ReturnType<typeof startPipeServer> | null } = { current: null };
-  /** D-4: focus sampler for this pane (started on session_start, stopped on session_shutdown). */
-  const sessionFocusPoller: { current: FocusPoller | null } = { current: null };
-  let pendingMachineRequest: { id: string; from: string | null; push: boolean; sinceTs: number } | null = null;
-  let latestCtx: { abort?: () => void } | null = null;
-
-  // triggerTurn:true — idle followUp must start a new turn or settlement is lost.
-  const sendUserMessageIn = (content: string): Promise<void> =>
-    (pi as unknown as { sendUserMessage?: (content: string, opts?: { deliverAs?: string; triggerTurn?: boolean }) => Promise<void> })
-      .sendUserMessage?.(content, { deliverAs: 'followUp', triggerTurn: true }) ?? Promise.resolve();
-  const sendUserMessageAs = (content: string, mode: 'steer' | 'followUp'): Promise<void> =>
-    (pi as unknown as { sendUserMessage?: (content: string, opts?: { deliverAs?: string; triggerTurn?: boolean }) => Promise<void> })
-      .sendUserMessage?.(content, { deliverAs: mode, triggerTurn: true }) ?? Promise.resolve();
-
-  const notices = createNoticeBuffer({
-    isBusy: () => agentActive || lastStopReason === ABORT_STOP_REASON,
-    send: sendUserMessageAs,
-    // P0-2: rank collapsed batches by relevance to the master's in-progress work
-    rank: async (contents) => {
-      if (!jevRuntime.available) return null;
-      const inProgressTodos = todos.items
-        .filter((item) => item.status === 'in_progress')
-        .map((item) => item.content);
-      let rankedOrder: number[] | null | undefined;
-      const result = await jevRuntime.ask(
-        noticeRankRequest({ inProgressTodos, notices: [...contents] }),
-        {
-          questionId: 'notice-rank',
-          sessionId,
-          extra: { site: 'notice-rank', noticeCount: contents.length },
-          enrich: ({ answers }) => {
-            if (!answers) return {};
-            rankedOrder = composeNoticeRanking(
-              contents.length,
-              answers,
-              Math.max(effConfig.jev.minConfidence, NOTICE_RANK_MIN_CONFIDENCE),
-            );
-            const values = Array.from({ length: contents.length }, (_, i) => {
-              const rank = answers[`notice_${i}_rank`];
-              const fail = answers[`notice_${i}_fail`];
-              return rank !== undefined && fail !== undefined && rank.type === 'score' && fail.type === 'noul'
-                ? `${rank.score.toFixed(2)}:${rank.confidence.toFixed(2)}:${fail.noul.toFixed(2)}`
-                : '?';
-            });
-            return { order: rankedOrder === null ? 'fallback' : rankedOrder.join(','), values };
-          },
-        },
-      );
-      if (!result.ok) return null;
-      return rankedOrder === undefined || rankedOrder === null ? null : rankedOrder.map((index) => contents[index]!);
-    },
-  });
-  const deliverNotice = notices.deliverNotice;
-  pi.on('turn_end', () => {
-    void notices.flush('steer');
-  });
-  pi.on('agent_settled', () => {
-    if (lastStopReason === ABORT_STOP_REASON) return;
-    void notices.flush('followUp');
-  });
-
-  pi.on('session_start', async (_event, ctx) => {
-    latestCtx = ctx as { abort?: () => void } | null;
-    const cwd = (ctx as { cwd?: string }).cwd ?? process.cwd();
-    const paneId = env?.paneId ?? '';
-    // D-4: herdr 0.9.0 never delivered pane.focused to plugins; 0.9.1+ does. Poller is a
-    // fallback for old servers (see resolveDefaultFocusPollMs). One poller per pane, self-scoped.
-    if (sessionFocusPoller.current) {
-      sessionFocusPoller.current.stop();
-      sessionFocusPoller.current = null;
-    }
-    const serverVer = await client.getServerVersion();
-    const pollMs = focusPollIntervalMs(process.env, serverVer);
-    if (paneId && client.available && pollMs > 0) {
-      sessionFocusPoller.current = startFocusPoller({
-        myPaneId: paneId,
-        intervalMs: pollMs,
-        sample: async () => {
-          // layout.export reports the focused pane of our own tab. Without that field (older herdr)
-          // the tick stays silent instead of guessing focus from the tree.
-          const layout = await client.exportLayout({ paneId });
-          const sample = parseFocusSample(layout);
-          return sample && sample.focusedPaneId !== null ? sample : null;
-        },
-        fire: (focusedPaneId, cause) => spawnReflow({ paneId: focusedPaneId, cause }),
-      });
-    }
-    if (!paneId) return;
-    const name = pipeNameFor(cwd, paneId);
-    if (pipeServerBox.current) {
-      try { pipeServerBox.current.close(); } catch { /* Previous instance. */ }
-      pipeServerBox.current = null;
-    }
-    try {
-      pipeServerBox.current = startPipeServer(name, async (req) => handlePipeRequest(req, {
-        paneId,
-        port: subagentPort,
-        claimSettleNotice,
-        deliverNotice,
-        sendUserMessageIn,
-        sendUserMessageAs,
-        abort: () => { latestCtx?.abort?.(); },
-        setPendingMachineRequest: (next) => { pendingMachineRequest = next; },
-      }));
-    } catch {
-      /* Pipe name collision (rare): this session has no channel; callers report an error after ping times out. */
-    }
-  });
-  pi.on('session_shutdown', () => {
-    sessionFocusPoller.current?.stop();
-    sessionFocusPoller.current = null;
-    if (pipeServerBox.current) {
-      try { pipeServerBox.current.close(); } catch { /* Already closed. */ }
-      pipeServerBox.current = null;
-    }
-  });
-
-  // D50: when this pane settles, push a summary and session path to any machine request awaiting a reply.
-  pi.on('agent_settled', async () => {
-    const req = pendingMachineRequest;
-    if (!req || !req.push || !req.from) return;
-    pendingMachineRequest = null;
-    try {
-      let text: string | null = null;
-      if (sessionId && /\.jsonl$/.test(sessionId)) {
-        const entries = readSessionFile(sessionId);
-        if (entries) text = lastAssistantText(entries, { sinceTs: req.sinceTs })?.text ?? null;
+    if (treeSnapshot) {
+      try {
+        unlinkSync(treeSnapshot.path);
+      } catch {
+        /* Already swept. */
       }
-      await pipeRequest(req.from, {
-        type: 'reply',
-        id: req.id,
-        paneId: env?.paneId ?? '',
-        text,
-        sessionFile: sessionId || null,
-      }, 5000);
-    } catch {
-      /* Push failed silently; the requester's pollLoop is the fallback. */
+      treeSnapshot = null;
     }
+    client.close();
   });
 
-  /* Workbench plugins (subagent/terminal + cordis) are herdr-master only.
-   * Bare pi and worker panes mount todo only so unused tools never appear.
-   * Dynamic import: worker/bare-pi must never load bootstrap/subagent-scope (C3). */
+  /* ── master vs worker mount (dynamic: workers never load the cordis tree, C3) ── */
   if (mode.composeMaster) {
     const { mountMasterPlugins } = await import('./index-master.ts');
     await mountMasterPlugins({
@@ -872,13 +800,76 @@ export default async function (pi: ExtensionAPI) {
       deliverNotice,
       noticePending: notices.noticePending,
       getSessionId: () => sessionId,
-      getBlockedDepth: () => blockedDepth,
+      getBlockedDepth: () => gates.depth(),
+      getWorkers: widgetWorkers,
       reconcileOnSettlement,
       withReconcileNotes,
       claimSettleNotice,
       isCompactionInFlight: () => coordinator.compactionInFlight,
       isIntentionalAbort: () => coordinator.intentionalAbort,
+      jev: { ask: (request, meta) => jevRuntime.ask(request, meta), getMinConfidence: () => effConfig.jev.minConfidence },
+      appendRoutingLog,
     });
+
+    /* ── /pier-tree (D113): full todo × subagent delegation tree; the resident widget is minimal ── */
+    pi.registerCommand('pier-tree', {
+      description: 'Show the full delegation tree: your todos plus every subagent\'s todos and settled nodes',
+      handler: async (args: unknown, ctx: unknown) => {
+        const ui = (ctx as { ui?: { notify?: (text: string, level?: string) => void } }).ui;
+        const lines = renderTreeLines();
+        const overlay = typeof args === 'string' && args.trim().toLowerCase() === 'overlay';
+
+        if (client.available && env) {
+          const treeFile = publishTreeSnapshot();
+          if (overlay) {
+            try {
+              const res = await client.openPluginPane({
+                pluginId: 'pier.workbench',
+                entrypoint: 'tree',
+                placement: 'overlay',
+                focus: true,
+                env: { PIER_PANEL: 'tree', PIER_TREE_FILE: treeFile },
+              });
+              if (res.mode === 'pane') return;
+            } catch {
+              // Plugin missing / older herdr: fall back to the in-pane notify view below.
+            }
+          } else {
+            const res = await openPierPanel({ client, env }, { panel: 'tree', treeFile });
+            if (res === 'popup') return;
+            if (res === 'tab') {
+              ui?.notify?.('Herdr < 0.9.1: Pier Tree opened in new tab', 'info');
+              return;
+            }
+            if (res === 'busy') {
+              ui?.notify?.('Another popup is already open — close it and run /pier-tree again.', 'warning');
+              return;
+            }
+          }
+          // 'unavailable' / failed overlay → the old in-pane view.
+        }
+        treeSnapshot = null;
+        ui?.notify?.(lines.join('\n'), 'info');
+      },
+    });
+
+    /** D113 resync: a resumed master rebuilds worker summaries from herdr pi-todo tokens until the
+     * next live push replaces them with full lists. */
+    const resyncWorkerTodos = async (): Promise<void> => {
+      try {
+        const agents = await client.listAgents();
+        for (const a of agents) {
+          const summary = a.tokens?.['pi-todo'];
+          if (typeof summary === 'string' && summary && !workerTodos.has(a.paneId)) {
+            workerTodos.set(a.paneId, { summary, ts: Date.now() });
+          }
+        }
+        todoUi.rerenderWidget?.();
+      } catch {
+        /* herdr absent or unreachable: live pushes remain the source */
+      }
+    };
+    pi.on('session_start', () => { void resyncWorkerTodos(); });
   } else {
     const { mountTodoOnly } = await import('./index-worker.ts');
     await mountTodoOnly({
@@ -886,12 +877,12 @@ export default async function (pi: ExtensionAPI) {
       todos,
       todoUi,
       mirrorTodos,
-      getBlockedDepth: () => blockedDepth,
+      getBlockedDepth: () => gates.depth(),
       ...(isSubagent
         ? {}
         : {
             stopReminder: {
-              getBlockedDepth: () => blockedDepth,
+              getBlockedDepth: () => gates.depth(),
               getRunningSubs: () => subagentPort.current?.listRunningSubs().length ?? 0,
               isCompactionInFlight: () => coordinator.compactionInFlight,
               isIntentionalAbort: () => coordinator.intentionalAbort,