pi-pier 0.3.0 → 0.4.1

package/src/subagent-output-action.ts

@@ -1,104 +0,0 @@
-import type { HerdrAgentState, HerdrClientLike } from './herdr-client.ts';
-import type { SubEntry } from './subagent-core.ts';
-import {
-  computeSubagentOutputDelta,
-  formatSubagentOutput,
-  resolveSubagentStatus,
-  type SubagentOutputCursor,
-} from './subagent-output-core.ts';
-import { readSubagentOutput } from './subagent-output-adapter.ts';
-import { toolError } from './tool-error.ts';
-
-export interface OutputActionParams {
-  agentId?: unknown;
-  taskId?: unknown;
-  max_chars?: unknown;
-  maxChars?: unknown;
-}
-
-export interface OutputActionResult {
-  content: Array<{ type: 'text'; text: string }>;
-  details: Record<string, unknown>;
-}
-
-export interface OutputActionDeps {
-  client: HerdrClientLike;
-  resolveEntry: (rawId: string, cwd: string) => { entry: SubEntry } | { error: string };
-  readAskFlag: (paneId: string) => Promise<string | null>;
-  outputCursors: Map<string, SubagentOutputCursor>;
-  getCwd: (toolCtx: unknown) => string;
-}
-
-export async function executeSubagentOutput(
-  params: OutputActionParams | undefined,
-  toolCtx: unknown,
-  deps: OutputActionDeps,
-): Promise<OutputActionResult> {
-  const rawId = String(params?.agentId ?? params?.taskId ?? '').trim();
-  if (!rawId) return toolError('Error: missing agentId for output (see action list)') as OutputActionResult;
-
-  const cwd = deps.getCwd(toolCtx);
-  const resolved = deps.resolveEntry(rawId, cwd);
-  if ('error' in resolved) return toolError(resolved.error) as OutputActionResult;
-
-  const entry = resolved.entry;
-  let agentState: HerdrAgentState | null = null;
-  let askFlag: string | null = null;
-  try {
-    const agents = await deps.client.listAgents();
-    const agent = agents.find((candidate) => candidate.paneId === entry.paneId);
-    agentState = agent?.status ?? null;
-    askFlag = agent?.tokens?.['pi-ask'] ?? null;
-  } catch {
-    /* Best effort: output remains useful without live status. */
-  }
-  if (!askFlag && agentState === 'blocked') {
-    try {
-      askFlag = await deps.readAskFlag(entry.paneId);
-    } catch {
-      /* Best effort. */
-    }
-  }
-
-  const status = resolveSubagentStatus({
-    localStatus: entry.status,
-    herdrStatus: agentState,
-    hasAskFlag: Boolean(askFlag),
-  });
-
-  let rawRead: { text: string; revision: number; truncated: boolean };
-  try {
-    rawRead = await readSubagentOutput(deps.client, entry.paneId);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    return toolError(`Error: failed to read output for subagent ${entry.paneId}: ${message}`) as OutputActionResult;
-  }
-
-  const prevCursor = deps.outputCursors.get(entry.paneId);
-  const maxChars = typeof params?.max_chars === 'number'
-    ? params.max_chars
-    : typeof params?.maxChars === 'number' ? params.maxChars : undefined;
-  const deltaResult = computeSubagentOutputDelta(prevCursor, rawRead.text, { maxChars });
-  deps.outputCursors.set(entry.paneId, deltaResult.nextCursor);
-
-  const formatted = formatSubagentOutput({
-    paneId: entry.paneId,
-    status,
-    revision: rawRead.revision,
-    bufferTruncated: rawRead.truncated,
-    deltaResult,
-    askQuestion: askFlag,
-  });
-
-  return {
-    content: [{ type: 'text', text: formatted }],
-    details: {
-      paneId: entry.paneId,
-      status,
-      revision: rawRead.revision,
-      truncated: rawRead.truncated || deltaResult.truncated,
-      restart: deltaResult.restart,
-      deltaLength: deltaResult.delta.length,
-    },
-  };
-}

package/src/subagent-output-adapter.ts

