@jyork0828/pi-pilot 0.0.5 → 0.0.6

package/dist/index.js

@@ -2,11 +2,11 @@
 
 // src/index.ts
 import { existsSync } from "fs";
-import { readFile as readFile5 } from "fs/promises";
+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
@@ -41,9 +41,9 @@ function configureHttpProxy() {
 }
 
 // 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 {
@@ -277,9 +277,9 @@ async function updatePrompt(opts) {
     await writeFile(newPath, text, "utf8");
     try {
       await unlink(opts.filePath);
-    } catch (err) {
+    } catch (err2) {
       await unlink(newPath).catch(() => void 0);
-      throw err;
+      throw err2;
     }
     return newPath;
   }
@@ -351,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;
@@ -380,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
@@ -502,57 +538,232 @@ 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("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.registerCommand("todos", {
+    description: "Show current todo list grouped by status.",
+    handler: async () => {
+      const visible = state.tasks.filter((t) => t.status !== "deleted");
+      if (visible.length === 0) {
+        pi.sendUserMessage("Show the current todo list.");
+        return;
+      }
+      const pending2 = visible.filter((t) => t.status === "pending");
+      const inProgress = visible.filter((t) => t.status === "in_progress");
+      const completed = visible.filter((t) => t.status === "completed");
+      const lines = [];
+      const total = visible.length;
+      const doneCount = completed.length;
+      lines.push(`Todos (${doneCount}/${total})`);
+      if (inProgress.length > 0) {
+        lines.push("\u2500\u2500 In Progress \u2500\u2500");
+        for (const t of inProgress) lines.push(`  \u25D0 #${t.id} ${t.subject}`);
+      }
+      if (pending2.length > 0) {
+        lines.push("\u2500\u2500 Pending \u2500\u2500");
+        for (const t of pending2) lines.push(`  \u25CB #${t.id} ${t.subject}`);
+      }
+      if (completed.length > 0) {
+        lines.push("\u2500\u2500 Completed \u2500\u2500");
+        for (const t of completed) lines.push(`  \u2713 #${t.id} ${t.subject}`);
+      }
+      pi.sendUserMessage(`Current todos:
+${lines.join("\n")}`);
     }
   });
+  pi.on("session_start", async (_event, ctx) => {
+    state = replayFromBranch(ctx);
+  });
+  pi.on("session_compact", async (_event, ctx) => {
+    try {
+      state = replayFromBranch(ctx);
+    } catch {
+    }
+  });
+  pi.on("session_tree", async (_event, ctx) => {
+    try {
+      state = replayFromBranch(ctx);
+    } catch {
+    }
+  });
+  pi.on("session_shutdown", async () => {
+    state = { tasks: [...EMPTY_STATE.tasks], nextId: EMPTY_STATE.nextId };
+  });
 };
 
 // src/extensions/ask_user/schema.ts
@@ -616,13 +827,6 @@ function resolveAnswer(toolCallId, answer, expectedSessionFile) {
   entry.resolve(answer);
   return true;
 }
