sakuraai 0.0.11 → 0.0.13

package/dist/index.js

@@ -103,8 +103,8 @@ var init_config = __esm({
 function apiBase() {
   return (loadAuth().serverUrl || DEFAULT_API_URL).replace(/\/+$/, "");
 }
-async function postJson(base, path12, body, token) {
-  const res = await fetch(`${base}${path12}`, {
+async function postJson(base, path18, body, token) {
+  const res = await fetch(`${base}${path18}`, {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
@@ -114,7 +114,7 @@ async function postJson(base, path12, body, token) {
   });
   if (!res.ok) {
     const text = await res.text().catch(() => "");
-    throw new Error(`${path12} \u2192 ${res.status} ${res.statusText}${text ? `: ${text}` : ""}`);
+    throw new Error(`${path18} \u2192 ${res.status} ${res.statusText}${text ? `: ${text}` : ""}`);
   }
   return await res.json();
 }
@@ -323,8 +323,200 @@ var init_logger = __esm({
   }
 });
 
-// src/runtime/util.ts
+// src/runtime/parts.ts
 import os3 from "os";
+import path2 from "path";
+function canonicalTool(name) {
+  return CANONICAL[name.toLowerCase()] ?? name;
+}
+function shortPath(p) {
+  const home = os3.homedir();
+  return p.startsWith(home + path2.sep) ? `~/${p.slice(home.length + 1)}` : p;
+}
+function trimOutput(s) {
+  if (s == null) return void 0;
+  const text = (typeof s === "string" ? s : JSON.stringify(s, null, 2)).trim();
+  if (!text) return void 0;
+  let out = text.split("\n").slice(0, OUTPUT_LINES).join("\n");
+  if (out.length > OUTPUT_CHARS) out = out.slice(0, OUTPUT_CHARS);
+  return out.length < text.length ? `${out}
+\u2026` : out;
+}
+function str(v) {
+  return typeof v === "string" && v ? v : void 0;
+}
+function diffStrings(file, 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}`)]);
+  }
+  const dp = Array.from({ length: a.length + 1 }, () => new Array(b.length + 1).fill(0));
+  for (let i2 = a.length - 1; i2 >= 0; i2--)
+    for (let j2 = b.length - 1; j2 >= 0; j2--)
+      dp[i2][j2] = a[i2] === b[j2] ? dp[i2 + 1][j2 + 1] + 1 : Math.max(dp[i2 + 1][j2], dp[i2][j2 + 1]);
+  const lines2 = [];
+  let i = 0;
+  let j = 0;
+  while (i < a.length && j < b.length) {
+    if (a[i] === b[j]) {
+      lines2.push(` ${a[i]}`);
+      i++;
+      j++;
+    } else if (dp[i + 1][j] >= dp[i][j + 1]) lines2.push(`-${a[i++]}`);
+    else lines2.push(`+${b[j++]}`);
+  }
+  while (i < a.length) lines2.push(`-${a[i++]}`);
+  while (j < b.length) lines2.push(`+${b[j++]}`);
+  return capDiff(file, lines2);
+}
+function diffFromHunks(file, 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);
+}
+function capDiff(file, 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),
+    added,
+    removed,
+    lines: truncated ? lines2.slice(0, DIFF_LINE_LIMIT) : lines2,
+    ...truncated ? { truncated } : {}
+  };
+}
+function toolPart(id, rawName, input) {
+  const name = canonicalTool(rawName);
+  const inp = typeof input === "string" ? safeJson(input) ?? { command: input } : input ?? {};
+  const file = str(inp.file_path) ?? str(inp.filePath) ?? str(inp.path) ?? str(inp.file);
+  let title;
+  let diff;
+  let todos;
+  switch (name) {
+    case "Bash":
+      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"));
+      break;
+    case "Write":
+      title = file ? shortPath(file) : "Write file";
+      if (file && typeof inp.content === "string") diff = diffStrings(file, "", inp.content);
+      break;
+    case "Read":
+    case "List":
+      title = file ? shortPath(file) : name === "List" ? "List files" : "Read file";
+      break;
+    case "Grep":
+    case "Glob":
+      title = str(inp.pattern) ?? str(inp.query) ?? name;
+      break;
+    case "Fetch":
+      title = str(inp.url) ?? "Fetch";
+      break;
+    case "Search":
+      title = str(inp.query) ?? "Web search";
+      break;
+    case "Agent":
+      title = str(inp.description) ?? str(inp.prompt)?.slice(0, 80) ?? "Sub-agent";
+      break;
+    case "Todos": {
+      const list3 = Array.isArray(inp.todos) ? inp.todos : Array.isArray(inp.plan) ? inp.plan : [];
+      todos = list3.map((t) => ({ content: String(t.content ?? t.step ?? ""), status: String(t.status ?? "pending") }));
+      const done = todos.filter((t) => t.status === "completed").length;
+      title = `${done}/${todos.length} done`;
+      break;
+    }
+    default:
+      title = file ? shortPath(file) : str(inp.description) ?? str(inp.command) ?? str(inp.query) ?? "";
+  }
+  return {
+    type: "tool",
+    id,
+    name,
+    title: title.replace(/\s+/g, " ").trim().slice(0, 160),
+    status: "running",
+    ...diff ? { diff } : {},
+    ...todos ? { todos } : {}
+  };
+}
+function safeJson(s) {
+  try {
+    const v = JSON.parse(s);
+    return v && typeof v === "object" ? v : null;
+  } catch {
+    return null;
+  }
+}
+function claudeContextWindow(model, usedTokens = 0) {
+  if (usedTokens > 2e5) return 1e6;
+  return /fable|mythos|opus-(4-[6-9]|5)|sonnet-(4-6|5)|haiku-5/.test(model ?? "") ? 1e6 : 2e5;
+}
+function textOf(parts) {
+  return parts.filter((p) => p.type === "text").map((p) => p.text).join("\n\n");
+}
+function userTextParts(text) {
+  if (SOURCE_REF.test(text.trim())) return [];
+  const parts = [];
+  const uploads = [...text.matchAll(UPLOAD_REF)].map((m) => m[1]);
+  const rest = text.replace(UPLOAD_REF, "").trim();
+  if (rest) parts.push({ type: "text", text: rest });
+  for (const p of uploads) {
+    const rel = p.split(`sakura-uploads${path2.sep}`)[1];
+    if (rel) parts.push({ type: "image", url: `/uploads/${rel.split(path2.sep).map(encodeURIComponent).join("/")}` });
+  }
+  return parts;
+}
+var OUTPUT_CHARS, OUTPUT_LINES, DIFF_LINE_LIMIT, CANONICAL, UPLOAD_REF, SOURCE_REF;
+var init_parts = __esm({
+  "src/runtime/parts.ts"() {
+    "use strict";
+    OUTPUT_CHARS = 1200;
+    OUTPUT_LINES = 40;
+    DIFF_LINE_LIMIT = 300;
+    CANONICAL = {
+      bash: "Bash",
+      shell: "Bash",
+      exec_command: "Bash",
+      local_shell: "Bash",
+      exec: "Bash",
+      read: "Read",
+      view: "Read",
+      edit: "Edit",
+      multiedit: "Edit",
+      str_replace: "Edit",
+      apply_patch: "Edit",
+      patch: "Edit",
+      write: "Write",
+      create: "Write",
+      grep: "Grep",
+      glob: "Glob",
+      ls: "List",
+      list: "List",
+      todowrite: "Todos",
+      update_plan: "Todos",
+      webfetch: "Fetch",
+      websearch: "Search",
+      web_search: "Search",
+      task: "Agent",
+      agent: "Agent"
+    };
+    UPLOAD_REF = /\[Image: ([^\]\n]*sakura-uploads[^\]\n]*)\]/g;
+    SOURCE_REF = /^\[Image: source: [^\]]+\]$/;
+  }
+});
+
+// src/runtime/util.ts
+import os4 from "os";
 function nowSecs() {
   return Math.floor(Date.now() / 1e3);
 }
@@ -339,7 +531,7 @@ function statusFromAge(ageSecs) {
   return "done";
 }
 function hostname() {
-  return os3.hostname();
+  return os4.hostname();
 }
 function stripLeadingTags(input) {
   let rest = input.trimStart();
@@ -370,20 +562,6 @@ function extractTextFromContent(content) {
   const title = stripped.replace(/\n/g, " ").slice(0, 80).trim();
   return title.length ? title : null;
 }
-function extractAssistantText(content) {
-  const parts = [];
-  let hasTools = false;
-  if (Array.isArray(content)) {
-    for (const p of content) {
-      const t = p?.type;
-      if (t === "text" && typeof p.text === "string") parts.push(p.text);
-      else if (t === "tool_use" || t === "tool_result") hasTools = true;
-    }
-  } else if (typeof content === "string") {
-    parts.push(content);
-  }
-  return { text: parts.join(""), hasTools };
-}
 function parseIsoUnix(s) {
   const t = Date.parse(s);
   return Number.isNaN(t) ? null : Math.floor(t / 1e3);
@@ -395,13 +573,13 @@ var HOME;
 var init_util = __esm({
   "src/runtime/util.ts"() {
     "use strict";
-    HOME = os3.homedir();
+    HOME = os4.homedir();
   }
 });
 
 // src/runtime/claude.ts
 import fs3 from "fs";
-import path2 from "path";
+import path3 from "path";
 import { spawn as spawn2 } from "child_process";
 function* jsonlEntries(file) {
   let content;
@@ -441,7 +619,7 @@ function listSessions() {
   }
   for (const d of dirs) {
     if (!d.isDirectory()) continue;
-    const dir = path2.join(PROJECTS_DIR, d.name);
+    const dir = path3.join(PROJECTS_DIR, d.name);
     let files;
     try {
       files = fs3.readdirSync(dir);
@@ -450,7 +628,7 @@ function listSessions() {
     }
     for (const f of files) {
       if (!f.endsWith(".jsonl")) continue;
-      const p = path2.join(dir, f);
+      const p = path3.join(dir, f);
       let mtime;
       try {
         mtime = Math.floor(fs3.statSync(p).mtimeMs / 1e3);
@@ -479,53 +657,108 @@ function findFile(sessionId) {
     return null;
   }
   for (const d of dirs) {
-    const p = path2.join(PROJECTS_DIR, d, `${sessionId}.jsonl`);
+    const p = path3.join(PROJECTS_DIR, d, `${sessionId}.jsonl`);
     if (fs3.existsSync(p)) return p;
   }
   return null;
 }
-function readMessages(file) {
+function resultText(content) {
+  if (typeof content === "string") return 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")) {
   const msgs = [];
+  const tools = /* @__PURE__ */ new Map();
+  let current = null;
   let lastUserSecs = null;
   for (const entry of jsonlEntries(file)) {
     if (entry?.isSidechain === true) continue;
     const tsStr = entry?.timestamp ?? "";
     const tsSecs = parseIsoUnix(tsStr);
+    const raw = entry?.message?.content;
+    const blocks = Array.isArray(raw) ? raw : typeof raw === "string" ? [{ type: "text", text: raw }] : [];
     if (entry?.type === "user") {
-      if (entry?.userType !== "external") continue;
-      const text = extractTextFromContent(entry?.message?.content);
-      if (text) {
-        lastUserSecs = tsSecs;
-        msgs.push({
-          id: entry?.uuid ?? "",
-          role: "user",
-          content: text,
-          timestamp: tsStr,
-          hasToolUse: false
-        });
+      for (const b of blocks) {
+        if (b?.type !== "tool_result") continue;
+        const part = tools.get(b.tool_use_id);
+        if (!part) continue;
+        part.status = b.is_error ? "error" : "done";
+        const tur = entry?.toolUseResult;
+        const hunks = tur && typeof tur === "object" ? tur.structuredPatch : void 0;
+        if (Array.isArray(hunks) && hunks.length && typeof tur.filePath === "string") {
+          part.diff = diffFromHunks(tur.filePath, hunks);
+        }
+        if (!(part.diff && !b.is_error)) part.output = trimOutput(resultText(b.content));
       }
-    } else if (entry?.type === "assistant") {
-      const { text, hasTools } = extractAssistantText(entry?.message?.content);
-      if (!text) continue;
-      const u = entry?.message?.usage;
-      const total = (u?.input_tokens ?? 0) + (u?.cache_read_input_tokens ?? 0) + (u?.cache_creation_input_tokens ?? 0);
-      const elapsed = lastUserSecs != null && tsSecs != null ? Math.max(0, tsSecs - lastUserSecs) : void 0;
+      if (entry?.userType !== "external" || entry?.isMeta) continue;
+      const parts = [];
+      blocks.forEach((b, idx) => {
+        if (b?.type === "text" && typeof b.text === "string") {
+          parts.push(...userTextParts(stripLeadingTags(b.text)));
+        } else if (b?.type === "image" && b?.source?.type === "base64") {
+          parts.push({
+            type: "image",
+            url: `/blobs/claude/${encodeURIComponent(sessionId)}/${encodeURIComponent(entry.uuid)}/${idx}`,
+            mediaType: b.source.media_type
+          });
+        }
+      });
+      if (!parts.length) continue;
+      current = null;
+      lastUserSecs = tsSecs;
       msgs.push({
         id: entry?.uuid ?? "",
-        role: "assistant",
-        content: text,
+        role: "user",
+        content: textOf(parts),
         timestamp: tsStr,
-        hasToolUse: hasTools,
-        inputTokens: total > 0 ? total : void 0,
-        elapsedSecs: elapsed
+        hasToolUse: false,
+        parts
       });
+    } else if (entry?.type === "assistant") {
+      const fresh = [];
+      for (const b of blocks) {
+        if (b?.type === "text" && typeof b.text === "string" && b.text.trim()) {
+          fresh.push({ type: "text", text: b.text });
+        } else if (b?.type === "tool_use" && b.id) {
+          const part = toolPart(b.id, String(b.name ?? "tool"), b.input);
+          tools.set(b.id, part);
+          fresh.push(part);
+        }
+      }
+      if (!fresh.length) continue;
+      if (!current) {
+        current = { id: entry?.uuid ?? "", role: "assistant", content: "", timestamp: tsStr, parts: [] };
+        msgs.push(current);
+      }
+      current.parts.push(...fresh);
+      current.content = textOf(current.parts);
+      current.hasToolUse = current.parts.some((p) => p.type === "tool");
+      const u = entry?.message?.usage;
+      const total = (u?.input_tokens ?? 0) + (u?.cache_read_input_tokens ?? 0) + (u?.cache_creation_input_tokens ?? 0);
+      if (total > 0) current.inputTokens = total;
+      const model = entry?.message?.model;
+      if (typeof model === "string" && model !== "<synthetic>") current.model = model;
+      current.contextWindow = claudeContextWindow(current.model, current.inputTokens);
+      if (lastUserSecs != null && tsSecs != null) current.elapsedSecs = Math.max(0, tsSecs - lastUserSecs);
     }
   }
   return msgs;
 }
+function imageBlock(sessionId, uuid, idx) {
+  const file = findFile(sessionId);
+  if (!file) return null;
+  for (const entry of jsonlEntries(file)) {
+    if (entry?.uuid !== uuid) continue;
+    const b = entry?.message?.content?.[idx];
+    if (b?.type !== "image" || b?.source?.type !== "base64") return null;
+    return { mediaType: String(b.source.media_type ?? "image/png"), data: Buffer.from(String(b.source.data), "base64") };
+  }
+  return null;
+}
 function messages(sessionId) {
   const file = findFile(sessionId);
-  return file ? readMessages(file) : [];
+  return file ? readMessages(file, sessionId) : [];
 }
 function sessionCwd(sessionId) {
   const file = findFile(sessionId);
@@ -608,14 +841,15 @@ var PROJECTS_DIR;
 var init_claude = __esm({
   "src/runtime/claude.ts"() {
     "use strict";
+    init_parts();
     init_util();
-    PROJECTS_DIR = path2.join(HOME, ".claude", "projects");
+    PROJECTS_DIR = path3.join(HOME, ".claude", "projects");
   }
 });
 
 // src/runtime/codex.ts
 import fs4 from "fs";
-import path3 from "path";
+import path4 from "path";
 import { spawn as spawn3 } from "child_process";
 function codexBin() {
   if (process.env.CODEX_BIN) return process.env.CODEX_BIN;
@@ -660,7 +894,7 @@ function listSessions2() {
   return out;
 }
 function findFile2(sessionId) {
-  const walk = (dir) => {
+  const walk2 = (dir) => {
     let entries;
     try {
       entries = fs4.readdirSync(dir, { withFileTypes: true });
@@ -668,9 +902,9 @@ function findFile2(sessionId) {
       return null;
     }
     for (const e of entries) {
-      const p = path3.join(dir, e.name);
+      const p = path4.join(dir, e.name);
       if (e.isDirectory()) {
-        const found = walk(p);
+        const found = walk2(p);
         if (found) return found;
       } else if (e.name.endsWith(".jsonl") && e.name.includes(sessionId)) {
         return p;
@@ -678,7 +912,23 @@ function findFile2(sessionId) {
     }
     return null;
   };
-  return walk(SESSIONS_DIR);
+  return walk2(SESSIONS_DIR);
+}
+function outputText(out) {
+  if (typeof out === "string") return out;
+  if (!Array.isArray(out)) return "";
+  return out.map((b) => typeof b?.text === "string" ? b.text : "").join("\n");
+}
+function execInput(name, input) {
+  if (typeof input !== "string") return { name, input };
+  const m = input.match(/exec_command\(\{\s*cmd\s*:\s*("(?:[^"\\]|\\.)*")/);
+  if (m) {
+    try {
+      return { name: "Bash", input: { command: JSON.parse(m[1]) } };
+    } catch {
+    }
+  }
+  return { name, input };
 }
 function readMessages2(file) {
   let content;
@@ -688,7 +938,18 @@ function readMessages2(file) {
     return [];
   }
   const msgs = [];
+  const tools = /* @__PURE__ */ new Map();
+  let current = null;
   let lastUserSecs = null;
+  const ensureAssistant = (ts) => {
+    if (!current) {
+      current = { id: ts, role: "assistant", content: "", timestamp: ts, parts: [], model, contextWindow };
+      msgs.push(current);
+    }
+    return current;
+  };
+  let model;
+  let contextWindow;
   for (const line of content.split("\n")) {
     if (!line.trim()) continue;
     let entry;
@@ -697,27 +958,60 @@ function readMessages2(file) {
     } catch {
       continue;
     }
+    const p = entry?.payload;
+    if (entry?.type === "turn_context" && typeof p?.model === "string") model = p.model;
+    if (entry?.type === "event_msg") {
+      if (p?.type === "task_started" && typeof p.model_context_window === "number") contextWindow = p.model_context_window;
+      const cur = current;
+      if (p?.type === "token_count" && cur) {
+        const u = p.info?.last_token_usage;
+        if (u?.input_tokens) cur.inputTokens = u.input_tokens;
+        if (typeof p.info?.model_context_window === "number") contextWindow = p.info.model_context_window;
+        cur.contextWindow = contextWindow;
+      }
+      if (p?.type === "thread_settings_applied" && typeof p.thread_settings?.model === "string") model = p.thread_settings.model;
+    }
     if (entry?.type !== "response_item") continue;
     const payload = entry?.payload;
-    if (payload?.type !== "message") continue;
-    const role = payload?.role;
-    if (role !== "user" && role !== "assistant") continue;
-    const part = Array.isArray(payload?.content) ? payload.content.find(
-      (p) => ["input_text", "output_text", "text"].includes(p?.type)
-    ) : null;
-    const text = part?.text ?? "";
-    if (!text) continue;
     const ts = entry?.timestamp ?? "";
     const tsSecs = parseIsoUnix(ts);
-    if (role === "user") lastUserSecs = tsSecs;
-    msgs.push({
-      id: ts,
-      role,
-      content: text,
-      timestamp: ts,
-      hasToolUse: false,
-      elapsedSecs: role === "assistant" && lastUserSecs != null && tsSecs != null ? Math.max(0, tsSecs - lastUserSecs) : void 0
-    });
+    const kind = payload?.type;
+    if (kind === "function_call" || kind === "custom_tool_call" || kind === "local_shell_call") {
+      const raw = kind === "function_call" ? payload.arguments : kind === "custom_tool_call" ? payload.input : payload.action;
+      const { name, input } = execInput(String(payload.name ?? "shell"), raw);
+      const part = toolPart(String(payload.call_id ?? ts), name, input);
+      tools.set(part.id, part);
+      const msg2 = ensureAssistant(ts);
+      msg2.parts.push(part);
+      msg2.hasToolUse = true;
+      continue;
+    }
+    if (kind === "function_call_output" || kind === "custom_tool_call_output") {
+      const part = tools.get(String(payload.call_id));
+      if (part) {
+        const text2 = outputText(payload.output);
+        part.status = /exit code [1-9]|"exit_code":\s*[1-9]/i.test(text2) ? "error" : "done";
+        part.output = trimOutput(text2);
+      }
+      continue;
+    }
+    if (kind !== "message") continue;
+    const role = payload?.role;
+    if (role !== "user" && role !== "assistant") continue;
+    const text = Array.isArray(payload?.content) ? payload.content.filter((p2) => ["input_text", "output_text", "text"].includes(p2?.type) && typeof p2.text === "string").map((p2) => p2.text).join("\n\n") : "";
+    if (!text.trim()) continue;
+    if (role === "user" && /^\s*<(environment_context|user_instructions|app-context|permissions)/.test(text)) continue;
+    if (role === "user") {
+      current = null;
+      lastUserSecs = tsSecs;
+      const parts = userTextParts(text);
+      msgs.push({ id: ts, role, content: textOf(parts), timestamp: ts, hasToolUse: false, parts });
+      continue;
+    }
+    const msg = ensureAssistant(ts);
+    msg.parts.push({ type: "text", text });
+    msg.content = textOf(msg.parts);
+    if (lastUserSecs != null && tsSecs != null) msg.elapsedSecs = Math.max(0, tsSecs - lastUserSecs);
   }
   return msgs;
 }
@@ -755,21 +1049,156 @@ var CODEX_DIR, INDEX_PATH, SESSIONS_DIR, MAC_APP_BIN;
 var init_codex = __esm({
   "src/runtime/codex.ts"() {
     "use strict";
+    init_parts();
     init_util();
-    CODEX_DIR = path3.join(HOME, ".codex");
-    INDEX_PATH = path3.join(CODEX_DIR, "session_index.jsonl");
-    SESSIONS_DIR = path3.join(CODEX_DIR, "sessions");
+    CODEX_DIR = path4.join(HOME, ".codex");
+    INDEX_PATH = path4.join(CODEX_DIR, "session_index.jsonl");
+    SESSIONS_DIR = path4.join(CODEX_DIR, "sessions");
     MAC_APP_BIN = "/Applications/Codex.app/Contents/Resources/codex";
   }
 });
 
-// src/runtime/opencode.ts
-import path4 from "path";
+// src/runtime/sqlite-transcript.ts
 import fs5 from "fs";
+function unifiedLines(diff) {
+  return diff.split("\n").filter((l) => !/^(---|\+\+\+|diff |index |Index: |=+$)/.test(l)).map((l) => l.startsWith("@@") ? "@@" : l);
+}
+function partToMessagePart(agent, sessionId, partId, v) {
+  if (v?.type === "text" && typeof v.text === "string" && v.text.trim() && !v.synthetic) {
+    return { type: "text", text: v.text };
+  }
+  if (v?.type === "file" && typeof v.mime === "string" && v.mime.startsWith("image/")) {
+    return {
+      type: "image",
+      url: `/blobs/${agent}/${encodeURIComponent(sessionId)}/${encodeURIComponent(partId)}`,
+      mediaType: v.mime
+    };
+  }
+  if (v?.type === "tool" && typeof v.tool === "string") {
+    const st = v.state ?? {};
+    const part = toolPart(String(v.callID ?? partId), v.tool, st.input);
+    part.status = st.status === "completed" ? "done" : st.status === "error" ? "error" : "running";
+    const md = typeof st.metadata?.diff === "string" ? st.metadata.diff : null;
+    if (md && part.diff) {
+      const lines2 = unifiedLines(md);
+      part.diff = {
+        ...part.diff,
+        lines: lines2.slice(0, 300),
+        added: lines2.filter((l) => l.startsWith("+")).length,
+        removed: lines2.filter((l) => l.startsWith("-")).length
+      };
+    }
+    if (!(part.diff && part.status === "done")) part.output = trimOutput(st.error ?? st.output);
+    return part;
+  }
+  return null;
+}
+function buildMessages(db, agent, sessionId) {
+  const msgRows = db.prepare("SELECT id, time_created, data FROM message WHERE session_id = ? ORDER BY time_created ASC").all(sessionId);
+  const partRows = db.prepare("SELECT id, message_id, data FROM part WHERE session_id = ? ORDER BY time_created ASC, id ASC").all(sessionId);
+  const partsMap = /* @__PURE__ */ new Map();
+  const tokensMap = /* @__PURE__ */ new Map();
+  for (const p of partRows) {
+    let v;
+    try {
+      v = JSON.parse(p.data);
+    } catch {
+      continue;
+    }
+    if (v?.type === "step-finish") {
+      const t = v.tokens ?? {};
+      const ctx = (t.input ?? 0) + (t.cache?.read ?? 0) + (t.cache?.write ?? 0);
+      if (ctx > 0) tokensMap.set(p.message_id, ctx);
+      continue;
+    }
+    const mp = partToMessagePart(agent, sessionId, p.id, v);
+    if (!mp) continue;
+    const arr = partsMap.get(p.message_id) ?? [];
+    arr.push(mp);
+    partsMap.set(p.message_id, arr);
+  }
+  const out = [];
+  let current = null;
+  let lastUserMs = null;
+  for (const m of msgRows) {
+    let v;
+    try {
+      v = JSON.parse(m.data);
+    } catch {
+      continue;
+    }
+    const role = v?.role;
+    if (role !== "user" && role !== "assistant") continue;
+    const parts = partsMap.get(m.id) ?? [];
+    if (!parts.length) continue;
+    if (role === "user") {
+      current = null;
+      lastUserMs = m.time_created;
+      out.push({
+        id: m.id,
+        role,
+        content: textOf(parts),
+        timestamp: chronoIso(Math.floor(m.time_created / 1e3)),
+        hasToolUse: false,
+        parts
+      });
+      continue;
+    }
+    if (!current) {
+      current = {
+        id: m.id,
+        role: "assistant",
+        content: "",
+        timestamp: chronoIso(Math.floor(m.time_created / 1e3)),
+        parts: []
+      };
+      out.push(current);
+    }
+    current.parts.push(...parts);
+    current.content = textOf(current.parts);
+    current.hasToolUse = current.parts.some((p) => p.type === "tool");
+    const ctx = tokensMap.get(m.id);
+    if (ctx) current.inputTokens = ctx;
+    const model = v?.modelID ?? v?.model?.modelID;
+    if (typeof model === "string" && model) current.model = model;
+    if (agent === "zcode") current.contextWindow = 1e6;
+    if (lastUserMs != null) current.elapsedSecs = Math.max(0, Math.floor((m.time_created - lastUserMs) / 1e3));
+  }
+  return out;
+}
+function filePartImage(db, sessionId, partId) {
+  const row = db.prepare("SELECT data FROM part WHERE id = ? AND session_id = ? LIMIT 1").get(partId, sessionId);
+  if (!row) return null;
+  let v;
+  try {
+    v = JSON.parse(row.data);
+  } catch {
+    return null;
+  }
+  if (v?.type !== "file" || typeof v.mime !== "string" || !v.mime.startsWith("image/")) return null;
+  const m = typeof v.url === "string" ? v.url.match(/^data:([^;]+);base64,(.*)$/s) : null;
+  if (m) return { mediaType: m[1], data: Buffer.from(m[2], "base64") };
+  const p = v.source?.path;
+  if (typeof p === "string" && fs5.existsSync(p) && fs5.statSync(p).isFile()) {
+    return { mediaType: v.mime, data: fs5.readFileSync(p) };
+  }
+  return null;
+}
+var init_sqlite_transcript = __esm({
+  "src/runtime/sqlite-transcript.ts"() {
+    "use strict";
+    init_util();
+    init_parts();
+  }
+});
+
+// src/runtime/opencode.ts
+import path5 from "path";
+import fs6 from "fs";
 import { spawn as spawn4 } from "child_process";
 function opencodeBin() {
   if (process.env.OPENCODE_BIN) return process.env.OPENCODE_BIN;
-  if (fs5.existsSync(MAC_APP_BIN2)) return MAC_APP_BIN2;
+  if (fs6.existsSync(MAC_APP_BIN2)) return MAC_APP_BIN2;
   return "opencode";
 }
 async function loadDriver() {
@@ -783,7 +1212,7 @@ async function loadDriver() {
   return _ctor ?? null;
 }
 function available() {
-  return fs5.existsSync(DB_PATH);
+  return fs6.existsSync(DB_PATH);
 }
 async function open() {
   if (!available()) return null;
@@ -825,103 +1254,493 @@ async function messages3(sessionId) {
   const db = await open();
   if (!db) return [];
   try {
-    const msgRows = db.prepare(
-      "SELECT id, time_created, data FROM message WHERE session_id = ? ORDER BY time_created ASC"
-    ).all(sessionId);
-    const partRows = db.prepare(
-      "SELECT message_id, data FROM part WHERE session_id = ? ORDER BY time_created ASC"
-    ).all(sessionId);
-    const partsMap = /* @__PURE__ */ new Map();
-    for (const p of partRows) {
-      try {
-        const v = JSON.parse(p.data);
-        if (v?.type === "text" && typeof v.text === "string") {
-          const arr = partsMap.get(p.message_id) ?? [];
-          arr.push(v.text);
-          partsMap.set(p.message_id, arr);
+    return buildMessages(db, "opencode", sessionId);
+  } finally {
+    db.close();
+  }
+}
+async function image(sessionId, partId) {
+  const db = await open();
+  if (!db) return null;
+  try {
+    return filePartImage(db, sessionId, partId);
+  } catch {
+    return null;
+  } finally {
+    db.close();
+  }
+}
+function send3(sessionId, message, onData, images, model) {
+  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], {
+      stdio: ["ignore", "pipe", "pipe"],
+      env: process.env
+    });
+    let out = "";
+    let err = "";
+    child2.stdout.on("data", (d) => {
+      out += d.toString();
+      onData?.(d.toString());
+    });
+    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}`
+      })
+    );
+  });
+}
+var DB_PATH, MAC_APP_BIN2, _ctor;
+var init_opencode = __esm({
+  "src/runtime/opencode.ts"() {
+    "use strict";
+    init_sqlite_transcript();
+    init_util();
+    DB_PATH = path5.join(HOME, ".local", "share", "opencode", "opencode.db");
+    MAC_APP_BIN2 = "/Applications/OpenCode.app/Contents/MacOS/opencode-cli";
+  }
+});
+
+// src/runtime/zcode.ts
+import path6 from "path";
+import fs7 from "fs";
+import { spawn as spawn5 } from "child_process";
+function launchArgs(args) {
+  if (process.env.ZCODE_BIN) return { cmd: process.env.ZCODE_BIN, args };
+  if (fs7.existsSync(MAC_APP_CJS)) return { cmd: process.execPath, args: [MAC_APP_CJS, ...args] };
+  return { cmd: "zcode", args };
+}
+function cliEnv() {
+  if (process.env.ZCODE_API_KEY || process.env.ZAI_API_KEY) return process.env;
+  try {
+    const cfg = JSON.parse(fs7.readFileSync(DESKTOP_CONFIG, "utf8"));
+    const zai = cfg?.provider?.["builtin:zai"];
+    const key = zai?.enabled !== false ? zai?.options?.apiKey : void 0;
+    if (typeof key === "string" && key) return { ...process.env, ZCODE_API_KEY: key };
+  } catch {
+  }
+  return process.env;
+}
+function configuredModel() {
+  try {
+    const cfg = JSON.parse(fs7.readFileSync(path6.join(HOME, ".zcode", "cli", "config.json"), "utf8"));
+    return typeof cfg?.model === "string" ? cfg.model : null;
+  } catch {
+    return null;
+  }
+}
+async function loadDriver2() {
+  if (_ctor2 !== void 0) return _ctor2;
+  try {
+    const mod = await import("better-sqlite3");
+    _ctor2 = mod.default ?? mod;
+  } catch {
+    _ctor2 = null;
+  }
+  return _ctor2 ?? null;
+}
+function available2() {
+  return fs7.existsSync(DB_PATH2);
+}
+async function open2() {
+  if (!available2()) return null;
+  const Ctor = await loadDriver2();
+  if (!Ctor) return null;
+  try {
+    return new Ctor(DB_PATH2, { readonly: true, fileMustExist: true });
+  } catch {
+    return null;
+  }
+}
+async function listSessions4() {
+  const db = await open2();
+  if (!db) return [];
+  const host = hostname();
+  const now = nowSecs();
+  try {
+    const rows = db.prepare(
+      "SELECT id, title, time_updated FROM session WHERE time_archived IS NULL ORDER BY time_updated DESC"
+    ).all();
+    return rows.map((r) => {
+      const mtime = Math.floor(r.time_updated / 1e3);
+      const age = Math.max(0, now - mtime);
+      return {
+        id: r.id,
+        title: r.title,
+        agent: "zcode",
+        status: statusFromAge(age),
+        updatedAt: formatAge(age),
+        machine: host,
+        mtime
+      };
+    });
+  } finally {
+    db.close();
+  }
+}
+async function hasSession(sessionId) {
+  const db = await open2();
+  if (!db) return false;
+  try {
+    const row = db.prepare("SELECT id FROM session WHERE id = ? LIMIT 1").get(sessionId);
+    return !!row;
+  } catch {
+    return false;
+  } finally {
+    db.close();
+  }
+}
+async function sessionDir(sessionId) {
+  const db = await open2();
+  if (!db) return null;
+  try {
+    const row = db.prepare("SELECT directory FROM session WHERE id = ? LIMIT 1").get(sessionId);
+    return row?.directory ?? null;
+  } catch {
+    return null;
+  } finally {
+    db.close();
+  }
+}
+async function messages4(sessionId) {
+  const db = await open2();
+  if (!db) return [];
+  try {
+    return buildMessages(db, "zcode", sessionId);
+  } finally {
+    db.close();
+  }
+}
+async function image2(sessionId, partId) {
+  const db = await open2();
+  if (!db) return null;
+  try {
+    return filePartImage(db, sessionId, partId);
+  } catch {
+    return null;
+  } finally {
+    db.close();
+  }
+}
+function send4(sessionId, message, onData, images, _model) {
+  return new Promise(async (resolve) => {
+    const args = ["--resume", sessionId];
+    const dir = 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);
+    const { cmd, args: argv } = launchArgs(args);
+    const child2 = spawn5(cmd, argv, {
+      stdio: ["ignore", "pipe", "pipe"],
+      env: cliEnv()
+    });
+    let buf = "";
+    let streamed = "";
+    let response = null;
+    let failure = null;
+    let err = "";
+    child2.stdout.on("data", (d) => {
+      buf += d.toString();
+      let nl;
+      while ((nl = buf.indexOf("\n")) >= 0) {
+        const line = buf.slice(0, nl);
+        buf = buf.slice(nl + 1);
+        if (!line.trim()) continue;
+        let ev;
+        try {
+          ev = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        const p = ev?.payload;
+        if (ev?.type === "model.streaming" && p?.kind === "text_start" && streamed) {
+          streamed += "\n\n";
+          onData?.("\n\n");
+        } else if (ev?.type === "model.streaming" && p?.kind === "text_delta" && typeof p.delta === "string") {
+          streamed += p.delta;
+          onData?.(p.delta);
+        } else if (ev?.type === "turn.failed") {
+          failure = p?.error?.message ?? "Turn failed";
+        } else if (ev?.type === "result" && typeof ev.response === "string") {
+          response = ev.response;
         }
-      } catch {
       }
+    });
+    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 && !failure,
+        output: (response ?? streamed).trim(),
+        error: code === 0 && !failure ? void 0 : failure || err.trim() || `exited ${code}`
+      })
+    );
+  });
+}
+var DB_PATH2, MAC_APP_CJS, DESKTOP_CONFIG, _ctor2;
+var init_zcode = __esm({
+  "src/runtime/zcode.ts"() {
+    "use strict";
+    init_sqlite_transcript();
+    init_util();
+    DB_PATH2 = path6.join(HOME, ".zcode", "cli", "db", "db.sqlite");
+    MAC_APP_CJS = "/Applications/ZCode.app/Contents/Resources/glm/zcode.cjs";
+    DESKTOP_CONFIG = path6.join(HOME, ".zcode", "v2", "config.json");
+  }
+});
+
+// src/runtime/deepseek.ts
+import path7 from "path";
+import fs8 from "fs";
+import zlib from "zlib";
+import { spawn as spawn6 } from "child_process";
+function dshBin() {
+  if (process.env.DSH_BIN) return process.env.DSH_BIN;
+  if (fs8.existsSync(MAC_APP_BIN3)) return MAC_APP_BIN3;
+  return "dsh";
+}
+function available3() {
+  return fs8.existsSync(SESSIONS_DIR2);
+}
+function zstdSupported() {
+  return typeof zlib.zstdDecompressSync === "function";
+}
+function decompress(file) {
+  if (!zstdSupported()) return null;
+  try {
+    return zlib.zstdDecompressSync(fs8.readFileSync(file)).toString("utf8");
+  } catch {
+    return null;
+  }
+}
+function parseSessionFile(file) {
+  const raw = decompress(file);
+  if (!raw) return null;
+  const events = [];
+  let header = null;
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const v = JSON.parse(line);
+      if (v?.type === "session" && !header) header = v;
+      else if (v?.type) events.push(v);
+    } catch {
+    }
+  }
+  return header ? { header, events } : null;
+}
+function allSessionFiles() {
+  const out = [];
+  if (!available3()) return out;
+  let buckets = [];
+  try {
+    buckets = fs8.readdirSync(SESSIONS_DIR2).filter((b) => !b.startsWith("."));
+  } catch {
+    return out;
+  }
+  for (const bucket of buckets) {
+    const dir = path7.join(SESSIONS_DIR2, bucket);
+    let entries = [];
+    try {
+      entries = fs8.readdirSync(dir);
+    } catch {
+      continue;
     }
-    const out = [];
-    let lastUserMs = null;
-    for (const m of msgRows) {
-      let v;
+    for (const e of entries) {
+      if (!e.startsWith("session-")) continue;
+      const file = path7.join(dir, e, "session.v4.jsonl.zstd");
+      let stat;
       try {
-        v = JSON.parse(m.data);
+        stat = fs8.statSync(file);
       } catch {
         continue;
       }
-      const role = v?.role;
-      if (role !== "user" && role !== "assistant") continue;
-      const text = (partsMap.get(m.id) ?? []).join("");
-      if (!text) continue;
-      const mtime = Math.floor(m.time_created / 1e3);
-      if (role === "user") lastUserMs = m.time_created;
-      out.push({
-        id: m.id,
-        role,
-        content: text,
-        timestamp: chronoIso(mtime),
-        hasToolUse: false,
-        // Per-turn duration: assistant time − the user msg that started it.
-        elapsedSecs: role === "assistant" && lastUserMs != null ? Math.max(0, Math.floor((m.time_created - lastUserMs) / 1e3)) : void 0
-      });
+      const parsed = parseSessionFile(file);
+      if (!parsed) continue;
+      out.push({ file, header: parsed.header, events: parsed.events, stat });
     }
-    return out;
-  } finally {
-    db.close();
   }
+  out.sort((a, b) => b.stat.mtimeMs - a.stat.mtimeMs);
+  return out;
 }
-function send3(sessionId, message, onData, images, model) {
+function resolveTitle(id, events) {
+  try {
+    const cacheFile = path7.join(PROJ_CACHE_DIR, `${id}.json`);
+    const cache = JSON.parse(fs8.readFileSync(cacheFile, "utf8"));
+    const t = cache?.rows?.title?.val;
+    if (typeof t === "string" && t.trim()) return t.trim();
+  } catch {
+  }
+  const firstUser = events.find(
+    (e) => e.type === "user/message" && textOf2(e)?.trim()
+  );
+  if (firstUser) {
+    const t = textOf2(firstUser).trim().replace(/\s+/g, " ");
+    return t.length > 60 ? `${t.slice(0, 57)}\u2026` : t;
+  }
+  return "DeepSeek task";
+}
+function textOf2(event) {
+  const blocks = event?.data?.content;
+  if (!Array.isArray(blocks)) return null;
+  return blocks.filter((b) => b?.type === "text" && typeof b.text === "string").map((b) => b.text).join("");
+}
+async function listSessions5() {
+  if (!available3()) return [];
+  const host = hostname();
+  const now = nowSecs();
+  return allSessionFiles().map(({ header, events, stat }) => {
+    const mtime = Math.floor(stat.mtimeMs / 1e3);
+    const age = Math.max(0, now - mtime);
+    return {
+      id: header.id,
+      title: resolveTitle(header.id, events),
+      agent: "deepseek",
+      status: statusFromAge(age),
+      updatedAt: formatAge(age),
+      machine: host,
+      mtime
+    };
+  });
+}
+function findFile3(sessionId) {
+  if (!sessionId.startsWith("session-") || sessionId.includes("/")) return null;
+  let buckets = [];
+  try {
+    buckets = fs8.readdirSync(SESSIONS_DIR2);
+  } catch {
+    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;
+  }
+  return null;
+}
+async function messages5(sessionId) {
+  const file = findFile3(sessionId);
+  if (!file) return [];
+  const parsed = parseSessionFile(file);
+  if (!parsed) return [];
+  const createdAtMs = parsed.header.createdAt ?? Date.now();
+  const out = [];
+  let lastUserMs = null;
+  let i = 0;
+  for (const e of parsed.events) {
+    if (e.type !== "user/message" && e.type !== "assistant/message") continue;
+    if (e.type === "user/message" && e.data?.source?.kind === "agent-instructions") continue;
+    const text = textOf2(e);
+    if (!text || !text.trim()) continue;
+    const role = e.type === "user/message" ? "user" : "assistant";
+    const tsMs = e?.data?.time?.created ?? e?.data?.createdAt ?? createdAtMs;
+    if (role === "user") lastUserMs = tsMs;
+    out.push({
+      id: String(e.seq ?? `${role}-${i++}`),
+      role,
+      content: text,
+      timestamp: chronoIso(Math.floor(tsMs / 1e3)),
+      hasToolUse: false,
+      elapsedSecs: role === "assistant" && lastUserMs != null ? Math.max(0, Math.floor((tsMs - lastUserMs) / 1e3)) : void 0
+    });
+  }
+  return out;
+}
+function send5(sessionId, message, onData, images, _model) {
   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], {
-      stdio: ["ignore", "pipe", "pipe"],
+    const file = findFile3(sessionId);
+    let cwd;
+    if (file) {
+      const parsed = parseSessionFile(file);
+      const dir = parsed?.header?.cwd;
+      if (dir && fs8.existsSync(dir)) cwd = dir;
+    }
+    let prompt = message;
+    if (images?.length) {
+      const refs = images.map((p) => `[Image: ${p}]`).join("\n");
+      prompt = prompt ? `${prompt}
+
+${refs}` : refs;
+    }
+    const child2 = spawn6(dshBin(), ["headless", "--json", "--session-id", sessionId, "-"], {
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"],
       env: process.env
     });
-    let out = "";
+    child2.stdin.end(prompt);
+    let buf = "";
+    let streamed = "";
+    let finalText = null;
+    let failure = null;
     let err = "";
     child2.stdout.on("data", (d) => {
-      out += d.toString();
-      onData?.(d.toString());
+      buf += d.toString();
+      let nl;
+      while ((nl = buf.indexOf("\n")) >= 0) {
+        const line = buf.slice(0, nl);
+        buf = buf.slice(nl + 1);
+        if (!line.trim()) continue;
+        let ev;
+        try {
+          ev = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (ev?.type === "text" && typeof ev.text === "string" && ev.text) {
+          const chunk = streamed ? `
+
+${ev.text}` : ev.text;
+          streamed += chunk;
+          onData?.(chunk);
+        } else if (ev?.type === "status" && ev.phase === "turn_end" && ev.reason?.kind === "error") {
+          failure = ev.reason.error?.message ?? "Turn failed";
+        } else if (ev?.type === "final" && typeof ev.text === "string") {
+          finalText = ev.text;
+        }
+      }
     });
     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}`
+        ok: code === 0 && !failure,
+        output: (finalText || streamed).trim(),
+        error: code === 0 && !failure ? void 0 : failure || err.trim() || `exited ${code}`
       })
     );
   });
 }
-var DB_PATH, MAC_APP_BIN2, _ctor;
-var init_opencode = __esm({
-  "src/runtime/opencode.ts"() {
+var SESSIONS_DIR2, PROJ_CACHE_DIR, MAC_APP_BIN3;
+var init_deepseek = __esm({
+  "src/runtime/deepseek.ts"() {
     "use strict";
     init_util();
-    DB_PATH = path4.join(HOME, ".local", "share", "opencode", "opencode.db");
-    MAC_APP_BIN2 = "/Applications/OpenCode.app/Contents/MacOS/opencode-cli";
+    SESSIONS_DIR2 = path7.join(HOME, ".dsh", "sessions");
+    PROJ_CACHE_DIR = path7.join(HOME, ".dsh", "storages", "session_projcache", "sessions");
+    MAC_APP_BIN3 = "/Applications/DeepSeek Harness.app/Contents/Resources/runtime/cli/bin/dsh";
   }
 });
 
 // src/runtime/meta.ts
-import fs6 from "fs";
-import path5 from "path";
+import fs9 from "fs";
+import path8 from "path";
 function read() {
   try {
-    return JSON.parse(fs6.readFileSync(META_PATH, "utf8"));
+    return JSON.parse(fs9.readFileSync(META_PATH, "utf8"));
   } catch {
     return {};
   }
 }
 function write2(store) {
-  fs6.mkdirSync(path5.dirname(META_PATH), { recursive: true });
-  fs6.writeFileSync(META_PATH, JSON.stringify(store, null, 2) + "\n", { mode: 384 });
+  fs9.mkdirSync(path8.dirname(META_PATH), { recursive: true });
+  fs9.writeFileSync(META_PATH, JSON.stringify(store, null, 2) + "\n", { mode: 384 });
 }
 function all() {
   return read();
@@ -942,18 +1761,22 @@ var init_meta = __esm({
   "src/runtime/meta.ts"() {
     "use strict";
     init_config();
-    META_PATH = path5.join(SAKURA_DIR, "session-meta.json");
+    META_PATH = path8.join(SAKURA_DIR, "session-meta.json");
   }
 });
 
 // src/runtime/sessions.ts
-import { spawn as spawn5 } from "child_process";
+import { spawn as spawn7 } from "child_process";
 async function list(opts = {}) {
   let sessions = [];
   if (!opts.agent || opts.agent === "claude") sessions.push(...listSessions());
   if (!opts.agent || opts.agent === "codex") sessions.push(...listSessions2());
   if (!opts.agent || opts.agent === "opencode")
     sessions.push(...await listSessions3());
+  if (!opts.agent || opts.agent === "zcode")
+    sessions.push(...await listSessions4());
+  if (!opts.agent || opts.agent === "deepseek")
+    sessions.push(...await listSessions5());
   sessions.sort((a, b) => b.mtime - a.mtime);
   const overrides = all();
   sessions = sessions.map((s) => {
@@ -981,11 +1804,13 @@ async function show(sessionId) {
 async function detectAgent(sessionId) {
   if (findFile(sessionId)) return "claude";
   if (findFile2(sessionId)) return "codex";
+  if (sessionId.startsWith("session-") && findFile3(sessionId)) return "deepseek";
+  if (await hasSession(sessionId)) return "zcode";
   const oc = await messages3(sessionId);
   if (oc.length) return "opencode";
   return null;
 }
-async function messages4(sessionId, agent) {
+async function messages6(sessionId, agent) {
   const a = agent ?? await detectAgent(sessionId);
   switch (a) {
     case "claude":
@@ -994,12 +1819,16 @@ async function messages4(sessionId, agent) {
       return messages2(sessionId);
     case "opencode":
       return messages3(sessionId);
+    case "zcode":
+      return messages4(sessionId);
+    case "deepseek":
+      return messages5(sessionId);
     default:
       return [];
   }
 }
 async function history(sessionId, opts = {}, agent) {
-  let msgs = await messages4(sessionId, agent);
+  let msgs = await messages6(sessionId, agent);
   if (!opts.all && opts.limit && opts.limit > 0) {
     msgs = msgs.slice(-opts.limit);
   }
@@ -1011,6 +1840,8 @@ async function chat(sessionId, prompt, agent, onData, images, model) {
   if (a === "claude") return send(sessionId, prompt, onData, images, model);
   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);
   return {
     ok: false,
     output: "",
@@ -1019,18 +1850,25 @@ async function chat(sessionId, prompt, agent, onData, images, model) {
 }
 function create(prompt, opts = {}) {
   const agent = opts.agent ?? "claude";
-  if (agent !== "claude") {
-    return Promise.resolve({
-      ok: false,
-      output: "",
-      error: `Creating sessions from the CLI is only supported for Claude (got ${agent}).`
-    });
+  if (agent === "claude") return runCreate(process.env.CLAUDE_BIN || "claude", ["-p", prompt], opts.cwd);
+  if (agent === "zcode") {
+    const { cmd, args } = launchArgs(["--prompt", prompt]);
+    return runCreate(cmd, args, opts.cwd, cliEnv());
   }
+  if (agent === "deepseek")
+    return runCreate(dshBin(), ["headless", prompt], opts.cwd);
+  return Promise.resolve({
+    ok: false,
+    output: "",
+    error: `Creating sessions from the CLI is only supported for Claude, ZCode and DeepSeek (got ${agent}).`
+  });
+}
+function runCreate(cmd, args, cwd, env = process.env) {
   return new Promise((resolve) => {
-    const bin = process.env.CLAUDE_BIN || "claude";
-    const child2 = spawn5(bin, ["-p", prompt], {
-      cwd: opts.cwd || process.cwd(),
-      stdio: ["ignore", "pipe", "pipe"]
+    const child2 = spawn7(cmd, args, {
+      cwd: cwd || process.cwd(),
+      stdio: ["ignore", "pipe", "pipe"],
+      env
     });
     let out = "";
     let err = "";
@@ -1053,6 +1891,8 @@ var init_sessions = __esm({
     init_claude();
     init_codex();
     init_opencode();
+    init_zcode();
+    init_deepseek();
     init_meta();
   }
 });
@@ -1067,12 +1907,12 @@ function addPushToken(token) {
 async function sendPush(title, body, data = {}) {
   const tokens = loadConfig().pushTokens ?? [];
   if (tokens.length === 0) return;
-  const messages5 = tokens.map((to) => ({ to, title, body, sound: "default", data }));
+  const messages7 = 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(messages5)
+      body: JSON.stringify(messages7)
     });
     if (!res.ok) console.error(`[push] send failed: HTTP ${res.status}`);
   } catch (e) {
@@ -1146,9 +1986,9 @@ __export(registry_exports, {
   thisMachine: () => thisMachine,
   updateAgentConfig: () => updateAgentConfig
 });
-import os4 from "os";
-import fs7 from "fs";
-import path6 from "path";
+import os5 from "os";
+import fs10 from "fs";
+import path9 from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 function listWorkspaces() {
   return loadConfig().workspaces;
@@ -1158,24 +1998,28 @@ function detectCli() {
   const candidates = {
     claude: process.env.CLAUDE_BIN || "claude",
     codex: process.env.CODEX_BIN || "codex",
-    opencode: process.env.OPENCODE_BIN || "opencode"
+    opencode: process.env.OPENCODE_BIN || "opencode",
+    zcode: process.env.ZCODE_BIN || "zcode",
+    deepseek: process.env.DSH_BIN || "dsh"
   };
-  const pathDirs = (process.env.PATH || "").split(path6.delimiter);
+  const pathDirs = (process.env.PATH || "").split(path9.delimiter);
   for (const [name, bin] of Object.entries(candidates)) {
     const onPath = pathDirs.some((dir) => {
       try {
-        return fs7.existsSync(path6.join(dir, bin));
+        return fs10.existsSync(path9.join(dir, bin));
       } catch {
         return false;
       }
     });
-    const home = os4.homedir();
+    const home = os5.homedir();
     const dataDirs = {
-      claude: path6.join(home, ".claude"),
-      codex: path6.join(home, ".codex"),
-      opencode: path6.join(home, ".local", "share", "opencode")
+      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")
     };
-    if (onPath || fs7.existsSync(dataDirs[name] ?? "")) found.push(name);
+    if (onPath || fs10.existsSync(dataDirs[name] ?? "")) found.push(name);
   }
   return found;
 }
@@ -1185,8 +2029,8 @@ function thisMachine() {
     id: cfg.machineId,
     name: cfg.machineName,
     online: true,
-    os: `${os4.type()} ${os4.release()}`,
-    hostname: os4.hostname(),
+    os: `${os5.type()} ${os5.release()}`,
+    hostname: os5.hostname(),
     cli: detectCli()
   };
 }
@@ -1199,15 +2043,15 @@ function listProjects() {
   return loadConfig().projects;
 }
 function addProject(dir, name) {
-  const abs = path6.resolve(dir);
-  if (!fs7.existsSync(abs) || !fs7.statSync(abs).isDirectory()) {
+  const abs = path9.resolve(dir);
+  if (!fs10.existsSync(abs) || !fs10.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 || path6.basename(abs),
+    name: name || path9.basename(abs),
     path: abs,
     addedAt: Date.now()
   };
@@ -1221,7 +2065,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 !== path6.resolve(idOrNameOrPath)
+      (p) => p.id !== idOrNameOrPath && p.name !== idOrNameOrPath && p.path !== path9.resolve(idOrNameOrPath)
     );
     removed = cfg.projects.length !== before;
   });
@@ -1229,7 +2073,7 @@ function deleteProject(idOrNameOrPath) {
 }
 function resolveProject(idOrNameOrPath) {
   const cfg = loadConfig();
-  const abs = path6.resolve(idOrNameOrPath);
+  const abs = path9.resolve(idOrNameOrPath);
   return cfg.projects.find(
     (p) => p.id === idOrNameOrPath || p.name === idOrNameOrPath || p.path === abs
   ) ?? null;
@@ -1297,12 +2141,16 @@ function refreshCapabilities(idOrName) {
   const MODELS = {
     claude: ["default", "opus", "haiku", "opus-1m"],
     codex: ["default", "gpt-5-codex"],
-    opencode: ["default"]
+    opencode: ["default"],
+    zcode: ["default"],
+    deepseek: ["default"]
   };
   const MODES = {
     claude: ["default", "accept_edits", "plan", "dont_ask", "full_access"],
     codex: ["default"],
-    opencode: ["default"]
+    opencode: ["default"],
+    zcode: ["default", "build", "edit", "plan", "yolo"],
+    deepseek: ["default"]
   };
   return {
     agentType: target.agentType,
@@ -1319,24 +2167,24 @@ var init_registry = __esm({
 });
 
 // src/runtime/fsops.ts
-import fs8 from "fs";
-import path7 from "path";
-import os5 from "os";
+import fs11 from "fs";
+import path10 from "path";
+import os6 from "os";
 function expand(p) {
   if (!p || p === "~") return HOME2;
-  if (p.startsWith("~/")) return path7.join(HOME2, p.slice(2));
-  return path7.resolve(p);
+  if (p.startsWith("~/")) return path10.join(HOME2, p.slice(2));
+  return path10.resolve(p);
 }
 function list2(dir) {
   const abs = expand(dir);
-  const dirents = fs8.readdirSync(abs, { withFileTypes: true });
+  const dirents = fs11.readdirSync(abs, { withFileTypes: true });
   const entries = [];
   for (const d of dirents) {
-    const p = path7.join(abs, d.name);
+    const p = path10.join(abs, d.name);
     let size = 0;
     let mtime = 0;
     try {
-      const st = fs8.statSync(p);
+      const st = fs11.statSync(p);
       size = st.size;
       mtime = Math.floor(st.mtimeMs / 1e3);
     } catch {
@@ -1349,7 +2197,7 @@ function list2(dir) {
     if (a.type !== "dir" && b.type === "dir") return 1;
     return a.name.localeCompare(b.name);
   });
-  const parent = abs === "/" ? null : path7.dirname(abs);
+  const parent = abs === "/" ? null : path10.dirname(abs);
   return { path: abs, parent, entries };
 }
 function looksBinary(buf) {
@@ -1359,12 +2207,12 @@ function looksBinary(buf) {
 }
 function read2(file) {
   const abs = expand(file);
-  const st = fs8.statSync(abs);
-  const fd = fs8.openSync(abs, "r");
+  const st = fs11.statSync(abs);
+  const fd = fs11.openSync(abs, "r");
   try {
     const len = Math.min(st.size, READ_CAP);
     const buf = Buffer.alloc(len);
-    fs8.readSync(fd, buf, 0, len, 0);
+    fs11.readSync(fd, buf, 0, len, 0);
     const binary = looksBinary(buf);
     return {
       path: abs,
@@ -1374,40 +2222,40 @@ function read2(file) {
       content: binary ? "" : buf.toString("utf8")
     };
   } finally {
-    fs8.closeSync(fd);
+    fs11.closeSync(fd);
   }
 }
 function write3(file, content) {
   const abs = expand(file);
-  fs8.mkdirSync(path7.dirname(abs), { recursive: true });
-  fs8.writeFileSync(abs, content, "utf8");
+  fs11.mkdirSync(path10.dirname(abs), { recursive: true });
+  fs11.writeFileSync(abs, content, "utf8");
   return { path: abs, bytes: Buffer.byteLength(content, "utf8") };
 }
 function mkdir(dir) {
   const abs = expand(dir);
-  fs8.mkdirSync(abs, { recursive: true });
+  fs11.mkdirSync(abs, { recursive: true });
   return { path: abs };
 }
 var HOME2, READ_CAP;
 var init_fsops = __esm({
   "src/runtime/fsops.ts"() {
     "use strict";
-    HOME2 = os5.homedir();
+    HOME2 = os6.homedir();
     READ_CAP = 512 * 1024;
   }
 });
 
 // src/tailscale.ts
-import fs9 from "fs";
-import { spawn as spawn6 } from "child_process";
+import fs12 from "fs";
+import { spawn as spawn8 } from "child_process";
 function tsBin() {
   const macPath = "/Applications/Tailscale.app/Contents/MacOS/Tailscale";
-  if (fs9.existsSync(macPath)) return macPath;
+  if (fs12.existsSync(macPath)) return macPath;
   return process.env.TAILSCALE_BIN || "tailscale";
 }
 function runTs(args, timeoutMs = 6e4) {
   return new Promise((resolve) => {
-    const child2 = spawn6(tsBin(), args, { stdio: ["ignore", "pipe", "pipe"] });
+    const child2 = spawn8(tsBin(), args, { stdio: ["ignore", "pipe", "pipe"] });
     let out = "";
     let err = "";
     const timer = setTimeout(() => {
@@ -1517,15 +2365,15 @@ var init_tailscale = __esm({
 });
 
 // src/runtime/models.ts
-import fs10 from "fs";
-import path8 from "path";
+import fs13 from "fs";
+import path11 from "path";
 import { execFileSync } from "child_process";
 function codexModels() {
   const out = [{ id: "", label: "Default" }];
   const seen = /* @__PURE__ */ new Set();
   let configured;
   try {
-    const cfg = fs10.readFileSync(path8.join(HOME, ".codex", "config.toml"), "utf8");
+    const cfg = fs13.readFileSync(path11.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];
@@ -1549,7 +2397,7 @@ function opencodeModels() {
   const allowed = /* @__PURE__ */ new Set(["opencode"]);
   try {
     const auth = JSON.parse(
-      fs10.readFileSync(path8.join(HOME, ".local", "share", "opencode", "auth.json"), "utf8")
+      fs13.readFileSync(path11.join(HOME, ".local", "share", "opencode", "auth.json"), "utf8")
     );
     for (const k of Object.keys(auth)) allowed.add(k);
   } catch {
@@ -1577,14 +2425,24 @@ function opencodeModels() {
 function listModels(agent) {
   if (agent === "codex") return codexModels();
   if (agent === "opencode") return opencodeModels();
+  if (agent === "zcode") return zcodeModels();
+  if (agent === "deepseek") return deepseekModels();
   return CLAUDE_MODELS;
 }
+function zcodeModels() {
+  const configured = configuredModel()?.split("/").pop();
+  return [{ id: "", label: configured ? `Default (${configured})` : "Default" }];
+}
+function deepseekModels() {
+  return [{ id: "", label: "Default" }];
+}
 var CLAUDE_MODELS, CODEX_CURATED, OC_PROVIDER_LABELS;
 var init_models = __esm({
   "src/runtime/models.ts"() {
     "use strict";
     init_util();
     init_opencode();
+    init_zcode();
     CLAUDE_MODELS = [
       { id: "", label: "Default" },
       { id: "opus", label: "Opus" },
@@ -1604,6 +2462,431 @@ var init_models = __esm({
   }
 });
 
+// src/runtime/usage.ts
+import fs14 from "fs";
+import path12 from "path";
+import readline from "readline";
+function claudeCost(model, u) {
+  const p = CLAUDE_PRICES.find((x) => x.match.test(model));
+  if (!p) return null;
+  return ((u.input_tokens ?? 0) * p.input + (u.output_tokens ?? 0) * p.output + (u.cache_read_input_tokens ?? 0) * p.cacheRead + (u.cache_creation_input_tokens ?? 0) * p.input * 1.25) / 1e6;
+}
+function hourKey(ms) {
+  return new Date(Math.floor(ms / 36e5) * 36e5).toISOString().slice(0, 13);
+}
+function add(b, ms, agent, model, tokens, cost) {
+  if (!Number.isFinite(ms) || tokens <= 0) return;
+  const k = `${hourKey(ms)}|${agent}|${model || "unknown"}`;
+  const cur = b[k] ??= { tokens: 0, cost: 0, unpriced: 0 };
+  cur.tokens += tokens;
+  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 });
+  for await (const line of rl) yield line;
+}
+function walk(dir, out = []) {
+  let entries;
+  try {
+    entries = fs14.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const e of entries) {
+    const p = path12.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) {
+  const b = {};
+  const seen = /* @__PURE__ */ new Set();
+  for await (const line of lines(file)) {
+    if (!line.includes('"usage"')) continue;
+    let e;
+    try {
+      e = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const m = e?.message;
+    if (e?.type !== "assistant" || !m?.usage || m.model === "<synthetic>") continue;
+    const id = m.id ?? e.uuid;
+    if (seen.has(id)) continue;
+    seen.add(id);
+    const u = m.usage;
+    const tokens = (u.input_tokens ?? 0) + (u.output_tokens ?? 0) + (u.cache_read_input_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0);
+    add(b, Date.parse(e.timestamp), "claude", String(m.model ?? "claude"), tokens, claudeCost(String(m.model ?? ""), u));
+  }
+  return { buckets: b };
+}
+function limitWindow(w) {
+  if (!w || typeof w.used_percent !== "number") return null;
+  return {
+    usedPercent: w.used_percent,
+    windowMinutes: Number(w.window_minutes ?? 0),
+    resetsAt: typeof w.resets_at === "number" ? w.resets_at : null
+  };
+}
+async function scanCodex(file) {
+  const b = {};
+  const extra = { plans: {}, limits: null };
+  let model = "codex";
+  let prevTotal = 0;
+  for await (const line of lines(file)) {
+    const isCount = line.includes('"token_count"');
+    if (!isCount && !line.includes('"model"')) continue;
+    let e;
+    try {
+      e = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const p = e?.payload ?? {};
+    const m = p.model ?? p.collaboration_mode?.model ?? p.thread_settings?.model ?? p.state?.collaboration_mode?.model;
+    if (typeof m === "string" && m) model = m;
+    if (p.type !== "token_count") continue;
+    const ms = Date.parse(e.timestamp);
+    const rl = p.rate_limits;
+    if (rl && Number.isFinite(ms)) {
+      if (typeof rl.plan_type === "string") {
+        const month = new Date(ms).toISOString().slice(0, 7);
+        const m2 = extra.plans[month] ??= {};
+        m2[rl.plan_type] = (m2[rl.plan_type] ?? 0) + 1;
+      }
+      const windows = [limitWindow(rl.primary), limitWindow(rl.secondary)].filter((w) => !!w);
+      if (windows.length && (!extra.limits || ms >= extra.limits.ts)) {
+        extra.limits = { ts: ms, plan: rl.plan_type ?? null, windows };
+      }
+    }
+    const total = p.info?.total_token_usage?.total_tokens;
+    if (typeof total !== "number") continue;
+    const delta = total >= prevTotal ? total - prevTotal : total;
+    prevTotal = total;
+    add(b, ms, "codex", model, delta, null);
+  }
+  return { buckets: b, extra };
+}
+async function scanSqlite(agent, dbPath) {
+  const b = {};
+  if (!fs14.existsSync(dbPath)) return b;
+  let Ctor;
+  try {
+    const mod = await import("better-sqlite3");
+    Ctor = mod.default ?? mod;
+  } catch {
+    return b;
+  }
+  let db = null;
+  try {
+    db = new Ctor(dbPath, { readonly: true, fileMustExist: true });
+    const rows = db.prepare(
+      `SELECT p.time_created AS t, p.data AS pd, m.data AS md FROM part p
+         JOIN message m ON m.id = p.message_id WHERE p.data LIKE '%"step-finish"%'`
+    ).all();
+    for (const r of rows) {
+      try {
+        const v = JSON.parse(r.pd);
+        const md = JSON.parse(r.md);
+        const t = v.tokens ?? {};
+        const tokens = (t.input ?? 0) + (t.output ?? 0) + (t.reasoning ?? 0) + (t.cache?.read ?? 0) + (t.cache?.write ?? 0);
+        const model = String(md.modelID ?? md.model?.modelID ?? agent);
+        add(b, r.t, agent, model, tokens, typeof v.cost === "number" ? v.cost : null);
+      } catch {
+      }
+    }
+  } catch {
+  } finally {
+    db?.close();
+  }
+  return b;
+}
+function loadCache() {
+  try {
+    const raw = JSON.parse(fs14.readFileSync(CACHE_FILE, "utf8"));
+    return raw?.version === CACHE_VERSION ? raw.files ?? {} : {};
+  } catch {
+    return {};
+  }
+}
+function saveCache(files) {
+  try {
+    fs14.mkdirSync(SAKURA_DIR, { recursive: true });
+    fs14.writeFileSync(CACHE_FILE, JSON.stringify({ version: CACHE_VERSION, files }));
+  } catch {
+  }
+}
+async function scanAll() {
+  if (inflight) return inflight;
+  inflight = (async () => {
+    const cache = 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])
+    ];
+    for (const [file, scan] of jobs) {
+      let st;
+      try {
+        st = fs14.statSync(file);
+      } catch {
+        continue;
+      }
+      const hit = cache[file];
+      if (hit && hit.mtimeMs === st.mtimeMs && hit.size === st.size) {
+        next[file] = hit;
+      } else {
+        const r = await scan(file);
+        next[file] = { mtimeMs: st.mtimeMs, size: st.size, buckets: r.buckets, ...r.extra ? { codex: r.extra } : {} };
+      }
+    }
+    saveCache(next);
+    const merged = {};
+    const merge = (b) => {
+      for (const [k, v] of Object.entries(b)) {
+        const cur = merged[k] ??= { tokens: 0, cost: 0, unpriced: 0 };
+        cur.tokens += v.tokens;
+        cur.cost += v.cost;
+        cur.unpriced += v.unpriced;
+      }
+    };
+    const codexPlans = {};
+    let codexLimits = null;
+    for (const f of Object.values(next)) {
+      merge(f.buckets);
+      for (const [month, plans] of Object.entries(f.codex?.plans ?? {})) {
+        const m = codexPlans[month] ??= {};
+        for (const [plan, n] of Object.entries(plans)) m[plan] = (m[plan] ?? 0) + n;
+      }
+      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")));
+    return { buckets: merged, codexPlans, codexLimits };
+  })().finally(() => {
+    inflight = null;
+  });
+  return inflight;
+}
+function planCatalog() {
+  return PLAN_CATALOG;
+}
+function setPlan(agent, plan, since) {
+  const cfg = updateConfig((c) => {
+    const kept = (c.plans ?? []).filter((p) => p.agent !== agent || p.since < since);
+    const [y, m] = since.split("-").map(Number);
+    const prevMonth = new Date(Date.UTC(y, m - 2, 1)).toISOString().slice(0, 7);
+    for (const p of kept) if (p.agent === agent && !p.until) p.until = prevMonth;
+    if (plan) {
+      const info2 = PLAN_CATALOG[agent]?.[plan];
+      kept.push({ agent, plan, monthlyUsd: info2?.usd ?? 0, since });
+    }
+    c.plans = kept;
+  });
+  return cfg.plans ?? [];
+}
+function monthsBetween(from, to) {
+  const out = [];
+  let [y, m] = from.split("-").map(Number);
+  const [ty, tm] = to.split("-").map(Number);
+  while (y < ty || y === ty && m <= tm) {
+    out.push(`${y}-${String(m).padStart(2, "0")}`);
+    m++;
+    if (m > 12) {
+      m = 1;
+      y++;
+    }
+  }
+  return out;
+}
+function planMonths(codexPlans, now) {
+  const current = new Date(now).toISOString().slice(0, 7);
+  const out = /* @__PURE__ */ new Map();
+  for (const [month, counts] of Object.entries(codexPlans)) {
+    const plan = Object.entries(counts).sort((a, b) => b[1] - a[1])[0]?.[0];
+    const info2 = plan ? PLAN_CATALOG.codex[plan] : void 0;
+    if (plan && info2) out.set(`codex|${month}`, { agent: "codex", month, plan, label: info2.label, usd: info2.usd, source: "detected" });
+  }
+  for (const p of loadConfig().plans ?? []) {
+    const label = PLAN_CATALOG[p.agent]?.[p.plan]?.label ?? p.plan;
+    for (const month of monthsBetween(p.since, p.until ?? current)) {
+      out.set(`${p.agent}|${month}`, { agent: p.agent, month, plan: p.plan, label, usd: p.monthlyUsd, source: "configured" });
+    }
+  }
+  return [...out.values()].filter((m) => m.month <= current).sort((a, b) => a.month.localeCompare(b.month));
+}
+function subscriptionSpend(months, since, now) {
+  let total = 0;
+  for (const pm of months) {
+    const [y, m] = pm.month.split("-").map(Number);
+    const start2 = Date.UTC(y, m - 1, 1);
+    const end = Date.UTC(y, m, 1);
+    if (!Number.isFinite(since)) {
+      total += pm.usd;
+      continue;
+    }
+    const overlap = Math.max(0, Math.min(end, now) - Math.max(start2, since));
+    total += pm.usd * (overlap / (end - start2));
+  }
+  return total;
+}
+function windowLabel(minutes) {
+  if (minutes === 300) return "5-hour";
+  if (minutes === 10080) return "Weekly";
+  if (minutes % 1440 === 0) return `${minutes / 1440}-day`;
+  return `${Math.round(minutes / 60)}-hour`;
+}
+function slices(map) {
+  return [...map.values()].sort((a, b) => b.tokens - a.tokens);
+}
+async function report(range = "all") {
+  const scan = await scanAll();
+  const buckets = scan.buckets;
+  const now = Date.now();
+  const since = now - RANGE_MS[range];
+  const totals = { tokens: 0, cost: 0, unpriced: 0 };
+  const byModel = /* @__PURE__ */ new Map();
+  const byAgent = /* @__PURE__ */ new Map();
+  const dayMap = /* @__PURE__ */ new Map();
+  const step = TIMELINE_STEP[range];
+  const perModel = /* @__PURE__ */ new Map();
+  const modelAgents = /* @__PURE__ */ new Map();
+  let earliest = Infinity;
+  for (const [k, v] of Object.entries(buckets)) {
+    const [hour, agent, model] = k.split("|");
+    const ms = Date.parse(`${hour}:00:00Z`);
+    if (ms + 36e5 > since) {
+      const bucket = Math.floor(ms / step) * step;
+      earliest = Math.min(earliest, bucket);
+      const m = perModel.get(model) ?? /* @__PURE__ */ new Map();
+      m.set(bucket, (m.get(bucket) ?? 0) + v.tokens);
+      perModel.set(model, m);
+      const ag = modelAgents.get(model) ?? /* @__PURE__ */ new Map();
+      ag.set(agent, (ag.get(agent) ?? 0) + v.tokens);
+      modelAgents.set(model, ag);
+    }
+    const day = hour.slice(0, 10);
+    const d = dayMap.get(day) ?? { tokens: 0, cost: 0 };
+    d.tokens += v.tokens;
+    d.cost += v.cost;
+    dayMap.set(day, d);
+    if (ms + 36e5 <= since) continue;
+    totals.tokens += v.tokens;
+    totals.cost += v.cost;
+    totals.unpriced += v.unpriced;
+    for (const [map, name] of [[byModel, model], [byAgent, agent]]) {
+      const s = map.get(name) ?? { name, tokens: 0, cost: 0, unpriced: 0 };
+      s.tokens += v.tokens;
+      s.cost += v.cost;
+      s.unpriced += v.unpriced;
+      map.set(name, s);
+    }
+  }
+  const today = /* @__PURE__ */ new Date(new Date(now).toISOString().slice(0, 10) + "T00:00:00Z");
+  const start2 = new Date(today);
+  start2.setUTCDate(start2.getUTCDate() - 52 * 7 - today.getUTCDay());
+  const days = [];
+  for (const d = new Date(start2); d <= today; d.setUTCDate(d.getUTCDate() + 1)) {
+    const date = d.toISOString().slice(0, 10);
+    days.push({ date, ...dayMap.get(date) ?? { tokens: 0, cost: 0 } });
+  }
+  const last = Math.floor(now / step) * step;
+  const first = Number.isFinite(since) ? Math.floor(since / step) * step : Math.min(earliest, last);
+  const starts = [];
+  for (let t = first; t <= last; t += step) starts.push(t);
+  const timeline = {
+    bucketMs: step,
+    starts,
+    series: slices(byModel).map(({ name }) => ({
+      name,
+      // The agent that ran this model most (one model can appear under several).
+      agent: [...(modelAgents.get(name) ?? /* @__PURE__ */ new Map()).entries()].sort((a, b) => b[1] - a[1])[0]?.[0] ?? "claude",
+      tokens: starts.map((t) => perModel.get(name)?.get(t) ?? 0)
+    }))
+  };
+  const months = planMonths(scan.codexPlans, now);
+  const thisMonth = new Date(now).toISOString().slice(0, 7);
+  const lim = scan.codexLimits;
+  const limits = [
+    {
+      agent: "claude",
+      // Claude Code keeps no plan-limit data on disk; only Anthropic's servers know.
+      available: false,
+      plan: months.find((m) => m.agent === "claude" && m.month === thisMonth)?.label ?? null,
+      asOf: null,
+      windows: []
+    },
+    ...lim ? [{
+      agent: "codex",
+      available: true,
+      plan: PLAN_CATALOG.codex[lim.plan ?? ""]?.label ?? lim.plan,
+      asOf: new Date(lim.ts).toISOString(),
+      windows: lim.windows.map((w) => ({
+        label: windowLabel(w.windowMinutes),
+        // A window that has reset since the snapshot is back to zero.
+        usedPercent: w.resetsAt != null && w.resetsAt * 1e3 < now ? 0 : w.usedPercent,
+        resetsAt: w.resetsAt != null ? new Date(w.resetsAt * 1e3).toISOString() : null
+      }))
+    }] : []
+  ];
+  return {
+    range,
+    totals,
+    subscription: {
+      spend: subscriptionSpend(months, since, now),
+      current: months.filter((m) => m.month === thisMonth && m.usd > 0).map(({ agent, label, usd, source }) => ({ agent, label, usd, source })),
+      months
+    },
+    limits,
+    days,
+    byModel: slices(byModel),
+    byAgent: slices(byAgent),
+    timeline,
+    generatedAt: new Date(now).toISOString()
+  };
+}
+var CLAUDE_PRICES, CACHE_FILE, CACHE_VERSION, inflight, RANGE_MS, PLAN_CATALOG, TIMELINE_STEP;
+var init_usage = __esm({
+  "src/runtime/usage.ts"() {
+    "use strict";
+    init_util();
+    init_config();
+    CLAUDE_PRICES = [
+      { match: /fable|mythos/, input: 10, output: 50, cacheRead: 0.25 },
+      { match: /opus-5-5/, input: 4, output: 20, cacheRead: 0.2 },
+      { match: /opus/, input: 5, output: 25, cacheRead: 0.5 },
+      { match: /sonnet-5/, input: 2, output: 10, cacheRead: 0.2 },
+      { match: /sonnet/, input: 3, output: 15, cacheRead: 0.3 },
+      { 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_VERSION = 2;
+    inflight = null;
+    RANGE_MS = { "24h": 864e5, "7d": 7 * 864e5, "30d": 30 * 864e5, all: Infinity };
+    PLAN_CATALOG = {
+      codex: {
+        none: { label: "No plan", usd: 0 },
+        // overrides detection (e.g. cancelled)
+        free: { label: "Free", usd: 0 },
+        plus: { label: "Plus", usd: 20 },
+        prolite: { label: "Pro $100", usd: 100 },
+        pro: { label: "Pro", usd: 200 }
+      },
+      claude: {
+        none: { label: "No plan", usd: 0 },
+        pro: { label: "Pro", usd: 20 },
+        "max-100": { label: "Max 5\xD7", usd: 100 },
+        "max-200": { label: "Max 20\xD7", usd: 200 }
+      }
+    };
+    TIMELINE_STEP = { "24h": 36e5, "7d": 6 * 36e5, "30d": 864e5, all: 7 * 864e5 };
+  }
+});
+
 // src/daemon/hub.ts
 function sessionKey(agent, sessionId) {
   return `${agent}:${sessionId}`;
@@ -1642,8 +2925,13 @@ var init_hub = __esm({
 });
 
 // src/daemon/stream.ts
+function turnState(agent, sessionId) {
+  return turns.get(sessionKey(agent, sessionId)) ?? null;
+}
 async function runTurn(sessionId, agent, prompt, images, model) {
   const key = sessionKey(agent, sessionId);
+  const turn = { status: "running", startedAt: Date.now() };
+  turns.set(key, turn);
   const emit = (e) => hub.broadcast(key, e);
   let lastEmitted = "\0";
   const emitLive = (text) => {
@@ -1665,30 +2953,61 @@ async function runTurn(sessionId, agent, prompt, images, model) {
   emitLive("");
   const baseIds = /* @__PURE__ */ new Set();
   try {
-    for (const m of await messages4(sessionId, agent)) baseIds.add(m.id);
+    for (const m of await messages6(sessionId, agent)) baseIds.add(m.id);
   } catch {
   }
   let stdoutAcc = "";
+  let persistedText = "";
+  const sentMsgs = /* @__PURE__ */ new Map();
+  const refreshLive = () => {
+    if (!persistedText) emitLive(stdoutAcc.trim());
+    else if (stdoutAcc.startsWith(persistedText)) emitLive(stdoutAcc.slice(persistedText.length).trim());
+    else emitLive("");
+  };
   const onData = (chunk) => {
     stdoutAcc += stripAnsi(chunk);
-    const t = stdoutAcc.trim();
-    if (t.length >= lastEmitted.replace("\0", "").length) emitLive(t);
+    refreshLive();
+  };
+  const pushFresh = (msgs) => {
+    const fresh = msgs.filter((m) => m.role === "assistant" && !baseIds.has(m.id));
+    for (const m of fresh) {
+      const json = JSON.stringify(m);
+      if (sentMsgs.get(m.id) === json) continue;
+      sentMsgs.set(m.id, json);
+      emit({ type: "message", sessionId, agent, data: m });
+    }
+    persistedText = fresh.flatMap((m) => m.parts ?? [{ type: "text", text: m.content }]).map((p) => p.type === "text" ? p.text : "").join("");
+    refreshLive();
   };
+  let polling = false;
   const timer = setInterval(async () => {
+    if (polling) return;
+    polling = true;
     try {
-      const msgs = await messages4(sessionId, agent);
-      const fresh = msgs.filter((m) => m.role === "assistant" && !baseIds.has(m.id)).map((m) => m.content).join("\n\n").trim();
-      if (fresh && fresh.length >= lastEmitted.length) emitLive(fresh);
+      pushFresh(await messages6(sessionId, agent));
     } catch {
+    } finally {
+      polling = false;
     }
   }, POLL_MS);
   const result = await chat(sessionId, prompt, agent, onData, images, model);
   clearInterval(timer);
-  emit({ type: "done", sessionId, agent, ok: result.ok, error: result.error });
+  turn.status = result.ok ? "done" : "error";
+  turn.finishedAt = Date.now();
+  turn.error = result.error;
+  emit({
+    type: "done",
+    sessionId,
+    agent,
+    ok: result.ok,
+    error: result.error,
+    startedAt: turn.startedAt,
+    finishedAt: turn.finishedAt
+  });
   notifyTurnEnd(agent, sessionId, result.ok, result.error, stdoutAcc);
   return { ok: result.ok, error: result.error };
 }
-var ANSI, stripAnsi, LIVE_ID, POLL_MS;
+var ANSI, stripAnsi, LIVE_ID, POLL_MS, turns;
 var init_stream = __esm({
   "src/daemon/stream.ts"() {
     "use strict";
@@ -1699,12 +3018,83 @@ var init_stream = __esm({
     stripAnsi = (s) => s.replace(ANSI, "");
     LIVE_ID = "__live__";
     POLL_MS = 300;
+    turns = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/runtime/presence.ts
+import fs15 from "fs";
+import path13 from "path";
+import { execFileSync as execFileSync2 } from "child_process";
+function alive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e?.code === "EPERM";
+  }
+}
+function claudePresence(sessionId) {
+  const dir = path13.join(HOME, ".claude", "sessions");
+  let files = [];
+  try {
+    files = fs15.readdirSync(dir).filter((f) => f.endsWith(".json"));
+  } catch {
+    return { open: false };
+  }
+  for (const f of files) {
+    try {
+      const rec = JSON.parse(fs15.readFileSync(path13.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;
+      const where = rec.entrypoint === "cli" ? "Claude Code in a terminal" : "Claude Code";
+      return { open: true, where, pid: rec.pid };
+    } catch {
+    }
+  }
+  return { open: false };
+}
+function processPresence(agent, sessionId) {
+  const program = AGENT_PROGRAM[agent];
+  if (!program) return { open: false };
+  let out = "";
+  try {
+    out = execFileSync2("ps", ["-axo", "pid=,command="], { encoding: "utf8", timeout: 2e3 });
+  } catch {
+    return { open: false };
+  }
+  for (const line of out.split("\n")) {
+    if (!line.includes(sessionId)) continue;
+    const m = line.trim().match(/^(\d+)\s+(.*)$/);
+    if (!m) continue;
+    const pid = Number(m[1]);
+    if (pid === process.pid || !program.test(m[2])) continue;
+    return { open: true, where: agent, pid };
+  }
+  return { open: false };
+}
+function presence(agent, sessionId) {
+  if (!sessionId) return { open: false };
+  return agent === "claude" ? claudePresence(sessionId) : processPresence(agent, sessionId);
+}
+var AGENT_PROGRAM;
+var init_presence = __esm({
+  "src/runtime/presence.ts"() {
+    "use strict";
+    init_util();
+    AGENT_PROGRAM = {
+      codex: /(^|\/)codex(\s|$)/,
+      opencode: /(^|\/)opencode(-cli)?(\s|$)/,
+      zcode: /(^|\/)zcode(\.cjs)?(\s|$)/,
+      deepseek: /(^|\/)dsh(\s|$)|dsh-desktop-host/
+    };
   }
 });
 
 // src/daemon/terminal.ts
-import os6 from "os";
-import { spawn as spawn7 } from "child_process";
+import os7 from "os";
+import { spawn as spawn9 } from "child_process";
 function cleanOutput(t, chunk) {
   let s = t.buf + chunk;
   s = s.replace(OSC, "").replace(CSI, "").replace(ESC2, "");
@@ -1722,8 +3112,8 @@ function defaultShell() {
 }
 function openTerminal(ws, opts) {
   const shell = defaultShell();
-  const child2 = spawn7(shell, ["-i"], {
-    cwd: opts?.cwd && opts.cwd.trim() ? opts.cwd : os6.homedir(),
+  const child2 = spawn9(shell, ["-i"], {
+    cwd: opts?.cwd && opts.cwd.trim() ? opts.cwd : os7.homedir(),
     env: {
       ...process.env,
       TERM: "dumb",
@@ -1754,7 +3144,7 @@ function openTerminal(ws, opts) {
 [shell error: ${e.message}]
 `));
   try {
-    ws.send(JSON.stringify({ type: "ready", shell, cwd: opts?.cwd || os6.homedir() }));
+    ws.send(JSON.stringify({ type: "ready", shell, cwd: opts?.cwd || os7.homedir() }));
   } catch {
   }
 }
