@sna-sdk/core 0.6.1 → 0.7.2

package/dist/server/standalone.js

@@ -18,6 +18,14 @@ 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() {
+  const modulesPath = process.env.SNA_MODULES_PATH;
+  if (modulesPath) {
+    const entry = path.join(modulesPath, "better-sqlite3");
+    if (fs.existsSync(entry)) {
+      const req2 = createRequire(path.join(modulesPath, "noop.js"));
+      return req2("better-sqlite3");
+    }
+  }
   const nativeEntry = path.join(NATIVE_DIR, "node_modules", "better-sqlite3");
   if (fs.existsSync(nativeEntry)) {
     const req2 = createRequire(path.join(NATIVE_DIR, "noop.js"));
@@ -402,13 +410,20 @@ function resolveClaudePath(cwd) {
     return "claude";
   }
 }
-var ClaudeCodeProcess = class {
+var _ClaudeCodeProcess = class _ClaudeCodeProcess {
   constructor(proc, options) {
     this.emitter = new EventEmitter();
     this._alive = true;
     this._sessionId = null;
     this._initEmitted = false;
     this.buffer = "";
+    /**
+     * FIFO event queue — ALL events (deltas, assistant, complete, etc.) go through
+     * this queue. A fixed-interval timer drains one item at a time, guaranteeing
+     * strict ordering: deltas → assistant → complete, never out of order.
+     */
+    this.eventQueue = [];
+    this.drainTimer = null;
     this.proc = proc;
     proc.stdout.on("data", (chunk) => {
       this.buffer += chunk.toString();
@@ -423,7 +438,7 @@ var ClaudeCodeProcess = class {
             this._sessionId = msg.session_id;
           }
           const event = this.normalizeEvent(msg);
-          if (event) this.emitter.emit("event", event);
+          if (event) this.enqueue(event);
         } catch {
         }
       }
@@ -436,10 +451,11 @@ var ClaudeCodeProcess = class {
         try {
           const msg = JSON.parse(this.buffer);
           const event = this.normalizeEvent(msg);
-          if (event) this.emitter.emit("event", event);
+          if (event) this.enqueue(event);
         } catch {
         }
       }
+      this.flushQueue();
       this.emitter.emit("exit", code);
       logger.log("agent", `process exited (code=${code})`);
     });
@@ -455,35 +471,58 @@ var ClaudeCodeProcess = class {
       this.send(options.prompt);
     }
   }
+  // ~67 events/sec
+  /**
+   * Enqueue an event for ordered emission.
+   * Starts the drain timer if not already running.
+   */
+  enqueue(event) {
+    this.eventQueue.push(event);
+    if (!this.drainTimer) {
+      this.drainTimer = setInterval(() => this.drainOne(), _ClaudeCodeProcess.DRAIN_INTERVAL_MS);
+    }
+  }
+  /** Emit one event from the front of the queue. Stop timer when empty. */
+  drainOne() {
+    const event = this.eventQueue.shift();
+    if (event) {
+      this.emitter.emit("event", event);
+    }
+    if (this.eventQueue.length === 0 && this.drainTimer) {
+      clearInterval(this.drainTimer);
+      this.drainTimer = null;
+    }
+  }
+  /** Flush all remaining queued events immediately (used on process exit). */
+  flushQueue() {
+    if (this.drainTimer) {
+      clearInterval(this.drainTimer);
+      this.drainTimer = null;
+    }
+    while (this.eventQueue.length > 0) {
+      this.emitter.emit("event", this.eventQueue.shift());
+    }
+  }
   /**
-   * 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.
+   * Split completed assistant text into delta chunks and enqueue them,
+   * followed by the final assistant event. All go through the FIFO queue
+   * so subsequent events (complete, etc.) are guaranteed to come after.
    */
-  emitTextAsDeltas(text) {
+  enqueueTextAsDeltas(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,
+      this.enqueue({
+        type: "assistant_delta",
+        delta: text.slice(i, i + CHUNK_SIZE),
+        index: 0,
         timestamp: Date.now()
       });
-    }, t);
+    }
+    this.enqueue({
+      type: "assistant",
+      message: text,
+      timestamp: Date.now()
+    });
   }
   get alive() {
     return this._alive;
@@ -584,10 +623,10 @@ var ClaudeCodeProcess = class {
         }
         if (events.length > 0 || textBlocks.length > 0) {
           for (const e of events) {
-            this.emitter.emit("event", e);
+            this.enqueue(e);
           }
           for (const text of textBlocks) {
-            this.emitTextAsDeltas(text);
+            this.enqueueTextAsDeltas(text);
           }
         }
         return null;
@@ -656,6 +695,8 @@ var ClaudeCodeProcess = class {
     }
   }
 };