-function cancelPendingExcept(keepSessionFile) {
-  for (const [id, entry] of pending) {
-    if (entry.sessionFile === keepSessionFile) continue;
-    pending.delete(id);
-    entry.reject(new Error("Session replaced before answer arrived"));
-  }
-}
 function cancelPendingForSession(sessionFile) {
   for (const [id, entry] of pending) {
     if (entry.sessionFile !== sessionFile) continue;
@@ -687,11 +891,11 @@ function waitForAnswer({
       cleanup();
       resolve6(a);
     };
-    const finishErr = (err) => {
+    const finishErr = (err2) => {
       if (settled) return;
       settled = true;
       cleanup();
-      reject(err);
+      reject(err2);
     };
     const onAbort = () => finishErr(new Error("Aborted by user"));
     if (signal?.aborted) {
@@ -709,7 +913,7 @@ function waitForAnswer({
       args: params,
       sessionFile,
       resolve: (answer) => finishOk(answer),
-      reject: (err) => finishErr(err)
+      reject: (err2) => finishErr(err2)
     });
   });
 }
@@ -759,6 +963,70 @@ function descriptionSuffix(params, index) {
   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";
@@ -769,15 +1037,17 @@ async function loadBuiltinPrefs() {
     const raw = await readFile3(PREFS_PATH, "utf8");
     const parsed = JSON.parse(raw);
     cache3 = { disabled: Array.isArray(parsed.disabled) ? parsed.disabled : [] };
-  } catch (err) {
+  } catch (err2) {
     cache3 = { disabled: [] };
-    if (err.code !== "ENOENT") {
-      console.warn(`[builtin-prefs] ignoring unreadable ${PREFS_PATH}:`, err);
+    if (err2.code !== "ENOENT") {
+      console.warn(`[builtin-prefs] ignoring unreadable ${PREFS_PATH}:`, err2);
     }
   }
 }
 function isBuiltinDisabled(id) {
-  return cache3.disabled.includes(id);
+  if (cache3.disabled.includes(id)) return true;
+  if (id === "todo" && cache3.disabled.includes("plan")) return true;
+  return false;
 }
 function getDisabledBuiltins() {
   return [...cache3.disabled];
@@ -797,12 +1067,12 @@ async function save2() {
 // src/extensions/index.ts
 var BUILTIN_EXTENSIONS = [
   {
-    id: "plan",
-    name: "Plan",
-    description: "A live task checklist for multi-step work \u2014 adds the update_plan tool and the /plan command.",
-    tools: ["update_plan"],
-    commands: ["plan"],
-    factory: planExtensionFactory
+    id: "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",
@@ -811,6 +1081,14 @@ var BUILTIN_EXTENSIONS = [
     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) {
@@ -1036,6 +1314,37 @@ function inFlightAssistantSnapshot(streamingMessage) {
   }
   return events;
 }
+function inFlightRunningToolsSnapshot(pendingToolCalls, messages) {
+  const pending2 = new Set(pendingToolCalls);
+  if (pending2.size === 0) return [];
+  const infoById = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    if (!message || typeof message !== "object") continue;
+    if (message.role !== "assistant") continue;
+    const content = message.content;
+    if (!Array.isArray(content)) continue;
+    for (const block of content) {
+      if (!block || typeof block !== "object") continue;
+      const b = block;
+      if (b.type === "toolCall" && typeof b.id === "string" && pending2.has(b.id)) {
+        infoById.set(b.id, { name: typeof b.name === "string" ? b.name : "tool", args: b.arguments });
+      }
+    }
+  }
+  const events = [];
+  for (const toolCallId of pending2) {
+    const info = infoById.get(toolCallId);
+    if (!info) continue;
+    if (info.name === "ask_user") continue;
+    events.push({
+      kind: "tool_execution_start",
+      toolCallId,
+      toolName: info.name,
+      args: info.args
+    });
+  }
+  return events;
+}
 function inFlightToolCallsSnapshot(sessionFile) {
   const pending2 = snapshotForSession(sessionFile);
   return pending2.map((p) => ({
@@ -1045,7 +1354,7 @@ function inFlightToolCallsSnapshot(sessionFile) {
     args: p.args
   }));
 }
-var DETAILS_FORWARD_WHITELIST = /* @__PURE__ */ new Set(["ask_user"]);
+var DETAILS_FORWARD_WHITELIST = /* @__PURE__ */ new Set(["ask_user", "todo"]);
 function shouldForwardDetails(toolName) {
   return DETAILS_FORWARD_WHITELIST.has(toolName);
 }
@@ -1146,6 +1455,7 @@ var ExtensionUIBridge = class {
 
 // src/workspace-manager.ts
 var EXTENSIONS_ENABLED = process.env.PI_PILOT_ENABLE_EXTENSIONS === "1";
+var MAX_LIVE_RUNTIMES = 12;
 var createRuntime = async ({
   cwd,
   sessionManager,
@@ -1169,18 +1479,36 @@ var createRuntime = async ({
     diagnostics: services.diagnostics
   };
 };
-var WorkspaceManager = class {
-  states = /* @__PURE__ */ new Map();
+var KEY_SEP = "\0";
+var SessionRuntimeManager = class {
+  /** All live runtimes, keyed by `runtimeKey`. */
+  runtimes = /* @__PURE__ */ new Map();
+  /** Per-build lock keyed by `runtimeKey` to serialize concurrent creations. */
+  pending = /* @__PURE__ */ new Map();
+  /** The runtime the hub last made primary, per workspace. Drives `get`. */
+  activeByWorkspace = /* @__PURE__ */ new Map();
   /**
-   * Subscribers live independently of `states` so the hub can register a
-   * WebSocket *before* `getOrCreate` triggers a runtime build (which may
-   * fire `session_start` synchronously, and any UI request from a
-   * session_start handler would otherwise broadcast to an empty set).
+   * WS subscribers, keyed by workspaceId (not runtimeKey): a connection
+   * viewing any session of a workspace receives that workspace's
+   * server-initiated broadcasts (extension errors, context_usage). Owned by
+   * the manager so it can pre-exist any runtime build (extensions may fire
+   * `onError` from `session_start` before any client subscribed).
    */
   subscribers = /* @__PURE__ */ new Map();
-  /** Per-workspace lock to serialize concurrent creations. */
-  pending = /* @__PURE__ */ new Map();
-  rebindListeners = /* @__PURE__ */ new Map();
+  touchSeq = 0;
+  /** `runtimeKey` for a (workspace, session identity). */
+  keyOf(workspaceId, sessionIdentity) {
+    return `${workspaceId}${KEY_SEP}${sessionIdentity}`;
+  }
+  /** `runtimeKey` for a built runtime, from its session file (or sessionId). */
+  keyForRuntime(workspaceId, runtime) {
+    const file = runtime.session.sessionFile;
+    return this.keyOf(workspaceId, file ? 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) {
@@ -1189,64 +1517,186 @@ var WorkspaceManager = class {
     }
     return set;
   }
-  async getOrCreate(workspaceId) {
-    const existing = this.states.get(workspaceId);
-    if (existing) return existing.runtime;
-    const inflight3 = this.pending.get(workspaceId);
-    if (inflight3) return (await inflight3).runtime;
-    const p = this.build(workspaceId);
-    this.pending.set(workspaceId, p);
-    try {
-      const state = await p;
-      this.states.set(workspaceId, state);
-      return state.runtime;
-    } finally {
-      this.pending.delete(workspaceId);
-    }
-  }
-  async build(workspaceId) {
-    const ws = await getWorkspace(workspaceId);
-    if (!ws) throw new Error(`Workspace not found: ${workspaceId}`);
-    const sessionManager = SessionManager.continueRecent(ws.path);
+  /**
+   * Build (but do not register) a runtime for `workspaceId` from a
+   * SessionManager factory. Binds the UI bridge + onError and runs ask_user
+   * post-restart cleanup. The bridge broadcasts to the workspace's subscriber
+   * set, resolved lazily so it works even if the set is created later.
+   */
+  async buildState(workspaceId, cwd, makeSessionManager) {
     const runtime = await createAgentSessionRuntime(createRuntime, {
-      cwd: ws.path,
+      cwd,
       agentDir: getAgentDir(),
-      sessionManager
+      sessionManager: makeSessionManager()
     });
-    const subscribers = this.getOrCreateSubscriberSet(workspaceId);
     const bridge = new ExtensionUIBridge();
-    const onError = (err) => {
+    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: err.extensionPath,
-        event: err.event,
-        message: err.error
+        extensionPath: err2.extensionPath,
+        event: err2.event,
+        message: err2.error
       };
-      broadcastTo(subscribers, msg);
+      const set = this.subscribers.get(workspaceId);
+      if (set) broadcastTo(set, msg);
       console.error(
-        `[ext-error] ${workspaceId} ${err.extensionPath}@${err.event}: ${err.error}` + (err.stack ? `
-${err.stack}` : "")
+        `[ext-error] ${workspaceId} ${err2.extensionPath}@${err2.event}: ${err2.error}` + (err2.stack ? `
+${err2.stack}` : "")
       );
     };
     await runtime.session.bindExtensions({ uiContext: bridge, onError });
-    safeReconcileAskUser(workspaceId, runtime.session.sessionManager);
-    runtime.setRebindSession(async () => {
-      await runtime.session.bindExtensions({ uiContext: bridge, onError });
-      cancelPendingExcept(runtime.session.sessionFile ?? null);
-      safeReconcileAskUser(workspaceId, runtime.session.sessionManager);
-      this.notifySessionReplaced(workspaceId);
-    });
-    return { runtime, bridge };
   }
+  /** Register a freshly-built state under its session key, deduping against a
+   *  concurrent build of the same session. Returns the winning state. */
+  async adopt(state) {
+    const key = this.keyForRuntime(state.workspaceId, state.runtime);
+    const existing = this.runtimes.get(key);
+    if (existing) {
+      await this.disposeState(state);
+      return existing;
+    }
+    this.runtimes.set(key, state);
+    this.evictIfOverCap(key);
+    return state;
+  }
+  /**
+   * Ensure a runtime exists for the target session and return it.
+   *
+   * - With `sessionPath`: opens that specific session (deduped by key).
+   * - Without: returns the workspace's active/any live runtime, or builds the
+   *   "continue recent" default if none exists yet.
+   *
+   * Does NOT change the active pointer — the hub owns that via `setActive`.
+   */
+  async getOrCreate(workspaceId, sessionPath) {
+    const ws = await getWorkspace(workspaceId);
+    if (!ws) throw new Error(`Workspace not found: ${workspaceId}`);
+    if (sessionPath) {
+      if (!isAbsolute2(sessionPath)) throw new Error("Session path must be absolute");
+      const resolved = 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) {
-    return this.states.get(workspaceId)?.runtime;
+    const activeKey = this.activeByWorkspace.get(workspaceId);
+    if (activeKey) {
+      const active = this.runtimes.get(activeKey);
+      if (active) return active.runtime;
+    }
+    for (const state of this.runtimes.values()) {
+      if (state.workspaceId === workspaceId) return state.runtime;
+    }
+    return void 0;
+  }
+  /** The runtime bound to a specific (workspace, session), if live. */
+  getForSession(workspaceId, sessionPath) {
+    return this.runtimes.get(this.keyOf(workspaceId, 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`. Safe to
-   * call before `getOrCreate`; the set is lazily created so the bridge,
-   * when later built, sees the same Set instance and any pre-existing
-   * subscribers.
+   * Register a WS connection as a subscriber for `workspaceId` (server-
+   * initiated broadcasts: extension errors, context_usage). Safe to call
+   * before any runtime build.
    */
   addSubscriber(workspaceId, ws) {
     this.getOrCreateSubscriberSet(workspaceId).add(ws);
@@ -1257,60 +1707,44 @@ ${err.stack}` : "")
     set.delete(ws);
     if (set.size === 0) this.subscribers.delete(workspaceId);
   }
-  /**
-   * Fan a server-initiated message out to every WS subscribed to the
-   * workspace. Used by API handlers that mutate runtime state and need
-   * to refresh derived snapshots (e.g. `context_usage` after `setModel`,
-   * which pi's event stream doesn't surface unless thinking-level also
-   * clamps).
-   */
+  /** Fan a server-initiated message out to every WS subscribed to the
+   *  workspace (e.g. context_usage after setModel). */
   broadcast(workspaceId, msg) {
     const set = this.subscribers.get(workspaceId);
     if (!set || set.size === 0) return;
     broadcastTo(set, msg);
   }
-  onSessionReplaced(workspaceId, listener) {
-    let listeners = this.rebindListeners.get(workspaceId);
-    if (!listeners) {
-      listeners = /* @__PURE__ */ new Set();
-      this.rebindListeners.set(workspaceId, listeners);
-    }
-    listeners.add(listener);
-    return () => {
-      const current = this.rebindListeners.get(workspaceId);
-      if (!current) return;
-      current.delete(listener);
-      if (current.size === 0) {
-        this.rebindListeners.delete(workspaceId);
-      }
-    };
-  }
-  notifySessionReplaced(workspaceId) {
-    const listeners = this.rebindListeners.get(workspaceId);
-    if (!listeners) return;
-    for (const listener of [...listeners]) {
-      try {
-        listener();
-      } catch (e) {
-        console.error(`[wm] rebind listener for ${workspaceId} failed:`, e);
-      }
-    }
+  /**
+   * Check that `sessionPath` belongs to the given workspace's session list.
+   * Returns an error string if validation fails, or `null` if the path is
+   * owned by this workspace.
+   */
+  async validateSessionOwnership(workspaceId, sessionPath) {
+    if (!isAbsolute2(sessionPath)) return "session path must be absolute";
+    const ws = await getWorkspace(workspaceId);
+    if (!ws) return `workspace not found: ${workspaceId}`;
+    const sessions = await SessionManager.list(ws.path);
+    const resolved = 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 = [];
@@ -1321,7 +1755,7 @@ ${err.stack}` : "")
       const role = msg.role;
       if (role === "user") {
         const text = extractUserText2(msg);
-        if (text) items.push({ kind: "user", text });
+        if (text) items.push({ kind: "user", text, entryId: entry.id });
       } else if (role === "assistant") {
         const { text, thinking, toolCalls } = extractAssistantContent(
           msg
@@ -1359,15 +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);
@@ -1381,69 +1813,89 @@ ${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() {
-    await Promise.allSettled([...this.pending.values()]);
-    const ids = [...this.states.keys()];
-    await Promise.all(ids.map((id) => this.dispose(id)));
+  /**
+   * Keep the live-runtime count under `MAX_LIVE_RUNTIMES` by disposing the
+   * least-recently-touched IDLE runtime (never streaming, never the freshly-
+   * registered one, never a workspace's active pointer). Best-effort: if every
+   * runtime is busy we simply exceed the cap until one frees up.
+   */
+  evictIfOverCap(justRegistered) {
+    while (this.runtimes.size > MAX_LIVE_RUNTIMES) {
+      let victimKey;
+      let victimTouched = Infinity;
+      for (const [key, state] of this.runtimes) {
+        if (key === justRegistered) continue;
+        if (this.activeByWorkspace.get(state.workspaceId) === key) continue;
+        if (state.runtime.session.isStreaming) continue;
+        if (state.touchedAt < victimTouched) {
+          victimTouched = state.touchedAt;
+          victimKey = key;
+        }
+      }
+      if (!victimKey) break;
+      const victim = this.runtimes.get(victimKey);
+      if (!victim) break;
+      void this.disposeState(victim, victimKey);
+    }
   }
 };
 function safeReconcileAskUser(workspaceId, sm) {
@@ -1453,13 +1905,14 @@ function safeReconcileAskUser(workspaceId, sm) {
     console.error(`[wm] ask_user cleanup for ${workspaceId} failed:`, e);
   }
 }
-function toSessionSummary(info) {
+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 extractUserText2(msg) {
@@ -1495,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) {
@@ -1578,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);
     }
   });
@@ -1605,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);
     }
   });
@@ -1630,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);
     }
   });
@@ -1654,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);
     }
   });
@@ -1817,9 +2299,9 @@ function mountFilesRoute(app2) {
       }
       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);
     }
   });
@@ -1901,9 +2383,9 @@ async function snapshot(workspaceId, roots, workspaceCwd) {
       shortcuts: [...e.shortcuts.keys()]
     };
   });
-  const extensionErrors = extResult.errors.map((err) => ({
-    path: err.path,
-    error: err.error
+  const extensionErrors = extResult.errors.map((err2) => ({
+    path: err2.path,
+    error: err2.error
   }));
   const disabledExtensions = EXTENSIONS_ENABLED ? [] : await scanExtensionDirs(workspaceCwd);
   const disabledBuiltins = new Set(getDisabledBuiltins());
@@ -1931,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) {
@@ -1953,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) => {
@@ -1966,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) => {
@@ -1992,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) => {
@@ -2017,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) => {
@@ -2042,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) => {
@@ -2058,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) => {
@@ -2084,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) => {
@@ -2109,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) => {
@@ -2134,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) => {
@@ -2150,8 +2632,8 @@ function mountResourcesRoute(app2) {
       await deletePrompt(filePath, roots);
       await reload(id);
       return c.json(await snapshot(id, roots, workspaceCwd));
-    } catch (err) {
-      return respondError(c, err);
+    } catch (err2) {
+      return respondError(c, err2);
     }
   });
   app2.put("/:id/resources/builtin-extensions", async (c) => {
@@ -2177,8 +2659,8 @@ function mountResourcesRoute(app2) {
       await runtime.session.reload();
       const { roots, workspaceCwd } = await rootsFor(id);
       return c.json(await snapshot(id, roots, workspaceCwd));
-    } catch (err) {
-      return respondError(c, err);
+    } catch (err2) {
+      return respondError(c, err2);
     }
   });
 }
@@ -2186,14 +2668,182 @@ function isScope(value) {
   return value === "user" || value === "project";
 }
 
+// src/api/tree.ts
+import { Hono } from "hono";
+var treeRoute = new Hono();
+treeRoute.get("/", async (c) => {
+  const id = c.req.param("id") ?? "";
+  const existed = await getWorkspace(id);
+  if (!existed) return c.json({ ok: false, error: "not found" }, 404);
+  try {
+    const runtime = await workspaceManager.getOrCreate(id);
+    const sm = runtime.session.sessionManager;
+    const tree = sm.getTree();
+    const leafId = sm.getLeafId();
+    const activeIds = /* @__PURE__ */ new Set();
+    if (leafId) {
+      const branch = sm.getBranch(leafId);
+      for (const entry of branch) {
+        activeIds.add(entry.id);
+      }
+    }
+    const nodes = [];
+    flattenTree(tree, leafId, activeIds, nodes, 0);
+    const body = { nodes, leafId };
+    return c.json(body);
+  } catch (err2) {
+    const message = err2 instanceof Error ? err2.message : String(err2);
+    console.error(`[api] tree for ${id} failed:`, err2);
+    return c.json({ ok: false, error: message }, 500);
+  }
+});
+function flattenTree(nodes, leafId, activeIds, out, depth) {
+  const sorted = [...nodes].sort(
+    (a, b) => new Date(a.entry.timestamp).getTime() - new Date(b.entry.timestamp).getTime()
+  );
+  for (const node of sorted) {
+    const entry = node.entry;
+    const id = entry.id;
+    out.push({
+      id,
+      parentId: entry.parentId,
+      depth,
+      entryType: mapEntryType(entry.type),
+      messageRole: entry.type === "message" ? mapMessageRole(entry["message"]) : void 0,
+      timestamp: entry.timestamp,
+      preview: extractPreview(entry),
+      active: activeIds.has(id),
+      isLeaf: id === leafId,
+      childCount: node.children.length,
+      label: node.label
+    });
+    if (node.children.length > 0) {
+      flattenTree(node.children, leafId, activeIds, out, depth + 1);
+    }
+  }
+}
+function mapEntryType(type) {
+  switch (type) {
+    case "message":
+      return "message";
+    case "compaction":
+      return "compaction";
+    case "branch_summary":
+      return "branch_summary";
+    case "model_change":
+      return "model_change";
+    case "thinking_level_change":
+      return "thinking_level_change";
+    case "custom":
+      return "custom";
+    case "custom_message":
+      return "custom_message";
+    case "label":
+      return "label";
+    case "session_info":
+      return "session_info";
+    default:
+      console.warn(`[tree] unknown entry type "${type}" \u2014 mapping to "custom". pi SDK may have added a type tree.ts doesn't handle yet.`);
+      return "custom";
+  }
+}
+function mapMessageRole(msg) {
+  if (!msg || typeof msg !== "object") return void 0;
+  const role = msg.role;
+  switch (role) {
+    case "user":
+      return "user";
+    case "assistant":
+      return "assistant";
+    case "toolResult":
+      return "toolResult";
+    case "bashExecution":
+      return "bashExecution";
+    case "custom":
+      return "custom";
+    case "branchSummary":
+      return "branchSummary";
+    case "compactionSummary":
+      return "compactionSummary";
+    default:
+      return void 0;
+  }
+}
+var PREVIEW_MAX = 120;
+function extractPreview(entry) {
+  switch (entry.type) {
+    case "message":
+      return extractMessagePreview(entry["message"]);
+    case "compaction":
+      return 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 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);
@@ -2202,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);
   }
 });
@@ -2220,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);
   }
 });
@@ -2245,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);
   }
 });
@@ -2260,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);
   }
 });
