@pi-unipi/unipi 2.6.3 → 2.7.0

package/packages/subagents/src/fleet-view.ts

@@ -0,0 +1,316 @@
+/**
+ * @pi-unipi/subagents — FleetView (persistent fleet panel)
+ *
+ * pi-subagents parity built on OUR panel system: a persistent setWidget slot
+ * (belowEditor/aboveEditor placement from config) summarizing active work —
+ * in-process agents from the AgentManager plus async process runs from the
+ * run dirs. Collapsed by default; ↓/← activates selection, j/k navigate,
+ * enter opens the inspector, esc deactivates.
+ */
+
+import type { ExtensionUIContext } from "@earendil-works/pi-coding-agent";
+import { matchesKey, Key, truncateToWidth } from "@earendil-works/pi-tui";
+import type { AgentManager } from "./agent-manager.js";
+import type { AgentActivity } from "./types.js";
+import { listAsyncRunSummaries, type AsyncRunSummary } from "./fleet-data.js";
+
+const REFRESH_MS = 500;
+const MAX_AGENT_ROWS = 6;
+
+export interface FleetEntry {
+  key: string;
+  source: "inprocess" | "async";
+  agent: string;
+  description?: string;
+  startedAt: number;
+  state: string;
+  /** Run dir for async entries (inspector target). */
+  runDir?: string;
+}
+
+export interface FleetViewOptions {
+  refreshMs?: number;
+  maxAgentRows?: number;
+  placement?: "belowEditor" | "aboveEditor";
+  /** Open the inspector for an entry (wired to ConversationViewer overlay). */
+  openInspector?: (entry: FleetEntry) => Promise<void> | void;
+}
+
+function isActiveState(state: string): boolean {
+  return state === "running" || state === "queued" || state === "pending";
+}
+
+/** Collect active entries across both transports. */
+export function collectFleetEntries(
+  manager: AgentManager,
+  activity: Map<string, AgentActivity>,
+  asyncDirRoot: string,
+): FleetEntry[] {
+  const entries: FleetEntry[] = [];
+
+  for (const record of manager.listAgents()) {
+    if (!isActiveState(record.status)) continue;
+    const act = activity.get(record.id);
+    entries.push({
+      key: `inprocess:${record.id}`,
+      source: "inprocess",
+      agent: record.type,
+      description: record.description,
+      startedAt: record.startedAt,
+      state: record.status,
+    });
+    void act;
+  }
+
+  for (const run of listAsyncRunSummaries(asyncDirRoot)) {
+    if (!isActiveState(run.state)) continue;
+    entries.push({
+      key: `async:${run.runId}`,
+      source: "async",
+      agent: run.agent,
+      description: run.taskSummary,
+      startedAt: run.startedAt,
+      state: run.state,
+      runDir: run.runDir,
+    });
+  }
+
+  return entries.sort((left, right) => left.startedAt - right.startedAt || left.key.localeCompare(right.key));
+}
+
+export class FleetView {
+  private uiCtx: ExtensionUIContext | undefined;
+  private tui: { requestRender(): void } | undefined;
+  private timer: ReturnType<typeof setInterval> | undefined;
+  private widgetRegistered = false;
+  private lastRenderKey = "";
+  private entries: FleetEntry[] = [];
+  private active = false;
+  private selectedKey = "main";
+  private inspectorOpen = false;
+
+  constructor(
+    private manager: AgentManager,
+    private activity: Map<string, AgentActivity>,
+    private asyncDirRoot: string,
+    private options: FleetViewOptions = {},
+  ) {}
+
+  setUICtx(ctx: ExtensionUIContext): void {
+    if (ctx === this.uiCtx) return;
+    this.clearRegistration();
+    this.uiCtx = ctx;
+    this.ensureTimer();
+    this.refresh();
+  }
+
+  dispose(): void {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = undefined;
+    this.clearRegistration();
+    this.uiCtx = undefined;
+    this.entries = [];
+    this.active = false;
+    this.selectedKey = "main";
+  }
+
+  /** Called when work starts/finishes to trigger a refresh. */
+  refresh(): void {
+    const ctx = this.uiCtx;
+    if (!ctx) return;
+    this.entries = collectFleetEntries(this.manager, this.activity, this.asyncDirRoot);
+    this.clampSelection();
+
+    if (this.inspectorOpen) {
+      this.lastRenderKey = "";
+      this.clearWidget();
+      return;
+    }
+    if (this.entries.length === 0) {
+      this.active = false;
+      this.selectedKey = "main";
+      this.lastRenderKey = "";
+      this.clearWidget();
+      return;
+    }
+
+    const renderKey = JSON.stringify({
+      active: this.active,
+      selected: this.selectedKey,
+      entries: this.entries.map((e) => [e.key, e.state]),
+    });
+    if (!this.widgetRegistered) {
+      ctx.setWidget(
+        "unipi-fleet-status",
+        (tui: unknown, _theme: unknown) => {
+          this.tui = tui as { requestRender(): void };
+          return {
+            render: (width: number) => this.render(width),
+            invalidate: () => {
+              this.lastRenderKey = "";
+            },
+            dispose: () => {
+              this.widgetRegistered = false;
+              this.tui = undefined;
+            },
+          };
+        },
+        { placement: this.options.placement ?? "belowEditor" },
+      );
+      this.widgetRegistered = true;
+      this.lastRenderKey = renderKey;
+      return;
+    }
+    if (renderKey === this.lastRenderKey) return;
+    this.lastRenderKey = renderKey;
+    this.tui?.requestRender();
+  }
+
+  /**
+   * Key handling for the collapsed/active roster. Returns consume intent.
+   * Wired from index.ts's terminal input hook.
+   */
+  handleKey(data: string, editorHasFocus: () => boolean): { consume?: boolean } | undefined {
+    const ctx = this.uiCtx;
+    if (!ctx || this.entries.length === 0) return undefined;
+    if (this.inspectorOpen) return undefined;
+    if (!editorHasFocus()) {
+      if (this.active) this.deactivate();
+      return undefined;
+    }
+
+    if (!this.active) {
+      const activates = matchesKey(data, "down") || matchesKey(data, "left");
+      if (!activates || ctx.getEditorText?.() !== "") return undefined;
+      this.active = true;
+      this.selectedKey = "main";
+      this.refresh();
+      return { consume: true };
+    }
+
+    const roster = this.rosterKeys();
+    const selectedIndex = Math.max(0, roster.indexOf(this.selectedKey));
+    if (matchesKey(data, "down") || matchesKey(data, "j")) {
+      this.selectedKey = roster[Math.min(roster.length - 1, selectedIndex + 1)] ?? "main";
+      this.refresh();
+      return { consume: true };
+    }
+    if (matchesKey(data, "up") || matchesKey(data, "k")) {
+      if (selectedIndex === 0) {
+        this.deactivate();
+        return { consume: true };
+      }
+      this.selectedKey = roster[selectedIndex - 1] ?? "main";
+      this.refresh();
+      return { consume: true };
+    }
+    if (matchesKey(data, "escape")) {
+      this.deactivate();
+      return { consume: true };
+    }
+    if (matchesKey(data, Key.enter)) {
+      if (this.selectedKey === "main") {
+        this.deactivate();
+        return { consume: true };
+      }
+      const entry = this.entries.find((e) => e.key === this.selectedKey);
+      if (!entry) return undefined;
+      this.inspectorOpen = true;
+      this.refresh();
+      void Promise.resolve()
+        .then(() => this.options.openInspector?.(entry))
+        .catch(() => {})
+        .finally(() => {
+          this.inspectorOpen = false;
+          this.refresh();
+        });
+      return { consume: true };
+    }
+    return undefined;
+  }
+
+  render(width: number): string[] {
+    if (this.entries.length === 0) return [];
+    if (!this.active) {
+      // Collapsed summary row.
+      const count = this.entries.length;
+      const noun = count === 1 ? "agent" : "agents";
+      const states = new Map<string, number>();
+      for (const entry of this.entries) states.set(entry.state, (states.get(entry.state) ?? 0) + 1);
+      const breakdown = [...states.entries()].map(([state, n]) => `${n} ${state}`).join(", ");
+      return [
+        truncateToWidth(`  ${count} active ${noun} (${breakdown}) · ↓ to inspect`, width),
+      ];
+    }
+
+    const roster = this.rosterKeys();
+    const selectedIndex = Math.max(0, roster.indexOf(this.selectedKey));
+    const lines = [truncateToWidth(`  ↑↓/jk select · enter inspect · esc back`, width), ""];
+    lines.push(truncateToWidth(`  ${this.bullet(0, selectedIndex)} main`, width));
+
+    const visibleCount = Math.min(this.options.maxAgentRows ?? MAX_AGENT_ROWS, this.entries.length);
+    const start = selectedIndex < visibleCount ? 0 : selectedIndex - visibleCount + 1;
+    const hiddenBelow = this.entries.length - (start + visibleCount);
+    if (start > 0) lines.push(truncateToWidth(`  ↑ ${start} more`, width));
+    for (let index = start; index < start + visibleCount; index++) {
+      const entry = this.entries[index];
+      if (!entry) break;
+      lines.push(...this.renderEntry(index + 1, selectedIndex, entry, width));
+    }
+    if (hiddenBelow > 0) lines.push(truncateToWidth(`  ↓ ${hiddenBelow} more`, width));
+    return lines;
+  }
+
+  private renderEntry(rosterIndex: number, selectedIndex: number, entry: FleetEntry, width: number): string[] {
+    void rosterIndex;
+    const elapsed = formatElapsed(Date.now() - entry.startedAt);
+    const sourceTag = entry.source === "async" ? "proc" : "local";
+    const left = `  ${this.bullet(-1, selectedIndex)} ${entry.agent} · ${entry.state}`;
+    const right = `${sourceTag} · ${elapsed}`;
+    return [truncateToWidth(`${left}  ${right}`, width)];
+  }
+
+  private bullet(_index: number, selectedIndex: number): string {
+    return selectedIndex > 0 ? ">" : " ";
+  }
+
+  private rosterKeys(): string[] {
+    return ["main", ...this.entries.map((entry) => entry.key)];
+  }
+
+  private clampSelection(): void {
+    if (!this.rosterKeys().includes(this.selectedKey)) this.selectedKey = "main";
+  }
+
+  private deactivate(): void {
+    this.active = false;
+    this.selectedKey = "main";
+    this.refresh();
+  }
+
+  private clearWidget(): void {
+    if (this.widgetRegistered && this.uiCtx) {
+      this.uiCtx.setWidget("unipi-fleet-status", undefined);
+      this.widgetRegistered = false;
+      this.tui = undefined;
+    }
+  }
+
+  private clearRegistration(): void {
+    this.clearWidget();
+  }
+
+  private ensureTimer(): void {
+    if (this.timer) return;
+    this.timer = setInterval(() => this.refresh(), this.options.refreshMs ?? REFRESH_MS);
+    this.timer.unref?.();
+  }
+}
+
+function formatElapsed(ms: number): string {
+  const seconds = Math.floor(ms / 1000);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m${seconds % 60}s`;
+  return `${Math.floor(minutes / 60)}h${minutes % 60}m`;
+}

package/packages/subagents/src/foreground-detach.ts

@@ -0,0 +1,59 @@
+/**
+ * @pi-unipi/subagents — Foreground detach shortcut
+ *
+ * Ported from pi-subagents foregroundDetachShortcut (config) +
+ * foregroundSingleHintText (render.ts). Optionally binds a shortcut that
+ * detaches the active foreground single-agent run WITHOUT terminating it:
+ * the parent stops waiting, the child keeps running, and the completion
+ * arrives later as a normal task-notification.
+ */
+
+export interface DetachShortcutConfig {
+  /** Shortcut string like "ctrl+b". Empty/unset disables the feature. */
+  shortcut?: string;
+}
+
+/** Parse a shortcut string into normalized parts ("ctrl+b" → ["ctrl","b"]). */
+export function parseDetachShortcut(raw: string | undefined): string[] | undefined {
+  const trimmed = raw?.trim().toLowerCase();
+  if (!trimmed) return undefined;
+  const parts = trimmed.split("+").map((part) => part.trim()).filter(Boolean);
+  if (parts.length === 0 || parts.some((part) => !part)) return undefined;
+  // Must include at least one modifier to avoid stealing plain keys.
+  const modifiers = new Set(["ctrl", "alt", "shift", "meta", "super"]);
+  if (!parts.slice(0, -1).some((part) => modifiers.has(part))) return undefined;
+  return parts;
+}
+
+/** Human-readable label ("ctrl+b" → "Ctrl+B"). */
+export function formatDetachHint(parts: string[] | undefined): string | undefined {
+  if (!parts) return undefined;
+  const label = parts
+    .map((part) => {
+      if (part === "ctrl") return "Ctrl";
+      if (part === "alt") return "Alt";
+      if (part === "shift") return "Shift";
+      if (part === "escape") return "Esc";
+      if (part.length === 1) return part.toUpperCase();
+      return part.charAt(0).toUpperCase() + part.slice(1);
+    })
+    .join("+");
+  return `${label} detaches (run continues in background)`;
+}
+
+/**
+ * Whether a raw terminal input matches the configured shortcut.
+ * Matches pi-tui-style control sequences for ctrl+<letter> plus literal text
+ * for other combos.
+ */
+export function matchesDetachInput(data: string, parts: string[] | undefined): boolean {
+  if (!parts) return false;
+  const hasCtrl = parts.includes("ctrl");
+  const key = parts[parts.length - 1]!;
+  if (hasCtrl && parts.length === 2 && key.length === 1) {
+    // Control sequence: C0 codes 0x01–0x1a map to ctrl+a–z.
+    const expected = String.fromCharCode(key.charCodeAt(0) - 96);
+    return data === expected;
+  }
+  return data === parts.join("+");
+}

package/packages/subagents/src/fork-context.ts

@@ -0,0 +1,285 @@
+/**
+ * @pi-unipi/subagents — Fork context resolution
+ *
+ * Ported from pi-subagents src/shared/fork-context.ts. Creates branched child
+ * sessions from the parent session file, sanitizes signed Anthropic thinking
+ * blocks (redacted_thinking always; signed thinking on Anthropic models),
+ * appends a thinking_level_change:off entry when sanitization occurred, and
+ * aligns the forked session cwd to the child launch cwd. Fork files nest
+ * under <parent-session-dir>/<parent-stem>/forks/ so top-level session
+ * discovery never picks them up.
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { randomUUID } from "node:crypto";
+import { SessionManager } from "@earendil-works/pi-coding-agent";
+
+export type SubagentExecutionContext = "fresh" | "fork";
+
+interface BranchSessionEntry {
+  type: string;
+  id?: string;
+  parentId?: string | null;
+  timestamp?: string;
+  message?: {
+    role?: string;
+    content?: unknown;
+    provider?: string;
+    api?: string;
+    model?: string;
+  };
+  thinkingLevel?: string;
+  cwd?: string;
+  [extra: string]: unknown;
+}
+
+export interface PreferredForkAvailability {
+  getSessionFile(): string | undefined;
+  getLeafId(): string | null;
+}
+
+export interface PreferredForkSnapshot {
+  parentSessionFile?: string;
+  leafId?: string | null;
+}
+
+export function resolveSubagentContext(value: unknown): SubagentExecutionContext {
+  return value === "fork" ? "fork" : "fresh";
+}
+
+export function canPreferFork(sessionManager: PreferredForkAvailability): boolean {
+  const parentSessionFile = sessionManager.getSessionFile();
+  const leafId = sessionManager.getLeafId();
+  if (!parentSessionFile || !leafId) return false;
+  try {
+    return fs.existsSync(parentSessionFile);
+  } catch {
+    return false;
+  }
+}
+
+export function canPreferForkFromSnapshot(input: PreferredForkSnapshot): boolean {
+  if (!input.parentSessionFile || !input.leafId) return false;
+  try {
+    return fs.existsSync(input.parentSessionFile);
+  } catch {
+    return false;
+  }
+}
+
+/** Anthropic provider/api models require thinking off on a sanitized fork. */
+export function forkedChildRequiresThinkingOff(
+  model: string | undefined,
+  modelInfoProvider?: string,
+  modelInfoApi?: string,
+): boolean {
+  if (!model) return true;
+  if (modelInfoProvider?.toLowerCase() === "anthropic") return true;
+  if (modelInfoApi?.toLowerCase() === "anthropic-messages") return true;
+  // Unknown models stay conservative (reference rule).
+  if (modelInfoProvider === undefined && modelInfoApi === undefined) return true;
+  return false;
+}
+
+function isUnsafeAnthropicThinkingBlock(message: BranchSessionEntry["message"], block: unknown): boolean {
+  if (!message || !block || typeof block !== "object" || !("type" in block)) return false;
+  const provider = typeof message.provider === "string" ? message.provider.toLowerCase() : "";
+  const api = typeof message.api === "string" ? message.api.toLowerCase() : "";
+  const model = typeof message.model === "string" ? message.model.toLowerCase() : "";
+  const isAnthropic = provider === "anthropic" || api === "anthropic-messages" || model.startsWith("anthropic/");
+  const b = block as Record<string, unknown>;
+  if (b.type === "redacted_thinking") return true;
+  if (b.type !== "thinking" || !isAnthropic) return false;
+  const signature =
+    "thinkingSignature" in b ? b.thinkingSignature : "signature" in b ? b.signature : undefined;
+  return b.redacted === true || (typeof signature === "string" && (signature as string).length > 0);
+}
+
+function createEntryId(entries: BranchSessionEntry[]): string {
+  const ids = new Set(entries.map((entry) => entry.id).filter((id): id is string => typeof id === "string"));
+  for (let attempt = 0; attempt < 100; attempt++) {
+    const id = randomUUID().slice(0, 8);
+    if (!ids.has(id)) return id;
+  }
+  return randomUUID();
+}
+
+function appendThinkingOffEntry(entries: BranchSessionEntry[]): void {
+  const last = entries[entries.length - 1];
+  if (last?.type === "thinking_level_change" && last.thinkingLevel === "off") return;
+  const parent = [...entries].reverse().find((entry) => typeof entry.id === "string");
+  entries.push({
+    type: "thinking_level_change",
+    id: createEntryId(entries),
+    parentId: parent?.id ?? null,
+    timestamp: new Date().toISOString(),
+    thinkingLevel: "off",
+  });
+}
+
+/** Strip signed/redacted Anthropic thinking blocks from forked entries. */
+export function sanitizeUnsafeThinkingBlocks(entries: BranchSessionEntry[]): boolean {
+  let sanitized = false;
+  for (const entry of entries) {
+    if (entry.type !== "message" || entry.message?.role !== "assistant" || !Array.isArray(entry.message.content)) continue;
+    const filtered = (entry.message.content as unknown[]).filter(
+      (block) => !isUnsafeAnthropicThinkingBlock(entry.message, block),
+    );
+    if (filtered.length === (entry.message.content as unknown[]).length) continue;
+    entry.message.content = filtered;
+    sanitized = true;
+  }
+  return sanitized;
+}
+
+function readSessionEntries(sessionFile: string): BranchSessionEntry[] {
+  const lines = fs.readFileSync(sessionFile, "utf-8").split("\n").filter((line) => line.trim().length > 0);
+  return lines.map((line, index) => {
+    try {
+      return JSON.parse(line) as BranchSessionEntry;
+    } catch (error) {
+      const cause = error instanceof Error ? error : new Error(String(error));
+      throw new Error(
+        `Unable to inspect forked session ${sessionFile}: invalid JSONL on line ${index + 1}: ${cause.message}`,
+        { cause },
+      );
+    }
+  });
+}
+
+/** Align a forked session's cwd to the child launch cwd. */
+export function alignForkedSessionCwd(sessionFile: string, cwd: string): void {
+  const entries = readSessionEntries(sessionFile);
+  const header = entries[0];
+  if (header?.type !== "session") {
+    throw new Error(`Forked session ${sessionFile} does not start with a session header.`);
+  }
+  const resolvedCwd = path.resolve(cwd);
+  const effectiveCwd = fs.realpathSync.native(resolvedCwd);
+  if (header.cwd === effectiveCwd) return;
+  header.cwd = effectiveCwd;
+  fs.writeFileSync(sessionFile, `${entries.map((entry) => JSON.stringify(entry)).join("\n")}\n`, "utf-8");
+}
+
+export interface ForkContextResolution {
+  sessionFile: string;
+  thinkingOverride?: "off";
+}
+
+export interface ForkContextResolver {
+  sessionFileForIndex(index?: number): string | undefined;
+  thinkingOverrideForIndex(index?: number): "off" | undefined;
+}
+
+interface ForkableSessionManager extends PreferredForkAvailability {
+  openSession?: (file: string, dir?: string) => {
+    createBranchedSession(leafId: string): string | undefined;
+    getHeader?: () => BranchSessionEntry | undefined;
+    getEntries?: () => BranchSessionEntry[] | undefined;
+  };
+}
+
+export interface ForkContextResolverOptions {
+  openSession?: ForkableSessionManager["openSession"];
+  forceThinkingOffForIndex?: (index: number) => boolean;
+}
+
+/**
+ * Create the fork resolver. Errors follow reference semantics: an explicit
+ * fork requires a persisted parent session + current leaf, failing fast
+ * rather than silently downgrading to fresh.
+ */
+export function createForkContextResolver(
+  sessionManager: ForkableSessionManager,
+  requestedContext: unknown,
+  options: ForkContextResolverOptions = {},
+): ForkContextResolver {
+  if (resolveSubagentContext(requestedContext) !== "fork") {
+    return {
+      sessionFileForIndex: () => undefined,
+      thinkingOverrideForIndex: () => undefined,
+    };
+  }
+
+  const parentSessionFile = sessionManager.getSessionFile();
+  if (!parentSessionFile) {
+    throw new Error("Forked subagent context requires a persisted parent session.");
+  }
+
+  const leafId = sessionManager.getLeafId();
+  if (!leafId) {
+    throw new Error("Forked subagent context requires a current leaf to fork from.");
+  }
+
+  const openSession =
+    options.openSession ?? sessionManager.openSession ?? ((file: string, dir?: string) => SessionManager.open(file, dir));
+
+  // Fork files nest under <parent-dir>/<parent-stem>/forks/ so top-level
+  // session discovery (largest-mtime *.jsonl, non-recursive) never hijacks.
+  const sessionDir = path.join(
+    path.dirname(parentSessionFile),
+    path.basename(parentSessionFile, ".jsonl"),
+    "forks",
+  );
+  const cachedResolutions = new Map<number, ForkContextResolution>();
+
+  const resolveFork = (index = 0): ForkContextResolution => {
+    const cached = cachedResolutions.get(index);
+    if (cached) return cached;
+    try {
+      if (!fs.existsSync(parentSessionFile)) {
+        throw new Error(
+          `Parent session file does not exist: ${parentSessionFile}. Pi has not persisted enough history to fork yet.`,
+        );
+      }
+      const sourceManager = openSession(parentSessionFile, sessionDir);
+      const sessionFile = sourceManager.createBranchedSession(leafId);
+      if (!sessionFile) {
+        throw new Error("Session manager did not return a forked session file.");
+      }
+      const forceThinkingOff = (sanitized: boolean): boolean =>
+        sanitized && (options.forceThinkingOffForIndex?.(index) ?? true);
+      let thinkingOverride: "off" | undefined;
+      if (!fs.existsSync(sessionFile)) {
+        const header = sourceManager.getHeader?.();
+        const entries = sourceManager.getEntries?.() as BranchSessionEntry[] | undefined;
+        if (!header || !entries) {
+          throw new Error(
+            `Session manager returned a forked session file that does not exist and cannot be persisted by fallback: ${sessionFile}`,
+          );
+        }
+        if (forceThinkingOff(sanitizeUnsafeThinkingBlocks(entries as BranchSessionEntry[]))) {
+          appendThinkingOffEntry(entries);
+          thinkingOverride = "off";
+        }
+        fs.mkdirSync(path.dirname(sessionFile), { recursive: true });
+        fs.writeFileSync(sessionFile, `${[header, ...entries].map((entry) => JSON.stringify(entry)).join("\n")}\n`, "utf-8");
+      } else {
+        const entries = readSessionEntries(sessionFile);
+        if (sanitizeUnsafeThinkingBlocks(entries)) {
+          if (forceThinkingOff(true)) {
+            appendThinkingOffEntry(entries);
+            thinkingOverride = "off";
+          }
+          fs.writeFileSync(sessionFile, `${entries.map((entry) => JSON.stringify(entry)).join("\n")}\n`, "utf-8");
+        }
+      }
+      const resolution = { sessionFile, ...(thinkingOverride ? { thinkingOverride } : {}) };
+      cachedResolutions.set(index, resolution);
+      return resolution;
+    } catch (error) {
+      const cause = error instanceof Error ? error : new Error(String(error));
+      throw new Error(`Failed to create forked subagent session: ${cause.message}`, { cause });
+    }
+  };
+
+  return {
+    sessionFileForIndex(index = 0): string | undefined {
+      return resolveFork(index).sessionFile;
+    },
+    thinkingOverrideForIndex(index = 0): "off" | undefined {
+      return resolveFork(index).thinkingOverride;
+    },
+  };
+}