funolio-agent 1.0.52 → 1.0.75

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

@@ -34,18 +34,66 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalCliPtySessionManager = void 0;
+exports.stripAnsi = stripAnsi;
+exports.resolveConptyOverwrites = resolveConptyOverwrites;
 exports.parseClaudeSessionRecord = parseClaudeSessionRecord;
 exports.parseCodexSessionRecord = parseCodexSessionRecord;
 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 CLAUDE_FRESH_SESSION_STARTUP_TIMEOUT_MS = 7_000;
+const CLAUDE_PTY_INACTIVITY_FAIL_TIMEOUT_MS = 60_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 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`
+        + (sessionId ? ` (${sessionId})` : ''));
+    err.name = 'ClaudeFreshSessionStartupTimeoutError';
+    err.code = 'CLAUDE_FRESH_SESSION_STARTUP_TIMEOUT';
+    return err;
+}
+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}`;
 }
@@ -81,6 +129,7 @@ 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;
@@ -95,16 +144,89 @@ function loadNodePtyModule() {
         for (const candidate of candidates) {
             if (!fs.existsSync(candidate))
                 continue;
-            _ptyModule = dynamicRequire(candidate);
+            _ptyModule = fileRequire(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,14 +245,14 @@ 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;
 }
@@ -138,9 +260,10 @@ function buildTurnPrompt(provider, systemPrompt, messages, freshSession) {
     if (!freshSession) {
         const lastMessage = messages.length > 0 ? messages[messages.length - 1] : null;
         if (lastMessage?.role === 'user') {
-            return typeof lastMessage.content === 'string'
+            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}`;
         }
     }
     if (provider === 'claude-cli') {
@@ -152,6 +275,246 @@ function buildTurnPrompt(provider, systemPrompt, messages, freshSession) {
     }
     return buildCodexSeedPrompt(systemPrompt, messages);
 }
+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(/\u00a0/g, ' ')
+        .replace(/[^\S\n]+/g, ' ');
+}
+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();
+    if (!trimmed)
+        return false;
+    if (/^Pasting text/i.test(trimmed))
+        return true;
+    if (/^\[Pasted.*lines?\]/i.test(trimmed))
+        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 (/^[-_=]{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;
+    const terminalView = extractTerminalFacingText(visibleText, activeTurn.assistantOutputDetected);
+    activeTurn.assistantOutputDetected = terminalView.assistantOutputDetected;
+    if (terminalView.terminalText) {
+        activeTurn.lastMeaningfulPtyDataAtMs = Date.now();
+        const terminalText = terminalView.terminalText.replace(/\n/g, '\r\n');
+        activeTurn.callbackChain = activeTurn.callbackChain
+            .catch(() => undefined)
+            .then(() => activeTurn.onRawChunk?.(terminalText))
+            .then(() => undefined);
+        await activeTurn.callbackChain;
+    }
+}
 function getProviderSessionRoot(provider) {
     if (provider === 'claude-cli') {
         return path.join(os.homedir(), '.claude', 'projects');
@@ -198,8 +561,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 +603,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;
                 }
             }
@@ -251,19 +636,106 @@ 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 findCodexSessionFileBySessionId(sessionId) {
+    if (!sessionId)
+        return null;
+    const candidates = listSessionFiles('codex-cli')
+        .map((candidate) => {
+        try {
+            return { candidate, mtimeMs: fs.statSync(candidate).mtimeMs };
+        }
+        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 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
@@ -310,15 +782,44 @@ 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);
+        }
+    }
+}
 function parseClaudeSessionRecord(record) {
     const sessionId = typeof record?.sessionId === 'string' ? record.sessionId : undefined;
     if (record?.type === 'assistant' && record?.message) {
@@ -330,43 +831,112 @@ function parseClaudeSessionRecord(record) {
                 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);
+                }
+                // 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) => {
-            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)}`;
-            }
-            return '';
-        })
-            .filter(Boolean)
-            .join('\n');
-        if (toolResultText) {
-            return { sessionId, detail: toolResultText };
+        const resolvedToolUseIds = record.message.content
+            .map((block) => (typeof block?.tool_use_id === 'string' ? block.tool_use_id : ''))
+            .filter((toolUseId) => !!toolUseId);
+        if (resolvedToolUseIds.length > 0) {
+            return { sessionId, resolvedToolUseIds };
         }
     }
+    // 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,16 +944,27 @@ 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) {
+            return {
+                usage: {
+                    inputTokens: (lastUsage.input_tokens || 0)
+                        + (lastUsage.cached_input_tokens || 0),
+                    outputTokens: lastUsage.output_tokens || 0,
+                },
+            };
+        }
         return {
             usage: {
                 inputTokens: (record.payload.info.total_token_usage.input_tokens || 0)
@@ -392,14 +973,19 @@ function parseCodexSessionRecord(record) {
             },
         };
     }
-    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 {};
@@ -408,18 +994,56 @@ async function waitForFirstTerminalData(session) {
     await Promise.race([session.readyPromise, delay(5000)]);
     await delay(session.startupDelayMs);
 }
+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');
 }
+const SESSION_IDLE_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
+const SESSION_REAPER_INTERVAL_MS = 60 * 1000; // check every 60 seconds
 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 runTurn(opts) {
         const key = sessionKey(opts.conversationId, opts.botId);
         let session = this.sessions.get(key);
@@ -429,7 +1053,14 @@ class LocalCliPtySessionManager {
             session = undefined;
         }
         if (!session) {
-            session = this.createSession(key, opts.provider, opts.cwd);
+            try {
+                session = this.createSession(key, opts.provider, opts.cwd, 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);
+            }
             this.sessions.set(key, session);
         }
         const run = async () => this.runTurnInternal(session, opts);
@@ -458,18 +1089,78 @@ class LocalCliPtySessionManager {
         }
         this.sessions.delete(key);
     }
