pi-pier 0.3.1 → 0.4.2

package/src/index.ts

@@ -19,6 +19,7 @@ import {
   hasAskUi,
   noUiResult,
   prepareAsk,
+  prepareAskArguments,
   runAsk,
 } from './ask-user.ts';
 import { pipeNameFor, pipeRequest, startPipeServer } from './pipe-channel.ts';
@@ -28,6 +29,8 @@ import { createHerdrClient } from './herdr-client.ts';
 import { bareSessionId, lastAssistantText, readSessionFile, resolveSessionFileValue } from './session-tail.ts';
 import { fileURLToPath } from 'node:url';
 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';
@@ -38,49 +41,48 @@ import { ABORT_STOP_REASON, planSettleWake, shouldPushSettleReply } from './sett
 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-core.ts';
+import { applyRestoredWorkerMode, planIndexMode } from './index-runtime.ts';
+import { buildResumeArgv, emptySubagentPortBox, sleepWhileSubsRunningNote } 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, 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 { openPierPanel } from './panel-open.ts';
+import { registerObservationPack, createCompactionBatchPackHook, type PickMiddleExcerpts } from './plugins/observation.ts';
 import { createJevRuntime } from './jev-client.ts';
 import {
   NOTICE_RANK_MIN_CONFIDENCE,
-  buildExcerptWindows,
   composeNoticeRanking,
   evaluateExcerptPick,
-  excerptAskIsSafe,
   excerptPickRequest,
   noticeRankRequest,
+  planExcerptAsks,
 } 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;
-}
-
 function agentSessionsDir(): string {
   return process.env.PI_CODING_AGENT_DIR ? join(process.env.PI_CODING_AGENT_DIR, 'sessions') : platformPaths.sessionsDir;
 }
 
 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 roleBase = process.env.PI_HERDR_ROLE_BASE || process.cwd();
 
@@ -89,7 +91,8 @@ export default async function (pi: ExtensionAPI) {
   let effConfig: EfficiencyConfig = resolveEfficiencyConfig();
   const coordinator = new CompactCoordinator();
   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);
@@ -108,30 +111,37 @@ export default async function (pi: ExtensionAPI) {
   /* ── 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;
+  /** P0-3: candidate windows are generated in code; jev only picks (rerank pattern), one request per batch. */
+  const pickMiddleExcerpts: PickMiddleExcerpts = async (items, excerptBudgetBytes) => {
+    const picks: Array<{ text: string; label: string } | null> = items.map(() => null);
+    if (!jevRuntime.available) return picks;
+    const asked = planExcerptAsks(items, excerptBudgetBytes);
+    const request = excerptPickRequest(asked);
+    if (!request) return picks;
     const result = await jevRuntime.ask(request, {
       questionId: 'obs-excerpt-window',
-      extra: { site: 'obs-excerpt', candidates: windows.map((w) => w.id) },
+      extra: {
+        site: 'obs-excerpt',
+        items: asked.map((a) => ({ obsId: a.obsId, windows: a.windows.map((w) => ({ id: w.id, startLine: w.startLine })) })),
+      },
       enrich: ({ answers }) => {
-        if (!answers || answers.window === undefined || answers.window.type !== 'choice') return {};
-        return { picked: answers.window.choice, confidence: answers.window.confidence };
+        if (!answers) return {};
+        return {
+          picked: asked.map((_, i) => {
+            const answer = answers[`excerpt_${i}_window`];
+            return answer?.type === 'choice' ? { choice: answer.choice, confidence: answer.confidence } : null;
+          }),
+        };
       },
     });
-    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;
+    if (!result.ok) return picks;
+    for (let i = 0; i < asked.length; i++) {
+      const { index, windows } = asked[i]!;
+      const picked = evaluateExcerptPick(result.answers, i, effConfig.jev.minConfidence);
+      const window = picked === null ? undefined : windows.find((w) => w.id === picked);
+      if (window) picks[index] = { text: window.text, label: window.label };
+    }
+    return picks;
   };
 
   const rendererTypes = installRenderers(pi);
@@ -189,16 +199,87 @@ export default async function (pi: ExtensionAPI) {
     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 });
-    const title = formatPaneTitle(todos.items, null, { progressSuffix: suffix, lastWriteAt: todos.lastWriteAt });
+    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,
+    }));
+  }
+
+  /* ── /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 [];
@@ -214,6 +295,8 @@ export default async function (pi: ExtensionAPI) {
         }
         todos.applyEdits(plan.edits, { source: 'reconcile' });
         mirrorTodos();
+        // Reconcile is not a tool call, so nothing else refreshes the resident widget after an edit.
+        todoUi.rerenderWidget?.();
       }
       return plan.noteLines;
     } catch {
@@ -246,10 +329,24 @@ export default async function (pi: ExtensionAPI) {
       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 */
