@jyork0828/pi-pilot 0.0.3 → 0.0.6

package/dist/index.js

@@ -2,11 +2,11 @@
 
 // src/index.ts
 import { existsSync } from "fs";
-import { readFile as readFile4 } from "fs/promises";
-import { dirname as dirname5, extname, join as join8, resolve as resolve5, sep as sep3 } from "path";
+import { readFile as readFile6 } from "fs/promises";
+import { dirname as dirname6, extname, join as join9, resolve as resolve5, sep as sep3 } from "path";
 import { fileURLToPath } from "url";
 import { serve } from "@hono/node-server";
-import { Hono as Hono4 } from "hono";
+import { Hono as Hono5 } from "hono";
 import { cors } from "hono/cors";
 
 // src/config.ts
@@ -24,10 +24,26 @@ var config = {
   corsOrigin: process.env.PI_PILOT_CORS_ORIGIN ?? "http://localhost:5173"
 };
 
+// src/http-proxy.ts
+import { EnvHttpProxyAgent, install, setGlobalDispatcher } from "undici";
+var configured = false;
+function configureHttpProxy() {
+  if (configured) return;
+  configured = true;
+  setGlobalDispatcher(
+    new EnvHttpProxyAgent({
+      allowH2: false,
+      bodyTimeout: 3e5,
+      headersTimeout: 3e5
+    })
+  );
+  install?.();
+}
+
 // src/api/workspaces.ts
-import { stat as stat2 } from "fs/promises";
+import { readFile as readFile4, stat as stat2 } from "fs/promises";
 import { basename as basename2, isAbsolute as isAbsolute3, resolve as resolve3 } from "path";
-import { Hono } from "hono";
+import { Hono as Hono2 } from "hono";
 
 // src/storage/resource-writer.ts
 import {
@@ -261,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;
   }
@@ -335,17 +351,22 @@ import { dirname as dirname2, join as join3 } from "path";
 import { randomUUID } from "crypto";
 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;
