pi-pier 0.2.7 → 0.3.1

package/src/git-adapter.ts

@@ -1,104 +0,0 @@
-import { execFile as nodeExecFile } from 'node:child_process'
-import { promisify } from 'node:util'
-import { runtimePolicy } from './runtime-policy.ts'
-
-const execFile = promisify(nodeExecFile)
-
-export interface GitResult {
-  readonly stdout: string
-  readonly stderr: string
-}
-
-export interface GitError extends Error {
-  readonly code?: string | number
-  readonly stdout?: string
-  readonly stderr?: string
-}
-
-/**
- * Injectable execFile used by NodeGitAdapter.
- * Why: tests drive git without a real process.
- */
-export type GitExecFile = (
-  file: string,
-  args: readonly string[],
-  options: { timeout: number; encoding: 'utf8' },
-) => Promise<{ stdout: string; stderr: string }>
-
-/**
- * Minimal Git adapter for worktree and status operations.
- *
- * Why: Centralizes platform-specific git executable resolution, timeout policy,
- * and error normalization; makes tests independent of real git processes.
- */
-export interface GitAdapter {
-  /**
-   * List worktrees in porcelain format.
-   * Returns stdout containing worktree entries.
-   */
-  listWorktrees(cwd: string): Promise<GitResult>
-
-  /**
-   * Get status of worktree in short format.
-   * Returns stdout containing status entries.
-   */
-  status(cwd: string): Promise<GitResult>
-
-  /**
-   * Run an arbitrary git command in `cwd` (`git -C <cwd> ...args`).
-   * Throws a GitError on failure/timeout — callers that want "null on error"
-   * (isolate sweep, placement) catch at the call site.
-   */
-  run(cwd: string, args: readonly string[]): Promise<GitResult>
-}
-export class NodeGitAdapter implements GitAdapter {
-  private readonly gitExecutable: string
-  private readonly timeoutMs: number
-  private readonly exec: GitExecFile
-
-  constructor(
-    gitExecutable: string = 'git',
-    timeoutMs: number = runtimePolicy.gitTimeoutMs,
-    exec: GitExecFile = execFile as unknown as GitExecFile,
-  ) {
-    this.gitExecutable = gitExecutable
-    this.timeoutMs = timeoutMs
-    this.exec = exec
-  }
-
-  listWorktrees(cwd: string): Promise<GitResult> {
-    return this.run(cwd, ['worktree', 'list', '--porcelain'])
-  }
-
-  status(cwd: string): Promise<GitResult> {
-    return this.run(cwd, ['status', '--short'])
-  }
-
-  async run(cwd: string, args: readonly string[]): Promise<GitResult> {
-    try {
-      const { stdout, stderr } = await this.exec(
-        this.gitExecutable,
-        ['-C', cwd, ...args],
-        { timeout: this.timeoutMs, encoding: 'utf8' },
-      )
-      return { stdout, stderr }
-    } catch (err) {
-      throw this.normalizeError(err, args[0] ?? 'command')
-    }
-  }
-
-  private normalizeError(err: unknown, operation: string): GitError {
-    if (err instanceof Error) {
-      const gitError = err as GitError
-      gitError.message = `Git ${operation} failed: ${gitError.message}`
-      return gitError
-    }
-    return new Error(`Git ${operation} failed: ${String(err)}`) as GitError
-  }
-}
-
-/**
- * Default production git adapter.
- * Tests should inject fake implementations or a fake exec.
- */
-export const defaultGitAdapter = new NodeGitAdapter()

package/src/notice-buffer.ts