-    createSession(key, provider, cwd) {
+    createSession(key, provider, cwd, resumeSessionId, newSessionId) {
         const ptyModule = loadNodePtyModule();
         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];
+            }
+        }
+        // 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));
         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;
+        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);
+            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 = 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 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,
@@ -477,7 +1168,7 @@ class LocalCliPtySessionManager {
                 useConpty: true,
                 name: 'xterm-color',
             })
-            : ptyModule.spawn('cmd.exe', [], {
+            : ptyModule.spawn(findExecutableOnPath('claude.exe') || findExecutableOnPath('claude.cmd') || 'claude', claudeArgs, {
                 cwd,
                 cols: 160,
                 rows: 48,
@@ -492,105 +1183,243 @@ class LocalCliPtySessionManager {
             pty,
             createdAtMs: Date.now(),
             lastUsedAtMs: Date.now(),
-            launchSnapshot: new Set(listSessionFiles(provider)),
-            sessionId: null,
-            sessionFilePath: null,
+            launchSnapshot: preSpawnSnapshot,
+            sessionId: knownSessionId,
+            sessionFilePath: knownSessionFilePath,
             sessionFileOffset: 0,
             sessionFileCarry: '',
             readyPromise,
             readyResolved: false,
             waitForNextSendMs: 250,
-            startupDelayMs: provider === 'codex-cli' ? 9000 : 1200,
-            submitDelayMs: provider === 'codex-cli' ? 350 : 0,
+            startupDelayMs: 1200,
+            submitDelayMs: provider === 'codex-cli' ? 350 : 400,
             currentPromptLocator: null,
             currentPromptStartedAtMs: 0,
+            activeTurn: null,
             closed: false,
             chain: Promise.resolve(),
+            childFollowers: new Map(),
+            childSnapshot: new Set(),
         };
         pty.on('data', (chunk) => {
             if (!session.readyResolved && chunk && chunk.trim()) {
                 session.readyResolved = true;
                 readyResolve?.();
             }
+            if (session.activeTurn && chunk) {
+                void emitPtyChunk(session, chunk);
+            }
         });
         pty.on('exit', () => {
             session.closed = true;
             this.sessions.delete(key);
         });
-        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(),
+        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();
+            throwIfAborted(abortSignal);
+            await waitForFirstTerminalData(session);
+            throwIfAborted(abortSignal);
             if (session.closed) {
-                throw new Error(`${opts.provider} PTY session exited while waiting for a response`);
+                throw new Error(`${session.provider} PTY 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;
-                    session.sessionFileCarry = '';
+            // 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) {
+                try {
+                    const currentSize = fs.statSync(session.sessionFilePath).size;
+                    session.sessionFileOffset = currentSize;
+                }
+                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);
+            }
+            const tracker = {
+                done: false,
+                sawExplicitCompletion: false,
+                finalContent: '',
+                usage: undefined,
+                lastAssistantText: '',
+                detailFingerprints: new Set(),
+                pendingToolUseIds: new Set(),
+                lastRecordAtMs: Date.now(),
+                sawCompletionSentinel: 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);
+            session.currentPromptLocator = promptText.trim();
+            session.currentPromptStartedAtMs = startedAtMs;
+            const activeTurn = {
+                promptEchoRemainder: normalizeTerminalChunk(promptText),
+                rawOutput: '',
+                lastDataAtMs: startedAtMs,
+                lastMeaningfulPtyDataAtMs: startedAtMs,
+                callbackChain: Promise.resolve(),
+                onChunk: opts.onChunk,
+                onRawChunk: opts.onRawChunk,
+                recentChromeLines: [],
+                assistantOutputDetected: 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();
+                }
             }
-            if (!tracker.done) {
-                await delay(250);
+            throwIfAborted(abortSignal);
+            await writeInteractivePrompt(session, promptText);
+            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`);
+                }
+                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 = getProviderSessionRoot(session.provider);
+                        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);
+                        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 (freshClaudeStartupDeadlineMs
+                    && Date.now() >= freshClaudeStartupDeadlineMs
+                    && !(session.sessionFilePath && fs.existsSync(session.sessionFilePath))) {
+                    this.closeSession(session.key);
+                    throw buildClaudeFreshSessionStartupError(session.sessionId);
+                }
+                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 (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`);
+                }
+                if (!tracker.done) {
+                    await delayWithAbort(1000, abortSignal);
+                }
+            }
+            const settleStartedAt = Date.now();
+            while (Date.now() - Math.max(activeTurn.lastDataAtMs, settleStartedAt) < 250) {
+                throwIfAborted(abortSignal);
+                if (Date.now() - settleStartedAt > 1500)
+                    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 = 400;
+            return {
+                content: (tracker.finalContent || tracker.lastAssistantText).trim(),
+                sessionId: session.sessionId,
+                usage: tracker.usage,
+                rawOutput: activeTurn.rawOutput,
+            };
+        }
+        finally {
+            session.activeTurn = null;
+            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');
+        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 +1435,115 @@ 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) {
         const parsed = session.provider === 'claude-cli'
             ? parseClaudeSessionRecord(record)
             : parseCodexSessionRecord(record);
@@ -623,14 +1553,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 +1598,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