@consultancy-outfit/ai-draftsman-cli 2.0.0 → 2.2.0

package/dist/index.js

@@ -50,7 +50,7 @@ function unreachableError(url, error) {
 }
 
 // src/lib/version.ts
-var VERSION = "2.0.0";
+var VERSION = "2.1.0";
 
 // src/lib/runtime.ts
 var state = {};
@@ -172,8 +172,8 @@ async function readCache(config2, maxAgeMs) {
   try {
     const file = JSON.parse(await readFile(cachePath(), "utf8"));
     if (file.baseUrl !== config2.baseUrl || file.keyTag !== keyTag(config2)) return void 0;
-    const age = Date.now() - file.fetchedAt;
-    if (age > maxAgeMs || file.info?.toolCalls === false && age > TOOLS_OFF_MAX_AGE_MS) return void 0;
+    const age2 = Date.now() - file.fetchedAt;
+    if (age2 > maxAgeMs || file.info?.toolCalls === false && age2 > TOOLS_OFF_MAX_AGE_MS) return void 0;
     return Array.isArray(file.info?.agents) ? file.info : void 0;
   } catch {
     return void 0;
@@ -609,11 +609,11 @@ var DeviceFlow = class {
       throw new CliError(`Sign-in failed (${res.status}): ${text2}`, 2);
     }
   }
-  post(path18, body, signal) {
+  post(path27, body, signal) {
     if (!isSafeUrl(`${this.base}/`)) {
       throw new CliError("baseUrl must use https (http is allowed for localhost only).", 3);
     }
-    return this.fetchImpl(this.base + path18, {
+    return this.fetchImpl(this.base + path27, {
       method: "POST",
       signal,
       headers: { "content-type": "application/json", accept: "application/json" },
@@ -772,10 +772,10 @@ async function resolveConfig(overrides = {}) {
 import { render } from "ink";
 
 // src/tui/App.tsx
-import { access, appendFile, readFile as readFile11 } from "fs/promises";
-import path15 from "path";
+import { access, appendFile, readFile as readFile15 } from "fs/promises";
+import path21 from "path";
 import { pathToFileURL } from "url";
-import { Box as Box7, Static, Text as Text7, useApp, useInput as useInput3, useStdout } from "ink";
+import { Box as Box8, Static, Text as Text8, useApp, useInput as useInput3, useStdout } from "ink";
 import { useCallback, useEffect as useEffect3, useMemo as useMemo4, useRef as useRef2, useState as useState4 } from "react";
 
 // src/agent/client.ts
@@ -1246,7 +1246,7 @@ async function saveInputHistory(entries) {
 }
 
 // src/agent/loop.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 
 // src/agent/tools/bash.ts
 import { spawn as spawn2, spawnSync } from "child_process";
@@ -1267,15 +1267,15 @@ function resolveReal(cwd, p) {
     try {
       return path6.join(realpathSync.native(current), ...tail);
     } catch {
-      const link = (() => {
+      const link2 = (() => {
         try {
           return lstatSync(current).isSymbolicLink() ? readlinkSync(current) : void 0;
         } catch {
           return void 0;
         }
       })();
-      if (link !== void 0) {
-        current = path6.resolve(path6.dirname(current), link);
+      if (link2 !== void 0) {
+        current = path6.resolve(path6.dirname(current), link2);
         continue;
       }
       const parent = path6.dirname(current);
@@ -1517,6 +1517,7 @@ function ruleKey(tool, args) {
     const a = args;
     return `connector:${a.connector}/${a.action}`;
   }
+  if (tool.kind === "browser") return `browser:${args.action}`;
   return tool.name;
 }
 function evaluate(tool, args, mode, rules, cwd) {
@@ -1540,6 +1541,14 @@ function evaluate(tool, args, mode, rules, cwd) {
     const key2 = ruleKey(tool, args);
     return rules.has(key2) ? { action: "allow" } : { action: "ask", key: key2 };
   }
+  if (tool.kind === "browser") {
+    if (mode === "plan") {
+      return { action: "deny", reason: "Plan mode is on, so browser actions are not allowed yet. Describe the browser steps in the plan, then call exit_plan_mode." };
+    }
+    if (mode === "bypass" || rules.grants(tool, args)) return { action: "allow" };
+    const key2 = ruleKey(tool, args);
+    return rules.has(key2) ? { action: "allow" } : { action: "ask", key: key2 };
+  }
   const target = tool.targetPath?.(args);
   const outside = target !== void 0 && !isInside(resolveReal(cwd, "."), resolveReal(cwd, target));
   if (tool.kind === "read") {
@@ -1673,9 +1682,10 @@ async function buildSystemPrompt(cwd, options) {
 // src/agent/tools/task.ts
 var SUBAGENT_TOOLS = {
   // read-only research: fast, cannot change anything
-  explore: (name) => ["read_file", "list_files", "grep", "web_fetch", "list_connectors"].includes(name),
+  // (message_agent / list_agents only work for a worker with a team; elsewhere they explain that they cannot)
+  explore: (name) => ["read_file", "list_files", "grep", "web_fetch", "list_connectors", "message_agent", "list_agents"].includes(name),
   // everything except starting more sub-agents, planning, and the shared todo list
-  general: (name) => !["task", "exit_plan_mode", "todo_write"].includes(name)
+  general: (name) => !["task", "exit_plan_mode", "todo_write", "spawn_agent", "list_sessions", "send_to_session"].includes(name)
 };
 var taskTool = {
   name: "task",
@@ -1856,9 +1866,9 @@ function parseBlock(raw, where) {
         })
       };
     case "callout": {
-      const tone = b.tone ?? "info";
-      if (!["info", "success", "warning", "danger"].includes(tone)) return fail(`${where}.tone`, "must be info, success, warning or danger.");
-      return { type: "callout", tone, title: text(b.title, `${where}.title`, true), text: text(b.text, `${where}.text`) };
+      const tone2 = b.tone ?? "info";
+      if (!["info", "success", "warning", "danger"].includes(tone2)) return fail(`${where}.tone`, "must be info, success, warning or danger.");
+      return { type: "callout", tone: tone2, title: text(b.title, `${where}.title`, true), text: text(b.text, `${where}.text`) };
     }
     case "code":
       return { type: "code", language: text(b.language, `${where}.language`, true), code: text(b.code, `${where}.code`) };
@@ -1990,8 +2000,8 @@ function renderBlock(block) {
     case "steps":
       return `<ol class="steps">${block.items.map((s) => `<li><div class="step-title">${inline(s.title)}</div>${s.text ? `<div class="step-text">${inline(s.text)}</div>` : ""}</li>`).join("")}</ol>`;
     case "callout": {
-      const tone = block.tone ?? "info";
-      return `<aside class="callout ${tone}" role="note"><span class="callout-icon" aria-hidden="true">${CALLOUT_ICON[tone]}</span><div>${block.title ? `<div class="callout-title">${inline(block.title)}</div>` : ""}<div class="callout-text">${inline(block.text)}</div></div></aside>`;
+      const tone2 = block.tone ?? "info";
+      return `<aside class="callout ${tone2}" role="note"><span class="callout-icon" aria-hidden="true">${CALLOUT_ICON[tone2]}</span><div>${block.title ? `<div class="callout-title">${inline(block.title)}</div>` : ""}<div class="callout-text">${inline(block.text)}</div></div></aside>`;
     }
     case "code":
       return `<figure class="code"><figcaption><span>${escapeHtml(block.language ?? "code")}</span><button type="button" class="copy" aria-label="Copy code">Copy</button></figcaption><pre><code>${escapeHtml(
@@ -2598,8 +2608,188 @@ var createArtifactTool = {
   }
 };
 
-// src/agent/tools/connectors.ts
+// src/lib/browser/client.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { readFile as readFile6 } from "fs/promises";
+import net from "net";
+
+// src/lib/browser/protocol.ts
+import { createHash as createHash2 } from "crypto";
+import path10 from "path";
+var HOST_NAME = "com.aidraftsman.browser";
+var BROWSER_ACTIONS = ["list_tabs", "navigate", "read_page", "click", "type"];
+var MAX_HOST_MESSAGE_BYTES = 1024 * 1024;
+var MAX_CLIENT_LINE_BYTES = 256 * 1024;
+function hostInfoPath() {
+  return path10.join(getConfigDir(), "browser", "host.json");
+}
+function defaultEndpoint() {
+  if (process.platform === "win32") {
+    const who = createHash2("sha256").update(getConfigDir()).digest("hex").slice(0, 12);
+    return "\\\\.\\pipe\\aidraftsman-browser-" + who;
+  }
+  return path10.join(getConfigDir(), "browser", "host.sock");
+}
+function encodeFrame(message) {
+  const body = Buffer.from(JSON.stringify(message), "utf8");
+  if (body.length > MAX_HOST_MESSAGE_BYTES) throw new Error(`Message to the browser is ${body.length} bytes; the limit is ${MAX_HOST_MESSAGE_BYTES}.`);
+  const header = Buffer.alloc(4);
+  header.writeUInt32LE(body.length, 0);
+  return Buffer.concat([header, body]);
+}
+var FrameDecoder = class {
+  constructor(maxBytes = 64 * 1024 * 1024) {
+    this.maxBytes = maxBytes;
+  }
+  maxBytes;
+  buffer = Buffer.alloc(0);
+  push(chunk) {
+    this.buffer = Buffer.concat([this.buffer, chunk]);
+    const out = [];
+    while (this.buffer.length >= 4) {
+      const length = this.buffer.readUInt32LE(0);
+      if (length > this.maxBytes) throw new Error(`Native message of ${length} bytes is over the ${this.maxBytes} byte limit.`);
+      if (this.buffer.length < 4 + length) break;
+      const body = this.buffer.subarray(4, 4 + length).toString("utf8");
+      this.buffer = this.buffer.subarray(4 + length);
+      out.push(JSON.parse(body));
+    }
+    return out;
+  }
+};
+function isBrowserAction(value) {
+  return typeof value === "string" && BROWSER_ACTIONS.includes(value);
+}
+
+// src/lib/browser/client.ts
+var NOT_RUNNING = "The AI Draftsman browser extension is not running. Install it with `ad browser install`, load it in Chrome (chrome://extensions \u2192 Load unpacked), and keep Chrome open.";
+async function readInfo(infoPath) {
+  try {
+    const info = JSON.parse(await readFile6(infoPath, "utf8"));
+    if (typeof info.endpoint !== "string" || typeof info.token !== "string") throw new Error("bad");
+    return info;
+  } catch {
+    throw new Error(NOT_RUNNING);
+  }
+}
+async function browserCall(action, args = {}, options = {}) {
+  if (options.signal?.aborted) throw new Error("Interrupted by the user.");
+  const info = await readInfo(options.infoPath ?? hostInfoPath());
+  return new Promise((resolve, reject) => {
+    const socket = net.connect(info.endpoint);
+    const authId = randomUUID2();
+    const callId = randomUUID2();
+    let buffer = "";
+    let done = false;
+    const finish = (error, value) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      options.signal?.removeEventListener("abort", onAbort);
+      socket.destroy();
+      if (error) reject(error);
+      else resolve(value);
+    };
+    const onAbort = () => finish(new Error("Interrupted by the user."));
+    const timer = setTimeout(() => finish(new Error("Timed out talking to the browser bridge.")), options.timeoutMs ?? 4e4);
+    options.signal?.addEventListener("abort", onAbort, { once: true });
+    socket.setEncoding("utf8");
+    socket.on("connect", () => socket.write(`${JSON.stringify({ id: authId, token: info.token })}
+`));
+    socket.on("error", () => finish(new Error(NOT_RUNNING)));
+    socket.on("close", () => finish(new Error("The browser bridge closed the connection.")));
+    socket.on("data", (chunk) => {
+      buffer += chunk;
+      let nl;
+      while ((nl = buffer.indexOf("\n")) >= 0) {
+        const line = buffer.slice(0, nl);
+        buffer = buffer.slice(nl + 1);
+        const response = JSON.parse(line);
+        if (response.id === authId) {
+          if (!response.ok) return finish(new Error(response.error));
+          socket.write(`${JSON.stringify({ id: callId, action, args })}
+`);
+        } else if (response.id === callId) {
+          if (response.ok) finish(void 0, response.result);
+          else finish(new Error(response.error));
+        }
+      }
+    });
+  });
+}
+
+// src/agent/tools/browser.ts
 var MAX_OUTPUT_CHARS = 3e4;
+var browserTool = {
+  name: "browser",
+  description: "Control the user's Chrome through the AI Draftsman extension (their real browser, already signed in). Actions: list_tabs; navigate {url, tab_id?} (omit tab_id to open a new tab); read_page {tab_id?} returns the page text and a numbered list of interactive elements; click {ref, tab_id?}; type {ref, text, submit?, tab_id?}. Refs come from the latest read_page of that tab: read the page again after anything that changes it. Never put passwords or payment details into a page.",
+  kind: "browser",
+  parameters: {
+    type: "object",
+    properties: {
+      action: { type: "string", enum: [...BROWSER_ACTIONS], description: "What to do." },
+      tab_id: { type: "number", description: "Tab from list_tabs. Default: the active tab." },
+      url: { type: "string", description: "For navigate: an http(s) URL." },
+      ref: { type: "number", description: "For click/type: the [number] of an element from read_page." },
+      text: { type: "string", description: "For type: the text to enter." },
+      submit: { type: "boolean", description: "For type: press Enter afterwards." }
+    },
+    required: ["action"]
+  },
+  parse: (raw) => {
+    const action = str(raw, "action");
+    if (!BROWSER_ACTIONS.includes(action)) {
+      throw new Error(`Unknown action "${action}". Use one of: ${BROWSER_ACTIONS.join(", ")}.`);
+    }
+    const args = { action };
+    const tab = num(raw, "tab_id");
+    if (tab !== void 0) args.tab_id = tab;
+    if (action === "navigate") {
+      const url = str(raw, "url").trim();
+      let parsed;
+      try {
+        parsed = new URL(url);
+      } catch {
+        throw new Error("navigate needs a full URL such as https://example.com.");
+      }
+      if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new Error("navigate only opens http and https URLs.");
+      args.url = parsed.toString();
+    }
+    if (action === "click" || action === "type") {
+      const ref = num(raw, "ref");
+      if (ref === void 0 || !Number.isInteger(ref) || ref < 0) throw new Error("ref must be the [number] of an element from read_page.");
+      args.ref = ref;
+    }
+    if (action === "type") {
+      args.text = str(raw, "text");
+      args.submit = raw.submit === true;
+    }
+    return args;
+  },
+  label: (args) => {
+    switch (args.action) {
+      case "navigate":
+        return `open ${args.url}`;
+      case "click":
+        return `click [${args.ref}]`;
+      case "type":
+        return `type into [${args.ref}]`;
+      case "read_page":
+        return "read page";
+      default:
+        return "list tabs";
+    }
+  },
+  async run(args, ctx) {
+    const { action, ...rest } = args;
+    const result = await browserCall(action, rest, { signal: ctx.signal });
+    const text2 = typeof result === "string" ? result : JSON.stringify(result, null, 2);
+    return { output: truncate(text2, MAX_OUTPUT_CHARS) };
+  }
+};
+
+// src/agent/tools/connectors.ts
+var MAX_OUTPUT_CHARS2 = 3e4;
 var configPromise;
 function config() {
   configPromise ??= resolveConfig();
@@ -2615,7 +2805,7 @@ async function call(name, args, signal) {
   const result = await callMcpTool(await config(), name, args);
   const text2 = textOf(result);
   if (result.isError) throw new Error(text2 || `${name} failed.`);
-  return truncate(text2, MAX_OUTPUT_CHARS);
+  return truncate(text2, MAX_OUTPUT_CHARS2);
 }
 var listConnectorsTool = {
   name: "list_connectors",
@@ -2679,16 +2869,16 @@ var callConnectorTool = {
 };
 
 // src/agent/tools/edit-file.ts
-import { readFile as readFile7, writeFile as writeFile6 } from "fs/promises";
+import { readFile as readFile8, writeFile as writeFile6 } from "fs/promises";
 
 // src/agent/tools/write-file.ts
-import { mkdir as mkdir5, readFile as readFile6, stat, writeFile as writeFile5 } from "fs/promises";
-import path10 from "path";
+import { mkdir as mkdir5, readFile as readFile7, stat, writeFile as writeFile5 } from "fs/promises";
+import path11 from "path";
 import { createTwoFilesPatch } from "diff";
 async function existing(file) {
   try {
     await stat(file);
-    return await readFile6(file, "utf8");
+    return await readFile7(file, "utf8");
   } catch {
     return void 0;
   }
@@ -2730,7 +2920,7 @@ var writeFileTool = {
     if (before !== void 0 && !ctx.readFiles.has(file)) {
       throw new Error(`${args.path} already exists. Read it with read_file before overwriting it.`);
     }
-    await mkdir5(path10.dirname(file), { recursive: true });
+    await mkdir5(path11.dirname(file), { recursive: true });
     await writeFile5(file, args.content, "utf8");
     ctx.readFiles.add(file);
     const display = buildDiff(ctx.cwd, file, before ?? "", args.content);
@@ -2765,7 +2955,7 @@ function plan(content, args) {
 }
 async function preview2(args, ctx) {
   const file = resolveInCwd(ctx.cwd, args.path);
-  const content = await readFile7(file, "utf8");
+  const content = await readFile8(file, "utf8");
   return buildDiff(ctx.cwd, file, content, plan(content, args).updated);
 }
 var editFileTool = {
@@ -2798,7 +2988,7 @@ var editFileTool = {
     }
     let content;
     try {
-      content = await readFile7(file, "utf8");
+      content = await readFile8(file, "utf8");
     } catch {
       throw new Error(`File not found: ${args.path}`);
     }
@@ -2812,7 +3002,7 @@ var editFileTool = {
 };
 
 // src/agent/tools/read-file.ts
-import { readFile as readFile8, stat as stat2 } from "fs/promises";
+import { readFile as readFile9, stat as stat2 } from "fs/promises";
 var MAX_LINES = 800;
 var MAX_BYTES = 512 * 1024;
 var readFileTool = {
@@ -2844,7 +3034,7 @@ var readFileTool = {
     if (info.size > MAX_BYTES && args.offset === void 0 && args.limit === void 0) {
       throw new Error(`File is ${Math.round(info.size / 1024)} KB. Pass offset and limit to read part of it.`);
     }
-    const buffer = await readFile8(file);
+    const buffer = await readFile9(file);
     if (looksBinary(buffer)) throw new Error(`${args.path} looks like a binary file.`);
     const lines = buffer.toString("utf8").split(/\r?\n/);
     const start = Math.max(1, Math.floor(args.offset ?? 1));
@@ -2862,7 +3052,7 @@ var readFileTool = {
 
 // src/agent/tools/search.ts
 import { stat as stat3 } from "fs/promises";
-import path11 from "path";
+import path12 from "path";
 import { Worker } from "worker_threads";
 import { glob } from "tinyglobby";
 var MAX_FILES = 150;
@@ -2870,14 +3060,14 @@ var MAX_MATCHES = 120;
 var MAX_FILE_BYTES = 1024 * 1024;
 var GREP_TIMEOUT_MS = 1e4;
 function checkGlob(pattern) {
-  if (/(^|[\\/])\.\.([\\/]|$)/.test(pattern) || path11.isAbsolute(pattern) || /^[\\/]/.test(pattern)) {
+  if (/(^|[\\/])\.\.([\\/]|$)/.test(pattern) || path12.isAbsolute(pattern) || /^[\\/]/.test(pattern)) {
     throw new Error("The glob must stay inside the search path. To search elsewhere, pass that directory as path instead.");
   }
 }
 async function globInside(pattern, root) {
   checkGlob(pattern);
   const files = await glob(pattern, { cwd: root, ignore: IGNORED_DIRS, onlyFiles: true, deep: 12, followSymbolicLinks: false });
-  return files.filter((f) => isInside(root, path11.resolve(root, f)));
+  return files.filter((f) => isInside(root, path12.resolve(root, f)));
 }
 var GREP_WORKER = `
 const { parentPort, workerData } = require('node:worker_threads');
@@ -2950,10 +3140,10 @@ var listFilesTool = {
     const files = await globInside(args.pattern, root);
     if (files.length === 0) return { output: "No files matched." };
     const withTimes = await Promise.all(
-      files.slice(0, 2e3).map(async (f) => ({ f, t: (await stat3(path11.join(root, f)).catch(() => void 0))?.mtimeMs ?? 0 }))
+      files.slice(0, 2e3).map(async (f) => ({ f, t: (await stat3(path12.join(root, f)).catch(() => void 0))?.mtimeMs ?? 0 }))
     );
     withTimes.sort((a, b) => b.t - a.t);
-    const shown = withTimes.slice(0, MAX_FILES).map((x) => displayPath(ctx.cwd, path11.join(root, x.f)));
+    const shown = withTimes.slice(0, MAX_FILES).map((x) => displayPath(ctx.cwd, path12.join(root, x.f)));
     const extra = files.length > MAX_FILES ? `
 \u2026 ${files.length - MAX_FILES} more. Narrow the pattern.` : "";
     return { output: shown.join("\n") + extra, display: { kind: "text", summary: `Found ${files.length} file${files.length === 1 ? "" : "s"}` } };
@@ -2991,7 +3181,7 @@ var grepTool = {
     const target = resolveInCwd(ctx.cwd, args.path ?? ".");
     const info = await stat3(target).catch(() => void 0);
     if (!info) throw new Error(`Path not found: ${args.path}`);
-    const files = info.isFile() ? [target] : (await globInside(args.glob ?? "**/*", target)).map((f) => path11.join(target, f));
+    const files = info.isFile() ? [target] : (await globInside(args.glob ?? "**/*", target)).map((f) => path12.join(target, f));
     const { results: hits, total } = await searchFiles(files, args.pattern, args.case_insensitive ? "i" : "", { signal: ctx.signal });
     const results = hits.map((h) => `${displayPath(ctx.cwd, h.file)}:${h.line}:${h.text}`);
     if (total === 0) return { output: "No matches." };
@@ -3001,6 +3191,121 @@ var grepTool = {
   }
 };
 
+// src/agent/tools/sessions.ts
+var NO_LINK = "Messaging other sessions is not available here (this is not an interactive session). Report your findings in your answer instead.";
+function link(ctx) {
+  if (!ctx.sessions) throw new Error(NO_LINK);
+  return ctx.sessions;
+}
+var listSessionsTool = {
+  name: "list_sessions",
+  description: "List the other AI Draftsman sessions running on this machine right now (their id, title, folder and agent), so you can pass something to one of them with send_to_session.",
+  kind: "meta",
+  parameters: { type: "object", properties: {} },
+  parse: () => ({}),
+  label: () => "sessions",
+  async run(_args, ctx) {
+    const output = await link(ctx).list();
+    return { output, display: { kind: "text", summary: "Listed running sessions" } };
+  }
+};
+var sendToSessionTool = {
+  name: "send_to_session",
+  description: "Send a message to another running AI Draftsman session on this machine (by id or title from list_sessions): a decision, a finding, or a question. The other session does not act on it by itself: its user sees it, and it reaches that session's agent with their next prompt. Keep it short and self-contained (the other session cannot see this conversation), and only send things the user would want shared: never secrets or credentials.",
+  kind: "meta",
+  parameters: {
+    type: "object",
+    properties: {
+      to: { type: "string", description: "Session id (or a unique prefix of it) or a unique part of its title." },
+      message: { type: "string", description: "What to tell it." }
+    },
+    required: ["to", "message"]
+  },
+  parse: (raw) => {
+    const message = str(raw, "message");
+    if (!message.trim()) throw new Error("message is empty.");
+    const to = str(raw, "to").trim();
+    if (!to) throw new Error("to is empty: give a session id or title (see list_sessions).");
+    return { to, message };
+  },
+  label: (args) => `\u2192 ${args.to}`,
+  async run(args, ctx) {
+    const output = await link(ctx).send(args.to, args.message);
+    return { output, display: { kind: "text", summary: output } };
+  }
+};
+
+// src/agent/tools/team.ts
+var NO_TEAM = "There is no agent team in this session (it is not running interactively). Do the work yourself instead.";
+function team(ctx) {
+  if (!ctx.team) throw new Error(NO_TEAM);
+  return ctx.team;
+}
+var spawnAgentTool = {
+  name: "spawn_agent",
+  description: "Start a worker agent in the background and return immediately. Use it for long or independent jobs you want to run in parallel with other workers (for example a researcher, an implementer and a reviewer working on one task together). Workers cannot see this conversation: put everything they need in the prompt, and tell them which teammates exist so they can coordinate with message_agent. Prefer `task` when you need the answer before you can continue.",
+  kind: "meta",
+  parameters: {
+    type: "object",
+    properties: {
+      description: { type: "string", description: "3-6 word label shown in the workers list." },
+      prompt: { type: "string", description: "Full instructions, and what to report when finished." },
+      subagent_type: { type: "string", enum: ["explore", "general"], description: '"explore" is read-only; "general" can also edit and run commands. Default "general".' },
+      name: { type: "string", description: 'Short unique name teammates use to address this worker, e.g. "researcher". Optional.' }
+    },
+    required: ["description", "prompt"]
+  },
+  parse: (raw) => {
+    const type = raw?.subagent_type ?? "general";
+    if (type !== "explore" && type !== "general") throw new Error('subagent_type must be "explore" or "general".');
+    const prompt = str(raw, "prompt");
+    if (!prompt.trim()) throw new Error("prompt is empty.");
+    return { description: str(raw, "description"), prompt, subagent_type: type, name: str(raw, "name", true)?.trim() || void 0 };
+  },
+  label: (args) => args.description,
+  async run(args, ctx) {
+    const t = team(ctx);
+    if (!t.spawn) throw new Error("Workers cannot start other workers. Message the lead agent if you need more help.");
+    const output = t.spawn({ description: args.description, prompt: args.prompt, type: args.subagent_type, name: args.name });
+    return { output, display: { kind: "text", summary: output.split("\n")[0] } };
+  }
+};
+var messageAgentTool = {
+  name: "message_agent",
+  description: `Send a message to a teammate: a worker by name or id, or "main" for the lead agent the user is talking to. It is delivered before the recipient's next step (a finished worker wakes up to handle it). Use it to hand over results, ask a question or ask for a review. Keep it short and self-contained; it does not wait for a reply.`,
+  kind: "meta",
+  parameters: {
+    type: "object",
+    properties: {
+      to: { type: "string", description: 'Worker name or id, or "main".' },
+      message: { type: "string", description: "What to tell them." }
+    },
+    required: ["to", "message"]
+  },
+  parse: (raw) => {
+    const message = str(raw, "message");
+    if (!message.trim()) throw new Error("message is empty.");
+    return { to: str(raw, "to").trim(), message };
+  },
+  label: (args) => `\u2192 ${args.to}`,
+  async run(args, ctx) {
+    const output = team(ctx).send(args.to, args.message);
+    return { output, display: { kind: "text", summary: output } };
+  }
+};
+var listAgentsTool = {
+  name: "list_agents",
+  description: "List the agents on this team (the lead and every worker) with each one's status and what it is doing.",
+  kind: "meta",
+  parameters: { type: "object", properties: {} },
+  parse: () => ({}),
+  label: () => "team",
+  async run(_args, ctx) {
+    const output = team(ctx).list();
+    return { output, display: { kind: "text", summary: "Listed the team" } };
+  }
+};
+
 // src/agent/tools/todo.ts
 var todoWriteTool = {
   name: "todo_write",
@@ -3240,12 +3545,20 @@ var ALL_TOOLS = [
   createArtifactTool,
   bashTool,
   webFetchTool,
+  browserTool,
   listConnectorsTool,
   callConnectorTool,
   taskTool,
+  spawnAgentTool,
+  messageAgentTool,
+  listAgentsTool,
+  listSessionsTool,
+  sendToSessionTool,
   todoWriteTool,
   exitPlanModeTool
 ];
+var TEAM_TOOLS = /* @__PURE__ */ new Set(["spawn_agent", "message_agent", "list_agents"]);
+var SESSION_TOOLS = /* @__PURE__ */ new Set(["list_sessions", "send_to_session"]);
 function findTool(name) {
   return ALL_TOOLS.find((t) => t.name === name);
 }
@@ -3267,6 +3580,8 @@ function toolDefs(allow) {
 function sessionToolFilter(profile) {
   return (name) => {
     if (name === "create_artifact") return profile.artifacts;
+    if (TEAM_TOOLS.has(name)) return profile.orchestration === true;
+    if (SESSION_TOOLS.has(name)) return profile.sessions === true;
     if (name === "exit_plan_mode") return profile.planMode !== false;
     return true;
   };
@@ -3332,6 +3647,11 @@ async function attemptSubagent(options, request, callId, model, named, progress)
     maxSteps: options.subagentMaxSteps ?? DEFAULT_SUBAGENT_MAX_STEPS,
     // A sub-agent stops at its limit and reports; only the person at the main prompt is asked to go on.
     confirmContinue: void 0,
+    // A `task` sub-agent is not a teammate: it neither speaks for the lead nor reads its mail.
+    team: void 0,
+    drainInbox: void 0,
+    // And it does not speak for the session to other sessions.
+    sessions: void 0,
     // Its own run, linked to the turn that started it.
     runId: void 0,
     parentRunId: options.runId,
@@ -3412,13 +3732,15 @@ async function runAgentTurn(options) {
   const maxSteps = options.maxSteps ?? DEFAULT_MAX_STEPS;
   const verify = verifyWatcher(options.onEvent);
   const onEvent = verify.watch;
-  const runId = options.runId ?? randomUUID2();
+  const runId = options.runId ?? randomUUID3();
   options = { ...options, onEvent, runId };
   const subagentSlot = concurrencyLimit(options.maxParallel ?? DEFAULT_MAX_PARALLEL_SUBAGENTS);
   const canVerify = (options.depth ?? 0) === 0 && options.tools !== false && (!options.toolFilter || options.toolFilter("bash"));
   const ctx = {
     cwd: options.cwd,
     signal,
+    ...options.team ? { team: options.team } : {},
+    ...options.sessions ? { sessions: options.sessions } : {},
     readFiles: options.readFiles,
     setTodos: (todos) => onEvent({ type: "todos", todos }),
     setMode: options.setMode,
@@ -3433,6 +3755,8 @@ async function runAgentTurn(options) {
       if (signal?.aborted) throw new CliError("Interrupted.", 130);
       limit += maxSteps;
     }
+    const mail = options.drainInbox?.();
+    if (mail?.length) history.push(...mail);
     const send = (extra = []) => streamChat(
       options.config,
       {
@@ -3488,8 +3812,8 @@ async function runAgentTurn(options) {
         let end = index;
         while (end < calls.length && isParallel(calls[end])) end++;
         const batch = calls.slice(index, end);
-        const run = (call2) => executeCall(call2, { ...ctx, callId: call2.id }, options);
-        history.push(...await Promise.all(batch.map((call2) => call2.function.name === "task" ? subagentSlot(() => run(call2)) : run(call2))));
+        const run2 = (call2) => executeCall(call2, { ...ctx, callId: call2.id }, options);
+        history.push(...await Promise.all(batch.map((call2) => call2.function.name === "task" ? subagentSlot(() => run2(call2)) : run2(call2))));
         index = end;
       } else {
         history.push(await executeCall(calls[index], { ...ctx, callId: calls[index].id }, options));
@@ -3553,137 +3877,1461 @@ async function executeCall(call2, ctx, options) {
     if (decision === "allow_always") options.rules.add(verdict.key || ruleKey(tool, args));
   }
   try {
-    const result = await tool.run(args, ctx);
+    if (options.checkpoint && tool.kind === "write" && tool.targetPath) {
+      const target = tool.targetPath(args);
+      if (target) await options.checkpoint(resolveInCwd(ctx.cwd, target)).catch(() => void 0);
+    }
+    const result = options.shellTracker && tool.kind === "exec" ? await options.shellTracker(ctx.cwd, () => tool.run(args, ctx)) : await tool.run(args, ctx);
     return reply(result.output, false, result.display);
   } catch (error) {
     return reply(error.message, true);
   }
 }
 
-// src/lib/diagnostics.ts
-async function probeServer(config2, fetchImpl = fetch) {
-  if (!config2.baseUrl) return {};
-  const started = Date.now();
+// src/agent/checkpoints.ts
+import { mkdir as mkdir6, readFile as readFile10, realpath, rm as rm3, stat as stat5, writeFile as writeFile7 } from "fs/promises";
+import path14 from "path";
+
+// src/agent/tree-snapshot.ts
+import { execFile } from "child_process";
+import { copyFile, mkdtemp, rm as rm2, rmdir, stat as stat4 } from "fs/promises";
+import os4 from "os";
+import path13 from "path";
+var GIT_TIMEOUT_MS = 2e4;
+var NO_EOL_CONVERSION = ["-c", "core.autocrlf=false", "-c", "core.safecrlf=false"];
+var EMPTY_TREE = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
+var attrSource;
+function supportsAttrSource(root) {
+  attrSource ??= git(root, [`--attr-source=${EMPTY_TREE}`, "rev-parse", "--git-dir"]).then(
+    () => true,
+    () => false
+  );
+  return attrSource;
+}
+async function exactBytes(root) {
+  return [...NO_EOL_CONVERSION, ...await supportsAttrSource(root) ? [`--attr-source=${EMPTY_TREE}`] : []];
+}
+var seedable = /* @__PURE__ */ new Map();
+async function canSeed(root) {
+  const known = seedable.get(root);
+  if (known !== void 0) return known;
+  let ok = true;
+  const config2 = async (key) => (await git(root, ["config", "--get", key]).catch(() => Buffer.alloc(0))).toString("utf8").trim().toLowerCase();
+  const autocrlf = await config2("core.autocrlf");
+  if (autocrlf === "true" || autocrlf === "input") ok = false;
+  if (ok && await config2("core.attributesfile")) ok = false;
+  if (ok) {
+    const attrs = await git(root, ["ls-files", "-z", "--cached", "--others", "--exclude-standard", "--", ":(glob)**/.gitattributes"]).catch(() => Buffer.alloc(0));
+    const gitDir = (await git(root, ["rev-parse", "--git-dir"]).catch(() => Buffer.alloc(0))).toString("utf8").trim();
+    const info = gitDir ? await stat4(path13.resolve(root, gitDir, "info", "attributes")).then(() => true, () => false) : false;
+    if (attrs.length > 0 || info) ok = false;
+  }
+  seedable.set(root, ok);
+  return ok;
+}
+function git(cwd, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = execFile(
+      "git",
+      args,
+      { cwd, env: { ...process.env, ...options.env }, encoding: "buffer", maxBuffer: 64 * 1024 * 1024, timeout: GIT_TIMEOUT_MS, windowsHide: true },
+      (error, stdout) => error ? reject(error) : resolve(stdout)
+    );
+    child.stdin?.on("error", () => void 0);
+    child.stdin?.end(options.input);
+  });
+}
+async function repoRoot(cwd) {
   try {
-    const res = await fetchImpl(new URL("/v1/models", config2.baseUrl), {
-      headers: { accept: "application/json", ...clientHeaders(), ...config2.apiKey ? { authorization: `Bearer ${config2.apiKey}` } : {} },
-      signal: AbortSignal.timeout(1e4)
-    });
-    await res.body?.cancel().catch(() => void 0);
-    const served = servedBy(res.headers);
-    return { status: res.status, ms: Date.now() - started, ...served ? { served } : {} };
+    const out = (await git(cwd, ["rev-parse", "--show-toplevel"])).toString("utf8").trim();
+    return out ? path13.resolve(out) : void 0;
   } catch {
-    return {};
+    return void 0;
   }
 }
-
-// src/tui/commands.ts
-import { readdir as readdir3, readFile as readFile9 } from "fs/promises";
-import path12 from "path";
-var INIT_PROMPT = `Analyze this codebase and create an AD.md file in the project root. It is read at the start of every session, so keep it short and useful. Include:
-- the commands to build, run, lint and test (check package.json, Makefile, etc.),
-- the high-level architecture and the directories that matter,
-- conventions that differ from the defaults.
-Do not invent anything: read the code first. If AD.md already exists, improve it instead of replacing it.`;
-function builtinCommands() {
-  return [
-    {
-      name: "help",
-      description: "Show commands and shortcuts",
-      run: (ctx) => {
-        const lines = ["Commands:"];
-        for (const c of ctx.allCommands()) lines.push(`  /${(c.name + (c.args ? ` ${c.args}` : "")).padEnd(22)}${c.description}`);
-        lines.push("", "Shortcuts:", "  @file  mention a file (or @app: one of your connected connectors) \xB7 !cmd  run a shell command \xB7 #note  save a note to AD.md", "  shift+tab  cycle permission mode \xB7 esc  interrupt \xB7 ctrl+j  new line");
-        ctx.info(lines.join("\n"));
-      }
-    },
-    { name: "agents", description: "Switch the agent", aliases: ["agent"], run: (ctx) => ctx.pickAgent() },
-    {
-      name: "model",
-      description: "Use a specific model instead of an agent",
-      args: "<model>",
-      run: (ctx, args) => args.trim() ? ctx.setModel(args.trim()) : ctx.pickAgent()
-    },
-    { name: "clear", description: "Start a new conversation", aliases: ["new", "reset"], run: (ctx) => ctx.clear() },
-    {
-      name: "compact",
-      description: "Summarize the conversation to free up context",
-      args: "[focus]",
-      run: (ctx, args) => ctx.compact(args.trim() || void 0)
-    },
-    { name: "resume", description: "Resume an earlier conversation", aliases: ["continue"], run: (ctx) => ctx.pickSession() },
-    { name: "plan", description: "Plan first: research without changing anything", run: (ctx) => ctx.setMode("plan") },
-    {
-      name: "open",
-      description: "Open the last artifact (or a .html file) in your browser",
-      args: "[file]",
-      run: (ctx, args) => ctx.openFile(args.trim() || void 0)
-    },
-    { name: "init", description: "Create an AD.md with project instructions", run: (ctx) => ctx.send(INIT_PROMPT, "/init") },
-    { name: "status", description: "Show account, agent and session details", run: (ctx) => ctx.info(ctx.describeStatus().join("\n")) },
-    { name: "usage", description: "Show token usage for this session", aliases: ["cost"], run: (ctx) => ctx.info(ctx.describeUsage().join("\n")) },
-    {
-      name: "permissions",
-      description: "Show the permission mode and what is allowed",
-      run: (ctx) => ctx.info(ctx.describePermissions().join("\n"))
-    },
-    {
-      name: "doctor",
-      description: "Check the connection and your setup",
-      run: async (ctx) => ctx.info((await ctx.doctor()).join("\n"))
-    },
-    { name: "login", description: "Sign in again or switch account", run: (ctx) => ctx.exit("login") },
-    { name: "logout", description: "Sign out", run: (ctx) => ctx.exit("logout") },
-    { name: "exit", description: "Quit", aliases: ["quit"], run: (ctx) => ctx.exit("exit") }
-  ];
+async function withTempIndex(root, seed, use) {
+  const dir = await mkdtemp(path13.join(os4.tmpdir(), "ad-index-"));
+  const index = path13.join(dir, "index");
+  try {
+    if (seed) {
+      const real = (await git(root, ["rev-parse", "--git-path", "index"])).toString("utf8").trim();
+      await copyFile(path13.resolve(root, real), index).catch(() => void 0);
+    }
+    return await use({ GIT_INDEX_FILE: index });
+  } finally {
+    await rm2(dir, { recursive: true, force: true }).catch(() => void 0);
+  }
 }
-function parseFrontmatter(raw) {
-  const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/.exec(raw);
-  if (!match) return { body: raw };
-  const description = /^description:\s*(.+)$/m.exec(match[1])?.[1]?.trim();
-  return { description, body: match[2] };
+async function snapshotTree(root) {
+  const exact = await exactBytes(root);
+  return withTempIndex(root, await canSeed(root), async (env) => {
+    await git(root, ["-c", "gc.auto=0", ...exact, "add", "-A", "--", "."], { env });
+    return (await git(root, ["write-tree"], { env })).toString("utf8").trim();
+  });
 }
-async function readCommandDir(dir, source) {
-  let names;
+async function changedBetween(root, before, after) {
+  const out = (await git(root, ["diff-tree", "-r", "--name-status", "--no-renames", "-z", before, after])).toString("utf8");
+  const parts = out.split("\0").filter((p) => p !== "");
+  const changes = [];
+  for (let i = 0; i + 1 < parts.length; i += 2) {
+    const status = parts[i];
+    if (status === "A" || status === "M" || status === "D") changes.push({ path: parts[i + 1], status });
+  }
+  return changes;
+}
+async function pruneEmptyDirs(root, file) {
+  let dir = path13.dirname(file);
+  while (dir.length > root.length && dir.startsWith(root)) {
+    try {
+      await rmdir(dir);
+    } catch {
+      return;
+    }
+    dir = path13.dirname(dir);
+  }
+}
+async function restoreFromTree(root, tree, wanted) {
+  const report = { restored: [], deleted: [], failed: [] };
+  const changes = wanted.filter((c) => {
+    const rel = path13.relative(root, path13.resolve(root, c.path));
+    const inside = rel !== "" && !rel.startsWith("..") && !path13.isAbsolute(rel);
+    if (!inside) report.failed.push({ file: c.path, reason: "outside the repository" });
+    return inside;
+  });
+  for (const change of changes.filter((c) => c.status === "A")) {
+    const file = path13.resolve(root, change.path);
+    try {
+      await rm2(file, { force: true });
+      await pruneEmptyDirs(root, file);
+      report.deleted.push(file);
+    } catch (error) {
+      report.failed.push({ file, reason: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  const back = changes.filter((c) => c.status !== "A");
+  if (back.length === 0) return report;
+  try {
+    const exact = await exactBytes(root);
+    await withTempIndex(root, false, async (env) => {
+      await git(root, ["read-tree", tree], { env });
+      await git(root, [...exact, "checkout-index", "-f", "-z", "--stdin"], { env, input: back.map((c) => c.path).join("\0") + "\0" });
+    });
+    for (const change of back) report.restored.push(path13.resolve(root, change.path));
+  } catch (error) {
+    const reason = error instanceof Error ? error.message.split("\n")[0] : String(error);
+    for (const change of back) report.failed.push({ file: path13.resolve(root, change.path), reason });
+  }
+  return report;
+}
+
+// src/agent/checkpoints.ts
+var MAX_SNAPSHOT_BYTES = 5 * 1024 * 1024;
+var SLOW_SNAPSHOT_MS = 8e3;
+var MAX_SNAPSHOT_FAILURES = 3;
+async function canonical(file) {
+  const abs = path14.resolve(file);
   try {
-    names = await readdir3(dir);
+    return await realpath(abs);
   } catch {
-    return [];
   }
-  const out = [];
-  for (const file of names.filter((n) => n.endsWith(".md"))) {
-    const name = file.slice(0, -3).toLowerCase().replace(/[^a-z0-9_-]/g, "-");
+  let dir = abs;
+  const rest = [];
+  for (; ; ) {
+    const parent = path14.dirname(dir);
+    rest.unshift(path14.basename(dir));
+    if (parent === dir) return abs;
     try {
-      const { description, body } = parseFrontmatter(await readFile9(path12.join(dir, file), "utf8"));
-      if (!body.trim()) continue;
-      out.push({
-        name,
-        source,
-        args: /\$ARGUMENTS/.test(body) ? "[arguments]" : void 0,
-        description: description ?? body.trim().split("\n")[0].slice(0, 70),
-        run: (ctx, args) => {
-          const prompt = /\$ARGUMENTS/.test(body) ? body.replace(/\$ARGUMENTS/g, args) : args ? `${body}
-
-${args}` : body;
-          ctx.send(prompt.trim(), `/${name}${args ? ` ${args}` : ""}`);
-        }
-      });
+      return path14.join(await realpath(parent), ...rest);
     } catch {
+      dir = parent;
     }
   }
-  return out;
-}
-async function loadCustomCommands(cwd) {
-  const [project, user] = await Promise.all([
-    readCommandDir(path12.join(cwd, ".ad", "commands"), "project"),
-    readCommandDir(path12.join(getConfigDir(), "commands"), "user")
-  ]);
-  const taken = new Set(project.map((c) => c.name));
-  return [...project, ...user.filter((c) => !taken.has(c.name))];
 }
-function findCommand(commands, name) {
-  const n = name.toLowerCase();
-  return commands.find((c) => c.name === n) ?? commands.find((c) => c.aliases?.includes(n));
+var TREE_ID = /^[0-9a-f]{40,64}$/;
+function isInsideRelative(p) {
+  return typeof p === "string" && p.length > 0 && !p.includes("\0") && !path14.isAbsolute(p) && !p.split(/[\\/]/).includes("..");
+}
+function parseShell(raw) {
+  if (raw === void 0) return [];
+  if (!Array.isArray(raw)) return void 0;
+  const out = [];
+  for (const r of raw) {
+    if (!r || typeof r.root !== "string" || typeof r.tree !== "string" || !TREE_ID.test(r.tree) || !Number.isFinite(r.at) || !Array.isArray(r.changes)) return void 0;
+    const changes = [];
+    for (const c of r.changes) {
+      if (!c || !isInsideRelative(c.path) || !(c.status === "A" || c.status === "M" || c.status === "D")) return void 0;
+      changes.push({ path: c.path, status: c.status });
+    }
+    out.push({ root: r.root, tree: r.tree, at: r.at, changes });
+  }
+  return out;
+}
+var CheckpointStore = class _CheckpointStore {
+  checkpoints = [];
+  nextId = 1;
+  rev = 0;
+  /** Files too big to snapshot, per checkpoint id. */
+  oversize = /* @__PURE__ */ new Map();
+  /** Repository root per working directory (null: not in one), so git is asked once. */
+  repoRoots = /* @__PURE__ */ new Map();
+  shellOff = false;
+  snapshotFailures = 0;
+  /** Changes whenever the checkpoints do, so a caller can tell whether there is anything new to save. */
+  get revision() {
+    return this.rev;
+  }
+  /** Starts a checkpoint; later `recordBefore` and `trackShell` calls belong to it. */
+  begin(prompt, historyLength) {
+    const checkpoint = {
+      id: this.nextId++,
+      prompt,
+      at: Date.now(),
+      historyLength,
+      files: /* @__PURE__ */ new Map(),
+      fileTimes: /* @__PURE__ */ new Map(),
+      shell: [],
+      untrackedShell: 0
+    };
+    this.checkpoints.push(checkpoint);
+    this.rev++;
+    return checkpoint;
+  }
+  // ---- saving with the session ---------------------------------------------------------------
+  /** Everything needed to rebuild this store later (file contents as base64). */
+  toJSON() {
+    return {
+      version: 2,
+      nextId: this.nextId,
+      checkpoints: this.checkpoints.map((c) => ({
+        id: c.id,
+        prompt: c.prompt,
+        at: c.at,
+        historyLength: c.historyLength,
+        files: [...c.files].map(([file, content]) => [file, content === null ? null : content.toString("base64"), c.fileTimes.get(file) ?? c.at]),
+        oversize: [...this.oversize.get(c.id) ?? []],
+        shell: c.shell,
+        untrackedShell: c.untrackedShell
+      }))
+    };
+  }
+  /** Rebuilds a store from `toJSON` output (version 1 files, from before shell tracking, load too). Anything that does not look right is refused, not guessed at. */
+  static fromJSON(data) {
+    const d = data;
+    if (!d || d.version !== 1 && d.version !== 2 || !Array.isArray(d.checkpoints) || !Number.isInteger(d.nextId)) return void 0;
+    const store = new _CheckpointStore();
+    let maxId = 0;
+    for (const c of d.checkpoints) {
+      if (!c || !Number.isInteger(c.id) || typeof c.prompt !== "string" || !Number.isFinite(c.at) || !Number.isInteger(c.historyLength) || c.historyLength < 0) return void 0;
+      if (!Array.isArray(c.files) || !Array.isArray(c.oversize) || c.id <= maxId) return void 0;
+      const files = /* @__PURE__ */ new Map();
+      const fileTimes = /* @__PURE__ */ new Map();
+      for (const entry of c.files) {
+        if (!Array.isArray(entry) || typeof entry[0] !== "string" || !(entry[1] === null || typeof entry[1] === "string")) return void 0;
+        files.set(entry[0], entry[1] === null ? null : Buffer.from(entry[1], "base64"));
+        fileTimes.set(entry[0], typeof entry[2] === "number" && Number.isFinite(entry[2]) ? entry[2] : c.at);
+      }
+      const shell = parseShell(c.shell);
+      if (!shell) return void 0;
+      const untracked = typeof c.untrackedShell === "number" && c.untrackedShell >= 0 ? Math.floor(c.untrackedShell) : 0;
+      store.checkpoints.push({ id: c.id, prompt: c.prompt, at: c.at, historyLength: c.historyLength, files, fileTimes, shell, untrackedShell: untracked });
+      if (c.oversize.length) store.oversize.set(c.id, new Set(c.oversize.filter((f) => typeof f === "string")));
+      maxId = c.id;
+    }
+    store.nextId = Math.max(d.nextId, maxId + 1);
+    return store;
+  }
+  /** Bytes of saved file content, which is what the size cap counts. */
+  sizeBytes() {
+    let total = 0;
+    for (const c of this.checkpoints) for (const content of c.files.values()) total += content?.length ?? 0;
+    return total;
+  }
+  /** Drops the OLDEST checkpoints until the saved content fits. Returns how many were dropped. */
+  trimToBytes(max) {
+    let dropped = 0;
+    while (this.checkpoints.length > 0 && this.sizeBytes() > max) {
+      const oldest = this.checkpoints.shift();
+      this.oversize.delete(oldest.id);
+      dropped++;
+    }
+    if (dropped) this.rev++;
+    return dropped;
+  }
+  /** Forgets checkpoints that point past the end of a conversation (it was saved shorter than they remember). */
+  dropBeyond(historyLength) {
+    const keep = this.checkpoints.filter((c) => c.historyLength <= historyLength);
+    if (keep.length !== this.checkpoints.length) {
+      this.checkpoints.splice(0, this.checkpoints.length, ...keep);
+      this.rev++;
+    }
+  }
+  /** Oldest first. */
+  list() {
+    return [...this.checkpoints];
+  }
+  get(id) {
+    return this.checkpoints.find((c) => c.id === id);
+  }
+  // ---- recording -----------------------------------------------------------------------------
+  /** Remembers `file` as it is now, once per checkpoint. Call before the file is changed. */
+  async recordBefore(file) {
+    const current = this.checkpoints.at(-1);
+    if (!current) return;
+    const key = await canonical(file);
+    if (current.files.has(key) || this.oversize.get(current.id)?.has(key)) return;
+    const at = Date.now();
+    let size;
+    try {
+      size = (await stat5(key)).size;
+    } catch {
+      current.files.set(key, null);
+      current.fileTimes.set(key, at);
+      this.rev++;
+      return;
+    }
+    if (size > MAX_SNAPSHOT_BYTES) {
+      const set = this.oversize.get(current.id) ?? /* @__PURE__ */ new Set();
+      set.add(key);
+      this.oversize.set(current.id, set);
+      this.rev++;
+      return;
+    }
+    try {
+      current.files.set(key, await readFile10(key));
+      current.fileTimes.set(key, at);
+      this.rev++;
+    } catch {
+    }
+  }
+  /**
+   * Runs a shell command and records which files it changed. Inside a git repository the work tree is
+   * snapshotted before and after; the difference is what the command did. Outside one (or if git fails or is
+   * too slow) the command still runs, and the checkpoint remembers that a command could not be tracked.
+   */
+  async trackShell(cwd, run2) {
+    const current = this.checkpoints.at(-1);
+    if (!current) return run2();
+    const untracked = () => {
+      current.untrackedShell++;
+      this.rev++;
+    };
+    if (this.shellOff) {
+      untracked();
+      return run2();
+    }
+    let root = this.repoRoots.get(cwd);
+    if (root === void 0) {
+      const top = await repoRoot(cwd);
+      root = top ? await canonical(top) : null;
+      this.repoRoots.set(cwd, root);
+    }
+    if (!root) {
+      untracked();
+      return run2();
+    }
+    const at = Date.now();
+    let before;
+    try {
+      before = await snapshotTree(root);
+      this.snapshotFailures = 0;
+    } catch {
+      if (++this.snapshotFailures >= MAX_SNAPSHOT_FAILURES) this.shellOff = true;
+    }
+    if (!before) {
+      untracked();
+      return run2();
+    }
+    if (Date.now() - at > SLOW_SNAPSHOT_MS) this.shellOff = true;
+    try {
+      return await run2();
+    } finally {
+      try {
+        const after = await snapshotTree(root);
+        if (after !== before) {
+          const changes = await changedBetween(root, before, after);
+          if (changes.length) {
+            current.shell.push({ root, tree: before, at, changes });
+            this.rev++;
+          }
+        }
+      } catch {
+        untracked();
+      }
+    }
+  }
+  // ---- looking and undoing -------------------------------------------------------------------
+  /** Files changed from this checkpoint onward, by file tools or shell commands. */
+  changedSince(id) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const c of this.checkpoints) {
+      if (c.id < id) continue;
+      for (const file of c.files.keys()) seen.add(file);
+      for (const file of this.oversize.get(c.id) ?? []) seen.add(file);
+      for (const rec of c.shell) for (const change of rec.changes) seen.add(path14.resolve(rec.root, change.path));
+    }
+    return [...seen];
+  }
+  /** How many shell commands since `id` ran where their changes could not be tracked. */
+  untrackedShellSince(id) {
+    return this.checkpoints.filter((c) => c.id >= id).reduce((n, c) => n + c.untrackedShell, 0);
+  }
+  /** How many files shell commands changed since `id`. */
+  shellChangesSince(id) {
+    const files = /* @__PURE__ */ new Set();
+    for (const c of this.checkpoints) {
+      if (c.id < id) continue;
+      for (const rec of c.shell) for (const change of rec.changes) files.add(path14.resolve(rec.root, change.path));
+    }
+    return files.size;
+  }
+  /** Puts every file changed since `id` back to how it was when that checkpoint began. */
+  async restoreFiles(id) {
+    const report = { restored: [], deleted: [], failed: [], skipped: [] };
+    const earliest = /* @__PURE__ */ new Map();
+    const consider = (file, source) => {
+      const have = earliest.get(file);
+      if (!have || source.time < have.time) earliest.set(file, source);
+    };
+    const oversize = /* @__PURE__ */ new Set();
+    for (const c of this.checkpoints) {
+      if (c.id < id) continue;
+      for (const [file, content] of c.files) consider(file, { time: c.fileTimes.get(file) ?? c.at, kind: "file", content });
+      for (const rec of c.shell) {
+        for (const change of rec.changes) consider(path14.resolve(rec.root, change.path), { time: rec.at, kind: "tree", root: rec.root, tree: rec.tree, change });
+      }
+      for (const file of this.oversize.get(c.id) ?? []) oversize.add(file);
+    }
+    const trees = /* @__PURE__ */ new Map();
+    for (const [file, source] of earliest) {
+      if (source.kind === "tree") {
+        const key = `${source.root}\0${source.tree}`;
+        const group = trees.get(key) ?? { root: source.root, tree: source.tree, changes: [] };
+        group.changes.push(source.change);
+        trees.set(key, group);
+        continue;
+      }
+      try {
+        if (source.content === null) {
+          await rm3(file, { force: true });
+          report.deleted.push(file);
+        } else {
+          await mkdir6(path14.dirname(file), { recursive: true });
+          await writeFile7(file, source.content);
+          report.restored.push(file);
+        }
+      } catch (error) {
+        report.failed.push({ file, reason: error instanceof Error ? error.message : String(error) });
+      }
+    }
+    for (const group of trees.values()) {
+      const done = await restoreFromTree(group.root, group.tree, group.changes);
+      report.restored.push(...done.restored);
+      report.deleted.push(...done.deleted);
+      report.failed.push(...done.failed);
+    }
+    for (const file of oversize) if (!earliest.has(file)) report.skipped.push(file);
+    return report;
+  }
+  /** Forgets this checkpoint and everything after it (the conversation went back past them). */
+  dropFrom(id) {
+    for (let i = this.checkpoints.length - 1; i >= 0; i--) {
+      if (this.checkpoints[i].id >= id) {
+        this.oversize.delete(this.checkpoints[i].id);
+        this.checkpoints.splice(i, 1);
+      }
+    }
+    this.rev++;
+  }
+  /** Keeps the checkpoints but forgets their saved changes (code was restored, so they are stale). */
+  forgetFilesFrom(id) {
+    for (const c of this.checkpoints) {
+      if (c.id >= id) {
+        c.files.clear();
+        c.fileTimes.clear();
+        c.shell = [];
+        c.untrackedShell = 0;
+        this.oversize.delete(c.id);
+      }
+    }
+    this.rev++;
+  }
+  /** Forgets everything: the conversation was cleared, compacted or replaced, so message positions no longer mean anything. */
+  clear() {
+    this.checkpoints.length = 0;
+    this.oversize.clear();
+    this.rev++;
+  }
+};
+
+// src/agent/checkpoint-file.ts
+import { readFile as readFile11, rm as rm4 } from "fs/promises";
+import path15 from "path";
+var MAX_PERSISTED_BYTES = 48 * 1024 * 1024;
+function fileFor2(sessionId) {
+  if (!/^[A-Za-z0-9-]+$/.test(sessionId)) throw new Error("Invalid session id.");
+  return path15.join(getConfigDir(), "checkpoints", `${sessionId}.json`);
+}
+async function saveCheckpoints(sessionId, store) {
+  const file = fileFor2(sessionId);
+  if (store.list().length === 0) {
+    await rm4(file, { force: true });
+    return;
+  }
+  store.trimToBytes(MAX_PERSISTED_BYTES);
+  await writePrivateFile(file, JSON.stringify(store.toJSON()));
+}
+async function loadCheckpoints(sessionId, messageCount) {
+  try {
+    const store = CheckpointStore.fromJSON(JSON.parse(await readFile11(fileFor2(sessionId), "utf8")));
+    if (!store) return void 0;
+    store.dropBeyond(messageCount);
+    return store.list().length ? store : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/agent/coordinator.ts
+var MAX_COORDINATOR_ROUNDS = 5;
+var MAX_EAGER_ROUNDS = 12;
+function coordinatorPrompt(goal, options = {}) {
+  const wakeNote = options.eager ? "you will be woken, with its report, each time a worker finishes (others may still be running). Use each early report to start follow-up work, but give the user the final result only once every worker has finished." : "you will be woken automatically, with their reports, once every worker has finished.";
+  return `You are now acting as a COORDINATOR for this goal:
+
+${goal.trim()}
+
+How to work:
+1. Look around first, read-only, just enough to plan well. Do not start implementing yourself.
+2. Split the goal into 2-5 independent sub-tasks that can run in parallel without editing the same files. If it cannot be split sensibly, say so and do it yourself instead.
+3. Start one worker per sub-task with spawn_agent. Give each a short name and a complete, self-contained prompt: the overall goal, its scope, which files it owns, constraints, and exactly what to report back. Tell each worker who its teammates are so it can hand work over with message_agent. Use subagent_type "explore" for pure research or review and "general" for anything that changes files.
+4. Then stop, and say in a few lines what you started. Do NOT wait or poll: ${wakeNote}
+5. When woken, check each report against the goal, deal with anything that failed or is missing (start follow-up workers or fix it yourself), run the project's tests or build if code changed, and give the user one consolidated result.`;
+}
+function wakePrompt(goal, round, max = MAX_COORDINATOR_ROUNDS, stillRunning = 0) {
+  if (stillRunning > 0) {
+    return `[coordinator] Round ${round} of ${max}: some background agents have finished (reports above); ${stillRunning} ${stillRunning === 1 ? "is" : "are"} still running. Check what finished against the goal ("${goal.trim().slice(0, 200)}") and act on anything failed or missing (you may start follow-up workers). Do NOT give the final answer yet: say in a line what you have so far and stop. You will be woken again as the rest finish.`;
+  }
+  return `[coordinator] Round ${round} of ${max}: every background agent has finished; their reports are above. Check them against the goal ("${goal.trim().slice(0, 200)}"), fix or follow up on anything failed or missing (you may start more workers), verify the result (run the tests or build if code changed), and give the user the final consolidated answer. If you start more workers, say so and stop: you will be woken again when they finish.`;
+}
+function shouldWake(input) {
+  if (input.running) return "wait";
+  if (input.finished > 0) {
+    if (input.live > 0 && !input.eager) return "wait";
+    const max = input.maxRounds ?? (input.eager ? MAX_EAGER_ROUNDS : MAX_COORDINATOR_ROUNDS);
+    return input.round >= max ? "stop-limit" : "wake";
+  }
+  if (input.live > 0) return "wait";
+  return input.spawned ? "wait" : "stop-idle";
+}
+
+// src/lib/review.ts
+import { execFile as execFile2 } from "child_process";
+import { promisify } from "util";
+var exec = promisify(execFile2);
+var MAX_DIFF_CHARS = 6e4;
+function isSafeRef(ref) {
+  return /^[A-Za-z0-9][A-Za-z0-9._/~^@{}:-]*$/.test(ref) && ref.length <= 200;
+}
+async function git2(cwd, args) {
+  const { stdout } = await exec("git", args, { cwd, maxBuffer: 32 * 1024 * 1024, windowsHide: true });
+  return stdout;
+}
+function cut(diff) {
+  if (diff.length <= MAX_DIFF_CHARS) return { text: diff, truncated: false };
+  const head = diff.slice(0, MAX_DIFF_CHARS);
+  return { text: head.slice(0, head.lastIndexOf("\n") + 1 || MAX_DIFF_CHARS), truncated: true };
+}
+async function collectReviewTarget(cwd, ref) {
+  try {
+    await git2(cwd, ["rev-parse", "--is-inside-work-tree"]);
+  } catch {
+    throw new Error("This folder is not a git repository, so there is no change to review.");
+  }
+  const wanted = ref?.trim();
+  if (wanted && !isSafeRef(wanted)) {
+    throw new Error(`"${wanted}" is not a branch, tag, commit or range I can use. Try a name like main, HEAD~3 or origin/main..HEAD.`);
+  }
+  const base = ["diff", "--no-color", "--no-ext-diff"];
+  let range;
+  let label;
+  if (wanted) {
+    range = [wanted];
+    label = `changes since ${wanted}`;
+  } else {
+    label = "uncommitted changes";
+    range = await git2(cwd, ["rev-parse", "--verify", "HEAD"]).then(
+      () => ["HEAD"],
+      () => ["--cached"]
+    );
+  }
+  let diff;
+  let names;
+  try {
+    diff = await git2(cwd, [...base, ...range, "--"]);
+    names = await git2(cwd, ["diff", "--name-only", ...range, "--"]);
+  } catch (error) {
+    const detail = error instanceof Error ? error.stderr?.trim() || error.message : String(error);
+    throw new Error(wanted ? `Git could not compare with "${wanted}": ${detail.split("\n")[0]}` : `Git could not read the changes: ${detail.split("\n")[0]}`);
+  }
+  const untracked = wanted ? [] : (await git2(cwd, ["ls-files", "--others", "--exclude-standard"]).catch(() => "")).split("\n").map((l) => l.trim()).filter(Boolean);
+  const files = names.split("\n").map((l) => l.trim()).filter(Boolean);
+  if (!diff.trim() && untracked.length === 0) {
+    throw new Error(wanted ? `Nothing differs from ${wanted}.` : "Nothing to review: there are no uncommitted changes.");
+  }
+  const { text: text2, truncated } = cut(diff);
+  return { label, diff: text2, files, untracked, truncated };
+}
+function buildReviewPrompt(target) {
+  const list2 = (items, max = 60) => `${items.slice(0, max).map((f) => `- ${f}`).join("\n")}${items.length > max ? `
+- \u2026 and ${items.length - max} more` : ""}`;
+  return [
+    `Review this change (${target.label}) for problems that would matter in production. You are read-only: do not modify anything.`,
+    "",
+    "Look for: correctness bugs, security problems, bad error handling, races and data loss, and missing or wrong tests. Ignore style, naming and formatting.",
+    "Read the surrounding code with read_file and grep whenever the diff alone does not show enough to judge. Do not guess: report only what you have verified in the code.",
+    "",
+    "For each finding give: severity (high, medium or low), file:line, what is wrong, a concrete input or state that triggers it, and a suggested fix. Most serious first.",
+    'If you find nothing, say "No issues found" and list what you checked.',
+    "",
+    target.files.length ? `Files changed (${target.files.length}):
+${list2(target.files)}` : "No tracked files changed.",
+    ...target.untracked.length ? ["", `New files git does not track yet (not in the diff below; read them):
+${list2(target.untracked)}`] : [],
+    ...target.truncated ? ["", `NOTE: the diff below was cut at ${MAX_DIFF_CHARS.toLocaleString()} characters. Read the files above for the rest.`] : [],
+    "",
+    "```diff",
+    target.diff.trimEnd(),
+    "```"
+  ].join("\n");
+}
+
+// src/agent/orchestrator.ts
+var DEFAULT_MAX_RUNNING_WORKERS = 3;
+var DEFAULT_MAX_ACTIVE_WORKERS = 8;
+var DEFAULT_MAX_TEAM_MESSAGES = 200;
+var MAX_MESSAGE_CHARS = 8e3;
+var MAX_INBOX = 50;
+var LEAD_NAMES = /* @__PURE__ */ new Set(["main", "lead", "you", "user"]);
+var isLive = (w) => w.status === "queued" || w.status === "running";
+var Orchestrator = class {
+  constructor(runner, options = {}) {
+    this.runner = runner;
+    this.slot = concurrencyLimit(Math.max(1, options.maxRunning ?? DEFAULT_MAX_RUNNING_WORKERS));
+    this.maxActive = Math.max(1, options.maxActive ?? DEFAULT_MAX_ACTIVE_WORKERS);
+    this.maxMessages = Math.max(1, options.maxMessages ?? DEFAULT_MAX_TEAM_MESSAGES);
+  }
+  runner;
+  workers = /* @__PURE__ */ new Map();
+  controllers = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  mainListeners = /* @__PURE__ */ new Set();
+  slot;
+  maxActive;
+  maxMessages;
+  seq = 0;
+  sent = 0;
+  /** Mail for the lead agent (the one the user talks to), waiting for its next turn. */
+  mainInbox = [];
+  // ---- watching ------------------------------------------------------------------------------
+  /** Called after any change to any worker. Returns the unsubscribe. */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  /** Called when a worker writes to the lead. */
+  onMainMessage(listener) {
+    this.mainListeners.add(listener);
+    return () => this.mainListeners.delete(listener);
+  }
+  emit() {
+    for (const listener of [...this.listeners]) {
+      try {
+        listener();
+      } catch {
+      }
+    }
+  }
+  // ---- reading -------------------------------------------------------------------------------
+  list() {
+    return [...this.workers.values()];
+  }
+  /** Queued or running. */
+  activeCount() {
+    return this.list().filter(isLive).length;
+  }
+  /** By id, then name, then a unique prefix of either ("res" finds "researcher"). */
+  find(query) {
+    const q = query.trim().toLowerCase();
+    if (!q) return void 0;
+    const all = this.list();
+    const exact = all.find((w) => w.id === q || w.name === q);
+    if (exact) return exact;
+    const prefixed = all.filter((w) => w.id.startsWith(q) || w.name.startsWith(q));
+    return prefixed.length === 1 ? prefixed[0] : void 0;
+  }
+  /** Mail for the lead since it last looked. Reading it empties the box. */
+  takeMainMail() {
+    const mail = this.mainInbox;
+    this.mainInbox = [];
+    return mail;
+  }
+  /** The team as text, for the model (`list_agents`) and for /workers. */
+  describe(self = "main") {
+    const lines = [`- main (the lead agent the user talks to)${self === "main" ? " \u2190 you" : ""}`];
+    for (const w of this.list()) {
+      const bits = [w.status, w.description];
+      if (w.toolUses) bits.push(`${w.toolUses} tool use${w.toolUses === 1 ? "" : "s"}`);
+      if (isLive(w) && w.activity) bits.push(w.activity);
+      lines.push(`- ${w.name} [${w.id}]${w.name === self ? " \u2190 you" : ""}: ${bits.join(" \xB7 ")}`);
+    }
+    return lines.join("\n");
+  }
+  // ---- acting --------------------------------------------------------------------------------
+  spawn(spec) {
+    if (this.activeCount() >= this.maxActive) {
+      throw new Error(`Already ${this.maxActive} workers are running or waiting. Wait for some to finish, or cancel one, before starting another.`);
+    }
+    const id = `w${++this.seq}`;
+    const worker = {
+      id,
+      name: this.uniqueName(spec.name, id),
+      description: spec.description.trim() || "worker",
+      prompt: spec.prompt,
+      type: spec.type,
+      status: "queued",
+      createdAt: Date.now(),
+      toolUses: 0,
+      tokens: 0,
+      history: [{ role: "user", content: spec.prompt }],
+      inbox: [],
+      log: [],
+      ...spec.interactive ? { interactive: true } : {},
+      ...spec.shown ? { shown: spec.shown } : {}
+    };
+    this.workers.set(id, worker);
+    this.drive(worker);
+    return worker;
+  }
+  /**
+   * Delivers a message. A worker that had finished wakes up to handle it. Throws a plain Error the model
+   * (or the user) can act on.
+   */
+  send(from, to, text2) {
+    const body = text2.trim();
+    if (!body) throw new Error("The message is empty.");
+    if (body.length > MAX_MESSAGE_CHARS) throw new Error(`The message is too long (${body.length} characters, at most ${MAX_MESSAGE_CHARS}). Shorten it.`);
+    if (this.sent >= this.maxMessages) {
+      throw new Error(`The team has used its budget of ${this.maxMessages} messages. Stop messaging and report to the user.`);
+    }
+    const target = to.trim().toLowerCase();
+    const sender = this.find(from);
+    if (LEAD_NAMES.has(target)) {
+      if (from === "main") throw new Error("You are the lead agent: that message would go to yourself.");
+      const message2 = { from, to: "main", text: body, at: Date.now() };
+      this.sent++;
+      this.mainInbox.push(message2);
+      sender?.log.push(message2);
+      for (const listener of [...this.mainListeners]) listener(message2);
+      this.emit();
+      return "Delivered to main.";
+    }
+    const worker = this.find(target);
+    if (!worker) {
+      throw new Error(`No agent named "${to}". Teammates:
+${this.describe(from)}`);
+    }
+    if (worker.name === from) throw new Error("That is you. Message a teammate.");
+    if (worker.status === "cancelled") throw new Error(`${worker.name} was cancelled by the user and cannot take messages.`);
+    if (worker.inbox.length >= MAX_INBOX) throw new Error(`${worker.name} has ${MAX_INBOX} unread messages. Wait for it to catch up.`);
+    const message = { from, to: worker.name, text: body, at: Date.now() };
+    this.sent++;
+    worker.inbox.push(message);
+    worker.log.push(message);
+    sender?.log.push(message);
+    const woke = worker.status === "done" || worker.status === "failed";
+    if (woke) this.drive(worker);
+    else this.emit();
+    return woke ? `Delivered to ${worker.name}. It had finished; it is working on this now.` : `Delivered to ${worker.name}.`;
+  }
+  /** Stops a worker. Finished ones are left as they are. */
+  cancel(query) {
+    const worker = this.find(query);
+    if (!worker) throw new Error(`No worker "${query}".`);
+    if (!isLive(worker)) return worker;
+    worker.status = "cancelled";
+    worker.endedAt = Date.now();
+    worker.activity = void 0;
+    this.controllers.get(worker.id)?.abort();
+    this.emit();
+    return worker;
+  }
+  cancelAll() {
+    let n = 0;
+    for (const worker of this.list()) {
+      if (isLive(worker)) {
+        this.cancel(worker.id);
+        n++;
+      }
+    }
+    return n;
+  }
+  /** What a worker (or the lead, as "main") may do to teammates. */
+  bridgeFor(self, canSpawn) {
+    return {
+      self,
+      send: (to, text2) => this.send(self, to, text2),
+      list: () => this.describe(self),
+      ...canSpawn ? {
+        spawn: (spec) => {
+          const worker = this.spawn(spec);
+          return `Started ${worker.name} [${worker.id}] in the background: ${worker.description}.
+It reports to you with message_agent, and you can check on it with list_agents. Carry on; do not wait for it unless you have nothing else to do.`;
+        }
+      } : {}
+    };
+  }
+  // ---- running -------------------------------------------------------------------------------
+  uniqueName(wanted, id) {
+    const base = (wanted ?? "").toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 24);
+    let name = !base || LEAD_NAMES.has(base) ? id : base;
+    const stem = name;
+    const taken = (n) => this.list().some((w) => w.name === n || w.id === n);
+    for (let i = 2; taken(name); i++) name = `${stem}-${i}`;
+    return name;
+  }
+  /** Takes a slot, then does the worker's stretch(es) of work. Used for the first run and for a wake-up. */
+  drive(worker) {
+    const ac = new AbortController();
+    this.controllers.set(worker.id, ac);
+    worker.status = "queued";
+    worker.endedAt = void 0;
+    worker.error = void 0;
+    this.emit();
+    void this.slot(async () => {
+      if (ac.signal.aborted) return;
+      worker.status = "running";
+      worker.startedAt ??= Date.now();
+      this.emit();
+      const run2 = {
+        worker,
+        signal: ac.signal,
+        drainInbox: () => this.drain(worker),
+        touch: () => this.emit(),
+        bridge: this.bridgeFor(worker.name, false)
+      };
+      try {
+        do {
+          await this.runner(run2);
+        } while (worker.inbox.length > 0 && !ac.signal.aborted);
+        if (!ac.signal.aborted) worker.status = "done";
+      } catch (error) {
+        if (!ac.signal.aborted) {
+          worker.status = "failed";
+          worker.error = error instanceof Error ? error.message : String(error);
+        }
+      } finally {
+        worker.activity = void 0;
+        worker.endedAt ??= Date.now();
+        this.emit();
+      }
+    });
+  }
+  drain(worker) {
+    const mail = worker.inbox.splice(0);
+    return mail.map((m) => ({ role: "user", content: worker.interactive && m.from === "you" ? m.text : `[message from ${m.from}] ${m.text}` }));
+  }
+};
+function trackWorkerEvent(worker, event, describe) {
+  switch (event.type) {
+    case "tool_start": {
+      worker.toolUses++;
+      const name = event.call.function.name;
+      worker.activity = `${name}(${describe(name, event.call.function.arguments)})`;
+      return true;
+    }
+    case "usage":
+      worker.tokens += event.usage.total_tokens;
+      return true;
+    case "assistant":
+      if (event.content.trim()) worker.result = event.content;
+      return false;
+    default:
+      return false;
+  }
+}
+
+// src/agent/worker-runner.ts
+var WORKER_NOTE = (worker) => `
+
+You are "${worker.name}", a worker agent on a team. The lead agent ("main") started you for this job and the user can watch your progress.
+- Teammates and the lead can message you; their messages appear in the conversation as "[message from <name>]". Read them and adjust.
+- Use message_agent to hand over results, ask a question or ask for a review, and list_agents to see who is on the team.
+- Do not ask the user questions: ask the lead with message_agent instead.
+- When your job is done, reply with a short final report (what you did, what you found, anything the lead must follow up on) and stop. Do not wait for replies in a loop; if you are waiting on a teammate, finish with what you have and say what is pending.`;
+var SIDE_NOTE = (worker) => `
+
+You are "${worker.name}", a SIDE assistant. The user opened you next to their main conversation to ask something on the side, and chats with you directly in a panel while the main agent keeps working on its own task.
+- Their messages arrive as ordinary user messages. Answer them directly and concisely: this is a conversation, so there is no final report to write.
+- The first message includes the main conversation so far, for context only. Do not repeat or take over the main agent's work.${worker.type === "explore" ? " You can read files and search but you cannot change anything." : " Only change files if the user clearly asks you to."}
+- The main agent is "main". Message it with message_agent only when the user asks you to pass something on.`;
+var TEAM_NOTE = (worker) => worker.interactive ? SIDE_NOTE(worker) : WORKER_NOTE(worker);
+function createWorkerRunner(base) {
+  return async ({ worker, signal, drainInbox, touch, bridge }) => {
+    const b = base();
+    const allowed = SUBAGENT_TOOLS[worker.type];
+    const system = await buildSystemPrompt(b.cwd, {
+      tools: true,
+      subagent: worker.type,
+      agentName: worker.name,
+      artifactTool: allowed("create_artifact") && b.toolFilter("create_artifact")
+    }) + TEAM_NOTE(worker);
+    await runAgentTurn({
+      config: b.config,
+      model: await b.model(),
+      system,
+      history: worker.history,
+      cwd: b.cwd,
+      mode: b.mode,
+      setMode: b.setMode,
+      rules: b.rules,
+      readFiles: b.readFiles,
+      ask: b.askFor(worker, signal),
+      signal,
+      ...b.checkpoint ? { checkpoint: b.checkpoint } : {},
+      ...b.shellTracker ? { shellTracker: b.shellTracker } : {},
+      sessionId: b.sessionId,
+      // Depth 1: no `task`, no verify nudge, and the loop treats it as a helper rather than the main agent.
+      depth: 1,
+      maxSteps: b.maxSteps ?? DEFAULT_SUBAGENT_MAX_STEPS * 2,
+      toolFilter: (name) => allowed(name) && b.toolFilter(name),
+      team: bridge,
+      drainInbox,
+      onEvent: (event) => {
+        if (event.type === "usage") b.onUsage?.(event.usage);
+        if (trackWorkerEvent(worker, event, describeCall)) touch();
+      }
+    });
+  };
+}
+
+// src/lib/session-bus.ts
+import { randomUUID as randomUUID4 } from "crypto";
+import { readFile as readFile12, readdir as readdir3, rm as rm5 } from "fs/promises";
+import path16 from "path";
+var MAX_SESSION_MESSAGE_CHARS = 8e3;
+var MAX_INBOX_MESSAGES = 50;
+var SAFE_ID = /^[A-Za-z0-9-]{1,64}$/;
+function isPidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function parsePresence(raw, fileId) {
+  try {
+    const p = JSON.parse(raw);
+    if (p.id !== fileId || !SAFE_ID.test(p.id)) return void 0;
+    if (typeof p.pid !== "number" || typeof p.seenAt !== "number" || typeof p.cwd !== "string") return void 0;
+    return {
+      id: p.id,
+      pid: p.pid,
+      cwd: p.cwd,
+      title: typeof p.title === "string" ? p.title : "",
+      agent: typeof p.agent === "string" ? p.agent : "",
+      startedAt: typeof p.startedAt === "number" ? p.startedAt : p.seenAt,
+      seenAt: p.seenAt
+    };
+  } catch {
+    return void 0;
+  }
+}
+var SessionBus = class {
+  dir;
+  pollMs;
+  heartbeatMs;
+  staleMs;
+  now;
+  alive;
+  identity;
+  onMessage;
+  lastId;
+  startedAt = 0;
+  timers = [];
+  polling = false;
+  /** Set by stop(): a heartbeat already in flight must not bring the presence file back. */
+  stopped = false;
+  constructor(options = {}) {
+    this.dir = options.dir ?? path16.join(getConfigDir(), "bus");
+    this.pollMs = options.pollMs ?? 1e3;
+    this.heartbeatMs = options.heartbeatMs ?? 5e3;
+    this.staleMs = options.staleMs ?? 2e4;
+    this.now = options.now ?? Date.now;
+    this.alive = options.pidAlive ?? isPidAlive;
+  }
+  presenceFile(id) {
+    return path16.join(this.dir, "presence", `${id}.json`);
+  }
+  inboxDir(id) {
+    return path16.join(this.dir, "inbox", id);
+  }
+  // ---- being here ----------------------------------------------------------------------------
+  /** Registers this session and starts reading its mail. `identity` is read each beat: the id changes on /clear and /resume. */
+  async start(identity, onMessage) {
+    this.identity = identity;
+    this.onMessage = onMessage;
+    this.stopped = false;
+    this.startedAt = this.now();
+    await this.beat().catch(() => void 0);
+    this.timers.push(setInterval(() => void this.beat().catch(() => void 0), this.heartbeatMs));
+    this.timers.push(setInterval(() => void this.poll().catch(() => void 0), this.pollMs));
+    for (const timer of this.timers) timer.unref?.();
+  }
+  /** Leaves: stops timers and removes this session's presence and any unread mail. */
+  async stop() {
+    this.stopped = true;
+    for (const timer of this.timers) clearInterval(timer);
+    this.timers = [];
+    const id = this.lastId;
+    this.lastId = void 0;
+    if (!id) return;
+    await rm5(this.presenceFile(id), { force: true }).catch(() => void 0);
+    await rm5(this.inboxDir(id), { recursive: true, force: true }).catch(() => void 0);
+  }
+  async beat() {
+    if (this.stopped) return;
+    const me = this.identity?.();
+    if (!me || !SAFE_ID.test(me.id)) return;
+    if (this.lastId && this.lastId !== me.id) {
+      await rm5(this.presenceFile(this.lastId), { force: true }).catch(() => void 0);
+      await rm5(this.inboxDir(this.lastId), { recursive: true, force: true }).catch(() => void 0);
+    }
+    this.lastId = me.id;
+    const presence = { ...me, pid: process.pid, startedAt: this.startedAt, seenAt: this.now() };
+    await writePrivateFile(this.presenceFile(me.id), JSON.stringify(presence));
+    if (this.stopped) await rm5(this.presenceFile(me.id), { force: true }).catch(() => void 0);
+  }
+  // ---- seeing others -------------------------------------------------------------------------
+  /** Sessions that are really running, newest first. Prunes the dead and the silent as it goes. */
+  async list() {
+    let names;
+    try {
+      names = await readdir3(path16.join(this.dir, "presence"));
+    } catch {
+      return [];
+    }
+    const live = [];
+    for (const name of names.filter((n) => n.endsWith(".json"))) {
+      const id = name.slice(0, -".json".length);
+      let session;
+      try {
+        session = parsePresence(await readFile12(path16.join(this.dir, "presence", name), "utf8"), id);
+      } catch {
+        continue;
+      }
+      if (session && this.alive(session.pid) && this.now() - session.seenAt <= this.staleMs) live.push(session);
+      else if (SAFE_ID.test(id)) await rm5(path16.join(this.dir, "presence", name), { force: true }).catch(() => void 0);
+    }
+    return live.sort((a, b) => b.startedAt - a.startedAt);
+  }
+  /** The one other session `query` means: by id, a unique id prefix, or a unique title. */
+  async resolve(query, selfId) {
+    const others = (await this.list()).filter((s) => s.id !== selfId);
+    if (others.length === 0) throw new Error("There is no other session running right now. Open another terminal and start `ad` there.");
+    const q = query.trim().toLowerCase();
+    if (!q) throw new Error("Say which session: an id (see /sessions) or part of its title.");
+    const byId = others.filter((s) => s.id.toLowerCase() === q);
+    const byPrefix = others.filter((s) => s.id.toLowerCase().startsWith(q));
+    const byTitle = others.filter((s) => s.title.toLowerCase() === q);
+    const byPart = others.filter((s) => s.title.toLowerCase().includes(q));
+    for (const found of [byId, byPrefix, byTitle, byPart]) {
+      if (found.length === 1) return found[0];
+      if (found.length > 1) {
+        throw new Error(`"${query}" matches ${found.length} sessions. Use more of the id:
+${found.map((s) => `  ${s.id.slice(0, 8)}  ${s.title || "(untitled)"}  ${s.cwd}`).join("\n")}`);
+      }
+    }
+    throw new Error(`No other session matches "${query}". See /sessions.`);
+  }
+  // ---- talking -------------------------------------------------------------------------------
+  /** Delivers `text` to another session. Throws a message the user or the model can act on. */
+  async send(from, query, text2) {
+    const body = text2.trim();
+    if (!body) throw new Error("The message is empty.");
+    if (body.length > MAX_SESSION_MESSAGE_CHARS) {
+      throw new Error(`The message is too long (${body.length} characters, at most ${MAX_SESSION_MESSAGE_CHARS}). Shorten it.`);
+    }
+    if (!SAFE_ID.test(from.id)) throw new Error("This session has no usable id yet.");
+    const target = await this.resolve(query, from.id);
+    const dir = this.inboxDir(target.id);
+    const waiting = (await readdir3(dir).catch(() => [])).filter((n) => n.endsWith(".json")).length;
+    if (waiting >= MAX_INBOX_MESSAGES) {
+      throw new Error(`"${target.title || target.id.slice(0, 8)}" already has ${MAX_INBOX_MESSAGES} unread messages. It is probably not being used; try again later.`);
+    }
+    const at = this.now();
+    const message = { id: randomUUID4(), from: { id: from.id, title: from.title, cwd: from.cwd }, text: body, at };
+    await writePrivateFile(path16.join(dir, `${String(at).padStart(15, "0")}-${message.id}.json`), JSON.stringify(message));
+    return target;
+  }
+  /** Reads and removes this session's mail, oldest first. Anything unreadable is dropped. */
+  async receive() {
+    const me = this.identity?.();
+    if (!me || !SAFE_ID.test(me.id)) return [];
+    const dir = this.inboxDir(me.id);
+    let names;
+    try {
+      names = (await readdir3(dir)).filter((n) => n.endsWith(".json")).sort();
+    } catch {
+      return [];
+    }
+    const messages = [];
+    for (const name of names) {
+      const file = path16.join(dir, name);
+      try {
+        const m = JSON.parse(await readFile12(file, "utf8"));
+        if (typeof m.text === "string" && m.text && typeof m.from?.id === "string") {
+          messages.push({
+            id: String(m.id ?? name),
+            from: { id: m.from.id, title: String(m.from.title ?? ""), cwd: String(m.from.cwd ?? "") },
+            text: m.text.slice(0, MAX_SESSION_MESSAGE_CHARS),
+            at: typeof m.at === "number" ? m.at : 0
+          });
+        }
+      } catch {
+      }
+      await rm5(file, { force: true }).catch(() => void 0);
+    }
+    return messages;
+  }
+  async poll() {
+    if (this.polling) return;
+    this.polling = true;
+    try {
+      for (const message of await this.receive()) this.onMessage?.(message);
+    } finally {
+      this.polling = false;
+    }
+  }
+};
+var clip = (text2, max) => {
+  const flat = text2.replace(/\s+/g, " ").trim();
+  return flat.length > max ? `${flat.slice(0, max - 1)}\u2026` : flat;
+};
+function age(ms) {
+  const s = Math.max(0, Math.floor(ms / 1e3));
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  return m < 60 ? `${m}m` : `${Math.floor(m / 60)}h`;
+}
+function describeSessions(sessions, selfId, now = Date.now()) {
+  if (sessions.length === 0) return ["No sessions are running."];
+  const lines = sessions.map((s) => {
+    const me = s.id === selfId ? " (this one)" : "";
+    return `${s.id.slice(0, 8)}  ${clip(s.title || "(untitled)", 50)}${me}
+    ${s.cwd} \xB7 ${s.agent || "agent"} \xB7 up ${age(now - s.startedAt)}`;
+  });
+  if (sessions.every((s) => s.id === selfId)) lines.push("No other session is running. Open another terminal and start `ad` there.");
+  return lines;
+}
+
+// src/tui/ask.ts
+function askWithSignal(open, signal) {
+  return new Promise((resolve) => {
+    if (signal?.aborted) return resolve("deny");
+    let slot;
+    const onAbort = () => {
+      slot?.close();
+      resolve("deny");
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+    slot = open((decision) => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve(decision);
+    });
+  });
+}
+
+// src/lib/diagnostics.ts
+async function probeServer(config2, fetchImpl = fetch) {
+  if (!config2.baseUrl) return {};
+  const started = Date.now();
+  try {
+    const res = await fetchImpl(new URL("/v1/models", config2.baseUrl), {
+      headers: { accept: "application/json", ...clientHeaders(), ...config2.apiKey ? { authorization: `Bearer ${config2.apiKey}` } : {} },
+      signal: AbortSignal.timeout(1e4)
+    });
+    await res.body?.cancel().catch(() => void 0);
+    const served = servedBy(res.headers);
+    return { status: res.status, ms: Date.now() - started, ...served ? { served } : {} };
+  } catch {
+    return {};
+  }
+}
+
+// src/tui/commands.ts
+import { readdir as readdir4, readFile as readFile13 } from "fs/promises";
+import path17 from "path";
+
+// src/tui/workers.ts
+var STATUS_ICON = {
+  queued: "\u25CC",
+  running: "\u25CF",
+  done: "\u2713",
+  failed: "\u2717",
+  cancelled: "\u2298"
+};
+function elapsed(ms) {
+  const s = Math.max(0, Math.floor(ms / 1e3));
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m ${String(s % 60).padStart(2, "0")}s`;
+  return `${Math.floor(m / 60)}h ${String(m % 60).padStart(2, "0")}m`;
+}
+function ranFor(w, now) {
+  if (!w.startedAt) return "waiting for a slot";
+  return elapsed((w.endedAt ?? now) - w.startedAt);
+}
+var tokens = (n) => n >= 1e3 ? `${(n / 1e3).toFixed(1)}k` : String(n);
+var clip2 = (text2, max) => {
+  const flat = text2.replace(/\s+/g, " ").trim();
+  return flat.length > max ? `${flat.slice(0, max - 1)}\u2026` : flat;
+};
+function workerRow(w, now = Date.now()) {
+  const bits = [`${w.status} ${ranFor(w, now)}`];
+  if (w.toolUses) bits.push(`${w.toolUses} tool use${w.toolUses === 1 ? "" : "s"}`);
+  if (w.tokens) bits.push(`${tokens(w.tokens)} tokens`);
+  if (w.status === "running" && w.activity) bits.push(w.activity);
+  if (w.status === "failed" && w.error) bits.push(clip2(w.error, 60));
+  if (w.inbox.length) bits.push(`${w.inbox.length} unread`);
+  return { label: `${STATUS_ICON[w.status]} ${w.name} \xB7 ${clip2(w.description, 40)}`, description: bits.join(" \xB7 ") };
+}
+function describeWorker(w, now = Date.now()) {
+  const lines = [
+    `${STATUS_ICON[w.status]} ${w.name} [${w.id}] \u2014 ${w.description}`,
+    `Status:  ${w.status} \xB7 ${ranFor(w, now)} \xB7 ${w.toolUses} tool use${w.toolUses === 1 ? "" : "s"} \xB7 ${tokens(w.tokens)} tokens \xB7 ${w.type === "explore" ? "read-only" : "can edit and run commands"}`,
+    `Task:    ${clip2(w.prompt, 300)}`
+  ];
+  if (w.status === "running" && w.activity) lines.push(`Now:     ${w.activity}`);
+  const calls = w.history.flatMap((m) => m.role === "assistant" ? m.tool_calls ?? [] : []).slice(-5).map((c) => `${c.function.name}(${describeCall(c.function.name, c.function.arguments)})`);
+  if (calls.length) lines.push("Recent steps:", ...calls.map((c) => `  \xB7 ${c}`));
+  if (w.log.length) {
+    lines.push("Messages:");
+    for (const m of w.log.slice(-6)) lines.push(`  ${m.from} \u2192 ${m.to}: ${clip2(m.text, 160)}`);
+  }
+  if (w.inbox.length) lines.push(`${w.inbox.length} unread message${w.inbox.length === 1 ? "" : "s"} waiting for its next step.`);
+  if (w.status === "failed" && w.error) lines.push(`Failed:  ${w.error}`);
+  if (w.status === "cancelled") lines.push("Cancelled by you.");
+  if (w.result && w.status !== "running") lines.push("Report:", ...w.result.trim().slice(0, 1500).split("\n").map((l) => `  ${l}`));
+  return lines;
+}
+function boardSummary(workers) {
+  if (workers.length === 0) return void 0;
+  const count = (status) => workers.filter((w) => w.status === status).length;
+  const parts = [];
+  const running = count("running");
+  const queued = count("queued");
+  const done = count("done");
+  const failed = count("failed");
+  if (running) parts.push(`${running} running`);
+  if (queued) parts.push(`${queued} queued`);
+  if (done) parts.push(`${done} done`);
+  if (failed) parts.push(`${failed} failed`);
+  return parts.length ? parts.join(" \xB7 ") : `${workers.length} stopped`;
+}
+function parseSpawnArgs(args) {
+  const text2 = args.trim();
+  const named = /^([A-Za-z0-9_-]{1,24}):\s+([\s\S]+)$/.exec(text2);
+  return named ? { name: named[1], task: named[2].trim() } : { task: text2 };
+}
+
+// src/tui/commands.ts
+var INIT_PROMPT = `Analyze this codebase and create an AD.md file in the project root. It is read at the start of every session, so keep it short and useful. Include:
+- the commands to build, run, lint and test (check package.json, Makefile, etc.),
+- the high-level architecture and the directories that matter,
+- conventions that differ from the defaults.
+Do not invent anything: read the code first. If AD.md already exists, improve it instead of replacing it.`;
+function builtinCommands() {
+  return [
+    {
+      name: "help",
+      description: "Show commands and shortcuts",
+      run: (ctx) => {
+        const lines = ["Commands:"];
+        for (const c of ctx.allCommands()) lines.push(`  /${(c.name + (c.args ? ` ${c.args}` : "")).padEnd(22)}${c.description}`);
+        lines.push("", "Shortcuts:", "  @file  mention a file (or @app: one of your connected connectors) \xB7 !cmd  run a shell command \xB7 #note  save a note to AD.md", "  shift+tab  cycle permission mode \xB7 esc  interrupt \xB7 ctrl+j  new line");
+        ctx.info(lines.join("\n"));
+      }
+    },
+    { name: "agents", description: "Switch the agent", aliases: ["agent"], run: (ctx) => ctx.pickAgent() },
+    {
+      name: "workers",
+      description: "Background agents: status board, open one, stop it",
+      args: "[name]",
+      aliases: ["bg"],
+      run: (ctx, args) => args.trim() ? ctx.workers.show(args.trim()) : ctx.workers.board()
+    },
+    {
+      name: "spawn",
+      description: "Start a background agent on a task",
+      args: "[name:] <task>",
+      run: (ctx, args) => {
+        const { name, task } = parseSpawnArgs(args);
+        if (!task) return ctx.info("Usage: /spawn [name:] <task>   e.g. /spawn reviewer: review the changes in src/agent", "warn");
+        ctx.workers.spawn(task, name);
+      }
+    },
+    {
+      name: "stop",
+      description: 'Stop a background agent (or "all")',
+      args: "<name|all>",
+      run: (ctx, args) => args.trim() ? ctx.workers.stop(args.trim()) : ctx.info("Usage: /stop <name|all>", "warn")
+    },
+    {
+      name: "msg",
+      description: "Send a message to a background agent",
+      args: "<name> <message>",
+      run: (ctx, args) => {
+        const [to = "", ...rest] = args.trim().split(/\s+/);
+        const text2 = rest.join(" ").trim();
+        if (!to || !text2) return ctx.info("Usage: /msg <name> <message>", "warn");
+        ctx.workers.message(to, text2);
+      }
+    },
+    {
+      name: "code-review",
+      description: "Review your uncommitted changes (or what differs from a branch) in the background",
+      args: "[branch|commit|range]",
+      aliases: ["review"],
+      run: (ctx, args) => ctx.review(args)
+    },
+    {
+      name: "coordinate",
+      description: "Split a big goal into parallel background agents, then merge their results",
+      args: "[--eager] <goal> | off",
+      run: (ctx, args) => ctx.coordinate(args)
+    },
+    {
+      name: "model",
+      description: "Use a specific model instead of an agent",
+      args: "<model>",
+      run: (ctx, args) => args.trim() ? ctx.setModel(args.trim()) : ctx.pickAgent()
+    },
+    { name: "clear", description: "Start a new conversation", aliases: ["new", "reset"], run: (ctx) => ctx.clear() },
+    {
+      name: "compact",
+      description: "Summarize the conversation to free up context",
+      args: "[focus]",
+      run: (ctx, args) => ctx.compact(args.trim() || void 0)
+    },
+    { name: "resume", description: "Resume an earlier conversation", aliases: ["continue"], run: (ctx) => ctx.pickSession() },
+    {
+      name: "rewind",
+      description: "Undo: go back to before an earlier prompt (code, conversation or both)",
+      aliases: ["undo", "checkpoint"],
+      run: (ctx) => ctx.rewind()
+    },
+    {
+      name: "side",
+      description: "Ask on the side, in a split view, while the main agent keeps working",
+      args: "[--edit] <question> | main | close | show | send",
+      aliases: ["btw"],
+      run: (ctx, args) => {
+        const text2 = args.trim();
+        const word = text2.toLowerCase();
+        if (!text2) return ctx.side.toggle();
+        if (word === "main") return ctx.side.focus("main");
+        if (word === "close") return ctx.side.close();
+        if (word === "show") return ctx.side.show();
+        if (word === "send") return ctx.side.sendToMain();
+        ctx.side.start(text2.replace(/^--edit\s*/, "").trim(), /^--edit(\s|$)/.test(text2));
+      }
+    },
+    { name: "sessions", description: "List the other sessions running on this machine", aliases: ["who"], run: (ctx) => ctx.sessions.list() },
+    {
+      name: "send",
+      description: "Send a message to another running session",
+      args: "<session> <message>",
+      run: (ctx, args) => {
+        const [to = "", ...rest] = args.trim().split(/\s+/);
+        const text2 = rest.join(" ").trim();
+        if (!to || !text2) return ctx.info("Usage: /send <session> <message>   (see /sessions for ids and titles)", "warn");
+        ctx.sessions.send(to, text2);
+      }
+    },
+    { name: "plan", description: "Plan first: research without changing anything", run: (ctx) => ctx.setMode("plan") },
+    {
+      name: "open",
+      description: "Open the last artifact (or a .html file) in your browser",
+      args: "[file]",
+      run: (ctx, args) => ctx.openFile(args.trim() || void 0)
+    },
+    { name: "init", description: "Create an AD.md with project instructions", run: (ctx) => ctx.send(INIT_PROMPT, "/init") },
+    { name: "status", description: "Show account, agent and session details", run: (ctx) => ctx.info(ctx.describeStatus().join("\n")) },
+    { name: "usage", description: "Show token usage for this session", aliases: ["cost"], run: (ctx) => ctx.info(ctx.describeUsage().join("\n")) },
+    {
+      name: "permissions",
+      description: "Show the permission mode and what is allowed",
+      run: (ctx) => ctx.info(ctx.describePermissions().join("\n"))
+    },
+    {
+      name: "doctor",
+      description: "Check the connection and your setup",
+      run: async (ctx) => ctx.info((await ctx.doctor()).join("\n"))
+    },
+    { name: "login", description: "Sign in again or switch account", run: (ctx) => ctx.exit("login") },
+    { name: "logout", description: "Sign out", run: (ctx) => ctx.exit("logout") },
+    { name: "exit", description: "Quit", aliases: ["quit"], run: (ctx) => ctx.exit("exit") }
+  ];
+}
+function parseFrontmatter(raw) {
+  const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/.exec(raw);
+  if (!match) return { body: raw };
+  const description = /^description:\s*(.+)$/m.exec(match[1])?.[1]?.trim();
+  return { description, body: match[2] };
+}
+async function readCommandDir(dir, source) {
+  let names;
+  try {
+    names = await readdir4(dir);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const file of names.filter((n) => n.endsWith(".md"))) {
+    const name = file.slice(0, -3).toLowerCase().replace(/[^a-z0-9_-]/g, "-");
+    try {
+      const { description, body } = parseFrontmatter(await readFile13(path17.join(dir, file), "utf8"));
+      if (!body.trim()) continue;
+      out.push({
+        name,
+        source,
+        args: /\$ARGUMENTS/.test(body) ? "[arguments]" : void 0,
+        description: description ?? body.trim().split("\n")[0].slice(0, 70),
+        run: (ctx, args) => {
+          const prompt = /\$ARGUMENTS/.test(body) ? body.replace(/\$ARGUMENTS/g, args) : args ? `${body}
+
+${args}` : body;
+          ctx.send(prompt.trim(), `/${name}${args ? ` ${args}` : ""}`);
+        }
+      });
+    } catch {
+    }
+  }
+  return out;
+}
+async function loadCustomCommands(cwd) {
+  const [project, user] = await Promise.all([
+    readCommandDir(path17.join(cwd, ".ad", "commands"), "project"),
+    readCommandDir(path17.join(getConfigDir(), "commands"), "user")
+  ]);
+  const taken = new Set(project.map((c) => c.name));
+  return [...project, ...user.filter((c) => !taken.has(c.name))];
+}
+function findCommand(commands, name) {
+  const n = name.toLowerCase();
+  return commands.find((c) => c.name === n) ?? commands.find((c) => c.aliases?.includes(n));
 }
 
 // src/tui/dialogs.tsx
@@ -4178,8 +5826,8 @@ function ShellView({ item }) {
     ] })
   ] });
 }
-function InfoLine({ text: text2, tone }) {
-  return /* @__PURE__ */ jsx3(Box3, { marginTop: 1, children: /* @__PURE__ */ jsx3(Text3, { color: tone === "warn" ? theme.warn : tone === "success" ? theme.success : void 0, dimColor: tone === void 0 || tone === "dim", children: text2 }) });
+function InfoLine({ text: text2, tone: tone2 }) {
+  return /* @__PURE__ */ jsx3(Box3, { marginTop: 1, children: /* @__PURE__ */ jsx3(Text3, { color: tone2 === "warn" ? theme.warn : tone2 === "success" ? theme.success : void 0, dimColor: tone2 === void 0 || tone2 === "dim", children: text2 }) });
 }
 function ErrorLine({ text: text2 }) {
   return /* @__PURE__ */ jsxs2(Box3, { marginTop: 1, children: [
@@ -4199,7 +5847,7 @@ function TodoList({ todos }) {
   ] });
 }
 function WorkingIndicator({
-  tokens,
+  tokens: tokens2,
   label,
   waiting,
   fallback
@@ -4223,7 +5871,7 @@ function WorkingIndicator({
       " "
     ] }),
     /* @__PURE__ */ jsx3(Text3, { color: theme.amber, children: label ?? waitLabel ?? fallback ?? `${verb}\u2026` }),
-    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: ` (esc to interrupt \xB7 ${seconds}s${tokens > 0 ? ` \xB7 \u2193 ${formatTokens(tokens)} tokens` : ""})` })
+    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: ` (esc to interrupt \xB7 ${seconds}s${tokens2 > 0 ? ` \xB7 \u2193 ${formatTokens(tokens2)} tokens` : ""})` })
   ] });
 }
 function formatTokens(n) {
@@ -4248,7 +5896,9 @@ function StatusLine(props) {
         /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: " (shift+tab to cycle)" })
       ] }) : /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: props.showHelpHint ? "? for shortcuts \xB7 shift+tab: permissions" : "shift+tab: permissions" }),
       props.running ? /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: " \xB7 esc to interrupt" }) : null,
-      props.queued > 0 ? /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: ` \xB7 ${props.queued} queued` }) : null
+      props.queued > 0 ? /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: ` \xB7 ${props.queued} queued` }) : null,
+      props.typingTo ? /* @__PURE__ */ jsx3(Text3, { color: "yellow", bold: true, children: ` \xB7 \u2192 typing to ${props.typingTo} (ctrl+o: main)` }) : null,
+      props.workers ? /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: ` \xB7 \u2699 ${props.workers} (/workers)` }) : null
     ] }) }),
     /* @__PURE__ */ jsxs2(Text3, { dimColor: true, children: [
       props.agentName,
@@ -4263,6 +5913,7 @@ var SHORTCUTS = [
   ["#", "add a note to AD.md"],
   ["shift+tab", "cycle permission mode"],
   ["esc", "interrupt the agent"],
+  ["ctrl+o", "switch between the main agent and the side session"],
   ["\u2191 / \u2193", "input history"],
   ["ctrl+j or \\ enter", "new line"],
   ["ctrl+c", "cancel \xB7 twice to exit"]
@@ -4385,6 +6036,14 @@ function optionsFor(request) {
       { answer: "deny", label: "No, and tell AI Draftsman what to do differently (esc)" }
     ];
   }
+  if (request.kind === "browser") {
+    const rule = request.key.replace(/^browser:/, "").replace("_", " ");
+    return [
+      { answer: "allow", label: "Yes" },
+      { answer: "allow_always", label: `Yes, and don't ask again for "${rule}" this session` },
+      { answer: "deny", label: "No, and tell AI Draftsman what to do differently (esc)" }
+    ];
+  }
   if (request.kind === "exec") {
     const rule = request.key.replace(/^bash:/, "");
     return [
@@ -4415,8 +6074,8 @@ function AskDialog({ request, onAnswer }) {
   const isPlan = request.toolName === "exit_plan_mode";
   const isArtifact = request.toolName === "create_artifact";
   const isContinue = request.toolName === "continue";
-  const title = isContinue ? "Step limit reached" : isPlan ? "Ready to code?" : isArtifact ? "Create artifact" : request.kind === "net" ? "Fetch web content" : request.kind === "external" ? "Use a connector" : request.kind === "exec" ? "Bash command" : request.kind === "write" ? isCreate ? "Create file" : "Edit file" : request.outside ? "Read outside the project" : toolTitle(request.toolName);
-  const question = isContinue ? "Continue?" : isPlan ? "Would you like to proceed?" : isArtifact ? `Do you want to create ${request.label.replace(/ \(\d+ sections\)$/, "")}?` : request.kind === "net" ? "Do you want to allow AI Draftsman to fetch this content?" : request.kind === "external" ? `Do you want AI Draftsman to run ${request.label} as you?` : request.kind === "exec" ? "Do you want to proceed?" : request.kind === "write" ? `Do you want to ${isCreate ? "create" : "make this edit to"} ${request.label}?` : `Allow ${toolTitle(request.toolName).toLowerCase()} of ${request.label}?`;
+  const title = isContinue ? "Step limit reached" : isPlan ? "Ready to code?" : isArtifact ? "Create artifact" : request.kind === "net" ? "Fetch web content" : request.kind === "browser" ? "Use your browser" : request.kind === "external" ? "Use a connector" : request.kind === "exec" ? "Bash command" : request.kind === "write" ? isCreate ? "Create file" : "Edit file" : request.outside ? "Read outside the project" : toolTitle(request.toolName);
+  const question = isContinue ? "Continue?" : isPlan ? "Would you like to proceed?" : isArtifact ? `Do you want to create ${request.label.replace(/ \(\d+ sections\)$/, "")}?` : request.kind === "net" ? "Do you want to allow AI Draftsman to fetch this content?" : request.kind === "browser" ? `Do you want AI Draftsman to ${request.label} in your Chrome?` : request.kind === "external" ? `Do you want AI Draftsman to run ${request.label} as you?` : request.kind === "exec" ? "Do you want to proceed?" : request.kind === "write" ? `Do you want to ${isCreate ? "create" : "make this edit to"} ${request.label}?` : `Allow ${toolTitle(request.toolName).toLowerCase()} of ${request.label}?`;
   return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", borderStyle: "round", borderColor: theme.amber, paddingX: 1, marginTop: 1, children: [
     /* @__PURE__ */ jsx4(Text4, { bold: true, color: theme.amber, children: title }),
     /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", marginTop: 1, paddingLeft: 1, children: display?.kind === "diff" ? /* @__PURE__ */ jsxs3(Fragment2, { children: [
@@ -4436,9 +6095,9 @@ function AskDialog({ request, onAnswer }) {
 }
 
 // src/lib/util/images.ts
-import { readFile as readFile10, stat as stat4 } from "fs/promises";
-import os4 from "os";
-import path13 from "path";
+import { readFile as readFile14, stat as stat6 } from "fs/promises";
+import os5 from "os";
+import path18 from "path";
 var MIME = {
   ".png": "image/png",
   ".jpg": "image/jpeg",
@@ -4449,16 +6108,16 @@ var MIME = {
 var MAX_IMAGE_BYTES = 5 * 1024 * 1024;
 var IMAGE_MENTION = /(?:^|\s)@(\S+?\.(?:png|jpe?g|gif|webp))(?=$|[\s,;:!?)\]])/gi;
 function resolveImagePath(cwd, file) {
-  const real = file === "~" || /^~[/\\]/.test(file) ? path13.join(os4.homedir(), file.slice(1)) : file;
-  return path13.resolve(cwd, real);
+  const real = file === "~" || /^~[/\\]/.test(file) ? path18.join(os5.homedir(), file.slice(1)) : file;
+  return path18.resolve(cwd, real);
 }
 async function loadImage(cwd, file) {
   const full = resolveImagePath(cwd, file);
-  const mime = MIME[path13.extname(full).toLowerCase()];
+  const mime = MIME[path18.extname(full).toLowerCase()];
   if (!mime) throw new CliError(`${file} is not a supported image (png, jpg, gif or webp).`, 3);
   let size;
   try {
-    const info = await stat4(full);
+    const info = await stat6(full);
     if (!info.isFile()) throw new Error("not a file");
     size = info.size;
   } catch {
@@ -4467,7 +6126,7 @@ async function loadImage(cwd, file) {
   if (size > MAX_IMAGE_BYTES) {
     throw new CliError(`${file} is ${(size / 1024 / 1024).toFixed(1)} MB; images must be under ${MAX_IMAGE_BYTES / 1024 / 1024} MB.`, 3);
   }
-  const data = await readFile10(full);
+  const data = await readFile14(full);
   return { type: "image_url", image_url: { url: `data:${mime};base64,${data.toString("base64")}` } };
 }
 function imageMentions(text2) {
@@ -4498,9 +6157,9 @@ import { Box as Box6, Text as Text6 } from "ink";
 import { useEffect as useEffect2, useMemo as useMemo3, useRef, useState as useState3 } from "react";
 
 // src/tui/path-complete.ts
-import { readdir as readdir4 } from "fs/promises";
-import os5 from "os";
-import path14 from "path";
+import { readdir as readdir5 } from "fs/promises";
+import os6 from "os";
+import path19 from "path";
 function isPathToken(token) {
   return /^(\.{1,2}([/\\]|$)|~([/\\]|$)|[/\\]|[A-Za-z]:)/.test(token) || /[/\\]/.test(token);
 }
@@ -4513,11 +6172,11 @@ async function completePath(cwd, token, limit = 50) {
   }
   const dirPart = typed.slice(0, slash + 1);
   const prefix = typed.slice(slash + 1).toLowerCase();
-  const real = dirPart.startsWith("~") ? path14.join(os5.homedir(), dirPart.slice(1)) : dirPart;
-  const dir = path14.resolve(cwd, real);
+  const real = dirPart.startsWith("~") ? path19.join(os6.homedir(), dirPart.slice(1)) : dirPart;
+  const dir = path19.resolve(cwd, real);
   let entries;
   try {
-    entries = await readdir4(dir, { withFileTypes: true });
+    entries = await readdir5(dir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -4820,22 +6479,215 @@ function PromptBox({ focus, cwd = process.cwd(), mode, commands, files, connecto
         }
       ) })
     ] }),
-    visible.length > 0 ? /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", paddingX: 2, children: [
-      visible.map((s, i) => {
-        const active = windowStart + i === sel;
-        return /* @__PURE__ */ jsxs5(Text6, { color: active ? theme.accent : void 0, dimColor: !active, children: [
-          active ? "\u276F " : "  ",
-          s.label.padEnd(labelWidth),
-          s.description ? /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: s.description }) : null
-        ] }, s.value);
-      }),
-      suggestions.length > MAX_SUGGESTIONS ? /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: `  \u2026 ${suggestions.length - MAX_SUGGESTIONS} more` }) : null
-    ] }) : null
+    visible.length > 0 ? /* @__PURE__ */ jsxs5(Box6, { flexDirection: "column", paddingX: 2, children: [
+      visible.map((s, i) => {
+        const active = windowStart + i === sel;
+        return /* @__PURE__ */ jsxs5(Text6, { color: active ? theme.accent : void 0, dimColor: !active, children: [
+          active ? "\u276F " : "  ",
+          s.label.padEnd(labelWidth),
+          s.description ? /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: s.description }) : null
+        ] }, s.value);
+      }),
+      suggestions.length > MAX_SUGGESTIONS ? /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: `  \u2026 ${suggestions.length - MAX_SUGGESTIONS} more` }) : null
+    ] }) : null
+  ] });
+}
+
+// src/tui/SidePane.tsx
+import { Box as Box7, Text as Text7 } from "ink";
+
+// src/tui/side.ts
+var MAX_SIDE_CONTEXT_CHARS = 12e3;
+var PER_MESSAGE_CHARS = 1500;
+var clip3 = (text2, max) => {
+  const flat = text2.trim();
+  return flat.length > max ? `${flat.slice(0, max - 1)}\u2026` : flat;
+};
+function snapshotConversation(history, max = MAX_SIDE_CONTEXT_CHARS) {
+  const lines = [];
+  let total = 0;
+  let cut2 = false;
+  for (let i = history.length - 1; i >= 0; i--) {
+    const m = history[i];
+    let line;
+    if (m.role === "user") {
+      const text2 = contentText(m.content).trim();
+      if (text2) line = `User: ${clip3(text2, PER_MESSAGE_CHARS)}`;
+    } else if (m.role === "assistant" && m.content?.trim()) {
+      line = `Agent: ${clip3(m.content, PER_MESSAGE_CHARS)}`;
+    }
+    if (!line) continue;
+    if (total + line.length > max && lines.length > 0) {
+      cut2 = true;
+      break;
+    }
+    lines.push(line);
+    total += line.length + 1;
+  }
+  lines.reverse();
+  return (cut2 ? ["(earlier messages left out)", ...lines] : lines).join("\n");
+}
+function buildSideBrief(snapshot, question) {
+  return [snapshot ? `Main conversation so far (for context only):
+${snapshot}` : "The main conversation has not started yet.", "", "The user's question:", question.trim()].join("\n");
+}
+function wrapText(text2, width) {
+  const w = Math.max(8, width);
+  const out = [];
+  for (const raw of text2.replace(/\r\n?/g, "\n").split("\n")) {
+    let line = "";
+    for (let word of raw.split(/\s+/).filter(Boolean)) {
+      while (word.length > w) {
+        if (line) {
+          out.push(line);
+          line = "";
+        }
+        out.push(word.slice(0, w));
+        word = word.slice(w);
+      }
+      if (!line) line = word;
+      else if (line.length + 1 + word.length <= w) line += ` ${word}`;
+      else {
+        out.push(line);
+        line = word;
+      }
+    }
+    out.push(line);
+  }
+  return out;
+}
+function sideTranscript(w, width) {
+  const lines = [];
+  w.history.forEach((m, index) => {
+    if (m.role === "user") {
+      const text2 = index === 0 && w.shown ? w.shown : contentText(m.content);
+      wrapText(text2, width - 2).forEach((l, i) => lines.push({ text: `${i === 0 ? "> " : "  "}${l}`, tone: "user" }));
+    } else if (m.role === "assistant") {
+      if (m.content?.trim()) for (const l of wrapText(m.content, width)) lines.push({ text: l, tone: "agent" });
+      for (const call2 of m.tool_calls ?? []) {
+        lines.push({ text: `\xB7 ${call2.function.name}(${describeCall(call2.function.name, call2.function.arguments)})`.slice(0, width), tone: "step" });
+      }
+    }
+  });
+  if (w.status === "running") lines.push({ text: `\u25CF ${w.activity ?? "thinking\u2026"}`.slice(0, width), tone: "status" });
+  else if (w.status === "queued") lines.push({ text: "\u25CC waiting for a slot", tone: "status" });
+  else if (w.status === "failed") lines.push({ text: `\u2717 ${w.error ?? "failed"}`.slice(0, width), tone: "status" });
+  else if (w.status === "cancelled") lines.push({ text: "\u2298 stopped", tone: "status" });
+  return lines;
+}
+function sideLines(w, width, maxLines) {
+  const all = sideTranscript(w, width);
+  if (all.length <= maxLines) return all;
+  const hidden = all.length - (maxLines - 1);
+  return [{ text: `\u2191 ${hidden} earlier line${hidden === 1 ? "" : "s"} \xB7 /side show`, tone: "dim" }, ...all.slice(all.length - (maxLines - 1))];
+}
+var SPLIT_MIN_COLUMNS = 110;
+var SPLIT_MAX_PANE = 56;
+function sideLayout(cols, rows) {
+  const split = cols >= SPLIT_MIN_COLUMNS;
+  return {
+    split,
+    paneWidth: split ? Math.min(SPLIT_MAX_PANE, Math.floor(cols * 0.42)) : Math.max(30, cols - 2),
+    paneLines: Math.max(6, Math.min(14, rows - 16))
+  };
+}
+function sideText(w) {
+  return sideTranscript(w, 100).map((l) => l.text).join("\n");
+}
+
+// src/tui/SidePane.tsx
+import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
+var STATE = {
+  queued: "waiting",
+  running: "working",
+  done: "ready",
+  failed: "failed",
+  cancelled: "stopped"
+};
+function tone(line) {
+  switch (line.tone) {
+    case "user":
+      return { color: theme.accent, bold: true, dim: false };
+    case "step":
+    case "dim":
+      return { color: void 0, bold: false, dim: true };
+    case "status":
+      return { color: theme.amber, bold: false, dim: false };
+    default:
+      return { color: void 0, bold: false, dim: false };
+  }
+}
+function SidePane({ worker, width, maxLines, focused }) {
+  const lines = sideLines(worker, Math.max(12, width - 4), maxLines);
+  return /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", width, borderStyle: "round", borderColor: focused ? theme.amber : theme.dim, paddingX: 1, children: [
+    /* @__PURE__ */ jsxs6(Text7, { children: [
+      /* @__PURE__ */ jsx7(Text7, { bold: true, color: focused ? theme.amber : void 0, children: `side \xB7 ${STATE[worker.status]}` }),
+      /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: focused ? "  \u2014 you are typing here" : "  \u2014 ctrl+o to type here" })
+    ] }),
+    lines.length === 0 ? /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "Asking\u2026" }) : null,
+    lines.map((line, i) => {
+      const t = tone(line);
+      return /* @__PURE__ */ jsx7(Text7, { color: t.color, bold: t.bold, dimColor: t.dim, children: line.text || " " }, i);
+    }),
+    /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "/side close \xB7 /side send \xB7 /side show" })
   ] });
 }
 
+// src/tui/rewind.ts
+import path20 from "path";
+var clip4 = (text2, max) => {
+  const flat = text2.replace(/\s+/g, " ").trim();
+  return flat.length > max ? `${flat.slice(0, max - 1)}\u2026` : flat;
+};
+function ago(at, now = Date.now()) {
+  const s = Math.max(0, Math.floor((now - at) / 1e3));
+  if (s < 45) return "just now";
+  const m = Math.round(s / 60);
+  if (m < 60) return `${m} min ago`;
+  const h = Math.round(m / 60);
+  return h < 24 ? `${h} h ago` : new Date(at).toLocaleDateString();
+}
+var plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+function rewindRows(store, now = Date.now()) {
+  return store.list().reverse().map((c) => {
+    const changed = store.changedSince(c.id).length;
+    const untracked = store.untrackedShellSince(c.id);
+    return {
+      value: String(c.id),
+      label: clip4(c.prompt, 70) || "(empty prompt)",
+      description: `${ago(c.at, now)} \xB7 ${changed ? `${plural(changed, "file")} changed since` : "no file changes since"}` + (untracked ? ` \xB7 ${plural(untracked, "shell command")} not tracked` : "")
+    };
+  });
+}
+function rewindModeRows(store, id) {
+  const files = store.changedSince(id).length;
+  const code = files ? `puts ${plural(files, "file")} back (files the agent created are deleted)` : "no files were changed";
+  return [
+    // Short labels: the picker clips them to a fixed column, and the description carries the detail.
+    { value: "both", label: "Code + conversation", description: `Go back to before this prompt; ${code}.` },
+    { value: "conversation", label: "Conversation only", description: "Forget everything after this prompt; keep the files as they are now." },
+    { value: "code", label: "Code only", description: `Keep the conversation; ${code}.` },
+    { value: "cancel", label: "Never mind", description: "Change nothing." }
+  ];
+}
+function describeRestore(report, cwd) {
+  const shown = (file) => {
+    const rel = path20.relative(cwd, file);
+    return rel && !rel.startsWith("..") ? rel : file;
+  };
+  const restored = report.restored.length;
+  const deleted = report.deleted.length;
+  const parts = [`${plural(restored, "file")} restored`];
+  if (deleted) parts.push(`${plural(deleted, "created file")} removed`);
+  const problems = [
+    ...report.failed.map((f) => `Could not restore ${shown(f.file)}: ${f.reason}`),
+    ...report.skipped.map((f) => `${shown(f)} is too large to have been saved, so it was not restored.`)
+  ];
+  return { summary: parts.join(", "), problems };
+}
+
 // src/tui/App.tsx
-import { Fragment as Fragment3, jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
+import { Fragment as Fragment3, jsx as jsx8, jsxs as jsxs7 } from "react/jsx-runtime";
 var CLEAR_SCREEN = "\x1B[2J\x1B[3J\x1B[H";
 function describeTtft(samples) {
   if (samples.length === 0) return "no requests yet";
@@ -4903,9 +6755,26 @@ function App(props) {
   const connectorsRef = useRef2([]);
   const [inputHistory, setInputHistory] = useState4([]);
   const [customCommands, setCustomCommands] = useState4([]);
-  const historyRef = useRef2(props.resume?.messages ?? []);
   const sessionRef = useRef2(props.resume ?? newSession(cwd, agent));
+  const historyRef = useRef2(sessionRef.current.messages);
   const rulesRef = useRef2(new AllowRules());
+  const checkpointsRef = useRef2(new CheckpointStore());
+  const savedRevRef = useRef2({ id: "", rev: -1 });
+  const persistCheckpoints = useCallback(() => {
+    const store = checkpointsRef.current;
+    const id = sessionRef.current.id;
+    if (savedRevRef.current.id === id && savedRevRef.current.rev === store.revision) return;
+    savedRevRef.current = { id, rev: store.revision };
+    void saveCheckpoints(id, store).catch(() => void 0);
+  }, []);
+  const adoptSavedCheckpoints = useCallback((id, messageCount) => {
+    void loadCheckpoints(id, messageCount).then((store) => {
+      if (store && sessionRef.current.id === id && checkpointsRef.current.list().length === 0) {
+        checkpointsRef.current = store;
+        savedRevRef.current = { id, rev: store.revision };
+      }
+    });
+  }, []);
   const readFilesRef = useRef2(/* @__PURE__ */ new Set());
   const abortRef = useRef2(null);
   const queueRef = useRef2([]);
@@ -4936,7 +6805,7 @@ function App(props) {
     return props.resume ? [first, { id: nextId(), kind: "info", text: `Resumed: ${props.resume.title}`, tone: "dim" }, ...itemsFromMessages(props.resume.messages, nextId)] : [first];
   });
   const push = useCallback((item) => setItems((prev) => [...prev, { ...item, id: nextId() }]), [nextId]);
-  const info = useCallback((text2, tone) => push({ kind: "info", text: text2, tone }), [push]);
+  const info = useCallback((text2, tone2) => push({ kind: "info", text: text2, tone: tone2 }), [push]);
   const showError = useCallback((text2) => push({ kind: "error", text: text2 }), [push]);
   const setMode = useCallback((next) => {
     modeRef.current = next;
@@ -4953,6 +6822,9 @@ function App(props) {
       live = false;
     };
   }, [props.refresh]);
+  useEffect3(() => {
+    if (props.resume) adoptSavedCheckpoints(props.resume.id, props.resume.messages.length);
+  }, []);
   useEffect3(() => {
     void loadInputHistory().then(setInputHistory);
     void loadCustomCommands(cwd).then(setCustomCommands);
@@ -4969,6 +6841,38 @@ function App(props) {
     };
   }, [cwd]);
   const commands = useMemo4(() => [...builtinCommands(), ...customCommands], [customCommands]);
+  const bus = useMemo4(() => props.bus ?? new SessionBus(), [props.bus]);
+  const sessionMailRef = useRef2([]);
+  const selfIdentity = useCallback(
+    () => ({ id: sessionRef.current.id, cwd, title: sessionRef.current.title, agent: agentRef.current.name }),
+    [cwd]
+  );
+  const sessionLink = useMemo4(
+    () => ({
+      list: async () => describeSessions(await bus.list(), selfIdentity().id).join("\n"),
+      send: async (to, text2) => {
+        const target = await bus.send(selfIdentity(), to, text2);
+        return `Delivered to session "${target.title || target.id.slice(0, 8)}" (${target.id.slice(0, 8)}). Its user will see it, and its agent gets it with their next prompt.`;
+      }
+    }),
+    [bus, selfIdentity]
+  );
+  useEffect3(() => {
+    void bus.start(selfIdentity, (m) => {
+      const who = `"${m.from.title || "untitled"}" (${m.from.id.slice(0, 8)})`;
+      const text2 = `[message from another session ${who}, working in ${m.from.cwd}]
+${m.text}`;
+      const shown = m.text.replace(/\s+/g, " ").slice(0, 200);
+      if (runningRef.current) {
+        sessionMailRef.current.push(text2);
+        info(`\u2709 message from session ${who}: ${shown} (the agent gets it now)`, "dim");
+      } else {
+        pendingContext.current += `${pendingContext.current ? "\n" : ""}${text2}`;
+        info(`\u2709 message from session ${who}: ${shown}`, "dim");
+      }
+    });
+    return () => void bus.stop();
+  }, [bus, info, selfIdentity]);
   const flushStream = useCallback(() => {
     flushTimer.current = null;
     setLiveText(streamRef.current);
@@ -5052,8 +6956,16 @@ function App(props) {
     [debug, flushStream, push]
   );
   const askChain = useRef2(Promise.resolve());
-  const askUser = useCallback((request) => {
-    const next = askChain.current.then(() => new Promise((resolve) => setDialog({ type: "ask", request, resolve })));
+  const askUser = useCallback((request, signal) => {
+    const next = askChain.current.then(
+      () => askWithSignal(
+        (answer) => {
+          setDialog({ type: "ask", request, resolve: answer });
+          return { close: () => setDialog((d) => d?.type === "ask" && d.resolve === answer ? null : d) };
+        },
+        signal
+      )
+    );
     askChain.current = next.catch(() => void 0);
     return next;
   }, []);
@@ -5072,6 +6984,126 @@ function App(props) {
     if (answer === "allow_always" && request.kind === "write") setMode("acceptEdits");
     resolve(answer);
   };
+  const [, setBoardTick] = useState4(0);
+  const coordRef = useRef2(null);
+  const runPromptRef = useRef2(() => void 0);
+  const maybeWakeRef = useRef2(() => void 0);
+  const workerBase = useRef2(void 0);
+  workerBase.current = {
+    config: config2,
+    cwd,
+    mode: () => modeRef.current,
+    setMode,
+    rules: rulesRef.current,
+    readFiles: readFilesRef.current,
+    sessionId: sessionRef.current.id,
+    model: () => pickSubagentModel(config2, agentRef.current.model),
+    toolFilter: sessionToolFilter({ artifacts: artifactsRef.current, orchestration: true }),
+    askFor: (worker, signal) => (request) => askUser({ ...request, label: `[${worker.name}] ${request.label}` }, signal),
+    checkpoint: (file) => checkpointsRef.current.recordBefore(file),
+    shellTracker: (cwd2, run2) => checkpointsRef.current.trackShell(cwd2, run2),
+    onUsage: (usage) => addUsage(sessionRef.current.usage, usage)
+  };
+  const orchestrator = useMemo4(
+    () => new Orchestrator(createWorkerRunner(() => workerBase.current), { maxRunning: maxParallelSubagents(config2, props.maxParallel) }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+  );
+  const [sideId, setSideId] = useState4(null);
+  const sideIdRef = useRef2(null);
+  const [focus, setFocusState] = useState4("main");
+  const focusRef = useRef2("main");
+  const setFocus = useCallback((next) => {
+    focusRef.current = next;
+    setFocusState(next);
+  }, []);
+  const sideWorker = () => {
+    const id = sideIdRef.current;
+    const w = id ? orchestrator.list().find((x) => x.id === id) : void 0;
+    return w && w.status !== "cancelled" ? w : void 0;
+  };
+  const closeSide = useCallback(() => {
+    const id = sideIdRef.current;
+    if (id) {
+      try {
+        orchestrator.cancel(id);
+      } catch {
+      }
+    }
+    sideIdRef.current = null;
+    setSideId(null);
+    setFocus("main");
+  }, [orchestrator, setFocus]);
+  const runsImmediately = (text2) => {
+    const t = text2.trim();
+    if (!t.startsWith("/") || t.startsWith("//")) return false;
+    const command = findCommand(commands, t.slice(1).split(/\s+/)[0] ?? "");
+    return !!command && ["side", "workers", "spawn", "stop", "msg", "code-review", "sessions", "send", "status", "usage", "permissions", "help"].includes(command.name);
+  };
+  const routesToSide = (text2) => focusRef.current === "side" && !!sideWorker() && !/^[/!#]/.test(text2.trim());
+  const sendToSide = (text2) => {
+    const w = sideWorker();
+    if (!w) return;
+    try {
+      orchestrator.send("you", w.name, text2);
+    } catch (error) {
+      showError(error instanceof Error ? error.message : String(error));
+    }
+  };
+  maybeWakeRef.current = () => {
+    const c = coordRef.current;
+    if (!c) return;
+    const workers = orchestrator.list().filter((w) => !w.interactive);
+    const ended = workers.filter((w) => (w.status === "done" || w.status === "failed" || w.status === "cancelled") && !c.reported.has(`${w.id}:${w.endedAt}`));
+    const live = workers.filter((w) => w.status === "queued" || w.status === "running").length;
+    const max = c.eager ? MAX_EAGER_ROUNDS : MAX_COORDINATOR_ROUNDS;
+    const decision = shouldWake({ running: runningRef.current, live, finished: ended.length, round: c.round, maxRounds: max, spawned: workers.length > 0, eager: c.eager });
+    if (decision === "wait") return;
+    if (decision !== "wake") {
+      coordRef.current = null;
+      return decision === "stop-idle" ? info("Coordinator off: the agent did not start any workers, so that ran as a normal prompt.", "dim") : info(`Coordinator stopped after ${max} rounds. Tell me what to do next.`, "warn");
+    }
+    for (const w of ended) c.reported.add(`${w.id}:${w.endedAt}`);
+    c.round++;
+    runPromptRef.current(wakePrompt(c.goal, c.round, max, live), `[coordinator] workers finished (round ${c.round})`);
+  };
+  useEffect3(() => {
+    if (phase === "idle") maybeWakeRef.current();
+  }, [phase]);
+  useEffect3(() => {
+    const seen = /* @__PURE__ */ new Map();
+    const off = orchestrator.subscribe(() => {
+      setBoardTick((t) => t + 1);
+      for (const w of orchestrator.list()) {
+        const before = seen.get(w.id);
+        seen.set(w.id, w.status);
+        if (!before || before === w.status) continue;
+        if (w.interactive) {
+          if (w.status === "failed") showError(`side session failed: ${w.error ?? "unknown error"}`);
+          if (w.status === "cancelled" && sideIdRef.current === w.id) setFocus("main");
+          continue;
+        }
+        if (w.status === "done") {
+          info(`\u2713 ${w.name} finished \xB7 /workers ${w.name} to read its report`, "success");
+          if (w.description.startsWith("Code review") && w.result) push({ kind: "assistant", text: w.result });
+          if (w.result) pendingContext.current += `${pendingContext.current ? "\n" : ""}Background agent "${w.name}" (${w.description}) finished. Its report:
+${w.result.slice(0, 3e3)}`;
+        } else if (w.status === "failed") {
+          showError(`${w.name} failed: ${w.error ?? "unknown error"}`);
+          pendingContext.current += `${pendingContext.current ? "\n" : ""}Background agent "${w.name}" (${w.description}) failed: ${w.error ?? "unknown error"}`;
+        } else if (w.status === "cancelled") {
+          pendingContext.current += `${pendingContext.current ? "\n" : ""}Background agent "${w.name}" (${w.description}) was stopped by the user before it finished.`;
+        }
+      }
+      maybeWakeRef.current();
+    });
+    const offMail = orchestrator.onMainMessage((m) => info(`\u2709 ${m.from} \u2192 you: ${m.text.replace(/\s+/g, " ").slice(0, 200)}`, "dim"));
+    return () => {
+      off();
+      offMail();
+      orchestrator.cancelAll();
+    };
+  }, [info, orchestrator, push, showError]);
   const finishTurn = useCallback(() => {
     runningRef.current = false;
     abortRef.current = null;
@@ -5082,6 +7114,7 @@ function App(props) {
     setWaiting(void 0);
     setTodos((prev) => prev.length && prev.every((t) => t.status === "completed") ? [] : prev);
     void saveSession(sessionRef.current).catch(() => void 0);
+    persistCheckpoints();
     const next = queueRef.current.shift();
     setQueued(queueRef.current.length);
     if (next) setTimeout(() => void processSubmission(next), 0);
@@ -5117,13 +7150,23 @@ function App(props) {
         setMode,
         rules: rulesRef.current,
         readFiles: readFilesRef.current,
+        checkpoint: (file) => checkpointsRef.current.recordBefore(file),
+        shellTracker: (cwd2, run2) => checkpointsRef.current.trackShell(cwd2, run2),
         ask: askUser,
         onEvent: handleEvent,
         signal: ac.signal,
         sessionId: sessionRef.current.id,
         tools: props.toolCalls,
         // The same list for every request of the session (plan mode is a permission, not a different list).
-        toolFilter: sessionToolFilter({ artifacts }),
+        toolFilter: sessionToolFilter({ artifacts, orchestration: true, sessions: true }),
+        // The lead can start workers, message them, and reads what they send it before each step.
+        team: orchestrator.bridgeFor("main", true),
+        drainInbox: () => [
+          ...orchestrator.takeMainMail().map((m) => ({ role: "user", content: `[message from ${m.from}] ${m.text}` })),
+          ...sessionMailRef.current.splice(0).map((content) => ({ role: "user", content }))
+        ],
+        // ...and can pass findings to other sessions on this machine.
+        sessions: sessionLink,
         ...config2.maxSteps ? { maxSteps: config2.maxSteps } : {},
         ...config2.subagentMaxSteps ? { subagentMaxSteps: config2.subagentMaxSteps } : {},
         maxParallel: maxParallelSubagents(config2, props.maxParallel),
@@ -5149,19 +7192,19 @@ function App(props) {
     } finally {
       finishTurn();
     }
-  }, [askUser, config2, cwd, finishTurn, handleEvent, info, props.maxParallel, props.toolCalls, push, setMode, showError]);
+  }, [askUser, config2, cwd, finishTurn, handleEvent, info, orchestrator, props.maxParallel, props.toolCalls, push, sessionLink, setMode, showError]);
   const runPrompt = useCallback(
     async (text2, display, images) => {
       const session = sessionRef.current;
       if (historyRef.current.length === 0) session.title = titleFrom(display ?? text2);
+      checkpointsRef.current.begin(titleFrom(display ?? text2), historyRef.current.length);
       push({ kind: "user", text: display ?? text2 });
       const note = connectorSelectionNote(text2, connectorsRef.current);
       const picked = note ? `${text2}
 
 ${note}` : text2;
-      const withContext = pendingContext.current ? `${pendingContext.current}
-
-${picked}` : picked;
+      const mail = orchestrator.takeMainMail().map((m) => `[message from ${m.from}] ${m.text}`).join("\n");
+      const withContext = [pendingContext.current, mail, picked].filter(Boolean).join("\n\n");
       pendingContext.current = "";
       let content;
       try {
@@ -5172,8 +7215,9 @@ ${picked}` : picked;
       historyRef.current.push({ role: "user", content });
       void startTurn();
     },
-    [cwd, push, showError, startTurn]
+    [cwd, orchestrator, push, showError, startTurn]
   );
+  runPromptRef.current = (text2, display) => void runPrompt(text2, display);
   const runShell = useCallback(
     async (command) => {
       const ac = new AbortController();
@@ -5209,9 +7253,11 @@ ${output.slice(0, 8e3)}`;
     [info]
   );
   const clearConversation = useCallback(() => {
-    historyRef.current = [];
     readFilesRef.current.clear();
+    checkpointsRef.current.clear();
+    closeSide();
     sessionRef.current = newSession(cwd, agentRef.current);
+    historyRef.current = sessionRef.current.messages;
     artifactsRef.current = false;
     pendingContext.current = "";
     warnedContext.current = false;
@@ -5221,7 +7267,7 @@ ${output.slice(0, 8e3)}`;
     stdout.write(CLEAR_SCREEN);
     setItems([headerItem(agentRef.current)]);
     setEpoch((e) => e + 1);
-  }, [cwd, headerItem, pastes, stdout]);
+  }, [closeSide, cwd, headerItem, pastes, stdout]);
   const compact = useCallback(
     async (instructions) => {
       if (historyRef.current.length < 2) return info("Nothing to compact yet.", "dim");
@@ -5247,11 +7293,14 @@ ${output.slice(0, 8e3)}`;
           },
           { signal: ac.signal }
         );
-        historyRef.current = [
+        historyRef.current.splice(
+          0,
+          historyRef.current.length,
           { role: "user", content: "Our conversation so far was compacted into this summary." },
           { role: "assistant", content: summary.content }
-        ];
+        );
         warnedContext.current = false;
+        checkpointsRef.current.clear();
         setContextTokens(0);
         info("Conversation compacted.", "success");
       } catch (error) {
@@ -5262,6 +7311,45 @@ ${output.slice(0, 8e3)}`;
     },
     [config2, cwd, finishTurn, info, showError]
   );
+  const applyRewind = useCallback(
+    async (id, mode2) => {
+      const store = checkpointsRef.current;
+      const point = store.get(id);
+      if (!point) return;
+      if (mode2 !== "conversation") {
+        const report = await store.restoreFiles(id);
+        const { summary, problems } = describeRestore(report, cwd);
+        for (const problem of problems) showError(problem);
+        const untracked = store.untrackedShellSince(id);
+        info(
+          `Code rewound: ${summary}.${untracked ? ` ${untracked} shell command${untracked === 1 ? "" : "s"} ran where changes could not be tracked (not a git repository, or git was too slow), so those were not undone.` : ""}`,
+          report.failed.length || untracked ? "warn" : "success"
+        );
+        readFilesRef.current.clear();
+      }
+      if (mode2 === "code") {
+        store.forgetFilesFrom(id);
+        persistCheckpoints();
+        return;
+      }
+      historyRef.current.splice(point.historyLength);
+      store.dropFrom(id);
+      pendingContext.current = "";
+      warnedContext.current = false;
+      setTodos([]);
+      setContextTokens(0);
+      stdout.write(CLEAR_SCREEN);
+      setItems([
+        headerItem(agentRef.current),
+        { id: nextId(), kind: "info", text: `Rewound to before: ${point.prompt}`, tone: "dim" },
+        ...itemsFromMessages(historyRef.current, nextId)
+      ]);
+      setEpoch((e) => e + 1);
+      void saveSession(sessionRef.current).catch(() => void 0);
+      persistCheckpoints();
+    },
+    [cwd, headerItem, info, nextId, persistCheckpoints, showError, stdout]
+  );
   const ctx = {
     info,
     error: showError,
@@ -5296,6 +7384,132 @@ ${output.slice(0, 8e3)}`;
     },
     compact: (instructions) => void compact(instructions),
     send: (prompt, display) => runPrompt(prompt, display),
+    review: (ref) => {
+      collectReviewTarget(cwd, ref.trim() || void 0).then(
+        (target) => {
+          try {
+            const w = orchestrator.spawn({ description: `Code review: ${target.label}`.slice(0, 50), prompt: buildReviewPrompt(target), type: "explore", name: "reviewer" });
+            const count = target.files.length + target.untracked.length;
+            info(`Reviewing ${target.label} (${count} file${count === 1 ? "" : "s"}) in the background as ${w.name} \xB7 /workers ${w.name} to follow it`, "success");
+          } catch (error) {
+            showError(error instanceof Error ? error.message : String(error));
+          }
+        },
+        (error) => showError(error instanceof Error ? error.message : String(error))
+      );
+    },
+    coordinate: (args) => {
+      const eager = /^--eager(\s|$)/.test(args.trim());
+      const goal = args.trim().replace(/^--eager\s*/, "").trim();
+      if (!goal) return info("Usage: /coordinate [--eager] <goal>   (or /coordinate off)", "warn");
+      if (goal.toLowerCase() === "off") {
+        coordRef.current = null;
+        return info("Coordinator off.", "dim");
+      }
+      coordRef.current = { goal, round: 0, reported: /* @__PURE__ */ new Set(), eager };
+      void runPrompt(coordinatorPrompt(goal, { eager }), `/coordinate ${eager ? "--eager " : ""}${goal}`);
+    },
+    workers: {
+      board: () => orchestrator.list().length ? setDialog({ type: "workers" }) : info("No background agents yet. Start one with /spawn <task>, or ask me to run several in parallel.", "dim"),
+      show: (query) => {
+        const w = orchestrator.find(query);
+        if (!w) return showError(`No background agent "${query}". See /workers.`);
+        info(describeWorker(w).join("\n"));
+      },
+      spawn: (task, name) => {
+        try {
+          const w = orchestrator.spawn({ description: task.split("\n")[0].slice(0, 50), prompt: task, type: "general", name });
+          info(`Started ${w.name} [${w.id}] in the background \xB7 /workers to watch it`, "success");
+        } catch (error) {
+          showError(error instanceof Error ? error.message : String(error));
+        }
+      },
+      stop: (query) => {
+        if (query.toLowerCase() === "all") {
+          const n = orchestrator.cancelAll();
+          return info(n ? `Stopped ${n} background agent${n === 1 ? "" : "s"}.` : "Nothing is running.", n ? "success" : "dim");
+        }
+        try {
+          const w = orchestrator.cancel(query);
+          info(`${w.name} is ${w.status}.`, "dim");
+        } catch (error) {
+          showError(error instanceof Error ? error.message : String(error));
+        }
+      },
+      message: (query, text2) => {
+        try {
+          info(orchestrator.send("main", query, text2), "success");
+        } catch (error) {
+          showError(error instanceof Error ? error.message : String(error));
+        }
+      }
+    },
+    rewind: () => {
+      if (runningRef.current) return info("Wait for the current turn to finish (or press esc to interrupt it) before rewinding.", "warn");
+      if (checkpointsRef.current.list().length === 0) return info("Nothing to rewind to yet: rewind points are made as you send prompts.", "dim");
+      setDialog({ type: "rewind" });
+    },
+    sessions: {
+      list: () => void bus.list().then(
+        (sessions) => info(describeSessions(sessions, selfIdentity().id).join("\n")),
+        (error) => showError(error instanceof Error ? error.message : String(error))
+      ),
+      send: (to, text2) => void bus.send(selfIdentity(), to, text2).then(
+        (target) => info(`Sent to session "${target.title || target.id.slice(0, 8)}" (${target.id.slice(0, 8)}).`, "success"),
+        (error) => showError(error instanceof Error ? error.message : String(error))
+      )
+    },
+    side: {
+      start: (question, edit) => {
+        if (!question) return info("Usage: /side [--edit] <question>", "warn");
+        const existing2 = sideWorker();
+        if (existing2) {
+          setFocus("side");
+          return sendToSide(question);
+        }
+        try {
+          const w = orchestrator.spawn({
+            name: "side",
+            description: `Side: ${question.replace(/\s+/g, " ").slice(0, 40)}`,
+            prompt: buildSideBrief(snapshotConversation(historyRef.current), question),
+            type: edit ? "general" : "explore",
+            interactive: true,
+            shown: question
+          });
+          sideIdRef.current = w.id;
+          setSideId(w.id);
+          setFocus("side");
+        } catch (error) {
+          showError(error instanceof Error ? error.message : String(error));
+        }
+      },
+      toggle: () => {
+        if (!sideWorker()) return info("No side session open. Start one with /side <question>.", "dim");
+        setFocus(focusRef.current === "side" ? "main" : "side");
+      },
+      focus: (target) => {
+        if (target === "side" && !sideWorker()) return info("No side session open. Start one with /side <question>.", "dim");
+        setFocus(target);
+      },
+      close: () => {
+        if (!sideIdRef.current) return info("No side session open.", "dim");
+        closeSide();
+        info("Side session closed.", "dim");
+      },
+      show: () => {
+        const id = sideIdRef.current;
+        const w = id ? orchestrator.list().find((x) => x.id === id) : void 0;
+        if (!w) return info("No side session open.", "dim");
+        info(sideText(w));
+      },
+      sendToMain: () => {
+        const w = sideWorker();
+        if (!w?.result) return info("The side session has not answered yet.", "dim");
+        pendingContext.current += `${pendingContext.current ? "\n" : ""}[from the user's side session]
+${w.result.slice(0, 3e3)}`;
+        info("The side session's last answer goes to the main agent with your next prompt.", "success");
+      }
+    },
     allCommands: () => commands,
     describeStatus: () => [
       `AI Draftsman v${VERSION}`,
@@ -5380,10 +7594,10 @@ ${output.slice(0, 8e3)}`;
       if (!note) return;
       push({ kind: "user", text: sub.display });
       try {
-        const file = path15.join(cwd, "AD.md");
+        const file = path21.join(cwd, "AD.md");
         let prefix = "";
         try {
-          prefix = (await readFile11(file, "utf8")).endsWith("\n") ? "" : "\n";
+          prefix = (await readFile15(file, "utf8")).endsWith("\n") ? "" : "\n";
         } catch {
         }
         await appendFile(file, `${prefix}- ${note}
@@ -5394,9 +7608,15 @@ ${output.slice(0, 8e3)}`;
       }
       return;
     }
+    if (routesToSide(text2)) return sendToSide(text2);
+    if (focusRef.current === "side") setFocus("main");
     void runPrompt(text2, sub.display);
   };
   const handleSubmit = (sub) => {
+    if (routesToSide(sub.text) || runsImmediately(sub.text)) {
+      void processSubmission(sub);
+      return;
+    }
     if (runningRef.current) {
       queueRef.current.push(sub);
       setQueued(queueRef.current.length);
@@ -5429,6 +7649,10 @@ ${output.slice(0, 8e3)}`;
         exitTimer.current = setTimeout(() => setExitHint(false), 2e3);
         return;
       }
+      if (key.ctrl && input === "o") {
+        if (sideWorker()) setFocus(focusRef.current === "side" ? "main" : "side");
+        return;
+      }
       if (key.ctrl && input === "d" && !runningRef.current) {
         result.action = "exit";
         exit();
@@ -5447,6 +7671,11 @@ ${output.slice(0, 8e3)}`;
     { isActive: dialog === null || dialog.type !== "ask" }
   );
   const rows = stdout.rows ?? 30;
+  const cols = stdout.columns ?? 100;
+  const sideShown = sideId ? orchestrator.list().find((w) => w.id === sideId) : void 0;
+  const layout = sideLayout(cols, rows);
+  const split = !!sideShown && layout.split;
+  const { paneWidth, paneLines } = layout;
   const agentItems = [
     { value: "__auto__", label: AUTO_AGENT.name, description: "let the gateway choose the model", hint: agent.model === AUTO_AGENT.model ? "(current)" : void 0 },
     ...agents.map((a) => ({
@@ -5459,47 +7688,52 @@ ${output.slice(0, 8e3)}`;
   const renderItem = (item) => {
     switch (item.kind) {
       case "header":
-        return /* @__PURE__ */ jsx7(Header, { agent: item.agent, account: item.account, cwd: item.cwd, notes: item.notes });
+        return /* @__PURE__ */ jsx8(Header, { agent: item.agent, account: item.account, cwd: item.cwd, notes: item.notes });
       case "user":
-        return /* @__PURE__ */ jsx7(UserMessage, { text: item.text });
+        return /* @__PURE__ */ jsx8(UserMessage, { text: item.text });
       case "assistant":
-        return /* @__PURE__ */ jsx7(AssistantMessage, { text: item.text });
+        return /* @__PURE__ */ jsx8(AssistantMessage, { text: item.text });
       case "tool":
-        return /* @__PURE__ */ jsx7(ToolView, { item });
+        return /* @__PURE__ */ jsx8(ToolView, { item });
       case "shell":
-        return /* @__PURE__ */ jsx7(ShellView, { item });
+        return /* @__PURE__ */ jsx8(ShellView, { item });
       case "info":
-        return /* @__PURE__ */ jsx7(InfoLine, { text: item.text, tone: item.tone });
+        return /* @__PURE__ */ jsx8(InfoLine, { text: item.text, tone: item.tone });
       case "error":
-        return /* @__PURE__ */ jsx7(ErrorLine, { text: item.text });
+        return /* @__PURE__ */ jsx8(ErrorLine, { text: item.text });
     }
   };
-  return /* @__PURE__ */ jsxs6(Fragment3, { children: [
-    /* @__PURE__ */ jsx7(Static, { items, children: (item) => /* @__PURE__ */ jsx7(Box7, { children: renderItem(item) }, item.id) }, epoch),
-    liveText ? /* @__PURE__ */ jsx7(AssistantMessage, { text: tailLines(liveText, Math.max(rows - 14, 6)) }) : null,
-    runningTools.map((t) => /* @__PURE__ */ jsxs6(Box7, { marginTop: 1, flexDirection: "column", children: [
-      /* @__PURE__ */ jsxs6(Text7, { children: [
-        /* @__PURE__ */ jsx7(Text7, { color: theme.amber, children: "\u25CF " }),
-        /* @__PURE__ */ jsx7(Text7, { bold: true, children: toolTitle(t.name) }),
-        /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: `(${t.label})` })
+  return /* @__PURE__ */ jsxs7(Fragment3, { children: [
+    /* @__PURE__ */ jsx8(Static, { items, children: (item) => /* @__PURE__ */ jsx8(Box8, { children: renderItem(item) }, item.id) }, epoch),
+    /* @__PURE__ */ jsxs7(Box8, { flexDirection: split ? "row" : "column", children: [
+      /* @__PURE__ */ jsxs7(Box8, { flexDirection: "column", flexGrow: 1, children: [
+        liveText ? /* @__PURE__ */ jsx8(AssistantMessage, { text: tailLines(liveText, Math.max(rows - 14, 6)) }) : null,
+        runningTools.map((t) => /* @__PURE__ */ jsxs7(Box8, { marginTop: 1, flexDirection: "column", children: [
+          /* @__PURE__ */ jsxs7(Text8, { children: [
+            /* @__PURE__ */ jsx8(Text8, { color: theme.amber, children: "\u25CF " }),
+            /* @__PURE__ */ jsx8(Text8, { bold: true, children: toolTitle(t.name) }),
+            /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: `(${t.label})` })
+          ] }),
+          t.name === "task" ? /* @__PURE__ */ jsxs7(Text8, { dimColor: true, children: [
+            "  \u23BF  ",
+            t.progress ? `${t.progress.activity} \xB7 ${t.progress.count} tool use${t.progress.count === 1 ? "" : "s"}` : "Starting\u2026"
+          ] }) : null
+        ] }, t.id)),
+        /* @__PURE__ */ jsx8(TodoList, { todos }),
+        phase === "running" && dialog === null ? /* @__PURE__ */ jsx8(
+          WorkingIndicator,
+          {
+            tokens: turnTokens,
+            label: workingLabel ?? statusText,
+            waiting: liveText || runningTools.length ? void 0 : waiting,
+            fallback: activityLabel(runningTools, liveText.length > 0)
+          }
+        ) : null
       ] }),
-      t.name === "task" ? /* @__PURE__ */ jsxs6(Text7, { dimColor: true, children: [
-        "  \u23BF  ",
-        t.progress ? `${t.progress.activity} \xB7 ${t.progress.count} tool use${t.progress.count === 1 ? "" : "s"}` : "Starting\u2026"
-      ] }) : null
-    ] }, t.id)),
-    /* @__PURE__ */ jsx7(TodoList, { todos }),
-    phase === "running" && dialog === null ? /* @__PURE__ */ jsx7(
-      WorkingIndicator,
-      {
-        tokens: turnTokens,
-        label: workingLabel ?? statusText,
-        waiting: liveText || runningTools.length ? void 0 : waiting,
-        fallback: activityLabel(runningTools, liveText.length > 0)
-      }
-    ) : null,
-    dialog?.type === "ask" ? /* @__PURE__ */ jsx7(AskDialog, { request: dialog.request, onAnswer: answerAsk }) : null,
-    dialog?.type === "agents" ? /* @__PURE__ */ jsx7(Box7, { marginTop: 1, children: /* @__PURE__ */ jsx7(
+      sideShown ? /* @__PURE__ */ jsx8(Box8, { marginTop: split ? 1 : 0, marginLeft: split ? 1 : 0, children: /* @__PURE__ */ jsx8(SidePane, { worker: sideShown, width: paneWidth, maxLines: paneLines, focused: focus === "side" }) }) : null
+    ] }),
+    dialog?.type === "ask" ? /* @__PURE__ */ jsx8(AskDialog, { request: dialog.request, onAnswer: answerAsk }) : null,
+    dialog?.type === "agents" ? /* @__PURE__ */ jsx8(Box8, { marginTop: 1, children: /* @__PURE__ */ jsx8(
       Picker,
       {
         title: dialog.first ? "Choose an agent to work with" : "Switch agent",
@@ -5528,7 +7762,64 @@ ${output.slice(0, 8e3)}`;
         }
       }
     ) }) : null,
-    dialog?.type === "sessions" ? /* @__PURE__ */ jsx7(Box7, { marginTop: 1, children: /* @__PURE__ */ jsx7(
+    dialog?.type === "workers" ? /* @__PURE__ */ jsx8(Box8, { marginTop: 1, children: /* @__PURE__ */ jsx8(
+      Picker,
+      {
+        title: "Background agents",
+        subtitle: "Enter to open one \xB7 esc to close \xB7 /spawn to start another",
+        items: orchestrator.list().map((w) => ({ value: w.id, ...workerRow(w) })),
+        onCancel: () => setDialog(null),
+        onSelect: (id) => setDialog({ type: "worker", id })
+      }
+    ) }) : null,
+    dialog?.type === "rewind" ? /* @__PURE__ */ jsx8(Box8, { marginTop: 1, children: /* @__PURE__ */ jsx8(
+      Picker,
+      {
+        title: "Rewind to before\u2026",
+        subtitle: "Pick the prompt to go back to \xB7 esc to cancel",
+        items: rewindRows(checkpointsRef.current),
+        onCancel: () => setDialog(null),
+        onSelect: (value) => setDialog({ type: "rewind-mode", id: Number(value) })
+      }
+    ) }) : null,
+    dialog?.type === "worker" ? /* @__PURE__ */ jsx8(Box8, { marginTop: 1, children: (() => {
+      const w = orchestrator.list().find((x) => x.id === dialog.id);
+      if (!w) return /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "That agent is gone." });
+      return /* @__PURE__ */ jsx8(
+        Picker,
+        {
+          title: `${w.name} \xB7 ${w.description}`,
+          subtitle: describeWorker(w).join("\n"),
+          items: [
+            { value: "back", label: "\u2190 Back to the list" },
+            ...w.status === "running" || w.status === "queued" ? [{ value: "stop", label: "Stop this agent" }] : [],
+            { value: "close", label: "Close" }
+          ],
+          onCancel: () => setDialog({ type: "workers" }),
+          onSelect: (choice2) => {
+            if (choice2 === "stop") {
+              orchestrator.cancel(w.id);
+              setDialog({ type: "workers" });
+            } else setDialog(choice2 === "back" ? { type: "workers" } : null);
+          }
+        }
+      );
+    })() }) : null,
+    dialog?.type === "rewind-mode" ? /* @__PURE__ */ jsx8(Box8, { marginTop: 1, children: /* @__PURE__ */ jsx8(
+      Picker,
+      {
+        title: `Rewind to before: ${checkpointsRef.current.get(dialog.id)?.prompt ?? ""}`,
+        subtitle: "What should be undone? Shell commands are tracked inside git repositories only.",
+        items: rewindModeRows(checkpointsRef.current, dialog.id),
+        onCancel: () => setDialog({ type: "rewind" }),
+        onSelect: (choice2) => {
+          const id = dialog.id;
+          setDialog(null);
+          if (choice2 !== "cancel") void applyRewind(id, choice2);
+        }
+      }
+    ) }) : null,
+    dialog?.type === "sessions" ? /* @__PURE__ */ jsx8(Box8, { marginTop: 1, children: /* @__PURE__ */ jsx8(
       Picker,
       {
         title: "Resume a conversation",
@@ -5549,6 +7840,8 @@ ${output.slice(0, 8e3)}`;
           agentRef.current = chosen.agent;
           setAgent(chosen.agent);
           readFilesRef.current.clear();
+          checkpointsRef.current.clear();
+          adoptSavedCheckpoints(chosen.id, chosen.messages.length);
           stdout.write(CLEAR_SCREEN);
           setItems([
             headerItem(chosen.agent),
@@ -5559,8 +7852,8 @@ ${output.slice(0, 8e3)}`;
         }
       }
     ) }) : null,
-    dialog === null ? /* @__PURE__ */ jsxs6(Box7, { flexDirection: "column", marginTop: 1, children: [
-      /* @__PURE__ */ jsx7(
+    dialog === null ? /* @__PURE__ */ jsxs7(Box8, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx8(
         PromptBox,
         {
           focus: true,
@@ -5575,8 +7868,8 @@ ${output.slice(0, 8e3)}`;
           onToggleHelp: () => setShowHelp((v) => !v)
         }
       ),
-      showHelp ? /* @__PURE__ */ jsx7(ShortcutsPanel, {}) : null,
-      /* @__PURE__ */ jsx7(
+      showHelp ? /* @__PURE__ */ jsx8(ShortcutsPanel, {}) : null,
+      /* @__PURE__ */ jsx8(
         StatusLine,
         {
           mode,
@@ -5585,7 +7878,9 @@ ${output.slice(0, 8e3)}`;
           contextTokens,
           exitHint,
           queued,
-          showHelpHint: !showHelp
+          showHelpHint: !showHelp,
+          workers: boardSummary(orchestrator.list()),
+          typingTo: sideShown && focus === "side" ? "side" : void 0
         }
       )
     ] }) : null
@@ -5593,7 +7888,7 @@ ${output.slice(0, 8e3)}`;
 }
 
 // src/tui/run.tsx
-import { jsx as jsx8 } from "react/jsx-runtime";
+import { jsx as jsx9 } from "react/jsx-runtime";
 async function runTui(options) {
   const { config: config2 } = options;
   const cwd = options.cwd ?? process.cwd();
@@ -5602,7 +7897,7 @@ async function runTui(options) {
   const agent = options.resume && !options.agent ? options.resume.agent : wanted ? findAgent(gateway.agents, wanted) : void 0;
   const result = { action: "exit" };
   const app = render(
-    /* @__PURE__ */ jsx8(
+    /* @__PURE__ */ jsx9(
       App,
       {
         config: config2,
@@ -5626,13 +7921,13 @@ async function runTui(options) {
 }
 
 // src/lib/update-check.ts
-import { mkdir as mkdir6, readFile as readFile12, writeFile as writeFile7 } from "fs/promises";
-import path16 from "path";
+import { mkdir as mkdir7, readFile as readFile16, writeFile as writeFile8 } from "fs/promises";
+import path22 from "path";
 var PACKAGE = "@consultancy-outfit/ai-draftsman-cli";
 var REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE.replace("/", "%2f")}/latest`;
 var CHECK_EVERY_MS = 24 * 60 * 60 * 1e3;
 var TIMEOUT_MS2 = 3e3;
-var cachePath2 = () => path16.join(getConfigDir(), "update-check.json");
+var cachePath2 = () => path22.join(getConfigDir(), "update-check.json");
 function compareVersions(a, b) {
   const parse = (v) => {
     const [core = "", pre] = v.trim().replace(/^v/, "").split("-", 2);
@@ -5650,7 +7945,7 @@ function compareVersions(a, b) {
 }
 async function readUpdateCache() {
   try {
-    const file = JSON.parse(await readFile12(cachePath2(), "utf8"));
+    const file = JSON.parse(await readFile16(cachePath2(), "utf8"));
     return Number.isFinite(file.checkedAt) ? file : void 0;
   } catch {
     return void 0;
@@ -5667,8 +7962,8 @@ async function refreshUpdateCache(fetchImpl = fetch) {
   } catch {
   }
   try {
-    await mkdir6(getConfigDir(), { recursive: true });
-    await writeFile7(cachePath2(), JSON.stringify(entry), "utf8");
+    await mkdir7(getConfigDir(), { recursive: true });
+    await writeFile8(cachePath2(), JSON.stringify(entry), "utf8");
   } catch {
   }
   return entry;
@@ -5787,8 +8082,8 @@ async function requireAuth() {
 
 // src/lib/app/headless.ts
 import { spawn as spawn3 } from "child_process";
-import { readFile as readFile13 } from "fs/promises";
-import path17 from "path";
+import { readFile as readFile17 } from "fs/promises";
+import path23 from "path";
 var CLAUDE_NAME = {
   bash: "Bash",
   read_file: "Read",
@@ -5816,6 +8111,7 @@ var GRANTS = {
   create_artifact: ["create_artifact"],
   web_fetch: ["web_fetch"],
   call_connector: ["call_connector"],
+  browser: ["browser"],
   // Claude Code's spellings for the connector server: the whole server, any tool on it, or the one tool.
   mcp__aidraftsman: ["call_connector"],
   "mcp__aidraftsman__*": ["call_connector"],
@@ -5847,7 +8143,7 @@ function claudeToolInput(name, rawArguments, cwd) {
   }
   const fileTool = name === "read_file" || name === "write_file" || name === "edit_file" || name === "create_artifact";
   if (fileTool && typeof args.path === "string") {
-    args.file_path = path17.resolve(cwd, args.path);
+    args.file_path = path23.resolve(cwd, args.path);
     delete args.path;
   }
   return args;
@@ -5876,6 +8172,10 @@ function applyAllowedTools(rules, values) {
       } else if (name === "webfetch" || name === "web_fetch") {
         const host = scope.replace(/^domain:/, "").trim();
         if (host) rules.add(`web:${host}`);
+      } else if (name === "browser") {
+        const actions = scope === "read" ? ["list_tabs", "read_page"] : [scope];
+        if (actions.every((a) => BROWSER_ACTIONS.includes(a))) for (const a of actions) rules.add(`browser:${a}`);
+        else unknown.push(spec);
       } else if (GRANTS[name]) {
         for (const tool of GRANTS[name]) rules.grantTool(tool);
       } else if (!NO_GRANT_NEEDED.has(name) && !name.startsWith("mcp__")) unknown.push(spec);
@@ -5891,7 +8191,7 @@ async function loadPreToolUseHooks(value) {
   let text2 = value.trim();
   if (!text2.startsWith("{")) {
     try {
-      text2 = await readFile13(value, "utf8");
+      text2 = await readFile17(value, "utf8");
     } catch (error) {
       throw new CliError(`--settings: cannot read ${value} (${error.message}).`, 3);
     }
@@ -6307,14 +8607,14 @@ function extractText(value) {
 }
 
 // src/lib/util/input.ts
-import { readFile as readFile14 } from "fs/promises";
+import { readFile as readFile18 } from "fs/promises";
 import process2 from "process";
 async function resolveTextInput(options) {
   if (options.message) {
     return options.message;
   }
   if (options.file) {
-    return readFile14(options.file, "utf8");
+    return readFile18(options.file, "utf8");
   }
   if (!process2.stdin.isTTY) {
     const chunks = [];
@@ -6426,6 +8726,399 @@ function registerAuthCommands(program) {
   });
 }
 
+// src/lib/browser/host.ts
+import { randomBytes, randomUUID as randomUUID5, timingSafeEqual } from "crypto";
+import { mkdir as mkdir9, rm as rm6 } from "fs/promises";
+import net2 from "net";
+import path25 from "path";
+
+// src/lib/browser/chat.ts
+import { spawn as spawn4 } from "child_process";
+import { mkdir as mkdir8 } from "fs/promises";
+import path24 from "path";
+var CHAT_PREAMBLE = `You are AI Draftsman inside the user's Chrome side panel. The user is looking at their browser right now. Use the browser tool to see and act on their pages: read_page first, then click or type by ref. Answer briefly. If a browser action is refused, tell the user to switch the panel to "Read and act".
+
+User: `;
+function allowedToolsFor(mode) {
+  return mode === "act" ? "browser" : "browser(read)";
+}
+function parseStreamLine(line) {
+  let event;
+  try {
+    event = JSON.parse(line);
+  } catch {
+    return [];
+  }
+  const out = [];
+  if (event.type === "system" && typeof event.session_id === "string") out.push({ kind: "session", sessionId: event.session_id });
+  const blocks = Array.isArray(event.message?.content) ? event.message.content : [];
+  if (event.type === "assistant") {
+    for (const b of blocks) {
+      if (b.type === "text" && b.text?.trim()) out.push({ kind: "text", text: b.text });
+      if (b.type === "tool_use" && typeof b.id === "string") out.push({ kind: "tool", id: b.id, label: describeTool(b.name ?? "", b.input ?? {}) });
+    }
+  } else if (event.type === "user") {
+    for (const b of blocks) if (b.type === "tool_result" && typeof b.tool_use_id === "string") out.push({ kind: "tool_result", id: b.tool_use_id, error: b.is_error === true });
+  } else if (event.type === "result") {
+    if (typeof event.session_id === "string") out.push({ kind: "session", sessionId: event.session_id });
+    out.push(event.is_error ? { kind: "error", text: event.result || "The agent stopped with an error." } : { kind: "done", text: event.result ?? "" });
+  }
+  return out;
+}
+function describeTool(name, input) {
+  if (name !== "browser") return name;
+  const action = String(input.action ?? "");
+  if (action === "navigate") return `Open ${String(input.url ?? "")}`;
+  if (action === "read_page") return "Read the page";
+  if (action === "list_tabs") return "List tabs";
+  if (action === "click") return `Click [${String(input.ref ?? "")}]`;
+  if (action === "type") return `Type into [${String(input.ref ?? "")}]`;
+  return `Browser ${action}`;
+}
+async function chatDir() {
+  const dir = path24.join(getConfigDir(), "browser", "chat");
+  await mkdir8(dir, { recursive: true, mode: 448 });
+  return dir;
+}
+async function startChat(options) {
+  const node = options.node ?? process.execPath;
+  const entry = options.entry ?? process.argv[1];
+  const args = [
+    entry,
+    "-p",
+    "--output-format",
+    "stream-json",
+    "--allowedTools",
+    allowedToolsFor(options.mode),
+    ...options.resume ? ["--resume", options.resume] : [],
+    ...options.extraArgs ?? [],
+    CHAT_PREAMBLE + options.text
+  ];
+  const child = spawn4(node, args, { cwd: options.cwd ?? await chatDir(), stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
+  let buffer = "";
+  let stderr = "";
+  let sawResult = false;
+  child.stdout.setEncoding("utf8");
+  child.stdout.on("data", (chunk) => {
+    buffer += chunk;
+    let nl;
+    while ((nl = buffer.indexOf("\n")) >= 0) {
+      const line = buffer.slice(0, nl).trim();
+      buffer = buffer.slice(nl + 1);
+      if (!line) continue;
+      for (const e of parseStreamLine(line)) {
+        if (e.kind === "done" || e.kind === "error") sawResult = true;
+        options.onEvent(e);
+      }
+    }
+  });
+  child.stderr.setEncoding("utf8");
+  child.stderr.on("data", (chunk) => stderr = (stderr + chunk).slice(-2e3));
+  const finished = new Promise((resolve) => {
+    child.on("error", (error) => {
+      if (!sawResult) options.onEvent({ kind: "error", text: `Could not start the agent: ${error.message}` });
+      sawResult = true;
+      resolve();
+    });
+    child.on("close", (code) => {
+      if (!sawResult) options.onEvent({ kind: "error", text: stderr.trim().split("\n").slice(-3).join(" ") || `The agent exited with code ${code}.` });
+      resolve();
+    });
+  });
+  return { stop: () => child.kill(), finished };
+}
+
+// src/lib/browser/host.ts
+function safeEqual(a, b) {
+  const x = Buffer.from(a);
+  const y = Buffer.from(b);
+  return x.length === y.length && timingSafeEqual(x, y);
+}
+async function startHost(options) {
+  const endpoint = options.endpoint ?? defaultEndpoint();
+  const infoFile = options.infoPath ?? hostInfoPath();
+  const timeoutMs = options.requestTimeoutMs ?? 3e4;
+  const log = options.log ?? ((line) => process.stderr.write(`[browser-host] ${line}
+`));
+  const token = randomBytes(24).toString("hex");
+  const info = { endpoint, token, pid: process.pid, startedAt: Date.now() };
+  const pending = /* @__PURE__ */ new Map();
+  let extensionReady = false;
+  let extensionVersion = "";
+  let stopped = false;
+  const toExtension = (message) => options.stdout.write(encodeFrame(message));
+  const runs = /* @__PURE__ */ new Map();
+  const launch = options.startChat ?? startChat;
+  function handleChat(m) {
+    if (typeof m.id !== "string") return;
+    if (m.type === "chat_stop") {
+      runs.get(m.id)?.stop();
+      return;
+    }
+    const text2 = typeof m.text === "string" ? m.text.slice(0, 8e3) : "";
+    if (!text2.trim() || runs.has(m.id)) return;
+    const send = (event) => {
+      if (!stopped) toExtension({ type: "chat_event", id: m.id, event });
+    };
+    const mode = m.mode === "act" ? "act" : "read";
+    launch({ text: text2, mode, ...typeof m.resume === "string" && m.resume ? { resume: m.resume } : {}, onEvent: send }).then(
+      (run2) => {
+        runs.set(m.id, run2);
+        void run2.finished.then(() => runs.delete(m.id));
+      },
+      (error) => send({ kind: "error", text: error.message })
+    );
+  }
+  const decoder = new FrameDecoder();
+  options.stdin.on("data", (chunk) => {
+    let messages;
+    try {
+      messages = decoder.push(chunk);
+    } catch (error) {
+      log(`bad frame from the extension: ${error.message}`);
+      void stop();
+      return;
+    }
+    for (const message of messages) {
+      const m = message;
+      if (m.type === "hello") {
+        extensionReady = true;
+        extensionVersion = typeof m.version === "string" ? m.version : "";
+        continue;
+      }
+      if (m.type === "chat" || m.type === "chat_stop") {
+        handleChat(message);
+        continue;
+      }
+      if (typeof m.id !== "string") continue;
+      const entry = pending.get(m.id);
+      if (!entry) continue;
+      pending.delete(m.id);
+      clearTimeout(entry.timer);
+      entry.reply(m);
+    }
+  });
+  const failAll = (error) => {
+    for (const [id, entry] of pending) {
+      clearTimeout(entry.timer);
+      entry.reply({ id, ok: false, error });
+    }
+    pending.clear();
+  };
+  const server = net2.createServer((socket) => {
+    let authed = false;
+    let buffer = "";
+    const send = (message) => {
+      if (!socket.destroyed) socket.write(`${JSON.stringify(message)}
+`);
+    };
+    const handle = (line) => {
+      let message;
+      try {
+        message = JSON.parse(line);
+      } catch {
+        return send({ id: "", ok: false, error: "Not valid JSON." });
+      }
+      const id = typeof message.id === "string" ? message.id : randomUUID5();
+      if (!authed) {
+        if (typeof message.token !== "string" || !safeEqual(message.token, token)) {
+          send({ id, ok: false, error: "Bad token." });
+          return socket.destroy();
+        }
+        authed = true;
+        return send({ id, ok: true, result: { connected: extensionReady, extensionVersion, pid: process.pid } });
+      }
+      if (message.action === "status") return send({ id, ok: true, result: { connected: extensionReady, extensionVersion, pending: pending.size } });
+      if (!isBrowserAction(message.action)) return send({ id, ok: false, error: `Unknown browser action "${String(message.action)}".` });
+      if (!extensionReady) return send({ id, ok: false, error: "The AI Draftsman extension is not connected. Open Chrome with the extension installed." });
+      const args = message.args && typeof message.args === "object" ? message.args : {};
+      const timer = setTimeout(() => {
+        pending.delete(id);
+        send({ id, ok: false, error: `The browser did not answer within ${Math.round(timeoutMs / 1e3)}s.` });
+      }, timeoutMs);
+      pending.set(id, { timer, reply: (response) => send({ ...response, id }) });
+      try {
+        toExtension({ id, action: message.action, args });
+      } catch (error) {
+        pending.delete(id);
+        clearTimeout(timer);
+        send({ id, ok: false, error: error.message });
+      }
+    };
+    socket.setEncoding("utf8");
+    socket.on("data", (chunk) => {
+      buffer += chunk;
+      if (Buffer.byteLength(buffer) > MAX_CLIENT_LINE_BYTES) return socket.destroy();
+      let nl;
+      while ((nl = buffer.indexOf("\n")) >= 0) {
+        const line = buffer.slice(0, nl).trim();
+        buffer = buffer.slice(nl + 1);
+        if (line) handle(line);
+      }
+    });
+    socket.on("error", () => void 0);
+  });
+  if (process.platform !== "win32") await rm6(endpoint, { force: true });
+  await mkdir9(path25.dirname(infoFile), { recursive: true, mode: 448 });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(endpoint, () => resolve());
+  });
+  await writePrivateFile(infoFile, JSON.stringify(info));
+  let closeResolve;
+  const closed = new Promise((resolve) => closeResolve = resolve);
+  async function stop() {
+    if (stopped) return;
+    stopped = true;
+    for (const run2 of runs.values()) run2.stop();
+    failAll("The browser connection closed.");
+    await new Promise((resolve) => server.close(() => resolve()));
+    await rm6(infoFile, { force: true });
+    if (process.platform !== "win32") await rm6(endpoint, { force: true });
+    closeResolve();
+  }
+  options.stdin.on("end", () => void stop());
+  options.stdin.on("close", () => void stop());
+  return { info, closed, stop };
+}
+
+// src/lib/browser/install.ts
+import { execFile as execFile3 } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+import { chmod as chmod3, mkdir as mkdir10, readFile as readFile19, rm as rm7, writeFile as writeFile9 } from "fs/promises";
+import os7 from "os";
+import path26 from "path";
+import { fileURLToPath } from "url";
+import { promisify as promisify2 } from "util";
+var run = promisify2(execFile3);
+function buildHostFiles(input) {
+  const { platform, nodePath, entry, extensionId, launcherPath } = input;
+  const manifest = {
+    name: HOST_NAME,
+    description: "AI Draftsman browser bridge",
+    path: launcherPath,
+    type: "stdio",
+    allowed_origins: [`chrome-extension://${extensionId}/`]
+  };
+  const launcher = platform === "win32" ? `@echo off\r
+"${nodePath}" "${entry}" browser host %*\r
+` : `#!/bin/sh
+exec "${nodePath}" "${entry}" browser host "$@"
+`;
+  return { manifest, launcher };
+}
+function findExtensionDir(from = path26.dirname(fileURLToPath(import.meta.url))) {
+  let dir = from;
+  for (let i = 0; i < 6; i++) {
+    const candidate = path26.join(dir, "extension", "chrome");
+    if (existsSync2(path26.join(candidate, "manifest.json"))) return candidate;
+    dir = path26.dirname(dir);
+  }
+  throw new Error("Could not find the extension folder (extension/chrome).");
+}
+async function readExtensionId(extensionDir) {
+  return (await readFile19(path26.join(extensionDir, "EXTENSION_ID"), "utf8")).trim();
+}
+var REGISTRY_ROOTS = ["HKCU\\Software\\Google\\Chrome\\NativeMessagingHosts", "HKCU\\Software\\Microsoft\\Edge\\NativeMessagingHosts"];
+function manifestDirs(platform) {
+  const home = os7.homedir();
+  if (platform === "darwin") {
+    return [
+      path26.join(home, "Library", "Application Support", "Google", "Chrome", "NativeMessagingHosts"),
+      path26.join(home, "Library", "Application Support", "Microsoft Edge", "NativeMessagingHosts")
+    ];
+  }
+  return [path26.join(home, ".config", "google-chrome", "NativeMessagingHosts"), path26.join(home, ".config", "microsoft-edge", "NativeMessagingHosts")];
+}
+async function installHost(options = {}) {
+  const platform = process.platform;
+  const extensionDir = findExtensionDir();
+  const extensionId = await readExtensionId(extensionDir);
+  const entry = options.entry ?? process.argv[1];
+  if (!entry || !/\.(m?js|cjs)$/.test(entry)) {
+    throw new Error("Run `ad browser install` from the installed CLI (or `npm run build` first); the launcher needs a built entry file.");
+  }
+  const dir = path26.join(getConfigDir(), "browser");
+  await mkdir10(dir, { recursive: true, mode: 448 });
+  const launcherPath = path26.join(dir, platform === "win32" ? "host.cmd" : "host.sh");
+  const manifestPath = path26.join(dir, `${HOST_NAME}.json`);
+  const { manifest, launcher } = buildHostFiles({ platform, nodePath: process.execPath, entry: path26.resolve(entry), extensionId, launcherPath });
+  await writeFile9(launcherPath, launcher, "utf8");
+  if (platform !== "win32") await chmod3(launcherPath, 493);
+  await writeFile9(manifestPath, JSON.stringify(manifest, null, 2), "utf8");
+  if (platform === "win32") {
+    for (const root of REGISTRY_ROOTS) {
+      await run("reg", ["add", `${root}\\${HOST_NAME}`, "/ve", "/t", "REG_SZ", "/d", manifestPath, "/f"]);
+    }
+  } else {
+    for (const target of manifestDirs(platform)) {
+      await mkdir10(target, { recursive: true });
+      await writeFile9(path26.join(target, `${HOST_NAME}.json`), JSON.stringify(manifest, null, 2), "utf8");
+    }
+  }
+  return { manifestPath, launcherPath, extensionDir, extensionId };
+}
+async function uninstallHost() {
+  if (process.platform === "win32") {
+    for (const root of REGISTRY_ROOTS) await run("reg", ["delete", `${root}\\${HOST_NAME}`, "/f"]).catch(() => void 0);
+  } else {
+    for (const target of manifestDirs(process.platform)) await rm7(path26.join(target, `${HOST_NAME}.json`), { force: true });
+  }
+  await rm7(path26.join(getConfigDir(), "browser"), { recursive: true, force: true });
+}
+
+// src/commands/browser/index.ts
+function registerBrowserCommands(program) {
+  const browser = program.command("browser").description("AI Draftsman for Chrome: let the CLI and desktop app use your browser");
+  browser.command("install").description("Register the browser bridge with Chrome and Edge, and show how to load the extension").action(async () => {
+    const result = await installHost();
+    process.stdout.write(
+      [
+        "Browser bridge registered.",
+        `  host manifest: ${result.manifestPath}`,
+        `  extension id:  ${result.extensionId}`,
+        "",
+        "Now load the extension (once):",
+        "  1. Open chrome://extensions and turn on Developer mode.",
+        '  2. Click "Load unpacked" and choose:',
+        `     ${result.extensionDir}`,
+        '  3. Click the AI Draftsman icon to open the side panel; it should say "Connected".',
+        "",
+        "Check with: ad browser status",
+        ""
+      ].join("\n")
+    );
+  });
+  browser.command("uninstall").description("Remove the browser bridge registration").action(async () => {
+    await uninstallHost();
+    process.stdout.write("Browser bridge removed. Remove the extension in chrome://extensions if you no longer want it.\n");
+  });
+  browser.command("status").description("Show whether Chrome and the extension are connected").action(async () => {
+    try {
+      const status = await browserCall("status");
+      process.stdout.write(
+        status.connected ? `Connected: AI Draftsman for Chrome ${status.extensionVersion ?? ""}
+` : "The bridge is running but the extension has not connected. Open Chrome with the extension loaded.\n"
+      );
+    } catch (error) {
+      process.stdout.write(`${error.message}
+`);
+      process.exitCode = 1;
+    }
+  });
+  browser.command("call").description("Run one browser action by hand (for testing), e.g. ad browser call read_page").argument("<action>", BROWSER_ACTIONS.join(" | ")).argument("[json]", "Arguments as a JSON object", "{}").action(async (action, json) => {
+    if (!isBrowserAction(action)) throw new Error(`Unknown action "${action}". Use one of: ${BROWSER_ACTIONS.join(", ")}.`);
+    const result = await browserCall(action, JSON.parse(json));
+    process.stdout.write(`${typeof result === "string" ? result : JSON.stringify(result, null, 2)}
+`);
+  });
+  browser.command("host", { hidden: true }).allowUnknownOption().allowExcessArguments().action(async () => {
+    const host = await startHost({ stdin: process.stdin, stdout: process.stdout });
+    await host.closed;
+    process.exit(0);
+  });
+}
+
 // src/lib/output/stream.ts
 function printStreamText(text2) {
   process.stdout.write(text2);
@@ -6814,6 +9507,7 @@ function buildCli() {
   registerConnectorsCommands(program);
   registerMcpCommands(program);
   registerSessionCommands(program);
+  registerBrowserCommands(program);
   return program;
 }