@sna-sdk/core 0.1.1 → 0.3.0

package/dist/server/standalone.js

@@ -15,11 +15,20 @@ import { createRequire } from "module";
 import fs from "fs";
 import path from "path";
 var DB_PATH = path.join(process.cwd(), "data/sna.db");
+var NATIVE_DIR = path.join(process.cwd(), ".sna/native");
 var _db = null;
+function loadBetterSqlite3() {
+  const nativeEntry = path.join(NATIVE_DIR, "node_modules", "better-sqlite3");
+  if (fs.existsSync(nativeEntry)) {
+    const req2 = createRequire(path.join(NATIVE_DIR, "noop.js"));
+    return req2("better-sqlite3");
+  }
+  const req = createRequire(import.meta.url);
+  return req("better-sqlite3");
+}
 function getDb() {
   if (!_db) {
-    const req = createRequire(import.meta.url);
-    const BetterSqlite3 = req("better-sqlite3");
+    const BetterSqlite3 = loadBetterSqlite3();
     const dir = path.dirname(DB_PATH);
     if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
     _db = new BetterSqlite3(DB_PATH);
@@ -41,6 +50,12 @@ function migrateChatSessionsMeta(db) {
   if (cols.length > 0 && !cols.some((c) => c.name === "meta")) {
     db.exec("ALTER TABLE chat_sessions ADD COLUMN meta TEXT");
   }
+  if (cols.length > 0 && !cols.some((c) => c.name === "cwd")) {
+    db.exec("ALTER TABLE chat_sessions ADD COLUMN cwd TEXT");
+  }
+  if (cols.length > 0 && !cols.some((c) => c.name === "last_start_config")) {
+    db.exec("ALTER TABLE chat_sessions ADD COLUMN last_start_config TEXT");
+  }
 }
 function initSchema(db) {
   migrateSkillEvents(db);
@@ -51,6 +66,8 @@ function initSchema(db) {
       label      TEXT NOT NULL DEFAULT '',
       type       TEXT NOT NULL DEFAULT 'main',
       meta       TEXT,
+      cwd        TEXT,
+      last_start_config TEXT,
       created_at TEXT NOT NULL DEFAULT (datetime('now'))
     );
 
@@ -136,17 +153,41 @@ function eventsRoute(c) {
   });
 }
 
+// src/server/api-types.ts
+function httpJson(c, _op, data, status) {
+  return c.json(data, status);
+}
+function wsReply(ws, msg, data) {
+  if (ws.readyState !== ws.OPEN) return;
+  const out = { ...data, type: msg.type };
+  if (msg.rid != null) out.rid = msg.rid;
+  ws.send(JSON.stringify(out));
+}
+
 // src/server/routes/emit.ts
-async function emitRoute(c) {
-  const { skill, type, message, data } = await c.req.json();
-  if (!skill || !type || !message) {
-    return c.json({ error: "missing fields" }, 400);
-  }
-  const db = getDb();
-  const result = db.prepare(
-    `INSERT INTO skill_events (skill, type, message, data) VALUES (?, ?, ?, ?)`
-  ).run(skill, type, message, data ?? null);
-  return c.json({ id: result.lastInsertRowid });
+function createEmitRoute(sessionManager2) {
+  return async (c) => {
+    const body = await c.req.json();
+    const { skill, type, message, data, session_id } = body;
+    if (!skill || !type || !message) {
+      return c.json({ error: "missing fields" }, 400);
+    }
+    const db = getDb();
+    const result = db.prepare(
+      `INSERT INTO skill_events (session_id, skill, type, message, data) VALUES (?, ?, ?, ?, ?)`
+    ).run(session_id ?? null, skill, type, message, data ?? null);
+    const id = Number(result.lastInsertRowid);
+    sessionManager2.broadcastSkillEvent({
+      id,
+      session_id: session_id ?? null,
+      skill,
+      type,
+      message,
+      data: data ?? null,
+      created_at: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return httpJson(c, "emit", { id });
+  };
 }
 
 // src/server/routes/run.ts
@@ -231,6 +272,7 @@ var tags = {
   stdin: chalk.bold.green(" IN  "),
   stdout: chalk.bold.yellow(" OUT "),
   route: chalk.bold.blue(" API "),
+  ws: chalk.bold.green(" WS  "),
   err: chalk.bold.red(" ERR ")
 };
 var tagPlain = {
@@ -240,6 +282,7 @@ var tagPlain = {
   stdin: " IN  ",
   stdout: " OUT ",
   route: " API ",
+  ws: " WS  ",
   err: " ERR "
 };
 function appendFile(tag, args) {
@@ -261,6 +304,7 @@ var logger = { log, err };
 // src/core/providers/claude-code.ts
 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();
@@ -294,6 +338,7 @@ var ClaudeCodeProcess = class {
     this.emitter = new EventEmitter();
     this._alive = true;
     this._sessionId = null;
+    this._initEmitted = false;
     this.buffer = "";
     this.proc = proc;
     proc.stdout.on("data", (chunk) => {
@@ -333,6 +378,29 @@ 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.prompt) {
       this.send(options.prompt);
     }
@@ -345,16 +413,42 @@ var ClaudeCodeProcess = class {
   }
   /**
    * Send a user message to the persistent Claude process via stdin.
+   * Accepts plain string or content block array (text + images).
    */
   send(input) {
     if (!this._alive || !this.proc.stdin.writable) return;
+    const content = typeof input === "string" ? input : input;
     const msg = JSON.stringify({
       type: "user",
-      message: { role: "user", content: input }
+      message: { role: "user", content }
     });
     logger.log("stdin", msg.slice(0, 200));
     this.proc.stdin.write(msg + "\n");
   }
+  interrupt() {
+    if (!this._alive || !this.proc.stdin.writable) return;
+    const msg = JSON.stringify({
+      type: "control_request",
+      request: { subtype: "interrupt" }
+    });
+    this.proc.stdin.write(msg + "\n");
+  }
+  setModel(model) {
+    if (!this._alive || !this.proc.stdin.writable) return;
+    const msg = JSON.stringify({
+      type: "control_request",
+      request: { subtype: "set_model", model }
+    });
+    this.proc.stdin.write(msg + "\n");
+  }
+  setPermissionMode(mode) {
+    if (!this._alive || !this.proc.stdin.writable) return;
+    const msg = JSON.stringify({
+      type: "control_request",
+      request: { subtype: "set_permission_mode", permission_mode: mode }
+    });
+    this.proc.stdin.write(msg + "\n");
+  }
   kill() {
     if (this._alive) {
       this._alive = false;
@@ -371,6 +465,8 @@ var ClaudeCodeProcess = class {
     switch (msg.type) {
       case "system": {
         if (msg.subtype === "init") {
+          if (this._initEmitted) return null;
+          this._initEmitted = true;
           return {
             type: "init",
             message: `Agent ready (${msg.model ?? "unknown"})`,
@@ -452,7 +548,15 @@ var ClaudeCodeProcess = class {
             timestamp: Date.now()
           };
         }
-        if (msg.subtype === "error" || msg.is_error) {
+        if (msg.subtype === "error_during_execution" && msg.is_error === false) {
+          return {
+            type: "interrupted",
+            message: "Turn interrupted by user",
+            data: { durationMs: msg.duration_ms, costUsd: msg.total_cost_usd },
+            timestamp: Date.now()
+          };
+        }
+        if (msg.subtype?.startsWith("error") || msg.is_error) {
           return {
             type: "error",
             message: msg.result ?? msg.error ?? "Unknown error",
@@ -483,14 +587,18 @@ var ClaudeCodeProvider = class {
     }
   }
   spawn(options) {
-    const claudePath = resolveClaudePath(options.cwd);
-    const hookScript = path3.join(options.cwd, "node_modules/@sna-sdk/core/dist/scripts/hook.js");
+    const claudeCommand = resolveClaudePath(options.cwd);
+    const claudeParts = claudeCommand.split(/\s+/);
+    const claudePath = claudeParts[0];
+    const claudePrefix = claudeParts.slice(1);
+    const hookScript = new URL("../../scripts/hook.js", import.meta.url).pathname;
+    const sessionId = options.env?.SNA_SESSION_ID ?? "default";
     const sdkSettings = {};
     if (options.permissionMode !== "bypassPermissions") {
       sdkSettings.hooks = {
         PreToolUse: [{
           matcher: ".*",
-          hooks: [{ type: "command", command: `node "${hookScript}"` }]
+          hooks: [{ type: "command", command: `node "${hookScript}" --session=${sessionId}` }]
         }]
       };
     }
@@ -539,12 +647,13 @@ var ClaudeCodeProvider = class {
     delete cleanEnv.CLAUDECODE;
     delete cleanEnv.CLAUDE_CODE_ENTRYPOINT;
     delete cleanEnv.CLAUDE_CODE_SESSION_ACCESS_TOKEN;
-    const proc = spawn2(claudePath, args, {
+    delete cleanEnv.CLAUDE_CODE_OAUTH_TOKEN;
+    const proc = spawn2(claudePath, [...claudePrefix, ...args], {
       cwd: options.cwd,
       env: cleanEnv,
       stdio: ["pipe", "pipe", "pipe"]
     });
-    logger.log("agent", `spawned claude-code (pid=${proc.pid}) \u2192 ${claudePath} ${args.join(" ")}`);
+    logger.log("agent", `spawned claude-code (pid=${proc.pid}) \u2192 ${claudeCommand} ${args.join(" ")}`);
     return new ClaudeCodeProcess(proc, options);
   }
 };
@@ -573,10 +682,94 @@ function getProvider(name = "claude-code") {
   return provider2;
 }
 
+// src/server/image-store.ts
+import fs4 from "fs";
+import path4 from "path";
+import { createHash } from "crypto";
+var IMAGE_DIR = path4.join(process.cwd(), "data/images");
+var MIME_TO_EXT = {
+  "image/png": "png",
+  "image/jpeg": "jpg",
+  "image/gif": "gif",
+  "image/webp": "webp",
+  "image/svg+xml": "svg"
+};
+function saveImages(sessionId, images) {
+  const dir = path4.join(IMAGE_DIR, sessionId);
+  fs4.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"));
+    }
+    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;
+}
+
 // src/server/routes/agent.ts
 function getSessionId(c) {
   return c.req.query("session") ?? "default";
 }
+var DEFAULT_RUN_ONCE_TIMEOUT = 12e4;
+async function runOnce(sessionManager2, opts) {
+  const sessionId = `run-once-${crypto.randomUUID().slice(0, 8)}`;
+  const timeout = opts.timeout ?? DEFAULT_RUN_ONCE_TIMEOUT;
+  const session = sessionManager2.createSession({
+    id: sessionId,
+    label: "run-once",
+    cwd: opts.cwd ?? process.cwd()
+  });
+  const provider2 = getProvider(opts.provider ?? "claude-code");
+  const extraArgs = opts.extraArgs ? [...opts.extraArgs] : [];
+  if (opts.systemPrompt) extraArgs.push("--system-prompt", opts.systemPrompt);
+  if (opts.appendSystemPrompt) extraArgs.push("--append-system-prompt", opts.appendSystemPrompt);
+  const proc = provider2.spawn({
+    cwd: session.cwd,
+    prompt: opts.message,
+    model: opts.model ?? "claude-sonnet-4-6",
+    permissionMode: opts.permissionMode ?? "bypassPermissions",
+    env: { SNA_SESSION_ID: sessionId },
+    extraArgs
+  });
+  sessionManager2.setProcess(sessionId, proc);
+  try {
+    const result = await new Promise((resolve, reject) => {
+      const texts = [];
+      let usage = null;
+      const timer = setTimeout(() => {
+        reject(new Error(`run-once timed out after ${timeout}ms`));
+      }, timeout);
+      const unsub = sessionManager2.onSessionEvent(sessionId, (_cursor, e) => {
+        if (e.type === "assistant" && e.message) {
+          texts.push(e.message);
+        }
+        if (e.type === "complete") {
+          clearTimeout(timer);
+          unsub();
+          usage = e.data ?? null;
+          resolve({ result: texts.join("\n"), usage });
+        }
+        if (e.type === "error") {
+          clearTimeout(timer);
+          unsub();
+          reject(new Error(e.message ?? "Agent error"));
+        }
+      });
+    });
+    return result;
+  } finally {
+    sessionManager2.killSession(sessionId);
+    sessionManager2.removeSession(sessionId);
+  }
+}
 function createAgentRoutes(sessionManager2) {
   const app = new Hono();
   app.post("/sessions", async (c) => {
@@ -587,22 +780,15 @@ function createAgentRoutes(sessionManager2) {
         cwd: body.cwd,
         meta: body.meta
       });
-      try {
-        const db = getDb();
-        db.prepare(
-          `INSERT OR IGNORE INTO chat_sessions (id, label, type, meta) VALUES (?, ?, 'main', ?)`
-        ).run(session.id, session.label, session.meta ? JSON.stringify(session.meta) : null);
-      } catch {
-      }
       logger.log("route", `POST /sessions \u2192 created "${session.id}"`);
-      return c.json({ status: "created", sessionId: session.id, label: session.label, meta: session.meta });
+      return httpJson(c, "sessions.create", { status: "created", sessionId: session.id, label: session.label, meta: session.meta });
     } catch (e) {
       logger.err("err", `POST /sessions \u2192 ${e.message}`);
       return c.json({ status: "error", message: e.message }, 409);
     }
   });
   app.get("/sessions", (c) => {
-    return c.json({ sessions: sessionManager2.listSessions() });
+    return httpJson(c, "sessions.list", { sessions: sessionManager2.listSessions() });
   });
   app.delete("/sessions/:id", (c) => {
     const id = c.req.param("id");
@@ -614,18 +800,33 @@ function createAgentRoutes(sessionManager2) {
       return c.json({ status: "error", message: "Session not found" }, 404);
     }
     logger.log("route", `DELETE /sessions/${id} \u2192 removed`);
-    return c.json({ status: "removed" });
+    return httpJson(c, "sessions.remove", { status: "removed" });
+  });
+  app.post("/run-once", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    if (!body.message) {
+      return c.json({ status: "error", message: "message is required" }, 400);
+    }
+    try {
+      const result = await runOnce(sessionManager2, body);
+      return httpJson(c, "agent.run-once", result);
+    } catch (e) {
+      logger.err("err", `POST /run-once \u2192 ${e.message}`);
+      return c.json({ status: "error", message: e.message }, 500);
+    }
   });
   app.post("/start", async (c) => {
     const sessionId = getSessionId(c);
     const body = await c.req.json().catch(() => ({}));
-    const session = sessionManager2.getOrCreateSession(sessionId);
+    const session = sessionManager2.getOrCreateSession(sessionId, {
+      cwd: body.cwd
+    });
     if (session.process?.alive && !body.force) {
       logger.log("route", `POST /start?session=${sessionId} \u2192 already_running`);
-      return c.json({
+      return httpJson(c, "agent.start", {
         status: "already_running",
         provider: "claude-code",
-        sessionId: session.process.sessionId
+        sessionId: session.process.sessionId ?? session.id
       });
     }
     if (session.process?.alive) {
@@ -647,18 +848,24 @@ function createAgentRoutes(sessionManager2) {
       }
     } catch {
     }
+    const providerName = body.provider ?? "claude-code";
+    const model = body.model ?? "claude-sonnet-4-6";
+    const permissionMode2 = body.permissionMode ?? "acceptEdits";
+    const extraArgs = body.extraArgs;
     try {
       const proc = provider2.spawn({
         cwd: session.cwd,
         prompt: body.prompt,
-        model: body.model ?? "claude-sonnet-4-6",
-        permissionMode: body.permissionMode ?? "acceptEdits",
+        model,
+        permissionMode: permissionMode2,
         env: { SNA_SESSION_ID: sessionId },
-        extraArgs: body.extraArgs
+        history: body.history,
+        extraArgs
       });
       sessionManager2.setProcess(sessionId, proc);
+      sessionManager2.saveStartConfig(sessionId, { provider: providerName, model, permissionMode: permissionMode2, extraArgs });
       logger.log("route", `POST /start?session=${sessionId} \u2192 started`);
-      return c.json({
+      return httpJson(c, "agent.start", {
         status: "started",
         provider: provider2.name,
         sessionId: session.id
@@ -679,21 +886,39 @@ function createAgentRoutes(sessionManager2) {
       );
     }
     const body = await c.req.json().catch(() => ({}));
-    if (!body.message) {
+    if (!body.message && !body.images?.length) {
       logger.err("err", `POST /send?session=${sessionId} \u2192 empty message`);
-      return c.json({ status: "error", message: "message is required" }, 400);
+      return c.json({ status: "error", message: "message or images required" }, 400);
+    }
+    const textContent = body.message ?? "(image)";
+    let meta = body.meta ? { ...body.meta } : {};
+    if (body.images?.length) {
+      const filenames = saveImages(sessionId, body.images);
+      meta.images = filenames;
     }
     try {
       const db = getDb();
       db.prepare(`INSERT OR IGNORE INTO chat_sessions (id, label, type) VALUES (?, ?, 'main')`).run(sessionId, session.label ?? sessionId);
-      db.prepare(`INSERT INTO chat_messages (session_id, role, content, meta) VALUES (?, 'user', ?, ?)`).run(sessionId, body.message, body.meta ? JSON.stringify(body.meta) : null);
+      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.touch(sessionId);
-    logger.log("route", `POST /send?session=${sessionId} \u2192 "${body.message.slice(0, 80)}"`);
-    session.process.send(body.message);
-    return c.json({ status: "sent" });
+    if (body.images?.length) {
+      const content = [
+        ...body.images.map((img) => ({
+          type: "image",
+          source: { type: "base64", media_type: img.mimeType, data: img.base64 }
+        })),
+        ...body.message ? [{ type: "text", text: body.message }] : []
+      ];
+      logger.log("route", `POST /send?session=${sessionId} \u2192 ${body.images.length} image(s) + "${(body.message ?? "").slice(0, 40)}"`);
+      session.process.send(content);
+    } else {
+      logger.log("route", `POST /send?session=${sessionId} \u2192 "${body.message.slice(0, 80)}"`);
+      session.process.send(body.message);
+    }
+    return httpJson(c, "agent.send", { status: "sent" });
   });
   app.get("/events", (c) => {
     const sessionId = getSessionId(c);
@@ -728,95 +953,113 @@ function createAgentRoutes(sessionManager2) {
       }
     });
   });
+  app.post("/restart", async (c) => {
+    const sessionId = getSessionId(c);
+    const body = await c.req.json().catch(() => ({}));
+    try {
+      const ccSessionId = sessionManager2.getSession(sessionId)?.ccSessionId;
+      const { config } = sessionManager2.restartSession(sessionId, body, (cfg) => {
+        const prov = getProvider(cfg.provider);
+        const resumeArgs = ccSessionId ? ["--resume", ccSessionId] : ["--resume"];
+        return prov.spawn({
+          cwd: sessionManager2.getSession(sessionId).cwd,
+          model: cfg.model,
+          permissionMode: cfg.permissionMode,
+          env: { SNA_SESSION_ID: sessionId },
+          extraArgs: [...cfg.extraArgs ?? [], ...resumeArgs]
+        });
+      });
+      logger.log("route", `POST /restart?session=${sessionId} \u2192 restarted`);
+      return httpJson(c, "agent.restart", {
+        status: "restarted",
+        provider: config.provider,
+        sessionId
+      });
+    } catch (e) {
+      logger.err("err", `POST /restart?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);
+    return httpJson(c, "agent.interrupt", { status: interrupted ? "interrupted" : "no_session" });
+  });
+  app.post("/set-model", async (c) => {
+    const sessionId = getSessionId(c);
+    const body = await c.req.json().catch(() => ({}));
+    if (!body.model) return c.json({ status: "error", message: "model is required" }, 400);
+    const updated = sessionManager2.setSessionModel(sessionId, body.model);
+    return httpJson(c, "agent.set-model", { status: updated ? "updated" : "no_session", model: body.model });
+  });
+  app.post("/set-permission-mode", async (c) => {
+    const sessionId = getSessionId(c);
+    const body = await c.req.json().catch(() => ({}));
+    if (!body.permissionMode) return c.json({ status: "error", message: "permissionMode is required" }, 400);
+    const updated = sessionManager2.setSessionPermissionMode(sessionId, body.permissionMode);
+    return httpJson(c, "agent.set-permission-mode", { status: updated ? "updated" : "no_session", permissionMode: body.permissionMode });
+  });
   app.post("/kill", async (c) => {
     const sessionId = getSessionId(c);
     const killed = sessionManager2.killSession(sessionId);
-    return c.json({ status: killed ? "killed" : "no_session" });
+    return httpJson(c, "agent.kill", { status: killed ? "killed" : "no_session" });
   });
   app.get("/status", (c) => {
     const sessionId = getSessionId(c);
     const session = sessionManager2.getSession(sessionId);
-    return c.json({
+    return httpJson(c, "agent.status", {
       alive: session?.process?.alive ?? false,
       sessionId: session?.process?.sessionId ?? null,
-      eventCount: session?.eventCounter ?? 0
+      ccSessionId: session?.ccSessionId ?? null,
+      eventCount: session?.eventCounter ?? 0,
+      config: session?.lastStartConfig ?? null
     });
   });
-  const pendingPermissions = /* @__PURE__ */ new Map();
   app.post("/permission-request", async (c) => {
     const sessionId = getSessionId(c);
     const body = await c.req.json().catch(() => ({}));
     logger.log("route", `POST /permission-request?session=${sessionId} \u2192 ${body.tool_name}`);
-    const session = sessionManager2.getSession(sessionId);
-    if (session) session.state = "permission";
-    const result = await new Promise((resolve) => {
-      pendingPermissions.set(sessionId, {
-        resolve,
-        request: body,
-        createdAt: Date.now()
-      });
-      setTimeout(() => {
-        if (pendingPermissions.has(sessionId)) {
-          pendingPermissions.delete(sessionId);
-          resolve(false);
-        }
-      }, 3e5);
-    });
+    const result = await sessionManager2.createPendingPermission(sessionId, body);
     return c.json({ approved: result });
   });
   app.post("/permission-respond", async (c) => {
     const sessionId = getSessionId(c);
     const body = await c.req.json().catch(() => ({}));
     const approved = body.approved ?? false;
-    const pending = pendingPermissions.get(sessionId);
-    if (!pending) {
+    const resolved = sessionManager2.resolvePendingPermission(sessionId, approved);
+    if (!resolved) {
       return c.json({ status: "error", message: "No pending permission request" }, 404);
     }
-    pending.resolve(approved);
-    pendingPermissions.delete(sessionId);
-    const session = sessionManager2.getSession(sessionId);
-    if (session) session.state = "processing";
     logger.log("route", `POST /permission-respond?session=${sessionId} \u2192 ${approved ? "approved" : "denied"}`);
-    return c.json({ status: approved ? "approved" : "denied" });
+    return httpJson(c, "permission.respond", { status: approved ? "approved" : "denied" });
   });
   app.get("/permission-pending", (c) => {
     const sessionId = c.req.query("session");
     if (sessionId) {
-      const pending = pendingPermissions.get(sessionId);
-      if (!pending) return c.json({ pending: null });
-      return c.json({
-        pending: {
-          sessionId,
-          request: pending.request,
-          createdAt: pending.createdAt
-        }
-      });
+      const pending = sessionManager2.getPendingPermission(sessionId);
+      return httpJson(c, "permission.pending", { pending: pending ? [{ sessionId, ...pending }] : [] });
     }
-    const all = Array.from(pendingPermissions.entries()).map(([id, p]) => ({
-      sessionId: id,
-      request: p.request,
-      createdAt: p.createdAt
-    }));
-    return c.json({ pending: all });
+    return httpJson(c, "permission.pending", { pending: sessionManager2.getAllPendingPermissions() });
   });
   return app;
 }
 
 // src/server/routes/chat.ts
 import { Hono as Hono2 } from "hono";
+import fs5 from "fs";
 function createChatRoutes() {
   const app = new Hono2();
   app.get("/sessions", (c) => {
     try {
       const db = getDb();
       const rows = db.prepare(
-        `SELECT id, label, type, meta, created_at FROM chat_sessions ORDER BY created_at DESC`
+        `SELECT id, label, type, meta, cwd, created_at FROM chat_sessions ORDER BY created_at DESC`
       ).all();
       const sessions = rows.map((r) => ({
         ...r,
         meta: r.meta ? JSON.parse(r.meta) : null
       }));
-      return c.json({ sessions });
+      return httpJson(c, "chat.sessions.list", { sessions });
     } catch (e) {
       return c.json({ status: "error", message: e.message, stack: e.stack }, 500);
     }
@@ -829,7 +1072,7 @@ function createChatRoutes() {
       db.prepare(
         `INSERT OR IGNORE INTO chat_sessions (id, label, type, meta) VALUES (?, ?, ?, ?)`
       ).run(id, body.label ?? id, body.type ?? "background", body.meta ? JSON.stringify(body.meta) : null);
-      return c.json({ status: "created", id, meta: body.meta ?? null });
+      return httpJson(c, "chat.sessions.create", { status: "created", id, meta: body.meta ?? null });
     } catch (e) {
       return c.json({ status: "error", message: e.message }, 500);
     }
@@ -842,7 +1085,7 @@ function createChatRoutes() {
     try {
       const db = getDb();
       db.prepare(`DELETE FROM chat_sessions WHERE id = ?`).run(id);
-      return c.json({ status: "deleted" });
+      return httpJson(c, "chat.sessions.remove", { status: "deleted" });
     } catch (e) {
       return c.json({ status: "error", message: e.message }, 500);
     }
@@ -854,7 +1097,7 @@ function createChatRoutes() {
       const db = getDb();
       const query = sinceParam ? db.prepare(`SELECT * FROM chat_messages WHERE session_id = ? AND id > ? ORDER BY id ASC`) : db.prepare(`SELECT * FROM chat_messages WHERE session_id = ? ORDER BY id ASC`);
       const messages = sinceParam ? query.all(id, parseInt(sinceParam, 10)) : query.all(id);
-      return c.json({ messages });
+      return httpJson(c, "chat.messages.list", { messages });
     } catch (e) {
       return c.json({ status: "error", message: e.message, stack: e.stack }, 500);
     }
@@ -877,7 +1120,7 @@ function createChatRoutes() {
         body.skill_name ?? null,
         body.meta ? JSON.stringify(body.meta) : null
       );
-      return c.json({ status: "created", id: result.lastInsertRowid });
+      return httpJson(c, "chat.messages.create", { status: "created", id: Number(result.lastInsertRowid) });
     } catch (e) {
       return c.json({ status: "error", message: e.message }, 500);
     }
@@ -887,27 +1130,119 @@ function createChatRoutes() {
     try {
       const db = getDb();
       db.prepare(`DELETE FROM chat_messages WHERE session_id = ?`).run(id);
-      return c.json({ status: "cleared" });
+      return httpJson(c, "chat.messages.clear", { status: "cleared" });
     } catch (e) {
       return c.json({ status: "error", message: e.message }, 500);
     }
   });
+  app.get("/images/:sessionId/:filename", (c) => {
+    const sessionId = c.req.param("sessionId");
+    const filename = c.req.param("filename");
+    const filePath = resolveImagePath(sessionId, filename);
+    if (!filePath) {
+      return c.json({ status: "error", message: "Image not found" }, 404);
+    }
+    const ext = filename.split(".").pop()?.toLowerCase();
+    const mimeMap = {
+      png: "image/png",
+      jpg: "image/jpeg",
+      jpeg: "image/jpeg",
+      gif: "image/gif",
+      webp: "image/webp",
+      svg: "image/svg+xml"
+    };
+    const contentType = mimeMap[ext ?? ""] ?? "application/octet-stream";
+    const data = fs5.readFileSync(filePath);
+    return new Response(data, { headers: { "Content-Type": contentType, "Cache-Control": "public, max-age=31536000, immutable" } });
+  });
   return app;
 }
 
 // src/server/session-manager.ts
 var DEFAULT_MAX_SESSIONS = 5;
 var MAX_EVENT_BUFFER = 500;
+var PERMISSION_TIMEOUT_MS = 3e5;
 var SessionManager = class {
   constructor(options = {}) {
     this.sessions = /* @__PURE__ */ new Map();
+    this.eventListeners = /* @__PURE__ */ new Map();
+    this.pendingPermissions = /* @__PURE__ */ new Map();
+    this.skillEventListeners = /* @__PURE__ */ new Set();
+    this.permissionRequestListeners = /* @__PURE__ */ new Set();
+    this.lifecycleListeners = /* @__PURE__ */ new Set();
+    this.configChangedListeners = /* @__PURE__ */ new Set();
     this.maxSessions = options.maxSessions ?? DEFAULT_MAX_SESSIONS;
+    this.restoreFromDb();
+  }
+  /** Restore session metadata from DB (cwd, label, meta). Process state is not restored. */
+  restoreFromDb() {
+    try {
+      const db = getDb();
+      const rows = db.prepare(
+        `SELECT id, label, meta, cwd, last_start_config, created_at FROM chat_sessions`
+      ).all();
+      for (const row of rows) {
+        if (this.sessions.has(row.id)) continue;
+        this.sessions.set(row.id, {
+          id: row.id,
+          process: null,
+          eventBuffer: [],
+          eventCounter: 0,
+          label: row.label,
+          cwd: row.cwd ?? process.cwd(),
+          meta: row.meta ? JSON.parse(row.meta) : null,
+          state: "idle",
+          lastStartConfig: row.last_start_config ? JSON.parse(row.last_start_config) : null,
+          ccSessionId: null,
+          createdAt: new Date(row.created_at).getTime() || Date.now(),
+          lastActivityAt: Date.now()
+        });
+      }
+    } catch {
+    }
+  }
+  /** Persist session metadata to DB. */
+  persistSession(session) {
+    try {
+      const db = getDb();
+      db.prepare(
+        `INSERT INTO chat_sessions (id, label, type, meta, cwd, last_start_config)
+         VALUES (?, ?, 'main', ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET
+           label = excluded.label,
+           meta = excluded.meta,
+           cwd = excluded.cwd,
+           last_start_config = excluded.last_start_config`
+      ).run(
+        session.id,
+        session.label,
+        session.meta ? JSON.stringify(session.meta) : null,
+        session.cwd,
+        session.lastStartConfig ? JSON.stringify(session.lastStartConfig) : null
+      );
+    } catch {
+    }
   }
   /** Create a new session. Throws if max sessions reached. */
   createSession(opts = {}) {
     const id = opts.id ?? crypto.randomUUID().slice(0, 8);
     if (this.sessions.has(id)) {
-      return this.sessions.get(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;
     }
     const aliveCount = Array.from(this.sessions.values()).filter((s) => s.process?.alive).length;
     if (aliveCount >= this.maxSessions) {
@@ -922,10 +1257,13 @@ var SessionManager = class {
       cwd: opts.cwd ?? process.cwd(),
       meta: opts.meta ?? null,
       state: "idle",
+      lastStartConfig: null,
+      ccSessionId: null,
       createdAt: Date.now(),
       lastActivityAt: Date.now()
     };
     this.sessions.set(id, session);
+    this.persistSession(session);
     return session;
   }
   /** Get a session by ID. */
@@ -935,7 +1273,13 @@ var SessionManager = class {
   /** Get or create a session (used for "default" backward compat). */
   getOrCreateSession(id, opts) {
     const existing = this.sessions.get(id);
-    if (existing) return existing;
+    if (existing) {
+      if (opts?.cwd && opts.cwd !== existing.cwd) {
+        existing.cwd = opts.cwd;
+        this.persistSession(existing);
+      }
+      return existing;
+    }
     return this.createSession({ id, ...opts });
   }
   /** Set the agent process for a session. Subscribes to events. */
@@ -946,22 +1290,195 @@ var SessionManager = class {
     session.state = "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 === "complete" || e.type === "error") {
+      if (e.type === "complete" || e.type === "error" || e.type === "interrupted") {
         session.state = "waiting";
       }
       this.persistEvent(sessionId, e);
+      const listeners = this.eventListeners.get(sessionId);
+      if (listeners) {
+        for (const cb of listeners) cb(session.eventCounter, e);
+      }
+    });
+    proc.on("exit", (code) => {
+      session.state = "idle";
+      this.emitLifecycle({ session: sessionId, state: code != null ? "exited" : "crashed", code });
+    });
+    proc.on("error", () => {
+      session.state = "idle";
+      this.emitLifecycle({ session: sessionId, state: "crashed" });
     });
+    this.emitLifecycle({ session: sessionId, state: "started" });
+  }
+  // ── Event pub/sub (for WebSocket) ─────────────────────────────
+  /** Subscribe to real-time events for a session. Returns unsubscribe function. */
+  onSessionEvent(sessionId, cb) {
+    let set = this.eventListeners.get(sessionId);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.eventListeners.set(sessionId, set);
+    }
+    set.add(cb);
+    return () => {
+      set.delete(cb);
+      if (set.size === 0) this.eventListeners.delete(sessionId);
+    };
+  }
+  // ── Skill event pub/sub ────────────────────────────────────────
+  /** Subscribe to skill events broadcast. Returns unsubscribe function. */
+  onSkillEvent(cb) {
+    this.skillEventListeners.add(cb);
+    return () => this.skillEventListeners.delete(cb);
+  }
+  /** Broadcast a skill event to all subscribers (called after DB insert). */
+  broadcastSkillEvent(event) {
+    for (const cb of this.skillEventListeners) cb(event);
+  }
+  // ── Permission pub/sub ────────────────────────────────────────
+  /** Subscribe to permission request notifications. Returns unsubscribe function. */
+  onPermissionRequest(cb) {
+    this.permissionRequestListeners.add(cb);
+    return () => this.permissionRequestListeners.delete(cb);
+  }
+  // ── Session lifecycle pub/sub ──────────────────────────────────
+  /** Subscribe to session lifecycle events (started/killed/exited/crashed). Returns unsubscribe function. */
+  onSessionLifecycle(cb) {
+    this.lifecycleListeners.add(cb);
+    return () => this.lifecycleListeners.delete(cb);
+  }
+  emitLifecycle(event) {
+    for (const cb of this.lifecycleListeners) cb(event);
+  }
+  // ── Config changed pub/sub ────────────────────────────────────
+  /** Subscribe to session config changes. Returns unsubscribe function. */
+  onConfigChanged(cb) {
+    this.configChangedListeners.add(cb);
+    return () => this.configChangedListeners.delete(cb);
+  }
+  emitConfigChanged(sessionId, config) {
+    for (const cb of this.configChangedListeners) cb({ session: sessionId, config });
+  }
+  // ── 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";
+    return new Promise((resolve) => {
+      const createdAt = Date.now();
+      this.pendingPermissions.set(sessionId, { resolve, request, createdAt });
+      for (const cb of this.permissionRequestListeners) cb(sessionId, request, createdAt);
+      setTimeout(() => {
+        if (this.pendingPermissions.has(sessionId)) {
+          this.pendingPermissions.delete(sessionId);
+          resolve(false);
+        }
+      }, PERMISSION_TIMEOUT_MS);
+    });
+  }
+  /** Resolve a pending permission request. Returns false if no pending request. */
+  resolvePendingPermission(sessionId, approved) {
+    const pending = this.pendingPermissions.get(sessionId);
+    if (!pending) return false;
+    pending.resolve(approved);
+    this.pendingPermissions.delete(sessionId);
+    const session = this.sessions.get(sessionId);
+    if (session) session.state = "processing";
+    return true;
+  }
+  /** Get a pending permission for a specific session. */
+  getPendingPermission(sessionId) {
+    const p = this.pendingPermissions.get(sessionId);
+    return p ? { request: p.request, createdAt: p.createdAt } : null;
+  }
+  /** Get all pending permissions across sessions. */
+  getAllPendingPermissions() {
+    return Array.from(this.pendingPermissions.entries()).map(([id, p]) => ({
+      sessionId: id,
+      request: p.request,
+      createdAt: p.createdAt
+    }));
+  }
+  // ── Session lifecycle ─────────────────────────────────────────
+  /** Kill the agent process in a session (session stays, can be restarted). */
+  /** Save the start config for a session (called by start handlers). */
+  saveStartConfig(id, config) {
+    const session = this.sessions.get(id);
+    if (!session) return;
+    session.lastStartConfig = config;
+    this.persistSession(session);
+  }
+  /** Restart session: kill → re-spawn with merged config + --resume. */
+  restartSession(id, overrides, spawnFn) {
+    const session = this.sessions.get(id);
+    if (!session) throw new Error(`Session "${id}" not found`);
+    const base = session.lastStartConfig;
+    if (!base) throw new Error(`Session "${id}" has no previous start config`);
+    const config = {
+      provider: overrides.provider ?? base.provider,
+      model: overrides.model ?? base.model,
+      permissionMode: overrides.permissionMode ?? base.permissionMode,
+      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;
+    this.persistSession(session);
+    this.emitLifecycle({ session: id, state: "restarted" });
+    this.emitConfigChanged(id, config);
+    return { config };
+  }
+  /** Interrupt the current turn. Process stays alive, returns to waiting. */
+  interruptSession(id) {
+    const session = this.sessions.get(id);
+    if (!session?.process?.alive) return false;
+    session.process.interrupt();
+    session.state = "waiting";
+    return true;
+  }
+  /** Change model. Sends control message if alive, always persists to config. */
+  setSessionModel(id, model) {
+    const session = this.sessions.get(id);
+    if (!session) return false;
+    if (session.process?.alive) session.process.setModel(model);
+    if (session.lastStartConfig) {
+      session.lastStartConfig.model = model;
+    } else {
+      session.lastStartConfig = { provider: "claude-code", model, permissionMode: "acceptEdits" };
+    }
+    this.persistSession(session);
+    this.emitConfigChanged(id, session.lastStartConfig);
+    return true;
+  }
+  /** Change permission mode. Sends control message if alive, always persists to config. */
+  setSessionPermissionMode(id, mode) {
+    const session = this.sessions.get(id);
+    if (!session) return false;
+    if (session.process?.alive) session.process.setPermissionMode(mode);
+    if (session.lastStartConfig) {
+      session.lastStartConfig.permissionMode = mode;
+    } else {
+      session.lastStartConfig = { provider: "claude-code", model: "claude-sonnet-4-6", permissionMode: mode };
+    }
+    this.persistSession(session);
+    this.emitConfigChanged(id, session.lastStartConfig);
+    return true;
   }
   /** Kill the agent process in a session (session stays, can be restarted). */
   killSession(id) {
     const session = this.sessions.get(id);
     if (!session?.process?.alive) return false;
     session.process.kill();
+    this.emitLifecycle({ session: id, state: "killed" });
     return true;
   }
   /** Remove a session entirely. Cannot remove "default". */
@@ -970,6 +1487,8 @@ var SessionManager = class {
     const session = this.sessions.get(id);
     if (!session) return false;
     if (session.process?.alive) session.process.kill();
+    this.eventListeners.delete(id);
+    this.pendingPermissions.delete(id);
     this.sessions.delete(id);
     return true;
   }
@@ -982,6 +1501,8 @@ var SessionManager = class {
       state: s.state,
       cwd: s.cwd,
       meta: s.meta,
+      config: s.lastStartConfig,
+      ccSessionId: s.ccSessionId,
       eventCount: s.eventCounter,
       createdAt: s.createdAt,
       lastActivityAt: s.lastActivityAt
@@ -1038,13 +1559,538 @@ var SessionManager = class {
   }
 };
 
+// src/server/ws.ts
+import { WebSocketServer } from "ws";
+function send(ws, data) {
+  if (ws.readyState === ws.OPEN) {
+    ws.send(JSON.stringify(data));
+  }
+}
+function reply(ws, msg, data) {
+  send(ws, { ...data, type: msg.type, ...msg.rid != null ? { rid: msg.rid } : {} });
+}
+function replyError(ws, msg, message) {
+  send(ws, { type: "error", ...msg.rid != null ? { rid: msg.rid } : {}, message });
+}
+function attachWebSocket(server2, sessionManager2) {
+  const wss = new WebSocketServer({ noServer: true });
+  server2.on("upgrade", (req, socket, head) => {
+    const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+    if (url.pathname === "/ws") {
+      wss.handleUpgrade(req, socket, head, (ws) => {
+        wss.emit("connection", ws, req);
+      });
+    } else {
+      socket.destroy();
+    }
+  });
+  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 };
+    state.lifecycleUnsub = sessionManager2.onSessionLifecycle((event) => {
+      send(ws, { type: "session.lifecycle", ...event });
+    });
+    state.configChangedUnsub = sessionManager2.onConfigChanged((event) => {
+      send(ws, { type: "session.config-changed", ...event });
+    });
+    ws.on("message", (raw) => {
+      let msg;
+      try {
+        msg = JSON.parse(raw.toString());
+      } catch {
+        send(ws, { type: "error", message: "invalid JSON" });
+        return;
+      }
+      if (!msg.type) {
+        send(ws, { type: "error", message: "type is required" });
+        return;
+      }
+      handleMessage(ws, msg, sessionManager2, state);
+    });
+    ws.on("close", () => {
+      logger.log("ws", "client disconnected");
+      for (const unsub of state.agentUnsubs.values()) unsub();
+      state.agentUnsubs.clear();
+      state.skillEventUnsub?.();
+      state.skillEventUnsub = null;
+      if (state.skillPollTimer) {
+        clearInterval(state.skillPollTimer);
+        state.skillPollTimer = null;
+      }
+      state.permissionUnsub?.();
+      state.permissionUnsub = null;
+      state.lifecycleUnsub?.();
+      state.lifecycleUnsub = null;
+      state.configChangedUnsub?.();
+      state.configChangedUnsub = null;
+    });
+  });
+  return wss;
+}
+function handleMessage(ws, msg, sm, state) {
+  switch (msg.type) {
+    // ── Session CRUD ──────────────────────────────────
+    case "sessions.create":
+      return handleSessionsCreate(ws, msg, sm);
+    case "sessions.list":
+      return wsReply(ws, msg, { sessions: sm.listSessions() });
+    case "sessions.remove":
+      return handleSessionsRemove(ws, msg, sm);
+    // ── Agent lifecycle ───────────────────────────────
+    case "agent.start":
+      return handleAgentStart(ws, msg, sm);
+    case "agent.send":
+      return handleAgentSend(ws, msg, sm);
+    case "agent.restart":
+      return handleAgentRestart(ws, msg, sm);
+    case "agent.interrupt":
+      return handleAgentInterrupt(ws, msg, sm);
+    case "agent.set-model":
+      return handleAgentSetModel(ws, msg, sm);
+    case "agent.set-permission-mode":
+      return handleAgentSetPermissionMode(ws, msg, sm);
+    case "agent.kill":
+      return handleAgentKill(ws, msg, sm);
+    case "agent.status":
+      return handleAgentStatus(ws, msg, sm);
+    case "agent.run-once":
+      handleAgentRunOnce(ws, msg, sm);
+      return;
+    // ── Agent event subscription ──────────────────────
+    case "agent.subscribe":
+      return handleAgentSubscribe(ws, msg, sm, state);
+    case "agent.unsubscribe":
+      return handleAgentUnsubscribe(ws, msg, state);
+    // ── Skill events ──────────────────────────────────
+    case "events.subscribe":
+      return handleEventsSubscribe(ws, msg, sm, state);
+    case "events.unsubscribe":
+      return handleEventsUnsubscribe(ws, msg, state);
+    case "emit":
+      return handleEmit(ws, msg, sm);
+    // ── Permission ────────────────────────────────────
+    case "permission.respond":
+      return handlePermissionRespond(ws, msg, sm);
+    case "permission.pending":
+      return handlePermissionPending(ws, msg, sm);
+    case "permission.subscribe":
+      return handlePermissionSubscribe(ws, msg, sm, state);
+    case "permission.unsubscribe":
+      return handlePermissionUnsubscribe(ws, msg, state);
+    // ── Chat sessions ─────────────────────────────────
+    case "chat.sessions.list":
+      return handleChatSessionsList(ws, msg);
+    case "chat.sessions.create":
+      return handleChatSessionsCreate(ws, msg);
+    case "chat.sessions.remove":
+      return handleChatSessionsRemove(ws, msg);
+    // ── Chat messages ─────────────────────────────────
+    case "chat.messages.list":
+      return handleChatMessagesList(ws, msg);
+    case "chat.messages.create":
+      return handleChatMessagesCreate(ws, msg);
+    case "chat.messages.clear":
+      return handleChatMessagesClear(ws, msg);
+    default:
+      replyError(ws, msg, `Unknown message type: ${msg.type}`);
+  }
+}
+function handleSessionsCreate(ws, msg, sm) {
+  try {
+    const session = sm.createSession({
+      label: msg.label,
+      cwd: msg.cwd,
+      meta: msg.meta
+    });
+    wsReply(ws, msg, { status: "created", sessionId: session.id, label: session.label, meta: session.meta });
+  } 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");
+  if (id === "default") return replyError(ws, msg, "Cannot remove default session");
+  const removed = sm.removeSession(id);
+  if (!removed) return replyError(ws, msg, "Session not found");
+  wsReply(ws, msg, { status: "removed" });
+}
+function handleAgentStart(ws, msg, sm) {
+  const sessionId = msg.session ?? "default";
+  const session = sm.getOrCreateSession(sessionId, {
+    cwd: msg.cwd
+  });
+  if (session.process?.alive && !msg.force) {
+    wsReply(ws, msg, { status: "already_running", provider: "claude-code", sessionId: session.id });
+    return;
+  }
+  if (session.process?.alive) session.process.kill();
+  session.eventBuffer.length = 0;
+  const provider2 = getProvider(msg.provider ?? "claude-code");
+  try {
+    const db = getDb();
+    db.prepare(`INSERT OR IGNORE INTO chat_sessions (id, label, type) VALUES (?, ?, 'main')`).run(sessionId, session.label ?? sessionId);
+    if (msg.prompt) {
+      db.prepare(`INSERT INTO chat_messages (session_id, role, content, meta) VALUES (?, 'user', ?, ?)`).run(sessionId, msg.prompt, msg.meta ? JSON.stringify(msg.meta) : null);
+    }
+    const skillMatch = msg.prompt?.match(/^Execute the skill:\s*(\S+)/);
+    if (skillMatch) {
+      db.prepare(`INSERT INTO skill_events (session_id, skill, type, message) VALUES (?, ?, 'invoked', ?)`).run(sessionId, skillMatch[1], `Skill ${skillMatch[1]} invoked`);
+    }
+  } catch {
+  }
+  const providerName = msg.provider ?? "claude-code";
+  const model = msg.model ?? "claude-sonnet-4-6";
+  const permissionMode2 = msg.permissionMode ?? "acceptEdits";
+  const extraArgs = msg.extraArgs;
+  try {
+    const proc = provider2.spawn({
+      cwd: session.cwd,
+      prompt: msg.prompt,
+      model,
+      permissionMode: permissionMode2,
+      env: { SNA_SESSION_ID: sessionId },
+      history: msg.history,
+      extraArgs
+    });
+    sm.setProcess(sessionId, proc);
+    sm.saveStartConfig(sessionId, { provider: providerName, model, permissionMode: permissionMode2, extraArgs });
+    wsReply(ws, msg, { status: "started", provider: provider2.name, sessionId: session.id });
+  } catch (e) {
+    replyError(ws, msg, e.message);
+  }
+}
+function handleAgentSend(ws, msg, sm) {
+  const sessionId = msg.session ?? "default";
+  const session = sm.getSession(sessionId);
+  if (!session?.process?.alive) {
+    return replyError(ws, msg, `No active agent session "${sessionId}". Start first.`);
+  }
+  const images = msg.images;
+  if (!msg.message && !images?.length) {
+    return replyError(ws, msg, "message or images required");
+  }
+  const textContent = msg.message ?? "(image)";
+  let meta = msg.meta ? { ...msg.meta } : {};
+  if (images?.length) {
+    const filenames = saveImages(sessionId, images);
+    meta.images = filenames;
+  }
+  try {
+    const db = getDb();
+    db.prepare(`INSERT OR IGNORE INTO chat_sessions (id, label, type) VALUES (?, ?, 'main')`).run(sessionId, session.label ?? sessionId);
+    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.touch(sessionId);
+  if (images?.length) {
+    const content = [
+      ...images.map((img) => ({
+        type: "image",
+        source: { type: "base64", media_type: img.mimeType, data: img.base64 }
+      })),
+      ...msg.message ? [{ type: "text", text: msg.message }] : []
+    ];
+    session.process.send(content);
+  } else {
+    session.process.send(msg.message);
+  }
+  wsReply(ws, msg, { status: "sent" });
+}
+function handleAgentRestart(ws, msg, sm) {
+  const sessionId = msg.session ?? "default";
+  try {
+    const ccSessionId = sm.getSession(sessionId)?.ccSessionId;
+    const { config } = sm.restartSession(
+      sessionId,
+      {
+        provider: msg.provider,
+        model: msg.model,
+        permissionMode: msg.permissionMode,
+        extraArgs: msg.extraArgs
+      },
+      (cfg) => {
+        const prov = getProvider(cfg.provider);
+        const resumeArgs = ccSessionId ? ["--resume", ccSessionId] : ["--resume"];
+        return prov.spawn({
+          cwd: sm.getSession(sessionId).cwd,
+          model: cfg.model,
+          permissionMode: cfg.permissionMode,
+          env: { SNA_SESSION_ID: sessionId },
+          extraArgs: [...cfg.extraArgs ?? [], ...resumeArgs]
+        });
+      }
+    );
+    wsReply(ws, msg, { status: "restarted", provider: config.provider, sessionId });
+  } catch (e) {
+    replyError(ws, msg, e.message);
+  }
+}
+function handleAgentInterrupt(ws, msg, sm) {
+  const sessionId = msg.session ?? "default";
+  const interrupted = sm.interruptSession(sessionId);
+  wsReply(ws, msg, { status: interrupted ? "interrupted" : "no_session" });
+}
+function handleAgentSetModel(ws, msg, sm) {
+  const sessionId = msg.session ?? "default";
+  const model = msg.model;
+  if (!model) return replyError(ws, msg, "model is required");
+  const updated = sm.setSessionModel(sessionId, model);
+  wsReply(ws, msg, { status: updated ? "updated" : "no_session", model });
+}
+function handleAgentSetPermissionMode(ws, msg, sm) {
+  const sessionId = msg.session ?? "default";
+  const permissionMode2 = msg.permissionMode;
+  if (!permissionMode2) return replyError(ws, msg, "permissionMode is required");
+  const updated = sm.setSessionPermissionMode(sessionId, permissionMode2);
+  wsReply(ws, msg, { status: updated ? "updated" : "no_session", permissionMode: permissionMode2 });
+}
+function handleAgentKill(ws, msg, sm) {
+  const sessionId = msg.session ?? "default";
+  const killed = sm.killSession(sessionId);
+  wsReply(ws, msg, { status: killed ? "killed" : "no_session" });
+}
+function handleAgentStatus(ws, msg, sm) {
+  const sessionId = msg.session ?? "default";
+  const session = sm.getSession(sessionId);
+  wsReply(ws, msg, {
+    alive: session?.process?.alive ?? false,
+    sessionId: session?.process?.sessionId ?? null,
+    ccSessionId: session?.ccSessionId ?? null,
+    eventCount: session?.eventCounter ?? 0,
+    config: session?.lastStartConfig ?? null
+  });
+}
+async function handleAgentRunOnce(ws, msg, sm) {
+  if (!msg.message) return replyError(ws, msg, "message is required");
+  try {
+    const { result, usage } = await runOnce(sm, msg);
+    wsReply(ws, msg, { result, usage });
+  } catch (e) {
+    replyError(ws, msg, e.message);
+  }
+}
+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;
+  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 });
+    }
+  }
+  const unsub = sm.onSessionEvent(sessionId, (eventCursor, event) => {
+    send(ws, { type: "agent.event", session: sessionId, cursor: eventCursor, event });
+  });
+  state.agentUnsubs.set(sessionId, unsub);
+  reply(ws, msg, { cursor });
+}
+function handleAgentUnsubscribe(ws, msg, state) {
+  const sessionId = msg.session ?? "default";
+  state.agentUnsubs.get(sessionId)?.();
+  state.agentUnsubs.delete(sessionId);
+  reply(ws, msg, {});
+}
+var SKILL_POLL_MS = 2e3;
+function handleEventsSubscribe(ws, msg, sm, state) {
+  state.skillEventUnsub?.();
+  state.skillEventUnsub = null;
+  if (state.skillPollTimer) {
+    clearInterval(state.skillPollTimer);
+    state.skillPollTimer = null;
+  }
+  let lastId = typeof msg.since === "number" ? msg.since : -1;
+  if (lastId <= 0) {
+    try {
+      const db = getDb();
+      const row = db.prepare("SELECT MAX(id) as maxId FROM skill_events").get();
+      lastId = row.maxId ?? 0;
+    } catch {
+      lastId = 0;
+    }
+  }
+  state.skillEventUnsub = sm.onSkillEvent((event) => {
+    const eventId = event.id;
+    if (eventId > lastId) {
+      lastId = eventId;
+      send(ws, { type: "skill.event", data: event });
+    }
+  });
+  state.skillPollTimer = setInterval(() => {
+    try {
+      const db = getDb();
+      const rows = db.prepare(
+        `SELECT id, session_id, skill, type, message, data, created_at
+         FROM skill_events WHERE id > ? ORDER BY id ASC LIMIT 50`
+      ).all(lastId);
+      for (const row of rows) {
+        if (row.id > lastId) {
+          lastId = row.id;
+          send(ws, { type: "skill.event", data: row });
+        }
+      }
+    } catch {
+    }
+  }, SKILL_POLL_MS);
+  reply(ws, msg, { lastId });
+}
+function handleEventsUnsubscribe(ws, msg, state) {
+  state.skillEventUnsub?.();
+  state.skillEventUnsub = null;
+  if (state.skillPollTimer) {
+    clearInterval(state.skillPollTimer);
+    state.skillPollTimer = null;
+  }
+  reply(ws, msg, {});
+}
+function handleEmit(ws, msg, sm) {
+  const skill = msg.skill;
+  const eventType = msg.eventType;
+  const emitMessage = msg.message;
+  const data = msg.data;
+  const sessionId = msg.session;
+  if (!skill || !eventType || !emitMessage) {
+    return replyError(ws, msg, "skill, eventType, message are required");
+  }
+  try {
+    const db = getDb();
+    const result = db.prepare(
+      `INSERT INTO skill_events (session_id, skill, type, message, data) VALUES (?, ?, ?, ?, ?)`
+    ).run(sessionId ?? null, skill, eventType, emitMessage, data ?? null);
+    const id = Number(result.lastInsertRowid);
+    sm.broadcastSkillEvent({
+      id,
+      session_id: sessionId ?? null,
+      skill,
+      type: eventType,
+      message: emitMessage,
+      data: data ?? null,
+      created_at: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    wsReply(ws, msg, { id });
+  } catch (e) {
+    replyError(ws, msg, e.message);
+  }
+}
+function handlePermissionRespond(ws, msg, sm) {
+  const sessionId = msg.session ?? "default";
+  const approved = msg.approved === true;
+  const resolved = sm.resolvePendingPermission(sessionId, approved);
+  if (!resolved) return replyError(ws, msg, "No pending permission request");
+  wsReply(ws, msg, { status: approved ? "approved" : "denied" });
+}
+function handlePermissionPending(ws, msg, sm) {
+  const sessionId = msg.session;
+  if (sessionId) {
+    const pending = sm.getPendingPermission(sessionId);
+    wsReply(ws, msg, { pending: pending ? [{ sessionId, ...pending }] : [] });
+  } else {
+    wsReply(ws, msg, { pending: sm.getAllPendingPermissions() });
+  }
+}
+function handlePermissionSubscribe(ws, msg, sm, state) {
+  state.permissionUnsub?.();
+  state.permissionUnsub = sm.onPermissionRequest((sessionId, request, createdAt) => {
+    send(ws, { type: "permission.request", session: sessionId, request, createdAt });
+  });
+  reply(ws, msg, {});
+}
+function handlePermissionUnsubscribe(ws, msg, state) {
+  state.permissionUnsub?.();
+  state.permissionUnsub = null;
+  reply(ws, msg, {});
+}
+function handleChatSessionsList(ws, msg) {
+  try {
+    const db = getDb();
+    const rows = db.prepare(
+      `SELECT id, label, type, meta, cwd, created_at FROM chat_sessions ORDER BY created_at DESC`
+    ).all();
+    const sessions = rows.map((r) => ({ ...r, meta: r.meta ? JSON.parse(r.meta) : null }));
+    wsReply(ws, msg, { sessions });
+  } catch (e) {
+    replyError(ws, msg, e.message);
+  }
+}
+function handleChatSessionsCreate(ws, msg) {
+  const id = msg.id ?? crypto.randomUUID().slice(0, 8);
+  try {
+    const db = getDb();
+    db.prepare(`INSERT OR IGNORE INTO chat_sessions (id, label, type, meta) VALUES (?, ?, ?, ?)`).run(id, msg.label ?? id, msg.chatType ?? "background", msg.meta ? JSON.stringify(msg.meta) : null);
+    wsReply(ws, msg, { status: "created", id, meta: msg.meta ?? null });
+  } catch (e) {
+    replyError(ws, msg, e.message);
+  }
+}
+function handleChatSessionsRemove(ws, msg) {
+  const id = msg.session;
+  if (!id) return replyError(ws, msg, "session is required");
+  if (id === "default") return replyError(ws, msg, "Cannot delete default session");
+  try {
+    const db = getDb();
+    db.prepare(`DELETE FROM chat_sessions WHERE id = ?`).run(id);
+    wsReply(ws, msg, { status: "deleted" });
+  } catch (e) {
+    replyError(ws, msg, e.message);
+  }
+}
+function handleChatMessagesList(ws, msg) {
+  const id = msg.session;
+  if (!id) return replyError(ws, msg, "session is required");
+  try {
+    const db = getDb();
+    const query = msg.since != null ? db.prepare(`SELECT * FROM chat_messages WHERE session_id = ? AND id > ? ORDER BY id ASC`) : db.prepare(`SELECT * FROM chat_messages WHERE session_id = ? ORDER BY id ASC`);
+    const messages = msg.since != null ? query.all(id, msg.since) : query.all(id);
+    wsReply(ws, msg, { messages });
+  } catch (e) {
+    replyError(ws, msg, e.message);
+  }
+}
+function handleChatMessagesCreate(ws, msg) {
+  const sessionId = msg.session;
+  if (!sessionId) return replyError(ws, msg, "session is required");
+  if (!msg.role) return replyError(ws, msg, "role is required");
+  try {
+    const db = getDb();
+    db.prepare(`INSERT OR IGNORE INTO chat_sessions (id, label, type) VALUES (?, ?, 'main')`).run(sessionId, sessionId);
+    const result = db.prepare(
+      `INSERT INTO chat_messages (session_id, role, content, skill_name, meta) VALUES (?, ?, ?, ?, ?)`
+    ).run(
+      sessionId,
+      msg.role,
+      msg.content ?? "",
+      msg.skill_name ?? null,
+      msg.meta ? JSON.stringify(msg.meta) : null
+    );
+    wsReply(ws, msg, { status: "created", id: Number(result.lastInsertRowid) });
+  } catch (e) {
+    replyError(ws, msg, e.message);
+  }
+}
+function handleChatMessagesClear(ws, msg) {
+  const id = msg.session;
+  if (!id) return replyError(ws, msg, "session is required");
+  try {
+    const db = getDb();
+    db.prepare(`DELETE FROM chat_messages WHERE session_id = ?`).run(id);
+    wsReply(ws, msg, { status: "cleared" });
+  } catch (e) {
+    replyError(ws, msg, e.message);
+  }
+}
+
 // src/server/index.ts
 function createSnaApp(options = {}) {
   const sessionManager2 = options.sessionManager ?? new SessionManager();
   const app = new Hono3();
   app.get("/health", (c) => c.json({ ok: true, name: "sna", version: "1" }));
   app.get("/events", eventsRoute);
-  app.post("/emit", emitRoute);
+  app.post("/emit", createEmitRoute(sessionManager2));
   app.route("/agent", createAgentRoutes(sessionManager2));
   app.route("/chat", createChatRoutes());
   if (options.runCommands) {
@@ -1060,7 +2106,8 @@ try {
   if (err2.message?.includes("NODE_MODULE_VERSION")) {
     console.error(`
 \u2717  better-sqlite3 was compiled for a different Node.js version.`);
-    console.error(`   Run: pnpm rebuild better-sqlite3
+    console.error(`   This usually happens when electron-rebuild overwrites the native binary.`);
+    console.error(`   Fix: run "sna api:up" which auto-installs an isolated copy in .sna/native/
 `);
   } else {
     console.error(`
@@ -1088,8 +2135,8 @@ var methodColor = {
 root.use("*", async (c, next) => {
   const m = c.req.method;
   const colorFn = methodColor[m] ?? chalk2.white;
-  const path4 = new URL(c.req.url).pathname;
-  logger.log("req", `${colorFn(m.padEnd(6))} ${path4}`);
+  const path5 = new URL(c.req.url).pathname;
+  logger.log("req", `${colorFn(m.padEnd(6))} ${path5}`);
   await next();
 });
 var sessionManager = new SessionManager({ maxSessions });
@@ -1130,8 +2177,10 @@ process.on("uncaughtException", (err2) => {
 server = serve({ fetch: root.fetch, port }, () => {
   console.log("");
   logger.log("sna", chalk2.green.bold(`API server ready \u2192 http://localhost:${port}`));
+  logger.log("sna", chalk2.dim(`WebSocket endpoint \u2192 ws://localhost:${port}/ws`));
   console.log("");
 });
+attachWebSocket(server, sessionManager);
 agentProcess.on("event", (e) => {
   if (e.type === "init") {
     logger.log("agent", chalk2.green(`agent ready (session=${e.data?.sessionId ?? "?"})`));