@pi-unipi/unipi 3.0.0-alpha.2 → 3.0.0-alpha.21

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

@@ -1,322 +0,0 @@
-/**
- * @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";
-  /**
-   * Current session id. The dock only shows async runs stamped with it, so a
-   * crashed sibling session's orphans never leak into this project's footer.
-   */
-  sessionId?: string;
-  /** 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,
-  sessionId?: 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, sessionId ? { sessionId } : {})) {
-    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.options.sessionId);
-    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

@@ -1,59 +0,0 @@
-/**
- * @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

@@ -1,285 +0,0 @@
-/**
- * @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;
-    },
-  };
-}

package/packages/subagents/src/global.d.ts

@@ -1,7 +0,0 @@
-import type { InfoRegistryLike } from "@pi-unipi/core/global-types";
-
-declare global {
-  var __unipi_info_registry: InfoRegistryLike | undefined;
-}
-
-export {};