pi-pier 0.2.7 → 0.3.1

package/src/index.ts

@@ -1,18 +1,13 @@
 /**
- * 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 {
@@ -27,149 +22,174 @@ import {
   runAsk,
 } from './ask-user.ts';
 import { pipeNameFor, pipeRequest, startPipeServer } from './pipe-channel.ts';
-import {
-  TODO_EDIT_CUSTOM_TYPE,
-  currentActivity,
-} from './todo-core.ts';
-
-/** Tier 2: record the synthesized manifest that governed a worker session (D38-compatible and branch-replayable). */
-const ROLE_MANIFEST_CUSTOM_TYPE = 'pi-herdr.role-manifest';
-
+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 { 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 { emptySubagentPortBox } from './subagent-core.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 './plugins/observation.ts';
+import { createJevRuntime } from './jev-client.ts';
+import {
+  NOTICE_RANK_MIN_CONFIDENCE,
+  buildExcerptWindows,
+  composeNoticeRanking,
+  evaluateExcerptPick,
+  excerptAskIsSafe,
+  excerptPickRequest,
+  noticeRankRequest,
+} from './jev-core.ts';
+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 { 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 { resolveDefaultFocusPollMs, parseFocusSample, spawnReflow, startFocusPoller, type FocusPoller } from './focus-poller.ts';
+import { composeMasterRuntime, createRoleRuntime } from './index-roles.ts';
+import { createGateRuntime } from './index-gates.ts';
+
+/** D-4: PIER_FOCUS_POLL_MS=0 disables the poller; invalid values fall back to the version default. */
+function focusPollIntervalMs(env: NodeJS.ProcessEnv = process.env, herdrVersion?: string | null): number {
+  const defaultMs = resolveDefaultFocusPollMs(herdrVersion);
+  const ms = Number(env.PIER_FOCUS_POLL_MS);
+  return env.PIER_FOCUS_POLL_MS !== undefined && env.PIER_FOCUS_POLL_MS.trim() !== '' && Number.isFinite(ms) && ms >= 0
+    ? ms
+    : defaultMs;
+}
 
-/**
- * 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;
-  }
+function agentSessionsDir(): string {
+  return process.env.PI_CODING_AGENT_DIR ? join(process.env.PI_CODING_AGENT_DIR, 'sessions') : platformPaths.sessionsDir;
 }
-// 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 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 ?? '';
-  /** M16: completion timestamps used as rate-estimation input, appended with todo.completed events. */
-  const completedStamps: number[] = [];
-
-  /* ── State reconstruction (branch correctness comes from the last todo_write snapshot on the branch) ── */
-
-  function rebuildFromBranch(ctx: unknown): void {
-    try {
-      const entries = (ctx as { sessionManager?: { getBranch?: () => readonly unknown[] } })
-        ?.sessionManager?.getBranch?.() ?? [];
-      todos.rebuild(entries);
-    } catch {
-      // A reconstruction failure must not disrupt the main flow; the next todo_write re-anchors state.
-    }
-  }
+  let sessionRoot: string | null = null;
+  let effConfig: EfficiencyConfig = resolveEfficiencyConfig();
+  const coordinator = new CompactCoordinator();
+  const { client, env } = createHerdrClient();
 
-  /* ── herdr reporting (zero cost for Noop; silent failures never affect pi's main flow) ── */
+  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(() => {});
+  };
 
-  /** 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;
+  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; // 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',
+      extra: { site: 'obs-excerpt', candidates: windows.map((w) => w.id) },
+      enrich: ({ answers }) => {
+        if (!answers || answers.window === undefined || answers.window.type !== 'choice') return {};
+        return { picked: answers.window.choice, confidence: answers.window.confidence };
+      },
+    });
+    if (!result.ok) return null;
+    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;
+  };
 
-  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(() => {});
+  const rendererTypes = installRenderers(pi);
+  if (process.env.PI_HERDR_TRACE) {
+    console.error(`[pi-herdr] transcript renderers: ${rendererTypes.length ? rendererTypes.join(', ') : 'none'}`);
   }
 
-  function reportSession(path: string): void {
-    if (!client.available) return;
-    client.reportAgentSession(path).catch(() => {});
-  }
+  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;
 
-  /** Session identity: sessionManager is authoritative (env may be unset in print/RPC mode), with env as fallback. */
+  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),
+  });
+
+  /** Session identity: sessionManager is authoritative (env may be unset in print/RPC mode). */
   function resolveSessionId(ctx: unknown): string {
     try {
       const sm = (ctx as {
-        sessionManager?: {
-          getSessionFile?: () => string | undefined;
-          getSessionId?: () => string;
-        };
+        sessionManager?: { getSessionFile?: () => string | undefined; getSessionId?: () => string };
       }).sessionManager;
-      return (
-        sm?.getSessionFile?.() ??
-        sm?.getSessionId?.() ??
-        process.env.PI_SESSION_FILE ??
-        process.env.PI_SESSION_ID ??
-        ''
+      return bareSessionId(
+        sm?.getSessionFile?.() ?? sm?.getSessionId?.() ?? process.env.PI_SESSION_FILE ?? process.env.PI_SESSION_ID ?? '',
       );
     } catch {
-      return process.env.PI_SESSION_FILE ?? '';
+      return bareSessionId(process.env.PI_SESSION_FILE ?? '');
+    }
+  }
+
+  /** Branch reconstruction: todos + OCC debt state (branch correctness from the last snapshot on the branch). */
+  function rebuildFromBranch(ctx: unknown): void {
+    try {
+      const entries = (ctx as { sessionManager?: { getBranch?: () => readonly unknown[] } })
+        ?.sessionManager?.getBranch?.() ?? [];
+      todos.rebuild(entries);
+      coordinator.rebuildFromBranch(entries);
+    } catch {
+      /* 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 = formatPaneTitle(todos.items, null, { progressSuffix: suffix, lastWriteAt: todos.lastWriteAt });
     updateSlimFrame({ title, items: todos.items, lastWriteAt: todos.lastWriteAt });
     client.reportMetadata({
       session: label,
@@ -179,8 +199,7 @@ export default async function (pi: ExtensionAPI) {
     }).catch(() => {});
   }
 
-  /* ── M17: automatic settlement reconciliation (pure planner + D38 authority; idempotent and safe to run through both paths) ── */
-
+  /** M17 settlement reconciliation: auto-complete settled todos / unblock on failure notes (idempotent). */
   function reconcileOnSettlement(description: string, outcome: 'settled' | 'failed'): string[] {
     if (!description) return [];
     try {
@@ -192,9 +211,8 @@ 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);
+        todos.applyEdits(plan.edits, { source: 'reconcile' });
         mirrorTodos();
       }
       return plan.noteLines;
@@ -203,29 +221,25 @@ 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 }) => {
+  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);
@@ -239,135 +253,253 @@ export default async function (pi: ExtensionAPI) {
     }
   });
 
