jeo-code 0.6.3 → 0.6.5

package/src/commands/launch/flags.ts

@@ -0,0 +1,282 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { type ProviderName, type ModelRole, type ThinkLevel, catalogMetadata } from "../../ai";
+
+export interface LaunchFlags {
+  list: boolean;
+  resume: boolean;
+  resumeId?: string;
+  noSession: boolean;
+  noTui: boolean;
+  /** Explicit step cap from --max-steps; 0 = dynamic (process-driven budget that
+   *  keeps extending while the turn shows progress — no hardcoded step ceiling). */
+  maxSteps: number;
+  message: string;
+  tmux: boolean;
+  worktree?: string;
+  model?: string;
+  provider?: ProviderName;
+  modelRole?: ModelRole;
+  thinking?: ThinkLevel;
+  errors: string[];
+  print?: boolean;
+  appendSystemPromptRaw?: string;
+  appendSystemPrompt?: string;
+  noSkills: boolean;
+  skills?: string;
+  noTools: boolean;
+  tools?: string;
+  systemPromptRaw?: string;
+  systemPrompt?: string;
+}
+
+function takeValue(args: string[], index: number, inlinePrefix: string): { value?: string; nextIndex: number } {
+  const current = args[index]!;
+  if (current.startsWith(inlinePrefix)) return { value: current.slice(inlinePrefix.length), nextIndex: index };
+  const next = args[index + 1];
+  if (next && !next.startsWith("-")) return { value: next, nextIndex: index + 1 };
+  return { nextIndex: index };
+}
+
+export function isProviderName(input: string | undefined): input is ProviderName {
+  return input === "anthropic" || input === "openai" || input === "gemini" || input === "antigravity" || input === "ollama";
+}
+
+export function isThinkingLevel(input: string | undefined): input is ThinkLevel {
+  return input === "minimal" || input === "low" || input === "medium" || input === "high" || input === "xhigh";
+}
+
+
+export function fastThinkingLevelForModel(modelId: string): ThinkLevel | undefined {
+  const supported = catalogMetadata(modelId)?.thinking ?? [];
+  if (supported.includes("minimal")) return "minimal";
+  if (supported.includes("low")) return "low";
+  if (/gemini-(2\.5|[3-9])/.test(modelId.toLowerCase())) return "minimal";
+  return undefined;
+}
+
+export function parseFlags(args: string[], cwd: string = process.cwd()): LaunchFlags {
+  const flags: LaunchFlags = { list: false, resume: false, noSession: false, noTui: false, maxSteps: 0, message: "", tmux: false, errors: [], print: false, noSkills: false, noTools: false };
+  const rest: string[] = [];
+  const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--") {
+      rest.push(...args.slice(i + 1));
+      break;
+    }
+    if (a === "--list") {
+      flags.list = true;
+    } else if (a === "-p" || a === "--print") {
+      flags.print = true;
+      flags.noTui = true;
+    } else if (a === "--tmux") {
+      flags.tmux = true;
+    } else if (a === "--worktree") {
+      const next = args[i + 1];
+      if (next && !next.startsWith("-")) {
+        flags.worktree = next;
+        i++;
+      }
+    } else if (a.startsWith("--worktree=")) {
+      flags.worktree = a.slice("--worktree=".length);
+    } else if (a === "--no-session") {
+      flags.noSession = true;
+    } else if (a === "--no-tui") {
+      flags.noTui = true;
+    } else if (a === "--max-steps") {
+      const n = parseInt(args[i + 1] ?? "", 10);
+      if (Number.isFinite(n) && n > 0) {
+        flags.maxSteps = n;
+        i++;
+      }
+    } else if (a.startsWith("--max-steps=")) {
+      const n = parseInt(a.slice(12), 10);
+      if (Number.isFinite(n) && n > 0) flags.maxSteps = n;
+    } else if (a === "--model") {
+      const { value, nextIndex } = takeValue(args, i, "--model=");
+      if (value) flags.model = value;
+      else flags.errors.push("--model requires a value");
+      i = nextIndex;
+    } else if (a.startsWith("--model=")) {
+      const { value } = takeValue(args, i, "--model=");
+      if (value) flags.model = value;
+      else flags.errors.push("--model requires a value");
+    } else if (a === "--provider") {
+      const { value, nextIndex } = takeValue(args, i, "--provider=");
+      const normalized = value?.toLowerCase();
+      if (isProviderName(normalized)) flags.provider = normalized;
+      else flags.errors.push("--provider must be one of: anthropic, openai, gemini, ollama");
+      i = nextIndex;
+    } else if (a.startsWith("--provider=")) {
+      const { value } = takeValue(args, i, "--provider=");
+      const normalized = value?.toLowerCase();
+      if (isProviderName(normalized)) flags.provider = normalized;
+      else flags.errors.push("--provider must be one of: anthropic, openai, gemini, ollama");
+    } else if (a === "--thinking") {
+      const { value, nextIndex } = takeValue(args, i, "--thinking=");
+      const normalized = value?.toLowerCase();
+      if (isThinkingLevel(normalized)) flags.thinking = normalized;
+      else flags.errors.push("--thinking must be one of: minimal, low, medium, high, xhigh");
+      i = nextIndex;
+    } else if (a.startsWith("--thinking=")) {
+      const { value } = takeValue(args, i, "--thinking=");
+      const normalized = value?.toLowerCase();
+      if (isThinkingLevel(normalized)) flags.thinking = normalized;
+      else flags.errors.push("--thinking must be one of: minimal, low, medium, high, xhigh");
+    } else if (a === "--smol" || a === "--slow" || a === "--plan") {
+      flags.modelRole = a.slice(2) as ModelRole;
+    } else if (a === "--resume" || a === "--continue" || a === "-c") {
+      flags.resume = true;
+      const next = args[i + 1];
+      if (next && UUID_REGEX.test(next)) {
+        flags.resumeId = next;
+        i++;
+      }
+    } else if (a.startsWith("--resume=") || a.startsWith("--continue=") || a.startsWith("-c=")) {
+      flags.resume = true;
+      const eqIdx = a.indexOf("=");
+      const val = a.slice(eqIdx + 1);
+      if (UUID_REGEX.test(val)) {
+        flags.resumeId = val;
+      } else {
+        rest.push(val);
+      }
+    } else if (a === "--append-system-prompt") {
+      const { value, nextIndex } = takeValue(args, i, "--append-system-prompt=");
+      if (value) {
+        flags.appendSystemPromptRaw = value;
+      } else {
+        flags.errors.push("--append-system-prompt requires a value");
+      }
+      i = nextIndex;
+    } else if (a.startsWith("--append-system-prompt=")) {
+      const { value } = takeValue(args, i, "--append-system-prompt=");
+      if (value) {
+        flags.appendSystemPromptRaw = value;
+      } else {
+        flags.errors.push("--append-system-prompt requires a value");
+      }
+    } else if (a === "--no-skills") {
+      flags.noSkills = true;
+    } else if (a === "--skills") {
+      const { value, nextIndex } = takeValue(args, i, "--skills=");
+      if (value) flags.skills = value;
+      else flags.errors.push("--skills requires a value");
+      i = nextIndex;
+    } else if (a.startsWith("--skills=")) {
+      const { value } = takeValue(args, i, "--skills=");
+      if (value) flags.skills = value;
+      else flags.errors.push("--skills requires a value");
+    } else if (a === "--no-tools") {
+      flags.noTools = true;
+    } else if (a === "--tools") {
+      const { value, nextIndex } = takeValue(args, i, "--tools=");
+      if (value) flags.tools = value;
+      else flags.errors.push("--tools requires a value");
+      i = nextIndex;
+    } else if (a.startsWith("--tools=")) {
+      const { value } = takeValue(args, i, "--tools=");
+      if (value) flags.tools = value;
+      else flags.errors.push("--tools requires a value");
+    } else if (a === "--system-prompt") {
+      const { value, nextIndex } = takeValue(args, i, "--system-prompt=");
+      if (value) flags.systemPromptRaw = value;
+      else flags.errors.push("--system-prompt requires a value");
+      i = nextIndex;
+    } else if (a.startsWith("--system-prompt=")) {
+      const { value } = takeValue(args, i, "--system-prompt=");
+      if (value) flags.systemPromptRaw = value;
+      else flags.errors.push("--system-prompt requires a value");
+    } else {
+      rest.push(a);
+    }
+  }
+  flags.message = rest.join(" ").trim();
+
+  if (flags.print && !flags.message) {
+    flags.errors.push("-p/--print requires a message argument");
+  }
+
+  if (flags.appendSystemPromptRaw) {
+    if (flags.appendSystemPromptRaw.startsWith("@")) {
+      const filePath = flags.appendSystemPromptRaw.slice(1);
+      const absPath = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
+      try {
+        flags.appendSystemPrompt = fs.readFileSync(absPath, "utf8");
+      } catch (err) {
+        flags.errors.push(`failed to read system prompt file: ${(err as Error).message}`);
+      }
+    } else {
+      flags.appendSystemPrompt = flags.appendSystemPromptRaw;
+    }
+  }
+  if (flags.systemPromptRaw) {
+    if (flags.systemPromptRaw.startsWith("@")) {
+      const filePath = flags.systemPromptRaw.slice(1);
+      const absPath = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
+      try {
+        flags.systemPrompt = fs.readFileSync(absPath, "utf8");
+      } catch (err) {
+        flags.errors.push(`failed to read system prompt file: ${(err as Error).message}`);
+      }
+    } else {
+      flags.systemPrompt = flags.systemPromptRaw;
+    }
+  }
+
+  return flags;
+}
+
+export function matchSkillGlob(pattern: string, name: string): boolean {
+  const p = pattern.toLowerCase();
+  const n = name.toLowerCase();
+  if (!p.includes("*")) {
+    return p === n;
+  }
+  const escaped = p.replace(/[.+^${}()|[\\\]]/g, "\\$&");
+  const regexStr = "^" + escaped.replace(/\*/g, ".*") + "$";
+  const regex = new RegExp(regexStr);
+  return regex.test(n);
+}
+
+export function filterToolMap(
+  tools: Record<string, any>,
+  allowlist: string[]
+): Record<string, any> {
+  const result: Record<string, any> = {};
+  for (const name of allowlist) {
+    if (name in tools) {
+      result[name] = tools[name];
+    }
+  }
+  return result;
+}
+
+export const TOOL_DESCRIPTIONS: Record<string, string> = {
+  read: "read   {filePath, lineRange?, raw?} — read a file; lines are prefixed `LINEhh|` (hh = 2-char content anchor; the | is a separator, not file bytes)",
+  write: "write  {filePath, content}         — create/overwrite a file",
+  edit: "edit   {filePath, editBlock}       — ≔A..B replace lines (append read anchors for safety: ≔12ab..15cd — rejected with fresh content if the lines changed); ≔A+ insert after line A; ≔$ append EOF (payload on next line). NEVER copy the `LINEhh|` prefixes into SEARCH blocks or payloads",
+  bash: "bash   {command, timeoutMs?, cwd?, env?} — run a shell command (cwd: subdir; env: extra vars)",
+  find: "find   {globPattern}               — find files by name",
+  search: "search {pattern, globPattern?, ignoreCase?, context?, maxMatches?} — grep (context: N lines around each match)",
+  ls: "ls     {dirPath}                   — list a directory's entries (dirs first)",
+};
+
+export function buildToolProtocol(allowedTools: Set<string>): string {
+  const lines: string[] = ["You have these tools (call exactly ONE per step):"];
+  let num = 1;
+  for (const name of ["read", "write", "edit", "bash", "find", "search", "ls"]) {
+    if (allowedTools.has(name)) {
+      lines.push(`${num}. ${TOOL_DESCRIPTIONS[name]}`);
+      num++;
+    }
+  }
+  lines.push(`${num}. done   {reason?}                   — call when the task is fully implemented AND verified`);
+  lines.push("");
+  lines.push("Reply with STRICT JSON only — no code fences. You MAY include an optional leading");
+  lines.push('"reasoning" string (one short sentence on your plan, shown live to the user) before "tool":');
+  lines.push('{ "reasoning": "<one short sentence>", "tool": "<name>", "arguments": { ... } }');
+  lines.push("Tool calibration: scale calls to difficulty — one for a known fact, a few for a normal task, more only when evidence is genuinely missing. Locate before you open: search/find first, then read the hit, instead of guessing paths.");
+  return lines.join("\n");
+}