@@ -1,23 +0,0 @@
-/**
- * D92 settlement-notice collapser (pure half of the followup-flood fix).
- *
- * Why: `sendUserMessage(followUp)` only delivers when the agent has no more
- * tool calls, so a long master run queues every settlement and floods at the
- * end. Buffer while busy; collapse at turn_end. The other half is the index
- * notice buffer.
- */
-export const NOTICE_MAX_SHOWN = 3;
-
-/**
- * Collapse a batch into one message body.
- * - empty → null (do not inject)
- * - ≤max → originals joined with `\n\n` (single-item byte-identical to the old format)
- * - >max → first max originals + a tail pointing at history / subagent list
- */
-export function collapseNotices(contents: readonly string[], max = NOTICE_MAX_SHOWN): string | null {
-  if (contents.length === 0) return null;
-  if (contents.length <= max) return contents.join('\n\n');
-  const hidden = contents.length - max;
-  const tail = `…另有 ${hidden} 条结算未逐条展示。全量结果看 history 台账（路径公式见 subagent resume 工具描述）；在跑代理用 subagent list 查看。`;
-  return [...contents.slice(0, max), tail].join('\n\n');
-}

package/src/subagent-git-io.ts

@@ -1,80 +0,0 @@
-/**
- * Git/worktree I/O used by spawn, isolate, GC, and settlement stat lines.
- *
- * Why: core/subagent mixed adapter calls with tool registration. Centralizing
- * git behind one cache/timeout policy keeps placement and isolate GC consistent.
- */
-import { defaultGitAdapter, type GitAdapter } from './git-adapter.ts';
-import { formatWorktreeStat, type SubEntry } from './subagent-core.ts';
-
-const WORKTREES_CACHE_MS = 5000;
-export interface GitIo {
-  listWorktrees(cwd: string): Promise<string[]>;
-  runGit(cwd: string, args: string[]): Promise<string | null>;
-  worktreeStatLine(entry: SubEntry): Promise<string | null>;
-  invalidateWorktreesCache(): void;
-}
-
-export function createGitIo(git: GitAdapter = defaultGitAdapter): GitIo {
-  let worktreesCache: { at: number; list: string[] } | null = null;
-  async function listWorktrees(cwd: string): Promise<string[]> {
-    if (worktreesCache && Date.now() - worktreesCache.at < WORKTREES_CACHE_MS) return worktreesCache.list;
-    let list: string[] = [];
-    try {
-      const { stdout } = await git.listWorktrees(cwd);
-      for (const line of String(stdout).split('\n')) {
-        const m = /^worktree (.+)$/.exec(line.trim());
-        if (m) list.push(m[1]);
-      }
-    } catch {
-      list = [];
-    }
-    worktreesCache = { at: Date.now(), list };
-    return list;
-  }
-
-  async function runGit(cwd: string, args: string[]): Promise<string | null> {
-    try {
-      const { stdout } = await git.run(cwd, args);
-      return stdout == null ? null : String(stdout);
-    } catch {
-      return null;
-    }
-  }
-
-  function lastStatLine(out: string | null): string | null {
-    if (!out) return null;
-    const lines = out.replace(/\r/g, '').split('\n').map((l) => l.trim()).filter(Boolean);
-    return lines.length ? lines[lines.length - 1]! : null;
-  }
-
-  async function worktreeStatLine(entry: SubEntry): Promise<string | null> {
-    const porcelain = await runGit(entry.cwd, ['status', '--porcelain']);
-    if (porcelain === null) return null;
-    const dirtyCount = porcelain.split('\n').filter((l) => l.trim() !== '').length;
-    if (entry.isolate) {
-      const statOut = await runGit(entry.cwd, ['diff', '--stat', `${entry.isolate.baseSha}...HEAD`]);
-      const commitsOut = await runGit(entry.cwd, ['rev-list', '--count', `${entry.isolate.baseSha}..HEAD`]);
-      const commits = commitsOut != null && /^\d+$/.test(commitsOut.trim()) ? Number(commitsOut.trim()) : null;
-      return formatWorktreeStat({ branch: entry.isolate.branch, commits, statLine: lastStatLine(statOut), dirtyCount });
-    }
-    return formatWorktreeStat({
-      branch: null,
-      commits: null,
-      statLine: lastStatLine(await runGit(entry.cwd, ['diff', '--stat', 'HEAD'])),
-      dirtyCount,
-    });
-  }
-
-  function invalidateWorktreesCache(): void {
-    worktreesCache = null;
-  }
-
-  return {
-    listWorktrees,
-    runGit,
-    worktreeStatLine,
-    invalidateWorktreesCache,
-  };
-}
-

