funolio-agent 1.0.53 → 1.1.65

package/dist/local-cli-pty-manager.js

@@ -34,18 +34,344 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalCliPtySessionManager = void 0;
+exports.detectCliInteractiveAuthFailureForTest = detectCliInteractiveAuthFailureForTest;
+exports.normalizeClaudeFreshSessionAuthErrorForTest = normalizeClaudeFreshSessionAuthErrorForTest;
+exports.shouldResetClaudeSessionForAuthChangeForTest = shouldResetClaudeSessionForAuthChangeForTest;
+exports.shouldRecycleClaudeSessionForFreshAuthForTest = shouldRecycleClaudeSessionForFreshAuthForTest;
+exports.resolveClaudeLaunchSessionIdsForTest = resolveClaudeLaunchSessionIdsForTest;
+exports.shouldContinueWaitingForFreshClaudeSessionForTest = shouldContinueWaitingForFreshClaudeSessionForTest;
+exports.buildTurnPromptForTest = buildTurnPromptForTest;
+exports.shouldIgnoreClaudeRecordForCurrentTurnForTest = shouldIgnoreClaudeRecordForCurrentTurnForTest;
+exports.stripAnsi = stripAnsi;
+exports.resolveConptyOverwrites = resolveConptyOverwrites;
+exports.getProviderSessionRootForTest = getProviderSessionRootForTest;
+exports.emitAssistantChunkSequenceForTest = emitAssistantChunkSequenceForTest;
 exports.parseClaudeSessionRecord = parseClaudeSessionRecord;
 exports.parseCodexSessionRecord = parseCodexSessionRecord;
+exports.trimPassthroughSlashChromeForTest = trimPassthroughSlashChromeForTest;
+exports.finalizePassthroughContentForTest = finalizePassthroughContentForTest;
 exports.getLocalCliPtySessionManager = getLocalCliPtySessionManager;
+exports.runLocalCliPtyHealthCheck = runLocalCliPtyHealthCheck;
+exports.runLocalCliPtyTurnHealthCheck = runLocalCliPtyTurnHealthCheck;
+exports.runLocalCliPtyProbe = runLocalCliPtyProbe;
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
+const module_1 = require("module");
 const claude_cli_prompt_1 = require("./providers/claude-cli-prompt");
+const live_activity_1 = require("./live-activity");
+const completion_marker_1 = require("./completion-marker");
+const sync_cli_config_1 = require("./mcp/sync-cli-config");
+const credential_reader_1 = require("./auth/credential-reader");
+const token_refresh_1 = require("./auth/token-refresh");
+const managed_process_registry_1 = require("./managed-process-registry");
+const CLAUDE_FRESH_SESSION_STARTUP_INITIAL_TIMEOUT_MS = 10_000;
+const CLAUDE_FRESH_SESSION_STARTUP_PROGRESS_STALL_MS = 10_000;
+const CLAUDE_FRESH_SESSION_STARTUP_MAX_TIMEOUT_MS = 30_000;
+const CLAUDE_PTY_INACTIVITY_FAIL_TIMEOUT_MS = 60_000;
+const PASSTHROUGH_FIRST_BYTE_TIMEOUT_MS = 10_000;
+const PASSTHROUGH_TRAILING_IDLE_MS = 2_000;
+const CLI_WARM_TIMEOUT_MS = 10_000;
+function getPtyInactivityFailTimeoutMs(provider) {
+    if (provider === 'claude-cli')
+        return CLAUDE_PTY_INACTIVITY_FAIL_TIMEOUT_MS;
+    return null;
+}
 let _ptyModule = null;
 let _manager = null;
 function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function fileFingerprint(filePath) {
+    if (!filePath)
+        return null;
+    try {
+        const stat = fs.statSync(filePath);
+        return [stat.dev, stat.ino, stat.size, Math.floor(stat.mtimeMs)].join(':');
+    }
+    catch {
+        return null;
+    }
+}
+function currentClaudeAuthFingerprint() {
+    return fileFingerprint((0, sync_cli_config_1.resolveClaudeCredentialsSourcePath)());
+}
+function appendRecentTerminalOutput(existing, chunk) {
+    const combined = `${existing || ''}${normalizeTerminalChunk(chunk || '')}`;
+    return combined.length > 4000 ? combined.slice(-4000) : combined;
+}
+const CLI_INTERACTIVE_AUTH_FAILURE_RE = /\b(not logged in|please run \/login|login required|unauthorized|invalid authorization|invalid api key|missing api key|authentication required|invalid authentication credentials|invalid bearer token|token expired|session expired|credentials expired|expired credentials|reauthenticate)\b/i;
+function isCliInteractiveAuthFailureText(text) {
+    return CLI_INTERACTIVE_AUTH_FAILURE_RE.test(text);
+}
+function detectCliInteractiveAuthFailure(provider, terminalOutput) {
+    if (!isCliInteractiveAuthFailureText(terminalOutput))
+        return null;
+    if (provider === 'claude-cli') {
+        return {
+            message: 'Claude authentication is required before this request can continue.',
+            detail: 'Claude authentication is required. Opening subscription login...',
+            providerId: 'claude-cli',
+            cli: 'claude',
+        };
+    }
+    if (provider === 'codex-cli') {
+        return {
+            message: 'Codex authentication is required before this request can continue.',
+            detail: 'Codex authentication is required. Opening subscription login...',
+            providerId: 'codex-cli',
+            cli: 'codex',
+        };
+    }
+    return null;
+}
+function detectCliInteractiveAuthFailureAcrossOutputs(provider, ...terminalOutputs) {
+    for (const output of terminalOutputs) {
+        const auth = detectCliInteractiveAuthFailure(provider, String(output || ''));
+        if (auth)
+            return auth;
+    }
+    return null;
+}
+function buildCliInteractiveAuthError(provider, terminalOutput) {
+    const auth = detectCliInteractiveAuthFailure(provider, terminalOutput);
+    if (!auth)
+        return null;
+    const err = new Error(auth.message);
+    err.authRequired = true;
+    err.providerId = auth.providerId;
+    err.cli = auth.cli;
+    return err;
+}
+function buildCliInteractiveAuthErrorFromOutputs(provider, ...terminalOutputs) {
+    const auth = detectCliInteractiveAuthFailureAcrossOutputs(provider, ...terminalOutputs);
+    if (!auth)
+        return null;
+    const err = new Error(auth.message);
+    err.authRequired = true;
+    err.providerId = auth.providerId;
+    err.cli = auth.cli;
+    return err;
+}
+function detectCliInteractiveAuthFailureForTest(provider, ...terminalOutputs) {
+    return detectCliInteractiveAuthFailureAcrossOutputs(provider, ...terminalOutputs);
+}
+function buildAbortError() {
+    const abortErr = new Error('PTY turn aborted');
+    abortErr.name = 'AbortError';
+    return abortErr;
+}
+function buildCliAuthRequiredError(provider) {
+    if (provider === 'claude-cli') {
+        const err = new Error('Claude authentication is required before this request can continue.');
+        err.authRequired = true;
+        err.providerId = 'claude-cli';
+        err.cli = 'claude';
+        return err;
+    }
+    const err = new Error('Codex authentication is required before this request can continue.');
+    err.authRequired = true;
+    err.providerId = 'codex-cli';
+    err.cli = 'codex';
+    return err;
+}
+function normalizeClaudeFreshSessionAuthError(err) {
+    const message = String(err?.message || '').trim();
+    if (!message)
+        return null;
+    const normalized = message.toLowerCase();
+    if (err instanceof token_refresh_1.TokenRefreshError
+        || normalized.includes('invalid_grant')
+        || normalized.includes('refresh token not found or invalid')
+        || normalized.includes('oauth token refresh failed')
+        || normalized.includes('invalid authentication credentials')
+        || normalized.includes('failed to authenticate')) {
+        return buildCliAuthRequiredError('claude-cli');
+    }
+    return null;
+}
+function normalizeClaudeFreshSessionAuthErrorForTest(err) {
+    const normalized = normalizeClaudeFreshSessionAuthError(err);
+    if (!normalized)
+        return null;
+    return {
+        message: normalized.message,
+        providerId: normalized.providerId,
+        cli: normalized.cli,
+    };
+}
+async function ensureClaudeAuthReadyForFreshSession() {
+    const credential = (0, credential_reader_1.readClaudeCredentials)();
+    if (!credential?.accessToken) {
+        throw buildCliAuthRequiredError('claude-cli');
+    }
+    if (!(0, credential_reader_1.isExpired)(credential)) {
+        return;
+    }
+    if (!credential.refreshToken) {
+        throw buildCliAuthRequiredError('claude-cli');
+    }
+    try {
+        await (0, token_refresh_1.refreshToken)(credential);
+    }
+    catch (err) {
+        const authError = normalizeClaudeFreshSessionAuthError(err);
+        if (authError)
+            throw authError;
+        throw err;
+    }
+}
+function buildClaudeFreshSessionStartupError(sessionId, elapsedMs) {
+    const err = new Error(`claude-cli fresh session startup timed out after ${Math.floor(elapsedMs / 1000)}s waiting for transcript file`
+        + (sessionId ? ` (${sessionId})` : ''));
+    err.name = 'ClaudeFreshSessionStartupTimeoutError';
+    err.code = 'CLAUDE_FRESH_SESSION_STARTUP_TIMEOUT';
+    return err;
+}
+function getTerminalAuthFailure(session, activeTurn) {
+    const visibleFailure = buildCliInteractiveAuthError(session.provider, activeTurn.visibleOutput);
+    if (visibleFailure)
+        return visibleFailure;
+    return buildCliInteractiveAuthErrorFromOutputs(session.provider, normalizeTerminalChunk(activeTurn.rawOutput), session.recentTerminalOutput);
+}
+function hasClaudeAuthFingerprintChanged(provider, storedFingerprint, currentFingerprint = currentClaudeAuthFingerprint()) {
+    if (provider !== 'claude-cli')
+        return false;
+    return storedFingerprint !== currentFingerprint;
+}
+function shouldResetClaudeSessionForAuthChange(session) {
+    return hasClaudeAuthFingerprintChanged(session.provider, session.claudeAuthFingerprint);
+}
+function syncClaudeSessionCredentialsBackToCanonical(session) {
+    if (session.provider !== 'claude-cli')
+        return;
+    try {
+        const botHomeDir = path.dirname(session.sessionFilesRoot);
+        (0, sync_cli_config_1.promoteClaudeBotHomeCredentialsToCanonical)(botHomeDir);
+    }
+    catch {
+        // best effort
+    }
+    session.claudeAuthFingerprint = currentClaudeAuthFingerprint();
+}
+function clearSessionWarmState(session) {
+    session.warmPromise = null;
+    session.warmRequestedAtMs = null;
+    session.warmReadyAtMs = null;
+}
+function isIdleClaudeSession(session) {
+    return session.provider === 'claude-cli' && !session.closed && session.activeTurn == null;
+}
+function shouldRecycleClaudeSessionForFreshAuth(session) {
+    // A healthy idle Claude PTY is exactly what we want to reuse. Recycling it
+    // here forced the next turn down the expensive --resume/fresh-session path.
+    return false;
+}
+function resolveClaudeLaunchSessionIds(resumeSessionId, newSessionId) {
+    const normalizedResumeSessionId = String(resumeSessionId || '').trim() || null;
+    const normalizedNewSessionId = String(newSessionId || '').trim() || null;
+    // Preserve Claude-side session history whenever Funolio has a stored session
+    // id. A fresh --session-id is only valid for a genuinely new epoch; recurring
+    // turns must relaunch with --resume if the live PTY is no longer available.
+    return {
+        resumeSessionId: normalizedResumeSessionId,
+        newSessionId: normalizedResumeSessionId ? null : normalizedNewSessionId,
+        knownSessionId: normalizedResumeSessionId || normalizedNewSessionId,
+    };
+}
+function shouldResetClaudeSessionForAuthChangeForTest(provider, storedFingerprint, currentFingerprint) {
+    return hasClaudeAuthFingerprintChanged(provider, storedFingerprint, currentFingerprint);
+}
+function shouldRecycleClaudeSessionForFreshAuthForTest(input) {
+    return shouldRecycleClaudeSessionForFreshAuth({
+        key: 'test::session',
+        conversationId: 'conversation',
+        botId: 'bot',
+        topicId: null,
+        warmRuntimeMode: null,
+        provider: input.provider,
+        cwd: process.cwd(),
+        useConpty: false,
+        pty: { write() { }, kill() { }, on() { } },
+        createdAtMs: 0,
+        lastUsedAtMs: 0,
+        launchSnapshot: new Set(),
+        sessionFilesRoot: '',
+        sessionId: null,
+        sessionFilePath: null,
+        sessionFileOffset: 0,
+        sessionFileCarry: '',
+        readyPromise: Promise.resolve(),
+        readyResolved: true,
+        waitForNextSendMs: 0,
+        startupDelayMs: 0,
+        startupDelayApplied: false,
+        submitDelayMs: 0,
+        currentPromptLocator: null,
+        currentPromptStartedAtMs: 0,
+        activeTurn: input.hasActiveTurn ? {} : null,
+        warmPromise: input.hasWarmPromise ? Promise.resolve() : null,
+        warmRequestedAtMs: input.hasWarmPromise ? Date.now() : null,
+        warmReadyAtMs: input.hasWarmReadyAtMs ? Date.now() : null,
+        recentTerminalOutput: '',
+        closed: !!input.closed,
+        exitReason: null,
+        childFollowers: new Map(),
+        childSnapshot: new Set(),
+        claudeAuthFingerprint: null,
+        runtimeHomeDir: null,
+        chain: Promise.resolve(),
+    });
+}
+function resolveClaudeLaunchSessionIdsForTest(resumeSessionId, newSessionId) {
+    return resolveClaudeLaunchSessionIds(resumeSessionId, newSessionId);
+}
+function shouldContinueWaitingForFreshClaudeSession(session, activeTurn, startedAtMs, now) {
+    const elapsedMs = now - startedAtMs;
+    if (elapsedMs < CLAUDE_FRESH_SESSION_STARTUP_INITIAL_TIMEOUT_MS)
+        return true;
+    if (elapsedMs >= CLAUDE_FRESH_SESSION_STARTUP_MAX_TIMEOUT_MS)
+        return false;
+    if (session.closed)
+        return false;
+    const postPromptProgressAtMs = Math.max(activeTurn.lastDataAtMs, activeTurn.lastMeaningfulPtyDataAtMs);
+    if (postPromptProgressAtMs > startedAtMs) {
+        return now - postPromptProgressAtMs <= CLAUDE_FRESH_SESSION_STARTUP_PROGRESS_STALL_MS;
+    }
+    return true;
+}
+function shouldContinueWaitingForFreshClaudeSessionForTest(input) {
+    const startedAtMs = input.startedAtMs;
+    return shouldContinueWaitingForFreshClaudeSession({
+        provider: 'claude-cli',
+        closed: !!input.sessionClosed,
+        readyResolved: !!input.readyResolved,
+    }, {
+        lastDataAtMs: input.lastDataAtMs ?? startedAtMs,
+        lastMeaningfulPtyDataAtMs: input.lastMeaningfulPtyDataAtMs ?? startedAtMs,
+    }, startedAtMs, input.nowMs);
+}
+function throwIfAborted(signal) {
+    if (!signal?.aborted)
+        return;
+    throw buildAbortError();
+}
+async function delayWithAbort(ms, signal) {
+    if (!signal) {
+        await delay(ms);
+        return;
+    }
+    await Promise.race([
+        delay(ms),
+        new Promise((_, reject) => {
+            const onAbort = () => {
+                signal.removeEventListener('abort', onAbort);
+                reject(buildAbortError());
+            };
+            signal.addEventListener('abort', onAbort, { once: true });
+        }),
+    ]);
+}
 function sessionKey(conversationId, botId) {
     return `${conversationId}::${botId}`;
 }
