@joeyshi12/casper 0.11.1 → 0.13.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.
@@ -383,8 +391,9 @@ var init_db = __esm({
     "use strict";
     init_config();
     SCHEMA = `
-CREATE TABLE IF NOT EXISTS sessions (
-  session_id TEXT PRIMARY KEY,
+CREATE TABLE IF NOT EXISTS chats (
+  chat_id    TEXT PRIMARY KEY,
+  session_id TEXT UNIQUE,
   title      TEXT,
   cwd        TEXT
 );
@@ -396,6 +405,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 (
+  chat_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 (chat_id, ordinal, path)
+);
 `;
   }
 });
@@ -405,10 +423,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 +434,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 +462,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 +480,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 +496,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 +509,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 +676,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 +797,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 chatDir(chatId) {
+  return path8.join(chatsRoot(), chatId);
 }
-function workspaceDir(workspaceId) {
-  return path8.join(workspacesRoot(), workspaceId);
+function chatUploadsDir(chatId) {
+  return path8.join(chatDir(chatId), "uploads");
 }
-function createWorkspace() {
-  const id = crypto3.randomUUID();
-  const dir = workspaceDir(id);
+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 +864,9 @@ async function realConfineToRoot(root, absPath) {
 function isValidSessionId(id) {
   return /^[A-Za-z0-9._-]+$/.test(id) && id !== "." && !id.includes("..");
 }
+function isValidChatId(id) {
+  return !!id && isValidSessionId(id);
+}
 var realRootCache;
 var init_paths2 = __esm({
   "server/src/util/paths.ts"() {
@@ -1083,9 +1082,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 +1094,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 +1118,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. */
@@ -1192,13 +1190,13 @@ var init_EventStore = __esm({
     "use strict";
     init_config();
     EventStore = class extends EventEmitter4 {
-      sessionId;
+      chatId;
       buffer = [];
       capacity;
       seq = 0;
-      constructor(sessionId) {
+      constructor(chatId) {
         super();
-        this.sessionId = sessionId;
+        this.chatId = chatId;
         this.capacity = config.eventBufferSize;
       }
       /** Append an event, assign it the next seq, and fan it out. */
@@ -1207,7 +1205,7 @@ var init_EventStore = __esm({
         const event = {
           seq: this.seq,
           ts: Date.now(),
-          sessionId: this.sessionId,
+          chatId: this.chatId,
           payload
         };
         this.buffer.push(event);
@@ -1255,83 +1253,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 };
+          case "process_exited":
+            this.snapshot = { ...s, turnStatus: "idle", compacting: false };
             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
-            };
-            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,10 +1320,6 @@ 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,
@@ -1381,42 +1328,18 @@ function summarize(j) {
     cwd: j.cwd,
     createdAt: j.created_at,
     updatedAt: j.updated_at,
-    liveness: "dormant",
     agentId: state?.agent_name,
     modelId: state?.rts_model_state?.model_info?.model_id,
-    running: false,
-    creditsSpent,
     contextUsagePercentage
   };
 }
-async function listPersistedSessions(log) {
-  let files;
-  try {
-    files = await fs9.readdir(config.kiroSessionsDir);
-  } catch {
-    return [];
-  }
-  const jsonFiles = files.filter((f) => f.endsWith(".json"));
-  const summaries = [];
-  await Promise.all(
-    jsonFiles.map(async (f) => {
-      try {
-        const raw = await fs9.readFile(path10.join(config.kiroSessionsDir, f), "utf8");
-        summaries.push(summarize(JSON.parse(raw)));
-      } catch (err) {
-        log.debug({ err, f }, "kiroFiles: skipping unreadable session file");
-      }
-    })
-  );
-  summaries.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
-  return summaries;
-}
 async function deletePersistedSession(sessionId) {
   if (!isValidSessionId(sessionId)) return;
   const targets = [
     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 +1356,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())
@@ -1524,38 +1453,92 @@ var init_kiroFiles = __esm({
   }
 });
 
-// server/src/session/sessionStore.ts
-var SessionStore;
-var init_sessionStore = __esm({
-  "server/src/session/sessionStore.ts"() {
+// server/src/session/chatStore.ts
+var ChatStore;
+var init_chatStore = __esm({
+  "server/src/session/chatStore.ts"() {
     "use strict";
     init_db();
-    SessionStore = class {
-      getTitle(sessionId) {
-        return this.read(sessionId, "title");
+    ChatStore = class {
+      /** Every chat. Ordering is kiro's business, applied once the file is joined on. */
+      all() {
+        return db().prepare("SELECT chat_id, session_id, title, cwd FROM chats").all().map((r) => ({ chatId: r.chat_id, sessionId: r.session_id, title: r.title, cwd: r.cwd }));
+      }
+      get(chatId) {
+        const r = db().prepare("SELECT chat_id, session_id, title, cwd FROM chats WHERE chat_id = ?").get(chatId);
+        return r ? { chatId: r.chat_id, sessionId: r.session_id, title: r.title, cwd: r.cwd } : void 0;
+      }
+      create(chatId) {
+        db().prepare("INSERT INTO chats (chat_id) VALUES (?) ON CONFLICT(chat_id) DO NOTHING").run(chatId);
+      }
+      /**
+       * kiro names the session once it starts one; bind it to the chat that owns it. A session
+       * belongs to exactly one chat, so any earlier claim on it is released.
+       */
+      bindSession(chatId, sessionId) {
+        db().prepare("UPDATE chats SET session_id = NULL WHERE session_id = ? AND chat_id <> ?").run(sessionId, chatId);
+        this.write(chatId, "session_id", sessionId);
+      }
+      sessionIdForChat(chatId) {
+        const row = db().prepare("SELECT session_id FROM chats WHERE chat_id = ?").get(chatId);
+        return row?.session_id ?? void 0;
       }
-      setTitle(sessionId, title) {
-        this.write(sessionId, "title", title);
+      getTitle(chatId) {
+        return this.read(chatId, "title");
       }
-      getCwd(sessionId) {
-        return this.read(sessionId, "cwd");
+      setTitle(chatId, title) {
+        this.write(chatId, "title", title);
       }
-      setCwd(sessionId, cwd) {
-        this.write(sessionId, "cwd", cwd);
+      getCwd(chatId) {
+        return this.read(chatId, "cwd");
       }
-      /** Forget every override for a session, when it's permanently deleted. */
-      remove(sessionId) {
-        db().prepare("DELETE FROM sessions WHERE session_id = ?").run(sessionId);
+      setCwd(chatId, cwd) {
+        this.write(chatId, "cwd", cwd);
       }
-      read(sessionId, column) {
-        const row = db().prepare(`SELECT ${column} AS value FROM sessions WHERE session_id = ?`).get(sessionId);
+      /** Record what was attached to one prompt. See db.ts for why the key is an ordinal. */
+      setAttachments(chatId, ordinal, files) {
+        if (files.length === 0) return;
+        const stmt = db().prepare(
+          `INSERT INTO message_attachments (chat_id, ordinal, path, name, size, kind)
+       VALUES (?, ?, ?, ?, ?, ?)
+       ON CONFLICT(chat_id, ordinal, path) DO NOTHING`
+        );
+        for (const f of files) {
+          stmt.run(chatId, ordinal, f.path, f.name, f.size, f.kind);
+        }
+      }
+      /** Every attachment in a chat, grouped by the message it belongs to. */
+      attachmentsByChat(chatId) {
+        const rows = db().prepare(
+          `SELECT ordinal, path, name, size, kind FROM message_attachments
+         WHERE chat_id = ? ORDER BY ordinal, path`
+        ).all(chatId);
+        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;
+      }
+      remove(chatId) {
+        db().prepare("DELETE FROM chats WHERE chat_id = ?").run(chatId);
+        db().prepare("DELETE FROM message_attachments WHERE chat_id = ?").run(chatId);
+      }
+      read(chatId, column) {
+        const row = db().prepare(`SELECT ${column} AS value FROM chats WHERE chat_id = ?`).get(chatId);
         return row?.value ?? void 0;
       }
-      write(sessionId, column, value) {
+      write(chatId, column, value) {
         db().prepare(
-          `INSERT INTO sessions (session_id, ${column}) VALUES (?, ?)
-         ON CONFLICT(session_id) DO UPDATE SET ${column} = excluded.${column}`
-        ).run(sessionId, value);
+          `INSERT INTO chats (chat_id, ${column}) VALUES (?, ?)
+         ON CONFLICT(chat_id) DO UPDATE SET ${column} = excluded.${column}`
+        ).run(chatId, value);
       }
     };
   }
@@ -1590,18 +1573,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,13 +1596,13 @@ var init_SessionManager = __esm({
     init_dist();
     init_config();
     init_agents();
-    init_workspaces();
+    init_chats();
     init_paths2();
     init_KiroProcess();
     init_EventStore();
     init_TurnState();
     init_kiroFiles();
-    init_sessionStore();
+    init_chatStore();
     Session = class {
       sessionId;
       store;
@@ -1688,7 +1661,7 @@ var init_SessionManager = __esm({
     SessionManager = class {
       sessions = /* @__PURE__ */ new Map();
       log;
-      store = new SessionStore();
+      store = new ChatStore();
       spawnProcess;
       constructor(log, opts = {}) {
         this.log = log;
@@ -1698,62 +1671,53 @@ var init_SessionManager = __esm({
        * What a session is called, from every read path. The folder is skipped for a workspace of
        * ours, whose name is a uuid.
        */
-      titleOf(sessionId, parts) {
+      titleOf(chat, parts) {
         return resolveSessionTitle({
-          override: this.store.getTitle(sessionId),
+          override: chat.title ?? void 0,
           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. */
-      renameSession(sessionId, title) {
+      renameChat(chatId, title) {
         const clean = sanitizeTitle(title);
-        this.store.setTitle(sessionId, clean);
-        const s = this.sessions.get(sessionId);
+        this.store.setTitle(chatId, clean);
+        const s = this.sessions.get(this.store.sessionIdForChat(chatId) ?? "");
         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) {
+      async setChatCwd(chatId, input) {
         const resolved = resolveCwd(input);
-        const s = await this.ensureOpen(sessionId);
-        this.store.setCwd(sessionId, resolved);
+        const s = await this.ensureOpen(chatId);
+        this.store.setCwd(chatId, resolved);
         if (s.cwd !== resolved) {
           s.cwd = resolved;
           s.proc?.dispose();
           s.proc = void 0;
-          this.log.info({ sessionId, cwd: resolved }, "session working directory changed");
+          this.log.info({ chatId, cwd: resolved }, "chat working directory changed");
         }
         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.
-       *
-       * 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`.
+       * 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.
        *
-       * 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);
+      async reloadChat(chatId) {
+        const s = await this.ensureOpen(chatId);
         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");
         }
@@ -1762,14 +1726,14 @@ var init_SessionManager = __esm({
           ready = resolve;
         });
         try {
-          return await this.replaceProcess(s);
+          return await this.replaceProcess(chatId, s);
         } finally {
           s.reloading = void 0;
           ready();
         }
       }
       /** The reload itself. Only ever called with the session's reload claim held. */
-      async replaceProcess(s) {
+      async replaceProcess(chatId, s) {
         if (!await hasRecordedTurns(s.sessionId)) {
           throw new Error(
             "kiro has not saved this session yet. Send a message first, then reload."
@@ -1788,7 +1752,7 @@ var init_SessionManager = __esm({
         s.lastActivity = Date.now();
         invalidateAgents();
         this.log.info({ sessionId: s.sessionId, cwd: s.cwd }, "session reloaded");
-        return this.getDetail(s.sessionId);
+        return this.getDetail(chatId);
       }
       /**
        * Wait out a reload before touching the session's process. Without this an action
@@ -1805,33 +1769,34 @@ var init_SessionManager = __esm({
       // -------------------------------------------------------------------------
       // Event subscription - works for any opened session, spawned or not.
       // -------------------------------------------------------------------------
-      onEvent(sessionId, cb) {
-        const s = this.sessions.get(sessionId);
+      onEvent(chatId, cb) {
+        const s = this.sessions.get(this.store.sessionIdForChat(chatId) ?? "");
         if (!s) return null;
         s.store.on("event", cb);
         return () => s.store.off("event", cb);
       }
-      getStore(sessionId) {
-        return this.sessions.get(sessionId)?.store;
+      getStore(chatId) {
+        return this.sessions.get(this.store.sessionIdForChat(chatId) ?? "")?.store;
       }
-      /** Get a session's working directory. Opens the session in memory if needed. */
-      async getSessionCwd(sessionId) {
-        const s = await this.ensureOpen(sessionId);
+      /** A chat's working directory. Opens it in memory if needed. */
+      async getChatCwd(chatId) {
+        const s = await this.ensureOpen(chatId);
         return s.cwd;
       }
-      /** Open a session in memory (store + metadata) WITHOUT spawning a process. */
-      async ensureOpen(sessionId) {
+      /** Open a chat's session in memory (store + metadata) WITHOUT spawning a process. */
+      async ensureOpen(chatId) {
+        const sessionId = this.sessionIdOf(chatId);
         const existing = this.sessions.get(sessionId);
         if (existing) return existing;
         const persisted = await readPersistedSession(sessionId);
         if (!persisted) throw new Error(`Unknown session: ${sessionId}`);
-        const effectiveCwd = this.store.getCwd(sessionId) ?? persisted.cwd;
+        const effectiveCwd = this.store.getCwd(chatId) ?? persisted.cwd;
         if (!isWithinRoot(config.fileRoot, effectiveCwd)) {
           throw new Error(
             `Session working directory is outside the allowed root: ${effectiveCwd}`
           );
         }
-        const store = new EventStore(sessionId);
+        const store = new EventStore(chatId);
         const s = new Session(sessionId, store, effectiveCwd);
         s.title = persisted.title;
         s.agentId = persisted.agentId;
@@ -1840,10 +1805,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;
       }
@@ -1930,10 +1892,11 @@ var init_SessionManager = __esm({
       // Creating / opening
       // -------------------------------------------------------------------------
       /** 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);
+      async createChat(opts) {
+        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 store = new EventStore(chatId);
         const s = new Session(tempId, store, cwd);
         s.agentId = opts.agentId ?? config.defaultAgent;
         s.currentModeId = s.agentId;
@@ -1945,18 +1908,20 @@ var init_SessionManager = __esm({
           this.evict(s.sessionId);
           throw err;
         }
+        this.store.create(chatId);
+        this.store.bindSession(chatId, s.sessionId);
         const name = sanitizeTitle(opts.title ?? "") || (opts.freshWorkspace ? "" : path11.basename(s.cwd));
         if (name) {
-          this.store.setTitle(s.sessionId, name);
+          this.store.setTitle(chatId, name);
           s.title = name;
         }
-        return this.buildDetail(s, []);
+        return this.buildDetail(this.store.get(chatId), s, []);
       }
       // -------------------------------------------------------------------------
       // Actions - these spawn the process lazily.
       // -------------------------------------------------------------------------
-      async runPrompt(sessionId, content) {
-        const s = await this.ensureOpen(sessionId);
+      async runPrompt(chatId, content, attachments) {
+        const s = await this.ensureOpen(chatId);
         await this.settleReload(s);
         if (s.running) throw new Error("A turn is already running for this session");
         s.running = true;
@@ -1968,14 +1933,20 @@ var init_SessionManager = __esm({
           s.running = false;
           throw err;
         }
-        if (!this.store.getTitle(s.sessionId)) {
+        if (!this.store.getTitle(chatId)) {
           const title = titleFromPrompt(content);
           if (title) {
-            this.store.setTitle(s.sessionId, title);
+            this.store.setTitle(chatId, title);
             s.title = title;
           }
         }
-        s.record({ kind: "turn_started", prompt: content });
+        let recorded;
+        if (attachments?.length) {
+          const ordinal = await promptCount(s.sessionId);
+          this.store.setAttachments(chatId, 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();
@@ -1989,12 +1960,12 @@ ${tail}` : err.message;
           s.lastActivity = Date.now();
         });
       }
-      cancel(sessionId) {
-        const s = this.sessions.get(sessionId);
+      cancel(chatId) {
+        const s = this.sessions.get(this.store.sessionIdForChat(chatId) ?? "");
         s?.proc?.cancel(s.sessionId);
       }
-      async setMode(sessionId, modeId) {
-        const s = await this.ensureOpen(sessionId);
+      async setMode(chatId, modeId) {
+        const s = await this.ensureOpen(chatId);
         await this.settleReload(s);
         const proc = await this.ensureProc(s);
         await proc.setMode(s.sessionId, modeId);
@@ -2002,114 +1973,124 @@ ${tail}` : err.message;
         s.agentId = modeId;
         s.lastActivity = Date.now();
       }
-      async setModel(sessionId, modelId) {
-        const s = await this.ensureOpen(sessionId);
+      async setModel(chatId, modelId) {
+        const s = await this.ensureOpen(chatId);
         await this.settleReload(s);
         const proc = await this.ensureProc(s);
         await proc.setModel(s.sessionId, modelId);
         s.modelId = modelId;
         s.lastActivity = Date.now();
       }
-      async execCommand(sessionId, command, args) {
-        const s = await this.ensureOpen(sessionId);
+      async execCommand(chatId, command) {
+        const s = await this.ensureOpen(chatId);
         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();
       }
-      summaryOf(live, persisted, transcript) {
-        const sessionId = live?.sessionId ?? persisted.sessionId;
+      // -------------------------------------------------------------------------
+      // Listing / detail - never spawns.
+      // -------------------------------------------------------------------------
+      /**
+       * The one place a ChatSummary 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(chat, live, persisted, transcript) {
         const snap = live?.turnState.get();
-        const cwd = live?.cwd ?? this.store.getCwd(sessionId) ?? persisted.cwd;
+        const cwd = live?.cwd ?? chat.cwd ?? persisted?.cwd ?? config.defaultCwd;
         return {
-          sessionId,
-          title: this.titleOf(sessionId, {
+          chatId: chat.chatId,
+          sessionId: live?.sessionId ?? chat.sessionId ?? void 0,
+          title: this.titleOf(chat, {
             // kiro's file is what kiro called it; the live copy is only a cache of it.
             kiroTitle: persisted?.title || live?.title,
             firstPrompt: transcript && firstPromptText(transcript),
             cwd
           }),
           cwd,
-          createdAt: persisted?.createdAt ?? live.createdAt,
+          createdAt: persisted?.createdAt ?? live?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
           // kiro's file and our own activity move separately.
-          updatedAt: live ? newerOf(persisted?.updatedAt, live.updatedAt) : persisted.updatedAt,
+          updatedAt: live ? newerOf(persisted?.updatedAt, live.updatedAt) : persisted?.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
           liveness: live?.proc ? "live" : "dormant",
           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
         };
       }
-      async listSessions() {
-        const persisted = await listPersistedSessions(this.log);
-        const files = new Map(persisted.map((p) => [p.sessionId, p]));
-        const byId = /* @__PURE__ */ new Map();
-        for (const p of persisted) {
-          byId.set(p.sessionId, this.summaryOf(void 0, p));
-        }
-        for (const s of this.sessions.values()) {
-          if (isGhost(s, files.has(s.sessionId))) {
-            this.evict(s.sessionId);
-            continue;
+      async listChats() {
+        const rows = this.store.all();
+        const files = await Promise.all(
+          rows.map((r) => r.sessionId ? readPersistedSession(r.sessionId) : null)
+        );
+        const out = [];
+        rows.forEach((row, i) => {
+          const live = row.sessionId ? this.sessions.get(row.sessionId) : void 0;
+          const persisted = files[i] ?? void 0;
+          if (live && isGhost(live, !!persisted)) {
+            this.evict(live.sessionId);
+            return;
           }
-          byId.set(s.sessionId, this.summaryOf(s, files.get(s.sessionId)));
-        }
-        return [...byId.values()].sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
-      }
-      async getDetail(sessionId) {
+          if (!persisted && !live) return;
+          out.push(this.summaryOf(row, live, persisted));
+        });
+        return out.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+      }
+      /** kiro's session id for a chat, or a throw if the chat is unknown. */
+      sessionIdOf(chatId) {
+        const sessionId = this.store.sessionIdForChat(chatId);
+        if (!sessionId) throw new Error(`Unknown chat: ${chatId}`);
+        return sessionId;
+      }
+      async getDetail(chatId) {
+        const chat = this.store.get(chatId);
+        if (!chat) throw new Error(`Unknown chat: ${chatId}`);
+        const sessionId = chat.sessionId;
         const [transcript, persisted] = await Promise.all([
-          hydrateTranscript(sessionId),
-          readPersistedSession(sessionId)
+          sessionId ? hydrateTranscript(sessionId, this.store.attachmentsByChat(chatId)) : Promise.resolve([]),
+          sessionId ? readPersistedSession(sessionId) : Promise.resolve(null)
         ]);
-        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
-        };
+        const s = sessionId ? this.sessions.get(sessionId) : void 0;
+        if (!s && !persisted) throw new Error(`Unknown chat: ${chatId}`);
+        return this.buildDetail(chat, s, transcript, persisted ?? void 0);
       }
       /**
        * A slice of the transcript for lazy "load older on scroll up". Re-hydrates
        * from disk (fast: ~150ms even for a multi-MB session) and returns the
        * requested window. offset/limit are clamped to the transcript bounds.
        */
-      async getTranscriptPage(sessionId, offset, limit) {
-        const transcript = await hydrateTranscript(sessionId);
+      async getTranscriptPage(chatId, offset, limit) {
+        const transcript = await hydrateTranscript(
+          this.sessionIdOf(chatId),
+          this.store.attachmentsByChat(chatId)
+        );
         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);
       }
-      buildDetail(s, transcript, persisted) {
-        const snap = s.turnState.get();
+      /** One projection, so a dormant session and a live one cannot disagree. */
+      buildDetail(chat, s, transcript, persisted) {
         return {
-          summary: this.summaryOf(s, persisted, transcript),
-          modes: s.availableModes,
-          currentModeId: s.currentModeId,
+          summary: this.summaryOf(chat, s, persisted, transcript),
+          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();
@@ -2147,16 +2128,18 @@ ${tail}` : err.message;
       }
       // Permanently delete a session: evict it from memory, remove its on-disk
       // files, and drop any title override.
-      async deleteSession(sessionId) {
-        const s = this.sessions.get(sessionId);
+      async deleteChat(chatId) {
+        const sessionId = this.store.sessionIdForChat(chatId);
+        const s = sessionId ? this.sessions.get(sessionId) : void 0;
         if (s?.proc) {
           await s.proc.disposeAndWait().catch(() => {
           });
           s.proc = void 0;
           s.running = false;
         }
+        this.store.remove(chatId);
+        if (!sessionId) return;
         this.evict(sessionId);
-        this.store.remove(sessionId);
         await deletePersistedSession(sessionId);
         setTimeout(() => void deletePersistedSession(sessionId).catch(() => {
         }), 2500).unref?.();
@@ -2214,13 +2197,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 +2225,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 +2253,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 +2285,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 +2293,6 @@ var init_auth = __esm({
     init_logins();
     init_rateLimit();
     SESSION_COOKIE = "casper.sid";
-    logins = new LoginStore();
     loginLimiter = new AttemptLimiter(10, 15 * 60 * 1e3);
   }
 });
@@ -2430,12 +2416,12 @@ function replyWith(reply, failure) {
   reply.code(failure.status);
   return { error: failure.error };
 }
-async function resolveSessionPath(sessions, sessionId, requestedPath, require2) {
+async function resolveChatPath(sessions, sessionId, requestedPath, require2) {
   let cwd;
   try {
-    cwd = await sessions.getSessionCwd(sessionId);
+    cwd = await sessions.getChatCwd(sessionId);
   } catch {
-    return { ok: false, status: 404, error: "Session not found" };
+    return { ok: false, status: 404, error: "Chat not found" };
   }
   const relative = (requestedPath ?? "").replace(/^\/+/, "");
   if (require2 === "file" && !relative) {
@@ -2520,15 +2506,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 +2586,7 @@ var init_filekind = __esm({
       ".tex"
     ]);
     MIME_MAP = {
-      ...IMAGE_EXTS2,
+      ...IMAGE_EXTS,
       ".txt": "text/plain",
       ".md": "text/markdown",
       ".csv": "text/csv",
@@ -2628,10 +2614,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 +2743,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 +2755,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 +2766,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,75 +2774,66 @@ 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();
   }
 });
 
-// server/src/routes/sessions.ts
-function registerSessionRoutes(app, manager) {
-  app.get("/api/sessions", async () => {
-    return { sessions: await manager.listSessions() };
+// server/src/routes/chats.ts
+function registerChatRoutes(app, manager) {
+  app.get("/api/chats", async () => {
+    return { chats: await manager.listChats() };
   });
-  app.post("/api/sessions", async (req, reply) => {
+  app.post("/api/chats", async (req, reply) => {
     const body = req.body ?? {};
     try {
-      return await manager.createSession({
+      return await manager.createChat({
         cwd: body.cwd,
         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);
       return { error: err.message };
     }
   });
-  app.get("/api/sessions/:id", async (req, reply) => {
+  app.get("/api/chats/:id", async (req, reply) => {
     try {
       return await manager.getDetail(req.params.id);
     } catch (err) {
@@ -2747,7 +2842,7 @@ function registerSessionRoutes(app, manager) {
     }
   });
   app.get(
-    "/api/sessions/:id/transcript",
+    "/api/chats/:id/transcript",
     async (req, reply) => {
       const offset = Number.parseInt(req.query.offset ?? "", 10);
       const limit = Number.parseInt(req.query.limit ?? "", 10);
@@ -2764,10 +2859,10 @@ function registerSessionRoutes(app, manager) {
     }
   );
   app.post(
-    "/api/sessions/:id/prompt",
+    "/api/chats/: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);
@@ -2775,33 +2870,33 @@ function registerSessionRoutes(app, manager) {
       }
     }
   );
-  app.post("/api/sessions/:id/cancel", async (req) => {
+  app.post("/api/chats/:id/cancel", async (req) => {
     manager.cancel(req.params.id);
     return { ok: true };
   });
   app.post(
-    "/api/sessions/:id/model",
+    "/api/chats/:id/model",
     async (req) => {
       await manager.setModel(req.params.id, req.body.modelId);
       return { ok: true };
     }
   );
   app.post(
-    "/api/sessions/:id/mode",
+    "/api/chats/:id/mode",
     async (req) => {
       await manager.setMode(req.params.id, req.body.modeId);
       return { ok: true };
     }
   );
   app.post(
-    "/api/sessions/:id/rename",
+    "/api/chats/:id/rename",
     async (req) => {
-      manager.renameSession(req.params.id, req.body.title);
+      manager.renameChat(req.params.id, req.body.title);
       return { ok: true };
     }
   );
   app.post(
-    "/api/sessions/:id/cwd",
+    "/api/chats/:id/cwd",
     async (req, reply) => {
       const cwd = (req.body?.cwd ?? "").trim();
       if (!cwd) {
@@ -2809,66 +2904,41 @@ function registerSessionRoutes(app, manager) {
         return { error: "cwd is required" };
       }
       try {
-        return { ok: true, cwd: await manager.setSessionCwd(req.params.id, cwd) };
+        return { ok: true, cwd: await manager.setChatCwd(req.params.id, cwd) };
       } catch (err) {
         reply.code(400);
         return { error: err.message };
       }
     }
   );
-  app.post("/api/sessions/:id/reload", async (req, reply) => {
+  app.post("/api/chats/:id/reload", async (req, reply) => {
     try {
-      return await manager.reloadSession(req.params.id);
+      return await manager.reloadChat(req.params.id);
     } catch (err) {
       reply.code(400);
       return { error: err.message };
     }
   });
-  app.delete("/api/sessions/:id", async (req) => {
-    await manager.deleteSession(req.params.id);
+  app.delete("/api/chats/:id", async (req) => {
+    await manager.deleteChat(req.params.id);
     return { ok: true };
   });
 }
-var init_sessions = __esm({
-  "server/src/routes/sessions.ts"() {
+var init_chats2 = __esm({
+  "server/src/routes/chats.ts"() {
     "use strict";
   }
 });
 
 // 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",
+    "/api/chats/:id/tree",
     async (req, reply) => {
-      const resolved = await resolveSessionPath(
+      const resolved = await resolveChatPath(
         manager,
         req.params.id,
         req.query.path,
@@ -2878,7 +2948,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 +2962,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,
@@ -2912,17 +2982,17 @@ function registerWorkspaceRoutes(app, manager) {
     }
   );
   app.get(
-    "/api/sessions/:id/download",
+    "/api/chats/:id/download",
     async (req, reply) => {
-      const resolved = await resolveSessionPath(manager, req.params.id, req.query.path, "file");
+      const resolved = await resolveChatPath(manager, req.params.id, req.query.path, "file");
       if (!resolved.ok) return replyWith(reply, resolved);
       const { real: realTarget, stat } = resolved;
       if (stat.size > MAX_DOWNLOAD_BYTES) {
         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,141 +3000,61 @@ 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(
-    "/api/sessions/:id/preview",
+    "/api/chats/:id/preview",
     async (req, reply) => {
-      const resolved = await resolveSessionPath(manager, req.params.id, req.query.path, "file");
+      const resolved = await resolveChatPath(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 +3067,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 +3090,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 +3113,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 +3133,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 +3158,7 @@ var init_uploads = __esm({
     init_config();
     init_filekind();
     init_paths2();
+    init_chats();
     STRINGS_SCAN_BYTES = 256 * 1024;
   }
 });
@@ -3197,7 +3182,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 +3206,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(
@@ -3266,7 +3251,7 @@ var init_dirWatchers = __esm({
 function send(socket, msg) {
   if (socket.readyState === socket.OPEN) socket.send(JSON.stringify(msg));
 }
-function handleConnection(socket, manager, sessionId, startCursor) {
+function handleConnection(socket, manager, chatId, startCursor) {
   let cursor = startCursor;
   let unsubscribe = null;
   let alive = true;
@@ -3274,12 +3259,12 @@ function handleConnection(socket, manager, sessionId, startCursor) {
   const watchers = createDirWatchers({
     resolve: async (relative) => {
       try {
-        return confineToRoot(await manager.getSessionCwd(sessionId), relative);
+        return confineToRoot(await manager.getChatCwd(chatId), relative);
       } catch {
         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;
@@ -3288,13 +3273,13 @@ function handleConnection(socket, manager, sessionId, startCursor) {
   };
   const attach = async () => {
     try {
-      await manager.ensureOpen(sessionId);
+      await manager.ensureOpen(chatId);
     } catch (err) {
       send(socket, { type: "error", message: err.message });
       socket.close(1011, "open failed");
       return;
     }
-    const store = manager.getStore(sessionId);
+    const store = manager.getStore(chatId);
     if (!store) {
       send(socket, { type: "error", message: "Session store unavailable" });
       socket.close(1011, "no store");
@@ -3311,7 +3296,7 @@ function handleConnection(socket, manager, sessionId, startCursor) {
       for (const e of events) forward(e);
     }
     send(socket, { type: "replay_complete", head: store.head() });
-    unsubscribe = manager.onEvent(sessionId, forward);
+    unsubscribe = manager.onEvent(chatId, forward);
     ready = true;
   };
   void attach();
@@ -3330,17 +3315,17 @@ 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(chatId, msg.content, msg.attachments));
       case "cancel":
-        return ack("cancel", () => manager.cancel(sessionId));
+        return ack("cancel", () => manager.cancel(chatId));
       case "set_mode":
-        return ack("set_mode", () => manager.setMode(sessionId, msg.modeId));
+        return ack("set_mode", () => manager.setMode(chatId, msg.modeId));
       case "set_model":
-        return ack("set_model", () => manager.setModel(sessionId, msg.modelId));
+        return ack("set_model", () => manager.setModel(chatId, msg.modelId));
       case "exec_command":
         return ack(
           "exec_command",
-          () => manager.execCommand(sessionId, msg.command, msg.args)
+          () => manager.execCommand(chatId, msg.command)
         );
       default:
         return send(socket, { type: "error", message: "Unknown message type" });
@@ -3387,15 +3372,15 @@ function registerWsGateway(app, manager) {
       socket.close(1008, "Unauthorized");
       return;
     }
-    if (!query.sessionId) {
-      send(socket, { type: "error", message: "Missing sessionId" });
-      socket.close(1008, "Missing sessionId");
+    if (!query.chatId) {
+      send(socket, { type: "error", message: "Missing chatId" });
+      socket.close(1008, "Missing chatId");
       return;
     }
     handleConnection(
       socket,
       manager,
-      query.sessionId,
+      query.chatId,
       Number.parseInt(query.cursor ?? "0", 10) || 0
     );
   });
@@ -3412,9 +3397,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 +3418,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 }
   });
@@ -3446,24 +3429,24 @@ async function buildApp() {
   registerModelRoutes(app);
   registerAgentRoutes(app);
   registerFsRoutes(app);
-  registerSessionRoutes(app, manager);
+  registerChatRoutes(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;
       }
@@ -3482,7 +3465,7 @@ var init_app = __esm({
     init_models2();
     init_agents2();
     init_fs();
-    init_sessions();
+    init_chats2();
     init_workspace();
     init_uploads();
     init_health();
@@ -3537,15 +3520,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 +3552,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 +3584,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 +3594,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 +3603,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 +3617,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 +4096,14 @@ var init_server2 = __esm({
   "server/src/mcp/server.ts"() {
     "use strict";
     init_protocol();
-    VERSION = true ? "0.11.1" : "dev";
+    VERSION = true ? "0.13.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 +7216,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 +7476,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.13.0" : "dev";
 async function bootstrap() {
   const file = configFilePath();
   const settings = readSettings(file);
@@ -7539,8 +7522,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 +7540,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());