@@ -2303,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 dirname4, isAbsolute as isAbsolute4, join as join7, resolve as resolve4 } from "path";
-import { Hono as Hono2 } from "hono";
-var fsRoute = new Hono2();
+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";
@@ -2317,8 +2990,8 @@ 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);
   }
@@ -2336,13 +3009,13 @@ fsRoute.get("/browse", async (c) => {
 });
 
 // src/api/model-configs.ts
-import { readFile as readFile4, writeFile as writeFile4, mkdir as mkdir4 } from "fs/promises";
+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 Hono3 } from "hono";
+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);
@@ -2356,13 +3029,13 @@ function modelsPath() {
 }
 async function readModelsJson() {
   try {
-    const raw = await readFile4(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) {
@@ -2393,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);
   }
 });
@@ -2411,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);
   }
 });
@@ -2438,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);
   }
 });
@@ -2462,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);
   }
 });
@@ -2494,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);
   }
 });
@@ -2530,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);
   }
 });
@@ -2559,17 +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";
+var BACKGROUND_CAP = 4;
 var replacementLocks = /* @__PURE__ */ new Map();
 function withReplacementLock(workspaceId, fn) {
   const prev = replacementLocks.get(workspaceId) ?? Promise.resolve();
@@ -2586,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 {
@@ -2597,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 });
       }
     });
