@joeyshi12/casper 0.12.0 → 0.13.1

package/dist/server.js

@@ -391,13 +391,11 @@ 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,
-  -- The chat that owns this session's uploads (see chats.ts). NULL for a session Casper did
-  -- not create; getChatId names those after the session.
-  chat_id    TEXT
+  cwd        TEXT
 );
 CREATE TABLE IF NOT EXISTS logins (
   id           TEXT PRIMARY KEY,
@@ -408,13 +406,13 @@ CREATE TABLE IF NOT EXISTS logins (
 );
 CREATE INDEX IF NOT EXISTS logins_hash ON logins (hash);
 CREATE TABLE IF NOT EXISTS message_attachments (
-  session_id TEXT    NOT NULL,
-  ordinal    INTEGER NOT NULL,
-  path       TEXT    NOT NULL,
-  name       TEXT    NOT NULL,
-  size       INTEGER NOT NULL,
-  kind       TEXT    NOT NULL,
-  PRIMARY KEY (session_id, ordinal, path)
+  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)
 );
 `;
   }
@@ -799,55 +797,24 @@ var init_agents = __esm({
   }
 });
 
-// server/src/session/chats.ts
-import fs7 from "node:fs";
-import path8 from "node:path";
-function chatsRoot() {
-  return path8.join(config.casperDataDir, "chats");
-}
-function chatDir(chatId) {
-  return path8.join(chatsRoot(), chatId);
-}
-function chatUploadsDir(chatId) {
-  return path8.join(chatDir(chatId), "uploads");
-}
-function chatWorkspaceDir(chatId) {
-  return path8.join(chatDir(chatId), "workspace");
-}
-function createChatWorkspace(chatId) {
-  const dir = chatWorkspaceDir(chatId);
-  fs7.mkdirSync(dir, { recursive: true, mode: 448 });
-  return dir;
-}
-function isManagedWorkspace(dir) {
-  const root = chatsRoot();
-  return dir === root || dir.startsWith(root + path8.sep);
-}
-var init_chats = __esm({
-  "server/src/session/chats.ts"() {
-    "use strict";
-    init_config();
-  }
-});
-
 // server/src/util/paths.ts
-import fs8 from "node:fs";
+import fs7 from "node:fs";
 import fsp from "node:fs/promises";
-import path9 from "node:path";
+import path8 from "node:path";
 function isWithinRoot(root, target) {
-  const resolved = path9.resolve(target);
-  if (root === path9.sep) return true;
-  return resolved === root || resolved.startsWith(root + path9.sep);
+  const resolved = path8.resolve(target);
+  if (root === path8.sep) return true;
+  return resolved === root || resolved.startsWith(root + path8.sep);
 }
 function confineToRoot(root, input) {
-  const resolved = path9.resolve(root, input);
+  const resolved = path8.resolve(root, input);
   return isWithinRoot(root, resolved) ? resolved : null;
 }
 function resolveRealRoot(root) {
   if (realRootCache && realRootCache.root === root) return realRootCache.real;
   let real;
   try {
-    real = fs8.realpathSync(root);
+    real = fs7.realpathSync(root);
   } catch {
     real = root;
   }
@@ -867,7 +834,7 @@ function isValidSessionId(id) {
   return /^[A-Za-z0-9._-]+$/.test(id) && id !== "." && !id.includes("..");
 }
 function isValidChatId(id) {
-  return !!id && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id);
+  return !!id && isValidSessionId(id);
 }
 var realRootCache;
 var init_paths2 = __esm({
@@ -877,6 +844,43 @@ var init_paths2 = __esm({
   }
 });
 
+// server/src/session/chats.ts
+import fs8 from "node:fs";
+import fsp2 from "node:fs/promises";
+import path9 from "node:path";
+function chatsRoot() {
+  return path9.join(config.casperDataDir, "chats");
+}
+function chatDir(chatId) {
+  return path9.join(chatsRoot(), chatId);
+}
+function chatUploadsDir(chatId) {
+  return path9.join(chatDir(chatId), "uploads");
+}
+function chatWorkspaceDir(chatId) {
+  return path9.join(chatDir(chatId), "workspace");
+}
+function createChatWorkspace(chatId) {
+  const dir = chatWorkspaceDir(chatId);
+  fs8.mkdirSync(dir, { recursive: true, mode: 448 });
+  return dir;
+}
+async function removeChatDir(chatId) {
+  if (!isValidChatId(chatId)) return;
+  await fsp2.rm(chatDir(chatId), { recursive: true, force: true });
+}
+function isManagedWorkspace(dir) {
+  const root = chatsRoot();
+  return dir === root || dir.startsWith(root + path9.sep);
+}
+var init_chats = __esm({
+  "server/src/session/chats.ts"() {
+    "use strict";
+    init_config();
+    init_paths2();
+  }
+});
+
 // server/src/acp/errors.ts
 function describeError(error) {
   const detail = detailText(error.data);
@@ -1192,13 +1196,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 +1211,7 @@ var init_EventStore = __esm({
         const event = {
           seq: this.seq,
           ts: Date.now(),
-          sessionId: this.sessionId,
+          chatId: this.chatId,
           payload
         };
         this.buffer.push(event);
@@ -1325,43 +1329,16 @@ function summarize(j) {
   const contextUsagePercentage = state?.rts_model_state?.context_usage_percentage ?? turns[turns.length - 1]?.context_usage_percentage;
   return {
     sessionId: j.session_id,
-    // kiro's file knows nothing about chats; summaryOf replaces this with the recorded id
-    // when there is one, and this matches what getChatId names a session without a row.
-    chatId: j.session_id,
     // Left empty when kiro has not named it; resolveSessionTitle decides what to show.
     title: j.title?.trim() ?? "",
     cwd: j.cwd,
     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,
     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 = [
@@ -1482,54 +1459,66 @@ 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");
-      }
-      setTitle(sessionId, title) {
-        this.write(sessionId, "title", 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 }));
       }
-      getCwd(sessionId) {
-        return this.read(sessionId, "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;
       }
-      setCwd(sessionId, cwd) {
-        this.write(sessionId, "cwd", cwd);
+      create(chatId) {
+        db().prepare("INSERT INTO chats (chat_id) VALUES (?) ON CONFLICT(chat_id) DO NOTHING").run(chatId);
       }
       /**
-       * The chat that owns this session's uploads. A session Casper did not create has no row -
-       * one started with kiro-cli directly still shows up in the list - so it is named after the
-       * session, which gives it one stable directory rather than a new one per call.
+       * 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.
        */
-      getChatId(sessionId) {
-        return this.read(sessionId, "chat_id") ?? sessionId;
+      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;
+      }
+      getTitle(chatId) {
+        return this.read(chatId, "title");
+      }
+      setTitle(chatId, title) {
+        this.write(chatId, "title", title);
       }
-      setChatId(sessionId, chatId) {
-        this.write(sessionId, "chat_id", chatId);
+      getCwd(chatId) {
+        return this.read(chatId, "cwd");
+      }
+      setCwd(chatId, cwd) {
+        this.write(chatId, "cwd", cwd);
       }
       /** Record what was attached to one prompt. See db.ts for why the key is an ordinal. */
-      setAttachments(sessionId, ordinal, files) {
+      setAttachments(chatId, ordinal, files) {
         if (files.length === 0) return;
         const stmt = db().prepare(
-          `INSERT INTO message_attachments (session_id, ordinal, path, name, size, kind)
+          `INSERT INTO message_attachments (chat_id, ordinal, path, name, size, kind)
        VALUES (?, ?, ?, ?, ?, ?)
-       ON CONFLICT(session_id, ordinal, path) DO NOTHING`
+       ON CONFLICT(chat_id, ordinal, path) DO NOTHING`
         );
         for (const f of files) {
-          stmt.run(sessionId, ordinal, f.path, f.name, f.size, f.kind);
+          stmt.run(chatId, ordinal, f.path, f.name, f.size, f.kind);
         }
       }
-      /** Every attachment in a session, grouped by the message it belongs to. */
-      attachmentsBySession(sessionId) {
+      /** 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 session_id = ? ORDER BY ordinal, path`
-        ).all(sessionId);
+         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) ?? [];
@@ -1543,20 +1532,19 @@ var init_sessionStore = __esm({
         }
         return out;
       }