package/src/commands/launch/input.ts

@@ -0,0 +1,330 @@
+export interface InFlightAbortHarness {
+  controller: AbortController;
+  handleSigint(): void;
+  handleData(chunk: string | Uint8Array): void;
+  dispose(): void;
+}
+
+interface AbortHarnessOptions {
+  controller?: AbortController;
+  captureEsc?: boolean;
+  stdin?: {
+    isTTY?: boolean;
+    isRaw?: boolean;
+    setRawMode?(raw: boolean): void;
+    resume?(): void;
+    on(event: "data", listener: (chunk: string | Uint8Array) => void): unknown;
+    off(event: "data", listener: (chunk: string | Uint8Array) => void): unknown;
+  };
+  onAbortNotice?: (message: string) => void;
+  onHardExit?: () => void;
+  /** Invoked when stray escape-sequence noise (wheel scroll etc.) arrives mid-turn. */
+  onNoise?: () => void;
+  /** Invoked when Ctrl+O (\u000f) is pressed mid-turn — the detail-view binding.
+   *  Without this hook the byte would be swallowed into the buffered input queue,
+   *  which is why Ctrl+O historically "did nothing" while the TUI owned stdin. */
+  onDetailKey?: () => void;
+  /** Invoked when an arrow / PageUp / PageDown key arrives mid-turn — scrolls the
+   *  open Ctrl+O detail panel. dir -1 = up/back, +1 = down/forward; page = full jump. */
+  onScrollKey?: (dir: -1 | 1, page: boolean) => void;
+  /** Invoked with printable keyboard input received while the live turn owns stdin. */
+  onBufferedInput?: (chunk: string) => void;
+  /** True while the input queue is inside a bracketed paste (mid-paste chunks
+   *  carry no marker and must keep routing to the queue, not the noise path). */
+  pasteActive?: () => boolean;
+}
+
+/** Bracketed-paste markers (DECSET 2004): terminals wrap pasted text in these so
+ *  an app can treat the paste as DATA instead of keystrokes — the prompt_toolkit
+ *  paste contract. jeo enables the mode for the REPL TTY so a multi-line paste
+ *  arrives atomically and executes one command per line, in order. */
+export const PASTE_START = "\u001b[200~";
+export const PASTE_END = "\u001b[201~";
+
+/** True when a stdin chunk is ONLY backspace bytes (DEL 0x7f or BS 0x08) — i.e. a
+ *  standalone Backspace keystroke with nothing else. A backspace on an EMPTY input
+ *  line is a no-op edit, but some Bun readline builds turn it into a spurious `close`
+ *  event, which the REPL would treat as a hard exit ("Backspace quits jeo"). The
+ *  input filter swallows these when the line buffer is already empty so the byte never
+ *  reaches readline and the close can't fire. */
+export function isStandaloneBackspace(chunk: string): boolean {
+  return chunk.length > 0 && /^[\x7f\b]+$/.test(chunk);
+}
+
+/**
+ * macOS / fixterms combo-key normalization for the boxed prompt's line editor.
+ *
+ * Bun's readline acts on Ctrl+arrow (CSI `1;5D`/`1;5C` → word jump), Home/End, and the
+ * Emacs control bytes (Ctrl+A/E/W/U/K, Meta+b/f/d, Meta+DEL) — but it does NOT act on
+ * the modifier-flagged cursor keys macOS users reach for most: Option+Left/Right (word
+ * jump, CSI `1;3D`/`1;3C`) and Cmd+Left/Right (line start/end, CSI `1;9D`/`1;9C`) are
+ * inert. Rather than racing readline for cursor state in a keypress handler, we rewrite
+ * each inert combo to the canonical control byte readline DOES act on, BEFORE it reaches
+ * readline. readline stays the single owner of `rl.line`/`rl.cursor`; the box just reads
+ * and repaints. Replacement targets are empirically verified against Bun's readline.
+ *
+ * Modifier digit in `CSI 1;<m><dir>`: 3=Alt/Option, 5=Ctrl (already handled), 9=Cmd/Super.
+ * Both the CSI form and the ESC-prefixed alt-as-meta form (`ESC ESC [ D`) are covered. */
+export const CURSOR_COMBO_REWRITES: ReadonlyArray<readonly [string, string]> = [
+  ["\u001b[1;3D", "\u001bb"],     // Option+Left   → word left
+  ["\u001b[1;3C", "\u001bf"],     // Option+Right  → word right
+  ["\u001b\u001b[D", "\u001bb"],  // Option+Left   (ESC-prefixed alt-as-meta)
+  ["\u001b\u001b[C", "\u001bf"],  // Option+Right  (ESC-prefixed alt-as-meta)
+  ["\u001b[1;9D", "\u0001"],      // Cmd+Left      → line start (Ctrl+A)
+  ["\u001b[1;9C", "\u0005"],      // Cmd+Right     → line end   (Ctrl+E)
+  ["\u001b[127;3u", "\u0017"],    // Option+Backspace (kitty CSI-u) → delete word left (Ctrl+W)
+  ["\u001b[127;9u", "\u0015"],    // Cmd+Backspace    (kitty CSI-u) → delete to line start (Ctrl+U)
+  ["\u001b[3;3~", "\u001bd"],     // Option+Delete (forward) → delete word right (Meta+d)
+];
+
+/** First combo-key rewrite whose source sequence begins at `data[i]`, else undefined. */
+export function matchCursorCombo(data: string, i: number): readonly [string, string] | undefined {
+  for (const pair of CURSOR_COMBO_REWRITES) if (data.startsWith(pair[0], i)) return pair;
+  return undefined;
+}
+
+/** Apply combo-key rewrites across a plain (non-paste) input segment. Shares
+ *  `matchCursorCombo` with the live input filter, so the filter and this exported
+ *  helper can never diverge. */
+export function rewriteCursorCombos(plain: string): string {
+  let out = "";
+  let i = 0;
+  while (i < plain.length) {
+    const combo = matchCursorCombo(plain, i);
+    if (combo) { out += combo[1]; i += combo[0].length; continue; }
+    out += plain[i];
+    i += 1;
+  }
+  return out;
+}
+
+export interface PromptInputQueue {
+  pendingLines: string[];
+  partial: string;
+  /** Complete lines that arrived inside a bracketed PASTE: intentional batch
+   *  commands, served one per prompt in order. Never folded into the typed-line
+   *  prefill (that contract is for keystrokes typed during a live turn). */
+  pastedLines: string[];
+  /** True while a bracketed paste spans chunks (between \x1b[200~ and \x1b[201~). */
+  inPaste: boolean;
+}
+
+/** Typed (non-paste) keystrokes: printable chars build the partial, Enter promotes
+ *  it to pendingLines, backspace edits — ESC/ctrl noise segments are rejected. */
+function feedTypedSegment(state: PromptInputQueue, segment: string): boolean {
+  if (!segment || segment.includes("\u001b") || segment.includes("\u0003")) return false;
+  let accepted = false;
+  const normalized = segment.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  for (const ch of Array.from(normalized)) {
+    if (ch === "\n") {
+      if (state.partial.length > 0) accepted = true;
+      state.pendingLines.push(state.partial);
+      state.partial = "";
+    } else if (ch === "\u007f" || ch === "\b") {
+      const chars = Array.from(state.partial);
+      chars.pop();
+      state.partial = chars.join("");
+      accepted = true;
+    } else if (ch === "\t" || ch >= " ") {
+      state.partial += ch;
+      accepted = true;
+    }
+  }
+  return accepted;
+}
+
+/** Pasted body: pure DATA — newlines split commands into pastedLines, the trailing
+ *  partial stays editable, and control bytes (incl. any stray ESC from copied ANSI
+ *  text) are dropped instead of being interpreted as keystrokes. */
+function feedPasteBody(state: PromptInputQueue, body: string): boolean {
+  if (!body) return false;
+  let accepted = false;
+  const normalized = body.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  for (const ch of Array.from(normalized)) {
+    if (ch === "\n") {
+      state.pastedLines.push(state.partial);
+      state.partial = "";
+      accepted = true;
+    } else if (ch === "\t" || ch >= " ") {
+      state.partial += ch;
+      accepted = true;
+    }
+  }
+  return accepted;
+}
+
+export function queuePromptInputChunk(state: PromptInputQueue, chunk: string): boolean {
+  if (!chunk) return false;
+  let accepted = false;
+  let rest = chunk;
+  while (rest.length > 0) {
+    if (state.inPaste) {
+      const end = rest.indexOf(PASTE_END);
+      const body = end === -1 ? rest : rest.slice(0, end);
+      if (end !== -1) state.inPaste = false;
+      rest = end === -1 ? "" : rest.slice(end + PASTE_END.length);
+      if (feedPasteBody(state, body)) accepted = true;
+    } else {
+      const start = rest.indexOf(PASTE_START);
+      const plain = start === -1 ? rest : rest.slice(0, start);
+      if (start !== -1) state.inPaste = true;
+      rest = start === -1 ? "" : rest.slice(start + PASTE_START.length);
+      if (feedTypedSegment(state, plain)) accepted = true;
+    }
+  }
+  return accepted;
+}
+
+/** Live-turn prompt capture: printable input edits the SAME next-prompt line the
+ * idle footer will show after the turn finishes. Enter does NOT promote a hidden
+ * queue entry; it merely marks the current line as ready, so the existing input
+ * box stays the single source of truth and the user presses Enter once more at
+ * the real prompt to run it. */
+function feedLivePromptSegment(state: PromptInputQueue, segment: string): boolean {
+  if (!segment || segment.includes("\u001b") || segment.includes("\u0003")) return false;
+  let accepted = false;
+  const normalized = segment.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  for (const ch of Array.from(normalized)) {
+    if (ch === "\n") {
+      accepted = true;
+    } else if (ch === "\u007f" || ch === "\b") {
+      const chars = Array.from(state.partial);
+      chars.pop();
+      state.partial = chars.join("");
+      accepted = true;
+    } else if (ch === "\t" || ch >= " ") {
+      state.partial += ch;
+      accepted = true;
+    }
+  }
+  return accepted;
+}
+
+function feedLivePromptPasteBody(state: PromptInputQueue, body: string): boolean {
+  if (!body) return false;
+  const normalized = body.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  const flattened = normalized.split("\n").map(part => part.trim()).filter(Boolean).join(" ");
+  if (!flattened) return false;
+  state.partial = state.partial ? `${state.partial} ${flattened}` : flattened;
+  return true;
+}
+
+export function captureLivePromptInputChunk(state: PromptInputQueue, chunk: string): boolean {
+  if (!chunk) return false;
+  let accepted = false;
+  let rest = chunk;
+  while (rest.length > 0) {
+    if (state.inPaste) {
+      const end = rest.indexOf(PASTE_END);
+      const body = end === -1 ? rest : rest.slice(0, end);
+      if (end !== -1) state.inPaste = false;
+      rest = end === -1 ? "" : rest.slice(end + PASTE_END.length);
+      if (feedLivePromptPasteBody(state, body)) accepted = true;
+    } else {
+      const start = rest.indexOf(PASTE_START);
+      const plain = start === -1 ? rest : rest.slice(0, start);
+      if (start !== -1) state.inPaste = true;
+      rest = start === -1 ? "" : rest.slice(start + PASTE_START.length);
+      if (feedLivePromptSegment(state, plain)) accepted = true;
+    }
+  }
+  return accepted;
+}
+
+/**
+ * TTY "new input first" contract: fold any queued FULL lines (stray
+ * Enter-terminated buffer noise, or older persisted queues) into the editable
+ * prompt prefill instead of leaving them to auto-execute as the next prompt.
+ * Without this, stale queued lines ran BEFORE the user's fresh input — jeo
+ * appeared to "continue the previous work first". Returns the number of lines
+ * folded. Pure over the queue object — piped/non-TTY callers must NOT use this
+ * (scripted stdin relies on in-order line execution).
+ */
+export function restoreQueuedLinesToPrefill(state: PromptInputQueue): number {
+  const lines = state.pendingLines.splice(0, state.pendingLines.length).map(l => l.trim()).filter(Boolean);
+  if (lines.length === 0) return 0;
+  const restored = lines.join(" ");
+  state.partial = state.partial ? `${restored} ${state.partial}`.trim() : restored;
+  return lines.length;
+}
+
+export function createInFlightAbortHarness(opts: AbortHarnessOptions = {}): InFlightAbortHarness {
+  const controller = opts.controller ?? new AbortController();
+  const stdin = opts.stdin ?? process.stdin;
+  const captureEsc = opts.captureEsc === true && !!stdin.isTTY;
+  const wasRaw = !!stdin.isRaw;
+  let rawChanged = false;
+
+  const abortNow = (message: string) => {
+    if (controller.signal.aborted) return false;
+    opts.onAbortNotice?.(message);
+    controller.abort();
+    return true;
+  };
+
+  const handleSigint = () => {
+    if (!controller.signal.aborted) controller.abort();
+    opts.onHardExit?.();
+  };
+
+  const handleData = (chunk: string | Uint8Array) => {
+    if (!captureEsc || controller.signal.aborted) return;
+    const text = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+    if (text.includes(PASTE_START) || opts.pasteActive?.()) {
+      opts.onBufferedInput?.(text);
+      return;
+    }
+    if (text === "\u000f") {
+      opts.onDetailKey?.();
+      return;
+    }
+    if (text === "\u001b[A") { opts.onScrollKey?.(-1, false); return; }
+    if (text === "\u001b[B") { opts.onScrollKey?.(1, false); return; }
+    if (text === "\u001b[5~") { opts.onScrollKey?.(-1, true); return; }
+    if (text === "\u001b[6~") { opts.onScrollKey?.(1, true); return; }
+    const escAt = text.indexOf("\u001b");
+    const sigintAt = text.indexOf("\u0003");
+    const controlAt =
+      escAt === -1 ? sigintAt :
+      sigintAt === -1 ? escAt :
+      Math.min(escAt, sigintAt);
+    if (controlAt >= 0) {
+      const printablePrefix = text.slice(0, controlAt);
+      if (printablePrefix) opts.onBufferedInput?.(printablePrefix);
+      if (text[controlAt] === "\u0003") {
+        handleSigint();
+        return;
+      }
+      if (text === "\u001b") {
+        abortNow("ESC pressed — cancelling current run…");
+        return;
+      }
+      opts.onNoise?.();
+      return;
+    }
+    opts.onBufferedInput?.(text);
+  };
+
+  process.on("SIGINT", handleSigint);
+  if (captureEsc) {
+    stdin.on("data", handleData);
+    if (stdin.setRawMode && !wasRaw) {
+      stdin.setRawMode(true);
+      rawChanged = true;
+    }
+    stdin.resume?.();
+  }
+
+  return {
+    controller,
+    handleSigint,
+    handleData,
+    dispose() {
+      process.removeListener("SIGINT", handleSigint);
+      if (captureEsc) {
+        stdin.off("data", handleData);
+        if (rawChanged) stdin.setRawMode?.(false);
+      }
+    },
+  };
+}