@love-moon/tui-driver 0.2.13 → 0.2.14

package/src/driver/TuiDriver.ts

@@ -19,6 +19,7 @@ import type { TuiDriverBehavior } from "./behavior/index.js";
 export interface TuiDriverOptions {
   profile: TuiProfile;
   cwd?: string;
+  expectedSessionId?: string;
   debug?: boolean;
   onSnapshot?: (snapshot: ScreenSnapshot, state: TuiState) => void;
   onSignals?: (signals: TuiScreenSignals, snapshot: ScreenSnapshot, state: TuiState) => void;
@@ -81,12 +82,34 @@ export interface TuiSessionUsageSummary {
   contextUsagePercent?: number;
 }
 
+export interface TuiSessionAssistantMessage {
+  backend: string;
+  sessionId: string;
+  sessionFilePath: string;
+  text: string;
+  timestamp?: string;
+}
+
+export interface TuiSessionAssistantMessageBatch {
+  backend: string;
+  sessionId: string;
+  sessionFilePath: string;
+  nextOffset: number;
+  fileSize: number;
+  messages: TuiSessionAssistantMessage[];
+}
+
 interface SessionFileCheckpoint {
   sessionInfo: TuiSessionInfo;
   size: number;
   mtimeMs: number;
 }
 
+interface SessionDiscoveryCandidate {
+  sessionId: string;
+  sessionFilePath: string;
+}
+
 interface SessionUsageCacheEntry {
   backend: string;
   sessionId: string;
@@ -100,6 +123,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 = promisify(execFile);
@@ -117,6 +141,10 @@ export class TuiDriver extends EventEmitter {
   private isBooted = false;
   private isKilled = false;
   private sessionCwd: string;
+  private hasExplicitSessionCwd: boolean;
+  private expectedSessionId: string;
+  private sessionDetectStartSec: number;
+  private sessionDetectBaselineIds: string[];
   private sessionInfo: TuiSessionInfo | null = null;
   private lastSessionInfo: TuiSessionInfo | null = null;
   private sessionUsageCache: SessionUsageCacheEntry | null = null;
@@ -130,7 +158,11 @@ export class TuiDriver extends 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] : [];
 
@@ -250,6 +282,43 @@ export class TuiDriver extends EventEmitter {
     return { ...summary };
   }
 
+  async getSessionFileSize(sessionInfo?: TuiSessionInfo | null): Promise<number> {
+    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: TuiSessionInfo,
+    startOffset = 0,
+  ): Promise<TuiSessionAssistantMessageBatch> {
+    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(): Promise<void> {
     if (this.isKilled) {
       throw this.createSessionClosedError();
@@ -261,6 +330,8 @@ export class TuiDriver extends 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);
@@ -450,7 +521,16 @@ export class TuiDriver extends EventEmitter {
 
       // 在 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) {
@@ -469,9 +549,12 @@ export class TuiDriver extends 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");
@@ -584,6 +667,84 @@ export class TuiDriver extends EventEmitter {
     }
   }
 
+  private getPinnedSessionIds(): string[] {
+    return Array.from(
+      new Set(
+        [
+          this.expectedSessionId,
+          this.sessionInfo?.sessionId,
+          this.lastSessionInfo?.sessionId,
+        ]
+          .map((value) => String(value || "").trim())
+          .filter(Boolean),
+      ),
+    );
+  }
+
+  private toSessionInfo(
+    backend: TuiSessionInfo["backend"],
+    candidate: SessionDiscoveryCandidate | null,
+  ): TuiSessionInfo | null {
+    if (!candidate) {
+      return null;
+    }
+    return {
+      backend,
+      sessionId: candidate.sessionId,
+      sessionFilePath: candidate.sessionFilePath,
+    };
+  }
+
+  private pickSessionDiscoveryCandidate(
+    candidates: SessionDiscoveryCandidate[],
+  ): SessionDiscoveryCandidate | null {
+    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;
+  }
+
+  private collectBaselineSessionIds(candidates: SessionDiscoveryCandidate[]): string[] {
+    return Array.from(
+      new Set(
+        candidates
+          .map((candidate) => String(candidate.sessionId || "").trim())
+          .filter(Boolean),
+      ),
+    ).slice(0, 256);
+  }
+
+  private async captureSessionBaseline(): Promise<string[]> {
+    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 [];
+    }
+  }
+
   private async detectCodexSessionInfo(): Promise<TuiSessionInfo | null> {
     const dbPath = join(homedir(), ".codex", "state_5.sqlite");
     if (!(await this.pathExists(dbPath))) {
@@ -607,9 +768,10 @@ export class TuiDriver extends EventEmitter {
       };
     };
 
-    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;`,
@@ -620,15 +782,59 @@ export class TuiDriver extends EventEmitter {
       }
     }
 
-    const escapedCwd = this.sessionCwd.replace(/'/g, "''");
+    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 source='cli' and model_provider='openai' and cwd='${escapedCwd}' order by updated_at desc limit 1;`,
+      `select id, rollout_path from threads where ${conditions.join(
+        " and ",
+      )} order by created_at asc, id asc limit 1;`,
     );
     return parseRowAsSessionInfo(row);
   }
 
-  private async detectClaudeSessionInfo(): Promise<TuiSessionInfo | null> {
+  private async captureCodexSessionBaseline(): Promise<string[]> {
+    if (String(this.profile.name || "").toLowerCase() !== "codex") {
+      return [];
+    }
+
+    const dbPath = join(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);
+  }
+
+  private async collectClaudeSessionCandidates(): Promise<SessionDiscoveryCandidate[]> {
     const projectDir = join(
       homedir(),
       ".claude",
@@ -636,9 +842,27 @@ export class TuiDriver extends EventEmitter {
       this.encodeClaudeProjectPath(this.sessionCwd),
     );
     if (!(await this.pathExists(projectDir))) {
-      return null;
+      return [];
     }
 
+    const candidates: SessionDiscoveryCandidate[] = [];
+    const seenSessionIds = new Set<string>();
+    const pushCandidate = async (sessionId: string, sessionFilePath: string) => {
+      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 = join(projectDir, "sessions-index.json");
     if (await this.pathExists(indexPath)) {
       try {
@@ -671,13 +895,7 @@ export class TuiDriver extends EventEmitter {
         for (const entry of candidates) {
           const sessionId = String(entry.sessionId || "").trim();
           const sessionFilePath = String(entry.fullPath || "").trim() || join(projectDir, `${sessionId}.jsonl`);
-          if (sessionId && sessionFilePath && (await this.pathExists(sessionFilePath))) {
-            return {
-              backend: "claude-code",
-              sessionId,
-              sessionFilePath,
-            };
-          }
+          await pushCandidate(sessionId, sessionFilePath);
         }
       } catch (error) {
         this.log(`claude session index parse failed: ${(error as Error)?.message || error}`);
@@ -696,25 +914,29 @@ export class TuiDriver extends EventEmitter {
         })),
       );
       stats.sort((a, b) => b.mtimeMs - a.mtimeMs);
-      const latest = stats[0];
-      if (!latest) {
-        return null;
+      for (const item of stats) {
+        await pushCandidate(basename(item.filePath, ".jsonl"), item.filePath);
       }
-      const sessionId = basename(latest.filePath, ".jsonl");
-      return {
-        backend: "claude-code",
-        sessionId,
-        sessionFilePath: latest.filePath,
-      };
     } catch {
-      return null;
+      return candidates;
     }
+
+    return candidates;
   }
 
-  private async detectCopilotSessionInfo(): Promise<TuiSessionInfo | null> {
+  private async captureClaudeSessionBaseline(): Promise<string[]> {
+    return this.collectBaselineSessionIds(await this.collectClaudeSessionCandidates());
+  }
+
+  private async detectClaudeSessionInfo(): Promise<TuiSessionInfo | null> {
+    const candidates = await this.collectClaudeSessionCandidates();
+    return this.toSessionInfo("claude-code", this.pickSessionDiscoveryCandidate(candidates));
+  }
+
+  private async collectCopilotSessionCandidates(): Promise<SessionDiscoveryCandidate[]> {
     const baseDir = join(homedir(), ".copilot", "session-state");
     if (!(await this.pathExists(baseDir))) {
-      return null;
+      return [];
     }
 
     try {
@@ -753,37 +975,45 @@ export class TuiDriver extends 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 [];
     }
   }
 
-  private async querySqliteRow(dbPath: string, query: string): Promise<string | null> {
+  private async captureCopilotSessionBaseline(): Promise<string[]> {
+    return this.collectBaselineSessionIds(await this.collectCopilotSessionCandidates());
+  }
+
+  private async detectCopilotSessionInfo(): Promise<TuiSessionInfo | null> {
+    const candidates = await this.collectCopilotSessionCandidates();
+    return this.toSessionInfo("copilot", this.pickSessionDiscoveryCandidate(candidates));
+  }
+
+  private async querySqliteRows(dbPath: string, query: string): Promise<string[]> {
     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 as Error)?.message || error}`);
-      return null;
+      return [];
     }
   }
 
+  private async querySqliteRow(dbPath: string, query: string): Promise<string | null> {
+    const rows = await this.querySqliteRows(dbPath, query);
+    return rows[0] ?? null;
+  }
+
   private encodeClaudeProjectPath(cwd: string): string {
     return String(cwd || "").replace(/\//g, "-");
   }
@@ -829,6 +1059,40 @@ export class TuiDriver extends EventEmitter {
     };
   }
 
+  private requiresSessionFileCheckpointForTurn(): boolean {
+    const backend = String(this.profile.name || "").toLowerCase();
+    return backend === "codex" || backend === "copilot";
+  }
+
+  private async resolveSessionFileCheckpointForTurn(
+    initialSessionInfo: TuiSessionInfo | null,
+  ): Promise<SessionFileCheckpoint | null> {
+    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;
+  }
+
   private async readSessionFileStat(
     sessionFilePath: string,
   ): Promise<{ size: number; mtimeMs: number }> {
@@ -876,7 +1140,11 @@ export class TuiDriver extends 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();
@@ -898,15 +1166,23 @@ export class TuiDriver extends EventEmitter {
             );
           }
         }
+        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}`,
+          `session file unchanged: backend=${checkpoint.sessionInfo.backend} checks=${unchangedChecks} completionMarkerSeen=${completionMarkerSeen} assistantReplySeen=${assistantReplySeen}`,
         );
         if (observedProgress && unchangedChecks >= 2) {
-          if (!requireCompletionMarker || completionMarkerSeen) {
+          if (!requireCompletionMarker || completionMarkerSeen || assistantReplySeen) {
             this.log(
-              `session file idle reached: backend=${checkpoint.sessionInfo.backend} checks=${unchangedChecks} completionMarkerSeen=${completionMarkerSeen}`,
+              `session file idle reached: backend=${checkpoint.sessionInfo.backend} checks=${unchangedChecks} completionMarkerSeen=${completionMarkerSeen} assistantReplySeen=${assistantReplySeen}`,
             );
             return;
           }
@@ -919,6 +1195,16 @@ export class TuiDriver extends 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");
@@ -1177,6 +1463,10 @@ export class TuiDriver extends EventEmitter {
     return backend === "codex" || backend === "copilot";
   }
 
+  private supportsSessionAssistantReplyIdleFallback(backend: string): boolean {
+    return backend === "codex";
+  }
+
   private async hasSessionCompletionMarker(
     checkpoint: SessionFileCheckpoint,
     endOffset?: number,
@@ -1218,6 +1508,63 @@ export class TuiDriver extends EventEmitter {
       .filter(Boolean);
   }
 
+  private async readSessionFileLinesSince(
+    sessionFilePath: string,
+    startOffset = 0,
+  ): Promise<{ lines: string[]; nextOffset: number; fileSize: number }> {
+    let fullBuffer: Buffer;
+    try {
+      fullBuffer = await fs.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,
+    };
+  }
+
+  private async hasSessionAssistantReply(
+    checkpoint: SessionFileCheckpoint,
+    endOffset?: number,
+  ): Promise<boolean> {
+    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));
+  }
+
   private extractAssistantReplyFromJsonLines(lines: string[], backend: string): string {
     const replies: string[] = [];
 
@@ -1248,6 +1595,48 @@ export class TuiDriver extends EventEmitter {
     return replies.length > 0 ? replies[replies.length - 1] : "";
   }
 
+  private extractAssistantMessagesFromJsonLines(
+    lines: string[],
+    sessionInfo: TuiSessionInfo,
+  ): TuiSessionAssistantMessage[] {
+    const messages: TuiSessionAssistantMessage[] = [];
+
+    for (const line of lines) {
+      let entry: Record<string, unknown> | null = null;
+      try {
+        entry = JSON.parse(line) as Record<string, unknown>;
+      } 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;
+  }
+
   private hasCodexTaskCompleteFromJsonLines(lines: string[]): boolean {
     for (const line of lines) {
       let entry: Record<string, unknown> | null = null;
@@ -1264,18 +1653,39 @@ export class TuiDriver extends EventEmitter {
   }
 
   private hasCopilotTurnEndFromJsonLines(lines: string[]): boolean {
-    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: Record<string, unknown> | null = null;
       try {
         entry = JSON.parse(line) as Record<string, unknown>;
       } 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;
   }
 
   private extractCodexTaskCompleteMessageFromJsonLines(lines: string[]): string {
@@ -1307,6 +1717,10 @@ export class TuiDriver extends EventEmitter {
     return payload?.type === "task_complete";
   }
 
+  private isCopilotTurnStartEntry(entry: Record<string, unknown>): boolean {
+    return entry.type === "assistant.turn_start";
+  }
+
   private isCopilotTurnEndEntry(entry: Record<string, unknown>): boolean {
     return entry.type === "assistant.turn_end";
   }