@alexjbarnes/cockpit 0.1.1 → 0.3.0

package/dist/src/server/session-manager.js

@@ -4,21 +4,41 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SessionManager = void 0;
-exports.extractTodosFromHistory = extractTodosFromHistory;
 const node_child_process_1 = require("node:child_process");
 const node_events_1 = require("node:events");
 const node_fs_1 = require("node:fs");
-const node_os_1 = require("node:os");
 const node_path_1 = __importDefault(require("node:path"));
 const uuid_1 = require("uuid");
 const models_1 = require("../lib/models");
+const paths_1 = require("../server/paths");
+const providers_1 = require("../server/providers");
 const debug_logger_1 = require("./debug-logger");
 const defaults_1 = require("./defaults");
 const event_parser_1 = require("./event-parser");
 const plans_1 = require("./plans");
+const pty_runtime_1 = require("./pty-runtime");
 const session_prefs_1 = require("./session-prefs");
+const singleton_1 = require("./singleton");
 const stream_processor_1 = require("./stream-processor");
+const todo_watcher_1 = require("./todo-watcher");
 const transcript_1 = require("./transcript");
+const transcript_watcher_1 = require("./transcript-watcher");
+function defaultRuntime() {
+    return "stream";
+}
+let resolvedClaudeBin = null;
+function getClaudeBin() {
+    if (resolvedClaudeBin)
+        return resolvedClaudeBin;
+    const cmd = process.platform === "win32" ? "where" : "which";
+    try {
+        resolvedClaudeBin = (0, node_child_process_1.execFileSync)(cmd, ["claude"], { encoding: "utf-8" }).trim().split("\n")[0];
+    }
+    catch {
+        resolvedClaudeBin = "claude";
+    }
+    return resolvedClaudeBin;
+}
 const smLog = (sessionId, msg) => {
     if (!(0, debug_logger_1.isDebugEnabled)())
         return;
@@ -32,9 +52,9 @@ class SessionManager {
         // Periodically check for sessions stuck in "running" with a dead process
         setInterval(() => {
             for (const [id, session] of this.sessions) {
-                if (session.info.status === "running" && !session.process) {
+                if (session.info.status === "running" && !session.process && !session.ptyRuntime?.isAlive) {
                     const short = id.slice(0, 8);
-                    (0, debug_logger_1.debugLog)(`[session:${short}] stale check: status=running but process=null, correcting to idle`);
+                    (0, debug_logger_1.debugLog)(`[session:${short}] stale check: status=running but no live process, correcting to idle`);
                     (0, debug_logger_1.logDiag)(id, "idle:stale-check");
                     session.info.status = "idle";
                     session.emitter.emit("status", id, "idle");
@@ -46,6 +66,8 @@ class SessionManager {
         const id = (0, uuid_1.v4)();
         const now = Date.now();
         const defaults = (0, defaults_1.getDefaults)();
+        const modelSlots = { main: defaults.modelSlots.main ?? "sonnet" };
+        const rt = options?.runtime ?? defaultRuntime();
         const info = {
             id,
             name: name || node_path_1.default.basename(cwd) || cwd,
@@ -53,7 +75,10 @@ class SessionManager {
             createdAt: now,
             lastActiveAt: now,
             status: "idle",
-            model: defaults.model || undefined,
+            model: modelSlots.main,
+            contextSize: defaults.modelSlots?.mainContext ?? models_1.DEFAULT_CONTEXT_SIZE,
+            runtime: rt,
+            pendingRequestCount: 0,
         };
         this.sessions.set(id, {
             info,
@@ -70,27 +95,42 @@ class SessionManager {
             thinkingLevel: defaults.thinkingLevel,
             streamState: null,
             contextUsage: null,
-            contextWindowSize: 200_000,
+            contextWindowSize: (0, models_1.contextSizeToWindow)(info.contextSize ?? models_1.DEFAULT_CONTEXT_SIZE),
             todoItems: [],
             pendingRequests: new Map(),
             controlCallbacks: new Map(),
             streamingSnapshot: null,
             queuedMessages: [],
             queuePaused: false,
+            modelSlots,
             transcriptBuffer: [],
             transcriptByteOffset: 0,
             transcriptTotalSize: 0,
             bufferCliSessionId: id,
             paginationPrevIds: [],
+            runtime: rt,
+            ptyRuntime: null,
+            transcriptWatcher: null,
+            todoWatcher: null,
+            attachmentPaths: [],
+            totalTokens: { input: 0, output: 0, cacheCreate: 0, cacheRead: 0 },
         });
+        (0, session_prefs_1.setSessionPrefs)(id, { runtime: rt });
         return info;
     }
     ensureSession(id, cwd) {
         let session = this.sessions.get(id);
         if (!session) {
             const prefs = (0, session_prefs_1.getSessionPrefs)(id);
+            const cliId = prefs?.cliSessionId || id;
+            const prevIds = prefs?.previousCliSessionIds || [];
+            const short = id.slice(0, 8);
+            (0, debug_logger_1.debugLog)(`[session:${short}] ensureSession: cliSessionId=${cliId.slice(0, 8)}, prevIds=[${prevIds.map((p) => p.slice(0, 8)).join(",")}], hasPrefs=${!!prefs}`);
             const defaults = (0, defaults_1.getDefaults)();
             const now = Date.now();
+            const modelSlots = prefs?.modelSlots ?? (prefs?.model ? { main: prefs.model } : { main: defaults.modelSlots.main ?? "sonnet" });
+            const restoredRuntime = prefs?.runtime ?? defaultRuntime();
+            const restoredContextSize = prefs?.contextSize ?? prefs?.modelSlots?.mainContext ?? models_1.DEFAULT_CONTEXT_SIZE;
             session = {
                 info: {
                     id,
@@ -99,23 +139,28 @@ class SessionManager {
                     createdAt: now,
                     lastActiveAt: now,
                     status: "idle",
-                    model: prefs?.model || defaults.model || undefined,
+                    model: modelSlots.main,
+                    contextSize: restoredContextSize,
+                    runtime: restoredRuntime,
+                    pendingRequestCount: 0,
                 },
                 process: null,
                 stdin: null,
                 emitter: new node_events_1.EventEmitter(),
                 hasSpawnedBefore: true,
-                cliSessionId: prefs?.cliSessionId || id,
-                previousCliSessionIds: prefs?.previousCliSessionIds || [],
+                cliSessionId: cliId,
+                previousCliSessionIds: prevIds,
                 bypassAllPermissions: prefs?.bypassAllPermissions ?? defaults.bypassAllPermissions,
                 planMode: prefs?.planMode ?? false,
                 pendingPlanReminder: prefs?.planMode ?? false,
                 needsRespawnForPermissions: false,
                 compacting: false,
-                thinkingLevel: prefs?.thinkingLevel ?? (0, models_1.recommendedEffort)((0, models_1.resolveModel)(prefs?.model || defaults.model)) ?? defaults.thinkingLevel,
+                thinkingLevel: prefs?.thinkingLevel ??
+                    (0, models_1.recommendedEffort)((0, models_1.resolveModel)((prefs?.model || defaults.modelSlots.main) ?? "sonnet")) ??
+                    defaults.thinkingLevel,
                 streamState: null,
                 contextUsage: null,
-                contextWindowSize: 200_000,
+                contextWindowSize: (0, models_1.contextSizeToWindow)(restoredContextSize),
                 todoItems: [],
                 pendingRequests: new Map(),
                 controlCallbacks: new Map(),
@@ -123,11 +168,18 @@ class SessionManager {
                 streamingSnapshot: null,
                 queuedMessages: [],
                 queuePaused: false,
+                modelSlots,
                 transcriptBuffer: [],
                 transcriptByteOffset: 0,
                 transcriptTotalSize: 0,
-                bufferCliSessionId: prefs?.cliSessionId || id,
+                bufferCliSessionId: cliId,
                 paginationPrevIds: [],
+                runtime: restoredRuntime,
+                ptyRuntime: null,
+                transcriptWatcher: null,
+                todoWatcher: null,
+                attachmentPaths: [],
+                totalTokens: { input: 0, output: 0, cacheCreate: 0, cacheRead: 0 },
             };
             this.sessions.set(id, session);
         }
@@ -146,30 +198,31 @@ class SessionManager {
             this.ensureSession(id, cwd);
             session = this.sessions.get(id);
         }
-        const result = await (0, transcript_1.loadTranscript)(session.cliSessionId, session.info.cwd, { tailLines: 150 });
+        const stitching = (0, defaults_1.getDefaults)().messageStitching;
+        const willStitch = stitching && session.previousCliSessionIds.length > 0;
+        // Load full current session when stitching to avoid losing middle messages.
+        // Without stitching, tail-read is fine because byteOffset stays pointing at
+        // the current session's file for backward pagination.
+        const result = await (0, transcript_1.loadTranscript)(session.cliSessionId, session.info.cwd, willStitch ? undefined : { tailLines: 150 });
         let { messages, byteOffset, totalSize, lastUsage } = result;
         session.bufferCliSessionId = session.cliSessionId;
-        // Stitch previous session messages across /clear boundaries so the full
-        // conversation is visible on refresh instead of only post-clear messages.
-        if (session.previousCliSessionIds.length > 0) {
-            const currentMessages = messages;
+        if (willStitch) {
             for (let i = session.previousCliSessionIds.length - 1; i >= 0; i--) {
                 const prevId = session.previousCliSessionIds[i];
                 const prevResult = await (0, transcript_1.loadTranscript)(prevId, session.info.cwd, { tailLines: 150 });
                 if (prevResult.messages.length > 0) {
                     const marker = {
-                        id: "clear-boundary-" + Date.now(),
+                        id: `clear-boundary-${i}`,
                         role: "system",
                         content: "__context_reset__",
                         toolUses: [],
                         blocks: [],
                         timestamp: Date.now(),
                     };
-                    messages = [...prevResult.messages, marker, ...currentMessages];
+                    messages = [...prevResult.messages, marker, ...messages];
                     byteOffset = prevResult.byteOffset;
                     lastUsage = lastUsage || prevResult.lastUsage;
                     session.bufferCliSessionId = prevId;
-                    break;
                 }
             }
         }
@@ -178,11 +231,11 @@ class SessionManager {
         session.transcriptByteOffset = byteOffset;
         session.transcriptTotalSize = totalSize;
         // Fresh pagination copy so getMoreHistory doesn't consume the canonical list
-        session.paginationPrevIds = [...session.previousCliSessionIds];
+        session.paginationPrevIds = stitching ? [...session.previousCliSessionIds] : [];
         // Send last 50 to client, keep rest in buffer
         const PAGE = 50;
         const clientMessages = messages.length > PAGE ? messages.slice(-PAGE) : messages;
-        const hasMore = messages.length > PAGE || byteOffset > 0 || session.previousCliSessionIds.length > 0;
+        const hasMore = messages.length > PAGE || byteOffset > 0 || (stitching && session.previousCliSessionIds.length > 0);
         const defaultName = node_path_1.default.basename(session.info.cwd) || session.info.cwd;
         if (session.info.name === defaultName && messages.length > 0) {
             const firstUser = messages.find((m) => m.role === "user" && m.content && !m.content.startsWith("[") && !m.content.startsWith("<"));
@@ -190,35 +243,46 @@ class SessionManager {
                 session.info.name = firstUser.content.slice(0, 120);
             }
         }
-        return { info: session.info, messages: clientMessages, hasMore, lastUsage };
+        const allCliIds = [...session.previousCliSessionIds, session.cliSessionId];
+        const historyArrays = await Promise.all(allCliIds.map((id) => (0, transcript_1.loadPromptHistory)(id, session.info.cwd)));
+        const seen = new Set();
+        const allPrompts = [];
+        for (const arr of historyArrays) {
+            for (const p of arr) {
+                if (seen.has(p))
+                    continue;
+                seen.add(p);
+                allPrompts.push(p);
+            }
+        }
+        const normalized = lastUsage ? { used: lastUsage.used, total: session.contextWindowSize } : null;
+        return { info: session.info, messages: clientMessages, hasMore, lastUsage: normalized, promptHistory: allPrompts };
     }
     async getSessionByCwd(id, cwd) {
         this.ensureSession(id, cwd);
         const session = this.sessions.get(id);
-        const result = await (0, transcript_1.loadTranscript)(session.cliSessionId, cwd, { tailLines: 150 });
+        const stitching = (0, defaults_1.getDefaults)().messageStitching;
+        const willStitch = stitching && session.previousCliSessionIds.length > 0;
+        const result = await (0, transcript_1.loadTranscript)(session.cliSessionId, cwd, willStitch ? undefined : { tailLines: 150 });
         let { messages, byteOffset, totalSize, lastUsage } = result;
         session.bufferCliSessionId = session.cliSessionId;
-        // Stitch previous session messages across /clear boundaries so the full
-        // conversation is visible on refresh instead of only post-clear messages.
-        if (session.previousCliSessionIds.length > 0) {
-            const currentMessages = messages;
+        if (willStitch) {
             for (let i = session.previousCliSessionIds.length - 1; i >= 0; i--) {
                 const prevId = session.previousCliSessionIds[i];
                 const prevResult = await (0, transcript_1.loadTranscript)(prevId, cwd, { tailLines: 150 });
                 if (prevResult.messages.length > 0) {
                     const marker = {
-                        id: "clear-boundary-" + Date.now(),
+                        id: `clear-boundary-${i}`,
                         role: "system",
                         content: "__context_reset__",
                         toolUses: [],
                         blocks: [],
                         timestamp: Date.now(),
                     };
-                    messages = [...prevResult.messages, marker, ...currentMessages];
+                    messages = [...prevResult.messages, marker, ...messages];
                     byteOffset = prevResult.byteOffset;
                     lastUsage = lastUsage || prevResult.lastUsage;
                     session.bufferCliSessionId = prevId;
-                    break;
                 }
             }
         }
@@ -227,11 +291,11 @@ class SessionManager {
         session.transcriptByteOffset = byteOffset;
         session.transcriptTotalSize = totalSize;
         // Fresh pagination copy so getMoreHistory doesn't consume the canonical list
-        session.paginationPrevIds = [...session.previousCliSessionIds];
+        session.paginationPrevIds = stitching ? [...session.previousCliSessionIds] : [];
         // Send last 50 to client, keep rest in buffer
         const PAGE = 50;
         const clientMessages = messages.length > PAGE ? messages.slice(-PAGE) : messages;
-        const hasMore = messages.length > PAGE || byteOffset > 0 || session.previousCliSessionIds.length > 0;
+        const hasMore = messages.length > PAGE || byteOffset > 0 || (stitching && session.previousCliSessionIds.length > 0);
         // Derive title from first user message if name is still the default
         const defaultName = node_path_1.default.basename(cwd) || cwd;
         if (session.info.name === defaultName && messages.length > 0) {
@@ -240,31 +304,43 @@ class SessionManager {
                 session.info.name = firstUser.content.slice(0, 120);
             }
         }
-        return { info: session.info, messages: clientMessages, hasMore, lastUsage };
+        const allCliIds = [...session.previousCliSessionIds, session.cliSessionId];
+        const historyArrays = await Promise.all(allCliIds.map((id) => (0, transcript_1.loadPromptHistory)(id, cwd)));
+        const seen = new Set();
+        const allPrompts = [];
+        for (const arr of historyArrays) {
+            for (const p of arr) {
+                if (seen.has(p))
+                    continue;
+                seen.add(p);
+                allPrompts.push(p);
+            }
+        }
+        const normalized = lastUsage ? { used: lastUsage.used, total: session.contextWindowSize } : null;
+        return { info: session.info, messages: clientMessages, hasMore, lastUsage: normalized, promptHistory: allPrompts };
     }
     async getCliSessionView(cliId, cwd) {
         if (!(0, transcript_1.transcriptExists)(cliId, cwd))
             return null;
         const chain = (0, session_prefs_1.findChainForCliSession)(cliId);
         const prevIds = chain ? chain.truncatedPrevIds : [];
-        const result = await (0, transcript_1.loadTranscript)(cliId, cwd, { tailLines: 150 });
+        const willStitch = (0, defaults_1.getDefaults)().messageStitching && prevIds.length > 0;
+        const result = await (0, transcript_1.loadTranscript)(cliId, cwd, willStitch ? undefined : { tailLines: 150 });
         let { messages, lastUsage } = result;
-        if (prevIds.length > 0) {
-            const currentMessages = messages;
+        if (willStitch) {
             for (let i = prevIds.length - 1; i >= 0; i--) {
                 const prevResult = await (0, transcript_1.loadTranscript)(prevIds[i], cwd, { tailLines: 150 });
                 if (prevResult.messages.length > 0) {
                     const marker = {
-                        id: "clear-boundary-" + Date.now(),
+                        id: `clear-boundary-${i}`,
                         role: "system",
                         content: "__context_reset__",
                         toolUses: [],
                         blocks: [],
                         timestamp: Date.now(),
                     };
-                    messages = [...prevResult.messages, marker, ...currentMessages];
+                    messages = [...prevResult.messages, marker, ...messages];
                     lastUsage = lastUsage || prevResult.lastUsage;
-                    break;
                 }
             }
         }
@@ -277,11 +353,27 @@ class SessionManager {
                 name = firstUser.content.slice(0, 120);
             }
         }
+        const allCliIds = [...prevIds, cliId];
+        const historyArrays = await Promise.all(allCliIds.map((id) => (0, transcript_1.loadPromptHistory)(id, cwd)));
+        const seen = new Set();
+        const allPrompts = [];
+        for (const arr of historyArrays) {
+            for (const p of arr) {
+                if (seen.has(p))
+                    continue;
+                seen.add(p);
+                allPrompts.push(p);
+            }
+        }
+        const prefs = (0, session_prefs_1.getSessionPrefs)(cliId);
+        const viewSize = prefs?.contextSize ?? prefs?.modelSlots?.mainContext ?? models_1.DEFAULT_CONTEXT_SIZE;
+        const normalized = lastUsage ? { used: lastUsage.used, total: (0, models_1.contextSizeToWindow)(viewSize) } : null;
         return {
             info: { id: cliId, name, cwd, createdAt: Date.now(), lastActiveAt: Date.now(), status: "idle" },
             messages: clientMessages,
             hasMore: messages.length > PAGE,
-            lastUsage,
+            lastUsage: normalized,
+            promptHistory: allPrompts,
         };
     }
     async getMoreHistory(sessionId, beforeMessageId) {
@@ -356,9 +448,21 @@ class SessionManager {
     isCompacting(id) {
         return this.sessions.get(id)?.compacting ?? false;
     }
+    getRuntime(id) {
+        return this.sessions.get(id)?.runtime ?? "stream";
+    }
+    getSessionCwd(id) {
+        return this.sessions.get(id)?.info.cwd ?? null;
+    }
+    getCliSessionId(id) {
+        return this.sessions.get(id)?.cliSessionId ?? null;
+    }
+    getSessionModel(id) {
+        return this.sessions.get(id)?.info.model ?? null;
+    }
     listActiveSessions() {
         return Array.from(this.sessions.values())
-            .filter((s) => s.process !== null)
+            .filter((s) => s.process !== null || !!s.ptyRuntime?.isAlive)
             .map((s) => s.info);
     }
     listKnownSessions() {
@@ -380,13 +484,18 @@ class SessionManager {
     }
     isProcessAlive(id) {
         const session = this.sessions.get(id);
-        return !!session?.process;
+        return !!session?.process || !!session?.ptyRuntime?.isAlive;
+    }
+    hasRunningProcess(id) {
+        const session = this.sessions.get(id);
+        return !!session?.process || !!session?.ptyRuntime?.isAlive;
     }
     fixStaleStatus(id) {
         const session = this.sessions.get(id);
-        if (session && session.info.status === "running" && !session.process) {
+        if (session && session.info.status === "running" && !session.process && !session.ptyRuntime?.isAlive) {
             session.info.status = "idle";
             session.pendingRequests.clear();
+            this.notifyPendingChanged(session, id);
         }
     }
     restartSession(sessionId) {
@@ -398,7 +507,11 @@ class SessionManager {
             return false;
         }
         this.killProcess(session);
+        if (!(0, transcript_1.transcriptExists)(session.cliSessionId, session.info.cwd)) {
+            session.hasSpawnedBefore = false;
+        }
         session.pendingRequests.clear();
+        this.notifyPendingChanged(session, sessionId);
         session.streamingSnapshot = null;
         session.info.status = "idle";
         session.emitter.emit("status", sessionId, "idle");
@@ -413,6 +526,20 @@ class SessionManager {
         if (session.process) {
             this.endProcess(session, "session_destroyed");
         }
+        if (session.ptyRuntime) {
+            const runtime = session.ptyRuntime;
+            session.ptyRuntime = null;
+            runtime.kill().catch(() => { });
+        }
+        if (session.transcriptWatcher) {
+            session.transcriptWatcher.stop();
+            session.transcriptWatcher = null;
+        }
+        if (session.todoWatcher) {
+            session.todoWatcher.stop();
+            session.todoWatcher = null;
+        }
+        this.cleanupAttachments(session);
         session.emitter.removeAllListeners();
         this.sessions.delete(id);
         return true;
@@ -429,14 +556,26 @@ class SessionManager {
     }
     onStatus(id, listener) {
         const session = this.sessions.get(id);
-        if (!session)
+        if (!session) {
+            smLog(id, "onStatus: session not in memory, returning null");
             return null;
+        }
         const handler = (_sessionId, status) => {
             listener(status);
         };
         session.emitter.on("status", handler);
         return () => session.emitter.off("status", handler);
     }
+    onPending(id, listener) {
+        const session = this.sessions.get(id);
+        if (!session)
+            return null;
+        const handler = (_sessionId, count) => {
+            listener(count);
+        };
+        session.emitter.on("pending", handler);
+        return () => session.emitter.off("pending", handler);
+    }
     onError(id, listener) {
         const session = this.sessions.get(id);
         if (!session)
@@ -447,19 +586,55 @@ class SessionManager {
         session.emitter.on("error", handler);
         return () => session.emitter.off("error", handler);
     }
+    onTranscript(id, listener) {
+        const session = this.sessions.get(id);
+        if (!session)
+            return null;
+        const handler = (_sessionId, messages) => listener(messages);
+        session.emitter.on("transcript", handler);
+        return () => session.emitter.off("transcript", handler);
+    }
     interrupt(id) {
         const session = this.sessions.get(id);
-        if (!session?.process) {
-            (0, debug_logger_1.logDiag)(id, "interrupt:no-process", { hasSession: !!session });
+        if (!session) {
+            (0, debug_logger_1.logDiag)(id, "interrupt:no-process", { hasSession: false });
             return false;
         }
         // Pause the queue atomically with the interrupt so
         // flushQueuedMessage (called on message_done) becomes a no-op.
-        // This prevents a race where message_done fires before a
-        // separate pause_queue WS message can arrive.
         if (session.queuedMessages.length > 0) {
             session.queuePaused = true;
         }
+        if (session.runtime === "pty") {
+            if (!session.ptyRuntime?.isAlive) {
+                (0, debug_logger_1.logDiag)(id, "interrupt:no-pty");
+                return false;
+            }
+            (0, debug_logger_1.logDiag)(id, "interrupt:pty-esc");
+            session.ptyRuntime.interrupt();
+            // Esc cancels the claude TUI turn but may not produce a Stop hook if it
+            // arrived before any response. Force-idle so the UI unsticks; the PTY
+            // process stays alive at its REPL prompt and accepts the next message.
+            if (session.info.status === "running") {
+                session.info.status = "idle";
+                session.streamingSnapshot = null;
+                if (session.streamState) {
+                    session.streamState.pendingBlocks.length = 0;
+                    session.streamState.pendingToolUses.length = 0;
+                    session.streamState.agentStack.length = 0;
+                    session.streamState.currentAssistantMsgId = null;
+                    session.streamState.flushedOnMessageDone = false;
+                }
+                session.emitter.emit("status", id, "idle");
+            }
+            session.pendingRequests.clear();
+            this.notifyPendingChanged(session, id);
+            return true;
+        }
+        if (!session.process) {
+            (0, debug_logger_1.logDiag)(id, "interrupt:no-process", { hasSession: true });
+            return false;
+        }
         // Send a control_request interrupt via stdin instead of SIGINT.
         // SIGINT kills the process, forcing a full respawn + transcript reload
         // on the next message. The control_request interrupt aborts the current
@@ -473,23 +648,34 @@ class SessionManager {
             };
             (0, debug_logger_1.logDiag)(id, "interrupt:stdin", { requestId: request.request_id });
             session.stdin.write(JSON.stringify(request) + "\n");
+            session.pendingRequests.clear();
+            this.notifyPendingChanged(session, id);
             return true;
         }
         // Fallback: if stdin is gone, kill the process group
         (0, debug_logger_1.logDiag)(id, "interrupt:kill-fallback");
         this.killProcessGroup(session.process);
+        session.pendingRequests.clear();
+        this.notifyPendingChanged(session, id);
         return true;
     }
     addPendingRequest(sessionId, request) {
         const session = this.sessions.get(sessionId);
         if (session) {
             session.pendingRequests.set(request.requestId, request);
+            this.notifyPendingChanged(session, sessionId);
         }
     }
     removePendingRequest(sessionId, requestId) {
         const session = this.sessions.get(sessionId);
         if (session) {
+            const had = session.pendingRequests.has(requestId);
+            const wasQuestion = session.pendingRequests.get(requestId)?.type === "question";
             session.pendingRequests.delete(requestId);
+            if (wasQuestion) {
+                console.log(`[question-debug] removePendingRequest: session=${sessionId.slice(0, 8)}, requestId=${requestId}, existed=${had}, remaining=${session.pendingRequests.size}`);
+            }
+            this.notifyPendingChanged(session, sessionId);
         }
     }
     getPendingRequests(sessionId) {
@@ -498,11 +684,26 @@ class SessionManager {
             return [];
         return Array.from(session.pendingRequests.values());
     }
+    getPendingRequest(sessionId, requestId) {
+        return this.sessions.get(sessionId)?.pendingRequests.get(requestId);
+    }
     respondToPermission(sessionId, requestId, allowed, toolInput, permissionSuggestions, denyReason) {
         const session = this.sessions.get(sessionId);
-        if (!session?.stdin)
+        if (!session)
+            return false;
+        if (session.runtime === "pty") {
+            if (!session.ptyRuntime?.isAlive)
+                return false;
+            session.pendingRequests.delete(requestId);
+            this.notifyPendingChanged(session, sessionId);
+            return session.ptyRuntime.notifyPermissionDecision(requestId, allowed
+                ? { behavior: "allow", ...(toolInput ? { updatedInput: toolInput } : {}) }
+                : { behavior: "deny", message: denyReason ?? "User denied" });
+        }
+        if (!session.stdin)
             return false;
         session.pendingRequests.delete(requestId);
+        this.notifyPendingChanged(session, sessionId);
         const response = {
             type: "control_response",
             response: {
@@ -511,7 +712,7 @@ class SessionManager {
                 response: allowed
                     ? {
                         behavior: "allow",
-                        ...(toolInput ? { updatedInput: toolInput } : {}),
+                        updatedInput: toolInput ?? {},
                         ...(permissionSuggestions?.length ? { updatedPermissions: permissionSuggestions } : {}),
                     }
                     : { behavior: "deny", message: denyReason ?? "User denied" },
@@ -540,6 +741,7 @@ class SessionManager {
         // Don't change CLI mode while in plan mode; bypass will restore on plan exit
         if (!session.planMode) {
             this.sendPermissionMode(session, sessionId, "bypassPermissions");
+            this.scheduleRespawnForPermissions(session);
         }
         this.emitSystem(session, sessionId, "__bypass_state::on");
     }
@@ -551,9 +753,36 @@ class SessionManager {
         (0, session_prefs_1.setSessionPrefs)(sessionId, { bypassAllPermissions: false });
         if (!session.planMode) {
             this.sendPermissionMode(session, sessionId, "default");
+            this.scheduleRespawnForPermissions(session);
         }
         this.emitSystem(session, sessionId, "__bypass_state::off");
     }
+    // Runtime set_permission_mode is unreliable when the CLI was spawned without
+    // the target mode. Respawning the process picks up --permission-mode from
+    // session state, guaranteeing the next message runs in the right mode.
+    // If a message is in flight, defer until message_done so we don't orphan it.
+    scheduleRespawnForPermissions(session) {
+        if (!session.process && !session.ptyRuntime?.isAlive)
+            return;
+        if (session.info.status === "idle") {
+            this.killProcess(session);
+            session.hasSpawnedBefore = (0, transcript_1.transcriptExists)(session.cliSessionId, session.info.cwd);
+        }
+        else {
+            session.needsRespawnForPermissions = true;
+        }
+    }
+    setRuntime(sessionId, runtime) {
+        const session = this.sessions.get(sessionId);
+        if (!session || session.runtime === runtime)
+            return false;
+        session.runtime = runtime;
+        session.info.runtime = runtime;
+        (0, session_prefs_1.setSessionPrefs)(sessionId, { runtime });
+        this.killProcess(session);
+        this.emitInfoUpdated(session, sessionId);
+        return true;
+    }
     isBypassActive(sessionId) {
         const session = this.sessions.get(sessionId);
         return session?.bypassAllPermissions ?? false;
@@ -567,13 +796,14 @@ class SessionManager {
         (0, session_prefs_1.setSessionPrefs)(sessionId, { planMode: true });
         // Kill process so it restarts without --allow-dangerously-skip-permissions,
         // which lets the CLI natively enforce plan mode tool restrictions.
-        if (session.process) {
+        if (session.process || session.ptyRuntime?.isAlive) {
             this.killProcess(session);
             session.info.status = "idle";
             session.emitter.emit("status", sessionId, "idle");
         }
         // Clear orphaned pending requests from the killed process
         session.pendingRequests.clear();
+        this.notifyPendingChanged(session, sessionId);
         this.emitSystem(session, sessionId, "__plan_state::on");
     }
     clearPlanMode(sessionId) {
@@ -584,13 +814,14 @@ class SessionManager {
         (0, session_prefs_1.setSessionPrefs)(sessionId, { planMode: false });
         // Kill process so it restarts with --allow-dangerously-skip-permissions,
         // restoring bypass capability for build mode.
-        if (session.process) {
+        if (session.process || session.ptyRuntime?.isAlive) {
             this.killProcess(session);
             session.info.status = "idle";
             session.emitter.emit("status", sessionId, "idle");
         }
         // Clear orphaned pending requests from the killed process
         session.pendingRequests.clear();
+        this.notifyPendingChanged(session, sessionId);
         this.emitSystem(session, sessionId, "__plan_state::off");
         // Re-sync bypass state with the client so the UI reflects it correctly
         // after the plan-mode process is torn down.
@@ -602,19 +833,41 @@ class SessionManager {
         const session = this.sessions.get(sessionId);
         return session?.planMode ?? false;
     }
-    setModel(sessionId, model) {
+    setModel(sessionId, model, contextSize) {
         const session = this.sessions.get(sessionId);
-        if (!session || session.info.model === model)
+        this.log(sessionId, `setModel: requested=${model} size=${contextSize ?? "(unspecified)"}, current=${session?.info.model} currentSize=${session?.info.contextSize ?? "(unset)"}, hasStdin=${!!session?.stdin}, hasPty=${!!session?.ptyRuntime}`);
+        if (!session)
+            return;
+        const currentSize = session.info.contextSize ?? models_1.DEFAULT_CONTEXT_SIZE;
+        const requestedSize = contextSize ?? currentSize;
+        const resolvedSize = (() => {
+            const sizes = (0, models_1.resolveModel)(model)?.contextSizes;
+            if (!sizes || sizes.length === 0)
+                return requestedSize;
+            return sizes.includes(requestedSize) ? requestedSize : sizes[0];
+        })();
+        // CLAUDE_CODE_DISABLE_1M_CONTEXT is applied at spawn, so a context-size
+        // change mid-session requires a CLI restart to take effect.
+        const contextChanged = currentSize !== resolvedSize;
+        if (session.info.model === model && !contextChanged) {
+            this.log(sessionId, `setModel: skipping (already ${model} with size ${resolvedSize})`);
             return;
-        // Detect 200K↔1M flip. The CLAUDE_CODE_DISABLE_1M_CONTEXT env var is
-        // applied at spawn, so toggling the [1m] suffix mid-session needs a CLI
-        // restart for the new context window to actually take effect.
-        const has1m = (m) => !!m && /\[1m\]/i.test(m);
-        const contextChanged = has1m(session.info.model) !== has1m(model);
+        }
         session.info.model = model;
-        (0, session_prefs_1.setSessionPrefs)(sessionId, { model });
+        session.info.contextSize = resolvedSize;
+        session.modelSlots = { ...session.modelSlots, main: model, mainContext: resolvedSize };
+        (0, session_prefs_1.setSessionPrefs)(sessionId, { model, contextSize: resolvedSize, modelSlots: session.modelSlots });
         const nextEntry = (0, models_1.resolveModel)(model);
-        const coerced = (0, models_1.coerceEffort)(session.thinkingLevel, nextEntry);
+        const coerced = nextEntry
+            ? (0, models_1.coerceEffort)(session.thinkingLevel, nextEntry)
+            : (() => {
+                const levels = this.modelEffortLevels(model);
+                if (levels.length === 0)
+                    return null;
+                if (levels.includes(session.thinkingLevel))
+                    return session.thinkingLevel;
+                return levels[levels.length - 1];
+            })();
         const levelChanged = coerced !== null && coerced !== session.thinkingLevel;
         if (levelChanged) {
             session.thinkingLevel = coerced;
@@ -622,13 +875,14 @@ class SessionManager {
             this.emitSystem(session, sessionId, `__thinking_level::${coerced}`);
         }
         if (session.stdin && !contextChanged) {
+            this.log(sessionId, `setModel: sending control_request set_model=${model}`);
             const request = {
                 type: "control_request",
                 request_id: `model-${Date.now()}`,
                 request: { subtype: "set_model", model },
             };
             session.stdin.write(JSON.stringify(request) + "\n");
-            if ((0, models_1.allowedEffortLevels)(nextEntry).length > 0) {
+            if (this.modelEffortLevels(model).length > 0) {
                 const effortRequest = {
                     type: "control_request",
                     request_id: `effort-${Date.now()}`,
@@ -638,13 +892,44 @@ class SessionManager {
             }
         }
         else {
+            this.log(sessionId, `setModel: killing process (hasStdin=${!!session.stdin}, contextChanged=${contextChanged})`);
             this.killProcess(session);
+            if (!(0, transcript_1.transcriptExists)(session.cliSessionId, session.info.cwd)) {
+                session.hasSpawnedBefore = false;
+            }
             session.queuedMessages.length = 0;
             session.queuePaused = false;
             session.info.status = "idle";
             session.emitter.emit("status", sessionId, "idle");
         }
         this.emitInfoUpdated(session, sessionId);
+        if (contextChanged) {
+            session.contextWindowSize = (0, models_1.contextSizeToWindow)(resolvedSize);
+        }
+        const cur = session.contextUsage;
+        if (cur) {
+            session.emitter.emit("usage", sessionId, { used: cur.used, total: session.contextWindowSize });
+        }
+    }
+    setModelSlot(sessionId, slot, modelId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return;
+        const slots = { ...session.modelSlots };
+        slots[slot] = modelId;
+        session.modelSlots = slots;
+        (0, session_prefs_1.setSessionPrefs)(sessionId, { modelSlots: slots });
+        if (slot === "main") {
+            this.setModel(sessionId, modelId);
+        }
+        else {
+            this.killProcess(session);
+            session.queuedMessages.length = 0;
+            session.queuePaused = false;
+            session.info.status = "idle";
+            session.emitter.emit("status", sessionId, "idle");
+            this.emitInfoUpdated(session, sessionId);
+        }
     }
     getModel(sessionId) {
         return this.sessions.get(sessionId)?.info.model || "sonnet";
@@ -655,7 +940,7 @@ class SessionManager {
             return;
         session.thinkingLevel = level;
         (0, session_prefs_1.setSessionPrefs)(sessionId, { thinkingLevel: level });
-        const supportsEffort = (0, models_1.allowedEffortLevels)((0, models_1.resolveModel)(session.info.model)).length > 0;
+        const supportsEffort = this.modelEffortLevels(session.info.model).length > 0;
         if (session.stdin && supportsEffort) {
             const request = {
                 type: "control_request",
@@ -857,45 +1142,33 @@ class SessionManager {
         session.emitter.on("init", handler);
         return () => session.emitter.off("init", handler);
     }
-    handleTodoWrite(session, sessionId, toolInput) {
-        try {
-            const input = JSON.parse(toolInput);
-            const todos = input.todos;
-            if (!Array.isArray(todos))
-                return;
-            session.todoItems = todos
-                .filter((t) => t.content && t.status)
-                .map((t) => ({
-                content: t.content,
-                status: t.status,
-                activeForm: t.activeForm || undefined,
-            }));
-            session.emitter.emit("todos", sessionId, [...session.todoItems]);
-        }
-        catch {
-            // invalid input, ignore
-        }
-    }
-    rebuildTodosFromHistory(sessionId, messages) {
+    loadTodosFromFiles(sessionId) {
         const session = this.sessions.get(sessionId);
         if (!session)
             return;
-        // If there's already a live todo state (set during the current process),
-        // don't overwrite it from history.
         if (session.todoItems.length > 0)
             return;
-        const todos = extractTodosFromHistory(messages);
+        const watcher = new todo_watcher_1.TodoWatcher(session.cliSessionId, () => { });
+        const todos = watcher.readOnce();
         if (todos.length === 0)
             return;
         session.todoItems = todos;
         session.emitter.emit("todos", sessionId, [...session.todoItems]);
     }
+    startTodoWatcher(session, sessionId) {
+        if (session.todoWatcher) {
+            session.todoWatcher.stop();
+        }
+        const watcher = new todo_watcher_1.TodoWatcher(session.cliSessionId, (todos) => {
+            session.todoItems = todos;
+            session.emitter.emit("todos", sessionId, [...todos]);
+        });
+        session.todoWatcher = watcher;
+        watcher.start();
+    }
     extractUsage(session, sessionId, line) {
         try {
             const raw = JSON.parse(line.trim());
-            if (raw.type === "result" && raw.modelUsage) {
-                this.extractContextWindowSize(session, raw.modelUsage);
-            }
             if (raw.type !== "assistant" || !raw.message?.usage)
                 return;
             // Skip synthetic responses (e.g. /context) that have all-zero usage
@@ -906,19 +1179,15 @@ class SessionManager {
             const usage = { used, total: session.contextWindowSize };
             session.contextUsage = usage;
             session.emitter.emit("usage", sessionId, usage);
+            session.totalTokens.input += u.input_tokens || 0;
+            session.totalTokens.output += u.output_tokens || 0;
+            session.totalTokens.cacheCreate += u.cache_creation_input_tokens || 0;
+            session.totalTokens.cacheRead += u.cache_read_input_tokens || 0;
         }
         catch {
             // not valid JSON, ignore
         }
     }
-    extractContextWindowSize(session, modelUsage) {
-        for (const model of Object.values(modelUsage)) {
-            if (model.contextWindow && model.contextWindow > 0) {
-                session.contextWindowSize = model.contextWindow;
-                return;
-            }
-        }
-    }
     killProcessGroup(proc) {
         if (!proc.pid)
             return;
@@ -963,12 +1232,28 @@ class SessionManager {
             session.process = null;
             session.stdin = null;
         }
+        if (session.ptyRuntime) {
+            const runtime = session.ptyRuntime;
+            session.ptyRuntime = null;
+            runtime.kill().catch(() => { });
+        }
         session.compacting = false;
     }
     emitSystem(session, sessionId, text) {
         session.emitter.emit("system", sessionId, text);
     }
+    notifyPendingChanged(session, sessionId) {
+        const count = session.pendingRequests.size;
+        if (session.info.pendingRequestCount === count)
+            return;
+        session.info.pendingRequestCount = count;
+        session.emitter.emit("pending", sessionId, count);
+    }
     applyProcessedResult(session, sessionId, result) {
+        const eventTypes = result.emit.map((e) => e.type).join(", ");
+        if (eventTypes) {
+            console.log(`[sm] applyProcessedResult for ${sessionId.slice(0, 8)}: events=[${eventTypes}], statusChange=${result.statusChange ?? "none"}, currentStatus=${session.info.status}`);
+        }
         for (const msg of result.intermediateMessages) {
             session.emitter.emit("event", sessionId, { type: "message_done", message: msg });
             if (msg.toolUses.some((t) => t.name === "Agent")) {
@@ -976,6 +1261,37 @@ class SessionManager {
             }
         }
         for (const sysMsg of result.systemMessages) {
+            if (sysMsg === "__tool_use_start") {
+                session.info.status = "running";
+                console.log(`[sm] emit status running (via tool_use_start) for ${sessionId.slice(0, 8)} (runtime=${session.runtime})`);
+                session.emitter.emit("status", sessionId, "running");
+                continue;
+            }
+            if (sysMsg === "__compact::hook_start") {
+                if (!session.compacting) {
+                    (0, debug_logger_1.logDiag)(sessionId, "compact:hook-start");
+                    session.compacting = true;
+                    this.emitSystem(session, sessionId, "__compact::start");
+                }
+                continue;
+            }
+            if (sysMsg === "__compact::hook_done") {
+                if (session.compacting) {
+                    (0, debug_logger_1.logDiag)(sessionId, "compact:hook-done");
+                    session.compacting = false;
+                    this.emitSystem(session, sessionId, "__compact::done");
+                    const postCompactEstimate = {
+                        used: Math.round(session.contextWindowSize * 0.1),
+                        total: session.contextWindowSize,
+                    };
+                    session.contextUsage = postCompactEstimate;
+                    session.emitter.emit("usage", sessionId, postCompactEstimate);
+                    session.info.status = "idle";
+                    session.emitter.emit("status", sessionId, "idle");
+                    this.flushQueuedMessage(session, sessionId);
+                }
+                continue;
+            }
             const permModePrefix = "__permission_mode::";
             if (sysMsg.startsWith(permModePrefix)) {
                 const mode = sysMsg.slice(permModePrefix.length);
@@ -998,9 +1314,14 @@ class SessionManager {
         for (const errMsg of result.errors) {
             session.emitter.emit("error", sessionId, errMsg);
         }
-        for (const todoInput of result.todoInputs) {
-            this.handleTodoWrite(session, sessionId, todoInput);
-        }
+        // After exiting plan mode the CLI process is killed and respawned with the
+        // correct --permission-mode flag (see needsRespawnForPermissions). Between
+        // the plan exit and the message_done that triggers the respawn, the old
+        // process may still send permission_request events. The server auto-approves
+        // these so the CLI isn't blocked, but we must also suppress the events from
+        // reaching the UI -- otherwise the user sees phantom permission prompts that
+        // don't actually gate anything.
+        const bypassedRequestIds = new Set();
         for (const pa of result.permissionActions) {
             if (pa.type === "auto_approve") {
                 this.respondToPermission(sessionId, pa.requestId, true, pa.rawToolInput);
@@ -1008,22 +1329,38 @@ class SessionManager {
             else if (pa.type === "auto_deny") {
                 this.respondToPermission(sessionId, pa.requestId, false, undefined, undefined, pa.denyReason);
             }
+            else if (session.bypassAllPermissions && !session.planMode && pa.toolName !== "AskUserQuestion") {
+                this.respondToPermission(sessionId, pa.requestId, true, pa.rawToolInput);
+                bypassedRequestIds.add(pa.requestId);
+            }
             else {
                 const planPath = pa.toolName === "ExitPlanMode" ? (0, plans_1.findLatestPlanFile)() : undefined;
+                const reqType = pa.toolName === "AskUserQuestion" ? "question" : "permission";
+                if (reqType === "question") {
+                    console.log(`[question-debug] adding pending question: session=${sessionId.slice(0, 8)}, requestId=${pa.requestId}, total=${session.pendingRequests.size + 1}`);
+                }
                 session.pendingRequests.set(pa.requestId, {
-                    type: pa.toolName === "AskUserQuestion" ? "question" : "permission",
+                    type: reqType,
                     requestId: pa.requestId,
                     toolName: pa.toolName,
                     toolInput: pa.toolInput || "",
                     rawToolInput: pa.rawToolInput,
+                    permissionSuggestions: pa.permissionSuggestions,
                     planFilePath: planPath,
                     planContent: planPath ? (0, plans_1.readPlanFile)(planPath) : undefined,
                 });
+                this.notifyPendingChanged(session, sessionId);
             }
         }
         if (result.compactDone) {
             session.compacting = false;
             this.emitSystem(session, sessionId, "__compact::done");
+            const postCompactEstimate = {
+                used: Math.round(session.contextWindowSize * 0.1),
+                total: session.contextWindowSize,
+            };
+            session.contextUsage = postCompactEstimate;
+            session.emitter.emit("usage", sessionId, postCompactEstimate);
         }
         if (result.emit.length > 0) {
             const listeners = session.emitter.listenerCount("event");
@@ -1032,6 +1369,9 @@ class SessionManager {
             }
         }
         for (const event of result.emit) {
+            // Skip phantom permission events that were already bypass-approved above
+            if (event.type === "permission_request" && event.requestId && bypassedRequestIds.has(event.requestId))
+                continue;
             session.emitter.emit("event", sessionId, event);
         }
         session.streamingSnapshot = result.snapshot;
@@ -1049,6 +1389,7 @@ class SessionManager {
         }
         if (result.statusChange === "idle") {
             session.info.status = "idle";
+            console.log(`[sm] emit status idle for ${sessionId.slice(0, 8)} (runtime=${session.runtime})`);
             session.emitter.emit("status", sessionId, "idle");
             this.flushQueuedMessage(session, sessionId);
         }
@@ -1115,6 +1456,7 @@ class SessionManager {
                     this.emitSystem(session, sessionId, `__model_picker::${current}`);
                     return true;
                 }
+                this.log(sessionId, `/model command: args="${args}", was=${session.info.model}`);
                 this.killProcess(session);
                 session.info.model = args;
                 session.info.status = "idle";
@@ -1141,18 +1483,148 @@ class SessionManager {
                     "  /clear, /reset, /new  - Clear conversation and start fresh",
                     "  /model [name]         - Show or switch model",
                     "  /rename <name>        - Rename this session",
+                    "  /cost                 - Show session token usage",
+                    "  /context              - Show context window usage",
+                    "  /status               - Show session status",
                     "  /help                 - Show this help message",
                     "",
-                    "All other slash commands (/compact, /cost, /context, /commit,",
-                    "/review, /analyze, etc.) are passed directly to Claude.",
+                    "Other commands (/compact, /commit, /review, etc.) are passed to Claude when possible.",
                 ].join("\n");
                 this.emitSystem(session, sessionId, helpText);
                 return true;
             }
+            case "/cost": {
+                const t = session.totalTokens;
+                const lines = [
+                    `Input tokens:       ${t.input.toLocaleString()}`,
+                    `Output tokens:      ${t.output.toLocaleString()}`,
+                    `Cache write tokens: ${t.cacheCreate.toLocaleString()}`,
+                    `Cache read tokens:  ${t.cacheRead.toLocaleString()}`,
+                ];
+                this.emitSystem(session, sessionId, lines.join("\n"));
+                return true;
+            }
+            case "/context": {
+                if (!session.contextUsage) {
+                    this.emitSystem(session, sessionId, "Context usage data not available yet.");
+                    return true;
+                }
+                const pct = session.contextWindowSize > 0 ? Math.round((session.contextUsage.used / session.contextWindowSize) * 100) : 0;
+                this.emitSystem(session, sessionId, `Context window: ${session.contextUsage.used.toLocaleString()} / ${session.contextWindowSize.toLocaleString()} (${pct}%)`);
+                return true;
+            }
+            case "/status": {
+                const model = session.info.model || "sonnet";
+                const runtime = session.runtime;
+                const plan = session.planMode ? " [plan]" : "";
+                this.emitSystem(session, sessionId, `Model: ${model}  Runtime: ${runtime}${plan}`);
+                return true;
+            }
+        }
+        // In PTY mode, intercept commands that render CLI dialogs to prevent hangs
+        if (session.ptyRuntime?.isAlive) {
+            const dialogCmd = cmd.replace("/", "");
+            if (SessionManager.DIALOG_COMMANDS.has(dialogCmd)) {
+                this.emitSystem(session, sessionId, `"${cmd}" opens an interactive CLI dialog that isn't available in remote mode.`);
+                return true;
+            }
         }
         // All other slash commands pass through to Claude
         return false;
     }
+    static DIALOG_COMMANDS = new Set([
+        "config",
+        "usage",
+        "session",
+        "stats",
+        "doctor",
+        "diff",
+        "mcp",
+        "permissions",
+        "hooks",
+        "tasks",
+        "agents",
+        "skills",
+        "memory",
+        "theme",
+        "fast",
+        "feedback",
+        "copy",
+        "branch",
+        "plan",
+        "chrome",
+        "desktop",
+        "ide",
+        "mobile",
+        "bridge",
+        "sandbox",
+        "export",
+        "login",
+        "logout",
+        "upgrade",
+        "rate-limit-options",
+        "privacy-settings",
+        "terminal-setup",
+        "install-github-app",
+        "remote-env",
+        "remote-setup",
+        "resume",
+        "add-dir",
+        "btw",
+        "extra-usage",
+        "passes",
+        "think-back",
+        "ultrareview",
+        "tag",
+        "exit",
+        "effort",
+        "color",
+        "files",
+    ]);
+    static MEDIA_EXT = {
+        "image/png": ".png",
+        "image/jpeg": ".jpg",
+        "image/gif": ".gif",
+        "image/webp": ".webp",
+        "application/pdf": ".pdf",
+    };
+    writeAttachments(images, documents) {
+        if (!images?.length && !documents?.length)
+            return [];
+        const dir = node_path_1.default.join((0, paths_1.getCockpitCacheDir)(), "attachments");
+        (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+        const paths = [];
+        for (const img of images ?? []) {
+            const ext = SessionManager.MEDIA_EXT[img.mediaType] || ".png";
+            const p = node_path_1.default.join(dir, `${(0, uuid_1.v4)()}${ext}`);
+            (0, node_fs_1.writeFileSync)(p, Buffer.from(img.data, "base64"));
+            paths.push(p);
+        }
+        for (const doc of documents ?? []) {
+            const ext = SessionManager.MEDIA_EXT[doc.mediaType] || ".pdf";
+            const p = node_path_1.default.join(dir, `${(0, uuid_1.v4)()}${ext}`);
+            (0, node_fs_1.writeFileSync)(p, Buffer.from(doc.data, "base64"));
+            paths.push(p);
+        }
+        return paths;
+    }
+    cleanupAttachments(session) {
+        for (const p of session.attachmentPaths) {
+            try {
+                (0, node_fs_1.unlinkSync)(p);
+            }
+            catch {
+                // file already cleaned up
+            }
+        }
+        session.attachmentPaths = [];
+    }
+    buildPtyText(text, attachmentPaths) {
+        if (attachmentPaths.length === 0)
+            return text;
+        const refs = attachmentPaths.map((p) => `[Attached image: ${p}]`).join("\n");
+        return `${refs}\n${text}`;
+    }
     buildContent(session, text, images, documents) {
         const reminder = session.pendingPlanReminder ? this.planModeReminderText() : null;
         if (session.pendingPlanReminder)
@@ -1197,6 +1669,27 @@ Additional Cockpit rules beyond the CLI's defaults:
         smLog(id, `recovery succeeded: restored from ${cwd}`);
         return true;
     }
+    estimateMessageTokens(text, images, documents) {
+        let tokens = Math.ceil(text.length / 4);
+        if (images)
+            tokens += images.length * 2000;
+        if (documents)
+            tokens += documents.reduce((sum, d) => sum + Math.ceil(d.data.length / 5), 0);
+        return tokens;
+    }
+    shouldPreCompact(session, text, images, documents) {
+        if (!session.contextUsage)
+            return false;
+        if (session.compacting)
+            return false;
+        if (text.trim().toLowerCase().startsWith("/compact"))
+            return false;
+        if (text.trim().startsWith("/"))
+            return false;
+        const estimate = this.estimateMessageTokens(text, images, documents);
+        const { used, total } = session.contextUsage;
+        return used + estimate > total * 0.85;
+    }
     sendMessage(sessionId, text, images, documents) {
         const session = this.sessions.get(sessionId);
         if (!session) {
@@ -1214,6 +1707,29 @@ Additional Cockpit rules beyond the CLI's defaults:
                 this.emitSystem(session, sessionId, "__compact::start");
             }
         }
+        // If the message would likely overflow the context window, compact first
+        // and queue the message for delivery after compaction finishes.
+        if (session.info.status !== "running" && this.shouldPreCompact(session, text, images, documents)) {
+            this.log(sessionId, "pre-send compact: message would exceed 85% of context window");
+            (0, debug_logger_1.logDiag)(sessionId, "compact:pre-send");
+            session.queuedMessages.push({ id: `q-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`, text, images, documents });
+            session.emitter.emit("queued", sessionId, session.queuedMessages.length);
+            session.compacting = true;
+            this.emitSystem(session, sessionId, "__compact::start");
+            session.info.status = "running";
+            session.emitter.emit("status", sessionId, "running");
+            if (session.ptyRuntime?.isAlive) {
+                session.ptyRuntime.sendText("/compact").catch(() => { });
+            }
+            else if (session.process && session.stdin) {
+                const compactInput = { type: "user", message: { role: "user", content: "/compact" } };
+                session.stdin.write(JSON.stringify(compactInput) + "\n");
+            }
+            else {
+                this.spawnProcess(session, sessionId, "/compact");
+            }
+            return true;
+        }
         const content = this.buildContent(session, text, images, documents);
         // If queue was paused (user interrupted then sent a new message),
         // discard the paused messages and reset the flag.
@@ -1228,9 +1744,27 @@ Additional Cockpit rules beyond the CLI's defaults:
             session.emitter.emit("queued", sessionId, session.queuedMessages.length);
             return true;
         }
-        (0, debug_logger_1.logDiag)(sessionId, "running:send", { hasProcess: !!session.process, hasStdin: !!session.stdin });
+        (0, debug_logger_1.logDiag)(sessionId, "running:send", {
+            hasProcess: !!session.process,
+            hasStdin: !!session.stdin,
+            runtime: session.runtime,
+            ptyAlive: !!session.ptyRuntime?.isAlive,
+        });
         session.info.status = "running";
+        console.log(`[sm] emit status running for ${sessionId.slice(0, 8)} (runtime=${session.runtime})`);
         session.emitter.emit("status", sessionId, "running");
+        if (session.runtime === "pty" && session.ptyRuntime?.isAlive) {
+            if (session.streamState)
+                session.streamState.thinkingStartedAt = Date.now();
+            this.cleanupAttachments(session);
+            const attachments = this.writeAttachments(images, documents);
+            session.attachmentPaths.push(...attachments);
+            const ptyText = this.buildPtyText(text, attachments);
+            session.ptyRuntime.sendText(ptyText).catch((err) => {
+                this.log(sessionId, `pty sendText failed: ${err instanceof Error ? err.message : String(err)}`);
+            });
+            return true;
+        }
         if (session.process && session.stdin) {
             if (session.streamState)
                 session.streamState.thinkingStartedAt = Date.now();
@@ -1250,11 +1784,27 @@ Additional Cockpit rules beyond the CLI's defaults:
     }
     ensureProcess(sessionId) {
         const session = this.sessions.get(sessionId);
-        if (!session || session.process)
+        if (!session || session.process || session.ptyRuntime?.isAlive)
             return;
         this.spawnProcess(session, sessionId);
     }
+    /** Check effort levels for built-in models or custom provider models. */
+    modelEffortLevels(modelId) {
+        if (!modelId)
+            return [];
+        const builtin = (0, models_1.resolveModel)(modelId);
+        if (builtin)
+            return (0, models_1.allowedEffortLevels)(builtin);
+        const resolved = (0, providers_1.resolveProviderModel)(modelId);
+        if (resolved)
+            return resolved.model.effortLevels;
+        return [];
+    }
     spawnProcess(session, sessionId, text, images, documents) {
+        if (session.runtime === "pty") {
+            this.spawnPtyProcess(session, sessionId, text, images, documents);
+            return;
+        }
         this.log(sessionId, `spawning CLI process (resume=${session.hasSpawnedBefore}, model=${session.info.model || "sonnet"})`);
         const args = ["-p", "--verbose", "--output-format", "stream-json", "--input-format", "stream-json"];
         // In plan mode, omit --allow-dangerously-skip-permissions so the CLI
@@ -1277,25 +1827,35 @@ Additional Cockpit rules beyond the CLI's defaults:
         else {
             args.push("--session-id", session.cliSessionId);
         }
-        if (session.info.model) {
-            args.push("--model", session.info.model);
+        const resolved = (0, providers_1.resolveProviderModel)(session.info.model ?? "sonnet");
+        const cliModel = resolved ? resolved.model.modelId : session.info.model;
+        this.log(sessionId, `spawn: info.model=${session.info.model}, resolved=${resolved ? `${resolved.provider.id}:${resolved.model.modelId}` : "null"}, cliModel=${cliModel}`);
+        if (cliModel) {
+            args.push("--model", cliModel);
         }
-        if ((0, models_1.allowedEffortLevels)((0, models_1.resolveModel)(session.info.model)).length > 0) {
+        if (this.modelEffortLevels(session.info.model).length > 0) {
             args.push("--effort", session.thinkingLevel);
         }
         const env = { ...process.env };
         delete env.CLAUDECODE;
         delete env.CLAUDE_CODE_ENTRYPOINT;
-        // Claude Code defaults to a model's full context window (1M for Opus 4.7,
-        // Sonnet 4.6) when no [1m] suffix is present, ignoring the suffix as the
-        // gate. CLAUDE_CODE_DISABLE_1M_CONTEXT is the only switch that forces 200K
-        // back regardless of model capability — set it when the user picked 200K.
-        if (session.info.model && !/\[1m\]/i.test(session.info.model)) {
+        if (resolved) {
+            Object.assign(env, resolved.provider.envVars);
+        }
+        // CLAUDE_CODE_DISABLE_1M_CONTEXT is the only switch that forces a model
+        // back to 200K regardless of its capability. Set it when the user picked
+        // 200K for this session.
+        const sizeKey = session.info.contextSize ?? models_1.DEFAULT_CONTEXT_SIZE;
+        if (models_1.CONTEXT_SIZES[sizeKey].disableEnv) {
             env.CLAUDE_CODE_DISABLE_1M_CONTEXT = "1";
         }
+        if (session.modelSlots.subagent && session.modelSlots.subagent !== session.modelSlots.main) {
+            const resolvedSub = (0, providers_1.resolveProviderModel)(session.modelSlots.subagent);
+            env.ANTHROPIC_SMALL_FAST_MODEL = resolvedSub ? resolvedSub.model.modelId : session.modelSlots.subagent;
+        }
         (0, node_fs_1.mkdirSync)(session.info.cwd, { recursive: true });
         const isWin = process.platform === "win32";
-        const proc = (0, node_child_process_1.spawn)("claude", args, {
+        const proc = (0, node_child_process_1.spawn)(getClaudeBin(), args, {
             cwd: session.info.cwd,
             env,
             stdio: ["pipe", "pipe", "pipe"],
@@ -1305,6 +1865,7 @@ Additional Cockpit rules beyond the CLI's defaults:
         session.stdin = proc.stdin;
         session.hasSpawnedBefore = true;
         this.log(sessionId, `CLI process spawned (pid=${proc.pid})`);
+        this.startTodoWatcher(session, sessionId);
         // Send initialize control request before the first user message to get
         // model capabilities, account info, and command metadata from the CLI.
         const initRequest = {
@@ -1405,6 +1966,12 @@ Additional Cockpit rules beyond the CLI's defaults:
                 (0, debug_logger_1.logDiag)(sessionId, "compact:done-on-close");
                 session.compacting = false;
                 this.emitSystem(session, sessionId, "__compact::done");
+                const postCompactEstimate = {
+                    used: Math.round(session.contextWindowSize * 0.1),
+                    total: session.contextWindowSize,
+                };
+                session.contextUsage = postCompactEstimate;
+                session.emitter.emit("usage", sessionId, postCompactEstimate);
             }
             if (session.todoItems.length > 0 && session.todoItems.every((t) => t.status === "completed")) {
                 session.todoItems = [];
@@ -1428,6 +1995,153 @@ Additional Cockpit rules beyond the CLI's defaults:
             this.flushQueuedMessage(session, sessionId);
         });
     }
+    spawnPtyProcess(session, sessionId, text, images, documents) {
+        if (session.ptyRuntime?.isAlive) {
+            const existing = session.ptyRuntime;
+            session.ptyRuntime = null;
+            existing.kill().catch(() => { });
+        }
+        const hookRouter = (0, singleton_1.getHookRouter)();
+        if (!hookRouter) {
+            const msg = "PTY runtime requires the hook router; server boot did not register one";
+            this.log(sessionId, msg);
+            session.info.status = "idle";
+            session.emitter.emit("status", sessionId, "idle");
+            session.emitter.emit("error", sessionId, msg);
+            return;
+        }
+        this.log(sessionId, `spawning PTY claude (resume=${session.hasSpawnedBefore}, model=${session.info.model || "sonnet"})`);
+        (0, node_fs_1.mkdirSync)(session.info.cwd, { recursive: true });
+        const streamState = (0, stream_processor_1.createStreamState)();
+        session.streamState = streamState;
+        streamState.thinkingStartedAt = Date.now();
+        const extraArgs = [];
+        if (session.hasSpawnedBefore || (0, transcript_1.transcriptExists)(session.cliSessionId, session.info.cwd)) {
+            extraArgs.push("--resume", session.cliSessionId);
+        }
+        else {
+            extraArgs.push("--session-id", session.cliSessionId);
+        }
+        const resolvedPty = (0, providers_1.resolveProviderModel)(session.info.model ?? "sonnet");
+        const cliModelPty = resolvedPty ? resolvedPty.model.modelId : session.info.model;
+        if (cliModelPty)
+            extraArgs.push("--model", cliModelPty);
+        if (this.modelEffortLevels(session.info.model).length > 0) {
+            extraArgs.push("--effort", session.thinkingLevel);
+        }
+        if (session.planMode) {
+            extraArgs.push("--permission-mode", "plan");
+        }
+        else if (session.bypassAllPermissions) {
+            extraArgs.push("--permission-mode", "bypassPermissions");
+        }
+        const extraEnv = {};
+        if (resolvedPty)
+            Object.assign(extraEnv, resolvedPty.provider.envVars);
+        const sizeKeyPty = session.info.contextSize ?? models_1.DEFAULT_CONTEXT_SIZE;
+        if (models_1.CONTEXT_SIZES[sizeKeyPty].disableEnv) {
+            extraEnv.CLAUDE_CODE_DISABLE_1M_CONTEXT = "1";
+        }
+        if (session.modelSlots.subagent && session.modelSlots.subagent !== session.modelSlots.main) {
+            const resolvedSub = (0, providers_1.resolveProviderModel)(session.modelSlots.subagent);
+            extraEnv.ANTHROPIC_SMALL_FAST_MODEL = resolvedSub ? resolvedSub.model.modelId : session.modelSlots.subagent;
+        }
+        const runtime = new pty_runtime_1.PtyRuntime({
+            sessionId,
+            cwd: session.info.cwd,
+            cliSessionId: session.cliSessionId,
+            hookRouter,
+            claudeBin: getClaudeBin(),
+            extraArgs,
+            extraEnv,
+            onEvents: (events) => {
+                const types = events.map((e) => e.type).join(", ");
+                console.log(`[sm] pty onEvents for ${sessionId.slice(0, 8)}: [${types}]`);
+                const result = (0, stream_processor_1.processEvents)(events, streamState, { planMode: session.planMode, compacting: session.compacting });
+                this.applyProcessedResult(session, sessionId, result);
+            },
+            onError: (err) => {
+                this.log(sessionId, `pty runtime error: ${err}`);
+                session.emitter.emit("error", sessionId, err);
+            },
+            onExit: ({ exitCode, signal }) => {
+                this.log(sessionId, `PTY claude exited (code=${exitCode}, signal=${signal ?? "none"})`);
+                if (session.ptyRuntime !== runtime)
+                    return;
+                session.ptyRuntime = null;
+                session.streamingSnapshot = null;
+                (0, debug_logger_1.logDiag)(sessionId, "idle:pty-exit", { exitCode, flushedOnMessageDone: streamState.flushedOnMessageDone });
+                if (session.transcriptWatcher) {
+                    session.transcriptWatcher.stop();
+                    session.transcriptWatcher = null;
+                }
+                session.info.status = "idle";
+                session.emitter.emit("status", sessionId, "idle");
+                if (session.compacting) {
+                    (0, debug_logger_1.logDiag)(sessionId, "compact:done-on-pty-exit");
+                    session.compacting = false;
+                    this.emitSystem(session, sessionId, "__compact::done");
+                    const postCompactEstimate = {
+                        used: Math.round(session.contextWindowSize * 0.1),
+                        total: session.contextWindowSize,
+                    };
+                    session.contextUsage = postCompactEstimate;
+                    session.emitter.emit("usage", sessionId, postCompactEstimate);
+                }
+                if (session.todoItems.length > 0 && session.todoItems.every((t) => t.status === "completed")) {
+                    session.todoItems = [];
+                    session.emitter.emit("todos", sessionId, []);
+                }
+                if (!streamState.flushedOnMessageDone) {
+                    this.flushQueuedMessage(session, sessionId);
+                }
+            },
+        });
+        session.ptyRuntime = runtime;
+        session.hasSpawnedBefore = true;
+        this.cleanupAttachments(session);
+        const attachments = this.writeAttachments(images, documents);
+        session.attachmentPaths.push(...attachments);
+        const ptyText = text ? this.buildPtyText(text, attachments) : text;
+        const watcher = new transcript_watcher_1.TranscriptWatcher(session.cliSessionId, session.info.cwd, (messages, lastUsage) => {
+            session.emitter.emit("transcript", sessionId, messages);
+            if (lastUsage) {
+                const usage = { used: lastUsage.used, total: session.contextWindowSize };
+                session.contextUsage = usage;
+                session.emitter.emit("usage", sessionId, usage);
+            }
+            if (session.compacting && messages.some((m) => m.content === "__compacted__")) {
+                (0, debug_logger_1.logDiag)(sessionId, "compact:done-on-transcript");
+                session.compacting = false;
+                this.emitSystem(session, sessionId, "__compact::done");
+                const postCompactEstimate = {
+                    used: Math.round(session.contextWindowSize * 0.1),
+                    total: session.contextWindowSize,
+                };
+                session.contextUsage = postCompactEstimate;
+                session.emitter.emit("usage", sessionId, postCompactEstimate);
+                session.info.status = "idle";
+                session.emitter.emit("status", sessionId, "idle");
+                this.flushQueuedMessage(session, sessionId);
+            }
+        });
+        session.transcriptWatcher = watcher;
+        this.startTodoWatcher(session, sessionId);
+        runtime
+            .start(ptyText)
+            .then(() => {
+            this.log(sessionId, `PTY claude ready (pid=${runtime.pid})`);
+            watcher.start();
+        })
+            .catch((err) => {
+            const msg = err instanceof Error ? err.message : String(err);
+            this.log(sessionId, `pty runtime start failed: ${msg}`);
+            session.ptyRuntime = null;
+            session.info.status = "idle";
+            session.emitter.emit("status", sessionId, "idle");
+            session.emitter.emit("error", sessionId, msg);
+        });
+    }
     async loadAgentChildren(session, sessionId, messageId, cwd) {
         try {
             const result = await (0, transcript_1.loadTranscript)(session.cliSessionId, cwd);
@@ -1451,12 +2165,15 @@ Additional Cockpit rules beyond the CLI's defaults:
     }
 }
 exports.SessionManager = SessionManager;
-const MCP_CACHE_PATH = node_path_1.default.join((0, node_os_1.homedir)(), ".cockpit", "mcp-servers.json");
+function mcpCachePath() {
+    return node_path_1.default.join((0, paths_1.getCockpitDir)(), "mcp-servers.json");
+}
 function loadMcpServerCache() {
     try {
-        if (!(0, node_fs_1.existsSync)(MCP_CACHE_PATH))
+        const fp = mcpCachePath();
+        if (!(0, node_fs_1.existsSync)(fp))
             return [];
-        return JSON.parse((0, node_fs_1.readFileSync)(MCP_CACHE_PATH, "utf-8"));
+        return JSON.parse((0, node_fs_1.readFileSync)(fp, "utf-8"));
     }
     catch {
         return [];
@@ -1464,43 +2181,12 @@ function loadMcpServerCache() {
 }
 function saveMcpServerCache(servers) {
     try {
-        const dir = node_path_1.default.dirname(MCP_CACHE_PATH);
+        const fp = mcpCachePath();
+        const dir = node_path_1.default.dirname(fp);
         (0, node_fs_1.mkdirSync)(dir, { recursive: true });
-        (0, node_fs_1.writeFileSync)(MCP_CACHE_PATH, JSON.stringify(servers));
+        (0, node_fs_1.writeFileSync)(fp, JSON.stringify(servers));
     }
     catch {
         // best-effort
     }
 }
-// Walk messages newest-first, stop at the most recent /clear boundary, and
-// pull todos from the last TodoWrite call. Pure function so the history-view
-// branch can use it without an in-memory session.
-function extractTodosFromHistory(messages) {
-    for (let i = messages.length - 1; i >= 0; i--) {
-        const msg = messages[i];
-        if (msg.role === "system" && msg.content === "__compacted__")
-            return [];
-        if (msg.role !== "assistant")
-            continue;
-        for (let j = msg.toolUses.length - 1; j >= 0; j--) {
-            if (msg.toolUses[j].name !== "TodoWrite")
-                continue;
-            try {
-                const input = JSON.parse(msg.toolUses[j].input);
-                if (!Array.isArray(input.todos))
-                    return [];
-                return input.todos
-                    .filter((t) => t.content && t.status)
-                    .map((t) => ({
-                    content: t.content,
-                    status: t.status,
-                    activeForm: t.activeForm || undefined,
-                }));
-            }
-            catch {
-                return [];
-            }
-        }
-    }
-    return [];
-}