codecaine-cli 0.1.0 → 0.1.2

package/dist/cli.mjs

@@ -2269,10 +2269,10 @@ var require_websocket = __commonJS({
     "use strict";
     var EventEmitter = __require("events");
     var https2 = __require("https");
-    var http3 = __require("http");
-    var net2 = __require("net");
+    var http4 = __require("http");
+    var net3 = __require("net");
     var tls2 = __require("tls");
-    var { randomBytes, createHash: createHash2 } = __require("crypto");
+    var { randomBytes: randomBytes2, createHash: createHash2 } = __require("crypto");
     var { Duplex, Readable: Readable2 } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -2823,8 +2823,8 @@ var require_websocket = __commonJS({
         }
       }
       const defaultPort = isSecure ? 443 : 80;
-      const key = randomBytes(16).toString("base64");
-      const request = isSecure ? https2.request : http3.request;
+      const key = randomBytes2(16).toString("base64");
+      const request = isSecure ? https2.request : http4.request;
       const protocolSet = /* @__PURE__ */ new Set();
       let perMessageDeflate;
       opts.createConnection = opts.createConnection || (isSecure ? tlsConnect : netConnect);
@@ -3027,12 +3027,12 @@ var require_websocket = __commonJS({
     }
     function netConnect(options) {
       options.path = options.socketPath;
-      return net2.connect(options);
+      return net3.connect(options);
     }
     function tlsConnect(options) {
       options.path = void 0;
       if (!options.servername && options.servername !== "") {
-        options.servername = net2.isIP(options.host) ? "" : options.host;
+        options.servername = net3.isIP(options.host) ? "" : options.host;
       }
       return tls2.connect(options);
     }
@@ -3320,7 +3320,7 @@ var require_websocket_server = __commonJS({
   "node_modules/ws/lib/websocket-server.js"(exports, module) {
     "use strict";
     var EventEmitter = __require("events");
-    var http3 = __require("http");
+    var http4 = __require("http");
     var { Duplex } = __require("stream");
     var { createHash: createHash2 } = __require("crypto");
     var extension2 = require_extension();
@@ -3401,8 +3401,8 @@ var require_websocket_server = __commonJS({
           );
         }
         if (options.port != null) {
-          this._server = http3.createServer((req, res) => {
-            const body = http3.STATUS_CODES[426];
+          this._server = http4.createServer((req, res) => {
+            const body = http4.STATUS_CODES[426];
             res.writeHead(426, {
               "Content-Length": body.length,
               "Content-Type": "text/plain"
@@ -3487,10 +3487,10 @@ var require_websocket_server = __commonJS({
             process.nextTick(emitClose, this);
           }
         } else {
-          const server = this._server;
+          const server2 = this._server;
           this._removeListeners();
           this._removeListeners = this._server = null;
-          server.close(() => {
+          server2.close(() => {
             emitClose(this);
           });
         }
@@ -3675,23 +3675,23 @@ var require_websocket_server = __commonJS({
       }
     };
     module.exports = WebSocketServer2;
-    function addListeners(server, map) {
-      for (const event of Object.keys(map)) server.on(event, map[event]);
+    function addListeners(server2, map) {
+      for (const event of Object.keys(map)) server2.on(event, map[event]);
       return function removeListeners() {
         for (const event of Object.keys(map)) {
-          server.removeListener(event, map[event]);
+          server2.removeListener(event, map[event]);
         }
       };
     }
-    function emitClose(server) {
-      server._state = CLOSED;
-      server.emit("close");
+    function emitClose(server2) {
+      server2._state = CLOSED;
+      server2.emit("close");
     }
     function socketOnError() {
       this.destroy();
     }
     function abortHandshake(socket, code, message, headers) {
-      message = message || http3.STATUS_CODES[code];
+      message = message || http4.STATUS_CODES[code];
       headers = {
         Connection: "close",
         "Content-Type": "text/html",
@@ -3700,15 +3700,15 @@ var require_websocket_server = __commonJS({
       };
       socket.once("finish", socket.destroy);
       socket.end(
-        `HTTP/1.1 ${code} ${http3.STATUS_CODES[code]}\r
+        `HTTP/1.1 ${code} ${http4.STATUS_CODES[code]}\r
 ` + Object.keys(headers).map((h) => `${h}: ${headers[h]}`).join("\r\n") + "\r\n\r\n" + message
       );
     }
-    function abortHandshakeOrEmitwsClientError(server, req, socket, code, message, headers) {
-      if (server.listenerCount("wsClientError")) {
+    function abortHandshakeOrEmitwsClientError(server2, req, socket, code, message, headers) {
+      if (server2.listenerCount("wsClientError")) {
         const err = new Error(message);
         Error.captureStackTrace(err, abortHandshakeOrEmitwsClientError);
-        server.emit("wsClientError", err, socket, req);
+        server2.emit("wsClientError", err, socket, req);
       } else {
         abortHandshake(socket, code, message, headers);
       }
@@ -3718,17 +3718,17 @@ var require_websocket_server = __commonJS({
 
 // src/cli.ts
 import crypto4 from "node:crypto";
-import { spawn } from "node:child_process";
-import fs15 from "node:fs";
-import path13 from "node:path";
+import { spawn as spawn2, spawnSync } from "node:child_process";
+import fs21 from "node:fs";
+import path20 from "node:path";
 import readline from "node:readline";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // src/server.ts
 import crypto3 from "node:crypto";
-import fs14 from "node:fs";
-import http2 from "node:http";
-import path12 from "node:path";
+import fs20 from "node:fs";
+import http3 from "node:http";
+import path19 from "node:path";
 
 // node_modules/ws/wrapper.mjs
 var import_stream = __toESM(require_stream(), 1);
@@ -3988,8 +3988,8 @@ function createProjectProxy(target, editorOrigin, guest) {
       current = new URL(origin.origin);
     }
   };
-  const port = () => server.address()?.port ?? -1;
-  const server = http.createServer(async (req, res) => {
+  const port = () => server2.address()?.port ?? -1;
+  const server2 = http.createServer(async (req, res) => {
     const url = req.url ?? "/";
     if (!isProxyHost(req.headers.host, port())) {
       res.writeHead(403, { connection: "close" });
@@ -4023,14 +4023,14 @@ function createProjectProxy(target, editorOrigin, guest) {
     }
     await relay(req, res, project, editorOrigin);
   });
-  server.on("upgrade", (req, socket, head) => {
+  server2.on("upgrade", (req, socket, head) => {
     if (!isProxyHost(req.headers.host, port()) || !upstreamUrl(req.url ?? "/", project.current())) {
       socket.end("HTTP/1.1 403 Forbidden\r\nconnection: close\r\n\r\n");
       return;
     }
     upgrade(req, socket, head, project.current());
   });
-  return server;
+  return server2;
 }
 function wantsDocument(headers) {
   const one = (name) => {
@@ -4108,7 +4108,7 @@ async function relay(req, res, project, editorOrigin) {
     return;
   }
   const hasBody = req.method !== "GET" && req.method !== "HEAD";
-  const send = () => fetch(upstream, {
+  const send2 = () => fetch(upstream, {
     method: req.method,
     headers: forwardedHeaders(req, target),
     body: hasBody ? req : void 0,
@@ -4120,10 +4120,10 @@ async function relay(req, res, project, editorOrigin) {
   let response;
   try {
     try {
-      response = await send();
+      response = await send2();
     } catch (error) {
       if (!isConnectionFailure(error) || hasBody) throw error;
-      response = await send();
+      response = await send2();
     }
   } catch (error) {
     if (!wantsDocument(req.headers)) {
@@ -4244,17 +4244,17 @@ function createLiveProxyHost(options) {
     if (!entry) {
       entry = (async () => {
         await readGuest();
-        const server = createProjectProxy(address, options.editorOrigin, readGuest);
+        const server2 = createProjectProxy(address, options.editorOrigin, readGuest);
         await new Promise((resolve3, reject) => {
-          server.once("error", reject);
-          server.listen(0, "127.0.0.1", resolve3);
+          server2.once("error", reject);
+          server2.listen(0, "127.0.0.1", resolve3);
         });
-        return { origin: `http://127.0.0.1:${server.address().port}`, server };
+        return { origin: `http://127.0.0.1:${server2.address().port}`, server: server2 };
       })();
       attached.set(key, entry);
-      const pending = entry;
-      pending.catch(() => {
-        if (attached.get(key) === pending) attached.delete(key);
+      const pending3 = entry;
+      pending3.catch(() => {
+        if (attached.get(key) === pending3) attached.delete(key);
       });
     }
     const { origin } = await entry;
@@ -4266,7 +4266,7 @@ function createLiveProxyHost(options) {
   function close() {
     for (const entry of attached.values()) {
       entry.then(
-        ({ server }) => server.close(),
+        ({ server: server2 }) => server2.close(),
         () => {
         }
       );
@@ -5127,11 +5127,11 @@ function createDocument(name = "Untitled") {
   };
   return { id: makeId(), name, rootId, nodes: { [rootId]: root } };
 }
-function insertNodeInto(nodes, parentId, node, index) {
+function insertNodeInto(nodes, parentId, node2, index) {
   const parent = nodes[parentId];
   if (!parent) throw new Error(`addNode: parent "${parentId}" not found`);
   const id = makeId();
-  const newNode = { ...node, props: withElementId(node.props), id, parent: parentId };
+  const newNode = { ...node2, props: withElementId(node2.props), id, parent: parentId };
   const children = [...parent.children];
   children.splice(index ?? children.length, 0, id);
   nodes[id] = newNode;
@@ -5145,8 +5145,8 @@ function addSubtree(doc, parentId, tree, index) {
   return { doc: { ...doc, nodes }, id };
 }
 function addSubtreeInto(nodes, parentId, tree, index, created) {
-  const { childNodes = [], ...node } = tree;
-  const id = insertNodeInto(nodes, parentId, node, index);
+  const { childNodes = [], ...node2 } = tree;
+  const id = insertNodeInto(nodes, parentId, node2, index);
   created?.push(id);
   for (const child of childNodes) addSubtreeInto(nodes, id, child, void 0, created);
   return id;
@@ -5254,16 +5254,16 @@ function hash(text3) {
   }
   return a.toString(16).padStart(8, "0") + b.toString(16).padStart(8, "0");
 }
-function serializeNode(node, order) {
+function serializeNode(node2, order) {
   const out = {
-    id: node.id,
-    type: node.type,
-    tag: node.tag
+    id: node2.id,
+    type: node2.type,
+    tag: node2.tag
   };
-  if (node.name !== void 0) out.name = node.name;
-  out.parent = node.parent;
+  if (node2.name !== void 0) out.name = node2.name;
+  out.parent = node2.parent;
   if (order !== null) out.order = order;
-  const record = node;
+  const record = node2;
   for (const key of Object.keys(record).sort()) {
     if (key === "children" || LEADING_KEYS.includes(key)) continue;
     if (record[key] === void 0) continue;
@@ -5316,18 +5316,18 @@ function documentFiles(document, changed, previousOrders, removed = []) {
     }
   } else {
     for (const id of changed) {
-      const node = document.nodes[id];
-      if (!node) continue;
+      const node2 = document.nodes[id];
+      if (!node2) continue;
       write.add(id);
-      rekey(node);
+      rekey(node2);
     }
   }
   const files = /* @__PURE__ */ new Map();
   for (const id of write) {
-    const node = document.nodes[id];
-    if (!node) continue;
-    const order = node.parent === null ? null : orders.get(id) ?? null;
-    files.set(id, { name: nodeFileName(id), text: serializeNode(node, order), order });
+    const node2 = document.nodes[id];
+    if (!node2) continue;
+    const order = node2.parent === null ? null : orders.get(id) ?? null;
+    files.set(id, { name: nodeFileName(id), text: serializeNode(node2, order), order });
   }
   if (changed === null) {
     for (const id of orders.keys()) if (!document.nodes[id]) orders.delete(id);
@@ -5349,12 +5349,12 @@ function readDocumentFiles(headText, nodeTexts) {
       throw new Error("a layer file has no id or type");
     }
     const { order, ...rest2 } = parsed;
-    const node = { props: {}, style: {}, ...rest2, children: [] };
-    if (typeof node.tag !== "string") node.tag = "div";
-    if (node.parent === void 0) node.parent = null;
-    if (nodes[node.id]) repairs.push(`two files hold layer ${node.id}; the last read was kept`);
-    nodes[node.id] = node;
-    if (isKey(order)) orders.set(node.id, order);
+    const node2 = { props: {}, style: {}, ...rest2, children: [] };
+    if (typeof node2.tag !== "string") node2.tag = "div";
+    if (node2.parent === void 0) node2.parent = null;
+    if (nodes[node2.id]) repairs.push(`two files hold layer ${node2.id}; the last read was kept`);
+    nodes[node2.id] = node2;
+    if (isKey(order)) orders.set(node2.id, order);
   }
   const root = nodes[rootId];
   if (!root) throw new Error(`the root layer ${rootId} has no file`);
@@ -5392,11 +5392,11 @@ function readDocumentFiles(headText, nodeTexts) {
     if (reached.has(id)) continue;
     const parent = nodes[id].parent;
     if (parent && reached.has(parent)) continue;
-    const node = nodes[id];
+    const node2 = nodes[id];
     if (parent && nodes[parent]) {
       nodes[parent].children = nodes[parent].children.filter((child) => child !== id);
     }
-    node.parent = rootId;
+    node2.parent = rootId;
     root.children = [...root.children, id];
     repairs.push(`layer ${id} was inside itself and was put at the top level`);
     const lift = [id];
@@ -6258,10 +6258,10 @@ function rewriteStyled(styled, css) {
 }
 function rewriteDocument(document, rewrite) {
   let nodes = null;
-  for (const [id, node] of Object.entries(document.nodes)) {
-    const props = rewriteBag(node.props, rewrite.attr);
-    const styled = rewriteStyled(node, rewrite.css);
-    if (props === node.props && styled === node) continue;
+  for (const [id, node2] of Object.entries(document.nodes)) {
+    const props = rewriteBag(node2.props, rewrite.attr);
+    const styled = rewriteStyled(node2, rewrite.css);
+    if (props === node2.props && styled === node2) continue;
     (nodes ??= { ...document.nodes })[id] = { ...styled, props };
   }
   let styles = document.styles;
@@ -8810,9 +8810,9 @@ function applyChanges(folderPath, changes) {
     ownedNodes.add(nodes);
   }
   const before = {};
-  for (const node of changes.nodes) {
-    if (nodes[node.id]) before[node.id] = nodes[node.id];
-    nodes[node.id] = node;
+  for (const node2 of changes.nodes) {
+    if (nodes[node2.id]) before[node2.id] = nodes[node2.id];
+    nodes[node2.id] = node2;
   }
   for (const id of changes.removed) {
     if (!nodes[id]) continue;
@@ -9015,8 +9015,8 @@ function adopt(folderPath, options = {}) {
   return { ok: true, report: { wrote, scaffolded, ...moved.length ? { moved } : {} } };
 }
 function openProject(folderPath, options = {}) {
-  const adopted = adopt(folderPath, options);
-  if (!adopted.ok) return { ok: false, error: adopted.error };
+  const adopted2 = adopt(folderPath, options);
+  if (!adopted2.ok) return { ok: false, error: adopted2.error };
   let manifest;
   try {
     manifest = readJsonWithBackupSync(manifestPath(folderPath));
@@ -9041,7 +9041,7 @@ function openProject(folderPath, options = {}) {
     manifest,
     document: read.document,
     revision: read.revision,
-    ...adopted.report ? { adopted: adopted.report } : {},
+    ...adopted2.report ? { adopted: adopted2.report } : {},
     ...read.repairs.length ? { repairs: read.repairs } : {}
   };
 }
@@ -9061,11 +9061,11 @@ function validateDocument(document) {
     if (onPath.has(id)) return `Cycle detected at node "${id}"`;
     if (visited.has(id)) continue;
     visited.add(id);
-    const node = document.nodes[id];
-    if (!node) return `Referenced node "${id}" does not exist`;
+    const node2 = document.nodes[id];
+    if (!node2) return `Referenced node "${id}" does not exist`;
     onPath.add(id);
     stack.push({ id, leaving: true });
-    for (const childId of node.children) {
+    for (const childId of node2.children) {
       if (onPath.has(childId)) return `Cycle detected at node "${childId}"`;
       stack.push({ id: childId, leaving: false });
     }
@@ -9104,7 +9104,7 @@ async function saveChanges(folderPath, changes, media2, saved) {
     const { document, previous, headChanged } = applied;
     const changed = assetScope(
       document,
-      changes.nodes.map((node) => document.nodes[node.id]),
+      changes.nodes.map((node2) => document.nodes[node2.id]),
       headChanged
     );
     const plan = planExtraction(changed);
@@ -9118,13 +9118,13 @@ async function saveChanges(folderPath, changes, media2, saved) {
     const { revision } = await writeDocumentAsync(
       folderPath,
       stored,
-      changes.nodes.map((node) => node.id),
+      changes.nodes.map((node2) => node2.id),
       changes.removed
     );
     const after = referencedAssets(
       assetScope(
         stored,
-        changes.nodes.map((node) => stored.nodes[node.id]),
+        changes.nodes.map((node2) => stored.nodes[node2.id]),
         headChanged
       )
     );
@@ -9141,7 +9141,7 @@ async function saveChanges(folderPath, changes, media2, saved) {
   }
 }
 function assetScope(document, nodes, withHead) {
-  const scoped = Object.fromEntries(nodes.map((node) => [node.id, node]));
+  const scoped = Object.fromEntries(nodes.map((node2) => [node2.id, node2]));
   if (withHead) return { ...document, nodes: scoped };
   return { id: document.id, name: document.name, rootId: document.rootId, nodes: scoped };
 }
@@ -9758,6 +9758,11 @@ function registerProjectIpc(ipc) {
     return relative4 ? mediaFile(relative4) : null;
   });
 }
+function looksLikeProject(folderPath) {
+  const folder = path10.resolve(folderPath);
+  if (folder === path10.resolve(os2.homedir()) || folder === path10.parse(folder).root) return false;
+  return fs12.existsSync(path10.join(folder, ".codecaine")) || fs12.existsSync(path10.join(folder, "package.json"));
+}
 
 // src/inbox.ts
 var MAX_CALLS = 60;
@@ -9771,9 +9776,17 @@ var Inbox = class {
   lastClient = null;
   theme = "dark";
   sequence = 0;
+  /** Told whenever a request needs an agent: a new one, or one said again. */
+  waiting = /* @__PURE__ */ new Set();
+  /** Agents that receive requests as Claude Code channel pushes, by name —
+   *  what the Agent panel reports as "requests reach it". */
+  pushTargets = /* @__PURE__ */ new Map();
+  onWaiting(listener) {
+    this.waiting.add(listener);
+    return () => this.waiting.delete(listener);
+  }
   heard(client) {
-    const name = client ?? this.lastClient;
-    if (!name) return;
+    const name = client ?? this.lastClient ?? "Your coding agent";
     this.lastClient = name;
     this.clients.set(name, Date.now());
   }
@@ -9804,6 +9817,7 @@ var Inbox = class {
     };
     this.requests.unshift(request);
     if (this.requests.length > MAX_REQUESTS) this.requests.length = MAX_REQUESTS;
+    for (const listener of this.waiting) listener(request);
     return request;
   }
   followUp(id, text3) {
@@ -9813,6 +9827,7 @@ var Inbox = class {
     request.status = "pending";
     request.step = "Waiting for your agent";
     request.updatedAt = Date.now();
+    for (const listener of this.waiting) listener(request);
     return request;
   }
   /** Pending requests for a folder (every folder when none is named), handed
@@ -9858,18 +9873,169 @@ function titleOf(request) {
   return line.length > 80 ? `${line.slice(0, 79)}\u2026` : line;
 }
 
-// src/agent.ts
+// ../editor/electron/bb/tool-server.ts
+import http2 from "node:http";
+import { randomBytes, timingSafeEqual } from "node:crypto";
 var DEFAULT_TIMEOUT_MS = 3e4;
+var SLOW_TOOL_TIMEOUT_MS = {
+  observePage: 12e4,
+  observeVideo: 12e4,
+  canvasPointer: 9e4
+};
+var MAX_BODY_BYTES = 4 * 1024 * 1024;
+var pending = /* @__PURE__ */ new Map();
+var seq = 0;
+function routeToolResponse(requestId, result) {
+  const entry = pending.get(requestId);
+  if (!entry) return false;
+  pending.delete(requestId);
+  clearTimeout(entry.timer);
+  entry.resolve(result);
+  return true;
+}
+function tokenMatches(header3, token) {
+  if (!header3) return false;
+  const m = /^Bearer\s+(.+)$/i.exec(header3.trim());
+  if (!m) return false;
+  const got = Buffer.from(m[1], "utf8");
+  const want = Buffer.from(token, "utf8");
+  if (got.length !== want.length) return false;
+  return timingSafeEqual(got, want);
+}
+function readBody(req) {
+  return new Promise((resolve3) => {
+    const chunks = [];
+    let total = 0;
+    req.on("data", (c) => {
+      total += c.length;
+      if (total > MAX_BODY_BYTES) {
+        resolve3(null);
+        req.destroy();
+        return;
+      }
+      chunks.push(c);
+    });
+    req.on("end", () => resolve3(Buffer.concat(chunks).toString("utf8")));
+    req.on("error", () => resolve3(null));
+  });
+}
+function send(res, status, body) {
+  const text3 = JSON.stringify(body);
+  res.writeHead(status, {
+    "content-type": "application/json",
+    "content-length": Buffer.byteLength(text3)
+  });
+  res.end(text3);
+}
+function startToolServer(opts) {
+  const token = randomBytes(32).toString("hex");
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const owner = {};
+  const sockets = /* @__PURE__ */ new Set();
+  const server2 = http2.createServer((req, res) => {
+    void handle(req, res);
+  });
+  server2.on("connection", (s) => {
+    sockets.add(s);
+    s.on("close", () => sockets.delete(s));
+  });
+  async function handle(req, res) {
+    const route = (req.url || "").split("?")[0];
+    if (route !== "/tool") return send(res, 404, { error: "not found" });
+    if (req.method !== "POST") return send(res, 405, { error: "use POST" });
+    if (!tokenMatches(req.headers.authorization, token)) {
+      return send(res, 401, { error: "unauthorized" });
+    }
+    const raw = await readBody(req);
+    if (raw === null) return send(res, 413, { error: "request body too large" });
+    let body;
+    try {
+      body = JSON.parse(raw || "{}");
+    } catch {
+      return send(res, 400, { error: "body must be JSON" });
+    }
+    const tool = typeof body.tool === "string" ? body.tool.trim() : "";
+    if (!tool) return send(res, 200, { error: "missing 'tool'" });
+    const params2 = body.params && typeof body.params === "object" ? body.params : {};
+    const cwd = typeof body.cwd === "string" ? body.cwd : "";
+    const deadline = opts.timeoutMs ?? SLOW_TOOL_TIMEOUT_MS[tool] ?? timeoutMs;
+    const requestId = `bbtool-${process.pid}-${++seq}`;
+    const result = await new Promise((resolve3) => {
+      const timer = setTimeout(() => {
+        pending.delete(requestId);
+        resolve3({
+          error: `no editor answered '${tool}' within ${deadline}ms \u2014 no project is open in the editor window, or it stopped responding`
+        });
+      }, deadline);
+      timer.unref?.();
+      pending.set(requestId, { resolve: resolve3, timer, owner });
+      try {
+        opts.send("canvasapi:call", { requestId, tool, params: params2, cwd });
+      } catch (err) {
+        pending.delete(requestId);
+        clearTimeout(timer);
+        resolve3({
+          error: `the editor could not receive the call: ${err instanceof Error ? err.message : String(err)}`
+        });
+      }
+    });
+    if (!result || typeof result !== "object") {
+      return send(res, 200, { error: "the editor sent an empty response" });
+    }
+    const failure = result.error;
+    if (typeof failure === "string") return send(res, 200, { error: failure });
+    return send(res, 200, { result });
+  }
+  return new Promise((resolve3, reject) => {
+    server2.once("error", reject);
+    server2.listen(0, "127.0.0.1", () => {
+      server2.removeListener("error", reject);
+      const addr = server2.address();
+      let stopped = null;
+      resolve3({
+        url: `http://127.0.0.1:${addr.port}`,
+        token,
+        port: addr.port,
+        stop() {
+          if (stopped) return stopped;
+          stopped = new Promise((done) => {
+            for (const [id, entry] of pending) {
+              if (entry.owner !== owner) continue;
+              pending.delete(id);
+              clearTimeout(entry.timer);
+              entry.resolve({ error: "the editor's tool server stopped" });
+            }
+            const grace = setTimeout(() => {
+              server2.closeAllConnections?.();
+              for (const s of sockets) s.destroy();
+              sockets.clear();
+            }, 50);
+            grace.unref?.();
+            server2.close(() => {
+              clearTimeout(grace);
+              done();
+            });
+            server2.closeIdleConnections?.();
+          });
+          return stopped;
+        }
+      });
+    });
+  });
+}
+
+// src/agent.ts
+var DEFAULT_TIMEOUT_MS2 = 3e4;
 var LONG_TIMEOUT_MS = 18e4;
 var SHOT_DIR2 = path11.join(os3.tmpdir(), "codecaine-agent-shots");
 function createAgentHost(ipc, options) {
-  const pending = /* @__PURE__ */ new Map();
+  const pending3 = /* @__PURE__ */ new Map();
   const inbox = new Inbox();
   let sequence = 0;
   ipc.handle("canvasapi:respond", async (message) => {
-    const entry = message?.requestId ? pending.get(message.requestId) : void 0;
-    if (!entry) return;
-    pending.delete(message.requestId);
+    const entry = message?.requestId ? pending3.get(message.requestId) : void 0;
+    if (!entry) return { ok: routeToolResponse(String(message?.requestId ?? ""), message?.result) };
+    pending3.delete(message.requestId);
     clearTimeout(entry.timer);
     entry.resolve(message.result);
   });
@@ -9945,15 +10111,15 @@ function createAgentHost(ipc, options) {
       });
     }
     const requestId = `mcp-${Date.now().toString(36)}-${++sequence}`;
-    const wait = timeoutMs ?? (FRAMES_TOOLS.includes(tool) ? LONG_TIMEOUT_MS : DEFAULT_TIMEOUT_MS);
+    const wait = timeoutMs ?? (FRAMES_TOOLS.includes(tool) ? LONG_TIMEOUT_MS : DEFAULT_TIMEOUT_MS2);
     return new Promise((resolve3) => {
       const timer = setTimeout(() => {
-        pending.delete(requestId);
+        pending3.delete(requestId);
         resolve3({
           error: "The editor did not answer. Its tab may be on the Projects screen rather than a design \u2014 open the project (or call open-project) and try again."
         });
       }, wait);
-      pending.set(requestId, { resolve: resolve3, timer });
+      pending3.set(requestId, { resolve: resolve3, timer });
       ipc.broadcast("canvasapi:call", { requestId, tool, params: params2, cwd });
     });
   }
@@ -10109,6 +10275,7 @@ function createAgentHost(ipc, options) {
   ].join("\n\n");
   return {
     inbox,
+    bringToFront,
     call,
     instructions,
     tools: () => [
@@ -10228,14 +10395,16 @@ function agentPage() {
   <h2>Connect your coding agent</h2>
   <p class="muted" style="margin:0">Keep <code>npx codecaine-cli</code> running, then add it once:</p>
   <div class="step"><span class="faint">Claude Code</span>
-    <div class="copy"><pre>claude mcp add codecaine -- npx -y codecaine-cli mcp</pre><button type="button">Copy</button></div></div>
+    <div class="copy"><pre>claude mcp add codecaine -- npx -y codecaine-cli mcp</pre><button type="button">Copy</button></div>
+    <span class="faint">then start it so board requests reach it by themselves</span>
+    <div class="copy"><pre>claude --dangerously-load-development-channels server:codecaine</pre><button type="button">Copy</button></div></div>
   <div class="step"><span class="faint">Cursor, Windsurf and others (mcp.json)</span>
     <div class="copy"><pre>{
   "mcpServers": {
     "codecaine": { "command": "npx", "args": ["-y", "codecaine-cli", "mcp"] }
   }
 }</pre><button type="button">Copy</button></div></div>
-  <p class="muted" style="margin:8px 0 0">Then, in your project's folder, ask it to <em>run the project and open it in Codecaine</em>. Requests typed on the board wait above until you tell it to <em>check Codecaine</em>.</p>
+  <p class="muted" style="margin:8px 0 0">Then, in your project's folder, ask it to <em>run the project and open it in Codecaine</em>. Requests typed on the board go straight to it.</p>
 </section>
 <script>
   const project = new URLSearchParams(location.search).get("project") || "";
@@ -10271,6 +10440,9 @@ function agentPage() {
     const line = el("span");
     if (state.agent) {
       line.append(el("strong", null, state.agent.name), document.createTextNode(" is connected "), el("span", "faint", "\xB7 last heard " + ago(state.agent.lastSeen)));
+      line.append(el("div", "faint", state.pushing
+        ? "Requests from the board reach it by themselves."
+        : "Requests wait until you tell it to check Codecaine \u2014 start it with --dangerously-load-development-channels server:codecaine to send them straight away."));
     } else {
       line.append(el("strong", null, "No coding agent connected"), document.createTextNode(" "), el("span", "faint", "\xB7 add one below"));
     }
@@ -10305,103 +10477,2434 @@ function agentPage() {
 </body>
 </html>`;
 }
+function assistantStartingPage() {
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>Starting the assistant</title>
+<style>
+  :root { --panel: #ffffff; --inset: #f5f5f5; --text: #17181c; --text-2: #696969; --text-3: #a8a8a8; --accent: #0099ff; --pink: #d42d73; }
+  :root[data-theme="dark"] { --panel: #1f1f1f; --inset: #2e2e2e; --text: #f5f5f5; --text-2: #a8a8a8; --text-3: #8a8a8a; --pink: #f0679f; }
+  * { box-sizing: border-box; }
+  html, body { margin: 0; height: 100%; background: var(--panel); color: var(--text); }
+  body { font: 12px/16px "Inter Variable", Inter, ui-sans-serif, system-ui, -apple-system, sans-serif; letter-spacing: -0.01em;
+         display: grid; place-content: center; padding: 24px 20px; text-align: center; }
+  h1 { margin: 0 0 6px; font-size: 13px; line-height: 18px; font-weight: 600; }
+  p { margin: 0; color: var(--text-2); }
+  .bar { width: 220px; height: 4px; margin: 14px auto 8px; border-radius: 2px; background: var(--inset); overflow: hidden; }
+  .fill { height: 100%; width: 0; background: var(--accent); border-radius: 2px; transition: width .4s ease; }
+  .bar.unknown .fill { width: 35%; animation: slide 1.2s ease-in-out infinite; }
+  @keyframes slide { from { transform: translateX(-100%); } to { transform: translateX(290%); } }
+  @media (prefers-reduced-motion: reduce) { .bar.unknown .fill { animation: none; width: 100%; opacity: .5; } }
+  .note { color: var(--text-3); }
+  .error { color: var(--pink); margin-top: 8px; max-width: 280px; word-break: break-word; }
+</style>
+</head>
+<body>
+  <h1 id="title">Starting the assistant\u2026</h1>
+  <p id="what">The first time, it downloads (about 240 MB) \u2014 after that it starts in seconds.</p>
+  <div class="bar unknown" id="bar"><div class="fill" id="fill"></div></div>
+  <p class="note" id="note"></p>
+  <p class="error" id="error" hidden></p>
+<script>
+  const query = new URLSearchParams(location.search);
+  document.documentElement.dataset.theme = matchMedia("(prefers-color-scheme: light)").matches ? "light" : "dark";
+  async function poll() {
+    let answer;
+    try {
+      answer = await (await fetch("assistant?" + query.toString(), { cache: "no-store" })).json();
+    } catch {
+      document.getElementById("note").textContent = "Lost the companion \u2014 is npx codecaine-cli still running?";
+      return setTimeout(poll, 2000);
+    }
+    const s = answer.state;
+    document.documentElement.dataset.theme = answer.theme || document.documentElement.dataset.theme;
+    if (answer.url) return location.replace(answer.url);
+    document.getElementById("title").textContent = s.phase === "failed" ? "The assistant did not start" : s.message || "Starting the assistant\u2026";
+    const bar = document.getElementById("bar");
+    bar.classList.toggle("unknown", s.percent == null);
+    document.getElementById("fill").style.width = s.percent == null ? "" : s.percent + "%";
+    document.getElementById("note").textContent = s.phase === "installing" && s.percent != null ? s.percent + "%" : "";
+    const error = document.getElementById("error");
+    error.hidden = s.phase !== "failed";
+    error.textContent = s.error || "";
+    document.getElementById("what").hidden = s.phase !== "installing" && s.phase !== "idle";
+    setTimeout(poll, s.phase === "failed" ? 5000 : 800);
+  }
+  poll();
+</script>
+</body>
+</html>`;
+}
 
-// src/ipc.ts
-var Ipc = class {
-  handlers = /* @__PURE__ */ new Map();
-  peers = /* @__PURE__ */ new Set();
-  handle(channel, handler) {
-    this.handlers.set(channel, handler);
+// src/bb.ts
+import { spawn } from "node:child_process";
+import fs19 from "node:fs";
+import path18 from "node:path";
+
+// ../editor/electron/bb/supervisor.ts
+import os4 from "node:os";
+import path12 from "node:path";
+import net2 from "node:net";
+import fs14 from "node:fs";
+import { createRequire } from "node:module";
+import { spawn as nodeSpawn } from "node:child_process";
+
+// ../editor/electron/bb/client.ts
+function isHostConnected(host) {
+  return host.status === "connected";
+}
+var BB_PERMISSION_MODES = ["accept-edits", "auto", "full"];
+function isBbPermissionMode(value) {
+  return typeof value === "string" && BB_PERMISSION_MODES.includes(value);
+}
+var BB_THREAD_STATUSES = [
+  "pending",
+  "idle",
+  "starting",
+  "active",
+  "stopping",
+  "error"
+];
+var BbApiError = class extends Error {
+  status;
+  url;
+  constructor(args2) {
+    super(`Agent backend ${args2.status}: ${args2.message}`);
+    this.name = "BbApiError";
+    this.status = args2.status;
+    this.url = args2.url;
   }
-  has(channel) {
-    return this.handlers.has(channel);
+};
+var DEFAULT_TIMEOUT_MS3 = 1e4;
+var REGISTRY_TIMEOUT_MS = 25e3;
+var INSTALL_TIMEOUT_MS = 13e4;
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function errorMessage(status, body) {
+  try {
+    const rec = asRecord(JSON.parse(body));
+    if (rec) {
+      if (typeof rec.error === "string") return rec.error;
+      if (typeof rec.message === "string") return rec.message;
+    }
+  } catch {
   }
-  async invoke(channel, args2) {
-    const handler = this.handlers.get(channel);
-    if (!handler) {
-      throw new Error(`${channel} is not available in the web build`);
+  return body.trim() || `HTTP ${status}`;
+}
+function parseProject(value) {
+  const rec = asRecord(value);
+  if (!rec || typeof rec.id !== "string") return null;
+  const sources = Array.isArray(rec.sources) ? rec.sources.flatMap((entry) => {
+    const source = asRecord(entry);
+    return source && typeof source.path === "string" && typeof source.hostId === "string" ? [{ hostId: source.hostId, path: source.path }] : [];
+  }) : [];
+  return {
+    id: rec.id,
+    name: typeof rec.name === "string" ? rec.name : rec.id,
+    sources
+  };
+}
+function parseThreadEvent(value) {
+  const rec = asRecord(value);
+  if (!rec || typeof rec.seq !== "number" || typeof rec.type !== "string") return null;
+  return { seq: rec.seq, type: rec.type, data: asRecord(rec.data) ?? {} };
+}
+function parseThread(value) {
+  const rec = asRecord(value);
+  if (!rec || typeof rec.id !== "string") return null;
+  return {
+    id: rec.id,
+    title: typeof rec.title === "string" ? rec.title : null,
+    createdAt: typeof rec.createdAt === "number" ? rec.createdAt : 0,
+    ...typeof rec.status === "string" && BB_THREAD_STATUSES.includes(rec.status) ? { status: rec.status } : {},
+    ...typeof rec.providerId === "string" && rec.providerId ? { providerId: rec.providerId } : {},
+    ...typeof rec.titleFallback === "string" ? { titleFallback: rec.titleFallback } : {},
+    ...typeof rec.updatedAt === "number" ? { updatedAt: rec.updatedAt } : {},
+    ...rec.hasPendingInteraction === true ? { hasPendingInteraction: true } : {}
+  };
+}
+function parseSkill(value) {
+  const rec = asRecord(value);
+  if (!rec || typeof rec.id !== "string" || typeof rec.name !== "string") return null;
+  return {
+    id: rec.id,
+    name: rec.name,
+    description: typeof rec.description === "string" ? rec.description : null,
+    scope: typeof rec.scope === "string" ? rec.scope : "unknown",
+    manageable: rec.manageable === true,
+    registrySkillId: typeof rec.registrySkillId === "string" ? rec.registrySkillId : null
+  };
+}
+function parseRegistrySkill(value) {
+  const rec = asRecord(value);
+  if (!rec || typeof rec.id !== "string" || typeof rec.source !== "string" || typeof rec.skillId !== "string" || typeof rec.name !== "string") {
+    return null;
+  }
+  return {
+    id: rec.id,
+    source: rec.source,
+    skillId: rec.skillId,
+    name: rec.name,
+    installs: typeof rec.installs === "number" ? rec.installs : 0,
+    url: typeof rec.url === "string" ? rec.url : `https://www.skills.sh/${rec.id}`,
+    summary: typeof rec.summary === "string" ? rec.summary : null
+  };
+}
+function parseTerminal(value) {
+  const rec = asRecord(value);
+  const id = rec && typeof rec.id === "string" ? rec.id : null;
+  const status = rec?.status;
+  if (!id || status !== "starting" && status !== "disconnected" && status !== "running" && status !== "exited") {
+    throw new Error("agent backend returned a malformed terminal");
+  }
+  return { id, status, exitCode: typeof rec?.exitCode === "number" ? rec.exitCode : null };
+}
+var BbClient = class {
+  origin;
+  baseUrl;
+  fetchImpl;
+  constructor(options) {
+    this.origin = `http://127.0.0.1:${options.port}`;
+    this.baseUrl = `${this.origin}/api/v1`;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+  }
+  async request(method, url, body, timeoutMs = DEFAULT_TIMEOUT_MS3) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    timer.unref?.();
+    let response;
+    try {
+      response = await this.fetchImpl(url, {
+        method,
+        // A JSON content-type is not decoration on the plugin routes: bb's
+        // "local" auth requires it for a mutation, which is what stops a page
+        // in a browser from forging one.
+        headers: body === void 0 ? {} : { "content-type": "application/json" },
+        ...body === void 0 ? {} : { body: JSON.stringify(body) },
+        signal: controller.signal
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+    const text3 = await response.text();
+    if (!response.ok) {
+      throw new BbApiError({
+        status: response.status,
+        message: errorMessage(response.status, text3),
+        url
+      });
+    }
+    if (!text3) return null;
+    try {
+      return JSON.parse(text3);
+    } catch {
+      return text3;
     }
-    return handler(...args2);
   }
-  addPeer(peer) {
-    this.peers.add(peer);
-    return () => this.peers.delete(peer);
+  /** `GET /health`, off the API prefix. Answers before the host daemon has
+   *  enrolled, which is why it is one of three probes and not the gate. */
+  async health(timeoutMs) {
+    try {
+      await this.request("GET", `${this.origin}/health`, void 0, timeoutMs);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /** `GET /api/v1/system/config`. Read as an opaque record: we only need it to
+   *  prove the server finished booting, since answering it reads config and the
+   *  database. */
+  async systemConfig(timeoutMs) {
+    const value = await this.request(
+      "GET",
+      `${this.baseUrl}/system/config`,
+      void 0,
+      timeoutMs
+    );
+    const rec = asRecord(value);
+    if (!rec) throw new Error("agent backend returned a malformed system config");
+    return rec;
+  }
+  /** `GET /api/v1/system/providers/state`: each provider CLI's health, with
+   *  the command that signs it in. Opaque here; bb-login.ts reads it. A health
+   *  check runs the CLI on the host, hence the longer wait. */
+  async providerStates(timeoutMs = 2e4) {
+    return this.request("GET", `${this.baseUrl}/system/providers/state`, void 0, timeoutMs);
+  }
+  /** `GET /api/v1/system/providers`: the providers bb offers, already in the
+   *  order its Settings › Providers list shows them. Opaque here;
+   *  provider-choice.ts reads it. */
+  async providers(timeoutMs = 2e4) {
+    return this.request("GET", `${this.baseUrl}/system/providers`, void 0, timeoutMs);
+  }
+  /** `GET /api/v1/system/execution-options`: for one provider, its models
+   *  (each with the reasoning levels it takes), the permission modes and
+   *  composer actions (plan) it supports, and the host's permission ceiling.
+   *  Opaque here; compose-options.ts reads it. Listing models runs the CLI on
+   *  the host, hence the longer wait. */
+  async executionOptions(providerId, timeoutMs = 2e4) {
+    const query = providerId ? `?providerId=${encodeURIComponent(providerId)}` : "";
+    return this.request("GET", `${this.baseUrl}/system/execution-options${query}`, void 0, timeoutMs);
+  }
+  /** `GET /api/v1/projects/:id/branches`: the checkout of the project's source
+   *  on a host — the branch it is on, the local branches, whether the tree is
+   *  dirty. Opaque here; compose-options.ts reads it. */
+  async projectBranches(projectId, hostId, timeoutMs = 15e3) {
+    return this.request(
+      "GET",
+      `${this.baseUrl}/projects/${encodeURIComponent(projectId)}/branches?hostId=${encodeURIComponent(hostId)}`,
+      void 0,
+      timeoutMs
+    );
   }
-  peerCount() {
-    return this.peers.size;
+  /** A provider's logo, at the `logoUrl` path `providers()` answered, as its
+   *  text. bb's logos are SVG; the caller checks before trusting that. */
+  async providerLogo(logoPath, timeoutMs) {
+    const value = await this.request("GET", new URL(logoPath, this.origin).toString(), void 0, timeoutMs);
+    return typeof value === "string" ? value : "";
+  }
+  /** `PUT /api/v1/settings/general`. bb's schema is strict and whole — every
+   *  field, no partial update — so the caller sends back the `generalSettings`
+   *  it read from `systemConfig` with its one change. */
+  async putGeneralSettings(settings) {
+    return this.request("PUT", `${this.baseUrl}/settings/general`, settings);
+  }
+  /** `GET /api/v1/hosts`. Rows bb cannot parse are dropped rather than thrown
+   *  over: one unknown host must not hide the connected one beside it. */
+  async hosts(timeoutMs) {
+    const value = await this.request(
+      "GET",
+      `${this.baseUrl}/hosts`,
+      void 0,
+      timeoutMs
+    );
+    if (!Array.isArray(value)) {
+      throw new Error("agent backend returned a malformed host list");
+    }
+    return value.flatMap((entry) => {
+      const rec = asRecord(entry);
+      const id = rec && typeof rec.id === "string" ? rec.id : null;
+      const status = rec && (rec.status === "connected" || rec.status === "disconnected") ? rec.status : null;
+      if (!id || !status) return [];
+      const name = rec && typeof rec.name === "string" ? rec.name : id;
+      return [{ id, name, status }];
+    });
   }
-  /** `webContents.send` to every connected editor. */
-  broadcast(channel, ...args2) {
-    for (const peer of this.peers) peer.send(channel, ...args2);
+  // ─────────────────────────── projects ───────────────────────────
+  /** `GET /api/v1/projects`. Rows bb answers with that this build cannot read
+   *  are dropped rather than thrown over: one unfamiliar project must not hide
+   *  the folder the editor has open. */
+  async projects() {
+    const value = await this.request("GET", `${this.baseUrl}/projects`);
+    if (!Array.isArray(value)) {
+      throw new Error("agent backend returned a malformed project list");
+    }
+    return value.flatMap((entry) => {
+      const project = parseProject(entry);
+      return project ? [project] : [];
+    });
   }
-};
-
-// src/wire.ts
-var BYTES = "$bytes";
-function toBase64(bytes) {
-  if (typeof Buffer !== "undefined") return Buffer.from(bytes).toString("base64");
-  let binary = "";
-  for (let i = 0; i < bytes.length; i += 32768) {
-    binary += String.fromCharCode(...bytes.subarray(i, i + 32768));
+  /**
+   * `POST /api/v1/projects` → 201.
+   *
+   * The wire body is `{name, source:{hostId, type:"local_path", path}}`, whose
+   * `source` arm is strict. The caller has a flat `{name, root, hostId}`, which
+   * is what it knows, so the nesting is assembled here.
+   */
+  async createProject(args2) {
+    const value = await this.request("POST", `${this.baseUrl}/projects`, {
+      name: args2.name,
+      source: { hostId: args2.hostId, type: "local_path", path: args2.root }
+    });
+    const project = parseProject(value);
+    if (!project) throw new Error("agent backend returned a malformed project");
+    return project;
+  }
+  // ─────────────────────────── threads ───────────────────────────
+  /** `GET /api/v1/threads?projectId=…`. An unreadable list is an empty one:
+   *  the panel then frames bb's compose view, which still works. */
+  async listThreads(projectId) {
+    const value = await this.request(
+      "GET",
+      `${this.baseUrl}/threads?projectId=${encodeURIComponent(projectId)}&archived=false`
+    );
+    const rows = Array.isArray(value) ? value : Array.isArray(asRecord(value)?.threads) ? asRecord(value).threads : [];
+    return rows.flatMap((entry) => {
+      const thread = parseThread(entry);
+      return thread ? [thread] : [];
+    });
   }
-  return btoa(binary);
-}
-function fromBase64(text3) {
-  if (typeof Buffer !== "undefined") {
-    const buffer = Buffer.from(text3, "base64");
-    return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+  /**
+   * `GET /api/v1/threads/:id` → the thread's `status`.
+   *
+   * What tells a save that the assistant's turn is over: `bb:send` resolves
+   * when the message is posted, and this is the one place bb says whether the
+   * turn it started is still running. Anything this build does not recognise
+   * is answered as null rather than guessed at.
+   */
+  async threadStatus(threadId) {
+    const value = await this.request(
+      "GET",
+      `${this.baseUrl}/threads/${encodeURIComponent(threadId)}`
+    );
+    const status = asRecord(value)?.status;
+    return typeof status === "string" && BB_THREAD_STATUSES.includes(status) ? status : null;
+  }
+  /** `POST /api/v1/threads` → 201. `origin` is required; "sdk" is what a
+   *  programmatic sender is. With no `execution`, bb picks the provider
+   *  itself — see model-choice.ts for why the editor names one. */
+  async createThread(args2) {
+    const execution = args2.execution;
+    const value = await this.request("POST", `${this.baseUrl}/threads`, {
+      projectId: args2.projectId,
+      origin: args2.origin ?? "sdk",
+      input: args2.input,
+      environment: args2.environment,
+      ...args2.visibility ? { visibility: args2.visibility } : {},
+      ...execution ? { providerId: execution.providerId } : {},
+      ...execution?.model ? { model: execution.model } : {},
+      ...execution?.reasoningLevel ? { reasoningLevel: execution.reasoningLevel } : {},
+      ...args2.permissionMode ? { permissionMode: args2.permissionMode } : {}
+    }, args2.timeoutMs);
+    const thread = parseThread(value);
+    if (!thread) throw new Error("agent backend returned a malformed thread");
+    return thread;
+  }
+  /**
+   * `POST /api/v1/threads/:id/send`.
+   *
+   * `steer-if-active` is what a composer means: deliver into a running turn if
+   * there is one, otherwise start one.
+   */
+  async sendMessage(threadId, input, options = {}) {
+    await this.request(
+      "POST",
+      `${this.baseUrl}/threads/${encodeURIComponent(threadId)}/send`,
+      {
+        input,
+        mode: options.mode ?? "steer-if-active",
+        ...options.reasoningLevel ? { reasoningLevel: options.reasoningLevel } : {}
+      }
+    );
   }
-  const binary = atob(text3);
-  const out = new Uint8Array(binary.length);
-  for (let i = 0; i < binary.length; i++) out[i] = binary.charCodeAt(i);
-  return out.buffer;
-}
-function encode(value) {
-  return JSON.stringify(value, (_key, item) => {
-    if (item instanceof ArrayBuffer) return { [BYTES]: toBase64(new Uint8Array(item)) };
-    if (ArrayBuffer.isView(item)) {
-      return { [BYTES]: toBase64(new Uint8Array(item.buffer, item.byteOffset, item.byteLength)) };
+  /**
+   * The newest few items of a thread's log, newest first — one small request
+   * however long the conversation is. What the Agent bar's jobs list names
+   * each running job's current step from (thread-step.ts).
+   */
+  async latestThreadItems(threadId, limit = 6) {
+    const value = await this.request(
+      "GET",
+      `${this.baseUrl}/threads/${encodeURIComponent(threadId)}/events?order=desc&limit=${Math.max(1, Math.floor(limit))}&types=item/started,item/completed`
+    );
+    const rows = Array.isArray(value) ? value : [];
+    return rows.flatMap((entry) => {
+      const event = parseThreadEvent(entry);
+      return event ? [event] : [];
+    });
+  }
+  /**
+   * `GET /api/v1/threads/:id/events?afterSeq=…&order=asc`.
+   *
+   * The thread's event log, oldest first. bb PRUNES `item/agentMessage/delta`
+   * rows once their `item/completed` lands (measured on 0.42.1: seqs 9–11 of a
+   * finished reply were gone), so a reader that wants the stream has to be
+   * reading while it happens; the completed item carries the whole text for
+   * anyone who arrives late.
+   */
+  async threadEvents(threadId, afterSeq, limit = 500) {
+    const value = await this.request(
+      "GET",
+      `${this.baseUrl}/threads/${encodeURIComponent(threadId)}/events?afterSeq=${Math.max(0, Math.floor(afterSeq))}&limit=${limit}&order=asc`
+    );
+    const rows = Array.isArray(value) ? value : [];
+    return rows.flatMap((entry) => {
+      const event = parseThreadEvent(entry);
+      return event ? [event] : [];
+    });
+  }
+  /** The newest event's `seq`, or 0 for an empty log — where a reader starts
+   *  so it sees only what a message it is about to send produces. */
+  async latestEventSeq(threadId) {
+    const value = await this.request(
+      "GET",
+      `${this.baseUrl}/threads/${encodeURIComponent(threadId)}/events?limit=1&order=desc`
+    );
+    const first = Array.isArray(value) ? parseThreadEvent(value[0]) : null;
+    return first?.seq ?? 0;
+  }
+  /**
+   * `GET /api/v1/threads/:id/events/wait?type=…&afterSeq=…&waitMs=…` — a long
+   * poll that returns as soon as an event of `type` lands after `afterSeq`
+   * (200) or when `waitMs` runs out (204). bb takes exactly ONE type here, so
+   * a reader waits on the one it is latency-sensitive to and re-reads the whole
+   * log on every wake. Answers whether something arrived; never throws for a
+   * plain timeout.
+   */
+  async waitForEvent(threadId, type, afterSeq, waitMs) {
+    const value = await this.request(
+      "GET",
+      `${this.baseUrl}/threads/${encodeURIComponent(threadId)}/events/wait?type=${encodeURIComponent(type)}&afterSeq=${Math.max(0, Math.floor(afterSeq))}&waitMs=${Math.max(0, Math.floor(waitMs))}`,
+      void 0,
+      waitMs + DEFAULT_TIMEOUT_MS3
+    );
+    return value !== null;
+  }
+  /** `POST /api/v1/threads/:id/stop` — interrupts the running turn. bb answers
+   *  `{ok:true}` at once and reaches `idle` a moment later. */
+  async stopThread(threadId) {
+    await this.request(
+      "POST",
+      `${this.baseUrl}/threads/${encodeURIComponent(threadId)}/stop`,
+      {}
+    );
+  }
+  /** `POST /api/v1/threads/:id/archive`. What bb's own docs ask of anything that
+   *  makes worker threads: put them away once they are done with. */
+  async archiveThread(threadId) {
+    await this.request(
+      "POST",
+      `${this.baseUrl}/threads/${encodeURIComponent(threadId)}/archive`,
+      {}
+    );
+  }
+  /**
+   * `GET /api/v1/system/providers/state` — which providers are installed and
+   * signed in on this machine. `ready` is the only status that can run a turn;
+   * bb's own default provider need not be one of them (it chose Codex on a
+   * machine with only Claude Code, and answered 503 to every thread).
+   */
+  async readyProviders() {
+    const value = await this.request("GET", `${this.baseUrl}/system/providers/state`);
+    const rows = asRecord(value)?.providers;
+    return Array.isArray(rows) ? rows.flatMap((row2) => {
+      const rec = asRecord(row2);
+      return rec && rec.status === "ready" && typeof rec.providerId === "string" ? [rec.providerId] : [];
+    }) : [];
+  }
+  /** `GET /api/v1/threads/:id/output` — the latest final assistant text, or
+   *  null when the thread has none yet. */
+  async threadOutput(threadId) {
+    const value = await this.request(
+      "GET",
+      `${this.baseUrl}/threads/${encodeURIComponent(threadId)}/output`
+    );
+    const output = asRecord(value)?.output;
+    return typeof output === "string" ? output : null;
+  }
+  // ─────────────────────────── plugins ───────────────────────────
+  /**
+   * `POST /api/v1/plugins/install` `{source}`.
+   *
+   * bb answers `{ok:false, error}` with a 422 for a plugin it refuses — most
+   * often one already registered from this same path, which is success as far
+   * as the editor is concerned. The caller decides that; this only reports it.
+   */
+  async installPlugin(source) {
+    const url = `${this.baseUrl}/plugins/install`;
+    const value = await this.request("POST", url, { source });
+    const rec = asRecord(value);
+    if (rec && rec.ok === false) {
+      throw new BbApiError({
+        status: 422,
+        message: typeof rec.error === "string" ? rec.error : "plugin install failed",
+        url
+      });
     }
-    return item;
-  });
-}
-function decode(text3) {
-  return JSON.parse(text3, (_key, item) => {
-    if (item && typeof item === "object" && BYTES in item && Object.keys(item).length === 1) {
-      return fromBase64(String(item[BYTES]));
+    return rec ? asRecord(rec.plugin) ?? rec : null;
+  }
+  /**
+   * `POST /api/v1/plugins/reload?id=<pluginId>`.
+   *
+   * Restarts a plugin's host, which is the only way code on disk becomes code
+   * bb is running: the plugin is registered by path once and never read again,
+   * so a `git pull` leaves an editor talking to the version installed months
+   * ago — with the tools, the schemas and the instructions of that version.
+   *
+   * Everything the plugin holds in memory goes with the restart, the editor's
+   * callback included. That is the caller's problem to sequence: the config
+   * POST has to come after.
+   */
+  async reloadPlugin(pluginId) {
+    const url = `${this.baseUrl}/plugins/reload?id=${encodeURIComponent(pluginId)}`;
+    const value = await this.request("POST", url, {});
+    const rec = asRecord(value);
+    if (rec && rec.ok === false) {
+      throw new BbApiError({
+        status: 422,
+        message: typeof rec.error === "string" ? rec.error : "plugin reload failed",
+        url
+      });
     }
-    return item;
-  });
-}
+    return rec;
+  }
+  /** One row of `GET /api/v1/plugins`, reduced to what the editor decides on. */
+  async listPlugins() {
+    const value = await this.request("GET", `${this.baseUrl}/plugins`);
+    const rows = Array.isArray(value) ? value : Array.isArray(asRecord(value)?.plugins) ? asRecord(value).plugins : [];
+    return rows.flatMap((entry) => {
+      const rec = asRecord(entry);
+      if (!rec || typeof rec.id !== "string") return [];
+      return [
+        {
+          id: rec.id,
+          source: typeof rec.source === "string" ? rec.source : "",
+          rootDir: typeof rec.rootDir === "string" ? rec.rootDir : "",
+          provenance: typeof rec.provenance === "string" ? rec.provenance : ""
+        }
+      ];
+    });
+  }
+  /**
+   * `DELETE /api/v1/plugins/:id`.
+   *
+   * Unloads the plugin's host and forgets its registration, settings and
+   * secrets. bb refuses it for a built-in (409), and the editor only ever asks
+   * it of a record that points at the editor's own plugin folder — see
+   * `evictShadowingPlugins` in canvas-tools.ts for the one case that needs it.
+   */
+  async removePlugin(pluginId) {
+    const url = `${this.baseUrl}/plugins/${encodeURIComponent(pluginId)}`;
+    const value = await this.request("DELETE", url);
+    const rec = asRecord(value);
+    if (rec && rec.ok === false) {
+      throw new BbApiError({
+        status: 422,
+        message: typeof rec.error === "string" ? rec.error : "plugin remove failed",
+        url
+      });
+    }
+  }
+  /** `GET /api/v1/plugins/:id/settings` → the plugin's current values. bb
+   *  answers 404 until the plugin's factory has run. */
+  async pluginSettings(pluginId) {
+    const value = await this.request(
+      "GET",
+      `${this.baseUrl}/plugins/${encodeURIComponent(pluginId)}/settings`
+    );
+    return asRecord(asRecord(value)?.values) ?? {};
+  }
+  /** `PUT /api/v1/plugins/:id/settings` `{values}` — a partial update, which bb
+   *  validates against the plugin's schema (400 with the reason) and hands to
+   *  the running plugin. */
+  async putPluginSettings(pluginId, values) {
+    await this.request(
+      "PUT",
+      `${this.baseUrl}/plugins/${encodeURIComponent(pluginId)}/settings`,
+      { values }
+    );
+  }
+  // ─────────────────────────── skills ───────────────────────────
+  /**
+   * `GET /api/v1/projects/:id/skills?environmentId=`.
+   *
+   * Every skill bb would load for that project's workspace — builtin, user,
+   * provider and plugin alike. `environmentId` is required-but-nullable on the
+   * wire, which a query string can only say as an empty value.
+   */
+  async projectSkills(projectId) {
+    const value = await this.request(
+      "GET",
+      `${this.baseUrl}/projects/${encodeURIComponent(projectId)}/skills?environmentId=`
+    );
+    const rows = asRecord(value)?.skills;
+    if (!Array.isArray(rows)) {
+      throw new Error("agent backend returned a malformed skill list");
+    }
+    return rows.flatMap((entry) => {
+      const skill = parseSkill(entry);
+      return skill ? [skill] : [];
+    });
+  }
+  /** `DELETE /api/v1/projects/:id/skills` `{skillId, environmentId}`. bb
+   *  refuses (403) anything it did not install itself — bundled and plugin
+   *  skills are not the user's to remove. */
+  async deleteSkill(projectId, skillId) {
+    await this.request(
+      "DELETE",
+      `${this.baseUrl}/projects/${encodeURIComponent(projectId)}/skills`,
+      { skillId, environmentId: null }
+    );
+  }
+  /**
+   * `GET /api/v1/skills-registry?q=&page=&perPage=`.
+   *
+   * bb's proxy onto skills.sh: trending with no query, all-time installs with
+   * one. Server-wide, so no project is named.
+   */
+  async searchSkillsRegistry(args2) {
+    const params2 = new URLSearchParams({
+      q: args2.query,
+      page: String(args2.page),
+      perPage: String(args2.perPage)
+    });
+    const value = await this.request(
+      "GET",
+      `${this.baseUrl}/skills-registry?${params2.toString()}`,
+      void 0,
+      REGISTRY_TIMEOUT_MS
+    );
+    const rec = asRecord(value);
+    if (!rec || !Array.isArray(rec.skills)) {
+      throw new Error("agent backend returned a malformed registry page");
+    }
+    const pagination = asRecord(rec.pagination);
+    return {
+      skills: rec.skills.flatMap((entry) => {
+        const skill = parseRegistrySkill(entry);
+        return skill ? [skill] : [];
+      }),
+      hasMore: pagination?.hasMore === true,
+      total: typeof pagination?.total === "number" ? pagination.total : rec.skills.length
+    };
+  }
+  /**
+   * `POST /api/v1/skills-registry/entries` `{ids}`.
+   *
+   * The same rows as a search, but read off each skill's own page, which is the
+   * only place skills.sh carries a summary. bb drops ids it cannot resolve
+   * rather than failing the batch.
+   */
+  async registryEntries(ids) {
+    const value = await this.request(
+      "POST",
+      `${this.baseUrl}/skills-registry/entries`,
+      { ids },
+      REGISTRY_TIMEOUT_MS
+    );
+    const rows = asRecord(value)?.entries;
+    return Array.isArray(rows) ? rows.flatMap((entry) => {
+      const skill = parseRegistrySkill(entry);
+      return skill ? [skill] : [];
+    }) : [];
+  }
+  /**
+   * `POST /api/v1/skills-registry/install` `{registrySkillId}`.
+   *
+   * bb runs the `skills` CLI under `npx` to fetch the package, validates the
+   * SKILL.md against the registry entry and moves it into `<dataDir>/skills`.
+   * Its own ceiling on that is two minutes, so ours sits just past it: a
+   * shorter one would report a failure for an install that went on to land.
+   */
+  async installRegistrySkill(registrySkillId) {
+    await this.request(
+      "POST",
+      `${this.baseUrl}/skills-registry/install`,
+      { registrySkillId },
+      INSTALL_TIMEOUT_MS
+    );
+  }
+  // ─────────────────────────── terminals ───────────────────────────
+  /** `POST /api/v1/terminals`: a pty on a host, in a folder, running one
+   *  command. The same terminals bb's own UI lists, so a dev server started
+   *  from the editor is one a person can find and stop there too. */
+  async createTerminal(args2) {
+    const value = await this.request("POST", `${this.baseUrl}/terminals`, {
+      cols: args2.cols ?? 120,
+      rows: args2.rows ?? 32,
+      target: { kind: "host_path", hostId: args2.hostId, cwd: args2.cwd },
+      start: { mode: "command", command: args2.command },
+      title: args2.title
+    });
+    return parseTerminal(value);
+  }
+  /** `GET /api/v1/terminals/:id`. */
+  async terminal(terminalId) {
+    return parseTerminal(
+      await this.request("GET", `${this.baseUrl}/terminals/${encodeURIComponent(terminalId)}`)
+    );
+  }
+  /** `GET /api/v1/terminals/:id/output?sinceSeq=`: what the pty printed after
+   *  `sinceSeq`, and the sequence number to ask from next time. */
+  async terminalOutput(terminalId, sinceSeq) {
+    const value = asRecord(
+      await this.request(
+        "GET",
+        `${this.baseUrl}/terminals/${encodeURIComponent(terminalId)}/output?sinceSeq=${sinceSeq}`
+      )
+    );
+    const chunks = Array.isArray(value?.chunks) ? value.chunks : [];
+    const text3 = chunks.map((chunk) => asRecord(chunk)?.dataBase64).filter((data) => typeof data === "string").map((data) => Buffer.from(data, "base64").toString("utf8")).join("");
+    const nextSeq = typeof value?.nextSeq === "number" ? value.nextSeq : sinceSeq;
+    return { text: text3, nextSeq };
+  }
+  /** `POST /api/v1/terminals/:id/close`. The body is required: bb answers
+   *  `{}` with a 400 ("expected one of force|if-clean"), which is how Cancel
+   *  once left the dev server running in bb while the panel said cancelled.
+   *  `force` because a dev server is never "clean" — it is always running. */
+  async closeTerminal(terminalId) {
+    await this.request(
+      "POST",
+      `${this.baseUrl}/terminals/${encodeURIComponent(terminalId)}/close`,
+      { mode: "force", reason: "user" }
+    );
+  }
+  /** Call a route the plugin registered with `bb.http.route`, which bb mounts
+   *  at `/api/v1/plugins/<id>/http/<path>`. */
+  async pluginHttp(pluginId, routePath, body) {
+    const path21 = routePath.replace(/^\/+/, "");
+    const url = `${this.baseUrl}/plugins/${encodeURIComponent(pluginId)}/http/${path21}`;
+    return this.request("POST", url, body ?? {});
+  }
+};
 
-// src/server.ts
-var VERSION = "0.1.0";
-var LOOPBACK = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]", "::1"]);
-var MAX_BODY_BYTES = 8 * 1024 * 1024;
-function hostIsLocal(host) {
-  if (!host) return true;
+// ../editor/electron/bb/supervisor.ts
+var BB_APP_VERSION = "0.42.1";
+var BB_DEFAULT_SERVER_PORT = 38886;
+var BB_DEFAULT_DAEMON_PORT = 38887;
+var USER_BB_DATA_DIR_NAME = ".bb";
+var PROBE_TIMEOUT_MS = 1e3;
+var ADOPT_READY_TIMEOUT_MS = 15e3;
+var SPAWN_READY_TIMEOUT_MS = 18e4;
+var READY_POLL_INTERVAL_MS = 250;
+function bbDataDir(homeDir = os4.homedir(), env = process.env) {
+  return env.CANVAS_BB_DATA_DIR || path12.join(homeDir, ".canvas", "bb");
+}
+function bbServerPort(env = process.env) {
+  const n = Number(env.CANVAS_BB_SERVER_PORT);
+  return Number.isInteger(n) && n > 0 && n < 65536 ? n : BB_DEFAULT_SERVER_PORT;
+}
+function bbDaemonPort(env = process.env) {
+  const n = Number(env.CANVAS_BB_DAEMON_PORT);
+  return Number.isInteger(n) && n > 0 && n < 65536 ? n : BB_DEFAULT_DAEMON_PORT;
+}
+function assertSafeDataDir(dataDir2, homeDir) {
+  const userBb = path12.resolve(homeDir, USER_BB_DATA_DIR_NAME);
+  const resolved = path12.resolve(dataDir2);
+  if (resolved === userBb || resolved.startsWith(`${userBb}${path12.sep}`)) {
+    throw new Error(
+      `refusing to run the agent backend against the user's own data dir (${resolved})`
+    );
+  }
+}
+function bundledLauncher(resolveFrom = (specifier) => createRequire(process.env.CODECAINE_BB_APP_DIR ? path12.join(process.env.CODECAINE_BB_APP_DIR, "package.json") : import.meta.url).resolve(specifier), exists = fs14.existsSync) {
+  let launcher;
   try {
-    return LOOPBACK.has(new URL(`http://${host}`).hostname);
+    launcher = resolveFrom("bb-app/dist/bb-app.js");
   } catch {
-    return false;
+    return null;
+  }
+  const unpacked = launcher.replace(
+    `${path12.sep}app.asar${path12.sep}`,
+    `${path12.sep}app.asar.unpacked${path12.sep}`
+  );
+  return exists(unpacked) ? unpacked : null;
+}
+function buildLaunchCommand(args2) {
+  const flags = [
+    "start",
+    "--data-dir",
+    shQuote(args2.dataDir),
+    "--server-bind-host",
+    "127.0.0.1",
+    "--server-port",
+    String(args2.serverPort),
+    "--host-daemon-port",
+    String(args2.daemonPort)
+  ].join(" ");
+  if (args2.launcher) {
+    return `if command -v node >/dev/null 2>&1; then exec node ${shQuote(args2.launcher)} ${flags}; else echo "the agent backend needs Node on your PATH to run" >&2; exit 127; fi`;
+  }
+  return `if command -v bb-app >/dev/null 2>&1; then exec bb-app ${flags}; else exec npx -y bb-app@${args2.version} ${flags}; fi`;
+}
+function loginShellInvocation(command, env = process.env, shell) {
+  return { shell: shell ?? env.SHELL ?? "/bin/zsh", args: ["-lc", command] };
+}
+function shQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+var childExited = /* @__PURE__ */ new WeakSet();
+async function probeReady(client, timeoutMs) {
+  if (!await client.health(timeoutMs)) return null;
+  try {
+    await client.systemConfig(timeoutMs);
+  } catch {
+    return null;
+  }
+  let hosts;
+  try {
+    hosts = await client.hosts(timeoutMs);
+  } catch {
+    return null;
   }
+  return hosts.find(isHostConnected) ?? null;
 }
-function tokenMatches(expected, given) {
-  if (!given) return false;
-  const a = Buffer.from(expected);
-  const b = Buffer.from(given);
-  return a.length === b.length && crypto3.timingSafeEqual(a, b);
+async function waitReady(client, deps, args2) {
+  for (; ; ) {
+    const host = await probeReady(client, args2.probeTimeoutMs);
+    if (host) return host;
+    if (args2.child && childExited.has(args2.child)) return null;
+    if (deps.now() >= args2.deadline) return null;
+    await deps.sleep(args2.pollIntervalMs);
+  }
 }
-function readBody(request) {
-  return new Promise((resolve3, reject) => {
-    const chunks = [];
-    let size = 0;
-    request.on("data", (chunk) => {
-      size += chunk.length;
-      if (size > MAX_BODY_BYTES) {
-        reject(new Error("Request body too large."));
-        request.destroy();
-        return;
+function defaultIsPortInUse(port, timeoutMs = 300) {
+  return new Promise((resolve3) => {
+    const socket = new net2.Socket();
+    const done = (inUse) => {
+      socket.removeAllListeners();
+      socket.destroy();
+      resolve3(inUse);
+    };
+    socket.setTimeout(timeoutMs);
+    socket.once("connect", () => done(true));
+    socket.once("timeout", () => done(true));
+    socket.once(
+      "error",
+      (err) => done(err.code !== "ECONNREFUSED")
+    );
+    socket.connect(port, "127.0.0.1");
+  });
+}
+var owned = null;
+var adopted = null;
+var launching = null;
+var starting = null;
+function ensureBbServer(options = {}) {
+  if (starting) return starting;
+  starting = startBbServer(options).finally(() => {
+    starting = null;
+  });
+  return starting;
+}
+async function startBbServer(options = {}) {
+  const env = options.env ?? process.env;
+  const homeDir = options.homeDir ?? os4.homedir();
+  const serverPort = options.serverPort ?? bbServerPort(env);
+  const daemonPort = options.daemonPort ?? bbDaemonPort(env);
+  const dataDir2 = options.dataDir ?? bbDataDir(homeDir, env);
+  const probeTimeoutMs = options.probeTimeoutMs ?? PROBE_TIMEOUT_MS;
+  const pollIntervalMs = options.pollIntervalMs ?? READY_POLL_INTERVAL_MS;
+  const deps = {
+    now: options.now ?? Date.now,
+    sleep: options.sleep ?? ((ms) => new Promise((r) => {
+      const t = setTimeout(r, ms);
+      t.unref?.();
+    })),
+    log: options.log ?? (() => {
+    })
+  };
+  if (owned && await probeReady(owned.handle.client, probeTimeoutMs)) {
+    return owned.handle;
+  }
+  const client = new BbClient({ port: serverPort, fetchImpl: options.fetchImpl });
+  if (await client.health(probeTimeoutMs)) {
+    deps.log(`[bb] server already listening on :${serverPort} \u2014 adopting it`);
+    const host2 = await waitReady(client, deps, {
+      probeTimeoutMs,
+      pollIntervalMs,
+      deadline: deps.now() + (options.readyTimeoutMs ?? ADOPT_READY_TIMEOUT_MS),
+      child: null
+    });
+    if (!host2) {
+      throw new Error(
+        `an agent backend is listening on :${serverPort} but never reported a connected host \u2014 nothing can be run against it`
+      );
+    }
+    let adoptedDaemonPort = daemonPort;
+    let adoptedDataDir = dataDir2;
+    try {
+      const config = await client.systemConfig(probeTimeoutMs);
+      if (typeof config.hostDaemonPort === "number") {
+        adoptedDaemonPort = config.hostDaemonPort;
+      }
+      if (typeof config.dataDir === "string" && config.dataDir) {
+        adoptedDataDir = config.dataDir;
+      }
+    } catch {
+    }
+    adopted = {
+      client,
+      serverPort,
+      daemonPort: adoptedDaemonPort,
+      dataDir: adoptedDataDir,
+      hostId: host2.id,
+      spawned: false
+    };
+    return adopted;
+  }
+  assertSafeDataDir(dataDir2, homeDir);
+  const portInUse = options.isPortInUse ?? defaultIsPortInUse;
+  if (await portInUse(daemonPort)) {
+    throw new Error(
+      `the agent backend's host-daemon port :${daemonPort} is already in use, but nothing is serving on :${serverPort} \u2014 usually a daemon orphaned by a previous session. Stop it and try again (\`lsof -nP -iTCP:${daemonPort} -sTCP:LISTEN\`).`
+    );
+  }
+  const launcher = options.launcher === void 0 ? bundledLauncher() : options.launcher;
+  const command = buildLaunchCommand({
+    launcher,
+    dataDir: dataDir2,
+    serverPort,
+    daemonPort,
+    version: options.bbAppVersion ?? BB_APP_VERSION
+  });
+  deps.log(
+    launcher ? `[bb] starting the bundled agent backend (${launcher})` : `[bb] no bundled agent backend \u2014 falling back to bb-app@${options.bbAppVersion ?? BB_APP_VERSION}`
+  );
+  const spawnImpl = options.spawnImpl ?? ((cmd, args2, opts) => nodeSpawn(cmd, args2, opts));
+  const login = loginShellInvocation(command, env, options.shell);
+  const child = spawnImpl(login.shell, login.args, {
+    env: {
+      ...env,
+      // bb's telemetry defaults ON; this is not our data to send.
+      BB_TELEMETRY: "false",
+      BB_DATA_DIR: dataDir2,
+      BB_SERVER_BIND_HOST: "127.0.0.1",
+      BB_SERVER_PORT: String(serverPort),
+      BB_HOST_DAEMON_PORT: String(daemonPort)
+    }
+  });
+  let markExited;
+  const exited = new Promise((resolve3) => markExited = resolve3);
+  child.once("exit", () => {
+    childExited.add(child);
+    markExited();
+  });
+  child.once("error", () => {
+    childExited.add(child);
+    markExited();
+  });
+  launching = { child, exited };
+  let stderr = "";
+  child.stderr?.on("data", (chunk) => {
+    stderr = (stderr + String(chunk)).slice(-2e3);
+  });
+  child.stdout?.on("data", () => {
+  });
+  const host = await waitReady(client, deps, {
+    probeTimeoutMs,
+    pollIntervalMs,
+    deadline: deps.now() + (options.readyTimeoutMs ?? SPAWN_READY_TIMEOUT_MS),
+    child
+  });
+  if (launching?.child === child) launching = null;
+  if (!host) {
+    try {
+      child.kill("SIGTERM");
+    } catch {
+    }
+    const tail = stderr.trim() ? `
+${stderr.trim()}` : "";
+    throw new Error(
+      `The agent backend did not become ready on :${serverPort} (data dir ${dataDir2})${tail}`
+    );
+  }
+  const handle = {
+    client,
+    serverPort,
+    daemonPort,
+    dataDir: dataDir2,
+    hostId: host.id,
+    spawned: true
+  };
+  if (owned && owned.child !== child) {
+    try {
+      owned.child.kill("SIGTERM");
+    } catch {
+    }
+  }
+  owned = { child, handle, exited };
+  adopted = null;
+  deps.log(`[bb] server ready on :${serverPort} (host ${host.id})`);
+  return handle;
+}
+
+// ../editor/electron/bb/canvas-tools.ts
+import fs16 from "node:fs";
+import path14 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// ../editor/electron/bb/antigravity.ts
+import { execFile as execFile2 } from "node:child_process";
+import fs15 from "node:fs";
+import os5 from "node:os";
+import path13 from "node:path";
+import { fileURLToPath } from "node:url";
+
+// ../editor/electron/bb/antigravity-ids.ts
+var ANTIGRAVITY_AGENT_ID = "antigravity";
+var ANTIGRAVITY_PROVIDER_ID = `acp-${ANTIGRAVITY_AGENT_ID}`;
+var ANTIGRAVITY_LOGO_SVG = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="12 13 88 88" fill="none"><path fill="currentColor" d="M89.6992 93.695C94.3659 97.195 101.366 94.8617 94.9492 88.445C75.6992 69.7783 79.7825 18.445 55.8659 18.445C31.9492 18.445 36.0325 69.7783 16.7825 88.445C9.78251 95.445 17.3658 97.195 22.0325 93.695C40.1159 81.445 38.9492 59.8617 55.8659 59.8617C72.7825 59.8617 71.6159 81.445 89.6992 93.695Z"/></svg>';
+var ANTIGRAVITY_LOGO_URL = `data:image/svg+xml,${encodeURIComponent(ANTIGRAVITY_LOGO_SVG)}`;
+var ANTIGRAVITY_TINT = { light: "#3186FF", dark: "#3186FF" };
+
+// ../editor/electron/bb/antigravity.ts
+var PROVIDER_ACP_PLUGIN_ID = "provider-acp";
+function antigravityAgentEntry(paths) {
+  const dirs = [.../* @__PURE__ */ new Set([path13.dirname(paths.node), path13.dirname(paths.agy), path13.dirname(paths.adapter), "/usr/bin", "/bin"])];
+  return {
+    id: ANTIGRAVITY_AGENT_ID,
+    displayName: "Antigravity",
+    command: paths.node,
+    args: [paths.shim, paths.adapter],
+    env: {
+      PATH: dirs.join(":"),
+      // Without it agy-acp looks for its own agy, and downloads one when it
+      // finds none — not the person's, signed-in copy.
+      AGY_BIN: paths.agy,
+      AGY_SKIP_DOWNLOAD: "1",
+      CANVAS_ANTIGRAVITY_MCP_ROOT: paths.mcpRoot
+    },
+    nativeSkillRoots: {
+      user: [{ path: ".gemini/config/skills", recursive: true }, { path: ".agents/skills", recursive: true }],
+      project: [{ path: ".agents/skills", recursive: true, ancestors: true }]
+    }
+  };
+}
+function readCustomAgents(value) {
+  if (Array.isArray(value)) return [...value];
+  if (typeof value !== "string" || !value.trim()) return [];
+  const parsed = JSON.parse(value);
+  if (!Array.isArray(parsed)) throw new Error("bb's custom ACP agents setting is not a list");
+  return parsed;
+}
+var idOf = (entry) => entry && typeof entry === "object" ? entry.id : void 0;
+function withAntigravity(list, entry) {
+  const at = list.findIndex((item) => idOf(item) === ANTIGRAVITY_AGENT_ID);
+  if (!entry) return at === -1 ? null : list.filter((_, index) => index !== at);
+  if (at !== -1 && JSON.stringify(list[at]) === JSON.stringify(entry)) return null;
+  const next = [...list];
+  if (at === -1) next.push(entry);
+  else next[at] = entry;
+  return next;
+}
+function antigravityShimPath(resourcesPath = process.resourcesPath, dirname5 = path13.dirname(fileURLToPath(import.meta.url))) {
+  const shim = (dir2) => path13.join(dir2, "antigravity", "acp-shim.mjs");
+  if (resourcesPath && fs15.existsSync(shim(resourcesPath))) return shim(resourcesPath);
+  let dir = path13.resolve(dirname5);
+  for (let up = 0; up < 6; up++) {
+    if (fs15.existsSync(shim(path13.join(dir, "resources")))) return shim(path13.join(dir, "resources"));
+    const parent = path13.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function antigravityBinaries(home = os5.homedir()) {
+  const bin = path13.join(home, ".local", "bin");
+  return { agy: path13.join(bin, "agy"), adapter: path13.join(bin, "agy-acp") };
+}
+function executable(file) {
+  try {
+    fs15.accessSync(file, fs15.constants.X_OK);
+    return fs15.statSync(file).isFile();
+  } catch {
+    return false;
+  }
+}
+async function ensureAntigravityAgent(client, deps) {
+  const log = deps.log ?? ((msg) => console.log(msg));
+  const isExecutable = deps.isExecutable ?? executable;
+  const { agy, adapter } = (deps.binaries ?? antigravityBinaries)();
+  const shim = (deps.shimPath ?? antigravityShimPath)();
+  let entry = null;
+  if (shim && isExecutable(agy) && isExecutable(adapter)) {
+    const node2 = await deps.resolveNode();
+    if (node2) {
+      entry = antigravityAgentEntry({
+        node: node2,
+        shim,
+        adapter,
+        agy,
+        mcpRoot: deps.mcpRoot ?? path13.join(os5.homedir(), ".canvas", "antigravity-mcp")
+      });
+    } else {
+      log("[bb] Antigravity not registered: no node on the login shell's PATH");
+    }
+  }
+  try {
+    const values = await client.pluginSettings(PROVIDER_ACP_PLUGIN_ID);
+    const next = withAntigravity(readCustomAgents(values.customAgents), entry);
+    if (!next) return entry ? "unchanged" : "unavailable";
+    await client.putPluginSettings(PROVIDER_ACP_PLUGIN_ID, {
+      customAgents: next.length === 0 ? "" : JSON.stringify(next)
+    });
+    log(entry ? `[bb] Antigravity registered (${adapter})` : "[bb] Antigravity removed: agy or agy-acp is gone");
+    return entry ? "registered" : "removed";
+  } catch (err) {
+    log(`[bb] Antigravity not registered: ${err instanceof Error ? err.message : String(err)}`);
+    return "unavailable";
+  }
+}
+var node = null;
+function loginShellNode() {
+  node ??= new Promise((resolve3) => {
+    const login = loginShellInvocation('printf "node=%s\\n" "$(command -v node)"');
+    execFile2(login.shell, login.args, { timeout: 1e4 }, (_error, stdout) => {
+      const line = String(stdout ?? "").split(/\r?\n/).reverse().find((row2) => row2.startsWith("node="));
+      const found = line?.slice(5).trim();
+      resolve3(found && path13.isAbsolute(found) ? found : null);
+    });
+  }).then((found) => {
+    if (!found) node = null;
+    return found;
+  });
+  return node;
+}
+function registerAntigravity(client) {
+  return ensureAntigravityAgent(client, { resolveNode: loginShellNode });
+}
+
+// ../editor/electron/bb/canvas-tools.ts
+var PLUGIN_ID = "canvas-editor";
+var pending2 = null;
+var server = null;
+var lastError = null;
+function pluginSourceDir(resourcesPath = process.resourcesPath, dirname5 = path14.dirname(fileURLToPath2(import.meta.url))) {
+  const has = (dir2) => fs16.existsSync(path14.join(dir2, "package.json"));
+  if (resourcesPath) {
+    const packaged = path14.join(resourcesPath, "bb-plugin");
+    if (has(packaged)) return packaged;
+  }
+  let dir = path14.resolve(dirname5);
+  for (let up = 0; up < 6; up++) {
+    const candidate = path14.join(dir, "resources", "bb-plugin");
+    if (has(candidate)) return candidate;
+    const parent = path14.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function sameDir(a, b) {
+  const norm = (dir) => {
+    const resolved = path14.resolve(dir);
+    try {
+      return fs16.realpathSync(resolved);
+    } catch {
+      return resolved;
+    }
+  };
+  return norm(a) === norm(b);
+}
+async function evictShadowingPlugins(client, dir, log) {
+  let records;
+  try {
+    records = await client.listPlugins();
+  } catch (err) {
+    log(`[bb] plugin list unavailable, not checking for a shadowing record: ${String(err)}`);
+    return;
+  }
+  for (const record of records) {
+    if (record.provenance === "builtin") continue;
+    const ours = record.id === PLUGIN_ID;
+    const here2 = record.rootDir !== "" && sameDir(record.rootDir, dir);
+    if (ours === here2) continue;
+    const why = ours ? `it loads from ${record.rootDir || "an unknown place"} rather than ${dir}` : `it is this plugin under another id and would own its tools`;
+    try {
+      await client.removePlugin(record.id);
+      log(`[bb] removed plugin record "${record.id}": ${why}`);
+    } catch (err) {
+      log(`[bb] could not remove plugin record "${record.id}" (${why}): ${String(err)}`);
+    }
+  }
+}
+async function configure(client, handle) {
+  await client.pluginHttp(PLUGIN_ID, "config", {
+    url: handle.url,
+    token: handle.token
+  });
+}
+function ensureCanvasTools(send2, deps = {}) {
+  if (pending2) return pending2;
+  const ensureServer = deps.ensureServer ?? ensureBbServer;
+  const startServer = deps.startServer ?? startToolServer;
+  const sourceDir = deps.sourceDir ?? (() => pluginSourceDir());
+  const log = deps.log ?? ((m) => console.log(m));
+  pending2 = (async () => {
+    try {
+      const dir = sourceDir();
+      if (!dir) {
+        lastError = "resources/bb-plugin not found";
+        log(`[bb] layer tools unavailable: ${lastError}`);
+        return null;
+      }
+      const { client } = await ensureServer();
+      server ??= await startServer({ send: send2 });
+      await evictShadowingPlugins(client, dir, log);
+      try {
+        await client.installPlugin(`path:${dir}`);
+      } catch (err) {
+        log(
+          `[bb] plugin install skipped (likely already installed): ${String(err)}`
+        );
+      }
+      try {
+        await client.reloadPlugin(PLUGIN_ID);
+      } catch (err) {
+        log(`[bb] plugin reload skipped: ${String(err)}`);
+      }
+      await configure(client, server);
+      await registerAntigravity(client);
+      lastError = null;
+      log(`[bb] layer tools ready on ${server.url}`);
+      return server;
+    } catch (err) {
+      lastError = err instanceof Error ? err.message : String(err);
+      log(`[bb] layer tools unavailable: ${lastError}`);
+      pending2 = null;
+      return null;
+    }
+  })();
+  return pending2;
+}
+async function waitForCanvasTools(send2, options = {}) {
+  const attempts = Math.max(1, options.attempts ?? 3);
+  const attemptTimeoutMs = options.attemptTimeoutMs ?? 3e4;
+  const backoffMs = options.backoffMs ?? [1e3, 3e3];
+  const sleep = options.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  let reason = null;
+  for (let attempt = 0; attempt < attempts; attempt++) {
+    if (attempt > 0) {
+      await sleep(backoffMs[Math.min(attempt - 1, backoffMs.length - 1)] ?? 0);
+    }
+    const trying = ensureCanvasTools(send2, options);
+    let timer;
+    const timedOut = new Promise((resolve3) => {
+      timer = setTimeout(() => resolve3("timeout"), attemptTimeoutMs);
+    });
+    try {
+      const outcome = await Promise.race([trying, timedOut]);
+      if (outcome === "timeout") {
+        if (pending2 === trying) pending2 = null;
+        reason = `loading them took longer than ${Math.round(attemptTimeoutMs / 1e3)}s`;
+        continue;
+      }
+      if (outcome) return outcome;
+      reason = lastError;
+    } catch (err) {
+      if (pending2 === trying) pending2 = null;
+      reason = err instanceof Error ? err.message : String(err);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  throw new Error(canvasToolsUnavailableMessage(reason));
+}
+function canvasToolsUnavailableMessage(reason) {
+  return "the assistant's canvas tools didn't load, so nothing was sent \u2014 a conversation started without them can't see the board" + (reason ? ` (${reason})` : "") + ". Try again in a moment. If it keeps failing, open the Agent panel and press Reconnect, or quit and reopen the app.";
+}
+async function setAgentInstructions(send2, args2, deps = {}) {
+  const log = deps.log ?? ((m) => console.log(m));
+  try {
+    return await pushToPlugin(
+      send2,
+      "instructions",
+      {
+        projectId: args2.projectId,
+        instructions: args2.instructions,
+        ...args2.path ? { path: args2.path } : {}
+      },
+      deps
+    );
+  } catch (err) {
+    log(`[bb] instructions not delivered: ${String(err)}`);
+    return false;
+  }
+}
+async function pushToPlugin(send2, route, body, deps = {}) {
+  const ready = await ensureCanvasTools(send2, deps);
+  if (!ready) return false;
+  const client = deps.client ?? (await (deps.ensureServer ?? ensureBbServer)()).client;
+  await client.pluginHttp(PLUGIN_ID, route, {
+    ...body,
+    url: ready.url,
+    token: ready.token
+  });
+  return true;
+}
+async function setCanvasSelection(send2, args2, deps = {}) {
+  try {
+    return await pushToPlugin(
+      send2,
+      "selection",
+      {
+        projectId: args2.projectId,
+        layers: args2.layers,
+        ...args2.path ? { path: args2.path } : {}
+      },
+      deps
+    );
+  } catch {
+    return false;
+  }
+}
+async function canvasToolsConnection(send2, args2 = {}, deps = {}) {
+  try {
+    const ready = await ensureCanvasTools(send2, deps);
+    if (!ready) return { connected: false, projects: [] };
+    const client = deps.client ?? (await (deps.ensureServer ?? ensureBbServer)()).client;
+    const answer = await client.pluginHttp(PLUGIN_ID, "state", {
+      url: ready.url,
+      token: ready.token,
+      // Only what we actually have: a project id with no picture behind it
+      // would clear what the plugin is holding rather than restore it.
+      ...args2.projectId ? { projectId: args2.projectId } : {},
+      ...args2.projectId && args2.instructions !== void 0 ? { instructions: args2.instructions } : {},
+      ...args2.projectId && args2.layers !== void 0 ? { layers: args2.layers } : {},
+      ...args2.projectId && args2.path ? { path: args2.path } : {}
+    });
+    const projects = Array.isArray(answer?.projects) ? answer.projects.flatMap((entry) => {
+      const row2 = entry ?? {};
+      return typeof row2.projectId === "string" ? [
+        {
+          projectId: row2.projectId,
+          instructions: typeof row2.instructions === "number" ? row2.instructions : 0,
+          selection: typeof row2.selection === "number" ? row2.selection : 0
+        }
+      ] : [];
+    }) : [];
+    return { connected: answer?.connected === true, projects };
+  } catch {
+    return { connected: false, projects: [] };
+  }
+}
+function canvasToolsStatus() {
+  return { connected: server !== null, url: server?.url ?? null, error: lastError };
+}
+
+// ../editor/electron/bb/project-map.ts
+import path15 from "node:path";
+function normalizeProjectRoot(root) {
+  const trimmed = root.trim();
+  if (!trimmed) return "";
+  const normalized = path15.normalize(trimmed);
+  return normalized === path15.sep ? normalized : normalized.replace(/[/\\]+$/u, "");
+}
+async function pickConnectedHostId(client) {
+  const hosts = await client.hosts();
+  const connected = hosts.find(isHostConnected);
+  if (connected) return connected.id;
+  throw new Error(noConnectedHostMessage(hosts));
+}
+function noConnectedHostMessage(hosts) {
+  const seen = hosts.length ? `Hosts it reported: ${hosts.map((host) => `${host.name} (${host.status})`).join(", ")}.` : "It reported no hosts at all.";
+  return `The agent backend has no connected host, so there is nowhere to run the assistant. ${seen} This machine enrols as a host a moment after the backend comes up \u2014 wait for it to finish, or reopen the project to relaunch it.`;
+}
+function findProjectForRoot(projects, root, hostId) {
+  const atRoot = (project, onHost) => project.sources.some(
+    (source) => normalizeProjectRoot(source.path) === root && (onHost === void 0 || source.hostId === onHost)
+  );
+  const matches = projects.filter((project) => atRoot(project));
+  return matches.find((project) => atRoot(project, hostId)) ?? matches[0];
+}
+function createProjectMap(client) {
+  const pending3 = /* @__PURE__ */ new Map();
+  async function resolveUncached(root) {
+    const hostId = await pickConnectedHostId(client);
+    const existing = findProjectForRoot(await client.projects(), root, hostId);
+    const projectId = existing ? existing.id : (await client.createProject({ name: path15.basename(root), root, hostId })).id;
+    return {
+      projectId,
+      hostId,
+      /**
+       * ALWAYS `unmanaged`, at the real path. bb's default workspace is a
+       * managed git worktree — a checkout inside bb's own data dir — so the
+       * assistant would be reading and writing a directory that is not the one
+       * the editor has open, and every change it made would appear to do
+       * nothing. `hostId` is required alongside it.
+       */
+      environment: {
+        type: "host",
+        hostId,
+        workspace: { type: "unmanaged", path: root }
+      }
+    };
+  }
+  return {
+    resolve(cwd) {
+      const root = normalizeProjectRoot(cwd);
+      const cached = pending3.get(root);
+      if (cached) return cached;
+      const attempt = resolveUncached(root).catch((err) => {
+        pending3.delete(root);
+        throw err;
+      });
+      pending3.set(root, attempt);
+      return attempt;
+    },
+    clear() {
+      pending3.clear();
+    }
+  };
+}
+
+// ../editor/electron/bb/thread-step.ts
+var CANVAS_TOOL_STEPS = {
+  listLayers: "Reading the layers",
+  getLayer: "Reading a layer",
+  getSelection: "Reading the selection",
+  listAnnotations: "Reading the comments",
+  resolveAnnotation: "Resolving a comment",
+  createLayer: "Adding a layer",
+  insertHtml: "Adding layers",
+  updateLayer: "Editing a layer",
+  replaceLayer: "Rebuilding a layer",
+  removeLayer: "Removing a layer",
+  moveLayer: "Moving a layer",
+  duplicateLayers: "Duplicating layers",
+  groupLayers: "Grouping layers",
+  scaleLayers: "Scaling layers",
+  setLayerFont: "Setting a font",
+  selectLayers: "Selecting layers",
+  holdLayer: "Holding a layer",
+  releaseLayer: "Letting a layer go",
+  askAboutLayer: "Asking about a layer",
+  setPageView: "Changing the view",
+  canvasPointer: "Using the page",
+  canvasHistory: "Undoing a change",
+  listElementTypes: "Reading the elements",
+  getCanvasScene: "Reading a 3D scene",
+  setCanvasScene: "Building a 3D scene",
+  exportHtml: "Reading the markup",
+  listVariables: "Reading the variables",
+  setVariable: "Setting a variable",
+  deleteVariable: "Removing a variable",
+  canvasReadPage: "Reading the page",
+  observePage: "Watching the page",
+  observeVideo: "Watching a video",
+  setAppBrief: "Writing the app brief",
+  canvasScreenshot: "Looking at the board"
+};
+var MAX = 60;
+function clip(text3) {
+  const one = text3.replace(/\s+/g, " ").trim();
+  return one.length > MAX ? `${one.slice(0, MAX - 1)}\u2026` : one;
+}
+function baseName(path21) {
+  if (typeof path21 !== "string" || !path21) return null;
+  return path21.replace(/[\\/]+$/, "").split(/[\\/]/).pop() || path21;
+}
+function humanize(name) {
+  const words = name.replace(/^mcp__[^_]+__/, "").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").trim().toLowerCase();
+  return words ? words[0].toUpperCase() + words.slice(1) : "Using a tool";
+}
+function describeItem(item) {
+  const presentation = item.presentation;
+  if (presentation && presentation.suppress !== true && typeof presentation.title === "string" && presentation.title.trim()) {
+    return clip(presentation.title);
+  }
+  switch (item.type) {
+    case "toolCall": {
+      const tool = typeof item.tool === "string" ? item.tool : "";
+      const bare = tool.replace(/^mcp__[^_]+__/, "");
+      return CANVAS_TOOL_STEPS[bare] ?? clip(humanize(tool));
+    }
+    case "commandExecution":
+      return typeof item.command === "string" && item.command.trim() ? clip(`Running ${item.command}`) : "Running a command";
+    case "fileChange": {
+      const changes = Array.isArray(item.changes) ? item.changes : [];
+      const first = baseName(changes[0]?.path);
+      if (!first) return "Editing files";
+      return changes.length > 1 ? clip(`Editing ${first} and ${changes.length - 1} more`) : clip(`Editing ${first}`);
+    }
+    case "fileRead": {
+      const name = baseName(item.path);
+      return name ? clip(`Reading ${name}`) : "Reading a file";
+    }
+    case "search":
+      return "Searching the project";
+    case "webSearch": {
+      const queries = Array.isArray(item.queries) ? item.queries : [];
+      return typeof queries[0] === "string" ? clip(`Searching the web for ${queries[0]}`) : "Searching the web";
+    }
+    case "webFetch": {
+      try {
+        return clip(`Reading ${new URL(String(item.url)).host}`);
+      } catch {
+        return "Reading a page";
+      }
+    }
+    case "imageView":
+      return "Looking at an image";
+    case "reasoning":
+      return "Thinking";
+    case "plan":
+    case "planSteps":
+      return "Planning";
+    case "agentMessage":
+      return "Writing a reply";
+    case "delegation":
+    case "backgroundTask":
+      return "Working in the background";
+    case "contextCompaction":
+      return "Tidying its notes";
+    default:
+      return null;
+  }
+}
+function describeStep(eventsNewestFirst) {
+  for (const event of eventsNewestFirst) {
+    if (event.type !== "item/started" && event.type !== "item/completed") continue;
+    const item = event.data.item;
+    if (!item || typeof item !== "object") continue;
+    const step = describeItem(item);
+    if (step) return step;
+  }
+  return null;
+}
+
+// ../editor/electron/bb/model-choice.ts
+import * as fs17 from "node:fs";
+import * as path16 from "node:path";
+var REASONING_LEVELS = [
+  "none",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "ultracode",
+  "max",
+  "ultra"
+];
+function parseModelChoice(value) {
+  if (typeof value !== "object" || value === null) return null;
+  const entry = value;
+  const providerId = typeof entry.providerId === "string" ? entry.providerId.trim() : "";
+  if (!providerId) return null;
+  const choice = { providerId };
+  const model = typeof entry.model === "string" ? entry.model.trim() : "";
+  if (model) choice.model = model;
+  const reasoning = entry.reasoningLevel;
+  if (typeof reasoning === "string" && REASONING_LEVELS.includes(reasoning)) {
+    choice.reasoningLevel = reasoning;
+  }
+  return choice;
+}
+function createModelChoiceStore(deps) {
+  const take = async () => {
+    let reading;
+    try {
+      reading = await deps.read();
+    } catch {
+      reading = "unreachable";
+    }
+    if (reading !== "unreachable") writeMirror(deps.file, reading);
+    return reading;
+  };
+  return {
+    async current() {
+      const reading = await take();
+      return reading === "unreachable" ? readMirror(deps.file) : reading;
+    },
+    async refresh() {
+      await take();
+    }
+  };
+}
+function readMirror(file) {
+  try {
+    return parseModelChoice(JSON.parse(fs17.readFileSync(file, "utf-8")));
+  } catch {
+    return null;
+  }
+}
+function writeMirror(file, choice) {
+  try {
+    fs17.mkdirSync(path16.dirname(file), { recursive: true });
+    fs17.writeFileSync(file, JSON.stringify(choice ?? {}, null, 2));
+  } catch {
+  }
+}
+
+// ../editor/electron/bb/compose-options.ts
+function asRecord2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+var PERMISSION_ORDER = ["accept-edits", "auto", "full"];
+function parseExecutionOptions(value, providerId) {
+  const rec = asRecord2(value) ?? {};
+  const models = (Array.isArray(rec.models) ? rec.models : []).flatMap((entry) => {
+    const m = asRecord2(entry);
+    if (!m || typeof m.model !== "string" || !m.model) return [];
+    const levels = (Array.isArray(m.supportedReasoningEfforts) ? m.supportedReasoningEfforts : []).flatMap((level) => {
+      const l = asRecord2(level);
+      return l && typeof l.reasoningEffort === "string" ? [{ id: l.reasoningEffort, description: typeof l.description === "string" ? l.description : "" }] : [];
+    });
+    return [
+      {
+        model: m.model,
+        displayName: typeof m.displayName === "string" && m.displayName ? m.displayName : m.model,
+        description: typeof m.description === "string" ? m.description : "",
+        reasoningLevels: levels,
+        defaultReasoning: typeof m.defaultReasoningEffort === "string" ? m.defaultReasoningEffort : null,
+        isDefault: m.isDefault === true
+      }
+    ];
+  });
+  const provider = (Array.isArray(rec.providers) ? rec.providers : []).map(asRecord2).find((p) => p?.id === providerId);
+  const supported = asRecord2(provider?.capabilities)?.permissionModes?.filter(isBbPermissionMode);
+  const ceiling = isBbPermissionMode(rec.permissionCeiling) ? rec.permissionCeiling : "full";
+  const permissionModes = PERMISSION_ORDER.filter(
+    (mode) => (supported && supported.length > 0 ? supported.includes(mode) : true) && PERMISSION_ORDER.indexOf(mode) <= PERMISSION_ORDER.indexOf(ceiling)
+  );
+  const commandFor = (kind) => {
+    for (const action of Array.isArray(provider?.composerActions) ? provider.composerActions : []) {
+      const a = asRecord2(action);
+      const command = asRecord2(a?.command);
+      if (a?.kind === kind && command && typeof command.trigger === "string" && typeof command.name === "string") {
+        const trailing = typeof command.trailingText === "string" && command.trailingText ? command.trailingText : " ";
+        return `${command.trigger}${command.name}${trailing}`;
+      }
+    }
+    return null;
+  };
+  const reasoningLabels = {};
+  for (const level of Array.isArray(provider?.reasoningLevels) ? provider.reasoningLevels : []) {
+    const l = asRecord2(level);
+    if (l && typeof l.id === "string" && typeof l.label === "string") reasoningLabels[l.id] = l.label;
+  }
+  const loadError = asRecord2(rec.modelLoadError);
+  return {
+    providerId,
+    models,
+    permissionModes,
+    planCommand: commandFor("plan"),
+    goalCommand: commandFor("goal"),
+    reasoningLabels,
+    modelLoadError: loadError && typeof loadError.code === "string" ? loadError.code : null
+  };
+}
+function parseBranches(value) {
+  const rec = asRecord2(value) ?? {};
+  const checkout = asRecord2(rec.checkout);
+  const current = checkout?.kind === "branch" && typeof checkout.branchName === "string" ? checkout.branchName : null;
+  const branches = (Array.isArray(rec.branches) ? rec.branches : []).filter(
+    (name) => typeof name === "string" && name.length > 0
+  );
+  return {
+    current,
+    branches: current && !branches.includes(current) ? [current, ...branches] : branches,
+    defaultBranch: typeof rec.defaultBranch === "string" ? rec.defaultBranch : null,
+    dirty: rec.hasUncommittedChanges === true
+  };
+}
+function branchName(value) {
+  if (typeof value !== "string") return void 0;
+  const name = value.trim();
+  if (!name || name.length > 200 || name.startsWith("-") || name.includes("..")) return void 0;
+  if (/[\s~^:?*[\\]/.test(name) || [...name].some((c) => c.charCodeAt(0) < 32 || c.charCodeAt(0) === 127)) {
+    return void 0;
+  }
+  return name;
+}
+function parseComposeWorkspace(value) {
+  const rec = asRecord2(value);
+  if (!rec) return null;
+  if (rec.kind === "local") {
+    const branch = branchName(rec.branch);
+    return branch ? { kind: "local", branch } : { kind: "local" };
+  }
+  if (rec.kind === "worktree") {
+    const baseBranch = branchName(rec.baseBranch);
+    return baseBranch ? { kind: "worktree", baseBranch } : { kind: "worktree" };
+  }
+  return null;
+}
+function environmentFor(base, workspace) {
+  if (!workspace) return base;
+  if (workspace.kind === "worktree") {
+    return {
+      type: "host",
+      hostId: base.hostId,
+      workspace: {
+        type: "managed-worktree",
+        baseBranch: workspace.baseBranch ? { kind: "named", name: workspace.baseBranch } : { kind: "default" }
+      }
+    };
+  }
+  if (!workspace.branch || base.workspace.type !== "unmanaged") return base;
+  return { ...base, workspace: { ...base.workspace, branch: { kind: "existing", name: workspace.branch } } };
+}
+function parseComposeExecution(value) {
+  return parseModelChoice(value);
+}
+
+// ../editor/electron/bb/workspace-url.ts
+var mapFor = null;
+var maps = /* @__PURE__ */ new WeakMap();
+function projectMap(client) {
+  if (mapFor) return mapFor(client);
+  let map = maps.get(client);
+  if (!map) {
+    map = createProjectMap(client);
+    maps.set(client, map);
+  }
+  return map;
+}
+async function bbProjectFor(cwd, deps = {}) {
+  const ensureServer = deps.ensureServer ?? ensureBbServer;
+  const server2 = await ensureServer();
+  return projectMap(server2.client).resolve(cwd);
+}
+async function bbWorkspaceUrl(cwd, deps = {}, preferThreadId, home = false) {
+  const ensureServer = deps.ensureServer ?? ensureBbServer;
+  const server2 = await ensureServer();
+  const target = await projectMap(server2.client).resolve(cwd);
+  const threads = home || !preferThreadId ? [] : await server2.client.listThreads(target.projectId).catch(() => []);
+  const preferred = preferThreadId ? threads.find((thread) => thread.id === preferThreadId) : void 0;
+  if (!preferred) {
+    return {
+      url: `${server2.client.origin}/projects/${encodeURIComponent(target.projectId)}`,
+      origin: server2.client.origin,
+      projectId: target.projectId
+    };
+  }
+  return {
+    url: threadUrl(server2.client.origin, target.projectId, preferred.id),
+    origin: server2.client.origin,
+    projectId: target.projectId,
+    threadId: preferred.id
+  };
+}
+function threadUrl(origin, projectId, threadId) {
+  return `${origin}/projects/${encodeURIComponent(projectId)}/threads/${encodeURIComponent(threadId)}`;
+}
+function latestThread(threads) {
+  let best;
+  for (const thread of threads) {
+    if (!best || (thread.createdAt ?? 0) >= (best.createdAt ?? 0)) best = thread;
+  }
+  return best;
+}
+async function sendToWorkspace(cwd, text3, deps = {}) {
+  const ensureServer = deps.ensureServer ?? ensureBbServer;
+  const server2 = await ensureServer();
+  await deps.ensureTools?.();
+  const target = await projectMap(server2.client).resolve(cwd);
+  const threads = await server2.client.listThreads(target.projectId).catch(() => []);
+  const latest = latestThread(threads);
+  if (latest) {
+    await server2.client.sendMessage(latest.id, [{ type: "text", text: text3 }]);
+    return { threadId: latest.id, created: false };
+  }
+  const thread = await createThreadAsPicked(server2.client, deps, {
+    projectId: target.projectId,
+    input: [{ type: "text", text: text3 }],
+    environment: target.environment
+  });
+  return { threadId: thread.id, created: true };
+}
+async function listWorkspaceThreads(cwd, deps = {}) {
+  const ensureServer = deps.ensureServer ?? ensureBbServer;
+  const server2 = await ensureServer();
+  const target = await projectMap(server2.client).resolve(cwd);
+  const threads = await server2.client.listThreads(target.projectId);
+  return [...threads].sort((a, b) => (b.createdAt ?? 0) - (a.createdAt ?? 0));
+}
+var ACTIVITY_WINDOW = 12;
+async function workspaceThreadActivity(cwd, deps = {}) {
+  const ensureServer = deps.ensureServer ?? ensureBbServer;
+  const server2 = await ensureServer();
+  const target = await projectMap(server2.client).resolve(cwd);
+  const threads = (await server2.client.listThreads(target.projectId)).sort((a, b) => (b.createdAt ?? 0) - (a.createdAt ?? 0)).slice(0, ACTIVITY_WINDOW);
+  const rows = await Promise.all(
+    threads.map(async (thread) => {
+      const status = thread.status ?? await server2.client.threadStatus(thread.id).catch(() => null);
+      const working = status === "pending" || status === "starting" || status === "active" || status === "stopping";
+      const step = working ? await server2.client.latestThreadItems(thread.id).then(describeStep).catch(() => null) : null;
+      return status ? {
+        id: thread.id,
+        title: thread.title ?? thread.titleFallback ?? null,
+        createdAt: thread.createdAt,
+        updatedAt: thread.updatedAt ?? thread.createdAt,
+        status,
+        providerId: thread.providerId ?? null,
+        needsYou: thread.hasPendingInteraction === true,
+        step
+      } : null;
+    })
+  );
+  return rows.flatMap((row2) => row2 ? [row2] : []);
+}
+async function sendToWorkspaceThread(cwd, threadId, text3, deps = {}) {
+  const ensureServer = deps.ensureServer ?? ensureBbServer;
+  const server2 = await ensureServer();
+  await deps.ensureTools?.();
+  const target = await projectMap(server2.client).resolve(cwd);
+  const threads = await server2.client.listThreads(target.projectId);
+  if (!threads.some((thread) => thread.id === threadId)) {
+    throw new Error("that conversation is not in this project");
+  }
+  await server2.client.sendMessage(threadId, [{ type: "text", text: text3 }], { mode: "queue-if-active" });
+  const origin = server2.client.origin;
+  return { url: threadUrl(origin, target.projectId, threadId), origin, projectId: target.projectId, threadId };
+}
+async function startWorkspaceThread(cwd, text3, deps = {}, options = {}) {
+  const ensureServer = deps.ensureServer ?? ensureBbServer;
+  const server2 = await ensureServer();
+  await deps.ensureTools?.();
+  const target = await projectMap(server2.client).resolve(cwd);
+  const picked = options.execution;
+  const thread = await createThreadAsPicked(
+    server2.client,
+    picked ? { ...deps, modelChoice: async () => picked } : deps,
+    {
+      projectId: target.projectId,
+      input: [{ type: "text", text: text3 }],
+      environment: environmentFor(target.environment, options.workspace ?? null),
+      ...options.permissionMode ? { permissionMode: options.permissionMode } : {}
+    }
+  );
+  const origin = server2.client.origin;
+  return {
+    url: threadUrl(origin, target.projectId, thread.id),
+    origin,
+    projectId: target.projectId,
+    threadId: thread.id
+  };
+}
+async function workspaceBranches(cwd, deps = {}) {
+  const ensureServer = deps.ensureServer ?? ensureBbServer;
+  const server2 = await ensureServer();
+  const target = await projectMap(server2.client).resolve(cwd);
+  return parseBranches(await server2.client.projectBranches(target.projectId, target.hostId));
+}
+async function createThreadAsPicked(client, deps, args2) {
+  const execution = deps.modelChoice ? await deps.modelChoice().catch(() => null) : null;
+  if (!execution) return client.createThread(args2);
+  try {
+    return await client.createThread({ ...args2, execution, origin: "app" });
+  } catch (err) {
+    if (!(err instanceof BbApiError) || err.status < 400 || err.status >= 500) throw err;
+    return client.createThread(args2);
+  }
+}
+async function bbAppUrl(deps = {}) {
+  const ensureServer = deps.ensureServer ?? ensureBbServer;
+  const server2 = await ensureServer();
+  const origin = server2.client.origin;
+  return { url: `${origin}/`, origin };
+}
+
+// ../editor/electron/bb/provider-choice.ts
+var STATUSES = [
+  "ready",
+  "not_installed",
+  "unauthenticated",
+  "expired",
+  "unsupported_version",
+  "unknown"
+];
+function asRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function parseProviders(value, origin) {
+  if (!Array.isArray(value)) return [];
+  const out = [];
+  for (const entry of value) {
+    const rec = asRecord3(entry);
+    const id = typeof rec?.id === "string" ? rec.id.trim() : "";
+    if (!rec || !id) continue;
+    const displayName = typeof rec.displayName === "string" && rec.displayName.trim() ? rec.displayName.trim() : id;
+    let logoUrl = null;
+    if (typeof rec.logoUrl === "string" && rec.logoUrl) {
+      try {
+        logoUrl = new URL(rec.logoUrl, origin).toString();
+      } catch {
+        logoUrl = null;
+      }
+    }
+    let iconTint = parseTint(rec);
+    if (id === ANTIGRAVITY_PROVIDER_ID && !logoUrl) {
+      logoUrl = ANTIGRAVITY_LOGO_URL;
+      iconTint ??= { ...ANTIGRAVITY_TINT };
+    }
+    out.push({ id, displayName, logoUrl, iconTint, available: rec.available !== false });
+  }
+  return out;
+}
+var COLOUR = /^(#[0-9a-f]{3,8}|(rgb|rgba|hsl|hsla|oklch|oklab)\([0-9a-z.,%\s/+-]*\)|[a-z]+)$/i;
+function parseTint(rec) {
+  const tint = asRecord3(asRecord3(rec.strings)?.iconTint);
+  const light = typeof tint?.light === "string" ? tint.light.trim() : "";
+  const dark = typeof tint?.dark === "string" ? tint.dark.trim() : "";
+  return COLOUR.test(light) && COLOUR.test(dark) ? { light, dark } : null;
+}
+async function inlineLogo(client, logoUrl) {
+  if (!logoUrl) return null;
+  if (logoUrl.startsWith("data:")) return logoUrl;
+  try {
+    const text3 = (await client.providerLogo(logoUrl, 5e3)).trim();
+    if (/^(<\?xml[^>]*>\s*)?<svg[\s>]/i.test(text3)) {
+      return `data:image/svg+xml;base64,${Buffer.from(text3, "utf-8").toString("base64")}`;
+    }
+  } catch {
+  }
+  return logoUrl;
+}
+function parseProviderStatuses(value) {
+  const statuses = /* @__PURE__ */ new Map();
+  const list = asRecord3(value)?.providers;
+  if (!Array.isArray(list)) return statuses;
+  for (const entry of list) {
+    const rec = asRecord3(entry);
+    if (typeof rec?.providerId !== "string") continue;
+    const status = STATUSES.includes(rec.status) ? rec.status : "unknown";
+    statuses.set(rec.providerId, status);
+  }
+  return statuses;
+}
+function generalSettingsOf(config) {
+  return asRecord3(config.generalSettings);
+}
+async function readProviderChoice(client) {
+  const [providers, statuses, config] = await Promise.all([
+    client.providers(),
+    client.providerStates().catch(() => null),
+    client.systemConfig()
+  ]);
+  const byId = parseProviderStatuses(statuses);
+  const defaultId = generalSettingsOf(config)?.defaultProviderId;
+  const listed = parseProviders(providers, client.origin);
+  const logos = await Promise.all(listed.map((provider) => inlineLogo(client, provider.logoUrl)));
+  return {
+    providers: listed.map((provider, index) => ({
+      ...provider,
+      logoUrl: logos[index],
+      status: byId.get(provider.id) ?? "unknown"
+    })),
+    defaultProviderId: typeof defaultId === "string" && defaultId ? defaultId : null
+  };
+}
+async function setDefaultProvider(client, providerId) {
+  const id = providerId.trim();
+  if (!id) throw new Error("No provider was chosen.");
+  const settings = generalSettingsOf(await client.systemConfig());
+  if (!settings) throw new Error("The agent backend did not report its settings.");
+  await client.putGeneralSettings({ ...settings, defaultProviderId: id });
+}
+
+// ../editor/electron/bb/attachments.ts
+import fs18 from "node:fs";
+import path17 from "node:path";
+var ATTACHMENTS_DIR = path17.join(".codecaine", "attachments");
+var MAX_ATTACHMENT_BYTES = 25 * 1024 * 1024;
+function attachmentFileName(name, now = Date.now()) {
+  const last = String(name || "attachment").split(/[\\/]/).pop() ?? "";
+  const base = last.replace(/[^\w.\- ]+/g, "_").replace(/\.{2,}/g, ".").replace(/^\.+/, "");
+  const trimmed = (base || "attachment").slice(-80);
+  return `${now.toString(36)}-${trimmed}`;
+}
+function saveAttachment(cwd, name, bytes) {
+  if (!cwd || !path17.isAbsolute(cwd) || !fs18.existsSync(cwd)) {
+    return { ok: false, error: "This document has no project folder to attach files to." };
+  }
+  if (!(bytes instanceof Uint8Array)) return { ok: false, error: "Nothing to attach." };
+  if (bytes.byteLength > MAX_ATTACHMENT_BYTES) {
+    return { ok: false, error: `${name} is larger than ${MAX_ATTACHMENT_BYTES / 1024 / 1024}MB.` };
+  }
+  const dir = path17.join(cwd, ATTACHMENTS_DIR);
+  fs18.mkdirSync(dir, { recursive: true });
+  const ignore = path17.join(dir, ".gitignore");
+  if (!fs18.existsSync(ignore)) fs18.writeFileSync(ignore, "*\n");
+  const relative4 = path17.join(ATTACHMENTS_DIR, attachmentFileName(name));
+  fs18.writeFileSync(path17.join(cwd, relative4), bytes);
+  return { ok: true, path: relative4.split(path17.sep).join("/") };
+}
+
+// src/bb.ts
+var BB_SERVER_PORT = 38896;
+var BB_DAEMON_PORT = 38897;
+var EXPECTED_INSTALL_BYTES = 244e6;
+var bbAppDir = () => path18.join(dataDir(), "bb-app");
+var launcherFile = () => path18.join(bbAppDir(), "node_modules", "bb-app", "dist", "bb-app.js");
+function isolate(env = process.env) {
+  env.CANVAS_BB_DATA_DIR ??= path18.join(dataDir(), "bb");
+  env.CANVAS_BB_SERVER_PORT ??= String(BB_SERVER_PORT);
+  env.CANVAS_BB_DAEMON_PORT ??= String(BB_DAEMON_PORT);
+  env.CODECAINE_BB_APP_DIR ??= bbAppDir();
+}
+function bbInstalled() {
+  try {
+    const manifest = JSON.parse(
+      fs19.readFileSync(path18.join(bbAppDir(), "node_modules", "bb-app", "package.json"), "utf8")
+    );
+    return manifest.version === BB_APP_VERSION && fs19.existsSync(launcherFile());
+  } catch {
+    return false;
+  }
+}
+async function folderBytes(dir) {
+  let total = 0;
+  const walk2 = async (at) => {
+    let entries;
+    try {
+      entries = await fs19.promises.readdir(at, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = path18.join(at, entry.name);
+      if (entry.isDirectory()) await walk2(full);
+      else if (entry.isFile()) total += (await fs19.promises.stat(full).catch(() => ({ size: 0 }))).size;
+    }
+  };
+  await walk2(dir);
+  return total;
+}
+function installBb(onProgress) {
+  fs19.mkdirSync(bbAppDir(), { recursive: true });
+  return new Promise((resolve3, reject) => {
+    const npm = process.platform === "win32" ? "npm.cmd" : "npm";
+    const child = spawn(
+      npm,
+      ["install", `bb-app@${BB_APP_VERSION}`, "--prefix", bbAppDir(), "--no-audit", "--no-fund", "--loglevel=error"],
+      { stdio: ["ignore", "ignore", "pipe"], shell: process.platform === "win32" }
+    );
+    let stderr = "";
+    child.stderr.on("data", (chunk) => stderr += chunk.toString());
+    let measuring = false;
+    let done = false;
+    const timer = setInterval(async () => {
+      if (measuring || done) return;
+      measuring = true;
+      const bytes = await folderBytes(path18.join(bbAppDir(), "node_modules"));
+      measuring = false;
+      if (!done) onProgress(Math.min(99, Math.round(bytes / EXPECTED_INSTALL_BYTES * 100)));
+    }, 700);
+    child.on("error", (error) => {
+      done = true;
+      clearInterval(timer);
+      reject(error);
+    });
+    child.on("exit", (code) => {
+      done = true;
+      clearInterval(timer);
+      if (code === 0 && bbInstalled()) {
+        onProgress(100);
+        resolve3();
+      } else {
+        reject(new Error(`installing the assistant failed (npm exited ${code})${stderr ? `: ${stderr.trim().split("\n").slice(-3).join(" ")}` : ""}`));
+      }
+    });
+  });
+}
+function createAssistant(ipc, onState = () => {
+}) {
+  isolate();
+  let state = { phase: bbInstalled() ? "idle" : "idle", percent: null, message: "", error: null };
+  const set = (next) => {
+    state = { ...state, ...next };
+    onState(state);
+    ipc.broadcast("companion:assistant", state);
+  };
+  const send2 = (channel, payload) => ipc.broadcast(channel, payload);
+  let pending3 = null;
+  function ready() {
+    if (state.phase === "ready") return Promise.resolve();
+    pending3 ??= (async () => {
+      try {
+        if (!bbInstalled()) {
+          set({ phase: "installing", percent: 0, message: "Downloading the assistant\u2026", error: null });
+          await installBb((percent) => set({ phase: "installing", percent, message: "Downloading the assistant\u2026" }));
+        }
+        set({ phase: "starting", percent: null, message: "Starting the assistant\u2026", error: null });
+        let lastError2 = null;
+        for (const pause of [0, 2e3, 5e3]) {
+          if (pause) await new Promise((resolve3) => setTimeout(resolve3, pause));
+          try {
+            const tools = await ensureCanvasTools(send2);
+            if (!tools) throw new Error(canvasToolsStatus().error ?? "the editor's tools could not be loaded into the assistant");
+            lastError2 = null;
+            break;
+          } catch (error) {
+            lastError2 = error;
+          }
+        }
+        if (lastError2) throw lastError2;
+        set({ phase: "ready", percent: 100, message: "Ready", error: null });
+      } catch (error) {
+        set({ phase: "failed", percent: null, message: "The assistant did not start", error: error instanceof Error ? error.message : String(error) });
+        throw error;
+      } finally {
+        pending3 = null;
+      }
+    })();
+    return pending3;
+  }
+  const modelChoices = createModelChoiceStore({
+    file: path18.join(dataDir(), "agent-model-choice.json"),
+    read: async () => "unreachable"
+  });
+  const fail = (error) => ({ ok: false, error: error instanceof Error ? error.message : String(error) });
+  const ensureTools = () => waitForCanvasTools(send2);
+  ipc.handle("agent:connect", async () => {
+    try {
+      await ready();
+      return { ok: true, url: `http://127.0.0.1:${BB_SERVER_PORT}` };
+    } catch (error) {
+      return fail(error);
+    }
+  });
+  ipc.handle("agent:status", async () => canvasToolsStatus());
+  ipc.handle("agent:connection", async (options = {}) => {
+    if (state.phase !== "ready") return { connected: true, projects: [] };
+    let projectId;
+    if (options?.cwd) {
+      try {
+        projectId = (await bbProjectFor(options.cwd)).projectId;
+      } catch {
+      }
+    }
+    return canvasToolsConnection(send2, {
+      ...projectId ? { projectId, path: options.cwd } : {},
+      ...options?.instructions !== void 0 ? { instructions: options.instructions } : {},
+      ...options?.layers !== void 0 ? { layers: options.layers } : {}
+    });
+  });
+  ipc.handle("bb:providers", async () => {
+    try {
+      await ready();
+      const { client } = await ensureBbServer();
+      return { ok: true, ...await readProviderChoice(client) };
+    } catch (error) {
+      return fail(error);
+    }
+  });
+  ipc.handle("bb:set-default-provider", async (options) => {
+    try {
+      const { client } = await ensureBbServer();
+      await setDefaultProvider(client, String(options?.providerId ?? ""));
+      return { ok: true };
+    } catch (error) {
+      return fail(error);
+    }
+  });
+  ipc.handle("bb:compose-options", async (options) => {
+    try {
+      await ready();
+      const { client } = await ensureBbServer();
+      const picked = await modelChoices.current().catch(() => null);
+      const asked = typeof options?.providerId === "string" && options.providerId ? options.providerId : null;
+      const fallback = typeof options?.fallbackProviderId === "string" && options.fallbackProviderId ? options.fallbackProviderId : null;
+      const providerId = asked ?? picked?.providerId ?? fallback;
+      if (!providerId) return { ok: false, error: "No agent is set up yet." };
+      return { ok: true, picked, options: parseExecutionOptions(await client.executionOptions(providerId), providerId) };
+    } catch (error) {
+      return fail(error);
+    }
+  });
+  ipc.handle("bb:branches", async (options) => {
+    try {
+      const cwd = String(options?.cwd ?? "");
+      if (!path18.isAbsolute(cwd)) throw new Error("not a project folder");
+      await ready();
+      return { ok: true, ...await workspaceBranches(cwd) };
+    } catch (error) {
+      return fail(error);
+    }
+  });
+  ipc.handle("bb:agent-url", async () => {
+    try {
+      await ready();
+      return { ok: true, ...await bbAppUrl() };
+    } catch (error) {
+      return fail(error);
+    }
+  });
+  ipc.handle("bb:instructions", async (options) => {
+    if (state.phase !== "ready") return { ok: true };
+    try {
+      const target = await bbProjectFor(options.cwd);
+      return { ok: await setAgentInstructions(send2, { projectId: target.projectId, path: options.cwd, instructions: options.instructions }) };
+    } catch (error) {
+      return fail(error);
+    }
+  });
+  ipc.handle("bb:selection", async (options) => {
+    if (state.phase !== "ready" || !options?.cwd) return { ok: true, shown: false, attached: true };
+    try {
+      const target = await bbProjectFor(options.cwd);
+      const attached = await setCanvasSelection(send2, { projectId: target.projectId, path: options.cwd, layers: options.layers ?? [] });
+      return { ok: true, shown: false, attached };
+    } catch (error) {
+      return { ok: true, shown: false, attached: false, error: error instanceof Error ? error.message : String(error) };
+    }
+  });
+  ipc.handle("bb:apply-chrome", async () => ({ ok: true }));
+  ipc.handle("bb:magic-cast", async () => ({ ok: true }));
+  ipc.handle("bb:send", async (options) => {
+    try {
+      await ready();
+      return { ok: true, ...await sendToWorkspace(options.cwd, options.text, { modelChoice: () => modelChoices.current(), ensureTools }) };
+    } catch (error) {
+      return fail(error);
+    }
+  });
+  ipc.handle("bb:thread-status", async (options) => {
+    try {
+      const { client } = await ensureBbServer();
+      return { ok: true, status: await client.threadStatus(options.threadId) };
+    } catch (error) {
+      return fail(error);
+    }
+  });
+  ipc.handle("bb:thread-activity", async (options) => {
+    if (state.phase !== "ready") return { ok: true, threads: [] };
+    try {
+      return { ok: true, threads: await workspaceThreadActivity(String(options?.cwd ?? "")) };
+    } catch (error) {
+      return fail(error);
+    }
+  });
+  ipc.handle("bb:threads", async (options) => {
+    if (state.phase !== "ready") return { ok: true, threads: [] };
+    try {
+      return { ok: true, threads: await listWorkspaceThreads(String(options?.cwd ?? "")) };
+    } catch (error) {
+      return fail(error);
+    }
+  });
+  ipc.handle("bb:send-thread", async (options) => {
+    try {
+      await ready();
+      return { ok: true, ...await sendToWorkspaceThread(String(options.cwd ?? ""), String(options.threadId ?? ""), String(options.text ?? ""), { ensureTools }) };
+    } catch (error) {
+      return fail(error);
+    }
+  });
+  ipc.handle(
+    "bb:new-thread",
+    async (options) => {
+      try {
+        await ready();
+        return {
+          ok: true,
+          ...await startWorkspaceThread(
+            options.cwd,
+            options.text,
+            { modelChoice: () => modelChoices.current(), ensureTools },
+            {
+              ...isBbPermissionMode(options.permissionMode) ? { permissionMode: options.permissionMode } : {},
+              execution: parseComposeExecution(options.execution),
+              workspace: parseComposeWorkspace(options.workspace)
+            }
+          )
+        };
+      } catch (error) {
+        return fail(error);
+      }
+    }
+  );
+  ipc.handle("bb:save-attachment", async (options) => {
+    try {
+      return saveAttachment(options.cwd, options.name, options.bytes);
+    } catch (error) {
+      return fail(error);
+    }
+  });
+  return { state: () => state, ready };
+}
+async function assistantTarget(cwd, threadId, home) {
+  const target = await bbWorkspaceUrl(cwd, {}, threadId, home);
+  return target;
+}
+
+// src/ipc.ts
+var Ipc = class {
+  handlers = /* @__PURE__ */ new Map();
+  peers = /* @__PURE__ */ new Set();
+  handle(channel, handler) {
+    this.handlers.set(channel, handler);
+  }
+  /** The handler a channel has now — for wrapping one in another. */
+  get(channel) {
+    return this.handlers.get(channel);
+  }
+  has(channel) {
+    return this.handlers.has(channel);
+  }
+  async invoke(channel, args2) {
+    const handler = this.handlers.get(channel);
+    if (!handler) {
+      throw new Error(`${channel} is not available in the web build`);
+    }
+    return handler(...args2);
+  }
+  addPeer(peer) {
+    this.peers.add(peer);
+    return () => this.peers.delete(peer);
+  }
+  peerCount() {
+    return this.peers.size;
+  }
+  /** `webContents.send` to every connected editor. */
+  broadcast(channel, ...args2) {
+    for (const peer of this.peers) peer.send(channel, ...args2);
+  }
+};
+
+// src/wire.ts
+var BYTES = "$bytes";
+function toBase64(bytes) {
+  if (typeof Buffer !== "undefined") return Buffer.from(bytes).toString("base64");
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += 32768) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + 32768));
+  }
+  return btoa(binary);
+}
+function fromBase64(text3) {
+  if (typeof Buffer !== "undefined") {
+    const buffer = Buffer.from(text3, "base64");
+    return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+  }
+  const binary = atob(text3);
+  const out = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) out[i] = binary.charCodeAt(i);
+  return out.buffer;
+}
+function encode(value) {
+  return JSON.stringify(value, (_key, item) => {
+    if (item instanceof ArrayBuffer) return { [BYTES]: toBase64(new Uint8Array(item)) };
+    if (ArrayBuffer.isView(item)) {
+      return { [BYTES]: toBase64(new Uint8Array(item.buffer, item.byteOffset, item.byteLength)) };
+    }
+    return item;
+  });
+}
+function decode(text3) {
+  return JSON.parse(text3, (_key, item) => {
+    if (item && typeof item === "object" && BYTES in item && Object.keys(item).length === 1) {
+      return fromBase64(String(item[BYTES]));
+    }
+    return item;
+  });
+}
+
+// src/server.ts
+var VERSION = "0.1.2";
+var LOOPBACK = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]", "::1"]);
+var MAX_BODY_BYTES2 = 8 * 1024 * 1024;
+function hostIsLocal(host) {
+  if (!host) return true;
+  try {
+    return LOOPBACK.has(new URL(`http://${host}`).hostname);
+  } catch {
+    return false;
+  }
+}
+function tokenMatches2(expected, given) {
+  if (!given) return false;
+  const a = Buffer.from(expected);
+  const b = Buffer.from(given);
+  return a.length === b.length && crypto3.timingSafeEqual(a, b);
+}
+function readBody2(request) {
+  return new Promise((resolve3, reject) => {
+    const chunks = [];
+    let size = 0;
+    request.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > MAX_BODY_BYTES2) {
+        reject(new Error("Request body too large."));
+        request.destroy();
+        return;
       }
       chunks.push(chunk);
     });
@@ -10432,8 +12935,40 @@ async function startCompanion(options) {
     })
   });
   const info = { name: "codecaine", version: VERSION, instructions: agent.instructions };
+  const viaInbox = Object.fromEntries(
+    ["bb:new-thread", "bb:send", "bb:send-thread", "bb:workspace-url"].map((channel) => [channel, ipc.get(channel)])
+  );
+  const useAssistant = options.assistant !== false;
+  const assistant = useAssistant ? createAssistant(ipc) : { state: () => ({ phase: "failed", percent: null, message: "Off", error: "The assistant is off (--no-assistant)." }), ready: () => Promise.reject(new Error("The assistant is off (--no-assistant).")) };
+  for (const [channel, inboxHandler] of Object.entries(viaInbox)) {
+    if (channel === "bb:workspace-url") continue;
+    const bbHandler = ipc.get(channel);
+    ipc.handle(channel, async (...args2) => {
+      const answer = await bbHandler(...args2);
+      return answer?.ok === false && assistant.state().phase === "failed" ? inboxHandler(...args2) : answer;
+    });
+  }
+  const startingUrl = (cwd, threadId, home) => `http://127.0.0.1:${port}/agent/${pageKey}/starting?` + new URLSearchParams({ cwd, ...threadId ? { thread: threadId } : {}, ...home ? { home: "1" } : {} }).toString();
+  ipc.handle("bb:workspace-url", async (args2) => {
+    if (!useAssistant) return viaInbox["bb:workspace-url"](args2);
+    const cwd = String(args2?.cwd ?? "");
+    const threadId = typeof args2?.threadId === "string" ? args2.threadId : null;
+    if (assistant.state().phase === "ready") {
+      try {
+        const target = await assistantTarget(cwd, threadId, args2?.home === true);
+        await waitForCanvasTools((channel, payload) => ipc.broadcast(channel, payload), { attempts: 1 }).catch(() => {
+        });
+        return { ok: true, ...target };
+      } catch (error) {
+        return { ok: false, error: error instanceof Error ? error.message : String(error) };
+      }
+    }
+    void assistant.ready().catch(() => {
+    });
+    return { ok: true, url: startingUrl(cwd, threadId, args2?.home === true), origin: `http://127.0.0.1:${port}`, projectId: cwd };
+  });
   const corsFor = (origin) => origin && allowed.has(origin) ? { "access-control-allow-origin": origin, vary: "Origin", "access-control-allow-private-network": "true" } : { vary: "Origin" };
-  const server = http2.createServer((request, response) => {
+  const server2 = http3.createServer((request, response) => {
     void route(request, response).catch((error) => {
       if (!response.headersSent) json(response, 500, { error: error instanceof Error ? error.message : String(error) });
       else response.destroy();
@@ -10465,12 +13000,34 @@ async function startCompanion(options) {
       response.writeHead(200, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store", "content-length": Buffer.byteLength(html) });
       return void response.end(html);
     }
+    if (url.pathname === `/agent/${pageKey}/starting`) {
+      const html = assistantStartingPage();
+      response.writeHead(200, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store", "content-length": Buffer.byteLength(html) });
+      return void response.end(html);
+    }
+    if (url.pathname === `/agent/${pageKey}/assistant`) {
+      const state = assistant.state();
+      if (state.phase === "idle") void assistant.ready().catch(() => {
+      });
+      let target = null;
+      if (state.phase === "ready") {
+        try {
+          target = (await assistantTarget(url.searchParams.get("cwd") ?? "", url.searchParams.get("thread"), url.searchParams.get("home") === "1")).url;
+        } catch (error) {
+          return json(response, 200, { state: { ...state, phase: "failed", error: error instanceof Error ? error.message : String(error) }, theme: agent.inbox.theme }, { "cache-control": "no-store" });
+        }
+      }
+      return json(response, 200, { state, url: target, theme: agent.inbox.theme }, { "cache-control": "no-store" });
+    }
     if (url.pathname === `/agent/${pageKey}/state`) {
       const project = url.searchParams.get("project") ?? "";
       const inbox = agent.inbox;
       return json(response, 200, {
         theme: inbox.theme,
         agent: inbox.connected(),
+        // Is a `codecaine mcp` waiting to push requests right now? It asks
+        // again every 25s, so a minute without asking means it has gone.
+        pushing: [...inbox.pushTargets.values()].some((at) => Date.now() - at < 6e4),
         requests: (project ? inbox.requests.filter((request2) => sameFolder(request2.cwd, project)) : inbox.requests).map(
           (request2) => ({ ...request2, words: wordsOf(request2.text) })
         ),
@@ -10478,8 +13035,86 @@ async function startCompanion(options) {
       }, { "cache-control": "no-store" });
     }
     if (url.pathname === "/mcp") return mcp(request, response);
+    if (url.pathname === "/inbox/wait") return inboxWait(request, response, url);
+    if (url.pathname === "/open" && request.method === "POST") return openOnStart(request, response);
+    if (url.pathname === "/assistant/start" && request.method === "POST") {
+      if (!agentAllowed(request, response)) return;
+      void assistant.ready().catch(() => {
+      });
+      return json(response, 200, assistant.state());
+    }
+    if (url.pathname === "/assistant/state") {
+      if (!agentAllowed(request, response)) return;
+      return json(response, 200, assistant.state());
+    }
     json(response, 404, { error: "Not found." });
   }
+  function agentAllowed(request, response) {
+    const origin = request.headers.origin;
+    if (origin && origin !== "null") {
+      try {
+        if (!LOOPBACK.has(new URL(origin).hostname)) {
+          json(response, 403, { error: "Forbidden origin." });
+          return false;
+        }
+      } catch {
+        json(response, 403, { error: "Forbidden origin." });
+        return false;
+      }
+    }
+    const header3 = request.headers.authorization;
+    const given = header3 && /^Bearer\s+(.+)$/i.exec(header3.trim())?.[1];
+    if (!tokenMatches2(options.mcpToken, given)) {
+      json(response, 401, { error: "Missing or wrong bearer token." }, { "www-authenticate": "Bearer" });
+      return false;
+    }
+    return true;
+  }
+  function inboxWait(request, response, url) {
+    if (!agentAllowed(request, response)) return;
+    const since = Number(url.searchParams.get("since") ?? 0);
+    const client = String(request.headers["x-codecaine-client"] ?? "") || "Your coding agent";
+    const inbox = agent.inbox;
+    inbox.pushTargets.set(client, Date.now());
+    inbox.heard(client);
+    const waiting = () => inbox.requests.filter((entry) => entry.status === "pending" && entry.updatedAt > since);
+    const ready = waiting();
+    if (ready.length) return json(response, 200, { requests: ready });
+    let done = false;
+    const finish = (requests) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      stop();
+      json(response, 200, { requests });
+    };
+    const stop = inbox.onWaiting(() => finish(waiting()));
+    const timer = setTimeout(() => finish([]), 25e3);
+    request.on("close", () => {
+      done = true;
+      clearTimeout(timer);
+      stop();
+    });
+  }
+  const broughtForward = /* @__PURE__ */ new Set();
+  async function openOnStart(request, response) {
+    if (!agentAllowed(request, response)) return;
+    let folder;
+    try {
+      folder = String(JSON.parse(await readBody2(request)).folder ?? "");
+    } catch {
+      return json(response, 400, { error: "Expected { folder }." });
+    }
+    if (!folder || !looksLikeProject(folder)) return json(response, 200, { opened: false, reason: "not a project" });
+    const tabs = readOpenTabs(openTabsFile());
+    const inFront = tabs.folderPaths[tabs.activeIndex] === path19.resolve(folder);
+    if (broughtForward.has(path19.resolve(folder)) || inFront && ipc.peerCount() > 0) {
+      return json(response, 200, { opened: false, reason: "already in front" });
+    }
+    broughtForward.add(path19.resolve(folder));
+    const result = await agent.bringToFront(folder);
+    json(response, 200, result.ok ? { opened: true, folder: result.folderPath } : { opened: false, reason: result.error });
+  }
   async function mcp(request, response) {
     const origin = request.headers.origin;
     if (origin && origin !== "null") {
@@ -10491,7 +13126,7 @@ async function startCompanion(options) {
     }
     const header3 = request.headers.authorization;
     const given = header3 && /^Bearer\s+(.+)$/i.exec(header3.trim())?.[1];
-    if (!tokenMatches(options.mcpToken, given)) {
+    if (!tokenMatches2(options.mcpToken, given)) {
       return json(response, 401, { error: "Missing or wrong bearer token." }, { "www-authenticate": "Bearer" });
     }
     if (request.method === "GET") {
@@ -10501,14 +13136,17 @@ async function startCompanion(options) {
     if (request.method !== "POST") return json(response, 405, { error: "POST only." }, { allow: "POST" });
     let payload;
     try {
-      payload = JSON.parse(await readBody(request));
+      payload = JSON.parse(await readBody2(request));
     } catch {
       return json(response, 400, rpcError(null, RPC_PARSE_ERROR, "Parse error."));
     }
     const cwd = String(request.headers["x-codecaine-cwd"] ?? "");
+    const named = String(request.headers["x-codecaine-client"] ?? "") || null;
     for (const message of Array.isArray(payload) ? payload : [payload]) {
       const hello = message;
-      agent.inbox.heard(hello?.method === "initialize" && typeof hello.params?.clientInfo?.name === "string" ? hello.params.clientInfo.name : null);
+      agent.inbox.heard(
+        hello?.method === "initialize" && typeof hello.params?.clientInfo?.name === "string" ? hello.params.clientInfo.name : named
+      );
     }
     const answer = await handlePayload(
       payload,
@@ -10522,7 +13160,7 @@ async function startCompanion(options) {
     json(response, 200, answer);
   }
   const sockets = new import_websocket_server.default({ noServer: true, maxPayload: 256 * 1024 * 1024 });
-  server.on("upgrade", (request, socket, head) => {
+  server2.on("upgrade", (request, socket, head) => {
     const url = new URL(request.url ?? "/", "http://127.0.0.1");
     const origin = request.headers.origin;
     if (url.pathname !== "/bridge" || !hostIsLocal(request.headers.host) || !origin || !allowed.has(origin)) {
@@ -10534,14 +13172,14 @@ async function startCompanion(options) {
   });
   let peerIds = 0;
   function connect(ws) {
-    const send = (message) => {
+    const send2 = (message) => {
       if (ws.readyState === ws.OPEN) ws.send(encode(message));
     };
     const remove = ipc.addPeer({
       id: ++peerIds,
-      send: (channel, ...args2) => send({ t: "event", channel, args: args2 })
+      send: (channel, ...args2) => send2({ t: "event", channel, args: args2 })
     });
-    send({
+    send2({
       t: "hello",
       version: VERSION,
       mediaOrigin: `http://127.0.0.1:${port}/media/${mediaKey}/`,
@@ -10561,15 +13199,15 @@ async function startCompanion(options) {
       }
       if (message.t !== "invoke") return;
       ipc.invoke(message.channel, message.args).then(
-        (value) => send({ t: "result", id: message.id, ok: true, value }),
-        (error) => send({ t: "result", id: message.id, ok: false, error: error instanceof Error ? error.message : String(error) })
+        (value) => send2({ t: "result", id: message.id, ok: true, value }),
+        (error) => send2({ t: "result", id: message.id, ok: false, error: error instanceof Error ? error.message : String(error) })
       );
     });
     ws.on("close", remove);
   }
   port = await new Promise((resolve3, reject) => {
-    server.once("error", reject);
-    server.listen(options.port, "127.0.0.1", () => resolve3(server.address().port));
+    server2.once("error", reject);
+    server2.listen(options.port, "127.0.0.1", () => resolve3(server2.address().port));
   });
   return {
     port,
@@ -10577,13 +13215,13 @@ async function startCompanion(options) {
     close: () => new Promise((resolve3) => {
       live.close();
       for (const ws of sockets.clients) ws.terminate();
-      server.closeAllConnections?.();
-      server.close(() => resolve3());
+      server2.closeAllConnections?.();
+      server2.close(() => resolve3());
     })
   };
 }
 function serveFile(request, response, file, type, headers) {
-  const size = fs14.statSync(file).size;
+  const size = fs20.statSync(file).size;
   const range = /^bytes=(\d*)-(\d*)$/.exec(String(request.headers.range ?? ""));
   const base = { ...headers, "content-type": type, "accept-ranges": "bytes", "cache-control": "private, max-age=31536000, immutable" };
   if (range) {
@@ -10594,21 +13232,21 @@ function serveFile(request, response, file, type, headers) {
       return void response.end();
     }
     response.writeHead(206, { ...base, "content-range": `bytes ${start}-${end}/${size}`, "content-length": end - start + 1 });
-    fs14.createReadStream(file, { start, end }).pipe(response);
+    fs20.createReadStream(file, { start, end }).pipe(response);
     return;
   }
   response.writeHead(200, { ...base, "content-length": size });
-  fs14.createReadStream(file).pipe(response);
+  fs20.createReadStream(file).pipe(response);
 }
 function guestCandidates(here2) {
-  return [path12.join(here2, "canvas-live-guest.js"), path12.join(here2, "..", "..", "dist", "canvas-live-guest.js")];
+  return [path19.join(here2, "canvas-live-guest.js"), path19.join(here2, "..", "..", "dist", "canvas-live-guest.js")];
 }
 
 // src/cli.ts
 var DEFAULT_PORT = 4317;
 var DEFAULT_EDITOR = "https://celebrated-souffle-e3f7bf.netlify.app";
 var PUBLISHED_ORIGINS = ["https://editor.codecainehq.com", "https://celebrated-souffle-e3f7bf.netlify.app"];
-var here = path13.dirname(fileURLToPath(import.meta.url));
+var here = path20.dirname(fileURLToPath3(import.meta.url));
 function flag(args2, name) {
   const at = args2.indexOf(name);
   return at >= 0 ? args2[at + 1] : void 0;
@@ -10616,7 +13254,10 @@ function flag(args2, name) {
 function openBrowser(url) {
   const [file, args2] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
   try {
-    spawn(file, args2, { stdio: "ignore", detached: true }).unref();
+    const child = spawn2(file, args2, { stdio: "ignore", detached: true });
+    child.on("error", () => {
+    });
+    child.unref();
   } catch {
   }
 }
@@ -10642,10 +13283,11 @@ async function serve(args2) {
   const origins = [
     .../* @__PURE__ */ new Set([new URL(editorUrl).origin, ...PUBLISHED_ORIGINS, ...extra, "http://localhost:5180", "http://127.0.0.1:5180"])
   ];
-  const guestFile = guestCandidates(here).find((file) => fs15.existsSync(file));
+  const guestFile = guestCandidates(here).find((file) => fs21.existsSync(file));
   if (!guestFile) throw new Error("canvas-live-guest.js is missing \u2014 build the web app first (npm run build).");
   const quiet = args2.includes("--no-open");
-  const folder = args2.find((arg, i) => !arg.startsWith("--") && !args2[i - 1]?.startsWith("--"));
+  const named = args2.find((arg, i) => !arg.startsWith("--") && !["--port", "--editor", "--origin"].includes(args2[i - 1] ?? ""));
+  const folder = named ?? (looksLikeProject(process.cwd()) ? process.cwd() : void 0);
   if (await health(port)) {
     console.log(`codecaine is already running on port ${port}.`);
     if (!quiet) openBrowser(editorUrl);
@@ -10653,7 +13295,15 @@ async function serve(args2) {
   }
   restoreOpenFolders();
   const token = mcpToken();
-  const companion = await startCompanion({ port, editorUrl, origins, guestFile, mcpToken: token, openBrowser });
+  const companion = await startCompanion({
+    port,
+    editorUrl,
+    origins,
+    guestFile,
+    mcpToken: token,
+    openBrowser,
+    assistant: !args2.includes("--no-assistant") && process.env.CODECAINE_NO_ASSISTANT !== "1"
+  });
   writeState({ pid: process.pid, port: companion.port, mcpPort: companion.port, mcpToken: token, version: VERSION });
   if (folder) {
     const loaded = openFolder(folder);
@@ -10681,10 +13331,10 @@ async function serve(args2) {
   process.on("SIGINT", stop);
   process.on("SIGTERM", stop);
 }
-async function mcpPipe() {
+async function ensureCompanion() {
   let state = readState();
   if (!state || !await health(state.port)) {
-    const child = spawn(process.execPath, [fileURLToPath(import.meta.url), "--no-open"], {
+    const child = spawn2(process.execPath, [fileURLToPath3(import.meta.url), "--no-open"], {
       detached: true,
       stdio: "ignore",
       env: process.env
@@ -10697,7 +13347,11 @@ async function mcpPipe() {
       if (state && await health(state.port)) break;
     }
   }
-  if (!state || !await health(state.port)) {
+  return state && await health(state.port) ? state : null;
+}
+async function mcpPipe() {
+  const state = await ensureCompanion();
+  if (!state) {
     process.stderr.write("codecaine: the companion did not start; run `npx codecaine-cli` to see why.\n");
     process.exit(1);
   }
@@ -10707,31 +13361,156 @@ async function mcpPipe() {
     authorization: `Bearer ${state.mcpToken}`,
     "x-codecaine-cwd": process.cwd()
   };
+  const write = (message) => process.stdout.write(JSON.stringify(message) + "\n");
   const lines = readline.createInterface({ input: process.stdin });
   let chain = Promise.resolve();
+  let pushing = false;
   lines.on("line", (line) => {
     if (!line.trim()) return;
+    let message = null;
+    try {
+      message = JSON.parse(line);
+    } catch {
+    }
+    if (message?.method === "initialize" && typeof message.params?.clientInfo?.name === "string") {
+      headers["x-codecaine-client"] = message.params.clientInfo.name;
+    }
     chain = chain.then(async () => {
       try {
         const response = await fetch(target, { method: "POST", headers, body: line });
         if (response.status === 202) return;
-        process.stdout.write(await response.text() + "\n");
-      } catch (error) {
-        let id = null;
-        try {
-          id = JSON.parse(line).id ?? null;
-        } catch {
+        const text3 = await response.text();
+        if (message?.method !== "initialize") {
+          process.stdout.write(text3 + "\n");
+          return;
         }
-        process.stdout.write(
-          JSON.stringify({ jsonrpc: "2.0", id, error: { code: -32603, message: `codecaine companion unreachable: ${String(error)}` } }) + "\n"
-        );
+        const answer = JSON.parse(text3);
+        if (answer.result?.capabilities) {
+          const experimental = answer.result.capabilities.experimental ?? {};
+          answer.result.capabilities.experimental = { ...experimental, "claude/channel": {} };
+        }
+        write(answer);
+        void fetch(`http://127.0.0.1:${state.port}/open`, {
+          method: "POST",
+          headers,
+          body: JSON.stringify({ folder: process.cwd() })
+        }).catch(() => {
+        });
+        if (!pushing) {
+          pushing = true;
+          void pushRequests(headers, write);
+        }
+      } catch (error) {
+        write({ jsonrpc: "2.0", id: message?.id ?? null, error: { code: -32603, message: `codecaine companion unreachable: ${String(error)}` } });
       }
     });
   });
   lines.on("close", () => void chain.then(() => process.exit(0)));
 }
+async function pushRequests(headers, write) {
+  const pushed = /* @__PURE__ */ new Map();
+  let since = Date.now() - 10 * 6e4;
+  for (; ; ) {
+    const state = readState();
+    try {
+      if (!state) throw new Error("no companion");
+      const response = await fetch(`http://127.0.0.1:${state.port}/inbox/wait?since=${since}`, {
+        headers: { ...headers, authorization: `Bearer ${state.mcpToken}` },
+        signal: AbortSignal.timeout(4e4)
+      });
+      const { requests = [] } = await response.json();
+      for (const request of requests) {
+        since = Math.max(since, request.updatedAt);
+        if (pushed.get(request.id) === request.updatedAt) continue;
+        pushed.set(request.id, request.updatedAt);
+        write({
+          jsonrpc: "2.0",
+          method: "notifications/claude/channel",
+          params: {
+            content: [
+              `New request from the Codecaine board${request.cwd ? ` (project ${request.cwd})` : ""}:`,
+              "",
+              wordsOf(request.text),
+              ...request.followUps.map((more) => `+ ${more}`),
+              "",
+              `Call the codecaine takeRequests tool${request.cwd ? ` with folder "${request.cwd}"` : ""} to collect it \u2014 it carries the editor's full instructions \u2014 do it, then finishRequest with one sentence about what you did.`
+            ].join("\n"),
+            meta: { request_id: request.id, kind: "board_request" }
+          }
+        });
+      }
+    } catch {
+      await new Promise((r) => setTimeout(r, 3e3));
+    }
+  }
+}
+async function setup(args2) {
+  const tty = process.stdout.isTTY;
+  const say = (line) => process.stdout.write(line + "\n");
+  say(`codecaine ${VERSION} \u2014 setting up this machine for Codecaine
+`);
+  say("1/3  Starting the companion\u2026");
+  const state = await ensureCompanion();
+  if (!state) {
+    say("     It did not start. Run `npx codecaine-cli` to see why.");
+    process.exit(1);
+  }
+  say(`     Running on http://127.0.0.1:${state.port}`);
+  say("2/3  Getting the assistant ready (the first time it downloads about 240 MB)\u2026");
+  const headers = { authorization: `Bearer ${state.mcpToken}` };
+  const base = `http://127.0.0.1:${state.port}`;
+  let assistant = await (await fetch(`${base}/assistant/start`, { method: "POST", headers })).json();
+  let lastShown = -1;
+  const width = 28;
+  while (assistant.phase !== "ready" && assistant.phase !== "failed") {
+    const percent = assistant.percent;
+    if (percent != null && percent !== lastShown) {
+      const filled = Math.round(percent / 100 * width);
+      const bar = `     [${"\u2588".repeat(filled)}${"\u2591".repeat(width - filled)}] ${String(percent).padStart(3)}%  ${assistant.message}`;
+      if (tty) process.stdout.write(`\r${bar}`);
+      else if (Math.floor(percent / 10) !== Math.floor(lastShown / 10)) say(bar);
+      lastShown = percent;
+    } else if (percent == null && lastShown !== -2 && assistant.phase === "starting") {
+      if (tty && lastShown >= 0) process.stdout.write("\n");
+      say("     Starting it\u2026");
+      lastShown = -2;
+    }
+    await new Promise((r) => setTimeout(r, 500));
+    assistant = await (await fetch(`${base}/assistant/state`, { headers })).json();
+  }
+  if (tty && lastShown >= 0) process.stdout.write("\n");
+  if (assistant.phase === "failed") {
+    say(`     The assistant did not start: ${assistant.error ?? "no reason given"}`);
+    say("     The editor still works; its Agent panel says the same and retries.");
+  } else {
+    say("     Ready \u2014 it is the Agent panel in the editor.");
+  }
+  say("3/3  Connecting your coding agent over MCP\u2026");
+  const has = (command) => spawnSync(process.platform === "win32" ? "where" : "which", [command], { stdio: "ignore" }).status === 0;
+  if (args2.includes("--no-mcp")) {
+    say("     Skipped (--no-mcp). Add the command `npx -y codecaine-cli mcp` as an MCP server whenever you want.");
+  } else if (has("claude")) {
+    if (spawnSync("claude", ["mcp", "get", "codecaine"], { stdio: "ignore" }).status === 0) {
+      say("     Claude Code already has it.");
+    } else {
+      const added = spawnSync("claude", ["mcp", "add", "codecaine", "-s", "user", "--", "npx", "-y", "codecaine-cli", "mcp"], { stdio: "ignore" });
+      say(added.status === 0 ? "     Added to Claude Code. Restart Claude Code to load it." : "     Could not add it to Claude Code; run: claude mcp add codecaine -- npx -y codecaine-cli mcp");
+    }
+  } else {
+    say("     Claude Code is not installed \u2014 skipped. Other agents: add the command `npx -y codecaine-cli mcp` as an MCP server.");
+  }
+  const editorUrl = (flag(args2, "--editor") ?? process.env.CODECAINE_EDITOR_URL ?? DEFAULT_EDITOR).replace(/\/+$/, "");
+  say(`
+Done. Open ${editorUrl} \u2014 it connects to this machine by itself.`);
+  if (!args2.includes("--no-open")) openBrowser(editorUrl);
+}
 var args = process.argv.slice(2);
-if (args[0] === "mcp") {
+if (args[0] === "setup") {
+  setup(args.slice(1)).catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  });
+} else if (args[0] === "mcp") {
   void mcpPipe();
 } else if (args[0] === "--version" || args[0] === "-v") {
   console.log(VERSION);