@jyork0828/pi-pilot 0.0.5 → 0.0.7

package/dist/index.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { existsSync } from "fs";
-import { readFile as readFile5 } from "fs/promises";
-import { dirname as dirname6, extname, join as join9, resolve as resolve5, sep as sep3 } from "path";
-import { fileURLToPath } from "url";
+import { existsSync as existsSync2 } from "fs";
+import { readFile as readFile9 } from "fs/promises";
+import { dirname as dirname6, extname, join as join16, resolve as resolve7, sep as sep3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import { serve } from "@hono/node-server";
-import { Hono as Hono4 } from "hono";
+import { Hono as Hono6 } from "hono";
 import { cors } from "hono/cors";
 
 // src/config.ts
@@ -41,9 +41,9 @@ function configureHttpProxy() {
 }
 
 // src/api/workspaces.ts
-import { stat as stat2 } from "fs/promises";
-import { basename as basename2, isAbsolute as isAbsolute3, resolve as resolve3 } from "path";
-import { Hono } from "hono";
+import { readFile as readFile7, stat as stat2 } from "fs/promises";
+import { basename as basename2, isAbsolute as isAbsolute3, resolve as resolve5 } from "path";
+import { Hono as Hono2 } from "hono";
 
 // src/storage/resource-writer.ts
 import {
@@ -54,7 +54,7 @@ import {
   unlink,
   writeFile
 } from "fs/promises";
-import { dirname, isAbsolute, join as join2, resolve, sep } from "path";
+import { basename, dirname, isAbsolute, join as join2, resolve, sep } from "path";
 var SKILL_NAME_RE = /^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/;
 var PROMPT_NAME_RE = /^[a-z0-9_](?:[a-z0-9_-]{0,62}[a-z0-9_])?$/;
 function ensureSkillName(name) {
@@ -277,9 +277,9 @@ async function updatePrompt(opts) {
     await writeFile(newPath, text, "utf8");
     try {
       await unlink(opts.filePath);
-    } catch (err) {
+    } catch (err2) {
       await unlink(newPath).catch(() => void 0);
-      throw err;
+      throw err2;
     }
     return newPath;
   }
@@ -311,7 +311,7 @@ async function readPromptFile(filePath, roots) {
   assertUnder(filePath, [roots.userPrompts, roots.projectPrompts]);
   const text = await readFile(filePath, "utf8");
   const { frontmatter, body } = parseFile(text);
-  const stem = basename(filePath).replace(/\.md$/, "");
+  const stem = basename(filePath, ".md");
   return {
     body,
     name: stem,
@@ -319,10 +319,6 @@ async function readPromptFile(filePath, roots) {
     argumentHint: stringOr(frontmatter["argument-hint"], void 0)
   };
 }
-function basename(p) {
-  const parts = p.split(sep);
-  return parts.at(-1) || p;
-}
 function stringOr(value, fallback) {
   return typeof value === "string" ? value : fallback;
 }
@@ -338,38 +334,72 @@ async function exists(p) {
   }
 }
 var HttpError = class extends Error {
-  constructor(status, message) {
+  constructor(status2, message) {
     super(message);
-    this.status = status;
+    this.status = status2;
   }
   status;
 };
 
 // src/storage/workspace-registry.ts
-import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname2, join as join3 } from "path";
+import { readFile as readFile2 } from "fs/promises";
+import { join as join3 } from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/storage/atomic-json.ts
+import { chmod, mkdir as mkdir2, rename, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2 } from "path";
 import { randomUUID } from "crypto";
+async function writeJsonAtomic(filePath, data, opts) {
+  await mkdir2(dirname2(filePath), { recursive: true });
+  const tmp = `${filePath}.${randomUUID()}.tmp`;
+  const text = JSON.stringify(data, null, 2);
+  try {
+    if (opts?.mode !== void 0) {
+      await writeFile2(tmp, text, { encoding: "utf8", mode: opts.mode });
+    } else {
+      await writeFile2(tmp, text, "utf8");
+    }
+    await rename(tmp, filePath);
+  } catch (err2) {
+    await rm2(tmp, { force: true }).catch(() => {
+    });
+    throw err2;
+  }
+  if (opts?.mode !== void 0) {
+    try {
+      await chmod(filePath, opts.mode);
+    } catch {
+    }
+  }
+}
+
+// src/storage/workspace-registry.ts
 var REGISTRY_PATH = join3(config.dataDir, "workspaces.json");
 var cache;
+var writeChain = Promise.resolve();
+function serializedWrite(fn) {
+  writeChain = writeChain.then(fn, fn);
+  return writeChain;
+}
 async function load() {
   if (cache) return cache;
   try {
     const raw = await readFile2(REGISTRY_PATH, "utf8");
     cache = JSON.parse(raw);
     if (!Array.isArray(cache.workspaces)) cache = { workspaces: [] };
-  } catch (err) {
-    if (err.code === "ENOENT") {
+  } catch (err2) {
+    if (err2.code === "ENOENT") {
       cache = { workspaces: [] };
     } else {
-      throw err;
+      throw err2;
     }
   }
   return cache;
 }
 async function save() {
   if (!cache) return;
-  await mkdir2(dirname2(REGISTRY_PATH), { recursive: true });
-  await writeFile2(REGISTRY_PATH, JSON.stringify(cache, null, 2), "utf8");
+  await writeJsonAtomic(REGISTRY_PATH, cache);
 }
 async function listWorkspaces() {
   const r = await load();
@@ -380,26 +410,70 @@ async function getWorkspace(id) {
   return r.workspaces.find((w) => w.id === id);
 }
 async function addWorkspace(input) {
-  const r = await load();
-  const existing = r.workspaces.find((w) => w.path === input.path);
-  if (existing) return existing;
-  const ws = {
-    id: randomUUID(),
-    name: input.name,
-    path: input.path,
-    addedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  r.workspaces.push(ws);
-  await save();
-  return ws;
+  let result;
+  await serializedWrite(async () => {
+    const r = await load();
+    const existing = r.workspaces.find((w) => w.path === input.path);
+    if (existing) {
+      result = existing;
+      return;
+    }
+    const ws = {
+      id: randomUUID2(),
+      name: input.name,
+      path: input.path,
+      addedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    r.workspaces.push(ws);
+    await save();
+    result = ws;
+  });
+  return result;
 }
 async function removeWorkspace(id) {
-  const r = await load();
-  const before = r.workspaces.length;
-  r.workspaces = r.workspaces.filter((w) => w.id !== id);
-  if (r.workspaces.length === before) return false;
-  await save();
-  return true;
+  let removed = false;
+  await serializedWrite(async () => {
+    const r = await load();
+    const before = r.workspaces.length;
+    r.workspaces = r.workspaces.filter((w) => w.id !== id);
+    if (r.workspaces.length === before) return;
+    removed = true;
+    await save();
+  });
+  return removed;
+}
+async function setWorkspaceTrustProjectAgents(id, trusted) {
+  let updated;
+  await serializedWrite(async () => {
+    const r = await load();
+    const ws = r.workspaces.find((w) => w.id === id);
+    if (!ws) return;
+    if (trusted) ws.trustProjectAgents = true;
+    else delete ws.trustProjectAgents;
+    await save();
+    updated = ws;
+  });
+  return updated;
+}
+async function reorderWorkspaces(ids) {
+  await serializedWrite(async () => {
+    const r = await load();
+    const byId = new Map(r.workspaces.map((w) => [w.id, w]));
+    const reordered = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const id of ids) {
+      const ws = byId.get(id);
+      if (ws && !seen.has(id)) {
+        reordered.push(ws);
+        seen.add(id);
+      }
+    }
+    for (const ws of r.workspaces) {
+      if (!seen.has(ws.id)) reordered.push(ws);
+    }
+    r.workspaces = reordered;
+    await save();
+  });
 }
 
 // src/storage/workspace-stats.ts
@@ -417,13 +491,14 @@ async function enrichWorkspace(ws) {
     path: ws.path,
     addedAt: ws.addedAt,
     gitBranch: stats.gitBranch,
-    fileCount: stats.fileCount
+    fileCount: stats.fileCount,
+    trustProjectAgents: ws.trustProjectAgents === true
   };
 }
 async function getStats(path) {
   const now = Date.now();
-  const cached = cache2.get(path);
-  if (cached && cached.expiresAt > now) return cached;
+  const cached2 = cache2.get(path);
+  if (cached2 && cached2.expiresAt > now) return cached2;
   const pending2 = inflight.get(path);
   if (pending2) return pending2;
   const probe = probeStats(path).then((stats) => {
@@ -493,66 +568,332 @@ async function runGit(cwd, args) {
 
 // src/workspace-manager.ts
 import { unlink as unlink2 } from "fs/promises";
-import { isAbsolute as isAbsolute2, resolve as resolve2 } from "path";
+import { isAbsolute as isAbsolute2, resolve as resolve4 } from "path";
 import {
   createAgentSessionFromServices,
   createAgentSessionRuntime,
   createAgentSessionServices,
-  getAgentDir,
+  getAgentDir as getAgentDir2,
   SessionManager
 } from "@earendil-works/pi-coding-agent";
 
-// src/extensions/plan/schema.ts
+// src/storage/session-tool-prefs.ts
+import { mkdir as mkdir3, readFile as readFile3, rename as rename2, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname3, join as join4, resolve as resolve2 } from "path";
+var PREFS_PATH = join4(config.dataDir, "session-tools.json");
+var cache3 = { sessions: {} };
+async function loadSessionToolPrefs() {
+  try {
+    const raw = await readFile3(PREFS_PATH, "utf8");
+    const parsed = JSON.parse(raw);
+    cache3 = { sessions: normalizeSessions(parsed.sessions) };
+  } catch (err2) {
+    cache3 = { sessions: {} };
+    if (err2.code !== "ENOENT") {
+      console.warn(`[session-tool-prefs] ignoring unreadable ${PREFS_PATH}:`, err2);
+    }
+  }
+}
+function keyOf(workspaceId, session) {
+  return session.sessionFile ? resolve2(session.sessionFile) : `${workspaceId}:${session.sessionId}`;
+}
+function storedDisabled(workspaceId, session) {
+  return cache3.sessions[keyOf(workspaceId, session)]?.disabled ?? [];
+}
+async function persistActiveTools(workspaceId, session, activeNames) {
+  const registered = session.getAllTools().map((t) => t.name);
+  const registeredSet = new Set(registered);
+  const active = new Set(activeNames);
+  const disabled = /* @__PURE__ */ new Set();
+  for (const name of registered) {
+    if (!active.has(name)) disabled.add(name);
+  }
+  for (const name of storedDisabled(workspaceId, session)) {
+    if (!registeredSet.has(name)) disabled.add(name);
+  }
+  cache3 = {
+    sessions: {
+      ...cache3.sessions,
+      [keyOf(workspaceId, session)]: {
+        disabled: sortUnique(disabled),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    }
+  };
+  await save2();
+  session.setActiveToolsByName(registered.filter((name) => !disabled.has(name)));
+}
+function reapplyToolPrefs(workspaceId, session) {
+  const disabled = storedDisabled(workspaceId, session);
+  if (disabled.length === 0) return;
+  const disabledSet = new Set(disabled);
+  const registered = session.getAllTools().map((t) => t.name);
+  session.setActiveToolsByName(registered.filter((name) => !disabledSet.has(name)));
+}
+async function forgetSessionToolPrefs(sessionPath) {
+  const key = resolve2(sessionPath);
+  if (!(key in cache3.sessions)) return;
+  const next = { ...cache3.sessions };
+  delete next[key];
+  cache3 = { sessions: next };
+  await save2();
+}
+function sortUnique(values) {
+  return [...new Set(values)].sort((a, b) => a.localeCompare(b));
+}
+function normalizeSessions(value) {
+  if (!value || typeof value !== "object") return {};
+  const out = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (!entry || typeof entry !== "object") continue;
+    const disabled = entry.disabled;
+    if (!Array.isArray(disabled)) continue;
+    const updatedAt = entry.updatedAt;
+    out[key] = {
+      disabled: sortUnique(disabled.filter((n) => typeof n === "string")),
+      updatedAt: typeof updatedAt === "string" ? updatedAt : (/* @__PURE__ */ new Date(0)).toISOString()
+    };
+  }
+  return out;
+}
+var writeChain2 = Promise.resolve();
+function save2() {
+  writeChain2 = writeChain2.catch(() => {
+  }).then(async () => {
+    await mkdir3(dirname3(PREFS_PATH), { recursive: true });
+    const tmp = `${PREFS_PATH}.tmp`;
+    await writeFile3(tmp, JSON.stringify(cache3, null, 2), "utf8");
+    await rename2(tmp, PREFS_PATH);
+  });
+  return writeChain2;
+}
+
+// src/extensions/todo/schema.ts
 import { Type } from "typebox";
-var planItemStatusSchema = Type.Union([
+var EMPTY_STATE = { tasks: [], nextId: 1 };
+var VALID_TRANSITIONS = {
+  pending: /* @__PURE__ */ new Set(["in_progress", "completed", "deleted"]),
+  in_progress: /* @__PURE__ */ new Set(["pending", "completed", "deleted"]),
+  completed: /* @__PURE__ */ new Set(["deleted"]),
+  deleted: /* @__PURE__ */ new Set()
+};
+function isTransitionValid(from, to) {
+  if (from === to) return true;
+  return VALID_TRANSITIONS[from].has(to);
+}
+var ActionEnum = Type.Union([
+  Type.Literal("create"),
+  Type.Literal("update"),
+  Type.Literal("list"),
+  Type.Literal("get"),
+  Type.Literal("delete"),
+  Type.Literal("clear")
+]);
+var StatusEnum = Type.Union([
   Type.Literal("pending"),
   Type.Literal("in_progress"),
-  Type.Literal("completed")
+  Type.Literal("completed"),
+  Type.Literal("deleted")
 ]);
-var planItemSchema = Type.Object({
-  id: Type.String({ description: 'Short stable identifier for the item (kebab-case, e.g. "wire-factory").' }),
-  title: Type.String({ description: "One-line description of the step. Specific and verifiable." }),
-  status: planItemStatusSchema,
-  note: Type.Optional(Type.String({ description: "Optional short context \u2014 blocker, decision, or follow-up." }))
-});
-var updatePlanParamsSchema = Type.Object({
-  items: Type.Array(planItemSchema, {
-    description: "The full ordered plan. Always send the complete list; previous tool calls are not merged."
-  })
+var todoParamsSchema = Type.Object({
+  action: ActionEnum,
+  subject: Type.Optional(Type.String({ description: "Task subject line (required for create)" })),
+  description: Type.Optional(Type.String({ description: "Long-form task description" })),
+  status: Type.Optional(StatusEnum),
+  id: Type.Optional(Type.Number({ description: "Task id (required for update, get, delete)" })),
+  includeDeleted: Type.Optional(Type.Boolean({
+    description: "If true, list action returns deleted (tombstoned) tasks as well. Default: false."
+  }))
 });
 
-// src/extensions/plan/factory.ts
-var planExtensionFactory = (pi) => {
+// src/extensions/todo/reducer.ts
+function err(state, message) {
+  return { state, text: `Error: ${message}`, error: message };
+}
+function formatListLine(t) {
+  return `[${t.status}] #${t.id} ${t.subject}`;
+}
+function applyTodoAction(state, action, params) {
+  switch (action) {
+    case "create": {
+      if (!params.subject?.trim()) {
+        return err(state, "subject required for create");
+      }
+      const task = {
+        id: state.nextId,
+        subject: params.subject,
+        status: "pending"
+      };
+      if (params.description) task.description = params.description;
+      const newTasks = [...state.tasks, task];
+      return {
+        state: { tasks: newTasks, nextId: state.nextId + 1 },
+        text: `Created #${task.id}: ${task.subject} (pending)`
+      };
+    }
+    case "update": {
+      if (params.id === void 0) return err(state, "id required for update");
+      const idx = state.tasks.findIndex((t) => t.id === params.id);
+      if (idx === -1) return err(state, `#${params.id} not found`);
+      const current = state.tasks[idx];
+      const hasMutation = params.subject !== void 0 || params.description !== void 0 || params.status !== void 0;
+      if (!hasMutation) return err(state, "update requires at least one mutable field");
+      let newStatus = current.status;
+      if (params.status !== void 0) {
+        if (!isTransitionValid(current.status, params.status)) {
+          return err(state, `illegal transition ${current.status} \u2192 ${params.status}`);
+        }
+        newStatus = params.status;
+      }
+      const updated = { ...current, status: newStatus };
+      if (params.subject !== void 0) updated.subject = params.subject;
+      if (params.description !== void 0) updated.description = params.description;
+      const newTasks = [...state.tasks];
+      newTasks[idx] = updated;
+      const transition = current.status !== newStatus ? ` (${current.status} \u2192 ${newStatus})` : "";
+      return {
+        state: { tasks: newTasks, nextId: state.nextId },
+        text: `Updated #${updated.id}${transition}`
+      };
+    }
+    case "list": {
+      let view = state.tasks;
+      if (!params.includeDeleted) view = view.filter((t) => t.status !== "deleted");
+      if (params.status) view = view.filter((t) => t.status === params.status);
+      return {
+        state,
+        text: view.length === 0 ? "No tasks" : view.map(formatListLine).join("\n")
+      };
+    }
+    case "get": {
+      if (params.id === void 0) return err(state, "id required for get");
+      const task = state.tasks.find((t) => t.id === params.id);
+      if (!task) return err(state, `#${params.id} not found`);
+      const lines = [`#${task.id} [${task.status}] ${task.subject}`];
+      if (task.description) lines.push(`  description: ${task.description}`);
+      return { state, text: lines.join("\n") };
+    }
+    case "delete": {
+      if (params.id === void 0) return err(state, "id required for delete");
+      const idx = state.tasks.findIndex((t) => t.id === params.id);
+      if (idx === -1) return err(state, `#${params.id} not found`);
+      const current = state.tasks[idx];
+      if (current.status === "deleted") return err(state, `#${current.id} is already deleted`);
+      const updated = { ...current, status: "deleted" };
+      const newTasks = [...state.tasks];
+      newTasks[idx] = updated;
+      return {
+        state: { tasks: newTasks, nextId: state.nextId },
+        text: `Deleted #${updated.id}: ${updated.subject}`
+      };
+    }
+    case "clear": {
+      const count = state.tasks.length;
+      return {
+        state: { tasks: [], nextId: 1 },
+        text: `Cleared ${count} tasks`
+      };
+    }
+  }
+}
+
+// src/extensions/todo/factory.ts
+var TOOL_NAME = "todo";
+function replayFromBranch(ctx) {
+  let result = { tasks: [...EMPTY_STATE.tasks], nextId: EMPTY_STATE.nextId };
+  for (const entry of ctx.sessionManager.getBranch()) {
+    const e = entry;
+    if (e.type !== "message") continue;
+    const msg = e.message;
+    if (msg?.role !== "toolResult" || msg.toolName !== TOOL_NAME) continue;
+    if (msg.isError) continue;
+    const details = msg.details;
+    if (!details || !Array.isArray(details.tasks) || typeof details.nextId !== "number") continue;
+    if (details.error) continue;
+    result = {
+      tasks: details.tasks.map((t) => ({ ...t })),
+      nextId: details.nextId
+    };
+  }
+  return result;
+}
+var todoExtensionFactory = (pi) => {
+  let state = { tasks: [...EMPTY_STATE.tasks], nextId: EMPTY_STATE.nextId };
   pi.registerTool({
-    name: "update_plan",
-    label: "Plan",
-    description: "Publish or refresh the working plan for the current task. Use for any task that takes 3+ discrete steps. Always send the full ordered list; previous calls are replaced, not merged.",
-    parameters: updatePlanParamsSchema,
-    promptSnippet: "update_plan: maintain a live checklist for multi-step tasks; update statuses as you progress.",
+    name: TOOL_NAME,
+    label: "Todo",
+    description: "Manage a task list for tracking multi-step progress. Actions: create (new task), update (change status/fields), list (all tasks, optionally filtered), get (single task), delete (tombstone), clear (reset). Status: pending \u2192 in_progress \u2192 completed, plus deleted tombstone.",
+    promptSnippet: "Manage a task list to track multi-step progress.",
     promptGuidelines: [
-      "For tasks with 3+ discrete steps, call update_plan once with the full list before starting work.",
-      "After completing each step, call update_plan again with refreshed statuses, then continue immediately \u2014 do not pause the turn just because the plan was updated.",
-      'Plan items should be specific and verifiable (e.g. "Add typebox dependency to packages/server"), not vague ("Set up infrastructure").',
-      "Exactly one item should be in_progress at a time. Mark completed only when the work is actually done."
+      "Use `todo` for complex work with 3+ steps or when the user gives you an explicit list of tasks. Skip it for single trivial tasks and purely conversational requests.",
+      "When starting any task, mark it in_progress BEFORE beginning work. Mark it completed IMMEDIATELY when done \u2014 never batch completions. Exactly one task should be in_progress at a time.",
+      "Never mark a task completed if tests are failing, the implementation is partial, or you hit unresolved errors \u2014 keep it in_progress and address the issue first."
     ],
-    execute: async (_toolCallId, params) => ({
-      content: [
-        {
-          type: "text",
-          text: `Plan updated (${params.items.length} item${params.items.length === 1 ? "" : "s"}).`
-        }
-      ],
-      details: params
-    })
+    parameters: todoParamsSchema,
+    async execute(_toolCallId, params) {
+      const result = applyTodoAction(state, params.action, params);
+      state = result.state;
+      const details = {
+        action: params.action,
+        tasks: state.tasks,
+        nextId: state.nextId,
+        ...result.error ? { error: result.error } : {}
+      };
+      return {
+        content: [{ type: "text", text: result.text }],
+        details
+      };
+    }
+  });
+  pi.registerCommand("todos", {
+    description: "Show current todo list grouped by status.",
+    handler: async () => {
+      const visible = state.tasks.filter((t) => t.status !== "deleted");
+      if (visible.length === 0) {
+        pi.sendUserMessage("Show the current todo list.");
+        return;
+      }
+      const pending2 = visible.filter((t) => t.status === "pending");
+      const inProgress = visible.filter((t) => t.status === "in_progress");
+      const completed = visible.filter((t) => t.status === "completed");
+      const lines = [];
+      const total = visible.length;
+      const doneCount = completed.length;
+      lines.push(`Todos (${doneCount}/${total})`);
+      if (inProgress.length > 0) {
+        lines.push("\u2500\u2500 In Progress \u2500\u2500");
+        for (const t of inProgress) lines.push(`  \u25D0 #${t.id} ${t.subject}`);
+      }
+      if (pending2.length > 0) {
+        lines.push("\u2500\u2500 Pending \u2500\u2500");
+        for (const t of pending2) lines.push(`  \u25CB #${t.id} ${t.subject}`);
+      }
+      if (completed.length > 0) {
+        lines.push("\u2500\u2500 Completed \u2500\u2500");
+        for (const t of completed) lines.push(`  \u2713 #${t.id} ${t.subject}`);
+      }
+      pi.sendUserMessage(`Current todos:
+${lines.join("\n")}`);
+    }
+  });
+  pi.on("session_start", async (_event, ctx) => {
+    state = replayFromBranch(ctx);
+  });
+  pi.on("session_compact", async (_event, ctx) => {
+    try {
+      state = replayFromBranch(ctx);
+    } catch {
+    }
   });
-  pi.registerCommand("plan", {
-    description: "Ask the agent to draft a plan for the current task.",
-    handler: async (args) => {
-      const task = args.trim();
-      const message = task ? `Draft a plan for: ${task}. Use the update_plan tool to publish it before starting any work.` : "Draft a plan for the current task. Use the update_plan tool to publish it before starting any work.";
-      pi.sendUserMessage(message);
+  pi.on("session_tree", async (_event, ctx) => {
+    try {
+      state = replayFromBranch(ctx);
+    } catch {
     }
   });
+  pi.on("session_shutdown", async () => {
+    state = { tasks: [...EMPTY_STATE.tasks], nextId: EMPTY_STATE.nextId };
+  });
 };
 
 // src/extensions/ask_user/schema.ts
@@ -616,13 +957,6 @@ function resolveAnswer(toolCallId, answer, expectedSessionFile) {
   entry.resolve(answer);
   return true;
 }
-function cancelPendingExcept(keepSessionFile) {
-  for (const [id, entry] of pending) {
-    if (entry.sessionFile === keepSessionFile) continue;
-    pending.delete(id);
-    entry.reject(new Error("Session replaced before answer arrived"));
-  }
-}
 function cancelPendingForSession(sessionFile) {
   for (const [id, entry] of pending) {
     if (entry.sessionFile !== sessionFile) continue;
@@ -673,7 +1007,7 @@ function waitForAnswer({
   sessionFile,
   signal
 }) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve8, reject) => {
     let settled = false;
     let timeoutHandle;
     const cleanup = () => {
@@ -685,13 +1019,13 @@ function waitForAnswer({
       if (settled) return;
       settled = true;
       cleanup();
-      resolve6(a);
+      resolve8(a);
     };
-    const finishErr = (err) => {
+    const finishErr = (err2) => {
       if (settled) return;
       settled = true;
       cleanup();
-      reject(err);
+      reject(err2);
     };
     const onAbort = () => finishErr(new Error("Aborted by user"));
     if (signal?.aborted) {
@@ -709,7 +1043,7 @@ function waitForAnswer({
       args: params,
       sessionFile,
       resolve: (answer) => finishOk(answer),
-      reject: (err) => finishErr(err)
+      reject: (err2) => finishErr(err2)
     });
   });
 }
@@ -759,102 +1093,1392 @@ function descriptionSuffix(params, index) {
   return desc ? ` \u2014 ${desc}` : "";
 }
 
-// src/storage/builtin-extension-prefs.ts
-import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
-import { dirname as dirname3, join as join4 } from "path";
-var PREFS_PATH = join4(config.dataDir, "builtin-extensions.json");
-var cache3 = { disabled: [] };
-async function loadBuiltinPrefs() {
-  try {
-    const raw = await readFile3(PREFS_PATH, "utf8");
-    const parsed = JSON.parse(raw);
-    cache3 = { disabled: Array.isArray(parsed.disabled) ? parsed.disabled : [] };
-  } catch (err) {
-    cache3 = { disabled: [] };
-    if (err.code !== "ENOENT") {
-      console.warn(`[builtin-prefs] ignoring unreadable ${PREFS_PATH}:`, err);
+// src/extensions/artifact/schema.ts
+import { Type as Type3 } from "typebox";
+var TypeEnum = Type3.Union(
+  [
+    Type3.Literal("html"),
+    Type3.Literal("svg"),
+    Type3.Literal("markdown"),
+    Type3.Literal("code")
+  ],
+  {
+    description: 'How to render the content: "html" (a self-contained HTML document or fragment, run in a sandboxed iframe), "svg" (SVG markup), "markdown" (rich text), or "code" (a source file shown with syntax highlighting).'
+  }
+);
+var createArtifactParamsSchema = Type3.Object({
+  id: Type3.Optional(
+    Type3.String({
+      description: 'Stable identifier. Omit on first creation. To REVISE an existing artifact, pass the same id you used before \u2014 that records a new version instead of a separate artifact. Use a short slug like "landing-page".'
+    })
+  ),
+  type: TypeEnum,
+  title: Type3.String({
+    description: "Short human-readable title shown in the artifact panel."
+  }),
+  content: Type3.String({
+    description: "The full artifact content \u2014 the complete document, markup, or source."
+  }),
+  language: Type3.Optional(
+    Type3.String({
+      description: 'For type="code", the language id for syntax highlighting (e.g. "python", "typescript").'
+    })
+  )
+});
+
+// src/extensions/artifact/factory.ts
+var TOOL_NAME2 = "create_artifact";
+var artifactExtensionFactory = (pi) => {
+  pi.registerTool({
+    name: TOOL_NAME2,
+    label: "Create artifact",
+    description: 'Publish a substantial, self-contained piece of content as an "artifact" the user can view and iterate on in a dedicated side panel: a web page (html), an SVG diagram (svg), a document (markdown), or a source file (code). Reuse the same `id` to revise an existing artifact (records a new version).',
+    promptSnippet: "create_artifact: render substantial, self-contained content (web page / SVG / document / code file) in a side panel the user can view and iterate on.",
+    promptGuidelines: [
+      "Use create_artifact for substantial, self-contained, reusable content the user will want to view, keep, or iterate on \u2014 a runnable HTML page, an SVG diagram, a full document, or a standalone code file. Do NOT use it for short snippets, command output, or your normal conversational answer; a fenced code block in your reply is better for those.",
+      "To revise an artifact, call create_artifact again with the SAME id and the full updated content \u2014 this records a new version the user can step through. Don't spawn a near-duplicate artifact under a new id.",
+      'Put the entire content in `content`, give it a concise `title`, and pick the `type` that matches how it should render. For type="code", set `language`.',
+      "After creating an artifact, keep your chat reply short \u2014 the content lives in the panel, so don't paste it again in prose."
+    ],
+    parameters: createArtifactParamsSchema,
+    execute: async (toolCallId, params) => {
+      const id = params.id?.trim() || toolCallId;
+      const details = {
+        id,
+        type: params.type,
+        title: params.title
+      };
+      const text = `Artifact "${params.title}" (${params.type}) is now shown to the user in the Artifacts panel. Its id is "${id}" \u2014 pass that same id to create_artifact to revise it.`;
+      return {
+        content: [{ type: "text", text }],
+        details
+      };
     }
+  });
+};
+
+// src/extensions/subagent/agents.ts
+import { readdirSync, readFileSync as readFileSync2 } from "fs";
+import { join as join6 } from "path";
+import { getAgentDir, parseFrontmatter } from "@earendil-works/pi-coding-agent";
+
+// src/extensions/subagent/builtin-agents.ts
+var COMMON_RULES = `Hard rules:
+- You run headless as a subagent: there is NO user to talk to. Never ask questions, never wait for confirmation \u2014 decide and proceed.
+- NEVER run the \`pi\` CLI or spawn any other agent. No nesting.
+- End with ONE final message that is a complete, self-contained report \u2014 it is the ONLY thing returned to the agent that delegated to you. Keep it under ~8000 characters and reference code as \`path:line\`.`;
+var scout = {
+  name: "scout",
+  source: "builtin",
+  description: "Fast read-only codebase recon: locate files, symbols, flows, conventions, and report compressed findings. Cheap to use; cannot edit anything.",
+  tools: ["read", "grep", "find", "ls"],
+  systemPrompt: `You are "scout", a read-only reconnaissance subagent.
+
+${COMMON_RULES}
+
+Method: start broad (find/ls/grep), then read only the spans that matter. Prefer reading slices over whole files. Stop as soon as you can answer confidently.
+
+Final report shape: a short answer first, then the supporting map \u2014 relevant files with one-line roles, key symbols as \`path:line\`, and any conventions or gotchas the delegator should know. Say explicitly what you did NOT verify.`
+};
+var worker = {
+  name: "worker",
+  source: "builtin",
+  description: "General-purpose implementer with the full default toolset (bash/edit/write). Use for a self-contained change with a precise brief; verifies its own work.",
+  systemPrompt: `You are "worker", an implementation subagent.
+
+${COMMON_RULES}
+
+Method: read the relevant code before changing it; follow the surrounding style exactly; make the smallest change that satisfies the brief. Verify with the project's own commands (typecheck / tests / build) when available \u2014 report what you ran and its outcome honestly.
+
+Final report shape: what changed (file by file, one line each), how it was verified (commands + results), and any caveats or follow-ups. If you could not finish, say precisely how far you got and what is left.`
+};
+var reviewer = {
+  name: "reviewer",
+  source: "builtin",
+  description: "Code review of specific files or diffs: correctness, edge cases, convention drift. Read-mostly (bash for git diff / running tests). Returns prioritized findings.",
+  tools: ["read", "grep", "find", "ls", "bash"],
+  systemPrompt: `You are "reviewer", a code-review subagent. Your job is to FIND problems, not to fix them \u2014 do not edit any file.
+
+${COMMON_RULES}
+
+Method: read the target code fully before judging; use bash only for read-only inspection (git diff/log, running existing tests). Hunt real defects first \u2014 correctness, edge cases, lifecycle/cleanup holes \u2014 then convention drift. Verify each suspicion against the actual code before reporting it.
+
+Final report shape: findings ordered by severity, each with \`path:line\`, what's wrong, why it matters, and a concrete suggested fix. End with what you checked and found clean, so silence isn't ambiguous.`
+};
+var BUILTIN_AGENTS = [scout, worker, reviewer];
+
+// src/extensions/subagent/trust.ts
+import { readFileSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join5, resolve as resolve3 } from "path";
+function isProjectDirTrusted(projectDir) {
+  const registryPath = join5(
+    process.env.PI_PILOT_DATA_DIR ?? join5(homedir2(), ".pi", "webui"),
+    "workspaces.json"
+  );
+  try {
+    const raw = JSON.parse(readFileSync(registryPath, "utf8"));
+    if (!Array.isArray(raw.workspaces)) return false;
+    const wanted = resolve3(projectDir);
+    return raw.workspaces.some(
+      (w) => typeof w?.path === "string" && resolve3(w.path) === wanted && w.trustProjectAgents === true
+    );
+  } catch {
+    return false;
   }
 }
-function isBuiltinDisabled(id) {
-  return cache3.disabled.includes(id);
+
+// src/extensions/subagent/agents.ts
+function userAgentsDir() {
+  return join6(getAgentDir(), "agents");
 }
-function getDisabledBuiltins() {
-  return [...cache3.disabled];
+function projectAgentsDir(projectDir) {
+  return join6(projectDir, ".pi", "agents");
 }
-async function setBuiltinEnabled(id, enabled) {
-  const next = new Set(cache3.disabled);
-  if (enabled) next.delete(id);
-  else next.add(id);
-  cache3 = { disabled: [...next] };
-  await save2();
+function discoverAgents(projectDir) {
+  const roster = /* @__PURE__ */ new Map();
+  for (const agent of BUILTIN_AGENTS) roster.set(agent.name, agent);
+  mergeDir(roster, userAgentsDir(), "user");
+  if (projectDir && isProjectDirTrusted(projectDir)) {
+    mergeDir(roster, projectAgentsDir(projectDir), "project");
+  }
+  return roster;
+}
+function mergeDir(roster, dir, source) {
+  let files;
+  try {
+    files = readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
+  } catch {
+    return;
+  }
+  for (const file of files) {
+    const def = parseAgentFile(join6(dir, file), file, source);
+    if (def) roster.set(def.name, def);
+  }
 }
-async function save2() {
-  await mkdir3(dirname3(PREFS_PATH), { recursive: true });
-  await writeFile3(PREFS_PATH, JSON.stringify(cache3, null, 2), "utf8");
+function rosterSummary(roster) {
+  return [...roster.values()].map((a) => `- ${a.name}: ${a.description || "(no description)"}`).join("\n");
 }
-
-// src/extensions/index.ts
-var BUILTIN_EXTENSIONS = [
-  {
-    id: "plan",
-    name: "Plan",
-    description: "A live task checklist for multi-step work \u2014 adds the update_plan tool and the /plan command.",
-    tools: ["update_plan"],
-    commands: ["plan"],
-    factory: planExtensionFactory
-  },
-  {
-    id: "ask_user",
-    name: "Ask user",
-    description: "Lets the agent pause and ask you a structured multiple-choice question \u2014 adds the ask_user tool.",
-    tools: ["ask_user"],
-    commands: [],
-    factory: askUserExtensionFactory
+function parseAgentFile(path, filename, source) {
+  try {
+    const raw = readFileSync2(path, "utf8");
+    const { frontmatter, body } = parseFrontmatter(raw);
+    const name = strField(frontmatter.name) ?? filename.replace(/\.md$/, "").trim();
+    if (!name) return void 0;
+    return {
+      name,
+      description: strField(frontmatter.description) ?? "",
+      systemPrompt: body.trim(),
+      tools: toolsField(frontmatter.tools),
+      model: strField(frontmatter.model),
+      source
+    };
+  } catch {
+    return void 0;
   }
-];
-function gate(def) {
-  return (pi) => {
-    if (isBuiltinDisabled(def.id)) return;
-    return def.factory(pi);
-  };
 }
-var builtinExtensionFactories = BUILTIN_EXTENSIONS.map(gate);
+function strField(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function toolsField(value) {
+  if (typeof value === "string") {
+    const parts = value.split(",").map((s) => s.trim()).filter(Boolean);
+    return parts.length > 0 ? parts : void 0;
+  }
+  if (Array.isArray(value)) {
+    const parts = value.filter((v) => typeof v === "string" && v.trim() !== "");
+    return parts.length > 0 ? parts.map((s) => s.trim()) : void 0;
+  }
+  return void 0;
+}
 
-// src/extensions/ask_user/cleanup.ts
-var CUSTOM_TYPE = "ask_user-restart-cancelled";
-function reconcileAfterRestart(sessionManager) {
-  const branch = sessionManager.getBranch();
-  if (branch.length === 0) return;
-  const satisfied = /* @__PURE__ */ new Set();
-  const danglingIds = [];
-  const danglingAlreadyHandled = /* @__PURE__ */ new Set();
-  for (let i = branch.length - 1; i >= 0; i--) {
-    const entry = branch[i];
-    if (entry.type === "custom_message") {
-      const cm = entry;
-      if (cm.customType === CUSTOM_TYPE) {
-        const ids = cm.details?.ids;
-        if (Array.isArray(ids)) {
-          for (const id of ids) {
-            if (typeof id === "string") danglingAlreadyHandled.add(id);
-          }
-        }
+// src/extensions/subagent/child.ts
+import { spawn } from "child_process";
+import {
+  createWriteStream,
+  mkdirSync,
+  mkdtempSync,
+  writeFileSync
+} from "fs";
+import { rm as rm3 } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join8 } from "path";
+
+// src/extensions/subagent/schema.ts
+import { Type as Type4 } from "typebox";
+var MAX_TASKS_PER_CALL = 8;
+var taskBriefDescription = "Complete, self-contained task brief. The subagent sees NOTHING of this conversation \u2014 include all relevant paths, constraints, context, and the exact shape of the answer you want back.";
+var subagentParamsSchema = Type4.Object({
+  agent: Type4.Optional(
+    Type4.String({
+      description: "Single mode: agent to delegate to, by name. The roster is listed in the tool description; an unknown name returns the available roster. Use together with `task`; omit when using `tasks`."
+    })
+  ),
+  task: Type4.Optional(Type4.String({ description: taskBriefDescription })),
+  tasks: Type4.Optional(
+    Type4.Array(
+      Type4.Object({
+        agent: Type4.String({ description: "Agent to delegate this task to, by name." }),
+        task: Type4.String({ description: taskBriefDescription })
+      }),
+      {
+        maxItems: MAX_TASKS_PER_CALL,
+        description: `Parallel mode: up to ${MAX_TASKS_PER_CALL} INDEPENDENT task briefs, run concurrently. All results return together in one combined report. Only for tasks with no ordering dependency \u2014 sequence dependent steps as separate subagent calls instead. Omit when using \`agent\`/\`task\`.`
       }
-      continue;
-    }
-    if (entry.type !== "message") continue;
-    const msg = entry.message;
-    if (msg.role === "toolResult" && typeof msg.toolCallId === "string") {
-      satisfied.add(msg.toolCallId);
-      continue;
+    )
+  )
+});
+function emptyUsage() {
+  return {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    cost: 0,
+    contextTokens: 0,
+    turns: 0
+  };
+}
+function isSubagentDetails(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return v.version === 1 && (v.mode === "single" || v.mode === "parallel") && Array.isArray(v.tasks);
+}
+
+// src/extensions/subagent/pi-bin.ts
+import { existsSync } from "fs";
+import { dirname as dirname4, join as join7 } from "path";
+import { fileURLToPath } from "url";
+var cached;
+function resolvePinnedPiCli() {
+  if (cached) return cached;
+  try {
+    const entry = fileURLToPath(
+      import.meta.resolve("@earendil-works/pi-coding-agent")
+    );
+    const candidate = join7(dirname4(entry), "cli.js");
+    if (existsSync(candidate)) {
+      cached = candidate;
+      return candidate;
     }
-    if (msg.role === "assistant" && Array.isArray(msg.content)) {
-      for (const block of msg.content) {
-        if (!block || typeof block !== "object") continue;
-        const b = block;
-        if (b.type !== "toolCall") continue;
-        if (b.name !== "ask_user") continue;
+  } catch {
+  }
+  const fallback = fileURLToPath(
+    new URL(
+      "../../../node_modules/@earendil-works/pi-coding-agent/dist/cli.js",
+      import.meta.url
+    )
+  );
+  if (existsSync(fallback)) {
+    cached = fallback;
+    return fallback;
+  }
+  throw new Error(
+    "subagent: cannot locate the pinned @earendil-works/pi-coding-agent CLI (tried import.meta.resolve and the package-local node_modules symlink)"
+  );
+}
+
+// src/extensions/subagent/registry.ts
+var children = /* @__PURE__ */ new Map();
+function registerChild(toolCallId, handle2) {
+  children.set(toolCallId, handle2);
+}
+function unregisterChild(toolCallId) {
+  children.delete(toolCallId);
+}
+function killChildrenForSession(sessionFile) {
+  let killed = 0;
+  for (const [id, handle2] of children) {
+    if (handle2.sessionFile !== sessionFile) continue;
+    children.delete(id);
+    handle2.kill();
+    killed++;
+  }
+  return killed;
+}
+function killAllChildren() {
+  let killed = 0;
+  for (const [id, handle2] of children) {
+    children.delete(id);
+    handle2.kill();
+    killed++;
+  }
+  return killed;
+}
+var MAX_CONCURRENT_CHILDREN = 8;
+var MAX_CONCURRENT_PER_SESSION = 4;
+var running = 0;
+var runningPerSession = /* @__PURE__ */ new Map();
+var waiters = [];
+function keyOf2(sessionFile) {
+  return sessionFile ?? "<unpersisted>";
+}
+function hasCapacity(sessionKey) {
+  return running < MAX_CONCURRENT_CHILDREN && (runningPerSession.get(sessionKey) ?? 0) < MAX_CONCURRENT_PER_SESSION;
+}
+function take(sessionKey) {
+  running++;
+  runningPerSession.set(sessionKey, (runningPerSession.get(sessionKey) ?? 0) + 1);
+}
+function acquireChildSlot(signal, sessionFile) {
+  const sessionKey = keyOf2(sessionFile);
+  return new Promise((resolve8, reject) => {
+    if (signal?.aborted) {
+      reject(new Error("Aborted by user"));
+      return;
+    }
+    if (hasCapacity(sessionKey)) {
+      take(sessionKey);
+      resolve8(makeRelease(sessionKey));
+      return;
+    }
+    const waiter = {
+      grant: () => resolve8(makeRelease(sessionKey)),
+      sessionKey,
+      signal,
+      onAbort: void 0
+    };
+    if (signal) {
+      const onAbort = () => {
+        const i = waiters.indexOf(waiter);
+        if (i >= 0) waiters.splice(i, 1);
+        reject(new Error("Aborted by user"));
+      };
+      waiter.onAbort = onAbort;
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+    waiters.push(waiter);
+  });
+}
+function makeRelease(sessionKey) {
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    running--;
+    const n = (runningPerSession.get(sessionKey) ?? 1) - 1;
+    if (n <= 0) runningPerSession.delete(sessionKey);
+    else runningPerSession.set(sessionKey, n);
+    pump();
+  };
+}
+function pump() {
+  for (let i = 0; i < waiters.length && running < MAX_CONCURRENT_CHILDREN; ) {
+    const waiter = waiters[i];
+    if (waiter.signal?.aborted) {
+      waiters.splice(i, 1);
+      continue;
+    }
+    if (!hasCapacity(waiter.sessionKey)) {
+      i++;
+      continue;
+    }
+    waiters.splice(i, 1);
+    if (waiter.signal && waiter.onAbort) {
+      waiter.signal.removeEventListener("abort", waiter.onAbort);
+    }
+    take(waiter.sessionKey);
+    waiter.grant();
+  }
+}
+
+// src/extensions/subagent/child.ts
+var PROMPT_DIR_PREFIX = "pi-pilot-subagent-";
+var TRANSCRIPTS_DIR = join8(tmpdir(), "pi-pilot-subagents", "transcripts");
+var ACTIVITY_MAX = 30;
+var LABEL_MAX = 160;
+var STDERR_TAIL_MAX = 2048;
+var FINAL_TEXT_MAX = 2e5;
+var SIGKILL_DELAY_MS = 5e3;
+async function runChild(opts) {
+  const startedAt = Date.now();
+  const cli = opts.cliPath ?? process.env.PI_PILOT_SUBAGENT_CLI ?? resolvePinnedPiCli();
+  const promptDir = mkdtempSync(join8(tmpdir(), PROMPT_DIR_PREFIX));
+  const promptPath = join8(promptDir, "prompt.md");
+  writeFileSync(promptPath, opts.appendSystemPrompt, { mode: 384 });
+  let transcriptPath;
+  let tee;
+  try {
+    mkdirSync(TRANSCRIPTS_DIR, { recursive: true });
+    transcriptPath = join8(TRANSCRIPTS_DIR, `${sanitizeId(opts.toolCallId)}.ndjson`);
+    tee = createWriteStream(transcriptPath, { flags: "w" });
+    tee.on("error", () => {
+    });
+  } catch {
+    transcriptPath = void 0;
+  }
+  const args = [cli, "--mode", "json", "-p", "--no-session", "--no-extensions", "--no-skills"];
+  const model = opts.agent.model ?? opts.inheritModel;
+  if (model) args.push("--model", model);
+  if (opts.agent.tools && opts.agent.tools.length > 0) {
+    args.push("--tools", opts.agent.tools.join(","));
+  }
+  args.push("--append-system-prompt", promptPath);
+  args.push(opts.task);
+  const usage = emptyUsage();
+  const activity = [];
+  let modelSeen;
+  let finalText = "";
+  let stopReason;
+  let errorMessage;
+  let stderrAccum = "";
+  let aborted = false;
+  let timedOut = false;
+  let costKilled = false;
+  const child = spawn(process.execPath, args, {
+    cwd: opts.cwd,
+    env: { ...process.env, PI_PILOT_SUBAGENT: opts.toolCallId },
+    stdio: ["ignore", "pipe", "pipe"],
+    shell: false
+  });
+  if (child.pid !== void 0) {
+    try {
+      writeFileSync(join8(promptDir, "pid"), `${child.pid}
+${process.pid}`);
+    } catch {
+    }
+  }
+  let killed = false;
+  let killTimer;
+  const killGracefully = () => {
+    if (killed) return;
+    killed = true;
+    try {
+      child.kill("SIGTERM");
+    } catch {
+    }
+    killTimer = setTimeout(() => {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+    }, SIGKILL_DELAY_MS);
+  };
+  registerChild(opts.toolCallId, {
+    sessionFile: opts.sessionFile,
+    agent: opts.agent.name,
+    kill: killGracefully
+  });
+  const onAbort = () => {
+    aborted = true;
+    killGracefully();
+  };
+  if (opts.signal?.aborted) onAbort();
+  else opts.signal?.addEventListener("abort", onAbort, { once: true });
+  let stalled = false;
+  const timeoutTimer = setTimeout(() => {
+    timedOut = true;
+    killGracefully();
+  }, opts.timeoutMs);
+  let stallTimer;
+  const armStallTimer = () => {
+    if (killed) return;
+    if (stallTimer) clearTimeout(stallTimer);
+    stallTimer = setTimeout(() => {
+      stalled = true;
+      timedOut = true;
+      killGracefully();
+    }, opts.stallTimeoutMs);
+  };
+  armStallTimer();
+  const emitProgress = () => {
+    opts.onProgress({
+      usage: { ...usage },
+      model: modelSeen,
+      activity: [...activity],
+      lastLabel: activity[activity.length - 1]?.label
+    });
+  };
+  const handleLine = (line) => {
+    if (!line.trim()) return;
+    tee?.write(line + "\n");
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      return;
+    }
+    const ev = event;
+    if (ev.type !== "message_end" || !ev.message || typeof ev.message !== "object") return;
+    const msg = ev.message;
+    if (msg.role !== "assistant") return;
+    usage.turns++;
+    const u = msg.usage;
+    if (u) {
+      usage.input += u.input ?? 0;
+      usage.output += u.output ?? 0;
+      usage.cacheRead += u.cacheRead ?? 0;
+      usage.cacheWrite += u.cacheWrite ?? 0;
+      usage.cost += u.cost?.total ?? 0;
+      usage.contextTokens = u.totalTokens ?? usage.contextTokens;
+    }
+    if (!modelSeen && typeof msg.model === "string") modelSeen = msg.model;
+    if (typeof msg.stopReason === "string") stopReason = msg.stopReason;
+    if (typeof msg.errorMessage === "string") errorMessage = msg.errorMessage;
+    if (Array.isArray(msg.content)) {
+      const textParts = [];
+      for (const block of msg.content) {
+        if (!block || typeof block !== "object") continue;
+        const b = block;
+        if (b.type === "text" && typeof b.text === "string") {
+          textParts.push(b.text);
+        } else if (b.type === "toolCall" && typeof b.name === "string") {
+          pushActivity(activity, b.name, b.arguments);
+        }
+      }
+      const text = textParts.join("").trim();
+      if (text) finalText = text.slice(0, FINAL_TEXT_MAX);
+    }
+    if (usage.cost > opts.costCeilingUsd && !costKilled) {
+      costKilled = true;
+      killGracefully();
+    }
+    emitProgress();
+  };
+  let buf = "";
+  child.stdout?.on("data", (chunk) => {
+    armStallTimer();
+    buf += chunk.toString("utf8");
+    let nl;
+    while ((nl = buf.indexOf("\n")) >= 0) {
+      handleLine(buf.slice(0, nl));
+      buf = buf.slice(nl + 1);
+    }
+  });
+  child.stderr?.on("data", (chunk) => {
+    armStallTimer();
+    stderrAccum = (stderrAccum + chunk.toString("utf8")).slice(-STDERR_TAIL_MAX);
+  });
+  const exitCode = await new Promise((resolve8) => {
+    child.on("error", (err2) => {
+      errorMessage ??= err2 instanceof Error ? err2.message : String(err2);
+      resolve8(-1);
+    });
+    child.on("close", (code) => resolve8(code ?? -1));
+  });
+  if (buf) handleLine(buf);
+  clearTimeout(timeoutTimer);
+  if (stallTimer) clearTimeout(stallTimer);
+  if (killTimer) clearTimeout(killTimer);
+  opts.signal?.removeEventListener("abort", onAbort);
+  unregisterChild(opts.toolCallId);
+  tee?.end();
+  await rm3(promptDir, { recursive: true, force: true }).catch(() => {
+  });
+  if (costKilled && !errorMessage) {
+    errorMessage = `cost ceiling ($${opts.costCeilingUsd}) exceeded \u2014 child terminated`;
+  }
+  if (timedOut && !aborted && !errorMessage) {
+    errorMessage = stalled ? `no output for ${Math.round(opts.stallTimeoutMs / 1e3)}s \u2014 presumed hung` : `wall-clock limit (${Math.round(opts.timeoutMs / 1e3)}s) reached while still active`;
+  }
+  const failed = exitCode !== 0 || stopReason === "error" || stopReason === "aborted" || costKilled;
+  const status2 = aborted ? "aborted" : timedOut ? "timeout" : failed ? "failed" : "done";
+  return {
+    status: status2,
+    finalText,
+    usage,
+    model: modelSeen,
+    stopReason,
+    errorMessage,
+    stderrTail: stderrAccum.trim(),
+    exitCode,
+    durationMs: Date.now() - startedAt,
+    transcriptPath,
+    activity
+  };
+}
+function sanitizeId(id) {
+  return id.replace(/[^A-Za-z0-9._-]/g, "_");
+}
+function pushActivity(activity, name, args) {
+  const label = toolLabel(name, args).slice(0, LABEL_MAX);
+  activity.push({ kind: "tool", label });
+  if (activity.length > ACTIVITY_MAX) {
+    activity.splice(0, activity.length - ACTIVITY_MAX);
+  }
+}
+function toolLabel(name, args) {
+  const a = args && typeof args === "object" ? args : {};
+  const pick = (...keys) => {
+    for (const key of keys) {
+      const v = a[key];
+      if (typeof v === "string" && v.trim()) return v;
+    }
+    return void 0;
+  };
+  let detail;
+  switch (name) {
+    case "bash":
+      detail = pick("command");
+      break;
+    case "read":
+    case "write":
+    case "edit":
+      detail = pick("path", "file_path");
+      break;
+    case "grep":
+      detail = pick("pattern");
+      break;
+    case "find":
+      detail = pick("pattern", "path");
+      break;
+    case "ls":
+      detail = pick("path");
+      break;
+    default: {
+      for (const v of Object.values(a)) {
+        if (typeof v === "string" && v.trim()) {
+          detail = v;
+          break;
+        }
+      }
+    }
+  }
+  const clean = detail?.replace(/\s+/g, " ").trim();
+  return clean ? `${name}: ${clean}` : name;
+}
+
+// src/extensions/subagent/factory.ts
+var TASK_OUTPUT_CAP = 12 * 1024;
+var AGGREGATE_OUTPUT_CAP = 48 * 1024;
+var PREVIEW_CAP = 8 * 1024;
+var STDERR_DETAILS_CAP = 1024;
+var UPDATE_THROTTLE_MS = 500;
+function tunable(envName, fallback) {
+  const raw = process.env[envName];
+  if (!raw) return fallback;
+  const n = Number.parseFloat(raw);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+var TASK_TIMEOUT_MS = tunable("PI_PILOT_SUBAGENT_TIMEOUT_SEC", 3600) * 1e3;
+var STALL_TIMEOUT_MS = tunable("PI_PILOT_SUBAGENT_STALL_SEC", 600) * 1e3;
+var COST_CEILING_USD = tunable("PI_PILOT_SUBAGENT_COST_USD", 20);
+var subagentExtensionFactory = (pi) => {
+  const lastDetails = /* @__PURE__ */ new Map();
+  const rosterAtRegistration = discoverAgents();
+  pi.registerTool({
+    name: "subagent",
+    label: "Subagent",
+    description: `Delegate self-contained tasks to subagents running in isolated contexts (separate pi processes that see nothing of this conversation). Returns only the subagents' final reports. Pass \`agent\` + \`task\` for one delegation, or \`tasks\` (up to ${MAX_TASKS_PER_CALL}) to run INDEPENDENT delegations in parallel. Available agents:
+` + rosterSummary(rosterAtRegistration) + `
+The roster is re-read on every call from ${userAgentsDir()}/*.md (builtin presets scout/worker/reviewer; a same-name user file overrides its preset; workspaces with project agents trusted also merge <cwd>/.pi/agents/*.md, which win over both).`,
+    parameters: subagentParamsSchema,
+    executionMode: "parallel",
+    promptSnippet: "subagent: delegate self-contained tasks (recon, a bounded implementation step, a review pass) to isolated child agents \u2014 only their final reports return, keeping large searches and side work out of this context. Independent tasks can fan out in parallel via `tasks`.",
+    promptGuidelines: [
+      "Use subagent when a task is self-contained and would otherwise flood this context (broad codebase recon, a bounded implementation step, a review pass). Don't delegate trivial lookups \u2014 a single read/grep inline is faster and cheaper than a child agent.",
+      "Write complete subagent briefs: the child sees NOTHING of this conversation. Include the relevant paths, constraints, acceptance criteria, and the exact shape of the report you want back.",
+      "Pick the cheapest sufficient agent: scout for read-only recon, reviewer for read-mostly review, worker only when files must change.",
+      `Use \`tasks\` (max ${MAX_TASKS_PER_CALL} per call) ONLY for independent work \u2014 no task's input may depend on another's output, and parallel workers must never edit the same files. All results return together; sequence dependent steps as separate calls instead.`,
+      "Subagents cannot ask the user questions and cannot spawn further subagents. Resolve user decisions (ask_user) BEFORE delegating, and sequence dependent work yourself: delegate, read the report, then issue the next call with the context it needs."
+    ],
+    execute: async (toolCallId, params, signal, onUpdate, ctx) => {
+      const roster = discoverAgents(ctx.cwd);
+      const calls = normalizeCalls(params);
+      if (typeof calls === "string") {
+        return invalidCallResult(calls, params);
+      }
+      const { mode, briefs } = calls;
+      const unknown = [...new Set(briefs.map((b) => b.agent.trim()))].filter(
+        (name) => !roster.has(name)
+      );
+      if (unknown.length > 0) {
+        return invalidCallResult(
+          `Unknown agent${unknown.length > 1 ? "s" : ""} ${unknown.map((n) => `"${n}"`).join(", ")}. Available agents:
+` + rosterSummary(roster) + "\nCall subagent again with one of these names.",
+          params
+        );
+      }
+      if (signal?.aborted) throw new Error("Aborted by user");
+      const sessionFile = ctx.sessionManager.getSessionFile() ?? null;
+      const resolved = briefs.map((b) => ({
+        agent: roster.get(b.agent.trim()),
+        task: b.task
+      }));
+      const tasks = resolved.map((r) => ({
+        agent: r.agent.name,
+        agentSource: r.agent.source,
+        task: r.task,
+        status: "queued",
+        activity: [],
+        usage: emptyUsage()
+      }));
+      const details = { version: 1, mode, tasks };
+      const emitter = makeThrottledEmitter(onUpdate, details);
+      emitter.emit(true);
+      const runOne = async (i) => {
+        const task = tasks[i];
+        const r = resolved[i];
+        let release;
+        try {
+          release = await acquireChildSlot(signal, sessionFile);
+        } catch (err2) {
+          if (!signal?.aborted) throw err2;
+          task.status = "aborted";
+          emitter.emit(true);
+          return void 0;
+        }
+        try {
+          task.status = "running";
+          emitter.emit(true);
+          const outcome = await runChild({
+            // Per-child id: registry entries, pidfiles and transcript
+            // files must not collide across one call's siblings.
+            toolCallId: mode === "single" ? toolCallId : `${toolCallId}.${i}`,
+            agent: r.agent,
+            task: r.task,
+            cwd: ctx.cwd,
+            sessionFile,
+            appendSystemPrompt: composeChildPrompt(r.agent),
+            inheritModel: r.agent.model ?? (ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : void 0),
+            signal,
+            timeoutMs: TASK_TIMEOUT_MS,
+            stallTimeoutMs: STALL_TIMEOUT_MS,
+            costCeilingUsd: COST_CEILING_USD,
+            onProgress: (p) => {
+              task.usage = p.usage;
+              task.model = p.model ?? task.model;
+              task.activity = p.activity;
+              emitter.emit();
+            }
+          });
+          mergeOutcome(task, outcome);
+          emitter.emit(true);
+          return outcome;
+        } finally {
+          release();
+        }
+      };
+      try {
+        const outcomes = await Promise.all(resolved.map((_, i) => runOne(i)));
+        emitter.cancel();
+        lastDetails.set(toolCallId, details);
+        if (tasks.some((t) => t.status === "aborted")) {
+          throw new Error("Aborted by user");
+        }
+        return {
+          content: [{ type: "text", text: combinedParentText(mode, resolved, outcomes) }],
+          details
+        };
+      } finally {
+        emitter.cancel();
+      }
+    }
+  });
+  pi.on("tool_result", (ev) => {
+    if (ev.toolName !== "subagent") return void 0;
+    const fromMap = lastDetails.get(ev.toolCallId);
+    lastDetails.delete(ev.toolCallId);
+    const details = isSubagentDetails(ev.details) ? ev.details : fromMap;
+    if (!details) return void 0;
+    const failed = details.tasks.some(
+      (t) => t.status === "failed" || t.status === "timeout"
+    );
+    const patch = {};
+    if (failed && !ev.isError) patch.isError = true;
+    if (ev.isError && !isSubagentDetails(ev.details) && fromMap) patch.details = fromMap;
+    return patch.isError !== void 0 || patch.details !== void 0 ? patch : void 0;
+  });
+};
+function normalizeCalls(params) {
+  const hasSingle = params.agent !== void 0 || params.task !== void 0;
+  const hasTasks = Array.isArray(params.tasks) && params.tasks.length > 0;
+  if (hasSingle && hasTasks) {
+    return "Pass EITHER `agent` + `task` (single delegation) OR `tasks` (parallel fan-out) \u2014 not both in one call.";
+  }
+  if (hasTasks) {
+    const list = params.tasks;
+    if (list.length > MAX_TASKS_PER_CALL) {
+      return `tasks[] is capped at ${MAX_TASKS_PER_CALL} per call (got ${list.length}). Split the fan-out into multiple subagent calls.`;
+    }
+    if (list.some((t) => !t?.agent?.trim() || !t?.task?.trim())) {
+      return "Every tasks[] entry needs a non-empty `agent` and `task`.";
+    }
+    return { mode: "parallel", briefs: list.map((t) => ({ agent: t.agent, task: t.task })) };
+  }
+  if (params.agent?.trim() && params.task?.trim()) {
+    return { mode: "single", briefs: [{ agent: params.agent, task: params.task }] };
+  }
+  return "Provide either `agent` + `task` (single delegation) or `tasks` (parallel fan-out of independent briefs).";
+}
+function invalidCallResult(text, params) {
+  return {
+    content: [{ type: "text", text }],
+    details: {
+      version: 1,
+      mode: Array.isArray(params.tasks) && params.tasks.length > 0 ? "parallel" : "single",
+      tasks: []
+    }
+  };
+}
+function composeChildPrompt(agent) {
+  const header = `You are running as the "${agent.name}" subagent, delegated one task by another agent via pi-pilot. Work only within the project's working directory.`;
+  return agent.systemPrompt ? `${header}
+
+${agent.systemPrompt}` : header;
+}
+function mergeOutcome(task, outcome) {
+  task.status = outcome.status;
+  task.usage = outcome.usage;
+  task.activity = outcome.activity;
+  task.model = outcome.model ?? task.model;
+  task.stopReason = outcome.stopReason;
+  task.errorMessage = outcome.errorMessage;
+  task.stderrTail = outcome.stderrTail ? outcome.stderrTail.slice(-STDERR_DETAILS_CAP) : void 0;
+  task.exitCode = outcome.exitCode;
+  task.durationMs = outcome.durationMs;
+  task.transcriptPath = outcome.transcriptPath;
+  task.finalPreview = outcome.finalText ? tailCap(outcome.finalText, PREVIEW_CAP) : void 0;
+}
+function combinedParentText(mode, resolved, outcomes) {
+  if (mode === "single") {
+    return formatParentText(resolved[0].agent, outcomes[0], TASK_OUTPUT_CAP);
+  }
+  const n = outcomes.length;
+  const perTaskCap = Math.min(TASK_OUTPUT_CAP, Math.floor(AGGREGATE_OUTPUT_CAP / n));
+  const counts = /* @__PURE__ */ new Map();
+  for (const o of outcomes) {
+    const s = o?.status ?? "aborted";
+    counts.set(s, (counts.get(s) ?? 0) + 1);
+  }
+  const summary = [...counts.entries()].map(([s, c]) => `${c} ${s}`).join(", ");
+  const sections = outcomes.map((o, i) => {
+    const head = `=== task ${i + 1}/${n} ===`;
+    const body = o ? formatParentText(resolved[i].agent, o, perTaskCap) : `[${resolved[i].agent.name}] never started (aborted while queued)`;
+    return `${head}
+${body}`;
+  });
+  return [`[subagent] ${n} parallel tasks: ${summary}`, ...sections].join("\n\n");
+}
+function formatParentText(agent, outcome, outputCap) {
+  const stats = `${Math.round(outcome.durationMs / 1e3)}s \xB7 ${outcome.usage.turns} turns \xB7 ${fmtTokens(outcome.usage.input + outcome.usage.output)} tokens \xB7 $${outcome.usage.cost.toFixed(3)}`;
+  if (outcome.status === "done") {
+    const body = outcome.finalText || "(the subagent produced no final text)";
+    return `[${agent.name}] done in ${stats}
+
+${tailCap(body, outputCap)}`;
+  }
+  const head = outcome.status === "timeout" ? `[${agent.name}] TIMED OUT after ${stats}` : `[${agent.name}] FAILED (stopReason=${outcome.stopReason ?? "?"}, exit ${outcome.exitCode}) after ${stats}`;
+  const parts = [head];
+  if (outcome.errorMessage) parts.push(`error: ${outcome.errorMessage}`);
+  if (outcome.finalText) parts.push(`partial output:
+${tailCap(outcome.finalText, 2 * 1024)}`);
+  if (outcome.stderrTail) parts.push(`stderr tail:
+${outcome.stderrTail.slice(-STDERR_DETAILS_CAP)}`);
+  if (outcome.transcriptPath) parts.push(`full transcript: ${outcome.transcriptPath}`);
+  if (outcome.status === "timeout") {
+    parts.push(
+      "note for the user: limits are env-tunable \u2014 PI_PILOT_SUBAGENT_STALL_SEC (silence detector) / PI_PILOT_SUBAGENT_TIMEOUT_SEC (total ceiling), server restart applies."
+    );
+  }
+  return parts.join("\n");
+}
+function tailCap(text, max) {
+  if (text.length <= max) return text;
+  const dropped = text.length - max;
+  return `\u2026(${dropped} chars truncated \u2014 full transcript in details)
+${text.slice(-max)}`;
+}
+function fmtTokens(n) {
+  return n >= 1e3 ? `${(n / 1e3).toFixed(1)}k` : String(n);
+}
+function makeThrottledEmitter(onUpdate, details) {
+  let lastEmit = 0;
+  let timer;
+  let cancelled = false;
+  const fire = () => {
+    timer = void 0;
+    lastEmit = Date.now();
+    onUpdate?.({
+      content: [{ type: "text", text: statusLine(details) }],
+      details: structuredClone(details)
+    });
+  };
+  return {
+    emit: (force = false) => {
+      if (cancelled || !onUpdate) return;
+      const elapsed = Date.now() - lastEmit;
+      if (force || elapsed >= UPDATE_THROTTLE_MS) {
+        if (timer) {
+          clearTimeout(timer);
+          timer = void 0;
+        }
+        fire();
+      } else if (!timer) {
+        timer = setTimeout(fire, UPDATE_THROTTLE_MS - elapsed);
+      }
+    },
+    cancel: () => {
+      cancelled = true;
+      if (timer) {
+        clearTimeout(timer);
+        timer = void 0;
+      }
+    }
+  };
+}
+function statusLine(details) {
+  if (details.tasks.length > 1) {
+    const counts = /* @__PURE__ */ new Map();
+    let cost = 0;
+    let turns = 0;
+    for (const t2 of details.tasks) {
+      counts.set(t2.status, (counts.get(t2.status) ?? 0) + 1);
+      cost += t2.usage.cost;
+      turns += t2.usage.turns;
+    }
+    const bits2 = [`${details.tasks.length} tasks`];
+    for (const status2 of ["running", "queued", "done", "failed", "timeout", "aborted"]) {
+      const c = counts.get(status2);
+      if (c) bits2.push(`${c} ${status2}`);
+    }
+    if (turns > 0) bits2.push(`$${cost.toFixed(3)}`);
+    return bits2.join(" \xB7 ");
+  }
+  const t = details.tasks[0];
+  if (!t) return "subagent";
+  const bits = [t.agent, t.status];
+  if (t.usage.turns > 0) {
+    bits.push(`${t.usage.turns} turns`);
+    bits.push(`${fmtTokens(t.usage.input + t.usage.output)} tok`);
+    bits.push(`$${t.usage.cost.toFixed(3)}`);
+  }
+  const last = t.activity[t.activity.length - 1];
+  if (last && t.status === "running") bits.push(last.label);
+  return bits.join(" \xB7 ");
+}
+
+// src/extensions/web_search/schema.ts
+import { Type as Type5 } from "typebox";
+var webSearchParamsSchema = Type5.Object({
+  query: Type5.String({
+    description: "The search query. Phrase it like a search-engine query (keywords, entities), not a chat sentence."
+  }),
+  max_results: Type5.Optional(
+    Type5.Number({
+      description: "How many results to return (1\u201310). Default 5.",
+      minimum: 1,
+      maximum: 10
+    })
+  ),
+  topic: Type5.Optional(
+    Type5.Union([Type5.Literal("general"), Type5.Literal("news")], {
+      description: 'Search topic. Use "news" for recent/current events. Default "general".'
+    })
+  ),
+  search_depth: Type5.Optional(
+    Type5.Union([Type5.Literal("basic"), Type5.Literal("advanced")], {
+      description: '"advanced" digs deeper (slower, costs more credits); "basic" is usually enough. Default "basic".'
+    })
+  )
+});
+var webFetchParamsSchema = Type5.Object({
+  urls: Type5.Array(
+    Type5.String({ description: "An absolute http(s) URL." }),
+    {
+      description: "URLs to fetch and extract the main text from (1\u20135).",
+      minItems: 1,
+      maxItems: 5
+    }
+  )
+});
+
+// src/storage/web-search-prefs.ts
+import { readFile as readFile4 } from "fs/promises";
+import { join as join9 } from "path";
+var PREFS_PATH2 = join9(config.dataDir, "web-search.json");
+var cache4 = {};
+async function loadWebSearchPrefs() {
+  try {
+    const raw = await readFile4(PREFS_PATH2, "utf8");
+    const parsed = JSON.parse(raw);
+    cache4 = { tavilyApiKey: typeof parsed.tavilyApiKey === "string" ? parsed.tavilyApiKey : void 0 };
+  } catch (err2) {
+    cache4 = {};
+    if (err2.code !== "ENOENT") {
+      console.warn(`[web-search-prefs] ignoring unreadable ${PREFS_PATH2}:`, err2);
+    }
+  }
+}
+function getTavilyApiKey() {
+  const fromSettings = cache4.tavilyApiKey?.trim();
+  if (fromSettings) return fromSettings;
+  const fromEnv = process.env.TAVILY_API_KEY?.trim();
+  return fromEnv || void 0;
+}
+function getKeyStatus() {
+  const fromSettings = cache4.tavilyApiKey?.trim();
+  const fromEnv = process.env.TAVILY_API_KEY?.trim();
+  const live = fromSettings || fromEnv || void 0;
+  const source = fromSettings ? "settings" : fromEnv ? "env" : "none";
+  return {
+    configured: Boolean(live),
+    source,
+    ...live ? { hint: maskKey(live) } : {}
+  };
+}
+function maskKey(key) {
+  return `\u2026${key.slice(-4)}`;
+}
+async function setTavilyApiKey(key) {
+  const trimmed = key.trim();
+  cache4 = trimmed ? { tavilyApiKey: trimmed } : {};
+  await save3();
+}
+async function clearTavilyApiKey() {
+  cache4 = {};
+  await save3();
+}
+async function save3() {
+  await writeJsonAtomic(PREFS_PATH2, cache4, { mode: 384 });
+}
+
+// src/extensions/web_search/client.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+function baseUrl() {
+  return process.env.TAVILY_BASE_URL ?? "https://api.tavily.com";
+}
+var WebSearchError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WebSearchError";
+  }
+};
+function apiKey() {
+  const key = getTavilyApiKey();
+  if (!key) {
+    throw new WebSearchError(
+      "Web search is not configured: add a Tavily API key in Settings \u2192 Web search, or set the TAVILY_API_KEY environment variable. Get a free key at https://app.tavily.com."
+    );
+  }
+  return key;
+}
+async function postJson(path, body, signal) {
+  const key = apiKey();
+  const ctl = new AbortController();
+  const onAbort = () => ctl.abort(signal?.reason);
+  if (signal) {
+    if (signal.aborted) ctl.abort(signal.reason);
+    else signal.addEventListener("abort", onAbort, { once: true });
+  }
+  const timer = setTimeout(
+    () => ctl.abort(new WebSearchError(`Tavily request timed out after ${DEFAULT_TIMEOUT_MS / 1e3}s.`)),
+    DEFAULT_TIMEOUT_MS
+  );
+  let res;
+  try {
+    res = await fetch(`${baseUrl()}${path}`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${key}`
+      },
+      body: JSON.stringify(body),
+      signal: ctl.signal
+    });
+  } catch (err2) {
+    if (signal?.aborted) throw err2;
+    const reason = ctl.signal.reason;
+    if (reason instanceof WebSearchError) throw reason;
+    throw new WebSearchError(`Tavily request failed: ${errMsg(err2)}`);
+  } finally {
+    clearTimeout(timer);
+    if (signal) signal.removeEventListener("abort", onAbort);
+  }
+  if (!res.ok) {
+    throw new WebSearchError(await describeHttpError(res));
+  }
+  try {
+    return await res.json();
+  } catch {
+    throw new WebSearchError(
+      `Tavily returned a non-JSON response (HTTP ${res.status}) \u2014 the service may be down or returning an error page.`
+    );
+  }
+}
+async function describeHttpError(res) {
+  let detail = "";
+  try {
+    const data = await res.json();
+    const d = data?.detail ?? data?.error;
+    if (typeof d === "string") detail = d;
+    else if (d && typeof d === "object" && typeof d.error === "string") {
+      detail = d.error;
+    }
+  } catch {
+  }
+  const suffix = detail ? `: ${detail}` : "";
+  if (res.status === 401 || res.status === 403) {
+    return `Tavily rejected the API key (HTTP ${res.status})${suffix}. Check TAVILY_API_KEY.`;
+  }
+  if (res.status === 429) {
+    return `Tavily rate limit / quota exceeded (HTTP 429)${suffix}.`;
+  }
+  return `Tavily request failed (HTTP ${res.status})${suffix}.`;
+}
+function errMsg(err2) {
+  return err2 instanceof Error ? err2.message : String(err2);
+}
+function tavilySearch(opts, signal) {
+  return postJson(
+    "/search",
+    {
+      query: opts.query,
+      max_results: opts.maxResults,
+      topic: opts.topic,
+      search_depth: opts.searchDepth,
+      include_answer: true
+    },
+    signal
+  );
+}
+function tavilyExtract(urls, signal) {
+  return postJson("/extract", { urls }, signal);
+}
+
+// src/extensions/web_search/factory.ts
+var SNIPPET_CARD_CAP = 320;
+var SNIPPET_MODEL_CAP = 1024;
+var FETCH_PREVIEW_CAP = 2 * 1024;
+var FETCH_PER_URL_CAP = 8 * 1024;
+var FETCH_TOTAL_CAP = 24 * 1024;
+function clampInt(v, lo, hi, dflt) {
+  if (typeof v !== "number" || !Number.isFinite(v)) return dflt;
+  return Math.max(lo, Math.min(hi, Math.round(v)));
+}
+function truncate(s, cap) {
+  return s.length <= cap ? s : `${s.slice(0, cap)}\u2026`;
+}
+var webSearchExtensionFactory = (pi) => {
+  pi.registerTool({
+    name: "web_search",
+    label: "Web search",
+    description: "Search the web and get back a short answer plus ranked results (title, URL, snippet). Use it for current events, external documentation, or facts you're unsure of or that may have changed since your training cutoff. Follow up with `web_fetch` to read a result's full page when the snippet isn't enough.",
+    parameters: webSearchParamsSchema,
+    executionMode: "parallel",
+    promptSnippet: "web_search: search the web (answer + ranked results) for current or uncertain facts; pair with web_fetch to read a page in full.",
+    promptGuidelines: [
+      "Reach for web_search when the answer depends on current / post-cutoff information, external docs, or facts you can't verify from the repo or your own knowledge \u2014 not for things you already know.",
+      'Phrase `query` like a search-engine query (keywords, entities), not a chat sentence. Set `topic: "news"` for recent events.',
+      "Cite the URLs you relied on, and use web_fetch to read a page in full before trusting details beyond the snippet."
+    ],
+    async execute(_toolCallId, params, signal) {
+      const query = params.query.trim();
+      if (!query) throw new WebSearchError("web_search needs a non-empty query.");
+      const maxResults = clampInt(params.max_results, 1, 10, 5);
+      const topic = params.topic === "news" ? "news" : "general";
+      const searchDepth = params.search_depth === "advanced" ? "advanced" : "basic";
+      const data = await tavilySearch({ query, maxResults, topic, searchDepth }, signal);
+      const raw = (data.results ?? []).filter(
+        (r) => typeof r.url === "string"
+      );
+      const answer = typeof data.answer === "string" && data.answer.trim() ? data.answer.trim() : void 0;
+      const results = raw.map((r) => ({
+        title: (r.title ?? "").trim() || r.url,
+        url: r.url,
+        content: truncate((r.content ?? "").trim(), SNIPPET_CARD_CAP),
+        score: typeof r.score === "number" ? r.score : void 0,
+        publishedDate: typeof r.published_date === "string" ? r.published_date : void 0
+      }));
+      const details = { version: 1, kind: "search", query, answer, results };
+      return { content: [{ type: "text", text: formatSearch(query, answer, raw) }], details };
+    }
+  });
+  pi.registerTool({
+    name: "web_fetch",
+    label: "Web fetch",
+    description: "Fetch one or more web pages and extract their main text as clean, readable content (stripped of HTML/navigation/boilerplate). Use it to read a page in full \u2014 a URL returned by web_search, a documentation link, or a URL the user gave you.",
+    parameters: webFetchParamsSchema,
+    executionMode: "parallel",
+    promptSnippet: "web_fetch: fetch URL(s) and extract the main page text \u2014 read a web_search result or a user-given link in full.",
+    promptGuidelines: [
+      "Use web_fetch to read the full text of a page when a web_search snippet isn't enough, or whenever the user hands you a URL.",
+      "Pass up to 5 absolute http(s) URLs in one call to read them together."
+    ],
+    async execute(_toolCallId, params, signal) {
+      const urls = params.urls.map((u) => u.trim()).filter(Boolean);
+      if (urls.length === 0) throw new WebSearchError("web_fetch needs at least one non-empty URL.");
+      const data = await tavilyExtract(urls, signal);
+      const results = (data.results ?? []).filter((r) => typeof r.url === "string").map((r) => {
+        const full = (r.raw_content ?? "").trim();
+        return { url: r.url, content: truncate(full, FETCH_PREVIEW_CAP), chars: full.length };
+      });
+      const failed = (data.failed_results ?? []).filter((f) => typeof f.url === "string").map((f) => ({ url: f.url, error: (f.error ?? "extraction failed").toString() }));
+      const details = { version: 1, kind: "fetch", results, failed };
+      return { content: [{ type: "text", text: formatFetch(data) }], details };
+    }
+  });
+};
+function formatSearch(query, answer, results) {
+  const lines = [];
+  lines.push(`Search results for "${query}" (${results.length} result${results.length === 1 ? "" : "s"}):`);
+  if (answer) {
+    lines.push("");
+    lines.push(`Answer: ${answer}`);
+  }
+  results.forEach((r, i) => {
+    lines.push("");
+    lines.push(`${i + 1}. ${(r.title ?? "").trim() || r.url}`);
+    lines.push(`   ${r.url}`);
+    const snippet = (r.content ?? "").trim();
+    if (snippet) lines.push(`   ${truncate(snippet, SNIPPET_MODEL_CAP)}`);
+  });
+  if (results.length === 0) {
+    lines.push("");
+    lines.push("No results found.");
+  }
+  return lines.join("\n");
+}
+function formatFetch(data) {
+  const results = (data.results ?? []).filter(
+    (r) => typeof r.url === "string"
+  );
+  const failed = (data.failed_results ?? []).filter(
+    (f) => typeof f.url === "string"
+  );
+  const lines = [];
+  let budget = FETCH_TOTAL_CAP;
+  for (const r of results) {
+    const full = (r.raw_content ?? "").trim();
+    const cap = Math.min(FETCH_PER_URL_CAP, budget);
+    const slice = full.length > cap ? `${full.slice(0, cap)}\u2026` : full;
+    budget -= Math.min(full.length, cap);
+    lines.push(`## ${r.url}`);
+    lines.push(slice || "(no extractable content)");
+    lines.push("");
+    if (budget <= 0) {
+      lines.push("\u2026 (remaining pages omitted to fit the context budget)");
+      break;
+    }
+  }
+  for (const f of failed) {
+    lines.push(`Failed to fetch ${f.url}: ${f.error ?? "extraction failed"}`);
+  }
+  if (results.length === 0 && failed.length === 0) lines.push("No content extracted.");
+  return lines.join("\n").trim();
+}
+
+// src/storage/builtin-extension-prefs.ts
+import { readFile as readFile5 } from "fs/promises";
+import { join as join10 } from "path";
+var PREFS_PATH3 = join10(config.dataDir, "builtin-extensions.json");
+var cache5 = { disabled: [] };
+async function loadBuiltinPrefs() {
+  try {
+    const raw = await readFile5(PREFS_PATH3, "utf8");
+    const parsed = JSON.parse(raw);
+    cache5 = { disabled: Array.isArray(parsed.disabled) ? parsed.disabled : [] };
+  } catch (err2) {
+    cache5 = { disabled: [] };
+    if (err2.code !== "ENOENT") {
+      console.warn(`[builtin-prefs] ignoring unreadable ${PREFS_PATH3}:`, err2);
+    }
+  }
+}
+function isBuiltinDisabled(id) {
+  if (cache5.disabled.includes(id)) return true;
+  if (id === "todo" && cache5.disabled.includes("plan")) return true;
+  return false;
+}
+function getDisabledBuiltins() {
+  return [...cache5.disabled];
+}
+async function setBuiltinEnabled(id, enabled) {
+  const next = new Set(cache5.disabled);
+  if (enabled) next.delete(id);
+  else next.add(id);
+  cache5 = { disabled: [...next] };
+  await save4();
+}
+async function save4() {
+  await writeJsonAtomic(PREFS_PATH3, cache5);
+}
+
+// src/extensions/index.ts
+var BUILTIN_EXTENSIONS = [
+  {
+    id: "todo",
+    name: "Todo",
+    description: "A CRUD task list for tracking multi-step work \u2014 adds the todo tool and the /todos command.",
+    tools: ["todo"],
+    commands: ["todos"],
+    factory: todoExtensionFactory
+  },
+  {
+    id: "ask_user",
+    name: "Ask user",
+    description: "Lets the agent pause and ask you a structured multiple-choice question \u2014 adds the ask_user tool.",
+    tools: ["ask_user"],
+    commands: [],
+    factory: askUserExtensionFactory
+  },
+  {
+    id: "artifact",
+    name: "Artifacts",
+    description: "Lets the agent publish substantial, self-contained content \u2014 web pages, SVG diagrams, documents, code files \u2014 as versioned artifacts rendered in a side panel. Adds the create_artifact tool.",
+    tools: ["create_artifact"],
+    commands: [],
+    factory: artifactExtensionFactory
+  },
+  {
+    id: "subagent",
+    name: "Subagent",
+    description: "Lets the agent delegate self-contained tasks to isolated child agents (separate pinned-pi processes; only their final report returns). Builtin presets scout/worker/reviewer; user agents from ~/.pi/agent/agents/*.md. Adds the subagent tool.",
+    tools: ["subagent"],
+    commands: [],
+    factory: subagentExtensionFactory
+  },
+  {
+    id: "web",
+    name: "Web search",
+    description: "Lets the agent search the web and read pages \u2014 adds the web_search and web_fetch tools (backed by Tavily; needs the TAVILY_API_KEY environment variable).",
+    tools: ["web_search", "web_fetch"],
+    commands: [],
+    factory: webSearchExtensionFactory
+  }
+];
+function gate(def) {
+  return (pi) => {
+    if (isBuiltinDisabled(def.id)) return;
+    return def.factory(pi);
+  };
+}
+var builtinExtensionFactories = BUILTIN_EXTENSIONS.map(gate);
+
+// src/extensions/ask_user/cleanup.ts
+var CUSTOM_TYPE = "ask_user-restart-cancelled";
+function reconcileAfterRestart(sessionManager) {
+  const branch = sessionManager.getBranch();
+  if (branch.length === 0) return;
+  const satisfied = /* @__PURE__ */ new Set();
+  const danglingIds = [];
+  const danglingAlreadyHandled = /* @__PURE__ */ new Set();
+  for (let i = branch.length - 1; i >= 0; i--) {
+    const entry = branch[i];
+    if (entry.type === "custom_message") {
+      const cm = entry;
+      if (cm.customType === CUSTOM_TYPE) {
+        const ids = cm.details?.ids;
+        if (Array.isArray(ids)) {
+          for (const id of ids) {
+            if (typeof id === "string") danglingAlreadyHandled.add(id);
+          }
+        }
+      }
+      continue;
+    }
+    if (entry.type !== "message") continue;
+    const msg = entry.message;
+    if (msg.role === "toolResult" && typeof msg.toolCallId === "string") {
+      satisfied.add(msg.toolCallId);
+      continue;
+    }
+    if (msg.role === "assistant" && Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        if (!block || typeof block !== "object") continue;
+        const b = block;
+        if (b.type !== "toolCall") continue;
+        if (b.name !== "ask_user") continue;
         if (typeof b.id !== "string") continue;
         if (satisfied.has(b.id)) continue;
         if (danglingAlreadyHandled.has(b.id)) continue;
@@ -876,6 +2500,116 @@ function reconcileAfterRestart(sessionManager) {
   );
 }
 
+// src/extensions/subagent/cleanup.ts
+import { execFile as execFile2 } from "child_process";
+import { readdir, readFile as readFile6, rm as rm4 } from "fs/promises";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join11 } from "path";
+var CUSTOM_TYPE2 = "subagent-restart-cancelled";
+function reconcileAfterRestart2(sessionManager) {
+  const branch = sessionManager.getBranch();
+  if (branch.length === 0) return;
+  const satisfied = /* @__PURE__ */ new Set();
+  const danglingIds = [];
+  const danglingAlreadyHandled = /* @__PURE__ */ new Set();
+  for (let i = branch.length - 1; i >= 0; i--) {
+    const entry = branch[i];
+    if (entry.type === "custom_message") {
+      const cm = entry;
+      if (cm.customType === CUSTOM_TYPE2) {
+        const ids = cm.details?.ids;
+        if (Array.isArray(ids)) {
+          for (const id of ids) {
+            if (typeof id === "string") danglingAlreadyHandled.add(id);
+          }
+        }
+      }
+      continue;
+    }
+    if (entry.type !== "message") continue;
+    const msg = entry.message;
+    if (msg.role === "toolResult" && typeof msg.toolCallId === "string") {
+      satisfied.add(msg.toolCallId);
+      continue;
+    }
+    if (msg.role === "assistant" && Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        if (!block || typeof block !== "object") continue;
+        const b = block;
+        if (b.type !== "toolCall") continue;
+        if (b.name !== "subagent") continue;
+        if (typeof b.id !== "string") continue;
+        if (satisfied.has(b.id)) continue;
+        if (danglingAlreadyHandled.has(b.id)) continue;
+        danglingIds.push(b.id);
+      }
+      break;
+    }
+    if (msg.role === "user") break;
+  }
+  if (danglingIds.length === 0) return;
+  const idList = danglingIds.join(", ");
+  const text = `[pi-pilot] Your previous subagent delegation(s) [${idList}] were cancelled because the server restarted mid-run. The child agent's work may be partially applied to the working tree \u2014 verify before assuming anything happened. Re-delegate if the task still matters.`;
+  sessionManager.appendCustomMessageEntry(
+    CUSTOM_TYPE2,
+    text,
+    true,
+    // display flag — no-op in pi-pilot, harmless in the TUI
+    { ids: danglingIds }
+  );
+}
+async function sweepOrphanedChildrenOnBoot(rootDir = tmpdir2()) {
+  let dirNames;
+  try {
+    dirNames = (await readdir(rootDir)).filter((n) => n.startsWith(PROMPT_DIR_PREFIX));
+  } catch {
+    return;
+  }
+  let swept = 0;
+  for (const name of dirNames) {
+    const dir = join11(rootDir, name);
+    const pidRaw = await readFile6(join11(dir, "pid"), "utf8").catch(() => "");
+    const [childLine, ownerLine] = pidRaw.split("\n");
+    const childPid = Number.parseInt((childLine ?? "").trim(), 10);
+    const ownerPid = Number.parseInt((ownerLine ?? "").trim(), 10);
+    if (Number.isInteger(ownerPid) && ownerPid > 1 && await isLiveNodeProcess(ownerPid)) {
+      continue;
+    }
+    try {
+      if (Number.isInteger(childPid) && childPid > 1 && await isLiveNodeProcess(childPid)) {
+        try {
+          process.kill(childPid, "SIGTERM");
+          swept++;
+        } catch {
+        }
+      }
+    } finally {
+      await rm4(dir, { recursive: true, force: true }).catch(() => {
+      });
+    }
+  }
+  if (swept > 0) {
+    console.warn(`[subagent] swept ${swept} orphaned child(ren) from a previous run`);
+  }
+}
+function isLiveNodeProcess(pid) {
+  try {
+    process.kill(pid, 0);
+  } catch {
+    return Promise.resolve(false);
+  }
+  return new Promise((resolve8) => {
+    execFile2("ps", ["-o", "ucomm=", "-p", String(pid)], (err2, stdout) => {
+      if (err2) {
+        resolve8(false);
+        return;
+      }
+      const name = stdout.trim().toLowerCase();
+      resolve8(name === "node" || name === "pi");
+    });
+  });
+}
+
 // src/ws/bridge.ts
 function translatePiEvent(ev) {
   switch (ev.type) {
@@ -917,13 +2651,16 @@ function translatePiEvent(ev) {
         toolName: ev.toolName,
         args: ev.args
       };
-    case "tool_execution_update":
+    case "tool_execution_update": {
+      const updateDetails = shouldForwardDetails(ev.toolName) ? ev.partialResult?.details : void 0;
       return {
         kind: "tool_execution_update",
         toolCallId: ev.toolCallId,
         toolName: ev.toolName,
-        partialText: extractText(ev.partialResult)
+        partialText: extractText(ev.partialResult),
+        ...updateDetails !== void 0 ? { details: updateDetails } : {}
       };
+    }
     case "tool_execution_end": {
       const details = shouldForwardDetails(ev.toolName) ? ev.result?.details : void 0;
       return {
@@ -1036,6 +2773,37 @@ function inFlightAssistantSnapshot(streamingMessage) {
   }
   return events;
 }
+function inFlightRunningToolsSnapshot(pendingToolCalls, messages) {
+  const pending2 = new Set(pendingToolCalls);
+  if (pending2.size === 0) return [];
+  const infoById = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    if (!message || typeof message !== "object") continue;
+    if (message.role !== "assistant") continue;
+    const content = message.content;
+    if (!Array.isArray(content)) continue;
+    for (const block of content) {
+      if (!block || typeof block !== "object") continue;
+      const b = block;
+      if (b.type === "toolCall" && typeof b.id === "string" && pending2.has(b.id)) {
+        infoById.set(b.id, { name: typeof b.name === "string" ? b.name : "tool", args: b.arguments });
+      }
+    }
+  }
+  const events = [];
+  for (const toolCallId of pending2) {
+    const info = infoById.get(toolCallId);
+    if (!info) continue;
+    if (info.name === "ask_user") continue;
+    events.push({
+      kind: "tool_execution_start",
+      toolCallId,
+      toolName: info.name,
+      args: info.args
+    });
+  }
+  return events;
+}
 function inFlightToolCallsSnapshot(sessionFile) {
   const pending2 = snapshotForSession(sessionFile);
   return pending2.map((p) => ({
@@ -1045,7 +2813,13 @@ function inFlightToolCallsSnapshot(sessionFile) {
     args: p.args
   }));
 }
-var DETAILS_FORWARD_WHITELIST = /* @__PURE__ */ new Set(["ask_user"]);
+var DETAILS_FORWARD_WHITELIST = /* @__PURE__ */ new Set([
+  "ask_user",
+  "todo",
+  "subagent",
+  "web_search",
+  "web_fetch"
+]);
 function shouldForwardDetails(toolName) {
   return DETAILS_FORWARD_WHITELIST.has(toolName);
 }
@@ -1146,6 +2920,7 @@ var ExtensionUIBridge = class {
 
 // src/workspace-manager.ts
 var EXTENSIONS_ENABLED = process.env.PI_PILOT_ENABLE_EXTENSIONS === "1";
+var MAX_LIVE_RUNTIMES = 12;
 var createRuntime = async ({
   cwd,
   sessionManager,
@@ -1169,18 +2944,36 @@ var createRuntime = async ({
     diagnostics: services.diagnostics
   };
 };
-var WorkspaceManager = class {
-  states = /* @__PURE__ */ new Map();
+var KEY_SEP = "\0";
+var SessionRuntimeManager = class {
+  /** All live runtimes, keyed by `runtimeKey`. */
+  runtimes = /* @__PURE__ */ new Map();
+  /** Per-build lock keyed by `runtimeKey` to serialize concurrent creations. */
+  pending = /* @__PURE__ */ new Map();
+  /** The runtime the hub last made primary, per workspace. Drives `get`. */
+  activeByWorkspace = /* @__PURE__ */ new Map();
   /**
-   * Subscribers live independently of `states` so the hub can register a
-   * WebSocket *before* `getOrCreate` triggers a runtime build (which may
-   * fire `session_start` synchronously, and any UI request from a
-   * session_start handler would otherwise broadcast to an empty set).
+   * WS subscribers, keyed by workspaceId (not runtimeKey): a connection
+   * viewing any session of a workspace receives that workspace's
+   * server-initiated broadcasts (extension errors, context_usage). Owned by
+   * the manager so it can pre-exist any runtime build (extensions may fire
+   * `onError` from `session_start` before any client subscribed).
    */
   subscribers = /* @__PURE__ */ new Map();
-  /** Per-workspace lock to serialize concurrent creations. */
-  pending = /* @__PURE__ */ new Map();
-  rebindListeners = /* @__PURE__ */ new Map();
+  touchSeq = 0;
+  /** `runtimeKey` for a (workspace, session identity). */
+  keyOf(workspaceId, sessionIdentity) {
+    return `${workspaceId}${KEY_SEP}${sessionIdentity}`;
+  }
+  /** `runtimeKey` for a built runtime, from its session file (or sessionId). */
+  keyForRuntime(workspaceId, runtime) {
+    const file = runtime.session.sessionFile;
+    return this.keyOf(workspaceId, file ? resolve4(file) : runtime.session.sessionId);
+  }
+  /** Public so the WS hub derives the exact same key for a returned runtime. */
+  runtimeKeyFor(workspaceId, runtime) {
+    return this.keyForRuntime(workspaceId, runtime);
+  }
   getOrCreateSubscriberSet(workspaceId) {
     let set = this.subscribers.get(workspaceId);
     if (!set) {
@@ -1189,64 +2982,187 @@ var WorkspaceManager = class {
     }
     return set;
   }
-  async getOrCreate(workspaceId) {
-    const existing = this.states.get(workspaceId);
-    if (existing) return existing.runtime;
-    const inflight3 = this.pending.get(workspaceId);
-    if (inflight3) return (await inflight3).runtime;
-    const p = this.build(workspaceId);
-    this.pending.set(workspaceId, p);
-    try {
-      const state = await p;
-      this.states.set(workspaceId, state);
-      return state.runtime;
-    } finally {
-      this.pending.delete(workspaceId);
-    }
-  }
-  async build(workspaceId) {
-    const ws = await getWorkspace(workspaceId);
-    if (!ws) throw new Error(`Workspace not found: ${workspaceId}`);
-    const sessionManager = SessionManager.continueRecent(ws.path);
+  /**
+   * Build (but do not register) a runtime for `workspaceId` from a
+   * SessionManager factory. Binds the UI bridge + onError and runs ask_user
+   * post-restart cleanup. The bridge broadcasts to the workspace's subscriber
+   * set, resolved lazily so it works even if the set is created later.
+   */
+  async buildState(workspaceId, cwd, makeSessionManager) {
     const runtime = await createAgentSessionRuntime(createRuntime, {
-      cwd: ws.path,
-      agentDir: getAgentDir(),
-      sessionManager
+      cwd,
+      agentDir: getAgentDir2(),
+      sessionManager: makeSessionManager()
     });
-    const subscribers = this.getOrCreateSubscriberSet(workspaceId);
     const bridge = new ExtensionUIBridge();
-    const onError = (err) => {
+    await this.bindExtensions(workspaceId, runtime, bridge);
+    reapplyToolPrefs(workspaceId, runtime.session);
+    safeReconcileBuiltins(workspaceId, runtime.session.sessionManager);
+    return {
+      runtime,
+      bridge,
+      workspaceId,
+      sessionPath: runtime.session.sessionFile ? resolve4(runtime.session.sessionFile) : null,
+      touchedAt: ++this.touchSeq
+    };
+  }
+  /** Bind (or re-bind, after a fork) the UI context + onError on a session. */
+  async bindExtensions(workspaceId, runtime, bridge) {
+    const onError = (err2) => {
       const msg = {
         type: "extension_error",
         workspaceId,
-        extensionPath: err.extensionPath,
-        event: err.event,
-        message: err.error
+        extensionPath: err2.extensionPath,
+        event: err2.event,
+        message: err2.error
       };
-      broadcastTo(subscribers, msg);
+      const set = this.subscribers.get(workspaceId);
+      if (set) broadcastTo(set, msg);
       console.error(
-        `[ext-error] ${workspaceId} ${err.extensionPath}@${err.event}: ${err.error}` + (err.stack ? `
-${err.stack}` : "")
+        `[ext-error] ${workspaceId} ${err2.extensionPath}@${err2.event}: ${err2.error}` + (err2.stack ? `
+${err2.stack}` : "")
       );
     };
     await runtime.session.bindExtensions({ uiContext: bridge, onError });
-    safeReconcileAskUser(workspaceId, runtime.session.sessionManager);
-    runtime.setRebindSession(async () => {
-      await runtime.session.bindExtensions({ uiContext: bridge, onError });
-      cancelPendingExcept(runtime.session.sessionFile ?? null);
-      safeReconcileAskUser(workspaceId, runtime.session.sessionManager);
-      this.notifySessionReplaced(workspaceId);
-    });
-    return { runtime, bridge };
   }
+  /** Register a freshly-built state under its session key, deduping against a
+   *  concurrent build of the same session. Returns the winning state. */
+  async adopt(state) {
+    const key = this.keyForRuntime(state.workspaceId, state.runtime);
+    const existing = this.runtimes.get(key);
+    if (existing) {
+      await this.disposeState(state);
+      return existing;
+    }
+    this.runtimes.set(key, state);
+    this.evictIfOverCap(key);
+    return state;
+  }
+  /**
+   * Ensure a runtime exists for the target session and return it.
+   *
+   * - With `sessionPath`: opens that specific session (deduped by key).
+   * - Without: returns the workspace's active/any live runtime, or builds the
+   *   "continue recent" default if none exists yet.
+   *
+   * Does NOT change the active pointer — the hub owns that via `setActive`.
+   */
+  async getOrCreate(workspaceId, sessionPath) {
+    const ws = await getWorkspace(workspaceId);
+    if (!ws) throw new Error(`Workspace not found: ${workspaceId}`);
+    if (sessionPath) {
+      if (!isAbsolute2(sessionPath)) throw new Error("Session path must be absolute");
+      const resolved = resolve4(sessionPath);
+      const key = this.keyOf(workspaceId, resolved);
+      const existing2 = this.runtimes.get(key);
+      if (existing2) {
+        existing2.touchedAt = ++this.touchSeq;
+        return existing2.runtime;
+      }
+      const inflight4 = this.pending.get(key);
+      if (inflight4) return (await inflight4).runtime;
+      const p2 = this.buildState(
+        workspaceId,
+        ws.path,
+        () => SessionManager.open(resolved, void 0, ws.path)
+      ).then((s) => this.adopt(s));
+      this.pending.set(key, p2);
+      try {
+        return (await p2).runtime;
+      } finally {
+        this.pending.delete(key);
+      }
+    }
+    const existing = this.get(workspaceId);
+    if (existing) return existing;
+    const defaultKey = this.keyOf(workspaceId, "<default>");
+    const inflight3 = this.pending.get(defaultKey);
+    if (inflight3) return (await inflight3).runtime;
+    const p = this.buildState(
+      workspaceId,
+      ws.path,
+      () => SessionManager.continueRecent(ws.path)
+    ).then((s) => this.adopt(s));
+    this.pending.set(defaultKey, p);
+    try {
+      return (await p).runtime;
+    } finally {
+      this.pending.delete(defaultKey);
+    }
+  }
+  /** Create a brand-new empty session + runtime for the workspace (does not
+   *  touch any existing runtime, so a streaming session keeps running). */
+  async createSession(workspaceId) {
+    const ws = await getWorkspace(workspaceId);
+    if (!ws) throw new Error(`Workspace not found: ${workspaceId}`);
+    const state = await this.buildState(
+      workspaceId,
+      ws.path,
+      () => SessionManager.create(ws.path)
+    );
+    return (await this.adopt(state)).runtime;
+  }
+  /**
+   * Fork an existing session at `entryId` into a new branched session and
+   * return a runtime bound to the branch. The source session's own runtime
+   * (if any) is untouched. Returns `{ cancelled: true }` if pi cancelled the
+   * fork (e.g. a `session_before_switch` veto).
+   */
+  async fork(workspaceId, sourceSessionPath, entryId) {
+    const ws = await getWorkspace(workspaceId);
+    if (!ws) throw new Error(`Workspace not found: ${workspaceId}`);
+    if (!isAbsolute2(sourceSessionPath)) throw new Error("Session path must be absolute");
+    const state = await this.buildState(
+      workspaceId,
+      ws.path,
+      () => SessionManager.open(resolve4(sourceSessionPath), void 0, ws.path)
+    );
+    let result;
+    try {
+      result = await state.runtime.fork(entryId);
+    } catch (err2) {
+      await this.disposeState(state);
+      throw err2;
+    }
+    if (result.cancelled) {
+      await this.disposeState(state);
+      return { cancelled: true };
+    }
+    await this.bindExtensions(workspaceId, state.runtime, state.bridge);
+    safeReconcileBuiltins(workspaceId, state.runtime.session.sessionManager);
+    state.sessionPath = state.runtime.session.sessionFile ? resolve4(state.runtime.session.sessionFile) : null;
+    const winner = await this.adopt(state);
+    return { cancelled: false, runtime: winner.runtime };
+  }
+  /** The active session's runtime for this workspace (hub-designated), or any
+   *  live runtime for it, or undefined. Used by per-workspace REST routes. */
   get(workspaceId) {
-    return this.states.get(workspaceId)?.runtime;
+    const activeKey = this.activeByWorkspace.get(workspaceId);
+    if (activeKey) {
+      const active = this.runtimes.get(activeKey);
+      if (active) return active.runtime;
+    }
+    for (const state of this.runtimes.values()) {
+      if (state.workspaceId === workspaceId) return state.runtime;
+    }
+    return void 0;
+  }
+  /** The runtime bound to a specific (workspace, session), if live. */
+  getForSession(workspaceId, sessionPath) {
+    return this.runtimes.get(this.keyOf(workspaceId, resolve4(sessionPath)))?.runtime;
+  }
+  /** Mark `runtime` as the active session for its workspace (hub on primary
+   *  bind), so per-workspace routes resolve to it. */
+  setActive(workspaceId, runtime) {
+    const key = this.keyForRuntime(workspaceId, runtime);
+    this.activeByWorkspace.set(workspaceId, key);
+    const state = this.runtimes.get(key);
+    if (state) state.touchedAt = ++this.touchSeq;
   }
   /**
-   * Register a WS connection as a subscriber for `workspaceId`. Safe to
-   * call before `getOrCreate`; the set is lazily created so the bridge,
-   * when later built, sees the same Set instance and any pre-existing
-   * subscribers.
+   * Register a WS connection as a subscriber for `workspaceId` (server-
+   * initiated broadcasts: extension errors, context_usage). Safe to call
+   * before any runtime build.
    */
   addSubscriber(workspaceId, ws) {
     this.getOrCreateSubscriberSet(workspaceId).add(ws);
@@ -1257,60 +3173,44 @@ ${err.stack}` : "")
     set.delete(ws);
     if (set.size === 0) this.subscribers.delete(workspaceId);
   }
-  /**
-   * Fan a server-initiated message out to every WS subscribed to the
-   * workspace. Used by API handlers that mutate runtime state and need
-   * to refresh derived snapshots (e.g. `context_usage` after `setModel`,
-   * which pi's event stream doesn't surface unless thinking-level also
-   * clamps).
-   */
+  /** Fan a server-initiated message out to every WS subscribed to the
+   *  workspace (e.g. context_usage after setModel). */
   broadcast(workspaceId, msg) {
     const set = this.subscribers.get(workspaceId);
     if (!set || set.size === 0) return;
     broadcastTo(set, msg);
   }
-  onSessionReplaced(workspaceId, listener) {
-    let listeners = this.rebindListeners.get(workspaceId);
-    if (!listeners) {
-      listeners = /* @__PURE__ */ new Set();
-      this.rebindListeners.set(workspaceId, listeners);
-    }
-    listeners.add(listener);
-    return () => {
-      const current = this.rebindListeners.get(workspaceId);
-      if (!current) return;
-      current.delete(listener);
-      if (current.size === 0) {
-        this.rebindListeners.delete(workspaceId);
-      }
-    };
-  }
-  notifySessionReplaced(workspaceId) {
-    const listeners = this.rebindListeners.get(workspaceId);
-    if (!listeners) return;
-    for (const listener of [...listeners]) {
-      try {
-        listener();
-      } catch (e) {
-        console.error(`[wm] rebind listener for ${workspaceId} failed:`, e);
-      }
-    }
+  /**
+   * Check that `sessionPath` belongs to the given workspace's session list.
+   * Returns an error string if validation fails, or `null` if the path is
+   * owned by this workspace.
+   */
+  async validateSessionOwnership(workspaceId, sessionPath) {
+    if (!isAbsolute2(sessionPath)) return "session path must be absolute";
+    const ws = await getWorkspace(workspaceId);
+    if (!ws) return `workspace not found: ${workspaceId}`;
+    const sessions = await SessionManager.list(ws.path);
+    const resolved = resolve4(sessionPath);
+    const found = sessions.some((s) => resolve4(s.path) === resolved);
+    if (!found) return `session not found in workspace: ${sessionPath}`;
+    return null;
   }
   async listSessions(workspaceId) {
     const ws = await getWorkspace(workspaceId);
     if (!ws) throw new Error(`Workspace not found: ${workspaceId}`);
+    const streaming = /* @__PURE__ */ new Set();
+    for (const state of this.runtimes.values()) {
+      if (state.workspaceId !== workspaceId) continue;
+      if (state.sessionPath && state.runtime.session.isStreaming) {
+        streaming.add(state.sessionPath);
+      }
+    }
     const sessions = await SessionManager.list(ws.path);
-    return sessions.slice().sort((a, b) => b.modified.getTime() - a.modified.getTime()).map(toSessionSummary);
+    return sessions.slice().sort((a, b) => b.modified.getTime() - a.modified.getTime()).map((info) => toSessionSummary(info, streaming.has(resolve4(info.path))));
   }
   getSessionHistory(workspaceId, sessionPath) {
-    const runtime = this.states.get(workspaceId)?.runtime;
+    const runtime = sessionPath ? this.getForSession(workspaceId, sessionPath) : this.get(workspaceId);
     if (!runtime) return { items: [], isStreaming: false };
-    if (sessionPath) {
-      const activeFile = runtime.session.sessionFile ? resolve2(runtime.session.sessionFile) : void 0;
-      if (activeFile !== resolve2(sessionPath)) {
-        return { items: [], isStreaming: false };
-      }
-    }
     const isStreaming = runtime.session.isStreaming ?? false;
     const branch = runtime.session.sessionManager.getBranch();
     const items = [];
@@ -1321,7 +3221,7 @@ ${err.stack}` : "")
       const role = msg.role;
       if (role === "user") {
         const text = extractUserText2(msg);
-        if (text) items.push({ kind: "user", text });
+        if (text) items.push({ kind: "user", text, entryId: entry.id });
       } else if (role === "assistant") {
         const { text, thinking, toolCalls } = extractAssistantContent(
           msg
@@ -1359,15 +3259,13 @@ ${err.stack}` : "")
   /**
    * Delete a session JSONL file belonging to this workspace.
    *
-   * Errors are tagged with HTTP semantics via HttpError so the route layer
-   * can map them to the right status code:
+   * HTTP-tagged errors (HttpError) map to status codes at the route layer:
    *   - 400: sessionPath not absolute
    *   - 404: workspace gone, or session not in this workspace's list
-   *   - 409: file is the currently-active session (caller must switch first)
+   *   - 409: a live runtime is bound to it and is streaming (stop it first)
    *
-   * Idempotent on ENOENT: if the file is missing at unlink time (e.g. a
-   * concurrent external delete between list and unlink), we treat it as
-   * success — the goal state has been reached.
+   * If a live but idle runtime is bound to the session, it is disposed before
+   * the file is unlinked. Idempotent on ENOENT.
    */
   async deleteSession(workspaceId, sessionPath) {
     const ws = await getWorkspace(workspaceId);
@@ -1376,90 +3274,124 @@ ${err.stack}` : "")
       throw new HttpError(400, "Session path must be absolute");
     }
     const sessions = await SessionManager.list(ws.path);
-    const resolved = resolve2(sessionPath);
-    const target = sessions.find((session) => resolve2(session.path) === resolved);
+    const resolved = resolve4(sessionPath);
+    const target = sessions.find((session) => resolve4(session.path) === resolved);
     if (!target) {
       throw new HttpError(404, `Session not found: ${sessionPath}`);
     }
-    const runtime = this.states.get(workspaceId)?.runtime;
-    const activePath = runtime?.session.sessionFile ? resolve2(runtime.session.sessionFile) : void 0;
-    if (activePath === resolved) {
-      throw new HttpError(
-        409,
-        "Cannot delete the currently active session \u2014 switch to another session first"
-      );
+    const key = this.keyOf(workspaceId, resolved);
+    const live = this.runtimes.get(key);
+    if (live) {
+      if (live.runtime.session.isStreaming) {
+        throw new HttpError(
+          409,
+          "Cannot delete a streaming session \u2014 stop it first"
+        );
+      }
+      await this.disposeState(live, key);
     }
     try {
       await unlink2(resolved);
-    } catch (err) {
-      if (err?.code === "ENOENT") {
+    } catch (err2) {
+      if (err2?.code === "ENOENT") {
         console.warn(
           `[wm] deleteSession: ${resolved} was already gone at unlink time`
         );
+        await forgetSessionToolPrefs(resolved);
         return;
-      }
-      throw err;
-    }
-  }
-  async switchSession(workspaceId, sessionPath) {
-    const ws = await getWorkspace(workspaceId);
-    if (!ws) throw new Error(`Workspace not found: ${workspaceId}`);
-    if (!isAbsolute2(sessionPath)) {
-      throw new Error("Session path must be absolute");
-    }
-    const sessions = await SessionManager.list(ws.path);
-    const resolved = resolve2(sessionPath);
-    const target = sessions.find((session) => resolve2(session.path) === resolved);
-    if (!target) {
-      throw new Error(`Session not found: ${sessionPath}`);
-    }
-    const runtime = await this.getOrCreate(workspaceId);
-    const currentPath = runtime.session.sessionFile ? resolve2(runtime.session.sessionFile) : void 0;
-    if (currentPath === resolved) return false;
-    if (runtime.session.isStreaming) {
-      throw new Error("Cannot switch sessions while the agent is streaming");
+      }
+      throw err2;
     }
-    const result = await runtime.switchSession(resolved, { cwdOverride: ws.path });
-    return !result.cancelled;
+    await forgetSessionToolPrefs(resolved);
   }
+  /** Dispose every runtime for a workspace (e.g. when it's removed). */
   async dispose(workspaceId) {
-    const state = this.states.get(workspaceId);
-    if (!state) return;
-    this.states.delete(workspaceId);
-    this.rebindListeners.delete(workspaceId);
+    this.activeByWorkspace.delete(workspaceId);
     this.subscribers.delete(workspaceId);
+    const doomed = [...this.runtimes].filter(([, s]) => s.workspaceId === workspaceId);
+    for (const [key, state] of doomed) {
+      await this.disposeState(state, key);
+    }
+  }
+  async disposeAll() {
+    await Promise.allSettled([...this.pending.values()]);
+    const states = [...this.runtimes.entries()];
+    this.runtimes.clear();
+    this.activeByWorkspace.clear();
+    this.subscribers.clear();
+    await Promise.all(states.map(([, state]) => this.disposeState(state)));
+  }
+  /** Tear down a single runtime + its bridge, releasing any ask_user Promises
+   *  bound to it first. Removes it from `runtimes` when `key` is given. */
+  async disposeState(state, key) {
+    if (key) this.runtimes.delete(key);
+    if (key && this.activeByWorkspace.get(state.workspaceId) === key) {
+      this.activeByWorkspace.delete(state.workspaceId);
+    }
     cancelPendingForSession(state.runtime.session.sessionFile ?? null);
     try {
       state.bridge.dispose();
     } catch (e) {
-      console.error(`[wm] dispose bridge ${workspaceId} failed:`, e);
+      console.error(`[wm] dispose bridge ${state.workspaceId} failed:`, e);
     }
     try {
-      state.runtime.session.dispose();
+      await state.runtime.dispose();
     } catch (e) {
-      console.error(`[wm] dispose ${workspaceId} failed:`, e);
+      console.error(`[wm] dispose ${state.workspaceId} failed:`, e);
+    }
+    const sweptChildren = killChildrenForSession(state.runtime.session.sessionFile ?? null);
+    if (sweptChildren > 0) {
+      console.warn(
+        `[wm] killed ${sweptChildren} lingering subagent child(ren) for ${state.workspaceId}`
+      );
     }
   }
-  async disposeAll() {
-    await Promise.allSettled([...this.pending.values()]);
-    const ids = [...this.states.keys()];
-    await Promise.all(ids.map((id) => this.dispose(id)));
+  /**
+   * Keep the live-runtime count under `MAX_LIVE_RUNTIMES` by disposing the
+   * least-recently-touched IDLE runtime (never streaming, never the freshly-
+   * registered one, never a workspace's active pointer). Best-effort: if every
+   * runtime is busy we simply exceed the cap until one frees up.
+   */
+  evictIfOverCap(justRegistered) {
+    while (this.runtimes.size > MAX_LIVE_RUNTIMES) {
+      let victimKey;
+      let victimTouched = Infinity;
+      for (const [key, state] of this.runtimes) {
+        if (key === justRegistered) continue;
+        if (this.activeByWorkspace.get(state.workspaceId) === key) continue;
+        if (state.runtime.session.isStreaming) continue;
+        if (state.touchedAt < victimTouched) {
+          victimTouched = state.touchedAt;
+          victimKey = key;
+        }
+      }
+      if (!victimKey) break;
+      const victim = this.runtimes.get(victimKey);
+      if (!victim) break;
+      void this.disposeState(victim, victimKey);
+    }
   }
 };
-function safeReconcileAskUser(workspaceId, sm) {
+function safeReconcileBuiltins(workspaceId, sm) {
   try {
     reconcileAfterRestart(sm);
   } catch (e) {
     console.error(`[wm] ask_user cleanup for ${workspaceId} failed:`, e);
   }
+  try {
+    reconcileAfterRestart2(sm);
+  } catch (e) {
+    console.error(`[wm] subagent cleanup for ${workspaceId} failed:`, e);
+  }
 }
-function toSessionSummary(info) {
+function toSessionSummary(info, running2) {
   const preview = info.firstMessage.replace(/\s+/g, " ").trim();
   return {
     path: info.path,
     name: info.name,
     updatedAt: info.modified.toISOString(),
-    preview: preview ? preview.slice(0, 160) : void 0
+    preview: preview ? preview.slice(0, 160) : void 0,
+    ...running2 ? { running: true } : {}
   };
 }
 function extractUserText2(msg) {
@@ -1495,7 +3427,7 @@ function extractContentText(content) {
   }
   return parts.join("");
 }
-var workspaceManager = new WorkspaceManager();
+var workspaceManager = new SessionRuntimeManager();
 function broadcastTo(subscribers, msg) {
   const wire = JSON.stringify(msg);
   for (const ws of subscribers) {
@@ -1508,6 +3440,9 @@ function broadcastTo(subscribers, msg) {
 }
 
 // src/api/config.ts
+var BUILTIN_TOOL_SOURCE = new Map(
+  BUILTIN_EXTENSIONS.flatMap((d) => d.tools.map((tool) => [tool, d.name]))
+);
 function buildConfigResponse(workspaceId) {
   const runtime = workspaceManager.get(workspaceId);
   if (!runtime) throw new Error("runtime not initialized");
@@ -1525,10 +3460,14 @@ function buildConfigResponse(workspaceId) {
     name: m.name,
     reasoning: m.reasoning
   }));
-  const allTools = session.getAllTools().map((t) => ({
-    name: t.name,
-    description: t.description
-  }));
+  const allTools = session.getAllTools().map((t) => {
+    const builtinExtension = BUILTIN_TOOL_SOURCE.get(t.name);
+    return {
+      name: t.name,
+      description: t.description,
+      ...builtinExtension ? { builtinExtension } : {}
+    };
+  });
   return {
     currentModel,
     thinkingLevel: session.thinkingLevel,
@@ -1578,8 +3517,8 @@ function mountConfigRoutes(app2) {
     try {
       await workspaceManager.getOrCreate(id);
       return c.json(buildConfigResponse(id));
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
+    } catch (err2) {
+      const message = err2 instanceof Error ? err2.message : String(err2);
       return c.json({ ok: false, error: message }, 500);
     }
   });
@@ -1605,8 +3544,8 @@ function mountConfigRoutes(app2) {
       await runtime.session.setModel(model);
       broadcastContextUsage(id, runtime);
       return c.json(buildConfigResponse(id));
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
+    } catch (err2) {
+      const message = err2 instanceof Error ? err2.message : String(err2);
       return c.json({ ok: false, error: message }, 500);
     }
   });
@@ -1630,8 +3569,8 @@ function mountConfigRoutes(app2) {
       }
       runtime.session.setThinkingLevel(body.level);
       return c.json(buildConfigResponse(id));
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
+    } catch (err2) {
+      const message = err2 instanceof Error ? err2.message : String(err2);
       return c.json({ ok: false, error: message }, 500);
     }
   });
@@ -1652,21 +3591,50 @@ function mountConfigRoutes(app2) {
       if (!runtime) {
         return c.json({ ok: false, error: "runtime not initialized" }, 500);
       }
-      runtime.session.setActiveToolsByName(body.tools);
+      await persistActiveTools(id, runtime.session, body.tools);
       return c.json(buildConfigResponse(id));
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
+    } catch (err2) {
+      const message = err2 instanceof Error ? err2.message : String(err2);
+      return c.json({ ok: false, error: message }, 500);
+    }
+  });
+  app2.put("/:id/config/session-name", async (c) => {
+    const id = c.req.param("id");
+    const exists2 = await requireWorkspace(c, id);
+    if (!exists2) return c.json({ ok: false, error: "not found" }, 404);
+    const body = await c.req.json();
+    if (typeof body?.name !== "string") {
+      return c.json({ ok: false, error: "name is required" }, 400);
+    }
+    const trimmed = body.name.trim();
+    if (!trimmed) {
+      return c.json({ ok: false, error: "name must not be empty" }, 400);
+    }
+    try {
+      const sessionPath = c.req.query("sessionPath");
+      if (sessionPath) {
+        const err2 = await workspaceManager.validateSessionOwnership(id, sessionPath);
+        if (err2) return c.json({ ok: false, error: err2 }, 404);
+      }
+      const runtime = await workspaceManager.getOrCreate(id, sessionPath || void 0);
+      if (runtime.session.isStreaming) {
+        return c.json({ ok: false, error: "cannot rename while the agent is streaming" }, 409);
+      }
+      runtime.session.setSessionName(trimmed);
+      return c.json({ name: trimmed });
+    } catch (err2) {
+      const message = err2 instanceof Error ? err2.message : String(err2);
       return c.json({ ok: false, error: message }, 500);
     }
   });
 }
 
 // src/api/files.ts
-import { execFile as execFile2 } from "child_process";
-import { readdir } from "fs/promises";
-import { join as join5, relative, sep as sep2 } from "path";
+import { execFile as execFile3 } from "child_process";
+import { readdir as readdir2 } from "fs/promises";
+import { join as join12, relative, sep as sep2 } from "path";
 import { promisify as promisify2 } from "util";
-var exec2 = promisify2(execFile2);
+var exec2 = promisify2(execFile3);
 var LIST_TTL_MS = 1e4;
 var MAX_CACHED_WORKSPACES = 16;
 var MAX_FILES_TRACKED = 2e4;
@@ -1694,8 +3662,8 @@ var listCache = /* @__PURE__ */ new Map();
 var inflight2 = /* @__PURE__ */ new Map();
 async function getFileList(workspacePath) {
   const now = Date.now();
-  const cached = listCache.get(workspacePath);
-  if (cached && cached.expiresAt > now) return cached.files;
+  const cached2 = listCache.get(workspacePath);
+  if (cached2 && cached2.expiresAt > now) return cached2.files;
   const pending2 = inflight2.get(workspacePath);
   if (pending2) return (await pending2).files;
   const probe = probeFileList(workspacePath).then((files) => {
@@ -1746,14 +3714,14 @@ async function walkDir(root, dir, depth, out) {
   if (depth > WALK_MAX_DEPTH) return;
   let dirents;
   try {
-    dirents = await readdir(dir, { withFileTypes: true });
+    dirents = await readdir2(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const d of dirents) {
     if (out.length >= MAX_FILES_TRACKED) return;
     if (WALK_IGNORES.has(d.name)) continue;
-    const abs = join5(dir, d.name);
+    const abs = join12(dir, d.name);
     if (d.isDirectory()) {
       await walkDir(root, abs, depth + 1, out);
     } else if (d.isFile()) {
@@ -1793,7 +3761,7 @@ function mountFilesRoute(app2) {
       if (!qRaw) {
         const slice = all.slice(0, limit);
         entries = slice.map((relPath) => ({
-          path: join5(workspacePath, relPath),
+          path: join12(workspacePath, relPath),
           relPath
         }));
         truncated = all.length > limit;
@@ -1810,25 +3778,25 @@ function mountFilesRoute(app2) {
         scored.sort((a, b) => b.score - a.score);
         const top = scored.slice(0, limit);
         entries = top.map((e) => ({
-          path: join5(workspacePath, e.relPath),
+          path: join12(workspacePath, e.relPath),
           relPath: e.relPath
         }));
         truncated = matchCount > limit;
       }
       const body = { workspacePath, entries, truncated };
       return c.json(body);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      console.error(`[api/files] search for ${id} failed:`, err);
+    } catch (err2) {
+      const message = err2 instanceof Error ? err2.message : String(err2);
+      console.error(`[api/files] search for ${id} failed:`, err2);
       return c.json({ ok: false, error: message }, 500);
     }
   });
 }
 
 // src/api/resources.ts
-import { readdir as readdir2 } from "fs/promises";
-import { join as join6 } from "path";
-import { getAgentDir as getAgentDir2 } from "@earendil-works/pi-coding-agent";
+import { readdir as readdir3 } from "fs/promises";
+import { join as join13 } from "path";
+import { getAgentDir as getAgentDir3 } from "@earendil-works/pi-coding-agent";
 function toResourceSource(info) {
   return {
     scope: info.scope,
@@ -1837,16 +3805,16 @@ function toResourceSource(info) {
   };
 }
 async function scanExtensionDirs(workspaceCwd) {
-  const dirs = [join6(getAgentDir2(), "extensions"), join6(workspaceCwd, ".pi", "extensions")];
+  const dirs = [join13(getAgentDir3(), "extensions"), join13(workspaceCwd, ".pi", "extensions")];
   const found = [];
   for (const dir of dirs) {
     try {
-      const entries = await readdir2(dir, { withFileTypes: true });
+      const entries = await readdir3(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isFile() && (entry.name.endsWith(".ts") || entry.name.endsWith(".js"))) {
-          found.push(join6(dir, entry.name));
+          found.push(join13(dir, entry.name));
         } else if (entry.isDirectory()) {
-          found.push(join6(dir, entry.name));
+          found.push(join13(dir, entry.name));
         }
       }
     } catch {
@@ -1901,9 +3869,9 @@ async function snapshot(workspaceId, roots, workspaceCwd) {
       shortcuts: [...e.shortcuts.keys()]
     };
   });
-  const extensionErrors = extResult.errors.map((err) => ({
-    path: err.path,
-    error: err.error
+  const extensionErrors = extResult.errors.map((err2) => ({
+    path: err2.path,
+    error: err2.error
   }));
   const disabledExtensions = EXTENSIONS_ENABLED ? [] : await scanExtensionDirs(workspaceCwd);
   const disabledBuiltins = new Set(getDisabledBuiltins());
@@ -1928,15 +3896,15 @@ async function snapshot(workspaceId, roots, workspaceCwd) {
 async function rootsFor(workspaceId) {
   const ws = await getWorkspace(workspaceId);
   if (!ws) throw new HttpError(404, "workspace not found");
-  const roots = resolveResourceRoots({ agentDir: getAgentDir2(), workspaceCwd: ws.path });
+  const roots = resolveResourceRoots({ agentDir: getAgentDir3(), workspaceCwd: ws.path });
   return { roots, workspaceCwd: ws.path };
 }
-function respondError(c, err) {
-  if (err instanceof HttpError) {
-    return c.json({ ok: false, error: err.message }, err.status);
+function respondError(c, err2) {
+  if (err2 instanceof HttpError) {
+    return c.json({ ok: false, error: err2.message }, err2.status);
   }
-  const message = err instanceof Error ? err.message : String(err);
-  console.error(`[api/resources] unexpected error:`, err);
+  const message = err2 instanceof Error ? err2.message : String(err2);
+  console.error(`[api/resources] unexpected error:`, err2);
   return c.json({ ok: false, error: message }, 500);
 }
 async function reload(workspaceId) {
@@ -1953,8 +3921,8 @@ function mountResourcesRoute(app2) {
       await workspaceManager.getOrCreate(id);
       const { roots, workspaceCwd } = await rootsFor(id);
       return c.json(await snapshot(id, roots, workspaceCwd));
-    } catch (err) {
-      return respondError(c, err);
+    } catch (err2) {
+      return respondError(c, err2);
     }
   });
   app2.post("/:id/resources/reload", async (c) => {
@@ -1966,8 +3934,8 @@ function mountResourcesRoute(app2) {
       await reload(id);
       const { roots, workspaceCwd } = await rootsFor(id);
       return c.json(await snapshot(id, roots, workspaceCwd));
-    } catch (err) {
-      return respondError(c, err);
+    } catch (err2) {
+      return respondError(c, err2);
     }
   });
   app2.get("/:id/resources/skill", async (c) => {
@@ -1992,8 +3960,8 @@ function mountResourcesRoute(app2) {
         body: data.body
       };
       return c.json(body);
-    } catch (err) {
-      return respondError(c, err);
+    } catch (err2) {
+      return respondError(c, err2);
     }
   });
   app2.post("/:id/resources/skills", async (c) => {
@@ -2017,8 +3985,8 @@ function mountResourcesRoute(app2) {
       });
       await reload(id);
       return c.json(await snapshot(id, roots, workspaceCwd));
-    } catch (err) {
-      return respondError(c, err);
+    } catch (err2) {
+      return respondError(c, err2);
     }
   });
   app2.put("/:id/resources/skills", async (c) => {
@@ -2042,8 +4010,8 @@ function mountResourcesRoute(app2) {
       });
       await reload(id);
       return c.json(await snapshot(id, roots, workspaceCwd));
-    } catch (err) {
-      return respondError(c, err);
+    } catch (err2) {
+      return respondError(c, err2);
     }
   });
   app2.delete("/:id/resources/skills", async (c) => {
@@ -2058,8 +4026,8 @@ function mountResourcesRoute(app2) {
       await deleteSkill(filePath, roots);
       await reload(id);
       return c.json(await snapshot(id, roots, workspaceCwd));
-    } catch (err) {
-      return respondError(c, err);
+    } catch (err2) {
+      return respondError(c, err2);
     }
   });
   app2.get("/:id/resources/prompt", async (c) => {
@@ -2084,8 +4052,8 @@ function mountResourcesRoute(app2) {
         body: data.body
       };
       return c.json(body);
-    } catch (err) {
-      return respondError(c, err);
+    } catch (err2) {
+      return respondError(c, err2);
     }
   });
   app2.post("/:id/resources/prompts", async (c) => {
@@ -2109,8 +4077,8 @@ function mountResourcesRoute(app2) {
       });
       await reload(id);
       return c.json(await snapshot(id, roots, workspaceCwd));
-    } catch (err) {
-      return respondError(c, err);
+    } catch (err2) {
+      return respondError(c, err2);
     }
   });
   app2.put("/:id/resources/prompts", async (c) => {
@@ -2134,8 +4102,8 @@ function mountResourcesRoute(app2) {
       });
       await reload(id);
       return c.json(await snapshot(id, roots, workspaceCwd));
-    } catch (err) {
-      return respondError(c, err);
+    } catch (err2) {
+      return respondError(c, err2);
     }
   });
   app2.delete("/:id/resources/prompts", async (c) => {
@@ -2150,8 +4118,8 @@ function mountResourcesRoute(app2) {
       await deletePrompt(filePath, roots);
       await reload(id);
       return c.json(await snapshot(id, roots, workspaceCwd));
-    } catch (err) {
-      return respondError(c, err);
+    } catch (err2) {
+      return respondError(c, err2);
     }
   });
   app2.put("/:id/resources/builtin-extensions", async (c) => {
@@ -2175,10 +4143,11 @@ function mountResourcesRoute(app2) {
       }
       await setBuiltinEnabled(body.id, body.enabled);
       await runtime.session.reload();
+      reapplyToolPrefs(id, runtime.session);
       const { roots, workspaceCwd } = await rootsFor(id);
       return c.json(await snapshot(id, roots, workspaceCwd));
-    } catch (err) {
-      return respondError(c, err);
+    } catch (err2) {
+      return respondError(c, err2);
     }
   });
 }
@@ -2186,14 +4155,182 @@ function isScope(value) {
   return value === "user" || value === "project";
 }
 
+// src/api/tree.ts
+import { Hono } from "hono";
+var treeRoute = new Hono();
+treeRoute.get("/", async (c) => {
+  const id = c.req.param("id") ?? "";
+  const existed = await getWorkspace(id);
+  if (!existed) return c.json({ ok: false, error: "not found" }, 404);
+  try {
+    const runtime = await workspaceManager.getOrCreate(id);
+    const sm = runtime.session.sessionManager;
+    const tree = sm.getTree();
+    const leafId = sm.getLeafId();
+    const activeIds = /* @__PURE__ */ new Set();
+    if (leafId) {
+      const branch = sm.getBranch(leafId);
+      for (const entry of branch) {
+        activeIds.add(entry.id);
+      }
+    }
+    const nodes = [];
+    flattenTree(tree, leafId, activeIds, nodes, 0);
+    const body = { nodes, leafId };
+    return c.json(body);
+  } catch (err2) {
+    const message = err2 instanceof Error ? err2.message : String(err2);
+    console.error(`[api] tree for ${id} failed:`, err2);
+    return c.json({ ok: false, error: message }, 500);
+  }
+});
+function flattenTree(nodes, leafId, activeIds, out, depth) {
+  const sorted = [...nodes].sort(
+    (a, b) => new Date(a.entry.timestamp).getTime() - new Date(b.entry.timestamp).getTime()
+  );
+  for (const node of sorted) {
+    const entry = node.entry;
+    const id = entry.id;
+    out.push({
+      id,
+      parentId: entry.parentId,
+      depth,
+      entryType: mapEntryType(entry.type),
+      messageRole: entry.type === "message" ? mapMessageRole(entry["message"]) : void 0,
+      timestamp: entry.timestamp,
+      preview: extractPreview(entry),
+      active: activeIds.has(id),
+      isLeaf: id === leafId,
+      childCount: node.children.length,
+      label: node.label
+    });
+    if (node.children.length > 0) {
+      flattenTree(node.children, leafId, activeIds, out, depth + 1);
+    }
+  }
+}
+function mapEntryType(type) {
+  switch (type) {
+    case "message":
+      return "message";
+    case "compaction":
+      return "compaction";
+    case "branch_summary":
+      return "branch_summary";
+    case "model_change":
+      return "model_change";
+    case "thinking_level_change":
+      return "thinking_level_change";
+    case "custom":
+      return "custom";
+    case "custom_message":
+      return "custom_message";
+    case "label":
+      return "label";
+    case "session_info":
+      return "session_info";
+    default:
+      console.warn(`[tree] unknown entry type "${type}" \u2014 mapping to "custom". pi SDK may have added a type tree.ts doesn't handle yet.`);
+      return "custom";
+  }
+}
+function mapMessageRole(msg) {
+  if (!msg || typeof msg !== "object") return void 0;
+  const role = msg.role;
+  switch (role) {
+    case "user":
+      return "user";
+    case "assistant":
+      return "assistant";
+    case "toolResult":
+      return "toolResult";
+    case "bashExecution":
+      return "bashExecution";
+    case "custom":
+      return "custom";
+    case "branchSummary":
+      return "branchSummary";
+    case "compactionSummary":
+      return "compactionSummary";
+    default:
+      return void 0;
+  }
+}
+var PREVIEW_MAX = 120;
+function extractPreview(entry) {
+  switch (entry.type) {
+    case "message":
+      return extractMessagePreview(entry["message"]);
+    case "compaction":
+      return truncate2(String(entry["summary"] ?? "Compaction"), PREVIEW_MAX);
+    case "branch_summary":
+      return truncate2(String(entry["summary"] ?? "Branch summary"), PREVIEW_MAX);
+    case "model_change":
+      return `${entry["provider"] ?? ""}/${entry["modelId"] ?? ""}`;
+    case "thinking_level_change":
+      return `Thinking: ${entry["thinkingLevel"] ?? ""}`;
+    case "session_info":
+      return entry["name"] ? `Name: ${entry["name"]}` : "Session info";
+    case "custom_message":
+      return truncate2(extractContentText2(entry["content"]), PREVIEW_MAX) || "Extension message";
+    case "custom":
+      return `Custom: ${entry["customType"] ?? ""}`;
+    case "label":
+      return "Label";
+    default:
+      return "";
+  }
+}
+function extractMessagePreview(msg) {
+  if (!msg || typeof msg !== "object") return "";
+  const m = msg;
+  if (m.role === "bashExecution") {
+    return truncate2(`$ ${m.command ?? ""}`, PREVIEW_MAX);
+  }
+  return truncate2(extractContentText2(m.content), PREVIEW_MAX);
+}
+function extractContentText2(content) {
+  if (typeof content === "string") return content.replace(/\s+/g, " ").trim();
+  if (!Array.isArray(content)) return "";
+  const parts = [];
+  for (const block of content) {
+    if (!block || typeof block !== "object") continue;
+    const b = block;
+    if (b.type === "text" && typeof b.text === "string") {
+      parts.push(b.text);
+    } else if (b.type === "thinking" && typeof b.thinking === "string") {
+      parts.push(b.thinking);
+    }
+  }
+  return parts.join(" ").replace(/\s+/g, " ").trim();
+}
+function truncate2(text, max) {
+  if (text.length <= max) return text;
+  return text.slice(0, max) + "\u2026";
+}
+
 // src/api/workspaces.ts
-var workspacesRoute = new Hono();
+var workspacesRoute = new Hono2();
 workspacesRoute.get("/", async (c) => {
   const raw = await listWorkspaces();
   const workspaces = await Promise.all(raw.map(enrichWorkspace));
   const body = { workspaces };
   return c.json(body);
 });
+workspacesRoute.put("/reorder", async (c) => {
+  const body = await c.req.json();
+  if (!body?.ids || !Array.isArray(body.ids) || body.ids.length === 0 || !body.ids.every((id) => typeof id === "string")) {
+    return c.json(
+      { ok: false, error: "ids must be a non-empty array of strings" },
+      400
+    );
+  }
+  await reorderWorkspaces(body.ids);
+  const raw = await listWorkspaces();
+  const workspaces = await Promise.all(raw.map(enrichWorkspace));
+  const resBody = { workspaces };
+  return c.json(resBody);
+});
 workspacesRoute.get("/:id/sessions", async (c) => {
   const id = c.req.param("id");
   const existed = await getWorkspace(id);
@@ -2202,9 +4339,9 @@ workspacesRoute.get("/:id/sessions", async (c) => {
     const sessions = await workspaceManager.listSessions(id);
     const body = { sessions };
     return c.json(body);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    console.error(`[api] list sessions for ${id} failed:`, err);
+  } catch (err2) {
+    const message = err2 instanceof Error ? err2.message : String(err2);
+    console.error(`[api] list sessions for ${id} failed:`, err2);
     return c.json({ ok: false, error: message }, 500);
   }
 });
@@ -2220,15 +4357,15 @@ workspacesRoute.delete("/:id/sessions", async (c) => {
     await workspaceManager.deleteSession(id, sessionPath);
     const body = { ok: true };
     return c.json(body);
-  } catch (err) {
-    if (err instanceof HttpError) {
+  } catch (err2) {
+    if (err2 instanceof HttpError) {
       return c.json(
-        { ok: false, error: err.message },
-        err.status
+        { ok: false, error: err2.message },
+        err2.status
       );
     }
-    const message = err instanceof Error ? err.message : String(err);
-    console.error(`[api] delete session for ${id} failed:`, err);
+    const message = err2 instanceof Error ? err2.message : String(err2);
+    console.error(`[api] delete session for ${id} failed:`, err2);
     return c.json({ ok: false, error: message }, 500);
   }
 });
@@ -2245,9 +4382,31 @@ workspacesRoute.get("/:id/fork-points", async (c) => {
     }));
     const body = { points };
     return c.json(body);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    console.error(`[api] fork-points for ${id} failed:`, err);
+  } catch (err2) {
+    const message = err2 instanceof Error ? err2.message : String(err2);
+    console.error(`[api] fork-points for ${id} failed:`, err2);
+    return c.json({ ok: false, error: message }, 500);
+  }
+});
+workspacesRoute.get("/:id/export", async (c) => {
+  const id = c.req.param("id");
+  const existed = await getWorkspace(id);
+  if (!existed) return c.json({ ok: false, error: "not found" }, 404);
+  try {
+    const sessionPath = c.req.query("sessionPath");
+    if (sessionPath) {
+      const err2 = await workspaceManager.validateSessionOwnership(id, sessionPath);
+      if (err2) return c.json({ ok: false, error: err2 }, 404);
+    }
+    const runtime = await workspaceManager.getOrCreate(id, sessionPath || void 0);
+    const outputPath = await runtime.session.exportToHtml();
+    const html = await readFile7(outputPath, "utf-8");
+    const filename = basename2(outputPath);
+    const body = { html, filename };
+    return c.json(body);
+  } catch (err2) {
+    const message = err2 instanceof Error ? err2.message : String(err2);
+    console.error(`[api] export for ${id} failed:`, err2);
     return c.json({ ok: false, error: message }, 500);
   }
 });
@@ -2260,9 +4419,9 @@ workspacesRoute.get("/:id/history", async (c) => {
     const sessionPath = c.req.query("sessionPath");
     const body = workspaceManager.getSessionHistory(id, sessionPath);
     return c.json(body);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    console.error(`[api] history for ${id} failed:`, err);
+  } catch (err2) {
+    const message = err2 instanceof Error ? err2.message : String(err2);
+    console.error(`[api] history for ${id} failed:`, err2);
     return c.json({ ok: false, error: message }, 500);
   }
 });
@@ -2274,7 +4433,7 @@ workspacesRoute.post("/", async (c) => {
   if (!isAbsolute3(body.path)) {
     return c.json({ ok: false, error: "path must be absolute" }, 400);
   }
-  const resolved = resolve3(body.path);
+  const resolved = resolve5(body.path);
   try {
     const st = await stat2(resolved);
     if (!st.isDirectory()) {
@@ -2300,35 +4459,47 @@ workspacesRoute.delete("/:id", async (c) => {
   const body = { ok: true };
   return c.json(body);
 });
+workspacesRoute.patch("/:id", async (c) => {
+  const id = c.req.param("id");
+  const body = await c.req.json();
+  if (typeof body?.trustProjectAgents !== "boolean") {
+    return c.json({ ok: false, error: "trustProjectAgents must be a boolean" }, 400);
+  }
+  const updated = await setWorkspaceTrustProjectAgents(id, body.trustProjectAgents);
+  if (!updated) return c.json({ ok: false, error: "not found" }, 404);
+  const res = { workspace: await enrichWorkspace(updated) };
+  return c.json(res);
+});
 mountConfigRoutes(workspacesRoute);
 mountResourcesRoute(workspacesRoute);
 mountFilesRoute(workspacesRoute);
+workspacesRoute.route("/:id/tree", treeRoute);
 
 // src/api/fs.ts
-import { readdir as readdir3 } from "fs/promises";
-import { homedir as homedir2 } from "os";
-import { dirname as dirname4, isAbsolute as isAbsolute4, join as join7, resolve as resolve4 } from "path";
-import { Hono as Hono2 } from "hono";
-var fsRoute = new Hono2();
+import { readdir as readdir4 } from "fs/promises";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname5, isAbsolute as isAbsolute4, join as join14, resolve as resolve6 } from "path";
+import { Hono as Hono3 } from "hono";
+var fsRoute = new Hono3();
 fsRoute.get("/browse", async (c) => {
   const rawPath = c.req.query("path");
   const showHidden = c.req.query("showHidden") === "1";
-  const target = rawPath && isAbsolute4(rawPath) ? resolve4(rawPath) : homedir2();
+  const target = rawPath && isAbsolute4(rawPath) ? resolve6(rawPath) : homedir3();
   let dirents;
   try {
-    dirents = await readdir3(target, { withFileTypes: true });
-  } catch (err) {
-    const code = err.code;
+    dirents = await readdir4(target, { withFileTypes: true });
+  } catch (err2) {
+    const code = err2.code;
     const msg = code === "EACCES" ? "permission denied" : code === "ENOENT" ? "not found" : "read failed";
     return c.json({ ok: false, error: msg, path: target }, 400);
   }
   const entries = dirents.filter((d) => d.isDirectory()).filter((d) => showHidden || !d.name.startsWith(".")).map((d) => ({
     name: d.name,
-    path: join7(target, d.name),
+    path: join14(target, d.name),
     type: "dir"
   })).sort((a, b) => a.name.localeCompare(b.name));
   const parent = (() => {
-    const p = dirname4(target);
+    const p = dirname5(target);
     return p === target ? null : p;
   })();
   const body = { path: target, parent, entries };
@@ -2336,13 +4507,49 @@ fsRoute.get("/browse", async (c) => {
 });
 
 // src/api/model-configs.ts
-import { readFile as readFile4, writeFile as writeFile4, mkdir as mkdir4 } from "fs/promises";
-import { dirname as dirname5, join as join8 } from "path";
-import { Hono as Hono3 } from "hono";
+import { readFile as readFile8 } from "fs/promises";
+import { join as join15 } from "path";
+import { Hono as Hono4 } from "hono";
 import {
-  getAgentDir as getAgentDir3
+  getAgentDir as getAgentDir4
 } from "@earendil-works/pi-coding-agent";
-var modelConfigsRoute = new Hono3();
+
+// src/api/model-config-keys.ts
+var MASKED_KEY_RE = /^….{1,8}$/;
+function maskApiKey(key) {
+  return `\u2026${key.slice(-4)}`;
+}
+function isPreservedApiKey(key) {
+  return key === "" || MASKED_KEY_RE.test(key);
+}
+function maskConfigForResponse(config2) {
+  const providers = {};
+  for (const [name, provider] of Object.entries(config2.providers)) {
+    providers[name] = {
+      ...provider,
+      apiKey: provider.apiKey ? maskApiKey(provider.apiKey) : ""
+    };
+  }
+  return { providers };
+}
+function preserveApiKeys(incoming, existing) {
+  const providers = { ...incoming.providers };
+  for (const [name, provider] of Object.entries(providers)) {
+    if (!isPreservedApiKey(provider.apiKey)) continue;
+    const prev = existing.providers[name]?.apiKey;
+    if (prev) {
+      providers[name] = { ...provider, apiKey: prev };
+    }
+  }
+  return { providers };
+}
+function resolveUpsertApiKey(incomingKey, existingKey) {
+  if (!isPreservedApiKey(incomingKey)) return incomingKey;
+  return existingKey || void 0;
+}
+
+// src/api/model-configs.ts
+var modelConfigsRoute = new Hono4();
 var writeLock = Promise.resolve();
 function withWriteLock(fn) {
   const next = writeLock.then(fn, fn);
@@ -2352,28 +4559,26 @@ function withWriteLock(fn) {
   return next;
 }
 function modelsPath() {
-  return join8(getAgentDir3(), "models.json");
+  return join15(getAgentDir4(), "models.json");
 }
 async function readModelsJson() {
   try {
-    const raw = await readFile4(modelsPath(), "utf-8");
+    const raw = await readFile8(modelsPath(), "utf-8");
     return JSON.parse(raw);
-  } catch (err) {
-    if (err?.code === "ENOENT") {
+  } catch (err2) {
+    if (err2?.code === "ENOENT") {
       return { providers: {} };
     }
-    throw err;
+    throw err2;
   }
 }
 async function writeModelsJson(config2) {
-  const p = modelsPath();
-  await mkdir4(dirname5(p), { recursive: true });
-  await writeFile4(p, JSON.stringify(config2, null, 2), "utf-8");
+  await writeJsonAtomic(modelsPath(), config2, { mode: 384 });
 }
 var ValidationError = class extends Error {
-  constructor(message, status) {
+  constructor(message, status2) {
     super(message);
-    this.status = status;
+    this.status = status2;
   }
   status;
 };
@@ -2391,10 +4596,10 @@ function refreshRegistry(workspaceId) {
 modelConfigsRoute.get("/", async (c) => {
   try {
     const config2 = await readModelsJson();
-    const body = { config: config2 };
+    const body = { config: maskConfigForResponse(config2) };
     return c.json(body);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
+  } catch (err2) {
+    const message = err2 instanceof Error ? err2.message : String(err2);
     return c.json({ ok: false, error: message }, 500);
   }
 });
@@ -2404,15 +4609,18 @@ modelConfigsRoute.put("/", async (c) => {
     return c.json({ ok: false, error: "config.providers is required" }, 400);
   }
   try {
-    await withWriteLock(async () => {
-      await writeModelsJson(body.config);
+    const config2 = await withWriteLock(async () => {
+      const existing = await readModelsJson();
+      const merged = preserveApiKeys(body.config, existing);
+      await writeModelsJson(merged);
+      return merged;
     });
     const workspaceId = c.req.query("workspaceId");
     refreshRegistry(workspaceId ?? void 0);
-    const resp = { config: body.config };
+    const resp = { config: maskConfigForResponse(config2) };
     return c.json(resp);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
+  } catch (err2) {
+    const message = err2 instanceof Error ? err2.message : String(err2);
     return c.json({ ok: false, error: message }, 500);
   }
 });
@@ -2421,8 +4629,8 @@ modelConfigsRoute.post("/providers", async (c) => {
   if (!body?.name || !body?.provider) {
     return c.json({ ok: false, error: "name and provider are required" }, 400);
   }
-  if (!body.provider.baseUrl || !body.provider.api || !body.provider.apiKey) {
-    return c.json({ ok: false, error: "provider must have baseUrl, api, and apiKey" }, 400);
+  if (!body.provider.baseUrl || !body.provider.api) {
+    return c.json({ ok: false, error: "provider must have baseUrl and api" }, 400);
   }
   if (!Array.isArray(body.provider.models)) {
     return c.json({ ok: false, error: "provider.models must be an array" }, 400);
@@ -2430,16 +4638,23 @@ modelConfigsRoute.post("/providers", async (c) => {
   try {
     const config2 = await withWriteLock(async () => {
       const cfg = await readModelsJson();
-      cfg.providers[body.name] = body.provider;
+      const apiKey2 = resolveUpsertApiKey(body.provider.apiKey, cfg.providers[body.name]?.apiKey);
+      if (!apiKey2) {
+        throw new ValidationError("apiKey is required for a new provider", 400);
+      }
+      cfg.providers[body.name] = { ...body.provider, apiKey: apiKey2 };
       await writeModelsJson(cfg);
       return cfg;
     });
     const workspaceId = c.req.query("workspaceId");
     refreshRegistry(workspaceId ?? void 0);
-    const resp = { config: config2 };
+    const resp = { config: maskConfigForResponse(config2) };
     return c.json(resp);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
+  } catch (err2) {
+    if (err2 instanceof ValidationError) {
+      return c.json({ ok: false, error: err2.message }, err2.status);
+    }
+    const message = err2 instanceof Error ? err2.message : String(err2);
     return c.json({ ok: false, error: message }, 500);
   }
 });
@@ -2460,13 +4675,13 @@ modelConfigsRoute.delete("/providers", async (c) => {
     });
     const workspaceId = c.req.query("workspaceId");
     refreshRegistry(workspaceId ?? void 0);
-    const resp = { config: config2 };
+    const resp = { config: maskConfigForResponse(config2) };
     return c.json(resp);
-  } catch (err) {
-    if (err instanceof ValidationError) {
-      return c.json({ ok: false, error: err.message }, err.status);
+  } catch (err2) {
+    if (err2 instanceof ValidationError) {
+      return c.json({ ok: false, error: err2.message }, err2.status);
     }
-    const message = err instanceof Error ? err.message : String(err);
+    const message = err2 instanceof Error ? err2.message : String(err2);
     return c.json({ ok: false, error: message }, 500);
   }
 });
@@ -2492,13 +4707,13 @@ modelConfigsRoute.post("/providers/:provider/models", async (c) => {
     });
     const workspaceId = c.req.query("workspaceId");
     refreshRegistry(workspaceId ?? void 0);
-    const resp = { config: config2 };
+    const resp = { config: maskConfigForResponse(config2) };
     return c.json(resp);
-  } catch (err) {
-    if (err instanceof ValidationError) {
-      return c.json({ ok: false, error: err.message }, err.status);
+  } catch (err2) {
+    if (err2 instanceof ValidationError) {
+      return c.json({ ok: false, error: err2.message }, err2.status);
     }
-    const message = err instanceof Error ? err.message : String(err);
+    const message = err2 instanceof Error ? err2.message : String(err2);
     return c.json({ ok: false, error: message }, 500);
   }
 });
@@ -2528,13 +4743,13 @@ modelConfigsRoute.put("/providers/:provider/models/:modelId", async (c) => {
     });
     const workspaceId = c.req.query("workspaceId");
     refreshRegistry(workspaceId ?? void 0);
-    const resp = { config: config2 };
+    const resp = { config: maskConfigForResponse(config2) };
     return c.json(resp);
-  } catch (err) {
-    if (err instanceof ValidationError) {
-      return c.json({ ok: false, error: err.message }, err.status);
+  } catch (err2) {
+    if (err2 instanceof ValidationError) {
+      return c.json({ ok: false, error: err2.message }, err2.status);
     }
-    const message = err instanceof Error ? err.message : String(err);
+    const message = err2 instanceof Error ? err2.message : String(err2);
     return c.json({ ok: false, error: message }, 500);
   }
 });
@@ -2557,19 +4772,83 @@ modelConfigsRoute.delete("/providers/:provider/models/:modelId", async (c) => {
     });
     const workspaceId = c.req.query("workspaceId");
     refreshRegistry(workspaceId ?? void 0);
-    const resp = { config: config2 };
+    const resp = { config: maskConfigForResponse(config2) };
     return c.json(resp);
-  } catch (err) {
-    if (err instanceof ValidationError) {
-      return c.json({ ok: false, error: err.message }, err.status);
+  } catch (err2) {
+    if (err2 instanceof ValidationError) {
+      return c.json({ ok: false, error: err2.message }, err2.status);
     }
-    const message = err instanceof Error ? err.message : String(err);
+    const message = err2 instanceof Error ? err2.message : String(err2);
+    return c.json({ ok: false, error: message }, 500);
+  }
+});
+
+// src/api/web-search.ts
+import { Hono as Hono5 } from "hono";
+var webSearchRoute = new Hono5();
+function status() {
+  return getKeyStatus();
+}
+webSearchRoute.get("/", (c) => c.json(status()));
+webSearchRoute.put("/", async (c) => {
+  const body = await c.req.json().catch(() => null);
+  if (!body || typeof body.apiKey !== "string") {
+    return c.json({ ok: false, error: "apiKey (string) is required" }, 400);
+  }
+  try {
+    await setTavilyApiKey(body.apiKey);
+    return c.json(status());
+  } catch (err2) {
+    const message = err2 instanceof Error ? err2.message : String(err2);
+    return c.json({ ok: false, error: message }, 500);
+  }
+});
+webSearchRoute.delete("/", async (c) => {
+  try {
+    await clearTavilyApiKey();
+    return c.json(status());
+  } catch (err2) {
+    const message = err2 instanceof Error ? err2.message : String(err2);
     return c.json({ ok: false, error: message }, 500);
   }
 });
 
 // src/ws/hub.ts
 import { WebSocketServer } from "ws";
+
+// src/security.ts
+var LOOPBACK_HOSTNAMES = ["127.0.0.1", "localhost"];
+function buildAllowedHosts() {
+  const ports = /* @__PURE__ */ new Set([config.port, 5173]);
+  const hosts = /* @__PURE__ */ new Set();
+  for (const name of LOOPBACK_HOSTNAMES) {
+    for (const port of ports) {
+      hosts.add(`${name}:${port}`);
+    }
+  }
+  return hosts;
+}
+function buildAllowedWsOrigins() {
+  const origins = /* @__PURE__ */ new Set([config.corsOrigin]);
+  for (const name of LOOPBACK_HOSTNAMES) {
+    origins.add(`http://${name}:${config.port}`);
+    origins.add(`http://${name}:5173`);
+  }
+  return origins;
+}
+var allowedHosts = buildAllowedHosts();
+var allowedWsOrigins = buildAllowedWsOrigins();
+function isAllowedHost(host) {
+  if (!host) return false;
+  return allowedHosts.has(host.toLowerCase());
+}
+function isAllowedWsOrigin(origin) {
+  if (!origin) return false;
+  return allowedWsOrigins.has(origin);
+}
+
+// src/ws/hub.ts
+var BACKGROUND_CAP = 4;
 var replacementLocks = /* @__PURE__ */ new Map();
 function withReplacementLock(workspaceId, fn) {
   const prev = replacementLocks.get(workspaceId) ?? Promise.resolve();
@@ -2584,23 +4863,40 @@ function withReplacementLock(workspaceId, fn) {
   return next;
 }
 function attachWsHub(httpServer) {
-  const wss = new WebSocketServer({ server: httpServer, path: "/ws" });
-  wss.on("connection", (ws) => {
-    const state = {};
-    ws.on("message", async (raw) => {
-      let msg;
-      try {
-        msg = JSON.parse(raw.toString());
-      } catch {
-        send(ws, { type: "error", message: "invalid JSON" });
+  const wss = new WebSocketServer({
+    server: httpServer,
+    path: "/ws",
+    verifyClient: (info, cb) => {
+      const host = info.req.headers.host;
+      const origin = info.origin;
+      if (!isAllowedHost(host) || !isAllowedWsOrigin(origin)) {
+        cb(false, 403, "Forbidden");
         return;
       }
-      try {
-        await handle(ws, state, msg);
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        send(ws, { type: "error", message, command: msg.type });
-      }
+      cb(true);
+    }
+  });
+  wss.on("connection", (ws) => {
+    const state = { background: /* @__PURE__ */ new Map() };
+    let inbound = Promise.resolve();
+    ws.on("message", (raw) => {
+      inbound = inbound.then(async () => {
+        let msg;
+        try {
+          msg = JSON.parse(raw.toString());
+        } catch {
+          send(ws, { type: "error", message: "invalid JSON" });
+          return;
+        }
+        try {
+          await handle(ws, state, msg);
+        } catch (err2) {
+          const message = err2 instanceof Error ? err2.message : String(err2);
+          send(ws, { type: "error", message, command: msg.type });
+        }
+      }).catch((err2) => {
+        console.error("[ws] inbound chain error:", err2);
+      });
     });
     ws.on("close", () => {
       detach(state, ws);
@@ -2611,124 +4907,162 @@ function attachWsHub(httpServer) {
 async function handle(ws, state, msg) {
   switch (msg.type) {
     case "subscribe": {
-      const hadCurrentSubscription = state.workspaceId === msg.workspaceId && !!state.unsubscribeSession;
-      ensureRebindListener(ws, state, msg.workspaceId);
-      await workspaceManager.getOrCreate(msg.workspaceId);
-      let switched = false;
-      let switchError;
-      if (msg.sessionPath) {
-        await withReplacementLock(msg.workspaceId, async () => {
-          try {
-            switched = await workspaceManager.switchSession(msg.workspaceId, msg.sessionPath);
-          } catch (err) {
-            switchError = err instanceof Error ? err.message : String(err);
-          }
-        });
-      }
-      if (!switched && !hadCurrentSubscription) {
-        bindCurrentSession(ws, state, msg.workspaceId);
-      }
-      if (switchError) {
-        send(ws, { type: "error", message: switchError, command: "subscribe" });
+      let runtime;
+      try {
+        runtime = await workspaceManager.getOrCreate(msg.workspaceId, msg.sessionPath);
+      } catch (err2) {
+        const message = err2 instanceof Error ? err2.message : String(err2);
+        send(ws, { type: "error", message, command: "subscribe" });
+        send(ws, { type: "ack", command: "subscribe" });
+        return;
       }
+      promoteToPrimary(ws, state, msg.workspaceId, runtime);
       send(ws, { type: "ack", command: "subscribe" });
       return;
     }
+    case "unsubscribe": {
+      for (const [key, bg] of [...state.background]) {
+        if (bg.workspaceId === msg.workspaceId) teardownBackground(state, key, ws);
+      }
+      return;
+    }
     case "prompt": {
-      const wsId = state.workspaceId;
-      if (!wsId) {
+      const primary = state.primary;
+      if (!primary) {
         send(ws, { type: "error", message: "not subscribed", command: "prompt" });
         return;
       }
-      if (replacementLocks.has(wsId)) {
+      if (replacementLocks.has(primary.workspaceId)) {
         send(ws, { type: "error", message: "session switching in progress", command: "prompt" });
         return;
       }
-      const runtime = workspaceManager.get(wsId);
-      if (!runtime) {
-        send(ws, { type: "error", message: "runtime gone", command: "prompt" });
-        return;
-      }
-      void runtime.session.prompt(msg.message, {
-        streamingBehavior: msg.streamingBehavior
-      }).catch((err) => {
-        const message = err instanceof Error ? err.message : String(err);
+      void primary.runtime.session.prompt(msg.message, { streamingBehavior: msg.streamingBehavior }).catch((err2) => {
+        const message = err2 instanceof Error ? err2.message : String(err2);
         send(ws, { type: "error", message, command: "prompt" });
       });
       return;
     }
     case "abort": {
-      const wsId = state.workspaceId;
-      if (!wsId) {
+      const primary = state.primary;
+      if (!primary) {
         send(ws, { type: "error", message: "not subscribed", command: "abort" });
         return;
       }
-      if (replacementLocks.has(wsId)) {
-        send(ws, { type: "error", message: "session switching in progress", command: "abort" });
-        return;
-      }
-      const runtime = workspaceManager.get(wsId);
-      if (!runtime) return;
-      await runtime.session.abort();
+      await primary.runtime.session.abort();
       return;
     }
     case "new_session": {
-      const wsId = state.workspaceId;
-      if (!wsId) {
-        send(ws, { type: "error", message: "not subscribed", command: "new_session" });
-        return;
-      }
-      await withReplacementLock(msg.workspaceId, async () => {
-        const runtime = workspaceManager.get(wsId);
-        if (!runtime) {
-          send(ws, { type: "error", message: "runtime gone", command: "new_session" });
-          return;
-        }
-        if (runtime.session.isStreaming) {
-          send(ws, { type: "error", message: "cannot create session while streaming", command: "new_session" });
+      const workspaceId = msg.workspaceId;
+      await withReplacementLock(workspaceId, async () => {
+        let runtime;
+        try {
+          runtime = await workspaceManager.createSession(workspaceId);
+        } catch (err2) {
+          const message = err2 instanceof Error ? err2.message : String(err2);
+          send(ws, { type: "error", message, command: "new_session" });
           return;
         }
-        const result = await runtime.newSession();
-        if (result.cancelled) {
-          send(ws, { type: "error", message: "new session cancelled", command: "new_session" });
-        }
+        promoteToPrimary(ws, state, workspaceId, runtime);
       });
       return;
     }
     case "fork": {
-      const wsId = state.workspaceId;
-      if (!wsId) {
+      const primary = state.primary;
+      if (!primary) {
         send(ws, { type: "error", message: "not subscribed", command: "fork" });
         return;
       }
-      await withReplacementLock(msg.workspaceId, async () => {
-        const runtime = workspaceManager.get(wsId);
-        if (!runtime) {
-          send(ws, { type: "error", message: "runtime gone", command: "fork" });
+      const workspaceId = primary.workspaceId;
+      await withReplacementLock(workspaceId, async () => {
+        const source = state.primary;
+        if (!source) {
+          send(ws, { type: "error", message: "not subscribed", command: "fork" });
           return;
         }
-        if (runtime.session.isStreaming) {
+        if (!source.sessionPath) {
+          send(ws, { type: "error", message: "cannot fork an unsaved session", command: "fork" });
+          return;
+        }
+        if (source.runtime.session.isStreaming) {
           send(ws, { type: "error", message: "cannot fork while streaming", command: "fork" });
           return;
         }
-        const result = await runtime.fork(msg.entryId);
-        if (result.cancelled) {
+        let result;
+        try {
+          result = await workspaceManager.fork(workspaceId, source.sessionPath, msg.entryId);
+        } catch (err2) {
+          const message = err2 instanceof Error ? err2.message : String(err2);
+          send(ws, { type: "error", message, command: "fork" });
+          return;
+        }
+        if (result.cancelled || !result.runtime) {
           send(ws, { type: "error", message: "fork cancelled", command: "fork" });
+          return;
         }
+        promoteToPrimary(ws, state, workspaceId, result.runtime);
       });
       return;
     }
     case "answer_question": {
-      const wsId = state.workspaceId;
-      if (!wsId) {
+      const primary = state.primary;
+      if (!primary) {
         send(ws, { type: "error", message: "not subscribed", command: "answer_question" });
         return;
       }
-      if (replacementLocks.has(wsId)) return;
-      const runtime = workspaceManager.get(wsId);
-      if (!runtime) return;
-      const activeFile = runtime.session.sessionFile ?? null;
-      resolveAnswer(msg.toolCallId, msg.answer, activeFile);
+      resolveAnswer(msg.toolCallId, msg.answer, primary.runtime.session.sessionFile ?? null);
+      return;
+    }
+    case "navigate_tree": {
+      const primary = state.primary;
+      if (!primary) {
+        send(ws, { type: "error", message: "not subscribed", command: "navigate_tree" });
+        return;
+      }
+      if (msg.workspaceId !== primary.workspaceId) {
+        send(ws, { type: "error", message: "workspace mismatch", command: "navigate_tree" });
+        return;
+      }
+      await withReplacementLock(primary.workspaceId, async () => {
+        const current = state.primary;
+        if (!current) {
+          send(ws, { type: "error", message: "not subscribed", command: "navigate_tree" });
+          return;
+        }
+        if (current.runtime.session.isStreaming) {
+          send(ws, { type: "error", message: "cannot navigate tree while streaming", command: "navigate_tree" });
+          return;
+        }
+        const result = await current.runtime.session.navigateTree(msg.targetId, {
+          summarize: msg.summarize,
+          customInstructions: msg.customInstructions
+        });
+        send(ws, {
+          type: "navigate_tree_result",
+          workspaceId: current.workspaceId,
+          editorText: result.editorText,
+          cancelled: result.cancelled
+        });
+      });
+      return;
+    }
+    case "compact": {
+      const primary = state.primary;
+      if (!primary) {
+        send(ws, { type: "error", message: "not subscribed", command: "compact" });
+        return;
+      }
+      if (primary.runtime.session.isStreaming) {
+        send(ws, { type: "error", message: "cannot compact while streaming", command: "compact" });
+        return;
+      }
+      if (primary.runtime.session.isCompacting) {
+        send(ws, { type: "error", message: "compaction already in progress", command: "compact" });
+        return;
+      }
+      primary.runtime.session.compact().catch((err2) => {
+        const message = err2 instanceof Error ? err2.message : String(err2);
+        send(ws, { type: "error", message, command: "compact" });
+      });
       return;
     }
     default: {
@@ -2738,28 +5072,26 @@ async function handle(ws, state, msg) {
     }
   }
 }
-function ensureRebindListener(ws, state, workspaceId) {
-  if (state.workspaceId === workspaceId && state.unsubscribeRebind) return;
-  detach(state, ws);
-  state.workspaceId = workspaceId;
-  workspaceManager.addSubscriber(workspaceId, ws);
-  state.unsubscribeRebind = workspaceManager.onSessionReplaced(workspaceId, () => {
-    if (state.workspaceId !== workspaceId) return;
-    bindCurrentSession(ws, state, workspaceId);
-  });
-}
-function bindCurrentSession(ws, state, workspaceId) {
-  const runtime = workspaceManager.get(workspaceId);
-  if (!runtime) {
-    send(ws, { type: "error", message: "runtime gone", command: "subscribe" });
+function promoteToPrimary(ws, state, workspaceId, runtime) {
+  const runtimeKey = workspaceManager.runtimeKeyFor(workspaceId, runtime);
+  if (state.primary?.runtimeKey === runtimeKey) {
+    workspaceManager.setActive(workspaceId, runtime);
+    sendSubscribed(ws, workspaceId, runtime);
     return;
   }
-  state.unsubscribeSession?.();
+  if (state.primary) demotePrimaryToBackground(ws, state);
+  if (state.background.has(runtimeKey)) teardownBackground(state, runtimeKey, ws);
+  bindPrimary(ws, state, workspaceId, runtime);
+}
+function bindPrimary(ws, state, workspaceId, runtime) {
+  workspaceManager.addSubscriber(workspaceId, ws);
+  workspaceManager.setActive(workspaceId, runtime);
   const session = runtime.session;
   const sessionPath = session.sessionFile ?? null;
+  const runtimeKey = workspaceManager.runtimeKeyFor(workspaceId, runtime);
   let assistantStartAt;
   let assistantFirstTokenAt;
-  state.unsubscribeSession = session.subscribe((ev) => {
+  const unsubscribe = session.subscribe((ev) => {
     const payload = translatePiEvent(ev);
     if (!payload) return;
     if (payload.kind === "message_start" && payload.role === "assistant") {
@@ -2768,12 +5100,7 @@ function bindCurrentSession(ws, state, workspaceId) {
     } else if (payload.kind === "message_update" && payload.delta.kind === "text" && assistantStartAt !== void 0 && assistantFirstTokenAt === void 0) {
       assistantFirstTokenAt = performance.now();
     }
-    send(ws, {
-      type: "event",
-      workspaceId,
-      sessionPath,
-      payload
-    });
+    send(ws, { type: "event", workspaceId, sessionPath, payload });
     if (payload.kind === "message_end" && payload.role === "assistant" && assistantStartAt !== void 0) {
       const now = performance.now();
       const timing = {
@@ -2781,12 +5108,7 @@ function bindCurrentSession(ws, state, workspaceId) {
         firstTokenMs: assistantFirstTokenAt !== void 0 ? Math.round(assistantFirstTokenAt - assistantStartAt) : null,
         totalMs: Math.round(now - assistantStartAt)
       };
-      send(ws, {
-        type: "event",
-        workspaceId,
-        sessionPath,
-        payload: timing
-      });
+      send(ws, { type: "event", workspaceId, sessionPath, payload: timing });
       assistantStartAt = void 0;
       assistantFirstTokenAt = void 0;
     }
@@ -2794,33 +5116,80 @@ function bindCurrentSession(ws, state, workspaceId) {
       sendContextUsage(ws, runtime, workspaceId, sessionPath);
     }
   });
-  send(ws, {
-    type: "subscribed",
-    workspaceId,
-    sessionPath,
-    sessionId: session.sessionId
-  });
-  const inFlight = inFlightAssistantSnapshot(runtime.session.state.streamingMessage);
+  state.primary = { runtimeKey, workspaceId, sessionPath, runtime, unsubscribe };
+  sendSubscribed(ws, workspaceId, runtime);
+  const streamingMessage = runtime.session.state.streamingMessage;
+  const scanMessages = streamingMessage ? [...runtime.session.messages, streamingMessage] : runtime.session.messages;
+  for (const payload of inFlightRunningToolsSnapshot(
+    runtime.session.state.pendingToolCalls,
+    scanMessages
+  )) {
+    send(ws, { type: "event", workspaceId, sessionPath, payload });
+  }
+  const inFlight = inFlightAssistantSnapshot(streamingMessage);
   if (inFlight) {
     for (const payload of inFlight) {
-      send(ws, {
-        type: "event",
-        workspaceId,
-        sessionPath,
-        payload
-      });
+      send(ws, { type: "event", workspaceId, sessionPath, payload });
     }
   }
   for (const payload of inFlightToolCallsSnapshot(sessionPath)) {
-    send(ws, {
-      type: "event",
-      workspaceId,
-      sessionPath,
-      payload
-    });
+    send(ws, { type: "event", workspaceId, sessionPath, payload });
   }
   sendContextUsage(ws, runtime, workspaceId, sessionPath);
 }
+function demotePrimaryToBackground(ws, state) {
+  const primary = state.primary;
+  if (!primary) return;
+  primary.unsubscribe();
+  state.primary = void 0;
+  const session = primary.runtime.session;
+  const sessionPath = primary.sessionPath;
+  const unsubscribeSession = session.subscribe((ev) => {
+    const payload = translatePiEvent(ev);
+    if (!payload) return;
+    send(ws, { type: "event", workspaceId: primary.workspaceId, sessionPath, payload });
+    if (payload.kind === "agent_end" || payload.kind === "compaction_end" || payload.kind === "session_info_changed" || payload.kind === "thinking_level_changed") {
+      sendContextUsage(ws, primary.runtime, primary.workspaceId, sessionPath);
+    }
+  });
+  state.background.set(primary.runtimeKey, {
+    workspaceId: primary.workspaceId,
+    sessionPath,
+    unsubscribeSession
+  });
+  while (state.background.size > BACKGROUND_CAP) {
+    const oldestKey = state.background.keys().next().value;
+    if (oldestKey === void 0) break;
+    const evicted = state.background.get(oldestKey);
+    teardownBackground(state, oldestKey, ws);
+    if (evicted) {
+      send(ws, {
+        type: "background_evicted",
+        workspaceId: evicted.workspaceId,
+        sessionPath: evicted.sessionPath
+      });
+    }
+  }
+}
+function teardownBackground(state, runtimeKey, ws) {
+  const bg = state.background.get(runtimeKey);
+  if (!bg) return;
+  bg.unsubscribeSession();
+  state.background.delete(runtimeKey);
+  if (ws) unrefWorkspaceSubscriber(state, bg.workspaceId, ws);
+}
+function sendSubscribed(ws, workspaceId, runtime) {
+  send(ws, {
+    type: "subscribed",
+    workspaceId,
+    sessionPath: runtime.session.sessionFile ?? null,
+    sessionId: runtime.session.sessionId
+  });
+}
+function unrefWorkspaceSubscriber(state, workspaceId, ws) {
+  const stillUsed = state.primary?.workspaceId === workspaceId || [...state.background.values()].some((b) => b.workspaceId === workspaceId);
+  if (!stillUsed) workspaceManager.removeSubscriber(workspaceId, ws);
+}
 function sendContextUsage(ws, runtime, workspaceId, sessionPath) {
   const usage = runtime.session.getContextUsage();
   if (!usage) return;
@@ -2830,22 +5199,20 @@ function sendContextUsage(ws, runtime, workspaceId, sessionPath) {
     contextWindow: usage.contextWindow,
     percent: usage.percent
   };
-  send(ws, {
-    type: "event",
-    workspaceId,
-    sessionPath,
-    payload
-  });
+  send(ws, { type: "event", workspaceId, sessionPath, payload });
+}
+function detachPrimary(state, ws) {
+  const primary = state.primary;
+  if (!primary) return;
+  primary.unsubscribe();
+  state.primary = void 0;
+  if (ws) unrefWorkspaceSubscriber(state, primary.workspaceId, ws);
 }
 function detach(state, ws) {
-  state.unsubscribeSession?.();
-  state.unsubscribeSession = void 0;
-  state.unsubscribeRebind?.();
-  state.unsubscribeRebind = void 0;
-  if (state.workspaceId && ws) {
-    workspaceManager.removeSubscriber(state.workspaceId, ws);
+  detachPrimary(state, ws);
+  for (const runtimeKey of [...state.background.keys()]) {
+    teardownBackground(state, runtimeKey, ws);
   }
-  state.workspaceId = void 0;
 }
 function send(ws, msg) {
   if (ws.readyState !== ws.OPEN) return;
@@ -2854,10 +5221,10 @@ function send(ws, msg) {
 
 // src/index.ts
 configureHttpProxy();
-var app = new Hono4();
-var distDir = dirname6(fileURLToPath(import.meta.url));
-var webRoot = resolve5(process.env.PI_PILOT_WEB_ROOT ?? join9(distDir, "..", "public"));
-var webIndexPath = join9(webRoot, "index.html");
+var app = new Hono6();
+var distDir = dirname6(fileURLToPath2(import.meta.url));
+var webRoot = resolve7(process.env.PI_PILOT_WEB_ROOT ?? join16(distDir, "..", "public"));
+var webIndexPath = join16(webRoot, "index.html");
 var mimeTypes = {
   ".css": "text/css; charset=utf-8",
   ".html": "text/html; charset=utf-8",
@@ -2883,7 +5250,7 @@ function safeResolveWebPath(pathname) {
     return void 0;
   }
   const relativePath = decoded === "/" ? "index.html" : decoded.replace(/^\/+/, "");
-  const candidate = resolve5(webRoot, relativePath);
+  const candidate = resolve7(webRoot, relativePath);
   if (candidate !== webRoot && !candidate.startsWith(`${webRoot}${sep3}`)) {
     return void 0;
   }
@@ -2891,11 +5258,11 @@ function safeResolveWebPath(pathname) {
 }
 async function readWebFile(path) {
   try {
-    return await readFile5(path);
-  } catch (err) {
-    const code = err.code;
+    return await readFile9(path);
+  } catch (err2) {
+    const code = err2.code;
     if (code === "ENOENT" || code === "EISDIR") return void 0;
-    throw err;
+    throw err2;
   }
 }
 async function serveWeb(c) {
@@ -2904,7 +5271,7 @@ async function serveWeb(c) {
   const assetPath = safeResolveWebPath(pathname);
   if (!assetPath) return c.text("invalid asset path", 400);
   const asset = await readWebFile(assetPath);
-  const body = asset ?? await readFile5(webIndexPath);
+  const body = asset ?? await readFile9(webIndexPath);
   const filePath = asset ? assetPath : webIndexPath;
   const headers = {
     "Content-Type": mimeTypes[extname(filePath)] ?? "application/octet-stream",
@@ -2912,6 +5279,12 @@ async function serveWeb(c) {
   };
   return new Response(body, { headers });
 }
+app.use("*", async (c, next) => {
+  if (!isAllowedHost(c.req.header("host"))) {
+    return c.text("Forbidden", 403);
+  }
+  await next();
+});
 app.use(
   "/api/*",
   cors({
@@ -2923,7 +5296,8 @@ app.get("/api/health", (c) => c.json({ ok: true }));
 app.route("/api/workspaces", workspacesRoute);
 app.route("/api/fs", fsRoute);
 app.route("/api/model-configs", modelConfigsRoute);
-if (existsSync(webIndexPath)) {
+app.route("/api/web-search", webSearchRoute);
+if (existsSync2(webIndexPath)) {
   app.get("*", serveWeb);
 } else {
   app.get(
@@ -2935,6 +5309,9 @@ if (existsSync(webIndexPath)) {
   );
 }
 await loadBuiltinPrefs();
+await loadSessionToolPrefs();
+await loadWebSearchPrefs();
+await sweepOrphanedChildrenOnBoot();
 var server = serve(
   {
     fetch: app.fetch,
@@ -2953,9 +5330,20 @@ async function shutdown(reason) {
   } catch (e) {
     console.error("[pi-pilot] disposeAll error:", e);
   }
+  const sweptChildren = killAllChildren();
+  if (sweptChildren > 0) {
+    console.warn(`[pi-pilot] killed ${sweptChildren} lingering subagent child(ren)`);
+  }
   server.close(() => process.exit(0));
   setTimeout(() => process.exit(1), 3e3).unref();
 }
+process.on("unhandledRejection", (reason) => {
+  console.error("[pi-pilot] unhandled rejection (process kept alive):", reason);
+});
+process.on("uncaughtException", (err2) => {
+  console.error("[pi-pilot] uncaught exception:", err2);
+  void shutdown("uncaughtException");
+});
 process.on("SIGINT", () => void shutdown("SIGINT"));
 process.on("SIGTERM", () => void shutdown("SIGTERM"));
 //# sourceMappingURL=index.js.map