@pi-archimedes/subagent 1.3.1 → 1.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-archimedes/subagent",
-  "version": "1.3.1",
+  "version": "1.3.3",
   "type": "module",
   "keywords": [
     "pi-package"
@@ -11,7 +11,7 @@
   ],
   "main": "./src/index.ts",
   "dependencies": {
-    "@pi-archimedes/core": "1.3.1"
+    "@pi-archimedes/core": "1.3.3"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": ">=0.1.0",

package/src/spawn.ts

@@ -1,15 +1,12 @@
-import { fork, type ChildProcess } from "node:child_process";
-import { fileURLToPath } from "node:url";
-import { dirname, join } from "node:path";
+import { spawn, type ChildProcess } from "node:child_process";
+import * as fs from "node:fs";
+import * as net from "node:net";
+import * as os from "node:os";
+import * as path from "node:path";
+import { randomUUID } from "node:crypto";
 import { getBus, Events } from "@pi-archimedes/core/bus";
-import type { ParentToChild, ChildToParent } from "./ipc-types.js";
 import type { AgentConfig } from "./agents.js";
 
-// Resolve child script path from this file's location
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const childScriptPath = join(__dirname, "child.ts");
-
 export interface SpawnOptions {
   task: string;
   model: string | undefined;
@@ -20,83 +17,213 @@ export interface SpawnOptions {
 }
 
 /**
- * Spawn a child process via fork() with IPC channel.
+ * Resolve the pi binary path.
+ *
+ * Walk up from process.argv[1] (the pi CLI entry point) looking for the
+ * @earendil-works/pi-coding-agent package root, then resolve its bin.pi field.
+ * Falls back to "pi" (PATH lookup) if resolution fails.
  */
-export function spawnSubagent(options: SpawnOptions): ChildProcess {
-  // Fork the child script with IPC channel
-  const child = fork(childScriptPath, [], {
-    cwd: options.cwd || process.cwd(),
-    env: { ...process.env },
-    execArgv: ["--experimental-strip-types"],
-    stdio: ["ignore", "ignore", "ignore", "ipc"],
-  });
+function resolvePiBinary(): string {
+  try {
+    const entry = process.argv[1];
+    if (!entry) return "pi";
 
-  // Send init message to child with all configuration
-  // Model priority: agent.model > options.model > options.activeModel
-  const model = options.agent?.model ?? options.model ?? options.activeModel;
-  const initBase: Partial<ParentToChild> & { type: "init"; task: string } = {
-    type: "init",
-    task: options.task,
-  };
-  if (model) initBase.model = model;
-  if (options.agent?.name) initBase.agentName = options.agent.name;
-  if (options.agent?.systemPrompt) initBase.agentSystemPrompt = options.agent.systemPrompt;
-  if (options.agent?.tools) initBase.agentTools = options.agent.tools;
-  if (options.agent?.model) initBase.agentModel = options.agent.model;
-  if (options.agent?.thinking) initBase.agentThinking = options.agent.thinking;
-  if (options.cwd) initBase.cwd = options.cwd;
-  child.send(initBase as ParentToChild);
-
-  // Handle messages from child
-  child.on("message", (msg: ChildToParent) => {
-    switch (msg.type) {
-      case "event": {
-        // Forward events to streamEvents via the child's message handler
-        // (streamEvents attaches its own listener)
-        break;
-      }
-      case "ask_request": {
-        // Forward ask requests to the bus for parent's ask dialog
-        getBus().emit(Events.ASK_REQUEST, {
-          source: `subagent:${options.agent?.name ?? "general"}`,
-          requestId: msg.requestId,
-          questions: msg.questions,
-        });
-        break;
-      }
-      case "ready": {
-        // Child is ready — session created
-        break;
-      }
-      case "error": {
-        console.error(`[subagent:child] ${msg.message}`);
-        break;
+    let dir = path.dirname(fs.realpathSync(entry));
+    const root = path.parse(dir).root;
+
+    while (dir !== root) {
+      const pkgPath = path.join(dir, "package.json");
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8")) as {
+          name?: string;
+          bin?: string | Record<string, string>;
+        };
+        if (pkg.name === "@earendil-works/pi-coding-agent") {
+          const binField = pkg.bin;
+          const binRelative =
+            typeof binField === "string"
+              ? binField
+              : binField?.pi ?? Object.values(binField ?? {})[0];
+          if (binRelative) {
+            const resolved = path.resolve(dir, binRelative);
+            if (fs.existsSync(resolved)) return resolved;
+          }
+          break;
+        }
+      } catch {
+        // package.json missing or invalid — keep walking
       }
+      const parent = path.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
     }
-  });
+  } catch {
+    // fall through
+  }
+  return "pi";
+}
+
+/**
+ * Start a Unix socket server that bridges the child's ask tool to the parent bus.
+ *
+ * The child's ask tool (in packages/ask) connects to PI_SUBAGENT_SOCKET and sends:
+ *   { type: "ask_request", requestId, questions } as a JSON line
+ * and waits for:
+ *   { type: "ask_response", requestId, cancelled, results } as a JSON line
+ *
+ * We forward the request onto the bus (ASK_REQUEST), the ask package shows the
+ * parent TUI dialog, then emits ASK_RESPONSE on the bus, and we write it back
+ * to the socket connection.
+ *
+ * Returns the socket path and a cleanup function.
+ */
+function startAskSocketServer(agentName: string): { socketPath: string; cleanup: () => void } {
+  // Use named pipes on Windows, Unix domain sockets elsewhere.
+  // Linux socket path limit is 108 chars — keep it short.
+  const id = randomUUID().slice(0, 8);
+  const socketPath =
+    process.platform === "win32"
+      ? `\\\\.\\pipe\\pi-ask-${id}`
+      : path.join(os.tmpdir(), `pi-ask-${id}.sock`);
 
-  // Handle ask responses from bus → send to child via IPC
-  const unsubAskResponse = getBus().on(Events.ASK_RESPONSE, (payload: unknown) => {
+  // Map of pending ask requests: requestId → write-back callback
+  const pending = new Map<string, (response: unknown) => void>();
+
+  // Listen for ASK_RESPONSE from the bus and route back to the waiting socket conn
+  const unsubResponse = getBus().on(Events.ASK_RESPONSE, (payload: unknown) => {
     const data = payload as {
       requestId: string;
       cancelled: boolean;
       results: Array<{ id: string; selectedOptions: string[]; customInput?: string }>;
     };
-    const responseMsg: ParentToChild = {
-      type: "ask_response",
-      requestId: data.requestId,
-      cancelled: data.cancelled,
-      results: data.results,
-    };
-    child.send(responseMsg);
+    const send = pending.get(data.requestId);
+    if (send) {
+      pending.delete(data.requestId);
+      send({
+        type: "ask_response",
+        requestId: data.requestId,
+        cancelled: data.cancelled,
+        results: data.results,
+      });
+    }
+  });
+
+  const server = net.createServer((socket) => {
+    let buffer = "";
+
+    socket.on("data", (chunk: Buffer) => {
+      buffer += chunk.toString("utf-8");
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        try {
+          const msg = JSON.parse(trimmed) as {
+            type: string;
+            requestId: string;
+            questions: unknown[];
+          };
+          if (msg.type === "ask_request") {
+            // Register write-back so ASK_RESPONSE handler can find this socket
+            pending.set(msg.requestId, (response) => {
+              try {
+                socket.write(JSON.stringify(response) + "\n");
+              } catch {
+                // socket already closed
+              }
+            });
+            // Forward to bus — ask package will show the TUI dialog
+            getBus().emit(Events.ASK_REQUEST, {
+              source: `subagent:${agentName}`,
+              requestId: msg.requestId,
+              questions: msg.questions,
+            });
+          }
+        } catch {
+          // malformed JSON — ignore
+        }
+      }
+    });
+
+    socket.on("error", () => { /* connection dropped */ });
   });
 
+  server.listen(socketPath);
+
+  const cleanup = () => {
+    unsubResponse();
+    server.close();
+    // Named pipes on Windows are cleaned up automatically; only unlink on Unix
+    if (process.platform !== "win32") {
+      try { fs.unlinkSync(socketPath); } catch { /* already gone */ }
+    }
+  };
+
+  return { socketPath, cleanup };
+}
+
+/**
+ * Spawn a subagent as a fresh `pi --mode json --no-session -p <task>` process.
+ *
+ * A Unix socket server is started in the parent to bridge the child's ask tool
+ * back to the parent's TUI dialog. The socket path is passed via PI_SUBAGENT_SOCKET.
+ */
+export function spawnSubagent(options: SpawnOptions): ChildProcess {
+  const piBinary = resolvePiBinary();
+  const agentName = options.agent?.name ?? "general";
+
+  // Start ask bridge socket before spawning so the env var is ready
+  const { socketPath, cleanup: cleanupSocket } = startAskSocketServer(agentName);
+
+  // Build CLI args
+  const args: string[] = ["--mode", "json", "--no-session", "-p"];
+
+  // Model: agent.model > options.model > options.activeModel
+  const model = options.agent?.model ?? options.model ?? options.activeModel;
+  if (model) {
+    args.push("--model", model);
+  }
+
+  // Thinking level from agent config
+  if (options.agent?.thinking) {
+    args.push("--thinking", options.agent.thinking);
+  }
+
+  // Tool allowlist from agent config
+  if (options.agent?.tools && options.agent.tools.length > 0) {
+    args.push("--tools", options.agent.tools.join(","));
+  }
+
+  // Always exclude the subagent tool itself to prevent infinite recursion
+  args.push("--exclude-tools", "subagent");
+
+  // Agent system prompt
+  const systemPrompt = options.agent?.systemPrompt?.trim();
+  if (systemPrompt) {
+    args.push("--system-prompt", systemPrompt);
+  }
+
+  // The task is the final positional argument
+  args.push(options.task);
+
+  const child = spawn(piBinary, args, {
+    cwd: options.cwd || process.cwd(),
+    env: {
+      ...process.env,
+      PI_SUBAGENT_SOCKET: socketPath,
+    },
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+
+  // Clean up socket server when child exits
+  child.on("exit", cleanupSocket);
+  child.on("error", cleanupSocket);
+
   // Handle abort signal
-  let abortHandler: (() => void) | undefined;
   if (options.signal) {
-    abortHandler = () => {
-      // Send abort message to child before killing
-      child.send({ type: "abort" });
+    const abortHandler = () => {
       if (child.pid && !child.killed) {
         child.kill("SIGTERM");
         const forceKill = setTimeout(() => {
@@ -106,19 +233,8 @@ export function spawnSubagent(options: SpawnOptions): ChildProcess {
       }
     };
     options.signal.addEventListener("abort", abortHandler, { once: true });
+    child.on("exit", () => options.signal!.removeEventListener("abort", abortHandler));
   }
 
-  // Clean up on exit
-  const exitCleanup = (): void => {
-    child.removeListener("exit", exitCleanup);
-    child.removeListener("error", exitCleanup);
-    if (abortHandler && options.signal) {
-      options.signal.removeEventListener("abort", abortHandler);
-    }
-    unsubAskResponse();
-  };
-  child.on("exit", exitCleanup);
-  child.on("error", exitCleanup);
-
   return child;
 }

package/src/stream.ts

@@ -1,5 +1,5 @@
+import { createInterface } from "node:readline";
 import type { ChildProcess } from "node:child_process";
-import type { ChildToParent } from "./ipc-types.js";
 import type { StreamState, SubagentProgress, SubagentResult } from "./types.js";
 import { getBus, Events } from "@pi-archimedes/core/bus";
 import {
@@ -18,7 +18,11 @@ export interface StreamCallbacks {
 }
 
 /**
- * Stream JSON events from a child pi process and build progress/result.
+ * Stream JSON events from a child `pi --mode json` process and build progress/result.
+ *
+ * The child writes one JSON object per line to stdout. We read each line via
+ * readline, parse it, and dispatch to the same handler functions used previously.
+ * stderr is drained silently (captured as the error string on non-zero exit).
  */
 export function streamEvents(
   child: ChildProcess,
@@ -27,20 +31,15 @@ export function streamEvents(
   return new Promise((resolve, reject) => {
     const startTime = Date.now();
 
-    // Startup safeguard: if the child produces no JSON event within
-    // STARTUP_TIMEOUT_MS, kill it. This guards against hangs during pi
-    // initialization (model never loads, auth fails, etc.) and is the only
-    // automatic timeout. Once any event arrives the model is considered
-    // active and runtime is controlled entirely by the user's abort
-    // signal — a model that is REALLY thinking is left alone until the
-    // user explicitly cancels.
+    // Startup safeguard: if no JSON event arrives within 2 minutes, kill the child.
     const STARTUP_TIMEOUT_MS = 2 * 60 * 1000;
-
     let startupTimer: NodeJS.Timeout | undefined = setTimeout(() => {
       child.kill("SIGKILL");
-      reject(new Error(
-        `subagent timed out: no model output within ${STARTUP_TIMEOUT_MS / 60_000} minutes of startup`,
-      ));
+      reject(
+        new Error(
+          `subagent timed out: no output within ${STARTUP_TIMEOUT_MS / 60_000} minutes of startup`,
+        ),
+      );
     }, STARTUP_TIMEOUT_MS);
 
     const clearStartupTimer = (): void => {
@@ -67,9 +66,13 @@ export function streamEvents(
       toolCalls: [],
       finalOutput: undefined,
     };
+
+    // Collect stderr for error reporting
+    const stderrChunks: Buffer[] = [];
+    child.stderr?.on("data", (chunk: Buffer) => stderrChunks.push(chunk));
+
     let error: string | undefined;
 
-    // Build progress from state
     const buildProgress = (): SubagentProgress => ({
       agent: callbacks.agent ?? "subagent",
       status: "running",
@@ -84,43 +87,50 @@ export function streamEvents(
       cost: state.totalCost,
       durationMs: Date.now() - startTime,
       error,
-      output: state.accumulatedOutput.length > 0 ? state.accumulatedOutput.join("\n\n") : undefined,
+      output:
+        state.accumulatedOutput.length > 0
+          ? state.accumulatedOutput.join("\n\n")
+          : undefined,
       recentOutput: state.recentOutput.length > 0 ? state.recentOutput : undefined,
       toolCalls: state.toolCalls.length > 0 ? state.toolCalls : undefined,
       model: state.model,
     });
 
-    const emitProgress = () => {
-      callbacks.onProgress?.(buildProgress());
-    };
+    const emitProgress = () => callbacks.onProgress?.(buildProgress());
 
-    // Periodic progress updates for live duration display
+    // Periodic heartbeat for live duration display
     const heartbeat = setInterval(emitProgress, 1000);
 
-    // Listen for IPC messages from child
-    child.on("message", (msg: unknown) => {
-      const childMsg = msg as ChildToParent;
+    // Read stdout as newline-delimited JSON
+    if (!child.stdout) {
+      clearStartupTimer();
+      clearInterval(heartbeat);
+      reject(new Error("subagent child has no stdout pipe"));
+      return;
+    }
 
-      // Handle error messages from child
-      if (childMsg.type === "error") {
-        error = childMsg.message;
-        return;
-      }
+    const rl = createInterface({ input: child.stdout, crlfDelay: Infinity });
 
-      // Only process "event" messages (AgentSessionEvent forwarded from child)
-      if (childMsg.type !== "event") return;
+    rl.on("line", (line) => {
+      const trimmed = line.trim();
+      if (!trimmed) return;
 
-      const event = childMsg.event as JsonEvent;
+      let event: JsonEvent;
+      try {
+        event = JSON.parse(trimmed) as JsonEvent;
+      } catch {
+        // Non-JSON output — ignore (can happen from pi startup messages)
+        return;
+      }
 
-      // First event received from the child means the model has engaged —
-      // from here on, the user controls lifetime via the abort signal.
+      // First real event means model has engaged — cancel startup watchdog
       clearStartupTimer();
 
       switch (event.type) {
         case "tool_execution_start": {
           handleToolStart(state, event);
           emitProgress();
-          // Forward manage_todo_list writes to the bus for parent widget
+          // Forward manage_todo_list writes to the parent's todo widget
           if (event.toolName === "manage_todo_list") {
             const args = event.args as Record<string, unknown> | undefined;
             const todoList = args?.todoList as Array<unknown> | undefined;
@@ -136,7 +146,6 @@ export function streamEvents(
         case "tool_execution_end": {
           handleToolEnd(state);
           emitProgress();
-          // Also capture tool result output here (previously in tool_result_end)
           handleToolResult(state, event);
           emitProgress();
           break;
@@ -154,6 +163,7 @@ export function streamEvents(
           handleAgentEnd(state, event);
           break;
         }
+        // Ignore: session, agent_start, message_start, message_update, turn_end, tool_execution_update
       }
     });
 
@@ -164,7 +174,11 @@ export function streamEvents(
       const durationMs = Date.now() - startTime;
       const exitCode = code ?? 1;
 
-      // Error is set via IPC error messages or remains undefined
+      // Surface stderr as error if the process failed and we have no other error
+      if (exitCode !== 0 && !error) {
+        const stderr = Buffer.concat(stderrChunks).toString("utf-8").trim();
+        if (stderr) error = stderr;
+      }
 
       const result: SubagentResult = {
         agent: callbacks.agent ?? "subagent",
@@ -193,10 +207,9 @@ export function streamEvents(
         },
       };
 
-      // Final progress update
       callbacks.onProgress?.(result.progress!);
 
-      // Clear subagent todos from the bus on process exit
+      // Clear subagent todos from the bus on exit
       getBus().emit(Events.TODOS_CLEAR, {
         source: `subagent:${callbacks.agent ?? "general"}`,
       });

package/src/child.ts

@@ -1,299 +0,0 @@
-/**
- * Forked child entry point for IPC-based subagent architecture.
- *
- * This script is forked by the parent process. It receives an "init" message
- * with task and configuration, creates an AgentSession, runs the agent loop,
- * and streams events back to the parent over IPC.
- *
- * Usage: node child.js (forked with stdio: ["pipe", "pipe", "pipe", "ipc"])
- */
-
-import {
-  createAgentSession,
-  SessionManager,
-} from "@earendil-works/pi-coding-agent";
-import type { Model } from "@earendil-works/pi-ai";
-import type { ParentToChild, ChildToParent, SerializedAgentEvent } from "./ipc-types.ts";
-import { createIpcAskTool } from "./ipc-ask-tool.ts";
-
-// ── Types ───────────────────────────────────────────────────────────────────
-
-type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
-
-interface InitParams {
-  task: string;
-  model: string | undefined;
-  agentName: string | undefined;
-  agentSystemPrompt: string | undefined;
-  agentTools: string[] | undefined;
-  agentModel: string | undefined;
-  agentThinking: string | undefined;
-  cwd: string | undefined;
-}
-
-// ── Model resolution ────────────────────────────────────────────────────────
-
-/**
- * Known providers' default model ids (subset of pi's defaultModelPerProvider).
- * Used by buildFallbackModel to pick a template model when the requested
- * model id isn't in the registry (e.g. newly-released openrouter models).
- */
-const DEFAULT_MODEL_PER_PROVIDER: Record<string, string | undefined> = {
-  openrouter: "anthropic/claude-sonnet-4-5",
-  anthropic: "claude-sonnet-4-5",
-  openai: "gpt-4o",
-  google: "gemini-2.5-pro",
-  // fall back to first model of provider when undefined
-};
-
-/**
- * Build a fallback model for a known provider when the exact model id isn't
- * registered. Mirrors pi's buildFallbackModel(): take the provider's default
- * model as a template and override id/name with the requested modelId.
- */
-function buildFallbackModel(provider: string, modelId: string, available: Model<any>[]): Model<any> | undefined {
-  const providerModels = available.filter((m) => m.provider === provider);
-  if (providerModels.length === 0) return undefined;
-  const defaultId = DEFAULT_MODEL_PER_PROVIDER[provider];
-  const baseModel = defaultId
-    ? (providerModels.find((m) => m.id === defaultId) ?? providerModels[0]!)
-    : providerModels[0]!;
-  return { ...baseModel, id: modelId, name: modelId };
-}
-
-interface ModelRegistryLike {
-  find(provider: string, modelId: string): Model<any> | undefined;
-  getAll(): Model<any>[];
-}
-
-/**
- * Resolve a model reference the same way the pi CLI does (resolveCliModel).
- *
- * Supports:
- * - "provider/modelId" where provider is a known provider
- * - "modelId" containing slashes (e.g. openrouter's "z-ai/glm-5.2")
- * - bare "modelId"
- * - fuzzy/partial matching on id within a provider
- * - fallback: build a custom model for a known provider when the id isn't
- *   registered (handles newly-released models like openrouter/z-ai/glm-5.2)
- *
- * The registry must include extension-registered providers (e.g. "tama"),
- * which is why this is called AFTER createAgentSession has loaded
- * extensions — not with a bare ModelRegistry.create() that only knows
- * built-ins + models.json.
- */
-function resolveModel(modelString: string | undefined, registry: ModelRegistryLike): Model<any> | undefined {
-  if (!modelString) return undefined;
-  const cliModel = modelString.trim();
-  if (!cliModel) return undefined;
-
-  const available = registry.getAll();
-  if (available.length === 0) return undefined;
-
-  const lower = cliModel.toLowerCase();
-
-  // Build canonical provider lookup (case-insensitive)
-  const providerMap = new Map<string, string>();
-  for (const m of available) {
-    if (!providerMap.has(m.provider.toLowerCase())) {
-      providerMap.set(m.provider.toLowerCase(), m.provider);
-    }
-  }
-
-  // If the input is a full canonical "provider/id", match it directly.
-  // This handles models whose ids contain slashes (e.g. openrouter "z-ai/glm-5.2").
-  const canonicalMatch = available.find(
-    (m) => `${m.provider}/${m.id}`.toLowerCase() === lower,
-  );
-  if (canonicalMatch) return canonicalMatch;
-
-  // Try interpreting "provider/modelId" when the prefix is a known provider.
-  const slashIndex = cliModel.indexOf("/");
-  if (slashIndex !== -1) {
-    const maybeProvider = cliModel.substring(0, slashIndex);
-    const canonicalProvider = providerMap.get(maybeProvider.toLowerCase());
-    if (canonicalProvider) {
-      const modelId = cliModel.substring(slashIndex + 1);
-      // Exact match within provider
-      const within = available.filter(
-        (m) => m.provider === canonicalProvider && m.id.toLowerCase() === modelId.toLowerCase(),
-      );
-      if (within.length === 1) return within[0];
-      // Fallback: unknown model id on a known provider → build a custom model
-      return buildFallbackModel(canonicalProvider, modelId, available);
-    }
-  }
-
-  // Bare id (no slash, or slash prefix isn't a known provider) — exact id match
-  const idMatches = available.filter((m) => m.id.toLowerCase() === lower);
-  if (idMatches.length === 1) return idMatches[0];
-
-  return undefined;
-}
-
-// ── Thinking level parsing ──────────────────────────────────────────────────
-
-function parseThinkingLevel(level: string | undefined): ThinkingLevel | undefined {
-  if (!level) return undefined;
-  const validLevels: readonly ThinkingLevel[] = [
-    "off",
-    "minimal",
-    "low",
-    "medium",
-    "high",
-    "xhigh",
-  ];
-  if (validLevels.includes(level as ThinkingLevel)) {
-    return level as ThinkingLevel;
-  }
-  return undefined;
-}
-
-// ── Parent message handler ──────────────────────────────────────────────────
-
-let session: Awaited<ReturnType<typeof createAgentSession>>["session"] | null = null;
-
-function handleParentMessage(msg: ParentToChild): void {
-  switch (msg.type) {
-    case "abort": {
-      session?.abort();
-      break;
-    }
-    // "init" is handled synchronously before this listener is set up
-    // "ask_response" is handled by the IPC ask tool's own per-execution listener
-  }
-}
-
-// ── Event serialization ─────────────────────────────────────────────────────
-
-/**
- * Strip non-serializable fields (functions, symbols) from events.
- */
-function serializeEvent(event: Record<string, unknown>): Record<string, unknown> {
-  return JSON.parse(JSON.stringify(event));
-}
-
-// ── Send helper ─────────────────────────────────────────────────────────────
-
-function sendToParent(msg: ChildToParent): void {
-  process.send?.(msg);
-}
-
-// ── Main ────────────────────────────────────────────────────────────────────
-
-async function main(): Promise<void> {
-  // Wait for the "init" message from parent.
-  let initParams: InitParams | null = null;
-
-  const initPromise = new Promise<InitParams>((resolve) => {
-    const handler = (msg: ParentToChild) => {
-      if (msg.type === "init") {
-        process.removeListener("message", handler);
-        resolve({
-          task: msg.task,
-          model: msg.model,
-          agentName: msg.agentName,
-          agentSystemPrompt: msg.agentSystemPrompt,
-          agentTools: msg.agentTools,
-          agentModel: msg.agentModel,
-          agentThinking: msg.agentThinking,
-          cwd: msg.cwd,
-        });
-      }
-    };
-    process.on("message", handler);
-  });
-
-  initParams = await initPromise;
-
-  // Resolve thinking level from agent config.
-  const thinkingLevel = parseThinkingLevel(initParams.agentThinking);
-
-  // Build tools allowlist from agent config.
-  const tools = initParams.agentTools;
-
-  // Build options object — omit undefined values to satisfy exactOptionalPropertyTypes.
-  // NOTE: we deliberately do NOT pass authStorage/modelRegistry/settingsManager —
-  // createAgentSession builds a DefaultResourceLoader that loads extensions
-  // (including custom providers like "tama") and registers them into the
-  // registry. Passing a bare ModelRegistry.create() would skip extension
-  // loading and break custom-provider model resolution.
-  const sessionOptions: Parameters<typeof createAgentSession>[0] = {
-    excludeTools: ["subagent"],
-    customTools: [createIpcAskTool()],
-    sessionManager: SessionManager.inMemory(),
-    ...(thinkingLevel ? { thinkingLevel } : {}),
-    ...(initParams.cwd ? { cwd: initParams.cwd } : {}),
-    ...(tools ? { tools } : {}),
-  };
-
-  // Create the agent session with IPC ask tool for user questions.
-  // The session loads extensions (custom providers) and picks the settings
-  // default model when none is passed.
-  const { session: agentSession } = await createAgentSession(sessionOptions);
-
-  session = agentSession;
-
-  // If a specific model was requested, resolve it through the session's
-  // registry (which now includes extension-registered providers) and switch
-  // to it. This handles "tama/whatevers-hot-n-fresh" and bare ids like "glm".
-  const modelString = initParams.agentModel ?? initParams.model;
-  const resolvedModel = resolveModel(modelString, session.modelRegistry);
-  if (resolvedModel && (session.model?.provider !== resolvedModel.provider || session.model?.id !== resolvedModel.id)) {
-    await session.setModel(resolvedModel);
-  }
-
-  // Bind extensions with empty bindings (no UI, no command context).
-  await session.bindExtensions({});
-
-  // Subscribe to agent events and stream them to parent.
-  session.subscribe((event) => {
-    const serialized = serializeEvent(event);
-    sendToParent({ type: "event", event: serialized as SerializedAgentEvent });
-
-    // On agent_end, exit the process.
-    if (event.type === "agent_end") {
-      const willRetry = (event as { willRetry?: boolean }).willRetry ?? false;
-      if (!willRetry) {
-        // Give events time to flush, then exit.
-        setTimeout(() => {
-          process.exit(0);
-        }, 100);
-      }
-    }
-  });
-
-  // Set up parent message handler for ask_response and abort.
-  process.on("message", handleParentMessage);
-
-  // Send ready signal to parent.
-  sendToParent({ type: "ready" });
-
-  // Start the agent loop.
-  // Prepend the agent's system prompt to the first prompt (no SDK-level systemPrompt option).
-  const fullPrompt = initParams.agentSystemPrompt && initParams.agentSystemPrompt.trim()
-    ? `${initParams.agentSystemPrompt}\n\n---\n\n${initParams.task}`
-    : initParams.task;
-  await session.prompt(fullPrompt);
-}
-
-// ── Graceful shutdown ───────────────────────────────────────────────────────
-
-function gracefulShutdown(signal: string): void {
-  if (session) {
-    session.abort();
-    session.dispose();
-  }
-  process.exit(signal === "SIGTERM" ? 143 : 130);
-}
-
-process.on("SIGTERM", () => gracefulShutdown("SIGTERM"));
-process.on("SIGINT", () => gracefulShutdown("SIGINT"));
-
-// ── Entry point ─────────────────────────────────────────────────────────────
-
-main().catch((err) => {
-  const message = err instanceof Error ? err.message : String(err);
-  sendToParent({ type: "error", message });
-  process.exit(1);
-});

package/src/ipc-ask-tool.ts

@@ -1,242 +0,0 @@
-/**
- * Minimal "ask" tool for the forked child process.
- *
- * Uses IPC (process.send / process.on("message")) to forward questions
- * to the parent, which displays the UI and sends back the response.
- */
-
-import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
-import { Type, type Static } from "typebox";
-import { randomUUID } from "node:crypto";
-
-// ── Schema (matches the existing ask tool) ───────────────────────────────────
-
-const OptionItemSchema = Type.Object({
-  label: Type.String({ description: "Display label" }),
-});
-
-const QuestionItemSchema = Type.Object({
-  id: Type.String({ description: "Question id" }),
-  question: Type.String({ description: "Question text" }),
-  description: Type.Optional(Type.String({
-    description: "Optional context in Markdown/plain text.",
-  })),
-  options: Type.Array(OptionItemSchema, {
-    description: "Available options. Do not include 'Other'.",
-    minItems: 1,
-  }),
-  multi: Type.Optional(Type.Boolean({ description: "Allow multi-select" })),
-  recommended: Type.Optional(Type.Number({
-    description: "0-indexed recommended option.",
-  })),
-});
-
-const AskParamsSchema = Type.Object({
-  questions: Type.Array(QuestionItemSchema, { description: "Questions to ask", minItems: 1 }),
-});
-
-type AskParams = Static<typeof AskParamsSchema>;
-
-// ── Session content helpers (minimal from packages/ask) ──────────────────────
-
-interface QuestionResult {
-  id: string;
-  question: string;
-  description: string | undefined;
-  options: string[];
-  multi: boolean;
-  selectedOptions: string[];
-  customInput: string | undefined;
-}
-
-function sanitizeForSessionText(value: string): string {
-  return value
-    .replace(/[\r\n\t]/g, " ")
-    .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "")
-    .replace(/\s{2,}/g, " ")
-    .trim();
-}
-
-function sanitizeMultilineForSessionText(value: string): string {
-  return value
-    .replace(/\r\n/g, "\n")
-    .replace(/\r/g, "\n")
-    .split("\n")
-    .map((line) => sanitizeForSessionText(line))
-    .join("\n")
-    .trim();
-}
-
-function toSessionSafeQuestionResult(result: QuestionResult): QuestionResult {
-  const selectedOptions = result.selectedOptions
-    .map(sanitizeForSessionText)
-    .filter((s) => s.length > 0);
-
-  const rawDescription = result.description;
-  const description = rawDescription == null ? undefined : sanitizeMultilineForSessionText(rawDescription);
-  const rawCustomInput = result.customInput;
-  const customInput = rawCustomInput == null ? undefined : sanitizeForSessionText(rawCustomInput);
-
-  return {
-    id: sanitizeForSessionText(result.id) || "(unknown)",
-    question: sanitizeForSessionText(result.question) || "(empty question)",
-    description: description && description.length > 0 ? description : undefined,
-    options: result.options.map((o) => sanitizeForSessionText(o) || "(empty option)"),
-    multi: result.multi,
-    selectedOptions,
-    customInput: customInput && customInput.length > 0 ? customInput : undefined,
-  };
-}
-
-function formatSelectionForSummary(result: QuestionResult): string {
-  const hasSelected = result.selectedOptions.length > 0;
-  const hasCustom = Boolean(result.customInput);
-
-  if (!hasSelected && !hasCustom) return "(cancelled)";
-  if (hasSelected && hasCustom) {
-    const selected = result.multi ? `[${result.selectedOptions.join(", ")}]` : result.selectedOptions[0] ?? "";
-    return `${selected} + Other: "${result.customInput}"`;
-  }
-  if (hasCustom) return `"${result.customInput}"`;
-  if (result.multi) return `[${result.selectedOptions.join(", ")}]`;
-  return result.selectedOptions[0] ?? "";
-}
-
-function formatQuestionResult(result: QuestionResult): string {
-  return `${result.id}: ${formatSelectionForSummary(result)}`;
-}
-
-function formatQuestionContext(result: QuestionResult, index: number): string {
-  const lines: string[] = [
-    `Question ${index + 1} (${result.id})`,
-    `Prompt: ${result.question}`,
-  ];
-
-  if (result.description) {
-    lines.push("Context:");
-    for (const line of result.description.split("\n")) {
-      lines.push(`  ${line}`);
-    }
-  }
-
-  lines.push("Options:");
-  lines.push(...result.options.map((opt, i) => `  ${i + 1}. ${opt}`));
-  lines.push("Response:");
-
-  const hasSelected = result.selectedOptions.length > 0;
-  const hasCustom = Boolean(result.customInput);
-
-  if (!hasSelected && !hasCustom) {
-    lines.push("  Selected: (cancelled)");
-    return lines.join("\n");
-  }
-
-  if (hasSelected) {
-    const text = result.multi ? `[${result.selectedOptions.join(", ")}]` : result.selectedOptions[0];
-    lines.push(`  Selected: ${text}`);
-  }
-
-  if (hasCustom) {
-    if (!hasSelected) lines.push("  Selected: (Other)");
-    lines.push(`  Custom input: ${result.customInput}`);
-  }
-
-  return lines.join("\n");
-}
-
-function buildAskSessionContent(results: QuestionResult[]): string {
-  const safe = results.map(toSessionSafeQuestionResult);
-  const summary = safe.map(formatQuestionResult).join("\n");
-  const context = safe.map((r, i) => formatQuestionContext(r, i)).join("\n\n");
-  return `User answers:\n${summary}\n\nAnswer context:\n${context}`;
-}
-
-// ── Tool definition ─────────────────────────────────────────────────────────
-
-const ASK_TOOL_DESCRIPTION = `
-Ask the user for clarification when a choice materially affects the outcome.
-
-- Use when multiple valid approaches have different trade-offs.
-- Prefer 2-5 concise options.
-- Use multi=true when multiple answers are valid.
-- Use recommended=<index> (0-indexed) to mark the default option.
-- Use description to provide Markdown/plain context.
-- You can ask multiple related questions in one call using questions[].
-- Do NOT include an 'Other' option; UI adds it automatically.
-`.trim();
-
-export function createIpcAskTool(): ToolDefinition<any, unknown, any> {
-  return {
-    name: "ask",
-    label: "Ask",
-    description: ASK_TOOL_DESCRIPTION,
-    parameters: AskParamsSchema,
-
-    async execute(_toolCallId, params: AskParams, _signal, _onUpdate, _ctx) {
-      const requestId = randomUUID();
-      const questions = params.questions;
-
-      // Send ask_request to parent via IPC.
-      process.send?.({ type: "ask_request", requestId, questions });
-
-      // Await response from parent.
-      const response = await new Promise<{
-        cancelled: boolean;
-        results: Array<{ id: string; selectedOptions: string[]; customInput?: string }>;
-      }>((resolve) => {
-        let resolved = false;
-        const finish = (r: { cancelled: boolean; results: Array<{ id: string; selectedOptions: string[]; customInput?: string }> }) => {
-          if (resolved) return;
-          resolved = true;
-          clearTimeout(timer);
-          process.removeListener("message", listener);
-          resolve(r);
-        };
-
-        const listener = (msg: { type?: string; requestId?: string; cancelled?: boolean; results?: unknown[] }) => {
-          if (msg.type === "ask_response" && msg.requestId === requestId) {
-            finish({
-              cancelled: msg.cancelled ?? true,
-              results: msg.results as Array<{ id: string; selectedOptions: string[]; customInput?: string }>,
-            });
-          }
-        };
-        process.on("message", listener);
-
-        // 5-minute timeout.
-        const timer = setTimeout(() => {
-          finish({ cancelled: true, results: questions.map((q) => ({ id: q.id, selectedOptions: [] })) });
-        }, 5 * 60 * 1000);
-        timer.unref();
-      });
-
-      // Build results matching the existing ask tool's format.
-      const results: QuestionResult[] = questions.map((q, i) => {
-        const r = response.results[i];
-        return {
-          id: q.id,
-          question: q.question,
-          description: q.description && q.description.trim().length > 0 ? q.description : undefined,
-          options: q.options.map((o) => o.label),
-          multi: q.multi ?? false,
-          selectedOptions: r?.selectedOptions ?? [],
-          customInput: r?.customInput ?? undefined,
-        };
-      });
-
-      const contentText = buildAskSessionContent(results);
-
-      if (response.cancelled && results.every((r) => r.selectedOptions.length === 0)) {
-        return {
-          content: [{ type: "text", text: "User cancelled the question." }],
-          details: {},
-        };
-      }
-
-      return {
-        content: [{ type: "text", text: contentText }],
-        details: {},
-      };
-    },
-  };
-}

package/src/ipc-types.ts

@@ -1,79 +0,0 @@
-/**
- * Shared IPC message types for fork+IPC subagent architecture.
- *
- * Parent sends "init" first, then "ask_response" / "abort".
- * Child sends "ready" after init, then "event" / "ask_request" / "error".
- */
-
-// ── Parent → Child ──────────────────────────────────────────────────────────
-
-export type ParentToChild =
-  | {
-      type: "ask_response";
-      requestId: string;
-      cancelled: boolean;
-      results: Array<{
-        id: string;
-        selectedOptions: string[];
-        customInput?: string;
-      }>;
-    }
-  | {
-      type: "abort";
-    }
-  | {
-      type: "init";
-      task: string;
-      model?: string;
-      agentName?: string;
-      agentSystemPrompt?: string;
-      agentTools?: string[];
-      agentModel?: string;
-      agentThinking?: string;
-      cwd?: string;
-    };
-
-// ── Serialized agent events ─────────────────────────────────────────────────
-// Matches the event types forwarded by stream.ts. Nested fields use `unknown`
-// because they contain complex objects (AgentMessage, etc.) serialized via
-// JSON.parse(JSON.stringify()). The key point is typing the `type` discriminator
-// and the top-level field names.
-
-export type SerializedAgentEvent =
-  | { type: "agent_start" }
-  | { type: "agent_end"; messages: unknown[]; willRetry?: boolean }
-  | { type: "turn_start" }
-  | { type: "turn_end"; message: unknown; toolResults: unknown[] }
-  | { type: "message_start"; message: unknown }
-  | { type: "message_update"; message: unknown; assistantMessageEvent: unknown }
-  | { type: "message_end"; message: unknown }
-  | { type: "tool_execution_start"; toolCallId: string; toolName: string; args: unknown }
-  | { type: "tool_execution_update"; toolCallId: string; toolName: string; args: unknown; partialResult: unknown }
-  | { type: "tool_execution_end"; toolCallId: string; toolName: string; result: unknown; isError: boolean };
-
-// ── Child → Parent ──────────────────────────────────────────────────────────
-
-export type ChildToParent =
-  | {
-      type: "event";
-      event: SerializedAgentEvent;
-    }
-  | {
-      type: "ask_request";
-      requestId: string;
-      questions: Array<{
-        id: string;
-        question: string;
-        description?: string;
-        options: Array<{ label: string }>;
-        multi?: boolean;
-        recommended?: number;
-      }>;
-    }
-  | {
-      type: "ready";
-    }
-  | {
-      type: "error";
-      message: string;
-    };