@@ -95,16 +421,99 @@ function loadNodePtyModule() {
         for (const candidate of candidates) {
             if (!fs.existsSync(candidate))
                 continue;
-            _ptyModule = dynamicRequire(candidate);
-            return _ptyModule;
+            try {
+                // Use dynamic require with the absolute path — this preserves __dirname
+                // resolution inside the PTY module for finding native .node addons.
+                _ptyModule = dynamicRequire(candidate);
+                return _ptyModule;
+            }
+            catch {
+                // Try createRequire fallback if dynamic require fails
+                const ptyRequire = (0, module_1.createRequire)(candidate);
+                _ptyModule = ptyRequire(candidate);
+                return _ptyModule;
+            }
         }
         throw new Error(`Failed to load PTY runtime. Tried package import and packaged resource candidates. Original error: ${firstErr instanceof Error ? firstErr.message : String(firstErr)}`);
     }
 }
+function parseBracketedSections(text) {
+    const lines = text.split('\n');
+    const sections = [];
+    let currentHeading = null;
+    let bodyLines = [];
+    const flush = () => {
+        if (!currentHeading)
+            return;
+        sections.push({
+            heading: currentHeading,
+            body: bodyLines.join('\n').trim(),
+        });
+    };
+    for (const line of lines) {
+        const trimmed = line.trim();
+        const match = /^\[(.+?)\]$/.exec(trimmed);
+        if (match) {
+            flush();
+            currentHeading = match[1];
+            bodyLines = [];
+            continue;
+        }
+        if (currentHeading) {
+            bodyLines.push(line);
+        }
+    }
+    flush();
+    return sections;
+}
+function trimSectionBody(body, maxChars) {
+    const trimmed = body.trim();
+    if (trimmed.length <= maxChars)
+        return trimmed;
+    return `${trimmed.slice(0, Math.max(0, maxChars - 32)).trim()}\n[Context trimmed for direct Codex PTY]`;
+}
+function compactCodexDirectSystemPrompt(systemPrompt) {
+    const trimmed = systemPrompt.trim();
+    if (!trimmed)
+        return '';
+    const sections = parseBracketedSections(trimmed);
+    if (sections.length === 0) {
+        return trimmed.length <= 900
+            ? trimmed
+            : `${trimmed.slice(0, 820).trim()}\n\n[Context trimmed for direct Codex PTY]`;
+    }
+    const priorities = [
+        { heading: 'Bot Identity', maxChars: 360 },
+        { heading: 'Project Overview', maxChars: 140 },
+        { heading: 'Recent Messages (Last 2 Turns)', maxChars: 120 },
+        { heading: 'Recent Messages (Last 3 Turns)', maxChars: 140 },
+        { heading: 'Recent Messages (Last 4 Turns)', maxChars: 160 },
+        { heading: 'Recent Messages (Last 5 Turns)', maxChars: 180 },
+    ];
+    const selected = [];
+    for (const priority of priorities) {
+        const section = sections.find((candidate) => candidate.heading === priority.heading);
+        if (!section)
+            continue;
+        const body = trimSectionBody(section.body, priority.maxChars);
+        if (!body)
+            continue;
+        selected.push(`[${section.heading}]\n${body}`);
+    }
+    const compacted = selected.join('\n\n').trim();
+    if (!compacted) {
+        return trimmed.length <= 900
+            ? trimmed
+            : `${trimmed.slice(0, 820).trim()}\n\n[Context trimmed for direct Codex PTY]`;
+    }
+    return compacted.length <= 900
+        ? compacted
+        : `${compacted.slice(0, 820).trim()}\n\n[Context trimmed for direct Codex PTY]`;
+}
 function buildCodexSeedPrompt(systemPrompt, messages) {
     let fullPrompt = '';
     if (systemPrompt) {
-        fullPrompt += `[System Instructions]\n${systemPrompt}\n\n`;
+        fullPrompt += `[System Instructions]\n${compactCodexDirectSystemPrompt(systemPrompt)}\n\n`;
     }
     const lastMessage = messages.length > 0 ? messages[messages.length - 1] : null;
     if (messages.length > 0) {
@@ -123,43 +532,511 @@ function buildCodexSeedPrompt(systemPrompt, messages) {
     }
     if (lastMessage?.role === 'user') {
         const prompt = typeof lastMessage.content === 'string' ? lastMessage.content : JSON.stringify(lastMessage.content);
-        fullPrompt += `[User Request]\n${prompt}`;
+        fullPrompt += `[User Request]\n${prompt}\n\n${completion_marker_1.CLI_COMPLETION_INSTRUCTION}`;
     }
     else if (lastMessage) {
         const content = typeof lastMessage.content === 'string' ? lastMessage.content : JSON.stringify(lastMessage.content);
-        fullPrompt += `[Latest Message]\n${content}\n\nContinue from the transcript above and respond appropriately.`;
+        fullPrompt += `[Latest Message]\n${content}\n\nContinue from the transcript above and respond appropriately. ${completion_marker_1.CLI_COMPLETION_INSTRUCTION}`;
     }
     else {
-        fullPrompt += '[User Request]\n';
+        fullPrompt += `[User Request]\n\n${completion_marker_1.CLI_COMPLETION_INSTRUCTION}`;
     }
     return fullPrompt;
 }
-function buildTurnPrompt(provider, systemPrompt, messages, freshSession) {
+function extractTextAndImagePaths(content) {
+    if (typeof content === 'string')
+        return { text: content, imagePaths: [] };
+    const textParts = [];
+    const imagePaths = [];
+    // Write images to OS temp dir, not project workspace
+    const tmpDir = path.join(os.tmpdir(), 'funolio-images');
+    for (const part of content) {
+        if (part.type === 'text') {
+            textParts.push(part.text);
+        }
+        else if (part.type === 'image' && part.data) {
+            const ext = (part.mimeType || 'image/png').split('/')[1] || 'png';
+            const filename = `funolio-img-${Date.now()}-${Math.random().toString(36).slice(2, 6)}.${ext}`;
+            const filePath = path.join(tmpDir, filename);
+            try {
+                if (!fs.existsSync(tmpDir))
+                    fs.mkdirSync(tmpDir, { recursive: true });
+                fs.writeFileSync(filePath, Buffer.from(part.data, 'base64'));
+                imagePaths.push(filePath);
+            }
+            catch {
+                // best effort
+            }
+        }
+    }
+    return { text: textParts.join('\n'), imagePaths };
+}
+function buildClaudeImagePathText(imagePaths) {
+    if (imagePaths.length === 0)
+        return '';
+    if (imagePaths.length === 1)
+        return `\n\nAnalyze this image: ${imagePaths[0]}.`;
+    return `\n\n${imagePaths.map((p, index) => `Analyze image ${index + 1}: ${p}.`).join(' ')}`;
+}
+function buildImageNote(provider, imagePaths) {
+    if (provider === 'claude-cli') {
+        return buildClaudeImagePathText(imagePaths);
+    }
+    if (imagePaths.length === 0)
+        return '';
+    return `\n\n[The user attached ${imagePaths.length} image(s). Read them with your Read tool:\n${imagePaths.map((p) => `  - ${p}`).join('\n')}\n]`;
+}
+function flattenMessagesForImages(provider, messages) {
+    // Extract images from the last user message and convert content to text + image note
+    const lastMessage = messages.length > 0 ? messages[messages.length - 1] : null;
+    if (!lastMessage || lastMessage.role !== 'user' || typeof lastMessage.content === 'string') {
+        return { messages, imageNote: '' };
+    }
+    const { text, imagePaths } = extractTextAndImagePaths(lastMessage.content);
+    const flatMessages = [
+        ...messages.slice(0, -1),
+        {
+            ...lastMessage,
+            content: provider === 'claude-cli'
+                ? `${text}${buildClaudeImagePathText(imagePaths)}`
+                : text,
+        },
+    ];
+    return {
+        messages: flatMessages,
+        imageNote: provider === 'claude-cli' ? '' : buildImageNote(provider, imagePaths),
+    };
+}
+function buildTurnPrompt(provider, systemPrompt, messages, freshSession, cwd = '.') {
     if (!freshSession) {
         const lastMessage = messages.length > 0 ? messages[messages.length - 1] : null;
         if (lastMessage?.role === 'user') {
-            return typeof lastMessage.content === 'string'
-                ? lastMessage.content
-                : JSON.stringify(lastMessage.content);
+            const { text, imagePaths } = extractTextAndImagePaths(lastMessage.content);
+            return `${text}${buildImageNote(provider, imagePaths)}\n\nRequired final line when the response is fully complete: ${completion_marker_1.CLI_COMPLETION_SENTINEL}`;
         }
     }
+    // For fresh sessions, flatten images before passing to prompt builders
+    const { messages: flatMessages, imageNote } = flattenMessagesForImages(provider, messages);
     if (provider === 'claude-cli') {
-        return (0, claude_cli_prompt_1.buildClaudeCliStylePrompt)({
+        const prompt = (0, claude_cli_prompt_1.buildClaudeCliStylePrompt)({
             system: systemPrompt,
-            messages,
+            messages: flatMessages,
             runtimeMode: 'local_desktop',
         });
+        return imageNote ? `${prompt}${imageNote}` : prompt;
+    }
+    const codexPrompt = buildCodexSeedPrompt(systemPrompt, flatMessages);
+    return imageNote ? `${codexPrompt}${imageNote}` : codexPrompt;
+}
+function buildTurnPromptForTest(provider, systemPrompt, messages, freshSession, cwd = '.') {
+    return buildTurnPrompt(provider, systemPrompt, messages, freshSession, cwd);
+}
+function normalizePromptSnippet(text) {
+    return String(text || '')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .toLowerCase();
+}
+function extractCurrentUserPromptSnippet(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (msg?.role !== 'user')
+            continue;
+        const { text } = extractTextAndImagePaths(msg.content);
+        const normalized = normalizePromptSnippet(text);
+        if (normalized)
+            return normalized.slice(0, 240);
+    }
+    return '';
+}
+function parseRecordTimestampMs(record) {
+    if (!record || typeof record !== 'object' || typeof record.timestamp !== 'string')
+        return null;
+    const parsed = Date.parse(record.timestamp);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function extractClaudeUserRecordText(record) {
+    if (!record || record.type !== 'user')
+        return '';
+    const content = record?.message?.content;
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .map((block) => {
+        if (!block || typeof block !== 'object')
+            return '';
+        if (typeof block.text === 'string')
+            return block.text;
+        if (typeof block.content === 'string')
+            return block.content;
+        return '';
+    })
+        .filter(Boolean)
+        .join('\n');
+}
+function updateClaudeTurnPromptSeen(tracker, record) {
+    if (tracker.sawCurrentTurnUserRecord)
+        return;
+    const expected = tracker.expectedUserPromptSnippet;
+    if (!expected || !record || record.type !== 'user')
+        return;
+    const normalized = normalizePromptSnippet(extractClaudeUserRecordText(record));
+    if (normalized && normalized.includes(expected)) {
+        tracker.sawCurrentTurnUserRecord = true;
+    }
+}
+function shouldIgnoreClaudeRecordForCurrentTurn(tracker, record) {
+    const timestampMs = parseRecordTimestampMs(record);
+    if (timestampMs != null && timestampMs < tracker.turnStartedAtMs - 2_000) {
+        return true;
+    }
+    updateClaudeTurnPromptSeen(tracker, record);
+    if (record?.type === 'assistant' && tracker.expectedUserPromptSnippet && !tracker.sawCurrentTurnUserRecord) {
+        return true;
+    }
+    return false;
+}
+function shouldIgnoreClaudeRecordForCurrentTurnForTest(turnStartedAtMs, expectedUserPrompt, sawCurrentTurnUserRecord, record) {
+    const tracker = {
+        done: false,
+        sawExplicitCompletion: false,
+        finalContent: '',
+        usage: undefined,
+        lastAssistantText: '',
+        detailFingerprints: new Set(),
+        pendingToolUseIds: new Set(),
+        lastRecordAtMs: turnStartedAtMs,
+        sawCompletionSentinel: false,
+        turnStartedAtMs,
+        expectedUserPromptSnippet: normalizePromptSnippet(expectedUserPrompt).slice(0, 240),
+        sawCurrentTurnUserRecord,
+    };
+    const ignore = shouldIgnoreClaudeRecordForCurrentTurn(tracker, record);
+    return {
+        ignore,
+        sawCurrentTurnUserRecord: tracker.sawCurrentTurnUserRecord,
+    };
+}
+function stripAnsi(text) {
+    if (!text)
+        return '';
+    return text
+        .replace(/\x00/g, '')
+        .replace(/\x1B\][^\x07]*(?:\x07|\x1B\\)/g, '')
+        .replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, '');
+}
+function resolveConptyOverwrites(text) {
+    if (!text)
+        return '';
+    const normalized = text.replace(/\r\n/g, '\n');
+    const output = [];
+    let line = '';
+    for (const ch of normalized) {
+        if (ch === '\r') {
+            line = '';
+            continue;
+        }
+        if (ch === '\b') {
+            line = line.slice(0, -1);
+            continue;
+        }
+        if (ch === '\n') {
+            output.push(line);
+            line = '';
+            continue;
+        }
+        line += ch;
+    }
+    output.push(line);
+    return output.join('\n');
+}
+function normalizeTerminalChunk(text) {
+    return resolveConptyOverwrites(stripAnsi(text))
+        .replace(/[\x01-\x08\x0B\x0C\x0E-\x1F\x7F]/g, '')
+        .replace(/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏✳✺✹✸✷✶✵✴✻✽⏵⏸●◐◑◒◓▉▊▋▌▍▎▏▐█▓▒░■□▪▫◼◻◾◽]+/g, ' ')
+        .replace(/\u00a0/g, ' ')
+        .replace(/[^\S\n]+/g, ' ');
+}
+function isCliBootstrapChromeLine(provider, line) {
+    const normalized = String(line || '')
+        .replace(/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏✳✺✹✸✷✶✵✴✻✽⏵⏸●◐◑◒◓▉▊▋▌▍▎▏▐█▓▒░■□▪▫◼◻◾◽]+/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+    if (!normalized)
+        return false;
+    if (provider === 'claude-cli') {
+        let hints = 0;
+        if (/\bClaude Code v\d/i.test(normalized))
+            hints += 2;
+        if (/\bClaude Max\b/i.test(normalized))
+            hints += 1;
+        if (/\bBot Identity\b/i.test(normalized))
+            hints += 1;
+        if (/\b(?:Opus|Sonnet|Haiku)\b.*\b(?:effort|thinking)\b/i.test(normalized))
+            hints += 1;
+        if (/\bclaude\.md\b/i.test(normalized))
+            hints += 1;
+        if (/[A-Za-z]:\\/.test(normalized))
+            hints += 1;
+        if (hints >= 2)
+            return true;
+    }
+    if (provider === 'codex-cli') {
+        if (/\bcodex\b/i.test(normalized) && /\b(model|approval|sandbox|cwd)\b/i.test(normalized)) {
+            return true;
+        }
+    }
+    return false;
+}
+function isSyntheticPromptEchoLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return false;
+    return (/^\[(System Instructions|Recent Transcript|User Request|Latest Message|Bot Identity|Project Overview|Workflow State|Response Style|Input from Previous Step|Context trimmed.*)\]$/i.test(trimmed)
+        || /^Current user request:$/i.test(trimmed)
+        || /^Recent transcript \(for continuity\):$/i.test(trimmed)
+        || /^(Bot Name|Role Label|Project|Workspace):/i.test(trimmed)
+        || /^Responsibilities:?$/i.test(trimmed)
+        || /^(USER|ASSISTANT|TOOL(?:\s+\(.+\))?):$/i.test(trimmed));
+}
+function isAutomationNoiseLine(provider, line) {
+    const trimmed = line.trim();
+    const normalizedLead = trimmed.replace(/^[>›â»âµâ–¸â–¶]+\s*/, '');
+    if (!trimmed)
+        return false;
+    if (isCliBootstrapChromeLine(provider, trimmed))
+        return true;
+    if (/^Pasting text/i.test(trimmed))
+        return true;
+    if (/^\[Pasted.*lines?\]/i.test(trimmed))
+        return true;
+    if (/^\[?Pasted text #?\d+\b/i.test(normalizedLead))
+        return true;
+    if (/^(?:Cerebrating|Choreographing)\.\.\.?$/i.test(normalizedLead))
+        return true;
+    if (/^ctrl\+g to edit in notepad$/i.test(trimmed))
+        return true;
+    if (/^\? for shortcuts$/i.test(trimmed))
+        return true;
+    if (/^Use \/skills to list available skills$/i.test(trimmed))
+        return true;
+    if (/^Improve documentation in @filename$/i.test(trimmed))
+        return true;
+    if (/^permissions on \(shift(?:\+|-)tab to cycle\)$/i.test(trimmed))
+        return true;
+    if (/^bypass permissions on \(shift(?:\+|-)tab to cycle\)$/i.test(trimmed))
+        return true;
+    if (/^(?:[-+*]\s*)?Brewing(?:\.\.\.?|…)?(?:-+)?$/i.test(normalizedLead))
+        return true;
+    if (/^Reading \d+ file(?:s)?\.\.\.\s*\(ctrl\+o to expand\)/i.test(normalizedLead))
+        return true;
+    if (/^\[last-prompt\]$/i.test(normalizedLead))
+        return true;
+    if (/^[-_=]{4,}$/.test(trimmed))
+        return true;
+    if (/^[•◦·*✢✶✻✽●]+$/.test(trimmed))
+        return true;
+    if (/^(Wo|or|rk|ki|in|ng|Wng|Wog)$/.test(trimmed))
+        return true;
+    if (trimmed.length <= 3 && /^[A-Za-z0-9]+$/.test(trimmed))
+        return true;
+    if (provider === 'claude-cli' && /^>\s*$/.test(trimmed))
+        return true;
+    if (provider === 'codex-cli' && /^›\s*$/.test(trimmed))
+        return true;
+    return false;
+}
+function isRepeatedChromeLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return false;
+    return (/(?:gpt-\d|claude|% left|esc to interrupt|for shortcuts|Use \/skills|Quantumizing|Working)/i.test(trimmed)
+        || /^› /.test(trimmed)
+        || /^> /.test(trimmed));
+}
+function isLikelyAssistantAnswerLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return false;
+    if (/^(?:>|›|\$|\/)/.test(trimmed))
+        return false;
+    if (/^(Running|Working|Thinking|Brewing|Analyzing|Searching|Reading|Preparing|Loading|Using|Tool|Status|Task|Step)\b/i.test(trimmed))
+        return false;
+    if (/^[-*]\s+/.test(trimmed) && trimmed.length >= 48)
+        return true;
+    if (/^\d+\.\s+/.test(trimmed) && trimmed.length >= 48)
+        return true;
+    const words = trimmed.split(/\s+/).filter(Boolean);
+    if (words.length >= 8 && /[a-z]/.test(trimmed) && /[.:!?]$/.test(trimmed))
+        return true;
+    if (trimmed.length >= 72 && /[a-z]/.test(trimmed))
+        return true;
+    return false;
+}
+function extractTerminalFacingText(text, assistantOutputDetected) {
+    if (!text || assistantOutputDetected) {
+        return { terminalText: '', assistantOutputDetected };
+    }
+    const terminalLines = [];
+    let detected = assistantOutputDetected;
+    for (const rawLine of text.split('\n')) {
+        const trimmed = rawLine.trim();
+        if (!trimmed) {
+            if (terminalLines.length > 0 && terminalLines[terminalLines.length - 1] !== '') {
+                terminalLines.push('');
+            }
+            continue;
+        }
+        if (isLikelyAssistantAnswerLine(trimmed)) {
+            detected = true;
+            break;
+        }
+        terminalLines.push(rawLine);
+    }
+    return {
+        terminalText: terminalLines.join('\n').replace(/\n{3,}/g, '\n\n').trim(),
+        assistantOutputDetected: detected,
+    };
+}
+function sanitizeVisibleChunk(provider, text, recentChromeLines) {
+    const sanitizedLines = [];
+    for (const rawLine of text.split('\n')) {
+        const trimmedRight = rawLine.replace(/\s+$/g, '');
+        const trimmed = trimmedRight.trim();
+        if (!trimmed) {
+            if (sanitizedLines.length > 0 && sanitizedLines[sanitizedLines.length - 1] !== '') {
+                sanitizedLines.push('');
+            }
+            continue;
+        }
+        if (isSyntheticPromptEchoLine(trimmedRight))
+            continue;
+        if (isAutomationNoiseLine(provider, trimmedRight))
+            continue;
+        if (isRepeatedChromeLine(trimmedRight) && recentChromeLines.includes(trimmed))
+            continue;
+        sanitizedLines.push(trimmedRight);
+        if (isRepeatedChromeLine(trimmedRight)) {
+            recentChromeLines.push(trimmed);
+            if (recentChromeLines.length > 12) {
+                recentChromeLines.splice(0, recentChromeLines.length - 12);
+            }
+        }
+    }
+    return sanitizedLines.join('\n').replace(/\n{3,}/g, '\n\n');
+}
+function trimPromptEcho(text, promptEchoRemainder) {
+    if (!text || !promptEchoRemainder) {
+        return { text, promptEchoRemainder };
+    }
+    let output = '';
+    let remainingPrompt = promptEchoRemainder;
+    let index = 0;
+    const maxIterations = (text.length + promptEchoRemainder.length) * 2;
+    let iterations = 0;
+    while (index < text.length) {
+        if (++iterations > maxIterations) {
+            output += text.slice(index);
+            break;
+        }
+        if (!remainingPrompt) {
+            output += text.slice(index);
+            break;
+        }
+        const current = text.slice(index);
+        if (remainingPrompt.startsWith(current)) {
+            return { text: output, promptEchoRemainder: remainingPrompt.slice(current.length) };
+        }
+        if (current.startsWith(remainingPrompt)) {
+            index += remainingPrompt.length;
+            remainingPrompt = '';
+            continue;
+        }
+        const maxPrefix = Math.min(current.length, remainingPrompt.length);
+        let matched = 0;
+        while (matched < maxPrefix && current[matched] === remainingPrompt[matched]) {
+            matched++;
+        }
+        if (matched > 0) {
+            index += matched;
+            remainingPrompt = remainingPrompt.slice(matched);
+            continue;
+        }
+        output += text[index];
+        index += 1;
+    }
+    return { text: output, promptEchoRemainder: remainingPrompt };
+}
+async function emitPtyChunk(session, chunk) {
+    const activeTurn = session.activeTurn;
+    if (!activeTurn)
+        return;
+    activeTurn.rawOutput += chunk;
+    activeTurn.lastDataAtMs = Date.now();
+    // Fix 13: Extract terminal title updates (OSC sequences) for live activity
+    // Format: \x1b]0;<title>\x07 or \x1b]0;<title>\x1b\\
+    const titleMatch = chunk.match(/\x1b\]0;([^\x07\x1b]*?)(?:\x07|\x1b\\)/);
+    if (titleMatch && titleMatch[1]) {
+        const title = titleMatch[1].replace(/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏✳✺✹✸✷✶✵✴✻✽⏵⏸●◐◑◒◓]/g, '').trim();
+        if (title && title !== session._lastPtyTitle && title.length > 3) {
+            session._lastPtyTitle = title;
+            activeTurn.lastMeaningfulPtyDataAtMs = Date.now();
+            // Store on session for the polling loop to emit via onDetail
+            session._pendingTitle = title;
+        }
+    }
+    const cleaned = normalizeTerminalChunk(chunk);
+    if (!cleaned.trim())
+        return;
+    const echoTrimmed = trimPromptEcho(cleaned, activeTurn.promptEchoRemainder);
+    activeTurn.promptEchoRemainder = echoTrimmed.promptEchoRemainder;
+    const visibleText = sanitizeVisibleChunk(session.provider, echoTrimmed.text, activeTurn.recentChromeLines);
+    if (!visibleText.trim())
+        return;
+    if (activeTurn.mode === 'passthrough') {
+        activeTurn.lastMeaningfulPtyDataAtMs = Date.now();
+        activeTurn.sawVisibleData = true;
+        const passthroughText = visibleText.replace(/\n/g, '\r\n');
+        activeTurn.visibleOutput += passthroughText;
+        activeTurn.callbackChain = activeTurn.callbackChain
+            .catch(() => undefined)
+            .then(() => activeTurn.onRawChunk?.(passthroughText))
+            .then(() => undefined);
+        await activeTurn.callbackChain;
+        return;
+    }
+    const terminalView = extractTerminalFacingText(visibleText, activeTurn.assistantOutputDetected);
+    activeTurn.assistantOutputDetected = terminalView.assistantOutputDetected;
+    if (terminalView.terminalText) {
+        activeTurn.lastMeaningfulPtyDataAtMs = Date.now();
+        activeTurn.sawVisibleData = true;
+        const terminalText = terminalView.terminalText.replace(/\n/g, '\r\n');
+        activeTurn.callbackChain = activeTurn.callbackChain
+            .catch(() => undefined)
+            .then(() => activeTurn.onRawChunk?.(terminalText))
+            .then(() => undefined);
+        await activeTurn.callbackChain;
     }