+      }
     }
   });
 
@@ -263,6 +360,18 @@ export default async function (pi: ExtensionAPI) {
     });
   });
 
+  /* ── Masters sleep-polled background workers (sleep 120…840) instead of trusting the settlement notice. ── */
+  if (!isSubagent) {
+    pi.on('tool_result', async (event: unknown) => {
+      const rec = (event ?? {}) as { toolName?: unknown; input?: { command?: unknown }; content?: unknown };
+      if (rec.toolName !== 'bash' || typeof rec.input?.command !== 'string') return;
+      const note = sleepWhileSubsRunningNote(rec.input.command, subagentPort.current?.listRunningSubs() ?? []);
+      if (!note) return;
+      const content = Array.isArray(rec.content) ? rec.content as Array<{ type: 'text'; text: string }> : [];
+      return { content: [...content, { type: 'text' as const, text: note }] };
+    });
+  }
+
   let locksHandle = { getHeldLocks: () => [] as readonly string[] };
   if (env) {
     locksHandle = installWriteLocks(pi, { client, env, hard: process.env[WRITE_LOCK_ENV] === '1' });
@@ -274,8 +383,12 @@ export default async function (pi: ExtensionAPI) {
       .sendUserMessage?.(content, { deliverAs: mode, triggerTurn: true });
     return Promise.resolve();
   };
+
   const notices = createNoticeBuffer({
-    isBusy: () => agentActive || lastStopReason === ABORT_STOP_REASON,
+    // pi core rejects prompts while it is compacting (and drops fire-and-forget sends), so a
+    // settlement landing inside the compaction window must stay buffered until the continuation
+    // run settles — otherwise the result is lost with nobody left to retry it.
+    isBusy: () => agentActive || lastStopReason === ABORT_STOP_REASON || coordinator.compactionInFlight,
     send: sendUserMessageAs,
     // P0-2: rank collapsed batches by relevance to the master's in-progress work.
     rank: async (contents) => {
@@ -341,13 +454,14 @@ export default async function (pi: ExtensionAPI) {
         abort: () => { latestCtx?.abort?.(); },
         setPendingMachineRequest: (next) => { pendingMachineRequest = next; },
         applyRoleSwitch: roles.applyRoleSwitch,
+        applyWorkerTodos,
       }));
     } catch {
       /* Pipe name collision (rare): this session has no channel; callers report after ping timeout. */
     }
   }
 