-      /** Forget every override for a session, when it's permanently deleted. */
-      remove(sessionId) {
-        db().prepare("DELETE FROM sessions WHERE session_id = ?").run(sessionId);
-        db().prepare("DELETE FROM message_attachments WHERE session_id = ?").run(sessionId);
+      remove(chatId) {
+        db().prepare("DELETE FROM chats WHERE chat_id = ?").run(chatId);
+        db().prepare("DELETE FROM message_attachments WHERE chat_id = ?").run(chatId);
       }
-      read(sessionId, column) {
-        const row = db().prepare(`SELECT ${column} AS value FROM sessions WHERE session_id = ?`).get(sessionId);
+      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);
       }
     };
   }
@@ -1620,14 +1608,12 @@ var init_SessionManager = __esm({
     init_EventStore();
     init_TurnState();
     init_kiroFiles();
-    init_sessionStore();
+    init_chatStore();
     Session = class {
       sessionId;
       store;
       turnState = new TurnState();
       cwd;
-      /** The chat that owns this session's uploads. See chats.ts. */
-      chatId;
       agentId;
       modelId;
       currentModeId;
@@ -1681,7 +1667,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;
@@ -1691,34 +1677,33 @@ 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: 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. 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;
       }
@@ -1731,8 +1716,8 @@ var init_SessionManager = __esm({
        * 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");
         }
@@ -1747,14 +1732,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."
@@ -1773,7 +1758,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
@@ -1790,33 +1775,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;
@@ -1912,11 +1898,11 @@ var init_SessionManager = __esm({
       // Creating / opening
       // -------------------------------------------------------------------------
       /** Create a new session. Spawns immediately so we get a real kiro sessionId. */
-      async createSession(opts) {
+      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;
@@ -1928,20 +1914,20 @@ var init_SessionManager = __esm({
           this.evict(s.sessionId);
           throw err;
         }
-        this.store.setChatId(s.sessionId, chatId);
-        s.chatId = chatId;
+        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, attachments) {
-        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;
@@ -1953,17 +1939,17 @@ 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;
           }
         }
         let recorded;
         if (attachments?.length) {
           const ordinal = await promptCount(s.sessionId);
-          this.store.setAttachments(s.sessionId, ordinal, attachments);
+          this.store.setAttachments(chatId, ordinal, attachments);
           recorded = attachments;
         }
         s.record({ kind: "turn_started", prompt: content, attachments: recorded });
@@ -1980,12 +1966,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);
@@ -1993,16 +1979,16 @@ ${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) {
-        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);
@@ -2012,27 +1998,26 @@ ${tail}` : err.message;
       // Listing / detail - never spawns.
       // -------------------------------------------------------------------------
       /**
-       * The one place a SessionSummary is assembled: kiro's file and Casper's live state each hold
+       * 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(live, persisted, transcript) {
-        const sessionId = live?.sessionId ?? persisted.sessionId;
+      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,
-          chatId: live?.chatId ?? this.store.getChatId(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,
@@ -2042,49 +2027,60 @@ ${tail}` : err.message;
           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, this.store.attachmentsBySession(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 && !persisted) throw new Error(`Unknown session: ${sessionId}`);
-        return this.buildDetail(s, transcript, persisted ?? void 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) {
+      async getTranscriptPage(chatId, offset, limit) {
         const transcript = await hydrateTranscript(
-          sessionId,
-          this.store.attachmentsBySession(sessionId)
+          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);
       }
       /** One projection, so a dormant session and a live one cannot disagree. */
-      buildDetail(s, transcript, persisted) {
+      buildDetail(chat, s, transcript, persisted) {
         return {
-          summary: this.summaryOf(s, persisted, transcript),
+          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.
@@ -2137,17 +2133,20 @@ ${tail}` : err.message;
         s.store.dispose();
       }
       // 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);
+      // files and the directory the chat owns, and drop any title override.
+      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);
+        await removeChatDir(chatId);
+        if (!sessionId) return;
         this.evict(sessionId);
-        this.store.remove(sessionId);
         await deletePersistedSession(sessionId);
         setTimeout(() => void deletePersistedSession(sessionId).catch(() => {
         }), 2500).unref?.();
@@ -2424,12 +2423,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) {
@@ -2817,15 +2816,15 @@ var init_fs = __esm({
   }
 });
 
-// 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,
@@ -2841,7 +2840,7 @@ function registerSessionRoutes(app, manager) {
       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) {
@@ -2850,7 +2849,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);
@@ -2867,7 +2866,7 @@ 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, req.body.attachments);
@@ -2878,33 +2877,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) {
@@ -2912,28 +2911,28 @@ 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";
   }
 });
@@ -2944,9 +2943,9 @@ 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,
@@ -2990,9 +2989,9 @@ 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) {
@@ -3012,9 +3011,9 @@ function registerWorkspaceRoutes(app, manager) {
     }
   );
   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;
       return sendFilePreview(req, reply, realTarget, stat);
@@ -3259,7 +3258,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;
@@ -3267,7 +3266,7 @@ 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;
       }
@@ -3281,13 +3280,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");
@@ -3304,7 +3303,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();
@@ -3323,17 +3322,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, msg.attachments));
+        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)
+          () => manager.execCommand(chatId, msg.command)
         );
       default:
         return send(socket, { type: "error", message: "Unknown message type" });
@@ -3380,15 +3379,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
     );
   });
@@ -3437,7 +3436,7 @@ async function buildApp() {
   registerModelRoutes(app);
   registerAgentRoutes(app);
   registerFsRoutes(app);
-  registerSessionRoutes(app, manager);
+  registerChatRoutes(app, manager);
   registerWorkspaceRoutes(app, manager);
   registerUploadRoutes(app);
   registerWsGateway(app, manager);
@@ -3473,7 +3472,7 @@ var init_app = __esm({
     init_models2();
     init_agents2();
     init_fs();
-    init_sessions();
+    init_chats2();
     init_workspace();
     init_uploads();
     init_health();
@@ -4104,7 +4103,7 @@ var init_server2 = __esm({
   "server/src/mcp/server.ts"() {
     "use strict";
     init_protocol();
-    VERSION = true ? "0.12.0" : "dev";
+    VERSION = true ? "0.13.1" : "dev";
   }
 });
 
@@ -7484,7 +7483,7 @@ var program = new Command();
 // server/src/cli/program.ts
 init_paths();
 init_settings();
-var VERSION2 = true ? "0.12.0" : "dev";
+var VERSION2 = true ? "0.13.1" : "dev";
 async function bootstrap() {
   const file = configFilePath();
   const settings = readSettings(file);