@sna-sdk/core 0.3.0 → 0.5.0

package/dist/server/standalone.js

@@ -14,7 +14,7 @@ import { streamSSE } from "hono/streaming";
 import { createRequire } from "module";
 import fs from "fs";
 import path from "path";
-var DB_PATH = path.join(process.cwd(), "data/sna.db");
+var DB_PATH = process.env.SNA_DB_PATH ?? path.join(process.cwd(), "data/sna.db");
 var NATIVE_DIR = path.join(process.cwd(), ".sna/native");
 var _db = null;
 function loadBetterSqlite3() {
@@ -247,16 +247,84 @@ import { streamSSE as streamSSE3 } from "hono/streaming";
 // src/core/providers/claude-code.ts
 import { spawn as spawn2, execSync } from "child_process";
 import { EventEmitter } from "events";
-import fs3 from "fs";
-import path3 from "path";
+import fs4 from "fs";
+import path4 from "path";
 
-// src/lib/logger.ts
-import chalk from "chalk";
+// src/core/providers/cc-history-adapter.ts
 import fs2 from "fs";
 import path2 from "path";
-var LOG_PATH = path2.join(process.cwd(), ".dev.log");
+function writeHistoryJsonl(history, opts) {
+  for (let i = 1; i < history.length; i++) {
+    if (history[i].role === history[i - 1].role) {
+      throw new Error(
+        `History validation failed: consecutive ${history[i].role} at index ${i - 1} and ${i}. Messages must alternate user\u2194assistant. Merge tool results into text before injecting.`
+      );
+    }
+  }
+  try {
+    const dir = path2.join(opts.cwd, ".sna", "history");
+    fs2.mkdirSync(dir, { recursive: true });
+    const sessionId = crypto.randomUUID();
+    const filePath = path2.join(dir, `${sessionId}.jsonl`);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const lines = [];
+    let prevUuid = null;
+    for (const msg of history) {
+      const uuid = crypto.randomUUID();
+      if (msg.role === "user") {
+        lines.push(JSON.stringify({
+          parentUuid: prevUuid,
+          isSidechain: false,
+          type: "user",
+          uuid,
+          timestamp: now,
+          cwd: opts.cwd,
+          sessionId,
+          message: { role: "user", content: msg.content }
+        }));
+      } else {
+        lines.push(JSON.stringify({
+          parentUuid: prevUuid,
+          isSidechain: false,
+          type: "assistant",
+          uuid,
+          timestamp: now,
+          cwd: opts.cwd,
+          sessionId,
+          message: {
+            role: "assistant",
+            content: [{ type: "text", text: msg.content }]
+          }
+        }));
+      }
+      prevUuid = uuid;
+    }
+    fs2.writeFileSync(filePath, lines.join("\n") + "\n");
+    return { filePath, extraArgs: ["--resume", filePath] };
+  } catch {
+    return null;
+  }
+}
+function buildRecalledConversation(history) {
+  const xml = history.map((msg) => `<${msg.role}>${msg.content}</${msg.role}>`).join("\n");
+  return JSON.stringify({
+    type: "assistant",
+    message: {
+      role: "assistant",
+      content: [{ type: "text", text: `<recalled-conversation>
+${xml}
+</recalled-conversation>` }]
+    }
+  });
+}
+
+// src/lib/logger.ts
+import chalk from "chalk";
+import fs3 from "fs";
+import path3 from "path";
+var LOG_PATH = path3.join(process.cwd(), ".dev.log");
 try {
-  fs2.writeFileSync(LOG_PATH, "");
+  fs3.writeFileSync(LOG_PATH, "");
 } catch {
 }
 function tsPlain() {
@@ -288,7 +356,7 @@ var tagPlain = {
 function appendFile(tag, args) {
   const line = `${tsPlain()} ${tag} ${args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ")}
 `;
-  fs2.appendFile(LOG_PATH, line, () => {
+  fs3.appendFile(LOG_PATH, line, () => {
   });
 }
 function log(tag, ...args) {
@@ -305,9 +373,9 @@ var logger = { log, err };
 var SHELL = process.env.SHELL || "/bin/zsh";
 function resolveClaudePath(cwd) {
   if (process.env.SNA_CLAUDE_COMMAND) return process.env.SNA_CLAUDE_COMMAND;
-  const cached = path3.join(cwd, ".sna/claude-path");
-  if (fs3.existsSync(cached)) {
-    const p = fs3.readFileSync(cached, "utf8").trim();
+  const cached = path4.join(cwd, ".sna/claude-path");
+  if (fs4.existsSync(cached)) {
+    const p = fs4.readFileSync(cached, "utf8").trim();
     if (p) {
       try {
         execSync(`test -x "${p}"`, { stdio: "pipe" });
@@ -378,33 +446,44 @@ var ClaudeCodeProcess = class {
       this._alive = false;
       this.emitter.emit("error", err2);
     });
-    if (options.history?.length) {
-      if (!options.prompt) {
-        throw new Error("history requires a prompt \u2014 the last stdin message must be a user message");
-      }
-      for (const msg of options.history) {
-        if (msg.role === "user") {
-          const line = JSON.stringify({
-            type: "user",
-            message: { role: "user", content: msg.content }
-          });
-          this.proc.stdin.write(line + "\n");
-        } else if (msg.role === "assistant") {
-          const line = JSON.stringify({
-            type: "assistant",
-            message: {
-              role: "assistant",
-              content: [{ type: "text", text: msg.content }]
-            }
-          });
-          this.proc.stdin.write(line + "\n");
-        }
-      }
+    if (options.history?.length && !options._historyViaResume) {
+      const line = buildRecalledConversation(options.history);
+      this.proc.stdin.write(line + "\n");
     }
     if (options.prompt) {
       this.send(options.prompt);
     }
   }
+  /**
+   * Split completed assistant text into chunks and emit assistant_delta events
+   * at a fixed rate (~270 chars/sec), followed by the final assistant event.
+   *
+   * CHUNK_SIZE chars every CHUNK_DELAY_MS → natural TPS feel regardless of length.
+   */
+  emitTextAsDeltas(text) {
+    const CHUNK_SIZE = 4;
+    const CHUNK_DELAY_MS = 15;
+    let t = 0;
+    for (let i = 0; i < text.length; i += CHUNK_SIZE) {
+      const chunk = text.slice(i, i + CHUNK_SIZE);
+      setTimeout(() => {
+        this.emitter.emit("event", {
+          type: "assistant_delta",
+          delta: chunk,
+          index: 0,
+          timestamp: Date.now()
+        });
+      }, t);
+      t += CHUNK_DELAY_MS;
+    }
+    setTimeout(() => {
+      this.emitter.emit("event", {
+        type: "assistant",
+        message: text,
+        timestamp: Date.now()
+      });
+    }, t);
+  }
   get alive() {
     return this._alive;
   }
@@ -480,6 +559,7 @@ var ClaudeCodeProcess = class {
         const content = msg.message?.content;
         if (!Array.isArray(content)) return null;
         const events = [];
+        const textBlocks = [];
         for (const block of content) {
           if (block.type === "thinking") {
             events.push({
@@ -497,15 +577,17 @@ var ClaudeCodeProcess = class {
           } else if (block.type === "text") {
             const text = (block.text ?? "").trim();
             if (text) {
-              events.push({ type: "assistant", message: text, timestamp: Date.now() });
+              textBlocks.push(text);
             }
           }
         }
-        if (events.length > 0) {
-          for (let i = 1; i < events.length; i++) {
-            this.emitter.emit("event", events[i]);
+        if (events.length > 0 || textBlocks.length > 0) {
+          for (const e of events) {
+            this.emitter.emit("event", e);
+          }
+          for (const text of textBlocks) {
+            this.emitTextAsDeltas(text);
           }
-          return events[0];
         }
         return null;
       }
@@ -640,6 +722,14 @@ var ClaudeCodeProvider = class {
     if (options.permissionMode) {
       args.push("--permission-mode", options.permissionMode);
     }
+    if (options.history?.length && options.prompt) {
+      const result = writeHistoryJsonl(options.history, { cwd: options.cwd });
+      if (result) {
+        args.push(...result.extraArgs);
+        options._historyViaResume = true;
+        logger.log("agent", `history via JSONL resume \u2192 ${result.filePath}`);
+      }
+    }
     if (extraArgsClean.length > 0) {
       args.push(...extraArgsClean);
     }
@@ -682,11 +772,34 @@ function getProvider(name = "claude-code") {
   return provider2;
 }
 
+// src/server/history-builder.ts
+function buildHistoryFromDb(sessionId) {
+  const db = getDb();
+  const rows = db.prepare(
+    `SELECT role, content FROM chat_messages
+     WHERE session_id = ? AND role IN ('user', 'assistant')
+     ORDER BY id ASC`
+  ).all(sessionId);
+  if (rows.length === 0) return [];
+  const merged = [];
+  for (const row of rows) {
+    const role = row.role;
+    if (!row.content?.trim()) continue;
+    const last = merged[merged.length - 1];
+    if (last && last.role === role) {
+      last.content += "\n\n" + row.content;
+    } else {
+      merged.push({ role, content: row.content });
+    }
+  }
+  return merged;
+}
+
 // src/server/image-store.ts
-import fs4 from "fs";
-import path4 from "path";
+import fs5 from "fs";
+import path5 from "path";
 import { createHash } from "crypto";
-var IMAGE_DIR = path4.join(process.cwd(), "data/images");
+var IMAGE_DIR = path5.join(process.cwd(), "data/images");
 var MIME_TO_EXT = {
   "image/png": "png",
   "image/jpeg": "jpg",
@@ -695,23 +808,23 @@ var MIME_TO_EXT = {
   "image/svg+xml": "svg"
 };
 function saveImages(sessionId, images) {
-  const dir = path4.join(IMAGE_DIR, sessionId);
-  fs4.mkdirSync(dir, { recursive: true });
+  const dir = path5.join(IMAGE_DIR, sessionId);
+  fs5.mkdirSync(dir, { recursive: true });
   return images.map((img) => {
     const ext = MIME_TO_EXT[img.mimeType] ?? "bin";
     const hash = createHash("sha256").update(img.base64).digest("hex").slice(0, 12);
     const filename = `${hash}.${ext}`;
-    const filePath = path4.join(dir, filename);
-    if (!fs4.existsSync(filePath)) {
-      fs4.writeFileSync(filePath, Buffer.from(img.base64, "base64"));
+    const filePath = path5.join(dir, filename);
+    if (!fs5.existsSync(filePath)) {
+      fs5.writeFileSync(filePath, Buffer.from(img.base64, "base64"));
     }
     return filename;
   });
 }
 function resolveImagePath(sessionId, filename) {
   if (filename.includes("..") || filename.includes("/")) return null;
-  const filePath = path4.join(IMAGE_DIR, sessionId, filename);
-  return fs4.existsSync(filePath) ? filePath : null;
+  const filePath = path5.join(IMAGE_DIR, sessionId, filename);
+  return fs5.existsSync(filePath) ? filePath : null;
 }
 
 // src/server/routes/agent.ts
@@ -902,7 +1015,13 @@ function createAgentRoutes(sessionManager2) {
       db.prepare(`INSERT INTO chat_messages (session_id, role, content, meta) VALUES (?, 'user', ?, ?)`).run(sessionId, textContent, Object.keys(meta).length > 0 ? JSON.stringify(meta) : null);
     } catch {
     }
-    session.state = "processing";
+    sessionManager2.pushEvent(sessionId, {
+      type: "user_message",
+      message: textContent,
+      data: Object.keys(meta).length > 0 ? meta : void 0,
+      timestamp: Date.now()
+    });
+    sessionManager2.updateSessionState(sessionId, "processing");
     sessionManager2.touch(sessionId);
     if (body.images?.length) {
       const content = [
@@ -924,32 +1043,59 @@ function createAgentRoutes(sessionManager2) {
     const sessionId = getSessionId(c);
     const session = sessionManager2.getOrCreateSession(sessionId);
     const sinceParam = c.req.query("since");
-    let cursor = sinceParam ? parseInt(sinceParam, 10) : session.eventCounter;
+    const sinceCursor = sinceParam ? parseInt(sinceParam, 10) : session.eventCounter;
     return streamSSE3(c, async (stream) => {
-      const POLL_MS = 300;
       const KEEPALIVE_MS = 15e3;
-      let lastSend = Date.now();
-      while (true) {
+      const signal = c.req.raw.signal;
+      const queue = [];
+      let wakeUp = null;
+      const unsub = sessionManager2.onSessionEvent(sessionId, (eventCursor, event) => {
+        queue.push({ cursor: eventCursor, event });
+        const fn = wakeUp;
+        wakeUp = null;
+        fn?.();
+      });
+      signal.addEventListener("abort", () => {
+        const fn = wakeUp;
+        wakeUp = null;
+        fn?.();
+      });
+      try {
+        let cursor = sinceCursor;
         if (cursor < session.eventCounter) {
           const startIdx = Math.max(
             0,
             session.eventBuffer.length - (session.eventCounter - cursor)
           );
-          const newEvents = session.eventBuffer.slice(startIdx);
-          for (const event of newEvents) {
+          for (const event of session.eventBuffer.slice(startIdx)) {
             cursor++;
-            await stream.writeSSE({
-              id: String(cursor),
-              data: JSON.stringify(event)
-            });
-            lastSend = Date.now();
+            await stream.writeSSE({ id: String(cursor), data: JSON.stringify(event) });
           }
+        } else {
+          cursor = session.eventCounter;
         }
-        if (Date.now() - lastSend > KEEPALIVE_MS) {
-          await stream.writeSSE({ data: "" });
-          lastSend = Date.now();
+        while (queue.length > 0 && queue[0].cursor <= cursor) queue.shift();
+        while (!signal.aborted) {
+          if (queue.length === 0) {
+            await Promise.race([
+              new Promise((r) => {
+                wakeUp = r;
+              }),
+              new Promise((r) => setTimeout(r, KEEPALIVE_MS))
+            ]);
+          }
+          if (signal.aborted) break;
+          if (queue.length > 0) {
+            while (queue.length > 0) {
+              const item = queue.shift();
+              await stream.writeSSE({ id: String(item.cursor), data: JSON.stringify(item.event) });
+            }
+          } else {
+            await stream.writeSSE({ data: "" });
+          }
         }
-        await new Promise((r) => setTimeout(r, POLL_MS));
+      } finally {
+        unsub();
       }
     });
   });
@@ -980,6 +1126,46 @@ function createAgentRoutes(sessionManager2) {
       return c.json({ status: "error", message: e.message }, 500);
     }
   });
+  app.post("/resume", async (c) => {
+    const sessionId = getSessionId(c);
+    const body = await c.req.json().catch(() => ({}));
+    const session = sessionManager2.getOrCreateSession(sessionId);
+    if (session.process?.alive) {
+      return c.json({ status: "error", message: "Session already running. Use agent.send instead." }, 400);
+    }
+    const history = buildHistoryFromDb(sessionId);
+    if (history.length === 0 && !body.prompt) {
+      return c.json({ status: "error", message: "No history in DB \u2014 nothing to resume." }, 400);
+    }
+    const providerName = body.provider ?? "claude-code";
+    const model = body.model ?? session.lastStartConfig?.model ?? "claude-sonnet-4-6";
+    const permissionMode2 = body.permissionMode ?? session.lastStartConfig?.permissionMode ?? "acceptEdits";
+    const extraArgs = body.extraArgs ?? session.lastStartConfig?.extraArgs;
+    const provider2 = getProvider(providerName);
+    try {
+      const proc = provider2.spawn({
+        cwd: session.cwd,
+        prompt: body.prompt,
+        model,
+        permissionMode: permissionMode2,
+        env: { SNA_SESSION_ID: sessionId },
+        history: history.length > 0 ? history : void 0,
+        extraArgs
+      });
+      sessionManager2.setProcess(sessionId, proc, "resumed");
+      sessionManager2.saveStartConfig(sessionId, { provider: providerName, model, permissionMode: permissionMode2, extraArgs });
+      logger.log("route", `POST /resume?session=${sessionId} \u2192 resumed (${history.length} history msgs)`);
+      return httpJson(c, "agent.resume", {
+        status: "resumed",
+        provider: providerName,
+        sessionId: session.id,
+        historyCount: history.length
+      });
+    } catch (e) {
+      logger.err("err", `POST /resume?session=${sessionId} \u2192 ${e.message}`);
+      return c.json({ status: "error", message: e.message }, 500);
+    }
+  });
   app.post("/interrupt", async (c) => {
     const sessionId = getSessionId(c);
     const interrupted = sessionManager2.interruptSession(sessionId);
@@ -1007,11 +1193,25 @@ function createAgentRoutes(sessionManager2) {
   app.get("/status", (c) => {
     const sessionId = getSessionId(c);
     const session = sessionManager2.getSession(sessionId);
+    const alive = session?.process?.alive ?? false;
+    let messageCount = 0;
+    let lastMessage = null;
+    try {
+      const db = getDb();
+      const count = db.prepare("SELECT COUNT(*) as c FROM chat_messages WHERE session_id = ?").get(sessionId);
+      messageCount = count?.c ?? 0;
+      const last = db.prepare("SELECT role, content, created_at FROM chat_messages WHERE session_id = ? ORDER BY id DESC LIMIT 1").get(sessionId);
+      if (last) lastMessage = { role: last.role, content: last.content, created_at: last.created_at };
+    } catch {
+    }
     return httpJson(c, "agent.status", {
-      alive: session?.process?.alive ?? false,
+      alive,
+      agentStatus: !alive ? "disconnected" : session?.state === "processing" ? "busy" : "idle",
       sessionId: session?.process?.sessionId ?? null,
       ccSessionId: session?.ccSessionId ?? null,
       eventCount: session?.eventCounter ?? 0,
+      messageCount,
+      lastMessage,
       config: session?.lastStartConfig ?? null
     });
   });
@@ -1046,7 +1246,7 @@ function createAgentRoutes(sessionManager2) {
 
 // src/server/routes/chat.ts
 import { Hono as Hono2 } from "hono";
-import fs5 from "fs";
+import fs6 from "fs";
 function createChatRoutes() {
   const app = new Hono2();
   app.get("/sessions", (c) => {
@@ -1152,7 +1352,7 @@ function createChatRoutes() {
       svg: "image/svg+xml"
     };
     const contentType = mimeMap[ext ?? ""] ?? "application/octet-stream";
-    const data = fs5.readFileSync(filePath);
+    const data = fs6.readFileSync(filePath);
     return new Response(data, { headers: { "Content-Type": contentType, "Cache-Control": "public, max-age=31536000, immutable" } });
   });
   return app;
@@ -1171,6 +1371,7 @@ var SessionManager = class {
     this.permissionRequestListeners = /* @__PURE__ */ new Set();
     this.lifecycleListeners = /* @__PURE__ */ new Set();
     this.configChangedListeners = /* @__PURE__ */ new Set();
+    this.stateChangedListeners = /* @__PURE__ */ new Set();
     this.maxSessions = options.maxSessions ?? DEFAULT_MAX_SESSIONS;
     this.restoreFromDb();
   }
@@ -1283,24 +1484,26 @@ var SessionManager = class {
     return this.createSession({ id, ...opts });
   }
   /** Set the agent process for a session. Subscribes to events. */
-  setProcess(sessionId, proc) {
+  setProcess(sessionId, proc, lifecycleState) {
     const session = this.sessions.get(sessionId);
     if (!session) throw new Error(`Session "${sessionId}" not found`);
     session.process = proc;
-    session.state = "processing";
+    this.setSessionState(sessionId, session, "processing");
     session.lastActivityAt = Date.now();
     proc.on("event", (e) => {
       if (e.type === "init" && e.data?.sessionId && !session.ccSessionId) {
         session.ccSessionId = e.data.sessionId;
         this.persistSession(session);
       }
-      session.eventBuffer.push(e);
-      session.eventCounter++;
-      if (session.eventBuffer.length > MAX_EVENT_BUFFER) {
-        session.eventBuffer.splice(0, session.eventBuffer.length - MAX_EVENT_BUFFER);
+      if (e.type !== "assistant_delta") {
+        session.eventBuffer.push(e);
+        if (session.eventBuffer.length > MAX_EVENT_BUFFER) {
+          session.eventBuffer.splice(0, session.eventBuffer.length - MAX_EVENT_BUFFER);
+        }
       }
+      session.eventCounter++;
       if (e.type === "complete" || e.type === "error" || e.type === "interrupted") {
-        session.state = "waiting";
+        this.setSessionState(sessionId, session, "waiting");
       }
       this.persistEvent(sessionId, e);
       const listeners = this.eventListeners.get(sessionId);
@@ -1309,14 +1512,14 @@ var SessionManager = class {
       }
     });
     proc.on("exit", (code) => {
-      session.state = "idle";
+      this.setSessionState(sessionId, session, "idle");
       this.emitLifecycle({ session: sessionId, state: code != null ? "exited" : "crashed", code });
     });
     proc.on("error", () => {
-      session.state = "idle";
+      this.setSessionState(sessionId, session, "idle");
       this.emitLifecycle({ session: sessionId, state: "crashed" });
     });
-    this.emitLifecycle({ session: sessionId, state: "started" });
+    this.emitLifecycle({ session: sessionId, state: lifecycleState ?? "started" });
   }
   // ── Event pub/sub (for WebSocket) ─────────────────────────────
   /** Subscribe to real-time events for a session. Returns unsubscribe function. */
@@ -1342,6 +1545,20 @@ var SessionManager = class {
   broadcastSkillEvent(event) {
     for (const cb of this.skillEventListeners) cb(event);
   }
+  /** Push a synthetic event into a session's event stream (for user message broadcast). */
+  pushEvent(sessionId, event) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return;
+    session.eventBuffer.push(event);
+    session.eventCounter++;
+    if (session.eventBuffer.length > MAX_EVENT_BUFFER) {
+      session.eventBuffer.splice(0, session.eventBuffer.length - MAX_EVENT_BUFFER);
+    }
+    const listeners = this.eventListeners.get(sessionId);
+    if (listeners) {
+      for (const cb of listeners) cb(session.eventCounter, event);
+    }
+  }
   // ── Permission pub/sub ────────────────────────────────────────
   /** Subscribe to permission request notifications. Returns unsubscribe function. */
   onPermissionRequest(cb) {
@@ -1366,11 +1583,29 @@ var SessionManager = class {
   emitConfigChanged(sessionId, config) {
     for (const cb of this.configChangedListeners) cb({ session: sessionId, config });
   }
+  // ── Agent status change pub/sub ────────────────────────────────
+  onStateChanged(cb) {
+    this.stateChangedListeners.add(cb);
+    return () => this.stateChangedListeners.delete(cb);
+  }
+  /** Update session state and push agentStatus change to subscribers. */
+  updateSessionState(sessionId, newState) {
+    const session = this.sessions.get(sessionId);
+    if (session) this.setSessionState(sessionId, session, newState);
+  }
+  setSessionState(sessionId, session, newState) {
+    const oldState = session.state;
+    session.state = newState;
+    const newStatus = !session.process?.alive ? "disconnected" : newState === "processing" ? "busy" : "idle";
+    if (oldState !== newState) {
+      for (const cb of this.stateChangedListeners) cb({ session: sessionId, agentStatus: newStatus, state: newState });
+    }
+  }
   // ── Permission management ─────────────────────────────────────
   /** Create a pending permission request. Returns a promise that resolves when approved/denied. */
   createPendingPermission(sessionId, request) {
     const session = this.sessions.get(sessionId);
-    if (session) session.state = "permission";
+    if (session) this.setSessionState(sessionId, session, "permission");
     return new Promise((resolve) => {
       const createdAt = Date.now();
       this.pendingPermissions.set(sessionId, { resolve, request, createdAt });
@@ -1390,7 +1625,7 @@ var SessionManager = class {
     pending.resolve(approved);
     this.pendingPermissions.delete(sessionId);
     const session = this.sessions.get(sessionId);
-    if (session) session.state = "processing";
+    if (session) this.setSessionState(sessionId, session, "processing");
     return true;
   }
   /** Get a pending permission for a specific session. */
@@ -1442,7 +1677,7 @@ var SessionManager = class {
     const session = this.sessions.get(id);
     if (!session?.process?.alive) return false;
     session.process.interrupt();
-    session.state = "waiting";
+    this.setSessionState(id, session, "waiting");
     return true;
   }
   /** Change model. Sends control message if alive, always persists to config. */
@@ -1499,11 +1734,13 @@ var SessionManager = class {
       label: s.label,
       alive: s.process?.alive ?? false,
       state: s.state,
+      agentStatus: !s.process?.alive ? "disconnected" : s.state === "processing" ? "busy" : "idle",
       cwd: s.cwd,
       meta: s.meta,
       config: s.lastStartConfig,
       ccSessionId: s.ccSessionId,
       eventCount: s.eventCounter,
+      ...this.getMessageStats(s.id),
       createdAt: s.createdAt,
       lastActivityAt: s.lastActivityAt
     }));
@@ -1514,6 +1751,23 @@ var SessionManager = class {
     if (session) session.lastActivityAt = Date.now();
   }
   /** Persist an agent event to chat_messages. */
+  getMessageStats(sessionId) {
+    try {
+      const db = getDb();
+      const count = db.prepare(
+        `SELECT COUNT(*) as c FROM chat_messages WHERE session_id = ?`
+      ).get(sessionId);
+      const last = db.prepare(
+        `SELECT role, content, created_at FROM chat_messages WHERE session_id = ? ORDER BY id DESC LIMIT 1`
+      ).get(sessionId);
+      return {
+        messageCount: count.c,
+        lastMessage: last ? { role: last.role, content: last.content, created_at: last.created_at } : null
+      };
+    } catch {
+      return { messageCount: 0, lastMessage: null };
+    }
+  }
   persistEvent(sessionId, e) {
     try {
       const db = getDb();
@@ -1586,13 +1840,16 @@ function attachWebSocket(server2, sessionManager2) {
   });
   wss.on("connection", (ws) => {
     logger.log("ws", "client connected");
-    const state = { agentUnsubs: /* @__PURE__ */ new Map(), skillEventUnsub: null, skillPollTimer: null, permissionUnsub: null, lifecycleUnsub: null, configChangedUnsub: null };
+    const state = { agentUnsubs: /* @__PURE__ */ new Map(), skillEventUnsub: null, skillPollTimer: null, permissionUnsub: null, lifecycleUnsub: null, configChangedUnsub: null, stateChangedUnsub: null };
     state.lifecycleUnsub = sessionManager2.onSessionLifecycle((event) => {
       send(ws, { type: "session.lifecycle", ...event });
     });
     state.configChangedUnsub = sessionManager2.onConfigChanged((event) => {
       send(ws, { type: "session.config-changed", ...event });
     });
+    state.stateChangedUnsub = sessionManager2.onStateChanged((event) => {
+      send(ws, { type: "session.state-changed", ...event });
+    });
     ws.on("message", (raw) => {
       let msg;
       try {
@@ -1623,6 +1880,8 @@ function attachWebSocket(server2, sessionManager2) {
       state.lifecycleUnsub = null;
       state.configChangedUnsub?.();
       state.configChangedUnsub = null;
+      state.stateChangedUnsub?.();
+      state.stateChangedUnsub = null;
     });
   });
   return wss;
@@ -1641,6 +1900,8 @@ function handleMessage(ws, msg, sm, state) {
       return handleAgentStart(ws, msg, sm);
     case "agent.send":
       return handleAgentSend(ws, msg, sm);
+    case "agent.resume":
+      return handleAgentResume(ws, msg, sm);
     case "agent.restart":
       return handleAgentRestart(ws, msg, sm);
     case "agent.interrupt":
@@ -1782,7 +2043,13 @@ function handleAgentSend(ws, msg, sm) {
     db.prepare(`INSERT INTO chat_messages (session_id, role, content, meta) VALUES (?, 'user', ?, ?)`).run(sessionId, textContent, Object.keys(meta).length > 0 ? JSON.stringify(meta) : null);
   } catch {
   }
-  session.state = "processing";
+  sm.pushEvent(sessionId, {
+    type: "user_message",
+    message: textContent,
+    data: Object.keys(meta).length > 0 ? meta : void 0,
+    timestamp: Date.now()
+  });
+  sm.updateSessionState(sessionId, "processing");
   sm.touch(sessionId);
   if (images?.length) {
     const content = [
@@ -1798,6 +2065,43 @@ function handleAgentSend(ws, msg, sm) {
   }
   wsReply(ws, msg, { status: "sent" });
 }
+function handleAgentResume(ws, msg, sm) {
+  const sessionId = msg.session ?? "default";
+  const session = sm.getOrCreateSession(sessionId);
+  if (session.process?.alive) {
+    return replyError(ws, msg, "Session already running. Use agent.send instead.");
+  }
+  const history = buildHistoryFromDb(sessionId);
+  if (history.length === 0 && !msg.prompt) {
+    return replyError(ws, msg, "No history in DB \u2014 nothing to resume.");
+  }
+  const providerName = msg.provider ?? session.lastStartConfig?.provider ?? "claude-code";
+  const model = msg.model ?? session.lastStartConfig?.model ?? "claude-sonnet-4-6";
+  const permissionMode2 = msg.permissionMode ?? session.lastStartConfig?.permissionMode ?? "acceptEdits";
+  const extraArgs = msg.extraArgs ?? session.lastStartConfig?.extraArgs;
+  const provider2 = getProvider(providerName);
+  try {
+    const proc = provider2.spawn({
+      cwd: session.cwd,
+      prompt: msg.prompt,
+      model,
+      permissionMode: permissionMode2,
+      env: { SNA_SESSION_ID: sessionId },
+      history: history.length > 0 ? history : void 0,
+      extraArgs
+    });
+    sm.setProcess(sessionId, proc, "resumed");
+    sm.saveStartConfig(sessionId, { provider: providerName, model, permissionMode: permissionMode2, extraArgs });
+    wsReply(ws, msg, {
+      status: "resumed",
+      provider: providerName,
+      sessionId: session.id,
+      historyCount: history.length
+    });
+  } catch (e) {
+    replyError(ws, msg, e.message);
+  }
+}
 function handleAgentRestart(ws, msg, sm) {
   const sessionId = msg.session ?? "default";
   try {
@@ -1854,11 +2158,25 @@ function handleAgentKill(ws, msg, sm) {
 function handleAgentStatus(ws, msg, sm) {
   const sessionId = msg.session ?? "default";
   const session = sm.getSession(sessionId);
+  const alive = session?.process?.alive ?? false;
+  let messageCount = 0;
+  let lastMessage = null;
+  try {
+    const db = getDb();
+    const count = db.prepare("SELECT COUNT(*) as c FROM chat_messages WHERE session_id = ?").get(sessionId);
+    messageCount = count?.c ?? 0;
+    const last = db.prepare("SELECT role, content, created_at FROM chat_messages WHERE session_id = ? ORDER BY id DESC LIMIT 1").get(sessionId);
+    if (last) lastMessage = { role: last.role, content: last.content, created_at: last.created_at };
+  } catch {
+  }
   wsReply(ws, msg, {
-    alive: session?.process?.alive ?? false,
+    alive,
+    agentStatus: !alive ? "disconnected" : session?.state === "processing" ? "busy" : "idle",
     sessionId: session?.process?.sessionId ?? null,
     ccSessionId: session?.ccSessionId ?? null,
     eventCount: session?.eventCounter ?? 0,
+    messageCount,
+    lastMessage,
     config: session?.lastStartConfig ?? null
   });
 }
@@ -1875,7 +2193,38 @@ function handleAgentSubscribe(ws, msg, sm, state) {
   const sessionId = msg.session ?? "default";
   const session = sm.getOrCreateSession(sessionId);
   state.agentUnsubs.get(sessionId)?.();
-  let cursor = typeof msg.since === "number" ? msg.since : session.eventCounter;
+  const includeHistory = msg.since === 0 || msg.includeHistory === true;
+  let cursor = 0;
+  if (includeHistory) {
+    try {
+      const db = getDb();
+      const rows = db.prepare(
+        `SELECT role, content, meta, created_at FROM chat_messages
+         WHERE session_id = ? ORDER BY id ASC`
+      ).all(sessionId);
+      for (const row of rows) {
+        cursor++;
+        const eventType = row.role === "user" ? "user_message" : row.role === "assistant" ? "assistant" : row.role === "thinking" ? "thinking" : row.role === "tool" ? "tool_use" : row.role === "tool_result" ? "tool_result" : row.role === "error" ? "error" : null;
+        if (!eventType) continue;
+        const meta = row.meta ? JSON.parse(row.meta) : void 0;
+        send(ws, {
+          type: "agent.event",
+          session: sessionId,
+          cursor,
+          isHistory: true,
+          event: {
+            type: eventType,
+            message: row.content,
+            data: meta,
+            timestamp: new Date(row.created_at).getTime()
+          }
+        });
+      }
+    } catch {
+    }
+  }
+  const bufferStart = typeof msg.since === "number" && msg.since > 0 ? msg.since : session.eventCounter;
+  if (!includeHistory) cursor = bufferStart;
   if (cursor < session.eventCounter) {
     const startIdx = Math.max(0, session.eventBuffer.length - (session.eventCounter - cursor));
     const events = session.eventBuffer.slice(startIdx);
@@ -1883,6 +2232,8 @@ function handleAgentSubscribe(ws, msg, sm, state) {
       cursor++;
       send(ws, { type: "agent.event", session: sessionId, cursor, event });
     }
+  } else {
+    cursor = session.eventCounter;
   }
   const unsub = sm.onSessionEvent(sessionId, (eventCursor, event) => {
     send(ws, { type: "agent.event", session: sessionId, cursor: eventCursor, event });
@@ -1995,10 +2346,14 @@ function handlePermissionPending(ws, msg, sm) {
 }
 function handlePermissionSubscribe(ws, msg, sm, state) {
   state.permissionUnsub?.();
+  const pending = sm.getAllPendingPermissions();
+  for (const p of pending) {
+    send(ws, { type: "permission.request", session: p.sessionId, request: p.request, createdAt: p.createdAt, isHistory: true });
+  }
   state.permissionUnsub = sm.onPermissionRequest((sessionId, request, createdAt) => {
     send(ws, { type: "permission.request", session: sessionId, request, createdAt });
   });
-  reply(ws, msg, {});
+  reply(ws, msg, { pendingCount: pending.length });
 }
 function handlePermissionUnsubscribe(ws, msg, state) {
   state.permissionUnsub?.();
@@ -2135,8 +2490,8 @@ var methodColor = {
 root.use("*", async (c, next) => {
   const m = c.req.method;
   const colorFn = methodColor[m] ?? chalk2.white;
-  const path5 = new URL(c.req.url).pathname;
-  logger.log("req", `${colorFn(m.padEnd(6))} ${path5}`);
+  const path6 = new URL(c.req.url).pathname;
+  logger.log("req", `${colorFn(m.padEnd(6))} ${path6}`);
   await next();
 });
 var sessionManager = new SessionManager({ maxSessions });