-  async function pushSettleReply(): Promise<void> {
+  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
@@ -356,6 +470,7 @@ export default async function (pi: ExtensionAPI) {
     // request armed; the post-compaction settle pushes it (settle-wake-core.ts).
     if (!shouldPushSettleReply({
       intentionalAbort: coordinator.intentionalAbort,
+      aborted,
       compactionInFlight: coordinator.compactionInFlight,
       lastStopReason,
     })) {
@@ -383,8 +498,6 @@ export default async function (pi: ExtensionAPI) {
     }
   }
 
-  const sessionFocusPoller: { current: FocusPoller | null } = { current: null };
-
   pi.on('session_start', async (event, ctx) => {
     sessionId = resolveSessionId(ctx);
     latestCtx = ctx as { abort?: () => void } | null;
@@ -412,31 +525,57 @@ export default async function (pi: ExtensionAPI) {
     // 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 }),
-      });
+    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 {
+          pi.appendEntry(DELEGATION_CUSTOM_TYPE, { version: 1, ...delegation, ts: Date.now() });
+        } catch {
+          /* Best effort; the marker already carries the identity. */
+        }
+      }
+      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'];
+      }
+    });
+  }
+
   pi.on('session_tree', async (_event, ctx) => {
     sessionId = resolveSessionId(ctx);
     rebuildFromBranch(ctx);
@@ -447,6 +586,12 @@ export default async function (pi: ExtensionAPI) {
     mirrorTodos();
   });
 
+  /* 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;
     // A11: reset so a previous turn's abort cannot taint this one.
@@ -454,6 +599,9 @@ export default async function (pi: ExtensionAPI) {
     // Safety fallback: pi core prohibits prompts while compaction is active.
     coordinator.compactionInFlight = false;
     coordinator.intentionalAbort = false;
+    // A selection that never became startable must not latch every later decision (and the
+    // settle-wake hold) until the next human input.
+    coordinator.selectedCompaction = null;
     gates.report('working', currentActivity(todos.items));
   });
 
@@ -477,15 +625,20 @@ export default async function (pi: ExtensionAPI) {
     // 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 };
+      const { role, stopReason, usage } = msg as { role?: unknown; stopReason?: unknown; usage?: unknown };
       if (role === 'assistant' && typeof stopReason === 'string') {
         lastStopReason = stopReason;
       }
+      if (role === 'assistant' && usage !== null && typeof usage === 'object') {
+        coordinator.onAssistantUsage(usage as { input?: number; cacheRead?: number; cacheWrite?: number });
+      }
       if (ctx && typeof ctx === 'object') {
         coordinator.onTurnEnd({
           ctx,
           todos: todos.items,
           config: effConfig.onlineContextCompact,
+          pi,
+          lastStopReason: typeof stopReason === 'string' ? stopReason : null,
           cancelReminder: todoUi.cancelReminder,
         });
       }
@@ -493,12 +646,16 @@ export default async function (pi: ExtensionAPI) {
     void notices.flush('steer');
   });
 
-  pi.on('agent_settled', async (_event: unknown, ctx) => {
+  pi.on('agent_settled', async (event: unknown, ctx) => {
     agentActive = false;
     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,
@@ -515,6 +672,13 @@ export default async function (pi: ExtensionAPI) {
       void sendUserMessageAs(notice, 'followUp');
     }
     if (plan.compact && ctx && typeof ctx === 'object') {
+      // Settlement notices that land inside the compaction window stay buffered (isBusy includes
+      // compactionInFlight). The continuation run flushes them at its own agent_settled; a cancelled
+      // or rejected compaction sends no continuation, so release the buffer once the coordinator is
+      // done and no run has started.
+      const flushAfterCompaction = (): void => {
+        if (!coordinator.compactionInFlight && !agentActive) void notices.flush('followUp');
+      };
       void coordinator.onAgentSettled({
         ctx,
         todos: todos.items,
@@ -525,12 +689,12 @@ export default async function (pi: ExtensionAPI) {
           getObsConfig: () => effConfig.observationPack,
           getManifest: () => roles.state.manifest,
           getSessionId: () => sessionId,
-          pickMiddleExcerpt,
+          pickMiddleExcerpts,
         }),
-      });
+      }).then(flushAfterCompaction, flushAfterCompaction);
     }
-    if (lastStopReason !== ABORT_STOP_REASON) void notices.flush('followUp');
-    void pushSettleReply();
+    if (lastStopReason !== ABORT_STOP_REASON && !aborted) void notices.flush('followUp');
+    void pushSettleReply(aborted);
   });
 
   /* ── D101 ObservationPack (obs_recall tool & context projector) ── */
@@ -538,7 +702,7 @@ export default async function (pi: ExtensionAPI) {
     pi,
     getConfig: () => effConfig,
     getRuntimeManifest: () => roles.state.manifest,
-    pickMiddleExcerpt,
+    pickMiddleExcerpts,
     getRemainingHorizon: () => {
       const usage = (latestCtx as { getContextUsage?: () => { contextWindow?: number } })?.getContextUsage?.();
       return coordinator.getRemainingHorizon(3, usage?.contextWindow ?? null);
@@ -552,6 +716,7 @@ 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) ── */
@@ -561,6 +726,8 @@ export default async function (pi: ExtensionAPI) {
     description: ASK_TOOL_DESCRIPTION,
     promptGuidelines: ASK_PROMPT_GUIDELINES,
     parameters: ASK_PARAMETERS,
+    // Models sometimes send options/questions as a JSON string; repair them before pi validates.
+    prepareArguments: prepareAskArguments,
     async execute(_tc, params, signal, _upd, ctx) {
       const prepared = prepareAsk(params);
       if (!prepared.ok) return prepared.result;
@@ -580,8 +747,6 @@ export default async function (pi: ExtensionAPI) {
   pi.on('session_shutdown', async () => {
     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;
@@ -592,6 +757,14 @@ export default async function (pi: ExtensionAPI) {
       } catch {
       }
     }
+    if (treeSnapshot) {
+      try {
+        unlinkSync(treeSnapshot.path);
+      } catch {
+        /* Already swept. */
+      }
+      treeSnapshot = null;
+    }
     client.close();
   });
 
@@ -612,6 +785,7 @@ export default async function (pi: ExtensionAPI) {
       noticePending: notices.noticePending,
       getSessionId: () => sessionId,
       getBlockedDepth: () => gates.depth(),
+      getWorkers: widgetWorkers,
       reconcileOnSettlement,
       withReconcileNotes,
       claimSettleNotice,
@@ -620,6 +794,66 @@ export default async function (pi: ExtensionAPI) {
       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({