@sna-sdk/core 0.2.3 → 0.4.0

package/dist/server/api-types.d.ts

@@ -25,6 +25,12 @@ interface ApiResponses {
     "agent.send": {
         status: "sent";
     };
+    "agent.resume": {
+        status: "resumed";
+        provider: string;
+        sessionId: string;
+        historyCount: number;
+    };
     "agent.restart": {
         status: "restarted";
         provider: string;
@@ -33,13 +39,29 @@ interface ApiResponses {
     "agent.interrupt": {
         status: "interrupted" | "no_session";
     };
+    "agent.set-model": {
+        status: "updated" | "no_session";
+        model: string;
+    };
+    "agent.set-permission-mode": {
+        status: "updated" | "no_session";
+        permissionMode: string;
+    };
     "agent.kill": {
         status: "killed" | "no_session";
     };
     "agent.status": {
         alive: boolean;
+        agentStatus: "idle" | "busy" | "disconnected";
         sessionId: string | null;
+        ccSessionId: string | null;
         eventCount: number;
+        config: {
+            provider: string;
+            model: string;
+            permissionMode: string;
+            extraArgs?: string[];
+        } | null;
     };
     "agent.run-once": {
         result: string;

package/dist/server/history-builder.d.ts

@@ -0,0 +1,16 @@
+import { HistoryMessage } from '../core/providers/types.js';
+
+/**
+ * Build HistoryMessage[] from chat_messages DB records.
+ *
+ * Filters to user/assistant roles, ensures alternation,
+ * and merges consecutive same-role messages.
+ */
+
+/**
+ * Load conversation history from DB for a session.
+ * Returns alternating user↔assistant messages ready for JSONL injection.
+ */
+declare function buildHistoryFromDb(sessionId: string): HistoryMessage[];
+
+export { buildHistoryFromDb };

package/dist/server/history-builder.js

@@ -0,0 +1,25 @@
+import { getDb } from "../db/schema.js";
+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;
+}
+export {
+  buildHistoryFromDb
+};

package/dist/server/image-store.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Image storage — saves base64 images to disk and serves them.
+ *
+ * Storage path: data/images/{sessionId}/{hash}.{ext}
+ * Retrieve via: GET /chat/images/:sessionId/:filename
+ */
+interface SavedImage {
+    filename: string;
+    path: string;
+}
+/**
+ * Save base64 images to disk. Returns filenames for meta storage.
+ */
+declare function saveImages(sessionId: string, images: Array<{
+    base64: string;
+    mimeType: string;
+}>): string[];
+/**
+ * Resolve an image file path. Returns null if not found.
+ */
+declare function resolveImagePath(sessionId: string, filename: string): string | null;
+
+export { type SavedImage, resolveImagePath, saveImages };

package/dist/server/image-store.js

@@ -0,0 +1,34 @@
+import fs from "fs";
+import path from "path";
+import { createHash } from "crypto";
+const IMAGE_DIR = path.join(process.cwd(), "data/images");
+const 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 = path.join(IMAGE_DIR, sessionId);
+  fs.mkdirSync(dir, { recursive: true });
+  return images.map((img) => {
+    const ext = MIME_TO_EXT[img.mimeType] ?? "bin";
+    const hash = createHash("sha256").update(img.base64).digest("hex").slice(0, 12);
+    const filename = `${hash}.${ext}`;
+    const filePath = path.join(dir, filename);
+    if (!fs.existsSync(filePath)) {
+      fs.writeFileSync(filePath, Buffer.from(img.base64, "base64"));
+    }
+    return filename;
+  });
+}
+function resolveImagePath(sessionId, filename) {
+  if (filename.includes("..") || filename.includes("/")) return null;
+  const filePath = path.join(IMAGE_DIR, sessionId, filename);
+  return fs.existsSync(filePath) ? filePath : null;
+}
+export {
+  resolveImagePath,
+  saveImages
+};

package/dist/server/index.d.ts

@@ -1,13 +1,14 @@
 import * as hono_types from 'hono/types';
 import { Hono } from 'hono';
 import { SessionManager } from './session-manager.js';
-export { Session, SessionInfo, SessionLifecycleEvent, SessionLifecycleState, SessionManagerOptions, StartConfig } from './session-manager.js';
+export { AgentStatus, Session, SessionConfigChangedEvent, SessionInfo, SessionLifecycleEvent, SessionLifecycleState, SessionManagerOptions, StartConfig } from './session-manager.js';
 export { eventsRoute } from './routes/events.js';
 export { createEmitRoute, emitRoute } from './routes/emit.js';
 export { createRunRoute } from './routes/run.js';
 export { createAgentRoutes } from './routes/agent.js';
 export { createChatRoutes } from './routes/chat.js';
 export { attachWebSocket } from './ws.js';
+export { buildHistoryFromDb } from './history-builder.js';
 import '../core/providers/types.js';
 import 'hono/utils/http-status';
 import 'ws';

package/dist/server/index.js

@@ -27,6 +27,7 @@ import { createAgentRoutes as createAgentRoutes2 } from "./routes/agent.js";
 import { createChatRoutes as createChatRoutes2 } from "./routes/chat.js";
 import { SessionManager as SessionManager2 } from "./session-manager.js";
 import { attachWebSocket } from "./ws.js";
+import { buildHistoryFromDb } from "./history-builder.js";
 function snaPortRoute(c) {
   const portFile = _path.join(process.cwd(), ".sna/sna-api.port");
   try {
@@ -39,6 +40,7 @@ function snaPortRoute(c) {
 export {
   SessionManager2 as SessionManager,
   attachWebSocket,
+  buildHistoryFromDb,
   createAgentRoutes2 as createAgentRoutes,
   createChatRoutes2 as createChatRoutes,
   createEmitRoute2 as createEmitRoute,

package/dist/server/routes/agent.js

@@ -5,7 +5,9 @@ import {
 } from "../../core/providers/index.js";
 import { logger } from "../../lib/logger.js";
 import { getDb } from "../../db/schema.js";
+import { buildHistoryFromDb } from "../history-builder.js";
 import { httpJson } from "../api-types.js";
+import { saveImages } from "../image-store.js";
 function getSessionId(c) {
   return c.req.query("session") ?? "default";
 }
@@ -28,7 +30,7 @@ async function runOnce(sessionManager, opts) {
     model: opts.model ?? "claude-sonnet-4-6",
     permissionMode: opts.permissionMode ?? "bypassPermissions",
     env: { SNA_SESSION_ID: sessionId },
-    extraArgs: extraArgs.length > 0 ? extraArgs : void 0
+    extraArgs
   });
   sessionManager.setProcess(sessionId, proc);
   try {
@@ -150,6 +152,7 @@ function createAgentRoutes(sessionManager) {
         model,
         permissionMode,
         env: { SNA_SESSION_ID: sessionId },
+        history: body.history,
         extraArgs
       });
       sessionManager.setProcess(sessionId, proc);
@@ -176,20 +179,38 @@ function createAgentRoutes(sessionManager) {
       );
     }
     const body = await c.req.json().catch(() => ({}));
-    if (!body.message) {
+    if (!body.message && !body.images?.length) {
       logger.err("err", `POST /send?session=${sessionId} \u2192 empty message`);
-      return c.json({ status: "error", message: "message is required" }, 400);
+      return c.json({ status: "error", message: "message or images required" }, 400);
+    }
+    const textContent = body.message ?? "(image)";
+    let meta = body.meta ? { ...body.meta } : {};
+    if (body.images?.length) {
+      const filenames = saveImages(sessionId, body.images);
+      meta.images = filenames;
     }
     try {
       const db = getDb();
       db.prepare(`INSERT OR IGNORE INTO chat_sessions (id, label, type) VALUES (?, ?, 'main')`).run(sessionId, session.label ?? sessionId);
-      db.prepare(`INSERT INTO chat_messages (session_id, role, content, meta) VALUES (?, 'user', ?, ?)`).run(sessionId, body.message, body.meta ? JSON.stringify(body.meta) : null);
+      db.prepare(`INSERT INTO chat_messages (session_id, role, content, meta) VALUES (?, 'user', ?, ?)`).run(sessionId, textContent, Object.keys(meta).length > 0 ? JSON.stringify(meta) : null);
     } catch {
     }
-    session.state = "processing";
+    sessionManager.updateSessionState(sessionId, "processing");
     sessionManager.touch(sessionId);
-    logger.log("route", `POST /send?session=${sessionId} \u2192 "${body.message.slice(0, 80)}"`);
-    session.process.send(body.message);
+    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) => {
@@ -229,14 +250,16 @@ function createAgentRoutes(sessionManager) {
     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,
           env: { SNA_SESSION_ID: sessionId },
-          extraArgs: [...cfg.extraArgs ?? [], "--resume"]
+          extraArgs: [...cfg.extraArgs ?? [], ...resumeArgs]
         });
       });
       logger.log("route", `POST /restart?session=${sessionId} \u2192 restarted`);
@@ -250,11 +273,65 @@ function createAgentRoutes(sessionManager) {
       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 ?? "claude-code";
+    const model = body.model ?? session.lastStartConfig?.model ?? "claude-sonnet-4-6";
+    const permissionMode = body.permissionMode ?? session.lastStartConfig?.permissionMode ?? "acceptEdits";
+    const extraArgs = body.extraArgs ?? session.lastStartConfig?.extraArgs;
+    const provider = getProvider(providerName);
+    try {
+      const proc = provider.spawn({
+        cwd: session.cwd,
+        prompt: body.prompt,
+        model,
+        permissionMode,
+        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, 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);
@@ -263,10 +340,14 @@ function createAgentRoutes(sessionManager) {
   app.get("/status", (c) => {
     const sessionId = getSessionId(c);
     const session = sessionManager.getSession(sessionId);
+    const alive = session?.process?.alive ?? false;
     return httpJson(c, "agent.status", {
-      alive: session?.process?.alive ?? false,
+      alive,
+      agentStatus: !alive ? "disconnected" : session?.state === "processing" ? "busy" : "idle",
       sessionId: session?.process?.sessionId ?? null,
-      eventCount: session?.eventCounter ?? 0
+      ccSessionId: session?.ccSessionId ?? null,
+      eventCount: session?.eventCounter ?? 0,
+      config: session?.lastStartConfig ?? null
     });
   });
   app.post("/permission-request", async (c) => {

package/dist/server/routes/chat.js

@@ -1,6 +1,8 @@
 import { Hono } from "hono";
+import fs from "fs";
 import { getDb } from "../../db/schema.js";
 import { httpJson } from "../api-types.js";
+import { resolveImagePath } from "../image-store.js";
 function createChatRoutes() {
   const app = new Hono();
   app.get("/sessions", (c) => {
@@ -89,6 +91,26 @@ function createChatRoutes() {
       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 = fs.readFileSync(filePath);
+    return new Response(data, { headers: { "Content-Type": contentType, "Cache-Control": "public, max-age=31536000, immutable" } });
+  });
   return app;
 }
 export {

package/dist/server/session-manager.d.ts

@@ -24,16 +24,22 @@ interface Session {
     meta: Record<string, unknown> | null;
     state: SessionState;
     lastStartConfig: StartConfig | null;
+    /** Claude Code's own session ID (from system.init event). Used for --resume. */
+    ccSessionId: string | null;
     createdAt: number;
     lastActivityAt: number;
 }
+type AgentStatus = "idle" | "busy" | "disconnected";
 interface SessionInfo {
     id: string;
     label: string;
     alive: boolean;
     state: SessionState;
+    agentStatus: AgentStatus;
     cwd: string;
     meta: Record<string, unknown> | null;
+    config: StartConfig | null;
+    ccSessionId: string | null;
     eventCount: number;
     createdAt: number;
     lastActivityAt: number;
@@ -41,12 +47,16 @@ interface SessionInfo {
 interface SessionManagerOptions {
     maxSessions?: number;
 }
-type SessionLifecycleState = "started" | "killed" | "exited" | "crashed" | "restarted";
+type SessionLifecycleState = "started" | "resumed" | "killed" | "exited" | "crashed" | "restarted";
 interface SessionLifecycleEvent {
     session: string;
     state: SessionLifecycleState;
     code?: number | null;
 }
+interface SessionConfigChangedEvent {
+    session: string;
+    config: StartConfig;
+}
 declare class SessionManager {
     private sessions;
     private maxSessions;
@@ -55,6 +65,8 @@ declare class SessionManager {
     private skillEventListeners;
     private permissionRequestListeners;
     private lifecycleListeners;
+    private configChangedListeners;
+    private stateChangedListeners;
     constructor(options?: SessionManagerOptions);
     /** Restore session metadata from DB (cwd, label, meta). Process state is not restored. */
     private restoreFromDb;
@@ -75,7 +87,7 @@ declare class SessionManager {
         cwd?: string;
     }): Session;
     /** Set the agent process for a session. Subscribes to events. */
-    setProcess(sessionId: string, proc: AgentProcess): void;
+    setProcess(sessionId: string, proc: AgentProcess, lifecycleState?: SessionLifecycleState): void;
     /** Subscribe to real-time events for a session. Returns unsubscribe function. */
     onSessionEvent(sessionId: string, cb: (cursor: number, event: AgentEvent) => void): () => void;
     /** Subscribe to skill events broadcast. Returns unsubscribe function. */
@@ -87,6 +99,17 @@ declare class SessionManager {
     /** Subscribe to session lifecycle events (started/killed/exited/crashed). Returns unsubscribe function. */
     onSessionLifecycle(cb: (event: SessionLifecycleEvent) => void): () => void;
     private emitLifecycle;
+    /** Subscribe to session config changes. Returns unsubscribe function. */
+    onConfigChanged(cb: (event: SessionConfigChangedEvent) => void): () => void;
+    private emitConfigChanged;
+    onStateChanged(cb: (event: {
+        session: string;
+        agentStatus: AgentStatus;
+        state: SessionState;
+    }) => void): () => void;
+    /** Update session state and push agentStatus change to subscribers. */
+    updateSessionState(sessionId: string, newState: SessionState): void;
+    private setSessionState;
     /** Create a pending permission request. Returns a promise that resolves when approved/denied. */
     createPendingPermission(sessionId: string, request: Record<string, unknown>): Promise<boolean>;
     /** Resolve a pending permission request. Returns false if no pending request. */
@@ -109,8 +132,12 @@ declare class SessionManager {
     restartSession(id: string, overrides: Partial<StartConfig>, spawnFn: (config: StartConfig) => AgentProcess): {
         config: StartConfig;
     };
-    /** Interrupt the current turn (SIGINT). Process stays alive, returns to waiting. */
+    /** Interrupt the current turn. Process stays alive, returns to waiting. */
     interruptSession(id: string): boolean;
+    /** Change model. Sends control message if alive, always persists to config. */
+    setSessionModel(id: string, model: string): boolean;
+    /** Change permission mode. Sends control message if alive, always persists to config. */
+    setSessionPermissionMode(id: string, mode: string): boolean;
     /** Kill the agent process in a session (session stays, can be restarted). */
     killSession(id: string): boolean;
     /** Remove a session entirely. Cannot remove "default". */
@@ -126,4 +153,4 @@ declare class SessionManager {
     get size(): number;
 }
 
-export { type Session, type SessionInfo, type SessionLifecycleEvent, type SessionLifecycleState, SessionManager, type SessionManagerOptions, type SessionState, type StartConfig };
+export { type AgentStatus, type Session, type SessionConfigChangedEvent, type SessionInfo, type SessionLifecycleEvent, type SessionLifecycleState, SessionManager, type SessionManagerOptions, type SessionState, type StartConfig };

package/dist/server/session-manager.js

@@ -10,6 +10,8 @@ class SessionManager {
     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.maxSessions = options.maxSessions ?? DEFAULT_MAX_SESSIONS;
     this.restoreFromDb();
   }
@@ -32,6 +34,7 @@ class SessionManager {
           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()
         });
@@ -44,7 +47,13 @@ class SessionManager {
     try {
       const db = getDb();
       db.prepare(
-        `INSERT OR REPLACE INTO chat_sessions (id, label, type, meta, cwd, last_start_config) VALUES (?, ?, 'main', ?, ?, ?)`
+        `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,
@@ -90,6 +99,7 @@ class SessionManager {
       meta: opts.meta ?? null,
       state: "idle",
       lastStartConfig: null,
+      ccSessionId: null,
       createdAt: Date.now(),
       lastActivityAt: Date.now()
     };
@@ -114,20 +124,24 @@ class SessionManager {
     return this.createSession({ id, ...opts });
   }
   /** Set the agent process for a session. Subscribes to events. */
-  setProcess(sessionId, proc) {
+  setProcess(sessionId, proc, lifecycleState) {
     const session = this.sessions.get(sessionId);
     if (!session) throw new Error(`Session "${sessionId}" not found`);
     session.process = proc;
-    session.state = "processing";
+    this.setSessionState(sessionId, session, "processing");
     session.lastActivityAt = Date.now();
     proc.on("event", (e) => {
+      if (e.type === "init" && e.data?.sessionId && !session.ccSessionId) {
+        session.ccSessionId = e.data.sessionId;
+        this.persistSession(session);
+      }
       session.eventBuffer.push(e);
       session.eventCounter++;
       if (session.eventBuffer.length > MAX_EVENT_BUFFER) {
         session.eventBuffer.splice(0, session.eventBuffer.length - MAX_EVENT_BUFFER);
       }
-      if (e.type === "complete" || e.type === "error") {
-        session.state = "waiting";
+      if (e.type === "complete" || e.type === "error" || e.type === "interrupted") {
+        this.setSessionState(sessionId, session, "waiting");
       }
       this.persistEvent(sessionId, e);
       const listeners = this.eventListeners.get(sessionId);
@@ -136,14 +150,14 @@ class SessionManager {
       }
     });
     proc.on("exit", (code) => {
-      session.state = "idle";
+      this.setSessionState(sessionId, session, "idle");
       this.emitLifecycle({ session: sessionId, state: code != null ? "exited" : "crashed", code });
     });
     proc.on("error", () => {
-      session.state = "idle";
+      this.setSessionState(sessionId, session, "idle");
       this.emitLifecycle({ session: sessionId, state: "crashed" });
     });
-    this.emitLifecycle({ session: sessionId, state: "started" });
+    this.emitLifecycle({ session: sessionId, state: lifecycleState ?? "started" });
   }
   // ── Event pub/sub (for WebSocket) ─────────────────────────────
   /** Subscribe to real-time events for a session. Returns unsubscribe function. */
@@ -184,11 +198,38 @@ class SessionManager {
   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 });
+  }
+  // ── Agent status change pub/sub ────────────────────────────────
+  onStateChanged(cb) {
+    this.stateChangedListeners.add(cb);
+    return () => this.stateChangedListeners.delete(cb);
+  }
+  /** Update session state and push agentStatus change to subscribers. */
+  updateSessionState(sessionId, newState) {
+    const session = this.sessions.get(sessionId);
+    if (session) this.setSessionState(sessionId, session, newState);
+  }
+  setSessionState(sessionId, session, newState) {
+    const oldState = session.state;
+    session.state = newState;
+    const newStatus = !session.process?.alive ? "disconnected" : newState === "processing" ? "busy" : "idle";
+    if (oldState !== newState) {
+      for (const cb of this.stateChangedListeners) cb({ session: sessionId, agentStatus: newStatus, state: newState });
+    }
+  }
   // ── Permission management ─────────────────────────────────────
   /** Create a pending permission request. Returns a promise that resolves when approved/denied. */
   createPendingPermission(sessionId, request) {
     const session = this.sessions.get(sessionId);
-    if (session) session.state = "permission";
+    if (session) this.setSessionState(sessionId, session, "permission");
     return new Promise((resolve) => {
       const createdAt = Date.now();
       this.pendingPermissions.set(sessionId, { resolve, request, createdAt });
@@ -208,7 +249,7 @@ class SessionManager {
     pending.resolve(approved);
     this.pendingPermissions.delete(sessionId);
     const session = this.sessions.get(sessionId);
-    if (session) session.state = "processing";
+    if (session) this.setSessionState(sessionId, session, "processing");
     return true;
   }
   /** Get a pending permission for a specific session. */
@@ -252,14 +293,43 @@ class SessionManager {
     session.lastStartConfig = config;
     this.persistSession(session);
     this.emitLifecycle({ session: id, state: "restarted" });
+    this.emitConfigChanged(id, config);
     return { config };
   }
-  /** Interrupt the current turn (SIGINT). Process stays alive, returns to waiting. */
+  /** Interrupt the current turn. Process stays alive, returns to waiting. */
   interruptSession(id) {
     const session = this.sessions.get(id);
     if (!session?.process?.alive) return false;
     session.process.interrupt();
-    session.state = "waiting";
+    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: "claude-code", model, permissionMode: "acceptEdits" };
+    }
+    this.persistSession(session);
+    this.emitConfigChanged(id, session.lastStartConfig);
+    return true;
+  }
+  /** Change permission mode. Sends control message if alive, always persists to config. */
+  setSessionPermissionMode(id, mode) {
+    const session = this.sessions.get(id);
+    if (!session) return false;
+    if (session.process?.alive) session.process.setPermissionMode(mode);
+    if (session.lastStartConfig) {
+      session.lastStartConfig.permissionMode = mode;
+    } else {
+      session.lastStartConfig = { provider: "claude-code", model: "claude-sonnet-4-6", permissionMode: mode };
+    }
+    this.persistSession(session);
+    this.emitConfigChanged(id, session.lastStartConfig);
     return true;
   }
   /** Kill the agent process in a session (session stays, can be restarted). */
@@ -288,8 +358,11 @@ class SessionManager {
       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,
       createdAt: s.createdAt,
       lastActivityAt: s.lastActivityAt