hammoc 1.5.0 → 1.7.0

package/packages/server/dist/handlers/websocket.js

@@ -7,13 +7,12 @@
 import { Server as SocketIOServer } from 'socket.io';
 import { existsSync, unlinkSync, readFileSync, readdirSync, statSync } from 'fs';
 import { randomUUID } from 'crypto';
-import { ERROR_CODES, IMAGE_CONSTRAINTS, parseQueueScript, TERMINAL_ERRORS, ROOT_BRANCH_KEY } from '@hammoc/shared';
+import { ERROR_CODES, IMAGE_CONSTRAINTS, parseQueueScript, TERMINAL_ERRORS, ROOT_BRANCH_KEY, effectiveModelIs1M } from '@hammoc/shared';
 import i18next from '../i18n.js';
 import { SUPPORTED_LANGUAGES } from '@hammoc/shared';
 import { isLocalIP, extractClientIP } from '../utils/networkUtils.js';
-import { query as sdkQuery } from '@anthropic-ai/claude-agent-sdk';
-import { ChatService } from '../services/chatService.js';
-import { SessionService } from '../services/sessionService.js';
+import { createChatEngine } from '../services/chatEngineFactory.js';
+import { SessionService, sessionService } from '../services/sessionService.js';
 import { parseSDKError, AbortedError, SDKErrorCode } from '../utils/errors.js';
 import { createSessionMiddleware } from '../middleware/session.js';
 import { config } from '../config/index.js';
@@ -22,7 +21,13 @@ import { preferencesService } from '../services/preferencesService.js';
 import { getOrCreateQueueService, getQueueInstances } from '../controllers/queueController.js';
 import { createLogger } from '../utils/logger.js';
 import { clampEffortForModel, supportsAdaptiveThinking } from '../utils/effortUtils.js';
+import { shouldForwardCliProgress, shouldForwardCliPtyMirror } from '../utils/cliEngineUtils.js';
+import { getCliScreen, getCliScreenStall, setCliScreenStall, deleteCliScreen } from '../services/cliScreenCache.js';
+import { createScreenStallWatchdog } from '../services/cliScreenStallWatchdog.js';
+import { modelMissingNative1MSupport } from '../utils/bundledBinaryModelSupport.js';
 import { buildStreamCallbacks } from './streamCallbacks.js';
+import { BackgroundTaskTracker } from '../utils/backgroundTaskTracker.js';
+import { createMcpCallRecorder } from '../services/observabilityService.js';
 import { rateLimitProbeService } from '../services/rateLimitProbeService.js';
 import { ptyService } from '../services/ptyService.js';
 import { projectService } from '../services/projectService.js';
@@ -37,6 +42,8 @@ import { isSnippetRef, resolveSnippet, listSnippets, SnippetError } from '../uti
 const log = createLogger('websocket');
 // Alias for concise usage in guards
 const queueInstances = getQueueInstances;
+// Defense B: models already warned about a stale-binary 1M fallback (warn once per model per process)
+const warnedMissing1M = new Set();
 // Socket-to-terminal mapping: socket.id → Set of terminalIds (Story 17.1)
 const socketTerminals = new Map();
 // Story 20.1: Session-to-project mapping for dashboard triggers
@@ -412,6 +419,25 @@ export function getActiveStreamSessionIds() {
         .filter(([, stream]) => stream.status === 'running')
         .map(([key]) => key);
 }