@@ -364,26 +385,57 @@ 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: randomUUID(),
+      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 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
@@ -408,8 +460,8 @@ async function getStats(path) {
   const now = Date.now();
   const cached = cache2.get(path);
   if (cached && cached.expiresAt > now) return cached;
-  const pending = inflight.get(path);
-  if (pending) return pending;
+  const pending2 = inflight.get(path);
+  if (pending2) return pending2;
   const probe = probeStats(path).then((stats) => {
     const entry = {
       ...stats,
@@ -486,307 +538,1213 @@ import {
   SessionManager
 } from "@earendil-works/pi-coding-agent";
 
-// src/extensions/plan/schema.ts
+// 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.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_compact", async (_event, ctx) => {
+    try {
+      state = replayFromBranch(ctx);
+    } catch {
+    }
+  });
+  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/index.ts
-var builtinExtensionFactories = [planExtensionFactory];
+// src/extensions/ask_user/schema.ts
+import { Type as Type2 } from "typebox";
+var askUserOptionSchema = Type2.Object({
+  label: Type2.String({
+    description: "Short, distinct choice (1\u20135 words). User-facing."
+  }),
+  description: Type2.Optional(
+    Type2.String({
+      description: "Optional one-line clarification of what this choice means or implies."
+    })
+  )
+});
+var askUserParamsSchema = Type2.Object({
+  question: Type2.String({
+    description: "Full question, specific and ending with '?'. Avoid yes/no when options can be more concrete."
+  }),
+  header: Type2.Optional(
+    Type2.String({
+      maxLength: 12,
+      description: "Optional short chip label (\u2264 12 chars), e.g. 'Auth method'. Shown next to the question."
+    })
+  ),
+  options: Type2.Array(askUserOptionSchema, {
+    minItems: 2,
+    maxItems: 4,
+    description: "2\u20134 mutually exclusive choices (unless multiSelect is true). Recommended option first; append ' (Recommended)' to its label."
+  }),
+  multiSelect: Type2.Optional(
+    Type2.Boolean({
+      description: "If true, render checkboxes and allow multiple selections. Default false."
+    })
+  ),
+  allowOther: Type2.Optional(
+    Type2.Boolean({
+      description: "If true, show a freeform 'Other' input as an escape hatch. Default true."
+    })
+  ),
+  timeoutSec: Type2.Optional(
+    Type2.Integer({
+      minimum: 5,
+      description: "Auto-resolve as skip after this many seconds. Only set for time-sensitive questions where a stale answer would be worse than no answer."
+    })
+  )
+});
 
-// src/ws/extension-ui.ts
-var ExtensionUIBridge = class {
-  /** Symmetric with the old bridge so workspace-manager's dispose path
-   *  can call it uniformly. There is no state to release. */
-  dispose() {
-  }
-  // ============== dialog methods (resolve to default) ==============
-  select() {
-    return Promise.resolve(void 0);
-  }
-  confirm() {
-    return Promise.resolve(false);
-  }
-  input() {
-    return Promise.resolve(void 0);
-  }
-  editor() {
-    return Promise.resolve(void 0);
-  }
-  // ============== fire-and-forget methods (no-op) ==============
-  notify() {
-  }
-  setStatus() {
-  }
-  setWidget() {
-  }
-  setTitle() {
-  }
-  setEditorText() {
-  }
-  pasteToEditor() {
-  }
-  // ============== TUI-only methods (no-op / defaults) ==============
-  onTerminalInput() {
-    return () => {
-    };
-  }
-  setWorkingMessage() {
-  }
-  setWorkingVisible() {
-  }
-  setWorkingIndicator() {
-  }
-  setHiddenThinkingLabel() {
-  }
-  setFooter() {
-  }
-  setHeader() {
-  }
-  async custom() {
-    return void 0;
-  }
-  getEditorText() {
-    return "";
-  }
-  addAutocompleteProvider() {
-  }
-  setEditorComponent() {
-  }
-  getEditorComponent() {
-    return void 0;
-  }
-  get theme() {
-    return void 0;
-  }
-  getAllThemes() {
-    return [];
-  }
-  getTheme() {
-    return void 0;
-  }
-  setTheme() {
-    return { success: false, error: "Theme switching not supported in pi-pilot" };
-  }
-  getToolsExpanded() {
-    return false;
+// src/extensions/ask_user/registry.ts
+var pending = /* @__PURE__ */ new Map();
+function register(toolCallId, entry) {
+  pending.set(toolCallId, entry);
+}
+function unregister(toolCallId) {
+  pending.delete(toolCallId);
+}
+function resolveAnswer(toolCallId, answer, expectedSessionFile) {
+  const entry = pending.get(toolCallId);
+  if (!entry) return false;
+  if (entry.sessionFile !== expectedSessionFile) return false;
+  pending.delete(toolCallId);
+  entry.resolve(answer);
+  return true;
+}
+function cancelPendingForSession(sessionFile) {
+  for (const [id, entry] of pending) {
+    if (entry.sessionFile !== sessionFile) continue;
+    pending.delete(id);
+    entry.reject(new Error("Workspace disposed"));
   }
-  setToolsExpanded() {
+}
+function snapshotForSession(sessionFile) {
+  const out = [];
+  for (const [id, entry] of pending) {
+    if (entry.sessionFile !== sessionFile) continue;
+    out.push({ toolCallId: id, args: entry.args });
   }
-};
+  return out;
+}
 
-// src/workspace-manager.ts
-var EXTENSIONS_ENABLED = process.env.PI_PILOT_ENABLE_EXTENSIONS === "1";
-var createRuntime = async ({
-  cwd,
-  sessionManager,
-  sessionStartEvent
-}) => {
-  const services = await createAgentSessionServices({
-    cwd,
-    resourceLoaderOptions: {
-      noExtensions: !EXTENSIONS_ENABLED,
-      extensionFactories: builtinExtensionFactories
+// src/extensions/ask_user/factory.ts
+var askUserExtensionFactory = (pi) => {
+  pi.registerTool({
+    name: "ask_user",
+    label: "Ask user",
+    description: "Pause and ask the user a structured multiple-choice question. Use ONLY for genuine forks where the user's preference materially changes the work (UI layout, library choice, scope boundary). Returns the user's selection (or 'skip' if they dismissed).",
+    parameters: askUserParamsSchema,
+    promptSnippet: "ask_user: pause and ask the user a structured multiple-choice question when a decision is genuinely theirs.",
+    promptGuidelines: [
+      "Call ask_user only for genuine forks where the user's preference materially changes the work \u2014 UI layout, library choice, scope boundary. Don't ask for opinions you can defend yourself.",
+      "Each ask_user call asks ONE question. If you have several, call it multiple times in order so the user sees one at a time.",
+      "ask_user options must be distinct and mutually exclusive (unless multiSelect is true). 2\u20134 options; put the recommended option first and append ' (Recommended)' to its label.",
+      "Don't follow up ask_user with 'Should I proceed?' \u2014 the answer already authorizes the next step.",
+      "Only set ask_user's timeoutSec for time-sensitive questions where a stale answer would be worse than no answer; otherwise let the user take as long as they need."
+    ],
+    execute: async (toolCallId, params, signal, _onUpdate, ctx) => {
+      const sessionFile = ctx.sessionManager.getSessionFile() ?? null;
+      const startedAt = Date.now();
+      const answer = await waitForAnswer({
+        toolCallId,
+        params,
+        sessionFile,
+        signal
+      });
+      return formatResult(params, answer, startedAt);
     }
   });
-  const sessionResult = await createAgentSessionFromServices({
-    services,
-    sessionManager,
-    sessionStartEvent
-  });
-  return {
-    ...sessionResult,
-    services,
-    diagnostics: services.diagnostics
-  };
 };
-var WorkspaceManager = class {
-  states = /* @__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).
-   */
-  subscribers = /* @__PURE__ */ new Map();
-  /** Per-workspace lock to serialize concurrent creations. */
-  pending = /* @__PURE__ */ new Map();
-  rebindListeners = /* @__PURE__ */ new Map();
-  getOrCreateSubscriberSet(workspaceId) {
-    let set = this.subscribers.get(workspaceId);
-    if (!set) {
-      set = /* @__PURE__ */ new Set();
-      this.subscribers.set(workspaceId, set);
-    }
-    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);
+function waitForAnswer({
+  toolCallId,
+  params,
+  sessionFile,
+  signal
+}) {
+  return new Promise((resolve6, reject) => {
+    let settled = false;
+    let timeoutHandle;
+    const cleanup = () => {
+      if (timeoutHandle) clearTimeout(timeoutHandle);
+      signal?.removeEventListener("abort", onAbort);
+      unregister(toolCallId);
+    };
+    const finishOk = (a) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve6(a);
+    };
+    const finishErr = (err2) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(err2);
+    };
+    const onAbort = () => finishErr(new Error("Aborted by user"));
+    if (signal?.aborted) {
+      finishErr(new Error("Aborted by user"));
+      return;
     }
-  }
-  async build(workspaceId) {
-    const ws = await getWorkspace(workspaceId);
-    if (!ws) throw new Error(`Workspace not found: ${workspaceId}`);
-    const sessionManager = SessionManager.continueRecent(ws.path);
-    const runtime = await createAgentSessionRuntime(createRuntime, {
-      cwd: ws.path,
-      agentDir: getAgentDir(),
-      sessionManager
+    signal?.addEventListener("abort", onAbort);
+    if (typeof params.timeoutSec === "number" && params.timeoutSec > 0) {
+      const ms = params.timeoutSec * 1e3;
+      timeoutHandle = setTimeout(() => {
+        finishOk({ kind: "timeout", afterMs: ms });
+      }, ms);
+    }
+    register(toolCallId, {
+      args: params,
+      sessionFile,
+      resolve: (answer) => finishOk(answer),
+      reject: (err2) => finishErr(err2)
     });
-    const subscribers = this.getOrCreateSubscriberSet(workspaceId);
-    const bridge = new ExtensionUIBridge();
-    const onError = (err) => {
-      const msg = {
-        type: "extension_error",
-        workspaceId,
-        extensionPath: err.extensionPath,
-        event: err.event,
-        message: err.error
-      };
-      broadcastTo(subscribers, msg);
-      console.error(
-        `[ext-error] ${workspaceId} ${err.extensionPath}@${err.event}: ${err.error}` + (err.stack ? `
-${err.stack}` : "")
-      );
+  });
+}
+function formatResult(params, answer, startedAt) {
+  if (answer.kind === "option") {
+    const labels = answer.indices.map((i) => params.options[i]?.label).filter((l) => typeof l === "string");
+    const text2 = labels.length === 1 ? `User selected: "${labels[0]}"${descriptionSuffix(params, answer.indices[0])}.` : `User selected: ${labels.map((l) => `"${l}"`).join(", ")}.`;
+    const details2 = {
+      kind: "option",
+      indices: answer.indices,
+      labels
+    };
+    return {
+      content: [{ type: "text", text: text2 }],
+      details: details2
     };
-    await runtime.session.bindExtensions({ uiContext: bridge, onError });
-    runtime.setRebindSession(async () => {
-      await runtime.session.bindExtensions({ uiContext: bridge, onError });
-      this.notifySessionReplaced(workspaceId);
-    });
-    return { runtime, bridge };
-  }
-  get(workspaceId) {
-    return this.states.get(workspaceId)?.runtime;
-  }
-  /**
-   * 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.
-   */
-  addSubscriber(workspaceId, ws) {
-    this.getOrCreateSubscriberSet(workspaceId).add(ws);
-  }
-  removeSubscriber(workspaceId, ws) {
-    const set = this.subscribers.get(workspaceId);
-    if (!set) return;
-    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).
-   */
-  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);
-      }
+  if (answer.kind === "other") {
+    const text2 = `User answered (freeform): "${answer.text}"`;
+    const details2 = { kind: "other", text: answer.text };
+    return {
+      content: [{ type: "text", text: text2 }],
+      details: details2
     };
   }
-  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);
-      }
-    }
+  if (answer.kind === "skip") {
+    const text2 = "User chose to skip this question. Use your best judgement and proceed; you may ask again later if it still matters.";
+    const details2 = { kind: "skip" };
+    return {
+      content: [{ type: "text", text: text2 }],
+      details: details2
+    };
   }
-  async listSessions(workspaceId) {
+  const waited = Math.round((Date.now() - startedAt) / 1e3);
+  const text = `No answer within ${waited}s (agent-supplied timeout). Use your best judgement and proceed; you may ask again later if it still matters.`;
+  const details = {
+    kind: "timeout",
+    afterMs: answer.afterMs
+  };
+  return {
+    content: [{ type: "text", text }],
+    details
+  };
+}
+function descriptionSuffix(params, index) {
+  const desc = params.options[index]?.description;
+  return desc ? ` \u2014 ${desc}` : "";
+}
+
+// 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/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 (err2) {
+    cache3 = { disabled: [] };
+    if (err2.code !== "ENOENT") {
+      console.warn(`[builtin-prefs] ignoring unreadable ${PREFS_PATH}:`, err2);
+    }
+  }
+}
+function isBuiltinDisabled(id) {
+  if (cache3.disabled.includes(id)) return true;
+  if (id === "todo" && cache3.disabled.includes("plan")) return true;
+  return false;
+}
+function getDisabledBuiltins() {
+  return [...cache3.disabled];
+}
+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();
+}
+async function save2() {
+  await mkdir3(dirname3(PREFS_PATH), { recursive: true });
+  await writeFile3(PREFS_PATH, JSON.stringify(cache3, null, 2), "utf8");
+}
+
+// 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
+  }
+];
+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;
+        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 ask_user call(s) [${idList}] were cancelled because the server restarted before the user answered. Use your best judgement and proceed; you may re-call ask_user if the decision still matters.`;
+  sessionManager.appendCustomMessageEntry(
+    CUSTOM_TYPE,
+    text,
+    true,
+    // display in TUI too (no-op in pi-pilot, but harmless)
+    { ids: danglingIds }
+  );
+}
+
+// src/ws/bridge.ts
+function translatePiEvent(ev) {
+  switch (ev.type) {
+    case "agent_start":
+      return { kind: "agent_start" };
+    case "agent_end":
+      return { kind: "agent_end", willRetry: ev.willRetry };
+    case "turn_start":
+      return { kind: "turn_start" };
+    case "turn_end":
+      return { kind: "turn_end" };
+    case "message_start": {
+      const role = roleOf(ev.message);
+      const text = role === "user" ? extractUserText(ev.message) : void 0;
+      return { kind: "message_start", role, text };
+    }
+    case "message_end":
+      return { kind: "message_end", role: roleOf(ev.message) };
+    case "message_update": {
+      const ame = ev.assistantMessageEvent;
+      if (ame.type === "text_delta") {
+        return {
+          kind: "message_update",
+          delta: { kind: "text", contentIndex: ame.contentIndex, text: ame.delta }
+        };
+      }
+      if (ame.type === "thinking_delta") {
+        return {
+          kind: "message_update",
+          delta: { kind: "thinking", contentIndex: ame.contentIndex, text: ame.delta }
+        };
+      }
+      return { kind: "message_update", delta: { kind: "other" } };
+    }
+    case "tool_execution_start":
+      return {
+        kind: "tool_execution_start",
+        toolCallId: ev.toolCallId,
+        toolName: ev.toolName,
+        args: ev.args
+      };
+    case "tool_execution_update":
+      return {
+        kind: "tool_execution_update",
+        toolCallId: ev.toolCallId,
+        toolName: ev.toolName,
+        partialText: extractText(ev.partialResult)
+      };
+    case "tool_execution_end": {
+      const details = shouldForwardDetails(ev.toolName) ? ev.result?.details : void 0;
+      return {
+        kind: "tool_execution_end",
+        toolCallId: ev.toolCallId,
+        toolName: ev.toolName,
+        isError: ev.isError,
+        text: extractText(ev.result),
+        ...details !== void 0 ? { details } : {}
+      };
+    }
+    case "queue_update":
+      return {
+        kind: "queue_update",
+        steering: [...ev.steering],
+        followUp: [...ev.followUp]
+      };
+    case "auto_retry_start":
+      return {
+        kind: "auto_retry_start",
+        attempt: ev.attempt,
+        maxAttempts: ev.maxAttempts,
+        delayMs: ev.delayMs,
+        errorMessage: ev.errorMessage
+      };
+    case "auto_retry_end":
+      return {
+        kind: "auto_retry_end",
+        success: ev.success,
+        attempt: ev.attempt,
+        finalError: ev.finalError
+      };
+    case "compaction_start":
+      return { kind: "compaction_start", reason: ev.reason };
+    case "compaction_end":
+      return {
+        kind: "compaction_end",
+        reason: ev.reason,
+        aborted: ev.aborted,
+        willRetry: ev.willRetry,
+        errorMessage: ev.errorMessage
+      };
+    case "session_info_changed":
+      return { kind: "session_info_changed", name: ev.name };
+    case "thinking_level_changed":
+      return { kind: "thinking_level_changed", level: ev.level };
+    default:
+      return void 0;
+  }
+}
+var warnedUnknownRoles = /* @__PURE__ */ new Set();
+function roleOf(message) {
+  const role = message?.role;
+  if (role === "user" || role === "assistant" || role === "toolResult" || role === "bashExecution") {
+    return role;
+  }
+  const key = typeof role === "string" ? role : `<${role === void 0 ? "missing" : typeof role}>`;
+  if (!warnedUnknownRoles.has(key)) {
+    warnedUnknownRoles.add(key);
+    console.warn(
+      `[bridge] unknown message role "${key}" \u2014 treating as assistant. Pi SDK may have added a role bridge.ts and chat.ts don't handle yet.`
+    );
+  }
+  return "assistant";
+}
+function extractUserText(message) {
+  if (!message || typeof message !== "object") return void 0;
+  const content = message.content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return void 0;
+  const parts = [];
+  for (const block of content) {
+    if (block && typeof block === "object" && block.type === "text") {
+      const text = block.text;
+      if (typeof text === "string") parts.push(text);
+    }
+  }
+  return parts.length === 0 ? void 0 : parts.join("");
+}
+function inFlightAssistantSnapshot(streamingMessage) {
+  if (!streamingMessage || typeof streamingMessage !== "object") return void 0;
+  const m = streamingMessage;
+  if (m.role !== "assistant" || !Array.isArray(m.content)) return void 0;
+  let textAccum = "";
+  let thinkingAccum = "";
+  for (const block of m.content) {
+    if (!block || typeof block !== "object") continue;
+    const b = block;
+    if (b.type === "text" && typeof b.text === "string") {
+      textAccum += b.text;
+    } else if (b.type === "thinking" && typeof b.thinking === "string") {
+      thinkingAccum += b.thinking;
+    }
+  }
+  if (!textAccum && !thinkingAccum) return void 0;
+  const events = [
+    { kind: "message_start", role: "assistant" }
+  ];
+  if (thinkingAccum) {
+    events.push({
+      kind: "message_update",
+      delta: { kind: "thinking", contentIndex: 0, text: thinkingAccum }
+    });
+  }
+  if (textAccum) {
+    events.push({
+      kind: "message_update",
+      delta: { kind: "text", contentIndex: 0, text: textAccum }
+    });
+  }
+  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) => ({
+    kind: "tool_execution_start",
+    toolCallId: p.toolCallId,
+    toolName: "ask_user",
+    args: p.args
+  }));
+}
+var DETAILS_FORWARD_WHITELIST = /* @__PURE__ */ new Set(["ask_user", "todo"]);
+function shouldForwardDetails(toolName) {
+  return DETAILS_FORWARD_WHITELIST.has(toolName);
+}
+function extractText(result) {
+  if (!result || typeof result !== "object") return void 0;
+  const content = result.content;
+  if (!Array.isArray(content)) return void 0;
+  const parts = [];
+  for (const c of content) {
+    if (c && typeof c === "object" && c.type === "text") {
+      const text = c.text;
+      if (typeof text === "string") parts.push(text);
+    }
+  }
+  return parts.length === 0 ? void 0 : parts.join("");
+}
+
+// src/ws/extension-ui.ts
+var ExtensionUIBridge = class {
+  /** Symmetric with the old bridge so workspace-manager's dispose path
+   *  can call it uniformly. There is no state to release. */
+  dispose() {
+  }
+  // ============== dialog methods (resolve to default) ==============
+  select() {
+    return Promise.resolve(void 0);
+  }
+  confirm() {
+    return Promise.resolve(false);
+  }
+  input() {
+    return Promise.resolve(void 0);
+  }
+  editor() {
+    return Promise.resolve(void 0);
+  }
+  // ============== fire-and-forget methods (no-op) ==============
+  notify() {
+  }
+  setStatus() {
+  }
+  setWidget() {
+  }
+  setTitle() {
+  }
+  setEditorText() {
+  }
+  pasteToEditor() {
+  }
+  // ============== TUI-only methods (no-op / defaults) ==============
+  onTerminalInput() {
+    return () => {
+    };
+  }
+  setWorkingMessage() {
+  }
+  setWorkingVisible() {
+  }
+  setWorkingIndicator() {
+  }
+  setHiddenThinkingLabel() {
+  }
+  setFooter() {
+  }
+  setHeader() {
+  }
+  async custom() {
+    return void 0;
+  }
+  getEditorText() {
+    return "";
+  }
+  addAutocompleteProvider() {
+  }
+  setEditorComponent() {
+  }
+  getEditorComponent() {
+    return void 0;
+  }
+  get theme() {
+    return void 0;
+  }
+  getAllThemes() {
+    return [];
+  }
+  getTheme() {
+    return void 0;
+  }
+  setTheme() {
+    return { success: false, error: "Theme switching not supported in pi-pilot" };
+  }
+  getToolsExpanded() {
+    return false;
+  }
+  setToolsExpanded() {
+  }
+};
+
+// src/workspace-manager.ts
+var EXTENSIONS_ENABLED = process.env.PI_PILOT_ENABLE_EXTENSIONS === "1";
+var MAX_LIVE_RUNTIMES = 12;
+var createRuntime = async ({
+  cwd,
+  sessionManager,
+  sessionStartEvent
+}) => {
+  const services = await createAgentSessionServices({
+    cwd,
+    resourceLoaderOptions: {
+      noExtensions: !EXTENSIONS_ENABLED,
+      extensionFactories: builtinExtensionFactories
+    }
+  });
+  const sessionResult = await createAgentSessionFromServices({
+    services,
+    sessionManager,
+    sessionStartEvent
+  });
+  return {
+    ...sessionResult,
+    services,
+    diagnostics: services.diagnostics
+  };
+};
+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();
+  /**
+   * 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();
+  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 ? resolve2(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) {
+      set = /* @__PURE__ */ new Set();
+      this.subscribers.set(workspaceId, set);
+    }
+    return set;
+  }
+  /**
+   * 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,
+      agentDir: getAgentDir(),
+      sessionManager: makeSessionManager()
+    });
+    const bridge = new ExtensionUIBridge();
+    await this.bindExtensions(workspaceId, runtime, bridge);
+    safeReconcileAskUser(workspaceId, runtime.session.sessionManager);
+    return {
+      runtime,
+      bridge,
+      workspaceId,
+      sessionPath: runtime.session.sessionFile ? resolve2(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: err2.extensionPath,
+        event: err2.event,
+        message: err2.error
+      };
+      const set = this.subscribers.get(workspaceId);
+      if (set) broadcastTo(set, msg);
+      console.error(
+        `[ext-error] ${workspaceId} ${err2.extensionPath}@${err2.event}: ${err2.error}` + (err2.stack ? `
+${err2.stack}` : "")
+      );
+    };
+    await runtime.session.bindExtensions({ uiContext: bridge, onError });
+  }
+  /** 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 = resolve2(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(resolve2(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);
+    safeReconcileAskUser(workspaceId, state.runtime.session.sessionManager);
+    state.sessionPath = state.runtime.session.sessionFile ? resolve2(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) {
+    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, resolve2(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` (server-
+   * initiated broadcasts: extension errors, context_usage). Safe to call
+   * before any runtime build.
+   */
+  addSubscriber(workspaceId, ws) {
+    this.getOrCreateSubscriberSet(workspaceId).add(ws);
+  }
+  removeSubscriber(workspaceId, ws) {
+    const set = this.subscribers.get(workspaceId);
+    if (!set) return;
+    set.delete(ws);
+    if (set.size === 0) this.subscribers.delete(workspaceId);
+  }
+  /** 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);
+  }
+  /**
+   * 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 = resolve2(sessionPath);
+    const found = sessions.some((s) => resolve2(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(resolve2(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 = [];
@@ -796,8 +1754,8 @@ ${err.stack}` : "")
       const msg = entry.message;
       const role = msg.role;
       if (role === "user") {
-        const text = extractUserText(msg);
-        if (text) items.push({ kind: "user", text });
+        const text = extractUserText2(msg);
+        if (text) items.push({ kind: "user", text, entryId: entry.id });
       } else if (role === "assistant") {
         const { text, thinking, toolCalls } = extractAssistantContent(
           msg
@@ -814,7 +1772,11 @@ ${err.stack}` : "")
           toolName: tr.toolName,
           args: argsByCallId.get(tr.toolCallId) ?? "",
           text: extractContentText(tr.content),
-          isError: tr.isError
+          isError: tr.isError,
+          // Mirror live wire whitelist (bridge.ts): only ship details
+          // for tools whose cards need the structured shape, so the
+          // history payload stays small for bash / edit / read.
+          ...shouldForwardDetails(tr.toolName) && tr.details !== void 0 ? { details: tr.details } : {}
         });
       } else if (role === "bashExecution") {
         const be = msg;
@@ -831,15 +1793,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);
@@ -853,79 +1813,109 @@ ${err.stack}` : "")
     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`
         );
         return;
       }
-      throw err;
+      throw err2;
     }
   }
-  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");
-    }
-    const result = await runtime.switchSession(resolved, { cwdOverride: ws.path });
-    return !result.cancelled;
-  }
+  /** 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);
     }
   }
-  async disposeAll() {
-    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 toSessionSummary(info) {
+function safeReconcileAskUser(workspaceId, sm) {
+  try {
+    reconcileAfterRestart(sm);
+  } catch (e) {
+    console.error(`[wm] ask_user cleanup for ${workspaceId} failed:`, e);
+  }
+}
+function toSessionSummary(info, running) {
   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,
+    ...running ? { running: true } : {}
   };
 }
-function extractUserText(msg) {
+function extractUserText2(msg) {
   if (typeof msg.content === "string") return msg.content;
   return extractContentText(msg.content);
 }
@@ -958,7 +1948,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) {
@@ -1041,8 +2031,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);
     }
   });
@@ -1068,8 +2058,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);
     }
   });
@@ -1093,8 +2083,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);
     }
   });
@@ -1117,8 +2107,37 @@ function mountConfigRoutes(app2) {
       }
       runtime.session.setActiveToolsByName(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);
     }
   });
@@ -1127,7 +2146,7 @@ function mountConfigRoutes(app2) {
 // src/api/files.ts
 import { execFile as execFile2 } from "child_process";
 import { readdir } from "fs/promises";
-import { join as join4, relative, sep as sep2 } from "path";
+import { join as join5, relative, sep as sep2 } from "path";
 import { promisify as promisify2 } from "util";
 var exec2 = promisify2(execFile2);
 var LIST_TTL_MS = 1e4;
@@ -1159,8 +2178,8 @@ async function getFileList(workspacePath) {
   const now = Date.now();
   const cached = listCache.get(workspacePath);
   if (cached && cached.expiresAt > now) return cached.files;
-  const pending = inflight2.get(workspacePath);
-  if (pending) return (await pending).files;
+  const pending2 = inflight2.get(workspacePath);
+  if (pending2) return (await pending2).files;
   const probe = probeFileList(workspacePath).then((files) => {
     const entry = {
       files,
@@ -1216,7 +2235,7 @@ async function walkDir(root, dir, depth, out) {
   for (const d of dirents) {
     if (out.length >= MAX_FILES_TRACKED) return;
     if (WALK_IGNORES.has(d.name)) continue;
-    const abs = join4(dir, d.name);
+    const abs = join5(dir, d.name);
     if (d.isDirectory()) {
       await walkDir(root, abs, depth + 1, out);
     } else if (d.isFile()) {
@@ -1256,7 +2275,7 @@ function mountFilesRoute(app2) {
       if (!qRaw) {
         const slice = all.slice(0, limit);
         entries = slice.map((relPath) => ({
-          path: join4(workspacePath, relPath),
+          path: join5(workspacePath, relPath),
           relPath
         }));
         truncated = all.length > limit;
@@ -1273,16 +2292,16 @@ function mountFilesRoute(app2) {
         scored.sort((a, b) => b.score - a.score);
         const top = scored.slice(0, limit);
         entries = top.map((e) => ({
-          path: join4(workspacePath, e.relPath),
+          path: join5(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);
     }
   });
@@ -1290,7 +2309,7 @@ function mountFilesRoute(app2) {
 
 // src/api/resources.ts
 import { readdir as readdir2 } from "fs/promises";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 import { getAgentDir as getAgentDir2 } from "@earendil-works/pi-coding-agent";
 function toResourceSource(info) {
   return {
@@ -1300,16 +2319,16 @@ function toResourceSource(info) {
   };
 }
 async function scanExtensionDirs(workspaceCwd) {
-  const dirs = [join5(getAgentDir2(), "extensions"), join5(workspaceCwd, ".pi", "extensions")];
+  const dirs = [join6(getAgentDir2(), "extensions"), join6(workspaceCwd, ".pi", "extensions")];
   const found = [];
   for (const dir of dirs) {
     try {
       const entries = await readdir2(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isFile() && (entry.name.endsWith(".ts") || entry.name.endsWith(".js"))) {
-          found.push(join5(dir, entry.name));
+          found.push(join6(dir, entry.name));
         } else if (entry.isDirectory()) {
-          found.push(join5(dir, entry.name));
+          found.push(join6(dir, entry.name));
         }
       }
     } catch {
@@ -1364,18 +2383,28 @@ 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());
+  const builtinExtensions = BUILTIN_EXTENSIONS.map((d) => ({
+    id: d.id,
+    name: d.name,
+    description: d.description,
+    enabled: !disabledBuiltins.has(d.id),
+    tools: d.tools,
+    commands: d.commands
+  }));
   return {
     skills: skillsOut,
     prompts: promptsOut,
     extensionsEnabled: EXTENSIONS_ENABLED,
     extensions: extensionsOut,
     extensionErrors,
-    disabledExtensions
+    disabledExtensions,
+    builtinExtensions
   };
 }
 async function rootsFor(workspaceId) {
@@ -1384,12 +2413,12 @@ async function rootsFor(workspaceId) {
   const roots = resolveResourceRoots({ agentDir: getAgentDir2(), 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) {
@@ -1406,8 +2435,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) => {
@@ -1419,8 +2448,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) => {
@@ -1445,8 +2474,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) => {
@@ -1470,8 +2499,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) => {
@@ -1495,8 +2524,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) => {
@@ -1511,8 +2540,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) => {
@@ -1537,8 +2566,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) => {
@@ -1562,8 +2591,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) => {
@@ -1587,8 +2616,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) => {
@@ -1603,23 +2632,218 @@ 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) => {
+    const id = c.req.param("id");
+    const ws = await getWorkspace(id);
+    if (!ws) return c.json({ ok: false, error: "not found" }, 404);
+    const body = await c.req.json().catch(() => null);
+    if (!body || typeof body.id !== "string" || typeof body.enabled !== "boolean") {
+      return c.json({ ok: false, error: "id and enabled are required" }, 400);
+    }
+    if (!BUILTIN_EXTENSIONS.some((d) => d.id === body.id)) {
+      return c.json({ ok: false, error: `unknown builtin extension: ${body.id}` }, 400);
+    }
+    try {
+      const runtime = await workspaceManager.getOrCreate(id);
+      if (runtime.session.isStreaming) {
+        return c.json(
+          { ok: false, error: "Stop the current turn before changing extensions" },
+          409
+        );
+      }
+      await setBuiltinEnabled(body.id, body.enabled);
+      await runtime.session.reload();
+      const { roots, workspaceCwd } = await rootsFor(id);
+      return c.json(await snapshot(id, roots, workspaceCwd));
+    } catch (err2) {
+      return respondError(c, err2);
+    }
+  });
+}
+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 truncate(String(entry["summary"] ?? "Compaction"), PREVIEW_MAX);
+    case "branch_summary":
+      return truncate(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 truncate(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 truncate(`$ ${m.command ?? ""}`, PREVIEW_MAX);
+  }
+  return truncate(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 isScope(value) {
-  return value === "user" || value === "project";
+function truncate(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);
@@ -1628,9 +2852,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);
   }
 });
@@ -1646,15 +2870,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);
   }
 });
@@ -1671,9 +2895,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 readFile4(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);
   }
 });
@@ -1686,9 +2932,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);
   }
 });
@@ -1729,13 +2975,14 @@ workspacesRoute.delete("/:id", async (c) => {
 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 dirname3, isAbsolute as isAbsolute4, join as join6, resolve as resolve4 } from "path";
-import { Hono as Hono2 } from "hono";
-var fsRoute = new Hono2();
+import { dirname as dirname4, isAbsolute as isAbsolute4, join as join7, resolve as resolve4 } 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";
@@ -1743,18 +2990,18 @@ fsRoute.get("/browse", async (c) => {
   let dirents;
   try {
     dirents = await readdir3(target, { withFileTypes: true });
-  } catch (err) {
-    const code = err.code;
+  } 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: join6(target, d.name),
+    path: join7(target, d.name),
     type: "dir"
   })).sort((a, b) => a.name.localeCompare(b.name));
   const parent = (() => {
-    const p = dirname3(target);
+    const p = dirname4(target);
     return p === target ? null : p;
   })();
   const body = { path: target, parent, entries };
@@ -1762,13 +3009,13 @@ fsRoute.get("/browse", async (c) => {
 });
 
 // src/api/model-configs.ts
-import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
-import { dirname as dirname4, join as join7 } from "path";
-import { Hono as Hono3 } from "hono";
+import { readFile as readFile5, writeFile as writeFile4, mkdir as mkdir4 } from "fs/promises";
+import { dirname as dirname5, join as join8 } from "path";
+import { Hono as Hono4 } from "hono";
 import {
   getAgentDir as getAgentDir3
 } from "@earendil-works/pi-coding-agent";
-var modelConfigsRoute = new Hono3();
+var modelConfigsRoute = new Hono4();
 var writeLock = Promise.resolve();
 function withWriteLock(fn) {
   const next = writeLock.then(fn, fn);
@@ -1778,23 +3025,23 @@ function withWriteLock(fn) {
   return next;
 }
 function modelsPath() {
-  return join7(getAgentDir3(), "models.json");
+  return join8(getAgentDir3(), "models.json");
 }
 async function readModelsJson() {
   try {
-    const raw = await readFile3(modelsPath(), "utf-8");
+    const raw = await readFile5(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 mkdir3(dirname4(p), { recursive: true });
-  await writeFile3(p, JSON.stringify(config2, null, 2), "utf-8");
+  await mkdir4(dirname5(p), { recursive: true });
+  await writeFile4(p, JSON.stringify(config2, null, 2), "utf-8");
 }
 var ValidationError = class extends Error {
   constructor(message, status) {
@@ -1819,8 +3066,8 @@ modelConfigsRoute.get("/", async (c) => {
     const config2 = await readModelsJson();
     const body = { config: 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);
   }
 });
@@ -1837,8 +3084,8 @@ modelConfigsRoute.put("/", async (c) => {
     refreshRegistry(workspaceId ?? void 0);
     const resp = { config: body.config };
     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);
   }
 });
@@ -1864,8 +3111,8 @@ modelConfigsRoute.post("/providers", async (c) => {
     refreshRegistry(workspaceId ?? void 0);
     const resp = { config: 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);
   }
 });
@@ -1888,11 +3135,11 @@ modelConfigsRoute.delete("/providers", async (c) => {
     refreshRegistry(workspaceId ?? void 0);
     const resp = { config: 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);
   }
 });
@@ -1920,11 +3167,11 @@ modelConfigsRoute.post("/providers/:provider/models", async (c) => {
     refreshRegistry(workspaceId ?? void 0);
     const resp = { config: 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);
   }
 });
@@ -1956,11 +3203,11 @@ modelConfigsRoute.put("/providers/:provider/models/:modelId", async (c) => {
     refreshRegistry(workspaceId ?? void 0);
     const resp = { config: 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);
   }
 });
@@ -1985,149 +3232,18 @@ modelConfigsRoute.delete("/providers/:provider/models/:modelId", async (c) => {
     refreshRegistry(workspaceId ?? void 0);
     const resp = { config: 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/ws/hub.ts
 import { WebSocketServer } from "ws";
-
-// src/ws/bridge.ts
-function translatePiEvent(ev) {
-  switch (ev.type) {
-    case "agent_start":
-      return { kind: "agent_start" };
-    case "agent_end":
-      return { kind: "agent_end", willRetry: ev.willRetry };
-    case "turn_start":
-      return { kind: "turn_start" };
-    case "turn_end":
-      return { kind: "turn_end" };
-    case "message_start": {
-      const role = roleOf(ev.message);
-      const text = role === "user" ? extractUserText2(ev.message) : void 0;
-      return { kind: "message_start", role, text };
-    }
-    case "message_end":
-      return { kind: "message_end", role: roleOf(ev.message) };
-    case "message_update": {
-      const ame = ev.assistantMessageEvent;
-      if (ame.type === "text_delta") {
-        return {
-          kind: "message_update",
-          delta: { kind: "text", contentIndex: ame.contentIndex, text: ame.delta }
-        };
-      }
-      if (ame.type === "thinking_delta") {
-        return {
-          kind: "message_update",
-          delta: { kind: "thinking", contentIndex: ame.contentIndex, text: ame.delta }
-        };
-      }
-      return { kind: "message_update", delta: { kind: "other" } };
-    }
-    case "tool_execution_start":
-      return {
-        kind: "tool_execution_start",
-        toolCallId: ev.toolCallId,
-        toolName: ev.toolName,
-        args: ev.args
-      };
-    case "tool_execution_update":
-      return {
-        kind: "tool_execution_update",
-        toolCallId: ev.toolCallId,
-        toolName: ev.toolName,
-        partialText: extractText(ev.partialResult)
-      };
-    case "tool_execution_end":
-      return {
-        kind: "tool_execution_end",
-        toolCallId: ev.toolCallId,
-        toolName: ev.toolName,
-        isError: ev.isError,
-        text: extractText(ev.result)
-      };
-    case "queue_update":
-      return {
-        kind: "queue_update",
-        steering: [...ev.steering],
-        followUp: [...ev.followUp]
-      };
-    case "auto_retry_start":
-      return {
-        kind: "auto_retry_start",
-        attempt: ev.attempt,
-        maxAttempts: ev.maxAttempts,
-        delayMs: ev.delayMs,
-        errorMessage: ev.errorMessage
-      };
-    case "auto_retry_end":
-      return {
-        kind: "auto_retry_end",
-        success: ev.success,
-        attempt: ev.attempt,
-        finalError: ev.finalError
-      };
-    case "compaction_start":
-      return { kind: "compaction_start", reason: ev.reason };
-    case "compaction_end":
-      return {
-        kind: "compaction_end",
-        reason: ev.reason,
-        aborted: ev.aborted,
-        willRetry: ev.willRetry,
-        errorMessage: ev.errorMessage
-      };
-    case "session_info_changed":
-      return { kind: "session_info_changed", name: ev.name };
-    case "thinking_level_changed":
-      return { kind: "thinking_level_changed", level: ev.level };
-    default:
-      return void 0;
-  }
-}
-function roleOf(message) {
-  const role = message?.role;
-  if (role === "user" || role === "assistant" || role === "toolResult" || role === "bashExecution") {
-    return role;
-  }
-  return "assistant";
-}
-function extractUserText2(message) {
-  if (!message || typeof message !== "object") return void 0;
-  const content = message.content;
-  if (typeof content === "string") return content;
-  if (!Array.isArray(content)) return void 0;
-  const parts = [];
-  for (const block of content) {
-    if (block && typeof block === "object" && block.type === "text") {
-      const text = block.text;
-      if (typeof text === "string") parts.push(text);
-    }
-  }
-  return parts.length === 0 ? void 0 : parts.join("");
-}
-function extractText(result) {
-  if (!result || typeof result !== "object") return void 0;
-  const content = result.content;
-  if (!Array.isArray(content)) return void 0;
-  const parts = [];
-  for (const c of content) {
-    if (c && typeof c === "object" && c.type === "text") {
-      const text = c.text;
-      if (typeof text === "string") parts.push(text);
-    }
-  }
-  return parts.length === 0 ? void 0 : parts.join("");
-}
-
-// src/ws/hub.ts
+var BACKGROUND_CAP = 4;
 var replacementLocks = /* @__PURE__ */ new Map();
 function withReplacementLock(workspaceId, fn) {
   const prev = replacementLocks.get(workspaceId) ?? Promise.resolve();
@@ -2144,7 +3260,7 @@ function withReplacementLock(workspaceId, fn) {
 function attachWsHub(httpServer) {
   const wss = new WebSocketServer({ server: httpServer, path: "/ws" });
   wss.on("connection", (ws) => {
-    const state = {};
+    const state = { background: /* @__PURE__ */ new Map() };
     ws.on("message", async (raw) => {
       let msg;
       try {
@@ -2155,8 +3271,8 @@ function attachWsHub(httpServer) {
       }
       try {
         await handle(ws, state, msg);
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
+      } catch (err2) {
+        const message = err2 instanceof Error ? err2.message : String(err2);
         send(ws, { type: "error", message, command: msg.type });
       }
     });
@@ -2169,110 +3285,161 @@ 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 primary = state.primary;
+      if (!primary) {
+        send(ws, { type: "error", message: "not subscribed", command: "answer_question" });
+        return;
+      }
+      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;
     }
@@ -2283,28 +3450,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") {
@@ -2313,12 +3478,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 = {
@@ -2326,12 +3486,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;
     }
@@ -2339,13 +3494,79 @@ function bindCurrentSession(ws, state, workspaceId) {
       sendContextUsage(ws, runtime, workspaceId, sessionPath);
     }
   });
+  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 });
+    }
+  }
+  for (const payload of inFlightToolCallsSnapshot(sessionPath)) {
+    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,
-    sessionId: session.sessionId
+    sessionPath: runtime.session.sessionFile ?? null,
+    sessionId: runtime.session.sessionId
   });
