@love-moon/tui-driver 0.2.12 → 0.2.14

package/dist/driver/TuiDriver.js

@@ -2,6 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TuiDriver = void 0;
 const events_1 = require("events");
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const node_util_1 = require("node:util");
 const PtySession_js_1 = require("../pty/PtySession.js");
 const HeadlessScreen_js_1 = require("../term/HeadlessScreen.js");
 const ScreenSnapshot_js_1 = require("../term/ScreenSnapshot.js");
@@ -11,6 +16,13 @@ const OutputExtractor_js_1 = require("../extract/OutputExtractor.js");
 const Diff_js_1 = require("../extract/Diff.js");
 const StateMachine_js_1 = require("./StateMachine.js");
 const index_js_1 = require("./behavior/index.js");
+const DEFAULT_STAGE_TIMEOUT_MAX_MS = 15 * 60 * 1000;
+const ABSOLUTE_STAGE_TIMEOUT_MAX_MS = 60 * 60 * 1000;
+const MIN_STAGE_TIMEOUT_MS = 100;
+const DEFAULT_SESSION_DISCOVERY_TIMEOUT_MS = 15_000;
+const DEFAULT_SESSION_CHECKPOINT_TIMEOUT_MS = 30_000;
+const DEFAULT_SESSION_POLL_INTERVAL_MS = 2_000;
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
 class TuiDriver extends events_1.EventEmitter {
     pty;
     screen;
@@ -23,6 +35,16 @@ class TuiDriver extends events_1.EventEmitter {
     onSignals;
     isBooted = false;
     isKilled = false;
+    sessionCwd;
+    hasExplicitSessionCwd;
+    expectedSessionId;
+    sessionDetectStartSec;
+    sessionDetectBaselineIds;
+    sessionInfo = null;
+    lastSessionInfo = null;
+    sessionUsageCache = null;
+    initialCommand;
+    initialArgs;
     constructor(options) {
         super();
         this.profile = options.profile;
@@ -30,10 +52,17 @@ class TuiDriver extends events_1.EventEmitter {
         this.debug = options.debug ?? false;
         this.onSnapshot = options.onSnapshot;
         this.onSignals = options.onSignals;
+        this.hasExplicitSessionCwd = options.cwd !== undefined;
+        this.sessionCwd = options.cwd ?? process.cwd();
+        this.expectedSessionId = String(options.expectedSessionId || "").trim();
+        this.sessionDetectStartSec = Math.floor(Date.now() / 1000);
+        this.sessionDetectBaselineIds = [];
+        this.initialCommand = this.profile.command;
+        this.initialArgs = Array.isArray(this.profile.args) ? [...this.profile.args] : [];
         const cols = this.profile.cols ?? 120;
         const rows = this.profile.rows ?? 40;
         const scrollback = this.profile.scrollback ?? 5000;
-        this.pty = new PtySession_js_1.PtySession(this.profile.command, this.profile.args, { cols, rows, env: this.profile.env, cwd: options.cwd });
+        this.pty = new PtySession_js_1.PtySession(this.initialCommand, this.initialArgs, { cols, rows, env: this.profile.env, cwd: this.sessionCwd });
         this.screen = new HeadlessScreen_js_1.HeadlessScreen({
             cols,
             rows,
@@ -54,6 +83,7 @@ class TuiDriver extends events_1.EventEmitter {
         this.pty.onExit((code, signal) => {
             this.log(`PTY exited: code=${code}, signal=${signal}`);
             this.isBooted = false;
+            this.sessionInfo = null;
             this.emit("exit", code, signal);
         });
         this.stateMachine.on("stateChange", (transition) => {
@@ -76,6 +106,74 @@ class TuiDriver extends events_1.EventEmitter {
     get running() {
         return this.pty.isRunning;
     }
+    getSessionInfo() {
+        const current = this.sessionInfo ?? this.lastSessionInfo;
+        return current ? { ...current } : null;
+    }
+    async ensureSessionInfo(timeoutMs = DEFAULT_SESSION_DISCOVERY_TIMEOUT_MS) {
+        if (!this.supportsSessionFileTracking()) {
+            return null;
+        }
+        if (this.sessionInfo) {
+            return { ...this.sessionInfo };
+        }
+        const boundedTimeoutMs = this.resolveTimeout(timeoutMs, DEFAULT_SESSION_DISCOVERY_TIMEOUT_MS);
+        const discovered = await this.discoverSessionInfo(boundedTimeoutMs);
+        return discovered ? { ...discovered } : null;
+    }
+    async getSessionUsageSummary() {
+        if (!this.supportsSessionFileTracking()) {
+            return null;
+        }
+        const sessionInfo = this.sessionInfo ?? this.lastSessionInfo ?? (await this.ensureSessionInfo());
+        if (!sessionInfo) {
+            return null;
+        }
+        const { size, mtimeMs } = await this.readSessionFileStat(sessionInfo.sessionFilePath);
+        if (this.sessionUsageCache &&
+            this.sessionUsageCache.backend === sessionInfo.backend &&
+            this.sessionUsageCache.sessionId === sessionInfo.sessionId &&
+            this.sessionUsageCache.sessionFilePath === sessionInfo.sessionFilePath &&
+            this.sessionUsageCache.size === size &&
+            this.sessionUsageCache.mtimeMs === mtimeMs) {
+            return { ...this.sessionUsageCache.summary };
+        }
+        const lines = await this.readSessionFileJsonLines(sessionInfo.sessionFilePath, 0);
+        const summary = this.extractSessionUsageSummaryFromJsonLines(lines, sessionInfo);
+        this.sessionUsageCache = {
+            backend: sessionInfo.backend,
+            sessionId: sessionInfo.sessionId,
+            sessionFilePath: sessionInfo.sessionFilePath,
+            size,
+            mtimeMs,
+            summary,
+        };
+        return { ...summary };
+    }
+    async getSessionFileSize(sessionInfo) {
+        const resolvedSessionInfo = sessionInfo ?? this.sessionInfo ?? this.lastSessionInfo ?? (await this.ensureSessionInfo());
+        if (!resolvedSessionInfo) {
+            return 0;
+        }
+        const { size } = await this.readSessionFileStat(resolvedSessionInfo.sessionFilePath);
+        return size;
+    }
+    async readSessionAssistantMessagesSince(sessionInfo, startOffset = 0) {
+        const resolvedSessionInfo = {
+            backend: String(sessionInfo?.backend || "").trim(),
+            sessionId: String(sessionInfo?.sessionId || "").trim(),
+            sessionFilePath: String(sessionInfo?.sessionFilePath || "").trim(),
+        };
+        const readResult = await this.readSessionFileLinesSince(resolvedSessionInfo.sessionFilePath, startOffset);
+        return {
+            backend: resolvedSessionInfo.backend,
+            sessionId: resolvedSessionInfo.sessionId,
+            sessionFilePath: resolvedSessionInfo.sessionFilePath,
+            nextOffset: readResult.nextOffset,
+            fileSize: readResult.fileSize,
+            messages: this.extractAssistantMessagesFromJsonLines(readResult.lines, resolvedSessionInfo),
+        };
+    }
     async boot() {
         if (this.isKilled) {
             throw this.createSessionClosedError();
@@ -84,6 +182,9 @@ class TuiDriver extends events_1.EventEmitter {
             return;
         }
         this.stateMachine.transition("BOOT");
+        this.sessionInfo = null;
+        this.sessionDetectStartSec = Math.floor(Date.now() / 1000);
+        this.sessionDetectBaselineIds = await this.captureSessionBaseline();
         this.pty.spawn();
         const bootTimeout = this.resolveTimeout(this.profile.timeouts?.boot, 15000);
         const readyMatcher = Matchers_js_1.Matchers.anyOf(this.profile.anchors.ready);
@@ -168,6 +269,7 @@ class TuiDriver extends events_1.EventEmitter {
         }
         this.isBooted = true;
         this.stateMachine.transition("WAIT_READY");
+        await this.ensureSessionInfo();
         this.captureSnapshot("boot_complete");
     }
     async ensureReady() {
@@ -194,6 +296,7 @@ class TuiDriver extends events_1.EventEmitter {
     }
     async ask(prompt) {
         const startTime = Date.now();
+        let sessionInfo = null;
         try {
             await this.ensureReady();
             // 健康检查：在执行前检测异常状态
@@ -210,6 +313,17 @@ class TuiDriver extends events_1.EventEmitter {
                         throw error;
                     }
                 }
+                else if (health.reason === "process_exited") {
+                    this.log("Health check detected exited process, attempting forced restart");
+                    await this.restart();
+                    const healthAfterRestart = this.healthCheck();
+                    if (!healthAfterRestart.healthy) {
+                        const error = new Error(`Cannot proceed: ${healthAfterRestart.message || healthAfterRestart.reason}`);
+                        error.reason = healthAfterRestart.reason;
+                        error.matchedPattern = healthAfterRestart.matchedPattern;
+                        throw error;
+                    }
+                }
                 else if (health.reason === "login_required") {
                     const error = new Error(`Cannot proceed: ${health.message}`);
                     error.reason = health.reason;
@@ -230,6 +344,7 @@ class TuiDriver extends events_1.EventEmitter {
                     }
                 }
             }
+            sessionInfo = await this.ensureSessionInfo();
             this.stateMachine.transition("PREPARE_TURN");
             await this.prepareTurn();
             this.stateMachine.transition("TYPE_PROMPT");
@@ -240,13 +355,39 @@ class TuiDriver extends events_1.EventEmitter {
             await this.submit();
             // 在 submit 之后保存快照，这样 diff 只包含 AI 的回答，不包含 prompt
             const beforeSnapshot = this.captureSnapshot("after_submit");
+            const sessionCheckpoint = await this.resolveSessionFileCheckpointForTurn(sessionInfo);
+            if (sessionCheckpoint) {
+                sessionInfo = sessionCheckpoint.sessionInfo;
+            }
+            if (!sessionCheckpoint && this.requiresSessionFileCheckpointForTurn()) {
+                if (this.profile.name === "copilot") {
+                    throw new Error("Copilot session file checkpoint unavailable");
+                }
+                throw new Error("Codex session file checkpoint unavailable");
+            }
             this.stateMachine.transition("WAIT_STREAM_START");
-            await this.waitStreamStart(preSubmitSnapshot);
+            if (sessionCheckpoint) {
+                await this.waitForSessionFileGrowth(sessionCheckpoint);
+            }
+            else {
+                await this.waitStreamStart(preSubmitSnapshot);
+            }
             this.stateMachine.transition("WAIT_STREAM_END");
-            await this.waitStreamEnd(beforeSnapshot);
+            if (sessionCheckpoint) {
+                await this.waitForSessionFileIdle(sessionCheckpoint);
+            }
+            else {
+                await this.waitStreamEnd(beforeSnapshot);
+            }
             this.stateMachine.transition("CAPTURE");
             const afterSnapshot = this.captureSnapshot("after_response");
-            const answer = this.extractAnswer(beforeSnapshot, afterSnapshot);
+            let answer = "";
+            if (sessionCheckpoint) {
+                answer = await this.extractAnswerFromSessionFile(sessionCheckpoint);
+            }
+            else {
+                answer = this.extractAnswer(beforeSnapshot, afterSnapshot);
+            }
             const signals = this.getSignals(afterSnapshot);
             this.stateMachine.transition("DONE");
             return {
@@ -262,6 +403,8 @@ class TuiDriver extends events_1.EventEmitter {
                 replyInProgress: signals.replyInProgress,
                 statusLine: signals.statusLine,
                 statusDoneLine: signals.statusDoneLine,
+                sessionId: sessionInfo?.sessionId,
+                sessionFilePath: sessionInfo?.sessionFilePath,
             };
         }
         catch (error) {
@@ -281,6 +424,8 @@ class TuiDriver extends events_1.EventEmitter {
                 replyInProgress: signals.replyInProgress,
                 statusLine: signals.statusLine,
                 statusDoneLine: signals.statusDoneLine,
+                sessionId: sessionInfo?.sessionId,
+                sessionFilePath: sessionInfo?.sessionFilePath,
             };
         }
     }
@@ -296,6 +441,965 @@ class TuiDriver extends events_1.EventEmitter {
     async submit() {
         await this.pty.sendKeys(this.profile.keys.submit, 50);
     }
+    supportsSessionFileTracking() {
+        const backend = String(this.profile.name || "").toLowerCase();
+        return backend === "codex" || backend === "claude-code" || backend === "copilot";
+    }
+    async discoverSessionInfo(timeoutMs) {
+        const startedAt = Date.now();
+        const deadline = startedAt + Math.max(MIN_STAGE_TIMEOUT_MS, timeoutMs);
+        while (Date.now() < deadline) {
+            this.assertAliveOrThrow();
+            const discovered = await this.detectSessionInfoByBackend();
+            if (discovered) {
+                const changed = !this.sessionInfo ||
+                    this.sessionInfo.sessionId !== discovered.sessionId ||
+                    this.sessionInfo.sessionFilePath !== discovered.sessionFilePath;
+                this.sessionInfo = discovered;
+                this.lastSessionInfo = discovered;
+                if (changed) {
+                    this.emit("session", { ...discovered });
+                    this.log(`session discovered: id=${discovered.sessionId} file=${discovered.sessionFilePath}`);
+                }
+                return discovered;
+            }
+            await this.sleep(250);
+        }
+        return this.sessionInfo ? { ...this.sessionInfo } : null;
+    }
+    async detectSessionInfoByBackend() {
+        if (!this.supportsSessionFileTracking()) {
+            return null;
+        }
+        try {
+            switch (this.profile.name) {
+                case "codex":
+                    return this.detectCodexSessionInfo();
+                case "claude-code":
+                    return this.detectClaudeSessionInfo();
+                case "copilot":
+                    return this.detectCopilotSessionInfo();
+                default:
+                    return null;
+            }
+        }
+        catch (error) {
+            this.log(`session detect failed: ${error?.message || error}`);
+            return null;
+        }
+    }
+    getPinnedSessionIds() {
+        return Array.from(new Set([
+            this.expectedSessionId,
+            this.sessionInfo?.sessionId,
+            this.lastSessionInfo?.sessionId,
+        ]
+            .map((value) => String(value || "").trim())
+            .filter(Boolean)));
+    }
+    toSessionInfo(backend, candidate) {
+        if (!candidate) {
+            return null;
+        }
+        return {
+            backend,
+            sessionId: candidate.sessionId,
+            sessionFilePath: candidate.sessionFilePath,
+        };
+    }
+    pickSessionDiscoveryCandidate(candidates) {
+        if (!Array.isArray(candidates) || candidates.length === 0) {
+            return null;
+        }
+        const pinnedIds = this.getPinnedSessionIds();
+        for (const pinnedId of pinnedIds) {
+            const match = candidates.find((candidate) => candidate.sessionId === pinnedId);
+            if (match) {
+                return match;
+            }
+        }
+        if (this.sessionDetectBaselineIds.length === 0) {
+            return candidates[0] ?? null;
+        }
+        const baselineIds = new Set(this.sessionDetectBaselineIds);
+        return candidates.find((candidate) => !baselineIds.has(candidate.sessionId)) ?? null;
+    }
+    collectBaselineSessionIds(candidates) {
+        return Array.from(new Set(candidates
+            .map((candidate) => String(candidate.sessionId || "").trim())
+            .filter(Boolean))).slice(0, 256);
+    }
+    async captureSessionBaseline() {
+        if (this.getPinnedSessionIds().length > 0) {
+            return [];
+        }
+        switch (this.profile.name) {
+            case "codex":
+                return this.captureCodexSessionBaseline();
+            case "claude-code":
+                return this.captureClaudeSessionBaseline();
+            case "copilot":
+                return this.captureCopilotSessionBaseline();
+            default:
+                return [];
+        }
+    }
+    async detectCodexSessionInfo() {
+        const dbPath = (0, node_path_1.join)((0, node_os_1.homedir)(), ".codex", "state_5.sqlite");
+        if (!(await this.pathExists(dbPath))) {
+            return null;
+        }
+        const parseRowAsSessionInfo = async (row) => {
+            if (!row) {
+                return null;
+            }
+            const [sessionIdRaw, sessionFilePathRaw] = row.split("|");
+            const sessionId = String(sessionIdRaw || "").trim();
+            const sessionFilePath = String(sessionFilePathRaw || "").trim();
+            if (!sessionId || !sessionFilePath || !(await this.pathExists(sessionFilePath))) {
+                return null;
+            }
+            return {
+                backend: "codex",
+                sessionId,
+                sessionFilePath,
+            };
+        };
+        const candidateSessionIds = this.getPinnedSessionIds();
+        for (const candidateSessionId of candidateSessionIds) {
+            const escapedSessionId = candidateSessionId.replace(/'/g, "''");
+            const pinnedRow = await this.querySqliteRow(dbPath, `select id, rollout_path from threads where source='cli' and model_provider='openai' and id='${escapedSessionId}' limit 1;`);
+            const pinnedSession = await parseRowAsSessionInfo(pinnedRow);
+            if (pinnedSession) {
+                return pinnedSession;
+            }
+        }
+        const conditions = [
+            "source='cli'",
+            "model_provider='openai'",
+            `created_at >= ${Math.max(0, this.sessionDetectStartSec)}`,
+        ];
+        if (this.hasExplicitSessionCwd) {
+            conditions.push(`cwd='${this.sessionCwd.replace(/'/g, "''")}'`);
+        }
+        if (this.sessionDetectBaselineIds.length > 0) {
+            const escapedBaselineIds = this.sessionDetectBaselineIds
+                .map((sessionId) => `'${sessionId.replace(/'/g, "''")}'`)
+                .join(", ");
+            conditions.push(`id not in (${escapedBaselineIds})`);
+        }
+        const row = await this.querySqliteRow(dbPath, `select id, rollout_path from threads where ${conditions.join(" and ")} order by created_at asc, id asc limit 1;`);
+        return parseRowAsSessionInfo(row);
+    }
+    async captureCodexSessionBaseline() {
+        if (String(this.profile.name || "").toLowerCase() !== "codex") {
+            return [];
+        }
+        const dbPath = (0, node_path_1.join)((0, node_os_1.homedir)(), ".codex", "state_5.sqlite");
+        if (!(await this.pathExists(dbPath))) {
+            return [];
+        }
+        const conditions = [
+            "source='cli'",
+            "model_provider='openai'",
+            `created_at >= ${Math.max(0, this.sessionDetectStartSec)}`,
+        ];
+        if (this.hasExplicitSessionCwd) {
+            conditions.push(`cwd='${this.sessionCwd.replace(/'/g, "''")}'`);
+        }
+        const rows = await this.querySqliteRows(dbPath, `select id from threads where ${conditions.join(" and ")} order by created_at asc, id asc limit 256;`);
+        return rows
+            .map((row) => String(row || "").trim())
+            .filter(Boolean);
+    }
+    async collectClaudeSessionCandidates() {
+        const projectDir = (0, node_path_1.join)((0, node_os_1.homedir)(), ".claude", "projects", this.encodeClaudeProjectPath(this.sessionCwd));
+        if (!(await this.pathExists(projectDir))) {
+            return [];
+        }
+        const candidates = [];
+        const seenSessionIds = new Set();
+        const pushCandidate = async (sessionId, sessionFilePath) => {
+            const normalizedSessionId = String(sessionId || "").trim();
+            const normalizedSessionFilePath = String(sessionFilePath || "").trim();
+            if (!normalizedSessionId || !normalizedSessionFilePath || seenSessionIds.has(normalizedSessionId)) {
+                return;
+            }
+            if (!(await this.pathExists(normalizedSessionFilePath))) {
+                return;
+            }
+            seenSessionIds.add(normalizedSessionId);
+            candidates.push({
+                sessionId: normalizedSessionId,
+                sessionFilePath: normalizedSessionFilePath,
+            });
+        };
+        const indexPath = (0, node_path_1.join)(projectDir, "sessions-index.json");
+        if (await this.pathExists(indexPath)) {
+            try {
+                const raw = await node_fs_1.promises.readFile(indexPath, "utf8");
+                const parsed = JSON.parse(raw);
+                const entries = Array.isArray(parsed.entries) ? parsed.entries : [];
+                const candidates = entries
+                    .filter((entry) => {
+                    const entrySessionId = String(entry?.sessionId || "").trim();
+                    if (!entrySessionId) {
+                        return false;
+                    }
+                    const entryProjectPath = String(entry?.projectPath || "").trim();
+                    return !entryProjectPath || entryProjectPath === this.sessionCwd;
+                })
+                    .sort((a, b) => {
+                    const scoreA = Number(a?.fileMtime || Date.parse(String(a?.modified || "")) || 0);
+                    const scoreB = Number(b?.fileMtime || Date.parse(String(b?.modified || "")) || 0);
+                    return scoreB - scoreA;
+                });
+                for (const entry of candidates) {
+                    const sessionId = String(entry.sessionId || "").trim();
+                    const sessionFilePath = String(entry.fullPath || "").trim() || (0, node_path_1.join)(projectDir, `${sessionId}.jsonl`);
+                    await pushCandidate(sessionId, sessionFilePath);
+                }
+            }
+            catch (error) {
+                this.log(`claude session index parse failed: ${error?.message || error}`);
+            }
+        }
+        try {
+            const dirents = await node_fs_1.promises.readdir(projectDir, { withFileTypes: true });
+            const jsonlFiles = dirents
+                .filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl"))
+                .map((entry) => (0, node_path_1.join)(projectDir, entry.name));
+            const stats = await Promise.all(jsonlFiles.map(async (filePath) => ({
+                filePath,
+                mtimeMs: (await node_fs_1.promises.stat(filePath)).mtimeMs,
+            })));
+            stats.sort((a, b) => b.mtimeMs - a.mtimeMs);
+            for (const item of stats) {
+                await pushCandidate((0, node_path_1.basename)(item.filePath, ".jsonl"), item.filePath);
+            }
+        }
+        catch {
+            return candidates;
+        }
+        return candidates;
+    }
+    async captureClaudeSessionBaseline() {
+        return this.collectBaselineSessionIds(await this.collectClaudeSessionCandidates());
+    }
+    async detectClaudeSessionInfo() {
+        const candidates = await this.collectClaudeSessionCandidates();
+        return this.toSessionInfo("claude-code", this.pickSessionDiscoveryCandidate(candidates));
+    }
+    async collectCopilotSessionCandidates() {
+        const baseDir = (0, node_path_1.join)((0, node_os_1.homedir)(), ".copilot", "session-state");
+        if (!(await this.pathExists(baseDir))) {
+            return [];
+        }
+        try {
+            const dirents = await node_fs_1.promises.readdir(baseDir, { withFileTypes: true });
+            const candidates = [];
+            for (const entry of dirents) {
+                if (!entry.isDirectory()) {
+                    continue;
+                }
+                const sessionDir = (0, node_path_1.join)(baseDir, entry.name);
+                const workspacePath = (0, node_path_1.join)(sessionDir, "workspace.yaml");
+                const eventsPath = (0, node_path_1.join)(sessionDir, "events.jsonl");
+                if (!(await this.pathExists(eventsPath))) {
+                    continue;
+                }
+                let workspaceCwd = "";
+                let workspaceId = "";
+                if (await this.pathExists(workspacePath)) {
+                    workspaceCwd = (await this.readWorkspaceYamlValue(workspacePath, "cwd")) || "";
+                    workspaceId = (await this.readWorkspaceYamlValue(workspacePath, "id")) || "";
+                }
+                if (workspaceCwd && workspaceCwd !== this.sessionCwd) {
+                    continue;
+                }
+                const sessionId = workspaceId || entry.name;
+                const mtimeMs = (await node_fs_1.promises.stat(eventsPath)).mtimeMs;
+                candidates.push({
+                    sessionId,
+                    sessionFilePath: eventsPath,
+                    mtimeMs,
+                });
+            }
+            candidates.sort((a, b) => b.mtimeMs - a.mtimeMs);
+            return candidates.map((candidate) => ({
+                sessionId: candidate.sessionId,
+                sessionFilePath: candidate.sessionFilePath,
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    async captureCopilotSessionBaseline() {
+        return this.collectBaselineSessionIds(await this.collectCopilotSessionCandidates());
+    }
+    async detectCopilotSessionInfo() {
+        const candidates = await this.collectCopilotSessionCandidates();
+        return this.toSessionInfo("copilot", this.pickSessionDiscoveryCandidate(candidates));
+    }
+    async querySqliteRows(dbPath, query) {
+        try {
+            const { stdout } = await execFileAsync("sqlite3", [dbPath, query], {
+                timeout: 3000,
+                maxBuffer: 1024 * 1024,
+            });
+            return String(stdout || "")
+                .split(/\r?\n/)
+                .map((line) => line.trim())
+                .filter(Boolean);
+        }
+        catch (error) {
+            this.log(`sqlite query failed: ${error?.message || error}`);
+            return [];
+        }
+    }
+    async querySqliteRow(dbPath, query) {
+        const rows = await this.querySqliteRows(dbPath, query);
+        return rows[0] ?? null;
+    }
+    encodeClaudeProjectPath(cwd) {
+        return String(cwd || "").replace(/\//g, "-");
+    }
+    async readWorkspaceYamlValue(filePath, key) {
+        try {
+            const raw = await node_fs_1.promises.readFile(filePath, "utf8");
+            const matcher = new RegExp(`^${key}:\\s*(.+)\\s*$`, "m");
+            const match = raw.match(matcher);
+            if (!match) {
+                return null;
+            }
+            const value = match[1].trim();
+            if (!value) {
+                return null;
+            }
+            return value.replace(/^['"]|['"]$/g, "");
+        }
+        catch {
+            return null;
+        }
+    }
+    async pathExists(filePath) {
+        try {
+            await node_fs_1.promises.access(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async captureSessionFileCheckpoint(sessionInfo) {
+        if (!sessionInfo) {
+            return null;
+        }
+        const { size, mtimeMs } = await this.readSessionFileStat(sessionInfo.sessionFilePath);
+        return {
+            sessionInfo,
+            size,
+            mtimeMs,
+        };
+    }
+    requiresSessionFileCheckpointForTurn() {
+        const backend = String(this.profile.name || "").toLowerCase();
+        return backend === "codex" || backend === "copilot";
+    }
+    async resolveSessionFileCheckpointForTurn(initialSessionInfo) {
+        const immediate = await this.captureSessionFileCheckpoint(initialSessionInfo);
+        if (immediate || !this.requiresSessionFileCheckpointForTurn()) {
+            return immediate;
+        }
+        const startedAt = Date.now();
+        while (Date.now() - startedAt < DEFAULT_SESSION_CHECKPOINT_TIMEOUT_MS) {
+            this.assertAliveOrThrow();
+            const elapsed = Date.now() - startedAt;
+            const remainingMs = Math.max(MIN_STAGE_TIMEOUT_MS, DEFAULT_SESSION_CHECKPOINT_TIMEOUT_MS - elapsed);
+            const discovered = await this.ensureSessionInfo(Math.min(DEFAULT_SESSION_DISCOVERY_TIMEOUT_MS, remainingMs));
+            const checkpoint = await this.captureSessionFileCheckpoint(discovered);
+            if (checkpoint) {
+                return checkpoint;
+            }
+            await this.sleep(250);
+        }
+        return null;
+    }
+    async readSessionFileStat(sessionFilePath) {
+        try {
+            const stats = await node_fs_1.promises.stat(sessionFilePath);
+            return {
+                size: stats.size,
+                mtimeMs: stats.mtimeMs,
+            };
+        }
+        catch {
+            return {
+                size: 0,
+                mtimeMs: 0,
+            };
+        }
+    }
+    async waitForSessionFileGrowth(checkpoint) {
+        const timeoutMs = this.resolveTimeout(this.profile.timeouts?.streamStart, 10000);
+        const startedAt = Date.now();
+        let lastSize = checkpoint.size;
+        let lastMtimeMs = checkpoint.mtimeMs;
+        while (Date.now() - startedAt < timeoutMs) {
+            this.assertAliveOrThrow();
+            const current = await this.readSessionFileStat(checkpoint.sessionInfo.sessionFilePath);
+            const changed = current.size !== lastSize || current.mtimeMs !== lastMtimeMs;
+            if (changed) {
+                this.log(`session file growth detected: ${checkpoint.sessionInfo.sessionFilePath} (${lastSize} -> ${current.size})`);
+                return;
+            }
+            await this.sleep(DEFAULT_SESSION_POLL_INTERVAL_MS);
+        }
+        throw new Error("Stream start timeout: session file did not grow");
+    }
+    async waitForSessionFileIdle(checkpoint) {
+        const timeoutMs = this.resolveTimeout(this.profile.timeouts?.streamEnd, 120000);
+        const startedAt = Date.now();
+        let previousSize = checkpoint.size;
+        let previousMtimeMs = checkpoint.mtimeMs;
+        let observedProgress = false;
+        let unchangedChecks = 0;
+        const requireCompletionMarker = this.requiresSessionCompletionMarker(checkpoint.sessionInfo.backend);
+        const allowAssistantReplyFallback = this.supportsSessionAssistantReplyIdleFallback(checkpoint.sessionInfo.backend);
+        let completionMarkerSeen = false;
+        let assistantReplySeen = false;
+        while (Date.now() - startedAt < timeoutMs) {
+            this.assertAliveOrThrow();
+            const current = await this.readSessionFileStat(checkpoint.sessionInfo.sessionFilePath);
+            const changed = current.size !== previousSize || current.mtimeMs !== previousMtimeMs;
+            if (changed) {
+                this.log(`session file changed: backend=${checkpoint.sessionInfo.backend} size=${previousSize}->${current.size} mtime=${previousMtimeMs}->${current.mtimeMs}`);
+                observedProgress = true;
+                unchangedChecks = 0;
+                previousSize = current.size;
+                previousMtimeMs = current.mtimeMs;
+                if (requireCompletionMarker && !completionMarkerSeen) {
+                    completionMarkerSeen = await this.hasSessionCompletionMarker(checkpoint, current.size);
+                    if (completionMarkerSeen) {
+                        this.log(`session completion marker observed: backend=${checkpoint.sessionInfo.backend} file=${checkpoint.sessionInfo.sessionFilePath}`);
+                    }
+                }
+                if (allowAssistantReplyFallback && !assistantReplySeen) {
+                    assistantReplySeen = await this.hasSessionAssistantReply(checkpoint, current.size);
+                    if (assistantReplySeen) {
+                        this.log(`session assistant reply observed: backend=${checkpoint.sessionInfo.backend} file=${checkpoint.sessionInfo.sessionFilePath}`);
+                    }
+                }
+            }
+            else {
+                unchangedChecks += 1;
+                this.log(`session file unchanged: backend=${checkpoint.sessionInfo.backend} checks=${unchangedChecks} completionMarkerSeen=${completionMarkerSeen} assistantReplySeen=${assistantReplySeen}`);
+                if (observedProgress && unchangedChecks >= 2) {
+                    if (!requireCompletionMarker || completionMarkerSeen || assistantReplySeen) {
+                        this.log(`session file idle reached: backend=${checkpoint.sessionInfo.backend} checks=${unchangedChecks} completionMarkerSeen=${completionMarkerSeen} assistantReplySeen=${assistantReplySeen}`);
+                        return;
+                    }
+                }
+            }
+            await this.sleep(DEFAULT_SESSION_POLL_INTERVAL_MS);
+        }
+        if (!observedProgress) {
+            throw new Error("Stream end timeout: session file did not grow");
+        }
+        if (requireCompletionMarker && !completionMarkerSeen) {
+            if (allowAssistantReplyFallback) {
+                const assistantReplyAvailable = assistantReplySeen || (await this.hasSessionAssistantReply(checkpoint));
+                if (assistantReplyAvailable) {
+                    this.log(`session completion marker missing; falling back to assistant reply: backend=${checkpoint.sessionInfo.backend} file=${checkpoint.sessionInfo.sessionFilePath}`);
+                    return;
+                }
+            }
+            throw new Error("Stream end timeout: session completion marker not observed");
+        }
+        throw new Error("Stream end timeout: session file did not become stable");
+    }
+    async extractAnswerFromSessionFile(checkpoint) {
+        const lines = await this.readSessionFileJsonLines(checkpoint.sessionInfo.sessionFilePath, checkpoint.size);
+        const codexTaskCompleteMessage = this.extractCodexTaskCompleteMessageFromJsonLines(lines);
+        if (codexTaskCompleteMessage) {
+            this.log(`session answer source=codex.task_complete preview="${this.summarizeForLog(codexTaskCompleteMessage, 160)}"`);
+            return codexTaskCompleteMessage;
+        }
+        const answer = this.extractAssistantReplyFromJsonLines(lines, checkpoint.sessionInfo.backend);
+        if (answer) {
+            this.log(`session answer source=${checkpoint.sessionInfo.backend}.assistant preview="${this.summarizeForLog(answer, 160)}"`);
+            return answer;
+        }
+        throw new Error("No assistant reply found in session file");
+    }
+    extractSessionUsageSummaryFromJsonLines(lines, sessionInfo) {
+        const backend = sessionInfo.backend;
+        const baseSummary = {
+            backend,
+            sessionId: sessionInfo.sessionId,
+            sessionFilePath: sessionInfo.sessionFilePath,
+        };
+        const usage = backend === "codex"
+            ? this.extractCodexUsageFromJsonLines(lines)
+            : backend === "claude-code"
+                ? this.extractClaudeUsageFromJsonLines(lines)
+                : backend === "copilot"
+                    ? this.extractCopilotUsageFromJsonLines(lines)
+                    : {};
+        return {
+            ...baseSummary,
+            ...usage,
+        };
+    }
+    extractCodexUsageFromJsonLines(lines) {
+        let tokenUsagePercent;
+        let contextUsagePercent;
+        for (const line of lines) {
+            let entry = null;
+            try {
+                entry = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (!entry || entry.type !== "event_msg") {
+                continue;
+            }
+            const payload = entry.payload;
+            if (!payload || typeof payload !== "object") {
+                continue;
+            }
+            const secondaryUsedPercent = this.readNumberPath(payload, ["rate_limits", "secondary", "used_percent"]);
+            if (secondaryUsedPercent !== undefined) {
+                tokenUsagePercent = this.normalizePercent(secondaryUsedPercent);
+            }
+            const inputTokens = this.readNumberPath(payload, ["info", "last_token_usage", "input_tokens"]);
+            const contextWindow = this.readNumberPath(payload, ["info", "model_context_window"]);
+            if (inputTokens !== undefined && contextWindow !== undefined && contextWindow > 0) {
+                contextUsagePercent = this.normalizePercent((inputTokens / contextWindow) * 100);
+            }
+        }
+        return {
+            tokenUsagePercent,
+            contextUsagePercent,
+        };
+    }
+    extractClaudeUsageFromJsonLines(lines) {
+        let tokenUsagePercent;
+        let contextUsagePercent;
+        let latestInputTokens;
+        let latestContextWindow;
+        for (const line of lines) {
+            let entry = null;
+            try {
+                entry = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (!entry || typeof entry !== "object") {
+                continue;
+            }
+            const secondaryUsedPercent = this.readNumberPath(entry, ["rate_limits", "secondary", "used_percent"]) ??
+                this.readNumberPath(entry, ["rateLimits", "secondary", "usedPercent"]);
+            if (secondaryUsedPercent !== undefined) {
+                tokenUsagePercent = this.normalizePercent(secondaryUsedPercent);
+            }
+            const inputTokens = this.readNumberPath(entry, ["message", "usage", "input_tokens"]) ??
+                this.readNumberPath(entry, ["message", "usage", "inputTokens"]) ??
+                this.readNumberPath(entry, ["usage", "input_tokens"]) ??
+                this.readNumberPath(entry, ["usage", "inputTokens"]);
+            if (inputTokens !== undefined) {
+                latestInputTokens = inputTokens;
+            }
+            const contextWindow = this.readNumberPath(entry, ["message", "model_context_window"]) ??
+                this.readNumberPath(entry, ["message", "modelContextWindow"]) ??
+                this.readNumberPath(entry, ["message", "context_window"]) ??
+                this.readNumberPath(entry, ["message", "contextWindow"]) ??
+                this.readNumberPath(entry, ["model_context_window"]) ??
+                this.readNumberPath(entry, ["modelContextWindow"]) ??
+                this.readNumberPath(entry, ["context_window"]) ??
+                this.readNumberPath(entry, ["contextWindow"]);
+            if (contextWindow !== undefined && contextWindow > 0) {
+                latestContextWindow = contextWindow;
+            }
+        }
+        if (latestInputTokens !== undefined &&
+            latestContextWindow !== undefined &&
+            latestContextWindow > 0) {
+            contextUsagePercent = this.normalizePercent((latestInputTokens / latestContextWindow) * 100);
+        }
+        return {
+            tokenUsagePercent,
+            contextUsagePercent,
+        };
+    }
+    extractCopilotUsageFromJsonLines(lines) {
+        let tokenUsagePercent;
+        let contextUsagePercent;
+        let latestContextTokens;
+        let latestContextLimit;
+        for (const line of lines) {
+            let entry = null;
+            try {
+                entry = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (!entry || typeof entry !== "object") {
+                continue;
+            }
+            const secondaryUsedPercent = this.readNumberPath(entry, ["data", "rate_limits", "secondary", "used_percent"]) ??
+                this.readNumberPath(entry, ["data", "rateLimits", "secondary", "usedPercent"]) ??
+                this.readNumberPath(entry, ["rate_limits", "secondary", "used_percent"]) ??
+                this.readNumberPath(entry, ["rateLimits", "secondary", "usedPercent"]);
+            if (secondaryUsedPercent !== undefined) {
+                tokenUsagePercent = this.normalizePercent(secondaryUsedPercent);
+            }
+            const responseTokenLimit = this.readNumberPath(entry, ["data", "toolTelemetry", "metrics", "responseTokenLimit"]) ??
+                this.readNumberPath(entry, ["data", "responseTokenLimit"]) ??
+                this.readNumberPath(entry, ["data", "modelContextWindow"]) ??
+                this.readNumberPath(entry, ["data", "model_context_window"]) ??
+                this.readNumberPath(entry, ["data", "contextWindow"]) ??
+                this.readNumberPath(entry, ["data", "context_window"]) ??
+                this.readNumberPath(entry, ["responseTokenLimit"]);
+            if (responseTokenLimit !== undefined && responseTokenLimit > 0) {
+                latestContextLimit = responseTokenLimit;
+            }
+            const contextTokens = this.readNumberPath(entry, ["data", "preCompactionTokens"]) ??
+                this.readNumberPath(entry, ["data", "compactionTokensUsed", "input"]) ??
+                this.readNumberPath(entry, ["data", "postCompactionTokens"]) ??
+                this.readNumberPath(entry, ["data", "tokenUsage", "input_tokens"]) ??
+                this.readNumberPath(entry, ["data", "usage", "input_tokens"]) ??
+                this.readNumberPath(entry, ["data", "inputTokens"]);
+            if (contextTokens !== undefined && contextTokens >= 0) {
+                latestContextTokens = contextTokens;
+            }
+        }
+        if (latestContextTokens !== undefined &&
+            latestContextLimit !== undefined &&
+            latestContextLimit > 0) {
+            contextUsagePercent = this.normalizePercent((latestContextTokens / latestContextLimit) * 100);
+        }
+        return {
+            tokenUsagePercent,
+            contextUsagePercent,
+        };
+    }
+    readNumberPath(source, path) {
+        let cursor = source;
+        for (const key of path) {
+            if (!cursor || typeof cursor !== "object") {
+                return undefined;
+            }
+            cursor = cursor[key];
+        }
+        if (typeof cursor === "number" && Number.isFinite(cursor)) {
+            return cursor;
+        }
+        if (typeof cursor === "string") {
+            const parsed = Number(cursor);
+            if (Number.isFinite(parsed)) {
+                return parsed;
+            }
+        }
+        return undefined;
+    }
+    normalizePercent(value) {
+        if (!Number.isFinite(value)) {
+            return 0;
+        }
+        if (value < 0) {
+            return 0;
+        }
+        if (value > 100) {
+            return 100;
+        }
+        return value;
+    }
+    requiresSessionCompletionMarker(backend) {
+        return backend === "codex" || backend === "copilot";
+    }
+    supportsSessionAssistantReplyIdleFallback(backend) {
+        return backend === "codex";
+    }
+    async hasSessionCompletionMarker(checkpoint, endOffset) {
+        const lines = await this.readSessionFileJsonLines(checkpoint.sessionInfo.sessionFilePath, checkpoint.size, endOffset);
+        if (checkpoint.sessionInfo.backend === "codex") {
+            return this.hasCodexTaskCompleteFromJsonLines(lines);
+        }
+        if (checkpoint.sessionInfo.backend === "copilot") {
+            return this.hasCopilotTurnEndFromJsonLines(lines);
+        }
+        return false;
+    }
+    async readSessionFileJsonLines(sessionFilePath, startOffset = 0, endOffset) {
+        let fullBuffer;
+        try {
+            fullBuffer = await node_fs_1.promises.readFile(sessionFilePath);
+        }
+        catch {
+            return [];
+        }
+        const boundedStartOffset = Math.max(0, Math.min(startOffset, fullBuffer.length));
+        const boundedEndOffset = Number.isFinite(endOffset)
+            ? Math.max(boundedStartOffset, Math.min(Number(endOffset), fullBuffer.length))
+            : fullBuffer.length;
+        return fullBuffer
+            .subarray(boundedStartOffset, boundedEndOffset)
+            .toString("utf8")
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter(Boolean);
+    }
+    async readSessionFileLinesSince(sessionFilePath, startOffset = 0) {
+        let fullBuffer;
+        try {
+            fullBuffer = await node_fs_1.promises.readFile(sessionFilePath);
+        }
+        catch {
+            return {
+                lines: [],
+                nextOffset: Math.max(0, startOffset),
+                fileSize: 0,
+            };
+        }
+        const fileSize = fullBuffer.length;
+        const boundedStartOffset = Math.max(0, Math.min(startOffset, fileSize));
+        const pendingBuffer = fullBuffer.subarray(boundedStartOffset);
+        const lastNewlineIndex = pendingBuffer.lastIndexOf(0x0a);
+        if (lastNewlineIndex < 0) {
+            return {
+                lines: [],
+                nextOffset: boundedStartOffset,
+                fileSize,
+            };
+        }
+        const completedBuffer = pendingBuffer.subarray(0, lastNewlineIndex + 1);
+        const nextOffset = boundedStartOffset + completedBuffer.length;
+        const lines = completedBuffer
+            .toString("utf8")
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter(Boolean);
+        return {
+            lines,
+            nextOffset,
+            fileSize,
+        };
+    }
+    async hasSessionAssistantReply(checkpoint, endOffset) {
+        if (!this.supportsSessionAssistantReplyIdleFallback(checkpoint.sessionInfo.backend)) {
+            return false;
+        }
+        const lines = await this.readSessionFileJsonLines(checkpoint.sessionInfo.sessionFilePath, checkpoint.size, endOffset);
+        return Boolean(this.extractAssistantReplyFromJsonLines(lines, checkpoint.sessionInfo.backend));
+    }
+    extractAssistantReplyFromJsonLines(lines, backend) {
+        const replies = [];
+        for (const line of lines) {
+            let entry = null;
+            try {
+                entry = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (!entry || typeof entry !== "object") {
+                continue;
+            }
+            const text = backend === "codex"
+                ? this.extractCodexAssistantText(entry)
+                : backend === "claude-code"
+                    ? this.extractClaudeAssistantText(entry)
+                    : backend === "copilot"
+                        ? this.extractCopilotAssistantText(entry)
+                        : "";
+            if (text) {
+                replies.push(text);
+            }
+        }
+        return replies.length > 0 ? replies[replies.length - 1] : "";
+    }
+    extractAssistantMessagesFromJsonLines(lines, sessionInfo) {
+        const messages = [];
+        for (const line of lines) {
+            let entry = null;
+            try {
+                entry = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (!entry || typeof entry !== "object") {
+                continue;
+            }
+            const text = sessionInfo.backend === "codex"
+                ? this.extractCodexAssistantText(entry)
+                : sessionInfo.backend === "claude-code"
+                    ? this.extractClaudeAssistantText(entry)
+                    : sessionInfo.backend === "copilot"
+                        ? this.extractCopilotAssistantText(entry)
+                        : "";
+            if (!text) {
+                continue;
+            }
+            const timestampRaw = typeof entry.timestamp === "string" ? entry.timestamp.trim() : "";
+            messages.push({
+                backend: sessionInfo.backend,
+                sessionId: sessionInfo.sessionId,
+                sessionFilePath: sessionInfo.sessionFilePath,
+                text,
+                timestamp: timestampRaw || undefined,
+            });
+        }
+        return messages;
+    }
+    hasCodexTaskCompleteFromJsonLines(lines) {
+        for (const line of lines) {
+            let entry = null;
+            try {
+                entry = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (entry && this.isCodexTaskCompleteEntry(entry)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    hasCopilotTurnEndFromJsonLines(lines) {
+        let latestAssistantMessageIndex = -1;
+        let latestCompletedTurnEndIndex = -1;
+        for (let index = 0; index < lines.length; index += 1) {
+            const line = lines[index];
+            let entry = null;
+            try {
+                entry = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (!entry) {
+                continue;
+            }
+            if (this.isCopilotTurnStartEntry(entry) && latestCompletedTurnEndIndex >= 0) {
+                latestCompletedTurnEndIndex = -1;
+            }
+            const assistantText = this.extractCopilotAssistantText(entry);
+            if (assistantText) {
+                latestAssistantMessageIndex = index;
+            }
+            if (this.isCopilotTurnEndEntry(entry) &&
+                latestAssistantMessageIndex >= 0 &&
+                index > latestAssistantMessageIndex) {
+                latestCompletedTurnEndIndex = index;
+            }
+        }
+        return latestCompletedTurnEndIndex >= 0;
+    }
+    extractCodexTaskCompleteMessageFromJsonLines(lines) {
+        let latestMessage = "";
+        for (const line of lines) {
+            let entry = null;
+            try {
+                entry = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (!entry || !this.isCodexTaskCompleteEntry(entry)) {
+                continue;
+            }
+            const payload = entry.payload;
+            const message = typeof payload?.last_agent_message === "string" ? payload.last_agent_message.trim() : "";
+            if (message) {
+                latestMessage = message;
+            }
+        }
+        return latestMessage;
+    }
+    isCodexTaskCompleteEntry(entry) {
+        if (entry.type !== "event_msg") {
+            return false;
+        }
+        const payload = entry.payload;
+        return payload?.type === "task_complete";
+    }
+    isCopilotTurnStartEntry(entry) {
+        return entry.type === "assistant.turn_start";
+    }
+    isCopilotTurnEndEntry(entry) {
+        return entry.type === "assistant.turn_end";
+    }
+    summarizeForLog(value, maxLen = 160) {
+        const normalized = String(value || "").replace(/\s+/g, " ").trim();
+        if (!normalized) {
+            return "";
+        }
+        if (normalized.length <= maxLen) {
+            return normalized;
+        }
+        return `${normalized.slice(0, maxLen)}...`;
+    }
+    extractCodexAssistantText(entry) {
+        if (entry.type !== "response_item") {
+            return "";
+        }
+        const payload = entry.payload;
+        if (!payload || payload.type !== "message" || payload.role !== "assistant") {
+            return "";
+        }
+        const content = payload.content;
+        if (!Array.isArray(content)) {
+            return "";
+        }
+        const text = content
+            .map((part) => (typeof part?.text === "string" ? part.text : ""))
+            .filter(Boolean)
+            .join("\n")
+            .trim();
+        return text;
+    }
+    extractClaudeAssistantText(entry) {
+        if (entry.type !== "assistant") {
+            return "";
+        }
+        const message = entry.message;
+        if (!message || message.role !== "assistant") {
+            return "";
+        }
+        const content = message.content;
+        if (typeof content === "string") {
+            return content.trim();
+        }
+        if (!Array.isArray(content)) {
+            return "";
+        }
+        const text = content
+            .map((block) => {
+            const typed = block;
+            return typed?.type === "text" && typeof typed?.text === "string" ? typed.text : "";
+        })
+            .filter(Boolean)
+            .join("\n")
+            .trim();
+        return text;
+    }
+    extractCopilotAssistantText(entry) {
+        if (entry.type !== "assistant.message") {
+            return "";
+        }
+        const data = entry.data;
+        if (!data || typeof data.content !== "string") {
+            return "";
+        }
+        return data.content.trim();
+    }
     async waitStreamStart(previousSnapshot) {
         const timeout = this.resolveTimeout(this.profile.timeouts?.streamStart, 10000);
         if (this.profile.anchors.busy && this.profile.anchors.busy.length > 0) {
@@ -571,12 +1675,88 @@ class TuiDriver extends events_1.EventEmitter {
     }
     async restart() {
         this.log("Restarting PTY...");
+        const restartSession = await this.resolveRestartSessionInfo();
+        const restartArgs = this.resolveRestartArgs(restartSession?.sessionId);
+        if (restartSession?.sessionId) {
+            this.log(`restart resume target: backend=${this.profile.name} session=${restartSession.sessionId} args=${JSON.stringify(restartArgs)}`);
+        }
+        else {
+            this.log(`restart without resume: backend=${this.profile.name} args=${JSON.stringify(restartArgs)}`);
+        }
         this.pty.kill();
+        this.pty.setCommandArgs(this.initialCommand, restartArgs);
         this.screen.reset();
         this.isBooted = false;
         await this.sleep(500);
         await this.boot();
     }
+    async resolveRestartSessionInfo() {
+        const cached = this.sessionInfo ?? this.lastSessionInfo;
+        if (cached?.sessionId) {
+            return { ...cached };
+        }
+        if (!this.supportsSessionFileTracking()) {
+            return null;
+        }
+        const detected = await this.detectSessionInfoByBackend();
+        if (!detected?.sessionId) {
+            return null;
+        }
+        this.lastSessionInfo = detected;
+        return { ...detected };
+    }
+    resolveRestartArgs(sessionId) {
+        const normalizedSessionId = String(sessionId || "").trim();
+        if (!normalizedSessionId) {
+            return [...this.initialArgs];
+        }
+        const baseArgs = this.stripResumeArgs(this.initialArgs, this.profile.name);
+        const resumeArgs = this.buildResumeArgsForBackend(this.profile.name, normalizedSessionId);
+        if (resumeArgs.length === 0) {
+            return [...this.initialArgs];
+        }
+        return [...baseArgs, ...resumeArgs];
+    }
+    stripResumeArgs(args, backendName) {
+        const result = [];
+        const backend = String(backendName || "").toLowerCase();
+        for (let index = 0; index < args.length; index += 1) {
+            const current = String(args[index] || "");
+            const next = args[index + 1];
+            if (current === "--resume") {
+                index += 1;
+                continue;
+            }
+            if (current.startsWith("--resume=")) {
+                continue;
+            }
+            if ((backend === "codex" || backend === "code") && current === "resume") {
+                if (typeof next === "string" && next.length > 0) {
+                    index += 1;
+                }
+                continue;
+            }
+            result.push(current);
+        }
+        return result;
+    }
+    buildResumeArgsForBackend(backendName, sessionId) {
+        const normalizedBackend = String(backendName || "").toLowerCase();
+        const normalizedSessionId = String(sessionId || "").trim();
+        if (!normalizedSessionId) {
+            return [];
+        }
+        if (normalizedBackend === "codex" || normalizedBackend === "code") {
+            return ["resume", normalizedSessionId];
+        }
+        if (normalizedBackend === "claude-code" || normalizedBackend === "claude") {
+            return ["--resume", normalizedSessionId];
+        }
+        if (normalizedBackend === "copilot") {
+            return [`--resume=${normalizedSessionId}`];
+        }
+        return [];
+    }
     captureSnapshot(label) {
         const snapshot = this.screen.snapshot();
         if (this.onSnapshot) {
@@ -743,11 +1923,16 @@ class TuiDriver extends events_1.EventEmitter {
     async write(data) {
         this.pty.write(data);
     }
+    async forceRestart() {
+        await this.restart();
+    }
     kill() {
         this.isKilled = true;
         this.pty.kill();
         this.screen.dispose();
         this.isBooted = false;
+        this.sessionInfo = null;
+        this.lastSessionInfo = null;
     }
     createSessionClosedError() {
         const error = new Error("TUI session closed");
@@ -765,13 +1950,35 @@ class TuiDriver extends events_1.EventEmitter {
     terminateSessionForLoginRequired() {
         this.pty.kill();
         this.isBooted = false;
+        this.sessionInfo = null;
+        this.lastSessionInfo = null;
     }
     resolveTimeout(timeoutMs, defaultTimeoutMs) {
-        const value = timeoutMs ?? defaultTimeoutMs;
-        if (!Number.isFinite(value) || value <= 0) {
-            return Number.POSITIVE_INFINITY;
+        const fallback = this.normalizeTimeoutValue(defaultTimeoutMs, Math.max(MIN_STAGE_TIMEOUT_MS, defaultTimeoutMs));
+        return this.normalizeTimeoutValue(timeoutMs, fallback);
+    }
+    normalizeTimeoutValue(timeoutMs, fallback) {
+        const parsed = Number(timeoutMs);
+        if (!Number.isFinite(parsed)) {
+            return fallback;
         }
-        return value;
+        // `0` means "disable hard timeout" for long-running turns.
+        if (parsed === 0) {
+            return this.resolveMaxStageTimeoutMs();
+        }
+        if (parsed < 0) {
+            return fallback;
+        }
+        const bounded = Math.max(MIN_STAGE_TIMEOUT_MS, Math.round(parsed));
+        return Math.min(bounded, this.resolveMaxStageTimeoutMs());
+    }
+    resolveMaxStageTimeoutMs() {
+        const raw = process.env.CONDUCTOR_TUI_MAX_TIMEOUT_MS;
+        const parsed = Number.parseInt(String(raw || ""), 10);
+        if (!Number.isFinite(parsed) || parsed <= 0) {
+            return DEFAULT_STAGE_TIMEOUT_MAX_MS;
+        }
+        return Math.min(Math.max(parsed, MIN_STAGE_TIMEOUT_MS), ABSOLUTE_STAGE_TIMEOUT_MAX_MS);
     }
     async waitForScrollbackIdle(idleMs, timeoutMs, completionHint) {
         const startTime = Date.now();