package/src/subagent-launch.ts

@@ -1,110 +0,0 @@
-/**
- * Subagent `execute` planners (validation + foreground wait).
- *
- * Why: execute mixed param checks, isolate git I/O, spawn, and wait-loop
- * decisions. The decisions are pure and must stay testable without a pane.
- */
-import { normalizeEntryKind } from './history-store.ts';
-
-export const FOREGROUND_POLL_MS = 2_000;
-
-export type LaunchParams = {
-  description?: unknown;
-  prompt?: unknown;
-  run_in_background?: unknown;
-  cwd?: unknown;
-  isolate?: unknown;
-  role?: unknown;
-  allowed_tools?: unknown;
-  tab?: unknown;
-};
-
-export type LaunchValidation =
-  | { kind: 'error'; text: string }
-  | {
-      kind: 'ok';
-      spec: SubagentSpec;
-      background: boolean;
-      isolate: boolean;
-      cwdParam: string | null;
-      roleKind: string;
-      suggested: string[];
-      tab: string | null;
-    };
-
-export function planLaunchValidation(
-  params: LaunchParams | null | undefined,
-  herdrAvailable: boolean,
-): LaunchValidation {
-  if (!herdrAvailable) {
-    return {
-      kind: 'error',
-      text: 'Error: subagent requires pi to run inside a herdr-managed pane (HERDR_ENV not set).',
-    };
-  }
-  const spec: SubagentSpec = {
-    description: String(params?.description ?? 'subagent'),
-    prompt: String(params?.prompt ?? ''),
-  };
-  if (!spec.prompt.trim()) {
-    return { kind: 'error', text: 'Error: `prompt` must be a non-empty string' };
-  }
-  const cwdParam = typeof params?.cwd === 'string' && params.cwd.trim() ? params.cwd.trim() : null;
-  const isolate = params?.isolate === true;
-  if (isolate && cwdParam) {
-    return {
-      kind: 'error',
-      text: 'Error: `isolate` and `cwd` are mutually exclusive — isolate creates a new worktree, cwd delegates into an existing one',
-    };
-  }
-  const suggested = Array.isArray(params?.allowed_tools)
-    ? params.allowed_tools.filter((t): t is string => typeof t === 'string' && t.trim() !== '')
-    : [];
-  const manifestRole =
-    typeof params?.role === 'string' && params.role.trim() ? params.role.trim() : 'worker-default';
-  const tab = typeof params?.tab === 'string' ? params.tab : null;
-  return {
-    kind: 'ok',
-    spec,
-    background: params?.run_in_background === true,
-    isolate,
-    cwdParam,
-    roleKind: normalizeEntryKind(typeof params?.role === 'string' ? params.role.trim() : undefined),
-    suggested,
-    manifestRole,
-    tab,
-  };
-}
-
-export function planIsolateRepoGuard(baseSha: string | null): { kind: 'error'; text: string } | { kind: 'ok'; sha: string } {
-  if (!baseSha) {
-    return { kind: 'error', text: 'Error: isolate requires a git repository with at least one commit' };
-  }
-  return { kind: 'ok', sha: baseSha };
-}
-
-export type ForegroundTickPlan =
-  | { kind: 'blocked' }
-  | { kind: 'settled'; text: string }
-  | { kind: 'wait'; delayMs: number }
-  | { kind: 'collect-final' }
-  | { kind: 'continue' };
-
-export function planForegroundTick(input: {
-  state: string | null;
-  session: { text: string | null; pendingTool: boolean; activity: boolean };
-}): ForegroundTickPlan {
-  if (input.state === 'blocked') return { kind: 'blocked' };
-  if (input.state === 'idle' || input.state === 'done') {
-    if (input.session.text) return { kind: 'settled', text: input.session.text };
-    if (input.session.pendingTool || !input.session.activity) {
-      return { kind: 'wait', delayMs: FOREGROUND_POLL_MS };
-    }
-    return { kind: 'collect-final' };
-  }
-  return { kind: 'continue' };
-}
-
-export function planPatienceExpiry(alive: boolean): 'move-to-background' | 'timeout' {
-  return alive ? 'move-to-background' : 'timeout';
-}