@@ -1,27 +0,0 @@
-/**
- * Herdr output-read adapter for subagents.
- *
- * Newer herdr exposes agent.read; older versions only expose pane.read. Prefer the semantic agent
- * endpoint and fall back to the pane endpoint so output observation stays version-compatible.
- */
-import type { HerdrClientLike } from './herdr-client.ts';
-
-export interface SubagentOutputRead {
-  text: string;
-  revision: number;
-  truncated: boolean;
-}
-
-export async function readSubagentOutput(
-  client: HerdrClientLike,
-  paneId: string,
-): Promise<SubagentOutputRead> {
-  if (typeof client.readAgent === 'function') {
-    try {
-      return await client.readAgent(paneId, { source: 'recent', stripAnsi: true });
-    } catch {
-      return await client.readPane(paneId, { source: 'recent', stripAnsi: true });
-    }
-  }
-  return await client.readPane(paneId, { source: 'recent', stripAnsi: true });
-}

package/src/subagent-output-core.ts

@@ -1,263 +0,0 @@
-/**
- * subagent-output-core.ts
- *
- * Pure functions for subagent incremental output extraction:
- *  - Cursor management (in-memory per-pane tail tracking)
- *  - Longest common suffix/prefix delta computation
- *  - Boundary handling for scrolling, clear-screen, repeated text (graceful degradation with restart: true)
- *  - Bounded character budgeting and metadata formatting
- */
-import type { HerdrAgentState } from './herdr-client.ts';
-import type { SubEntry } from './subagent-core.ts';
-
-export const OUTPUT_DEFAULT_MAX_CHARS = 6000;
-export const OUTPUT_HARD_CAP_CHARS = 16000;
-export const OUTPUT_MIN_OVERLAP = 16;
-export const OUTPUT_TAIL_CHARS = 500;
-
-export type SubagentStatus = 'running' | 'idle' | 'blocked' | 'settled';
-
-export interface SubagentOutputCursor {
-  /** Suffix of previous full text used for boundary matching */
-  tail: string;
-  /** Length of previous full text */
-  fullLength: number;
-}
-
-export interface SubagentOutputDeltaOptions {
-  /** Max characters of delta to return (default: 6000) */
-  maxChars?: number;
-  /** Minimum overlap length required for partial scroll matching (default: 16) */
-  minOverlap?: number;
-  /** Length of tail to retain in cursor (default: 500) */
-  tailChars?: number;
-}
-
-export interface SubagentOutputDeltaResult {
-  /** The new output text (or full bounded text on initial/restart) */
-  delta: string;
-  /** Whether the increment could not be determined reliably (scrolled away, cleared, ambiguous repeat) */
-  restart: boolean;
-  /** Whether delta was truncated to maxChars */
-  truncated: boolean;
-  /** New cursor to save for next call */
-  nextCursor: SubagentOutputCursor;
-}
-
-/**
- * Extract tail characters from a text buffer for cursor matching.
- */
-export function extractTail(text: string, tailChars = OUTPUT_TAIL_CHARS): string {
-  if (text.length <= tailChars) return text;
-  return text.slice(text.length - tailChars);
-}
-
-/**
- * Bound text to a maximum character budget, retaining the tail (most recent output).
- */
-export function boundText(text: string, maxChars: number): { text: string; truncated: boolean } {
-  if (text.length <= maxChars) {
-    return { text, truncated: false };
-  }
-  return {
-    text: text.slice(text.length - maxChars),
-    truncated: true,
-  };
-}
-
-/**
- * Pure function: Given previous cursor (tail + fullLength) and current full buffer text,
- * compute the incremental delta since last read.
- *
- * Boundary handling:
- *  1. Initial read (prevCursor is null/empty): returns full bounded text, restart=false.
- *  2. No change: fullLength and tail match, delta is empty, restart=false.
- *  3. Normal append: prevTail appears uniquely in currText -> delta is text after prevTail.
- *  4. Repeated text: prevTail appears multiple times -> ambiguous, returns full bounded text with restart=true.
- *  5. Partial buffer scroll: prevTail partially scrolled off top -> longest suffix of prevTail
- *     matching prefix of currText (>= minOverlap) identifies boundary.
- *  6. Full scroll / clear screen: no valid overlap found -> returns full bounded text with restart=true.
- */
-export function computeSubagentOutputDelta(
-  prevCursor: SubagentOutputCursor | null | undefined,
-  currText: string,
-  options?: SubagentOutputDeltaOptions,
-): SubagentOutputDeltaResult {
-  const rawMaxChars = options?.maxChars ?? OUTPUT_DEFAULT_MAX_CHARS;
-  const maxChars = Math.max(1, Math.min(rawMaxChars, OUTPUT_HARD_CAP_CHARS));
-  const minOverlap = options?.minOverlap ?? OUTPUT_MIN_OVERLAP;
-  const tailChars = options?.tailChars ?? OUTPUT_TAIL_CHARS;
-
-  // Case 1: First call (no previous cursor)
-  if (!prevCursor || !prevCursor.tail) {
-    const bounded = boundText(currText, maxChars);
-    return {
-      delta: bounded.text,
-      restart: false,
-      truncated: bounded.truncated,
-      nextCursor: {
-        tail: extractTail(currText, tailChars),
-        fullLength: currText.length,
-      },
-    };
-  }
-
-  const prevTail = prevCursor.tail;
-
-  // Case 2: Exact same content (no new output)
-  if (currText.length === prevCursor.fullLength && currText.endsWith(prevTail)) {
-    return {
-      delta: '',
-      restart: false,
-      truncated: false,
-      nextCursor: prevCursor,
-    };
-  }
-
-  // Case 3: prevTail appears in currText
-  const firstIdx = currText.indexOf(prevTail);
-  const lastIdx = currText.lastIndexOf(prevTail);
-
-  if (firstIdx !== -1) {
-    // 3a: Ambiguous duplicate occurrences in current text
-    if (firstIdx !== lastIdx) {
-      const bounded = boundText(currText, maxChars);
-      return {
-        delta: bounded.text,
-        restart: true,
-        truncated: bounded.truncated,
-        nextCursor: {
-          tail: extractTail(currText, tailChars),
-          fullLength: currText.length,
-        },
-      };
-    }
-
-    // 3b: Unique match
-    const rawDelta = currText.slice(firstIdx + prevTail.length);
-    if (rawDelta.length === 0) {
-      return {
-        delta: '',
-        restart: false,
-        truncated: false,
-        nextCursor: prevCursor,
-      };
-    }
-
-    const bounded = boundText(rawDelta, maxChars);
-    return {
-      delta: bounded.text,
-      restart: false,
-      truncated: bounded.truncated,
-      nextCursor: {
-        tail: extractTail(currText, tailChars),
-        fullLength: currText.length,
-      },
-    };
-  }
-
-  // Case 4: prevTail is not found in full. Check if a suffix of prevTail matches a prefix of currText
-  // (terminal buffer scrolled lines off the top).
-  let longestOverlap = 0;
-  const maxPossibleOverlap = Math.min(prevTail.length - 1, currText.length);
-  const effectiveMinOverlap = Math.min(minOverlap, prevTail.length);
-
-  for (let k = maxPossibleOverlap; k >= effectiveMinOverlap; k--) {
-    const suffix = prevTail.slice(prevTail.length - k);
-    if (currText.startsWith(suffix)) {
-      longestOverlap = k;
-      break;
-    }
-  }
-
-  if (longestOverlap >= effectiveMinOverlap) {
-    const rawDelta = currText.slice(longestOverlap);
-    const bounded = boundText(rawDelta, maxChars);
-    return {
-      delta: bounded.text,
-      restart: false,
-      truncated: bounded.truncated,
-      nextCursor: {
-        tail: extractTail(currText, tailChars),
-        fullLength: currText.length,
-      },
-    };
-  }
-
-  // Case 5: Clear screen or full scroll out -> degraded reset
-  const bounded = boundText(currText, maxChars);
-  return {
-    delta: bounded.text,
-    restart: true,
-    truncated: bounded.truncated,
-    nextCursor: {
-      tail: extractTail(currText, tailChars),
-      fullLength: currText.length,
-    },
-  };
-}
-
-/**
- * Resolve subagent semantic status from local subs registry and herdr agent state.
- */
-export function resolveSubagentStatus(opts: {
-  localStatus: SubEntry['status'];
-  herdrStatus?: HerdrAgentState | null;
-  hasAskFlag?: boolean;
-}): SubagentStatus {
-  if (opts.hasAskFlag || opts.herdrStatus === 'blocked') {
-    return 'blocked';
-  }
-  if (opts.herdrStatus === 'working') {
-    return 'running';
-  }
-  if (opts.localStatus === 'settled' || opts.localStatus === 'closed' || opts.herdrStatus === 'done') {
-    return 'settled';
-  }
-  if (opts.herdrStatus === 'idle') {
-    return 'idle';
-  }
-  if (opts.localStatus === 'running') {
-    return 'running';
-  }
-  return 'running';
-}
-
-export interface FormatSubagentOutputOpts {
-  paneId: string;
-  status: SubagentStatus;
-  revision: number;
-  bufferTruncated: boolean;
-  deltaResult: SubagentOutputDeltaResult;
-  askQuestion?: string | null;
-}
-
-/**
- * Format subagent output for display to the master model.
- */
-export function formatSubagentOutput(opts: FormatSubagentOutputOpts): string {
-  const parts: string[] = [];
-  const metaItems: string[] = [
-    `pane: ${opts.paneId}`,
-    `status: ${opts.status}${opts.status === 'blocked' && opts.askQuestion ? ` (question: "${opts.askQuestion}")` : ''}`,
-    `revision: ${opts.revision}`,
-  ];
-
-  if (opts.deltaResult.restart) {
-    metaItems.push('restart: true (buffer reset or scrolled)');
-  }
-  if (opts.bufferTruncated || opts.deltaResult.truncated) {
-    metaItems.push('truncated: true');
-  }
-
-  const header = `[Subagent Output | ${metaItems.join(' | ')}]`;
-  parts.push(header);
-
-  if (opts.deltaResult.delta.length === 0) {
-    parts.push('(no new output since last read)');
-  } else {
-    parts.push(opts.deltaResult.delta);
-  }
-
-  return parts.join('\n');
-}