+/**
+ * Running streams for a project, with their captured first prompt. Used by the
+ * session list to surface a session whose JSONL file does not exist yet (the CLI
+ * boot window) and which the client may have already navigated away from — so it
+ * is no longer in getJoinedSessionIdsByProject. Prefers the synchronously-captured
+ * stream.projectSlug, falling back to the async-populated sessionProjectMap.
+ */
+export function getActiveStreamMetaByProject(projectSlug) {
+    const out = [];
+    for (const [sessionId, stream] of activeStreams.entries()) {
+        if (stream.status !== 'running')
+            continue;
+        const slug = stream.projectSlug ?? sessionProjectMap.get(sessionId);
+        if (slug !== projectSlug)
+            continue;
+        out.push({ sessionId, firstPrompt: stream.firstPrompt ?? '' });
+    }
+    return out;
+}
 /** Get active (running) session counts grouped by project slug (in-memory, no I/O) */
 export function getActiveSessionCountsByProject() {
     const counts = new Map();
@@ -918,6 +944,13 @@ export async function initializeWebSocket(httpServer) {
                 resumeSessionAt: data.resumeSessionAt,
                 expectedBranchTotal: data.expectedBranchTotal,
                 isFork: !!data.forkSession,
+                // Captured up front so a file-less waiting session (esp. the CLI boot window)
+                // can be listed for its project with a real preview even if the client has
+                // already left the session view (joinedIds would no longer include it).
+                projectSlug: data.workingDirectory
+                    ? sessionService.encodeProjectPath(data.workingDirectory)
+                    : undefined,
+                firstPrompt: data.content || undefined,
             };
             activeStreams.set(streamKey, stream);
             // Bump drain generation so any pending scheduled drain is invalidated
@@ -1064,31 +1097,43 @@ export async function initializeWebSocket(httpServer) {
                 return;
             const { mode, projectSlug } = data;
             const stream = activeStreams.get(sessionId);
-            // 1) Update SDK permission mode — only when stream is actively running
+            // Story 37.5: the CLI engine's setPermissionMode runs a live Shift+Tab closed loop and may
+            // LAND on a different mode than requested (fail-safe / off-cycle). setPermissionMode returns
+            // void (signature unchanged), so we read the *verified* applied mode back via
+            // getPermissionMode() and broadcast/persist THAT — not the inbound request value. Without the
+            // read-back the requested mode would be broadcast even on a fail-safe (the live screen never
+            // reached it), silently violating AC3 ("verified, not assumed"). SDK mode: getPermissionMode()
+            // == requested, so the read-back is a harmless no-op there.
+            let effectiveMode = mode;
+            let modeDiverged = false; // verified mode differed from the request (CLI fail-safe / off-cycle)
+            // 1) Update the engine's permission mode — only when stream is actively running
             if (stream?.chatService && stream.status === 'running') {
                 try {
                     await stream.chatService.setPermissionMode(mode);
-                    log.debug(`Permission mode changed to "${mode}" for session ${sessionId}`);
+                    effectiveMode = stream.chatService.getPermissionMode(); // verified (closed-loop) mode
+                    modeDiverged = effectiveMode !== mode;
+                    log.debug(`Permission mode requested "${mode}", applied "${effectiveMode}" for session ${sessionId}`);
                 }
                 catch (err) {
                     log.error('Failed to change permission mode:', err);
                     return; // Don't persist or broadcast a mode that failed to apply
                 }
             }
-            // Update pending chain items so the next drain uses the new mode.
-            // Outside the running-stream block because mode can change between turns
+            // Update pending chain items so the next drain uses the new mode. Use the verified mode so a
+            // CLI fail-safe also corrects the next-spawn posture (== request on every non-CLI/non-diverged
+            // path). Outside the running-stream block because mode can change between turns
             // (e.g., during the 1s chain drain delay when no stream is active).
             const chainItems = chainState.get(sessionId);
             if (chainItems) {
                 for (const item of chainItems) {
                     if (item.status === 'pending' || item.status === 'sending') {
-                        item.permissionMode = mode;
+                        item.permissionMode = effectiveMode;
                     }
                 }
             }
             // 2) Always persist per-session permission mode (read only when policy is 'always')
             // Use projectSlug from client as fallback when sessionProjectMap entry is gone (stream ended)
-            await persistSessionPermissionMode(sessionId, mode, projectSlug);
+            await persistSessionPermissionMode(sessionId, effectiveMode, projectSlug);
             // 3) Broadcast to other viewers based on sync policy
             let syncPolicy = 'always';
             try {
@@ -1100,8 +1145,16 @@ export async function initializeWebSocket(httpServer) {
             }
             if (syncPolicy === 'streaming' && stream?.status !== 'running')
                 return;
-            // 'always' or ('streaming' + running) → broadcast via Socket.io room
-            socket.to(`session:${sessionId}`).emit('permission:mode-change', { mode });
+            // 'always' or ('streaming' + running) → broadcast the VERIFIED mode via Socket.io room.
+            socket.to(`session:${sessionId}`).emit('permission:mode-change', { mode: effectiveMode });
+            // Story 37.5: originator convergence. The broadcast above excludes the sending socket
+            // (socket.to), so on a fail-safe (verified ≠ requested) the SENDER's selector would stay on
+            // the wrong requested value. Echo the verified mode back to the sender ONLY in that case; the
+            // normal path (verified == requested) leaves the sender's optimistic value correct, so no
+            // redundant self-echo is sent.
+            if (modeDiverged) {
+                socket.emit('permission:mode-change', { mode: effectiveMode });
+            }
         });
         // Handle session:join event — attach socket to active running stream (broadcast)
         // Also joins a persistent Socket.io room so future streams auto-include this socket.
@@ -1185,6 +1238,26 @@ export async function initializeWebSocket(httpServer) {
             if (alreadyJoinedSame) {
                 return;
             }
+            // Story 37.8: CLI mirror late-join / refresh sync. If this session has a cached screen
+            // frame (refreshed each ~100ms during a turn and at teardown), push it once to THIS
+            // socket so a newly-connected or refreshed browser initializes to the CURRENT claude
+            // screen (color intact), then follows live cli:screen-frame updates. Room-wide broadcast
+            // is unnecessary (sockets already in the room are live-current). A browser refresh
+            // reconnects with a NEW socket id, so it is past the alreadyJoinedSame dedup above and
+            // receives the frame — only a same-socket re-join is deduped. Cache miss (e.g. SDK mode,
+            // or before the first turn ends) → no emit, blank-screen fallback, unchanged from before.
+            const cachedScreen = getCliScreen(sessionId);
+            if (cachedScreen) {
+                socket.emit('cli:screen-frame', { sessionId, frame: cachedScreen });
+            }
+            // Resync the soft screen-stall flag (CLI mode). cli:screen-stall is emitted only on a
+            // stalled↔live transition, so a socket that joined / reconnected AFTER the stall began
+            // (tab switch, mobile sleep/wake) never saw it and would otherwise show a stale card.
+            // Re-send the current flag once so the stall notice matches reality. Only when stalled:
+            // the client resets the flag to false on stream restore, so a false needs no wire traffic.
+            if (getCliScreenStall(sessionId)) {
+                socket.emit('cli:screen-stall', { sessionId, stalled: true });
+            }
             if (!stream || stream.status !== 'running') {
                 // Story 27.1: Deliver buffer messages via stream:history (no HTTP fetch needed).
                 // Wrapped in a helper that re-checks activeStreams because the async
@@ -1299,6 +1372,32 @@ export async function initializeWebSocket(httpServer) {
             // NOW add to broadcast set — live events flow from here
             stream.sockets.add(socket);
         });
+        // Story 37.8: CLI mirror collapse/expand + remount restore. The mirror panel emits this
+        // (no payload) whenever it (re)mounts; resolve the socket's current session and push a
+        // one-time cli:screen-frame from the screen cache. A collapse/expand or panel remount does
+        // NOT re-fire session:join, so this control channel is how the panel pulls the current
+        // screen. Cache miss (SDK mode / before first turn / no session) → no-op.
+        socket.on('cli:request-screen-frame', () => {
+            const sid = socketToSession.get(socket.id) ?? socketSessionRoom.get(socket.id);
+            if (!sid)
+                return;
+            const cachedFrame = getCliScreen(sid);
+            if (cachedFrame) {
+                socket.emit('cli:screen-frame', { sessionId: sid, frame: cachedFrame });
+            }
+        });
+        // CLI debug log relay — client sends decision entries, server writes them to the
+        // per-session CLI debug log file alongside server-side entries.
+        socket.on('cli:debug-log', (data) => {
+            const sid = socketToSession.get(socket.id) ?? socketSessionRoom.get(socket.id);
+            if (!sid)
+                return;
+            const stream = activeStreams.get(sid);
+            const engine = stream?.chatService;
+            if (engine && 'currentDebugLog' in engine) {
+                engine.currentDebugLog?.clientWithTs(data.ts, data.ev, data.d);
+            }
+        });
         // Handle session:leave event — detach socket from current stream and session room
         // (client navigating away from a session while streaming continues in background)
         socket.on('session:leave', (sessionId) => {
@@ -1562,50 +1661,27 @@ export async function initializeWebSocket(httpServer) {
                 return;
             log.info(`session:rewind-files sessionId=${sessionId}, messageUuid=${messageUuid}, dryRun=${!!dryRun}`);
             try {
-                const sessionService = new SessionService();
-                const _projectSlug = sessionService.encodeProjectPath(workingDirectory);
-                const rewindQuery = sdkQuery({
-                    prompt: '',
-                    options: {
-                        resume: sessionId,
-                        cwd: workingDirectory,
-                        enableFileCheckpointing: true,
-                        // Do NOT pass sessionId here — CLI rejects --session-id
-                        // combined with --resume unless --fork-session is also set.
-                        // resume: sessionId already identifies the session.
-                    },
-                });
-                try {
-                    const rewindResult = await rewindQuery.rewindFiles(messageUuid, { dryRun: !!dryRun });
-                    log.info(`rewindFiles result: canRewind=${rewindResult.canRewind}, filesChanged=${rewindResult.filesChanged?.length ?? 0}, insertions=${rewindResult.insertions ?? 0}, deletions=${rewindResult.deletions ?? 0}`);
-                    if (rewindResult.canRewind) {
-                        socket.emit('session:rewind-result', {
-                            success: true,
-                            dryRun: !!dryRun,
-                            filesChanged: rewindResult.filesChanged,
-                            insertions: rewindResult.insertions,
-                            deletions: rewindResult.deletions,
-                        });
-                    }
-                    else {
-                        socket.emit('session:rewind-result', {
-                            success: false,
-                            dryRun: !!dryRun,
-                            error: rewindResult.error,
-                        });
-                    }
+                // Standalone rewind is now a ChatEngine operation (Story 32.3) — the SDK
+                // mechanism (throwaway resume query + markRewindDirty + close) lives
+                // behind the seam in ChatService.rewindFiles. The handler keeps only the
+                // transport concerns: result → session:rewind-result mapping.
+                const engine = createChatEngine(await projectService.getEffectiveEngineMode(workingDirectory), { workingDirectory });
+                const result = await engine.rewindFiles({ sessionId, messageUuid, dryRun: !!dryRun });
+                if (result.canRewind) {
+                    socket.emit('session:rewind-result', {
+                        success: true,
+                        dryRun: !!dryRun,
+                        filesChanged: result.filesChanged,
+                        insertions: result.insertions,
+                        deletions: result.deletions,
+                    });
                 }
-                finally {
-                    // Mark session as dirty BEFORE close — SDK query({ prompt: '' })
-                    // writes an empty user message to the JSONL which causes
-                    // cache_control 400 errors. chatService will clean the JSONL
-                    // before the next resume.
-                    sessionService.markRewindDirty(workingDirectory, sessionId);
-                    // Clean up the query object
-                    try {
-                        rewindQuery.close();
-                    }
-                    catch { /* best-effort */ }
+                else {
+                    socket.emit('session:rewind-result', {
+                        success: false,
+                        dryRun: !!dryRun,
+                        error: result.error,
+                    });
                 }
             }
             catch (err) {
@@ -2090,6 +2166,9 @@ export async function initializeWebSocket(httpServer) {
                     // Only destroy if no active stream (streaming continues in background)
                     if (!activeStreams.has(disconnectSessionId)) {
                         sessionBufferManager.destroy(disconnectSessionId);
+                        // Story 37.7: drop the CLI mirror screen cache on the same room-empty seam
+                        // (no observer left to sync) so the session-lifetime Map does not leak.
+                        deleteCliScreen(disconnectSessionId);
                     }
                     // Notify session list viewers when no sockets remain for this session
                     const slug = socketProjectRoom.get(socket.id) || sessionProjectMap.get(disconnectSessionId);
@@ -2183,6 +2262,45 @@ export async function broadcastSnippetList(workingDirectory, originSocketId) {
         log.warn(`broadcastSnippetList failed for socket ${originSocketId}: ${String(err)}`);
     }
 }
+/**
+ * Broadcast a global-preferences change to every OTHER connected browser
+ * (multi-device settings sync). The originating socket is excluded so it never
+ * receives its own echo — it already applied the change optimistically. With no
+ * origin id (e.g. a non-browser caller) the change goes to everyone.
+ */
+export function broadcastPreferencesChange(preferences, originSocketId) {
+    try {
+        // Strip credential-bearing fields — telegram/webPush are managed via
+        // dedicated (masked) endpoints and must not be broadcast in plaintext to
+        // other browsers. Clients keep their existing values for these (merge).
+        const safe = { ...preferences };
+        delete safe.telegram;
+        delete safe.webPush;
+        // theme & diffLayout are device-local (each browser's localStorage, not the server) —
+        // broadcasting them would yank another device's theme / diff layout. Never sync them.
+        delete safe.theme;
+        delete safe.diffLayout;
+        const target = originSocketId ? io.except(originSocketId) : io;
+        target.emit('preferences:changed', { preferences: safe });
+    }
+    catch (err) {
+        log.warn(`broadcastPreferencesChange failed: ${String(err)}`);
+    }
+}
+/**
+ * Broadcast a project-settings change to OTHER browsers (multi-device sync).
+ * Sent to everyone except the origin socket; the payload is keyed by projectSlug
+ * so each client applies it only while viewing that project's settings.
+ */
+export function broadcastProjectSettingsChange(projectSlug, settings, originSocketId) {
+    try {
+        const target = originSocketId ? io.except(originSocketId) : io;
+        target.emit('project:settings-changed', { projectSlug, settings });
+    }
+    catch (err) {
+        log.warn(`broadcastProjectSettingsChange failed: ${String(err)}`);
+    }
+}
 /**
  * Get the current number of connected clients
  * @returns Number of connected clients
@@ -2294,10 +2412,14 @@ async function handleChatSend(stream, data, abortController, lang) {
     const sessionService = new SessionService();
     const projectSlug = sessionService.encodeProjectPath(workingDirectory);
     // Story 27.2: Store images as files, emit URL-based ImageRef[] instead of base64.
+    // CLI engine (image support): also resolve the on-disk absolute paths so the CLI path
+    // can reference attachments by --add-dir + prompt (it can't embed base64 over the PTY).
+    let attachedImagePaths = [];
     if (!forkSession) {
         let imageRefs;
         if (images && images.length > 0) {
             imageRefs = await imageStorageService.storeImages(projectSlug, sessionId || '', images);
+            attachedImagePaths = imageStorageService.resolveImagePaths(projectSlug, sessionId || '', images);
         }
         emit('user:message', {
             content,
@@ -2364,6 +2486,14 @@ async function handleChatSend(stream, data, abortController, lang) {
         }
     }
     let timeoutId = null;
+    // CLI screen-stall watchdog — assigned once prefs/engineMode are known (below). Declared at the
+    // function scope so the finally can dispose() it (a try-block `const` wouldn't be in scope there).
+    let stallWatchdog = null;
+    // Story 35.1: when true the inactivity timer is paused because we're awaiting
+    // user input (permission approval / AskUserQuestion selection). resetTimeout()
+    // short-circuits while this is set so no activity can re-arm the timer, and
+    // canUseTool clears it + re-arms once the user responds.
+    let permissionWaiting = false;
     // Snapshot JSONL files before SDK query to detect phantom checkpoint files.
     // The SDK's file checkpointing creates separate JSONL files (new UUIDs) with
     // only file-history-snapshot entries alongside the real session file. These
@@ -2380,12 +2510,20 @@ async function handleChatSend(stream, data, abortController, lang) {
         // Non-critical — cleanup will be skipped if snapshot fails
     }
     try {
-        const chatService = new ChatService({ workingDirectory, permissionMode });
-        stream.chatService = chatService;
         // Load preferences early for advanced settings + timeout
         const effectivePrefs = await preferencesService.getEffectivePreferences();
+        // Story 33.3: resolve the effective engine mode (override > global > 'sdk' default).
+        // Captured once into a local so the progress-callback gating below reuses the same
+        // decision (no second resolve, and `engineMode === 'cli'` stays consistent).
+        const engineMode = await projectService.getEffectiveEngineMode(workingDirectory);
+        // Auto-compaction master switch (both engines). Default ON. Gates the engine-internal
+        // auto-compact (forwarded into each engine's settings) AND Hammoc's overflow-triggered
+        // /compact recovery below, so one toggle controls all auto-compaction.
+        const autoCompactEnabled = effectivePrefs.autoCompactEnabled ?? true;
+        const chatService = createChatEngine(engineMode, { workingDirectory, permissionMode, cliBinaryPath: effectivePrefs.cliBinaryPath, cliShowThinkingSummaries: effectivePrefs.cliShowThinkingSummaries, cliResumeChoice: effectivePrefs.cliResumeChoice, autoCompactEnabled, planModeBypassBehavior: effectivePrefs.planModeBypassBehavior });
+        stream.chatService = chatService;
         const effectiveEffort = clampEffortForModel(effort ?? effectivePrefs.defaultEffort, model);
-        // Opus 4.7 flipped `thinking.display` default to 'omitted' — ThinkingBlock UI stays blank
+        // Opus 4.7+ flipped `thinking.display` default to 'omitted' — ThinkingBlock UI stays blank
         // unless we explicitly opt in. For adaptive-thinking models, forward an explicit `thinking`
         // config based on the user's showThinkingBlocks preference (Hammoc default: true).
         // Legacy models (Sonnet 4.5, Opus 4.5, Haiku, Sonnet 4) keep the `maxThinkingTokens` path
@@ -2399,11 +2537,17 @@ async function handleChatSend(stream, data, abortController, lang) {
             ...(isResuming ? { resume: sessionId } : { sessionId }),
             abortController,
             model,
-            images,
+            // SDK mode embeds base64 image blocks directly; CLI mode can't (the PTY is
+            // text-only), so it instead receives the on-disk paths resolved above and
+            // references them via --add-dir + an explicit prompt instruction. Each engine
+            // ignores the other's field, so we only send the one that applies.
+            ...(engineMode === 'cli'
+                ? (attachedImagePaths.length > 0 ? { attachedImagePaths } : {})
+                : { images }),
             // Advanced settings from preferences
             customSystemPrompt: effectivePrefs.customSystemPrompt,
             // maxThinkingTokens: legacy path; SDK docs say it takes precedence for backward-compat,
-            // which conflicts with adaptive mode on Opus 4.7 (rejects enabled+budget). Skip on
+            // which conflicts with adaptive mode on Opus 4.7+ (rejects enabled+budget). Skip on
             // adaptive-capable models so the explicit `thinking` field governs.
             ...(!adaptiveCapable && { maxThinkingTokens: effectivePrefs.maxThinkingTokens }),
             ...(thinkingConfig && { thinking: thinkingConfig }),
@@ -2449,6 +2593,10 @@ async function handleChatSend(stream, data, abortController, lang) {
                 sessionId: sessionIdRef.current || '',
                 toolCall: { id: requestId, name: toolName, input },
                 requiresApproval: true,
+                // CLI engine emits no tool:call, so a normal-tool permission has no tool card to
+                // attach to — tell the client to render it as an independent card. AskUserQuestion
+                // already renders independently (client keys off the tool name), so exclude it.
+                standalone: engineMode === 'cli' && !isAskUserQuestion,
             });
             // Notify via Telegram if no socket connected (or alwaysNotify enabled)
             if (notificationService.shouldNotify(stream.sockets.size)) {
@@ -2457,38 +2605,59 @@ async function handleChatSend(stream, data, abortController, lang) {
                     : `${toolName}`;
                 notificationService.notifyInputRequired(stream.sessionId, toolName, prompt);
             }
-            // Wait for user response — Promise stays pending if no socket connected
-            const userResponse = await new Promise((resolve) => {
-                stream.pendingPermissions.set(requestId, {
-                    resolve,
-                    interactionType: isAskUserQuestion ? 'question' : 'permission',
+            // Story 35.1: pause the inactivity timer for the input-wait. Waiting on a human
+            // (permission approval / AskUserQuestion selection) is by-design indefinite —
+            // "respond when you can" — so the activity-based timeout must not fire here. Stop
+            // it on the way in; the finally below resumes it on EVERY exit path. Generation-hang
+            // detection is unaffected: the timer still governs all activity outside this wait.
+            permissionWaiting = true;
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+                timeoutId = null;
+            }
+            try {
+                // Wait for user response — Promise stays pending if no socket connected
+                const userResponse = await new Promise((resolve) => {
+                    stream.pendingPermissions.set(requestId, {
+                        resolve,
+                        interactionType: isAskUserQuestion ? 'question' : 'permission',
+                    });
                 });
-            });
-            if (isAskUserQuestion) {
-                const questions = input.questions;
-                let answers;
-                if (typeof userResponse.response === 'object' && !Array.isArray(userResponse.response) && userResponse.response !== null) {
-                    answers = userResponse.response;
+                if (isAskUserQuestion) {
+                    const questions = input.questions;
+                    let answers;
+                    if (typeof userResponse.response === 'object' && !Array.isArray(userResponse.response) && userResponse.response !== null) {
+                        answers = userResponse.response;
+                    }
+                    else {
+                        const answer = typeof userResponse.response === 'string'
+                            ? userResponse.response
+                            : Array.isArray(userResponse.response) ? userResponse.response.join(', ') : '';
+                        answers = { [questions[0].question]: answer };
+                    }
+                    log.info(`[canUseTool] AskUserQuestion result: questionCount=${questions.length}, answerCount=${Object.keys(answers).length}, responseType=${typeof userResponse.response}, isArray=${Array.isArray(userResponse.response)}, answerKeys=${JSON.stringify(Object.keys(answers))}`);
+                    return {
+                        behavior: 'allow',
+                        updatedInput: {
+                            questions,
+                            answers,
+                        },
+                    };
+                }
+                if (userResponse.approved) {
+                    return { behavior: 'allow', updatedInput: input };
                 }
                 else {
-                    const answer = typeof userResponse.response === 'string'
-                        ? userResponse.response
-                        : Array.isArray(userResponse.response) ? userResponse.response.join(', ') : '';
-                    answers = { [questions[0].question]: answer };
-                }
-                return {
-                    behavior: 'allow',
-                    updatedInput: {
-                        questions,
-                        answers,
-                    },
-                };
-            }
-            if (userResponse.approved) {
-                return { behavior: 'allow', updatedInput: input };
+                    return { behavior: 'deny', message: 'User denied permission', interrupt: true };
+                }
             }
-            else {
-                return { behavior: 'deny', message: 'User denied permission', interrupt: true };
+            finally {
+                // Story 35.1: resume on EVERY exit path (resolve / throw / early return). Clear
+                // the pause FIRST so resetTimeout's guard lets this call re-arm the timer; later
+                // SDK activity then resets it normally. Skipping this would leave hang-detection
+                // disabled for the rest of the turn.
+                permissionWaiting = false;
+                resetTimeout('permission-resolved');
             }
         };
         // Activity-based timeout: resets on every SDK callback event
@@ -2496,8 +2665,24 @@ async function handleChatSend(stream, data, abortController, lang) {
         // Timeout value from preferences (with env var override), clamped to 5s–30min range
         const rawTimeoutMs = effectivePrefs.chatTimeoutMs ?? config.chat.timeoutMs;
         const timeoutMs = (rawTimeoutMs >= 5000 && rawTimeoutMs <= 1800000) ? rawTimeoutMs : 300000;
+        // CLI mode has NO inactivity timeout. The activity-based timeout is an SDK-mode safeguard
+        // against a silently-stalled query; in CLI mode it does more harm than good — a turn can be
+        // legitimately quiet (deep thinking, a long tool run) yet the spinner stops repainting, so the
+        // timer would abort healthy work. The genuine stuck case it used to (slowly, confusingly) catch
+        // is now handled directly: the usage-limit notice is detected on the PTY and fails the turn
+        // immediately (cliChatEngine.detectUsageLimit), and a crashed REPL surfaces via pty.onExit.
+        // Anything else ends via end_turn or the user's Stop button. So CLI never arms the timer.
+        const isCliEngine = engineMode === 'cli';
         let lastResetSource = 'initial';
         const resetTimeout = (source) => {
+            if (isCliEngine)
+                return; // CLI mode: no inactivity timeout (see above)
+            // Story 35.1: while awaiting user input (permission / AskUserQuestion) the timer
+            // is paused — ignore every activity-driven reset (onActivity, raw PTY frames,
+            // compact/retry) so the wait stays indefinite. canUseTool clears the pause and
+            // calls this once to re-arm when the user responds.
+            if (permissionWaiting)
+                return;
             if (source)
                 lastResetSource = source;
             if (timeoutId)
@@ -2508,6 +2693,71 @@ async function handleChatSend(stream, data, abortController, lang) {
             }, timeoutMs);
         };
         resetTimeout('initial');
+        // CLI screen-stall watchdog (soft, advisory — see cliScreenStallWatchdog). The reconstructed
+        // screen changes ~1×/second while claude is healthy (spinner glyph + ticking clock), so a long
+        // flat-line of NO change is a reliable "claude froze" signal — unlike the removed inactivity
+        // timeout, which watched JSONL activity that legitimately pauses during thinking. We do NOT
+        // auto-abort: emit a soft `cli:screen-stall` so the UI can offer a Stop. CLI mode only, driven by
+        // the mirror frames (so it follows the mirror gate), clamped to 5s–10min (0 = off). Fires only on
+        // a still-running, non-modal turn; disposed at turn end so a stale timer can't leak into the next.
+        const rawStallMs = effectivePrefs.cliScreenStallMs ?? 20000;
+        const screenStallMs = (engineMode !== 'cli' || rawStallMs <= 0)
+            ? 0
+            : Math.min(Math.max(rawStallMs, 5000), 600000);
+        stallWatchdog = createScreenStallWatchdog({
+            stallMs: screenStallMs,
+            isActive: () => stream.status === 'running' && !permissionWaiting,
+            onStallChange: (stalled) => {
+                // Mirror onto the session screen cache so a late-join / reconnect can resync this
+                // transition-only signal (see session:join above). sessionId is set by the time a turn
+                // streams, but it's typed optional at this scope — guard so the cache key is never empty.
+                if (sessionId)
+                    setCliScreenStall(sessionId, stalled);
+                emit('cli:screen-stall', { sessionId, stalled });
+            },
+        });
+        // Story 32.7: forward the CLI engine's transient generation-progress counter
+        // ("↓ N tokens · Ns" parsed from the spinner) to the browser. Live-only — the
+        // client skips it on buffer replay (mirrors tool:progress). The SDK engine never
+        // calls this (real token streaming makes it unnecessary). Defined once and passed
+        // as the 6th arg to every sendMessageWithCallbacks below; the queue path omits it
+        // (no live progress UI there — the same asymmetry as onRawMessage).
+        const onGenerationProgress = (progress) => {
+            emit('generation:progress', progress);
+        };
+        // Story 36.2: CLI pre-generation phase (launching/submitting/waiting/null). Same
+        // transient/live-only semantics and the SAME gating as the progress counter below.
+        const onPhase = (phase) => {
+            emit('cli:phase', { phase });
+        };
+        // Story 37.8: full-screen mirror frame. The CLI engine serializes the headless emulator's
+        // CURRENT screen (color intact) and paces it to ~100ms; forward each frame to the room so
+        // the read-only mirror renders the actual claude screen. Self-contained (a whole screen,
+        // not a delta), so the same frame restores a late-join / refresh / collapse-expand. The
+        // session:join + cli:request-screen-frame paths reuse this same event from the cache.
+        const onScreenFrame = (frame) => {
+            stallWatchdog?.noteFrame(frame); // soft screen-stall watchdog (CLI mode; no-op when disabled)
+            emit('cli:screen-frame', { sessionId, frame });
+        };
+        // Story 33.3: gate the progress counter on CLI mode + the user's preference (default
+        // ON, Story 33.2). In SDK mode the engine ignores the callback anyway; passing
+        // `undefined` makes the gate explicit so the 'cli' + pref-OFF case emits nothing.
+        const cliProgress = shouldForwardCliProgress(engineMode, effectivePrefs.cliShowGenerationProgress);
+        const generationProgressCb = cliProgress ? onGenerationProgress : undefined;
+        const cliPhaseCb = cliProgress ? onPhase : undefined;
+        // Mirror gate — a SEPARATE preference (default ON, opt-out), independent of the progress
+        // gate. Forwarded unless the user explicitly turned the mirror off.
+        const screenFrameCb = shouldForwardCliPtyMirror(engineMode, effectivePrefs.cliPtyMirror) ? onScreenFrame : undefined;
+        // Story 37.8: mirror refresh interval (ms) — the user's preference, applied as the engine's
+        // trailing-throttle interval. undefined → engine default (200ms). Harmless when the mirror is off.
+        const mirrorThrottleMs = effectivePrefs.cliMirrorThrottleMs;
+        const backgroundTracker = new BackgroundTaskTracker((state) => {
+            emit('background:waiting', {
+                sessionId: sessionIdRef.current ?? sessionId,
+                waiting: state.waiting,
+                pendingCount: state.pending,
+            });
+        });
         // Build shared callbacks (common logic for browser & queue paths)
         const { callbacks, sessionIdRef } = buildStreamCallbacks({
             emit,
@@ -2518,6 +2768,11 @@ async function handleChatSend(stream, data, abortController, lang) {
             rekeyStream: (sid) => rekeyStream(stream, sid),
             broadcastStreamChange,
             notificationService,
+            // Story 31.3 — browser path resolves projectSlug from the working dir
+            // (async; memoized by the recorder). append is read-only so the lazy
+            // slug resolution cannot disrupt the stream.
+            mcpRecorder: createMcpCallRecorder(() => projectService.findProjectByPath(workingDirectory).then((p) => p?.projectSlug)),
+            backgroundTracker,
         }, {
             onCallbackActivity: (source) => resetTimeout(source),
             onSessionIdResolved: (sid) => {
@@ -2611,9 +2866,28 @@ async function handleChatSend(stream, data, abortController, lang) {
                 origOnError?.(error);
             };
         }
+        // Defense B: if the bundled engine doesn't recognize this native-1M model, its
+        // 1M context silently falls back to ~200K (long sessions then compact early and
+        // can break on resume). Warn once per model so the fallback isn't invisible.
+        // Non-blocking: the binary scan must not delay the query.
+        // Only warn when 1M is actually intended (Opus auto, or an explicit `[1m]`
+        // opt-in). A bare Sonnet now runs at 200K by design — warning there would be
+        // a false alarm about a window the user never asked for.
+        const warnModel = model;
+        if (warnModel && effectiveModelIs1M(warnModel) && !warnedMissing1M.has(warnModel)) {
+            void modelMissingNative1MSupport(warnModel).then((missing) => {
+                if (missing && !warnedMissing1M.has(warnModel)) {
+                    warnedMissing1M.add(warnModel);
+                    log.warn(`Bundled Claude Code engine does not recognize model "${warnModel}" — native 1M context will not apply (falls back to ~200K). Update @anthropic-ai/claude-agent-sdk.`);
+                    emit('system:info', { message: `⚠️ "${warnModel}" 1M context is not active — the bundled engine doesn't recognize this model yet, so it's limited to ~200K. Update @anthropic-ai/claude-agent-sdk to enable the full 1M window.` });
+                }
+            }).catch(() => { });
+        }
         try {
             const sendResult = await chatService.sendMessageWithCallbacks(content, callbacks, chatOptions, canUseTool, (messageType) => {
                 resetTimeout(`raw:${messageType}`);
+            }, generationProgressCb, cliPhaseCb, screenFrameCb, mirrorThrottleMs, backgroundTracker, (mode) => {
+                emit('permission:mode-change', { mode });
             });
             // SDK may return "No conversation found" as an error result (not a thrown exception).
             // Convert to a thrown error so the retry logic below can handle it.
@@ -2638,6 +2912,7 @@ async function handleChatSend(stream, data, abortController, lang) {
             // /compact is a CLI-level command processed before context evaluation,
             // so it works even when context is overflowing.
             if (isResumeAttempt
+                && autoCompactEnabled
                 && parsedError.code === SDKErrorCode.CONTEXT_OVERFLOW
                 && !abortController.signal.aborted
                 && !hasEmittedOutput) {
@@ -2650,12 +2925,16 @@ async function handleChatSend(stream, data, abortController, lang) {
                 // Run /compact to shrink context (preserves session file)
                 await chatService.sendMessageWithCallbacks('/compact', callbacks, chatOptions, canUseTool, (messageType) => {
                     resetTimeout(`compact:${messageType}`);
+                }, generationProgressCb, cliPhaseCb, screenFrameCb, mirrorThrottleMs, backgroundTracker, (mode) => {
+                    emit('permission:mode-change', { mode });
                 });
                 // Retry the original message after compaction
                 log.info(`[AUTO-COMPACT] compaction done, retrying original message: sessionId=${sessionId}`);
                 resetTimeout('auto-compact-retry');
                 await chatService.sendMessageWithCallbacks(content, callbacks, chatOptions, canUseTool, (messageType) => {
                     resetTimeout(`retry:${messageType}`);
+                }, generationProgressCb, cliPhaseCb, screenFrameCb, mirrorThrottleMs, backgroundTracker, (mode) => {
+                    emit('permission:mode-change', { mode });
                 });
                 // Resume failed for other unknown reasons — retry without resume (fresh session).
                 // Guards:
@@ -2694,6 +2973,8 @@ async function handleChatSend(stream, data, abortController, lang) {
                 resetTimeout('resume-retry');
                 await chatService.sendMessageWithCallbacks(content, callbacks, retryOptions, canUseTool, (messageType) => {
                     resetTimeout(`raw:${messageType}`);
+                }, generationProgressCb, cliPhaseCb, screenFrameCb, mirrorThrottleMs, backgroundTracker, (mode) => {
+                    emit('permission:mode-change', { mode });
                 });
             }
             else {
@@ -2712,13 +2993,20 @@ async function handleChatSend(stream, data, abortController, lang) {
         const sdkError = parseSDKError(error, lang);
         log.info(`[CHAIN-DRAIN] handleChatSend catch: sessionId=${stream.sessionId}, aborted=${abortController.signal.aborted}, reason=${abortController.signal.reason}, error=${sdkError.message.slice(0, 120)}`);
         if (sdkError instanceof AbortedError || abortController.signal.aborted) {
-            if (abortController.signal.reason === 'user-abort' || abortController.signal.reason === 'another-client') {
+            const abortReason = abortController.signal.reason;
+            if (abortReason === 'user-abort' || abortReason === 'another-client') {
                 return false;
             }
-            emit('error', {
-                code: ERROR_CODES.TIMEOUT_ERROR,
-                message: t('ws.error.timeout'),
-            });
+            // Only a genuine inactivity timeout (abortController.abort('timeout'), SDK mode) is a "timeout".
+            // Any OTHER abort/interruption surfaces its real message instead of a misleading "응답 시간 초과"
+            // — that catch-all previously masked e.g. a CLI boot-readiness failure across several debugging
+            // cycles (the user saw "timeout" for what was actually a resume-classify abort).
+            if (abortReason === 'timeout') {
+                emit('error', { code: ERROR_CODES.TIMEOUT_ERROR, message: t('ws.error.timeout') });
+            }
+            else {
+                emit('error', { code: ERROR_CODES.CHAT_ERROR, message: sdkError.message });
+            }
             return false;
         }
         emit('error', {
@@ -2731,6 +3019,10 @@ async function handleChatSend(stream, data, abortController, lang) {
         if (timeoutId) {
             clearTimeout(timeoutId);
         }
+        // Screen-stall watchdog teardown: clear the pending timer so a stale fire can't leak into the
+        // NEXT turn (the stream object is reused and its status flips back to 'running'), and drop any
+        // active stall so every viewer's "looks stuck?" affordance clears when the turn ends.
+        stallWatchdog?.dispose();
         // Delete phantom checkpoint files created by SDK file checkpointing.
         // These are separate JSONL files (new UUIDs) containing only
         // file-history-snapshot entries. The same snapshot data already exists