funolio-agent 1.0.75 → 1.1.65

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

@@ -34,10 +34,22 @@ 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;
@@ -49,8 +61,17 @@ 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 CLAUDE_FRESH_SESSION_STARTUP_TIMEOUT_MS = 7_000;
+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;
@@ -61,18 +82,275 @@ 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 buildClaudeFreshSessionStartupError(sessionId) {
-    const err = new Error(`claude-cli fresh session startup timed out after ${Math.floor(CLAUDE_FRESH_SESSION_STARTUP_TIMEOUT_MS / 1000)}s waiting for transcript file`
+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;
@@ -129,7 +407,6 @@ function loadNodePtyModule() {
     if (_ptyModule)
         return _ptyModule;
     const dynamicRequire = eval('require');
-    const fileRequire = (0, module_1.createRequire)(path.join(process.cwd(), 'sea-entry.js'));
     try {
         _ptyModule = dynamicRequire('@homebridge/node-pty-prebuilt-multiarch');
         return _ptyModule;
@@ -144,8 +421,18 @@ function loadNodePtyModule() {
         for (const candidate of candidates) {
             if (!fs.existsSync(candidate))
                 continue;
-            _ptyModule = fileRequire(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)}`);
     }
@@ -256,24 +543,181 @@ function buildCodexSeedPrompt(systemPrompt, messages) {
     }
     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') {
-            const prompt = typeof lastMessage.content === 'string'
-                ? lastMessage.content
-                : JSON.stringify(lastMessage.content);
-            return `${prompt}\n\nRequired final line when the response is fully complete: ${completion_marker_1.CLI_COMPLETION_SENTINEL}`;
+            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;
     }
-    return buildCodexSeedPrompt(systemPrompt, messages);
+    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)
@@ -310,9 +754,42 @@ function resolveConptyOverwrites(text) {
 }
 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)
@@ -326,12 +803,19 @@ function isSyntheticPromptEchoLine(line) {
 }
 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))
@@ -340,7 +824,15 @@ function isAutomationNoiseLine(provider, line) {
         return true;
     if (/^Improve documentation in @filename$/i.test(trimmed))
         return true;
-    if (/^permissions on \(shift-tab to cycle\)$/i.test(trimmed))
+    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;
@@ -503,10 +995,23 @@ async function emitPtyChunk(session, chunk) {
     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)
@@ -515,14 +1020,23 @@ async function emitPtyChunk(session, chunk) {
         await activeTurn.callbackChain;
     }
 }
-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 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) {
-    const root = getProviderSessionRoot(provider);
+function listSessionFiles(provider, sessionRoot) {
+    const root = sessionRoot || getProviderSessionRoot(provider);
     if (!fs.existsSync(root))
         return [];
     const results = [];
@@ -623,8 +1137,8 @@ function recentFileContainsPrompt(provider, filePath, promptText, startedAtMs) {
     }
     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 {
@@ -699,6 +1213,24 @@ function findCodexSessionFileBySessionId(sessionId) {
     }
     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}`;
@@ -818,16 +1350,49 @@ async function emitAssistantChunk(tracker, nextText, cb) {
         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;
@@ -847,6 +1412,14 @@ function parseClaudeSessionRecord(record) {
                 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 || {});
@@ -911,8 +1484,39 @@ function parseClaudeSessionRecord(record) {
         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')
+                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);
+            }
+            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 };
+            return {
+                sessionId,
+                resolvedToolUseIds,
+                ...(resultActivities.length > 0 ? { activities: resultActivities } : {}),
+            };
         }
     }
     // system/turn_duration is a fallback completion signal from the CLI
@@ -957,18 +1561,31 @@ function parseCodexSessionRecord(record) {
     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: (lastUsage.input_tokens || 0)
-                        + (lastUsage.cached_input_tokens || 0),
+                    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,
             },
         };
@@ -992,7 +1609,66 @@ function parseCodexSessionRecord(record) {
 }
 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) {
@@ -1025,41 +1701,389 @@ async function writeInteractivePrompt(session, promptText) {
     await delay(session.submitDelayMs);
     session.pty.write('\r');
 }
-const SESSION_IDLE_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
-const SESSION_REAPER_INTERVAL_MS = 60 * 1000; // check every 60 seconds
+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();
-    reaperTimer = null;
-    constructor() {
-        this.reaperTimer = setInterval(() => this.reapIdleSessions(), SESSION_REAPER_INTERVAL_MS);
-    }
-    reapIdleSessions() {
-        const now = Date.now();
-        for (const [key, session] of this.sessions) {
-            if (session.activeTurn)
-                continue; // don't kill active sessions
-            if (now - session.lastUsedAtMs > SESSION_IDLE_TIMEOUT_MS) {
-                console.log(`[pty-reaper] Closing idle session: ${key} (idle ${Math.floor((now - session.lastUsedAtMs) / 1000)}s)`);
-                this.closeSession(key);
+    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) {
+            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.provider, opts.cwd, opts.resumeSessionId, opts.newSessionId);
+                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.provider, opts.cwd, opts.resumeSessionId, opts.newSessionId);
+                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);
         }