-  sendContextUsage(ws, runtime, workspaceId, sessionPath);
+}
+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();
@@ -2356,22 +3577,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;
@@ -2379,10 +3598,11 @@ function send(ws, msg) {
 }
 
 // src/index.ts
-var app = new Hono4();
-var distDir = dirname5(fileURLToPath(import.meta.url));
-var webRoot = resolve5(process.env.PI_PILOT_WEB_ROOT ?? join8(distDir, "..", "public"));
-var webIndexPath = join8(webRoot, "index.html");
+configureHttpProxy();
+var app = new Hono5();
+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 mimeTypes = {
   ".css": "text/css; charset=utf-8",
   ".html": "text/html; charset=utf-8",
@@ -2416,11 +3636,11 @@ function safeResolveWebPath(pathname) {
 }
 async function readWebFile(path) {
   try {
-    return await readFile4(path);
-  } catch (err) {
-    const code = err.code;
+    return await readFile6(path);
+  } catch (err2) {
+    const code = err2.code;
     if (code === "ENOENT" || code === "EISDIR") return void 0;
-    throw err;
+    throw err2;
   }
 }
 async function serveWeb(c) {
@@ -2429,7 +3649,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 readFile4(webIndexPath);
+  const body = asset ?? await readFile6(webIndexPath);
   const filePath = asset ? assetPath : webIndexPath;
   const headers = {
     "Content-Type": mimeTypes[extname(filePath)] ?? "application/octet-stream",
@@ -2459,6 +3679,7 @@ if (existsSync(webIndexPath)) {
     )
   );
 }
+await loadBuiltinPrefs();
 var server = serve(
   {
     fetch: app.fetch,