@sna-sdk/core 0.9.10 → 0.9.11

package/dist/electron/index.cjs

@@ -34,6 +34,7 @@ __export(electron_exports, {
   parseCommandVOutput: () => parseCommandVOutput,
   resolveClaudeCli: () => resolveClaudeCli,
   startSnaServer: () => startSnaServer,
+  startSnaServerInProcess: () => startSnaServerInProcess,
   validateClaudePath: () => validateClaudePath
 });
 module.exports = __toCommonJS(electron_exports);
@@ -43,17 +44,72 @@ var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${_
 var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
 
 // src/electron/index.ts
-var import_child_process2 = require("child_process");
-var import_url = require("url");
-var import_fs3 = __toESM(require("fs"), 1);
+var import_child_process3 = require("child_process");
+var import_url2 = require("url");
+var import_fs7 = __toESM(require("fs"), 1);
 
 // src/core/providers/claude-code.ts
 var import_child_process = require("child_process");
 var import_events = require("events");
-var import_fs2 = __toESM(require("fs"), 1);
-var import_path2 = __toESM(require("path"), 1);
+var import_fs3 = __toESM(require("fs"), 1);
+var import_path3 = __toESM(require("path"), 1);
+var import_url = require("url");
 
 // src/core/providers/cc-history-adapter.ts
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+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 = import_path.default.join(opts.cwd, ".sna", "history");
+    import_fs.default.mkdirSync(dir, { recursive: true });
+    const sessionId = crypto.randomUUID();
+    const filePath = import_path.default.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;
+    }
+    import_fs.default.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({
@@ -68,11 +124,11 @@ ${xml}
 }
 
 // src/lib/logger.ts
-var import_fs = __toESM(require("fs"), 1);
-var import_path = __toESM(require("path"), 1);
-var LOG_PATH = import_path.default.join(process.cwd(), ".dev.log");
+var import_fs2 = __toESM(require("fs"), 1);
+var import_path2 = __toESM(require("path"), 1);
+var LOG_PATH = import_path2.default.join(process.cwd(), ".dev.log");
 try {
-  import_fs.default.writeFileSync(LOG_PATH, "");
+  import_fs2.default.writeFileSync(LOG_PATH, "");
 } catch {
 }
 function ts() {
@@ -91,7 +147,7 @@ var tags = {
 function appendFile(tag, args) {
   const line = `${ts()} ${tag} ${args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ")}
 `;
-  import_fs.default.appendFile(LOG_PATH, line, () => {
+  import_fs2.default.appendFile(LOG_PATH, line, () => {
   });
 }
 function log(tag, ...args) {
@@ -117,7 +173,7 @@ function parseCommandVOutput(raw) {
 }
 function validateClaudePath(claudePath) {
   try {
-    const claudeDir = import_path2.default.dirname(claudePath);
+    const claudeDir = import_path3.default.dirname(claudePath);
     const env = { ...process.env, PATH: `${claudeDir}:${process.env.PATH ?? ""}` };
     const out = (0, import_child_process.execSync)(`"${claudePath}" --version`, { encoding: "utf8", stdio: "pipe", timeout: 1e4, env }).trim();
     return { ok: true, version: out.split("\n")[0].slice(0, 30) };
@@ -126,10 +182,10 @@ function validateClaudePath(claudePath) {
   }
 }
 function cacheClaudePath(claudePath, cacheDir) {
-  const dir = cacheDir ?? import_path2.default.join(process.cwd(), ".sna");
+  const dir = cacheDir ?? import_path3.default.join(process.cwd(), ".sna");
   try {
-    if (!import_fs2.default.existsSync(dir)) import_fs2.default.mkdirSync(dir, { recursive: true });
-    import_fs2.default.writeFileSync(import_path2.default.join(dir, "claude-path"), claudePath);
+    if (!import_fs3.default.existsSync(dir)) import_fs3.default.mkdirSync(dir, { recursive: true });
+    import_fs3.default.writeFileSync(import_path3.default.join(dir, "claude-path"), claudePath);
   } catch {
   }
 }
@@ -139,9 +195,9 @@ function resolveClaudeCli(opts) {
     const v = validateClaudePath(process.env.SNA_CLAUDE_COMMAND);
     return { path: process.env.SNA_CLAUDE_COMMAND, version: v.version, source: "env" };
   }
-  const cacheFile = cacheDir ? import_path2.default.join(cacheDir, "claude-path") : import_path2.default.join(process.cwd(), ".sna/claude-path");
+  const cacheFile = cacheDir ? import_path3.default.join(cacheDir, "claude-path") : import_path3.default.join(process.cwd(), ".sna/claude-path");
   try {
-    const cached = import_fs2.default.readFileSync(cacheFile, "utf8").trim();
+    const cached = import_fs3.default.readFileSync(cacheFile, "utf8").trim();
     if (cached) {
       const v = validateClaudePath(cached);
       if (v.ok) return { path: cached, version: v.version, source: "cache" };
@@ -176,6 +232,11 @@ function resolveClaudeCli(opts) {
   }
   return { path: "claude", source: "fallback" };
 }
+function resolveClaudePath(cwd) {
+  const result = resolveClaudeCli({ cacheDir: import_path3.default.join(cwd, ".sna") });
+  logger.log("agent", `claude path: ${result.source}=${result.path}${result.version ? ` (${result.version})` : ""}`);
+  return result.path;
+}
 var _ClaudeCodeProcess = class _ClaudeCodeProcess {
   constructor(proc, options) {
     this.emitter = new import_events.EventEmitter();
@@ -517,16 +578,2232 @@ var _ClaudeCodeProcess = class _ClaudeCodeProcess {
 };
 _ClaudeCodeProcess.DRAIN_INTERVAL_MS = 15;
 var ClaudeCodeProcess = _ClaudeCodeProcess;
+var ClaudeCodeProvider = class {
+  constructor() {
+    this.name = "claude-code";
+  }
+  async isAvailable() {
+    try {
+      const p = resolveClaudePath(process.cwd());
+      (0, import_child_process.execSync)(`test -x "${p}"`, { stdio: "pipe" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  spawn(options) {
+    const claudeCommand = resolveClaudePath(options.cwd);
+    const claudeParts = claudeCommand.split(/\s+/);
+    const claudePath = claudeParts[0];
+    const claudePrefix = claudeParts.slice(1);
+    let pkgRoot = import_path3.default.dirname((0, import_url.fileURLToPath)(importMetaUrl));
+    while (!import_fs3.default.existsSync(import_path3.default.join(pkgRoot, "package.json"))) {
+      const parent = import_path3.default.dirname(pkgRoot);
+      if (parent === pkgRoot) break;
+      pkgRoot = parent;
+    }
+    const hookScript = import_path3.default.join(pkgRoot, "dist", "scripts", "hook.js");
+    const sessionId = options.env?.SNA_SESSION_ID ?? "default";
+    const sdkSettings = {};
+    if (options.permissionMode !== "bypassPermissions") {
+      sdkSettings.hooks = {
+        PreToolUse: [{
+          matcher: ".*",
+          hooks: [{ type: "command", command: `node "${hookScript}" --session=${sessionId}` }]
+        }]
+      };
+    }
+    let extraArgsClean = options.extraArgs ? [...options.extraArgs] : [];
+    const settingsIdx = extraArgsClean.indexOf("--settings");
+    if (settingsIdx !== -1 && settingsIdx + 1 < extraArgsClean.length) {
+      try {
+        const appSettings = JSON.parse(extraArgsClean[settingsIdx + 1]);
+        if (appSettings.hooks) {
+          for (const [event, hooks] of Object.entries(appSettings.hooks)) {
+            if (sdkSettings.hooks && sdkSettings.hooks[event]) {
+              sdkSettings.hooks[event] = [
+                ...sdkSettings.hooks[event],
+                ...hooks
+              ];
+            } else {
+              sdkSettings.hooks[event] = hooks;
+            }
+          }
+          delete appSettings.hooks;
+        }
+        Object.assign(sdkSettings, appSettings);
+      } catch {
+      }
+      extraArgsClean.splice(settingsIdx, 2);
+    }
+    const args = [
+      "--output-format",
+      "stream-json",
+      "--input-format",
+      "stream-json",
+      "--verbose",
+      "--include-partial-messages",
+      "--settings",
+      JSON.stringify(sdkSettings)
+    ];
+    if (options.model) {
+      args.push("--model", options.model);
+    }
+    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);
+    }
+    const cleanEnv = { ...process.env, ...options.env };
+    if (options.configDir) {
+      cleanEnv.CLAUDE_CONFIG_DIR = options.configDir;
+    }
+    delete cleanEnv.CLAUDECODE;
+    delete cleanEnv.CLAUDE_CODE_ENTRYPOINT;
+    delete cleanEnv.CLAUDE_CODE_SESSION_ACCESS_TOKEN;
+    delete cleanEnv.CLAUDE_CODE_OAUTH_TOKEN;
+    const claudeDir = import_path3.default.dirname(claudePath);
+    if (claudeDir && claudeDir !== ".") {
+      cleanEnv.PATH = `${claudeDir}:${cleanEnv.PATH ?? ""}`;
+    }
+    const proc = (0, import_child_process.spawn)(claudePath, [...claudePrefix, ...args], {
+      cwd: options.cwd,
+      env: cleanEnv,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    logger.log("agent", `spawned claude-code (pid=${proc.pid}) \u2192 ${claudeCommand} ${args.join(" ")}`);
+    return new ClaudeCodeProcess(proc, options);
+  }
+};
+
+// src/electron/index.ts
+var import_path6 = __toESM(require("path"), 1);
+var import_hono4 = require("hono");
+var import_cors = require("hono/cors");
+var import_node_server = require("@hono/node-server");
+
+// src/server/index.ts
+var import_hono3 = require("hono");
+
+// src/server/routes/events.ts
+var import_streaming = require("hono/streaming");
+
+// src/db/schema.ts
+var import_node_module = require("module");
+var import_fs4 = __toESM(require("fs"), 1);
+var import_path4 = __toESM(require("path"), 1);
+var DB_PATH = process.env.SNA_DB_PATH ?? import_path4.default.join(process.cwd(), "data/sna.db");
+var NATIVE_DIR = import_path4.default.join(process.cwd(), ".sna/native");
+var _db = null;
+function loadBetterSqlite3() {
+  const modulesPath = process.env.SNA_MODULES_PATH;
+  if (modulesPath) {
+    const entry = import_path4.default.join(modulesPath, "better-sqlite3");
+    if (import_fs4.default.existsSync(entry)) {
+      const req2 = (0, import_node_module.createRequire)(import_path4.default.join(modulesPath, "noop.js"));
+      return req2("better-sqlite3");
+    }
+  }
+  const nativeEntry = import_path4.default.join(NATIVE_DIR, "node_modules", "better-sqlite3");
+  if (import_fs4.default.existsSync(nativeEntry)) {
+    const req2 = (0, import_node_module.createRequire)(import_path4.default.join(NATIVE_DIR, "noop.js"));
+    return req2("better-sqlite3");
+  }
+  const req = (0, import_node_module.createRequire)(importMetaUrl);
+  return req("better-sqlite3");
+}
+function getDb() {
+  if (!_db) {
+    const BetterSqlite3 = loadBetterSqlite3();
+    const dir = import_path4.default.dirname(DB_PATH);
+    if (!import_fs4.default.existsSync(dir)) import_fs4.default.mkdirSync(dir, { recursive: true });
+    const nativeBinding = process.env.SNA_SQLITE_NATIVE_BINDING || void 0;
+    _db = nativeBinding ? new BetterSqlite3(DB_PATH, { nativeBinding }) : new BetterSqlite3(DB_PATH);
+    _db.pragma("journal_mode = WAL");
+    initSchema(_db);
+  }
+  return _db;
+}
+function migrateSkillEvents(db) {
+  const row = db.prepare(
+    "SELECT sql FROM sqlite_master WHERE type='table' AND name='skill_events'"
+  ).get();
+  if (row?.sql?.includes("CHECK(type IN")) {
+    db.exec("DROP TABLE IF EXISTS skill_events");
+  }
+}
+function migrateChatSessionsMeta(db) {
+  const cols = db.prepare("PRAGMA table_info(chat_sessions)").all();
+  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);
+  migrateChatSessionsMeta(db);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS chat_sessions (
+      id         TEXT PRIMARY KEY,
+      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'))
+    );
+
+    -- Ensure default session always exists
+    INSERT OR IGNORE INTO chat_sessions (id, label, type) VALUES ('default', 'Chat', 'main');
+
+    CREATE TABLE IF NOT EXISTS chat_messages (
+      id         INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL REFERENCES chat_sessions(id) ON DELETE CASCADE,
+      role       TEXT NOT NULL,
+      content    TEXT NOT NULL DEFAULT '',
+      skill_name TEXT,
+      meta       TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_chat_messages_session ON chat_messages(session_id);
+
+    CREATE TABLE IF NOT EXISTS skill_events (
+      id         INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT REFERENCES chat_sessions(id) ON DELETE SET NULL,
+      skill      TEXT NOT NULL,
+      type       TEXT NOT NULL,
+      message    TEXT NOT NULL,
+      data       TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_skill_events_skill ON skill_events(skill);
+    CREATE INDEX IF NOT EXISTS idx_skill_events_created ON skill_events(created_at);
+    CREATE INDEX IF NOT EXISTS idx_skill_events_session ON skill_events(session_id);
+  `);
+}
+
+// src/config.ts
+var defaults = {
+  port: 3099,
+  model: "claude-sonnet-4-6",
+  defaultProvider: "claude-code",
+  defaultPermissionMode: "default",
+  maxSessions: 5,
+  maxEventBuffer: 500,
+  permissionTimeoutMs: 0,
+  // app controls — no SDK-side timeout
+  runOnceTimeoutMs: 12e4,
+  pollIntervalMs: 500,
+  keepaliveIntervalMs: 15e3,
+  skillPollMs: 2e3,
+  dbPath: "data/sna.db"
+};
+function fromEnv() {
+  const env = {};
+  if (process.env.SNA_PORT) env.port = parseInt(process.env.SNA_PORT, 10);
+  if (process.env.SNA_MODEL) env.model = process.env.SNA_MODEL;
+  if (process.env.SNA_PERMISSION_MODE) env.defaultPermissionMode = process.env.SNA_PERMISSION_MODE;
+  if (process.env.SNA_MAX_SESSIONS) env.maxSessions = parseInt(process.env.SNA_MAX_SESSIONS, 10);
+  if (process.env.SNA_DB_PATH) env.dbPath = process.env.SNA_DB_PATH;
+  if (process.env.SNA_PERMISSION_TIMEOUT_MS) env.permissionTimeoutMs = parseInt(process.env.SNA_PERMISSION_TIMEOUT_MS, 10);
+  return env;
+}
+var current = { ...defaults, ...fromEnv() };
+function getConfig() {
+  return current;
+}
+function setConfig(overrides) {
+  current = { ...current, ...overrides };
+}
+
+// src/server/routes/events.ts
+function eventsRoute(c) {
+  const sinceParam = c.req.query("since");
+  let lastId = sinceParam ? parseInt(sinceParam) : -1;
+  if (lastId <= 0) {
+    const db = getDb();
+    const row = db.prepare("SELECT MAX(id) as maxId FROM skill_events").get();
+    lastId = row.maxId ?? 0;
+  }
+  return (0, import_streaming.streamSSE)(c, async (stream) => {
+    let closed = false;
+    stream.onAbort(() => {
+      closed = true;
+    });
+    const keepaliveTimer = setInterval(async () => {
+      if (closed) {
+        clearInterval(keepaliveTimer);
+        return;
+      }
+      try {
+        await stream.writeSSE({ data: "", event: "keepalive" });
+      } catch {
+        closed = true;
+        clearInterval(keepaliveTimer);
+      }
+    }, getConfig().keepaliveIntervalMs);
+    while (!closed) {
+      try {
+        const db = getDb();
+        const rows = db.prepare(`
+          SELECT 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 (closed) break;
+          await stream.writeSSE({ data: JSON.stringify(row) });
+          lastId = row.id;
+        }
+      } catch {
+      }
+      await stream.sleep(getConfig().pollIntervalMs);
+    }
+    clearInterval(keepaliveTimer);
+  });
+}
+
+// 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
+function createEmitRoute(sessionManager) {
+  return async (c) => {
+    const body = await c.req.json();
+    const { skill, message, data } = body;
+    const type = body.type ?? body.eventType;
+    const session_id = c.req.query("session") ?? body.session_id ?? body.session ?? null;
+    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, skill, type, message, data ?? null);
+    const id = Number(result.lastInsertRowid);
+    sessionManager.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
+var import_child_process2 = require("child_process");
+var import_streaming2 = require("hono/streaming");
+var ROOT = process.cwd();
+function createRunRoute(commands) {
+  return function runRoute(c) {
+    const skill = c.req.query("skill") ?? "";
+    const cmd = commands[skill];
+    if (!cmd) {
+      return c.text(`data: unknown skill: ${skill}
+
+data: [done]
+
+`, 200, {
+        "Content-Type": "text/event-stream"
+      });
+    }
+    return (0, import_streaming2.streamSSE)(c, async (stream) => {
+      await stream.writeSSE({ data: `$ ${cmd.slice(1).join(" ")}` });
+      const child = (0, import_child_process2.spawn)(cmd[0], cmd.slice(1), {
+        cwd: ROOT,
+        env: { ...process.env, FORCE_COLOR: "0" }
+      });
+      const write = (chunk) => {
+        for (const line of chunk.toString().split("\n")) {
+          if (line.trim()) stream.writeSSE({ data: line });
+        }
+      };
+      child.stdout.on("data", write);
+      child.stderr.on("data", (chunk) => {
+        for (const line of chunk.toString().split("\n")) {
+          if (line.trim() && !line.startsWith(">")) stream.writeSSE({ data: line });
+        }
+      });
+      await new Promise((resolve) => {
+        child.on("close", async (code) => {
+          await stream.writeSSE({ data: `[exit ${code ?? 0}]` });
+          await stream.writeSSE({ data: "[done]" });
+          resolve();
+        });
+        child.on("error", async (err2) => {
+          await stream.writeSSE({ data: `Error: ${err2.message}` });
+          await stream.writeSSE({ data: "[done]" });
+          resolve();
+        });
+      });
+    });
+  };
+}
+
+// src/server/routes/agent.ts
+var import_hono = require("hono");
+var import_streaming3 = require("hono/streaming");
+
+// src/core/providers/codex.ts
+var CodexProvider = class {
+  constructor() {
+    this.name = "codex";
+  }
+  async isAvailable() {
+    return false;
+  }
+  spawn(_options) {
+    throw new Error("Codex provider not yet implemented");
+  }
+};
+
+// src/core/providers/index.ts
+var providers = {
+  "claude-code": new ClaudeCodeProvider(),
+  "codex": new CodexProvider()
+};
+function getProvider(name = "claude-code") {
+  const provider = providers[name];
+  if (!provider) throw new Error(`Unknown agent provider: ${name}`);
+  return provider;
+}
+
+// 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
+var import_fs5 = __toESM(require("fs"), 1);
+var import_path5 = __toESM(require("path"), 1);
+var import_crypto = require("crypto");
+var IMAGE_DIR = import_path5.default.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 = import_path5.default.join(IMAGE_DIR, sessionId);
+  import_fs5.default.mkdirSync(dir, { recursive: true });
+  return images.map((img) => {
+    const ext = MIME_TO_EXT[img.mimeType] ?? "bin";
+    const hash = (0, import_crypto.createHash)("sha256").update(img.base64).digest("hex").slice(0, 12);
+    const filename = `${hash}.${ext}`;
+    const filePath = import_path5.default.join(dir, filename);
+    if (!import_fs5.default.existsSync(filePath)) {
+      import_fs5.default.writeFileSync(filePath, Buffer.from(img.base64, "base64"));
+    }
+    return filename;
+  });
+}
+function resolveImagePath(sessionId, filename) {
+  if (filename.includes("..") || filename.includes("/")) return null;
+  const filePath = import_path5.default.join(IMAGE_DIR, sessionId, filename);
+  return import_fs5.default.existsSync(filePath) ? filePath : null;
+}
+
+// src/server/routes/agent.ts
+function getSessionId(c) {
+  return c.req.query("session") ?? "default";
+}
+async function runOnce(sessionManager, opts) {
+  const sessionId = `run-once-${crypto.randomUUID().slice(0, 8)}`;
+  const timeout = opts.timeout ?? getConfig().runOnceTimeoutMs;
+  const session = sessionManager.createSession({
+    id: sessionId,
+    label: "run-once",
+    cwd: opts.cwd ?? process.cwd()
+  });
+  const cfg = getConfig();
+  const provider = getProvider(opts.provider ?? cfg.defaultProvider);
+  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 = provider.spawn({
+    cwd: session.cwd,
+    prompt: opts.message,
+    model: opts.model ?? cfg.model,
+    permissionMode: opts.permissionMode ?? cfg.defaultPermissionMode,
+    env: { SNA_SESSION_ID: sessionId },
+    extraArgs
+  });
+  sessionManager.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 = sessionManager.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 {
+    sessionManager.killSession(sessionId);
+    sessionManager.removeSession(sessionId);
+  }
+}
+function createAgentRoutes(sessionManager) {
+  const app = new import_hono.Hono();
+  app.post("/sessions", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    try {
+      const session = sessionManager.createSession({
+        id: body.id,
+        label: body.label,
+        cwd: body.cwd,
+        meta: body.meta
+      });
+      logger.log("route", `POST /sessions \u2192 created "${session.id}"`);
+      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 httpJson(c, "sessions.list", { sessions: sessionManager.listSessions() });
+  });
+  app.delete("/sessions/:id", (c) => {
+    const id = c.req.param("id");
+    if (id === "default") {
+      return c.json({ status: "error", message: "Cannot remove default session" }, 400);
+    }
+    const removed = sessionManager.removeSession(id);
+    if (!removed) {
+      return c.json({ status: "error", message: "Session not found" }, 404);
+    }
+    logger.log("route", `DELETE /sessions/${id} \u2192 removed`);
+    return httpJson(c, "sessions.remove", { status: "removed" });
+  });
+  app.patch("/sessions/:id", async (c) => {
+    const id = c.req.param("id");
+    const body = await c.req.json().catch(() => ({}));
+    try {
+      sessionManager.updateSession(id, {
+        label: body.label,
+        meta: body.meta,
+        cwd: body.cwd
+      });
+      logger.log("route", `PATCH /sessions/${id} \u2192 updated`);
+      return httpJson(c, "sessions.update", { status: "updated", session: id });
+    } catch (e) {
+      logger.err("err", `PATCH /sessions/${id} \u2192 ${e.message}`);
+      return c.json({ status: "error", message: e.message }, 404);
+    }
+  });
+  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(sessionManager, 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 = sessionManager.getOrCreateSession(sessionId, {
+      cwd: body.cwd
+    });
+    if (session.process?.alive && !body.force) {
+      logger.log("route", `POST /start?session=${sessionId} \u2192 already_running`);
+      return httpJson(c, "agent.start", {
+        status: "already_running",
+        provider: getConfig().defaultProvider,
+        sessionId: session.process.sessionId ?? session.id
+      });
+    }
+    if (session.process?.alive) {
+      session.process.kill();
+    }
+    const provider = getProvider(body.provider ?? getConfig().defaultProvider);
+    try {
+      const db = getDb();
+      db.prepare(`INSERT OR IGNORE INTO chat_sessions (id, label, type) VALUES (?, ?, 'main')`).run(sessionId, session.label ?? sessionId);
+      if (body.prompt) {
+        db.prepare(`INSERT INTO chat_messages (session_id, role, content, meta) VALUES (?, 'user', ?, ?)`).run(sessionId, body.prompt, body.meta ? JSON.stringify(body.meta) : null);
+      }
+      const skillMatch = body.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 = body.provider ?? getConfig().defaultProvider;
+    const model = body.model ?? getConfig().model;
+    const permissionMode = body.permissionMode;
+    const configDir = body.configDir;
+    const extraArgs = body.extraArgs;
+    try {
+      const proc = provider.spawn({
+        cwd: session.cwd,
+        prompt: body.prompt,
+        model,
+        permissionMode,
+        configDir,
+        env: { SNA_SESSION_ID: sessionId },
+        history: body.history,
+        extraArgs
+      });
+      sessionManager.setProcess(sessionId, proc);
+      sessionManager.saveStartConfig(sessionId, { provider: providerName, model, permissionMode, configDir, extraArgs });
+      logger.log("route", `POST /start?session=${sessionId} \u2192 started`);
+      return httpJson(c, "agent.start", {
+        status: "started",
+        provider: provider.name,
+        sessionId: session.id
+      });
+    } catch (e) {
+      logger.err("err", `POST /start?session=${sessionId} failed: ${e.message}`);
+      return c.json({ status: "error", message: e.message }, 500);
+    }
+  });
+  app.post("/send", async (c) => {
+    const sessionId = getSessionId(c);
+    const session = sessionManager.getSession(sessionId);
+    if (!session?.process?.alive) {
+      logger.err("err", `POST /send?session=${sessionId} \u2192 no active session`);
+      return c.json(
+        { status: "error", message: `No active agent session "${sessionId}". Call POST /start first.` },
+        400
+      );
+    }
+    const body = await c.req.json().catch(() => ({}));
+    if (!body.message && !body.images?.length) {
+      logger.err("err", `POST /send?session=${sessionId} \u2192 empty message`);
+      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, textContent, Object.keys(meta).length > 0 ? JSON.stringify(meta) : null);
+    } catch {
+    }
+    sessionManager.pushEvent(sessionId, {
+      type: "user_message",
+      message: textContent,
+      data: Object.keys(meta).length > 0 ? meta : void 0,
+      timestamp: Date.now()
+    });
+    sessionManager.updateSessionState(sessionId, "processing");
+    sessionManager.touch(sessionId);
+    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);
+    const session = sessionManager.getOrCreateSession(sessionId);
+    const sinceParam = c.req.query("since");
+    const sinceCursor = sinceParam ? parseInt(sinceParam, 10) : session.eventCounter;
+    return (0, import_streaming3.streamSSE)(c, async (stream) => {
+      const KEEPALIVE_MS = getConfig().keepaliveIntervalMs;
+      const signal = c.req.raw.signal;
+      const queue = [];
+      let wakeUp = null;
+      const unsub = sessionManager.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)
+          );
+          for (const event of session.eventBuffer.slice(startIdx)) {
+            cursor++;
+            await stream.writeSSE({ id: String(cursor), data: JSON.stringify(event) });
+          }
+        } else {
+          cursor = session.eventCounter;
+        }
+        while (queue.length > 0 && queue[0].cursor !== -1 && 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();
+              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: "" });
+          }
+        }
+      } finally {
+        unsub();
+      }
+    });
+  });
+  app.post("/restart", async (c) => {
+    const sessionId = getSessionId(c);
+    const body = await c.req.json().catch(() => ({}));
+    try {
+      const ccSessionId = sessionManager.getSession(sessionId)?.ccSessionId;
+      const { config } = sessionManager.restartSession(sessionId, body, (cfg) => {
+        const prov = getProvider(cfg.provider);
+        const resumeArgs = ccSessionId ? ["--resume", ccSessionId] : ["--resume"];
+        return prov.spawn({
+          cwd: sessionManager.getSession(sessionId).cwd,
+          model: cfg.model,
+          permissionMode: cfg.permissionMode,
+          configDir: cfg.configDir,
+          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("/resume", async (c) => {
+    const sessionId = getSessionId(c);
+    const body = await c.req.json().catch(() => ({}));
+    const session = sessionManager.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 ?? getConfig().defaultProvider;
+    const model = body.model ?? session.lastStartConfig?.model ?? getConfig().model;
+    const permissionMode = body.permissionMode ?? session.lastStartConfig?.permissionMode;
+    const configDir = body.configDir ?? session.lastStartConfig?.configDir;
+    const extraArgs = body.extraArgs ?? session.lastStartConfig?.extraArgs;
+    const provider = getProvider(providerName);
+    try {
+      const proc = provider.spawn({
+        cwd: session.cwd,
+        prompt: body.prompt,
+        model,
+        permissionMode,
+        configDir,
+        env: { SNA_SESSION_ID: sessionId },
+        history: history.length > 0 ? history : void 0,
+        extraArgs
+      });
+      sessionManager.setProcess(sessionId, proc, "resumed");
+      sessionManager.saveStartConfig(sessionId, { provider: providerName, model, permissionMode, configDir, 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 = sessionManager.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 = sessionManager.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 = sessionManager.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 = sessionManager.killSession(sessionId);
+    return httpJson(c, "agent.kill", { status: killed ? "killed" : "no_session" });
+  });
+  app.get("/status", (c) => {
+    const sessionId = getSessionId(c);
+    const session = sessionManager.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,
+      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
+    });
+  });
+  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 result = await sessionManager.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 resolved = sessionManager.resolvePendingPermission(sessionId, approved);
+    if (!resolved) {
+      return c.json({ status: "error", message: "No pending permission request" }, 404);
+    }
+    logger.log("route", `POST /permission-respond?session=${sessionId} \u2192 ${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 = sessionManager.getPendingPermission(sessionId);
+      return httpJson(c, "permission.pending", { pending: pending ? [{ sessionId, ...pending }] : [] });
+    }
+    return httpJson(c, "permission.pending", { pending: sessionManager.getAllPendingPermissions() });
+  });
+  return app;
+}
+
+// src/server/routes/chat.ts
+var import_hono2 = require("hono");
+var import_fs6 = __toESM(require("fs"), 1);
+function createChatRoutes() {
+  const app = new import_hono2.Hono();
+  app.get("/sessions", (c) => {
+    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
+      }));
+      return httpJson(c, "chat.sessions.list", { sessions });
+    } catch (e) {
+      return c.json({ status: "error", message: e.message, stack: e.stack }, 500);
+    }
+  });
+  app.post("/sessions", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const id = body.id ?? crypto.randomUUID().slice(0, 8);
+    const sessionType = body.type ?? body.chatType ?? "background";
+    try {
+      const db = getDb();
+      db.prepare(
+        `INSERT OR IGNORE INTO chat_sessions (id, label, type, meta) VALUES (?, ?, ?, ?)`
+      ).run(id, body.label ?? id, sessionType, body.meta ? JSON.stringify(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);
+    }
+  });
+  app.delete("/sessions/:id", (c) => {
+    const id = c.req.param("id");
+    if (id === "default") {
+      return c.json({ status: "error", message: "Cannot delete default session" }, 400);
+    }
+    try {
+      const db = getDb();
+      db.prepare(`DELETE FROM chat_sessions WHERE id = ?`).run(id);
+      return httpJson(c, "chat.sessions.remove", { status: "deleted" });
+    } catch (e) {
+      return c.json({ status: "error", message: e.message }, 500);
+    }
+  });
+  app.get("/sessions/:id/messages", (c) => {
+    const id = c.req.param("id");
+    const sinceParam = c.req.query("since");
+    try {
+      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 httpJson(c, "chat.messages.list", { messages });
+    } catch (e) {
+      return c.json({ status: "error", message: e.message, stack: e.stack }, 500);
+    }
+  });
+  app.post("/sessions/:id/messages", async (c) => {
+    const sessionId = c.req.param("id");
+    const body = await c.req.json().catch(() => ({}));
+    if (!body.role) {
+      return c.json({ status: "error", message: "role is required" }, 400);
+    }
+    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,
+        body.role,
+        body.content ?? "",
+        body.skill_name ?? null,
+        body.meta ? JSON.stringify(body.meta) : null
+      );
+      return httpJson(c, "chat.messages.create", { status: "created", id: Number(result.lastInsertRowid) });
+    } catch (e) {
+      return c.json({ status: "error", message: e.message }, 500);
+    }
+  });
+  app.delete("/sessions/:id/messages", (c) => {
+    const id = c.req.param("id");
+    try {
+      const db = getDb();
+      db.prepare(`DELETE FROM chat_messages WHERE session_id = ?`).run(id);
+      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 = import_fs6.default.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 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.stateChangedListeners = /* @__PURE__ */ new Set();
+    this.metadataChangedListeners = /* @__PURE__ */ new Set();
+    this.maxSessions = options.maxSessions ?? getConfig().maxSessions;
+    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 session already exists or max sessions reached. */
+  createSession(opts = {}) {
+    const id = opts.id ?? crypto.randomUUID().slice(0, 8);
+    if (this.sessions.has(id)) {
+      throw new Error(`Session "${id}" already exists`);
+    }
+    const aliveCount = Array.from(this.sessions.values()).filter((s) => s.process?.alive).length;
+    if (aliveCount >= this.maxSessions) {
+      throw new Error(`Max active sessions (${this.maxSessions}) reached \u2014 ${aliveCount} alive`);
+    }
+    const session = {
+      id,
+      process: null,
+      eventBuffer: [],
+      eventCounter: 0,
+      label: opts.label ?? id,
+      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;
+  }
+  /** 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);
+  }
+  /** Get or create a session (used for "default" backward compat). */
+  getOrCreateSession(id, opts) {
+    const existing = this.sessions.get(id);
+    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. */
+  setProcess(sessionId, proc, lifecycleState) {
+    const session = this.sessions.get(sessionId);
+    if (!session) throw new Error(`Session "${sessionId}" not found`);
+    session.process = proc;
+    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") {
+        if (e.data?.sessionId && !session.ccSessionId) {
+          session.ccSessionId = e.data.sessionId;
+          this.persistSession(session);
+        }
+        this.setSessionState(sessionId, session, "waiting");
+      }
+      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 > getConfig().maxEventBuffer) {
+          session.eventBuffer.splice(0, session.eventBuffer.length - getConfig().maxEventBuffer);
+        }
+        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) => {
+      this.setSessionState(sessionId, session, "idle");
+      this.emitLifecycle({ session: sessionId, state: code != null ? "exited" : "crashed", code });
+    });
+    proc.on("error", () => {
+      this.setSessionState(sessionId, session, "idle");
+      this.emitLifecycle({ session: sessionId, state: "crashed" });
+    });
+    this.emitLifecycle({ session: sessionId, state: lifecycleState ?? "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);
+  }
+  /** 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.eventCounter++;
+    session.eventBuffer.push(event);
+    if (session.eventBuffer.length > getConfig().maxEventBuffer) {
+      session.eventBuffer.splice(0, session.eventBuffer.length - getConfig().maxEventBuffer);
+    }
+    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) {
+    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 });
+  }
+  // ── 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);
+    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, opts) {
+    const session = this.sessions.get(sessionId);
+    if (session) this.setSessionState(sessionId, session, "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);
+      const timeout = opts?.timeoutMs ?? getConfig().permissionTimeoutMs;
+      if (timeout > 0) {
+        setTimeout(() => {
+          if (this.pendingPermissions.has(sessionId)) {
+            this.pendingPermissions.delete(sessionId);
+            resolve(false);
+          }
+        }, timeout);
+      }
+    });
+  }
+  /** 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) this.setSessionState(sessionId, session, "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();
+    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();
+    this.setSessionState(id, session, "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: getConfig().defaultProvider, model, permissionMode: getConfig().defaultPermissionMode };
+    }
+    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: getConfig().defaultProvider, model: getConfig().model, 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". */
+  removeSession(id) {
+    if (id === "default") return false;
+    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;
+  }
+  /** List all sessions as serializable info objects. */
+  listSessions() {
+    return Array.from(this.sessions.values()).map((s) => ({
+      id: s.id,
+      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
+    }));
+  }
+  /** Touch a session's lastActivityAt timestamp. */
+  touch(id) {
+    const session = this.sessions.get(id);
+    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 };
+    }
+  }
+  /** Persist an agent event to chat_messages. Returns true if a row was inserted. */
+  persistEvent(sessionId, e) {
+    try {
+      const db = getDb();
+      switch (e.type) {
+        case "assistant":
+          if (e.message) {
+            db.prepare(`INSERT INTO chat_messages (session_id, role, content) VALUES (?, 'assistant', ?)`).run(sessionId, e.message);
+            return true;
+          }
+          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;
+          }
+          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 ?? {}));
+          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 ?? {}));
+          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 }));
+          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" }));
+          return true;
+        default:
+          return false;
+      }
+    } catch {
+      return false;
+    }
+  }
+  /** Kill all sessions. Used during shutdown. */
+  killAll() {
+    const pids = [];
+    for (const session of this.sessions.values()) {
+      if (session.process?.alive) {
+        const pid = session.process.pid;
+        session.process.kill();
+        if (pid) pids.push(pid);
+      }
+    }
+    if (pids.length > 0) {
+      setTimeout(() => {
+        for (const pid of pids) {
+          try {
+            process.kill(pid, "SIGKILL");
+          } catch {
+          }
+        }
+      }, 1e3);
+    }
+  }
+  get size() {
+    return this.sessions.size;
+  }
+};
+
+// src/server/ws.ts
+var import_ws = require("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(server, sessionManager) {
+  const wss = new import_ws.WebSocketServer({ noServer: true });
+  server.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, 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;
+      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, sessionManager, 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;
+      state.stateChangedUnsub?.();
+      state.stateChangedUnsub = null;
+      state.metadataChangedUnsub?.();
+      state.metadataChangedUnsub = 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.update":
+      return handleSessionsUpdate(ws, msg, sm);
+    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.resume":
+      return handleAgentResume(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({
+      id: msg.id,
+      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 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");
+  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: getConfig().defaultProvider, sessionId: session.id });
+    return;
+  }
+  if (session.process?.alive) session.process.kill();
+  const provider = getProvider(msg.provider ?? getConfig().defaultProvider);
+  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 cfg = getConfig();
+  const providerName = msg.provider ?? cfg.defaultProvider;
+  const model = msg.model ?? cfg.model;
+  const permissionMode = msg.permissionMode;
+  const configDir = msg.configDir;
+  const extraArgs = msg.extraArgs;
+  try {
+    const proc = provider.spawn({
+      cwd: session.cwd,
+      prompt: msg.prompt,
+      model,
+      permissionMode,
+      configDir,
+      env: { SNA_SESSION_ID: sessionId },
+      history: msg.history,
+      extraArgs
+    });
+    sm.setProcess(sessionId, proc);
+    sm.saveStartConfig(sessionId, { provider: providerName, model, permissionMode, configDir, extraArgs });
+    wsReply(ws, msg, { status: "started", provider: provider.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 {
+  }
+  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 = [
+      ...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 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 ?? getConfig().defaultProvider;
+  const model = msg.model ?? session.lastStartConfig?.model ?? getConfig().model;
+  const permissionMode = msg.permissionMode ?? session.lastStartConfig?.permissionMode;
+  const configDir = msg.configDir ?? session.lastStartConfig?.configDir;
+  const extraArgs = msg.extraArgs ?? session.lastStartConfig?.extraArgs;
+  const provider = getProvider(providerName);
+  try {
+    const proc = provider.spawn({
+      cwd: session.cwd,
+      prompt: msg.prompt,
+      model,
+      permissionMode,
+      configDir,
+      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, configDir, 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 {
+    const ccSessionId = sm.getSession(sessionId)?.ccSessionId;
+    const { config } = sm.restartSession(
+      sessionId,
+      {
+        provider: msg.provider,
+        model: msg.model,
+        permissionMode: msg.permissionMode,
+        configDir: msg.configDir,
+        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,
+          configDir: cfg.configDir,
+          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 permissionMode = msg.permissionMode;
+  if (!permissionMode) return replyError(ws, msg, "permissionMode is required");
+  const updated = sm.setSessionPermissionMode(sessionId, permissionMode);
+  wsReply(ws, msg, { status: updated ? "updated" : "no_session", permissionMode });
+}
+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);
+  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,
+    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
+  });
+}
+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)?.();
+  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 {
+    }
+    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 = 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) => {
+    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 });
+}
+function handleAgentUnsubscribe(ws, msg, state) {
+  const sessionId = msg.session ?? "default";
+  state.agentUnsubs.get(sessionId)?.();
+  state.agentUnsubs.delete(sessionId);
+  reply(ws, msg, {});
+}
+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 {
+    }
+  }, getConfig().skillPollMs);
+  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?.();
+  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, { pendingCount: pending.length });
+}
+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 sessionManager = options.sessionManager ?? new SessionManager();
+  const app = new import_hono3.Hono();
+  app.get("/health", (c) => c.json({ ok: true, name: "sna", version: "1" }));
+  app.get("/events", eventsRoute);
+  app.post("/emit", createEmitRoute(sessionManager));
+  app.route("/agent", createAgentRoutes(sessionManager));
+  app.route("/chat", createChatRoutes());
+  if (options.runCommands) {
+    app.get("/run", createRunRoute(options.runCommands));
+  }
+  return app;
+}
 
 // src/electron/index.ts
-var import_path3 = __toESM(require("path"), 1);
 function resolveStandaloneScript() {
-  const selfPath = (0, import_url.fileURLToPath)(importMetaUrl);
-  let script = import_path3.default.resolve(import_path3.default.dirname(selfPath), "../server/standalone.js");
+  const selfPath = (0, import_url2.fileURLToPath)(importMetaUrl);
+  let script = import_path6.default.resolve(import_path6.default.dirname(selfPath), "../server/standalone.js");
   if (script.includes(".asar") && !script.includes(".asar.unpacked")) {
     script = script.replace(/(\.asar)([/\\])/, ".asar.unpacked$2");
   }
-  if (!import_fs3.default.existsSync(script)) {
+  if (!import_fs7.default.existsSync(script)) {
     throw new Error(
       `SNA standalone script not found: ${script}
 Ensure "@sna-sdk/core" is listed in asarUnpack in your electron-builder config.`
@@ -537,14 +2814,14 @@ Ensure "@sna-sdk/core" is listed in asarUnpack in your electron-builder config.`
 function buildNodePath() {
   const resourcesPath = process.resourcesPath;
   if (!resourcesPath) return void 0;
-  const unpacked = import_path3.default.join(resourcesPath, "app.asar.unpacked", "node_modules");
-  if (!import_fs3.default.existsSync(unpacked)) return void 0;
+  const unpacked = import_path6.default.join(resourcesPath, "app.asar.unpacked", "node_modules");
+  if (!import_fs7.default.existsSync(unpacked)) return void 0;
   const existing = process.env.NODE_PATH;
-  return existing ? `${unpacked}${import_path3.default.delimiter}${existing}` : unpacked;
+  return existing ? `${unpacked}${import_path6.default.delimiter}${existing}` : unpacked;
 }
 async function startSnaServer(options) {
   const port = options.port ?? 3099;
-  const cwd = options.cwd ?? import_path3.default.dirname(options.dbPath);
+  const cwd = options.cwd ?? import_path6.default.dirname(options.dbPath);
   const readyTimeout = options.readyTimeout ?? 15e3;
   const { onLog } = options;
   const standaloneScript = resolveStandaloneScript();
@@ -552,7 +2829,7 @@ async function startSnaServer(options) {
   let consumerModules;
   try {
     const bsPkg = require.resolve("better-sqlite3/package.json", { paths: [process.cwd()] });
-    consumerModules = import_path3.default.resolve(bsPkg, "../..");
+    consumerModules = import_path6.default.resolve(bsPkg, "../..");
   } catch {
   }
   const env = {
@@ -569,7 +2846,7 @@ async function startSnaServer(options) {
     // Consumer overrides last so they can always win
     ...options.env ?? {}
   };
-  const proc = (0, import_child_process2.fork)(standaloneScript, [], {
+  const proc = (0, import_child_process3.fork)(standaloneScript, [], {
     cwd,
     env,
     stdio: "pipe"
@@ -624,11 +2901,83 @@ async function startSnaServer(options) {
     }
   };
 }
+async function startSnaServerInProcess(options) {
+  const port = options.port ?? 3099;
+  const cwd = options.cwd ?? import_path6.default.dirname(options.dbPath);
+  setConfig({
+    port,
+    dbPath: options.dbPath,
+    ...options.maxSessions != null ? { maxSessions: options.maxSessions } : {},
+    ...options.permissionMode ? { defaultPermissionMode: options.permissionMode } : {},
+    ...options.model ? { model: options.model } : {},
+    ...options.permissionTimeoutMs != null ? { permissionTimeoutMs: options.permissionTimeoutMs } : {}
+  });
+  process.env.SNA_PORT = String(port);
+  process.env.SNA_DB_PATH = options.dbPath;
+  if (options.maxSessions != null) process.env.SNA_MAX_SESSIONS = String(options.maxSessions);
+  if (options.permissionMode) process.env.SNA_PERMISSION_MODE = options.permissionMode;
+  if (options.model) process.env.SNA_MODEL = options.model;
+  if (options.permissionTimeoutMs != null) process.env.SNA_PERMISSION_TIMEOUT_MS = String(options.permissionTimeoutMs);
+  if (options.nativeBinding) process.env.SNA_SQLITE_NATIVE_BINDING = options.nativeBinding;
+  if (!process.env.SNA_MODULES_PATH) {
+    try {
+      const bsPkg = require.resolve("better-sqlite3/package.json", { paths: [process.cwd()] });
+      process.env.SNA_MODULES_PATH = import_path6.default.resolve(bsPkg, "../..");
+    } catch {
+    }
+  }
+  const originalCwd = process.cwd();
+  try {
+    process.chdir(cwd);
+  } catch {
+  }
+  try {
+    getDb();
+  } catch (err2) {
+    process.chdir(originalCwd);
+    throw new Error(`SNA in-process: database init failed: ${err2.message}`);
+  }
+  const config = getConfig();
+  const root = new import_hono4.Hono();
+  root.use("*", (0, import_cors.cors)({ origin: "*", allowMethods: ["GET", "POST", "PATCH", "DELETE", "OPTIONS"] }));
+  root.onError((err2, c) => {
+    const pathname = new URL(c.req.url).pathname;
+    if (options.onLog) options.onLog(`ERR ${c.req.method} ${pathname} \u2192 ${err2.message}`);
+    return c.json({ status: "error", message: err2.message, stack: err2.stack }, 500);
+  });
+  root.use("*", async (c, next) => {
+    const m = c.req.method;
+    const pathname = new URL(c.req.url).pathname;
+    if (options.onLog) options.onLog(`${m.padEnd(6)} ${pathname}`);
+    await next();
+  });
+  const sessionManager = new SessionManager({ maxSessions: config.maxSessions });
+  root.route("/", createSnaApp({ sessionManager }));
+  const httpServer = (0, import_node_server.serve)({ fetch: root.fetch, port }, () => {
+    if (options.onLog) options.onLog(`API server ready \u2192 http://localhost:${port}`);
+    if (options.onLog) options.onLog(`WebSocket endpoint \u2192 ws://localhost:${port}/ws`);
+  });
+  attachWebSocket(httpServer, sessionManager);
+  return {
+    process: null,
+    port,
+    sessionManager,
+    httpServer,
+    async stop() {
+      sessionManager.killAll();
+      await new Promise((resolve) => {
+        httpServer.close(() => resolve());
+        setTimeout(() => resolve(), 3e3).unref();
+      });
+    }
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   cacheClaudePath,
   parseCommandVOutput,
   resolveClaudeCli,
   startSnaServer,
+  startSnaServerInProcess,
   validateClaudePath
 });