package/src/subagent-poll-loop.ts

@@ -1,305 +0,0 @@
-/**
- * Background settlement poller (takeover, blocked gate, observation, vacuum).
- *
- * Why: planners already live in subagent-poller.ts; this adapter owns the
- * herdr/session I/O loop and pane-scope lifecycle so the plugin only starts it.
- */
-import { appendFileSync } from 'node:fs';
-import type { Context } from '@deepseek-ai/cordis';
-import type { HerdrClientLike, HerdrAgentState } from './herdr-client.ts';
-import { applyReportedSessionFile } from './history-store.ts';
-import { runtimePolicy, type RuntimePolicy } from './runtime-policy.ts';
-import { mountSubagentScope } from './subagent-scope.ts';
-import {
-  OBSERVATION_TICK_MS,
-  TAKEOVER_RECHECK_MS,
-  buildSettlementNoticeText,
-  formatObservationTimeoutNotice,
-  formatPaneClosedNotice,
-  isSettlementCandidate,
-  planBlockedGate,
-  planObservationTick,
-  planTakeoverTick,
-  planVacuumTick,
-} from './subagent-poller.ts';
-import { buildBlockedGateNotice, type SubEntry } from './subagent-core.ts';
-import type { SessionIo } from './subagent-session-io.ts';
-import type { GitIo } from './subagent-git-io.ts';
-
-export function sleep(ms: number): Promise<void> {
-  const wait = Promise.withResolvers<void>();
-  setTimeout(wait.resolve, ms);
-  return wait.promise;
-}
-
-export interface PollerHost {
-  client: HerdrClientLike;
-  sessionRoot: Context;
-  subs: Map<string, SubEntry>;
-  persistSubs(): void;
-  writeHistory(e: SubEntry, patch?: { outcome?: string | null; status?: SubEntry['status']; closedAt?: number }, via?: string): void;
-  blockedGateNotified: Set<string>;
-  lastMachineInjectAt: Map<string, number>;
-  session: SessionIo;
-  git: GitIo;
-  injectNotice(content: string): Promise<void>;
-  reconcileOnSettlement(description: string, outcome: 'settled' | 'failed'): string[];
-  withReconcileNotes(base: string, notes: readonly string[]): string;
-  claimSettleNotice(key: string): boolean;
-  /** Optional sleep seam for timing control without real delays */
-  sleep?: (ms: number) => Promise<void>;
-  /** Optional clock seam for deterministic virtual timestamps */
-  now?: () => number;
-  /** Optional runtime policy overrides for testing */
-  policy?: Partial<RuntimePolicy>;
-}
-
-export interface Poller {
-  startPoller(paneId: string, cwd: string, spawnedAt: number, injectTs: number, description: string, requestId: string): Promise<void>;
-  readonly pollers: Set<string>;
-}
-
-export function createPoller(h: PollerHost): Poller {
-  const pollers = new Set<string>();
-  const subScopes = new Map<string, { dispose: () => Promise<void> }>();
-  const doSleep = h.sleep ?? sleep;
-  const now = h.now ?? Date.now;
-  const observeWindowMs = h.policy?.observationWindowMs ?? runtimePolicy.observationWindowMs;
-  const machineInjectGraceMs = h.policy?.settlementWindowMs ?? runtimePolicy.settlementWindowMs;
-  const takeoverIdleMs = h.policy?.settlementWindowMs ?? runtimePolicy.settlementWindowMs;
-  const timeoutMs = h.policy?.subagentTimeoutMs ?? runtimePolicy.subagentTimeoutMs;
-  const pollIntervalMs = h.policy?.pollIntervalMs ?? runtimePolicy.pollIntervalMs;
-
-  async function pollLoop(
-    paneId: string,
-    cwd: string,
-    spawnedAt: number,
-    injectTs: number,
-    description: string,
-    requestId: string,
-  ): Promise<void> {
-    void spawnedAt;
-    const startedAt = now();
-    let lastActivityAt = now();
-    const pollTrace = process.env.PI_HERDR_TRACE
-      ? (msg: string) => { try { appendFileSync(process.env.PI_HERDR_TRACE!, `d98poll ${now()} ${paneId} ${msg}\n`); } catch { /* best-effort */ } }
-      : null;
-    try {
-      while (true) {
-        const entry = h.subs.get(paneId);
-        if (!entry || entry.status === 'settled') return;
-
-        if (entry.userTakeover) {
-          try {
-            const agents = await h.client.listAgents();
-            const agent = agents.find((a) => a.paneId === paneId);
-            const tick = planTakeoverTick({
-              currentStatus: agent?.status ?? null,
-              previousStatus: entry.lastAgentStatus,
-              idleStartedAt: entry.observationStartedAt,
-              now: now(),
-              idleMs: takeoverIdleMs,
-            });
-            if (tick.kind === 'start-idle') {
-              entry.observationStartedAt = now();
-              entry.lastAgentStatus = 'idle';
-              h.persistSubs();
-            } else if (tick.kind === 'return-control') {
-              entry.userTakeover = false;
-              entry.observationStartedAt = null;
-              entry.lastAgentStatus = null;
-              h.persistSubs();
-            } else if (tick.kind === 'hold' && tick.clearIdleTimer) {
-              entry.lastAgentStatus = tick.lastAgentStatus;
-              entry.observationStartedAt = null;
-              h.persistSubs();
-            }
-          } catch {
-            /* status probe failure must not stop the poller */
-          }
-          if (entry.userTakeover) {
-            await doSleep(TAKEOVER_RECHECK_MS);
-            continue;
-          }
-        }
-
-        let state: HerdrAgentState | null;
-        try {
-          state = await h.client.waitAgent(paneId, ['idle', 'done', 'blocked'], pollIntervalMs);
-        } catch {
-          state = null;
-        }
-        const gate = planBlockedGate(state, h.blockedGateNotified.has(paneId));
-        if (gate.kind === 'stay-blocked') {
-          if (gate.notify) {
-            h.blockedGateNotified.add(paneId);
-            const question = await h.session.readAskFlag(paneId);
-            try {
-              await h.injectNotice(buildBlockedGateNotice({ paneId, description, question }));
-            } catch {
-              /* list_agents can recover a missed notice */
-            }
-          }
-          continue;
-        }
-        if (gate.kind === 'clear-gate') h.blockedGateNotified.delete(paneId);
-        if (state === 'idle' || state === 'done') {
-          const s = await h.session.subSessionState(paneId, cwd, injectTs);
-          pollTrace?.(`state=${state} text=${s.text ? s.text.length : 'null'} pend=${s.pendingTool} act=${s.activity} obs=${String(entry.observationStartedAt ?? null)} takeover=${String(Boolean(entry.userTakeover))}`);
-          if (isSettlementCandidate(s)) {
-            const closing = s.text;
-            const obs = planObservationTick({
-              observationStartedAt: entry.observationStartedAt,
-              now: now(),
-              windowMs: observeWindowMs,
-              agentStatus: null,
-              machineInjectAgoMs: now() - (h.lastMachineInjectAt.get(paneId) ?? 0),
-              machineInjectGraceMs,
-            });
-            if (obs.kind === 'start-observation') {
-              entry.observationStartedAt = now();
-              entry.lastAgentStatus = 'idle';
-              h.persistSubs();
-              await doSleep(OBSERVATION_TICK_MS);
-              continue;
-            }
-            let agentStatus: string | null = null;
-            try {
-              const agents = await h.client.listAgents();
-              agentStatus = agents.find((a) => a.paneId === paneId)?.status ?? null;
-            } catch {
-              /* observation continues */
-            }
-            const obs2 = planObservationTick({
-              observationStartedAt: entry.observationStartedAt,
-              now: now(),
-              windowMs: observeWindowMs,
-              agentStatus,
-              machineInjectAgoMs: now() - (h.lastMachineInjectAt.get(paneId) ?? 0),
-              machineInjectGraceMs,
-            });
-            if (obs2.kind === 'user-takeover') {
-              entry.userTakeover = true;
-              entry.observationStartedAt = now();
-              entry.lastAgentStatus = 'working';
-              h.persistSubs();
-              continue;
-            }
-            if (obs2.kind === 'machine-inject-reset') {
-              entry.observationStartedAt = now();
-              h.persistSubs();
-              await doSleep(OBSERVATION_TICK_MS);
-              continue;
-            }
-            if (obs2.kind === 'wait') {
-              await doSleep(OBSERVATION_TICK_MS);
-              continue;
-            }
-            entry.observationStartedAt = null;
-            if (!entry.sessionFile) {
-              entry.sessionFile = applyReportedSessionFile(
-                entry.sessionFile,
-                await h.session.resolveSessionFile(paneId, cwd),
-              );
-            }
-            entry.status = 'consumed';
-            entry.consumedAt = now();
-            // A3: this path consumed the sub too - persist, or the session snapshot keeps it
-            // "running" and a restart replays a ghost subagent into list/settle-wake/zombie sweep.
-            h.persistSubs();
-            h.writeHistory(entry, { outcome: closing }, 'poll-settle');
-            const notes = h.reconcileOnSettlement(description, 'settled');
-            const statLine = await h.git.worktreeStatLine(entry);
-            const notice = h.withReconcileNotes(
-              buildSettlementNoticeText(`${paneId} (${description})`, closing, statLine),
-              notes,
-            );
-            if (h.claimSettleNotice(`${paneId}:${requestId}`)) {
-              try {
-                await h.injectNotice(notice);
-              } catch {
-                /* list_agents can recover */
-              }
-            }
-            return;
-          }
-        }
-        let alive = false;
-        try {
-          alive = (await h.client.listPanes()).some((p) => p.paneId === paneId);
-        } catch {
-          alive = true;
-        }
-        const vacuum = planVacuumTick({
-          waitState: state,
-          paneAlive: alive,
-          now: now(),
-          lastActivityAt,
-          timeoutMs,
-        });
-        if (vacuum.refreshActivity) lastActivityAt = now();
-        if (vacuum.action === 'pane-closed') {
-          entry.status = 'consumed';
-          entry.consumedAt = now();
-          h.persistSubs();
-          h.writeHistory(entry, { outcome: 'pane closed before settling' }, 'poll-pane-closed');
-          const notes = h.reconcileOnSettlement(description, 'failed');
-          const notice = h.withReconcileNotes(
-            formatPaneClosedNotice(paneId, description),
-            notes,
-          );
-          try {
-            await h.injectNotice(notice);
-          } catch { /* non-fatal */ }
-          return;
-        }
-        if (vacuum.action === 'timeout') {
-          entry.status = 'consumed';
-          entry.consumedAt = now();
-          h.persistSubs();
-          h.writeHistory(entry, { outcome: 'observation timeout' }, 'poll-timeout');
-          const notes = h.reconcileOnSettlement(description, 'failed');
-          const notice = h.withReconcileNotes(
-            formatObservationTimeoutNotice({
-              paneId,
-              description,
-              idleSeconds: Math.round((now() - lastActivityAt) / 1000),
-              startedAtIso: new Date(startedAt).toISOString(),
-            }),
-            notes,
-          );
-          try {
-            await h.injectNotice(notice);
-          } catch { /* non-fatal */ }
-          return;
-        }
-      }
-    } finally {
-      pollers.delete(paneId);
-    }
-  }
-
-  function startPoller(paneId: string, cwd: string, spawnedAt: number, injectTs: number, description: string, requestId: string): Promise<void> {
-    if (pollers.has(paneId)) return Promise.resolve();
-    pollers.add(paneId);
-    return (async () => {
-      try {
-        if (!subScopes.has(paneId)) {
-          const fiber = await mountSubagentScope(h.sessionRoot, paneId, {
-            onDispose: () => { pollers.delete(paneId); },
-          });
-          subScopes.set(paneId, fiber);
-        }
-        await pollLoop(paneId, cwd, spawnedAt, injectTs, description, requestId);
-        const fiber = subScopes.get(paneId);
-        subScopes.delete(paneId);
-        try { await fiber?.dispose(); } catch { /* already gone */ }
-      } catch (err) {
-        pollers.delete(paneId);
-        console.error(`pier: subagent poller ${paneId} crashed: ${(err as Error)?.message ?? err}`);
-      }
-    })();
-  }
-
-  return { startPoller, pollers };
-}