-  if (env) {
-    installWriteLocks(pi, {
-      client,
-      env,
-      hard: process.env[WRITE_LOCK_ENV] === '1',
+  /* ── 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: () => effConfig.jev.minConfidence },
     });
+  });
+
+  let locksHandle = { getHeldLocks: () => [] as readonly string[] };
+  if (env) {
+    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();
   };
+  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;
 
-  /* ── Lifecycle ────────────────────────────────────────────────────── */
+  /* ── 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;
+  }
 
-  pi.on('session_start', async (event, ctx) => {
-    sessionId = resolveSessionId(ctx);
-    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.
-    if (env) registerSlimFrame(ctx);
-    mirrorTodos();
-    reportSession(sessionId);
-    // 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);
+  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;
     }
-    // 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') {
-        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}`);
-          }
-        } catch {
-          /* Best effort visible layer; the mandatory layer remains active. */
-        }
-      }
+    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,
+      }));
+    } catch {
+      /* Pipe name collision (rare): this session has no channel; callers report after ping timeout. */
     }
-    reportAgent('idle', null);
-  });
+  }
 
-  /* ── 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') {
-      return { block: true, reason: gate.reason };
+  async function pushSettleReply(): 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,
+      compactionInFlight: coordinator.compactionInFlight,
+      lastStopReason,
+    })) {
+      return;
     }
-    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?.(
-          'pi-herdr.approval-needed',
-          { role: runtimeManifest.role, tool, ts: Date.now() },
-        );
-      } catch {
-        /* Best effort. */
+    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}`);
     }
-  });
+  }
 
+  const sessionFocusPoller: { current: FocusPoller | null } = { current: null };
+
+  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'
+        ? (ctx as { isProjectTrusted: () => boolean }).isProjectTrusted()
+        : false;
+    effConfig = loadEfficiencyConfigFromDisk({ cwd, isProjectTrusted: isTrusted });
+    sessionRoot = resolveSessionRoot(
+      (ctx as { sessionManager?: { getSessionDir?: () => string | undefined } })?.sessionManager?.getSessionDir?.(),
+      sessionId,
+    );
+    // 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();
+    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(() => {});
+
+    // D-4 focus sampling: herdr <0.9.1 never delivered pane.focused to plugins;
+    // 0.9.1+ is event-first (pollMs 0). One poller per pane, self-scoped.
+    if (sessionFocusPoller.current) sessionFocusPoller.current.stop();
+    sessionFocusPoller.current = null;
+    const paneId = env?.paneId ?? '';
+    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 the
+          // field (older herdr) the tick stays silent instead of guessing.
+          const layout = await client.exportLayout({ paneId });
+          const sample = parseFocusSample(layout);
+          return sample && sample.focusedPaneId !== null ? sample : null;
+        },
+        fire: (focusedPaneId, cause) => spawnReflow({ paneId: focusedPaneId, cause }),
+      });
+    }
+    startPipeServerFor(cwd);
+  });
 
-  // 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.on('turn_start', async () => {
     agentActive = true;
-    reportAgent('working', currentActivity(todos.items));
+    // A11: reset so a previous turn's abort cannot taint this one.
+    lastStopReason = null;
+    // Safety fallback: pi core prohibits prompts while compaction is active.
+    coordinator.compactionInFlight = false;
+    coordinator.intentionalAbort = false;
+    gates.report('working', currentActivity(todos.items));
+  });
+
+  pi.on('before_provider_request', (_event: unknown, ctx: unknown) => {
+    const usage = (ctx as { getContextUsage?: () => { tokens?: number | null } })?.getContextUsage?.();
+    if (typeof usage?.tokens === 'number') {
+      coordinator.onBeforeProviderRequest(usage.tokens);
+    }
   });
-  pi.on('turn_end', async (event: unknown) => {
-    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;
+
+  pi.on('input', (event: unknown) => {
+    if (event && typeof event === 'object') {
+      coordinator.onInput(event as { text?: string; source?: string; streamingBehavior?: string });
+    }
+  });
+
+  pi.on('session_before_tree', () => (coordinator.compactionInFlight ? { cancel: true } : undefined));
+
+  pi.on('turn_end', async (event: unknown, ctx) => {
+    // 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 () => {
+  pi.on('agent_settled', async (_event: unknown, ctx) => {
     agentActive = false;
-    reportAgent('idle', null);
+    gates.report('idle', null);
     const plan = planSettleWake({
       lastStopReason,
+      intentionalAbort: coordinator.intentionalAbort,
+      compactionPending: coordinator.selectedCompaction !== null || coordinator.compactionInFlight,
       running: subagentPort.current?.listRunningSubs() ?? [],
       lastNoticeKey: d96NoticeKey,
       lastNoticeAt: d96NoticeAt,
@@ -375,74 +507,54 @@ 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');
     }
-  });
-
-  // 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.
-  function enterBlocked(label: string | null): void {
-    blockedDepth += 1;
-    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?.();
-  }
-  function exitBlocked(): void {
-    blockedDepth = Math.max(0, blockedDepth - 1);
-    if (blockedDepth === 0) {
-      reportAgent(agentActive ? 'working' : 'idle', agentActive ? currentActivity(todos.items) : null);
-      // D95: gate released → clear marker.
-      void client.reportAskFlag(null).catch(() => {});
+    if (plan.compact && ctx && typeof ctx === 'object') {
+      void coordinator.onAgentSettled({
+        ctx,
+        todos: todos.items,
+        pi,
+        config: effConfig.onlineContextCompact,
+        cancelReminder: todoUi.cancelReminder,
+        onBeforeCompact: createCompactionBatchPackHook({
+          getObsConfig: () => effConfig.observationPack,
+          getManifest: () => roles.state.manifest,
+          getSessionId: () => sessionId,
+          pickMiddleExcerpt,
+        }),
+      });
     }
-    // Gate closed → restore the full widget window.
-    todoUi.rerenderWidget?.();
-  }
+    if (lastStopReason !== ABORT_STOP_REASON) void notices.flush('followUp');
+    void pushSettleReply();
+  });
 
-  // emit() is synchronous; this flag stops our own listener from double-counting depth.
-  let publishingHerdrBlocked = false;
-  function publishHerdrBlocked(active: boolean, label: string | null): void {
-    publishingHerdrBlocked = true;
-    try {
-      if (active) enterBlocked(label);
-      else exitBlocked();
-      pi.events.emit(
-        'herdr:blocked',
-        active ? { active: true, ...(label ? { label } : {}) } : { active: false },
-      );
-    } finally {
-      publishingHerdrBlocked = false;
-    }
-  }
-  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);
+  /* ── D101 ObservationPack (obs_recall tool & context projector) ── */
+  registerObservationPack({
+    pi,
+    getConfig: () => effConfig,
+    getRuntimeManifest: () => roles.state.manifest,
+    pickMiddleExcerpt,
+    getRemainingHorizon: () => {
+      const usage = (latestCtx as { getContextUsage?: () => { contextWindow?: number } })?.getContextUsage?.();
+      return coordinator.getRemainingHorizon(3, usage?.contextWindow ?? null);
+    },
   });
 
-  /* ── Tool: ask_user_question (v1.3 M8 human gate, available to master and subagents) ── */
+  installConfigCommand({ pi });
+  installDashboardCommand({
+    pi,
+    client,
+    env,
+    getTodoItems: () => todos.items,
+    getHeldLocks: () => locksHandle.getHeldLocks(),
+  });
 
+  /* ── ask_user_question (v1.3 M8 human gate; master and subagents) ── */
   pi.registerTool({
     name: ASK_TOOL_NAME,
     label: 'Ask User',
@@ -454,117 +566,36 @@ 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);
-      // Fallback when herdr:pi is absent: a one-shot pi-herdr blocked report can lose
-      // to later working reports; refresh while the gate is open. Do not re-emit
-      // herdr:blocked here — official blockedCount is edge-triggered.
-      const hb = setInterval(() => { reportAgent('blocked', label); }, 5000);
+      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 {
-        clearInterval(hb);
-        publishHerdrBlocked(false, null);
+        gates.publish(false, null);
       }
     },
   });
 
   pi.on('session_shutdown', async () => {
-    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 };
-  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 { 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 { 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,
-  });
-  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 ?? '';
-    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', () => {
+    coordinator.compactionInFlight = false;
+    coordinator.intentionalAbort = false;
+    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 (sessionRoot) {
+      try {
+        await pruneSessionObjects(sessionRoot);
+      } catch {
       }
-      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. */
     }
+    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({
@@ -580,10 +611,14 @@ export default async function (pi: ExtensionAPI) {
       deliverNotice,
       noticePending: notices.noticePending,
       getSessionId: () => sessionId,
-      getBlockedDepth: () => blockedDepth,
+      getBlockedDepth: () => gates.depth(),
       reconcileOnSettlement,
       withReconcileNotes,
       claimSettleNotice,
+      isCompactionInFlight: () => coordinator.compactionInFlight,
+      isIntentionalAbort: () => coordinator.intentionalAbort,
+      jev: { ask: (request, meta) => jevRuntime.ask(request, meta), getMinConfidence: () => effConfig.jev.minConfidence },
+      appendRoutingLog,
     });
   } else {
     const { mountTodoOnly } = await import('./index-worker.ts');
@@ -592,13 +627,15 @@ 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,
             },
           }),
     });