@love-moon/tui-driver 0.2.13 → 0.2.14

package/src/driver/index.ts

@@ -5,8 +5,13 @@ export {
   TuiScreenSignals,
   HealthStatus,
   HealthReason,
+  TuiSessionAssistantMessage,
+  TuiSessionAssistantMessageBatch,
+} from "./TuiDriver.js";
+export type {
+  TuiSessionInfo,
+  TuiSessionUsageSummary,
 } from "./TuiDriver.js";
-export type { TuiSessionInfo, TuiSessionUsageSummary } from "./TuiDriver.js";
 export { TuiProfile, TuiProfileName, TuiAnchors, TuiKeys, TuiExtraction, TuiSignals, createProfile } from "./TuiProfile.js";
 export { StateMachine, TuiState, StateTransition } from "./StateMachine.js";
 export { claudeCodeProfile, codexProfile, copilotProfile } from "./profiles/index.js";

package/src/driver/profiles/copilot.profile.ts

@@ -19,18 +19,18 @@ export const copilotProfile: TuiProfile = createProfile({
 
   anchors: {
     ready: [
-      /^(?![\s\S]*Thinking \(Esc to cancel)(?=[\s\S]*(?:^|\n)❯\s+)(?=[\s\S]*Remaining reqs\.:)[\s\S]*$/,
-      /^(?![\s\S]*Thinking \(Esc to cancel)(?=[\s\S]*(?:^|\n)Start of Prompt Indicator\b)(?=[\s\S]*Remaining reqs\.:)[\s\S]*$/i,
-      /^(?![\s\S]*Thinking \(Esc to cancel)(?=[\s\S]*(?:^|\n)❯\s+)[\s\S]*$/,
-      /^(?![\s\S]*Thinking \(Esc to cancel)(?=[\s\S]*(?:^|\n)Start of Prompt Indicator\b)[\s\S]*$/i,
+      /^(?![\s\S]*(?:^|\n)\s*[∙◉◎◐◑◒◓◔◕●○•◦]\s*.+\(Esc to cancel(?:\s*·.*)?\))(?=[\s\S]*(?:^|\n)❯\s+)(?=[\s\S]*Remaining reqs\.:)[\s\S]*$/,
+      /^(?![\s\S]*(?:^|\n)\s*[∙◉◎◐◑◒◓◔◕●○•◦]\s*.+\(Esc to cancel(?:\s*·.*)?\))(?=[\s\S]*(?:^|\n)Start of Prompt Indicator\b)(?=[\s\S]*Remaining reqs\.:)[\s\S]*$/i,
+      /^(?![\s\S]*(?:^|\n)\s*[∙◉◎◐◑◒◓◔◕●○•◦]\s*.+\(Esc to cancel(?:\s*·.*)?\))(?=[\s\S]*(?:^|\n)❯\s+)[\s\S]*$/,
+      /^(?![\s\S]*(?:^|\n)\s*[∙◉◎◐◑◒◓◔◕●○•◦]\s*.+\(Esc to cancel(?:\s*·.*)?\))(?=[\s\S]*(?:^|\n)Start of Prompt Indicator\b)[\s\S]*$/i,
     ],
     trust: [
       /Remember screen reader mode/i,
       /Do you want to remember screen reader mode/i,
     ],
     busy: [
-      /^\s*[∙◉◎]\s*Thinking \(Esc to cancel(?:\s*·.*)?\)\s*$/m,
-      /^\s*Thinking \(Esc to cancel(?:\s*·.*)?\)\s*$/m,
+      /^\s*[∙◉◎◐◑◒◓◔◕●○•◦]\s*.+\(Esc to cancel(?:\s*·.*)?\)\s*$/m,
+      /^\s*.+\(Esc to cancel(?:\s*·.*)?\)\s*$/m,
     ],
     error: [
       /^Error:/m,
@@ -78,8 +78,8 @@ export const copilotProfile: TuiProfile = createProfile({
       /^\s*●\s*/gm,
       /^Copilot said:\s*/gim,
       /^You said:\s*/gim,
-      /^\s*[∙◉◎]\s*Thinking \(Esc to cancel(?:\s*·.*)?\)\s*$/gm,
-      /^\s*Thinking \(Esc to cancel(?:\s*·.*)?\)\s*$/gm,
+      /^\s*[∙◉◎◐◑◒◓◔◕●○•◦]\s*.+\(Esc to cancel(?:\s*·.*)?\)\s*$/gm,
+      /^\s*.+\(Esc to cancel(?:\s*·.*)?\)\s*$/gm,
       /^[-─]{10,}\s*$/gm,
       /^\s*shift\+tab switch mode.*$/gim,
       /^\s*Remaining reqs\.:.*$/gim,
@@ -95,8 +95,8 @@ export const copilotProfile: TuiProfile = createProfile({
     replyStart: [/^\s*●\s+/m, /^Copilot said:\s*/i],
     replyStop: [/^❯\s+/m, /^Start of Prompt Indicator\b/i],
     status: [
-      /^\s*[∙◉◎]\s*Thinking \(Esc to cancel(?:\s*·.*)?\)\s*$/m,
-      /^\s*Thinking \(Esc to cancel(?:\s*·.*)?\)\s*$/m,
+      /^\s*[∙◉◎◐◑◒◓◔◕●○•◦]\s*.+\(Esc to cancel(?:\s*·.*)?\)\s*$/m,
+      /^\s*.+\(Esc to cancel(?:\s*·.*)?\)\s*$/m,
     ],
   },
 

package/src/index.ts

@@ -30,6 +30,8 @@ export {
   TuiScreenSignals,
   HealthStatus,
   HealthReason,
+  TuiSessionAssistantMessage,
+  TuiSessionAssistantMessageBatch,
   defaultTuiDriverBehavior,
   claudeBehavior,
   copilotBehavior,

package/test/backend-session-discovery.test.ts

@@ -0,0 +1,134 @@
+import { promises as fs } from "node:fs";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { TuiDriver } from "../src/driver/TuiDriver.js";
+import { claudeCodeProfile } from "../src/driver/profiles/claudeCode.profile.js";
+import { copilotProfile } from "../src/driver/profiles/copilot.profile.js";
+
+function createDirent(name: string, isDirectory: boolean) {
+  return {
+    name,
+    isDirectory: () => isDirectory,
+    isFile: () => !isDirectory,
+  };
+}
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("backend session discovery", () => {
+  it("captures claude baseline session ids from the current workspace", async () => {
+    const driver = new TuiDriver({
+      profile: claudeCodeProfile,
+      cwd: "/tmp/claude-workspace",
+    });
+
+    vi.spyOn(driver as any, "pathExists").mockResolvedValue(true);
+    vi.spyOn(fs, "readFile").mockResolvedValue(
+      JSON.stringify({
+        entries: [
+          {
+            sessionId: "session-existing",
+            fullPath: "/tmp/claude-existing.jsonl",
+            fileMtime: 200,
+            projectPath: "/tmp/claude-workspace",
+          },
+          {
+            sessionId: "session-other",
+            fullPath: "/tmp/claude-other.jsonl",
+            fileMtime: 100,
+            projectPath: "/tmp/claude-workspace",
+          },
+        ],
+      }) as any,
+    );
+    vi.spyOn(fs, "readdir").mockResolvedValue([] as any);
+
+    const baselineIds = await (driver as any).captureSessionBaseline();
+
+    expect(baselineIds).toEqual(["session-existing", "session-other"]);
+    driver.kill();
+  });
+
+  it("skips claude baseline sessions and picks the next fresh session", async () => {
+    const driver = new TuiDriver({
+      profile: claudeCodeProfile,
+      cwd: "/tmp/claude-workspace",
+    });
+    (driver as any).sessionDetectBaselineIds = ["session-existing"];
+
+    vi.spyOn(driver as any, "pathExists").mockResolvedValue(true);
+    vi.spyOn(fs, "readFile").mockResolvedValue(
+      JSON.stringify({
+        entries: [
+          {
+            sessionId: "session-existing",
+            fullPath: "/tmp/claude-existing.jsonl",
+            fileMtime: 200,
+            projectPath: "/tmp/claude-workspace",
+          },
+          {
+            sessionId: "session-new",
+            fullPath: "/tmp/claude-new.jsonl",
+            fileMtime: 100,
+            projectPath: "/tmp/claude-workspace",
+          },
+        ],
+      }) as any,
+    );
+    vi.spyOn(fs, "readdir").mockResolvedValue([] as any);
+
+    const detected = await (driver as any).detectClaudeSessionInfo();
+
+    expect(detected).toEqual({
+      backend: "claude-code",
+      sessionId: "session-new",
+      sessionFilePath: "/tmp/claude-new.jsonl",
+    });
+    driver.kill();
+  });
+
+  it("prefers pinned copilot session id before the latest workspace session", async () => {
+    const driver = new TuiDriver({
+      profile: copilotProfile,
+      cwd: "/tmp/copilot-workspace",
+    });
+    (driver as any).lastSessionInfo = {
+      backend: "copilot",
+      sessionId: "session-pinned",
+      sessionFilePath: "/tmp/pinned/events.jsonl",
+    };
+
+    vi.spyOn(driver as any, "pathExists").mockResolvedValue(true);
+    vi.spyOn(driver as any, "readWorkspaceYamlValue").mockImplementation(
+      async (filePath: string, key: string) => {
+        if (filePath.includes("/latest/")) {
+          return key === "cwd" ? "/tmp/copilot-workspace" : "session-latest";
+        }
+        if (filePath.includes("/pinned/")) {
+          return key === "cwd" ? "/tmp/copilot-workspace" : "session-pinned";
+        }
+        return "";
+      },
+    );
+    vi.spyOn(fs, "readdir").mockResolvedValue([
+      createDirent("latest", true),
+      createDirent("pinned", true),
+    ] as any);
+    vi.spyOn(fs, "stat").mockImplementation(async (filePath: any) => {
+      const target = String(filePath || "");
+      return {
+        mtimeMs: target.includes("/latest/") ? 300 : 100,
+      } as any;
+    });
+
+    const detected = await (driver as any).detectCopilotSessionInfo();
+
+    expect(detected).toEqual({
+      backend: "copilot",
+      sessionId: "session-pinned",
+      sessionFilePath: expect.stringContaining("/pinned/events.jsonl"),
+    });
+    driver.kill();
+  });
+});

package/test/codex-session-discovery.test.ts

@@ -3,12 +3,14 @@ import { TuiDriver } from "../src/driver/TuiDriver.js";
 import { codexProfile } from "../src/driver/profiles/codex.profile.js";
 
 describe("codex session discovery", () => {
-  it("returns session info when current cwd has a matching codex thread", async () => {
+  it("returns session info when current cwd has a new codex thread after boot", async () => {
     const rolloutPath = "/tmp/rollout-current.jsonl";
     const driver = new TuiDriver({
       profile: codexProfile,
       cwd: "/tmp/current-workspace",
     });
+    (driver as any).sessionDetectStartSec = 100;
+    (driver as any).sessionDetectBaselineIds = [];
 
     (driver as any).pathExists = vi.fn(async (filePath: string) => {
       return filePath.endsWith("state_5.sqlite") || filePath === rolloutPath;
@@ -28,6 +30,8 @@ describe("codex session discovery", () => {
       profile: codexProfile,
       cwd: "/tmp/task-workspace",
     });
+    (driver as any).sessionDetectStartSec = 100;
+    (driver as any).sessionDetectBaselineIds = [];
 
     (driver as any).pathExists = vi.fn(async (filePath: string) => filePath.endsWith("state_5.sqlite"));
     const querySqliteRow = vi.fn(async () => null);
@@ -36,6 +40,7 @@ describe("codex session discovery", () => {
     const detected = await (driver as any).detectCodexSessionInfo();
     expect(detected).toBeNull();
     expect(querySqliteRow).toHaveBeenCalledTimes(1);
+    expect(String(querySqliteRow.mock.calls[0]?.[1] || "")).toContain("created_at >= 100");
     expect(String(querySqliteRow.mock.calls[0]?.[1] || "")).toContain("cwd='/tmp/task-workspace'");
   });
 
@@ -45,6 +50,8 @@ describe("codex session discovery", () => {
       profile: codexProfile,
       cwd: "/tmp/task-workspace",
     });
+    (driver as any).sessionDetectStartSec = 100;
+    (driver as any).sessionDetectBaselineIds = [];
 
     (driver as any).lastSessionInfo = {
       backend: "codex",
@@ -67,12 +74,14 @@ describe("codex session discovery", () => {
     expect(String(querySqliteRow.mock.calls[0]?.[1] || "")).toContain("id='session-pinned'");
   });
 
-  it("falls back to cwd lookup when pinned session id is missing", async () => {
-    const cwdPath = "/tmp/rollout-cwd.jsonl";
+  it("falls back to launch-window lookup when pinned session id is missing", async () => {
+    const launchPath = "/tmp/rollout-launch.jsonl";
     const driver = new TuiDriver({
       profile: codexProfile,
       cwd: "/tmp/task-workspace",
     });
+    (driver as any).sessionDetectStartSec = 100;
+    (driver as any).sessionDetectBaselineIds = ["session-existing"];
 
     (driver as any).lastSessionInfo = {
       backend: "codex",
@@ -80,22 +89,24 @@ describe("codex session discovery", () => {
       sessionFilePath: "/tmp/missing.jsonl",
     };
     (driver as any).pathExists = vi.fn(async (filePath: string) => {
-      return filePath.endsWith("state_5.sqlite") || filePath === cwdPath;
+      return filePath.endsWith("state_5.sqlite") || filePath === launchPath;
     });
     const querySqliteRow = vi
       .fn(async () => null)
       .mockImplementationOnce(async () => null)
-      .mockImplementationOnce(async () => `session-cwd|${cwdPath}`);
+      .mockImplementationOnce(async () => `session-new|${launchPath}`);
     (driver as any).querySqliteRow = querySqliteRow;
 
     const detected = await (driver as any).detectCodexSessionInfo();
     expect(detected).toEqual({
       backend: "codex",
-      sessionId: "session-cwd",
-      sessionFilePath: cwdPath,
+      sessionId: "session-new",
+      sessionFilePath: launchPath,
     });
     expect(querySqliteRow).toHaveBeenCalledTimes(2);
     expect(String(querySqliteRow.mock.calls[0]?.[1] || "")).toContain("id='session-missing'");
+    expect(String(querySqliteRow.mock.calls[1]?.[1] || "")).toContain("created_at >= 100");
     expect(String(querySqliteRow.mock.calls[1]?.[1] || "")).toContain("cwd='/tmp/task-workspace'");
+    expect(String(querySqliteRow.mock.calls[1]?.[1] || "")).toContain("id not in ('session-existing')");
   });
 });

package/test/copilot-profile.test.ts

@@ -68,6 +68,18 @@ describe("copilot profile busy and reply signals", () => {
     expect(statusMatcher(snapshot)).toBe(true);
   });
 
+  it("matches busy/status lines for non-thinking Esc-to-cancel states", () => {
+    const snapshot = createSnapshot([
+      "◐ Preparing parallel timer and intent report (Esc to cancel · 198 B)",
+      "◎ Running timer (Esc to cancel · 202 B)",
+    ].join("\n"));
+
+    const busyMatcher = Matchers.anyOf(copilotProfile.anchors.busy ?? []);
+    const statusMatcher = Matchers.anyOf(copilotProfile.signals?.status ?? []);
+    expect(busyMatcher(snapshot)).toBe(true);
+    expect(statusMatcher(snapshot)).toBe(true);
+  });
+
   it("matches assistant reply starts in non-screen-reader and screen-reader modes", () => {
     const snapshot = createSnapshot([
       "● Hello! I'm GitHub Copilot CLI.",

package/test/copilot-signals.test.ts

@@ -33,6 +33,20 @@ describe("copilot getSignals current-turn scope", () => {
     driver.kill();
   });
 
+  it("captures Running status lines with Esc-to-cancel prefixes", () => {
+    const driver = new TuiDriver({ profile: copilotProfile });
+    const snapshot = createSnapshot([
+      "You said: start timer",
+      "◎ Running timer (Esc to cancel · 202 B)",
+      "❯  Type @ to mention files, / for commands, or ? for shortcuts",
+    ].join("\n"));
+
+    const signals = driver.getSignals(snapshot);
+    expect(signals.statusLine).toBe("◎ Running timer (Esc to cancel · 202 B)");
+
+    driver.kill();
+  });
+
   it("captures reply from the latest turn when using You said markers", () => {
     const driver = new TuiDriver({ profile: copilotProfile });
     const snapshot = createSnapshot([

package/test/session-file-extraction.test.ts

@@ -1,4 +1,7 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, vi } from "vitest";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
 import { TuiDriver } from "../src/driver/TuiDriver.js";
 import { claudeCodeProfile } from "../src/driver/profiles/claudeCode.profile.js";
 import { codexProfile } from "../src/driver/profiles/codex.profile.js";
@@ -77,6 +80,74 @@ describe("session file reply extraction", () => {
     driver.kill();
   });
 
+  it("does not treat copilot turn_end as completed when a follow-up turn starts", () => {
+    const driver = new TuiDriver({ profile: codexProfile });
+    const lines = [
+      JSON.stringify({
+        type: "assistant.message",
+        data: {
+          content: "first reply",
+        },
+      }),
+      JSON.stringify({
+        type: "assistant.turn_end",
+        data: {
+          turnId: "0",
+        },
+      }),
+      JSON.stringify({
+        type: "assistant.turn_start",
+        data: {
+          turnId: "1",
+        },
+      }),
+    ];
+
+    const detected = (driver as any).hasCopilotTurnEndFromJsonLines(lines);
+    expect(detected).toBe(false);
+    driver.kill();
+  });
+
+  it("detects final copilot completion when follow-up turn produces assistant text", () => {
+    const driver = new TuiDriver({ profile: codexProfile });
+    const lines = [
+      JSON.stringify({
+        type: "assistant.message",
+        data: {
+          content: "",
+        },
+      }),
+      JSON.stringify({
+        type: "assistant.turn_end",
+        data: {
+          turnId: "0",
+        },
+      }),
+      JSON.stringify({
+        type: "assistant.turn_start",
+        data: {
+          turnId: "1",
+        },
+      }),
+      JSON.stringify({
+        type: "assistant.message",
+        data: {
+          content: "final reply",
+        },
+      }),
+      JSON.stringify({
+        type: "assistant.turn_end",
+        data: {
+          turnId: "1",
+        },
+      }),
+    ];
+
+    const detected = (driver as any).hasCopilotTurnEndFromJsonLines(lines);
+    expect(detected).toBe(true);
+    driver.kill();
+  });
+
   it("extracts the latest codex assistant message from jsonl lines", () => {
     const driver = new TuiDriver({ profile: codexProfile });
     const lines = [
@@ -103,6 +174,197 @@ describe("session file reply extraction", () => {
     driver.kill();
   });
 
+  it("reads incremental codex assistant messages from session file and ignores wrapper duplicates", async () => {
+    const driver = new TuiDriver({ profile: codexProfile });
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "codex-session-batch-"));
+    const sessionFilePath = path.join(tempDir, "session.jsonl");
+    fs.writeFileSync(
+      sessionFilePath,
+      [
+        JSON.stringify({
+          type: "event_msg",
+          payload: {
+            type: "agent_message",
+            message: "wrapper duplicate",
+          },
+        }),
+        JSON.stringify({
+          timestamp: "2026-03-06T08:20:49.689Z",
+          type: "response_item",
+          payload: {
+            type: "message",
+            role: "assistant",
+            content: [{ type: "output_text", text: "first streamed reply" }],
+          },
+        }),
+        JSON.stringify({
+          type: "event_msg",
+          payload: {
+            type: "task_complete",
+            last_agent_message: "first streamed reply",
+          },
+        }),
+        "",
+      ].join("\n"),
+      "utf8",
+    );
+
+    const batch = await driver.readSessionAssistantMessagesSince(
+      {
+        backend: "codex",
+        sessionId: "session-1",
+        sessionFilePath,
+      },
+      0,
+    );
+
+    expect(batch.messages).toEqual([
+      {
+        backend: "codex",
+        sessionId: "session-1",
+        sessionFilePath,
+        text: "first streamed reply",
+        timestamp: "2026-03-06T08:20:49.689Z",
+      },
+    ]);
+    expect(batch.nextOffset).toBe(fs.readFileSync(sessionFilePath).length);
+    driver.kill();
+  });
+
+  it("keeps incomplete trailing json lines for the next session file poll", async () => {
+    const driver = new TuiDriver({ profile: codexProfile });
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "codex-session-partial-"));
+    const sessionFilePath = path.join(tempDir, "session.jsonl");
+    const firstLine = JSON.stringify({
+      type: "response_item",
+      payload: {
+        type: "message",
+        role: "assistant",
+        content: [{ type: "output_text", text: "first reply" }],
+      },
+    });
+    const secondLine = JSON.stringify({
+      type: "response_item",
+      payload: {
+        type: "message",
+        role: "assistant",
+        content: [{ type: "output_text", text: "second reply" }],
+      },
+    });
+    const splitAt = Math.max(1, Math.floor(secondLine.length / 2));
+    fs.writeFileSync(
+      sessionFilePath,
+      `${firstLine}\n${secondLine.slice(0, splitAt)}`,
+      "utf8",
+    );
+
+    const firstBatch = await driver.readSessionAssistantMessagesSince(
+      {
+        backend: "codex",
+        sessionId: "session-2",
+        sessionFilePath,
+      },
+      0,
+    );
+
+    expect(firstBatch.messages.map((message) => message.text)).toEqual(["first reply"]);
+
+    fs.appendFileSync(sessionFilePath, `${secondLine.slice(splitAt)}\n`, "utf8");
+
+    const secondBatch = await driver.readSessionAssistantMessagesSince(
+      {
+        backend: "codex",
+        sessionId: "session-2",
+        sessionFilePath,
+      },
+      firstBatch.nextOffset,
+    );
+
+    expect(secondBatch.messages.map((message) => message.text)).toEqual(["second reply"]);
+    driver.kill();
+  });
+
+  it("allows codex session idle completion without a fresh task_complete when assistant reply exists", async () => {
+    const driver = new TuiDriver({ profile: codexProfile });
+    const checkpoint = {
+      sessionInfo: {
+        backend: "codex",
+        sessionId: "session-1",
+        sessionFilePath: "/tmp/codex-session-1.jsonl",
+      },
+      size: 10,
+      mtimeMs: 100,
+    };
+    const stats = [
+      { size: 20, mtimeMs: 200 },
+      { size: 20, mtimeMs: 200 },
+      { size: 20, mtimeMs: 200 },
+    ];
+    let statIndex = 0;
+
+    vi.spyOn(driver as any, "assertAliveOrThrow").mockImplementation(() => {});
+    vi.spyOn(driver as any, "sleep").mockResolvedValue(undefined);
+    vi.spyOn(driver as any, "readSessionFileStat").mockImplementation(async () => {
+      const next = stats[Math.min(statIndex, stats.length - 1)];
+      statIndex += 1;
+      return next;
+    });
+    vi.spyOn(driver as any, "hasSessionCompletionMarker").mockResolvedValue(false);
+    vi.spyOn(driver as any, "hasSessionAssistantReply").mockResolvedValue(true);
+
+    await expect((driver as any).waitForSessionFileIdle(checkpoint)).resolves.toBeUndefined();
+    driver.kill();
+  });
+
+  it("keeps codex completion timeout when neither marker nor assistant reply exists", async () => {
+    const driver = new TuiDriver({
+      profile: {
+        ...codexProfile,
+        timeouts: {
+          ...codexProfile.timeouts,
+          streamEnd: 100,
+        },
+      },
+    });
+    const checkpoint = {
+      sessionInfo: {
+        backend: "codex",
+        sessionId: "session-2",
+        sessionFilePath: "/tmp/codex-session-2.jsonl",
+      },
+      size: 10,
+      mtimeMs: 100,
+    };
+    const stats = [
+      { size: 20, mtimeMs: 200 },
+      { size: 20, mtimeMs: 200 },
+      { size: 20, mtimeMs: 200 },
+    ];
+    let statIndex = 0;
+    let now = 0;
+
+    vi.spyOn(driver as any, "assertAliveOrThrow").mockImplementation(() => {});
+    vi.spyOn(driver as any, "sleep").mockResolvedValue(undefined);
+    vi.spyOn(driver as any, "readSessionFileStat").mockImplementation(async () => {
+      const next = stats[Math.min(statIndex, stats.length - 1)];
+      statIndex += 1;
+      return next;
+    });
+    vi.spyOn(driver as any, "hasSessionCompletionMarker").mockResolvedValue(false);
+    vi.spyOn(driver as any, "hasSessionAssistantReply").mockResolvedValue(false);
+    const dateNowSpy = vi.spyOn(Date, "now").mockImplementation(() => {
+      now += 30;
+      return now;
+    });
+
+    await expect((driver as any).waitForSessionFileIdle(checkpoint)).rejects.toThrow(
+      "Stream end timeout: session completion marker not observed",
+    );
+
+    dateNowSpy.mockRestore();
+    driver.kill();
+  });
+
   it("extracts the latest claude assistant text block", () => {
     const driver = new TuiDriver({ profile: codexProfile });
     const lines = [
@@ -157,6 +419,49 @@ describe("session file reply extraction", () => {
     driver.kill();
   });
 
+  it("does not fallback to global latest codex session when discovery query misses", async () => {
+    const driver = new TuiDriver({ profile: codexProfile });
+    const querySpy = vi
+      .spyOn(driver as any, "querySqliteRow")
+      .mockResolvedValue(null);
+    const pathSpy = vi
+      .spyOn(driver as any, "pathExists")
+      .mockResolvedValue(true);
+    const result = await (driver as any).detectCodexSessionInfo();
+
+    expect(result).toBeNull();
+    expect(querySpy).toHaveBeenCalledTimes(1);
+    expect(String(querySpy.mock.calls[0]?.[1] || "")).toContain("created_at >=");
+
+    querySpy.mockRestore();
+    pathSpy.mockRestore();
+    driver.kill();
+  });
+
+  it("returns codex session when expected session-id query hits", async () => {
+    const driver = new TuiDriver({ profile: codexProfile, expectedSessionId: "session-1" });
+    const querySpy = vi
+      .spyOn(driver as any, "querySqliteRow")
+      .mockResolvedValue("session-1|/tmp/codex-session-1.jsonl");
+    const pathSpy = vi
+      .spyOn(driver as any, "pathExists")
+      .mockResolvedValue(true);
+
+    const result = await (driver as any).detectCodexSessionInfo();
+
+    expect(result).toEqual({
+      backend: "codex",
+      sessionId: "session-1",
+      sessionFilePath: "/tmp/codex-session-1.jsonl",
+    });
+    expect(querySpy).toHaveBeenCalledTimes(1);
+    expect(String(querySpy.mock.calls[0]?.[1] || "")).toContain("id='session-1'");
+
+    querySpy.mockRestore();
+    pathSpy.mockRestore();
+    driver.kill();
+  });
+
   it("builds claude and copilot resume args for restart", () => {
     const claudeDriver = new TuiDriver({
       profile: {