-    return buildCodexSeedPrompt(systemPrompt, messages);
 }
-function getProviderSessionRoot(provider) {
+function getDefaultProviderHome(provider) {
     if (provider === 'claude-cli') {
-        return path.join(os.homedir(), '.claude', 'projects');
+        return path.join(os.homedir(), '.claude');
     }
-    return path.join(os.homedir(), '.codex', 'sessions');
+    return path.join(os.homedir(), '.codex');
 }
-function listSessionFiles(provider) {
-    const root = getProviderSessionRoot(provider);
+function getProviderSessionRoot(provider, cliHomeDir) {
+    const homeDir = cliHomeDir || getDefaultProviderHome(provider);
+    return provider === 'claude-cli'
+        ? path.join(homeDir, 'projects')
+        : path.join(homeDir, 'sessions');
+}
+function getProviderSessionRootForTest(provider, cliHomeDir) {
+    return getProviderSessionRoot(provider, cliHomeDir);
+}
+function listSessionFiles(provider, sessionRoot) {
+    const root = sessionRoot || getProviderSessionRoot(provider);
     if (!fs.existsSync(root))
         return [];
     const results = [];
@@ -198,8 +1075,24 @@ function extractUserPromptFromRecord(provider, record) {
     }
     return '';
 }
-function recentFileContainsPrompt(provider, filePath, promptText) {
-    const expected = promptText.trim();
+function normalizePromptMatchText(text) {
+    return text.replace(/\r/g, '').trim();
+}
+function recordTimestampMs(record) {
+    const raw = typeof record?.timestamp === 'string'
+        ? record.timestamp
+        : typeof record?.ts === 'number'
+            ? record.ts * 1000
+            : null;
+    if (typeof raw === 'number')
+        return Number.isFinite(raw) ? raw : null;
+    if (!raw)
+        return null;
+    const parsed = Date.parse(raw);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function recentFileContainsPrompt(provider, filePath, promptText, startedAtMs) {
+    const expected = normalizePromptMatchText(promptText);
     if (!expected)
         return false;
     let stat;
@@ -224,7 +1117,13 @@ function recentFileContainsPrompt(provider, filePath, promptText) {
                 continue;
             try {
                 const record = JSON.parse(line);
-                if (extractUserPromptFromRecord(provider, record) === expected) {
+                if (provider === 'codex-cli' && startedAtMs) {
+                    const ts = recordTimestampMs(record);
+                    if (ts !== null && ts < (startedAtMs - 2000)) {
+                        continue;
+                    }
+                }
+                if (normalizePromptMatchText(extractUserPromptFromRecord(provider, record)) === expected) {
                     return true;
                 }
             }
@@ -238,8 +1137,8 @@ function recentFileContainsPrompt(provider, filePath, promptText) {
     }
     return false;
 }
-function discoverSessionFile(provider, launchSnapshot, startedAtMs, promptLocator) {
-    const candidates = listSessionFiles(provider)
+function discoverSessionFile(provider, launchSnapshot, startedAtMs, promptLocator, sessionRoot) {
+    const candidates = listSessionFiles(provider, sessionRoot)
         .map((candidate) => {
         let mtimeMs = 0;
         try {
@@ -251,44 +1150,149 @@ function discoverSessionFile(provider, launchSnapshot, startedAtMs, promptLocato
         return { candidate, mtimeMs, isNew: !launchSnapshot.has(candidate) };
     })
         .filter((item) => !!item)
-        .filter((item) => item.mtimeMs >= (startedAtMs - 5000))
-        .sort((a, b) => {
-        if (a.isNew !== b.isNew)
-            return a.isNew ? -1 : 1;
-        return b.mtimeMs - a.mtimeMs;
-    });
+        .filter((item) => item.isNew && item.mtimeMs >= (startedAtMs - 5000))
+        .sort((a, b) => b.mtimeMs - a.mtimeMs);
     if (promptLocator?.trim()) {
-        const matched = candidates.find((item) => recentFileContainsPrompt(provider, item.candidate, promptLocator));
+        const matched = candidates.find((item) => recentFileContainsPrompt(provider, item.candidate, promptLocator, startedAtMs));
         if (matched)
             return matched.candidate;
+        if (provider === 'codex-cli') {
+            return null;
+        }
     }
     return candidates[0]?.candidate || null;
 }
-function extractClaudeText(record) {
-    const blocks = Array.isArray(record?.message?.content) ? record.message.content : [];
-    return blocks
-        .map((block) => {
-        if (!block || typeof block !== 'object')
-            return '';
-        return block.type === 'text' && typeof block.text === 'string' ? block.text : '';
-    })
-        .join('');
-}
-function extractClaudeToolNames(record) {
-    const blocks = Array.isArray(record?.message?.content) ? record.message.content : [];
-    return blocks
-        .map((block) => (block?.type === 'tool_use' && typeof block?.name === 'string' ? block.name : ''))
-        .filter((name) => !!name);
-}
-function extractCodexAssistantText(record) {
-    if (!record || typeof record !== 'object')
-        return '';
-    if (record.type === 'event_msg') {
-        if (record.payload?.type === 'agent_message' && typeof record.payload?.message === 'string') {
-            return record.payload.message;
+function findCodexSessionFileBySessionId(sessionId) {
+    if (!sessionId)
+        return null;
+    const candidates = listSessionFiles('codex-cli')
+        .map((candidate) => {
+        try {
+            return { candidate, mtimeMs: fs.statSync(candidate).mtimeMs };
         }
-        if (record.payload?.type === 'task_complete' && typeof record.payload?.last_agent_message === 'string') {
-            return record.payload.last_agent_message;
+        catch {
+            return null;
+        }
+    })
+        .filter((item) => !!item)
+        .sort((a, b) => b.mtimeMs - a.mtimeMs);
+    for (const item of candidates) {
+        let stat;
+        try {
+            stat = fs.statSync(item.candidate);
+        }
+        catch {
+            continue;
+        }
+        const readLength = Math.min(stat.size, 64 * 1024);
+        if (readLength <= 0)
+            continue;
+        const fd = fs.openSync(item.candidate, 'r');
+        try {
+            const buffer = Buffer.alloc(readLength);
+            fs.readSync(fd, buffer, 0, readLength, 0);
+            const text = buffer.toString('utf8');
+            for (const rawLine of text.split('\n')) {
+                const line = rawLine.trim();
+                if (!line)
+                    continue;
+                try {
+                    const record = JSON.parse(line);
+                    if (record?.type === 'session_meta' && record?.payload?.id === sessionId) {
+                        return item.candidate;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    return null;
+}
+function describePtyExit(exitArgs) {
+    const first = exitArgs[0];
+    const code = first && typeof first === 'object'
+        ? (first.exitCode ?? first.code)
+        : first;
+    const signal = first && typeof first === 'object'
+        ? first.signal
+        : exitArgs[1];
+    const parts = [];
+    if (code !== undefined && code !== null)
+        parts.push(`exitCode=${String(code)}`);
+    if (signal !== undefined && signal !== null)
+        parts.push(`signal=${String(signal)}`);
+    return parts.length > 0 ? parts.join(', ') : 'no exit details';
+}
+function formatClosedSessionError(session, context) {
+    return new Error(`${session.provider} PTY session ${context}${session.exitReason ? ` (${session.exitReason})` : ''}`);
+}
+function formatToolUseDetail(toolName, input) {
+    if (!input || typeof input !== 'object')
+        return `🔧 ${toolName}`;
+    // Format common tools nicely
+    switch (toolName) {
+        case 'Agent':
+            return `🤖 Agent: ${input.description || input.subagent_type || 'working'}`;
+        case 'Read':
+            return `📄 Read: ${input.file_path || ''}`;
+        case 'Write':
+            return `✏️ Write: ${input.file_path || ''}`;
+        case 'Edit':
+            return `✏️ Edit: ${input.file_path || ''}`;
+        case 'Bash':
+            return `💻 Bash: ${String(input.command || '').slice(0, 200)}`;
+        case 'Grep':
+            return `🔍 Grep: "${input.pattern || ''}" ${input.path ? 'in ' + input.path : ''}`;
+        case 'Glob':
+            return `📁 Glob: ${input.pattern || ''}${input.path ? ' in ' + input.path : ''}`;
+        case 'WebSearch':
+            return `🌐 Search: ${input.query || ''}`;
+        case 'WebFetch':
+            return `🌐 Fetch: ${input.url || ''}`;
+        default:
+            return `🔧 ${toolName}: ${JSON.stringify(input).slice(0, 200)}`;
+    }
+}
+function formatToolResultDetail(toolUseId, content) {
+    const trimmedId = toolUseId.slice(-8);
+    const lines = content.split('\n').length;
+    const chars = content.length;
+    if (chars <= 200) {
+        return `✅ Result [${trimmedId}]: ${content}`;
+    }
+    const firstLine = content.split('\n')[0].slice(0, 120);
+    return `✅ Result [${trimmedId}]: ${firstLine}... (${lines} lines, ${chars} chars)`;
+}
+function extractClaudeText(record) {
+    const blocks = Array.isArray(record?.message?.content) ? record.message.content : [];
+    return blocks
+        .map((block) => {
+        if (!block || typeof block !== 'object')
+            return '';
+        return block.type === 'text' && typeof block.text === 'string' ? block.text : '';
+    })
+        .join('');
+}
+function extractClaudeToolNames(record) {
+    const blocks = Array.isArray(record?.message?.content) ? record.message.content : [];
+    return blocks
+        .map((block) => (block?.type === 'tool_use' && typeof block?.name === 'string' ? block.name : ''))
+        .filter((name) => !!name);
+}
+function extractCodexAssistantText(record) {
+    if (!record || typeof record !== 'object')
+        return '';
+    if (record.type === 'event_msg') {
+        if (record.payload?.type === 'agent_message' && typeof record.payload?.message === 'string') {
+            return record.payload.message;
+        }
+        if (record.payload?.type === 'task_complete' && typeof record.payload?.last_agent_message === 'string') {
+            return record.payload.last_agent_message;
         }
     }
     if (record.type === 'response_item' && record.payload?.type === 'message' && record.payload?.role === 'assistant') {
@@ -310,63 +1314,233 @@ function extractCodexAssistantText(record) {
 function normalizeAssistantContent(text) {
     return text.replace(/^\s+/, '').replace(/\r/g, '');
 }
+function normalizeCompletionState(text) {
+    const normalized = normalizeAssistantContent(text);
+    if (!normalized)
+        return { text: '', hasSentinel: false };
+    const stripped = (0, completion_marker_1.stripCompletionSentinel)(normalized);
+    return { text: stripped.text, hasSentinel: stripped.found };
+}
 async function emitDetail(tracker, detail, cb) {
     const trimmed = detail.trim();
     if (!trimmed)
         return;
-    if (tracker.detailFingerprints.has(trimmed))
+    // Only deduplicate consecutive identical details, not across the whole turn
+    if (tracker.lastDetail === trimmed)
         return;
-    tracker.detailFingerprints.add(trimmed);
+    tracker.lastDetail = trimmed;
     await cb?.(trimmed);
 }
+async function emitAssistantChunk(tracker, nextText, cb) {
+    const normalized = normalizeCompletionState(nextText).text;
+    if (!normalized)
+        return;
+    const previous = tracker.lastAssistantText;
+    if (normalized === previous)
+        return;
+    tracker.lastAssistantText = normalized;
+    if (!cb)
+        return;
+    if (!previous) {
+        await cb(normalized);
+        return;
+    }
+    if (normalized.startsWith(previous)) {
+        const delta = normalized.slice(previous.length);
+        if (delta) {
+            await cb(delta);
+        }
+        return;
+    }
+    const separator = previous.match(/\n\s*\n\s*$/) ? '' : '\n\n';
+    await cb(`${separator}${normalized}`);
+}
+async function emitAssistantChunkSequenceForTest(chunks) {
+    const tracker = {
+        done: false,
+        sawExplicitCompletion: false,
+        finalContent: '',
+        detailFingerprints: new Set(),
+        lastAssistantText: '',
+        pendingToolUseIds: new Set(),
+        lastRecordAtMs: 0,
+        sawCompletionSentinel: false,
+        turnStartedAtMs: 0,
+        expectedUserPromptSnippet: '',
+        sawCurrentTurnUserRecord: false,
+    };
+    const emitted = [];
+    for (const chunk of chunks) {
+        await emitAssistantChunk(tracker, chunk, async (delta) => {
+            emitted.push(delta);
+        });
+    }
+    return emitted;
+}
 function parseClaudeSessionRecord(record) {
     const sessionId = typeof record?.sessionId === 'string' ? record.sessionId : undefined;
     if (record?.type === 'assistant' && record?.message) {
+        // token.txt Change 1: keep `inputTokens` as the sum (back-compat
+        // with downstream readers — SSE meta events, ChatJob persistence,
+        // etc.) AND populate the three breakdown fields so the LlmUsageLog
+        // path can record cache-aware costs.
+        const fresh = record.message.usage?.input_tokens || 0;
+        const cacheCreation = record.message.usage?.cache_creation_input_tokens || 0;
+        const cacheRead = record.message.usage?.cache_read_input_tokens || 0;
         const usage = record.message.usage
             ? {
-                inputTokens: (record.message.usage.input_tokens || 0)
-                    + (record.message.usage.cache_read_input_tokens || 0)
-                    + (record.message.usage.cache_creation_input_tokens || 0),
+                inputTokens: fresh + cacheCreation + cacheRead,
+                inputTokensFresh: fresh,
+                inputTokensCacheCreation: cacheCreation,
+                inputTokensCacheRead: cacheRead,
                 outputTokens: record.message.usage.output_tokens || 0,
             }
             : undefined;
-        const toolNames = extractClaudeToolNames(record);
-        if (toolNames.length > 0) {
-            return {
-                sessionId,
-                detail: `Running ${toolNames.join(', ')}...`,
-                usage,
-            };
+        // Build detail lines and live activity events from ALL content blocks
+        const blocks = Array.isArray(record.message.content) ? record.message.content : [];
+        const details = [];
+        const activities = [];
+        const openedToolUseIds = [];
+        for (const block of blocks) {
+            if (!block || typeof block !== 'object')
+                continue;
+            if (block.type === 'thinking' && typeof block.thinking === 'string' && block.thinking.trim()) {
+                details.push(`💭 Thinking`);
+            }
+            else if (block.type === 'tool_use') {
+                const toolName = typeof block.name === 'string' ? block.name : 'unknown';
+                if (typeof block.id === 'string' && block.id.trim()) {
+                    openedToolUseIds.push(block.id);
+                }
+                // Always emit a structured tool_call activity for every tool_use block.
+                // This is consumed by workflow-engine to produce worker_tool_call events.
+                activities.push({
+                    type: 'tool_call',
+                    label: toolName,
+                    key: block.id || undefined,
+                    timestamp: Date.now(),
+                });
+                // Emit structured live activity events
+                if (toolName === 'Agent') {
+                    const activityLabel = (0, live_activity_1.agentToolUseToLabel)(block.input || {});
+                    if (activityLabel) {
+                        activities.push({
+                            type: 'subagent_started',
+                            label: activityLabel,
+                            key: block.id || undefined,
+                            timestamp: Date.now(),
+                        });
+                    }
+                }
+                else {
+                    const activityLabel = (0, live_activity_1.toolUseToActivityLabel)(toolName);
+                    if (activityLabel) {
+                        activities.push({
+                            type: 'working',
+                            label: activityLabel,
+                            key: block.id || undefined,
+                            timestamp: Date.now(),
+                        });
+                    }
+                }
+            }
         }
-        const text = normalizeAssistantContent(extractClaudeText(record));
+        const completionState = normalizeCompletionState(extractClaudeText(record));
+        const text = completionState.text;
+        const detailStr = details.length > 0 ? details.join('\n') : undefined;
+        // Completion detection:
+        // 1. Explicit stop_reason (end_turn, max_tokens, stop_sequence) = done immediately
+        // 2. stop_reason: null or tool_use = NOT done (wait for system/turn_duration fallback)
+        // Why not "text + no tool_use = done"? Because CLI writes text and tool_use as
+        // separate records — text arrives first with stop_reason: null, then tool_use follows.
+        // We'd mark done prematurely before the tool_use record arrives.
+        const stopReason = record.message?.stop_reason;
+        const isDone = !!stopReason && stopReason !== 'tool_use';
+        const activityResult = activities.length > 0 ? { activities } : {};
+        const toolUseResult = openedToolUseIds.length > 0 ? { openedToolUseIds } : {};
         if (text) {
+            const shouldFinalize = isDone || completionState.hasSentinel;
             return {
                 sessionId,
-                ...(record.message.stop_reason === 'end_turn'
+                assistantText: text,
+                ...(detailStr ? { detail: detailStr } : {}),
+                ...(shouldFinalize
                     ? { finalContent: text, done: true, usage }
-                    : { detail: text, usage }),
+                    : { usage }),
+                ...activityResult,
+                ...toolUseResult,
             };
         }
-        return { sessionId, usage };
+        return {
+            sessionId,
+            ...(detailStr ? { detail: detailStr } : {}),
+            ...(completionState.hasSentinel ? { done: true } : {}),
+            usage,
+            ...activityResult,
+            ...toolUseResult,
+        };
     }
     if (record?.type === 'user' && Array.isArray(record?.message?.content)) {
-        const toolResultText = record.message.content
-            .map((block) => {
+        const resolvedToolUseIds = record.message.content
+            .map((block) => (typeof block?.tool_use_id === 'string' ? block.tool_use_id : ''))
+            .filter((toolUseId) => !!toolUseId);
+        // Build tool_result activities so workflow-engine can emit worker_tool_result events
+        const resultActivities = [];
+        for (const block of record.message.content) {
             if (!block || typeof block !== 'object')
-                return '';
-            if (typeof block.tool_use_id === 'string' && typeof block.content === 'string') {
-                return `Tool result (${block.tool_use_id}): ${String(block.content).slice(0, 240)}`;
+                continue;
+            if (typeof block.tool_use_id !== 'string' || !block.tool_use_id)
+                continue;
+            const isError = !!block.is_error;
+            // Extract a short summary from the result content (could be string or array of blocks)
+            let summary = '';
+            if (typeof block.content === 'string') {
+                summary = block.content.replace(/\s+/g, ' ').trim().slice(0, 200);
             }
-            return '';
-        })
-            .filter(Boolean)
-            .join('\n');
-        if (toolResultText) {
-            return { sessionId, detail: toolResultText };
+            else if (Array.isArray(block.content)) {
+                const textBlocks = block.content
+                    .map((c) => (c && typeof c === 'object' && typeof c.text === 'string' ? c.text : ''))
+                    .filter(Boolean);
+                summary = textBlocks.join(' ').replace(/\s+/g, ' ').trim().slice(0, 200);
+            }
+            resultActivities.push({
+                type: 'tool_result',
+                label: summary || (isError ? 'tool error' : 'tool completed'),
+                key: block.tool_use_id,
+                isError,
+                timestamp: Date.now(),
+            });
         }
+        if (resolvedToolUseIds.length > 0) {
+            return {
+                sessionId,
+                resolvedToolUseIds,
+                ...(resultActivities.length > 0 ? { activities: resultActivities } : {}),
+            };
+        }
+    }
+    // system/turn_duration is a fallback completion signal from the CLI
+    if (record?.type === 'system' && record?.subtype === 'turn_duration') {
+        return { sessionId, done: true };
+    }
+    // Skip internal bookkeeping records, surface anything else
+    const skipTypes = ['permission-mode', 'file-history-snapshot', 'attachment', 'system'];
+    if (record?.type && !skipTypes.includes(record.type) && record.type !== 'assistant' && record.type !== 'user') {
+        return { sessionId, detail: `[${record.type}]` };
     }
     return sessionId ? { sessionId } : {};
 }
+function canFinalizeClaudeTurnOnSessionExit(session, tracker) {
+    if (session.provider !== 'claude-cli')
+        return false;
+    if (tracker.sawExplicitCompletion || tracker.done)
+        return false;
+    if (!tracker.lastAssistantText.trim())
+        return false;
+    if (tracker.pendingToolUseIds.size > 0)
+        return false;
+    return true;
+}
 function parseCodexSessionRecord(record) {
     if (!record || typeof record !== 'object')
         return {};
@@ -374,62 +1548,543 @@ function parseCodexSessionRecord(record) {
         return { sessionId: record.payload.id };
     }
     if (record.type === 'event_msg' && record.payload?.type === 'task_started') {
-        return { detail: 'Task started' };
+        return {};
     }
     if (record.type === 'event_msg' && record.payload?.type === 'task_complete') {
-        const finalContent = normalizeAssistantContent(typeof record.payload?.last_agent_message === 'string' ? record.payload.last_agent_message : '');
+        const completionState = normalizeCompletionState(typeof record.payload?.last_agent_message === 'string' ? record.payload.last_agent_message : '');
         return {
-            finalContent,
+            assistantText: completionState.text,
+            finalContent: completionState.text,
             done: true,
         };
     }
     if (record.type === 'event_msg' && record.payload?.type === 'token_count' && record.payload?.info?.total_token_usage) {
+        const lastUsage = record.payload.info.last_token_usage;
+        if (lastUsage) {
+            // token.txt Change 1: keep inputTokens sum + add breakdown.
+            // Codex exposes only one cache field (cached_input_tokens) —
+            // we map it to inputTokensCacheRead since "cached" semantically
+            // means "served from cache." inputTokensCacheCreation is always
+            // 0 for Codex (no separate write billing on OpenAI).
+            const fresh = lastUsage.input_tokens || 0;
+            const cacheRead = lastUsage.cached_input_tokens || 0;
+            return {
+                usage: {
+                    inputTokens: fresh + cacheRead,
+                    inputTokensFresh: fresh,
+                    inputTokensCacheCreation: 0,
+                    inputTokensCacheRead: cacheRead,
+                    outputTokens: lastUsage.output_tokens || 0,
+                },
+            };
+        }
+        const fresh = record.payload.info.total_token_usage.input_tokens || 0;
+        const cacheRead = record.payload.info.total_token_usage.cached_input_tokens || 0;
         return {
             usage: {
-                inputTokens: (record.payload.info.total_token_usage.input_tokens || 0)
-                    + (record.payload.info.total_token_usage.cached_input_tokens || 0),
+                inputTokens: fresh + cacheRead,
+                inputTokensFresh: fresh,
+                inputTokensCacheCreation: 0,
+                inputTokensCacheRead: cacheRead,
                 outputTokens: record.payload.info.total_token_usage.output_tokens || 0,
             },
         };
     }
-    const assistantText = normalizeAssistantContent(extractCodexAssistantText(record));
+    const completionState = normalizeCompletionState(extractCodexAssistantText(record));
+    const assistantText = completionState.text;
     if (assistantText) {
-        return { finalContent: assistantText };
+        return {
+            assistantText,
+            finalContent: assistantText,
+            ...(completionState.hasSentinel ? { done: true } : {}),
+        };
     }
     if (record.type === 'event_msg' && typeof record.payload?.type === 'string') {
         const eventType = record.payload.type;
         if (!['user_message', 'agent_message', 'token_count', 'task_complete'].includes(eventType)) {
-            return { detail: eventType.replace(/_/g, ' ') };
+            return {};
         }
     }
     return {};
 }
 async function waitForFirstTerminalData(session) {
     await Promise.race([session.readyPromise, delay(5000)]);
-    await delay(session.startupDelayMs);
+    if (!session.startupDelayApplied) {
+        await delay(session.startupDelayMs);
+        session.startupDelayApplied = true;
+    }
+}
+async function waitForOutputToSettle(session, quietMs = 500, maxMs = 4000) {
+    const start = Date.now();
+    let lastLen = session.recentTerminalOutput.length;
+    while (Date.now() - start < maxMs) {
+        await delay(quietMs);
+        const currentLen = session.recentTerminalOutput.length;
+        if (currentLen === lastLen)
+            return;
+        lastLen = currentLen;
+    }
+}
+function buildWarmTimeoutError(provider, timeoutMs) {
+    const err = new Error(`${provider} warm session timed out after ${Math.floor(timeoutMs / 1000)}s`);
+    err.code = 'CLI_WARM_TIMEOUT';
+    err.name = 'CliWarmTimeoutError';
+    return err;
+}
+function withWarmTimeout(promise, timeoutMs, onTimeout, provider) {
+    let timeout = null;
+    const timeoutPromise = new Promise((_, reject) => {
+        timeout = setTimeout(() => {
+            try {
+                onTimeout();
+            }
+            finally {
+                reject(buildWarmTimeoutError(provider, timeoutMs));
+            }
+        }, timeoutMs);
+    });
+    return Promise.race([promise, timeoutPromise]).finally(() => {
+        if (timeout)
+            clearTimeout(timeout);
+    });
+}
+function logCliWarmEvent(event, fields) {
+    const suffix = Object.entries(fields)
+        .filter(([, value]) => value !== undefined && value !== null && value !== '')
+        .map(([key, value]) => `${key}=${JSON.stringify(value)}`)
+        .join(' ');
+    console.info(`[cli-warm] ${event}${suffix ? ` ${suffix}` : ''}`);
+}
+function buildCliWarmDiscardFailureReason(err) {
+    const error = err;
+    if (error?.code === 'CLI_WARM_TIMEOUT')
+        return 'warm_timeout';
+    if (error?.authRequired === true)
+        return 'auth_required';
+    if (error?.code === 'CLAUDE_FRESH_SESSION_STARTUP_TIMEOUT')
+        return 'warm_startup_timeout';
+    if (error?.name === 'AbortError')
+        return 'warm_aborted';
+    const message = String(error?.message || '').toLowerCase();
+    if (message.includes('closed before it was ready'))
+        return 'session_closed_before_ready';
+    return 'warm_failed';
+}
+async function writePromptInChunks(pty, promptText, chunkSize = 512, chunkDelayMs = 15) {
+    for (let offset = 0; offset < promptText.length; offset += chunkSize) {
+        pty.write(promptText.slice(offset, offset + chunkSize));
+        if (offset + chunkSize < promptText.length) {
+            await delay(chunkDelayMs);
+        }
+    }
+}
+async function writeBracketedPaste(pty, promptText, chunkSize, chunkDelayMs) {
+    pty.write('\x1b[200~');
+    await writePromptInChunks(pty, promptText, chunkSize, chunkDelayMs);
+    pty.write('\x1b[201~');
 }
 async function writeInteractivePrompt(session, promptText) {
     if (session.provider === 'codex-cli') {
-        session.pty.write(promptText);
+        const multiline = promptText.includes('\n');
+        if (multiline) {
+            await writeBracketedPaste(session.pty, promptText, 512, 15);
+        }
+        else {
+            await writePromptInChunks(session.pty, promptText);
+        }
         await delay(session.submitDelayMs);
         session.pty.write('\r');
         return;
     }
-    session.pty.write(promptText);
+    // 512-byte chunks with 10ms delays — proven safe for Windows ConPTY pipe buffer.
+    await writeBracketedPaste(session.pty, promptText, 512, 10);
+    await delay(session.submitDelayMs);
+    session.pty.write('\r');
+}
+async function writeNakedPrompt(session, text) {
+    await writePromptInChunks(session.pty, text);
+    await delay(session.submitDelayMs);
     session.pty.write('\r');
 }
+function parseJsonObject(raw) {
+    const trimmed = String(raw || '').trim();
+    if (!trimmed)
+        return null;
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // ignore invalid JSON and fall back to the default CLI behavior
+    }
+    return null;
+}
+function buildClaudeCliArgs(resumeSessionId, newSessionId, settings) {
+    const args = ['--dangerously-skip-permissions'];
+    const model = String(settings?.model || '').trim();
+    if (model && model.toLowerCase() !== 'default') {
+        args.push('--model', model);
+    }
+    const effortLevel = String(settings?.effortLevel || '').trim().toLowerCase();
+    if (['low', 'medium', 'high', 'max'].includes(effortLevel)) {
+        args.push('--effort', effortLevel);
+    }
+    const runtimeSettings = {};
+    const outputStyle = String(settings?.outputStyle || '').trim();
+    if (outputStyle && outputStyle.toLowerCase() !== 'default')
+        runtimeSettings.outputStyle = outputStyle;
+    if (settings?.fastMode === true)
+        runtimeSettings.fastMode = true;
+    const permissions = parseJsonObject(settings?.permissionsJson);
+    if (permissions)
+        runtimeSettings.permissions = permissions;
+    if (Object.keys(runtimeSettings).length > 0) {
+        args.push('--settings', JSON.stringify(runtimeSettings));
+    }
+    if (resumeSessionId) {
+        args.push('--resume', resumeSessionId);
+    }
+    else if (newSessionId) {
+        args.push('--session-id', newSessionId);
+    }
+    return args;
+}
+function appendCodexConfigOverride(args, key, value) {
+    const trimmed = String(value || '').trim();
+    if (!trimmed)
+        return;
+    args.push('-c', `${key}=${JSON.stringify(trimmed)}`);
+}
+function buildCodexCliArgs(resumeSessionId, settings) {
+    const model = String(settings?.model || '').trim();
+    const sandboxPolicy = String(settings?.sandboxPolicy || '').trim() || 'danger-full-access';
+    const approvalPolicy = String(settings?.approvalPolicy || '').trim() || 'never';
+    const args = resumeSessionId ? ['resume', resumeSessionId] : [];
+    args.push('--no-alt-screen');
+    if (model && model.toLowerCase() !== 'default') {
+        args.push('-m', model);
+    }
+    args.push('-s', sandboxPolicy, '-a', approvalPolicy);
+    appendCodexConfigOverride(args, 'shell_environment_policy.inherit', 'all');
+    appendCodexConfigOverride(args, 'model_reasoning_effort', settings?.reasoningEffort);
+    appendCodexConfigOverride(args, 'personality', settings?.personality);
+    appendCodexConfigOverride(args, 'service_tier', settings?.serviceTier);
+    return args;
+}
+function trimPassthroughSlashChrome(command, rawText) {
+    const normalized = rawText.replace(/\r\n/g, '\n').trim();
+    if (!command.startsWith('/'))
+        return normalized;
+    const markers = [
+        `\n> ${command}\n\n`,
+        `\n${command}\n\n`,
+        `\n> ${command}\n`,
+        `\n${command}\n`,
+        `> ${command}\n\n`,
+        `${command}\n\n`,
+    ];
+    for (const marker of markers) {
+        const idx = normalized.indexOf(marker);
+        if (idx < 0)
+            continue;
+        const candidate = normalized.slice(idx + marker.length).trim();
+        if (candidate)
+            return cleanPassthroughSlashText(command, candidate);
+    }
+    return cleanPassthroughSlashText(command, normalized);
+}
+function finalizePassthroughContent(command, visibleOutput, rawOutput) {
+    const visible = String(visibleOutput || '').trim();
+    if (visible) {
+        return trimPassthroughSlashChrome(command, visible);
+    }
+    const rawNormalized = normalizeTerminalChunk(rawOutput || '');
+    return trimPassthroughSlashChrome(command, rawNormalized);
+}
+function cleanPassthroughSlashText(command, text) {
+    const normalizedCommand = String(command || '').trim().toLowerCase();
+    if (!text.trim()) {
+        return text.trim();
+    }
+    const kept = [];
+    let lastFingerprint = '';
+    for (const rawLine of text.replace(/\r\n/g, '\n').split('\n')) {
+        const cleanedLine = cleanNormalizedSlashPassthroughLine(normalizedCommand, rawLine);
+        if (cleanedLine === null)
+            continue;
+        if (!cleanedLine) {
+            if (kept.length > 0 && kept[kept.length - 1] !== '')
+                kept.push('');
+            continue;
+        }
+        const fingerprint = cleanedLine.toLowerCase();
+        if (fingerprint === lastFingerprint)
+            continue;
+        kept.push(cleanedLine);
+        lastFingerprint = fingerprint;
+    }
+    return kept.join('\n').replace(/\n{3,}/g, '\n\n').trim();
+}
+function cleanSlashPassthroughLine(command, rawLine) {
+    const trimmedRight = rawLine.replace(/\s+$/g, '');
+    const trimmed = trimmedRight.trim();
+    if (!trimmed)
+        return '';
+    let withoutChrome = trimmedRight
+        .replace(/^\s*Esc to cancel\s+/i, '')
+        .replace(/(?:^|\s)(?:[>›â»âµâ–¸â–¶]+\s*)?bypass permissions on \(shift(?:\+|-)tab to cycle\).*$/i, '')
+        .replace(/\s+[•●·-]+\s*\/effort\s*$/i, '')
+        .replace(/\s+\/effort\s*$/i, '')
+        .trim();
+    if (!withoutChrome)
+        return null;
+    if (/^[─━│═┄┈]{4,}$/u.test(withoutChrome))
+        return null;
+    if (/^Status(?:\s+Config)?(?:\s+Usage)?(?:\s+Stats)?$/i.test(withoutChrome))
+        return null;
+    if (/^(?:Loading usage data|Scanning local sessions)$/i.test(withoutChrome))
+        return null;
+    if (command === '/usage' && /^[dw]\s+to\s+\w+/i.test(withoutChrome))
+        return null;
+    if (/^(?:[>›â»âµâ–¸â–¶]+\s*)?bypass permissions on \(shift(?:\+|-)tab to cycle\)/i.test(withoutChrome))
+        return null;
+    if (/^permissions on \(shift(?:\+|-)tab to cycle\)/i.test(withoutChrome))
+        return null;
+    return withoutChrome || null;
+}
+function cleanNormalizedSlashPassthroughLine(command, rawLine) {
+    const trimmedRight = rawLine.replace(/\s+$/g, '');
+    const trimmed = trimmedRight.trim();
+    if (!trimmed)
+        return '';
+    let withoutChrome = trimmedRight
+        .replace(/^\s*Esc to cancel\s+/i, '')
+        .replace(/(?:^|\s)(?:>+\s*)?bypass permissions on \(shift(?:\+|-)tab to cycle\).*$/i, '')
+        .replace(/\s+[•●·-]+\s*\/effort\s*$/i, '')
+        .replace(/\s+\/effort\s*$/i, '')
+        .trim();
+    if (!withoutChrome)
+        return null;
+    if (/^[\u2500-\u257F\u2580-\u259F=_-]{4,}$/u.test(withoutChrome))
+        return null;
+    if (/^>+\s*$/.test(withoutChrome))
+        return null;
+    if (/^permissions on \(shift(?:\+|-)tab to cycle\)/i.test(withoutChrome))
+        return null;
+    if (/^bypass permissions on \(shift(?:\+|-)tab to cycle\)/i.test(withoutChrome))
+        return null;
+    if (command === '/cost' || command === '/usage') {
+        if (/^Status(?:\s+Config)?(?:\s+Usage)?(?:\s+Stats)?$/i.test(withoutChrome))
+            return null;
+        if (/^(?:Loading usage data|Scanning local sessions)$/i.test(withoutChrome))
+            return null;
+        if (command === '/usage' && /^[dw]\s+to\s+\w+/i.test(withoutChrome))
+            return null;
+    }
+    return withoutChrome || null;
+}
+function trimPassthroughSlashChromeForTest(command, rawText) {
+    return trimPassthroughSlashChrome(command, rawText);
+}
+function finalizePassthroughContentForTest(command, visibleOutput, rawOutput) {
+    return finalizePassthroughContent(command, visibleOutput, rawOutput);
+}
 class LocalCliPtySessionManager {
     sessions = new Map();
+    async warmSession(opts) {
+        const key = sessionKey(opts.conversationId, opts.botId);
+        const isServiceMode = process.env.FUNOLIO_RUN_CONTEXT === 'windows-service'
+            || process.argv.includes('--mode') && (process.argv.includes('service') || process.argv.includes('windows-service'));
+        const requestedUseConpty = opts.useConpty ?? !isServiceMode;
+        let session = this.sessions.get(key);
+        if (session
+            && (session.provider !== opts.provider
+                || session.cwd !== opts.cwd
+                || session.useConpty !== requestedUseConpty
+                || shouldRecycleClaudeSessionForFreshAuth(session)
+                || shouldResetClaudeSessionForAuthChange(session)
+                || session.closed)) {
+            if (session.provider === 'claude-cli' && shouldRecycleClaudeSessionForFreshAuth(session)) {
+                console.info(`[claude-auth] recycling warm session before resume (${opts.botId} ${opts.conversationId})`);
+            }
+            else if (session.provider === 'claude-cli' && shouldResetClaudeSessionForAuthChange(session)) {
+                console.info(`[claude-auth] recycling warm session after auth change (${opts.botId})`);
+            }
+            this.closeSession(key);
+            session = undefined;
+        }
+        const reusedExistingSession = !!session;
+        if (!session) {
+            if (opts.provider === 'claude-cli') {
+                await ensureClaudeAuthReadyForFreshSession();
+            }
+            session = this.createSession(key, opts.botId, opts.conversationId, opts.provider, opts.botSettings, opts.cwd, requestedUseConpty, {
+                actorId: opts.toolActorId,
+                projectId: opts.toolProjectId,
+                todoTaskId: opts.currentTodoTaskId,
+            }, opts.resumeSessionId, opts.newSessionId);
+            this.sessions.set(key, session);
+        }
+        if (opts.topicId !== undefined) {
+            session.topicId = opts.topicId || null;
+        }
+        if (opts.runtimeMode !== undefined) {
+            session.warmRuntimeMode = opts.runtimeMode || null;
+        }
+        if (reusedExistingSession && !session.warmPromise && !session.warmReadyAtMs && session.readyResolved) {
+            (0, managed_process_registry_1.markReused)(key);
+            logCliWarmEvent('warm_reuse_existing', {
+                conversationId: opts.conversationId,
+                botId: opts.botId,
+                provider: opts.provider,
+                runtimeMode: session.warmRuntimeMode || opts.runtimeMode || 'local_desktop',
+                topicId: session.topicId,
+                reusedExistingSession,
+                ageMs: Date.now() - session.lastUsedAtMs,
+            });
+            return {
+                sessionId: session.sessionId,
+                reusedExistingSession,
+                readyAgeMs: Math.max(0, Date.now() - session.lastUsedAtMs),
+            };
+        }
+        if (!session.warmPromise && !session.warmReadyAtMs) {
+            const warmStartedAtMs = Date.now();
+            session.warmRequestedAtMs = warmStartedAtMs;
+            const warmTask = (async () => {
+                await waitForFirstTerminalData(session);
+                if (session.closed) {
+                    throw new Error(`${opts.provider} warm session closed before it was ready`);
+                }
+                if (!session.readyResolved) {
+                    throw new Error(`${opts.provider} warm session did not produce startup output`);
+                }
+                const authFailure = buildCliInteractiveAuthError(session.provider, session.recentTerminalOutput);
+                if (authFailure) {
+                    throw authFailure;
+                }
+                await waitForOutputToSettle(session);
+                session.warmReadyAtMs = Date.now();
+            })();
+            session.warmPromise = withWarmTimeout(warmTask, opts.timeoutMs ?? CLI_WARM_TIMEOUT_MS, () => this.closeSession(key), opts.provider).catch((err) => {
+                if (this.sessions.get(key) === session) {
+                    this.closeSession(key);
+                }
+                throw err;
+            });
+        }
+        await session.warmPromise;
+        const readyAtMs = session.warmReadyAtMs || Date.now();
+        return {
+            sessionId: session.sessionId,
+            reusedExistingSession,
+            readyAgeMs: Math.max(0, Date.now() - readyAtMs),
+        };
+    }
     async runTurn(opts) {
         const key = sessionKey(opts.conversationId, opts.botId);
+        // Default to WinPTY (useConpty: false) when running as a detached sidecar
+        // without a console window. ConPTY requires a console host and fails silently
+        // when the process was launched with CREATE_NO_WINDOW.
+        const isServiceMode = process.env.FUNOLIO_RUN_CONTEXT === 'windows-service'
+            || process.argv.includes('--mode') && (process.argv.includes('service') || process.argv.includes('windows-service'));
+        const requestedUseConpty = opts.useConpty ?? !isServiceMode;
         let session = this.sessions.get(key);
+        const preserveFreshWarm = !!session
+            && !!opts.forceFreshSession
+            && session.provider === 'codex-cli'
+            && !!session.warmReadyAtMs
+            && !session.sessionId;
         if (session
-            && (opts.forceFreshSession || session.provider !== opts.provider || session.cwd !== opts.cwd || session.closed)) {
+            && ((opts.forceFreshSession && !preserveFreshWarm)
+                || session.provider !== opts.provider
+                || session.cwd !== opts.cwd
+                || session.useConpty !== requestedUseConpty
+                || shouldRecycleClaudeSessionForFreshAuth(session)
+                || shouldResetClaudeSessionForAuthChange(session)
+                || session.closed)) {
+            if (session.provider === 'claude-cli' && shouldRecycleClaudeSessionForFreshAuth(session)) {
+                console.info(`[claude-auth] recycling turn session before resume (${opts.botId} ${opts.conversationId})`);
+            }
+            else if (session.provider === 'claude-cli' && shouldResetClaudeSessionForAuthChange(session)) {
+                console.info(`[claude-auth] recycling turn session after auth change (${opts.botId})`);
+            }
             this.closeSession(key);
             session = undefined;
         }
+        if (session?.warmPromise) {
+            try {
+                await session.warmPromise;
+                logCliWarmEvent('warm_reused', {
+                    conversationId: opts.conversationId,
+                    botId: opts.botId,
+                    provider: opts.provider,
+                    runtimeMode: session.warmRuntimeMode || 'local_desktop',
+                    topicId: session.topicId,
+                    reusedExistingSession: true,
+                    ageMs: session.warmReadyAtMs ? Date.now() - session.warmReadyAtMs : 0,
+                });
+                session.warmPromise = null;
+                session.warmRequestedAtMs = null;
+                session.warmReadyAtMs = null;
+            }
+            catch (err) {
+                logCliWarmEvent('warm_discarded', {
+                    conversationId: opts.conversationId,
+                    botId: opts.botId,
+                    provider: opts.provider,
+                    runtimeMode: session.warmRuntimeMode || 'local_desktop',
+                    topicId: session.topicId,
+                    reusedExistingSession: true,
+                    failureReason: buildCliWarmDiscardFailureReason(err),
+                });
+                if (this.sessions.get(key) === session) {
+                    this.closeSession(key);
+                }
+                session = undefined;
+            }
+        }
+        else if (session?.warmReadyAtMs) {
+            logCliWarmEvent('warm_reused', {
+                conversationId: opts.conversationId,
+                botId: opts.botId,
+                provider: opts.provider,
+                runtimeMode: session.warmRuntimeMode || 'local_desktop',
+                topicId: session.topicId,
+                reusedExistingSession: true,
+                ageMs: Date.now() - session.warmReadyAtMs,
+            });
+            session.warmPromise = null;
+            session.warmRequestedAtMs = null;
+            session.warmReadyAtMs = null;
+        }
         if (!session) {
-            session = this.createSession(key, opts.provider, opts.cwd);
+            if (opts.provider === 'claude-cli') {
+                await ensureClaudeAuthReadyForFreshSession();
+            }
+            logCliWarmEvent('send_cold', {
+                conversationId: opts.conversationId,
+                botId: opts.botId,
+                provider: opts.provider,
+            });
+            try {
+                session = this.createSession(key, opts.botId, opts.conversationId, opts.provider, opts.botSettings, opts.cwd, requestedUseConpty, {
+                    actorId: opts.toolActorId,
+                    projectId: opts.toolProjectId,
+                    todoTaskId: opts.currentTodoTaskId,
+                }, opts.resumeSessionId, opts.newSessionId);
+            }
+            catch (firstErr) {
+                console.warn(`[pty] Session creation failed, retrying in 1s: ${firstErr instanceof Error ? firstErr.message : String(firstErr)}`);
+                await delay(1000);
+                session = this.createSession(key, opts.botId, opts.conversationId, opts.provider, opts.botSettings, opts.cwd, requestedUseConpty, {
+                    actorId: opts.toolActorId,
+                    projectId: opts.toolProjectId,
+                    todoTaskId: opts.currentTodoTaskId,
+                }, opts.resumeSessionId, opts.newSessionId);
+            }
             this.sessions.set(key, session);
         }
         const run = async () => this.runTurnInternal(session, opts);
@@ -437,9 +2092,107 @@ class LocalCliPtySessionManager {
         session.chain = queued.then(() => undefined, () => undefined);
         return queued;
     }
+    async runPassthroughCommand(opts) {
+        const key = sessionKey(opts.conversationId, opts.botId);
+        const isServiceMode = process.env.FUNOLIO_RUN_CONTEXT === 'windows-service'
+            || process.argv.includes('--mode') && (process.argv.includes('service') || process.argv.includes('windows-service'));
+        const requestedUseConpty = opts.useConpty ?? !isServiceMode;
+        let session = this.sessions.get(key);
+        if (session
+            && (opts.forceFreshSession
+                || session.provider !== opts.provider
+                || session.cwd !== opts.cwd
+                || session.useConpty !== requestedUseConpty
+                || shouldRecycleClaudeSessionForFreshAuth(session)
+                || shouldResetClaudeSessionForAuthChange(session)
+                || session.closed)) {
+            if (session.provider === 'claude-cli' && shouldRecycleClaudeSessionForFreshAuth(session)) {
+                console.info(`[claude-auth] recycling passthrough session before resume (${opts.botId} ${opts.conversationId})`);
+            }
+            else if (session.provider === 'claude-cli' && shouldResetClaudeSessionForAuthChange(session)) {
+                console.info(`[claude-auth] recycling passthrough session after auth change (${opts.botId})`);
+            }
+            this.closeSession(key);
+            session = undefined;
+        }
+        if (!session) {
+            if (opts.provider === 'claude-cli') {
+                await ensureClaudeAuthReadyForFreshSession();
+            }
+            session = this.createSession(key, opts.botId, opts.conversationId, opts.provider, opts.botSettings, opts.cwd, requestedUseConpty, {
+                actorId: opts.toolActorId,
+                projectId: opts.toolProjectId,
+                todoTaskId: opts.currentTodoTaskId,
+            }, opts.resumeSessionId, opts.newSessionId);
+            this.sessions.set(key, session);
+        }
+        const run = async () => this.runPassthroughInternal(session, opts);
+        const queued = session.chain.then(run, run);
+        session.chain = queued.then(() => undefined, () => undefined);
+        return queued;
+    }
+    hasActiveSession(conversationId, botId) {
+        const session = this.sessions.get(sessionKey(conversationId, botId));
+        return !!session && !session.closed;
+    }
     closeSessionByConversation(conversationId, botId) {
         this.closeSession(sessionKey(conversationId, botId));
     }
+    logSessionFailureByConversation(conversationId, botId, context, error) {
+        const session = this.sessions.get(sessionKey(conversationId, botId));
+        if (!session)
+            return;
+        const ptyBuffer = session.recentTerminalOutput || session.activeTurn?.rawOutput || '';
+        const ptyPid = session.pty.pid;
+        console.warn(`[local-cli-pty] ${context}`
+            + ` | sessionId=${session.sessionId || 'unknown'}`
+            + ` | botId=${botId}`
+            + ` | pid=${ptyPid || 'unknown'}`
+            + (error ? ` | error=${String(error?.message || error)}` : '')
+            + (ptyBuffer
+                ? `\n--- PTY buffer (last ${ptyBuffer.length} chars) ---\n${ptyBuffer}\n--- end PTY buffer ---`
+                : ''));
+    }
+    closeSessionsByConversation(conversationId) {
+        const prefix = `${conversationId}::`;
+        let closed = 0;
+        for (const key of [...this.sessions.keys()]) {
+            if (key.startsWith(prefix)) {
+                this.closeSession(key);
+                closed++;
+            }
+        }
+        return closed;
+    }
+    closeWarmSessionsByConversation(conversationId) {
+        const prefix = `${conversationId}::`;
+        let closed = 0;
+        for (const [key, session] of [...this.sessions.entries()]) {
+            if (key.startsWith(prefix) && (session.warmPromise || session.warmReadyAtMs)) {
+                this.closeSession(key);
+                closed++;
+            }
+        }
+        return closed;
+    }
+    closeIdleClaudeSessions() {
+        let closed = 0;
+        for (const [key, session] of [...this.sessions.entries()]) {
+            if (!isIdleClaudeSession(session))
+                continue;
+            this.closeSession(key);
+            closed++;
+        }
+        return closed;
+    }
+    closeSessionsByBotId(botId) {
+        const suffix = `::${botId}`;
+        for (const key of [...this.sessions.keys()]) {
+            if (key.endsWith(suffix)) {
+                this.closeSession(key);
+            }
+        }
+    }
     closeAll() {
         for (const key of [...this.sessions.keys()]) {
             this.closeSession(key);
@@ -450,147 +2203,524 @@ class LocalCliPtySessionManager {
         if (!session)
             return;
         session.closed = true;
-        try {
-            session.pty.kill();
+        clearSessionWarmState(session);
+        const ptyPid = session.pty.pid;
+        let closeFailed = false;
+        if (ptyPid) {
+            const killResult = (0, managed_process_registry_1.killProcessTreeDetailed)(ptyPid);
+            closeFailed = !killResult.killed || !!killResult.error;
         }
-        catch {
-            // best effort
+        else {
+            try {
+                session.pty.kill();
+            }
+            catch {
+                closeFailed = true;
+            }
         }
         this.sessions.delete(key);
+        (0, managed_process_registry_1.unregisterProcess)(key, false, closeFailed);
+    }
+    closeSessionByKey(key) {
+        this.closeSession(key);
     }
-    createSession(key, provider, cwd) {
+    createSession(key, botId, conversationId, provider, botSettings, cwd, useConpty, toolEnv, resumeSessionId, newSessionId) {
         const ptyModule = loadNodePtyModule();
+        const claudeSessionHome = provider === 'claude-cli'
+            ? (0, sync_cli_config_1.ensureCliSessionRuntimeHome)('claude-cli', botId, conversationId)
+            : null;
+        const sessionFilesRoot = getProviderSessionRoot(provider, claudeSessionHome || undefined);
         const cleanEnv = { ...process.env };
-        delete cleanEnv.CLAUDECODE;
-        delete cleanEnv.CLAUDE_CODE_ENTRYPOINT;
-        delete cleanEnv.CLAUDE_CODE_SESSION_ID;
+        for (const envKey of Object.keys(cleanEnv)) {
+            if (envKey === 'CLAUDECODE' || envKey.startsWith('CLAUDE_CODE_')) {
+                delete cleanEnv[envKey];
+            }
+        }
+        if (claudeSessionHome) {
+            cleanEnv.CLAUDE_CONFIG_DIR = claudeSessionHome;
+        }
+        if (toolEnv?.actorId?.trim())
+            cleanEnv.FUNOLIO_TOOL_ACTOR_ID = toolEnv.actorId.trim();
+        if (toolEnv?.projectId !== undefined && toolEnv.projectId !== null)
+            cleanEnv.FUNOLIO_TOOL_PROJECT_ID = String(toolEnv.projectId);
+        if (toolEnv?.todoTaskId !== undefined && toolEnv.todoTaskId !== null)
+            cleanEnv.FUNOLIO_TOOL_TODO_ID = String(toolEnv.todoTaskId);
+        const markerEnv = (0, managed_process_registry_1.getMarkerEnv)(key);
+        for (const [mk, mv] of Object.entries(markerEnv)) {
+            cleanEnv[mk] = mv;
+        }
+        if (provider === 'claude-cli') {
+            (0, sync_cli_config_1.syncClaudeJsonConfig)({
+                ...(toolEnv?.actorId?.trim() ? { FUNOLIO_TOOL_ACTOR_ID: toolEnv.actorId.trim() } : {}),
+                ...(toolEnv?.projectId !== undefined && toolEnv.projectId !== null ? { FUNOLIO_TOOL_PROJECT_ID: String(toolEnv.projectId) } : {}),
+            }, (0, sync_cli_config_1.claudeJsonConfigPath)(claudeSessionHome || undefined));
+        }
+        else {
+            void (0, sync_cli_config_1.syncMcpToCliConfig)('codex-cli', {
+                ...(toolEnv?.actorId?.trim() ? { FUNOLIO_TOOL_ACTOR_ID: toolEnv.actorId.trim() } : {}),
+                ...(toolEnv?.projectId !== undefined && toolEnv.projectId !== null ? { FUNOLIO_TOOL_PROJECT_ID: String(toolEnv.projectId) } : {}),
+            }).catch(() => { });
+        }
+        // Snapshot existing session files BEFORE spawning the PTY.
+        // Only needed for Pattern B providers (no --session-id support).
+        // Pattern A providers know their file path from the generated ID.
+        const preSpawnSnapshot = new Set(listSessionFiles(provider, sessionFilesRoot));
         let readyResolve = null;
         const readyPromise = new Promise((resolve) => {
             readyResolve = resolve;
         });
+        // Build Claude CLI args with session control:
+        // Claude: when launching a brand-new process, prefer a fresh Claude
+        // session-id over reviving a dead Claude-side session with --resume.
+        // Codex: no session flags on new, codex resume <id> for existing.
+        const claudeLaunch = resolveClaudeLaunchSessionIds(resumeSessionId, newSessionId);
+        const claudeArgs = buildClaudeCliArgs(claudeLaunch.resumeSessionId, claudeLaunch.newSessionId, botSettings?.claude);
+        // Determine known session info for transcript discovery.
+        const knownSessionId = claudeLaunch.knownSessionId;
+        let knownSessionFilePath = null;
+        if (knownSessionId && provider === 'claude-cli') {
+            // Search all project directories for the session file.
+            // Don't try to derive the directory name — Claude's naming convention
+            // (e.g., C--Projects-Funolio) doesn't match simple path normalization.
+            const projectRoot = sessionFilesRoot;
+            if (fs.existsSync(projectRoot)) {
+                try {
+                    const projectDirs = fs.readdirSync(projectRoot);
+                    for (const dir of projectDirs) {
+                        const candidate = path.join(projectRoot, dir, `${knownSessionId}.jsonl`);
+                        if (fs.existsSync(candidate)) {
+                            knownSessionFilePath = candidate;
+                            break;
+                        }
+                    }
+                }
+                catch { }
+            }
+            // For new sessions, file doesn't exist yet. We'll find it after Claude creates it
+            // by searching again in the polling loop (or it'll be discovered via discoverSessionFile).
+        }
+        else if (knownSessionId && provider === 'codex-cli') {
+            knownSessionFilePath = findCodexSessionFileBySessionId(knownSessionId);
+        }
+        const codexArgs = buildCodexCliArgs(resumeSessionId, botSettings?.codex);
         const pty = provider === 'codex-cli'
-            ? ptyModule.spawn(findExecutableOnPath('codex.cmd') || 'codex.cmd', ['--no-alt-screen'], {
+            ? ptyModule.spawn(findExecutableOnPath('codex.cmd') || 'codex.cmd', codexArgs, {
                 cwd,
                 cols: 160,
                 rows: 48,
                 env: cleanEnv,
-                useConpty: true,
+                useConpty,
                 name: 'xterm-color',
             })
-            : ptyModule.spawn('cmd.exe', [], {
+            : ptyModule.spawn(findExecutableOnPath('claude.exe') || findExecutableOnPath('claude.cmd') || 'claude', claudeArgs, {
                 cwd,
                 cols: 160,
                 rows: 48,
                 env: cleanEnv,
-                useConpty: true,
+                useConpty,
                 name: 'xterm-color',
             });
         const session = {
             key,
+            conversationId,
+            botId,
+            topicId: null,
+            warmRuntimeMode: null,
             provider,
             cwd,
+            useConpty,
             pty,
             createdAtMs: Date.now(),
             lastUsedAtMs: Date.now(),
-            launchSnapshot: new Set(listSessionFiles(provider)),
-            sessionId: null,
-            sessionFilePath: null,
+            launchSnapshot: preSpawnSnapshot,
+            sessionFilesRoot,
+            sessionId: knownSessionId,
+            sessionFilePath: knownSessionFilePath,
             sessionFileOffset: 0,
             sessionFileCarry: '',
             readyPromise,
             readyResolved: false,
-            waitForNextSendMs: 250,
-            startupDelayMs: provider === 'codex-cli' ? 9000 : 1200,
-            submitDelayMs: provider === 'codex-cli' ? 350 : 0,
+            waitForNextSendMs: 100,
+            startupDelayMs: 1200,
+            startupDelayApplied: false,
+            submitDelayMs: provider === 'codex-cli' ? 175 : 200,
             currentPromptLocator: null,
             currentPromptStartedAtMs: 0,
+            activeTurn: null,
+            warmPromise: null,
+            warmRequestedAtMs: null,
+            warmReadyAtMs: null,
+            recentTerminalOutput: '',
             closed: false,
+            exitReason: null,
             chain: Promise.resolve(),
+            childFollowers: new Map(),
+            childSnapshot: new Set(),
+            claudeAuthFingerprint: provider === 'claude-cli' ? currentClaudeAuthFingerprint() : null,
+            runtimeHomeDir: claudeSessionHome,
         };
+        const ptyPid = pty.pid;
+        if (ptyPid) {
+            (0, managed_process_registry_1.registerProcess)({
+                sessionKey: key,
+                provider,
+                conversationId,
+                botId,
+                pid: ptyPid,
+                cwd,
+                createdAt: new Date(session.createdAtMs).toISOString(),
+                lastUsedAt: new Date(session.lastUsedAtMs).toISOString(),
+            });
+        }
         pty.on('data', (chunk) => {
+            if (chunk) {
+                (0, managed_process_registry_1.markTurnActivity)(session.key, 'pty_data');
+                session.recentTerminalOutput = appendRecentTerminalOutput(session.recentTerminalOutput, chunk);
+            }
             if (!session.readyResolved && chunk && chunk.trim()) {
                 session.readyResolved = true;
                 readyResolve?.();
             }
+            if (session.activeTurn && chunk) {
+                void emitPtyChunk(session, chunk);
+            }
         });
-        pty.on('exit', () => {
+        pty.on('exit', (...exitArgs) => {
             session.closed = true;
+            session.exitReason = describePtyExit(exitArgs);
+            console.warn(`[local-cli-pty] ${provider} PTY exited (${session.exitReason}) cwd=${cwd}`);
             this.sessions.delete(key);
+            (0, managed_process_registry_1.unregisterProcess)(key, false);
         });
-        if (provider === 'claude-cli') {
-            pty.write('claude\r');
-        }
         return session;
     }
-    async runTurnInternal(session, opts) {
-        session.lastUsedAtMs = Date.now();
-        await waitForFirstTerminalData(session);
-        if (session.closed) {
-            throw new Error(`${session.provider} PTY session closed before prompt was sent`);
-        }
-        if (session.waitForNextSendMs > 0) {
-            await delay(session.waitForNextSendMs);
-        }
-        const tracker = {
-            done: false,
-            finalContent: '',
-            usage: undefined,
-            lastAssistantText: '',
-            detailFingerprints: new Set(),
+    async runPassthroughInternal(session, opts) {
+        const abortSignal = opts.abortSignal;
+        const abortHandler = () => {
+            this.closeSession(session.key);
         };
-        const timeoutMs = opts.timeoutMs ?? 10 * 60 * 1000;
-        const startedAtMs = Date.now();
-        const promptText = buildTurnPrompt(opts.provider, opts.systemPrompt, opts.messages, opts.forceFreshSession || !session.sessionFilePath);
-        session.currentPromptLocator = promptText.trim();
-        session.currentPromptStartedAtMs = startedAtMs;
-        await writeInteractivePrompt(session, promptText);
-        while (!tracker.done) {
-            if (Date.now() - startedAtMs > timeoutMs) {
-                throw new Error(`${opts.provider} PTY session timed out waiting for a response`);
+        abortSignal?.addEventListener('abort', abortHandler, { once: true });
+        try {
+            session.lastUsedAtMs = Date.now();
+            (0, managed_process_registry_1.updateLastUsed)(session.key);
+            (0, managed_process_registry_1.markTurnStarted)(session.key, 'pty_passthrough');
+            throwIfAborted(abortSignal);
+            await waitForFirstTerminalData(session);
+            throwIfAborted(abortSignal);
+            if (session.closed) {
+                throw formatClosedSessionError(session, `closed before ${opts.command} was sent`);
+            }
+            if (session.waitForNextSendMs > 0) {
+                await delayWithAbort(session.waitForNextSendMs, abortSignal);
+            }
+            const timeoutMs = opts.timeoutMs ?? 30_000;
+            const startedAtMs = Date.now();
+            const activeTurn = {
+                mode: 'passthrough',
+                promptEchoRemainder: normalizeTerminalChunk(opts.command),
+                rawOutput: '',
+                visibleOutput: '',
+                lastDataAtMs: startedAtMs,
+                lastMeaningfulPtyDataAtMs: startedAtMs,
+                callbackChain: Promise.resolve(),
+                onRawChunk: opts.onRawChunk,
+                recentChromeLines: [],
+                assistantOutputDetected: false,
+                sawVisibleData: false,
+            };
+            session.activeTurn = activeTurn;
+            throwIfAborted(abortSignal);
+            await writeNakedPrompt(session, opts.command);
+            while (true) {
+                throwIfAborted(abortSignal);
+                const now = Date.now();
+                const authFailure = getTerminalAuthFailure(session, activeTurn);
+                if (authFailure) {
+                    if (session.provider === 'claude-cli')
+                        this.closeSession(session.key);
+                    throw authFailure;
+                }
+                if (!activeTurn.rawOutput) {
+                    if (now - startedAtMs > PASSTHROUGH_FIRST_BYTE_TIMEOUT_MS) {
+                        throw new Error(`${session.provider} PTY session returned no output for ${opts.command}`);
+                    }
+                }
+                else if (now - activeTurn.lastDataAtMs >= PASSTHROUGH_TRAILING_IDLE_MS) {
+                    break;
+                }
+                if (now - startedAtMs > timeoutMs) {
+                    throw new Error(`${session.provider} PTY session timed out waiting for ${opts.command}`);
+                }
+                await delayWithAbort(50, abortSignal);
             }
+            await activeTurn.callbackChain.catch(() => undefined);
+            return {
+                content: finalizePassthroughContent(opts.command, activeTurn.visibleOutput, activeTurn.rawOutput),
+                sessionId: session.sessionId,
+                rawOutput: activeTurn.rawOutput,
+            };
+        }
+        finally {
+            syncClaudeSessionCredentialsBackToCanonical(session);
+            session.activeTurn = null;
+            (0, managed_process_registry_1.markTurnFinished)(session.key, 'pty_passthrough_finished');
+            abortSignal?.removeEventListener('abort', abortHandler);
+        }
+    }
+    async runTurnInternal(session, opts) {
+        const abortSignal = opts.abortSignal;
+        const abortHandler = () => {
+            this.closeSession(session.key);
+        };
+        abortSignal?.addEventListener('abort', abortHandler, { once: true });
+        try {
+            session.lastUsedAtMs = Date.now();
+            (0, managed_process_registry_1.updateLastUsed)(session.key);
+            (0, managed_process_registry_1.markTurnStarted)(session.key, 'pty_turn');
+            throwIfAborted(abortSignal);
+            await waitForFirstTerminalData(session);
+            throwIfAborted(abortSignal);
             if (session.closed) {
-                throw new Error(`${opts.provider} PTY session exited while waiting for a response`);
+                throw formatClosedSessionError(session, 'closed before prompt was sent');
             }
-            if (!session.sessionFilePath) {
-                const discovered = discoverSessionFile(session.provider, session.launchSnapshot, session.currentPromptStartedAtMs || session.createdAtMs, session.currentPromptLocator);
-                if (discovered) {
-                    session.sessionFilePath = discovered;
-                    session.sessionFileOffset = 0;
+            // Reset the read offset at the start of every turn so we only consume records
+            // appended after this prompt. A shared Claude session file can be advanced by
+            // another caller between turns, and replaying that backlog can finalize the
+            // wrong assistant response before the current prompt lands.
+            if (session.sessionFilePath) {
+                try {
+                    const currentSize = fs.statSync(session.sessionFilePath).size;
+                    session.sessionFileOffset = currentSize;
                     session.sessionFileCarry = '';
                 }
+                catch {
+                    // File may not exist yet for new sessions — that's fine.
+                }
             }
-            if (session.sessionFilePath && fs.existsSync(session.sessionFilePath)) {
-                await this.consumeSessionFile(session, tracker, opts.onDetail);
+            if (session.waitForNextSendMs > 0) {
+                await delayWithAbort(session.waitForNextSendMs, abortSignal);
             }
-            if (!tracker.done) {
-                await delay(250);
+            const timeoutMs = opts.timeoutMs ?? 10 * 60 * 1000;
+            const startedAtMs = Date.now();
+            const tracker = {
+                done: false,
+                sawExplicitCompletion: false,
+                finalContent: '',
+                usage: undefined,
+                lastAssistantText: '',
+                detailFingerprints: new Set(),
+                pendingToolUseIds: new Set(),
+                lastRecordAtMs: Date.now(),
+                sawCompletionSentinel: false,
+                turnStartedAtMs: startedAtMs,
+                expectedUserPromptSnippet: extractCurrentUserPromptSnippet(opts.messages),
+                sawCurrentTurnUserRecord: false,
+            };
+            const waitForFreshClaudeTranscript = opts.forceFreshSession && session.provider === 'claude-cli';
+            const promptText = buildTurnPrompt(opts.provider, opts.systemPrompt, opts.messages, opts.forceFreshSession || !session.sessionFilePath, opts.cwd);
+            session.currentPromptLocator = promptText.trim();
+            session.currentPromptStartedAtMs = startedAtMs;
+            const activeTurn = {
+                mode: 'default',
+                promptEchoRemainder: normalizeTerminalChunk(promptText),
+                rawOutput: '',
+                visibleOutput: '',
+                lastDataAtMs: startedAtMs,
+                lastMeaningfulPtyDataAtMs: startedAtMs,
+                callbackChain: Promise.resolve(),
+                onChunk: opts.onChunk,
+                onRawChunk: opts.onRawChunk,
+                recentChromeLines: [],
+                assistantOutputDetected: false,
+                sawVisibleData: false,
+            };
+            session.activeTurn = activeTurn;
+            // Snapshot existing child subagent files before this turn
+            session.childFollowers.clear();
+            if (session.sessionFilePath && session.provider === 'claude-cli') {
+                const sessionDir = session.sessionFilePath.replace(/\.jsonl$/, '');
+                const subagentsDir = path.join(sessionDir, 'subagents');
+                if (fs.existsSync(subagentsDir)) {
+                    try {
+                        const existing = fs.readdirSync(subagentsDir).filter((f) => f.endsWith('.jsonl'));
+                        session.childSnapshot = new Set(existing.map((f) => path.join(subagentsDir, f)));
+                    }
+                    catch {
+                        session.childSnapshot = new Set();
+                    }
+                }
+                else {
+                    session.childSnapshot = new Set();
+                }
+            }
+            throwIfAborted(abortSignal);
+            await writeInteractivePrompt(session, promptText);
+            (0, managed_process_registry_1.markTurnActivity)(session.key, 'prompt_sent');
+            let lastHeartbeatAtMs = Date.now();
+            const HEARTBEAT_INTERVAL_MS = 120_000; // 2 minutes
+            while (!tracker.done) {
+                throwIfAborted(abortSignal);
+                if (Date.now() - startedAtMs > timeoutMs) {
+                    throw new Error(`${opts.provider} PTY session timed out waiting for a response`);
+                }
+                if (!activeTurn.assistantOutputDetected && !tracker.lastAssistantText.trim()) {
+                    const authFailure = getTerminalAuthFailure(session, activeTurn);
+                    if (authFailure) {
+                        if (session.provider === 'claude-cli')
+                            this.closeSession(session.key);
+                        throw authFailure;
+                    }
+                }
+                const inactivityFailTimeoutMs = getPtyInactivityFailTimeoutMs(session.provider);
+                if (inactivityFailTimeoutMs != null
+                    && Date.now() - activeTurn.lastMeaningfulPtyDataAtMs > inactivityFailTimeoutMs) {
+                    if (session.sessionFilePath && fs.existsSync(session.sessionFilePath)) {
+                        await this.consumeSessionFile(session, tracker, opts.onChunk, opts.onDetail);
+                    }
+                    if (tracker.done) {
+                        break;
+                    }
+                    throw new Error(`${opts.provider} PTY session had no meaningful PTY activity for ${Math.floor(inactivityFailTimeoutMs / 1000)}s`);
+                }
+                // Heartbeat: if no detail emitted for 2+ minutes, send a status pulse
+                if (opts.onDetail && Date.now() - lastHeartbeatAtMs > HEARTBEAT_INTERVAL_MS) {
+                    const elapsed = Math.floor((Date.now() - startedAtMs) / 1000);
+                    await opts.onDetail(`⏳ Still working... (${elapsed}s elapsed)`);
+                    lastHeartbeatAtMs = Date.now();
+                }
+                if (!session.sessionFilePath) {
+                    // Pattern A (known session ID): search for our specific file by ID
+                    if (session.sessionId && session.provider === 'claude-cli') {
+                        const projectRoot = session.sessionFilesRoot;
+                        if (fs.existsSync(projectRoot)) {
+                            try {
+                                for (const dir of fs.readdirSync(projectRoot)) {
+                                    const candidate = path.join(projectRoot, dir, `${session.sessionId}.jsonl`);
+                                    if (fs.existsSync(candidate)) {
+                                        session.sessionFilePath = candidate;
+                                        session.sessionFileOffset = 0;
+                                        session.sessionFileCarry = '';
+                                        break;
+                                    }
+                                }
+                            }
+                            catch { }
+                        }
+                    }
+                    // Pattern B (unknown ID): discover by snapshot diff
+                    if (!session.sessionFilePath) {
+                        const discovered = discoverSessionFile(session.provider, session.launchSnapshot, session.currentPromptStartedAtMs || session.createdAtMs, session.currentPromptLocator, session.sessionFilesRoot);
+                        if (discovered) {
+                            session.sessionFilePath = discovered;
+                            session.sessionFileOffset = 0;
+                            session.sessionFileCarry = '';
+                        }
+                    }
+                }
+                if (session.sessionFilePath && fs.existsSync(session.sessionFilePath)) {
+                    await this.consumeSessionFile(session, tracker, opts.onChunk, opts.onDetail);
+                }
+                if (waitForFreshClaudeTranscript
+                    && !(session.sessionFilePath && fs.existsSync(session.sessionFilePath))) {
+                    const now = Date.now();
+                    if (!shouldContinueWaitingForFreshClaudeSession(session, activeTurn, startedAtMs, now)) {
+                        const ptyBuffer = session.recentTerminalOutput || activeTurn.rawOutput || '';
+                        const ptyPid = session.pty.pid;
+                        if (ptyBuffer) {
+                            console.warn(`[local-cli-pty] Failed fresh session PTY output before kill`
+                                + ` | sessionId=${session.sessionId || 'unknown'}`
+                                + ` | botId=${session.botId}`
+                                + ` | pid=${ptyPid || 'unknown'}`
+                                + `\n--- PTY buffer (last ${ptyBuffer.length} chars) ---\n${ptyBuffer}\n--- end PTY buffer ---`);
+                        }
+                        else {
+                            console.warn(`[local-cli-pty] Failed fresh session with no PTY output`
+                                + ` | sessionId=${session.sessionId || 'unknown'}`
+                                + ` | botId=${session.botId}`
+                                + ` | pid=${ptyPid || 'unknown'}`);
+                        }
+                        const authFailure = getTerminalAuthFailure(session, activeTurn);
+                        if (authFailure) {
+                            this.closeSession(session.key);
+                            throw authFailure;
+                        }
+                        this.closeSession(session.key);
+                        throw buildClaudeFreshSessionStartupError(session.sessionId, now - startedAtMs);
+                    }
+                }
+                if (session._pendingTitle) {
+                    session._pendingTitle = null;
+                }
+                // Fix 12: Follow child sub-agent JSON files for live progress
+                if (session.sessionFilePath && session.provider === 'claude-cli' && opts.onDetail) {
+                    await this.consumeChildSubagentFiles(session, tracker, opts.onDetail);
+                }
+                if (session.closed) {
+                    if (!activeTurn.assistantOutputDetected && !tracker.lastAssistantText.trim()) {
+                        const authFailure = getTerminalAuthFailure(session, activeTurn);
+                        if (authFailure) {
+                            if (session.provider === 'claude-cli')
+                                this.closeSession(session.key);
+                            throw authFailure;
+                        }
+                    }
+                    if (canFinalizeClaudeTurnOnSessionExit(session, tracker)) {
+                        tracker.done = true;
+                        tracker.finalContent = tracker.finalContent || tracker.lastAssistantText;
+                        break;
+                    }
+                    throw formatClosedSessionError(session, 'exited while waiting for a response');
+                }
+                if (!tracker.done) {
+                    await delayWithAbort(200, abortSignal);
+                }
+            }
+            const settleStartedAt = Date.now();
+            while (Date.now() - Math.max(activeTurn.lastDataAtMs, settleStartedAt) < 100) {
+                throwIfAborted(abortSignal);
+                if (Date.now() - settleStartedAt > 500)
+                    break;
+                await delayWithAbort(50, abortSignal);
             }
+            if (session.sessionFilePath && fs.existsSync(session.sessionFilePath)) {
+                await this.consumeSessionFile(session, tracker, opts.onChunk, opts.onDetail);
+            }
+            await activeTurn.callbackChain;
+            session.lastUsedAtMs = Date.now();
+            session.waitForNextSendMs = 150;
+            return {
+                content: (tracker.finalContent || tracker.lastAssistantText).trim(),
+                sessionId: session.sessionId,
+                usage: tracker.usage,
+                rawOutput: activeTurn.rawOutput,
+            };
+        }
+        finally {
+            syncClaudeSessionCredentialsBackToCanonical(session);
+            session.activeTurn = null;
+            (0, managed_process_registry_1.markTurnFinished)(session.key, 'pty_turn_finished');
+            abortSignal?.removeEventListener('abort', abortHandler);
         }
-        session.lastUsedAtMs = Date.now();
-        session.waitForNextSendMs = 400;
-        return {
-            content: tracker.finalContent.trim(),
-            sessionId: session.sessionId,
-            usage: tracker.usage,
-        };
     }
-    async consumeSessionFile(session, tracker, onDetail) {
+    async consumeSessionFile(session, tracker, onChunk, onDetail) {
         if (!session.sessionFilePath)
             return;
         let stat;
         try {
-            stat = fs.statSync(session.sessionFilePath);
+            stat = await fs.promises.stat(session.sessionFilePath);
         }
         catch {
             return;
         }
         if (stat.size <= session.sessionFileOffset)
             return;
-        const fd = fs.openSync(session.sessionFilePath, 'r');
+        (0, managed_process_registry_1.markTurnActivity)(session.key, 'transcript_data');
+        let fh = null;
         try {
+            fh = await fs.promises.open(session.sessionFilePath, 'r');
             const length = stat.size - session.sessionFileOffset;
             const buffer = Buffer.alloc(length);
-            fs.readSync(fd, buffer, 0, length, session.sessionFileOffset);
+            await fh.read(buffer, 0, length, session.sessionFileOffset);
             session.sessionFileOffset = stat.size;
             const text = session.sessionFileCarry + buffer.toString('utf8');
             const lines = text.split('\n');
@@ -606,14 +2736,118 @@ class LocalCliPtySessionManager {
                 catch {
                     continue;
                 }
-                await this.applyRecord(session, tracker, record, onDetail);
+                await this.applyRecord(session, tracker, record, onChunk, onDetail);
             }
         }
         finally {
-            fs.closeSync(fd);
+            await fh?.close();
+        }
+    }
+    /**
+     * Fix 12: Watch for child sub-agent .jsonl files and emit curated progress.
+     * Claude sub-agents write to: <parent-session-folder>/subagents/agent-<id>.jsonl
+     * We discover new files by watching the directory (not by deriving from agentId,
+     * which isn't available until the sub-agent completes).
+     */
+    async consumeChildSubagentFiles(session, tracker, onDetail) {
+        if (!session.sessionFilePath)
+            return;
+        // Derive the subagents directory from the session file path
+        const sessionDir = session.sessionFilePath.replace(/\.jsonl$/, '');
+        const subagentsDir = path.join(sessionDir, 'subagents');
+        if (!fs.existsSync(subagentsDir))
+            return;
+        // Scan for new child files
+        try {
+            const entries = fs.readdirSync(subagentsDir).filter((f) => f.endsWith('.jsonl'));
+            for (const entry of entries) {
+                const childPath = path.join(subagentsDir, entry);
+                if (session.childSnapshot.has(childPath))
+                    continue; // Already known from before this turn
+                // Start following this child file if not already
+                if (!session.childFollowers.has(childPath)) {
+                    session.childFollowers.set(childPath, { offset: 0, carry: '' });
+                }
+                const follower = session.childFollowers.get(childPath);
+                let stat;
+                try {
+                    stat = fs.statSync(childPath);
+                }
+                catch {
+                    continue;
+                }
+                if (stat.size <= follower.offset)
+                    continue;
+                // Read new content
+                let fh = null;
+                try {
+                    fh = await fs.promises.open(childPath, 'r');
+                    const length = stat.size - follower.offset;
+                    const buffer = Buffer.alloc(length);
+                    await fh.read(buffer, 0, length, follower.offset);
+                    follower.offset = stat.size;
+                    const text = follower.carry + buffer.toString('utf8');
+                    const lines = text.split('\n');
+                    follower.carry = lines.pop() || '';
+                    for (const line of lines) {
+                        const trimmed = line.trim();
+                        if (!trimmed)
+                            continue;
+                        let record;
+                        try {
+                            record = JSON.parse(trimmed);
+                        }
+                        catch {
+                            continue;
+                        }
+                        // Extract curated child progress
+                        if (record?.type === 'assistant' && record?.message?.content) {
+                            const blocks = Array.isArray(record.message.content) ? record.message.content : [];
+                            for (const block of blocks) {
+                                if (!block || typeof block !== 'object')
+                                    continue;
+                                if (block.type === 'text' && typeof block.text === 'string') {
+                                    const shortText = block.text.trim().slice(0, 150);
+                                    if (shortText) {
+                                        const activity = {
+                                            type: 'subagent_working',
+                                            label: shortText,
+                                            key: childPath,
+                                            timestamp: Date.now(),
+                                        };
+                                        await onDetail(`__ACTIVITY__${JSON.stringify(activity)}`);
+                                    }
+                                }
+                                else if (block.type === 'tool_use') {
+                                    const toolName = typeof block.name === 'string' ? block.name : 'tool';
+                                    const activityLabel = (0, live_activity_1.toolUseToActivityLabel)(toolName);
+                                    if (activityLabel) {
+                                        const activity = {
+                                            type: 'subagent_working',
+                                            label: activityLabel,
+                                            key: childPath,
+                                            timestamp: Date.now(),
+                                        };
+                                        await onDetail(`__ACTIVITY__${JSON.stringify(activity)}`);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                finally {
+                    await fh?.close();
+                }
+            }
+        }
+        catch {
+            // subagents dir not readable — skip silently
         }
     }
-    async applyRecord(session, tracker, record, onDetail) {
+    async applyRecord(session, tracker, record, onChunk, onDetail) {
+        if (session.provider === 'claude-cli' && shouldIgnoreClaudeRecordForCurrentTurn(tracker, record)) {
+            return;
+        }
         const parsed = session.provider === 'claude-cli'
             ? parseClaudeSessionRecord(record)
             : parseCodexSessionRecord(record);
@@ -623,14 +2857,40 @@ class LocalCliPtySessionManager {
         if (parsed.usage) {
             tracker.usage = parsed.usage;
         }
+        if (parsed.openedToolUseIds?.length) {
+            for (const toolUseId of parsed.openedToolUseIds) {
+                tracker.pendingToolUseIds.add(toolUseId);
+            }
+            tracker.lastRecordAtMs = Date.now();
+        }
+        if (parsed.resolvedToolUseIds?.length) {
+            for (const toolUseId of parsed.resolvedToolUseIds) {
+                tracker.pendingToolUseIds.delete(toolUseId);
+            }
+            tracker.lastRecordAtMs = Date.now();
+        }
         if (parsed.detail) {
+            tracker.lastRecordAtMs = Date.now();
             await emitDetail(tracker, parsed.detail, onDetail);
         }
+        // Emit structured live activity events as JSON-prefixed detail lines
+        // Frontend can distinguish these from plain text details by the prefix
+        if (parsed.activities && parsed.activities.length > 0 && onDetail) {
+            for (const activity of parsed.activities) {
+                const encoded = `__ACTIVITY__${JSON.stringify(activity)}`;
+                await emitDetail(tracker, encoded, onDetail);
+            }
+        }
+        if (parsed.assistantText) {
+            tracker.lastRecordAtMs = Date.now();
+            await emitAssistantChunk(tracker, parsed.assistantText, onChunk);
+        }
         if (parsed.finalContent) {
             tracker.finalContent = parsed.finalContent;
             tracker.lastAssistantText = parsed.finalContent;
         }
         if (parsed.done) {
+            tracker.sawExplicitCompletion = true;
             tracker.done = true;
         }
     }
@@ -642,4 +2902,161 @@ function getLocalCliPtySessionManager() {
     }
     return _manager;
 }
+async function runLocalCliPtyHealthCheck() {
+    const execDir = path.dirname(process.execPath);
+    const appDir = getAppDirFromExec(execDir);
+    const packagedIndexPath = path.join(appDir, 'resources', 'node-pty-prebuilt', 'lib', 'index.js');
+    const outputChunks = [];
+    try {
+        const ptyModule = loadNodePtyModule();
+        const pty = ptyModule.spawn('cmd.exe', [], {
+            cwd: process.cwd(),
+            cols: 80,
+            rows: 24,
+            env: { ...process.env },
+            useConpty: true,
+            name: 'xterm-color',
+        });
+        const result = await new Promise((resolve) => {
+            let finished = false;
+            const finish = (value) => {
+                if (finished)
+                    return;
+                finished = true;
+                try {
+                    pty.kill();
+                }
+                catch { }
+                resolve(value);
+            };
+            const timeout = setTimeout(() => {
+                finish({
+                    ok: false,
+                    output: outputChunks.join(''),
+                    error: 'Timed out waiting for PTY echo response',
+                });
+            }, 5000);
+            pty.on('data', (chunk) => {
+                outputChunks.push(chunk);
+                if (outputChunks.join('').includes('PTY_OK')) {
+                    clearTimeout(timeout);
+                    finish({ ok: true, output: outputChunks.join('') });
+                }
+            });
+            pty.on('exit', () => {
+                clearTimeout(timeout);
+                if (!finished) {
+                    finish({
+                        ok: false,
+                        output: outputChunks.join(''),
+                        error: 'PTY session exited before echo response',
+                    });
+                }
+            });
+            pty.write('echo PTY_OK\r');
+            pty.write('exit\r');
+        });
+        return {
+            ok: result.ok,
+            execPath: process.execPath,
+            packagedIndexPath,
+            output: result.output,
+            error: result.error,
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            execPath: process.execPath,
+            packagedIndexPath,
+            output: outputChunks.join(''),
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+async function runLocalCliPtyTurnHealthCheck(provider, cwd) {
+    const manager = getLocalCliPtySessionManager();
+    const conversationId = `pty-health-${Date.now()}`;
+    const botId = `${provider}-health`;
+    const expected = provider === 'claude-cli' ? 'CLAUDE_PTY_TURN_OK' : 'CODEX_PTY_TURN_OK';
+    try {
+        const result = await manager.runTurn({
+            conversationId,
+            botId,
+            provider,
+            cwd,
+            systemPrompt: '',
+            messages: [
+                {
+                    role: 'user',
+                    content: `Reply with exactly ${expected} and nothing else.`,
+                },
+            ],
+            forceFreshSession: true,
+            timeoutMs: 90_000,
+        });
+        manager.closeSessionByConversation(conversationId, botId);
+        return {
+            ok: result.content.trim() === expected,
+            provider,
+            cwd,
+            content: result.content,
+            error: result.content.trim() === expected
+                ? undefined
+                : `Unexpected response content: ${JSON.stringify(result.content)}`,
+        };
+    }
+    catch (error) {
+        manager.closeSessionByConversation(conversationId, botId);
+        return {
+            ok: false,
+            provider,
+            cwd,
+            content: '',
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+async function runLocalCliPtyProbe(provider, cwd, prompt, systemPrompt = '') {
+    const manager = getLocalCliPtySessionManager();
+    const conversationId = `pty-probe-${Date.now()}`;
+    const botId = `${provider}-probe`;
+    const startedAt = Date.now();
+    try {
+        const result = await manager.runTurn({
+            conversationId,
+            botId,
+            provider,
+            cwd,
+            systemPrompt,
+            messages: [
+                {
+                    role: 'user',
+                    content: prompt,
+                },
+            ],
+            forceFreshSession: true,
+            timeoutMs: 180_000,
+        });
+        manager.closeSessionByConversation(conversationId, botId);
+        return {
+            ok: result.content.trim().length > 0,
+            provider,
+            cwd,
+            content: result.content,
+            elapsedMs: Date.now() - startedAt,
+        };
+    }
+    catch (error) {
+        manager.closeSessionByConversation(conversationId, botId);
+        return {
+            ok: false,
+            provider,
+            cwd,
+            content: '',
+            elapsedMs: Date.now() - startedAt,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
 //# sourceMappingURL=local-cli-pty-manager.js.map