package/src/subagent-poll-loop.ts

@@ -1,285 +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 } from './runtime-policy.ts';
-import { mountSubagentScope } from './subagent-scope.ts';
-import {
-  OBSERVATION_TICK_MS,
-  TAKEOVER_RECHECK_MS,
-  planBlockedGate,
-  planObservationTick,
-  planTakeoverTick,
-  planVacuumTick,
-} from './subagent-poller.ts';
-import { buildBlockedGateNotice, type SubEntry } from './subagent-core.ts';
-import { formatSettlementNotice } from './vocab.ts';
-import type { SessionIo } from './subagent-session-io.ts';
-import type { GitIo } from './subagent-git-io.ts';
-
-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;
-}
-
-export interface Poller {
-  startPoller(paneId: string, cwd: string, spawnedAt: number, injectTs: number, description: string, requestId: string): 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 observeWindowMs = runtimePolicy.observationWindowMs;
-  const machineInjectGraceMs = runtimePolicy.settlementWindowMs;
-  const takeoverIdleMs = runtimePolicy.settlementWindowMs;
-  const timeoutMs = runtimePolicy.subagentTimeoutMs;
-
-  async function pollLoop(
-    paneId: string,
-    cwd: string,
-    spawnedAt: number,
-    injectTs: number,
-    description: string,
-    requestId: string,
-  ): Promise<void> {
-    void spawnedAt;
-    const startedAt = Date.now();
-    let lastActivityAt = Date.now();
-    const pollTrace = process.env.PI_HERDR_TRACE
-      ? (msg: string) => { try { appendFileSync(process.env.PI_HERDR_TRACE!, `d98poll ${Date.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: Date.now(),
-              idleMs: takeoverIdleMs,
-            });
-            if (tick.kind === 'start-idle') {
-              entry.observationStartedAt = Date.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 sleep(TAKEOVER_RECHECK_MS);
-            continue;
-          }
-        }
-
-        let state: HerdrAgentState | null;
-        try {
-          state = await h.client.waitAgent(paneId, ['idle', 'done', 'blocked'], runtimePolicy.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(entry.userTakeover === true)}`);
-          if (s.text || (!s.pendingTool && s.activity)) {
-            const closing = s.text;
-            const obs = planObservationTick({
-              observationStartedAt: entry.observationStartedAt,
-              now: Date.now(),
-              windowMs: observeWindowMs,
-              agentStatus: null,
-              machineInjectAgoMs: Date.now() - (h.lastMachineInjectAt.get(paneId) ?? 0),
-              machineInjectGraceMs,
-            });
-            if (obs.kind === 'start-observation') {
-              entry.observationStartedAt = Date.now();
-              entry.lastAgentStatus = 'idle';
-              h.persistSubs();
-              await sleep(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: Date.now(),
-              windowMs: observeWindowMs,
-              agentStatus,
-              machineInjectAgoMs: Date.now() - (h.lastMachineInjectAt.get(paneId) ?? 0),
-              machineInjectGraceMs,
-            });
-            if (obs2.kind === 'user-takeover') {
-              entry.userTakeover = true;
-              entry.observationStartedAt = Date.now();
-              entry.lastAgentStatus = 'working';
-              h.persistSubs();
-              continue;
-            }
-            if (obs2.kind === 'machine-inject-reset') {
-              entry.observationStartedAt = Date.now();
-              h.persistSubs();
-              await sleep(OBSERVATION_TICK_MS);
-              continue;
-            }
-            if (obs2.kind === 'wait') {
-              await sleep(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 = Date.now();
-            h.writeHistory(entry, { outcome: closing }, 'poll-settle');
-            const notes = h.reconcileOnSettlement(description, 'settled');
-            const statLine = await h.git.worktreeStatLine(entry);
-            const notice = h.withReconcileNotes(
-              formatSettlementNotice(`${paneId} (${description})`, closing) + (statLine ? `\n${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.listAgents()).some((a) => a.paneId === paneId);
-        } catch {
-          alive = true;
-        }
-        const vacuum = planVacuumTick({
-          waitState: state,
-          paneAlive: alive,
-          now: Date.now(),
-          lastActivityAt,
-          timeoutMs,
-        });
-        if (vacuum.refreshActivity) lastActivityAt = Date.now();
-        if (vacuum.action === 'pane-closed') {
-          entry.status = 'consumed';
-          entry.consumedAt = Date.now();
-          h.persistSubs();
-          h.writeHistory(entry, { outcome: 'pane closed before settling' }, 'poll-pane-closed');
-          const notes = h.reconcileOnSettlement(description, 'failed');
-          const notice = h.withReconcileNotes(
-            `Background subagent ${paneId} (${description}) stopped before settling (its pane closed).`,
-            notes,
-          );
-          try {
-            await h.injectNotice(notice);
-          } catch { /* non-fatal */ }
-          return;
-        }
-        if (vacuum.action === 'timeout') {
-          entry.status = 'consumed';
-          entry.consumedAt = Date.now();
-          h.persistSubs();
-          h.writeHistory(entry, { outcome: 'observation timeout' }, 'poll-timeout');
-          const notes = h.reconcileOnSettlement(description, 'failed');
-          const notice = h.withReconcileNotes(
-            `Background subagent ${paneId} (${description}) has shown no progress for ${Math.round((Date.now() - lastActivityAt) / 1000)}s (observed since ${new Date(startedAt).toISOString()}). Run subagent(action: "list") to check its live state; if it is working, let it run — its settlement notice will arrive automatically. Do not sleep-wait.`,
-            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): void {
-    if (pollers.has(paneId)) return;
-    pollers.add(paneId);
-    void (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 };
-}

package/src/subagent-port.ts

@@ -1,27 +0,0 @@
-/**
- * Subagent outbound port (composition root → plugin).
- *
- * Why: index used to pass a bag of independently-nullable callbacks that the
- * plugin mutated field-by-field. A missing bag crashed at mount
- * (`Cannot set properties of undefined (setting 'applyReplySession')`).
- * Binding one `current` object is atomic: all methods or none.
- */
-export interface RunningSub {
-  paneId: string;
-  description: string;
-}
-
-export interface SubagentPort {
-  applyReplySession(paneId: string, sessionFile: string | null): void;
-  reconcileOnReply(paneId: string): string[];
-  listRunningSubs(): RunningSub[];
-  settleStatLine(paneId: string): Promise<string | null>;
-}
-
-export interface SubagentPortBox {
-  current: SubagentPort | null;
-}
-
-export function emptySubagentPortBox(): SubagentPortBox {
-  return { current: null };
-}

package/src/subagent-scope.ts

@@ -1,39 +0,0 @@
-/**
- * One Cordis fiber per subagent in the master process.
- * pipe / poller / history cleanup uses ctx.effect (LIFO dispose).
- * C3: workers must not import this module.
- */
-import { Context } from '@deepseek-ai/cordis';
-
-export interface ScopeHooks {
-  onDispose?: () => void;
-}
-
-export function createSessionRoot(hooks: ScopeHooks = {}): Context {
-  const root = new Context();
-  if (hooks.onDispose) {
-    root.effect(() => () => { hooks.onDispose?.(); }, 'session-root');
-  }
-  return root;
-}
-
-export async function mountSubagentScope(
-  root: Context,
-  paneId: string,
-  hooks: ScopeHooks = {},
-) {
-  return root.plugin({
-    name: `subagent:${paneId}`,
-    apply(ctx: Context) {
-      ctx.effect(() => () => { hooks.onDispose?.(); }, `subagent:${paneId}`);
-    },
-  }, { paneId });
-}
-
-export async function disposeSessionRoot(root: Context): Promise<void> {
-  try {
-    await root.fiber.dispose();
-  } catch {
-    /* second dispose is a no-op */
-  }
-}