@love-moon/tui-driver 0.2.11 → 0.2.13

package/src/driver/TuiProfile.ts

@@ -1,3 +1,5 @@
+import type { TuiDriverBehavior } from "./behavior/types.js";
+
 export type TuiProfileName = "claude-code" | "codex" | "copilot";
 
 export interface TuiAnchors {
@@ -39,6 +41,7 @@ export interface TuiProfile {
   command: string;
   args: string[];
   env?: Record<string, string>;
+  behavior?: TuiDriverBehavior;
   anchors: TuiAnchors;
   keys: TuiKeys;
   preflightKeys?: string[];

package/src/driver/behavior/claude.behavior.ts

@@ -0,0 +1,54 @@
+import type { MatcherFn } from "../../expect/Matchers.js";
+import type { TuiDriverBehavior } from "./types.js";
+
+function findLastClaudeUserPromptIndex(lines: string[]): number {
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    if (/^\s*❯\s+(?!\d+\.)\S+/.test(lines[i])) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+function findClaudeContinuationStatusLine(lines: string[]): string | null {
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    if (/^\s*⎿\s+\S+/.test(lines[i])) {
+      return lines[i];
+    }
+  }
+  return null;
+}
+
+export const claudeBehavior: TuiDriverBehavior = {
+  getSignalScopeLines: ({ lines }) => {
+    const startIndex = findLastClaudeUserPromptIndex(lines);
+    if (startIndex < 0) {
+      return lines;
+    }
+    return lines.slice(startIndex);
+  },
+
+  resolveStatusLine: ({ lines, defaultStatusLine }) => {
+    if (defaultStatusLine) {
+      return defaultStatusLine;
+    }
+    return findClaudeContinuationStatusLine(lines);
+  },
+
+  matchStreamStartFallback: ({ previousSnapshot, snapshot }) => {
+    return snapshot.hash !== previousSnapshot.hash;
+  },
+
+  buildStreamEndCompleteMatcher: ({ readyMatcher }) => readyMatcher,
+
+  buildStreamEndStatusClearMatcher: ({ getSignals }): MatcherFn => {
+    return (snapshot) => {
+      const currentSignals = getSignals(snapshot);
+      return currentSignals.statusDoneLine
+        ? true
+        : !currentSignals.statusLine;
+    };
+  },
+};
+
+export default claudeBehavior;

package/src/driver/behavior/copilot.behavior.ts

@@ -0,0 +1,63 @@
+import type { TuiDriverBehavior } from "./types.js";
+
+function findLastCopilotUserPromptIndex(lines: string[]): number {
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    const current = lines[i];
+    if (/^\s*You said:\s*\S+/i.test(current)) {
+      return i;
+    }
+    if (/^\s*❯\s+(?!Type @ to mention files,\s*\/ for commands,\s*or \? for shortcuts\b)(?!\d+\.)\S+/i.test(current)) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+export const copilotBehavior: TuiDriverBehavior = {
+  getSignalScopeLines: ({ lines }) => {
+    const startIndex = findLastCopilotUserPromptIndex(lines);
+    if (startIndex < 0) {
+      return lines;
+    }
+    return lines.slice(startIndex);
+  },
+
+  matchStreamStartFallback: ({ previousSnapshot, snapshot }) => {
+    return snapshot.hash !== previousSnapshot.hash;
+  },
+
+  matchStreamEndReplyFallback: ({
+    snapshot,
+    turnStartHash,
+    readyMatcher,
+    busyMatcher,
+    promptMatcher,
+    sawBusyDuringWait,
+    waitStartedAt,
+    hasAnyNewScrollbackLine,
+  }) => {
+    const busyNow = busyMatcher ? busyMatcher(snapshot) : false;
+    if (busyNow) {
+      return false;
+    }
+    if (turnStartHash && snapshot.hash === turnStartHash) {
+      return false;
+    }
+    const hasPrompt = promptMatcher ? promptMatcher(snapshot) : readyMatcher(snapshot);
+    if (!hasPrompt) {
+      return false;
+    }
+    if (sawBusyDuringWait) {
+      return true;
+    }
+    if (!hasAnyNewScrollbackLine(snapshot)) {
+      return false;
+    }
+    if (Date.now() - waitStartedAt < 1000) {
+      return false;
+    }
+    return true;
+  },
+};
+
+export default copilotBehavior;

package/src/driver/behavior/default.behavior.ts

@@ -0,0 +1,12 @@
+import type { TuiDriverBehavior } from "./types.js";
+
+export const defaultTuiDriverBehavior: TuiDriverBehavior = {
+  getSignalScopeLines: ({ lines }) => lines,
+  resolveStatusLine: ({ defaultStatusLine }) => defaultStatusLine,
+  matchStreamStartFallback: () => false,
+  matchStreamEndReplyFallback: () => false,
+  buildStreamEndCompleteMatcher: ({ defaultMatcher }) => defaultMatcher,
+  buildStreamEndStatusClearMatcher: ({ defaultMatcher }) => defaultMatcher,
+};
+
+export default defaultTuiDriverBehavior;

package/src/driver/behavior/index.ts

@@ -0,0 +1,14 @@
+export type {
+  SignalHelpers,
+  SignalScopeContext,
+  ResolveStatusLineContext,
+  StreamStartFallbackContext,
+  StreamEndReplyFallbackContext,
+  StreamEndCompleteMatcherContext,
+  StreamEndStatusClearMatcherContext,
+  TuiDriverBehavior,
+} from "./types.js";
+
+export { defaultTuiDriverBehavior } from "./default.behavior.js";
+export { claudeBehavior } from "./claude.behavior.js";
+export { copilotBehavior } from "./copilot.behavior.js";

package/src/driver/behavior/types.ts

@@ -0,0 +1,64 @@
+import type { MatcherFn } from "../../expect/Matchers.js";
+import type { ScreenSnapshot } from "../../term/ScreenSnapshot.js";
+import type { TuiSignals } from "../TuiProfile.js";
+
+export interface SignalHelpers {
+  findLastMatch: (lines: string[], patterns?: RegExp[]) => string | null;
+}
+
+export interface SignalScopeContext {
+  lines: string[];
+  signals: TuiSignals;
+  helpers: SignalHelpers;
+}
+
+export interface ResolveStatusLineContext {
+  lines: string[];
+  signals: TuiSignals;
+  defaultStatusLine: string | null;
+  helpers: SignalHelpers;
+}
+
+export interface StreamStartFallbackContext {
+  previousSnapshot: ScreenSnapshot;
+  snapshot: ScreenSnapshot;
+  previousScrollback: string;
+  addedLines: string[];
+  hasNewReplyStart: boolean;
+}
+
+export interface StreamEndReplyFallbackContext {
+  snapshot: ScreenSnapshot;
+  turnStartSnapshot?: ScreenSnapshot;
+  turnStartScrollback: string;
+  turnStartHash: string;
+  readyMatcher: MatcherFn;
+  busyMatcher?: MatcherFn | null;
+  promptMatcher?: MatcherFn | null;
+  sawBusyDuringWait: boolean;
+  waitStartedAt: number;
+  hasAnyNewScrollbackLine: (snapshot: ScreenSnapshot) => boolean;
+}
+
+export interface StreamEndCompleteMatcherContext {
+  readyMatcher: MatcherFn;
+  busyMatcher?: MatcherFn | null;
+  defaultMatcher: MatcherFn;
+}
+
+export interface StreamEndStatusClearMatcherContext {
+  defaultMatcher: MatcherFn;
+  getSignals: (snapshot: ScreenSnapshot) => {
+    statusLine?: string;
+    statusDoneLine?: string;
+  };
+}
+
+export interface TuiDriverBehavior {
+  getSignalScopeLines?: (context: SignalScopeContext) => string[];
+  resolveStatusLine?: (context: ResolveStatusLineContext) => string | null;
+  matchStreamStartFallback?: (context: StreamStartFallbackContext) => boolean;
+  matchStreamEndReplyFallback?: (context: StreamEndReplyFallbackContext) => boolean;
+  buildStreamEndCompleteMatcher?: (context: StreamEndCompleteMatcherContext) => MatcherFn;
+  buildStreamEndStatusClearMatcher?: (context: StreamEndStatusClearMatcherContext) => MatcherFn;
+}

package/src/driver/index.ts

@@ -1,4 +1,23 @@
-export { TuiDriver, TuiDriverOptions, AskResult, TuiScreenSignals, HealthStatus, HealthReason } from "./TuiDriver.js";
+export {
+  TuiDriver,
+  TuiDriverOptions,
+  AskResult,
+  TuiScreenSignals,
+  HealthStatus,
+  HealthReason,
+} 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";
+export { defaultTuiDriverBehavior, claudeBehavior, copilotBehavior } from "./behavior/index.js";
+export type {
+  TuiDriverBehavior,
+  SignalHelpers,
+  SignalScopeContext,
+  ResolveStatusLineContext,
+  StreamStartFallbackContext,
+  StreamEndReplyFallbackContext,
+  StreamEndCompleteMatcherContext,
+  StreamEndStatusClearMatcherContext,
+} from "./behavior/index.js";

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

@@ -1,4 +1,5 @@
 import { TuiProfile, createProfile } from "../TuiProfile.js";
+import { claudeBehavior } from "../behavior/claude.behavior.js";
 
 export const claudeCodeProfile: TuiProfile = createProfile({
   name: "claude-code",
@@ -9,6 +10,7 @@ export const claudeCodeProfile: TuiProfile = createProfile({
     LANG: "en_US.UTF-8",
     LC_ALL: "en_US.UTF-8",
   },
+  behavior: claudeBehavior,
 
   anchors: {
     ready: [
@@ -24,6 +26,7 @@ export const claudeCodeProfile: TuiProfile = createProfile({
       /⏺/,                         // Claude's streaming indicator
       /Thinking/i,
       /Working/i,
+      /^\s*⎿\s*(?:Retrying\b.*\battempt\s+\d+\/\d+\b|.*\bAPI_TIMEOUT_MS=\d+ms\b).*$/im,
     ],
     error: [
       // 只匹配 CLI 系统错误，不匹配代码中的文本
@@ -68,7 +71,7 @@ export const claudeCodeProfile: TuiProfile = createProfile({
   extraction: {
     mode: "diff-scrollback",
     includeLinePatterns: [
-      /^⏺\s(?!.*(tool|mcp|running|calling|call))/i,
+      /^⏺\s(?!.*\b(tool|mcp|running|calling|recalled)\b)/i,
     ],
     stopLinePatterns: [
       /^❯\s*/m,
@@ -91,11 +94,12 @@ export const claudeCodeProfile: TuiProfile = createProfile({
   signals: {
     prompt: [/^❯\s*/m],
     promptHint: [/^❯\s+(?!\d+\.)\S+/m],
-    replyStart: [/^⏺\s(?!.*(tool|mcp|running|calling|call))/i],
+    replyStart: [/^⏺\s(?!.*\b(tool|mcp|running|calling|recalled)\b)/i],
     replyStop: [/^❯\s*/m],
     status: [
-      /^⏺\s.*(tool|mcp|running|calling|call)/i,
+      /^⏺\s.*\b(tool|mcp|running|calling)\b/i,
       /^✻\s.*\(\d+s\s*•/i,  // Working status with updating time: "✻ ... (5s • esc to interrupt)"
+      /^\s*⎿\s*(?:Retrying\b.*\battempt\s+\d+\/\d+\b|.*\bAPI_TIMEOUT_MS=\d+ms\b).*$/im,
     ],
     statusDone: [
       /^✻\s.*for\s+\d+(\.\d+)?s/i,  // Final status with fixed time: "✻ Cooked for 33s"

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

@@ -1,4 +1,5 @@
 import { TuiProfile, createProfile } from "../TuiProfile.js";
+import { copilotBehavior } from "../behavior/copilot.behavior.js";
 
 export const copilotProfile: TuiProfile = createProfile({
   name: "copilot",
@@ -14,11 +15,14 @@ export const copilotProfile: TuiProfile = createProfile({
     LANG: "en_US.UTF-8",
     LC_ALL: "en_US.UTF-8",
   },
+  behavior: copilotBehavior,
 
   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,
     ],
     trust: [
       /Remember screen reader mode/i,

package/src/extract/OutputExtractor.ts

@@ -20,12 +20,13 @@ export class OutputExtractor {
       rawText = this.extractFromScrollback(before, after);
     }
 
-    const text = this.cleanText(rawText);
+    const boundedRawText = this.extractLatestReplyBlockFromSnapshot(before, after) ?? rawText;
+    const text = this.cleanText(boundedRawText);
 
     return {
       text,
-      rawText,
-      linesAdded: text.split("\n").length,
+      rawText: boundedRawText,
+      linesAdded: text ? text.split("\n").length : 0,
     };
   }
 
@@ -42,24 +43,144 @@ export class OutputExtractor {
     return added.join("\n");
   }
 
+  /**
+   * Extract the latest reply block by TUI markers:
+   * reply starts from includeLinePatterns (e.g. "• ...")
+   * and ends at the latest stopLinePatterns match (e.g. "› ...").
+   * Content after the latest prompt line is ignored.
+   * Returns:
+   * - null: rule not applicable (missing markers/config)
+   * - "": prompt found but no valid new reply block before it
+   * - string: bounded raw reply block
+   */
+  private extractLatestReplyBlockFromSnapshot(
+    before: ScreenSnapshot,
+    after: ScreenSnapshot
+  ): string | null {
+    const includeLinePatterns = this.extraction.includeLinePatterns ?? [];
+    const stopLinePatterns = this.extraction.stopLinePatterns ?? [];
+    if (this.extraction.mode !== "diff-scrollback") {
+      return null;
+    }
+    if (includeLinePatterns.length === 0 || stopLinePatterns.length === 0) {
+      return null;
+    }
+
+    const beforeLines = before.scrollbackText.split("\n");
+    const lines = after.scrollbackText.split("\n");
+    const stopIndex = this.findLastMatchingLineIndex(lines, stopLinePatterns);
+    if (stopIndex < 0) {
+      return null;
+    }
+    if (stopIndex === 0) {
+      return "";
+    }
+
+    const firstChangedIndex = this.findFirstChangedLineIndex(beforeLines, lines);
+    if (firstChangedIndex < 0) {
+      return "";
+    }
+
+    // Prefer reply markers that appeared in this turn's changed range.
+    const startIndex = this.findLastMatchingLineIndexInRange(
+      lines,
+      firstChangedIndex,
+      stopIndex,
+      includeLinePatterns
+    );
+    if (startIndex < 0) {
+      return "";
+    }
+
+    if (!this.rangeHasChangedContentBeforeStop({
+      lines,
+      startIndex,
+      stopIndex,
+      firstChangedIndex,
+      stopLinePatterns,
+    })) {
+      return "";
+    }
+
+    const block = lines.slice(startIndex, stopIndex + 1);
+    return block.join("\n");
+  }
+
+  private findFirstChangedLineIndex(beforeLines: string[], afterLines: string[]): number {
+    const minLength = Math.min(beforeLines.length, afterLines.length);
+    let prefixLength = 0;
+    while (prefixLength < minLength && beforeLines[prefixLength] === afterLines[prefixLength]) {
+      prefixLength += 1;
+    }
+    return prefixLength < afterLines.length ? prefixLength : -1;
+  }
+
+  private findLastMatchingLineIndexInRange(
+    lines: string[],
+    startIndex: number,
+    endExclusive: number,
+    patterns: RegExp[]
+  ): number {
+    const safeStart = Math.max(0, startIndex);
+    const safeEnd = Math.min(lines.length, Math.max(safeStart, endExclusive));
+    for (let index = safeEnd - 1; index >= safeStart; index -= 1) {
+      if (this.matchesAny(lines[index], patterns)) {
+        return index;
+      }
+    }
+    return -1;
+  }
+
+  private rangeHasChangedContentBeforeStop(options: {
+    lines: string[];
+    startIndex: number;
+    stopIndex: number;
+    firstChangedIndex: number;
+    stopLinePatterns: RegExp[];
+  }): boolean {
+    const { lines, startIndex, stopIndex, firstChangedIndex, stopLinePatterns } = options;
+    const from = Math.max(startIndex, firstChangedIndex);
+    const to = Math.min(stopIndex, lines.length);
+
+    for (let index = from; index < to; index += 1) {
+      const line = lines[index];
+      if (!line || line.trim().length === 0) {
+        continue;
+      }
+      if (this.matchesAny(line, stopLinePatterns)) {
+        continue;
+      }
+      return true;
+    }
+    return false;
+  }
+
   private cleanText(text: string): string {
     let result = text;
     const includeLinePatterns = this.extraction.includeLinePatterns;
     const stopLinePatterns = this.extraction.stopLinePatterns ?? [];
 
+    if (stopLinePatterns.length > 0) {
+      const boundedLines = result.split("\n");
+      const lastStopIndex = this.findLastMatchingLineIndex(boundedLines, stopLinePatterns);
+      if (lastStopIndex >= 0) {
+        result = boundedLines.slice(0, lastStopIndex + 1).join("\n");
+      }
+    }
+
     if (includeLinePatterns && includeLinePatterns.length > 0) {
       const lines = result.split("\n");
       const kept: string[] = [];
       let including = false;
 
       for (const line of lines) {
-        if (includeLinePatterns.some(pattern => pattern.test(line))) {
+        if (this.matchesAny(line, includeLinePatterns)) {
           including = true;
           kept.push(line);
           continue;
         }
 
-        if (including && stopLinePatterns.some(pattern => pattern.test(line))) {
+        if (including && this.matchesAny(line, stopLinePatterns)) {
           including = false;
           continue;
         }
@@ -85,4 +206,23 @@ export class OutputExtractor {
 
     return result.trim();
   }
+
+  private findLastMatchingLineIndex(lines: string[], patterns: RegExp[]): number {
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+      if (this.matchesAny(lines[index], patterns)) {
+        return index;
+      }
+    }
+    return -1;
+  }
+
+  private matchesAny(line: string, patterns: RegExp[]): boolean {
+    for (const pattern of patterns) {
+      pattern.lastIndex = 0;
+      if (pattern.test(line)) {
+        return true;
+      }
+    }
+    return false;
+  }
 }

package/src/index.ts

@@ -30,6 +30,21 @@ export {
   TuiScreenSignals,
   HealthStatus,
   HealthReason,
+  defaultTuiDriverBehavior,
+  claudeBehavior,
+  copilotBehavior,
+} from "./driver/index.js";
+export type {
+  TuiSessionInfo,
+  TuiSessionUsageSummary,
+  TuiDriverBehavior,
+  SignalHelpers,
+  SignalScopeContext,
+  ResolveStatusLineContext,
+  StreamStartFallbackContext,
+  StreamEndReplyFallbackContext,
+  StreamEndCompleteMatcherContext,
+  StreamEndStatusClearMatcherContext,
 } from "./driver/index.js";
 
 // Extract

package/src/pty/PtySession.ts

@@ -137,10 +137,20 @@ export class PtySession extends EventEmitter {
 
     this.ptyProcess.onExit(({ exitCode, signal }) => {
       this._isRunning = false;
+      // Clear spawn state on natural exit so follow-up restarts can spawn safely.
+      this.ptyProcess = null;
       this.emit("exit", exitCode, signal);
     });
   }
 
+  setCommandArgs(command: string, args: string[] = []): void {
+    if (this.ptyProcess) {
+      throw new Error("Cannot update PTY command while session is running");
+    }
+    this.command = command;
+    this.args = Array.isArray(args) ? [...args] : [];
+  }
+
   write(data: string): void {
     if (!this.ptyProcess) {
       throw new Error("PTY session not spawned");

package/test/claude-profile.test.ts

@@ -1,5 +1,46 @@
 import { describe, expect, it } from "vitest";
+import { Matchers } from "../src/expect/Matchers.js";
 import { claudeCodeProfile } from "../src/driver/profiles/claudeCode.profile.js";
+import { ScreenSnapshot } from "../src/term/ScreenSnapshot.js";
+
+function createSnapshot(text: string): ScreenSnapshot {
+  return new ScreenSnapshot({
+    viewportText: text,
+    scrollbackText: text,
+    cursor: { x: 0, y: 0 },
+    hash: ScreenSnapshot.computeHash(text),
+    timestamp: Date.now(),
+    cols: 120,
+    rows: 40,
+  });
+}
+
+describe("claude profile busy and status signals", () => {
+  it("matches retry status line with attempt and timeout hint", () => {
+    const snapshot = createSnapshot([
+      "❯ hi, 1+1=",
+      "  ⎿ Retrying in 14 seconds… (attempt 9/10) · API_TIMEOUT_MS=3000000ms, try increasing it",
+    ].join("\n"));
+
+    const busyMatcher = Matchers.anyOf(claudeCodeProfile.anchors.busy ?? []);
+    const statusMatcher = Matchers.anyOf(claudeCodeProfile.signals?.status ?? []);
+    const replyStartMatcher = Matchers.anyOf(claudeCodeProfile.signals?.replyStart ?? [], "scrollback");
+
+    expect(busyMatcher(snapshot)).toBe(true);
+    expect(statusMatcher(snapshot)).toBe(true);
+    expect(replyStartMatcher(snapshot)).toBe(false);
+  });
+
+  it("does not classify recalled memory summary as reply or tool status", () => {
+    const snapshot = createSnapshot("⏺ Recalled 1 memory, wrote 1 memory (ctrl+o to expand)");
+
+    const statusMatcher = Matchers.anyOf(claudeCodeProfile.signals?.status ?? []);
+    const replyStartMatcher = Matchers.anyOf(claudeCodeProfile.signals?.replyStart ?? [], "scrollback");
+
+    expect(statusMatcher(snapshot)).toBe(false);
+    expect(replyStartMatcher(snapshot)).toBe(false);
+  });
+});
 
 describe("claude profile timeout policy", () => {
   it("disables hard timeouts for long-running turns", () => {

package/test/claude-signals.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, it } from "vitest";
+import { TuiDriver } from "../src/driver/TuiDriver.js";
+import { claudeCodeProfile } from "../src/driver/profiles/claudeCode.profile.js";
+import { ScreenSnapshot } from "../src/term/ScreenSnapshot.js";
+
+function createSnapshot(text: string): ScreenSnapshot {
+  return new ScreenSnapshot({
+    viewportText: text,
+    scrollbackText: text,
+    cursor: { x: 0, y: 0 },
+    hash: ScreenSnapshot.computeHash(text),
+    timestamp: Date.now(),
+    cols: 120,
+    rows: 40,
+  });
+}
+
+describe("claude getSignals continuation status", () => {
+  it("ignores history status lines before latest user prompt", () => {
+    const driver = new TuiDriver({ profile: claudeCodeProfile });
+    const snapshot = createSnapshot([
+      "❯ old question",
+      "  ⎿ API Error: 500",
+      "❯ new question",
+      "⏺ Recalled 1 memory, wrote 1 memory (ctrl+o to expand)",
+      "❯ ",
+    ].join("\n"));
+
+    const signals = driver.getSignals(snapshot);
+    expect(signals.statusLine).toBeUndefined();
+
+    driver.kill();
+  });
+
+  it("captures not-logged-in continuation line after latest user prompt", () => {
+    const driver = new TuiDriver({ profile: claudeCodeProfile });
+    const snapshot = createSnapshot([
+      "❯ old question",
+      "  ⎿ API Error: 500",
+      "⏺ Recalled 1 memory, wrote 1 memory (ctrl+o to expand)",
+      "❯ new question",
+      "  ⎿ Not logged in · Please run /login",
+      "❯ ",
+    ].join("\n"));
+
+    const signals = driver.getSignals(snapshot);
+    expect(signals.statusLine).toBe("  ⎿ Not logged in · Please run /login");
+
+    driver.kill();
+  });
+
+  it("captures api error continuation line after user prompt", () => {
+    const driver = new TuiDriver({ profile: claudeCodeProfile });
+    const snapshot = createSnapshot([
+      "❯ please continue",
+      "  ⎿ API Error: 401",
+      "❯ ",
+    ].join("\n"));
+
+    const signals = driver.getSignals(snapshot);
+    expect(signals.statusLine).toBe("  ⎿ API Error: 401");
+
+    driver.kill();
+  });
+
+  it("uses the latest continuation line within current turn", () => {
+    const driver = new TuiDriver({ profile: claudeCodeProfile });
+    const snapshot = createSnapshot([
+      "❯ retry this",
+      "  ⎿ Not logged in · Please run /login",
+      "  ⎿ API Error: 401",
+      "❯ ",
+    ].join("\n"));
+
+    const signals = driver.getSignals(snapshot);
+    expect(signals.statusLine).toBe("  ⎿ API Error: 401");
+
+    driver.kill();
+  });
+});