@sna-sdk/core 0.1.1 → 0.3.0

package/dist/server/routes/chat.js

@@ -1,18 +1,21 @@
 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) => {
     try {
       const db = getDb();
       const rows = db.prepare(
-        `SELECT id, label, type, meta, created_at FROM chat_sessions ORDER BY created_at DESC`
+        `SELECT id, label, type, meta, cwd, created_at FROM chat_sessions ORDER BY created_at DESC`
       ).all();
       const sessions = rows.map((r) => ({
         ...r,
         meta: r.meta ? JSON.parse(r.meta) : null
       }));
-      return c.json({ sessions });
+      return httpJson(c, "chat.sessions.list", { sessions });
     } catch (e) {
       return c.json({ status: "error", message: e.message, stack: e.stack }, 500);
     }
@@ -25,7 +28,7 @@ function createChatRoutes() {
       db.prepare(
         `INSERT OR IGNORE INTO chat_sessions (id, label, type, meta) VALUES (?, ?, ?, ?)`
       ).run(id, body.label ?? id, body.type ?? "background", body.meta ? JSON.stringify(body.meta) : null);
-      return c.json({ status: "created", id, meta: body.meta ?? null });
+      return httpJson(c, "chat.sessions.create", { status: "created", id, meta: body.meta ?? null });
     } catch (e) {
       return c.json({ status: "error", message: e.message }, 500);
     }
@@ -38,7 +41,7 @@ function createChatRoutes() {
     try {
       const db = getDb();
       db.prepare(`DELETE FROM chat_sessions WHERE id = ?`).run(id);
-      return c.json({ status: "deleted" });
+      return httpJson(c, "chat.sessions.remove", { status: "deleted" });
     } catch (e) {
       return c.json({ status: "error", message: e.message }, 500);
     }
@@ -50,7 +53,7 @@ function createChatRoutes() {
       const db = getDb();
       const query = sinceParam ? db.prepare(`SELECT * FROM chat_messages WHERE session_id = ? AND id > ? ORDER BY id ASC`) : db.prepare(`SELECT * FROM chat_messages WHERE session_id = ? ORDER BY id ASC`);
       const messages = sinceParam ? query.all(id, parseInt(sinceParam, 10)) : query.all(id);
-      return c.json({ messages });
+      return httpJson(c, "chat.messages.list", { messages });
     } catch (e) {
       return c.json({ status: "error", message: e.message, stack: e.stack }, 500);
     }
@@ -73,7 +76,7 @@ function createChatRoutes() {
         body.skill_name ?? null,
         body.meta ? JSON.stringify(body.meta) : null
       );
-      return c.json({ status: "created", id: result.lastInsertRowid });
+      return httpJson(c, "chat.messages.create", { status: "created", id: Number(result.lastInsertRowid) });
     } catch (e) {
       return c.json({ status: "error", message: e.message }, 500);
     }
@@ -83,11 +86,31 @@ function createChatRoutes() {
     try {
       const db = getDb();
       db.prepare(`DELETE FROM chat_messages WHERE session_id = ?`).run(id);
-      return c.json({ status: "cleared" });
+      return httpJson(c, "chat.messages.clear", { status: "cleared" });
     } catch (e) {
       return c.json({ status: "error", message: e.message }, 500);
     }
   });
