sakuraai 0.0.16 → 0.0.17

package/dist/index.js

@@ -24,16 +24,16 @@ function readTsnetState() {
 function ensureDir(dir) {
   fs.mkdirSync(dir, { recursive: true });
 }
-function readJson(file, fallback) {
+function readJson(file2, fallback) {
   try {
-    return { ...fallback, ...JSON.parse(fs.readFileSync(file, "utf8")) };
+    return { ...fallback, ...JSON.parse(fs.readFileSync(file2, "utf8")) };
   } catch {
     return fallback;
   }
 }
-function writeJson(file, value) {
-  ensureDir(path.dirname(file));
-  fs.writeFileSync(file, JSON.stringify(value, null, 2) + "\n", { mode: 384 });
+function writeJson(file2, value) {
+  ensureDir(path.dirname(file2));
+  fs.writeFileSync(file2, JSON.stringify(value, null, 2) + "\n", { mode: 384 });
 }
 function defaultConfig() {
   const hostname2 = os.hostname();
@@ -103,8 +103,8 @@ var init_config = __esm({
 function apiBase() {
   return (loadAuth().serverUrl || DEFAULT_API_URL).replace(/\/+$/, "");
 }
-async function postJson(base, path22, body, token) {
-  const res = await fetch(`${base}${path22}`, {
+async function postJson(base, path24, body, token) {
+  const res = await fetch(`${base}${path24}`, {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
@@ -114,7 +114,7 @@ async function postJson(base, path22, body, token) {
   });
   if (!res.ok) {
     const text = await res.text().catch(() => "");
-    throw new Error(`${path22} \u2192 ${res.status} ${res.statusText}${text ? `: ${text}` : ""}`);
+    throw new Error(`${path24} \u2192 ${res.status} ${res.statusText}${text ? `: ${text}` : ""}`);
   }
   return await res.json();
 }
@@ -345,11 +345,11 @@ function trimOutput(s) {
 function str(v) {
   return typeof v === "string" && v ? v : void 0;
 }
-function diffStrings(file, before, after) {
+function diffStrings(file2, before, after) {
   const a = before ? before.split("\n") : [];
   const b = after ? after.split("\n") : [];
   if (a.length * b.length > 25e4) {
-    return capDiff(file, [...a.map((l) => `-${l}`), ...b.map((l) => `+${l}`)]);
+    return capDiff(file2, [...a.map((l) => `-${l}`), ...b.map((l) => `+${l}`)]);
   }
   const dp = Array.from({ length: a.length + 1 }, () => new Array(b.length + 1).fill(0));
   for (let i2 = a.length - 1; i2 >= 0; i2--)
@@ -368,22 +368,22 @@ function diffStrings(file, before, after) {
   }
   while (i < a.length) lines2.push(`-${a[i++]}`);
   while (j < b.length) lines2.push(`+${b[j++]}`);
-  return capDiff(file, lines2);
+  return capDiff(file2, lines2);
 }
-function diffFromHunks(file, hunks) {
+function diffFromHunks(file2, hunks) {
   const lines2 = [];
   for (const h of hunks) {
     if (lines2.length) lines2.push(`@@ ${h?.newStart ?? ""}`);
     for (const l of Array.isArray(h?.lines) ? h.lines : []) lines2.push(String(l));
   }
-  return capDiff(file, lines2);
+  return capDiff(file2, lines2);
 }
-function capDiff(file, lines2) {
+function capDiff(file2, lines2) {
   const added = lines2.filter((l) => l.startsWith("+")).length;
   const removed = lines2.filter((l) => l.startsWith("-")).length;
   const truncated = lines2.length > DIFF_LINE_LIMIT;
   return {
-    file: shortPath(file),
+    file: shortPath(file2),
     added,
     removed,
     lines: truncated ? lines2.slice(0, DIFF_LINE_LIMIT) : lines2,
@@ -393,7 +393,7 @@ function capDiff(file, lines2) {
 function toolPart(id, rawName, input2) {
   const name = canonicalTool(rawName);
   const inp = typeof input2 === "string" ? safeJson(input2) ?? { command: input2 } : input2 ?? {};
-  const file = str(inp.file_path) ?? str(inp.filePath) ?? str(inp.path) ?? str(inp.file);
+  const file2 = str(inp.file_path) ?? str(inp.filePath) ?? str(inp.path) ?? str(inp.file);
   let title;
   let diff;
   let todos;
@@ -402,19 +402,19 @@ function toolPart(id, rawName, input2) {
       title = str(inp.description) ?? str(inp.command) ?? str(inp.cmd) ?? (Array.isArray(inp.command) ? inp.command.join(" ") : "Run command");
       break;
     case "Edit":
-      title = file ? shortPath(file) : "Edit file";
-      if (file && (inp.old_string != null || inp.oldString != null))
-        diff = diffStrings(file, inp.old_string ?? inp.oldString ?? "", inp.new_string ?? inp.newString ?? "");
-      else if (file && Array.isArray(inp.edits))
-        diff = diffStrings(file, inp.edits.map((e) => e.old_string ?? "").join("\n"), inp.edits.map((e) => e.new_string ?? "").join("\n"));
+      title = file2 ? shortPath(file2) : "Edit file";
+      if (file2 && (inp.old_string != null || inp.oldString != null))
+        diff = diffStrings(file2, inp.old_string ?? inp.oldString ?? "", inp.new_string ?? inp.newString ?? "");
+      else if (file2 && Array.isArray(inp.edits))
+        diff = diffStrings(file2, inp.edits.map((e) => e.old_string ?? "").join("\n"), inp.edits.map((e) => e.new_string ?? "").join("\n"));
       break;
     case "Write":
-      title = file ? shortPath(file) : "Write file";
-      if (file && typeof inp.content === "string") diff = diffStrings(file, "", inp.content);
+      title = file2 ? shortPath(file2) : "Write file";
+      if (file2 && typeof inp.content === "string") diff = diffStrings(file2, "", inp.content);
       break;
     case "Read":
     case "List":
-      title = file ? shortPath(file) : name === "List" ? "List files" : "Read file";
+      title = file2 ? shortPath(file2) : name === "List" ? "List files" : "Read file";
       break;
     case "Grep":
     case "Glob":
@@ -437,7 +437,7 @@ function toolPart(id, rawName, input2) {
       break;
     }
     default:
-      title = file ? shortPath(file) : str(inp.description) ?? str(inp.command) ?? str(inp.query) ?? "";
+      title = file2 ? shortPath(file2) : str(inp.description) ?? str(inp.command) ?? str(inp.query) ?? "";
   }
   return {
     type: "tool",
@@ -581,10 +581,10 @@ var init_util = __esm({
 import fs3 from "fs";
 import path3 from "path";
 import { spawn as spawn2 } from "child_process";
-function* jsonlEntries(file) {
+function* jsonlEntries(file2) {
   let content;
   try {
-    content = fs3.readFileSync(file, "utf8");
+    content = fs3.readFileSync(file2, "utf8");
   } catch {
     return;
   }
@@ -596,9 +596,9 @@ function* jsonlEntries(file) {
     }
   }
 }
-function sessionTitle(file) {
+function sessionTitle(file2) {
   for (let pass = 0; pass < 2; pass++) {
-    for (const entry of jsonlEntries(file)) {
+    for (const entry of jsonlEntries(file2)) {
       if (entry?.type !== "user") continue;
       if (pass === 0 && entry?.userType !== "external") continue;
       const title = extractTextFromContent(entry?.message?.content);
@@ -607,9 +607,9 @@ function sessionTitle(file) {
   }
   return "Untitled";
 }
-function headCwd(file) {
+function headCwd(file2) {
   try {
-    const fd = fs3.openSync(file, "r");
+    const fd = fs3.openSync(file2, "r");
     const buf = Buffer.alloc(64 * 1024);
     const n = fs3.readSync(fd, buf, 0, buf.length, 0);
     fs3.closeSync(fd);
@@ -680,12 +680,12 @@ function resultText(content) {
   if (!Array.isArray(content)) return "";
   return content.filter((b) => b?.type === "text" && typeof b.text === "string").map((b) => b.text).join("\n");
 }
-function readMessages(file, sessionId = path3.basename(file, ".jsonl")) {
+function readMessages(file2, sessionId = path3.basename(file2, ".jsonl")) {
   const msgs = [];
   const tools = /* @__PURE__ */ new Map();
   let current = null;
   let lastUserSecs = null;
-  for (const entry of jsonlEntries(file)) {
+  for (const entry of jsonlEntries(file2)) {
     if (entry?.isSidechain === true) continue;
     const tsStr = entry?.timestamp ?? "";
     const tsSecs = parseIsoUnix(tsStr);
@@ -759,9 +759,9 @@ function readMessages(file, sessionId = path3.basename(file, ".jsonl")) {
   return msgs;
 }
 function imageBlock(sessionId, uuid, idx) {
-  const file = findFile(sessionId);
-  if (!file) return null;
-  for (const entry of jsonlEntries(file)) {
+  const file2 = findFile(sessionId);
+  if (!file2) return null;
+  for (const entry of jsonlEntries(file2)) {
     if (entry?.uuid !== uuid) continue;
     const b = entry?.message?.content?.[idx];
     if (b?.type !== "image" || b?.source?.type !== "base64") return null;
@@ -770,13 +770,13 @@ function imageBlock(sessionId, uuid, idx) {
   return null;
 }
 function messages(sessionId) {
-  const file = findFile(sessionId);
-  return file ? readMessages(file, sessionId) : [];
+  const file2 = findFile(sessionId);
+  return file2 ? readMessages(file2, sessionId) : [];
 }
 function sessionCwd(sessionId) {
-  const file = findFile(sessionId);
-  if (!file) return void 0;
-  for (const entry of jsonlEntries(file)) {
+  const file2 = findFile(sessionId);
+  if (!file2) return void 0;
+  for (const entry of jsonlEntries(file2)) {
     if (typeof entry?.cwd === "string" && entry.cwd) return entry.cwd;
   }
   return void 0;
@@ -784,7 +784,7 @@ function sessionCwd(sessionId) {
 function prepareNew(sessionId, cwd) {
   pendingNew.set(sessionId, cwd);
 }
-function send(sessionId, message, onData, images, model, run5 = {}) {
+function send(sessionId, message, onData, images, model, run6 = {}) {
   return new Promise((resolve) => {
     const bin = process.env.CLAUDE_BIN || "claude";
     const newCwd = pendingNew.get(sessionId);
@@ -799,9 +799,9 @@ ${refs}` : refs;
     }
     const modelArgs = model ? ["--model", model] : [];
     const runArgs = [
-      ...run5.effort ? ["--effort", run5.effort] : [],
-      ...run5.mode ? ["--permission-mode", run5.mode] : [],
-      ...run5.fast ? ["--settings", JSON.stringify({ fastMode: true })] : []
+      ...run6.effort ? ["--effort", run6.effort] : [],
+      ...run6.mode ? ["--permission-mode", run6.mode] : [],
+      ...run6.fast ? ["--settings", JSON.stringify({ fastMode: true })] : []
     ];
     const child2 = spawn2(
       bin,
@@ -981,10 +981,10 @@ function execInput(name, input2) {
   }
   return { name, input: input2 };
 }
-function readMessages2(file) {
+function readMessages2(file2) {
   let content;
   try {
-    content = fs4.readFileSync(file, "utf8");
+    content = fs4.readFileSync(file2, "utf8");
   } catch {
     return [];
   }
@@ -1067,14 +1067,16 @@ function readMessages2(file) {
   return msgs;
 }
 function messages2(sessionId) {
-  const file = findFile2(sessionId);
-  return file ? readMessages2(file) : [];
+  const file2 = findFile2(sessionId);
+  return file2 ? readMessages2(file2) : [];
 }
-function send2(sessionId, message, onData, images, model) {
+function send2(sessionId, message, onData, images, model, cwd) {
   return new Promise((resolve) => {
     const imageArgs = (images ?? []).flatMap((p) => ["-i", p]);
     const modelArgs = model ? ["--model", model] : [];
-    const child2 = spawn3(codexBin(), ["exec", ...modelArgs, "resume", sessionId, ...imageArgs, message], {
+    const target2 = sessionId ? ["resume", sessionId] : ["--skip-git-repo-check"];
+    const child2 = spawn3(codexBin(), ["exec", ...modelArgs, ...target2, ...imageArgs, message], {
+      cwd,
       stdio: ["ignore", "pipe", "pipe"],
       env: process.env
     });
@@ -1322,11 +1324,13 @@ async function image(sessionId, partId) {
     db.close();
   }
 }
-function send3(sessionId, message, onData, images, model) {
+function send3(sessionId, message, onData, images, model, cwd) {
   return new Promise((resolve) => {
     const fileArgs = (images ?? []).flatMap((p) => ["-f", p]);
     const modelArgs = model ? ["-m", model] : [];
-    const child2 = spawn4(opencodeBin(), ["run", "-s", sessionId, ...modelArgs, ...fileArgs, message], {
+    const sessionArgs = sessionId ? ["-s", sessionId] : [];
+    const child2 = spawn4(opencodeBin(), ["run", ...sessionArgs, ...modelArgs, ...fileArgs, message], {
+      cwd,
       stdio: ["ignore", "pipe", "pipe"],
       env: process.env
     });
@@ -1338,14 +1342,18 @@ function send3(sessionId, message, onData, images, model) {
     });
     child2.stderr.on("data", (d) => err += d.toString());
     child2.on("error", (e) => resolve({ ok: false, output: "", error: e.message }));
-    child2.on(
-      "close",
-      (code) => resolve({
-        ok: code === 0,
-        output: out.trim(),
-        error: code === 0 ? void 0 : err.trim() || `exited ${code}`
-      })
-    );
+    child2.on("close", (code) => {
+      const strip = (t) => t.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "");
+      const plain = strip(out);
+      const printed = /^Error:\s*(.+)$/m.exec(`${plain}
+${strip(err)}`)?.[1]?.trim();
+      const ok2 = code === 0 && !printed;
+      resolve({
+        ok: ok2,
+        output: plain.trim(),
+        error: ok2 ? void 0 : printed || err.trim() || `exited ${code}`
+      });
+    });
   });
 }
 var DB_PATH, MAC_APP_BIN2, _ctor;
@@ -1481,10 +1489,10 @@ async function image2(sessionId, partId) {
     db.close();
   }
 }
-function send4(sessionId, message, onData, images, _model) {
+function send4(sessionId, message, onData, images, _model, cwd) {
   return new Promise(async (resolve) => {
-    const args = ["--resume", sessionId];
-    const dir = await sessionDir(sessionId).catch(() => null);
+    const args = sessionId ? ["--resume", sessionId] : [];
+    const dir = cwd ?? await sessionDir(sessionId).catch(() => null);
     if (dir && fs7.existsSync(dir)) args.push("--cwd", dir);
     for (const p of images ?? []) args.push("--attach", p);
     args.push("--output-format", "stream-json", "--prompt", message);
@@ -1565,16 +1573,16 @@ function available3() {
 function zstdSupported() {
   return typeof zlib.zstdDecompressSync === "function";
 }
-function decompress(file) {
+function decompress(file2) {
   if (!zstdSupported()) return null;
   try {
-    return zlib.zstdDecompressSync(fs8.readFileSync(file)).toString("utf8");
+    return zlib.zstdDecompressSync(fs8.readFileSync(file2)).toString("utf8");
   } catch {
     return null;
   }
 }
-function parseSessionFile(file) {
-  const raw = decompress(file);
+function parseSessionFile(file2) {
+  const raw = decompress(file2);
   if (!raw) return null;
   const events = [];
   let header = null;
@@ -1608,16 +1616,16 @@ function allSessionFiles() {
     }
     for (const e of entries) {
       if (!e.startsWith("session-")) continue;
-      const file = path7.join(dir, e, "session.v4.jsonl.zstd");
+      const file2 = path7.join(dir, e, "session.v4.jsonl.zstd");
       let stat;
       try {
-        stat = fs8.statSync(file);
+        stat = fs8.statSync(file2);
       } catch {
         continue;
       }
-      const parsed = parseSessionFile(file);
+      const parsed = parseSessionFile(file2);
       if (!parsed) continue;
-      out.push({ file, header: parsed.header, events: parsed.events, stat });
+      out.push({ file: file2, header: parsed.header, events: parsed.events, stat });
     }
   }
   out.sort((a, b) => b.stat.mtimeMs - a.stat.mtimeMs);
@@ -1673,15 +1681,15 @@ function findFile3(sessionId) {
     return null;
   }
   for (const bucket of buckets) {
-    const file = path7.join(SESSIONS_DIR2, bucket, sessionId, "session.v4.jsonl.zstd");
-    if (fs8.existsSync(file)) return file;
+    const file2 = path7.join(SESSIONS_DIR2, bucket, sessionId, "session.v4.jsonl.zstd");
+    if (fs8.existsSync(file2)) return file2;
   }
   return null;
 }
 async function messages5(sessionId) {
-  const file = findFile3(sessionId);
-  if (!file) return [];
-  const parsed = parseSessionFile(file);
+  const file2 = findFile3(sessionId);
+  if (!file2) return [];
+  const parsed = parseSessionFile(file2);
   if (!parsed) return [];
   const createdAtMs = parsed.header.createdAt ?? Date.now();
   const out = [];
@@ -1706,14 +1714,14 @@ async function messages5(sessionId) {
   }
   return out;
 }
-function send5(sessionId, message, onData, images, _model) {
+function send5(sessionId, message, onData, images, _model, dir) {
   return new Promise((resolve) => {
-    const file = findFile3(sessionId);
-    let cwd;
-    if (file) {
-      const parsed = parseSessionFile(file);
-      const dir = parsed?.header?.cwd;
-      if (dir && fs8.existsSync(dir)) cwd = dir;
+    const file2 = sessionId ? findFile3(sessionId) : null;
+    let cwd = dir;
+    if (file2) {
+      const parsed = parseSessionFile(file2);
+      const dir2 = parsed?.header?.cwd;
+      if (dir2 && fs8.existsSync(dir2)) cwd = dir2;
     }
     let prompt = message;
     if (images?.length) {
@@ -1722,7 +1730,8 @@ function send5(sessionId, message, onData, images, _model) {
 
 ${refs}` : refs;
     }
-    const child2 = spawn6(dshBin(), ["headless", "--json", "--session-id", sessionId, "-"], {
+    const sessionArgs = sessionId ? ["--session-id", sessionId] : [];
+    const child2 = spawn6(dshBin(), ["headless", "--json", ...sessionArgs, "-"], {
       cwd,
       stdio: ["pipe", "pipe", "pipe"],
       env: process.env
@@ -1782,45 +1791,565 @@ var init_deepseek = __esm({
   }
 });
 
-// src/runtime/meta.ts
+// src/runtime/acp.ts
 import fs9 from "fs";
+import os5 from "os";
 import path8 from "path";
-function read() {
+import { createHash, randomUUID as randomUUID2 } from "crypto";
+import { execFile, spawn as spawn7 } from "child_process";
+import { promisify } from "util";
+async function registry(force = false) {
+  if (!force && registryMem && Date.now() - registryMem.at < REGISTRY_TTL_MS) return registryMem.agents;
+  try {
+    const src = process.env.SAKURA_ACP_REGISTRY || REGISTRY_URL;
+    let body;
+    if (/^https?:/.test(src)) {
+      const res = await fetch(src, { signal: AbortSignal.timeout(15e3) });
+      if (!res.ok) throw new Error(`registry ${res.status}`);
+      body = await res.json();
+    } else {
+      body = JSON.parse(fs9.readFileSync(src, "utf8"));
+    }
+    const agents = (body.agents ?? []).filter((a) => a?.id && a?.name && a?.distribution);
+    fs9.mkdirSync(ACP_DIR, { recursive: true });
+    fs9.writeFileSync(REGISTRY_CACHE, JSON.stringify(agents));
+    registryMem = { at: Date.now(), agents };
+    return agents;
+  } catch {
+    if (registryMem) return registryMem.agents;
+    try {
+      const agents = JSON.parse(fs9.readFileSync(REGISTRY_CACHE, "utf8"));
+      registryMem = { at: Date.now() - REGISTRY_TTL_MS + 6e4, agents };
+      return agents;
+    } catch {
+      return [];
+    }
+  }
+}
+async function findAgent(id) {
+  return (await registry()).find((a) => a.id === id) ?? null;
+}
+function method(a) {
+  if (a.distribution.binary?.[PLATFORM]) return "binary";
+  if (a.distribution.npx?.package && onPath("npx")) return "npx";
+  if (a.distribution.uvx?.package && onPath("uvx")) return "uvx";
+  return null;
+}
+function installed(a) {
+  const m = method(a);
+  if (m !== "binary") return m != null;
+  const t = a.distribution.binary[PLATFORM];
+  return fs9.existsSync(path8.join(binDir(a), t.cmd));
+}
+async function catalog() {
+  const enabled = new Set(loadConfig().acpAgents ?? []);
+  return (await registry()).map((a) => ({
+    id: a.id,
+    name: a.name,
+    version: a.version,
+    description: a.description,
+    website: a.website ?? a.repository,
+    icon: a.icon,
+    via: method(a),
+    installed: installed(a),
+    enabled: enabled.has(a.id)
+  }));
+}
+function install(a) {
+  if (method(a) !== "binary" || installed(a)) return Promise.resolve();
+  const t = a.distribution.binary[PLATFORM];
+  const existing = installing.get(a.id);
+  if (existing) return existing;
+  const job = (async () => {
+    const dir = binDir(a);
+    const stage = `${dir}.${randomUUID2().slice(0, 8)}`;
+    fs9.mkdirSync(stage, { recursive: true });
+    try {
+      const file2 = path8.join(stage, path8.basename(new URL(t.archive).pathname));
+      await run("curl", ["-fsSL", "--retry", "2", "-o", file2, t.archive], { timeout: 6e5 });
+      if (t.sha256) {
+        const sum = createHash("sha256").update(fs9.readFileSync(file2)).digest("hex");
+        if (sum !== t.sha256.toLowerCase()) throw new Error(`checksum mismatch for ${a.name}`);
+      }
+      if (/\.zip$/i.test(file2)) await run("unzip", ["-q", "-o", file2, "-d", stage], { timeout: 12e4 });
+      else if (/\.tar\.(gz|bz2|xz)$|\.tgz$/i.test(file2)) await run("tar", ["xf", file2, "-C", stage], { timeout: 12e4 });
+      else fs9.copyFileSync(file2, path8.join(stage, t.cmd));
+      fs9.rmSync(file2, { force: true });
+      const bin = path8.join(stage, t.cmd);
+      if (!fs9.existsSync(bin)) throw new Error(`${a.name}'s archive has no ${t.cmd}`);
+      fs9.chmodSync(bin, 493);
+      fs9.rmSync(dir, { recursive: true, force: true });
+      fs9.mkdirSync(path8.dirname(dir), { recursive: true });
+      fs9.renameSync(stage, dir);
+    } finally {
+      fs9.rmSync(stage, { recursive: true, force: true });
+    }
+  })().finally(() => installing.delete(a.id));
+  installing.set(a.id, job);
+  return job;
+}
+async function setEnabled(id, on) {
+  const a = await findAgent(id);
+  if (!a) throw new Error(`${id} is not in the ACP registry`);
+  if (on) {
+    if (!method(a)) throw new Error(`${a.name} can't run on this Mac (it needs ${a.distribution.npx ? "npx" : a.distribution.uvx ? "uvx" : `a ${PLATFORM} build`}).`);
+    await install(a);
+  }
+  updateConfig((c) => {
+    const set = new Set(c.acpAgents ?? []);
+    if (on) set.add(id);
+    else set.delete(id);
+    c.acpAgents = [...set];
+  });
+  return (await catalog()).find((x) => x.id === id);
+}
+function launchCommand(a) {
+  const m = method(a);
+  if (m === "binary") {
+    const t = a.distribution.binary[PLATFORM];
+    return { cmd: path8.join(binDir(a), t.cmd), args: t.args ?? [], env: t.env ?? {} };
+  }
+  if (m === "npx") {
+    const d = a.distribution.npx;
+    return { cmd: "npx", args: ["-y", d.package, ...d.args ?? []], env: d.env ?? {} };
+  }
+  if (m === "uvx") {
+    const d = a.distribution.uvx;
+    return { cmd: "uvx", args: [d.package, ...d.args ?? []], env: d.env ?? {} };
+  }
+  throw new Error(`${a.name} can't run on this Mac.`);
+}
+function read(id) {
+  try {
+    return JSON.parse(fs9.readFileSync(file(id), "utf8"));
+  } catch {
+    return null;
+  }
+}
+function write2(s) {
+  fs9.mkdirSync(SESSIONS_DIR3, { recursive: true });
+  const tmp = `${file(s.id)}.${process.pid}.tmp`;
+  fs9.writeFileSync(tmp, JSON.stringify(s));
+  fs9.renameSync(tmp, file(s.id));
+}
+async function prepareNew2(sessionId, cwd, acpId) {
+  const a = await findAgent(acpId);
+  if (!a) throw new Error(`${acpId} is not in the ACP registry`);
+  const now = Date.now();
+  write2({ id: sessionId, acp: acpId, name: a.name, cwd, title: "", createdAt: now, updatedAt: now, messages: [] });
+}
+function listSessions6() {
+  let names = [];
+  try {
+    names = fs9.readdirSync(SESSIONS_DIR3).filter((f) => f.endsWith(".json"));
+  } catch {
+    return [];
+  }
+  const host = hostname();
+  const now = nowSecs();
+  const out = [];
+  for (const n of names) {
+    const s = read(n.slice(0, -5));
+    if (!s) continue;
+    const mtime = Math.floor(s.updatedAt / 1e3);
+    const age = Math.max(0, now - mtime);
+    out.push({
+      id: s.id,
+      title: s.title || "New chat",
+      agent: "acp",
+      status: statusFromAge(age),
+      updatedAt: formatAge(age),
+      machine: host,
+      mtime,
+      cwd: s.cwd,
+      acp: { id: s.acp, name: s.name }
+    });
+  }
+  return out;
+}
+function messages6(id) {
+  return read(id)?.messages ?? [];
+}
+function cachedModels() {
   try {
-    return JSON.parse(fs9.readFileSync(META_PATH, "utf8"));
+    return JSON.parse(fs9.readFileSync(MODELS_CACHE, "utf8"));
   } catch {
     return {};
   }
 }
-function write2(store) {
-  fs9.mkdirSync(path8.dirname(META_PATH), { recursive: true });
-  fs9.writeFileSync(META_PATH, JSON.stringify(store, null, 2) + "\n", { mode: 384 });
+function models(acpId) {
+  return [{ id: "", label: "Default" }, ...cachedModels()[acpId] ?? []];
+}
+function rememberModels(acpId, list4) {
+  const all2 = cachedModels();
+  all2[acpId] = list4.map((m) => ({ id: m.modelId, label: m.name || m.modelId, desc: m.description ?? void 0 }));
+  try {
+    fs9.mkdirSync(ACP_DIR, { recursive: true });
+    fs9.writeFileSync(MODELS_CACHE, JSON.stringify(all2));
+  } catch {
+  }
+}
+function blockText(c) {
+  if (!c) return "";
+  if (c.type === "text") return c.text ?? "";
+  if (c.type === "content") return blockText(c.content);
+  if (c.type === "diff") return `${c.path ?? ""}`;
+  if (c.type === "resource_link") return c.uri ?? "";
+  if (c.type === "resource") return c.resource?.text ?? "";
+  return "";
+}
+function primer(prior) {
+  const lines2 = prior.map((m) => `${m.role === "user" ? "User" : "Assistant"}: ${m.content}`.trim());
+  let text = lines2.join("\n\n");
+  if (text.length > 6e4) text = `\u2026${text.slice(-6e4)}`;
+  return `This conversation is continuing in a new session. Here is everything so far:
+
+<conversation>
+${text}
+</conversation>
+
+`;
+}
+async function send6(sessionId, message, onData, images, model, runOpts = {}) {
+  const s = read(sessionId);
+  if (!s) return { ok: false, output: "", error: "chat not found" };
+  const a = await findAgent(s.acp);
+  if (!a) return { ok: false, output: "", error: `${s.name} is no longer in the ACP registry` };
+  try {
+    await install(a);
+  } catch (e) {
+    return { ok: false, output: "", error: `Couldn't install ${a.name}: ${e.message}` };
+  }
+  const prior = s.messages.slice();
+  const now = () => (/* @__PURE__ */ new Date()).toISOString();
+  s.messages.push({ id: randomUUID2(), role: "user", content: message, timestamp: now() });
+  if (!s.title) s.title = message.length > 60 ? `${message.slice(0, 57)}\u2026` : message;
+  const reply = { id: randomUUID2(), role: "assistant", content: "", timestamp: now(), parts: [], model: model || void 0 };
+  s.messages.push(reply);
+  const started = Date.now();
+  const save = () => {
+    reply.content = reply.parts.filter((p) => p.type === "text").map((p) => p.text).join("");
+    reply.hasToolUse = reply.parts.some((p) => p.type === "tool");
+    reply.elapsedSecs = Math.round((Date.now() - started) / 1e3);
+    s.updatedAt = Date.now();
+    write2(s);
+  };
+  save();
+  const appendText = (text) => {
+    if (!text) return;
+    const last = reply.parts[reply.parts.length - 1];
+    if (last?.type === "text") last.text += text;
+    else reply.parts.push({ type: "text", text });
+    onData?.(text);
+  };
+  const tools = /* @__PURE__ */ new Map();
+  const toolUpdate = (u) => {
+    const id = String(u.toolCallId ?? randomUUID2());
+    let t = tools.get(id);
+    if (!t) {
+      t = { type: "tool", id, name: TOOL_NAMES[u.kind] ?? "Tool", title: u.title ?? "Tool call", status: "running" };
+      tools.set(id, t);
+      reply.parts.push(t);
+    }
+    if (u.title) t.title = u.title;
+    if (u.kind) t.name = TOOL_NAMES[u.kind] ?? t.name;
+    if (u.status === "completed") t.status = "done";
+    else if (u.status === "failed") t.status = "error";
+    const out = (u.content ?? []).map(blockText).filter(Boolean).join("\n");
+    if (out) t.output = out.length > 4e3 ? `${out.slice(0, 4e3)}\u2026` : out;
+    if (u.rawInput?.command && t.name === "Bash") t.title = String(u.rawInput.command);
+  };
+  let loading = false;
+  let lastSave = 0;
+  const onNotify = (method2, params) => {
+    if (method2 !== "session/update" || loading) return;
+    const u = params?.update ?? {};
+    switch (u.sessionUpdate) {
+      case "agent_message_chunk":
+        appendText(blockText(u.content));
+        break;
+      case "tool_call":
+      case "tool_call_update":
+        toolUpdate(u);
+        break;
+      case "plan":
+        reply.parts.push({
+          type: "tool",
+          id: `plan-${Date.now()}`,
+          name: "Todos",
+          title: "Plan",
+          status: "done",
+          todos: (u.entries ?? []).map((e) => ({ content: e.content, status: e.status }))
+        });
+        break;
+      default:
+        return;
+    }
+    if (Date.now() - lastSave > 250) {
+      lastSave = Date.now();
+      save();
+    }
+  };
+  const onRequest = async (method2, params) => {
+    if (method2 === "session/request_permission") {
+      const opts = params?.options ?? [];
+      const readOnly = ["read", "search", "think", "fetch"].includes(params?.toolCall?.kind);
+      const allow = runOpts.mode !== "plan" || readOnly;
+      const pick2 = allow ? opts.find((o) => o.kind === "allow_once") ?? opts.find((o) => o.kind.startsWith("allow")) : opts.find((o) => o.kind === "reject_once") ?? opts.find((o) => o.kind.startsWith("reject"));
+      return pick2 ? { outcome: { outcome: "selected", optionId: pick2.optionId } } : { outcome: { outcome: "cancelled" } };
+    }
+    const err = new Error(`Sakura doesn't handle ${method2}`);
+    err.code = -32601;
+    throw err;
+  };
+  const { cmd, args, env } = launchCommand(a);
+  let child2;
+  try {
+    child2 = spawn7(cmd, args, { cwd: fs9.existsSync(s.cwd) ? s.cwd : os5.homedir(), stdio: ["pipe", "pipe", "pipe"], env: { ...process.env, ...env } });
+  } catch (e) {
+    return finish(false, e.message);
+  }
+  const rpc = new Rpc(child2, onNotify, onRequest);
+  function finish(ok2, error) {
+    if (!ok2 && error && !reply.parts.length) reply.parts.push({ type: "text", text: `\u26A0\uFE0F ${error}` });
+    save();
+    return { ok: ok2, output: reply.content, error: ok2 ? void 0 : error };
+  }
+  try {
+    const init = await rpc.call("initialize", {
+      protocolVersion: 1,
+      clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false },
+      clientInfo: { name: "sakura", version: "1" }
+    }, 3e5);
+    const caps = init?.agentCapabilities ?? {};
+    const mcpServers = [];
+    let remote = s.remoteId;
+    let resumed = false;
+    if (remote && caps.loadSession) {
+      loading = true;
+      try {
+        await rpc.call("session/load", { sessionId: remote, cwd: s.cwd, mcpServers }, 12e4);
+        resumed = true;
+      } catch {
+        remote = void 0;
+      } finally {
+        loading = false;
+      }
+    }
+    if (!resumed) {
+      let created;
+      try {
+        created = await rpc.call("session/new", { cwd: s.cwd, mcpServers }, 12e4);
+      } catch (e) {
+        const methods = init?.authMethods ?? [];
+        if (e.code !== -32e3 || !methods.length) throw e;
+        await rpc.call("authenticate", { methodId: methods[0].id }, 18e4).catch(() => {
+          throw new Error(`${a.name} needs you to sign in on your Mac first (${methods.map((m) => m.name ?? m.id).join(", ")}).`);
+        });
+        created = await rpc.call("session/new", { cwd: s.cwd, mcpServers }, 12e4);
+      }
+      remote = created?.sessionId;
+      s.remoteId = remote;
+      const avail = created?.models?.availableModels;
+      if (Array.isArray(avail) && avail.length) rememberModels(a.id, avail);
+    }
+    if (!remote) throw new Error(`${a.name} didn't open a session`);
+    if (model) await rpc.call("session/set_model", { sessionId: remote, modelId: model }, 3e4).catch(() => {
+    });
+    const prompt = [];
+    const text = !resumed && prior.length ? `${primer(prior)}${message}` : message;
+    prompt.push({ type: "text", text });
+    for (const p of images ?? []) {
+      const mediaType = /\.png$/i.test(p) ? "image/png" : /\.gif$/i.test(p) ? "image/gif" : /\.webp$/i.test(p) ? "image/webp" : "image/jpeg";
+      if (caps.promptCapabilities?.image) prompt.push({ type: "image", mimeType: mediaType, data: fs9.readFileSync(p).toString("base64") });
+      else prompt[0] = { type: "text", text: `${text}
+
+[Image: ${p}]` };
+    }
+    const result = await rpc.call("session/prompt", { sessionId: remote, prompt });
+    const stop2 = result?.stopReason;
+    for (const t of tools.values()) if (t.status === "running") t.status = "done";
+    if (stop2 === "refusal") return finish(false, `${a.name} declined this request.`);
+    return finish(true);
+  } catch (e) {
+    const msg = e.message || rpc.lastError() || "the agent failed";
+    return finish(false, msg);
+  } finally {
+    child2.stdin?.end();
+    child2.kill("SIGTERM");
+    setTimeout(() => {
+      if (child2.exitCode == null) child2.kill("SIGKILL");
+    }, 3e3).unref();
+  }
+}
+var run, REGISTRY_URL, ACP_DIR, SESSIONS_DIR3, BIN_DIR, REGISTRY_CACHE, MODELS_CACHE, REGISTRY_TTL_MS, registryMem, PLATFORM, onPath, binDir, installing, file, has, Rpc, TOOL_NAMES;
+var init_acp = __esm({
+  "src/runtime/acp.ts"() {
+    "use strict";
+    init_config();
+    init_util();
+    run = promisify(execFile);
+    REGISTRY_URL = "https://cdn.agentclientprotocol.com/registry/v1/latest/registry.json";
+    ACP_DIR = path8.join(SAKURA_DIR, "acp");
+    SESSIONS_DIR3 = path8.join(ACP_DIR, "sessions");
+    BIN_DIR = path8.join(ACP_DIR, "bin");
+    REGISTRY_CACHE = path8.join(ACP_DIR, "registry.json");
+    MODELS_CACHE = path8.join(ACP_DIR, "models.json");
+    REGISTRY_TTL_MS = 6 * 36e5;
+    registryMem = null;
+    PLATFORM = `${{ darwin: "darwin", linux: "linux", win32: "windows" }[process.platform] ?? process.platform}-${{ arm64: "aarch64", x64: "x86_64" }[process.arch] ?? process.arch}`;
+    onPath = (bin) => (process.env.PATH ?? "").split(path8.delimiter).some((d) => d && fs9.existsSync(path8.join(d, bin)));
+    binDir = (a) => path8.join(BIN_DIR, a.id, a.version);
+    installing = /* @__PURE__ */ new Map();
+    file = (id) => path8.join(SESSIONS_DIR3, `${id}.json`);
+    has = (id) => fs9.existsSync(file(id));
+    Rpc = class {
+      constructor(child2, onNotify, onRequest) {
+        this.child = child2;
+        this.onNotify = onNotify;
+        this.onRequest = onRequest;
+        child2.stdout.on("data", (d) => this.feed(d.toString()));
+        child2.stderr.on("data", (d) => {
+          this.stderr = (this.stderr + d.toString()).slice(-4e3);
+        });
+        this.exited = new Promise((resolve) => child2.on("close", (code) => {
+          for (const p of this.pending.values()) p.reject(new Error(this.lastError() || `agent exited (${code})`));
+          this.pending.clear();
+          resolve(code);
+        }));
+        child2.on("error", (e) => {
+          for (const p of this.pending.values()) p.reject(e);
+          this.pending.clear();
+        });
+      }
+      child;
+      onNotify;
+      onRequest;
+      next = 1;
+      pending = /* @__PURE__ */ new Map();
+      buf = "";
+      stderr = "";
+      exited;
+      lastError() {
+        return this.stderr.trim().split("\n").filter(Boolean).pop() ?? "";
+      }
+      send(msg) {
+        this.child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", ...msg })}
+`);
+      }
+      call(method2, params, timeoutMs = 0) {
+        const id = this.next++;
+        return new Promise((resolve, reject) => {
+          const timer = timeoutMs ? setTimeout(() => {
+            this.pending.delete(id);
+            reject(new Error(`${method2} timed out`));
+          }, timeoutMs) : null;
+          this.pending.set(id, {
+            resolve: (v) => {
+              if (timer) clearTimeout(timer);
+              resolve(v);
+            },
+            reject: (e) => {
+              if (timer) clearTimeout(timer);
+              reject(e);
+            }
+          });
+          this.send({ id, method: method2, params });
+        });
+      }
+      feed(chunk) {
+        this.buf += chunk;
+        let nl;
+        while ((nl = this.buf.indexOf("\n")) >= 0) {
+          const line = this.buf.slice(0, nl).trim();
+          this.buf = this.buf.slice(nl + 1);
+          if (!line) continue;
+          let msg;
+          try {
+            msg = JSON.parse(line);
+          } catch {
+            continue;
+          }
+          if (msg.id != null && msg.method) {
+            this.onRequest(msg.method, msg.params).then(
+              (result) => this.send({ id: msg.id, result }),
+              (e) => this.send({ id: msg.id, error: { code: e.code ?? -32603, message: e.message } })
+            );
+          } else if (msg.id != null) {
+            const p = this.pending.get(msg.id);
+            if (!p) continue;
+            this.pending.delete(msg.id);
+            if (msg.error) {
+              const err = new Error(msg.error.message || "agent error");
+              err.code = msg.error.code;
+              err.data = msg.error.data;
+              p.reject(err);
+            } else {
+              p.resolve(msg.result);
+            }
+          } else if (msg.method) {
+            this.onNotify(msg.method, msg.params);
+          }
+        }
+      }
+    };
+    TOOL_NAMES = {
+      read: "Read",
+      edit: "Edit",
+      delete: "Edit",
+      move: "Edit",
+      search: "Grep",
+      execute: "Bash",
+      think: "Think",
+      fetch: "Fetch",
+      switch_mode: "Mode",
+      other: "Tool"
+    };
+  }
+});
+
+// src/runtime/meta.ts
+import fs10 from "fs";
+import path9 from "path";
+function read2() {
+  try {
+    return JSON.parse(fs10.readFileSync(META_PATH, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function write3(store) {
+  fs10.mkdirSync(path9.dirname(META_PATH), { recursive: true });
+  fs10.writeFileSync(META_PATH, JSON.stringify(store, null, 2) + "\n", { mode: 384 });
 }
 function all() {
-  return read();
+  return read2();
 }
 function setTitle(sessionId, title) {
-  const store = read();
+  const store = read2();
   store[sessionId] = { ...store[sessionId], title };
-  write2(store);
+  write3(store);
 }
 function setArchived(sessionId, archived) {
-  const store = read();
+  const store = read2();
   store[sessionId] = { ...store[sessionId], archived };
   if (!store[sessionId].title && !store[sessionId].archived) delete store[sessionId];
-  write2(store);
+  write3(store);
 }
 var META_PATH;
 var init_meta = __esm({
   "src/runtime/meta.ts"() {
     "use strict";
     init_config();
-    META_PATH = path8.join(SAKURA_DIR, "session-meta.json");
+    META_PATH = path9.join(SAKURA_DIR, "session-meta.json");
   }
 });
 
 // src/runtime/sessions.ts
-import { spawn as spawn7 } from "child_process";
+import { spawn as spawn8 } from "child_process";
+import fs11 from "fs";
+import os6 from "os";
+import path10 from "path";
 async function list(opts = {}) {
   let sessions = [];
   if (!opts.agent || opts.agent === "claude") sessions.push(...listSessions());
@@ -1831,6 +2360,7 @@ async function list(opts = {}) {
     sessions.push(...await listSessions4());
   if (!opts.agent || opts.agent === "deepseek")
     sessions.push(...await listSessions5());
+  if (!opts.agent || opts.agent === "acp") sessions.push(...listSessions6());
   sessions.sort((a, b) => b.mtime - a.mtime);
   if (sessions.some((s) => s.agent === "codex")) {
     const cwds = await threadCwds();
@@ -1861,6 +2391,7 @@ async function show(sessionId) {
 }
 async function detectAgent(sessionId) {
   if (findFile(sessionId)) return "claude";
+  if (has(sessionId)) return "acp";
   if (findFile2(sessionId)) return "codex";
   if (sessionId.startsWith("session-") && findFile3(sessionId)) return "deepseek";
   if (await hasSession(sessionId)) return "zcode";
@@ -1868,7 +2399,7 @@ async function detectAgent(sessionId) {
   if (oc.length) return "opencode";
   return null;
 }
-async function messages6(sessionId, agent) {
+async function messages7(sessionId, agent) {
   const a = agent ?? await detectAgent(sessionId);
   switch (a) {
     case "claude":
@@ -1881,31 +2412,70 @@ async function messages6(sessionId, agent) {
       return messages4(sessionId);
     case "deepseek":
       return messages5(sessionId);
+    case "acp":
+      return messages6(sessionId);
     default:
       return [];
   }
 }
 async function history(sessionId, opts = {}, agent) {
-  let msgs = await messages6(sessionId, agent);
+  let msgs = await messages7(sessionId, agent);
   if (!opts.all && opts.limit && opts.limit > 0) {
     msgs = msgs.slice(-opts.limit);
   }
   if (opts.reverse) msgs = [...msgs].reverse();
   return msgs;
 }
-async function chat(sessionId, prompt, agent, onData, images, model, run5) {
+async function chat(sessionId, prompt, agent, onData, images, model, run6) {
   const a = agent ?? await detectAgent(sessionId);
-  if (a === "claude") return send(sessionId, prompt, onData, images, model, run5);
+  if (a === "claude") return send(sessionId, prompt, onData, images, model, run6);
   if (a === "codex") return send2(sessionId, prompt, onData, images, model);
   if (a === "opencode") return send3(sessionId, prompt, onData, images, model);
   if (a === "zcode") return send4(sessionId, prompt, onData, images, model);
   if (a === "deepseek") return send5(sessionId, prompt, onData, images, model);
+  if (a === "acp") return send6(sessionId, prompt, onData, images, model, run6);
   return {
     ok: false,
     output: "",
     error: `Sending is not supported for this session (got ${a ?? "unknown"}).`
   };
 }
+function chatNew(agent, cwd, prompt, onData, model) {
+  if (agent === "codex") return send2("", prompt, onData, void 0, model, cwd);
+  if (agent === "opencode") return send3("", prompt, onData, void 0, model, cwd);
+  if (agent === "zcode") return send4("", prompt, onData, void 0, model, cwd);
+  if (agent === "deepseek") return send5("", prompt, onData, void 0, model, cwd);
+  return Promise.resolve({ ok: false, output: "", error: `Can't start a ${agent} session this way.` });
+}
+async function awaitNewSession(agent, cwd, before, done, timeoutMs = 6e4) {
+  let finished = false;
+  void done.finally(() => {
+    finished = true;
+  });
+  const deadline = Date.now() + timeoutMs;
+  for (; ; ) {
+    const fresh = (await list({ agent, all: true })).filter((s) => !before.has(s.id));
+    const pick2 = fresh.find((s) => s.cwd === cwd) ?? fresh[0];
+    if (pick2) return pick2.id;
+    if (finished || Date.now() > deadline) return null;
+    await new Promise((r) => setTimeout(r, 400));
+  }
+}
+function runnableAgents() {
+  const bins = {
+    claude: () => onPath2(process.env.CLAUDE_BIN || "claude") || fs11.existsSync(path10.join(os6.homedir(), ".local", "bin", "claude")),
+    codex: () => onPath2(codexBin()),
+    opencode: () => onPath2(opencodeBin()),
+    zcode: () => {
+      const { cmd, args } = launchArgs([]);
+      return cmd === process.execPath ? fs11.existsSync(args[0] ?? "") : onPath2(cmd);
+    },
+    deepseek: () => onPath2(dshBin()),
+    acp: () => false
+    // registry agents are listed on their own (acp.enabledAgents)
+  };
+  return Object.keys(bins).filter((a) => bins[a]());
+}
 function create(prompt, opts = {}) {
   const agent = opts.agent ?? "claude";
   if (agent === "claude") return runCreate(process.env.CLAUDE_BIN || "claude", ["-p", prompt], opts.cwd);
@@ -1923,7 +2493,7 @@ function create(prompt, opts = {}) {
 }
 function runCreate(cmd, args, cwd, env = process.env) {
   return new Promise((resolve) => {
-    const child2 = spawn7(cmd, args, {
+    const child2 = spawn8(cmd, args, {
       cwd: cwd || process.cwd(),
       stdio: ["ignore", "pipe", "pipe"],
       env
@@ -1943,6 +2513,7 @@ function runCreate(cmd, args, cwd, env = process.env) {
     );
   });
 }
+var onPath2;
 var init_sessions = __esm({
   "src/runtime/sessions.ts"() {
     "use strict";
@@ -1951,7 +2522,70 @@ var init_sessions = __esm({
     init_opencode();
     init_zcode();
     init_deepseek();
+    init_acp();
     init_meta();
+    onPath2 = (bin) => path10.isAbsolute(bin) ? fs11.existsSync(bin) : (process.env.PATH ?? "").split(path10.delimiter).some((d) => d && fs11.existsSync(path10.join(d, bin)));
+  }
+});
+
+// src/runtime/handoff.ts
+function render(m, who) {
+  const body = [];
+  for (const p of m.parts ?? [{ type: "text", text: m.content }]) {
+    if (p.type === "text" && p.text.trim()) body.push(p.text.trim());
+    else if (p.type === "tool") body.push(`- ${p.name}: ${p.title}${p.status === "error" ? " (failed)" : ""}`);
+  }
+  return body.length ? `**${m.role === "user" ? "User" : who}:**
+${body.join("\n")}` : "";
+}
+async function handoffTitle(from) {
+  const first = (await list({ all: true })).find((x) => x.id === from[0]?.id);
+  const more = from.length > 1 ? ` +${from.length - 1}` : "";
+  return `Continued: ${first?.title ?? "conversation"}${more}`.slice(0, 80);
+}
+async function handoffPrompt(from, ask) {
+  const all2 = await list({ all: true });
+  const blocks = [];
+  for (const src of from) {
+    const s = all2.find((x) => x.id === src.id && x.agent === src.agent);
+    const who = s?.acp?.name ?? LABEL[src.agent];
+    const msgs = await messages7(src.id, src.agent);
+    let text = msgs.map((m) => render(m, who)).filter(Boolean).join("\n\n");
+    if (text.length > PER_CHAT) text = `[earlier part cut]
+${text.slice(-PER_CHAT)}`;
+    blocks.push(`## ${s?.title ?? "Conversation"} (with ${who})
+
+${text || "(empty)"}`);
+  }
+  let context = blocks.join("\n\n---\n\n");
+  if (context.length > TOTAL) context = `[earlier part cut]
+${context.slice(-TOTAL)}`;
+  const n = from.length;
+  return [
+    `<sakura-handoff count="${n}">`,
+    `You're picking up ${n === 1 ? "a conversation" : `${n} conversations`} the user had with another coding agent in this project. Treat it as your own history: the files it changed are already changed.`,
+    "",
+    context,
+    "</sakura-handoff>",
+    "",
+    ask?.trim() || "Pick up where this left off: say in a few lines where things stand, then carry on with what was in progress."
+  ].join("\n");
+}
+var LABEL, PER_CHAT, TOTAL;
+var init_handoff = __esm({
+  "src/runtime/handoff.ts"() {
+    "use strict";
+    init_sessions();
+    LABEL = {
+      claude: "Claude Code",
+      codex: "Codex",
+      opencode: "OpenCode",
+      zcode: "ZCode",
+      deepseek: "DeepSeek",
+      acp: "ACP agent"
+    };
+    PER_CHAT = 3e4;
+    TOTAL = 9e4;
   }
 });
 
@@ -1965,12 +2599,12 @@ function addPushToken(token) {
 async function sendPush(title, body, data = {}) {
   const tokens = loadConfig().pushTokens ?? [];
   if (tokens.length === 0) return;
-  const messages7 = tokens.map((to) => ({ to, title, body, sound: "default", data }));
+  const messages8 = tokens.map((to) => ({ to, title, body, sound: "default", data }));
   try {
     const res = await fetch(EXPO_PUSH_URL, {
       method: "POST",
       headers: { "Content-Type": "application/json", Accept: "application/json" },
-      body: JSON.stringify(messages7)
+      body: JSON.stringify(messages8)
     });
     if (!res.ok) console.error(`[push] send failed: HTTP ${res.status}`);
   } catch (e) {
@@ -2044,10 +2678,10 @@ __export(registry_exports, {
   thisMachine: () => thisMachine,
   updateAgentConfig: () => updateAgentConfig
 });
-import os5 from "os";
-import fs10 from "fs";
-import path9 from "path";
-import { randomUUID as randomUUID2 } from "crypto";
+import os7 from "os";
+import fs12 from "fs";
+import path11 from "path";
+import { randomUUID as randomUUID3 } from "crypto";
 function listWorkspaces() {
   return loadConfig().workspaces;
 }
@@ -2060,24 +2694,24 @@ function detectCli() {
     zcode: process.env.ZCODE_BIN || "zcode",
     deepseek: process.env.DSH_BIN || "dsh"
   };
-  const pathDirs = (process.env.PATH || "").split(path9.delimiter);
+  const pathDirs = (process.env.PATH || "").split(path11.delimiter);
   for (const [name, bin] of Object.entries(candidates)) {
-    const onPath = pathDirs.some((dir) => {
+    const onPath3 = pathDirs.some((dir) => {
       try {
-        return fs10.existsSync(path9.join(dir, bin));
+        return fs12.existsSync(path11.join(dir, bin));
       } catch {
         return false;
       }
     });
-    const home = os5.homedir();
+    const home = os7.homedir();
     const dataDirs = {
-      claude: path9.join(home, ".claude"),
-      codex: path9.join(home, ".codex"),
-      opencode: path9.join(home, ".local", "share", "opencode"),
-      zcode: path9.join(home, ".zcode"),
-      deepseek: path9.join(home, ".dsh")
+      claude: path11.join(home, ".claude"),
+      codex: path11.join(home, ".codex"),
+      opencode: path11.join(home, ".local", "share", "opencode"),
+      zcode: path11.join(home, ".zcode"),
+      deepseek: path11.join(home, ".dsh")
     };
-    if (onPath || fs10.existsSync(dataDirs[name] ?? "")) found.push(name);
+    if (onPath3 || fs12.existsSync(dataDirs[name] ?? "")) found.push(name);
   }
   return found;
 }
@@ -2087,8 +2721,8 @@ function thisMachine() {
     id: cfg.machineId,
     name: cfg.machineName,
     online: true,
-    os: `${os5.type()} ${os5.release()}`,
-    hostname: os5.hostname(),
+    os: `${os7.type()} ${os7.release()}`,
+    hostname: os7.hostname(),
     cli: detectCli()
   };
 }
@@ -2101,15 +2735,15 @@ function listProjects() {
   return loadConfig().projects;
 }
 function addProject(dir, name) {
-  const abs = path9.resolve(dir);
-  if (!fs10.existsSync(abs) || !fs10.statSync(abs).isDirectory()) {
+  const abs = path11.resolve(dir);
+  if (!fs12.existsSync(abs) || !fs12.statSync(abs).isDirectory()) {
     throw new Error(`Not a directory: ${abs}`);
   }
   const existing = loadConfig().projects.find((p) => p.path === abs);
   if (existing) return existing;
   const project = {
-    id: randomUUID2(),
-    name: name || path9.basename(abs),
+    id: randomUUID3(),
+    name: name || path11.basename(abs),
     path: abs,
     addedAt: Date.now()
   };
@@ -2123,7 +2757,7 @@ function deleteProject(idOrNameOrPath) {
   updateConfig((cfg) => {
     const before = cfg.projects.length;
     cfg.projects = cfg.projects.filter(
-      (p) => p.id !== idOrNameOrPath && p.name !== idOrNameOrPath && p.path !== path9.resolve(idOrNameOrPath)
+      (p) => p.id !== idOrNameOrPath && p.name !== idOrNameOrPath && p.path !== path11.resolve(idOrNameOrPath)
     );
     removed = cfg.projects.length !== before;
   });
@@ -2131,7 +2765,7 @@ function deleteProject(idOrNameOrPath) {
 }
 function resolveProject(idOrNameOrPath) {
   const cfg = loadConfig();
-  const abs = path9.resolve(idOrNameOrPath);
+  const abs = path11.resolve(idOrNameOrPath);
   return cfg.projects.find(
     (p) => p.id === idOrNameOrPath || p.name === idOrNameOrPath || p.path === abs
   ) ?? null;
@@ -2154,7 +2788,7 @@ function resolveAgentConfig(idOrName) {
 function createAgentConfig(input2) {
   const now = Date.now();
   const config = {
-    id: randomUUID2(),
+    id: randomUUID3(),
     name: input2.name,
     agentType: input2.agentType,
     description: input2.description,
@@ -2225,14 +2859,14 @@ var init_registry = __esm({
 });
 
 // src/runtime/projects.ts
-import fs11 from "fs";
-import path10 from "path";
-import { createHash, randomUUID as randomUUID3 } from "crypto";
-import { execFile } from "child_process";
-import { promisify } from "util";
+import fs13 from "fs";
+import path12 from "path";
+import { createHash as createHash2, randomUUID as randomUUID4 } from "crypto";
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
 async function git(cwd, args) {
   try {
-    const { stdout } = await run("git", args, {
+    const { stdout } = await run2("git", args, {
       cwd,
       timeout: 5e3,
       maxBuffer: 4 * 1024 * 1024,
@@ -2247,11 +2881,11 @@ async function git(cwd, args) {
 async function projectRoot(cwd) {
   if (rootCache.has(cwd)) return rootCache.get(cwd);
   let root = null;
-  if (fs11.existsSync(cwd)) {
+  if (fs13.existsSync(cwd)) {
     const out = await git(cwd, ["rev-parse", "--path-format=absolute", "--git-common-dir", "--show-toplevel"]);
     if (out) {
       const [common, top] = out.trim().split("\n");
-      root = common && path10.basename(common) === ".git" ? path10.dirname(common) : top || cwd;
+      root = common && path12.basename(common) === ".git" ? path12.dirname(common) : top || cwd;
     } else {
       root = cwd;
     }
@@ -2262,9 +2896,9 @@ async function projectRoot(cwd) {
 function isScratch(p) {
   if (p === HOME || p === "/") return true;
   if (/^\/(private\/)?(tmp|var\/folders)(\/|$)/.test(p)) return true;
-  const rel = path10.relative(HOME, p);
+  const rel = path12.relative(HOME, p);
   if (rel.startsWith("..")) return false;
-  return rel.split(path10.sep).some((seg) => seg.startsWith(".")) || /(^|\/)default-workspace$/.test(rel);
+  return rel.split(path12.sep).some((seg) => seg.startsWith(".")) || /(^|\/)default-workspace$/.test(rel);
 }
 function githubSlug(url) {
   const m = /github\.com[:/]([^/]+\/[^/]+?)(\.git)?$/.exec(url.trim());
@@ -2303,19 +2937,29 @@ async function list2() {
       const last = ss.length ? Math.max(...ss.map((s) => s.mtime)) : null;
       return {
         id: projectId(p),
-        name: registered.get(p)?.name ?? path10.basename(p),
+        name: registered.get(p)?.name ?? path12.basename(p),
         path: p,
         registered: registered.has(p),
         sessions: ss.length,
         agents: [...new Set(ss.map((s) => s.agent))],
         lastActive: last,
         updatedAt: last != null ? formatAge(Math.max(0, now - last)) : null,
-        git: fs11.existsSync(p) ? await gitSummary(p) : null
+        git: fs13.existsSync(p) ? await gitSummary(p) : null
       };
     })
   );
   return out.sort((a, b) => (b.lastActive ?? 0) - (a.lastActive ?? 0) || a.name.localeCompare(b.name));
 }
+async function tagSessions(list4) {
+  const cfg = loadConfig();
+  const hidden = new Set(cfg.hiddenProjects ?? []);
+  const names = new Map(cfg.projects.map((p) => [p.path, p.name]));
+  return Promise.all(list4.map(async (s) => {
+    const root = s.cwd ? await projectRoot(s.cwd) : null;
+    if (!root || hidden.has(root) || isScratch(root)) return s;
+    return { ...s, project: { id: projectId(root), name: names.get(root) ?? path12.basename(root) } };
+  }));
+}
 async function find(id) {
   return (await list2()).find((p) => p.id === id) ?? null;
 }
@@ -2334,16 +2978,16 @@ async function detail(id) {
   ]);
   const counts = /* @__PURE__ */ new Map();
   for (const line of (numstat ?? "").split("\n")) {
-    const [a, d, file] = line.split("	");
-    if (file) counts.set(file.replace(/^.*\{.* => (.*)\}.*$/, "$1"), [Number(a) || 0, Number(d) || 0]);
+    const [a, d, file2] = line.split("	");
+    if (file2) counts.set(file2.replace(/^.*\{.* => (.*)\}.*$/, "$1"), [Number(a) || 0, Number(d) || 0]);
   }
   const changes = [];
   for (const line of (status2 ?? "").split("\n")) {
     if (line.length < 4) continue;
     const code = line[0] !== " " ? line[0] : line[1];
-    const file = line.slice(3).split(" -> ").pop().replace(/^"|"$/g, "");
-    const [additions, deletions] = counts.get(file) ?? [0, 0];
-    changes.push({ path: file, status: STATUS[code] ?? "modified", additions, deletions });
+    const file2 = line.slice(3).split(" -> ").pop().replace(/^"|"$/g, "");
+    const [additions, deletions] = counts.get(file2) ?? [0, 0];
+    changes.push({ path: file2, status: STATUS[code] ?? "modified", additions, deletions });
   }
   const commits = (log2 ?? "").split("\n").filter(Boolean).map((l) => {
     const [hash, subject, author, ct] = l.split("");
@@ -2353,7 +2997,7 @@ async function detail(id) {
   return { ...p, changes, commits, branches, sessionList };
 }
 function add(dir) {
-  const abs = path10.resolve(dir.replace(/^~(?=$|\/)/, HOME));
+  const abs = path12.resolve(dir.replace(/^~(?=$|\/)/, HOME));
   addProject(abs);
   updateConfig((c) => {
     c.hiddenProjects = (c.hiddenProjects ?? []).filter((h) => h !== abs);
@@ -2370,47 +3014,60 @@ async function remove(id) {
   return true;
 }
 function browse(dir) {
-  const abs = path10.resolve((dir || HOME).replace(/^~(?=$|\/)/, HOME));
-  if (path10.relative(HOME, abs).startsWith("..")) throw new Error("Only folders inside your home folder can be added.");
+  const abs = path12.resolve((dir || HOME).replace(/^~(?=$|\/)/, HOME));
+  if (path12.relative(HOME, abs).startsWith("..")) throw new Error("Only folders inside your home folder can be added.");
   const entries = [];
-  for (const d of fs11.readdirSync(abs, { withFileTypes: true })) {
+  for (const d of fs13.readdirSync(abs, { withFileTypes: true })) {
     if (!d.isDirectory() || d.name.startsWith(".") || d.name === "node_modules") continue;
-    const p = path10.join(abs, d.name);
-    entries.push({ name: d.name, path: p, isGit: fs11.existsSync(path10.join(p, ".git")) });
+    const p = path12.join(abs, d.name);
+    entries.push({ name: d.name, path: p, isGit: fs13.existsSync(path12.join(p, ".git")) });
   }
   entries.sort((a, b) => Number(b.isGit) - Number(a.isGit) || a.name.localeCompare(b.name));
-  return { path: abs, parent: abs === HOME ? null : path10.dirname(abs), entries: entries.slice(0, 400) };
+  return { path: abs, parent: abs === HOME ? null : path12.dirname(abs), entries: entries.slice(0, 400) };
 }
-async function prepareSession(id, agent, worktree) {
+async function prepareSession(id, agent, worktree, acpId) {
   const p = await find(id);
   if (!p) throw new Error("project not found");
-  if (agent !== "claude") throw new Error("Starting chats from a project currently supports Claude Code.");
-  const sessionId = randomUUID3();
+  const sessionId = randomUUID4();
   let cwd = p.path;
   let branch;
   if (worktree) {
     if (!p.git) throw new Error("Worktrees need a git repository.");
     const short = sessionId.slice(0, 8);
     branch = `sakura/${short}`;
-    cwd = path10.join(WORKTREES_DIR, `${p.name}-${short}`);
-    fs11.mkdirSync(WORKTREES_DIR, { recursive: true });
+    cwd = path12.join(WORKTREES_DIR, `${p.name}-${short}`);
+    fs13.mkdirSync(WORKTREES_DIR, { recursive: true });
     if (await git(p.path, ["worktree", "add", "-b", branch, cwd]) == null) {
       throw new Error("Could not create a git worktree for this chat.");
     }
   }
-  prepareNew(sessionId, cwd);
+  await prepareFor(agent, sessionId, cwd, acpId);
   return { sessionId, cwd, branch };
 }
+async function prepareScratch(agent, acpId) {
+  const sessionId = randomUUID4();
+  const cwd = path12.join(SAKURA_DIR, "chats", sessionId.slice(0, 8));
+  fs13.mkdirSync(cwd, { recursive: true });
+  await prepareFor(agent, sessionId, cwd, acpId);
+  return { sessionId, cwd };
+}
+async function prepareFor(agent, sessionId, cwd, acpId) {
+  if (agent === "claude") prepareNew(sessionId, cwd);
+  if (agent === "acp") {
+    if (!acpId) throw new Error("Pick which ACP agent to use.");
+    await prepareNew2(sessionId, cwd, acpId);
+  }
+}
 async function chatContext(sessionId, agent) {
   const s = (await list({})).find((x) => x.id === sessionId && x.agent === agent);
   const cwd = s?.cwd ?? pendingCwd(sessionId) ?? null;
   const machine = loadConfig().machineName || hostname();
-  if (!cwd || !fs11.existsSync(cwd)) return { cwd, project: null, git: null, machine };
+  if (!cwd || !fs13.existsSync(cwd)) return { cwd, project: null, git: null, machine };
   const root = await projectRoot(cwd);
-  const project = root && !isScratch(root) ? { id: projectId(root), name: path10.basename(root), path: root } : null;
+  const project = root && !isScratch(root) ? { id: projectId(root), name: path12.basename(root), path: root } : null;
   return { cwd, project, git: await gitSummary(cwd), machine };
 }
-var run, WORKTREES_DIR, projectId, rootCache, STATUS;
+var run2, WORKTREES_DIR, projectId, rootCache, STATUS;
 var init_projects = __esm({
   "src/runtime/projects.ts"() {
     "use strict";
@@ -2418,34 +3075,35 @@ var init_projects = __esm({
     init_registry();
     init_sessions();
     init_claude();
+    init_acp();
     init_util();
-    run = promisify(execFile);
-    WORKTREES_DIR = path10.join(HOME, ".sakura", "worktrees");
-    projectId = (p) => createHash("sha1").update(p).digest("hex").slice(0, 12);
+    run2 = promisify2(execFile2);
+    WORKTREES_DIR = path12.join(HOME, ".sakura", "worktrees");
+    projectId = (p) => createHash2("sha1").update(p).digest("hex").slice(0, 12);
     rootCache = /* @__PURE__ */ new Map();
     STATUS = { M: "modified", A: "added", D: "deleted", R: "renamed", "?": "untracked" };
   }
 });
 
 // src/runtime/fsops.ts
-import fs12 from "fs";
-import path11 from "path";
-import os6 from "os";
+import fs14 from "fs";
+import path13 from "path";
+import os8 from "os";
 function expand(p) {
   if (!p || p === "~") return HOME2;
-  if (p.startsWith("~/")) return path11.join(HOME2, p.slice(2));
-  return path11.resolve(p);
+  if (p.startsWith("~/")) return path13.join(HOME2, p.slice(2));
+  return path13.resolve(p);
 }
 function list3(dir) {
   const abs = expand(dir);
-  const dirents = fs12.readdirSync(abs, { withFileTypes: true });
+  const dirents = fs14.readdirSync(abs, { withFileTypes: true });
   const entries = [];
   for (const d of dirents) {
-    const p = path11.join(abs, d.name);
+    const p = path13.join(abs, d.name);
     let size = 0;
     let mtime = 0;
     try {
-      const st = fs12.statSync(p);
+      const st = fs14.statSync(p);
       size = st.size;
       mtime = Math.floor(st.mtimeMs / 1e3);
     } catch {
@@ -2458,7 +3116,7 @@ function list3(dir) {
     if (a.type !== "dir" && b.type === "dir") return 1;
     return a.name.localeCompare(b.name);
   });
-  const parent = abs === "/" ? null : path11.dirname(abs);
+  const parent = abs === "/" ? null : path13.dirname(abs);
   return { path: abs, parent, entries };
 }
 function looksBinary(buf) {
@@ -2466,14 +3124,14 @@ function looksBinary(buf) {
   for (let i = 0; i < n; i++) if (buf[i] === 0) return true;
   return false;
 }
-function read2(file) {
-  const abs = expand(file);
-  const st = fs12.statSync(abs);
-  const fd = fs12.openSync(abs, "r");
+function read3(file2) {
+  const abs = expand(file2);
+  const st = fs14.statSync(abs);
+  const fd = fs14.openSync(abs, "r");
   try {
     const len = Math.min(st.size, READ_CAP);
     const buf = Buffer.alloc(len);
-    fs12.readSync(fd, buf, 0, len, 0);
+    fs14.readSync(fd, buf, 0, len, 0);
     const binary = looksBinary(buf);
     return {
       path: abs,
@@ -2483,40 +3141,40 @@ function read2(file) {
       content: binary ? "" : buf.toString("utf8")
     };
   } finally {
-    fs12.closeSync(fd);
+    fs14.closeSync(fd);
   }
 }
-function write3(file, content) {
-  const abs = expand(file);
-  fs12.mkdirSync(path11.dirname(abs), { recursive: true });
-  fs12.writeFileSync(abs, content, "utf8");
+function write4(file2, content) {
+  const abs = expand(file2);
+  fs14.mkdirSync(path13.dirname(abs), { recursive: true });
+  fs14.writeFileSync(abs, content, "utf8");
   return { path: abs, bytes: Buffer.byteLength(content, "utf8") };
 }
 function mkdir(dir) {
   const abs = expand(dir);
-  fs12.mkdirSync(abs, { recursive: true });
+  fs14.mkdirSync(abs, { recursive: true });
   return { path: abs };
 }
 var HOME2, READ_CAP;
 var init_fsops = __esm({
   "src/runtime/fsops.ts"() {
     "use strict";
-    HOME2 = os6.homedir();
+    HOME2 = os8.homedir();
     READ_CAP = 512 * 1024;
   }
 });
 
 // src/tailscale.ts
-import fs13 from "fs";
-import { spawn as spawn8 } from "child_process";
+import fs15 from "fs";
+import { spawn as spawn9 } from "child_process";
 function tsBin() {
   const macPath = "/Applications/Tailscale.app/Contents/MacOS/Tailscale";
-  if (fs13.existsSync(macPath)) return macPath;
+  if (fs15.existsSync(macPath)) return macPath;
   return process.env.TAILSCALE_BIN || "tailscale";
 }
 function runTs(args, timeoutMs = 6e4) {
   return new Promise((resolve) => {
-    const child2 = spawn8(tsBin(), args, { stdio: ["ignore", "pipe", "pipe"] });
+    const child2 = spawn9(tsBin(), args, { stdio: ["ignore", "pipe", "pipe"] });
     let out = "";
     let err = "";
     const timer = setTimeout(() => {
@@ -2607,7 +3265,7 @@ function serve(port2) {
 function serveOff() {
   return runTs(["serve", "--https=443", "off"]);
 }
-async function installed() {
+async function installed2() {
   const r = await runTs(["version"]);
   return { installed: r.code !== "not_installed", version: r.stdout, code: r.code };
 }
@@ -2626,8 +3284,8 @@ var init_tailscale = __esm({
 });
 
 // src/runtime/usage.ts
-import fs14 from "fs";
-import path12 from "path";
+import fs16 from "fs";
+import path14 from "path";
 import readline from "readline";
 function claudeCost(model, u) {
   const p = CLAUDE_PRICES.find((x) => x.match.test(model));
@@ -2645,28 +3303,28 @@ function add2(b, ms, agent, model, tokens, cost) {
   if (cost == null) cur.unpriced += tokens;
   else cur.cost += cost;
 }
-async function* lines(file) {
-  const rl = readline.createInterface({ input: fs14.createReadStream(file, "utf8"), crlfDelay: Infinity });
+async function* lines(file2) {
+  const rl = readline.createInterface({ input: fs16.createReadStream(file2, "utf8"), crlfDelay: Infinity });
   for await (const line of rl) yield line;
 }
 function walk(dir, out = []) {
   let entries;
   try {
-    entries = fs14.readdirSync(dir, { withFileTypes: true });
+    entries = fs16.readdirSync(dir, { withFileTypes: true });
   } catch {
     return out;
   }
   for (const e of entries) {
-    const p = path12.join(dir, e.name);
+    const p = path14.join(dir, e.name);
     if (e.isDirectory()) walk(p, out);
     else if (e.name.endsWith(".jsonl")) out.push(p);
   }
   return out;
 }
-async function scanClaude(file) {
+async function scanClaude(file2) {
   const b = {};
   const seen = /* @__PURE__ */ new Set();
-  for await (const line of lines(file)) {
+  for await (const line of lines(file2)) {
     if (!line.includes('"usage"')) continue;
     let e;
     try {
@@ -2693,12 +3351,12 @@ function limitWindow(w) {
     resetsAt: typeof w.resets_at === "number" ? w.resets_at : null
   };
 }
-async function scanCodex(file) {
+async function scanCodex(file2) {
   const b = {};
   const extra = { plans: {}, limits: null };
   let model = "codex";
   let prevTotal = 0;
-  for await (const line of lines(file)) {
+  for await (const line of lines(file2)) {
     const isCount = line.includes('"token_count"');
     if (!isCount && !line.includes('"model"')) continue;
     let e;
@@ -2734,7 +3392,7 @@ async function scanCodex(file) {
 }
 async function scanSqlite(agent, dbPath) {
   const b = {};
-  if (!fs14.existsSync(dbPath)) return b;
+  if (!fs16.existsSync(dbPath)) return b;
   let Ctor;
   try {
     const mod = await import("better-sqlite3");
@@ -2768,7 +3426,7 @@ async function scanSqlite(agent, dbPath) {
 }
 function loadCache() {
   try {
-    const raw = JSON.parse(fs14.readFileSync(CACHE_FILE, "utf8"));
+    const raw = JSON.parse(fs16.readFileSync(CACHE_FILE, "utf8"));
     return raw?.version === CACHE_VERSION ? raw.files ?? {} : {};
   } catch {
     return {};
@@ -2776,8 +3434,8 @@ function loadCache() {
 }
 function saveCache(files) {
   try {
-    fs14.mkdirSync(SAKURA_DIR, { recursive: true });
-    fs14.writeFileSync(CACHE_FILE, JSON.stringify({ version: CACHE_VERSION, files }));
+    fs16.mkdirSync(SAKURA_DIR, { recursive: true });
+    fs16.writeFileSync(CACHE_FILE, JSON.stringify({ version: CACHE_VERSION, files }));
   } catch {
   }
 }
@@ -2787,22 +3445,22 @@ async function scanAll() {
     const cache2 = loadCache();
     const next = {};
     const jobs = [
-      ...walk(path12.join(HOME, ".claude", "projects")).map((f) => [f, scanClaude]),
-      ...walk(path12.join(HOME, ".codex", "sessions")).map((f) => [f, scanCodex])
+      ...walk(path14.join(HOME, ".claude", "projects")).map((f) => [f, scanClaude]),
+      ...walk(path14.join(HOME, ".codex", "sessions")).map((f) => [f, scanCodex])
     ];
-    for (const [file, scan] of jobs) {
+    for (const [file2, scan] of jobs) {
       let st;
       try {
-        st = fs14.statSync(file);
+        st = fs16.statSync(file2);
       } catch {
         continue;
       }
-      const hit = cache2[file];
+      const hit = cache2[file2];
       if (hit && hit.mtimeMs === st.mtimeMs && hit.size === st.size) {
-        next[file] = hit;
+        next[file2] = hit;
       } else {
-        const r = await scan(file);
-        next[file] = { mtimeMs: st.mtimeMs, size: st.size, buckets: r.buckets, ...r.extra ? { codex: r.extra } : {} };
+        const r = await scan(file2);
+        next[file2] = { mtimeMs: st.mtimeMs, size: st.size, buckets: r.buckets, ...r.extra ? { codex: r.extra } : {} };
       }
     }
     saveCache(next);
@@ -2826,8 +3484,8 @@ async function scanAll() {
       const l = f.codex?.limits;
       if (l && (!codexLimits || l.ts > codexLimits.ts)) codexLimits = l;
     }
-    merge(await scanSqlite("opencode", path12.join(HOME, ".local", "share", "opencode", "opencode.db")));
-    merge(await scanSqlite("zcode", path12.join(HOME, ".zcode", "cli", "db", "db.sqlite")));
+    merge(await scanSqlite("opencode", path14.join(HOME, ".local", "share", "opencode", "opencode.db")));
+    merge(await scanSqlite("zcode", path14.join(HOME, ".zcode", "cli", "db", "db.sqlite")));
     return { buckets: merged, codexPlans, codexLimits };
   })().finally(() => {
     inflight = null;
@@ -3026,7 +3684,7 @@ var init_usage = __esm({
       { match: /haiku-5/, input: 0.1, output: 0.5, cacheRead: 0.01 },
       { match: /haiku/, input: 1, output: 5, cacheRead: 0.1 }
     ];
-    CACHE_FILE = path12.join(SAKURA_DIR, "usage-cache.json");
+    CACHE_FILE = path14.join(SAKURA_DIR, "usage-cache.json");
     CACHE_VERSION = 2;
     inflight = null;
     RANGE_MS = { "24h": 864e5, "7d": 7 * 864e5, "30d": 30 * 864e5, all: Infinity };
@@ -3051,21 +3709,21 @@ var init_usage = __esm({
 });
 
 // src/runtime/limits.ts
-import fs15 from "fs";
-import path13 from "path";
-import { execFile as execFile2 } from "child_process";
-import { promisify as promisify2 } from "util";
+import fs17 from "fs";
+import path15 from "path";
+import { execFile as execFile3 } from "child_process";
+import { promisify as promisify3 } from "util";
 async function claudeToken() {
   let raw = null;
   if (process.platform === "darwin") {
     try {
-      raw = (await run2("security", ["find-generic-password", "-s", "Claude Code-credentials", "-w"], { timeout: 3e3 })).stdout;
+      raw = (await run3("security", ["find-generic-password", "-s", "Claude Code-credentials", "-w"], { timeout: 3e3 })).stdout;
     } catch {
     }
   }
   if (!raw) {
     try {
-      raw = fs15.readFileSync(path13.join(HOME, ".claude", ".credentials.json"), "utf8");
+      raw = fs17.readFileSync(path15.join(HOME, ".claude", ".credentials.json"), "utf8");
     } catch {
       return null;
     }
@@ -3105,13 +3763,13 @@ async function planLimits(agent) {
   }
   return [];
 }
-var run2, CLAUDE_WINDOWS, cache;
+var run3, CLAUDE_WINDOWS, cache;
 var init_limits = __esm({
   "src/runtime/limits.ts"() {
     "use strict";
     init_util();
     init_usage();
-    run2 = promisify2(execFile2);
+    run3 = promisify3(execFile3);
     CLAUDE_WINDOWS = [
       ["seven_day", "Weekly"],
       ["five_hour", "5 hours"],
@@ -3123,12 +3781,12 @@ var init_limits = __esm({
 });
 
 // src/runtime/models.ts
-import fs16 from "fs";
-import path14 from "path";
+import fs18 from "fs";
+import path16 from "path";
 import { execFileSync } from "child_process";
 function configuredClaudeModel() {
   try {
-    const m = JSON.parse(fs16.readFileSync(path14.join(HOME, ".claude", "settings.json"), "utf8")).model;
+    const m = JSON.parse(fs18.readFileSync(path16.join(HOME, ".claude", "settings.json"), "utf8")).model;
     return typeof m === "string" && m ? m : void 0;
   } catch {
     return void 0;
@@ -3146,7 +3804,7 @@ async function claudeModels() {
     if (!res.ok) return claudeCache?.models ?? CLAUDE_ALIASES;
     const list4 = (await res.json())?.data ?? [];
     const seen = /* @__PURE__ */ new Set();
-    const models = list4.map((m) => {
+    const models2 = list4.map((m) => {
       const family = /claude-([a-z]+)/.exec(m.id)?.[1] ?? "";
       const desc = FAMILY_DESC[family]?.[seen.has(family) ? 1 : 0];
       seen.add(family);
@@ -3159,8 +3817,8 @@ async function claudeModels() {
       const i = Object.values(FAMILY_DESC).findIndex(([latest]) => latest === m.desc);
       return i < 0 ? 99 : i;
     };
-    models.sort((a, b) => rank(a) - rank(b));
-    const out = [{ id: "", label: "Default", desc: defLabel }, ...models];
+    models2.sort((a, b) => rank(a) - rank(b));
+    const out = [{ id: "", label: "Default", desc: defLabel }, ...models2];
     claudeCache = { at: Date.now(), models: out };
     return out;
   } catch {
@@ -3172,7 +3830,7 @@ function codexModels() {
   const seen = /* @__PURE__ */ new Set();
   let configured;
   try {
-    const cfg = fs16.readFileSync(path14.join(HOME, ".codex", "config.toml"), "utf8");
+    const cfg = fs18.readFileSync(path16.join(HOME, ".codex", "config.toml"), "utf8");
     configured = /^\s*model\s*=\s*"([^"]+)"/m.exec(cfg)?.[1];
     for (const m of cfg.matchAll(/model\s*=\s*"([^"]+)"/g)) {
       const id = m[1];
@@ -3196,7 +3854,7 @@ function opencodeModels() {
   const allowed = /* @__PURE__ */ new Set(["opencode"]);
   try {
     const auth = JSON.parse(
-      fs16.readFileSync(path14.join(HOME, ".local", "share", "opencode", "auth.json"), "utf8")
+      fs18.readFileSync(path16.join(HOME, ".local", "share", "opencode", "auth.json"), "utf8")
     );
     for (const k of Object.keys(auth)) allowed.add(k);
   } catch {
@@ -3271,12 +3929,12 @@ var init_models = __esm({
 });
 
 // src/runtime/mentions.ts
-import fs17 from "fs";
-import path15 from "path";
-function frontmatter(file) {
+import fs19 from "fs";
+import path17 from "path";
+function frontmatter(file2) {
   let text;
   try {
-    text = fs17.readFileSync(file, "utf8").slice(0, 4e3);
+    text = fs19.readFileSync(file2, "utf8").slice(0, 4e3);
   } catch {
     return {};
   }
@@ -3298,31 +3956,31 @@ function frontmatter(file) {
 function skillsIn(dir, source, prefix = "") {
   let names;
   try {
-    names = fs17.readdirSync(path15.join(dir, "skills"));
+    names = fs19.readdirSync(path17.join(dir, "skills"));
   } catch {
     return [];
   }
   return names.flatMap((n) => {
-    const file = path15.join(dir, "skills", n, "SKILL.md");
-    if (!fs17.existsSync(file)) return [];
-    const fm = frontmatter(file);
+    const file2 = path17.join(dir, "skills", n, "SKILL.md");
+    if (!fs19.existsSync(file2)) return [];
+    const fm = frontmatter(file2);
     return [{ name: `${prefix}${fm.name || n}`, description: fm.description ?? "", source }];
   });
 }
 function commandsIn(dir, source, prefix = "") {
-  const root = path15.join(dir, "commands");
+  const root = path17.join(dir, "commands");
   const out = [];
   const walk2 = (d, ns) => {
     let entries;
     try {
-      entries = fs17.readdirSync(d, { withFileTypes: true });
+      entries = fs19.readdirSync(d, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of entries) {
-      if (e.isDirectory()) walk2(path15.join(d, e.name), [...ns, e.name]);
+      if (e.isDirectory()) walk2(path17.join(d, e.name), [...ns, e.name]);
       else if (e.name.endsWith(".md")) {
-        const fm = frontmatter(path15.join(d, e.name));
+        const fm = frontmatter(path17.join(d, e.name));
         const name = [...ns, e.name.slice(0, -3)].join(":");
         out.push({ name: `${prefix}${name}`, description: fm.description ?? "", source });
       }
@@ -3333,19 +3991,19 @@ function commandsIn(dir, source, prefix = "") {
 }
 function plugins() {
   try {
-    const file = path15.join(HOME, ".claude", "plugins", "installed_plugins.json");
-    const all2 = JSON.parse(fs17.readFileSync(file, "utf8")).plugins ?? {};
+    const file2 = path17.join(HOME, ".claude", "plugins", "installed_plugins.json");
+    const all2 = JSON.parse(fs19.readFileSync(file2, "utf8")).plugins ?? {};
     return Object.entries(all2).flatMap(([key, installs]) => {
       const dir = installs?.[0]?.installPath;
-      return dir && fs17.existsSync(dir) ? [{ name: key.split("@")[0], dir }] : [];
+      return dir && fs19.existsSync(dir) ? [{ name: key.split("@")[0], dir }] : [];
     });
   } catch {
     return [];
   }
 }
 function mentions(cwd) {
-  const user = path15.join(HOME, ".claude");
-  const project = cwd ? path15.join(cwd, ".claude") : null;
+  const user = path17.join(HOME, ".claude");
+  const project = cwd ? path17.join(cwd, ".claude") : null;
   const plug = plugins();
   const skills = [
     ...project ? skillsIn(project, "project") : [],
@@ -3419,7 +4077,7 @@ var init_hub = __esm({
 function turnState(agent, sessionId) {
   return turns.get(sessionKey(agent, sessionId)) ?? null;
 }
-async function runTurn(sessionId, agent, prompt, images, model, run5) {
+async function runTurn(sessionId, agent, prompt, images, model, run6, launched) {
   const key = sessionKey(agent, sessionId);
   const turn = { status: "running", startedAt: Date.now() };
   turns.set(key, turn);
@@ -3444,7 +4102,7 @@ async function runTurn(sessionId, agent, prompt, images, model, run5) {
   emitLive("");
   const baseIds = /* @__PURE__ */ new Set();
   try {
-    for (const m of await messages6(sessionId, agent)) baseIds.add(m.id);
+    for (const m of await messages7(sessionId, agent)) baseIds.add(m.id);
   } catch {
   }
   let stdoutAcc = "";
@@ -3475,13 +4133,13 @@ async function runTurn(sessionId, agent, prompt, images, model, run5) {
     if (polling) return;
     polling = true;
     try {
-      pushFresh(await messages6(sessionId, agent));
+      pushFresh(await messages7(sessionId, agent));
     } catch {
     } finally {
       polling = false;
     }
   }, POLL_MS);
-  const result = await chat(sessionId, prompt, agent, onData, images, model, run5);
+  const result = await (launched ? launched(onData) : chat(sessionId, prompt, agent, onData, images, model, run6));
   clearInterval(timer);
   turn.status = result.ok ? "done" : "error";
   turn.finishedAt = Date.now();
@@ -3514,8 +4172,8 @@ var init_stream = __esm({
 });
 
 // src/runtime/presence.ts
-import fs18 from "fs";
-import path16 from "path";
+import fs20 from "fs";
+import path18 from "path";
 import { execFileSync as execFileSync2 } from "child_process";
 function alive(pid) {
   try {
@@ -3526,16 +4184,16 @@ function alive(pid) {
   }
 }
 function claudePresence(sessionId) {
-  const dir = path16.join(HOME, ".claude", "sessions");
+  const dir = path18.join(HOME, ".claude", "sessions");
   let files = [];
   try {
-    files = fs18.readdirSync(dir).filter((f) => f.endsWith(".json"));
+    files = fs20.readdirSync(dir).filter((f) => f.endsWith(".json"));
   } catch {
     return { open: false };
   }
   for (const f of files) {
     try {
-      const rec = JSON.parse(fs18.readFileSync(path16.join(dir, f), "utf8"));
+      const rec = JSON.parse(fs20.readFileSync(path18.join(dir, f), "utf8"));
       if (rec?.sessionId !== sessionId || typeof rec.pid !== "number") continue;
       if (rec.kind && rec.kind !== "interactive") continue;
       if (!alive(rec.pid)) continue;
@@ -3584,8 +4242,8 @@ var init_presence = __esm({
 });
 
 // src/daemon/terminal.ts
-import os7 from "os";
-import { spawn as spawn9 } from "child_process";
+import os9 from "os";
+import { spawn as spawn10 } from "child_process";
 function cleanOutput(t, chunk) {
   let s = t.buf + chunk;
   s = s.replace(OSC, "").replace(CSI, "").replace(ESC2, "");
@@ -3603,8 +4261,8 @@ function defaultShell() {
 }
 function openTerminal(ws, opts) {
   const shell = defaultShell();
-  const child2 = spawn9(shell, ["-i"], {
-    cwd: opts?.cwd && opts.cwd.trim() ? opts.cwd : os7.homedir(),
+  const child2 = spawn10(shell, ["-i"], {
+    cwd: opts?.cwd && opts.cwd.trim() ? opts.cwd : os9.homedir(),
     env: {
       ...process.env,
       TERM: "dumb",
@@ -3635,7 +4293,7 @@ function openTerminal(ws, opts) {
 [shell error: ${e.message}]
 `));
   try {
-    ws.send(JSON.stringify({ type: "ready", shell, cwd: opts?.cwd || os7.homedir() }));
+    ws.send(JSON.stringify({ type: "ready", shell, cwd: opts?.cwd || os9.homedir() }));
   } catch {
   }
 }
@@ -3670,43 +4328,78 @@ var init_terminal = __esm({
 });
 
 // src/daemon/sim.ts
-import fs19 from "fs";
-import os8 from "os";
-import path17 from "path";
-import { execFile as execFile3, spawn as spawn10 } from "child_process";
-import { promisify as promisify3 } from "util";
+import fs21 from "fs";
+import os10 from "os";
+import path19 from "path";
+import { execFile as execFile4, spawn as spawn11 } from "child_process";
+import { promisify as promisify4 } from "util";
 import { randomBytes as randomBytes2 } from "crypto";
 async function devices() {
-  const { stdout } = await run3("xcrun", ["simctl", "list", "devices", "available", "-j"], { timeout: 1e4 });
+  const { stdout } = await run4("xcrun", ["simctl", "list", "devices", "available", "-j"], { timeout: 1e4 });
   const out = [];
   for (const [runtime, list4] of Object.entries(JSON.parse(stdout).devices ?? {})) {
     const m = /SimRuntime\.(\w+)-([\d-]+)$/.exec(runtime);
     if (!m || m[1] !== "iOS") continue;
-    const os12 = `${m[1]} ${m[2].replace(/-/g, ".")}`;
-    for (const d of list4) out.push({ udid: d.udid, name: d.name, os: os12, booted: d.state === "Booted" });
+    const os14 = `${m[1]} ${m[2].replace(/-/g, ".")}`;
+    for (const d of list4) out.push({ udid: d.udid, name: d.name, os: os14, booted: d.state === "Booted" });
   }
   return out.sort((a, b) => Number(b.booted) - Number(a.booted) || b.os.localeCompare(a.os, void 0, { numeric: true }));
 }
 async function boot(udid) {
-  await run3("xcrun", ["simctl", "boot", udid], { timeout: 6e4 }).catch((e) => {
+  await run4("xcrun", ["simctl", "boot", udid], { timeout: 6e4 }).catch((e) => {
     if (!/current state: Booted/.test(String(e?.stderr))) throw e;
   });
-  spawn10("open", ["-g", "-a", "Simulator"], { stdio: "ignore", detached: true }).unref();
+  spawn11("open", ["-g", "-a", "Simulator"], { stdio: "ignore", detached: true }).unref();
+}
+function axePath() {
+  if (foundAxe) return foundAxe;
+  const dirs = [AXE_DIR, ...(process.env.PATH ?? "").split(":"), "/opt/homebrew/bin", "/usr/local/bin"];
+  foundAxe = dirs.map((d) => path19.join(d, "axe")).find((p) => fs21.existsSync(p)) ?? null;
+  return foundAxe;
+}
+function ensureAxe() {
+  const have = axePath();
+  if (have) return Promise.resolve(have);
+  installing2 ??= (async () => {
+    const stage = `${AXE_DIR}.${randomBytes2(4).toString("hex")}`;
+    fs21.mkdirSync(stage, { recursive: true });
+    try {
+      const tgz = path19.join(stage, "axe.tar.gz");
+      await run4("curl", ["-fsSL", "--retry", "2", "-o", tgz, AXE_URL], { timeout: 6e5 });
+      await run4("tar", ["xzf", tgz, "-C", stage], { timeout: 6e4 });
+      fs21.rmSync(tgz, { force: true });
+      const { stdout } = await run4("find", [stage, "-name", "axe", "-type", "f", "-perm", "-u+x"], { timeout: 1e4 });
+      const bin = stdout.split("\n").filter(Boolean).sort((a, b) => a.length - b.length)[0];
+      if (!bin) throw new Error("no axe binary in the download");
+      fs21.rmSync(AXE_DIR, { recursive: true, force: true });
+      fs21.renameSync(path19.dirname(bin), AXE_DIR);
+      return foundAxe = path19.join(AXE_DIR, "axe");
+    } finally {
+      fs21.rmSync(stage, { recursive: true, force: true });
+    }
+  })().finally(() => {
+    installing2 = null;
+  });
+  return installing2;
 }
 async function axe(args) {
-  const bin = axePath();
-  if (!bin) throw new Error("Touch needs AXe on your Mac: brew install cameroncooke/axe/axe");
-  await run3(bin, args, { timeout: 15e3 });
+  let bin;
+  try {
+    bin = await ensureAxe();
+  } catch (e) {
+    throw new Error(`Couldn\u2019t set up touch on your Mac (${e?.message ?? e}). Check its internet connection and try again.`);
+  }
+  await run4(bin, args, { timeout: 15e3 });
 }
 async function frame(udid, maxSide = 1e3) {
-  fs19.mkdirSync(TMP, { recursive: true });
-  const file = path17.join(TMP, `${randomBytes2(6).toString("hex")}.jpg`);
+  fs21.mkdirSync(TMP, { recursive: true });
+  const file2 = path19.join(TMP, `${randomBytes2(6).toString("hex")}.jpg`);
   try {
-    await run3("xcrun", ["simctl", "io", udid, "screenshot", "--type=jpeg", file], { timeout: 1e4 });
-    if (maxSide > 0) await run3("sips", ["-Z", String(maxSide), "-s", "formatOptions", "60", file], { timeout: 1e4 });
-    return fs19.readFileSync(file);
+    await run4("xcrun", ["simctl", "io", udid, "screenshot", "--type=jpeg", file2], { timeout: 1e4 });
+    if (maxSide > 0) await run4("sips", ["-Z", String(maxSide), "-s", "formatOptions", "60", file2], { timeout: 1e4 });
+    return fs21.readFileSync(file2);
   } finally {
-    fs19.rmSync(file, { force: true });
+    fs21.rmSync(file2, { force: true });
   }
 }
 function jpegSize(buf) {
@@ -3783,20 +4476,20 @@ async function input(udid, ev) {
     case "text":
       if (canTouch()) return axe(["type", ev.text, "--udid", udid]);
       await new Promise((resolve, reject) => {
-        const p = spawn10("xcrun", ["simctl", "pbcopy", udid]);
+        const p = spawn11("xcrun", ["simctl", "pbcopy", udid]);
         p.on("error", reject);
         p.on("exit", (c) => c === 0 ? resolve() : reject(new Error("pbcopy failed")));
         p.stdin.end(ev.text);
       });
       return;
     case "openurl":
-      await run3("xcrun", ["simctl", "openurl", udid, ev.url], { timeout: 15e3 });
+      await run4("xcrun", ["simctl", "openurl", udid, ev.url], { timeout: 15e3 });
       return;
     case "appearance":
-      await run3("xcrun", ["simctl", "ui", udid, "appearance", ev.mode], { timeout: 15e3 });
+      await run4("xcrun", ["simctl", "ui", udid, "appearance", ev.mode], { timeout: 15e3 });
       return;
     case "shake":
-      await run3("xcrun", ["simctl", "spawn", udid, "notifyutil", "-p", "com.apple.UIKit.SimulatorShake"], { timeout: 15e3 });
+      await run4("xcrun", ["simctl", "spawn", udid, "notifyutil", "-p", "com.apple.UIKit.SimulatorShake"], { timeout: 15e3 });
       return;
   }
 }
@@ -3851,7 +4544,11 @@ function viewer(udid, framed) {
 async function handle(req, res, route, url) {
   const udid = url.searchParams.get("udid") ?? "";
   try {
-    if (route === "/devices") return json(res, 200, { ok: true, devices: await devices(), touch: canTouch() });
+    if (route === "/devices") {
+      ensureAxe().catch(() => {
+      });
+      return json(res, 200, { ok: true, devices: await devices(), touch: canTouch() });
+    }
     if (!/^[0-9A-F-]{36}$/i.test(udid)) return json(res, 400, { ok: false, error: "udid required" });
     if (route === "/view") {
       res.writeHead(200, { "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-store" });
@@ -3878,22 +4575,19 @@ async function handle(req, res, route, url) {
     json(res, 500, { ok: false, error: String(e?.stderr || e?.message || e).trim().split("\n").pop() });
   }
 }
-var run3, TMP, axePath, canTouch, pointSize;
+var run4, TMP, AXE_VERSION, AXE_DIR, AXE_URL, foundAxe, installing2, canTouch, pointSize;
 var init_sim = __esm({
   "src/daemon/sim.ts"() {
     "use strict";
-    run3 = promisify3(execFile3);
-    TMP = path17.join(os8.tmpdir(), "sakura-sim");
-    axePath = /* @__PURE__ */ (() => {
-      let cached;
-      return () => {
-        if (cached !== void 0) return cached;
-        const dirs = [...(process.env.PATH ?? "").split(":"), "/opt/homebrew/bin", "/usr/local/bin"];
-        cached = dirs.map((d) => path17.join(d, "axe")).find((p) => fs19.existsSync(p)) ?? null;
-        return cached;
-      };
-    })();
-    canTouch = () => axePath() != null;
+    init_config();
+    run4 = promisify4(execFile4);
+    TMP = path19.join(os10.tmpdir(), "sakura-sim");
+    AXE_VERSION = "1.8.0";
+    AXE_DIR = path19.join(SAKURA_DIR, "axe", AXE_VERSION);
+    AXE_URL = `https://github.com/cameroncooke/AXe/releases/download/v${AXE_VERSION}/AXe-macOS-v${AXE_VERSION}-universal.tar.gz`;
+    foundAxe = null;
+    installing2 = null;
+    canTouch = () => process.platform === "darwin";
     pointSize = /* @__PURE__ */ new Map();
   }
 });
@@ -3902,8 +4596,8 @@ var init_sim = __esm({
 import http from "http";
 import net from "net";
 import { randomBytes as randomBytes3 } from "crypto";
-import { execFile as execFile4 } from "child_process";
-import { promisify as promisify4 } from "util";
+import { execFile as execFile5 } from "child_process";
+import { promisify as promisify5 } from "util";
 function cookies(req) {
   const out = {};
   for (const part of String(req.headers.cookie ?? "").split(";")) {
@@ -3994,7 +4688,7 @@ async function control(req, res, url) {
 async function ports(daemonPort) {
   let out = "";
   try {
-    ({ stdout: out } = await run4("lsof", ["-nP", "-iTCP", "-sTCP:LISTEN", "-Fcn"], { timeout: 4e3 }));
+    ({ stdout: out } = await run5("lsof", ["-nP", "-iTCP", "-sTCP:LISTEN", "-Fcn"], { timeout: 4e3 }));
   } catch (e) {
     out = e?.stdout ?? "";
   }
@@ -4012,13 +4706,13 @@ async function ports(daemonPort) {
   }
   return [...seen].map(([port2, process2]) => ({ port: port2, process: process2 })).sort((a, b) => a.port - b.port);
 }
-var run4, KEY, KEY_COOKIE, PORT_COOKIE, authed, SYSTEM;
+var run5, KEY, KEY_COOKIE, PORT_COOKIE, authed, SYSTEM;
 var init_preview = __esm({
   "src/daemon/preview.ts"() {
     "use strict";
     init_auth();
     init_sim();
-    run4 = promisify4(execFile4);
+    run5 = promisify5(execFile5);
     KEY = randomBytes3(24).toString("hex");
     KEY_COOKIE = "sakura_pk";
     PORT_COOKIE = "sakura_pp";
@@ -4029,22 +4723,22 @@ var init_preview = __esm({
 
 // src/daemon/server.ts
 import http2 from "http";
-import fs20 from "fs";
-import os9 from "os";
+import fs22 from "fs";
+import os11 from "os";
 import zlib2 from "zlib";
-import path18 from "path";
+import path20 from "path";
 import { URL as URL2 } from "url";
 import { execFileSync as execFileSync3 } from "child_process";
 import { WebSocketServer } from "ws";
-function add3(method, path22, handler) {
+function add3(method2, path24, handler) {
   const keys = [];
   const pattern = new RegExp(
-    "^" + path22.replace(/:[^/]+/g, (m) => {
+    "^" + path24.replace(/:[^/]+/g, (m) => {
       keys.push(m.slice(1));
       return "([^/]+)";
     }) + "/?$"
   );
-  routes.push({ method, pattern, keys, handler });
+  routes.push({ method: method2, pattern, keys, handler });
 }
 function runOptions(body) {
   return {
@@ -4069,8 +4763,8 @@ function sniffExt(buf) {
   return null;
 }
 function saveImages(sessionId, images) {
-  const dir = path18.join(os9.tmpdir(), "sakura-uploads", sessionId.slice(0, 24));
-  fs20.mkdirSync(dir, { recursive: true });
+  const dir = path20.join(os11.tmpdir(), "sakura-uploads", sessionId.slice(0, 24));
+  fs22.mkdirSync(dir, { recursive: true });
   const paths = [];
   images.forEach((img, i) => {
     const raw = String(img?.data ?? "");
@@ -4081,22 +4775,22 @@ function saveImages(sessionId, images) {
     }
     const bytes = Buffer.from(m[2], "base64");
     const ext = sniffExt(bytes) ?? EXT_BY_MIME[m[1]] ?? "png";
-    const base = img.name ? path18.parse(img.name).name.replace(/[^\w.\-]/g, "_") : "";
+    const base = img.name ? path20.parse(img.name).name.replace(/[^\w.\-]/g, "_") : "";
     const stem = `${base || "image"}-${Date.now()}-${i + 1}`;
-    let file = path18.join(dir, `${stem}.${ext}`);
-    fs20.writeFileSync(file, bytes);
+    let file2 = path20.join(dir, `${stem}.${ext}`);
+    fs22.writeFileSync(file2, bytes);
     if (ext === "heic") {
-      const jpg = path18.join(dir, `${stem}.jpg`);
+      const jpg = path20.join(dir, `${stem}.jpg`);
       try {
-        execFileSync3("sips", ["-s", "format", "jpeg", file, "--out", jpg], { stdio: "ignore" });
-        fs20.rmSync(file, { force: true });
-        file = jpg;
+        execFileSync3("sips", ["-s", "format", "jpeg", file2, "--out", jpg], { stdio: "ignore" });
+        fs22.rmSync(file2, { force: true });
+        file2 = jpg;
       } catch {
-        log.info(`saveImages: HEIC\u2192JPEG conversion failed for ${file}; sending HEIC as-is`);
+        log.info(`saveImages: HEIC\u2192JPEG conversion failed for ${file2}; sending HEIC as-is`);
       }
     }
-    log.info(`saveImages: wrote ${file} (${bytes.length} bytes)`);
-    paths.push(file);
+    log.info(`saveImages: wrote ${file2} (${bytes.length} bytes)`);
+    paths.push(file2);
   });
   return paths;
 }
@@ -4114,6 +4808,28 @@ function sendBytes(res, img) {
   });
   res.end(img.data);
 }
+async function startChat(agent, prepared, cwd, prompt, model, run6) {
+  const fail2 = (id2) => (e) => log.warn(`new session ${id2} failed: ${e.message}`);
+  if (agent === "claude" || agent === "acp") {
+    void runTurn(prepared, agent, prompt, void 0, model, run6).catch(fail2(prepared));
+    return prepared;
+  }
+  const before = new Set((await list({ agent, all: true })).map((x) => x.id));
+  let sink = null;
+  const early = [];
+  const done = chatNew(agent, cwd, prompt, (c) => sink ? sink(c) : early.push(c), model);
+  const id = await awaitNewSession(agent, cwd, before, done);
+  if (!id) {
+    const r = await done;
+    throw new Error(r.error || `${agent} didn't start a session`);
+  }
+  void runTurn(id, agent, prompt, void 0, model, run6, (onData) => {
+    sink = onData;
+    early.splice(0).forEach(onData);
+    return done;
+  }).catch(fail2(id));
+  return id;
+}
 function kvToObj(env) {
   if (!Array.isArray(env)) return void 0;
   const out = {};
@@ -4139,7 +4855,7 @@ function readBody(req) {
     req.on("error", () => resolve(null));
   });
 }
-function send6(res, status2, payload) {
+function send7(res, status2, payload) {
   const body = JSON.stringify(payload);
   const headers = {
     "Content-Type": "application/json",
@@ -4159,35 +4875,35 @@ function send6(res, status2, payload) {
 }
 function createServer(port2) {
   const server = http2.createServer(async (req, res) => {
-    const method = req.method ?? "GET";
+    const method2 = req.method ?? "GET";
     const url = new URL2(req.url ?? "/", `http://localhost:${port2}`);
-    if (method === "GET" && url.pathname === "/ping") {
-      return send6(res, 200, { pong: true, pid: process.pid });
+    if (method2 === "GET" && url.pathname === "/ping") {
+      return send7(res, 200, { pong: true, pid: process.pid });
     }
     if (url.pathname.startsWith("/__preview/")) return control(req, res, url);
     const previewPort = target(req, port2);
     if (previewPort) return proxy(req, res, previewPort);
-    if (method === "OPTIONS") return send6(res, 204, {});
+    if (method2 === "OPTIONS") return send7(res, 204, {});
     const expected = getToken();
     const auth = req.headers["authorization"];
     const presented = typeof auth === "string" && auth.startsWith("Bearer ") ? auth.slice(7) : void 0;
     if (!expected || presented !== expected) {
-      return send6(res, 401, { error: "Unauthorized" });
+      return send7(res, 401, { error: "Unauthorized" });
     }
     const route = routes.find(
-      (r) => r.method === method && r.pattern.test(url.pathname)
+      (r) => r.method === method2 && r.pattern.test(url.pathname)
     );
-    if (!route) return send6(res, 404, { error: "Not found" });
+    if (!route) return send7(res, 404, { error: "Not found" });
     const match = route.pattern.exec(url.pathname);
     const params = {};
     route.keys.forEach((k, i) => params[k] = decodeURIComponent(match[i + 1]));
-    const body = method === "GET" ? null : await readBody(req);
+    const body = method2 === "GET" ? null : await readBody(req);
     try {
       const result = await route.handler({ req, res, url, params, body, port: port2 });
-      if (!res.headersSent) send6(res, 200, result);
+      if (!res.headersSent) send7(res, 200, result);
     } catch (e) {
       log.error("handler error", e.message);
-      send6(res, 500, fail("nonzero", e.message));
+      send7(res, 500, fail("nonzero", e.message));
     }
   });
   const wss = new WebSocketServer({ noServer: true });
@@ -4257,6 +4973,8 @@ var init_server = __esm({
     init_config();
     init_logger();
     init_sessions();
+    init_acp();
+    init_handoff();
     init_push();
     init_registry();
     init_projects();
@@ -4296,24 +5014,24 @@ var init_server = __esm({
       const reader = params.agent === "opencode" ? image : params.agent === "zcode" ? image2 : null;
       sendBytes(res, reader ? await reader(params.session, params.part) : null);
     });
-    UPLOADS_DIR = path18.join(os9.tmpdir(), "sakura-uploads");
+    UPLOADS_DIR = path20.join(os11.tmpdir(), "sakura-uploads");
     add3("GET", "/uploads/:dir/:file", ({ res, params }) => {
-      const file = path18.resolve(UPLOADS_DIR, params.dir, params.file);
-      const ext = path18.extname(file).slice(1).toLowerCase();
+      const file2 = path20.resolve(UPLOADS_DIR, params.dir, params.file);
+      const ext = path20.extname(file2).slice(1).toLowerCase();
       const mime = Object.entries(EXT_BY_MIME).find(([, e]) => e === ext)?.[0];
-      const ok2 = file.startsWith(UPLOADS_DIR + path18.sep) && mime && fs20.existsSync(file);
-      sendBytes(res, ok2 ? { mediaType: mime, data: fs20.readFileSync(file) } : null);
+      const ok2 = file2.startsWith(UPLOADS_DIR + path20.sep) && mime && fs22.existsSync(file2);
+      sendBytes(res, ok2 ? { mediaType: mime, data: fs22.readFileSync(file2) } : null);
     });
     add3("GET", "/sessions", async ({ url }) => {
       const archived = url.searchParams.get("archived") === "true";
       const all2 = url.searchParams.get("all") === "true";
       const list4 = await list({ archived, all: all2 });
-      return { sessions: list4 };
+      return { sessions: await tagSessions(list4) };
     });
     add3("GET", "/sessions/:id/messages", async ({ params, url }) => {
       const agent = url.searchParams.get("agent") || void 0;
-      const messages7 = await messages6(params.id, agent);
-      return { messages: messages7 };
+      const messages8 = await messages7(params.id, agent);
+      return { messages: messages8 };
     });
     add3("POST", "/sessions/:id/send", async ({ params, body }) => {
       const agent = body?.agent || await detectAgent(params.id);
@@ -4324,8 +5042,8 @@ var init_server = __esm({
       const imagePaths = incoming.length ? saveImages(params.id, incoming) : [];
       if (imagePaths.length) log.info(`send: attached ${imagePaths.length} image(s) to ${agent} prompt`);
       const model = body?.model ? String(body.model) : void 0;
-      const run5 = runOptions(body);
-      const r = await runTurn(params.id, agent, message, imagePaths, model, run5);
+      const run6 = runOptions(body);
+      const r = await runTurn(params.id, agent, message, imagePaths, model, run6);
       return { ok: r.ok, error: r.error };
     });
     add3("GET", "/sessions/:id/status", async ({ params, url }) => {
@@ -4371,7 +5089,7 @@ var init_server = __esm({
         case "logs": {
           let logs2 = "";
           try {
-            const lines2 = fs20.readFileSync(LOG_PATH, "utf8").split("\n");
+            const lines2 = fs22.readFileSync(LOG_PATH, "utf8").split("\n");
             logs2 = lines2.slice(-200).join("\n");
           } catch {
           }
@@ -4428,13 +5146,37 @@ var init_server = __esm({
       if (!prompt) return fail("bad_request", "prompt required");
       const agent = body?.agent || "claude";
       const model = body?.model ? String(body.model) : void 0;
-      const run5 = runOptions(body);
+      const run6 = runOptions(body);
       try {
-        const s = await prepareSession(params.id, agent, !!body?.worktree);
-        void runTurn(s.sessionId, agent, prompt, void 0, model, run5).catch(
-          (e) => log.warn(`project session ${s.sessionId} failed: ${e.message}`)
-        );
-        return ok({ ...s, agent });
+        const s = await prepareSession(params.id, agent, !!body?.worktree, body?.acp ? String(body.acp) : void 0);
+        return ok({ ...s, sessionId: await startChat(agent, s.sessionId, s.cwd, prompt, model, run6), agent });
+      } catch (e) {
+        return fail("bad_request", e.message);
+      }
+    });
+    add3("POST", "/sakura/projects/:id/handoff", async ({ params, body }) => {
+      const from = (Array.isArray(body?.from) ? body.from : []).filter((x) => x?.id && x?.agent).map((x) => ({ id: String(x.id), agent: x.agent }));
+      if (!from.length) return fail("bad_request", "pick at least one conversation");
+      const agent = body?.agent || "claude";
+      const model = body?.model ? String(body.model) : void 0;
+      try {
+        const prompt = await handoffPrompt(from, body?.prompt ? String(body.prompt) : void 0);
+        const s = await prepareSession(params.id, agent, false, body?.acp ? String(body.acp) : void 0);
+        const sessionId = await startChat(agent, s.sessionId, s.cwd, prompt, model, runOptions(body));
+        rename(sessionId, await handoffTitle(from));
+        return ok({ ...s, sessionId, agent });
+      } catch (e) {
+        return fail("bad_request", e.message);
+      }
+    });
+    add3("POST", "/sakura/chats", async ({ body }) => {
+      const prompt = String(body?.prompt ?? "").trim();
+      if (!prompt) return fail("bad_request", "prompt required");
+      const agent = body?.agent || "claude";
+      const model = body?.model ? String(body.model) : void 0;
+      try {
+        const s = await prepareScratch(agent, body?.acp ? String(body.acp) : void 0);
+        return ok({ ...s, sessionId: await startChat(agent, s.sessionId, s.cwd, prompt, model, runOptions(body)), agent });
       } catch (e) {
         return fail("bad_request", e.message);
       }
@@ -4446,7 +5188,11 @@ var init_server = __esm({
       return ok(await chatContext(id, agent));
     });
     add3("GET", "/sakura/preview/ports", async ({ port: port2 }) => ok(await ports(port2)));
-    add3("GET", "/sakura/sim/devices", async () => ok({ devices: await devices(), touch: canTouch() }));
+    add3("GET", "/sakura/sim/devices", async () => {
+      ensureAxe().catch(() => {
+      });
+      return ok({ devices: await devices(), touch: canTouch() });
+    });
     add3("POST", "/sakura/sim/:udid/boot", async ({ params }) => {
       await boot(params.udid);
       return ok();
@@ -4483,9 +5229,22 @@ var init_server = __esm({
     });
     add3("GET", "/sakura/models", async ({ url }) => {
       const agent = url.searchParams.get("agent") || "claude";
+      if (agent === "acp") return ok(models(url.searchParams.get("acp") ?? ""));
       return ok(await listModels(agent));
     });
-    add3("GET", "/sakura/machine", () => ok({ name: loadConfig().machineName || os9.hostname() }));
+    add3("GET", "/sakura/acp/registry", async ({ url }) => {
+      if (url.searchParams.get("refresh") === "1") await registry(true);
+      return ok(await catalog());
+    });
+    add3("POST", "/sakura/acp/agents/:id", async ({ params, body }) => {
+      try {
+        return ok(await setEnabled(params.id, body?.enabled !== false));
+      } catch (e) {
+        return fail("bad_request", e.message);
+      }
+    });
+    add3("GET", "/sakura/agents", () => ok(runnableAgents()));
+    add3("GET", "/sakura/machine", () => ok({ name: loadConfig().machineName || os11.hostname() }));
     add3("GET", "/sakura/mentions", ({ url }) => ok(mentions(url.searchParams.get("cwd") ?? void 0)));
     add3("POST", "/sakura/push-token", ({ body }) => {
       let b = body;
@@ -4531,8 +5290,8 @@ var init_server = __esm({
       const agent = body?.agent || await detectAgent(params.id);
       if (!agent) return fail("nonzero", "unknown agent for session");
       const model = body?.model ? String(body.model) : void 0;
-      const run5 = runOptions(body);
-      const r = await runTurn(params.id, agent, String(body?.prompt ?? ""), void 0, model, run5);
+      const run6 = runOptions(body);
+      const r = await runTurn(params.id, agent, String(body?.prompt ?? ""), void 0, model, run6);
       return r.ok ? ok({ ok: true }) : fail("nonzero", r.error ?? "chat failed");
     });
     add3(
@@ -4619,7 +5378,7 @@ var init_server = __esm({
       const p = url.searchParams.get("path");
       if (!p) return fail("nonzero", "path required");
       try {
-        return ok(read2(p));
+        return ok(read3(p));
       } catch (e) {
         return fail("nonzero", e.message);
       }
@@ -4627,7 +5386,7 @@ var init_server = __esm({
     add3("POST", "/sakura/fs/write", ({ body }) => {
       if (!body?.path) return fail("nonzero", "path required");
       try {
-        return ok(write3(body.path, String(body.content ?? "")));
+        return ok(write4(body.path, String(body.content ?? "")));
       } catch (e) {
         return fail("nonzero", e.message);
       }
@@ -4640,7 +5399,7 @@ var init_server = __esm({
         return fail("nonzero", e.message);
       }
     });
-    add3("GET", "/tailscale/health", () => installed());
+    add3("GET", "/tailscale/health", () => installed2());
     add3("GET", "/tailscale/status", ({ port: port2 }) => status(port2));
     add3("POST", "/tailscale/up", () => up());
     add3("POST", "/tailscale/down", () => down());
@@ -4652,24 +5411,24 @@ var init_server = __esm({
 
 // src/daemon/tsnet.ts
 import crypto from "crypto";
-import fs21 from "fs";
-import path19 from "path";
+import fs23 from "fs";
+import path21 from "path";
 import { fileURLToPath } from "url";
-import { spawn as spawn11 } from "child_process";
+import { spawn as spawn12 } from "child_process";
 function resolveBinary() {
   const envBin = process.env.SAKURA_TSNET_BIN;
-  if (envBin && fs21.existsSync(envBin)) return envBin;
-  const here = path19.dirname(fileURLToPath(import.meta.url));
+  if (envBin && fs23.existsSync(envBin)) return envBin;
+  const here = path21.dirname(fileURLToPath(import.meta.url));
   const name = process.platform === "win32" ? "sakura-tsnet.exe" : "sakura-tsnet";
   const candidates = [
-    path19.join(here, "..", "bin", name),
+    path21.join(here, "..", "bin", name),
     // package/bin (postinstall download / build-sidecar.sh)
-    path19.join(here, "bin", name),
-    path19.join(process.cwd(), "bin", name),
-    path19.join(SAKURA_DIR, name)
+    path21.join(here, "bin", name),
+    path21.join(process.cwd(), "bin", name),
+    path21.join(SAKURA_DIR, name)
     // user-dropped
   ];
-  return candidates.find((p) => fs21.existsSync(p)) ?? null;
+  return candidates.find((p) => fs23.existsSync(p)) ?? null;
 }
 function startTsnet(port2) {
   const cfg = loadConfig();
@@ -4685,22 +5444,22 @@ function startTsnet(port2) {
   }
   stopping = false;
   resetStateIfKeyChanged(ts.authKey);
-  const fresh = !fs21.existsSync(path19.join(STATE_DIR, "tailscaled.state")) && !fs21.existsSync(JOINED_MARK);
+  const fresh = !fs23.existsSync(path21.join(STATE_DIR, "tailscaled.state")) && !fs23.existsSync(JOINED_MARK);
   spawnSidecar(bin, ts.controlUrl, ts.authKey, ts.hostname || cfg.machineName, port2, fresh);
 }
 function resetStateIfKeyChanged(authKey) {
   const hash = crypto.createHash("sha256").update(authKey).digest("hex");
   let prev = null;
   try {
-    prev = fs21.readFileSync(KEY_MARK, "utf8").trim();
+    prev = fs23.readFileSync(KEY_MARK, "utf8").trim();
   } catch {
   }
   if (prev && prev !== hash) {
     log.info("tailnet key changed \u2014 re-registering this Mac on the new key");
-    fs21.rmSync(STATE_DIR, { recursive: true, force: true });
+    fs23.rmSync(STATE_DIR, { recursive: true, force: true });
   }
-  fs21.mkdirSync(STATE_DIR, { recursive: true });
-  fs21.writeFileSync(KEY_MARK, hash);
+  fs23.mkdirSync(STATE_DIR, { recursive: true });
+  fs23.writeFileSync(KEY_MARK, hash);
 }
 function spawnSidecar(bin, controlUrl, authKey, hostname2, port2, forceLogin) {
   const env = {
@@ -4713,8 +5472,8 @@ function spawnSidecar(bin, controlUrl, authKey, hostname2, port2, forceLogin) {
     SAKURA_TS_PORT: String(port2)
   };
   if (forceLogin) env.TSNET_FORCE_LOGIN = "1";
-  log.info(`starting embedded Tailscale sidecar (${path19.basename(bin)})${forceLogin ? " with a forced login" : ""}`);
-  const c = spawn11(bin, [], { stdio: ["ignore", "pipe", "pipe"], env });
+  log.info(`starting embedded Tailscale sidecar (${path21.basename(bin)})${forceLogin ? " with a forced login" : ""}`);
+  const c = spawn12(bin, [], { stdio: ["ignore", "pipe", "pipe"], env });
   child = c;
   let joinFailed = false;
   const pipe = (buf) => buf.toString().split("\n").filter(Boolean).forEach((line) => {
@@ -4722,7 +5481,7 @@ function spawnSidecar(bin, controlUrl, authKey, hostname2, port2, forceLogin) {
     if (line.includes("failed to join tailnet")) joinFailed = true;
     if (line.includes("on tailnet as")) {
       try {
-        fs21.writeFileSync(JOINED_MARK, (/* @__PURE__ */ new Date()).toISOString());
+        fs23.writeFileSync(JOINED_MARK, (/* @__PURE__ */ new Date()).toISOString());
       } catch {
       }
     }
@@ -4732,7 +5491,7 @@ function spawnSidecar(bin, controlUrl, authKey, hostname2, port2, forceLogin) {
   c.on("exit", (code) => {
     child = null;
     if (stopping) return;
-    const force = forceLogin || joinFailed && !fs21.existsSync(JOINED_MARK);
+    const force = forceLogin || joinFailed && !fs23.existsSync(JOINED_MARK);
     log.warn(`tsnet sidecar exited (code ${code}); restarting in 5s`);
     restartTimer = setTimeout(() => {
       if (!stopping) spawnSidecar(bin, controlUrl, authKey, hostname2, port2, force);
@@ -4753,7 +5512,7 @@ function stopTsnet() {
     child = null;
   }
   try {
-    fs21.rmSync(TSNET_PATH, { force: true });
+    fs23.rmSync(TSNET_PATH, { force: true });
   } catch {
   }
 }
@@ -4766,15 +5525,15 @@ var init_tsnet = __esm({
     child = null;
     stopping = false;
     restartTimer = null;
-    STATE_DIR = path19.join(SAKURA_DIR, "tsnet-state");
-    KEY_MARK = path19.join(STATE_DIR, "joined-with");
-    JOINED_MARK = path19.join(STATE_DIR, "joined");
+    STATE_DIR = path21.join(SAKURA_DIR, "tsnet-state");
+    KEY_MARK = path21.join(STATE_DIR, "joined-with");
+    JOINED_MARK = path21.join(STATE_DIR, "joined");
   }
 });
 
 // src/daemon/manager.ts
-import fs22 from "fs";
-import { spawn as spawn12 } from "child_process";
+import fs24 from "fs";
+import { spawn as spawn13 } from "child_process";
 async function ensureTailnetProvisioned() {
   const serverToken = getServerToken();
   if (!serverToken) return;
@@ -4796,7 +5555,7 @@ async function ensureTailnetProvisioned() {
 }
 function readDaemonInfo() {
   try {
-    return JSON.parse(fs22.readFileSync(DAEMON_PATH, "utf8"));
+    return JSON.parse(fs24.readFileSync(DAEMON_PATH, "utf8"));
   } catch {
     return null;
   }
@@ -4813,8 +5572,8 @@ function running() {
   const info2 = readDaemonInfo();
   if (info2 && pidAlive(info2.pid)) return info2;
   if (info2) {
-    fs22.rmSync(DAEMON_PATH, { force: true });
-    fs22.rmSync(PID_PATH, { force: true });
+    fs24.rmSync(DAEMON_PATH, { force: true });
+    fs24.rmSync(PID_PATH, { force: true });
   }
   return null;
 }
@@ -4837,8 +5596,8 @@ async function runServer(version) {
     url: `http://${host}:${port2}`,
     startedAt: Date.now()
   };
-  fs22.writeFileSync(DAEMON_PATH, JSON.stringify(info2, null, 2));
-  fs22.writeFileSync(PID_PATH, String(process.pid));
+  fs24.writeFileSync(DAEMON_PATH, JSON.stringify(info2, null, 2));
+  fs24.writeFileSync(PID_PATH, String(process.pid));
   await ensureTailnetProvisioned();
   startTsnet(port2);
   const tailnet = await discoverBaseUrl(port2).catch(() => null);
@@ -4849,8 +5608,8 @@ async function runServer(version) {
     log.info("shutting down");
     stopTsnet();
     server.close();
-    fs22.rmSync(DAEMON_PATH, { force: true });
-    fs22.rmSync(PID_PATH, { force: true });
+    fs24.rmSync(DAEMON_PATH, { force: true });
+    fs24.rmSync(PID_PATH, { force: true });
     process.exit(0);
   };
   process.on("SIGINT", shutdown);
@@ -4861,9 +5620,9 @@ function start() {
   if (existing) return existing;
   ensureSakuraDirs();
   const entry = process.argv[1] ?? "";
-  const out = fs22.openSync(LOG_PATH, "a");
-  const err = fs22.openSync(LOG_PATH, "a");
-  const child2 = spawn12(process.execPath, [entry, "__run-daemon"], {
+  const out = fs24.openSync(LOG_PATH, "a");
+  const err = fs24.openSync(LOG_PATH, "a");
+  const child2 = spawn13(process.execPath, [entry, "__run-daemon"], {
     detached: true,
     stdio: ["ignore", out, err],
     env: process.env
@@ -4884,8 +5643,8 @@ function stop() {
     process.kill(info2.pid, "SIGTERM");
   } catch {
   }
-  fs22.rmSync(DAEMON_PATH, { force: true });
-  fs22.rmSync(PID_PATH, { force: true });
+  fs24.rmSync(DAEMON_PATH, { force: true });
+  fs24.rmSync(PID_PATH, { force: true });
   return true;
 }
 function restart() {
@@ -4895,7 +5654,7 @@ function restart() {
 }
 function logs(lines2 = 50) {
   try {
-    const all2 = fs22.readFileSync(LOG_PATH, "utf8").split("\n");
+    const all2 = fs24.readFileSync(LOG_PATH, "utf8").split("\n");
     return all2.slice(-lines2).join("\n");
   } catch {
     return "";
@@ -4915,18 +5674,18 @@ var init_manager = __esm({
 });
 
 // src/pairing.ts
-import os10 from "os";
+import os12 from "os";
 import qrcode from "qrcode-terminal";
-import fs23 from "fs";
+import fs25 from "fs";
 function recentTsnetLog(max = 6) {
   let text = "";
   try {
-    const fd = fs23.openSync(LOG_PATH, "r");
-    const size = fs23.fstatSync(fd).size;
+    const fd = fs25.openSync(LOG_PATH, "r");
+    const size = fs25.fstatSync(fd).size;
     const len = Math.min(size, 64 * 1024);
     const buf = Buffer.alloc(len);
-    fs23.readSync(fd, buf, 0, len, size - len);
-    fs23.closeSync(fd);
+    fs25.readSync(fd, buf, 0, len, size - len);
+    fs25.closeSync(fd);
     text = buf.toString("utf8");
   } catch {
     return [];
@@ -4998,7 +5757,7 @@ function renderQr(deepLink) {
   });
 }
 function localIp() {
-  const nets = os10.networkInterfaces();
+  const nets = os12.networkInterfaces();
   for (const name of Object.keys(nets)) {
     for (const net2 of nets[name] ?? []) {
       if (net2.family === "IPv4" && !net2.internal) return net2.address;
@@ -5087,7 +5846,7 @@ var init_pair = __esm({
 import { Command } from "commander";
 
 // src/version.ts
-var VERSION = "0.0.16";
+var VERSION = "0.0.17";
 
 // src/index.ts
 init_config();
@@ -5137,9 +5896,9 @@ function registerAuth(program) {
   });
   program.command("whoami").description("Show the current login + token status").option("--json", "output as JSON").action((opts) => {
     const auth = loadAuth();
-    const has = !!getToken();
-    if (opts.json) return printJson({ loggedIn: has, login: auth.login, machineName: auth.machineName });
-    if (!has) return warn("Not signed in. Run `sakuraai login`.");
+    const has2 = !!getToken();
+    if (opts.json) return printJson({ loggedIn: has2, login: auth.login, machineName: auth.machineName });
+    if (!has2) return warn("Not signed in. Run `sakuraai login`.");
     info(`Signed in as ${auth.login ?? "unknown"} on "${auth.machineName ?? "unknown"}".`);
   });
 }
@@ -5205,7 +5964,7 @@ function registerRuntime(program, version) {
 // src/commands/session.ts
 init_sessions();
 init_output();
-import fs24 from "fs";
+import fs26 from "fs";
 function resolveSessionId(arg) {
   const id = arg || process.env.SAKURA_SESSION_ID;
   if (!id) die("Provide a sessionId (positional or via SAKURA_SESSION_ID).");
@@ -5214,7 +5973,7 @@ function resolveSessionId(arg) {
 async function resolvePrompt(positional, opts) {
   if (positional) return positional;
   if (opts.prompt) return opts.prompt;
-  if (opts.promptFile) return fs24.readFileSync(opts.promptFile, "utf8");
+  if (opts.promptFile) return fs26.readFileSync(opts.promptFile, "utf8");
   if (!process.stdin.isTTY) {
     const chunks = [];
     for await (const c of process.stdin) chunks.push(c);
@@ -5245,7 +6004,7 @@ function registerSession(program) {
     const id = resolveSessionId(sessionId);
     const meta = await show(id);
     if (!meta) die(`Session not found: ${id}`);
-    const msgs = await messages6(id, meta.agent);
+    const msgs = await messages7(id, meta.agent);
     const enriched = { ...meta, historyCount: msgs.length };
     if (opts.json) return printJson(enriched);
     info(`ID:       ${meta.id}`);
@@ -5529,25 +6288,25 @@ init_pair();
 
 // src/commands/welcome.ts
 init_config();
-import fs25 from "fs";
-import path20 from "path";
+import fs27 from "fs";
+import path22 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { spawn as spawn13 } from "child_process";
-var WELCOMED_MARKER = path20.join(SAKURA_DIR, ".welcomed");
+import { spawn as spawn14 } from "child_process";
+var WELCOMED_MARKER = path22.join(SAKURA_DIR, ".welcomed");
 function resolveBinary2() {
   const envBin = process.env.SAKURA_ONBOARD_BIN;
-  if (envBin && fs25.existsSync(envBin)) return envBin;
-  const here = path20.dirname(fileURLToPath2(import.meta.url));
+  if (envBin && fs27.existsSync(envBin)) return envBin;
+  const here = path22.dirname(fileURLToPath2(import.meta.url));
   const name = process.platform === "win32" ? "sakura-onboard.exe" : "sakura-onboard";
   const candidates = [
-    path20.join(here, "..", "bin", name),
+    path22.join(here, "..", "bin", name),
     // package/bin (postinstall download)
-    path20.join(here, "bin", name),
-    path20.join(process.cwd(), "bin", name),
-    path20.join(SAKURA_DIR, name)
+    path22.join(here, "bin", name),
+    path22.join(process.cwd(), "bin", name),
+    path22.join(SAKURA_DIR, name)
     // user-dropped
   ];
-  return candidates.find((p) => fs25.existsSync(p)) ?? null;
+  return candidates.find((p) => fs27.existsSync(p)) ?? null;
 }
 function showWelcome() {
   return new Promise((resolve) => {
@@ -5556,7 +6315,7 @@ function showWelcome() {
       printFallback();
       return resolve();
     }
-    const child2 = spawn13(bin, [], { stdio: "inherit" });
+    const child2 = spawn14(bin, [], { stdio: "inherit" });
     child2.on("error", () => {
       printFallback();
       resolve();
@@ -5565,10 +6324,10 @@ function showWelcome() {
   });
 }
 async function maybeFirstRunWelcome() {
-  if (fs25.existsSync(WELCOMED_MARKER)) return;
+  if (fs27.existsSync(WELCOMED_MARKER)) return;
   if (!process.stdout.isTTY || !process.stdin.isTTY) return;
   try {
-    fs25.writeFileSync(WELCOMED_MARKER, (/* @__PURE__ */ new Date()).toISOString());
+    fs27.writeFileSync(WELCOMED_MARKER, (/* @__PURE__ */ new Date()).toISOString());
   } catch {
   }
   await showWelcome();
@@ -5606,9 +6365,9 @@ function registerWelcome(program) {
 }
 
 // src/commands/app.ts
-import fs26 from "fs";
-import os11 from "os";
-import path21 from "path";
+import fs28 from "fs";
+import os13 from "os";
+import path23 from "path";
 import { execFileSync as execFileSync4 } from "child_process";
 init_output();
 var APP_PATH = "/Applications/Sakura.app";
@@ -5619,13 +6378,13 @@ function dmgUrl() {
 async function download(url, dest) {
   const res = await fetch(url, { redirect: "follow" });
   if (!res.ok) throw new Error(`download failed: HTTP ${res.status} for ${url}`);
-  fs26.writeFileSync(dest, Buffer.from(await res.arrayBuffer()));
+  fs28.writeFileSync(dest, Buffer.from(await res.arrayBuffer()));
 }
-async function install() {
+async function install2() {
   if (process.platform !== "darwin") die("The Sakura menu bar app is macOS only.");
-  const tmp = fs26.mkdtempSync(path21.join(os11.tmpdir(), "sakura-app-"));
-  const dmg = path21.join(tmp, "Sakura.dmg");
-  const mount = path21.join(tmp, "mnt");
+  const tmp = fs28.mkdtempSync(path23.join(os13.tmpdir(), "sakura-app-"));
+  const dmg = path23.join(tmp, "Sakura.dmg");
+  const mount = path23.join(tmp, "mnt");
   info(`Downloading Sakura.app ${VERSION}\u2026`);
   try {
     await download(dmgUrl(), dmg);
@@ -5633,27 +6392,27 @@ async function install() {
     die(`${e.message}
 Build it yourself instead: ./mac/scripts/build-dmg.sh in the Sakura repo.`);
   }
-  fs26.mkdirSync(mount);
+  fs28.mkdirSync(mount);
   execFileSync4("hdiutil", ["attach", dmg, "-nobrowse", "-quiet", "-mountpoint", mount]);
   try {
     try {
       execFileSync4("osascript", ["-e", 'tell application id "mom.sakura.mac" to quit']);
     } catch {
     }
-    fs26.rmSync(APP_PATH, { recursive: true, force: true });
-    execFileSync4("ditto", [path21.join(mount, "Sakura.app"), APP_PATH]);
+    fs28.rmSync(APP_PATH, { recursive: true, force: true });
+    execFileSync4("ditto", [path23.join(mount, "Sakura.app"), APP_PATH]);
   } finally {
     execFileSync4("hdiutil", ["detach", mount, "-quiet"]);
-    fs26.rmSync(tmp, { recursive: true, force: true });
+    fs28.rmSync(tmp, { recursive: true, force: true });
   }
   execFileSync4("open", [APP_PATH]);
   success("Sakura is in your menu bar (look for the blossom).");
 }
 function registerApp(program) {
   const app = program.command("app").description("The optional Sakura menu bar app for macOS");
-  app.command("install").description("Download Sakura.app into /Applications and open it").action(install);
+  app.command("install").description("Download Sakura.app into /Applications and open it").action(install2);
   app.command("open").description("Open the Sakura menu bar app").action(() => {
-    if (!fs26.existsSync(APP_PATH)) die("Sakura.app is not installed. Run `sakuraai app install`.");
+    if (!fs28.existsSync(APP_PATH)) die("Sakura.app is not installed. Run `sakuraai app install`.");
     execFileSync4("open", [APP_PATH]);
   });
 }