@love-moon/tui-driver 0.2.13 → 0.2.14

package/dist/driver/TuiDriver.js

@@ -20,6 +20,7 @@ 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 {
@@ -35,6 +36,10 @@ class TuiDriver extends events_1.EventEmitter {
     isBooted = false;
     isKilled = false;
     sessionCwd;
+    hasExplicitSessionCwd;
+    expectedSessionId;
+    sessionDetectStartSec;
+    sessionDetectBaselineIds;
     sessionInfo = null;
     lastSessionInfo = null;
     sessionUsageCache = null;
@@ -47,7 +52,11 @@ 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;
@@ -141,6 +150,30 @@ class TuiDriver extends events_1.EventEmitter {
         };
         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();
@@ -150,6 +183,8 @@ class TuiDriver extends events_1.EventEmitter {
         }
         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);
@@ -320,7 +355,16 @@ class TuiDriver extends events_1.EventEmitter {
             await this.submit();
             // 在 submit 之后保存快照，这样 diff 只包含 AI 的回答，不包含 prompt
             const beforeSnapshot = this.captureSnapshot("after_submit");
-            const sessionCheckpoint = await this.captureSessionFileCheckpoint(sessionInfo);
+            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");
             if (sessionCheckpoint) {
                 await this.waitForSessionFileGrowth(sessionCheckpoint);
@@ -337,9 +381,13 @@ class TuiDriver extends events_1.EventEmitter {
             }
             this.stateMachine.transition("CAPTURE");
             const afterSnapshot = this.captureSnapshot("after_response");
-            const answer = sessionCheckpoint
-                ? await this.extractAnswerFromSessionFile(sessionCheckpoint)
-                : 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 {
@@ -440,6 +488,62 @@ class TuiDriver extends events_1.EventEmitter {
             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))) {
@@ -461,24 +565,75 @@ class TuiDriver extends events_1.EventEmitter {
                 sessionFilePath,
             };
         };
-        const pinnedSessionId = String(this.sessionInfo?.sessionId || this.lastSessionInfo?.sessionId || "").trim();
-        if (pinnedSessionId) {
-            const escapedSessionId = pinnedSessionId.replace(/'/g, "''");
+        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 escapedCwd = this.sessionCwd.replace(/'/g, "''");
-        const row = await this.querySqliteRow(dbPath, `select id, rollout_path from threads where source='cli' and model_provider='openai' and cwd='${escapedCwd}' order by updated_at desc limit 1;`);
+        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 detectClaudeSessionInfo() {
+    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 null;
+            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 {
@@ -502,13 +657,7 @@ class TuiDriver extends events_1.EventEmitter {
                 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`);
-                    if (sessionId && sessionFilePath && (await this.pathExists(sessionFilePath))) {
-                        return {
-                            backend: "claude-code",
-                            sessionId,
-                            sessionFilePath,
-                        };
-                    }
+                    await pushCandidate(sessionId, sessionFilePath);
                 }
             }
             catch (error) {
@@ -525,25 +674,26 @@ class TuiDriver extends events_1.EventEmitter {
                 mtimeMs: (await node_fs_1.promises.stat(filePath)).mtimeMs,
             })));
             stats.sort((a, b) => b.mtimeMs - a.mtimeMs);
-            const latest = stats[0];
-            if (!latest) {
-                return null;
+            for (const item of stats) {
+                await pushCandidate((0, node_path_1.basename)(item.filePath, ".jsonl"), item.filePath);
             }
-            const sessionId = (0, node_path_1.basename)(latest.filePath, ".jsonl");
-            return {
-                backend: "claude-code",
-                sessionId,
-                sessionFilePath: latest.filePath,
-            };
         }
         catch {
-            return null;
+            return candidates;
         }
+        return candidates;
     }
-    async detectCopilotSessionInfo() {
+    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 null;
+            return [];
         }
         try {
             const dirents = await node_fs_1.promises.readdir(baseDir, { withFileTypes: true });
@@ -576,37 +726,42 @@ class TuiDriver extends events_1.EventEmitter {
                 });
             }
             candidates.sort((a, b) => b.mtimeMs - a.mtimeMs);
-            const latest = candidates[0];
-            if (!latest) {
-                return null;
-            }
-            return {
-                backend: "copilot",
-                sessionId: latest.sessionId,
-                sessionFilePath: latest.sessionFilePath,
-            };
+            return candidates.map((candidate) => ({
+                sessionId: candidate.sessionId,
+                sessionFilePath: candidate.sessionFilePath,
+            }));
         }
         catch {
-            return null;
+            return [];
         }
     }
-    async querySqliteRow(dbPath, query) {
+    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,
             });
-            const lines = String(stdout || "")
+            return String(stdout || "")
                 .split(/\r?\n/)
                 .map((line) => line.trim())
                 .filter(Boolean);
-            return lines[0] ?? null;
         }
         catch (error) {
             this.log(`sqlite query failed: ${error?.message || error}`);
-            return null;
+            return [];
         }
     }
+    async querySqliteRow(dbPath, query) {
+        const rows = await this.querySqliteRows(dbPath, query);
+        return rows[0] ?? null;
+    }
     encodeClaudeProjectPath(cwd) {
         return String(cwd || "").replace(/\//g, "-");
     }
@@ -648,6 +803,29 @@ class TuiDriver extends events_1.EventEmitter {
             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);
@@ -688,7 +866,9 @@ class TuiDriver extends events_1.EventEmitter {
         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);
@@ -705,13 +885,19 @@ class TuiDriver extends events_1.EventEmitter {
                         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}`);
+                this.log(`session file unchanged: backend=${checkpoint.sessionInfo.backend} checks=${unchangedChecks} completionMarkerSeen=${completionMarkerSeen} assistantReplySeen=${assistantReplySeen}`);
                 if (observedProgress && unchangedChecks >= 2) {
-                    if (!requireCompletionMarker || completionMarkerSeen) {
-                        this.log(`session file idle reached: backend=${checkpoint.sessionInfo.backend} checks=${unchangedChecks} completionMarkerSeen=${completionMarkerSeen}`);
+                    if (!requireCompletionMarker || completionMarkerSeen || assistantReplySeen) {
+                        this.log(`session file idle reached: backend=${checkpoint.sessionInfo.backend} checks=${unchangedChecks} completionMarkerSeen=${completionMarkerSeen} assistantReplySeen=${assistantReplySeen}`);
                         return;
                     }
                 }
@@ -722,6 +908,13 @@ class TuiDriver extends events_1.EventEmitter {
             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");
@@ -929,6 +1122,9 @@ class TuiDriver extends events_1.EventEmitter {
     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") {
@@ -958,6 +1154,49 @@ class TuiDriver extends events_1.EventEmitter {
             .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) {
@@ -984,6 +1223,40 @@ class TuiDriver extends events_1.EventEmitter {
         }
         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;
@@ -1000,7 +1273,10 @@ class TuiDriver extends events_1.EventEmitter {
         return false;
     }
     hasCopilotTurnEndFromJsonLines(lines) {
-        for (const line of 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);
@@ -1008,11 +1284,23 @@ class TuiDriver extends events_1.EventEmitter {
             catch {
                 continue;
             }
-            if (entry && this.isCopilotTurnEndEntry(entry)) {
-                return true;
+            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 false;
+        return latestCompletedTurnEndIndex >= 0;
     }
     extractCodexTaskCompleteMessageFromJsonLines(lines) {
         let latestMessage = "";
@@ -1042,6 +1330,9 @@ class TuiDriver extends events_1.EventEmitter {
         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";
     }