+_ClaudeCodeProcess.DRAIN_INTERVAL_MS = 15;
+var ClaudeCodeProcess = _ClaudeCodeProcess;
 var ClaudeCodeProvider = class {
   constructor() {
     this.name = "claude-code";
@@ -946,7 +987,6 @@ function createAgentRoutes(sessionManager2) {
     if (session.process?.alive) {
       session.process.kill();
     }
-    session.eventBuffer.length = 0;
     const provider2 = getProvider(body.provider ?? "claude-code");
     try {
       const db = getDb();
@@ -1075,7 +1115,7 @@ function createAgentRoutes(sessionManager2) {
         } else {
           cursor = session.eventCounter;
         }
-        while (queue.length > 0 && queue[0].cursor <= cursor) queue.shift();
+        while (queue.length > 0 && queue[0].cursor !== -1 && queue[0].cursor <= cursor) queue.shift();
         while (!signal.aborted) {
           if (queue.length === 0) {
             await Promise.race([
@@ -1089,7 +1129,11 @@ function createAgentRoutes(sessionManager2) {
           if (queue.length > 0) {
             while (queue.length > 0) {
               const item = queue.shift();
-              await stream.writeSSE({ id: String(item.cursor), data: JSON.stringify(item.event) });
+              if (item.cursor === -1) {
+                await stream.writeSSE({ data: JSON.stringify(item.event) });
+              } else {
+                await stream.writeSSE({ id: String(item.cursor), data: JSON.stringify(item.event) });
+              }
             }
           } else {
             await stream.writeSSE({ data: "" });
@@ -1373,6 +1417,7 @@ var SessionManager = class {
     this.lifecycleListeners = /* @__PURE__ */ new Set();
     this.configChangedListeners = /* @__PURE__ */ new Set();
     this.stateChangedListeners = /* @__PURE__ */ new Set();
+    this.metadataChangedListeners = /* @__PURE__ */ new Set();
     this.maxSessions = options.maxSessions ?? DEFAULT_MAX_SESSIONS;
     this.restoreFromDb();
   }
@@ -1425,26 +1470,11 @@ var SessionManager = class {
     } catch {
     }
   }
-  /** Create a new session. Throws if max sessions reached. */
+  /** Create a new session. Throws if session already exists or max sessions reached. */
   createSession(opts = {}) {
     const id = opts.id ?? crypto.randomUUID().slice(0, 8);
     if (this.sessions.has(id)) {
-      const existing = this.sessions.get(id);
-      let changed = false;
-      if (opts.cwd && opts.cwd !== existing.cwd) {
-        existing.cwd = opts.cwd;
-        changed = true;
-      }
-      if (opts.label && opts.label !== existing.label) {
-        existing.label = opts.label;
-        changed = true;
-      }
-      if (opts.meta !== void 0 && opts.meta !== existing.meta) {
-        existing.meta = opts.meta ?? null;
-        changed = true;
-      }
-      if (changed) this.persistSession(existing);
-      return existing;
+      throw new Error(`Session "${id}" already exists`);
     }
     const aliveCount = Array.from(this.sessions.values()).filter((s) => s.process?.alive).length;
     if (aliveCount >= this.maxSessions) {
@@ -1468,6 +1498,17 @@ var SessionManager = class {
     this.persistSession(session);
     return session;
   }
+  /** Update an existing session's metadata. Throws if session not found. */
+  updateSession(id, opts) {
+    const session = this.sessions.get(id);
+    if (!session) throw new Error(`Session "${id}" not found`);
+    if (opts.label !== void 0) session.label = opts.label;
+    if (opts.meta !== void 0) session.meta = opts.meta;
+    if (opts.cwd !== void 0) session.cwd = opts.cwd;
+    this.persistSession(session);
+    this.emitMetadataChanged(id);
+    return session;
+  }
   /** Get a session by ID. */
   getSession(id) {
     return this.sessions.get(id);
@@ -1489,27 +1530,45 @@ var SessionManager = class {
     const session = this.sessions.get(sessionId);
     if (!session) throw new Error(`Session "${sessionId}" not found`);
     session.process = proc;
-    this.setSessionState(sessionId, session, "processing");
     session.lastActivityAt = Date.now();
+    session.eventBuffer.length = 0;
+    try {
+      const db = getDb();
+      const row = db.prepare(
+        `SELECT COUNT(*) as c FROM chat_messages WHERE session_id = ?`
+      ).get(sessionId);
+      session.eventCounter = row.c;
+    } catch {
+    }
     proc.on("event", (e) => {
-      if (e.type === "init" && e.data?.sessionId && !session.ccSessionId) {
-        session.ccSessionId = e.data.sessionId;
-        this.persistSession(session);
+      if (e.type === "init") {
+        if (e.data?.sessionId && !session.ccSessionId) {
+          session.ccSessionId = e.data.sessionId;
+          this.persistSession(session);
+        }
+        this.setSessionState(sessionId, session, "waiting");
       }
-      if (e.type !== "assistant_delta") {
+      if (e.type === "thinking" || e.type === "tool_use" || e.type === "assistant_delta") {
+        this.setSessionState(sessionId, session, "processing");
+      } else if (e.type === "complete" || e.type === "error" || e.type === "interrupted") {
+        this.setSessionState(sessionId, session, "waiting");
+      }
+      const persisted = this.persistEvent(sessionId, e);
+      if (persisted) {
+        session.eventCounter++;
         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") {
-        this.setSessionState(sessionId, session, "waiting");
-      }
-      this.persistEvent(sessionId, e);
-      const listeners = this.eventListeners.get(sessionId);
-      if (listeners) {
-        for (const cb of listeners) cb(session.eventCounter, e);
+        const listeners = this.eventListeners.get(sessionId);
+        if (listeners) {
+          for (const cb of listeners) cb(session.eventCounter, e);
+        }
+      } else if (e.type === "assistant_delta") {
+        const listeners = this.eventListeners.get(sessionId);
+        if (listeners) {
+          for (const cb of listeners) cb(-1, e);
+        }
       }
     });
     proc.on("exit", (code) => {
@@ -1547,11 +1606,17 @@ var SessionManager = class {
     for (const cb of this.skillEventListeners) cb(event);
   }
   /** Push a synthetic event into a session's event stream (for user message broadcast). */
+  /**
+   * Push an externally-persisted event into the session.
+   * The caller is responsible for DB persistence — this method only updates
+   * the in-memory counter/buffer and notifies listeners.
+   * eventCounter increments to stay in sync with the DB row count.
+   */
   pushEvent(sessionId, event) {
     const session = this.sessions.get(sessionId);
     if (!session) return;
-    session.eventBuffer.push(event);
     session.eventCounter++;
+    session.eventBuffer.push(event);
     if (session.eventBuffer.length > MAX_EVENT_BUFFER) {
       session.eventBuffer.splice(0, session.eventBuffer.length - MAX_EVENT_BUFFER);
     }
@@ -1584,6 +1649,14 @@ var SessionManager = class {
   emitConfigChanged(sessionId, config) {
     for (const cb of this.configChangedListeners) cb({ session: sessionId, config });
   }
+  // ── Session metadata change pub/sub ─────────────────────────────
+  onMetadataChanged(cb) {
+    this.metadataChangedListeners.add(cb);
+    return () => this.metadataChangedListeners.delete(cb);
+  }
+  emitMetadataChanged(sessionId) {
+    for (const cb of this.metadataChangedListeners) cb(sessionId);
+  }
   // ── Agent status change pub/sub ────────────────────────────────
   onStateChanged(cb) {
     this.stateChangedListeners.add(cb);
@@ -1664,7 +1737,6 @@ var SessionManager = class {
       extraArgs: overrides.extraArgs ?? base.extraArgs
     };
     if (session.process?.alive) session.process.kill();
-    session.eventBuffer.length = 0;
     const proc = spawnFn(config);
     this.setProcess(id, proc);
     session.lastStartConfig = config;
@@ -1769,6 +1841,7 @@ var SessionManager = class {
       return { messageCount: 0, lastMessage: null };
     }
   }
+  /** Persist an agent event to chat_messages. Returns true if a row was inserted. */
   persistEvent(sessionId, e) {
     try {
       const db = getDb();
@@ -1776,29 +1849,34 @@ var SessionManager = class {
         case "assistant":
           if (e.message) {
             db.prepare(`INSERT INTO chat_messages (session_id, role, content) VALUES (?, 'assistant', ?)`).run(sessionId, e.message);
+            return true;
           }
-          break;
+          return false;
         case "thinking":
           if (e.message) {
             db.prepare(`INSERT INTO chat_messages (session_id, role, content) VALUES (?, 'thinking', ?)`).run(sessionId, e.message);
+            return true;
           }
-          break;
+          return false;
         case "tool_use": {
           const toolName = e.data?.toolName ?? e.message ?? "tool";
           db.prepare(`INSERT INTO chat_messages (session_id, role, content, meta) VALUES (?, 'tool', ?, ?)`).run(sessionId, toolName, JSON.stringify(e.data ?? {}));
-          break;
+          return true;
         }
         case "tool_result":
           db.prepare(`INSERT INTO chat_messages (session_id, role, content, meta) VALUES (?, 'tool_result', ?, ?)`).run(sessionId, e.message ?? "", JSON.stringify(e.data ?? {}));
-          break;
+          return true;
         case "complete":
           db.prepare(`INSERT INTO chat_messages (session_id, role, content, meta) VALUES (?, 'status', '', ?)`).run(sessionId, JSON.stringify({ status: "complete", ...e.data }));
-          break;
+          return true;
         case "error":
           db.prepare(`INSERT INTO chat_messages (session_id, role, content, meta) VALUES (?, 'error', ?, ?)`).run(sessionId, e.message ?? "Error", JSON.stringify({ status: "error" }));
-          break;
+          return true;
+        default:
+          return false;
       }
     } catch {
+      return false;
     }
   }
   /** Kill all sessions. Used during shutdown. */
@@ -1841,15 +1919,22 @@ 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, stateChangedUnsub: null };
+    const state = { agentUnsubs: /* @__PURE__ */ new Map(), skillEventUnsub: null, skillPollTimer: null, permissionUnsub: null, lifecycleUnsub: null, configChangedUnsub: null, stateChangedUnsub: null, metadataChangedUnsub: null };
+    const pushSnapshot = () => send(ws, { type: "sessions.snapshot", sessions: sessionManager2.listSessions() });
+    pushSnapshot();
     state.lifecycleUnsub = sessionManager2.onSessionLifecycle((event) => {
       send(ws, { type: "session.lifecycle", ...event });
+      pushSnapshot();
     });
     state.configChangedUnsub = sessionManager2.onConfigChanged((event) => {
       send(ws, { type: "session.config-changed", ...event });
     });
     state.stateChangedUnsub = sessionManager2.onStateChanged((event) => {
       send(ws, { type: "session.state-changed", ...event });
+      pushSnapshot();
+    });
+    state.metadataChangedUnsub = sessionManager2.onMetadataChanged(() => {
+      pushSnapshot();
     });
     ws.on("message", (raw) => {
       let msg;
@@ -1883,6 +1968,8 @@ function attachWebSocket(server2, sessionManager2) {
       state.configChangedUnsub = null;
       state.stateChangedUnsub?.();
       state.stateChangedUnsub = null;
+      state.metadataChangedUnsub?.();
+      state.metadataChangedUnsub = null;
     });
   });
   return wss;
@@ -1894,6 +1981,8 @@ function handleMessage(ws, msg, sm, state) {
       return handleSessionsCreate(ws, msg, sm);
     case "sessions.list":
       return wsReply(ws, msg, { sessions: sm.listSessions() });
+    case "sessions.update":
+      return handleSessionsUpdate(ws, msg, sm);
     case "sessions.remove":
       return handleSessionsRemove(ws, msg, sm);
     // ── Agent lifecycle ───────────────────────────────
@@ -1969,6 +2058,20 @@ function handleSessionsCreate(ws, msg, sm) {
     replyError(ws, msg, e.message);
   }
 }
+function handleSessionsUpdate(ws, msg, sm) {
+  const id = msg.session;
+  if (!id) return replyError(ws, msg, "session is required");
+  try {
+    sm.updateSession(id, {
+      label: msg.label,
+      meta: msg.meta,
+      cwd: msg.cwd
+    });
+    wsReply(ws, msg, { status: "updated", session: id });
+  } catch (e) {
+    replyError(ws, msg, e.message);
+  }
+}
 function handleSessionsRemove(ws, msg, sm) {
   const id = msg.session;
   if (!id) return replyError(ws, msg, "session is required");
@@ -1987,7 +2090,6 @@ function handleAgentStart(ws, msg, sm) {
     return;
   }
   if (session.process?.alive) session.process.kill();
-  session.eventBuffer.length = 0;
   const provider2 = getProvider(msg.provider ?? "claude-code");
   try {
     const db = getDb();
@@ -2223,21 +2325,33 @@ function handleAgentSubscribe(ws, msg, sm, state) {
       }
     } 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);
-    for (const event of events) {
-      cursor++;
-      send(ws, { type: "agent.event", session: sessionId, cursor, event });
+    if (cursor < session.eventCounter) {
+      const unpersisted = session.eventCounter - cursor;
+      const bufferSlice = session.eventBuffer.slice(-unpersisted);
+      for (const event of bufferSlice) {
+        cursor++;
+        send(ws, { type: "agent.event", session: sessionId, cursor, event });
+      }
     }
   } else {
-    cursor = session.eventCounter;
+    cursor = typeof msg.since === "number" && msg.since > 0 ? msg.since : session.eventCounter;
+    if (cursor < session.eventCounter) {
+      const startIdx = Math.max(0, session.eventBuffer.length - (session.eventCounter - cursor));
+      const events = session.eventBuffer.slice(startIdx);
+      for (const event of events) {
+        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 });
+    if (eventCursor === -1) {
+      send(ws, { type: "agent.event", session: sessionId, event });
+    } else {
+      send(ws, { type: "agent.event", session: sessionId, cursor: eventCursor, event });
+    }
   });
   state.agentUnsubs.set(sessionId, unsub);
   reply(ws, msg, { cursor });
@@ -2496,7 +2610,7 @@ root.use("*", async (c, next) => {
   await next();
 });
 var sessionManager = new SessionManager({ maxSessions });
-sessionManager.createSession({ id: "default", cwd: process.cwd() });
+sessionManager.getOrCreateSession("default", { cwd: process.cwd() });
 var provider = getProvider("claude-code");
 logger.log("sna", "spawning agent...");
 var agentProcess = provider.spawn({ cwd: process.cwd(), permissionMode, model: defaultModel });

package/dist/server/ws.d.ts

@@ -13,6 +13,7 @@ import '../core/providers/types.js';
  *   Server → Client:  { type: "sessions.list", rid: "1", sessions: [...] }
  *   Server → Client:  { type: "error", rid: "1", message: "..." }
  *   Server → Client:  { type: "agent.event", session: "abc", cursor: 42, event: {...} }  (push)
+ *   Server → Client:  { type: "sessions.snapshot", sessions: [...] }                   (auto-push on connect + state change)
  *   Server → Client:  { type: "session.lifecycle", session: "abc", state: "killed" }   (auto-push)
  *   Server → Client:  { type: "skill.event", data: {...} }  (push)
  *

package/dist/server/ws.js

@@ -31,15 +31,22 @@ function attachWebSocket(server, sessionManager) {
   });
   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, stateChangedUnsub: null };
+    const state = { agentUnsubs: /* @__PURE__ */ new Map(), skillEventUnsub: null, skillPollTimer: null, permissionUnsub: null, lifecycleUnsub: null, configChangedUnsub: null, stateChangedUnsub: null, metadataChangedUnsub: null };
+    const pushSnapshot = () => send(ws, { type: "sessions.snapshot", sessions: sessionManager.listSessions() });
+    pushSnapshot();
     state.lifecycleUnsub = sessionManager.onSessionLifecycle((event) => {
       send(ws, { type: "session.lifecycle", ...event });
+      pushSnapshot();
     });
     state.configChangedUnsub = sessionManager.onConfigChanged((event) => {
       send(ws, { type: "session.config-changed", ...event });
     });
     state.stateChangedUnsub = sessionManager.onStateChanged((event) => {
       send(ws, { type: "session.state-changed", ...event });
+      pushSnapshot();
+    });
+    state.metadataChangedUnsub = sessionManager.onMetadataChanged(() => {
+      pushSnapshot();
     });
     ws.on("message", (raw) => {
       let msg;
@@ -73,6 +80,8 @@ function attachWebSocket(server, sessionManager) {
       state.configChangedUnsub = null;
       state.stateChangedUnsub?.();
       state.stateChangedUnsub = null;
+      state.metadataChangedUnsub?.();
+      state.metadataChangedUnsub = null;
     });
   });
   return wss;
@@ -84,6 +93,8 @@ function handleMessage(ws, msg, sm, state) {
       return handleSessionsCreate(ws, msg, sm);
     case "sessions.list":
       return wsReply(ws, msg, { sessions: sm.listSessions() });
+    case "sessions.update":
+      return handleSessionsUpdate(ws, msg, sm);
     case "sessions.remove":
       return handleSessionsRemove(ws, msg, sm);
     // ── Agent lifecycle ───────────────────────────────
@@ -159,6 +170,20 @@ function handleSessionsCreate(ws, msg, sm) {
     replyError(ws, msg, e.message);
   }
 }
+function handleSessionsUpdate(ws, msg, sm) {
+  const id = msg.session;
+  if (!id) return replyError(ws, msg, "session is required");
+  try {
+    sm.updateSession(id, {
+      label: msg.label,
+      meta: msg.meta,
+      cwd: msg.cwd
+    });
+    wsReply(ws, msg, { status: "updated", session: id });
+  } catch (e) {
+    replyError(ws, msg, e.message);
+  }
+}
 function handleSessionsRemove(ws, msg, sm) {
   const id = msg.session;
   if (!id) return replyError(ws, msg, "session is required");
@@ -177,7 +202,6 @@ function handleAgentStart(ws, msg, sm) {
     return;
   }
   if (session.process?.alive) session.process.kill();
-  session.eventBuffer.length = 0;
   const provider = getProvider(msg.provider ?? "claude-code");
   try {
     const db = getDb();
@@ -413,21 +437,33 @@ function handleAgentSubscribe(ws, msg, sm, state) {
       }
     } 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);
-    for (const event of events) {
-      cursor++;
-      send(ws, { type: "agent.event", session: sessionId, cursor, event });
+    if (cursor < session.eventCounter) {
+      const unpersisted = session.eventCounter - cursor;
+      const bufferSlice = session.eventBuffer.slice(-unpersisted);
+      for (const event of bufferSlice) {
+        cursor++;
+        send(ws, { type: "agent.event", session: sessionId, cursor, event });
+      }
     }
   } else {
-    cursor = session.eventCounter;
+    cursor = typeof msg.since === "number" && msg.since > 0 ? msg.since : session.eventCounter;
+    if (cursor < session.eventCounter) {
+      const startIdx = Math.max(0, session.eventBuffer.length - (session.eventCounter - cursor));
+      const events = session.eventBuffer.slice(startIdx);
+      for (const event of events) {
+        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 });
+    if (eventCursor === -1) {
+      send(ws, { type: "agent.event", session: sessionId, event });
+    } else {
+      send(ws, { type: "agent.event", session: sessionId, cursor: eventCursor, event });
+    }
   });
   state.agentUnsubs.set(sessionId, unsub);
   reply(ws, msg, { cursor });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sna-sdk/core",
-  "version": "0.6.1",
+  "version": "0.7.2",
   "description": "Skills-Native Application runtime — server, providers, session management, database, and CLI",
   "type": "module",
   "bin": {
@@ -102,12 +102,14 @@
   ],
   "dependencies": {
     "@hono/node-server": "^1.19.11",
-    "better-sqlite3": "^12.6.2",
     "chalk": "^5.0.0",
     "hono": "^4.12.7",
     "js-yaml": "^4.1.0",
     "ws": "^8.20.0"
   },
+  "peerDependencies": {
+    "better-sqlite3": ">=11.0.0"
+  },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",
     "@types/js-yaml": "^4.0.9",