@@ -1068,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);
@@ -1081,50 +2203,86 @@ 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, resumeSessionId, newSessionId) {
+    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 };
         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));
+        const preSpawnSnapshot = new Set(listSessionFiles(provider, sessionFilesRoot));
         let readyResolve = null;
         const readyPromise = new Promise((resolve) => {
             readyResolve = resolve;
         });
         // Build Claude CLI args with session control:
-        // Pattern A: --session-id for new, --resume for existing
-        // Pattern B (Codex): no session flags on new, codex resume <id> for existing
-        const claudeArgs = ['--dangerously-skip-permissions'];
-        if (provider === 'claude-cli') {
-            if (resumeSessionId) {
-                claudeArgs.push('--resume', resumeSessionId);
-            }
-            else if (newSessionId) {
-                claudeArgs.push('--session-id', newSessionId);
-            }
-        }
-        // Determine known session info for Pattern A
-        const knownSessionId = resumeSessionId || newSessionId || null;
+        // 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 = getProviderSessionRoot(provider);
+            const projectRoot = sessionFilesRoot;
             if (fs.existsSync(projectRoot)) {
                 try {
                     const projectDirs = fs.readdirSync(projectRoot);
@@ -1144,28 +2302,14 @@ class LocalCliPtySessionManager {
         else if (knownSessionId && provider === 'codex-cli') {
             knownSessionFilePath = findCodexSessionFileBySessionId(knownSessionId);
         }
-        const codexArgs = resumeSessionId
-            ? [
-                'resume',
-                resumeSessionId,
-                '--no-alt-screen',
-                '--dangerously-bypass-approvals-and-sandbox',
-                '-c',
-                'shell_environment_policy.inherit=all',
-            ]
-            : [
-                '--no-alt-screen',
-                '--dangerously-bypass-approvals-and-sandbox',
-                '-c',
-                'shell_environment_policy.inherit=all',
-            ];
+        const codexArgs = buildCodexCliArgs(resumeSessionId, botSettings?.codex);
         const pty = provider === 'codex-cli'
             ? ptyModule.spawn(findExecutableOnPath('codex.cmd') || 'codex.cmd', codexArgs, {
                 cwd,
                 cols: 160,
                 rows: 48,
                 env: cleanEnv,
-                useConpty: true,
+                useConpty,
                 name: 'xterm-color',
             })
             : ptyModule.spawn(findExecutableOnPath('claude.exe') || findExecutableOnPath('claude.cmd') || 'claude', claudeArgs, {
@@ -1173,35 +2317,66 @@ class LocalCliPtySessionManager {
                 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: preSpawnSnapshot,
+            sessionFilesRoot,
             sessionId: knownSessionId,
             sessionFilePath: knownSessionFilePath,
             sessionFileOffset: 0,
             sessionFileCarry: '',
             readyPromise,
             readyResolved: false,
-            waitForNextSendMs: 250,
+            waitForNextSendMs: 100,
             startupDelayMs: 1200,
-            submitDelayMs: provider === 'codex-cli' ? 350 : 400,
+            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?.();
@@ -1210,12 +2385,88 @@ class LocalCliPtySessionManager {
                 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);
         });
         return session;
     }
+    async runPassthroughInternal(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_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 = () => {
@@ -1224,27 +2475,33 @@ class LocalCliPtySessionManager {
         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(`${session.provider} PTY session closed before prompt was sent`);
+                throw formatClosedSessionError(session, 'closed before prompt was sent');
             }
-            // For resumed sessions with a known file, set the read offset NOW (after CLI is ready)
-            // so we only read new content appended after this point. Setting it at spawn time is
-            // too early — CLI may still be loading session history into the file.
-            if (session.sessionFilePath && session.sessionFileOffset === 0 && session.sessionId) {
+            // 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
+                    // File may not exist yet for new sessions — that's fine.
                 }
             }
             if (session.waitForNextSendMs > 0) {
                 await delayWithAbort(session.waitForNextSendMs, abortSignal);
             }
+            const timeoutMs = opts.timeoutMs ?? 10 * 60 * 1000;
+            const startedAtMs = Date.now();
             const tracker = {
                 done: false,
                 sawExplicitCompletion: false,
@@ -1255,18 +2512,19 @@ class LocalCliPtySessionManager {
                 pendingToolUseIds: new Set(),
                 lastRecordAtMs: Date.now(),
                 sawCompletionSentinel: false,
+                turnStartedAtMs: startedAtMs,
+                expectedUserPromptSnippet: extractCurrentUserPromptSnippet(opts.messages),
+                sawCurrentTurnUserRecord: false,
             };
-            const timeoutMs = opts.timeoutMs ?? 10 * 60 * 1000;
-            const startedAtMs = Date.now();
-            const freshClaudeStartupDeadlineMs = opts.forceFreshSession && session.provider === 'claude-cli'
-                ? startedAtMs + CLAUDE_FRESH_SESSION_STARTUP_TIMEOUT_MS
-                : null;
-            const promptText = buildTurnPrompt(opts.provider, opts.systemPrompt, opts.messages, opts.forceFreshSession || !session.sessionFilePath);
+            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(),
@@ -1274,6 +2532,7 @@ class LocalCliPtySessionManager {
                 onRawChunk: opts.onRawChunk,
                 recentChromeLines: [],
                 assistantOutputDetected: false,
+                sawVisibleData: false,
             };
             session.activeTurn = activeTurn;
             // Snapshot existing child subagent files before this turn
@@ -1296,6 +2555,7 @@ class LocalCliPtySessionManager {
             }
             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) {
@@ -1303,6 +2563,14 @@ class LocalCliPtySessionManager {
                 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) {
@@ -1323,7 +2591,7 @@ class LocalCliPtySessionManager {
                 if (!session.sessionFilePath) {
                     // Pattern A (known session ID): search for our specific file by ID
                     if (session.sessionId && session.provider === 'claude-cli') {
-                        const projectRoot = getProviderSessionRoot(session.provider);
+                        const projectRoot = session.sessionFilesRoot;
                         if (fs.existsSync(projectRoot)) {
                             try {
                                 for (const dir of fs.readdirSync(projectRoot)) {
@@ -1341,7 +2609,7 @@ class LocalCliPtySessionManager {
                     }
                     // Pattern B (unknown ID): discover by snapshot diff
                     if (!session.sessionFilePath) {
-                        const discovered = discoverSessionFile(session.provider, session.launchSnapshot, session.currentPromptStartedAtMs || session.createdAtMs, session.currentPromptLocator);
+                        const discovered = discoverSessionFile(session.provider, session.launchSnapshot, session.currentPromptStartedAtMs || session.createdAtMs, session.currentPromptLocator, session.sessionFilesRoot);
                         if (discovered) {
                             session.sessionFilePath = discovered;
                             session.sessionFileOffset = 0;
@@ -1352,11 +2620,33 @@ class LocalCliPtySessionManager {
                 if (session.sessionFilePath && fs.existsSync(session.sessionFilePath)) {
                     await this.consumeSessionFile(session, tracker, opts.onChunk, opts.onDetail);
                 }
-                if (freshClaudeStartupDeadlineMs
-                    && Date.now() >= freshClaudeStartupDeadlineMs
+                if (waitForFreshClaudeTranscript
                     && !(session.sessionFilePath && fs.existsSync(session.sessionFilePath))) {
-                    this.closeSession(session.key);
-                    throw buildClaudeFreshSessionStartupError(session.sessionId);
+                    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;
@@ -1366,21 +2656,29 @@ class LocalCliPtySessionManager {
                     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 new Error(`${opts.provider} PTY session exited while waiting for a response`);
+                    throw formatClosedSessionError(session, 'exited while waiting for a response');
                 }
                 if (!tracker.done) {
-                    await delayWithAbort(1000, abortSignal);
+                    await delayWithAbort(200, abortSignal);
                 }
             }
             const settleStartedAt = Date.now();
-            while (Date.now() - Math.max(activeTurn.lastDataAtMs, settleStartedAt) < 250) {
+            while (Date.now() - Math.max(activeTurn.lastDataAtMs, settleStartedAt) < 100) {
                 throwIfAborted(abortSignal);
-                if (Date.now() - settleStartedAt > 1500)
+                if (Date.now() - settleStartedAt > 500)
                     break;
                 await delayWithAbort(50, abortSignal);
             }
@@ -1389,7 +2687,7 @@ class LocalCliPtySessionManager {
             }
             await activeTurn.callbackChain;
             session.lastUsedAtMs = Date.now();
-            session.waitForNextSendMs = 400;
+            session.waitForNextSendMs = 150;
             return {
                 content: (tracker.finalContent || tracker.lastAssistantText).trim(),
                 sessionId: session.sessionId,
@@ -1398,7 +2696,9 @@ class LocalCliPtySessionManager {
             };
         }
         finally {
+            syncClaudeSessionCredentialsBackToCanonical(session);
             session.activeTurn = null;
+            (0, managed_process_registry_1.markTurnFinished)(session.key, 'pty_turn_finished');
             abortSignal?.removeEventListener('abort', abortHandler);
         }
     }
@@ -1414,6 +2714,7 @@ class LocalCliPtySessionManager {
         }
         if (stat.size <= session.sessionFileOffset)
             return;
+        (0, managed_process_registry_1.markTurnActivity)(session.key, 'transcript_data');
         let fh = null;
         try {
             fh = await fs.promises.open(session.sessionFilePath, 'r');
@@ -1544,6 +2845,9 @@ class LocalCliPtySessionManager {
         }
     }
     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);