@@ -1790,15 +3180,17 @@ var init_terminal = __esm({
 
 // src/daemon/server.ts
 import http from "http";
-import fs11 from "fs";
-import os7 from "os";
-import path9 from "path";
+import fs16 from "fs";
+import os8 from "os";
+import zlib2 from "zlib";
+import path14 from "path";
 import { URL } from "url";
+import { execFileSync as execFileSync3 } from "child_process";
 import { WebSocketServer } from "ws";
-function add(method, path12, handler) {
+function add2(method, path18, handler) {
   const keys = [];
   const pattern = new RegExp(
-    "^" + path12.replace(/:[^/]+/g, (m) => {
+    "^" + path18.replace(/:[^/]+/g, (m) => {
       keys.push(m.slice(1));
       return "([^/]+)";
     }) + "/?$"
@@ -1811,9 +3203,18 @@ function ok(data = null) {
 function fail(code, stderr, data = null) {
   return { ok: false, data, stdout: "", stderr, code };
 }
+function sniffExt(buf) {
+  if (buf.length < 12) return null;
+  if (buf[0] === 137 && buf.toString("latin1", 1, 4) === "PNG") return "png";
+  if (buf[0] === 255 && buf[1] === 216 && buf[2] === 255) return "jpg";
+  if (buf.toString("latin1", 0, 4) === "GIF8") return "gif";
+  if (buf.toString("latin1", 0, 4) === "RIFF" && buf.toString("latin1", 8, 12) === "WEBP") return "webp";
+  if (buf.toString("latin1", 4, 8) === "ftyp" && /^(heic|heix|hevc|mif1|msf1)$/.test(buf.toString("latin1", 8, 12))) return "heic";
+  return null;
+}
 function saveImages(sessionId, images) {
-  const dir = path9.join(os7.tmpdir(), "sakura-uploads", sessionId.slice(0, 24));
-  fs11.mkdirSync(dir, { recursive: true });
+  const dir = path14.join(os8.tmpdir(), "sakura-uploads", sessionId.slice(0, 24));
+  fs16.mkdirSync(dir, { recursive: true });
   const paths = [];
   images.forEach((img, i) => {
     const raw = String(img?.data ?? "");
@@ -1822,15 +3223,41 @@ function saveImages(sessionId, images) {
       log.info(`saveImages: image ${i} did not match data-url (len=${raw.length}, prefix="${raw.slice(0, 40)}")`);
       return;
     }
-    const ext = EXT_BY_MIME[m[1]] ?? "png";
-    const safe = img.name && /\.[a-z0-9]+$/i.test(img.name) ? img.name.replace(/[^\w.\-]/g, "_") : `image-${Date.now()}-${i + 1}.${ext}`;
-    const file = path9.join(dir, safe);
-    fs11.writeFileSync(file, Buffer.from(m[2], "base64"));
-    log.info(`saveImages: wrote ${file} (${m[2].length} b64 chars)`);
+    const bytes = Buffer.from(m[2], "base64");
+    const ext = sniffExt(bytes) ?? EXT_BY_MIME[m[1]] ?? "png";
+    const base = img.name ? path14.parse(img.name).name.replace(/[^\w.\-]/g, "_") : "";
+    const stem = `${base || "image"}-${Date.now()}-${i + 1}`;
+    let file = path14.join(dir, `${stem}.${ext}`);
+    fs16.writeFileSync(file, bytes);
+    if (ext === "heic") {
+      const jpg = path14.join(dir, `${stem}.jpg`);
+      try {
+        execFileSync3("sips", ["-s", "format", "jpeg", file, "--out", jpg], { stdio: "ignore" });
+        fs16.rmSync(file, { force: true });
+        file = jpg;
+      } catch {
+        log.info(`saveImages: HEIC\u2192JPEG conversion failed for ${file}; sending HEIC as-is`);
+      }
+    }
+    log.info(`saveImages: wrote ${file} (${bytes.length} bytes)`);
     paths.push(file);
   });
   return paths;
 }
+function sendBytes(res, img) {
+  if (!img) {
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "image not found" }));
+    return;
+  }
+  res.writeHead(200, {
+    "Content-Type": img.mediaType,
+    "Content-Length": img.data.length,
+    "Cache-Control": "private, max-age=86400"
+    // transcript images never change
+  });
+  res.end(img.data);
+}
 function kvToObj(env) {
   if (!Array.isArray(env)) return void 0;
   const out = {};
@@ -1856,44 +3283,52 @@ function readBody(req) {
     req.on("error", () => resolve(null));
   });
 }
-function send4(res, status2, payload) {
+function send6(res, status2, payload) {
   const body = JSON.stringify(payload);
-  res.writeHead(status2, {
+  const headers = {
     "Content-Type": "application/json",
     "Access-Control-Allow-Origin": "*",
     "Access-Control-Allow-Headers": "Authorization, Content-Type",
     "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS"
-  });
+  };
+  const accepts = /\bgzip\b/.test(String(res.req?.headers["accept-encoding"] ?? ""));
+  if (accepts && body.length > 8 * 1024) {
+    const gz = zlib2.gzipSync(body, { level: 6 });
+    res.writeHead(status2, { ...headers, "Content-Encoding": "gzip", "Content-Length": gz.length });
+    res.end(gz);
+    return;
+  }
+  res.writeHead(status2, headers);
   res.end(body);
 }
 function createServer(port2) {
   const server = http.createServer(async (req, res) => {
     const method = req.method ?? "GET";
     const url = new URL(req.url ?? "/", `http://localhost:${port2}`);
-    if (method === "OPTIONS") return send4(res, 204, {});
+    if (method === "OPTIONS") return send6(res, 204, {});
     if (method === "GET" && url.pathname === "/ping") {
-      return send4(res, 200, { pong: true, pid: process.pid });
+      return send6(res, 200, { pong: true, pid: process.pid });
     }
     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 send4(res, 401, { error: "Unauthorized" });
+      return send6(res, 401, { error: "Unauthorized" });
     }
     const route = routes.find(
       (r) => r.method === method && r.pattern.test(url.pathname)
     );
-    if (!route) return send4(res, 404, { error: "Not found" });
+    if (!route) return send6(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);
     try {
       const result = await route.handler({ req, res, url, params, body, port: port2 });
-      send4(res, 200, result);
+      if (!res.headersSent) send6(res, 200, result);
     } catch (e) {
       log.error("handler error", e.message);
-      send4(res, 500, fail("nonzero", e.message));
+      send6(res, 500, fail("nonzero", e.message));
     }
   });
   const wss = new WebSocketServer({ noServer: true });
@@ -1953,7 +3388,7 @@ function createServer(port2) {
 function setVersion(v) {
   VERSION2 = v;
 }
-var routes, EXT_BY_MIME, VERSION2;
+var routes, EXT_BY_MIME, UPLOADS_DIR, VERSION2;
 var init_server = __esm({
   "src/daemon/server.ts"() {
     "use strict";
@@ -1967,8 +3402,13 @@ var init_server = __esm({
     init_tailscale();
     init_registry();
     init_models();
+    init_usage();
+    init_claude();
+    init_opencode();
+    init_zcode();
     init_hub();
     init_stream();
+    init_presence();
     init_terminal();
     routes = [];
     EXT_BY_MIME = {
@@ -1979,18 +3419,35 @@ var init_server = __esm({
       "image/webp": "webp",
       "image/heic": "heic"
     };
-    add("GET", "/sessions", async ({ url }) => {
+    add2(
+      "GET",
+      "/blobs/claude/:session/:uuid/:idx",
+      ({ res, params }) => sendBytes(res, imageBlock(params.session, params.uuid, Number(params.idx)))
+    );
+    add2("GET", "/blobs/:agent/:session/:part", async ({ res, params }) => {
+      const reader = params.agent === "opencode" ? image : params.agent === "zcode" ? image2 : null;
+      sendBytes(res, reader ? await reader(params.session, params.part) : null);
+    });
+    UPLOADS_DIR = path14.join(os8.tmpdir(), "sakura-uploads");
+    add2("GET", "/uploads/:dir/:file", ({ res, params }) => {
+      const file = path14.resolve(UPLOADS_DIR, params.dir, params.file);
+      const ext = path14.extname(file).slice(1).toLowerCase();
+      const mime = Object.entries(EXT_BY_MIME).find(([, e]) => e === ext)?.[0];
+      const ok2 = file.startsWith(UPLOADS_DIR + path14.sep) && mime && fs16.existsSync(file);
+      sendBytes(res, ok2 ? { mediaType: mime, data: fs16.readFileSync(file) } : null);
+    });
+    add2("GET", "/sessions", async ({ url }) => {
       const archived = url.searchParams.get("archived") === "true";
       const all2 = url.searchParams.get("all") === "true";
       const list3 = await list({ archived, all: all2 });
       return { sessions: list3 };
     });
-    add("GET", "/sessions/:id/messages", async ({ params, url }) => {
+    add2("GET", "/sessions/:id/messages", async ({ params, url }) => {
       const agent = url.searchParams.get("agent") || void 0;
-      const messages5 = await messages4(params.id, agent);
-      return { messages: messages5 };
+      const messages7 = await messages6(params.id, agent);
+      return { messages: messages7 };
     });
-    add("POST", "/sessions/:id/send", async ({ params, body }) => {
+    add2("POST", "/sessions/:id/send", async ({ params, body }) => {
       const agent = body?.agent || await detectAgent(params.id);
       if (!agent) return { ok: false, error: "unknown agent for session" };
       const message = String(body?.message ?? "");
@@ -2002,26 +3459,33 @@ var init_server = __esm({
       const r = await runTurn(params.id, agent, message, imagePaths, model);
       return { ok: r.ok, error: r.error };
     });
-    add("POST", "/sessions/:id/rename", ({ params, body }) => {
+    add2("GET", "/sessions/:id/status", async ({ params, url }) => {
+      const agent = url.searchParams.get("agent") || await detectAgent(params.id);
+      if (!agent) return { ok: false, error: "unknown agent for session" };
+      const turn = turnState(agent, params.id);
+      const elsewhere = turn?.status === "running" ? { open: false } : presence(agent, params.id);
+      return { ok: true, agent, turn, openOnMac: elsewhere };
+    });
+    add2("POST", "/sessions/:id/rename", ({ params, body }) => {
       const title = String(body?.title ?? "").trim();
       if (!title) return { ok: false, error: "title is required" };
       rename(params.id, title);
       return { ok: true };
     });
-    add("POST", "/sessions/:id/archive", ({ params }) => {
+    add2("POST", "/sessions/:id/archive", ({ params }) => {
       setArchived2(params.id, true);
       return { ok: true };
     });
-    add("POST", "/sessions/:id/restore", ({ params }) => {
+    add2("POST", "/sessions/:id/restore", ({ params }) => {
       setArchived2(params.id, false);
       return { ok: true };
     });
-    add(
+    add2(
       "GET",
       "/sakura/health",
       () => ok({ installed: true, daemon: true, version: VERSION2 })
     );
-    add("GET", "/sakura/status", async ({ port: port2 }) => {
+    add2("GET", "/sakura/status", async ({ port: port2 }) => {
       const machine = thisMachine();
       const ts = await discoverBaseUrl(port2).catch(() => null);
       return ok({
@@ -2031,15 +3495,15 @@ var init_server = __esm({
         tailnetBaseUrl: ts
       });
     });
-    add("POST", "/sakura/daemon/:action", ({ params }) => {
+    add2("POST", "/sakura/daemon/:action", ({ params }) => {
       switch (params.action) {
         case "status":
           return ok({ running: true, pid: process.pid, machine: thisMachine() });
         case "logs": {
           let logs2 = "";
           try {
-            const lines = fs11.readFileSync(LOG_PATH, "utf8").split("\n");
-            logs2 = lines.slice(-200).join("\n");
+            const lines2 = fs16.readFileSync(LOG_PATH, "utf8").split("\n");
+            logs2 = lines2.slice(-200).join("\n");
           } catch {
           }
           return ok({ logs: logs2 });
@@ -2056,8 +3520,8 @@ var init_server = __esm({
           return fail("nonzero", `unknown daemon action: ${params.action}`);
       }
     });
-    add("GET", "/sakura/workspaces", () => ok(listWorkspaces()));
-    add(
+    add2("GET", "/sakura/workspaces", () => ok(listWorkspaces()));
+    add2(
       "GET",
       "/sakura/github",
       () => (
@@ -2065,67 +3529,88 @@ var init_server = __esm({
         ok([])
       )
     );
-    add(
+    add2(
       "GET",
       "/sakura/machines",
       ({ url }) => ok(listMachines(url.searchParams.get("onlineOnly") === "true"))
     );
-    add("GET", "/sakura/projects", () => ok(listProjects()));
-    add("GET", "/sakura/models", ({ url }) => {
+    add2("GET", "/sakura/projects", () => ok(listProjects()));
+    add2("GET", "/sakura/usage", async ({ url }) => {
+      const r = url.searchParams.get("range");
+      const range = r === "24h" || r === "7d" || r === "30d" ? r : "all";
+      return ok(await report(range));
+    });
+    add2("GET", "/sakura/usage/plans", () => ok({ catalog: planCatalog(), configured: loadConfig().plans ?? [] }));
+    add2("POST", "/sakura/usage/plan", ({ body }) => {
+      const agent = String(body?.agent ?? "");
+      const since = String(body?.since ?? "");
+      if (!agent || !/^\d{4}-\d{2}$/.test(since)) return fail("bad_request", "agent and since (YYYY-MM) are required");
+      const plan = body?.plan ? String(body.plan) : null;
+      if (plan && !planCatalog()[agent]?.[plan]) return fail("bad_request", `unknown plan ${plan} for ${agent}`);
+      return ok(setPlan(agent, plan, since));
+    });
+    add2("GET", "/sakura/models", ({ url }) => {
       const agent = url.searchParams.get("agent") || "claude";
       return ok(listModels(agent));
     });
-    add("POST", "/sakura/push-token", ({ body }) => {
-      const token = String(body?.token ?? "");
+    add2("POST", "/sakura/push-token", ({ body }) => {
+      let b = body;
+      if (typeof b === "string") {
+        try {
+          b = JSON.parse(b);
+        } catch {
+        }
+      }
+      const token = String(b?.token ?? "");
       if (!token) return fail("bad_request", "token required");
       addPushToken(token);
       return ok({ registered: true });
     });
-    add("POST", "/sakura/push-test", async () => {
+    add2("POST", "/sakura/push-test", async () => {
       await sendPush("\u{1F338} Sakura says hi", "Push is locked in. Your agents will ping you here.", { kind: "test" });
       return ok({ sent: true });
     });
-    add("GET", "/sakura/sessions", async ({ url }) => {
+    add2("GET", "/sakura/sessions", async ({ url }) => {
       const limit = Number(url.searchParams.get("limit")) || void 0;
       const agent = url.searchParams.get("agent") || void 0;
       return ok(await list({ limit, agent }));
     });
-    add("POST", "/sakura/sessions", async ({ body }) => {
+    add2("POST", "/sakura/sessions", async ({ body }) => {
       const r = await create(String(body?.prompt ?? ""), {
         agent: body?.agent,
         cwd: body?.cwd
       });
       return r.ok ? ok({ output: r.output }) : fail("nonzero", r.error ?? "create failed");
     });
-    add("GET", "/sakura/sessions/:id", async ({ params }) => {
+    add2("GET", "/sakura/sessions/:id", async ({ params }) => {
       const s = await show(params.id);
       return s ? ok(s) : fail("nonzero", "session not found");
     });
-    add("GET", "/sakura/sessions/:id/history", async ({ params, url }) => {
+    add2("GET", "/sakura/sessions/:id/history", async ({ params, url }) => {
       const all2 = url.searchParams.get("all") === "true";
       const limit = Number(url.searchParams.get("limit")) || void 0;
       const reverse = url.searchParams.get("reverse") === "true";
       return ok(await history(params.id, { all: all2, limit, reverse }));
     });
-    add("POST", "/sakura/sessions/:id/chat", async ({ params, body }) => {
+    add2("POST", "/sakura/sessions/:id/chat", async ({ params, body }) => {
       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 r = await runTurn(params.id, agent, String(body?.prompt ?? ""), void 0, model);
       return r.ok ? ok({ ok: true }) : fail("nonzero", r.error ?? "chat failed");
     });
-    add(
+    add2(
       "POST",
       "/sakura/sessions/:id/cancel",
       () => fail("nonzero", "cancel is not supported for local file-backed sessions")
     );
-    add("POST", "/sakura/sessions/:id/rename", ({ params, body }) => {
+    add2("POST", "/sakura/sessions/:id/rename", ({ params, body }) => {
       const title = String(body?.title ?? "").trim();
       if (!title) return fail("nonzero", "title is required");
       rename(params.id, title);
       return ok({ id: params.id, title });
     });
-    add("POST", "/sakura/sessions/:id/:action", ({ params }) => {
+    add2("POST", "/sakura/sessions/:id/:action", ({ params }) => {
       switch (params.action) {
         case "archive":
           setArchived2(params.id, true);
@@ -2140,8 +3625,8 @@ var init_server = __esm({
           );
       }
     });
-    add("GET", "/sakura/agent-configs", () => ok(listAgentConfigs()));
-    add("POST", "/sakura/agent-configs", ({ body }) => {
+    add2("GET", "/sakura/agent-configs", () => ok(listAgentConfigs()));
+    add2("POST", "/sakura/agent-configs", ({ body }) => {
       try {
         return ok(
           createAgentConfig({
@@ -2156,7 +3641,7 @@ var init_server = __esm({
         return fail("nonzero", e.message);
       }
     });
-    add("PUT", "/sakura/agent-configs", ({ body }) => {
+    add2("PUT", "/sakura/agent-configs", ({ body }) => {
       try {
         return ok(
           updateAgentConfig(body.id_or_name ?? body.idOrName, {
@@ -2171,30 +3656,30 @@ var init_server = __esm({
         return fail("nonzero", e.message);
       }
     });
-    add("GET", "/sakura/agent-configs/:id", ({ params }) => {
+    add2("GET", "/sakura/agent-configs/:id", ({ params }) => {
       const a = resolveAgentConfig(params.id);
       return a ? ok(a) : fail("nonzero", "agent-config not found");
     });
-    add(
+    add2(
       "DELETE",
       "/sakura/agent-configs/:id",
       ({ params }) => deleteAgentConfig(params.id) ? ok({ deleted: true }) : fail("nonzero", "agent-config not found")
     );
-    add("POST", "/sakura/agent-configs/:id/refresh", ({ params }) => {
+    add2("POST", "/sakura/agent-configs/:id/refresh", ({ params }) => {
       try {
         return ok(refreshCapabilities(params.id));
       } catch (e) {
         return fail("nonzero", e.message);
       }
     });
-    add("GET", "/sakura/fs/list", ({ url }) => {
+    add2("GET", "/sakura/fs/list", ({ url }) => {
       try {
         return ok(list2(url.searchParams.get("path") ?? void 0));
       } catch (e) {
         return fail("nonzero", e.message);
       }
     });
-    add("GET", "/sakura/fs/read", ({ url }) => {
+    add2("GET", "/sakura/fs/read", ({ url }) => {
       const p = url.searchParams.get("path");
       if (!p) return fail("nonzero", "path required");
       try {
@@ -2203,7 +3688,7 @@ var init_server = __esm({
         return fail("nonzero", e.message);
       }
     });
-    add("POST", "/sakura/fs/write", ({ body }) => {
+    add2("POST", "/sakura/fs/write", ({ body }) => {
       if (!body?.path) return fail("nonzero", "path required");
       try {
         return ok(write3(body.path, String(body.content ?? "")));
@@ -2211,7 +3696,7 @@ var init_server = __esm({
         return fail("nonzero", e.message);
       }
     });
-    add("POST", "/sakura/fs/mkdir", ({ body }) => {
+    add2("POST", "/sakura/fs/mkdir", ({ body }) => {
       if (!body?.path) return fail("nonzero", "path required");
       try {
         return ok(mkdir(body.path));
@@ -2219,35 +3704,35 @@ var init_server = __esm({
         return fail("nonzero", e.message);
       }
     });
-    add("GET", "/tailscale/health", () => installed());
-    add("GET", "/tailscale/status", ({ port: port2 }) => status(port2));
-    add("POST", "/tailscale/up", () => up());
-    add("POST", "/tailscale/down", () => down());
-    add("POST", "/tailscale/serve", ({ port: port2 }) => serve(port2));
-    add("POST", "/tailscale/serve-off", () => serveOff());
+    add2("GET", "/tailscale/health", () => installed());
+    add2("GET", "/tailscale/status", ({ port: port2 }) => status(port2));
+    add2("POST", "/tailscale/up", () => up());
+    add2("POST", "/tailscale/down", () => down());
+    add2("POST", "/tailscale/serve", ({ port: port2 }) => serve(port2));
+    add2("POST", "/tailscale/serve-off", () => serveOff());
     VERSION2 = "0.0.0";
   }
 });
 
 // src/daemon/tsnet.ts
-import fs12 from "fs";
-import path10 from "path";
+import fs17 from "fs";
+import path15 from "path";
 import { fileURLToPath } from "url";
-import { spawn as spawn8 } from "child_process";
+import { spawn as spawn10 } from "child_process";
 function resolveBinary() {
   const envBin = process.env.SAKURA_TSNET_BIN;
-  if (envBin && fs12.existsSync(envBin)) return envBin;
-  const here = path10.dirname(fileURLToPath(import.meta.url));
+  if (envBin && fs17.existsSync(envBin)) return envBin;
+  const here = path15.dirname(fileURLToPath(import.meta.url));
   const name = process.platform === "win32" ? "sakura-tsnet.exe" : "sakura-tsnet";
   const candidates = [
-    path10.join(here, "..", "bin", name),
+    path15.join(here, "..", "bin", name),
     // package/bin (postinstall download / build-sidecar.sh)
-    path10.join(here, "bin", name),
-    path10.join(process.cwd(), "bin", name),
-    path10.join(SAKURA_DIR, name)
+    path15.join(here, "bin", name),
+    path15.join(process.cwd(), "bin", name),
+    path15.join(SAKURA_DIR, name)
     // user-dropped
   ];
-  return candidates.find((p) => fs12.existsSync(p)) ?? null;
+  return candidates.find((p) => fs17.existsSync(p)) ?? null;
 }
 function startTsnet(port2) {
   const cfg = loadConfig();
@@ -2270,12 +3755,12 @@ function spawnSidecar(bin, controlUrl, authKey, hostname2, port2) {
     SAKURA_TS_CONTROL_URL: controlUrl,
     SAKURA_TS_AUTH_KEY: authKey,
     SAKURA_TS_HOSTNAME: hostname2,
-    SAKURA_TS_STATE_DIR: path10.join(SAKURA_DIR, "tsnet-state"),
+    SAKURA_TS_STATE_DIR: path15.join(SAKURA_DIR, "tsnet-state"),
     SAKURA_TS_STATE_FILE: TSNET_PATH,
     SAKURA_TS_PORT: String(port2)
   };
-  log.info(`starting embedded Tailscale sidecar (${path10.basename(bin)})`);
-  const c = spawn8(bin, [], { stdio: ["ignore", "pipe", "pipe"], env });
+  log.info(`starting embedded Tailscale sidecar (${path15.basename(bin)})`);
+  const c = spawn10(bin, [], { stdio: ["ignore", "pipe", "pipe"], env });
   child = c;
   const pipe = (buf) => buf.toString().split("\n").filter(Boolean).forEach((line) => log.info(`[tsnet] ${line}`));
   c.stdout?.on("data", pipe);
@@ -2303,7 +3788,7 @@ function stopTsnet() {
     child = null;
   }
   try {
-    fs12.rmSync(TSNET_PATH, { force: true });
+    fs17.rmSync(TSNET_PATH, { force: true });
   } catch {
   }
 }
@@ -2320,8 +3805,8 @@ var init_tsnet = __esm({
 });
 
 // src/daemon/manager.ts
-import fs13 from "fs";
-import { spawn as spawn9 } from "child_process";
+import fs18 from "fs";
+import { spawn as spawn11 } from "child_process";
 async function ensureTailnetProvisioned() {
   const serverToken = getServerToken();
   if (!serverToken) return;
@@ -2343,7 +3828,7 @@ async function ensureTailnetProvisioned() {
 }
 function readDaemonInfo() {
   try {
-    return JSON.parse(fs13.readFileSync(DAEMON_PATH, "utf8"));
+    return JSON.parse(fs18.readFileSync(DAEMON_PATH, "utf8"));
   } catch {
     return null;
   }
@@ -2360,8 +3845,8 @@ function running() {
   const info2 = readDaemonInfo();
   if (info2 && pidAlive(info2.pid)) return info2;
   if (info2) {
-    fs13.rmSync(DAEMON_PATH, { force: true });
-    fs13.rmSync(PID_PATH, { force: true });
+    fs18.rmSync(DAEMON_PATH, { force: true });
+    fs18.rmSync(PID_PATH, { force: true });
   }
   return null;
 }
@@ -2384,8 +3869,8 @@ async function runServer(version) {
     url: `http://${host}:${port2}`,
     startedAt: Date.now()
   };
-  fs13.writeFileSync(DAEMON_PATH, JSON.stringify(info2, null, 2));
-  fs13.writeFileSync(PID_PATH, String(process.pid));
+  fs18.writeFileSync(DAEMON_PATH, JSON.stringify(info2, null, 2));
+  fs18.writeFileSync(PID_PATH, String(process.pid));
   await ensureTailnetProvisioned();
   startTsnet(port2);
   const tailnet = await discoverBaseUrl(port2).catch(() => null);
@@ -2396,8 +3881,8 @@ async function runServer(version) {
     log.info("shutting down");
     stopTsnet();
     server.close();
-    fs13.rmSync(DAEMON_PATH, { force: true });
-    fs13.rmSync(PID_PATH, { force: true });
+    fs18.rmSync(DAEMON_PATH, { force: true });
+    fs18.rmSync(PID_PATH, { force: true });
     process.exit(0);
   };
   process.on("SIGINT", shutdown);
@@ -2408,9 +3893,9 @@ function start() {
   if (existing) return existing;
   ensureSakuraDirs();
   const entry = process.argv[1] ?? "";
-  const out = fs13.openSync(LOG_PATH, "a");
-  const err = fs13.openSync(LOG_PATH, "a");
-  const child2 = spawn9(process.execPath, [entry, "__run-daemon"], {
+  const out = fs18.openSync(LOG_PATH, "a");
+  const err = fs18.openSync(LOG_PATH, "a");
+  const child2 = spawn11(process.execPath, [entry, "__run-daemon"], {
     detached: true,
     stdio: ["ignore", out, err],
     env: process.env
@@ -2431,8 +3916,8 @@ function stop() {
     process.kill(info2.pid, "SIGTERM");
   } catch {
   }
-  fs13.rmSync(DAEMON_PATH, { force: true });
-  fs13.rmSync(PID_PATH, { force: true });
+  fs18.rmSync(DAEMON_PATH, { force: true });
+  fs18.rmSync(PID_PATH, { force: true });
   return true;
 }
 function restart() {
@@ -2440,10 +3925,10 @@ function restart() {
   Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 300);
   return start();
 }
-function logs(lines = 50) {
+function logs(lines2 = 50) {
   try {
-    const all2 = fs13.readFileSync(LOG_PATH, "utf8").split("\n");
-    return all2.slice(-lines).join("\n");
+    const all2 = fs18.readFileSync(LOG_PATH, "utf8").split("\n");
+    return all2.slice(-lines2).join("\n");
   } catch {
     return "";
   }
@@ -2462,7 +3947,7 @@ var init_manager = __esm({
 });
 
 // src/pairing.ts
-import os8 from "os";
+import os9 from "os";
 import qrcode from "qrcode-terminal";
 async function buildPairing() {
   const token = requireToken();
@@ -2492,7 +3977,7 @@ function renderQr(deepLink) {
   });
 }
 function localIp() {
-  const nets = os8.networkInterfaces();
+  const nets = os9.networkInterfaces();
   for (const name of Object.keys(nets)) {
     for (const net of nets[name] ?? []) {
       if (net.family === "IPv4" && !net.internal) return net.address;
@@ -2564,7 +4049,7 @@ var init_pair = __esm({
 import { Command } from "commander";
 
 // src/version.ts
-var VERSION = "0.0.11";
+var VERSION = "0.0.13";
 
 // src/index.ts
 init_config();
@@ -2693,7 +4178,7 @@ function registerRuntime(program, version) {
 // src/commands/session.ts
 init_sessions();
 init_output();
-import fs14 from "fs";
+import fs19 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).");
@@ -2702,7 +4187,7 @@ function resolveSessionId(arg) {
 async function resolvePrompt(positional, opts) {
   if (positional) return positional;
   if (opts.prompt) return opts.prompt;
-  if (opts.promptFile) return fs14.readFileSync(opts.promptFile, "utf8");
+  if (opts.promptFile) return fs19.readFileSync(opts.promptFile, "utf8");
   if (!process.stdin.isTTY) {
     const chunks = [];
     for await (const c of process.stdin) chunks.push(c);
@@ -2733,7 +4218,7 @@ function registerSession(program) {
     const id = resolveSessionId(sessionId);
     const meta = await show(id);
     if (!meta) die(`Session not found: ${id}`);
-    const msgs = await messages4(id, meta.agent);
+    const msgs = await messages6(id, meta.agent);
     const enriched = { ...meta, historyCount: msgs.length };
     if (opts.json) return printJson(enriched);
     info(`ID:       ${meta.id}`);
@@ -3017,25 +4502,25 @@ init_pair();
 
 // src/commands/welcome.ts
 init_config();
-import fs15 from "fs";
-import path11 from "path";
+import fs20 from "fs";
+import path16 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { spawn as spawn10 } from "child_process";
-var WELCOMED_MARKER = path11.join(SAKURA_DIR, ".welcomed");
+import { spawn as spawn12 } from "child_process";
+var WELCOMED_MARKER = path16.join(SAKURA_DIR, ".welcomed");
 function resolveBinary2() {
   const envBin = process.env.SAKURA_ONBOARD_BIN;
-  if (envBin && fs15.existsSync(envBin)) return envBin;
-  const here = path11.dirname(fileURLToPath2(import.meta.url));
+  if (envBin && fs20.existsSync(envBin)) return envBin;
+  const here = path16.dirname(fileURLToPath2(import.meta.url));
   const name = process.platform === "win32" ? "sakura-onboard.exe" : "sakura-onboard";
   const candidates = [
-    path11.join(here, "..", "bin", name),
+    path16.join(here, "..", "bin", name),
     // package/bin (postinstall download)
-    path11.join(here, "bin", name),
-    path11.join(process.cwd(), "bin", name),
-    path11.join(SAKURA_DIR, name)
+    path16.join(here, "bin", name),
+    path16.join(process.cwd(), "bin", name),
+    path16.join(SAKURA_DIR, name)
     // user-dropped
   ];
-  return candidates.find((p) => fs15.existsSync(p)) ?? null;
+  return candidates.find((p) => fs20.existsSync(p)) ?? null;
 }
 function showWelcome() {
   return new Promise((resolve) => {
@@ -3044,7 +4529,7 @@ function showWelcome() {
       printFallback();
       return resolve();
     }
-    const child2 = spawn10(bin, [], { stdio: "inherit" });
+    const child2 = spawn12(bin, [], { stdio: "inherit" });
     child2.on("error", () => {
       printFallback();
       resolve();
@@ -3053,10 +4538,10 @@ function showWelcome() {
   });
 }
 async function maybeFirstRunWelcome() {
-  if (fs15.existsSync(WELCOMED_MARKER)) return;
+  if (fs20.existsSync(WELCOMED_MARKER)) return;
   if (!process.stdout.isTTY || !process.stdin.isTTY) return;
   try {
-    fs15.writeFileSync(WELCOMED_MARKER, (/* @__PURE__ */ new Date()).toISOString());
+    fs20.writeFileSync(WELCOMED_MARKER, (/* @__PURE__ */ new Date()).toISOString());
   } catch {
   }
   await showWelcome();
@@ -3093,6 +4578,59 @@ function registerWelcome(program) {
   });
 }
 
+// src/commands/app.ts
+import fs21 from "fs";
+import os10 from "os";
+import path17 from "path";
+import { execFileSync as execFileSync4 } from "child_process";
+init_output();
+var APP_PATH = "/Applications/Sakura.app";
+function dmgUrl() {
+  const base = process.env.SAKURA_APP_BASE_URL || `https://github.com/Nishu0/sakura-tsnet/releases/download/v${VERSION}`;
+  return `${base}/Sakura.dmg`;
+}
+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}`);
+  fs21.writeFileSync(dest, Buffer.from(await res.arrayBuffer()));
+}
+async function install() {
+  if (process.platform !== "darwin") die("The Sakura menu bar app is macOS only.");
+  const tmp = fs21.mkdtempSync(path17.join(os10.tmpdir(), "sakura-app-"));
+  const dmg = path17.join(tmp, "Sakura.dmg");
+  const mount = path17.join(tmp, "mnt");
+  info(`Downloading Sakura.app ${VERSION}\u2026`);
+  try {
+    await download(dmgUrl(), dmg);
+  } catch (e) {
+    die(`${e.message}
+Build it yourself instead: ./mac/scripts/build-dmg.sh in the Sakura repo.`);
+  }
+  fs21.mkdirSync(mount);
+  execFileSync4("hdiutil", ["attach", dmg, "-nobrowse", "-quiet", "-mountpoint", mount]);
+  try {
+    try {
+      execFileSync4("osascript", ["-e", 'tell application id "mom.sakura.mac" to quit']);
+    } catch {
+    }
+    fs21.rmSync(APP_PATH, { recursive: true, force: true });
+    execFileSync4("ditto", [path17.join(mount, "Sakura.app"), APP_PATH]);
+  } finally {
+    execFileSync4("hdiutil", ["detach", mount, "-quiet"]);
+    fs21.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("open").description("Open the Sakura menu bar app").action(() => {
+    if (!fs21.existsSync(APP_PATH)) die("Sakura.app is not installed. Run `sakuraai app install`.");
+    execFileSync4("open", [APP_PATH]);
+  });
+}
+
 // src/index.ts
 init_manager();
 async function main() {
@@ -3116,6 +4654,7 @@ async function main() {
   registerConnectivity(program);
   registerPair(program);
   registerWelcome(program);
+  registerApp(program);
   program.showHelpAfterError("(add --help for usage)");
   await program.parseAsync(process.argv);
 }