@@ -2611,124 +3285,162 @@ function attachWsHub(httpServer) {
 async function handle(ws, state, msg) {
   switch (msg.type) {
     case "subscribe": {
-      const hadCurrentSubscription = state.workspaceId === msg.workspaceId && !!state.unsubscribeSession;
-      ensureRebindListener(ws, state, msg.workspaceId);
-      await workspaceManager.getOrCreate(msg.workspaceId);
-      let switched = false;
-      let switchError;
-      if (msg.sessionPath) {
-        await withReplacementLock(msg.workspaceId, async () => {
-          try {
-            switched = await workspaceManager.switchSession(msg.workspaceId, msg.sessionPath);
-          } catch (err) {
-            switchError = err instanceof Error ? err.message : String(err);
-          }
-        });
-      }
-      if (!switched && !hadCurrentSubscription) {
-        bindCurrentSession(ws, state, msg.workspaceId);
-      }
-      if (switchError) {
-        send(ws, { type: "error", message: switchError, command: "subscribe" });
+      let runtime;
+      try {
+        runtime = await workspaceManager.getOrCreate(msg.workspaceId, msg.sessionPath);
+      } catch (err2) {
+        const message = err2 instanceof Error ? err2.message : String(err2);
+        send(ws, { type: "error", message, command: "subscribe" });
+        send(ws, { type: "ack", command: "subscribe" });
+        return;
       }
+      promoteToPrimary(ws, state, msg.workspaceId, runtime);
       send(ws, { type: "ack", command: "subscribe" });
       return;
     }
+    case "unsubscribe": {
+      for (const [key, bg] of [...state.background]) {
+        if (bg.workspaceId === msg.workspaceId) teardownBackground(state, key, ws);
+      }
+      return;
+    }
     case "prompt": {
-      const wsId = state.workspaceId;
-      if (!wsId) {
+      const primary = state.primary;
+      if (!primary) {
         send(ws, { type: "error", message: "not subscribed", command: "prompt" });
         return;
       }
-      if (replacementLocks.has(wsId)) {
+      if (replacementLocks.has(primary.workspaceId)) {
         send(ws, { type: "error", message: "session switching in progress", command: "prompt" });
         return;
       }
-      const runtime = workspaceManager.get(wsId);
-      if (!runtime) {
-        send(ws, { type: "error", message: "runtime gone", command: "prompt" });
-        return;
-      }
-      void runtime.session.prompt(msg.message, {
-        streamingBehavior: msg.streamingBehavior
-      }).catch((err) => {
-        const message = err instanceof Error ? err.message : String(err);
+      void primary.runtime.session.prompt(msg.message, { streamingBehavior: msg.streamingBehavior }).catch((err2) => {
+        const message = err2 instanceof Error ? err2.message : String(err2);
         send(ws, { type: "error", message, command: "prompt" });
       });
       return;
     }
     case "abort": {
-      const wsId = state.workspaceId;
-      if (!wsId) {
+      const primary = state.primary;
+      if (!primary) {
         send(ws, { type: "error", message: "not subscribed", command: "abort" });
         return;
       }
-      if (replacementLocks.has(wsId)) {
-        send(ws, { type: "error", message: "session switching in progress", command: "abort" });
-        return;
-      }
-      const runtime = workspaceManager.get(wsId);
-      if (!runtime) return;
-      await runtime.session.abort();
+      await primary.runtime.session.abort();
       return;
     }
     case "new_session": {
-      const wsId = state.workspaceId;
-      if (!wsId) {
-        send(ws, { type: "error", message: "not subscribed", command: "new_session" });
-        return;
-      }
-      await withReplacementLock(msg.workspaceId, async () => {
-        const runtime = workspaceManager.get(wsId);
-        if (!runtime) {
-          send(ws, { type: "error", message: "runtime gone", command: "new_session" });
-          return;
-        }
-        if (runtime.session.isStreaming) {
-          send(ws, { type: "error", message: "cannot create session while streaming", command: "new_session" });
+      const workspaceId = msg.workspaceId;
+      await withReplacementLock(workspaceId, async () => {
+        let runtime;
+        try {
+          runtime = await workspaceManager.createSession(workspaceId);
+        } catch (err2) {
+          const message = err2 instanceof Error ? err2.message : String(err2);
+          send(ws, { type: "error", message, command: "new_session" });
           return;
         }
-        const result = await runtime.newSession();
-        if (result.cancelled) {
-          send(ws, { type: "error", message: "new session cancelled", command: "new_session" });
-        }
+        promoteToPrimary(ws, state, workspaceId, runtime);
       });
       return;
     }
     case "fork": {
-      const wsId = state.workspaceId;
-      if (!wsId) {
+      const primary = state.primary;
+      if (!primary) {
         send(ws, { type: "error", message: "not subscribed", command: "fork" });
         return;
       }
-      await withReplacementLock(msg.workspaceId, async () => {
-        const runtime = workspaceManager.get(wsId);
-        if (!runtime) {
-          send(ws, { type: "error", message: "runtime gone", command: "fork" });
+      const workspaceId = primary.workspaceId;
+      await withReplacementLock(workspaceId, async () => {
+        const source = state.primary;
+        if (!source) {
+          send(ws, { type: "error", message: "not subscribed", command: "fork" });
           return;
         }
-        if (runtime.session.isStreaming) {
+        if (!source.sessionPath) {
+          send(ws, { type: "error", message: "cannot fork an unsaved session", command: "fork" });
+          return;
+        }
+        if (source.runtime.session.isStreaming) {
           send(ws, { type: "error", message: "cannot fork while streaming", command: "fork" });
           return;
         }
-        const result = await runtime.fork(msg.entryId);
-        if (result.cancelled) {
+        let result;
+        try {
+          result = await workspaceManager.fork(workspaceId, source.sessionPath, msg.entryId);
+        } catch (err2) {
+          const message = err2 instanceof Error ? err2.message : String(err2);
+          send(ws, { type: "error", message, command: "fork" });
+          return;
+        }
+        if (result.cancelled || !result.runtime) {
           send(ws, { type: "error", message: "fork cancelled", command: "fork" });
+          return;
         }
+        promoteToPrimary(ws, state, workspaceId, result.runtime);
       });
       return;
     }
     case "answer_question": {
-      const wsId = state.workspaceId;
-      if (!wsId) {
+      const primary = state.primary;
+      if (!primary) {
         send(ws, { type: "error", message: "not subscribed", command: "answer_question" });
         return;
       }
-      if (replacementLocks.has(wsId)) return;
-      const runtime = workspaceManager.get(wsId);
-      if (!runtime) return;
-      const activeFile = runtime.session.sessionFile ?? null;
-      resolveAnswer(msg.toolCallId, msg.answer, activeFile);
+      resolveAnswer(msg.toolCallId, msg.answer, primary.runtime.session.sessionFile ?? null);
+      return;
+    }
+    case "navigate_tree": {
+      const primary = state.primary;
+      if (!primary) {
+        send(ws, { type: "error", message: "not subscribed", command: "navigate_tree" });
+        return;
+      }
+      if (msg.workspaceId !== primary.workspaceId) {
+        send(ws, { type: "error", message: "workspace mismatch", command: "navigate_tree" });
+        return;
+      }
+      await withReplacementLock(primary.workspaceId, async () => {
+        const current = state.primary;
+        if (!current) {
+          send(ws, { type: "error", message: "not subscribed", command: "navigate_tree" });
+          return;
+        }
+        if (current.runtime.session.isStreaming) {
+          send(ws, { type: "error", message: "cannot navigate tree while streaming", command: "navigate_tree" });
+          return;
+        }
+        const result = await current.runtime.session.navigateTree(msg.targetId, {
+          summarize: msg.summarize,
+          customInstructions: msg.customInstructions
+        });
+        send(ws, {
+          type: "navigate_tree_result",
+          workspaceId: current.workspaceId,
+          editorText: result.editorText,
+          cancelled: result.cancelled
+        });
+      });
+      return;
+    }
+    case "compact": {
+      const primary = state.primary;
+      if (!primary) {
+        send(ws, { type: "error", message: "not subscribed", command: "compact" });
+        return;
+      }
+      if (primary.runtime.session.isStreaming) {
+        send(ws, { type: "error", message: "cannot compact while streaming", command: "compact" });
+        return;
+      }
+      if (primary.runtime.session.isCompacting) {
+        send(ws, { type: "error", message: "compaction already in progress", command: "compact" });
+        return;
+      }
+      primary.runtime.session.compact().catch((err2) => {
+        const message = err2 instanceof Error ? err2.message : String(err2);
+        send(ws, { type: "error", message, command: "compact" });
+      });
       return;
     }
     default: {
@@ -2738,28 +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") {
@@ -2768,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 = {
@@ -2781,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;
     }
@@ -2794,33 +3494,80 @@ function bindCurrentSession(ws, state, workspaceId) {
       sendContextUsage(ws, runtime, workspaceId, sessionPath);
     }
   });
-  send(ws, {
-    type: "subscribed",
-    workspaceId,
-    sessionPath,
-    sessionId: session.sessionId
-  });
-  const inFlight = inFlightAssistantSnapshot(runtime.session.state.streamingMessage);
+  state.primary = { runtimeKey, workspaceId, sessionPath, runtime, unsubscribe };
+  sendSubscribed(ws, workspaceId, runtime);
+  const streamingMessage = runtime.session.state.streamingMessage;
+  const scanMessages = streamingMessage ? [...runtime.session.messages, streamingMessage] : runtime.session.messages;
+  for (const payload of inFlightRunningToolsSnapshot(
+    runtime.session.state.pendingToolCalls,
+    scanMessages
+  )) {
+    send(ws, { type: "event", workspaceId, sessionPath, payload });
+  }
+  const inFlight = inFlightAssistantSnapshot(streamingMessage);
   if (inFlight) {
     for (const payload of inFlight) {
-      send(ws, {
-        type: "event",
-        workspaceId,
-        sessionPath,
-        payload
-      });
+      send(ws, { type: "event", workspaceId, sessionPath, payload });
     }
   }
   for (const payload of inFlightToolCallsSnapshot(sessionPath)) {
-    send(ws, {
-      type: "event",
-      workspaceId,
-      sessionPath,
-      payload
-    });
+    send(ws, { type: "event", workspaceId, sessionPath, payload });
   }
   sendContextUsage(ws, runtime, workspaceId, sessionPath);
 }
+function demotePrimaryToBackground(ws, state) {
+  const primary = state.primary;
+  if (!primary) return;
+  primary.unsubscribe();
+  state.primary = void 0;
+  const session = primary.runtime.session;
+  const sessionPath = primary.sessionPath;
+  const unsubscribeSession = session.subscribe((ev) => {
+    const payload = translatePiEvent(ev);
+    if (!payload) return;
+    send(ws, { type: "event", workspaceId: primary.workspaceId, sessionPath, payload });
+    if (payload.kind === "agent_end" || payload.kind === "compaction_end" || payload.kind === "session_info_changed" || payload.kind === "thinking_level_changed") {
+      sendContextUsage(ws, primary.runtime, primary.workspaceId, sessionPath);
+    }
+  });
+  state.background.set(primary.runtimeKey, {
+    workspaceId: primary.workspaceId,
+    sessionPath,
+    unsubscribeSession
+  });
+  while (state.background.size > BACKGROUND_CAP) {
+    const oldestKey = state.background.keys().next().value;
+    if (oldestKey === void 0) break;
+    const evicted = state.background.get(oldestKey);
+    teardownBackground(state, oldestKey, ws);
+    if (evicted) {
+      send(ws, {
+        type: "background_evicted",
+        workspaceId: evicted.workspaceId,
+        sessionPath: evicted.sessionPath
+      });
+    }
+  }
+}
+function teardownBackground(state, runtimeKey, ws) {
+  const bg = state.background.get(runtimeKey);
+  if (!bg) return;
+  bg.unsubscribeSession();
+  state.background.delete(runtimeKey);
+  if (ws) unrefWorkspaceSubscriber(state, bg.workspaceId, ws);
+}
+function sendSubscribed(ws, workspaceId, runtime) {
+  send(ws, {
+    type: "subscribed",
+    workspaceId,
+    sessionPath: runtime.session.sessionFile ?? null,
+    sessionId: runtime.session.sessionId
+  });
+}
+function unrefWorkspaceSubscriber(state, workspaceId, ws) {
+  const stillUsed = state.primary?.workspaceId === workspaceId || [...state.background.values()].some((b) => b.workspaceId === workspaceId);
+  if (!stillUsed) workspaceManager.removeSubscriber(workspaceId, ws);
+}
 function sendContextUsage(ws, runtime, workspaceId, sessionPath) {
   const usage = runtime.session.getContextUsage();
   if (!usage) return;
@@ -2830,22 +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;
@@ -2854,7 +3599,7 @@ function send(ws, msg) {
 
 // src/index.ts
 configureHttpProxy();
-var app = new Hono4();
+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");
@@ -2891,11 +3636,11 @@ function safeResolveWebPath(pathname) {
 }
 async function readWebFile(path) {
   try {
-    return await readFile5(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) {
@@ -2904,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 readFile5(webIndexPath);
+  const body = asset ?? await readFile6(webIndexPath);
   const filePath = asset ? assetPath : webIndexPath;
   const headers = {
     "Content-Type": mimeTypes[extname(filePath)] ?? "application/octet-stream",