jeo-code 0.6.4 → 0.6.6

package/src/commands/launch.ts

@@ -60,9 +60,10 @@ import { liveModelPicker, renderLiveModelPicker, type ModelAssignmentBadge } fro
 import { providerPicker, renderProviderPicker } from "../tui/components/provider-picker";
 import { detectLanguage, languageLabel, parseLineRange, sliceLines, formatCodeBlock, formatDiff, sanitizeForTerminal } from "../tui/components/code-view";
 import { categoryBadge } from "../tui/components/category-index";
-import { renderInputFrame } from "../tui/components/input-box";
+import { renderInputFrame, verticalCursorOffset } from "../tui/components/input-box";
+
 import { renderStatusBar } from "../tui/components/status";
-import { detectColorLevel, ColorLevel } from "../tui/components/color";
+import { detectColorLevel, ColorLevel, visibleWidth } from "../tui/components/color";
 import { readClipboardImage } from "../util/clipboard-image";
 import { formatTranscript } from "../tui/components/transcript";
 import { loadInputHistory, appendInputHistory } from "../agent/input-history";
@@ -92,438 +93,100 @@ import {
   sessionPath,
   appendCompaction,
 } from "../agent/session";
-import { clearLine, cursorUp, toColumn, truncate as truncateAnsi, size as terminalSize, resetMouseTracking } from "../tui/terminal";
-
-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;
-}
-
-const PROVIDER_DEFAULT: Record<ProviderName, string> = { anthropic: "sonnet", openai: "gpt-5.5", gemini: "flash", antigravity: "antigravity/gemini-3-pro-high", ollama: "fast" };
-
-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 };
-}
-
-function isProviderName(input: string | undefined): input is ProviderName {
-  return input === "anthropic" || input === "openai" || input === "gemini" || input === "antigravity" || input === "ollama";
-}
-
-function isThinkingLevel(input: string | undefined): input is ThinkLevel {
-  return input === "minimal" || input === "low" || input === "medium" || input === "high" || input === "xhigh";
-}
-
-function fastThinkingLevelForModel(modelId: string): ThinkLevel | undefined {
-  const supported = catalogMetadata(modelId)?.thinking ?? [];
-  if (supported.includes("minimal")) return "minimal";
-  if (supported.includes("low")) return "low";
-  // Fallback for the one thinking-capable family that misses a catalog entry in practice:
-  // the dynamic antigravity `gemini-3.x` variants (gemini-3.5-flash-low/-extra-low, …) the
-  // CCA backend serves but the static catalog can't enumerate. They apply a thinking budget,
-  // so /fast offers `minimal` as the fast level instead of reporting "unsupported". (openai
-  // reasoning models and *-thinking/-high/-low antigravity ids are already catalogued.)
-  if (/gemini-(2\.5|[3-9])/.test(modelId.toLowerCase())) return "minimal";
-  return undefined;
-}
-
-function hashString(input: string): string {
-  let hash = 2166136261;
-  for (let i = 0; i < input.length; i++) {
-    hash ^= input.charCodeAt(i);
-    hash = Math.imul(hash, 16777619);
-  }
-  return (hash >>> 0).toString(36).padStart(6, "0").slice(0, 6);
-}
-
-function tmuxSafeNamePart(input: string, max = 32): string {
-  const safe = input.replace(/[^a-zA-Z0-9_-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "") || "value";
-  if (safe.length <= max) return safe;
-  return `${safe.slice(0, Math.max(1, max - 7))}-${hashString(input)}`;
-}
-
-function tmuxRuntimeSuffix(flags: LaunchFlags): string {
-  const parts: string[] = [];
-  if (flags.provider) parts.push(`provider-${flags.provider}`);
-  if (flags.model) parts.push(`model-${tmuxSafeNamePart(flags.model)}`);
-  else if (flags.modelRole) parts.push(flags.modelRole);
-  if (flags.thinking) parts.push(`think-${flags.thinking}`);
-  // Only an EXPLICIT --max-steps cap names the session; the dynamic default (0) adds nothing.
-  if (flags.maxSteps > 0) parts.push(`steps-${flags.maxSteps}`);
-  if (parts.length === 0) return "";
-  const joined = parts.join("-");
-  const suffix = joined.length <= 72 ? joined : `${joined.slice(0, 65)}-${hashString(joined)}`;
-  return `-${suffix}`;
-}
-
-/**
- * Base tmux session name for `jeo --tmux`. Keyed on the working DIRECTORY (not just the
- * git branch) so two different projects/worktrees on the same branch (e.g. `main`)
- * never share a base. {@link uniqueTmuxSessionName} then makes each concurrent invocation
- * fully independent, so a second `jeo --tmux` never attaches to (and mirrors) the first.
- */
-export function tmuxSessionName(cwd: string, branch: string, flags: LaunchFlags): string {
-  const dirTag = `${tmuxSafeNamePart(path.basename(cwd) || "root", 16)}-${hashString(cwd)}`;
-  const base = branch ? `jeo-${branch}-${dirTag}` : `jeo-${dirTag}`;
-  return base + tmuxRuntimeSuffix(flags);
-}
-
-/**
- * Count uncommitted git entries for the `⑂ <branch> ?N` footer dirty flag (gjc parity).
- * One `git status --porcelain` spawn per CALL; callers invoke it once per turn start, not
- * per render. Returns undefined when not a repo / git absent / clean.
- */
-export function gitDirtyCount(cwd: string): number | undefined {
-  try {
-    const res = Bun.spawnSync(["git", "status", "--porcelain"], { cwd, stdout: "pipe", stderr: "ignore" });
-    if (res.exitCode !== 0) return undefined;
-    const n = res.stdout.toString().split("\n").filter(l => l.trim().length > 0).length;
-    return n || undefined;
-  } catch {
-    return undefined;
-  }
-}
+import { clearLine, cursorUp, toColumn, truncate as truncateAnsi, size as terminalSize, resetMouseTracking, clearScreen, clearToEnd } from "../tui/terminal";
 
-/**
- * Allocate + create an INDEPENDENT tmux session from a base name. Each separate,
- * concurrent `jeo --tmux` invocation gets its OWN session instead of attaching to (and
- * mirroring) one another process already created: try `base`, then `base-2`, `base-3`, …
- * The create itself is the guard, so this is race-safe — two processes starting at the
- * same instant can't both win `base`. `tryCreate` must attempt to create the named session
- * and return `"ok"` (created — it's ours), `"taken"` (name already live / lost the race →
- * try the next suffix), or `"error:<msg>"` (a real failure → abort). Sessions die with
- * their jeo process, so a sequential re-run reuses the clean base; only live overlap is
- * suffixed.
- */
-export type TmuxCreateResult = "ok" | "taken" | `error:${string}`;
-export function allocateTmuxSession(
-  base: string,
-  tryCreate: (name: string) => TmuxCreateResult,
-): { name: string } | { error: string } {
-  for (let n = 1; n <= 1000; n++) {
-    const candidate = n === 1 ? base : `${base}-${n}`;
-    const result = tryCreate(candidate);
-    if (result === "ok") return { name: candidate };
-    if (result === "taken") continue;
-    return { error: result.slice("error:".length) };
-  }
-  return { error: `could not allocate a free tmux session name for ${base} (1000 already live?)` };
-}
-
-function shellQuote(arg: string): string {
-  return `'${arg.replace(/'/g, `'\\''`)}'`;
-}
-
-/**
- * True when `jeo --tmux` runs INSIDE an existing tmux session and should enable
- * session-scoped mouse mode for the CURRENT session: no jeo-owned session is created
- * on this path, so without `mouse on` tmux ignores the wheel entirely and the
- * mid-turn scrollback (ledger lines flushed above the live frame) is unreachable.
- * Skipped for jeo-spawned sessions (JEO_TMUX_LAUNCHED=1 — the creator already set
- * it) and when JEO_TMUX_MOUSE=0 opts out.
- */
-export function shouldEnableCurrentTmuxMouse(env: Record<string, string | undefined>): boolean {
-  return !!env.TMUX
-    && (env.JEO_TMUX_LAUNCHED ?? env.JEO_TMUX_LAUNCHED) !== "1"
-    && (env.JEO_TMUX_MOUSE ?? env.JEO_TMUX_MOUSE) !== "0";
-}
-
-/**
- * The runnable command for the INNER `jeo launch` a `--tmux` session executes.
- * Pure — testable. Three runtime shapes:
- *  - compiled standalone binary: `argv[1]` is a Bun VIRTUAL path (`/$bunfs/…`)
- *    that does not exist on disk; the binary itself (`execPath`) is the
- *    entrypoint. Passing the virtual path made the inner command crash on
- *    spawn, so `tmux new-session` died instantly and the follow-up attach
- *    failed with "can't find session".
- *  - source run (`bun src/cli.ts`): re-run the script through the runtime.
- *  - anything else (a shim/binary path on disk): run it directly.
- */
-export function tmuxLaunchCommand(argv1: string | undefined, execPath: string, cwd: string): string[] {
-  const entrypoint = argv1 ?? "";
-  if (entrypoint === "" || entrypoint.startsWith("/$bunfs/") || entrypoint.startsWith("B:\\~BUN\\")) {
-    return [execPath];
-  }
-  const resolved = path.isAbsolute(entrypoint) ? entrypoint : path.resolve(cwd, entrypoint);
-  if (/\.(ts|js|mjs)$/.test(entrypoint)) return [execPath, resolved];
-  return [resolved];
-}
-
-/** One tmux configuration step applied to a jeo-owned session after creation. */
-export interface TmuxProfileCommand {
-  description: string;
-  args: string[];
-}
-
-/**
- * gjc-parity tmux profile for jeo-OWNED sessions (mirrors gjc's
- * `buildGjcTmuxProfileCommands`). Applied right after `new-session`, before attach:
- *  - `mouse on` (session-scoped): wheel-up enters copy-mode over the REAL pane
- *    history — this is what makes the mid-turn scrollback (ledger lines flushed
- *    above the inline live frame) reachable with the mouse wheel. Wheel-down at
- *    the bottom drops back out. `JEO_TMUX_MOUSE=0` opts out.
- *  - ownership/identity markers (`@jeo-profile`, `@jeo-branch`, `@jeo-project`):
- *    lets tooling tell jeo-owned sessions apart from user sessions (gjc parity
- *    with `@gjc-*`). Never applied to foreign sessions.
- *  - `set-clipboard on` + a readable copy-mode `mode-style`: text selected while
- *    wheel-scrolled back is visibly highlighted and lands on the system clipboard
- *    (OSC52). `JEO_TMUX_PROFILE=0` opts out of these cosmetic extras while keeping
- *    mouse + markers.
- */
-export function tmuxProfileCommands(
-  target: string,
-  env: Record<string, string | undefined>,
-  meta: { branch?: string; project?: string } = {},
-): TmuxProfileCommand[] {
-  // Exact-name session target. `=name:` (explicit session:window form), NOT bare
-  // `=name`: tmux 3.6 rejects bare `=name` for set-option/show-options with
-  // "no such session" even while the session is live (has-session/attach accept
-  // it). The trailing colon makes cmd-find parse `=name` as the session part —
-  // exact-matched, never prefix-matched — and resolves the session's current
-  // window for set-window-option. This was the silent failure that left
-  // `mouse on` unset, killing wheel-up scrollback in jeo-owned sessions.
-  const t = `=${target}:`;
-  const commands: TmuxProfileCommand[] = [];
-  if ((env.JEO_TMUX_MOUSE ?? env.JEO_TMUX_MOUSE) !== "0") {
-    commands.push({
-      description: "enable tmux mouse scrolling (wheel-up → copy-mode over real history)",
-      args: ["set-option", "-t", t, "mouse", "on"],
-    });
-  }
-  commands.push({
-    description: "mark jeo tmux ownership",
-    args: ["set-option", "-t", t, "@jeo-profile", "1"],
-  });
-  if (meta.branch) {
-    commands.push({
-      description: "record jeo branch identity",
-      args: ["set-option", "-t", t, "@jeo-branch", meta.branch],
-    });
-  }
-  if (meta.project) {
-    commands.push({
-      description: "record jeo project identity",
-      args: ["set-option", "-t", t, "@jeo-project", meta.project],
-    });
-  }
-  if ((env.JEO_TMUX_PROFILE ?? env.JEO_TMUX_PROFILE) !== "0") {
-    commands.push(
-      {
-        description: "enable tmux clipboard integration",
-        args: ["set-option", "-t", t, "set-clipboard", "on"],
-      },
-      {
-        description: "make copy-mode selection readable",
-        args: ["set-window-option", "-t", t, "mode-style", "fg=colour231,bg=colour60"],
-      },
-    );
-  }
-  return commands;
-}
-
-/**
- * A `process.stdout` view whose visible-output methods become no-ops while `gated()` is
- * true. Used as readline's `output` so that, while the boxed slash-preview footer is armed,
- * readline's OWN prompt/echo is suppressed and only our box is visible — no duplicated raw
- * `jeo>` line. The previous approach monkeypatched `rl._writeToOutput`, a Node internal Bun
- * does not expose (so on Bun both inputs showed at once). Gating the shared `output` stream
- * works on both runtimes. Our footer is written straight to `process.stdout`, never through
- * this proxy, so it always renders. Geometry/everything else is forwarded unchanged.
- */
-const GATED_OUTPUT_METHODS = new Set(["write", "cursorTo", "moveCursor", "clearLine", "clearScreenDown", "_write", "_writev"]);
-export function gatedStdout(real: NodeJS.WriteStream, gated: () => boolean): NodeJS.WriteStream {
-  return new Proxy(real, {
-    get(target, prop, _receiver) {
-      if (typeof prop === "string" && GATED_OUTPUT_METHODS.has(prop)) {
-        return (...args: any[]) => {
-          if (gated()) {
-            const cb = args[args.length - 1]; // honor readline's write callback so it never stalls
-            if (typeof cb === "function") cb();
-            return true;
-          }
-          return (target as any)[prop](...args);
-        };
-      }
-      const value = Reflect.get(target, prop, target);
-      return typeof value === "function" ? value.bind(target) : value;
-    },
-  }) as unknown as NodeJS.WriteStream;
-}
-
-function firstOutputLine(output: string | undefined): string {
-  if (!output) return "";
-  const line = String(output)
-    .split("\n")
-    .map(l => l.trim())
-    .find(l => l.length > 0);
-  return line ? line.replace(/\s+/g, " ").slice(0, 140) : "";
-}
-
-function streamResultSuffix(tool: string, ok: boolean, output: string | undefined): string {
-  const summary = firstOutputLine(output);
-  if (!summary) return "";
-  if (!ok || tool === "task") return ` — ${summary}`;
-  return "";
-}
-
-export function formatTaskSubEvent(e: TaskSubEvent): string {
-  const role = e.role || "subagent";
-  const roleLabel = e.index && e.total ? `${role.toUpperCase()}[${e.index}/${e.total}]` : role.toUpperCase();
-  const tokTag = e.tokens ? ` (${e.tokens.input + e.tokens.output} tok)` : "";
-  const detail = firstOutputLine(e.detail);
-  const summary = e.summary ? ` — ${e.summary}` : "";
-  // No ` step N/M` marker — step counters carry no meaning under the dynamic
-  // budget (user feedback); a tree prefix makes nested subagent activity scan as
-  // one readable branch in plain logs and TUI scrollback.
-  const badge = categoryBadge("subagent");
-  if (e.kind === "start") return `${badge} ${chalk.magenta(`▸ ${roleLabel}`)} · ${detail}`.slice(0, 240);
-  if (e.kind === "step") return `  ${badge} ${chalk.cyan(`├─ ${roleLabel}`)} · ${detail || "working"}`;
-  if (e.kind === "tool") return `  ${badge} ${e.success === false ? chalk.red("├─") : chalk.green("├─")} ${roleLabel} ${e.success === false ? chalk.red("✗") : chalk.green("✓")} ${detail || "tool"}${summary}`;
-  if (e.kind === "error") return `  ${badge} ${chalk.red("├─")} ${roleLabel} ${chalk.red("✗")} ${detail || "error"}`;
-  return `${badge} ${e.success === false ? chalk.red("└─") : chalk.green("└─")} ${roleLabel} done${tokTag}${e.success === false ? " (incomplete)" : ""}${detail ? `: ${detail}` : ""}`;
-}
-
-function logTaskSubEvent(e: TaskSubEvent, log: (line: string) => void = (s: string) => console.log(s)): void {
-  log(formatTaskSubEvent(e));
-}
-
-
-/**
- * Plain (non-TTY / `--no-tui`) progress sink — the cmd-mode equivalent of the live TUI, and
- * the gjc-parity fix for "I typed a request but saw no steps/results". The old sink only
- * logged tool RESULTS, so a turn that finished without a tool call (or before the first
- * result) printed nothing but the final reply. This surfaces every STEP, the tool it is about
- * to run (with the real file/command target via `summarizeForgeInvocation`), and each result —
- * tracking the current step + pending invocation across the engine's
- * onStep → onAssistant → onToolResult sequence.
- */
-export function createStreamEvents(
-  _maxSteps: number,
-  log: (line: string) => void = (s: string) => console.log(s),
-  now: () => number = Date.now,
-): AgentLoopEvents {
-  let pending = "";
-  let latestUsage: { inputTokens: number; outputTokens: number } | undefined;
-  const startTime = now();
-
-  return {
-    // Lazy header: nothing is printed until the tool call is known (onAssistant).
-    // A `done` / invalid reply therefore emits no progress line at all. The step
-    // NUMBER itself is never shown — meaningless under the dynamic budget.
-    onStep: () => {},
-    onAssistant: (_raw: string, invocation: { tool?: string; arguments?: unknown } | null) => {
-      const tool = typeof invocation?.tool === "string" ? invocation.tool.trim() : "";
-      if (!tool || tool === "done") return;
-      pending = summarizeForgeInvocation(tool, invocation?.arguments).title;
-      // gjc-style live status unit: step header + tool target + elapsed + token usage.
-      const elapsedMs = now() - startTime;
-      let suffix = "";
-      if (elapsedMs >= 1000) suffix += ` · ${formatDuration(elapsedMs)}`;
-      if (latestUsage) suffix += ` · ${formatUsage(latestUsage)}`;
-      log(`${categoryBadge("progress")} ${pending}${suffix ? chalk.dim(suffix) : ""}`);
-    },
-    onToolResult: (tool: string, ok: boolean, output?: string) => {
-      const label = pending || tool;
-      const mark = ok ? chalk.green("✓") : chalk.red("✗");
-      log(`  ${categoryBadge(ok ? "done" : "error")} ${mark} ${label}${streamResultSuffix(tool, ok, output)}`);
-      pending = "";
-    },
-    onNotice: (msg: string) => log(`  ${categoryBadge("progress")} ${chalk.yellow(msg)}`),
-    onBudget: (_limit: number, reason: string) => {
-      log(`  ${categoryBadge("progress")} ${chalk.yellow(reason)}`);
-    },
-    onUsage: (usage: { inputTokens: number; outputTokens: number }) => {
-      latestUsage = usage;
-    },
-  };
-}
-
-export function shouldUseOneShotTui(noTui: boolean): boolean {
-  return LaunchTui.usable(noTui);
-}
-
-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);
-}
-
-/** gjc-parity slash-command aliases, applied once before dispatch so each real command
- *  keeps a SINGLE handler: `/login`→`/provider login`, `/settings`→`/config`,
- *  `/subagent(s)`→`/agents`. Pure rewrite that preserves any trailing args. */
+import {
+  type LaunchFlags,
+  parseFlags,
+  matchSkillGlob,
+  filterToolMap,
+  buildToolProtocol,
+  TOOL_DESCRIPTIONS,
+  fastThinkingLevelForModel,
+  isProviderName,
+  isThinkingLevel,
+} from "./launch/flags";
+import {
+  tmuxSessionName,
+  gitDirtyCount,
+  allocateTmuxSession,
+  shouldEnableCurrentTmuxMouse,
+  tmuxLaunchCommand,
+  tmuxProfileCommands,
+  resolveWorktree,
+  shellQuote,
+  type TmuxCreateResult,
+  type TmuxProfileCommand,
+} from "./launch/tmux";
+import {
+  type InFlightAbortHarness,
+  type PromptInputQueue,
+  PASTE_START,
+  PASTE_END,
+  isStandaloneBackspace,
+  CURSOR_COMBO_REWRITES,
+  matchCursorCombo,
+  rewriteCursorCombos,
+  queuePromptInputChunk,
+  captureLivePromptInputChunk,
+  restoreQueuedLinesToPrefill,
+  createInFlightAbortHarness,
+} from "./launch/input";
+import {
+  gatedStdout,
+  formatTaskSubEvent,
+  logTaskSubEvent,
+  createStreamEvents,
+  shouldUseOneShotTui,
+} from "./launch/stream";
+import {
+  WORKFLOW_NAMES,
+  isWorkflowSkill,
+  runWorkflowEngine,
+} from "./launch/workflow";
+
+export {
+  type LaunchFlags,
+  parseFlags,
+  matchSkillGlob,
+  filterToolMap,
+  buildToolProtocol,
+  TOOL_DESCRIPTIONS,
+  fastThinkingLevelForModel,
+  isProviderName,
+  isThinkingLevel,
+  tmuxSessionName,
+  gitDirtyCount,
+  allocateTmuxSession,
+  shouldEnableCurrentTmuxMouse,
+  tmuxLaunchCommand,
+  tmuxProfileCommands,
+  resolveWorktree,
+  shellQuote,
+  type TmuxCreateResult,
+  type TmuxProfileCommand,
+  type InFlightAbortHarness,
+  type PromptInputQueue,
+  PASTE_START,
+  PASTE_END,
+  isStandaloneBackspace,
+  CURSOR_COMBO_REWRITES,
+  matchCursorCombo,
+  rewriteCursorCombos,
+  queuePromptInputChunk,
+  captureLivePromptInputChunk,
+  restoreQueuedLinesToPrefill,
+  createInFlightAbortHarness,
+
+  gatedStdout,
+  formatTaskSubEvent,
+  logTaskSubEvent,
+  createStreamEvents,
+  shouldUseOneShotTui,
+  WORKFLOW_NAMES,
+  isWorkflowSkill,
+  runWorkflowEngine,
+};
 export function normalizeSlashAlias(input: string): string {
   if (input === "/login" || input.startsWith("/login ")) return `/provider login${input.slice("/login".length)}`;
   if (input === "/settings") return "/config";
@@ -533,539 +196,12 @@ export function normalizeSlashAlias(input: string): string {
   return input;
 }
 
-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 = () => {
-    // Ctrl+C is a hard terminal break. Older jeo softened the first press into
-    // "abort current run; press again to exit", which left users trapped in raw
-    // TTY/TUI states when they expected the terminal to stop. Abort the controller
-    // for cleanup observers, then invoke the hard-exit hook immediately.
-    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");
-    // Bracketed paste is DATA, not keystrokes (the prompt_toolkit contract):
-    // marker-carrying and mid-paste chunks go straight to the input queue BEFORE
-    // any ESC interpretation — the markers themselves contain ESC, and a paste
-    // must never be classified as cancel/noise.
-    if (text.includes(PASTE_START) || opts.pasteActive?.()) {
-      opts.onBufferedInput?.(text);
-      return;
-    }
-    // Ctrl+O — detail view. Exact-match like the lone-ESC cancel: a raw \u000f
-    // keystroke arrives as its own chunk; embedded \u000f inside pasted/streamed
-    // data must NOT trigger the view.
-    if (text === "\u000f") {
-      opts.onDetailKey?.();
-      return;
-    }
-    // Arrow / PageUp / PageDown — scroll the open Ctrl+O detail panel. Exact-match
-    // (whole chunk) like Ctrl+O so embedded sequences in pasted/streamed data don't
-    // trigger; bracketed paste already returned above. When the panel is closed the
-    // hook is a no-op, so these keys stay inert mid-turn as before.
-    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);
-  };
+const PROVIDER_DEFAULT: Record<ProviderName, string> = { anthropic: "sonnet", openai: "gpt-5.5", gemini: "flash", antigravity: "antigravity/gemini-3-pro-high", ollama: "fast" };
 
-  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);
-      }
-    },
-  };
-}
-
-/** The exact resume command printed on REPL exit (and testable in isolation) —
- *  same convention as the `--list` handler's hint. */
 export function formatResumeHint(sessionId: string): string {
   return `Resume with: jeo launch --resume ${sessionId}`;
 }
-export function parseFlags(args: string[], cwd: string = process.cwd()): LaunchFlags {
-  // maxSteps 0 = dynamic: the engine's process-driven budget extends itself while the
-  // turn shows progress instead of stopping at a hardcoded count (old default: 100).
-  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");
-}
-
-/**
- * Resolve a git worktree path (gjc `--worktree <path>` parity). If the path
- * already exists it is reused as-is; otherwise a new worktree is created on a
- * branch derived from the path basename. Returns the absolute worktree path.
- */
-function resolveWorktree(cwd: string, wt: string): string {
-  const abs = path.isAbsolute(wt) ? wt : path.resolve(cwd, wt);
-  if (fs.existsSync(abs)) return abs;
-  if (!Bun.which("git")) {
-    console.error("error: --worktree requires git on PATH");
-    process.exit(1);
-  }
-  const branch = (path.basename(abs).replace(/[^a-zA-Z0-9_-]/g, "-") || "jeo-wt");
-  const withBranch = Bun.spawnSync(["git", "worktree", "add", "-b", branch, abs], {
-    cwd,
-    stdout: "pipe",
-    stderr: "pipe",
-  });
-  if (withBranch.exitCode !== 0) {
-    // Branch may already exist; retry attaching the existing branch.
-    const plain = Bun.spawnSync(["git", "worktree", "add", abs], {
-      cwd,
-      stdout: "pipe",
-      stderr: "pipe",
-    });
-    if (plain.exitCode !== 0) {
-      console.error(
-        `error: failed to create git worktree at ${abs}: ${withBranch.stderr.toString().trim()}`,
-      );
-      process.exit(1);
-    }
-  }
-  return abs;
-}
-
-/** The bundled workflow skills that run through a dedicated engine (deep-interview /
- *  ralplan / team / ultragoal), not the ordinary agent loop. Single source of truth —
- *  the menu listing, the dispatch guards, and the engine switch all read from here. */
-export const WORKFLOW_NAMES = ["deep-interview", "ralplan", "team", "ultragoal"] as const;
-
-/** True when a skill name is one of the bundled workflow engines. */
-export function isWorkflowSkill(name: string): boolean {
-  return (WORKFLOW_NAMES as readonly string[]).includes(name);
-}
-
-/** Dispatch a bundled workflow by name to its engine. Keeps the name→engine mapping in
- *  ONE place so the one-shot and interactive skill runners can't drift apart. */
-export function runWorkflowEngine(
-  name: string,
-  opts: DeepInterviewEngineOptions & RalplanEngineOptions & TeamEngineOptions & UltragoalEngineOptions,
-): Promise<{ ok: boolean; reason?: string }> {
-  if (name === "deep-interview") return runDeepInterviewEngine(opts);
-  if (name === "ralplan") return runRalplanEngine(opts);
-  if (name === "team") return runTeamEngine(opts);
-  return runUltragoalEngine(opts);
-}
 
 export async function runLaunchCommand(args: string[]): Promise<void> {
   let cwd = process.cwd();
@@ -1868,9 +1004,13 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     cols: terminalSize().cols,
     unicode: supportsUnicode(),
     color: welcomeTheme.color,
+    center: true,
     accent: accentPaint(welcomeTheme),
     accentShadow: accentShadowPaint(welcomeTheme),
   };
+  // gjc-style fresh-start clear so the banner opens atop a clean screen. TTY only,
+  // never mid-turn (scrollback flood). ponytail: add an opt-out env if anyone misses their scrollback.
+  if (process.stdout.isTTY) process.stdout.write(clearScreen());
   // Launch sweep: the DNA Claw's gradient loops seamlessly (default 2 full
   // cycles, JEO_WELCOME_ANIM_CYCLES overrides), ending on the static banner.
   // Truecolor TTYs only; JEO_NO_WELCOME_ANIM=1 opts out.
@@ -2083,7 +1223,8 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   let keyFilter: PassThrough | undefined;
   // Holder for the active readline so the input filter can see the current line
   // buffer (used by the empty-line backspace guard below). Set after rl is created.
-  let activeRl: { line?: string } | undefined;
+  let activeRl: { line?: string; cursor?: number } | undefined;
+
   if (multilineInput) {
     const kf = new PassThrough();
     (kf as unknown as { isTTY: boolean }).isTTY = true;
@@ -2125,6 +1266,26 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           if (data.startsWith(seq, i)) { out += SENTINEL; i += seq.length; matched = true; break; }
         }
         if (matched) continue;
+        // Normalize macOS/fixterms combo cursor keys readline ignores (Option/Cmd+arrow,
+        // Option/Cmd+Backspace) into the canonical control bytes it DOES act on.
+        const combo = matchCursorCombo(data, i);
+        if (combo) { out += combo[1]; i += combo[0].length; continue; }
+        // Up/Down inside a multi-line / wrapped draft move the caret between the box's
+        // visual rows (textarea feel). Only when no slash list or history panel owns ↑/↓,
+        // and only away from the top/bottom edge — at the edge the keys fall through to
+        // readline so ↑/↓ still recalls input history.
+        if ((data.startsWith("\u001b[", i) || data.startsWith("\u001bO", i)) && (data[i + 2] === "A" || data[i + 2] === "B")) {
+          const dir = data[i + 2] === "A" ? "up" : "down";
+          const line = activeRl?.line ?? "";
+          if (line.length > 0 && navMatches.length === 0 && promptHistoryLines == null && activeRl) {
+            const winCols = Math.max(24, (process.stdout.columns ?? 80) - 1);
+            const textWidth = Math.max(1, Math.max(24, Math.min(120, winCols)) - 6);
+            const cur = typeof activeRl.cursor === "number" ? activeRl.cursor : line.length;
+            const next = verticalCursorOffset(expandSentinel(line), cur, textWidth, dir);
+            if (next != null) { activeRl.cursor = next; i += 3; continue; }
+          }
+          out += data.slice(i, i + 3); i += 3; continue;
+        }
         if (loneLfShiftEnter && data[i] === "\n") { out += SENTINEL; i += 1; continue; } // lone LF = Shift+Enter (opt-in)
         out += data[i]; i += 1;
       }
@@ -2225,7 +1386,12 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       pasteLineFired = true;
       return;
     }
-    if (!interactiveTurnActive) pendingStdinLines.push(l);
+    // A select picker (/model, /agents, …) reads keypresses directly while NO
+    // rl.question is active, so its filter-text + selecting Enter fire an ORPHAN
+    // `line` event here. Queuing that would auto-serve the leftover filter as the
+    // next prompt (the "/model · /agents leaves typed text behind" bug). Drop it:
+    // the picker owns those keystrokes and clears the readline buffer on exit.
+    if (!interactiveTurnActive && !pickerActive) pendingStdinLines.push(l);
   });
   let stdinClosed = false;
   let notifyStdinClosed: (() => void) | undefined;
@@ -2402,6 +1568,10 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   // Row (within the reservation) where the real cursor was last parked; the next
   // drawFooter/disarmPreview must hop back to the top from here before painting.
   let footerParkedRow = 0;
+  // The footer's last painted lines (padded to the reservation height). The resize
+  // relayout uses these to find the frame's physical top at the live width — a full-width
+  // line painted at an older, wider geometry reflows onto extra rows after a width shrink.
+  let lastDrawnLines: string[] = [];
   const padToFooter = (lines: string[]): string[] => {
     if (lines.length >= footerRows) return lines.slice(0, footerRows);
     return [...lines, ...new Array(footerRows - lines.length).fill("")];
@@ -2439,6 +1609,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       s += toColumn(1) + "\x1b[?25h";
       out.write(s);
       footerRendered = 0;
+      lastDrawnLines = [];
     } else {
       out.write("\x1b[?25h");
     }
@@ -2581,6 +1752,9 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     // and no row can spill past it — the bug fix that kept `@folder<more text>`
     // typing from scrolling the input box (and prior output) off the top.
     const padded = padToFooter(lines);
+    // Remember the exact painted frame so resize/disarm can clear its real physical
+    // footprint at the (possibly changed) live width instead of trusting logical rows.
+    lastDrawnLines = padded;
     // Pure caret moves (arrow keys) change no content — include the caret cell in
     // the repaint key so they still reposition the terminal cursor.
     const tRow = lines.length ? Math.min(footerCursor.row, footerRendered - 1) : 0;
@@ -3176,8 +2350,43 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       lastIdleCols = cols;
       lastIdleRows = rows;
       try {
-        disarmPreview();
-        armPreview();
+        // Resolution-safe relayout, anchored to the CURSOR (not the screen bottom). The
+        // previous frame was painted at the OLD width; on resize the terminal reflows its
+        // full-width rows AND repositions the frame — a width shrink wraps lines and floats
+        // the frame UP by its blank tail, while a height grow leaves the frame high while
+        // adding rows at the bottom. In every case the terminal keeps the REAL cursor on
+        // the input caret's cell, so the caret is the one stable anchor. The old logical
+        // disarm→arm cycle ignored this, clearing the wrong rows and scrolling the stray
+        // frame into scrollback (the stacked status-bar corruption).
+        //
+        // Hop UP from the caret to the frame's physical top — `footerParkedRow` logical
+        // rows of content sit above the caret; recompute their PHYSICAL height at the new
+        // width (wrapped lines count for more) — then clear-to-end-of-display in one op.
+        // This wipes the whole stray frame regardless of which way it drifted, and is
+        // banner-safe: the hop stops exactly at the frame top (just below the static
+        // content). ED is safe here — this path emits no bottom-margin scroll, so (unlike
+        // the mid-turn ledger flush) tmux never copies the erased rows into history.
+        const c = Math.max(1, cols);
+        let abovePhysical = 0;
+        for (let i = 0; i < footerParkedRow && i < lastDrawnLines.length; i++) {
+          abovePhysical += Math.max(1, Math.ceil(Math.max(1, visibleWidth(lastDrawnLines[i]!)) / c));
+        }
+        // The caret may sit on a LOWER physical sub-row of its own (now-wrapped) line: a
+        // long input wraps and the terminal keeps the cursor on its cell, so add the
+        // caret's sub-row offset (caret column / width) or the hop stops below the top.
+        const caretSubRow = Math.floor(Math.max(0, footerCursor.col - 1) / c);
+        const hopUp = abovePhysical + caretSubRow;
+        let s = (hopUp > 0 ? cursorUp(hopUp) : "") + toColumn(1) + clearToEnd();
+        // Re-pin a clean reservation to the screen bottom and repaint. ED already blanked
+        // from the frame top down to the bottom, so just position at the bottom region.
+        footerRows = previewRowsFor(rows);
+        s += `\x1b[${Math.max(1, rows)};1H`;
+        if (footerRows > 1) s += cursorUp(footerRows - 1);
+        s += toColumn(1);
+        out.write(s);
+        footerRendered = footerRows;
+        footerParkedRow = 0;
+        lastFooterKey = "";
         drawFooter(promptHistoryLines ? historyPreviewLines(promptHistoryLines) : previewLines(typedLine, navIdx));
       } catch { /* ignore resize render races */ }
     };
@@ -3314,7 +2523,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         // scrollback, and re-render the welcome banner so /clear looks like a fresh launch.
         if (process.stdout.isTTY) {
           disarmPreview();
-          process.stdout.write("\x1b[2J\x1b[3J\x1b[H"); // clear screen + scrollback + cursor home
+          process.stdout.write(clearScreen()); // clear screen + scrollback + cursor home
           console.log(renderWelcome(welcomeData).join("\n"));
         }
         console.log("(history cleared — back to the start screen)");
@@ -3419,7 +2628,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
               // so the resumed view reads like a fresh, intact screen.
               if (process.stdout.isTTY) {
                 disarmPreview();
-                process.stdout.write("\x1b[2J\x1b[3J\x1b[H");
+                process.stdout.write(clearScreen());
                 console.log(renderWelcome(welcomeData).join("\n"));
               }
               const sep = "─".repeat(Math.min(48, Math.max(20, (process.stdout.columns ?? 80) - 1)));