@straiffi/archon 1.0.0

package/dist/server/lib/agent.js

@@ -0,0 +1,1302 @@
+import { spawn } from 'child_process';
+import { randomUUID } from 'crypto';
+import { isAbsolute, join, relative, resolve, sep } from 'path';
+import Database from 'better-sqlite3';
+import db from '../db.js';
+import { getChatSession, updateChatSessionUsageSnapshot } from './chats.js';
+import { normalizeModelId } from './models.js';
+import { resolveOpencodeDbPath } from './runtimePaths.js';
+import { markTicketDescriptionVisibleInBundle } from './ticketMessages.js';
+import { getTicket } from './tickets.js';
+const OPENCODE_PLACEHOLDER_TITLE_PATTERN = /^New session\b/i;
+const OPENCODE_SESSION_METADATA_LOOKUP_DELAY_MS = 1500;
+const AGENT_PROGRESS_UPDATE_INTERVAL_MS = 100;
+const OPENCODE_SESSION_BY_ID_QUERY = 'SELECT id, title FROM session WHERE id = ? LIMIT 1';
+const OPENCODE_SESSION_BY_CREATED_AT_QUERY = 'SELECT id, title FROM session WHERE time_created > ? ORDER BY time_created DESC LIMIT 1';
+const OPENCODE_COMPLETED_ASSISTANT_MESSAGE_USAGE_QUERY = "SELECT data FROM message WHERE session_id = ? AND json_extract(data, '$.role') = 'assistant' AND json_extract(data, '$.time.completed') IS NOT NULL ORDER BY time_created DESC LIMIT 1";
+const OPENCODE_COMPLETED_ASSISTANT_MESSAGE_USAGE_SINCE_QUERY = "SELECT data FROM message WHERE session_id = ? AND time_created >= ? AND json_extract(data, '$.role') = 'assistant' AND json_extract(data, '$.time.completed') IS NOT NULL ORDER BY time_created DESC LIMIT 1";
+const OPENCODE_STEP_FINISH_USAGE_QUERY = "SELECT data FROM part WHERE session_id = ? AND json_extract(data, '$.type') = 'step-finish' ORDER BY time_created DESC LIMIT 1";
+const OPENCODE_STEP_FINISH_USAGE_SINCE_QUERY = "SELECT data FROM part WHERE session_id = ? AND time_created >= ? AND json_extract(data, '$.type') = 'step-finish' ORDER BY time_created DESC LIMIT 1";
+const GET_PERSISTED_CHAT_STATE_QUERY = 'SELECT agent_log, streaming_response, opencode_session_id FROM chat_sessions WHERE id = ?';
+const EMPTY_CHAT_USAGE_SNAPSHOT = {
+    usage_snapshot_context_window: null,
+    usage_snapshot_max_output_tokens: null,
+    usage_snapshot_total_tokens: null,
+    usage_snapshot_input_tokens: null,
+    usage_snapshot_output_tokens: null,
+    usage_snapshot_cache_read_tokens: null,
+    usage_snapshot_reasoning_tokens: null,
+};
+const toFiniteNumber = (value) => {
+    return typeof value === 'number' && Number.isFinite(value)
+        ? value
+        : null;
+};
+const getValueAtPath = (value, path) => {
+    let current = value;
+    for (const segment of path) {
+        if (!current || typeof current !== 'object' || !(segment in current)) {
+            return null;
+        }
+        current = current[segment];
+    }
+    return current;
+};
+const getNumberAtPaths = (value, paths) => {
+    for (const path of paths) {
+        const candidate = toFiniteNumber(getValueAtPath(value, path));
+        if (candidate !== null) {
+            return candidate;
+        }
+    }
+    return null;
+};
+const mergeChatUsageSnapshot = (current, next) => {
+    return {
+        usage_snapshot_context_window: next.usage_snapshot_context_window ?? current.usage_snapshot_context_window,
+        usage_snapshot_max_output_tokens: next.usage_snapshot_max_output_tokens ?? current.usage_snapshot_max_output_tokens,
+        usage_snapshot_total_tokens: next.usage_snapshot_total_tokens ?? current.usage_snapshot_total_tokens,
+        usage_snapshot_input_tokens: next.usage_snapshot_input_tokens ?? current.usage_snapshot_input_tokens,
+        usage_snapshot_output_tokens: next.usage_snapshot_output_tokens ?? current.usage_snapshot_output_tokens,
+        usage_snapshot_cache_read_tokens: next.usage_snapshot_cache_read_tokens ?? current.usage_snapshot_cache_read_tokens,
+        usage_snapshot_reasoning_tokens: next.usage_snapshot_reasoning_tokens ?? current.usage_snapshot_reasoning_tokens,
+    };
+};
+const extractChatUsageSnapshot = (value) => {
+    if (!value || typeof value !== 'object') {
+        return {};
+    }
+    return {
+        usage_snapshot_context_window: getNumberAtPaths(value, [
+            ['contextWindow'],
+            ['context_window'],
+            ['result', 'contextWindow'],
+            ['result', 'context_window'],
+            ['limit', 'context'],
+            ['limits', 'context'],
+        ]),
+        usage_snapshot_max_output_tokens: getNumberAtPaths(value, [
+            ['maxOutputTokens'],
+            ['max_output_tokens'],
+            ['result', 'maxOutputTokens'],
+            ['result', 'max_output_tokens'],
+            ['limit', 'output'],
+            ['limits', 'output'],
+        ]),
+        usage_snapshot_total_tokens: getNumberAtPaths(value, [
+            ['tokens', 'total'],
+            ['usage', 'tokens', 'total'],
+            ['usage', 'total'],
+            ['usage', 'totalTokens'],
+            ['result', 'tokens', 'total'],
+            ['result', 'usage', 'tokens', 'total'],
+            ['result', 'usage', 'total'],
+            ['result', 'usage', 'totalTokens'],
+        ]),
+        usage_snapshot_input_tokens: getNumberAtPaths(value, [
+            ['tokens', 'input'],
+            ['usage', 'tokens', 'input'],
+            ['usage', 'input'],
+            ['usage', 'inputTokens'],
+            ['result', 'tokens', 'input'],
+            ['result', 'usage', 'tokens', 'input'],
+            ['result', 'usage', 'input'],
+            ['result', 'usage', 'inputTokens'],
+        ]),
+        usage_snapshot_output_tokens: getNumberAtPaths(value, [
+            ['tokens', 'output'],
+            ['usage', 'tokens', 'output'],
+            ['usage', 'output'],
+            ['usage', 'outputTokens'],
+            ['result', 'tokens', 'output'],
+            ['result', 'usage', 'tokens', 'output'],
+            ['result', 'usage', 'output'],
+            ['result', 'usage', 'outputTokens'],
+        ]),
+        usage_snapshot_cache_read_tokens: getNumberAtPaths(value, [
+            ['tokens', 'cache', 'read'],
+            ['usage', 'tokens', 'cacheRead'],
+            ['usage', 'cacheRead'],
+            ['usage', 'cacheReadTokens'],
+            ['result', 'tokens', 'cache', 'read'],
+            ['result', 'usage', 'tokens', 'cacheRead'],
+            ['result', 'usage', 'cacheRead'],
+            ['result', 'usage', 'cacheReadTokens'],
+        ]),
+        usage_snapshot_reasoning_tokens: getNumberAtPaths(value, [
+            ['tokens', 'reasoning'],
+            ['usage', 'tokens', 'reasoning'],
+            ['usage', 'reasoning'],
+            ['usage', 'reasoningTokens'],
+            ['result', 'tokens', 'reasoning'],
+            ['result', 'usage', 'tokens', 'reasoning'],
+            ['result', 'usage', 'reasoning'],
+            ['result', 'usage', 'reasoningTokens'],
+        ]),
+    };
+};
+const mergeUsageFromJsonLine = (current, line) => {
+    const trimmedLine = line.trim();
+    if (!trimmedLine.startsWith('{')) {
+        return current;
+    }
+    const { jsonObjects } = extractLeadingJsonObjects(trimmedLine);
+    let next = current;
+    for (const jsonObject of jsonObjects) {
+        try {
+            next = mergeChatUsageSnapshot(next, extractChatUsageSnapshot(JSON.parse(jsonObject)));
+        }
+        catch {
+            continue;
+        }
+    }
+    return next;
+};
+const hasUsageSnapshot = (value) => {
+    return Object.values(value).some(candidate => candidate !== null && candidate !== undefined);
+};
+const hasMatchingUsageSnapshot = (current, next) => {
+    return current.usage_snapshot_context_window === next.usage_snapshot_context_window
+        && current.usage_snapshot_max_output_tokens === next.usage_snapshot_max_output_tokens
+        && current.usage_snapshot_total_tokens === next.usage_snapshot_total_tokens
+        && current.usage_snapshot_input_tokens === next.usage_snapshot_input_tokens
+        && current.usage_snapshot_output_tokens === next.usage_snapshot_output_tokens
+        && current.usage_snapshot_cache_read_tokens === next.usage_snapshot_cache_read_tokens
+        && current.usage_snapshot_reasoning_tokens === next.usage_snapshot_reasoning_tokens;
+};
+const activeBuildProcesses = new Map();
+const activeChatProcesses = new Map();
+const getErrorMessage = (error) => {
+    return error instanceof Error ? error.message : String(error);
+};
+const getPersistedChatState = (chatSessionId) => {
+    const row = db.prepare(GET_PERSISTED_CHAT_STATE_QUERY).get(chatSessionId);
+    if (!row) {
+        return null;
+    }
+    return {
+        agentLog: row.agent_log ?? null,
+        streamingResponse: row.streaming_response ?? null,
+        opencodeSessionId: row.opencode_session_id ?? null,
+    };
+};
+const preferNonEmptyChatValue = (value, fallback) => {
+    if (typeof value === 'string' && value.trim()) {
+        return value;
+    }
+    if (typeof fallback === 'string' && fallback.trim()) {
+        return fallback;
+    }
+    return null;
+};
+const getPreservedChatOutput = ({ chatSessionId, log, response, }) => {
+    const persistedState = getPersistedChatState(chatSessionId);
+    return {
+        log: preferNonEmptyChatValue(log, persistedState?.agentLog ?? null),
+        response: preferNonEmptyChatValue(response, persistedState?.streamingResponse ?? null),
+        opencodeSessionId: persistedState?.opencodeSessionId ?? null,
+    };
+};
+const updateStatus = (ticketId, status, log, io, streamingResponse = null, options = {}) => {
+    db.prepare('UPDATE tickets SET agent_status = ?, agent_log = ?, streaming_response = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?').run(status, log ?? null, streamingResponse ?? null, ticketId);
+    const updatedTicket = getTicket(ticketId);
+    if (updatedTicket?.worktree_bundle_id && updatedTicket.state !== 'plan') {
+        markTicketDescriptionVisibleInBundle(ticketId);
+    }
+    if (options.emit === false) {
+        return;
+    }
+    if (updatedTicket) {
+        io.emit('ticket:updated', getTicket(ticketId) ?? updatedTicket);
+    }
+};
+const updateSessionId = (ticketId, sessionId, sessionField, io) => {
+    db.prepare(`UPDATE tickets SET ${sessionField} = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?`).run(sessionId, ticketId);
+    const updatedTicket = getTicket(ticketId);
+    if (sessionField === 'session_id'
+        && updatedTicket?.worktree_bundle_id
+        && updatedTicket.state !== 'plan') {
+        markTicketDescriptionVisibleInBundle(ticketId);
+    }
+    if (updatedTicket) {
+        io.emit('ticket:updated', getTicket(ticketId) ?? updatedTicket);
+    }
+};
+const updateChatSessionStatus = (chatSessionId, status, log, io, streamingResponse = null) => {
+    db.prepare('UPDATE chat_sessions SET agent_status = ?, agent_log = ?, streaming_response = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?').run(status, log ?? null, streamingResponse ?? null, chatSessionId);
+    const chatSession = getChatSession(chatSessionId, { includeMessages: true });
+    if (chatSession) {
+        io.emit('chat-session:updated', chatSession);
+    }
+};
+const updateChatSessionId = (chatSessionId, tool, sessionId, io) => {
+    const sessionField = tool === 'claude' ? 'claude_session_id' : 'opencode_session_id';
+    db.prepare(`UPDATE chat_sessions SET ${sessionField} = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?`).run(sessionId, chatSessionId);
+    const chatSession = getChatSession(chatSessionId, { includeMessages: true });
+    if (chatSession) {
+        io.emit('chat-session:updated', chatSession);
+    }
+};
+const createThrottledProgressUpdater = (flushUpdate) => {
+    let timer = null;
+    let hasPendingUpdate = false;
+    const clearTimer = () => {
+        if (timer === null) {
+            return;
+        }
+        clearTimeout(timer);
+        timer = null;
+    };
+    return {
+        schedule: () => {
+            hasPendingUpdate = true;
+            if (timer !== null) {
+                return;
+            }
+            timer = setTimeout(() => {
+                timer = null;
+                if (!hasPendingUpdate) {
+                    return;
+                }
+                hasPendingUpdate = false;
+                flushUpdate();
+            }, AGENT_PROGRESS_UPDATE_INTERVAL_MS);
+            timer.unref?.();
+        },
+        cancel: () => {
+            hasPendingUpdate = false;
+            clearTimer();
+        },
+    };
+};
+const openOpencodeDatabase = () => new Database(resolveOpencodeDbPath(), { readonly: true });
+const readOpencodeSession = (statement, value) => {
+    const opencodeDb = openOpencodeDatabase();
+    try {
+        const row = opencodeDb.prepare(statement).get(value);
+        if (!row?.id) {
+            return null;
+        }
+        const normalizedTitle = typeof row.title === 'string'
+            ? row.title.trim() || null
+            : null;
+        const title = normalizedTitle && !OPENCODE_PLACEHOLDER_TITLE_PATTERN.test(normalizedTitle)
+            ? normalizedTitle
+            : null;
+        return {
+            id: row.id,
+            title,
+        };
+    }
+    finally {
+        opencodeDb.close();
+    }
+};
+const readOpencodeUsageSnapshot = ({ sessionId, spawnTimestamp = null, }) => {
+    const opencodeDb = openOpencodeDatabase();
+    try {
+        const completedAssistantMessage = (spawnTimestamp === null
+            ? opencodeDb.prepare(OPENCODE_COMPLETED_ASSISTANT_MESSAGE_USAGE_QUERY).get(sessionId)
+            : opencodeDb.prepare(OPENCODE_COMPLETED_ASSISTANT_MESSAGE_USAGE_SINCE_QUERY).get(sessionId, spawnTimestamp));
+        if (typeof completedAssistantMessage?.data === 'string') {
+            try {
+                const parsedUsage = extractChatUsageSnapshot(JSON.parse(completedAssistantMessage.data));
+                if (hasUsageSnapshot(parsedUsage)) {
+                    return mergeChatUsageSnapshot(EMPTY_CHAT_USAGE_SNAPSHOT, parsedUsage);
+                }
+            }
+            catch {
+                // Fall through to the step-finish lookup below.
+            }
+        }
+        const latestStepFinish = (spawnTimestamp === null
+            ? opencodeDb.prepare(OPENCODE_STEP_FINISH_USAGE_QUERY).get(sessionId)
+            : opencodeDb.prepare(OPENCODE_STEP_FINISH_USAGE_SINCE_QUERY).get(sessionId, spawnTimestamp));
+        if (typeof latestStepFinish?.data === 'string') {
+            try {
+                const parsedUsage = extractChatUsageSnapshot(JSON.parse(latestStepFinish.data));
+                if (hasUsageSnapshot(parsedUsage)) {
+                    return mergeChatUsageSnapshot(EMPTY_CHAT_USAGE_SNAPSHOT, parsedUsage);
+                }
+            }
+            catch {
+                return EMPTY_CHAT_USAGE_SNAPSHOT;
+            }
+        }
+        return EMPTY_CHAT_USAGE_SNAPSHOT;
+    }
+    finally {
+        opencodeDb.close();
+    }
+};
+const resolveOpencodeUsageSnapshot = ({ current, sessionId, spawnTimestamp = null, }) => {
+    try {
+        return mergeChatUsageSnapshot(current, readOpencodeUsageSnapshot({ sessionId, spawnTimestamp }));
+    }
+    catch {
+        return current;
+    }
+};
+export const refreshChatSessionUsageSnapshot = (chatSessionId, options = {}) => {
+    const chatSession = getChatSession(chatSessionId, { includeMessages: options.includeMessages });
+    if (!chatSession || chatSession.tool !== 'opencode' || !chatSession.opencode_session_id) {
+        return chatSession;
+    }
+    let nextUsageSnapshot;
+    try {
+        nextUsageSnapshot = readOpencodeUsageSnapshot({
+            sessionId: chatSession.opencode_session_id,
+        });
+    }
+    catch {
+        return chatSession;
+    }
+    if (hasMatchingUsageSnapshot(chatSession, nextUsageSnapshot)) {
+        return chatSession;
+    }
+    updateChatSessionUsageSnapshot(chatSessionId, nextUsageSnapshot);
+    return getChatSession(chatSessionId, { includeMessages: options.includeMessages });
+};
+const updateChatSessionOpencodeMetadata = (chatSessionId, sessionId, title, io) => {
+    db.prepare('UPDATE chat_sessions SET opencode_session_id = ?, title = COALESCE(?, title), updated_at = CURRENT_TIMESTAMP WHERE id = ?').run(sessionId, title, chatSessionId);
+    const chatSession = getChatSession(chatSessionId, { includeMessages: true });
+    if (chatSession) {
+        io.emit('chat-session:updated', chatSession);
+    }
+};
+const createOpencodeMetadataRefresher = ({ chatSessionId, io, spawnTimestamp, initialSessionId = null, }) => {
+    let lookupTimer = null;
+    let stopped = false;
+    let knownSessionId = initialSessionId;
+    let lastAppliedSessionId = null;
+    let lastAppliedTitle = null;
+    const clearLookupTimer = () => {
+        if (!lookupTimer) {
+            return;
+        }
+        clearTimeout(lookupTimer);
+        lookupTimer = null;
+    };
+    const readCurrentSession = () => {
+        if (knownSessionId) {
+            return readOpencodeSession(OPENCODE_SESSION_BY_ID_QUERY, knownSessionId);
+        }
+        if (spawnTimestamp === null) {
+            return null;
+        }
+        return readOpencodeSession(OPENCODE_SESSION_BY_CREATED_AT_QUERY, spawnTimestamp);
+    };
+    const refresh = () => {
+        if (stopped) {
+            return { hasSession: false, hasResolvedTitle: false, sessionId: knownSessionId };
+        }
+        try {
+            const session = readCurrentSession();
+            if (!session) {
+                return { hasSession: false, hasResolvedTitle: false, sessionId: knownSessionId };
+            }
+            knownSessionId = session.id;
+            if (session.id !== lastAppliedSessionId || session.title !== lastAppliedTitle) {
+                updateChatSessionOpencodeMetadata(chatSessionId, session.id, session.title, io);
+                lastAppliedSessionId = session.id;
+                lastAppliedTitle = session.title;
+            }
+            return {
+                hasSession: true,
+                hasResolvedTitle: session.title !== null,
+                sessionId: session.id,
+            };
+        }
+        catch {
+            return { hasSession: false, hasResolvedTitle: false, sessionId: knownSessionId };
+        }
+    };
+    const scheduleRetry = () => {
+        if (stopped) {
+            return;
+        }
+        clearLookupTimer();
+        lookupTimer = setTimeout(() => {
+            const result = refresh();
+            if (!result.hasResolvedTitle) {
+                scheduleRetry();
+            }
+        }, OPENCODE_SESSION_METADATA_LOOKUP_DELAY_MS);
+    };
+    return {
+        refresh,
+        scheduleRetry,
+        stop: () => {
+            stopped = true;
+            clearLookupTimer();
+        },
+    };
+};
+const TOOL_CALL_PREVIEW_MAX_LENGTH = 100;
+const APPLY_PATCH_START_MARKER = '[[archon-apply-patch]]';
+const APPLY_PATCH_END_MARKER = '[[/archon-apply-patch]]';
+const toDisplayPath = (filePath, cwd) => {
+    if (!cwd || !isAbsolute(filePath)) {
+        return filePath;
+    }
+    const resolvedCwd = resolve(cwd);
+    const resolvedFilePath = resolve(filePath);
+    if (resolvedFilePath === resolvedCwd) {
+        return filePath;
+    }
+    const cwdPrefix = `${resolvedCwd}${sep}`;
+    if (!resolvedFilePath.startsWith(cwdPrefix)) {
+        return filePath;
+    }
+    return relative(resolvedCwd, resolvedFilePath);
+};
+const formatApplyPatchToolCall = (input, cwd) => {
+    const patchText = typeof input?.patchText === 'string'
+        ? input.patchText.trim()
+        : null;
+    if (!patchText) {
+        return 'apply_patch';
+    }
+    const displayLines = [APPLY_PATCH_START_MARKER];
+    const lines = patchText.replace(/\r\n/g, '\n').split('\n');
+    let currentFilePath = null;
+    let lastDisplayedFileIndex = -1;
+    for (const line of lines) {
+        const trimmedLine = line.trimEnd();
+        const fileMatch = trimmedLine.match(/^\*\*\* (Update|Add|Delete) File: (.+)$/);
+        if (fileMatch) {
+            currentFilePath = toDisplayPath(fileMatch[2].trim(), cwd);
+            displayLines.push(currentFilePath);
+            lastDisplayedFileIndex = displayLines.length - 1;
+            continue;
+        }
+        const moveToMatch = trimmedLine.match(/^\*\*\* Move to: (.+)$/);
+        if (moveToMatch && currentFilePath && lastDisplayedFileIndex >= 0) {
+            const movedToPath = toDisplayPath(moveToMatch[1].trim(), cwd);
+            displayLines[lastDisplayedFileIndex] = `${currentFilePath} -> ${movedToPath}`;
+            currentFilePath = movedToPath;
+            continue;
+        }
+        if (/^[ +\\-]/.test(line)) {
+            displayLines.push(line);
+        }
+    }
+    if (displayLines.length === 1) {
+        return 'apply_patch';
+    }
+    displayLines.push(APPLY_PATCH_END_MARKER);
+    return displayLines.join('\n');
+};
+const formatToolCall = (name, input, cwd) => {
+    if (name.toLowerCase() === 'apply_patch') {
+        return formatApplyPatchToolCall(input, cwd);
+    }
+    const val = {
+        Read: input?.file_path,
+        Write: input?.file_path,
+        Edit: input?.file_path,
+        Bash: input?.command,
+        Glob: input?.pattern,
+        Grep: input?.pattern,
+        WebFetch: input?.url,
+        WebSearch: input?.query,
+        Task: input?.description,
+        NotebookEdit: input?.notebook_path,
+    }[name] ?? Object.values(input ?? {}).find(v => typeof v === 'string');
+    if (typeof val !== 'string' || val.length === 0) {
+        return `_${name}_`;
+    }
+    const display = val.length > TOOL_CALL_PREVIEW_MAX_LENGTH ? val.slice(0, TOOL_CALL_PREVIEW_MAX_LENGTH) + '…' : val;
+    return `_${name}_ \`${display}\``;
+};
+const parseClaudeStreamJsonLine = (line, cwd) => {
+    const trimmed = line.trim();
+    if (!trimmed) {
+        return { logFragment: null, responseFragment: null };
+    }
+    let event;
+    try {
+        event = JSON.parse(trimmed);
+    }
+    catch {
+        return { logFragment: trimmed, responseFragment: trimmed };
+    }
+    if (event.type === 'assistant' && Array.isArray(event.message?.content)) {
+        const logParts = [];
+        const responseParts = [];
+        for (const block of event.message.content) {
+            if (block.type === 'text' && block.text) {
+                const text = block.text.trim();
+                if (text) {
+                    logParts.push(text);
+                    responseParts.push(text);
+                }
+            }
+            else if (block.type === 'tool_use' && block.name) {
+                logParts.push(formatToolCall(block.name, block.input, cwd));
+            }
+        }
+        return {
+            logFragment: logParts.length > 0 ? logParts.join('\n\n') : null,
+            responseFragment: responseParts.length > 0 ? responseParts.join('\n\n') : null,
+        };
+    }
+    return { logFragment: null, responseFragment: null };
+};
+const formatOpencodeToolUse = (event, cwd) => {
+    const toolName = event.part?.tool;
+    if (!toolName) {
+        return null;
+    }
+    return formatToolCall(toolName, event.part?.state?.input, cwd);
+};
+const formatOpencodeStepTitle = (event) => {
+    const title = event.part?.title?.trim();
+    return title || null;
+};
+const extractLeadingJsonObject = (line) => {
+    if (!line.startsWith('{')) {
+        return null;
+    }
+    let depth = 0;
+    let inString = false;
+    let escaping = false;
+    for (let index = 0; index < line.length; index += 1) {
+        const char = line[index];
+        if (inString) {
+            if (escaping) {
+                escaping = false;
+                continue;
+            }
+            if (char === '\\') {
+                escaping = true;
+                continue;
+            }
+            if (char === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (char === '"') {
+            inString = true;
+            continue;
+        }
+        if (char === '{') {
+            depth += 1;
+            continue;
+        }
+        if (char === '}') {
+            depth -= 1;
+            if (depth === 0) {
+                return line.slice(0, index + 1);
+            }
+        }
+    }
+    return null;
+};
+const extractLeadingJsonObjects = (line) => {
+    const jsonObjects = [];
+    let remaining = line.trim();
+    while (remaining.startsWith('{')) {
+        const jsonObject = extractLeadingJsonObject(remaining);
+        if (!jsonObject) {
+            break;
+        }
+        jsonObjects.push(jsonObject);
+        remaining = remaining.slice(jsonObject.length).trim();
+    }
+    return {
+        jsonObjects,
+        remainder: remaining,
+    };
+};
+const parseOpencodeJsonEvent = (event, cwd) => {
+    if (event.type === 'text' && event.part?.type === 'text' && event.part.text) {
+        const text = event.part.text.trim();
+        const phase = event.part.metadata?.openai?.phase;
+        return {
+            logFragment: text || null,
+            responseFragment: text && (!phase || phase === 'final_answer') ? text : null,
+        };
+    }
+    if (event.type === 'reasoning' && event.part?.type === 'reasoning') {
+        const text = event.part.text?.trim() ?? '';
+        return {
+            logFragment: text || null,
+            responseFragment: null,
+        };
+    }
+    if (event.type === 'tool_use') {
+        const toolFragment = formatOpencodeToolUse(event, cwd);
+        return {
+            logFragment: toolFragment,
+            responseFragment: null,
+        };
+    }
+    if (event.type === 'step_start') {
+        return {
+            logFragment: formatOpencodeStepTitle(event),
+            responseFragment: null,
+        };
+    }
+    if (event.type === 'step_finish') {
+        return {
+            logFragment: null,
+            responseFragment: null,
+        };
+    }
+    return { logFragment: null, responseFragment: null };
+};
+const parseOpencodeJsonLine = (line, cwd) => {
+    const trimmed = line.trim();
+    if (!trimmed) {
+        return { logFragment: null, responseFragment: null };
+    }
+    const { jsonObjects, remainder } = extractLeadingJsonObjects(trimmed);
+    if (jsonObjects.length === 0) {
+        if (trimmed.startsWith('{')) {
+            return { logFragment: null, responseFragment: null };
+        }
+        return { logFragment: trimmed, responseFragment: trimmed };
+    }
+    const logFragments = [];
+    const responseFragments = [];
+    for (const jsonObject of jsonObjects) {
+        let event;
+        try {
+            event = JSON.parse(jsonObject);
+        }
+        catch {
+            continue;
+        }
+        const { logFragment, responseFragment } = parseOpencodeJsonEvent(event, cwd);
+        if (logFragment !== null) {
+            logFragments.push(logFragment);
+        }
+        if (responseFragment !== null) {
+            responseFragments.push(responseFragment);
+        }
+    }
+    if (logFragments.length > 0 || responseFragments.length > 0) {
+        return {
+            logFragment: logFragments.length > 0 ? logFragments.join('\n\n') : null,
+            responseFragment: responseFragments.length > 0 ? responseFragments.join('\n\n') : null,
+        };
+    }
+    if (remainder) {
+        return { logFragment: remainder, responseFragment: remainder };
+    }
+    return { logFragment: null, responseFragment: null };
+};
+const isModelResolutionError = (message) => {
+    if (typeof message !== 'string') {
+        return false;
+    }
+    return /ProviderModelNotFoundError|Model not found/i.test(message);
+};
+const isProcessAlive = (proc) => {
+    if (!proc) {
+        return false;
+    }
+    return proc.exitCode === null && proc.signalCode === null;
+};
+const killProcess = (proc, signal) => {
+    if (!isProcessAlive(proc)) {
+        return;
+    }
+    if (proc.pid && process.platform !== 'win32') {
+        try {
+            process.kill(-proc.pid, signal);
+            return;
+        }
+        catch (error) {
+            if (error.code === 'ESRCH') {
+                return;
+            }
+        }
+    }
+    try {
+        proc.kill(signal);
+    }
+    catch {
+    }
+};
+const waitForProcessExit = async (proc, timeoutMs) => {
+    const deadline = Date.now() + timeoutMs;
+    await new Promise(resolve => {
+        const check = () => {
+            if (!isProcessAlive(proc) || Date.now() >= deadline) {
+                resolve();
+            }
+            else {
+                setTimeout(check, 100);
+            }
+        };
+        setTimeout(check, 100);
+    });
+};
+const untrackBuildProcess = (ticketId, state) => {
+    if (activeBuildProcesses.get(ticketId) === state) {
+        activeBuildProcesses.delete(ticketId);
+    }
+    if (state.sessionLookupTimer) {
+        clearTimeout(state.sessionLookupTimer);
+        state.sessionLookupTimer = null;
+    }
+};
+const untrackChatProcess = (chatSessionId, state) => {
+    if (activeChatProcesses.get(chatSessionId) === state) {
+        activeChatProcesses.delete(chatSessionId);
+    }
+    state.metadataRefresher?.stop();
+    state.metadataRefresher = null;
+};
+export const isBuildAgentRunning = (ticketId) => activeBuildProcesses.has(ticketId);
+export const stopAllBuildAgents = async () => {
+    const ticketIds = [...activeBuildProcesses.keys()];
+    await Promise.all(ticketIds.map(stopBuildAgent));
+};
+export const stopBuildAgent = async (ticketId) => {
+    const state = activeBuildProcesses.get(ticketId);
+    if (!state?.child) {
+        return false;
+    }
+    state.stopRequested = true;
+    killProcess(state.child, 'SIGTERM');
+    await waitForProcessExit(state.child, 5000);
+    if (isProcessAlive(state.child)) {
+        killProcess(state.child, 'SIGKILL');
+        await waitForProcessExit(state.child, 1000);
+    }
+    return true;
+};
+export const stopChatAgent = async (chatSessionId) => {
+    const state = activeChatProcesses.get(chatSessionId);
+    if (!state?.child) {
+        return false;
+    }
+    state.stopRequested = true;
+    state.metadataRefresher?.stop();
+    killProcess(state.child, 'SIGTERM');
+    await waitForProcessExit(state.child, 5000);
+    if (isProcessAlive(state.child)) {
+        killProcess(state.child, 'SIGKILL');
+        await waitForProcessExit(state.child, 1000);
+    }
+    return true;
+};
+export const runAgent = ({ ticketId, tool, prompt, cwd, io, model, variant = null, resumeSessionId = null, sessionField = 'session_id', trackBuildProcess = false, emitSuccessUpdate = true, }) => {
+    const resolvedModel = normalizeModelId(model);
+    return new Promise((resolve, reject) => {
+        let sessionId = null;
+        let spawnTimestamp = null;
+        let sessionLookupTimer = null;
+        let hasResolvedOpencodeSessionId = Boolean(resumeSessionId);
+        let settled = false;
+        const buildState = trackBuildProcess
+            ? { child: null, stopRequested: false, sessionLookupTimer: null }
+            : null;
+        const settle = (handler) => (value) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            if (sessionLookupTimer) {
+                clearTimeout(sessionLookupTimer);
+                sessionLookupTimer = null;
+            }
+            if (trackBuildProcess && buildState) {
+                untrackBuildProcess(ticketId, buildState);
+            }
+            handler(value);
+        };
+        const resolveOnce = settle(resolve);
+        const rejectOnce = settle(reject);
+        const attemptOpencodeSessionLookup = () => {
+            if (tool !== 'opencode' || hasResolvedOpencodeSessionId || spawnTimestamp === null) {
+                return hasResolvedOpencodeSessionId;
+            }
+            try {
+                const session = readOpencodeSession(OPENCODE_SESSION_BY_CREATED_AT_QUERY, spawnTimestamp);
+                if (session?.id) {
+                    hasResolvedOpencodeSessionId = true;
+                    updateSessionId(ticketId, session.id, sessionField, io);
+                }
+            }
+            catch {
+                // Ticket session metadata is best-effort.
+            }
+            return hasResolvedOpencodeSessionId;
+        };
+        const [cmd, args] = tool === 'claude'
+            ? (() => {
+                sessionId = resumeSessionId || randomUUID();
+                return [
+                    'claude',
+                    [
+                        '--dangerously-skip-permissions',
+                        '--print',
+                        '--verbose',
+                        '--output-format',
+                        'stream-json',
+                        resumeSessionId ? '--resume' : '--session-id',
+                        sessionId,
+                        prompt,
+                    ]
+                ];
+            })()
+            : ['opencode', ['run', '--format', 'json', '--thinking', ...(resumeSessionId ? ['--session', resumeSessionId] : []), ...(resolvedModel ? ['--model', resolvedModel] : []), ...(variant ? ['--variant', variant] : []), prompt]];
+        updateStatus(ticketId, 'running', null, io);
+        if (tool === 'claude' && sessionId) {
+            updateSessionId(ticketId, sessionId, sessionField, io);
+        }
+        if (tool === 'opencode') {
+            spawnTimestamp = Date.now();
+        }
+        const child = spawn(cmd, args, {
+            cwd,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: process.env,
+            detached: process.platform !== 'win32',
+        });
+        if (trackBuildProcess && buildState) {
+            buildState.child = child;
+            activeBuildProcesses.set(ticketId, buildState);
+        }
+        if (tool === 'claude') {
+            const logLines = [];
+            const responseLines = [];
+            let remainder = '';
+            const stderrChunks = [];
+            const progressUpdater = createThrottledProgressUpdater(() => {
+                updateStatus(ticketId, 'running', logLines.join('\n\n'), io, responseLines.join('\n\n'));
+            });
+            child.stdout?.on('data', (chunk) => {
+                const text = remainder + chunk.toString();
+                const lines = text.split('\n');
+                remainder = lines.pop() ?? '';
+                for (const line of lines) {
+                    const { logFragment, responseFragment } = parseClaudeStreamJsonLine(line, cwd);
+                    if (logFragment !== null) {
+                        logLines.push(logFragment);
+                    }
+                    if (responseFragment !== null) {
+                        responseLines.push(responseFragment);
+                    }
+                    if (logFragment !== null || responseFragment !== null) {
+                        progressUpdater.schedule();
+                    }
+                }
+            });
+            child.stderr?.on('data', (chunk) => stderrChunks.push(chunk));
+            child.on('close', code => {
+                progressUpdater.cancel();
+                if (remainder.trim()) {
+                    const { logFragment, responseFragment } = parseClaudeStreamJsonLine(remainder, cwd);
+                    if (logFragment !== null) {
+                        logLines.push(logFragment);
+                    }
+                    if (responseFragment !== null) {
+                        responseLines.push(responseFragment);
+                    }
+                }
+                const errOutput = Buffer.concat(stderrChunks).toString();
+                const finalLog = logLines.join('\n\n') || errOutput;
+                const finalResponse = responseLines.join('\n\n') || errOutput;
+                const modelError = isModelResolutionError(finalLog);
+                if (buildState?.stopRequested) {
+                    updateStatus(ticketId, 'stopped', finalLog, io, finalResponse);
+                    resolveOnce(finalResponse);
+                    return;
+                }
+                if (code === 0 && !modelError) {
+                    updateStatus(ticketId, 'done', finalLog, io, finalResponse, { emit: emitSuccessUpdate });
+                    resolveOnce(finalResponse);
+                    return;
+                }
+                updateStatus(ticketId, 'error', finalLog + (errOutput ? '\n\n' + errOutput : ''), io, finalResponse);
+                rejectOnce(new Error(`Agent exited with code ${code ?? 'null'}\n${finalLog}`));
+            });
+            child.on('error', err => {
+                progressUpdater.cancel();
+                if (buildState?.stopRequested) {
+                    updateStatus(ticketId, 'stopped', null, io);
+                    resolveOnce(null);
+                    return;
+                }
+                updateStatus(ticketId, 'error', getErrorMessage(err), io);
+                rejectOnce(err instanceof Error ? err : new Error(getErrorMessage(err)));
+            });
+            return;
+        }
+        const logLines = [];
+        const responseLines = [];
+        let remainder = '';
+        const stderrChunks = [];
+        const progressUpdater = createThrottledProgressUpdater(() => {
+            updateStatus(ticketId, 'running', logLines.join('\n\n'), io, responseLines.join('\n\n'));
+        });
+        child.stdout?.on('data', (chunk) => {
+            const text = remainder + chunk.toString();
+            const lines = text.split('\n');
+            remainder = lines.pop() ?? '';
+            for (const line of lines) {
+                const { logFragment, responseFragment } = parseOpencodeJsonLine(line);
+                if (logFragment !== null) {
+                    logLines.push(logFragment);
+                }
+                if (responseFragment !== null) {
+                    responseLines.push(responseFragment);
+                }
+                if (logFragment !== null || responseFragment !== null) {
+                    progressUpdater.schedule();
+                }
+            }
+        });
+        child.stderr?.on('data', (chunk) => stderrChunks.push(chunk));
+        if (tool === 'opencode' && !resumeSessionId) {
+            sessionLookupTimer = setTimeout(() => {
+                attemptOpencodeSessionLookup();
+                sessionLookupTimer = null;
+            }, 1500);
+            if (trackBuildProcess && buildState) {
+                buildState.sessionLookupTimer = sessionLookupTimer;
+            }
+        }
+        child.on('close', code => {
+            progressUpdater.cancel();
+            const resolvedSessionOnClose = attemptOpencodeSessionLookup();
+            if (sessionLookupTimer && (resolvedSessionOnClose || hasResolvedOpencodeSessionId)) {
+                clearTimeout(sessionLookupTimer);
+                sessionLookupTimer = null;
+            }
+            if (remainder.trim()) {
+                const { logFragment, responseFragment } = parseOpencodeJsonLine(remainder);
+                if (logFragment !== null) {
+                    logLines.push(logFragment);
+                }
+                if (responseFragment !== null) {
+                    responseLines.push(responseFragment);
+                }
+            }
+            const stderrOutput = Buffer.concat(stderrChunks).toString();
+            const log = logLines.join('\n\n') || stderrOutput;
+            const finalResponse = responseLines.join('\n\n') || stderrOutput;
+            const modelError = isModelResolutionError(log);
+            if (buildState?.stopRequested) {
+                updateStatus(ticketId, 'stopped', log, io, finalResponse);
+                resolveOnce(finalResponse);
+                return;
+            }
+            if (code === 0 && !modelError) {
+                updateStatus(ticketId, 'done', log, io, finalResponse, { emit: emitSuccessUpdate });
+                resolveOnce(finalResponse);
+                return;
+            }
+            updateStatus(ticketId, 'error', log, io, finalResponse);
+            rejectOnce(new Error(`Agent exited with code ${code ?? 'null'}\n${log}`));
+        });
+        child.on('error', err => {
+            progressUpdater.cancel();
+            if (sessionLookupTimer && hasResolvedOpencodeSessionId) {
+                clearTimeout(sessionLookupTimer);
+                sessionLookupTimer = null;
+            }
+            if (buildState?.stopRequested) {
+                updateStatus(ticketId, 'stopped', null, io);
+                resolveOnce(null);
+                return;
+            }
+            updateStatus(ticketId, 'error', getErrorMessage(err), io);
+            rejectOnce(err instanceof Error ? err : new Error(getErrorMessage(err)));
+        });
+    });
+};
+export const runChatAgent = ({ chatSessionId, tool, prompt, cwd, io, model, variant = null, resumeSessionId = null, opencodeAgentMode = 'build', }) => {
+    const resolvedModel = normalizeModelId(model);
+    return new Promise((resolve, reject) => {
+        let sessionId = null;
+        let spawnTimestamp = null;
+        let opencodeMetadataRefresher = null;
+        let settled = false;
+        let usageSnapshot = EMPTY_CHAT_USAGE_SNAPSHOT;
+        const chatState = {
+            child: null,
+            stopRequested: false,
+            metadataRefresher: null,
+        };
+        const settle = (handler) => (value) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            opencodeMetadataRefresher?.stop();
+            untrackChatProcess(chatSessionId, chatState);
+            handler(value);
+        };
+        const resolveOnce = settle(resolve);
+        const rejectOnce = settle(reject);
+        const [cmd, args] = tool === 'claude'
+            ? (() => {
+                sessionId = resumeSessionId || randomUUID();
+                return [
+                    'claude',
+                    [
+                        '--dangerously-skip-permissions',
+                        '--print',
+                        '--verbose',
+                        '--output-format',
+                        'stream-json',
+                        resumeSessionId ? '--resume' : '--session-id',
+                        sessionId,
+                        prompt,
+                    ]
+                ];
+            })()
+            : ['opencode', ['run', ...(opencodeAgentMode === 'plan' ? ['--agent', 'plan'] : []), '--format', 'json', ...(opencodeAgentMode === 'build' ? ['--thinking'] : []), ...(resumeSessionId ? ['--session', resumeSessionId] : []), ...(resolvedModel ? ['--model', resolvedModel] : []), ...(variant ? ['--variant', variant] : []), prompt]];
+        updateChatSessionStatus(chatSessionId, 'running', null, io);
+        if (tool === 'claude' && sessionId) {
+            updateChatSessionId(chatSessionId, tool, sessionId, io);
+        }
+        if (tool === 'opencode') {
+            spawnTimestamp = Date.now();
+            opencodeMetadataRefresher = createOpencodeMetadataRefresher({
+                chatSessionId,
+                io,
+                spawnTimestamp,
+                initialSessionId: resumeSessionId,
+            });
+            chatState.metadataRefresher = opencodeMetadataRefresher;
+            if (resumeSessionId) {
+                const result = opencodeMetadataRefresher.refresh();
+                if (!result.hasResolvedTitle) {
+                    opencodeMetadataRefresher.scheduleRetry();
+                }
+            }
+        }
+        const child = spawn(cmd, args, {
+            cwd,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: process.env,
+            detached: process.platform !== 'win32',
+        });
+        chatState.child = child;
+        activeChatProcesses.set(chatSessionId, chatState);
+        if (tool === 'claude') {
+            const logLines = [];
+            const responseLines = [];
+            let remainder = '';
+            const stderrChunks = [];
+            const progressUpdater = createThrottledProgressUpdater(() => {
+                updateChatSessionStatus(chatSessionId, 'running', logLines.join('\n\n'), io, responseLines.join('\n\n'));
+            });
+            child.stdout?.on('data', (chunk) => {
+                const text = remainder + chunk.toString();
+                const lines = text.split('\n');
+                remainder = lines.pop() ?? '';
+                for (const line of lines) {
+                    const { logFragment, responseFragment } = parseClaudeStreamJsonLine(line);
+                    usageSnapshot = mergeUsageFromJsonLine(usageSnapshot, line);
+                    if (logFragment !== null) {
+                        logLines.push(logFragment);
+                    }
+                    if (responseFragment !== null) {
+                        responseLines.push(responseFragment);
+                    }
+                    if (logFragment !== null || responseFragment !== null) {
+                        progressUpdater.schedule();
+                    }
+                }
+            });
+            child.stderr?.on('data', (chunk) => stderrChunks.push(chunk));
+            child.on('close', code => {
+                progressUpdater.cancel();
+                if (remainder.trim()) {
+                    usageSnapshot = mergeUsageFromJsonLine(usageSnapshot, remainder);
+                    const { logFragment, responseFragment } = parseClaudeStreamJsonLine(remainder);
+                    if (logFragment !== null) {
+                        logLines.push(logFragment);
+                    }
+                    if (responseFragment !== null) {
+                        responseLines.push(responseFragment);
+                    }
+                }
+                const errOutput = Buffer.concat(stderrChunks).toString();
+                const finalLog = logLines.join('\n\n') || errOutput;
+                const finalResponse = responseLines.join('\n\n') || errOutput;
+                if (chatState.stopRequested) {
+                    const preservedOutput = getPreservedChatOutput({
+                        chatSessionId,
+                        log: finalLog,
+                        response: finalResponse,
+                    });
+                    updateChatSessionStatus(chatSessionId, 'running', preservedOutput.log, io, preservedOutput.response);
+                    resolveOnce({
+                        completionStatus: 'stopped',
+                        finalResponse: preservedOutput.response,
+                        usageSnapshot,
+                    });
+                    return;
+                }
+                const modelError = isModelResolutionError(finalLog);
+                if (code === 0 && !modelError) {
+                    const finalOutput = getPreservedChatOutput({
+                        chatSessionId,
+                        log: finalLog,
+                        response: finalResponse,
+                    });
+                    updateChatSessionStatus(chatSessionId, 'running', finalOutput.log, io, finalOutput.response);
+                    resolveOnce({
+                        completionStatus: 'done',
+                        finalResponse: finalOutput.response,
+                        usageSnapshot,
+                    });
+                    return;
+                }
+                updateChatSessionStatus(chatSessionId, 'error', finalLog + (errOutput ? '\n\n' + errOutput : ''), io, finalResponse);
+                rejectOnce(new Error(`Agent exited with code ${code ?? 'null'}\n${finalLog}`));
+            });
+            child.on('error', err => {
+                progressUpdater.cancel();
+                if (chatState.stopRequested) {
+                    const log = logLines.join('\n\n') || null;
+                    const response = responseLines.join('\n\n') || null;
+                    const preservedOutput = getPreservedChatOutput({
+                        chatSessionId,
+                        log,
+                        response,
+                    });
+                    updateChatSessionStatus(chatSessionId, 'running', preservedOutput.log, io, preservedOutput.response);
+                    resolveOnce({
+                        completionStatus: 'stopped',
+                        finalResponse: preservedOutput.response,
+                        usageSnapshot,
+                    });
+                    return;
+                }
+                updateChatSessionStatus(chatSessionId, 'error', getErrorMessage(err), io);
+                rejectOnce(err instanceof Error ? err : new Error(getErrorMessage(err)));
+            });
+            return;
+        }
+        const logLines = [];
+        const responseLines = [];
+        let remainder = '';
+        const stderrChunks = [];
+        const progressUpdater = createThrottledProgressUpdater(() => {
+            updateChatSessionStatus(chatSessionId, 'running', logLines.join('\n\n'), io, responseLines.join('\n\n'));
+        });
+        child.stdout?.on('data', (chunk) => {
+            const text = remainder + chunk.toString();
+            const lines = text.split('\n');
+            remainder = lines.pop() ?? '';
+            for (const line of lines) {
+                usageSnapshot = mergeUsageFromJsonLine(usageSnapshot, line);
+                const { logFragment, responseFragment } = parseOpencodeJsonLine(line, cwd);
+                if (logFragment !== null) {
+                    logLines.push(logFragment);
+                }
+                if (responseFragment !== null) {
+                    responseLines.push(responseFragment);
+                }
+                if (logFragment !== null || responseFragment !== null) {
+                    progressUpdater.schedule();
+                }
+            }
+        });
+        child.stderr?.on('data', (chunk) => stderrChunks.push(chunk));
+        if (!resumeSessionId) {
+            opencodeMetadataRefresher?.scheduleRetry();
+        }
+        child.on('close', code => {
+            progressUpdater.cancel();
+            if (remainder.trim()) {
+                usageSnapshot = mergeUsageFromJsonLine(usageSnapshot, remainder);
+                const { logFragment, responseFragment } = parseOpencodeJsonLine(remainder, cwd);
+                if (logFragment !== null) {
+                    logLines.push(logFragment);
+                }
+                if (responseFragment !== null) {
+                    responseLines.push(responseFragment);
+                }
+            }
+            const stderrOutput = Buffer.concat(stderrChunks).toString();
+            const log = logLines.join('\n\n') || stderrOutput;
+            const finalResponse = responseLines.join('\n\n') || stderrOutput;
+            const preservedOutput = chatState.stopRequested
+                ? getPreservedChatOutput({
+                    chatSessionId,
+                    log,
+                    response: finalResponse,
+                })
+                : null;
+            const metadataResult = opencodeMetadataRefresher?.refresh();
+            const resolvedOpencodeSessionId = metadataResult?.sessionId
+                ?? preservedOutput?.opencodeSessionId
+                ?? getChatSession(chatSessionId)?.opencode_session_id
+                ?? resumeSessionId;
+            if (chatState.stopRequested) {
+                if (resolvedOpencodeSessionId) {
+                    usageSnapshot = resolveOpencodeUsageSnapshot({
+                        current: usageSnapshot,
+                        sessionId: resolvedOpencodeSessionId,
+                        spawnTimestamp,
+                    });
+                }
+                updateChatSessionStatus(chatSessionId, 'running', preservedOutput?.log ?? null, io, preservedOutput?.response ?? null);
+                resolveOnce({
+                    completionStatus: 'stopped',
+                    finalResponse: preservedOutput?.response ?? null,
+                    usageSnapshot,
+                });
+                return;
+            }
+            const modelError = isModelResolutionError(log);
+            if (code === 0 && !modelError) {
+                const finalOutput = getPreservedChatOutput({
+                    chatSessionId,
+                    log,
+                    response: finalResponse,
+                });
+                if (resolvedOpencodeSessionId && spawnTimestamp !== null) {
+                    usageSnapshot = resolveOpencodeUsageSnapshot({
+                        current: usageSnapshot,
+                        sessionId: resolvedOpencodeSessionId,
+                        spawnTimestamp,
+                    });
+                }
+                updateChatSessionStatus(chatSessionId, 'running', finalOutput.log, io, finalOutput.response);
+                resolveOnce({
+                    completionStatus: 'done',
+                    finalResponse: finalOutput.response,
+                    usageSnapshot,
+                });
+                return;
+            }
+            updateChatSessionStatus(chatSessionId, 'error', log, io, finalResponse);
+            rejectOnce(new Error(`Agent exited with code ${code ?? 'null'}\n${log}`));
+        });
+        child.on('error', err => {
+            progressUpdater.cancel();
+            if (chatState.stopRequested) {
+                const log = logLines.join('\n\n') || null;
+                const response = responseLines.join('\n\n') || null;
+                const preservedOutput = getPreservedChatOutput({
+                    chatSessionId,
+                    log,
+                    response,
+                });
+                updateChatSessionStatus(chatSessionId, 'running', preservedOutput.log, io, preservedOutput.response);
+                resolveOnce({
+                    completionStatus: 'stopped',
+                    finalResponse: preservedOutput.response,
+                    usageSnapshot,
+                });
+                return;
+            }
+            updateChatSessionStatus(chatSessionId, 'error', getErrorMessage(err), io);
+            rejectOnce(err instanceof Error ? err : new Error(getErrorMessage(err)));
+        });
+    });
+};
+//# sourceMappingURL=agent.js.map