+  app.get("/images/:sessionId/:filename", (c) => {
+    const sessionId = c.req.param("sessionId");
+    const filename = c.req.param("filename");
+    const filePath = resolveImagePath(sessionId, filename);
+    if (!filePath) {
+      return c.json({ status: "error", message: "Image not found" }, 404);
+    }
+    const ext = filename.split(".").pop()?.toLowerCase();
+    const mimeMap = {
+      png: "image/png",
+      jpg: "image/jpeg",
+      jpeg: "image/jpeg",
+      gif: "image/gif",
+      webp: "image/webp",
+      svg: "image/svg+xml"
+    };
+    const contentType = mimeMap[ext ?? ""] ?? "application/octet-stream";
+    const data = fs.readFileSync(filePath);
+    return new Response(data, { headers: { "Content-Type": contentType, "Cache-Control": "public, max-age=31536000, immutable" } });
+  });
   return app;
 }
 export {

package/dist/server/routes/emit.d.ts

@@ -1,11 +1,21 @@
 import * as hono_utils_http_status from 'hono/utils/http-status';
 import * as hono from 'hono';
 import { Context } from 'hono';
+import { SessionManager } from '../session-manager.js';
+import '../../core/providers/types.js';
 
+/**
+ * Create an emit route handler that broadcasts to WS subscribers.
+ */
+declare function createEmitRoute(sessionManager: SessionManager): (c: Context) => Promise<Response & hono.TypedResponse<any, any, "json">>;
+/**
+ * Legacy plain handler (no broadcast). Kept for backward compatibility
+ * when consumers import emitRoute directly without SessionManager.
+ */
 declare function emitRoute(c: Context): Promise<(Response & hono.TypedResponse<{
     error: string;
 }, 400, "json">) | (Response & hono.TypedResponse<{
     id: number;
 }, hono_utils_http_status.ContentfulStatusCode, "json">)>;
 
-export { emitRoute };
+export { createEmitRoute, emitRoute };

package/dist/server/routes/emit.js

@@ -1,4 +1,29 @@
 import { getDb } from "../../db/schema.js";
+import { httpJson } from "../api-types.js";
+function createEmitRoute(sessionManager) {
+  return async (c) => {
+    const body = await c.req.json();
+    const { skill, type, message, data, session_id } = body;
+    if (!skill || !type || !message) {
+      return c.json({ error: "missing fields" }, 400);
+    }
+    const db = getDb();
+    const result = db.prepare(
+      `INSERT INTO skill_events (session_id, skill, type, message, data) VALUES (?, ?, ?, ?, ?)`
+    ).run(session_id ?? null, skill, type, message, data ?? null);
+    const id = Number(result.lastInsertRowid);
+    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 });
+  };
+}
 async function emitRoute(c) {
   const { skill, type, message, data } = await c.req.json();
   if (!skill || !type || !message) {
@@ -11,5 +36,6 @@ async function emitRoute(c) {
   return c.json({ id: result.lastInsertRowid });
 }
 export {
+  createEmitRoute,
   emitRoute
 };

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

@@ -8,6 +8,12 @@ import { AgentProcess, AgentEvent } from '../core/providers/types.js';
  */
 
 type SessionState = "idle" | "processing" | "waiting" | "permission";
+interface StartConfig {
+    provider: string;
+    model: string;
+    permissionMode: string;
+    extraArgs?: string[];
+}
 interface Session {
     id: string;
     process: AgentProcess | null;
@@ -17,6 +23,9 @@ interface Session {
     cwd: string;
     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;
 }
@@ -27,6 +36,8 @@ interface SessionInfo {
     state: SessionState;
     cwd: string;
     meta: Record<string, unknown> | null;
+    config: StartConfig | null;
+    ccSessionId: string | null;
     eventCount: number;
     createdAt: number;
     lastActivityAt: number;
@@ -34,10 +45,30 @@ interface SessionInfo {
 interface SessionManagerOptions {
     maxSessions?: number;
 }
+type SessionLifecycleState = "started" | "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;
+    private eventListeners;
+    private pendingPermissions;
+    private skillEventListeners;
+    private permissionRequestListeners;
+    private lifecycleListeners;
+    private configChangedListeners;
     constructor(options?: SessionManagerOptions);
+    /** Restore session metadata from DB (cwd, label, meta). Process state is not restored. */
+    private restoreFromDb;
+    /** Persist session metadata to DB. */
+    private persistSession;
     /** Create a new session. Throws if max sessions reached. */
     createSession(opts?: {
         id?: string;
@@ -54,6 +85,48 @@ declare class SessionManager {
     }): Session;
     /** Set the agent process for a session. Subscribes to events. */
     setProcess(sessionId: string, proc: AgentProcess): 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. */
+    onSkillEvent(cb: (event: Record<string, unknown>) => void): () => void;
+    /** Broadcast a skill event to all subscribers (called after DB insert). */
+    broadcastSkillEvent(event: Record<string, unknown>): void;
+    /** Subscribe to permission request notifications. Returns unsubscribe function. */
+    onPermissionRequest(cb: (sessionId: string, request: Record<string, unknown>, createdAt: number) => void): () => void;
+    /** 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;
+    /** 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. */
+    resolvePendingPermission(sessionId: string, approved: boolean): boolean;
+    /** Get a pending permission for a specific session. */
+    getPendingPermission(sessionId: string): {
+        request: Record<string, unknown>;
+        createdAt: number;
+    } | null;
+    /** Get all pending permissions across sessions. */
+    getAllPendingPermissions(): Array<{
+        sessionId: string;
+        request: Record<string, unknown>;
+        createdAt: number;
+    }>;
+    /** 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: string, config: StartConfig): void;
+    /** Restart session: kill → re-spawn with merged config + --resume. */
+    restartSession(id: string, overrides: Partial<StartConfig>, spawnFn: (config: StartConfig) => AgentProcess): {
+        config: StartConfig;
+    };
+    /** 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". */
@@ -69,4 +142,4 @@ declare class SessionManager {
     get size(): number;
 }
 
-export { type Session, type SessionInfo, SessionManager, type SessionManagerOptions, type SessionState };
+export { type Session, type SessionConfigChangedEvent, type SessionInfo, type SessionLifecycleEvent, type SessionLifecycleState, SessionManager, type SessionManagerOptions, type SessionState, type StartConfig };

package/dist/server/session-manager.js

@@ -1,16 +1,88 @@
 import { getDb } from "../db/schema.js";
 const DEFAULT_MAX_SESSIONS = 5;
 const MAX_EVENT_BUFFER = 500;
+const PERMISSION_TIMEOUT_MS = 3e5;
 class SessionManager {
   constructor(options = {}) {
     this.sessions = /* @__PURE__ */ new Map();
+    this.eventListeners = /* @__PURE__ */ new Map();
+    this.pendingPermissions = /* @__PURE__ */ new Map();
+    this.skillEventListeners = /* @__PURE__ */ new Set();
+    this.permissionRequestListeners = /* @__PURE__ */ new Set();
+    this.lifecycleListeners = /* @__PURE__ */ new Set();
+    this.configChangedListeners = /* @__PURE__ */ new Set();
     this.maxSessions = options.maxSessions ?? DEFAULT_MAX_SESSIONS;
+    this.restoreFromDb();
+  }
+  /** Restore session metadata from DB (cwd, label, meta). Process state is not restored. */
+  restoreFromDb() {
+    try {
+      const db = getDb();
+      const rows = db.prepare(
+        `SELECT id, label, meta, cwd, last_start_config, created_at FROM chat_sessions`
+      ).all();
+      for (const row of rows) {
+        if (this.sessions.has(row.id)) continue;
+        this.sessions.set(row.id, {
+          id: row.id,
+          process: null,
+          eventBuffer: [],
+          eventCounter: 0,
+          label: row.label,
+          cwd: row.cwd ?? process.cwd(),
+          meta: row.meta ? JSON.parse(row.meta) : null,
+          state: "idle",
+          lastStartConfig: row.last_start_config ? JSON.parse(row.last_start_config) : null,
+          ccSessionId: null,
+          createdAt: new Date(row.created_at).getTime() || Date.now(),
+          lastActivityAt: Date.now()
+        });
+      }
+    } catch {
+    }
+  }
+  /** Persist session metadata to DB. */
+  persistSession(session) {
+    try {
+      const db = getDb();
+      db.prepare(
+        `INSERT INTO chat_sessions (id, label, type, meta, cwd, last_start_config)
+         VALUES (?, ?, 'main', ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET
+           label = excluded.label,
+           meta = excluded.meta,
+           cwd = excluded.cwd,
+           last_start_config = excluded.last_start_config`
+      ).run(
+        session.id,
+        session.label,
+        session.meta ? JSON.stringify(session.meta) : null,
+        session.cwd,
+        session.lastStartConfig ? JSON.stringify(session.lastStartConfig) : null
+      );
+    } catch {
+    }
   }
   /** Create a new session. Throws if max sessions reached. */
   createSession(opts = {}) {
     const id = opts.id ?? crypto.randomUUID().slice(0, 8);
     if (this.sessions.has(id)) {
-      return this.sessions.get(id);
+      const existing = this.sessions.get(id);
+      let changed = false;
+      if (opts.cwd && opts.cwd !== existing.cwd) {
+        existing.cwd = opts.cwd;
+        changed = true;
+      }
+      if (opts.label && opts.label !== existing.label) {
+        existing.label = opts.label;
+        changed = true;
+      }
+      if (opts.meta !== void 0 && opts.meta !== existing.meta) {
+        existing.meta = opts.meta ?? null;
+        changed = true;
+      }
+      if (changed) this.persistSession(existing);
+      return existing;
     }
     const aliveCount = Array.from(this.sessions.values()).filter((s) => s.process?.alive).length;
     if (aliveCount >= this.maxSessions) {
@@ -25,10 +97,13 @@ class SessionManager {
       cwd: opts.cwd ?? process.cwd(),
       meta: opts.meta ?? null,
       state: "idle",
+      lastStartConfig: null,
+      ccSessionId: null,
       createdAt: Date.now(),
       lastActivityAt: Date.now()
     };
     this.sessions.set(id, session);
+    this.persistSession(session);
     return session;
   }
   /** Get a session by ID. */
@@ -38,7 +113,13 @@ class SessionManager {
   /** Get or create a session (used for "default" backward compat). */
   getOrCreateSession(id, opts) {
     const existing = this.sessions.get(id);
-    if (existing) return existing;
+    if (existing) {
+      if (opts?.cwd && opts.cwd !== existing.cwd) {
+        existing.cwd = opts.cwd;
+        this.persistSession(existing);
+      }
+      return existing;
+    }
     return this.createSession({ id, ...opts });
   }
   /** Set the agent process for a session. Subscribes to events. */
@@ -49,22 +130,195 @@ class SessionManager {
     session.state = "processing";
     session.lastActivityAt = Date.now();
     proc.on("event", (e) => {
+      if (e.type === "init" && e.data?.sessionId && !session.ccSessionId) {
+        session.ccSessionId = e.data.sessionId;
+        this.persistSession(session);
+      }
       session.eventBuffer.push(e);
       session.eventCounter++;
       if (session.eventBuffer.length > MAX_EVENT_BUFFER) {
         session.eventBuffer.splice(0, session.eventBuffer.length - MAX_EVENT_BUFFER);
       }
-      if (e.type === "complete" || e.type === "error") {
+      if (e.type === "complete" || e.type === "error" || e.type === "interrupted") {
         session.state = "waiting";
       }
       this.persistEvent(sessionId, e);
+      const listeners = this.eventListeners.get(sessionId);
+      if (listeners) {
+        for (const cb of listeners) cb(session.eventCounter, e);
+      }
+    });
+    proc.on("exit", (code) => {
+      session.state = "idle";
+      this.emitLifecycle({ session: sessionId, state: code != null ? "exited" : "crashed", code });
+    });
+    proc.on("error", () => {
+      session.state = "idle";
+      this.emitLifecycle({ session: sessionId, state: "crashed" });
     });
+    this.emitLifecycle({ session: sessionId, state: "started" });
+  }
+  // ── Event pub/sub (for WebSocket) ─────────────────────────────
+  /** Subscribe to real-time events for a session. Returns unsubscribe function. */
+  onSessionEvent(sessionId, cb) {
+    let set = this.eventListeners.get(sessionId);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.eventListeners.set(sessionId, set);
+    }
+    set.add(cb);
+    return () => {
+      set.delete(cb);
+      if (set.size === 0) this.eventListeners.delete(sessionId);
+    };
+  }
+  // ── Skill event pub/sub ────────────────────────────────────────
+  /** Subscribe to skill events broadcast. Returns unsubscribe function. */
+  onSkillEvent(cb) {
+    this.skillEventListeners.add(cb);
+    return () => this.skillEventListeners.delete(cb);
+  }
+  /** Broadcast a skill event to all subscribers (called after DB insert). */
+  broadcastSkillEvent(event) {
+    for (const cb of this.skillEventListeners) cb(event);
+  }
+  // ── Permission pub/sub ────────────────────────────────────────
+  /** Subscribe to permission request notifications. Returns unsubscribe function. */
+  onPermissionRequest(cb) {
+    this.permissionRequestListeners.add(cb);
+    return () => this.permissionRequestListeners.delete(cb);
+  }
+  // ── Session lifecycle pub/sub ──────────────────────────────────
+  /** Subscribe to session lifecycle events (started/killed/exited/crashed). Returns unsubscribe function. */
+  onSessionLifecycle(cb) {
+    this.lifecycleListeners.add(cb);
+    return () => this.lifecycleListeners.delete(cb);
+  }
+  emitLifecycle(event) {
+    for (const cb of this.lifecycleListeners) cb(event);
+  }
+  // ── Config changed pub/sub ────────────────────────────────────
+  /** Subscribe to session config changes. Returns unsubscribe function. */
+  onConfigChanged(cb) {
+    this.configChangedListeners.add(cb);
+    return () => this.configChangedListeners.delete(cb);
+  }
+  emitConfigChanged(sessionId, config) {
+    for (const cb of this.configChangedListeners) cb({ session: sessionId, config });
+  }
+  // ── Permission management ─────────────────────────────────────
+  /** Create a pending permission request. Returns a promise that resolves when approved/denied. */
+  createPendingPermission(sessionId, request) {
+    const session = this.sessions.get(sessionId);
+    if (session) session.state = "permission";
+    return new Promise((resolve) => {
+      const createdAt = Date.now();
+      this.pendingPermissions.set(sessionId, { resolve, request, createdAt });
+      for (const cb of this.permissionRequestListeners) cb(sessionId, request, createdAt);
+      setTimeout(() => {
+        if (this.pendingPermissions.has(sessionId)) {
+          this.pendingPermissions.delete(sessionId);
+          resolve(false);
+        }
+      }, PERMISSION_TIMEOUT_MS);
+    });
+  }
+  /** Resolve a pending permission request. Returns false if no pending request. */
+  resolvePendingPermission(sessionId, approved) {
+    const pending = this.pendingPermissions.get(sessionId);
+    if (!pending) return false;
+    pending.resolve(approved);
+    this.pendingPermissions.delete(sessionId);
+    const session = this.sessions.get(sessionId);
+    if (session) session.state = "processing";
+    return true;
+  }
+  /** Get a pending permission for a specific session. */
+  getPendingPermission(sessionId) {
+    const p = this.pendingPermissions.get(sessionId);
+    return p ? { request: p.request, createdAt: p.createdAt } : null;
+  }
+  /** Get all pending permissions across sessions. */
+  getAllPendingPermissions() {
+    return Array.from(this.pendingPermissions.entries()).map(([id, p]) => ({
+      sessionId: id,
+      request: p.request,
+      createdAt: p.createdAt
+    }));
+  }
+  // ── Session lifecycle ─────────────────────────────────────────
+  /** Kill the agent process in a session (session stays, can be restarted). */
+  /** Save the start config for a session (called by start handlers). */
+  saveStartConfig(id, config) {
+    const session = this.sessions.get(id);
+    if (!session) return;
+    session.lastStartConfig = config;
+    this.persistSession(session);
+  }
+  /** Restart session: kill → re-spawn with merged config + --resume. */
+  restartSession(id, overrides, spawnFn) {
+    const session = this.sessions.get(id);
+    if (!session) throw new Error(`Session "${id}" not found`);
+    const base = session.lastStartConfig;
+    if (!base) throw new Error(`Session "${id}" has no previous start config`);
+    const config = {
+      provider: overrides.provider ?? base.provider,
+      model: overrides.model ?? base.model,
+      permissionMode: overrides.permissionMode ?? base.permissionMode,
+      extraArgs: overrides.extraArgs ?? base.extraArgs
+    };
+    if (session.process?.alive) session.process.kill();
+    session.eventBuffer.length = 0;
+    const proc = spawnFn(config);
+    this.setProcess(id, proc);
+    session.lastStartConfig = config;
+    this.persistSession(session);
+    this.emitLifecycle({ session: id, state: "restarted" });
+    this.emitConfigChanged(id, config);
+    return { config };
+  }
+  /** Interrupt the current turn. Process stays alive, returns to waiting. */
+  interruptSession(id) {
+    const session = this.sessions.get(id);
+    if (!session?.process?.alive) return false;
+    session.process.interrupt();
+    session.state = "waiting";
+    return true;
+  }
+  /** Change model. Sends control message if alive, always persists to config. */
+  setSessionModel(id, model) {
+    const session = this.sessions.get(id);
+    if (!session) return false;
+    if (session.process?.alive) session.process.setModel(model);
+    if (session.lastStartConfig) {
+      session.lastStartConfig.model = model;
+    } else {
+      session.lastStartConfig = { provider: "claude-code", model, permissionMode: "acceptEdits" };
+    }
+    this.persistSession(session);
+    this.emitConfigChanged(id, session.lastStartConfig);
+    return true;
+  }
+  /** Change permission mode. Sends control message if alive, always persists to config. */
+  setSessionPermissionMode(id, mode) {
+    const session = this.sessions.get(id);
+    if (!session) return false;
+    if (session.process?.alive) session.process.setPermissionMode(mode);
+    if (session.lastStartConfig) {
+      session.lastStartConfig.permissionMode = mode;
+    } else {
+      session.lastStartConfig = { provider: "claude-code", model: "claude-sonnet-4-6", permissionMode: mode };
+    }
+    this.persistSession(session);
+    this.emitConfigChanged(id, session.lastStartConfig);
+    return true;
   }
   /** Kill the agent process in a session (session stays, can be restarted). */
   killSession(id) {
     const session = this.sessions.get(id);
     if (!session?.process?.alive) return false;
     session.process.kill();
+    this.emitLifecycle({ session: id, state: "killed" });
     return true;
   }
   /** Remove a session entirely. Cannot remove "default". */
@@ -73,6 +327,8 @@ class SessionManager {
     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;
   }
@@ -85,6 +341,8 @@ class SessionManager {
       state: s.state,
       cwd: s.cwd,
       meta: s.meta,
+      config: s.lastStartConfig,
+      ccSessionId: s.ccSessionId,
       eventCount: s.eventCounter,
       createdAt: s.createdAt,
       lastActivityAt: s.lastActivityAt