@joeyshi12/casper 0.11.1 → 0.12.0

package/dist/server.js

@@ -29,7 +29,7 @@ var init_paths = __esm({
 });
 
 // server/src/cli/settings.ts
-import crypto from "node:crypto";
+import crypto2 from "node:crypto";
 import fs2 from "node:fs";
 import path3 from "node:path";
 function readSettings(file) {
@@ -50,7 +50,7 @@ function updateSettings(file, changes) {
   fs2.renameSync(tmp, file);
 }
 function generateToken() {
-  return crypto.randomBytes(24).toString("hex");
+  return crypto2.randomBytes(24).toString("hex");
 }
 function printTokenBlock(token, heading) {
   const line = "\u2500".repeat(Math.max(heading.length, token.length) + 2);
@@ -71,6 +71,17 @@ var init_settings = __esm({
   }
 });
 
+// server/src/util/hash.ts
+import { createHash } from "node:crypto";
+function sha256(text2) {
+  return createHash("sha256").update(text2).digest("hex");
+}
+var init_hash = __esm({
+  "server/src/util/hash.ts"() {
+    "use strict";
+  }
+});
+
 // server/src/cli/agentFile.ts
 var agentFile_exports = {};
 __export(agentFile_exports, {
@@ -78,7 +89,6 @@ __export(agentFile_exports, {
   agentPrompt: () => agentPrompt,
   installAgentFile: () => installAgentFile
 });
-import crypto2 from "node:crypto";
 import fs3 from "node:fs";
 import path4 from "node:path";
 import url from "node:url";
@@ -121,9 +131,6 @@ function agentConfig(prompt, mcp) {
     model: null
   };
 }
-function sha256(text2) {
-  return crypto2.createHash("sha256").update(text2).digest("hex");
-}
 function installAgentFile(home2, dataDir) {
   const target = path4.join(home2, ".kiro", "agents", "casper.json");
   const prompt = agentPrompt();
@@ -165,6 +172,7 @@ function installAgentFile(home2, dataDir) {
 var init_agentFile = __esm({
   "server/src/cli/agentFile.ts"() {
     "use strict";
+    init_hash();
   }
 });
 
@@ -320,7 +328,7 @@ var init_config = __esm({
        */
       defaultAgent: setting("DEFAULT_AGENT", "defaultAgent", "casper"),
       /**
-       * Filesystem root the file endpoints (/api/fs/dirs, /api/fs/image) are confined to; anything
+       * Filesystem root the file endpoints (/api/fs/dirs, /api/fs/file) are confined to; anything
        * resolving outside it is rejected. Defaults to /, so browsing spans everything the process
        * can read - set a narrower path to keep authenticated users out of system files such as /etc
        * or SSH keys.
@@ -386,7 +394,10 @@ var init_db = __esm({
 CREATE TABLE IF NOT EXISTS sessions (
   session_id TEXT PRIMARY KEY,
   title      TEXT,
-  cwd        TEXT
+  cwd        TEXT,
+  -- The chat that owns this session's uploads (see chats.ts). NULL for a session Casper did
+  -- not create; getChatId names those after the session.
+  chat_id    TEXT
 );
 CREATE TABLE IF NOT EXISTS logins (
   id           TEXT PRIMARY KEY,
@@ -396,6 +407,15 @@ CREATE TABLE IF NOT EXISTS logins (
   user_agent   TEXT
 );
 CREATE INDEX IF NOT EXISTS logins_hash ON logins (hash);
+CREATE TABLE IF NOT EXISTS message_attachments (
+  session_id TEXT    NOT NULL,
+  ordinal    INTEGER NOT NULL,
+  path       TEXT    NOT NULL,
+  name       TEXT    NOT NULL,
+  size       INTEGER NOT NULL,
+  kind       TEXT    NOT NULL,
+  PRIMARY KEY (session_id, ordinal, path)
+);
 `;
   }
 });
@@ -405,10 +425,7 @@ var logins_exports = {};
 __export(logins_exports, {
   LoginStore: () => LoginStore
 });
-import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
-function sha2562(s) {
-  return createHash("sha256").update(s).digest("hex");
-}
+import { randomBytes, timingSafeEqual } from "node:crypto";
 function sameHash(a, b) {
   if (a.length !== b.length) return false;
   return timingSafeEqual(Buffer.from(a, "hex"), Buffer.from(b, "hex"));
@@ -419,6 +436,7 @@ var init_logins = __esm({
     "use strict";
     init_config();
     init_db();
+    init_hash();
     LAST_SEEN_WRITE_INTERVAL_MS = 6e4;
     str = (v) => typeof v === "string" ? v : "";
     toRecord = (r) => ({
@@ -446,7 +464,7 @@ var init_logins = __esm({
         const nowIso = (/* @__PURE__ */ new Date()).toISOString();
         const record = {
           id: randomBytes(9).toString("base64url"),
-          hash: sha2562(token),
+          hash: sha256(token),
           createdAt: nowIso,
           lastSeenAt: nowIso,
           userAgent
@@ -464,7 +482,7 @@ var init_logins = __esm({
       verify(token) {
         if (!token) return null;
         const now = Date.now();
-        const row = db().prepare("SELECT * FROM logins WHERE hash = ?").get(sha2562(token));
+        const row = db().prepare("SELECT * FROM logins WHERE hash = ?").get(sha256(token));
         if (!row) return null;
         const record = toRecord(row);
         if (now - Date.parse(record.lastSeenAt) > this.ttlMs()) {
@@ -480,7 +498,7 @@ var init_logins = __esm({
       /** List all active devices, marking the one owning `currentToken`. */
       list(currentToken) {
         this.pruneExpired();
-        const currentHash = currentToken ? sha2562(currentToken) : void 0;
+        const currentHash = currentToken ? sha256(currentToken) : void 0;
         const rows = db().prepare("SELECT * FROM logins ORDER BY last_seen_at DESC").all();
         return rows.map(toRecord).map((r) => ({
           id: r.id,
@@ -493,7 +511,7 @@ var init_logins = __esm({
       /** Revoke the device holding this token (used on logout). */
       revokeToken(token) {
         if (!token) return;
-        db().prepare("DELETE FROM logins WHERE hash = ?").run(sha2562(token));
+        db().prepare("DELETE FROM logins WHERE hash = ?").run(sha256(token));
       }
       /** Revoke a device by its public id. Returns false if there was no such device. */
       revokeId(id) {
@@ -660,45 +678,20 @@ var init_acp = __esm({
 });
 
 // shared/dist/attachments.js
-function attachmentPaths(text2) {
-  const line = text2.split("\n").find((l) => l.startsWith(ATTACHMENTS_PREFIX));
-  if (!line)
-    return [];
-  return line.slice(ATTACHMENTS_PREFIX.length).split(", ").map((s) => s.trim()).filter(Boolean);
-}
-function imageAttachmentPaths(text2) {
-  return attachmentPaths(text2).filter((p) => {
-    const lower = p.toLowerCase();
-    return IMAGE_EXTS.some((ext) => lower.endsWith(ext));
-  });
-}
 function stripAttachmentsLine(text2) {
   return text2.split("\n").filter((l) => !l.startsWith(ATTACHMENTS_PREFIX)).join("\n").trim();
 }
-var ATTACHMENTS_PREFIX, IMAGE_EXTS;
+var ATTACHMENTS_PREFIX;
 var init_attachments = __esm({
   "shared/dist/attachments.js"() {
     "use strict";
     ATTACHMENTS_PREFIX = "Attached files: ";
-    IMAGE_EXTS = [".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg", ".bmp", ".ico", ".avif"];
   }
 });
 
 // shared/dist/observability.js
 function emptyObservabilitySnapshot() {
-  return {
-    turnStatus: "idle",
-    creditsSpent: 0,
-    lastTurnCredits: 0,
-    contextUsagePercentage: 0,
-    lastTurnDurationMs: 0,
-    subagents: [],
-    pendingStages: [],
-    mcpServers: [],
-    availableCommands: [],
-    oauthPrompts: [],
-    compacting: false
-  };
+  return { turnStatus: "idle", contextUsagePercentage: 0, compacting: false };
 }
 var init_observability = __esm({
   "shared/dist/observability.js"() {
@@ -806,27 +799,32 @@ var init_agents = __esm({
   }
 });
 
-// server/src/session/workspaces.ts
-import crypto3 from "node:crypto";
+// server/src/session/chats.ts
 import fs7 from "node:fs";
 import path8 from "node:path";
-function workspacesRoot() {
-  return path8.join(config.casperDataDir, "workspaces");
+function chatsRoot() {
+  return path8.join(config.casperDataDir, "chats");
 }
-function workspaceDir(workspaceId) {
-  return path8.join(workspacesRoot(), workspaceId);
+function chatDir(chatId) {
+  return path8.join(chatsRoot(), chatId);
 }
-function createWorkspace() {
-  const id = crypto3.randomUUID();
-  const dir = workspaceDir(id);
+function chatUploadsDir(chatId) {
+  return path8.join(chatDir(chatId), "uploads");
+}
+function chatWorkspaceDir(chatId) {
+  return path8.join(chatDir(chatId), "workspace");
+}
+function createChatWorkspace(chatId) {
+  const dir = chatWorkspaceDir(chatId);
   fs7.mkdirSync(dir, { recursive: true, mode: 448 });
-  return { id, dir };
+  return dir;
 }
-function isWorkspacePath(dir) {
-  return dir === workspacesRoot() || dir.startsWith(workspacesRoot() + path8.sep);
+function isManagedWorkspace(dir) {
+  const root = chatsRoot();
+  return dir === root || dir.startsWith(root + path8.sep);
 }
-var init_workspaces = __esm({
-  "server/src/session/workspaces.ts"() {
+var init_chats = __esm({
+  "server/src/session/chats.ts"() {
     "use strict";
     init_config();
   }
@@ -868,6 +866,9 @@ async function realConfineToRoot(root, absPath) {
 function isValidSessionId(id) {
   return /^[A-Za-z0-9._-]+$/.test(id) && id !== "." && !id.includes("..");
 }
+function isValidChatId(id) {
+  return !!id && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id);
+}
 var realRootCache;
 var init_paths2 = __esm({
   "server/src/util/paths.ts"() {
@@ -1083,9 +1084,9 @@ var init_KiroProcess = __esm({
         this.child.stdout.on("error", () => {
         });
       }
-      /** Perform the ACP initialize handshake. Idempotent. */
+      /** Perform the ACP initialize handshake. kiro's reply is not used. */
       async initialize() {
-        const result = await this.client.request(ACP_METHODS.initialize, {
+        await this.client.request(ACP_METHODS.initialize, {
           protocolVersion: 1,
           clientCapabilities: {
             fs: { readTextFile: false, writeTextFile: false },
@@ -1095,7 +1096,6 @@ var init_KiroProcess = __esm({
           // worth wiring to package.json.
           clientInfo: { name: "casper", version: "0.5.0" }
         });
-        return result;
       }
       newSession(params) {
         return this.client.request(ACP_METHODS.sessionNew, params);
@@ -1120,10 +1120,10 @@ var init_KiroProcess = __esm({
       setModel(sessionId, modelId) {
         return this.client.request(ACP_METHODS.sessionSetModel, { sessionId, modelId });
       }
-      execCommand(sessionId, command, args) {
+      execCommand(sessionId, command) {
         return this.client.request(ACP_METHODS.commandsExecute, {
           sessionId,
-          command: { command: command.replace(/^\//, ""), args: args ? { input: args } : {} }
+          command: { command: command.replace(/^\//, ""), args: {} }
         });
       }
       /** Cleanly shut down: close stdin (triggers kiro's graceful exit), then kill. */
@@ -1255,83 +1255,36 @@ var init_TurnState = __esm({
       get() {
         return this.snapshot;
       }
-      /** Apply one event; returns the updated snapshot. */
       apply(payload) {
         const s = this.snapshot;
         switch (payload.kind) {
-          case "turn_started": {
-            this.snapshot = { ...s, turnStatus: "running", currentTurnStartedAt: Date.now() };
+          case "turn_started":
+            this.snapshot = { ...s, turnStatus: "running" };
             break;
-          }
-          case "turn_ended": {
-            this.snapshot = { ...s, turnStatus: "idle", currentTurnStartedAt: void 0 };
+          case "turn_ended":
+          case "turn_error":
+            this.snapshot = { ...s, turnStatus: "idle" };
             break;
-          }
-          case "turn_error": {
-            this.snapshot = { ...s, turnStatus: "idle", currentTurnStartedAt: void 0 };
-            break;
-          }
-          case "process_exited": {
-            this.snapshot = { ...s, turnStatus: "idle", currentTurnStartedAt: void 0 };
-            break;
-          }
-          case "metadata": {
-            const p = payload.params;
-            const turnCredits = (p.meteringUsage ?? []).reduce((sum, m) => sum + m.value, 0);
-            this.snapshot = {
-              ...s,
-              contextUsagePercentage: p.contextUsagePercentage ?? s.contextUsagePercentage,
-              // meteringUsage is emitted per-turn; accumulate into the session total.
-              creditsSpent: turnCredits > 0 ? s.creditsSpent + turnCredits : s.creditsSpent,
-              lastTurnCredits: turnCredits > 0 ? turnCredits : s.lastTurnCredits,
-              lastTurnDurationMs: p.turnDurationMs ?? s.lastTurnDurationMs
-            };
+          case "process_exited":
+            this.snapshot = { ...s, turnStatus: "idle", compacting: false };
             break;
-          }
-          case "subagent_update": {
+          case "metadata":
             this.snapshot = {
               ...s,
-              subagents: payload.params.subagents,
-              pendingStages: payload.params.pendingStages
+              contextUsagePercentage: payload.params.contextUsagePercentage ?? s.contextUsagePercentage
             };
             break;
-          }
-          case "mcp_health": {
-            const { serverName, error } = payload.params;
-            const status = payload.ok ? "initialized" : "failed";
-            const next = s.mcpServers.filter((m) => m.serverName !== serverName);
-            next.push({ serverName, status, error, updatedAt: Date.now() });
-            this.snapshot = { ...s, mcpServers: next };
-            break;
-          }
-          case "commands_available": {
-            this.snapshot = { ...s, availableCommands: payload.params.commands };
-            break;
-          }
-          case "compaction": {
+          case "compaction":
             this.snapshot = { ...s, compacting: payload.params.status.type === "started" };
             break;
-          }
-          case "oauth_request": {
-            const prompts = [
-              ...s.oauthPrompts,
-              {
-                serverName: payload.params.serverName,
-                url: payload.params.url,
-                createdAt: Date.now()
-              }
-            ];
-            this.snapshot = { ...s, oauthPrompts: prompts };
-            break;
-          }
           default:
             break;
         }
         return this.snapshot;
       }
-      /** Seed cumulative credits/context from kiro's persisted metadata on resume. */
-      seed(creditsSpent, contextUsagePercentage) {
-        this.snapshot = { ...this.snapshot, creditsSpent, contextUsagePercentage };
+      /** Seed context usage from kiro's persisted metadata on resume. */
+      seed(contextUsagePercentage) {
+        this.snapshot = { ...this.snapshot, contextUsagePercentage };
       }
     };
   }
@@ -1369,13 +1322,12 @@ function renderableBlocks(content) {
 function summarize(j) {
   const state = j.session_state;
   const turns = state?.conversation_metadata?.user_turn_metadatas ?? [];
-  const creditsSpent = turns.reduce(
-    (sum, t) => sum + (t.metering_usage ?? []).reduce((a, m) => a + m.value, 0),
-    0
-  );
   const contextUsagePercentage = state?.rts_model_state?.context_usage_percentage ?? turns[turns.length - 1]?.context_usage_percentage;
   return {
     sessionId: j.session_id,
+    // kiro's file knows nothing about chats; summaryOf replaces this with the recorded id
+    // when there is one, and this matches what getChatId names a session without a row.
+    chatId: j.session_id,
     // Left empty when kiro has not named it; resolveSessionTitle decides what to show.
     title: j.title?.trim() ?? "",
     cwd: j.cwd,
@@ -1385,7 +1337,6 @@ function summarize(j) {
     agentId: state?.agent_name,
     modelId: state?.rts_model_state?.model_info?.model_id,
     running: false,
-    creditsSpent,
     contextUsagePercentage
   };
 }
@@ -1417,6 +1368,7 @@ async function deletePersistedSession(sessionId) {
     path10.join(config.kiroSessionsDir, `${sessionId}.json`),
     path10.join(config.kiroSessionsDir, `${sessionId}.jsonl`),
     path10.join(config.kiroSessionsDir, `${sessionId}.history`),
+    path10.join(config.kiroSessionsDir, `${sessionId}.lock`),
     path10.join(config.kiroSessionsDir, sessionId)
   ];
   await Promise.all(targets.map((f) => fs9.rm(f, { recursive: true, force: true })));
@@ -1433,48 +1385,54 @@ async function readPersistedSession(sessionId) {
     return null;
   }
 }
-async function hasRecordedTurns(sessionId) {
-  if (!isValidSessionId(sessionId)) return false;
-  try {
-    const st = await fs9.stat(path10.join(config.kiroSessionsDir, `${sessionId}.jsonl`));
-    return st.size > 0;
-  } catch {
-    return false;
-  }
+async function promptCount(sessionId) {
+  const entries = await readJsonlEntries(sessionId);
+  return entries.filter((e) => e.kind === "Prompt").length;
 }
-async function hydrateTranscript(sessionId) {
+async function readJsonlEntries(sessionId) {
   if (!isValidSessionId(sessionId)) return [];
   let raw;
   try {
-    raw = await fs9.readFile(
-      path10.join(config.kiroSessionsDir, `${sessionId}.jsonl`),
-      "utf8"
-    );
+    raw = await fs9.readFile(path10.join(config.kiroSessionsDir, `${sessionId}.jsonl`), "utf8");
   } catch {
     return [];
   }
-  const items = [];
-  const toolsById = /* @__PURE__ */ new Map();
+  const entries = [];
   for (const line of raw.split("\n")) {
     const trimmed = line.trim();
     if (!trimmed) continue;
-    let entry;
     try {
-      entry = JSON.parse(trimmed);
+      entries.push(JSON.parse(trimmed));
     } catch {
-      continue;
     }
+  }
+  return entries;
+}
+async function hasRecordedTurns(sessionId) {
+  if (!isValidSessionId(sessionId)) return false;
+  try {
+    const st = await fs9.stat(path10.join(config.kiroSessionsDir, `${sessionId}.jsonl`));
+    return st.size > 0;
+  } catch {
+    return false;
+  }
+}
+async function hydrateTranscript(sessionId, attachments) {
+  const items = [];
+  let userOrdinal = 0;
+  const toolsById = /* @__PURE__ */ new Map();
+  for (const entry of await readJsonlEntries(sessionId)) {
     const content = contentBlocks(entry.data.content);
     const textOf = (kind) => content.filter((c) => c.kind === kind).map(blockText).join("");
     const baseId = entry.data.message_id ?? `${items.length}`;
     const ts = entry.data.meta?.timestamp;
     const pushMsg = (msg) => items.push({ type: "message", message: msg });
     if (entry.kind === "Prompt") {
-      const raw2 = textOf("text");
-      const text2 = stripAttachmentsLine(raw2);
-      const imagePaths = imageAttachmentPaths(raw2);
-      if (text2.trim() || imagePaths.length)
-        pushMsg({ id: `u-${baseId}`, role: "user", text: text2, timestamp: ts, imagePaths });
+      const text2 = stripAttachmentsLine(textOf("text"));
+      const attached = attachments?.get(userOrdinal);
+      userOrdinal++;
+      if (text2.trim() || attached?.length)
+        pushMsg({ id: `u-${baseId}`, role: "user", text: text2, timestamp: ts, attachments: attached });
     } else if (entry.kind === "AssistantMessage") {
       const thinking = textOf("thinking");
       if (thinking.trim())
@@ -1543,9 +1501,52 @@ var init_sessionStore = __esm({
       setCwd(sessionId, cwd) {
         this.write(sessionId, "cwd", cwd);
       }
+      /**
+       * The chat that owns this session's uploads. A session Casper did not create has no row -
+       * one started with kiro-cli directly still shows up in the list - so it is named after the
+       * session, which gives it one stable directory rather than a new one per call.
+       */
+      getChatId(sessionId) {
+        return this.read(sessionId, "chat_id") ?? sessionId;
+      }
+      setChatId(sessionId, chatId) {
+        this.write(sessionId, "chat_id", chatId);
+      }
+      /** Record what was attached to one prompt. See db.ts for why the key is an ordinal. */
+      setAttachments(sessionId, ordinal, files) {
+        if (files.length === 0) return;
+        const stmt = db().prepare(
+          `INSERT INTO message_attachments (session_id, ordinal, path, name, size, kind)
+       VALUES (?, ?, ?, ?, ?, ?)
+       ON CONFLICT(session_id, ordinal, path) DO NOTHING`
+        );
+        for (const f of files) {
+          stmt.run(sessionId, ordinal, f.path, f.name, f.size, f.kind);
+        }
+      }
+      /** Every attachment in a session, grouped by the message it belongs to. */
+      attachmentsBySession(sessionId) {
+        const rows = db().prepare(
+          `SELECT ordinal, path, name, size, kind FROM message_attachments
+         WHERE session_id = ? ORDER BY ordinal, path`
+        ).all(sessionId);
+        const out = /* @__PURE__ */ new Map();
+        for (const r of rows) {
+          const list = out.get(r.ordinal) ?? [];
+          list.push({
+            path: r.path,
+            name: r.name,
+            size: r.size,
+            kind: r.kind
+          });
+          out.set(r.ordinal, list);
+        }
+        return out;
+      }
       /** Forget every override for a session, when it's permanently deleted. */
       remove(sessionId) {
         db().prepare("DELETE FROM sessions WHERE session_id = ?").run(sessionId);
+        db().prepare("DELETE FROM message_attachments WHERE session_id = ?").run(sessionId);
       }
       read(sessionId, column) {
         const row = db().prepare(`SELECT ${column} AS value FROM sessions WHERE session_id = ?`).get(sessionId);
@@ -1590,18 +1591,8 @@ function mapNotification(n) {
       return { kind: "session_update", update: n.params.update };
     case KIRO_NOTIFICATIONS.metadata:
       return { kind: "metadata", params: n.params };
-    case KIRO_NOTIFICATIONS.subagentListUpdate:
-      return { kind: "subagent_update", params: n.params };
-    case KIRO_NOTIFICATIONS.mcpServerInitialized:
-      return { kind: "mcp_health", params: n.params, ok: true };
-    case KIRO_NOTIFICATIONS.mcpServerInitFailure:
-      return { kind: "mcp_health", params: n.params, ok: false };
-    case KIRO_NOTIFICATIONS.commandsAvailable:
-      return { kind: "commands_available", params: n.params };
     case KIRO_NOTIFICATIONS.compactionStatus:
       return { kind: "compaction", params: n.params };
-    case KIRO_NOTIFICATIONS.mcpOauthRequest:
-      return { kind: "oauth_request", params: n.params };
     default:
       return null;
   }
@@ -1623,7 +1614,7 @@ var init_SessionManager = __esm({
     init_dist();
     init_config();
     init_agents();
-    init_workspaces();
+    init_chats();
     init_paths2();
     init_KiroProcess();
     init_EventStore();
@@ -1635,6 +1626,8 @@ var init_SessionManager = __esm({
       store;
       turnState = new TurnState();
       cwd;
+      /** The chat that owns this session's uploads. See chats.ts. */
+      chatId;
       agentId;
       modelId;
       currentModeId;
@@ -1703,7 +1696,7 @@ var init_SessionManager = __esm({
           override: this.store.getTitle(sessionId),
           kiroTitle: parts.kiroTitle,
           firstPrompt: parts.firstPrompt,
-          folder: isWorkspacePath(parts.cwd) ? void 0 : path11.basename(parts.cwd)
+          folder: isManagedWorkspace(parts.cwd) ? void 0 : path11.basename(parts.cwd)
         });
       }
       /** Set a user title override for a session. */
@@ -1714,9 +1707,7 @@ var init_SessionManager = __esm({
         if (s) s.title = clean || s.title;
       }
       /**
-       * Re-point a session at a different working directory, for when the original was moved
-       * or deleted. Validates and creates the target exactly like a new session's cwd, so a
-       * folder is only created on this explicit action. Any live process was spawned with the
+       * Re-point a session at a different working directory. Any live process was spawned with the
        * old cwd, so it is disposed and the next turn respawns in the new one, transcript intact.
        */
       async setSessionCwd(sessionId, input) {
@@ -1732,28 +1723,22 @@ var init_SessionManager = __esm({
         return resolved;
       }
       /**
-       * Restart the session's kiro child, so everything kiro only reads when a child
-       * starts is read again: the agent definition, the workspace's `.kiro` directory,
-       * and the MCP servers kiro launches for itself.
+       * Restart the session's kiro child, so what kiro reads only at startup is read again: the
+       * agent definition, the workspace's `.kiro`, and the MCP servers kiro launches itself.
+       * Replacing the process is the only way - no ACP method does it, and `session/set_mode`
+       * leaves those MCP servers alone.
        *
-       * No ACP method does this. kiro advertises no reload command, and `session/set_mode`
-       * leaves the MCP servers it started alone, so replacing the process is the only
-       * way - the transcript comes back with `session/load`.
-       *
-       * The old child is awaited out before the new one starts, because kiro flushes its
-       * session file on shutdown and the replacement reads that file to reload the
-       * conversation. Respawned eagerly rather than at the next prompt, so the caller
-       * gets a detail that reflects what the fresh process reported.
-       *
-       * Needs a session that has recorded a turn, so it can be loaded back. Verified
-       * against kiro 2.11: loading one with an empty event log fails with "Session not
-       * found", and kiro deletes both its files when that process exits.
+       * The old child must be awaited out first: kiro flushes its session file on shutdown and
+       * the replacement reads that file to reload the conversation.
        */
       async reloadSession(sessionId) {
         const s = await this.ensureOpen(sessionId);
         if (s.running) {
           throw new Error("Cannot reload while a turn is running");
         }
+        if (s.turnState.get().compacting) {
+          throw new Error("Cannot reload while the conversation is being compacted");
+        }
         if (s.reloading) {
           throw new Error("A reload is already running for this session");
         }
@@ -1840,10 +1825,7 @@ var init_SessionManager = __esm({
         s.createdAt = persisted.createdAt;
         s.updatedAt = persisted.updatedAt;
         s.markLive();
-        s.turnState.seed(
-          persisted.creditsSpent ?? 0,
-          persisted.contextUsagePercentage ?? 0
-        );
+        s.turnState.seed(persisted.contextUsagePercentage ?? 0);
         this.sessions.set(sessionId, s);
         return s;
       }
@@ -1931,7 +1913,8 @@ var init_SessionManager = __esm({
       // -------------------------------------------------------------------------
       /** Create a new session. Spawns immediately so we get a real kiro sessionId. */
       async createSession(opts) {
-        const cwd = opts.freshWorkspace ? createWorkspace().dir : resolveCwd(opts.cwd);
+        const chatId = isValidChatId(opts.chatId) ? opts.chatId : crypto.randomUUID();
+        const cwd = opts.freshWorkspace ? createChatWorkspace(chatId) : resolveCwd(opts.cwd);
         const tempId = `pending-${Date.now()}-${Math.floor(this.sessions.size)}`;
         const store = new EventStore(tempId);
         const s = new Session(tempId, store, cwd);
@@ -1945,6 +1928,8 @@ var init_SessionManager = __esm({
           this.evict(s.sessionId);
           throw err;
         }
+        this.store.setChatId(s.sessionId, chatId);
+        s.chatId = chatId;
         const name = sanitizeTitle(opts.title ?? "") || (opts.freshWorkspace ? "" : path11.basename(s.cwd));
         if (name) {
           this.store.setTitle(s.sessionId, name);
@@ -1955,7 +1940,7 @@ var init_SessionManager = __esm({
       // -------------------------------------------------------------------------
       // Actions - these spawn the process lazily.
       // -------------------------------------------------------------------------
-      async runPrompt(sessionId, content) {
+      async runPrompt(sessionId, content, attachments) {
         const s = await this.ensureOpen(sessionId);
         await this.settleReload(s);
         if (s.running) throw new Error("A turn is already running for this session");
@@ -1975,7 +1960,13 @@ var init_SessionManager = __esm({
             s.title = title;
           }
         }
-        s.record({ kind: "turn_started", prompt: content });
+        let recorded;
+        if (attachments?.length) {
+          const ordinal = await promptCount(s.sessionId);
+          this.store.setAttachments(s.sessionId, ordinal, attachments);
+          recorded = attachments;
+        }
+        s.record({ kind: "turn_started", prompt: content, attachments: recorded });
         proc.prompt({ sessionId: s.sessionId, prompt: content }).then((res) => s.record({ kind: "turn_ended", stopReason: res.stopReason })).catch((err) => {
           this.log.error({ err, sessionId: s.sessionId }, "prompt turn failed");
           const tail = proc.stderrTail();
@@ -2010,19 +2001,28 @@ ${tail}` : err.message;
         s.modelId = modelId;
         s.lastActivity = Date.now();
       }
-      async execCommand(sessionId, command, args) {
+      async execCommand(sessionId, command) {
         const s = await this.ensureOpen(sessionId);
         await this.settleReload(s);
         const proc = await this.ensureProc(s);
-        await proc.execCommand(s.sessionId, command, args);
+        await proc.execCommand(s.sessionId, command);
         s.lastActivity = Date.now();
       }
+      // -------------------------------------------------------------------------
+      // Listing / detail - never spawns.
+      // -------------------------------------------------------------------------
+      /**
+       * The one place a SessionSummary is assembled: kiro's file and Casper's live state each hold
+       * part of the truth, so every read path projects them through here. `persisted` is absent for
+       * a session with no file yet, `live` for a dormant one, and callers guarantee one of them.
+       */
       summaryOf(live, persisted, transcript) {
         const sessionId = live?.sessionId ?? persisted.sessionId;
         const snap = live?.turnState.get();
         const cwd = live?.cwd ?? this.store.getCwd(sessionId) ?? persisted.cwd;
         return {
           sessionId,
+          chatId: live?.chatId ?? this.store.getChatId(sessionId),
           title: this.titleOf(sessionId, {
             // kiro's file is what kiro called it; the live copy is only a cache of it.
             kiroTitle: persisted?.title || live?.title,
@@ -2037,9 +2037,8 @@ ${tail}` : err.message;
           agentId: live?.agentId ?? persisted?.agentId,
           modelId: live?.modelId ?? persisted?.modelId,
           running: live?.running ?? false,
-          // A dormant session's totals live in kiro's file; a live one's snapshot
-          // starts at zero until the first turn reports, so fall back to the file.
-          creditsSpent: snap?.creditsSpent || persisted?.creditsSpent,
+          // A live snapshot starts at zero until the first turn reports, so a dormant
+          // session's value comes from kiro's file.
           contextUsagePercentage: snap?.contextUsagePercentage || persisted?.contextUsagePercentage
         };
       }
@@ -2061,25 +2060,12 @@ ${tail}` : err.message;
       }
       async getDetail(sessionId) {
         const [transcript, persisted] = await Promise.all([
-          hydrateTranscript(sessionId),
+          hydrateTranscript(sessionId, this.store.attachmentsBySession(sessionId)),
           readPersistedSession(sessionId)
         ]);
         const s = this.sessions.get(sessionId);
-        if (s) return this.buildDetail(s, transcript, persisted ?? void 0);
-        if (!persisted) throw new Error(`Unknown session: ${sessionId}`);
-        return {
-          summary: this.summaryOf(void 0, persisted, transcript),
-          modes: [],
-          currentModeId: persisted.agentId,
-          transcript: transcript.slice(-TRANSCRIPT_PAGE_SIZE),
-          transcriptTotal: transcript.length,
-          observability: {
-            ...emptyObservabilitySnapshot(),
-            creditsSpent: persisted.creditsSpent ?? 0,
-            contextUsagePercentage: persisted.contextUsagePercentage ?? 0
-          },
-          head: 0
-        };
+        if (!s && !persisted) throw new Error(`Unknown session: ${sessionId}`);
+        return this.buildDetail(s, transcript, persisted ?? void 0);
       }
       /**
        * A slice of the transcript for lazy "load older on scroll up". Re-hydrates
@@ -2087,29 +2073,34 @@ ${tail}` : err.message;
        * requested window. offset/limit are clamped to the transcript bounds.
        */
       async getTranscriptPage(sessionId, offset, limit) {
-        const transcript = await hydrateTranscript(sessionId);
+        const transcript = await hydrateTranscript(
+          sessionId,
+          this.store.attachmentsBySession(sessionId)
+        );
         const start = Math.max(0, Math.min(offset, transcript.length));
         const end = Math.max(start, Math.min(start + limit, transcript.length));
         return transcript.slice(start, end);
       }
+      /** One projection, so a dormant session and a live one cannot disagree. */
       buildDetail(s, transcript, persisted) {
-        const snap = s.turnState.get();
         return {
           summary: this.summaryOf(s, persisted, transcript),
-          modes: s.availableModes,
-          currentModeId: s.currentModeId,
+          modes: s?.availableModes ?? [],
+          currentModeId: s?.currentModeId ?? persisted?.agentId,
           // Only the tail is sent on load; replayHead/title use the full transcript.
           transcript: transcript.slice(-TRANSCRIPT_PAGE_SIZE),
           transcriptTotal: transcript.length,
-          observability: snap,
-          head: this.replayHead(s, transcript)
+          observability: s?.turnState.get() ?? {
+            ...emptyObservabilitySnapshot(),
+            contextUsagePercentage: persisted?.contextUsagePercentage ?? 0
+          },
+          head: s ? this.replayHead(s, transcript) : 0
         };
       }
       /**
-       * The cursor a reconnecting client should start from. Normally the store head, but kiro writes
-       * a turn to its jsonl only once the turn completes, so a hydrated transcript is missing one in
-       * flight. Rewind to just before its turn_started and let the WS replay the whole turn. Guarded
-       * against duplication in case kiro ever persists the prompt at turn start.
+       * The cursor a reconnecting client starts from. Normally the store head, but kiro writes a turn
+       * to its jsonl only once it completes, so a hydrated transcript is missing one in flight:
+       * rewind to just before its turn_started and let the socket replay the whole turn.
        */
       replayHead(s, transcript) {
         const head = s.store.head();
@@ -2214,13 +2205,17 @@ var init_rateLimit = __esm({
 });
 
 // server/src/routes/auth.ts
-import crypto4 from "node:crypto";
+import crypto3 from "node:crypto";
 import fastifyCookie from "@fastify/cookie";
+function logins() {
+  loginStore ??= new LoginStore();
+  return loginStore;
+}
 function secretMatches(supplied, expected) {
   if (typeof supplied !== "string") return false;
-  const a = crypto4.createHash("sha256").update(supplied).digest();
-  const b = crypto4.createHash("sha256").update(expected).digest();
-  return crypto4.timingSafeEqual(a, b);
+  const a = crypto3.createHash("sha256").update(supplied).digest();
+  const b = crypto3.createHash("sha256").update(expected).digest();
+  return crypto3.timingSafeEqual(a, b);
 }
 function extractToken(req) {
   const auth = req.headers["authorization"];
@@ -2238,7 +2233,7 @@ function sessionToken(req) {
   return req.cookies?.[SESSION_COOKIE];
 }
 function hasValidSession(req) {
-  return logins.verify(sessionToken(req)) !== null;
+  return logins().verify(sessionToken(req)) !== null;
 }
 function cookieOptions() {
   return {
@@ -2266,27 +2261,27 @@ async function registerAuth(app) {
       loginLimiter.succeed(req.ip);
     }
     const ua = req.headers["user-agent"];
-    const { token } = logins.create(typeof ua === "string" ? ua : void 0);
+    const { token } = logins().create(typeof ua === "string" ? ua : void 0);
     reply.setCookie(SESSION_COOKIE, token, cookieOptions());
     return { ok: true };
   });
   app.post("/api/logout", async (req, reply) => {
-    logins.revokeToken(sessionToken(req));
+    logins().revokeToken(sessionToken(req));
     reply.clearCookie(SESSION_COOKIE, { path: "/" });
     return { ok: true };
   });
   app.get("/api/devices", async (req) => {
-    return { devices: logins.list(sessionToken(req)) };
+    return { devices: logins().list(sessionToken(req)) };
   });
   app.delete("/api/devices/:id", async (req, reply) => {
     const { id } = req.params;
-    const current = logins.list(sessionToken(req)).find((d) => d.current);
-    const removed = logins.revokeId(id);
+    const current = logins().list(sessionToken(req)).find((d) => d.current);
+    const removed = logins().revokeId(id);
     if (current?.id === id) reply.clearCookie(SESSION_COOKIE, { path: "/" });
     return { ok: removed };
   });
   app.post("/api/logout-all", async (_req, reply) => {
-    logins.revokeAll();
+    logins().revokeAll();
     reply.clearCookie(SESSION_COOKIE, { path: "/" });
     return { ok: true };
   });
@@ -2298,7 +2293,7 @@ async function registerAuth(app) {
     reply.code(401).send({ error: "Unauthorized: log in first" });
   });
 }
-var SESSION_COOKIE, logins, loginLimiter;
+var SESSION_COOKIE, loginStore, loginLimiter;
 var init_auth = __esm({
   "server/src/routes/auth.ts"() {
     "use strict";
@@ -2306,7 +2301,6 @@ var init_auth = __esm({
     init_logins();
     init_rateLimit();
     SESSION_COOKIE = "casper.sid";
-    logins = new LoginStore();
     loginLimiter = new AttemptLimiter(10, 15 * 60 * 1e3);
   }
 });
@@ -2520,15 +2514,15 @@ function looksBinary(buf) {
 }
 function classifyKind(name) {
   const ext = path13.extname(name).toLowerCase();
-  if (ext in IMAGE_EXTS2) return "image";
+  if (ext in IMAGE_EXTS) return "image";
   if (TEXT_EXTS.has(ext)) return "text";
   return "binary";
 }
-var IMAGE_EXTS2, TEXT_EXTS, MIME_MAP;
+var IMAGE_EXTS, TEXT_EXTS, MIME_MAP;
 var init_filekind = __esm({
   "server/src/util/filekind.ts"() {
     "use strict";
-    IMAGE_EXTS2 = {
+    IMAGE_EXTS = {
       ".png": "image/png",
       ".jpg": "image/jpeg",
       ".jpeg": "image/jpeg",
@@ -2600,7 +2594,7 @@ var init_filekind = __esm({
       ".tex"
     ]);
     MIME_MAP = {
-      ...IMAGE_EXTS2,
+      ...IMAGE_EXTS,
       ".txt": "text/plain",
       ".md": "text/markdown",
       ".csv": "text/csv",
@@ -2628,10 +2622,128 @@ var init_filekind = __esm({
   }
 });
 
-// server/src/routes/fs.ts
+// server/src/routes/filePreview.ts
 import fs12 from "node:fs/promises";
 import { createReadStream } from "node:fs";
 import path14 from "node:path";
+function tooLargeForPreview(size, maxBytes) {
+  return {
+    error: `File too large for preview (${(size / 1024 / 1024).toFixed(1)} MB, max ${maxBytes / 1024 / 1024} MB)`
+  };
+}
+function hexdump(buf) {
+  const lines = [];
+  for (let off = 0; off < buf.length; off += 16) {
+    const slice = buf.subarray(off, off + 16);
+    const hex = [];
+    let ascii = "";
+    for (let i = 0; i < 16; i++) {
+      if (i < slice.length) {
+        const b = slice[i];
+        hex.push(b.toString(16).padStart(2, "0"));
+        ascii += b >= 32 && b <= 126 ? String.fromCharCode(b) : ".";
+      } else {
+        hex.push("  ");
+      }
+      if (i === 7) hex.push("");
+    }
+    lines.push(`${off.toString(16).padStart(8, "0")}  ${hex.join(" ")}  |${ascii}|`);
+  }
+  return lines.join("\n");
+}
+async function sendFilePreview(req, reply, realTarget, stat) {
+  const ext = path14.extname(realTarget).toLowerCase();
+  const mime = mimeForExt(ext);
+  const isImage = mime.startsWith("image/");
+  const isPdf = mime === "application/pdf";
+  const isHtml = mime === "text/html" && req.query.raw === "1";
+  const kind = classifyKind(realTarget);
+  if (isImage || isPdf) {
+    if (stat.size > MAX_IMAGE_PREVIEW_BYTES) {
+      reply.code(413);
+      return tooLargeForPreview(stat.size, MAX_IMAGE_PREVIEW_BYTES);
+    }
+  } else if (kind !== "binary") {
+    if (stat.size > MAX_TEXT_PREVIEW_BYTES) {
+      reply.code(413);
+      return tooLargeForPreview(stat.size, MAX_TEXT_PREVIEW_BYTES);
+    }
+  }
+  if (isHtml) {
+    if (stat.size > MAX_TEXT_PREVIEW_BYTES) {
+      reply.code(413);
+      return tooLargeForPreview(stat.size, MAX_TEXT_PREVIEW_BYTES);
+    }
+    reply.header("Content-Security-Policy", "sandbox allow-scripts allow-forms");
+    reply.header("Content-Type", "text/html; charset=utf-8");
+    reply.header("Cache-Control", "no-store");
+    return reply.send(createReadStream(realTarget));
+  }
+  if (isImage || isPdf) {
+    const etag = `W/"${stat.size}-${stat.mtimeMs}"`;
+    reply.header("Cache-Control", "private, no-cache");
+    reply.header("ETag", etag);
+    reply.header("Last-Modified", stat.mtime.toUTCString());
+    const ifNoneMatch = req.headers["if-none-match"];
+    if (ifNoneMatch === etag) {
+      reply.code(304);
+      return reply.send();
+    }
+    reply.header("Content-Type", mime);
+    reply.header("Content-Disposition", "inline");
+    reply.header("Content-Length", stat.size);
+    return reply.send(createReadStream(realTarget));
+  }
+  if (kind === "binary") {
+    let fh;
+    try {
+      fh = await fs12.open(realTarget, "r");
+      const buf = Buffer.alloc(Math.min(HEXDUMP_BYTES, stat.size));
+      const { bytesRead } = await fh.read(buf, 0, buf.length, 0);
+      const head = buf.subarray(0, bytesRead);
+      if (!looksBinary(head)) {
+        if (stat.size > MAX_TEXT_PREVIEW_BYTES) {
+          reply.code(413);
+          return tooLargeForPreview(stat.size, MAX_TEXT_PREVIEW_BYTES);
+        }
+        reply.header("Content-Type", "text/plain; charset=utf-8");
+        reply.header("Content-Disposition", "inline");
+        reply.header("Content-Length", stat.size);
+        return reply.send(createReadStream(realTarget));
+      }
+      const dump = hexdump(head);
+      const header = `Binary file - ${stat.size} bytes
+Showing first ${bytesRead} bytes as hexdump:
+
+`;
+      const body = header + dump + (stat.size > bytesRead ? "\n\n\u2026 (truncated)" : "");
+      reply.header("Content-Type", "text/plain; charset=utf-8");
+      reply.header("Content-Disposition", "inline");
+      return reply.send(body);
+    } finally {
+      await fh?.close();
+    }
+  }
+  reply.header("Content-Type", "text/plain; charset=utf-8");
+  reply.header("Content-Disposition", "inline");
+  reply.header("Content-Length", stat.size);
+  return reply.send(createReadStream(realTarget));
+}
+var HEXDUMP_BYTES, MAX_TEXT_PREVIEW_BYTES, MAX_IMAGE_PREVIEW_BYTES;
+var init_filePreview = __esm({
+  "server/src/routes/filePreview.ts"() {
+    "use strict";
+    init_filekind();
+    HEXDUMP_BYTES = 4096;
+    MAX_TEXT_PREVIEW_BYTES = 1024 * 1024;
+    MAX_IMAGE_PREVIEW_BYTES = 20 * 1024 * 1024;
+  }
+});
+
+// server/src/routes/fs.ts
+import fs13 from "node:fs/promises";
+import { createReadStream as createReadStream2 } from "node:fs";
+import path15 from "node:path";
 function registerFsRoutes(app) {
   app.get(
     "/api/fs/dirs",
@@ -2639,10 +2751,10 @@ function registerFsRoutes(app) {
       const input = (req.query.path ?? "").trim();
       const base = config.defaultCwd;
       const endsWithSep = input.endsWith("/");
-      const resolved = input ? path14.resolve(base, input) : base;
-      const dir = endsWithSep || !input ? resolved : path14.dirname(resolved);
-      const prefix = endsWithSep || !input ? "" : path14.basename(resolved);
-      const targetKind = await fs12.stat(resolved).then((s) => s.isDirectory() ? "directory" : "file").catch(() => "missing");
+      const resolved = input ? path15.resolve(base, input) : base;
+      const dir = endsWithSep || !input ? resolved : path15.dirname(resolved);
+      const prefix = endsWithSep || !input ? "" : path15.basename(resolved);
+      const targetKind = await fs13.stat(resolved).then((s) => s.isDirectory() ? "directory" : "file").catch(() => "missing");
       const listing = await resolveAbsolutePath(dir, "directory");
       if (!listing.ok) {
         if (listing.status === 403) return replyWith(reply, listing);
@@ -2651,7 +2763,7 @@ function registerFsRoutes(app) {
       const realDir = listing.real;
       let entries = [];
       try {
-        const dirents = await fs12.readdir(realDir, { withFileTypes: true });
+        const dirents = await fs13.readdir(realDir, { withFileTypes: true });
         const checks2 = await Promise.all(
           dirents.map(async (d) => {
             const target = await classifyDirent(realDir, d, absoluteRoots());
@@ -2662,7 +2774,7 @@ function registerFsRoutes(app) {
         entries = checks2.filter((name) => name !== null).filter((name) => name.toLowerCase().startsWith(prefix.toLowerCase())).sort((a, b) => {
           if (isDot(a) !== isDot(b)) return isDot(a) ? 1 : -1;
           return a.localeCompare(b);
-        }).slice(0, 500).map((name) => path14.join(dir, name));
+        }).slice(0, 500).map((name) => path15.join(dir, name));
       } catch {
         entries = [];
       }
@@ -2670,51 +2782,38 @@ function registerFsRoutes(app) {
     }
   );
   app.get(
-    "/api/fs/image",
+    "/api/fs/file",
     async (req, reply) => {
       const filePath = (req.query.path ?? "").trim();
       if (!filePath) {
         reply.code(400);
         return { error: "path parameter is required" };
       }
-      if (!path14.isAbsolute(filePath)) {
+      if (!path15.isAbsolute(filePath)) {
         reply.code(400);
         return { error: "path must be absolute" };
       }
-      const ext = path14.extname(filePath).toLowerCase();
-      if (classifyKind(filePath) !== "image") {
-        reply.code(400);
-        return { error: `Not a supported image type: ${ext}` };
-      }
-      const resolvedImage = await resolveAbsolutePath(filePath, "file");
-      if (!resolvedImage.ok) return replyWith(reply, resolvedImage);
-      const { real, stat } = resolvedImage;
-      if (stat.size > MAX_IMAGE_BYTES) {
-        reply.code(413);
-        return { error: "Image too large" };
-      }
-      const etag = `W/"${stat.size}-${stat.mtimeMs}"`;
-      reply.header("Cache-Control", "private, no-cache");
-      reply.header("ETag", etag);
-      reply.header("Last-Modified", stat.mtime.toUTCString());
-      if (req.headers["if-none-match"] === etag) {
-        reply.code(304);
-        return reply.send();
+      const resolved = await resolveAbsolutePath(filePath, "file");
+      if (!resolved.ok) return replyWith(reply, resolved);
+      if (req.query.download === "1") {
+        reply.header("Content-Type", "application/octet-stream");
+        reply.header(
+          "Content-Disposition",
+          `attachment; filename="${path15.basename(resolved.real).replace(/"/g, "")}"`
+        );
+        reply.header("Content-Length", resolved.stat.size);
+        return reply.send(createReadStream2(resolved.real));
       }
-      reply.header("Content-Type", mimeForExt(ext));
-      reply.header("Content-Length", stat.size);
-      return reply.send(createReadStream(real));
+      return sendFilePreview(req, reply, resolved.real, resolved.stat);
     }
   );
 }
-var MAX_IMAGE_BYTES;
 var init_fs = __esm({
   "server/src/routes/fs.ts"() {
     "use strict";
     init_config();
     init_confinedFile();
-    init_filekind();
-    MAX_IMAGE_BYTES = 20 * 1024 * 1024;
+    init_filePreview();
   }
 });
 
@@ -2731,7 +2830,11 @@ function registerSessionRoutes(app, manager) {
         agentId: body.agentId,
         modelId: body.modelId,
         freshWorkspace: body.freshWorkspace,
-        title: body.title
+        title: body.title,
+        // Not optional in practice: the client's chat already owns any file uploaded before
+        // the session existed, so dropping it here strands those files under an id nothing
+        // refers to again.
+        chatId: body.chatId
       });
     } catch (err) {
       reply.code(400);
@@ -2767,7 +2870,7 @@ function registerSessionRoutes(app, manager) {
     "/api/sessions/:id/prompt",
     async (req, reply) => {
       try {
-        await manager.runPrompt(req.params.id, req.body.prompt);
+        await manager.runPrompt(req.params.id, req.body.prompt, req.body.attachments);
         return { ok: true };
       } catch (err) {
         reply.code(400);
@@ -2836,34 +2939,9 @@ var init_sessions = __esm({
 });
 
 // server/src/routes/workspace.ts
-import fs13 from "node:fs/promises";
-import { createReadStream as createReadStream2 } from "node:fs";
-import path15 from "node:path";
-function tooLargeForPreview(size, maxBytes) {
-  return {
-    error: `File too large for preview (${(size / 1024 / 1024).toFixed(1)} MB, max ${maxBytes / 1024 / 1024} MB)`
-  };
-}
-function hexdump(buf) {
-  const lines = [];
-  for (let off = 0; off < buf.length; off += 16) {
-    const slice = buf.subarray(off, off + 16);
-    const hex = [];
-    let ascii = "";
-    for (let i = 0; i < 16; i++) {
-      if (i < slice.length) {
-        const b = slice[i];
-        hex.push(b.toString(16).padStart(2, "0"));
-        ascii += b >= 32 && b <= 126 ? String.fromCharCode(b) : ".";
-      } else {
-        hex.push("  ");
-      }
-      if (i === 7) hex.push("");
-    }
-    lines.push(`${off.toString(16).padStart(8, "0")}  ${hex.join(" ")}  |${ascii}|`);
-  }
-  return lines.join("\n");
-}
+import fs14 from "node:fs/promises";
+import { createReadStream as createReadStream3 } from "node:fs";
+import path16 from "node:path";
 function registerWorkspaceRoutes(app, manager) {
   app.get(
     "/api/sessions/:id/tree",
@@ -2878,7 +2956,7 @@ function registerWorkspaceRoutes(app, manager) {
       const { cwd, relative, real: realTarget } = resolved;
       let dirents;
       try {
-        dirents = await fs13.readdir(realTarget, { withFileTypes: true, encoding: "utf8" });
+        dirents = await fs14.readdir(realTarget, { withFileTypes: true, encoding: "utf8" });
       } catch {
         return replyWith(reply, await workspaceNotFound(cwd));
       }
@@ -2892,7 +2970,7 @@ function registerWorkspaceRoutes(app, manager) {
           continue;
         }
         try {
-          const stat = await fs13.stat(target.real);
+          const stat = await fs14.stat(target.real);
           entries.push({
             name: d.name,
             path: entryRelative,
@@ -2921,8 +2999,8 @@ function registerWorkspaceRoutes(app, manager) {
         reply.code(413);
         return { error: `File too large (${(stat.size / 1024 / 1024).toFixed(1)} MB, max 100 MB)` };
       }
-      const ext = path15.extname(realTarget);
-      const filename = path15.basename(realTarget);
+      const ext = path16.extname(realTarget);
+      const filename = path16.basename(realTarget);
       const asciiName = filename.replace(/[^\w.\-]/g, "_");
       reply.header("Content-Type", mimeForExt(ext));
       reply.header(
@@ -2930,7 +3008,7 @@ function registerWorkspaceRoutes(app, manager) {
         `attachment; filename="${asciiName}"; filename*=UTF-8''${encodeURIComponent(filename)}`
       );
       reply.header("Content-Length", stat.size);
-      return reply.send(createReadStream2(realTarget));
+      return reply.send(createReadStream3(realTarget));
     }
   );
   app.get(
@@ -2939,132 +3017,52 @@ function registerWorkspaceRoutes(app, manager) {
       const resolved = await resolveSessionPath(manager, req.params.id, req.query.path, "file");
       if (!resolved.ok) return replyWith(reply, resolved);
       const { real: realTarget, stat } = resolved;
-      const ext = path15.extname(realTarget).toLowerCase();
-      const mime = mimeForExt(ext);
-      const isImage = mime.startsWith("image/");
-      const isPdf = mime === "application/pdf";
-      const isHtml = mime === "text/html" && req.query.raw === "1";
-      const kind = classifyKind(realTarget);
-      if (isImage || isPdf) {
-        if (stat.size > MAX_IMAGE_PREVIEW_BYTES) {
-          reply.code(413);
-          return tooLargeForPreview(stat.size, MAX_IMAGE_PREVIEW_BYTES);
-        }
-      } else if (kind !== "binary") {
-        if (stat.size > MAX_TEXT_PREVIEW_BYTES) {
-          reply.code(413);
-          return tooLargeForPreview(stat.size, MAX_TEXT_PREVIEW_BYTES);
-        }
-      }
-      if (isHtml) {
-        if (stat.size > MAX_TEXT_PREVIEW_BYTES) {
-          reply.code(413);
-          return tooLargeForPreview(stat.size, MAX_TEXT_PREVIEW_BYTES);
-        }
-        reply.header("Content-Security-Policy", "sandbox allow-scripts allow-forms");
-        reply.header("Content-Type", "text/html; charset=utf-8");
-        reply.header("Cache-Control", "no-store");
-        return reply.send(createReadStream2(realTarget));
-      }
-      if (isImage || isPdf) {
-        const etag = `W/"${stat.size}-${stat.mtimeMs}"`;
-        reply.header("Cache-Control", "private, no-cache");
-        reply.header("ETag", etag);
-        reply.header("Last-Modified", stat.mtime.toUTCString());
-        const ifNoneMatch = req.headers["if-none-match"];
-        if (ifNoneMatch === etag) {
-          reply.code(304);
-          return reply.send();
-        }
-        reply.header("Content-Type", mime);
-        reply.header("Content-Disposition", "inline");
-        reply.header("Content-Length", stat.size);
-        return reply.send(createReadStream2(realTarget));
-      }
-      if (kind === "binary") {
-        let fh;
-        try {
-          fh = await fs13.open(realTarget, "r");
-          const buf = Buffer.alloc(Math.min(HEXDUMP_BYTES, stat.size));
-          const { bytesRead } = await fh.read(buf, 0, buf.length, 0);
-          const head = buf.subarray(0, bytesRead);
-          if (!looksBinary(head)) {
-            if (stat.size > MAX_TEXT_PREVIEW_BYTES) {
-              reply.code(413);
-              return tooLargeForPreview(stat.size, MAX_TEXT_PREVIEW_BYTES);
-            }
-            reply.header("Content-Type", "text/plain; charset=utf-8");
-            reply.header("Content-Disposition", "inline");
-            reply.header("Content-Length", stat.size);
-            return reply.send(createReadStream2(realTarget));
-          }
-          const dump = hexdump(head);
-          const header = `Binary file - ${stat.size} bytes
-Showing first ${bytesRead} bytes as hexdump:
-
-`;
-          const body = header + dump + (stat.size > bytesRead ? "\n\n\u2026 (truncated)" : "");
-          reply.header("Content-Type", "text/plain; charset=utf-8");
-          reply.header("Content-Disposition", "inline");
-          return reply.send(body);
-        } finally {
-          await fh?.close();
-        }
-      }
-      reply.header("Content-Type", "text/plain; charset=utf-8");
-      reply.header("Content-Disposition", "inline");
-      reply.header("Content-Length", stat.size);
-      return reply.send(createReadStream2(realTarget));
+      return sendFilePreview(req, reply, realTarget, stat);
     }
   );
 }
-var MAX_DOWNLOAD_BYTES, HEXDUMP_BYTES, MAX_TEXT_PREVIEW_BYTES, MAX_IMAGE_PREVIEW_BYTES;
+var MAX_DOWNLOAD_BYTES;
 var init_workspace = __esm({
   "server/src/routes/workspace.ts"() {
     "use strict";
     init_config();
     init_confinedFile();
     init_filekind();
+    init_filePreview();
     MAX_DOWNLOAD_BYTES = 100 * 1024 * 1024;
-    HEXDUMP_BYTES = 4096;
-    MAX_TEXT_PREVIEW_BYTES = 1024 * 1024;
-    MAX_IMAGE_PREVIEW_BYTES = 20 * 1024 * 1024;
   }
 });
 
 // server/src/routes/uploads.ts
-import { createReadStream as createReadStream3, createWriteStream } from "node:fs";
-import fs14 from "node:fs/promises";
-import path16 from "node:path";
-import crypto5 from "node:crypto";
+import { createReadStream as createReadStream4, createWriteStream } from "node:fs";
+import fs15 from "node:fs/promises";
+import path17 from "node:path";
+import crypto4 from "node:crypto";
 import { execFile as execFile3 } from "node:child_process";
 import { pipeline } from "node:stream/promises";
-function uploadDirFor(sessionId) {
-  return path16.join(config.casperDataDir, "sessions", sessionId, "uploads");
-}
 function sanitizeName(raw) {
-  const base = path16.basename(raw).replace(/[^\w.\- ]/g, "_").trim();
+  const base = path17.basename(raw).replace(/[^\w.\- ]/g, "_").trim();
   if (!base || base === "." || base === "..") return `upload-${Date.now()}`;
   return base.replace(/^\.+/, "") || `upload-${Date.now()}`;
 }
 async function uniquePath(dir, name) {
-  const ext = path16.extname(name);
+  const ext = path17.extname(name);
   const stem = name.slice(0, name.length - ext.length);
   let candidate = name;
   let n = 1;
   while (true) {
     try {
-      await fs14.access(path16.join(dir, candidate));
+      await fs15.access(path17.join(dir, candidate));
       candidate = `${stem} (${n++})${ext}`;
     } catch {
-      return path16.join(dir, candidate);
+      return path17.join(dir, candidate);
     }
   }
 }
 function sha256File(absPath) {
   return new Promise((resolve, reject) => {
-    const hash = crypto5.createHash("sha256");
-    createReadStream3(absPath).on("data", (d) => hash.update(d)).on("end", () => resolve(hash.digest("hex"))).on("error", reject);
+    const hash = crypto4.createHash("sha256");
+    createReadStream4(absPath).on("data", (d) => hash.update(d)).on("end", () => resolve(hash.digest("hex"))).on("error", reject);
   });
 }
 function fileType(absPath) {
@@ -3077,7 +3075,7 @@ function fileType(absPath) {
 async function sampleStrings(absPath, limit = 40) {
   let fh;
   try {
-    fh = await fs14.open(absPath, "r");
+    fh = await fs15.open(absPath, "r");
     const buf = Buffer.alloc(STRINGS_SCAN_BYTES);
     const { bytesRead } = await fh.read(buf, 0, STRINGS_SCAN_BYTES, 0);
     const out = [];
@@ -3100,22 +3098,16 @@ async function sampleStrings(absPath, limit = 40) {
     await fh?.close();
   }
 }
-function registerUploadRoutes(app, manager) {
+function registerUploadRoutes(app) {
   app.post(
-    "/api/sessions/:id/uploads",
+    "/api/chats/:chatId/uploads",
     async (req, reply) => {
-      try {
-        await manager.getSessionCwd(req.params.id);
-      } catch {
-        reply.code(404);
-        return { error: "Session not found" };
-      }
-      if (!isValidSessionId(req.params.id)) {
+      if (!isValidChatId(req.params.chatId)) {
         reply.code(400);
-        return { error: "Invalid session id" };
+        return { error: "Invalid chat id" };
       }
-      const uploadDir = uploadDirFor(req.params.id);
-      await fs14.mkdir(uploadDir, { recursive: true, mode: 448 });
+      const uploadDir = chatUploadsDir(req.params.chatId);
+      await fs15.mkdir(uploadDir, { recursive: true, mode: 448 });
       const results = [];
       const parts = req.files();
       for await (const part of parts) {
@@ -3129,17 +3121,17 @@ function registerUploadRoutes(app, manager) {
           return { error: `Failed to store ${name}` };
         }
         if (part.file.truncated) {
-          await fs14.rm(dest, { force: true });
+          await fs15.rm(dest, { force: true });
           reply.code(413);
           return {
             error: `${name} exceeds the max upload size (${Math.round(config.maxUploadBytes / 1024 / 1024)} MB)`
           };
         }
-        const stat = await fs14.stat(dest);
-        const ext = path16.extname(dest);
+        const stat = await fs15.stat(dest);
+        const ext = path17.extname(dest);
         const kind = classifyKind(dest);
         const uploaded = {
-          name: path16.basename(dest),
+          name: path17.basename(dest),
           // Absolute, because the file sits outside the session's workspace: a
           // relative path would resolve against the wrong root for both the agent
           // and the image endpoint.
@@ -3149,14 +3141,14 @@ function registerUploadRoutes(app, manager) {
           kind
         };
         if (kind === "binary") {
-          const [type, sha2563, strings] = await Promise.all([
+          const [type, sha2562, strings] = await Promise.all([
             fileType(dest),
             sha256File(dest),
             sampleStrings(dest)
           ]);
           uploaded.triage = {
             fileType: type || void 0,
-            sha256: sha2563,
+            sha256: sha2562,
             strings: strings.length ? strings : void 0
           };
         }
@@ -3174,6 +3166,7 @@ var init_uploads = __esm({
     init_config();
     init_filekind();
     init_paths2();
+    init_chats();
     STRINGS_SCAN_BYTES = 256 * 1024;
   }
 });
@@ -3197,7 +3190,7 @@ var init_health = __esm({
 });
 
 // server/src/ws/dirWatchers.ts
-import fs15 from "node:fs";
+import fs16 from "node:fs";
 function diffWatchSet(current, next) {
   const have = new Set(current);
   const want = new Set(next.slice(0, MAX_WATCHES));
@@ -3221,7 +3214,7 @@ function createDirWatchers(opts) {
     const target = await opts.resolve(relative);
     if (!target || closed) return;
     try {
-      const watcher = fs15.watch(target, { persistent: false }, () => {
+      const watcher = fs16.watch(target, { persistent: false }, () => {
         const existing = timers.get(relative);
         if (existing) clearTimeout(existing);
         timers.set(
@@ -3279,7 +3272,7 @@ function handleConnection(socket, manager, sessionId, startCursor) {
         return null;
       }
     },
-    onChange: (path19) => send(socket, { type: "fs_changed", path: path19 })
+    onChange: (path20) => send(socket, { type: "fs_changed", path: path20 })
   });
   const forward = (event) => {
     if (event.seq <= cursor) return;
@@ -3330,7 +3323,7 @@ function handleConnection(socket, manager, sessionId, startCursor) {
       case "watch_paths":
         return watchers.sync(msg.paths);
       case "prompt":
-        return ack("prompt", () => manager.runPrompt(sessionId, msg.content));
+        return ack("prompt", () => manager.runPrompt(sessionId, msg.content, msg.attachments));
       case "cancel":
         return ack("cancel", () => manager.cancel(sessionId));
       case "set_mode":
@@ -3340,7 +3333,7 @@ function handleConnection(socket, manager, sessionId, startCursor) {
       case "exec_command":
         return ack(
           "exec_command",
-          () => manager.execCommand(sessionId, msg.command, msg.args)
+          () => manager.execCommand(sessionId, msg.command)
         );
       default:
         return send(socket, { type: "error", message: "Unknown message type" });
@@ -3412,9 +3405,8 @@ var init_gateway = __esm({
 });
 
 // server/src/app.ts
-import fs16 from "node:fs";
+import fs17 from "node:fs";
 import Fastify from "fastify";
-import cors from "@fastify/cors";
 import websocket from "@fastify/websocket";
 import fastifyStatic from "@fastify/static";
 import multipart from "@fastify/multipart";
@@ -3434,7 +3426,6 @@ async function buildApp() {
   });
   const manager = new SessionManager(logger);
   const startedAt = Date.now();
-  await app.register(cors, { origin: true });
   await app.register(websocket, {
     options: { maxPayload: 16 * 1024 * 1024 }
   });
@@ -3448,22 +3439,22 @@ async function buildApp() {
   registerFsRoutes(app);
   registerSessionRoutes(app, manager);
   registerWorkspaceRoutes(app, manager);
-  registerUploadRoutes(app, manager);
+  registerUploadRoutes(app);
   registerWsGateway(app, manager);
-  if (fs16.existsSync(config.webDist)) {
+  if (fs17.existsSync(config.webDist)) {
     await app.register(fastifyStatic, {
       root: config.webDist
     });
     app.addHook("onSend", async (req, reply) => {
-      const path19 = req.url.split("?")[0] ?? "";
-      if (path19 === "/manifest.json" || path19.startsWith("/icons/")) {
+      const path20 = req.url.split("?")[0] ?? "";
+      if (path20 === "/manifest.json" || path20.startsWith("/icons/")) {
         reply.header("cache-control", "public, max-age=300");
       }
     });
     app.setNotFoundHandler((req, reply) => {
-      const path19 = req.url.split("?")[0] ?? "";
-      const looksLikeAsset = path19.startsWith("/assets/") || /\.[a-zA-Z0-9]+$/.test(path19);
-      if (path19.startsWith("/api/") || path19.startsWith("/ws") || looksLikeAsset) {
+      const path20 = req.url.split("?")[0] ?? "";
+      const looksLikeAsset = path20.startsWith("/assets/") || /\.[a-zA-Z0-9]+$/.test(path20);
+      if (path20.startsWith("/api/") || path20.startsWith("/ws") || looksLikeAsset) {
         reply.code(404).send({ error: "Not found" });
         return;
       }
@@ -3537,15 +3528,15 @@ __export(doctor_exports, {
   mcpWiring: () => mcpWiring
 });
 import { execFileSync as execFileSync3 } from "node:child_process";
-import fs17 from "node:fs";
-import path17 from "node:path";
+import fs18 from "node:fs";
+import path18 from "node:path";
 function which(bin) {
-  if (bin.includes("/")) return fs17.existsSync(bin) ? bin : void 0;
-  for (const dir of (process.env.PATH ?? "").split(path17.delimiter)) {
+  if (bin.includes("/")) return fs18.existsSync(bin) ? bin : void 0;
+  for (const dir of (process.env.PATH ?? "").split(path18.delimiter)) {
     if (dir === "") continue;
-    const candidate = path17.join(dir, bin);
+    const candidate = path18.join(dir, bin);
     try {
-      fs17.accessSync(candidate, fs17.constants.X_OK);
+      fs18.accessSync(candidate, fs18.constants.X_OK);
       return candidate;
     } catch {
     }
@@ -3569,7 +3560,7 @@ function mcpWiring(agentJson, resolve) {
     return { ok: false, detail: `${command || "(no command)"} not found - widgets are unavailable` };
   }
   const script = args.find((a) => a.endsWith(".js"));
-  if (script && !fs17.existsSync(script)) {
+  if (script && !fs18.existsSync(script)) {
     return { ok: false, detail: `${script} is gone - delete the agent file and restart to rewrite it` };
   }
   return { ok: true, detail: script ?? `${command} ${args.join(" ")}` };
@@ -3601,7 +3592,7 @@ function checks() {
   const settings = readSettings(config.configFile);
   const hasToken = typeof settings.token === "string" && settings.token !== "";
   out.push(
-    fs17.existsSync(config.configFile) ? {
+    fs18.existsSync(config.configFile) ? {
       ok: hasToken,
       name: "settings",
       detail: hasToken ? `${config.configFile} (token set)` : `${config.configFile} exists but has no token - auth is DISABLED`
@@ -3611,8 +3602,8 @@ function checks() {
       detail: `${config.configFile} not found; a token is generated on first run`
     }
   );
-  if (fs17.existsSync(config.configFile)) {
-    const mode = fs17.statSync(config.configFile).mode & 511;
+  if (fs18.existsSync(config.configFile)) {
+    const mode = fs18.statSync(config.configFile).mode & 511;
     out.push({
       ok: mode === 384,
       name: "settings mode",
@@ -3620,10 +3611,10 @@ function checks() {
     });
   }
   try {
-    fs17.mkdirSync(config.casperDataDir, { recursive: true });
-    fs17.accessSync(config.casperDataDir, fs17.constants.W_OK);
-    const db2 = path17.join(config.casperDataDir, "casper.db");
-    const size = fs17.existsSync(db2) ? `, casper.db ${(fs17.statSync(db2).size / 1024).toFixed(0)} KB` : "";
+    fs18.mkdirSync(config.casperDataDir, { recursive: true });
+    fs18.accessSync(config.casperDataDir, fs18.constants.W_OK);
+    const db2 = path18.join(config.casperDataDir, "casper.db");
+    const size = fs18.existsSync(db2) ? `, casper.db ${(fs18.statSync(db2).size / 1024).toFixed(0)} KB` : "";
     out.push({ ok: true, name: "data dir", detail: `${config.casperDataDir} writable${size}` });
   } catch (err) {
     out.push({
@@ -3634,22 +3625,22 @@ function checks() {
     });
   }
   out.push(
-    fs17.existsSync(config.webDist) ? { ok: true, name: "web app", detail: config.webDist } : {
+    fs18.existsSync(config.webDist) ? { ok: true, name: "web app", detail: config.webDist } : {
       ok: false,
       fatal: true,
       name: "web app",
       detail: `${config.webDist} not found - the package is incomplete or CASPER_WEB_DIST is wrong`
     }
   );
-  const agent = path17.join(config.kiroSessionsDir, "..", "..", "agents", "casper.json");
-  const hasAgent = fs17.existsSync(agent);
+  const agent = path18.join(config.kiroSessionsDir, "..", "..", "agents", "casper.json");
+  const hasAgent = fs18.existsSync(agent);
   out.push({
     ok: hasAgent,
     name: "casper agent",
     detail: hasAgent ? agent : `${agent} missing - it is installed on first run`
   });
   if (hasAgent) {
-    const wiring = mcpWiring(fs17.readFileSync(agent, "utf8"), which);
+    const wiring = mcpWiring(fs18.readFileSync(agent, "utf8"), which);
     out.push({ ok: wiring.ok, name: "casper mcp", detail: wiring.detail });
   }
   return out;
@@ -4113,14 +4104,14 @@ var init_server2 = __esm({
   "server/src/mcp/server.ts"() {
     "use strict";
     init_protocol();
-    VERSION = true ? "0.11.1" : "dev";
+    VERSION = true ? "0.12.0" : "dev";
   }
 });
 
 // server/src/cli/program.ts
-import fs18 from "node:fs";
+import fs19 from "node:fs";
 import os4 from "node:os";
-import path18 from "node:path";
+import path19 from "node:path";
 
 // server/node_modules/commander/lib/error.js
 var CommanderError = class extends Error {
@@ -7233,9 +7224,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
    * @param {string} [path]
    * @return {(string|null|Command)}
    */
-  executableDir(path19) {
-    if (path19 === void 0) return this._executableDir;
-    this._executableDir = path19;
+  executableDir(path20) {
+    if (path20 === void 0) return this._executableDir;
+    this._executableDir = path20;
     return this;
   }
   /**
@@ -7493,7 +7484,7 @@ var program = new Command();
 // server/src/cli/program.ts
 init_paths();
 init_settings();
-var VERSION2 = true ? "0.11.1" : "dev";
+var VERSION2 = true ? "0.12.0" : "dev";
 async function bootstrap() {
   const file = configFilePath();
   const settings = readSettings(file);
@@ -7539,8 +7530,8 @@ async function resetToken(value) {
   updateSettings(file, { token });
   process.stdout.write(`wrote a new token to ${file}
 `);
-  const dbFile = path18.join(dataDirPath(), "casper.db");
-  if (fs18.existsSync(dbFile)) {
+  const dbFile = path19.join(dataDirPath(), "casper.db");
+  if (fs19.existsSync(dbFile)) {
     const { LoginStore: LoginStore2 } = await Promise.resolve().then(() => (init_logins(), logins_exports));
     new LoginStore2().revokeAll();
     process.stdout.write("revoked all device sessions\n");
@@ -7557,26 +7548,26 @@ async function resetToken(value) {
 }
 function buildProgram() {
   const program2 = new Command();
-  program2.name("casper").description("Web client for kiro-cli over the Agent Client Protocol").version(VERSION2, "-v, --version").showHelpAfterError().allowUnknownOption(false).allowExcessArguments(false).addHelpText("after", `
+  program2.name("casper").description("Web client for kiro-cli over the Agent Client Protocol").version(VERSION2, "-v, --version").showHelpAfterError().addHelpText("after", `
 Settings live in ${configFilePath()}.
 Update with: npm install -g @joeyshi12/casper`);
-  program2.command("start").description("run the server in the foreground").allowUnknownOption(false).allowExcessArguments(false).action(async () => {
+  program2.command("start").description("run the server in the foreground").action(async () => {
     await bootstrap();
     const { serve: serve2 } = await Promise.resolve().then(() => (init_server(), server_exports));
     await serve2();
   });
-  program2.command("token").description("print the access token").allowUnknownOption(false).allowExcessArguments(false).action(printToken);
-  program2.command("reset-token").argument("[value]", "token to set; generated when omitted").description("set a new token and sign every device out").allowUnknownOption(false).allowExcessArguments(false).action(async (value) => {
+  program2.command("token").description("print the access token").action(printToken);
+  program2.command("reset-token").argument("[value]", "token to set; generated when omitted").description("set a new token and sign every device out").action(async (value) => {
     await resetToken(value);
   });
-  program2.command("doctor").description("check kiro-cli, settings, data directory and web app").allowUnknownOption(false).allowExcessArguments(false).action(async () => {
+  program2.command("doctor").description("check kiro-cli, settings, data directory and web app").action(async () => {
     process.exitCode = (await Promise.resolve().then(() => (init_doctor(), doctor_exports))).doctor();
   });
-  program2.command("mcp").description("run the generative-UI MCP server on stdio (kiro spawns this itself)").allowUnknownOption(false).allowExcessArguments(false).action(async () => {
+  program2.command("mcp").description("run the generative-UI MCP server on stdio (kiro spawns this itself)").action(async () => {
     (await Promise.resolve().then(() => (init_server2(), server_exports2))).runMcpServer();
   });
   const service = program2.command("service").description("manage the systemd user service");
-  const svcCommand = (name, describe, run) => service.command(name).description(describe).allowUnknownOption(false).allowExcessArguments(false).action(async () => {
+  const svcCommand = (name, describe, run) => service.command(name).description(describe).action(async () => {
     process.exitCode = run(await Promise.resolve().then(() => (init_service(), service_exports)));
   });
   svcCommand("install", "run Casper as a systemd user service", (m) => m.serviceInstall());