jeo-code 0.6.3 → 0.6.5

package/src/commands/launch.ts

@@ -19,8 +19,9 @@ import { formatForgeBox } from "../tui/components/forge";
 import { interactiveOAuthLogin } from "./auth";
 import { logoutOAuth } from "../auth";
 import type { AuthProvider } from "../auth";
-import { matchSlash, isSlashAttempt, formatSlashCommandList, formatSlashPreview, slashPreviewMatches, activeTriggerToken, tabCompleteSelection, type SlashCommandInfo } from "../tui/components/slash";
+import { matchSlash, isSlashAttempt, suggestSlashCommands, formatSlashCommandList, formatSlashPreview, slashPreviewMatches, activeTriggerToken, tabCompleteSelection, type SlashCommandInfo } from "../tui/components/slash";
 import { staticCompletionContext, readlineCompleter, formatCompletionPreview, tokenize, type CompletionContext } from "../tui/components/autocomplete";
+import { normalizeBaseUrl } from "./setup-helpers";
 import { EVOLUTION_STAGES, animateAsciiArt } from "../tui/components/ascii-art";
 import { getEvolutionTip } from "../tui/components/evolution";
 import { renderWelcome, playWelcomeSweep } from "../tui/components/welcome";
@@ -37,6 +38,7 @@ import { readGlobalConfig, saveConfigPatch } from "../agent/state";
 import { rememberModelPatch, recentModelsForDisplay } from "../agent/model-recency";
 import { describeModel, describeAllProviders, thinkingMaxTokens, discoverModels, flattenModels, resolveSelection, catalogMetadata, resolveRoleModel, CODEX_MODELS, qualifyModelId } from "../ai";
 import type { ProviderModelsResult, PickEntry, ProviderName, ModelRole, ThinkLevel } from "../ai";
+import { readGoalState, writeGoalState, clearGoalState, verifyGoal } from "../agent/goal-verifier";
 
 import { listAliases } from "../ai/model-registry";
 
@@ -45,7 +47,6 @@ import { SelectList, renderSelectList, type SelectItem } from "../tui/components
 import {
   formatModelLine,
   formatProviderPanel,
-  emitLoginCleanup,
   formatAgentsPanel,
   formatAgentDetail,
   formatConfigPanel,
@@ -56,12 +57,12 @@ import {
 } from "../tui/components/config-panel";
 import { liveModelPicker, renderLiveModelPicker, type ModelAssignmentBadge } from "../tui/components/live-model-picker";
 
-import { providerPicker, renderProviderPicker, buildProviderChoices } from "../tui/components/provider-picker";
+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 { 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";
@@ -91,438 +92,100 @@ import {
   sessionPath,
   appendCompaction,
 } from "../agent/session";
-import { clearLine, cursorUp, toColumn, truncate as truncateAnsi, size as terminalSize, resetMouseTracking } from "../tui/terminal";
+import { clearLine, cursorUp, toColumn, truncate as truncateAnsi, size as terminalSize, resetMouseTracking, clearScreen, clearToEnd } 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;
-  }
-}
-
-/**
- * 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";
@@ -532,539 +195,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);
-  };
-
-  process.on("SIGINT", handleSigint);
-  if (captureEsc) {
-    stdin.on("data", handleData);
-    if (stdin.setRawMode && !wasRaw) {
-      stdin.setRawMode(true);
-      rawChanged = true;
-    }
-    stdin.resume?.();
-  }
+const PROVIDER_DEFAULT: Record<ProviderName, string> = { anthropic: "sonnet", openai: "gpt-5.5", gemini: "flash", antigravity: "antigravity/gemini-3-pro-high", ollama: "fast" };
 
-  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();
@@ -1549,14 +685,48 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         // Todos checklist used to end a finished turn stuck at "✓0 ◐1 ·4 / 5"
         // because nothing ever forced the model to update item statuses).
         let turnTodos: { title: string; status: string }[] = [];
-        const onBeforeDone = (): string | null => {
+        const onBeforeDone = async (reason: string): Promise<string | null> => {
           const unfinished = turnTodos.filter(t => t.status !== "done");
-          if (turnTodos.length === 0 || unfinished.length === 0) return null;
-          return (
-            `Your todo list still shows ${unfinished.length} unfinished item(s): ${unfinished.map(t => `"${t.title}"`).join(", ")}. ` +
-            `Reconcile the plan first — call the todo tool resending the FULL list with every actually-completed item marked "done" ` +
-            `(drop items that no longer apply), then call done again.`
-          );
+          if (turnTodos.length > 0 && unfinished.length > 0) {
+            return (
+              `Your todo list still shows ${unfinished.length} unfinished item(s): ${unfinished.map(t => `"${t.title}"`).join(", ")}. ` +
+              `Reconcile the plan first — call the todo tool resending the FULL list with every actually-completed item marked "done" ` +
+              `(drop items that no longer apply), then call done again.`
+            );
+          }
+
+          const goalState = await readGoalState(cwd);
+          if (goalState && goalState.condition) {
+            const reBlockCount = goalState.verdicts.filter(v => v.verdict === "NOT_MET" || v.verdict === "IMPOSSIBLE").length;
+            const MAX_RE_BLOCKS = 2;
+
+            if (reBlockCount >= MAX_RE_BLOCKS) {
+              if (tui) tui.events().onNotice?.(`[Goal Verifier] Re-block cap of ${MAX_RE_BLOCKS} reached. Auto-allowing done.`);
+              else console.log(`[Goal Verifier] Re-block cap of ${MAX_RE_BLOCKS} reached. Auto-allowing done.`);
+              return null;
+            }
+
+            if (tui) tui.events().onNotice?.("[Goal Verifier] Running goal verification...");
+            const verdict = await verifyGoal(goalState.condition, history, sessionModel);
+
+            goalState.verdicts.push({
+              at: Date.now(),
+              verdict: verdict.verdict,
+              gap: verdict.reason,
+            });
+            await writeGoalState(goalState, cwd);
+
+            if (verdict.verdict === "NOT_MET" || verdict.verdict === "IMPOSSIBLE") {
+              const prefix = verdict.verdict === "IMPOSSIBLE" ? "[IMPOSSIBLE] " : "";
+              return (
+                `Goal verifier check failed: The goal "${goalState.condition}" is not yet met.\n` +
+                `Reason: ${prefix}${verdict.reason}\n` +
+                `Please address the remaining gaps and call done again.`
+              );
+            }
+          }
+
+          return null;
         };
         const fullTools = {
           ...DEFAULT_TOOLS,
@@ -1836,6 +1006,9 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     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.
@@ -2090,6 +1263,10 @@ 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; }
         if (loneLfShiftEnter && data[i] === "\n") { out += SENTINEL; i += 1; continue; } // lone LF = Shift+Enter (opt-in)
         out += data[i]; i += 1;
       }
@@ -2190,7 +1367,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;
@@ -2367,6 +1549,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("")];
@@ -2404,6 +1590,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");
     }
@@ -2473,7 +1660,10 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     const caret = rli.line === line && typeof rli.cursor === "number" ? rli.cursor : line.length;
     const { accent: boxAccent, shadow: boxShadow } = boxAccents(line);
     const frame = renderInputFrame(expandSentinel(line), {
-      cols,
+      // Cap the input box at 120 cols to match the live-turn box (renderLiveInputBox)
+      // and the user-card width, so the box doesn't visibly jump width on the
+      // idle→live transition on wide terminals. The status bar below stays full-width.
+      cols: Math.min(120, cols),
       color: true,
       unicode: true,
       accent: boxAccent,
@@ -2543,6 +1733,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;
@@ -3121,16 +2314,83 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     // Idle-prompt resize: re-reserve the footer at the new terminal height so the
     // fixed reservation stays accurate (otherwise the next paint would target the
     // old row count and either over-shoot or under-paint the reserved region).
-    const idleResizeHandler = () => {
+    // gjc-style responsiveness: re-reserve the footer IMMEDIATELY on the first resize
+    // event (leading edge → no lag), then cap re-reservations to ~30fps during a
+    // drag-resize, with a trailing settle so the FINAL height is always reserved exactly.
+    // Skip same-geometry events; each re-reserve disarms→arms so it must not run per-event.
+    const RESIZE_THROTTLE_MS = 33;
+    let idleResizeTimer: ReturnType<typeof setTimeout> | undefined;
+    let lastIdleAt = 0;
+    let lastIdleCols = process.stdout.columns ?? 80;
+    let lastIdleRows = process.stdout.rows ?? 24;
+    const reReserveFooter = () => {
       if (!previewArmed) return;
+      const cols = process.stdout.columns ?? 80;
+      const rows = process.stdout.rows ?? 24;
+      if (cols === lastIdleCols && rows === lastIdleRows) return;
+      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 */ }
     };
+    const idleResizeHandler = () => {
+      if (!previewArmed) return;
+      const now = Date.now();
+      if (now - lastIdleAt >= RESIZE_THROTTLE_MS) {
+        lastIdleAt = now;
+        reReserveFooter();
+        return;
+      }
+      if (idleResizeTimer) clearTimeout(idleResizeTimer);
+      idleResizeTimer = setTimeout(() => {
+        idleResizeTimer = undefined;
+        lastIdleAt = Date.now();
+        reReserveFooter();
+      }, RESIZE_THROTTLE_MS);
+    };
     process.stdout.on("resize", idleResizeHandler);
-    promptListenerCleanups.push(() => process.stdout.off("resize", idleResizeHandler));
+    promptListenerCleanups.push(() => {
+      process.stdout.off("resize", idleResizeHandler);
+      if (idleResizeTimer) clearTimeout(idleResizeTimer);
+    });
   }
 
   while (true) {
@@ -3244,7 +2504,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)");
@@ -3349,7 +2609,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)));
@@ -3548,6 +2808,32 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         }
         continue;
       }
+      if (input === "/goal" || input.startsWith("/goal ")) {
+        const arg = input.substring(5).trim();
+        if (!arg) {
+          const current = await readGoalState(cwd);
+          if (current) {
+            console.log(`Current goal: "${current.condition}" (set at ${new Date(current.setAt).toLocaleTimeString()})`);
+          } else {
+            console.log("Usage: /goal <condition>   (set a natural language stop condition for the session)");
+            console.log("       /goal clear         (clear the current goal)");
+          }
+          continue;
+        }
+        if (arg === "clear" || arg === "none") {
+          await clearGoalState(cwd);
+          console.log("Goal cleared.");
+          continue;
+        }
+        const state = {
+          condition: arg,
+          setAt: Date.now(),
+          verdicts: [],
+        };
+        await writeGoalState(state, cwd);
+        console.log(`Goal set to: "${arg}"`);
+        continue;
+      }
       // ---- gjc-parity inspection commands ------------------------------------
       if (input === "/usage") {
         const total = sessionUsage.inputTokens + sessionUsage.outputTokens;
@@ -3632,8 +2918,17 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       }
       if (input.startsWith("/provider") && (input === "/provider" || input[9] === " ")) {
         const tokens = input.substring(9).trim().split(/\s+/).filter(Boolean);
-        let name = (tokens[0] ?? "").toLowerCase();
-        const explicitModel = tokens[1];
+        const name = (tokens[0] ?? "").toLowerCase();
+        // gjc-parity (semantic): /provider is ONBOARDING ONLY — set up OAuth credentials
+        // or an API-compatible endpoint. Switching the active provider/model lives in /model.
+        const providerOnboardingUsage = (): string[] => [
+          "Provider onboarding — set up credentials or an API-compatible endpoint:",
+          "  OAuth / subscription : /provider login [anthropic|openai|gemini|antigravity]   (alias: /login)",
+          "  API-compatible       : /provider add --base-url <url> [--model <model>] [--compat openai]   (reads OPENAI_API_KEY)",
+          "                         show current / clear: /provider add   ·   /provider add clear",
+          "  Logout               : /logout <provider>",
+          "Switch the active model or provider with /model.",
+        ];
         // `/provider login|auth [name]` → run OAuth login from the REPL.
         if (name === "login" || name === "auth") {
           const cloud = ["anthropic", "openai", "gemini", "antigravity"] as const;
@@ -3643,14 +2938,13 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
             if (process.stdin.isTTY && process.stdout.isTTY) {
               target = await pickCloudProvider(statuses);
             } else {
-              // No provider given → show current status and let the user pick.
               console.log("Log in to which provider?");
               cloud.forEach((p, i) => {
                 const st = statuses.find(s => s.name === p);
                 console.log(`  ${i + 1}) ${p.padEnd(10)} ${st?.ready ? `✓ ${st.label}` : "· not ready"}`);
               });
-              const ans = (await promptInput("Choose [1-3] or name (blank to cancel): ")).trim().toLowerCase();
-              const byNum: Record<string, string> = { "1": "anthropic", "2": "openai", "3": "gemini" };
+              const ans = (await promptInput(`Choose [1-${cloud.length}] or name (blank to cancel): `)).trim().toLowerCase();
+              const byNum: Record<string, string> = Object.fromEntries(cloud.map((p, i) => [String(i + 1), p]));
               target = byNum[ans] ?? ((cloud as readonly string[]).includes(ans) ? ans : undefined);
             }
             if (!target) {
@@ -3661,131 +2955,107 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           console.log(`Starting OAuth login for ${target}…`);
           try {
             const { email } = await interactiveOAuthLogin(target as AuthProvider, rl);
-            // Tidy back to the initial query-input screen: the OAuth flow printed
-            // browser prompts / "waiting…" lines that clutter scrollback. Clear the
-            // screen + scrollback and re-render the welcome (same path as /clear),
-            // then a single concise confirmation. lastPickIndex is still seeded so
-            // `/model #N` works; the verbose live-model dump is dropped (it cluttered).
+            console.log(`[SUCCESS] OAuth login complete for ${target}${email ? ` (${email})` : ""}. Tokens saved to ~/.jeo/config.json.`);
             const live = await refreshLiveModelsCache();
             const after = (await describeAllProviders()).find(s => s.name === target);
+            if (after) console.log(`  status → ${after.name}: ${after.ready ? `✓ ${after.label}` : after.label}`);
             const forProvider = live.filter(r => r.provider === target);
-            if (forProvider.some(r => r.ok && r.models.length > 0)) lastPickIndex = flattenModels(forProvider);
-            // Tidy back to the initial query-input screen: the OAuth flow printed
-            // browser prompts / "waiting…" lines that clutter scrollback. emitLoginCleanup
-            // clears + re-renders the welcome (same path as /clear) then prints one
-            // confirmation; the verbose live-model dump is dropped (lastPickIndex is
-            // still seeded so /model #N works). Orchestration is unit-tested.
-            emitLoginCleanup(
-              {
-                clear: () => { disarmPreview(); process.stdout.write("\x1b[2J\x1b[3J\x1b[H"); },
-                write: line => console.log(line),
-              },
-              {
-                isTty: process.stdout.isTTY === true,
-                provider: target,
-                email,
-                ready: after?.ready ?? false,
-                label: after?.label,
-                welcomeLines: renderWelcome(welcomeData),
-              },
-            );
+            if (forProvider.some(r => r.ok && r.models.length > 0)) {
+              lastPickIndex = flattenModels(forProvider);
+              const viaCatalog = forProvider.some(r => r.fallback);
+              console.log(`  ${viaCatalog ? "catalog" : "live"} ${target} models → /model #N${viaCatalog ? "  (live list endpoint rejected this token; showing known models)" : ""}`);
+              logLines(formatPickListWithCapabilities(lastPickIndex, { cap: 12 }));
+            } else {
+              const failed = forProvider.find(r => !r.ok);
+              if (failed?.error) console.log(`  live ${target} models unavailable: ${failed.error}`);
+            }
           } catch (err) {
             console.log(`[FAILED] ${(err as Error).message} — or set ${target.toUpperCase()}_API_KEY.`);
+          } finally {
+            // The OAuth manual-code prompt opens an rl.question that is aborted the
+            // instant the browser callback (or a failure) settles the flow. Bun leaves
+            // that abandoned question's buffer behind, so the next prompt would adopt
+            // it as residual prefill and resurrect the submitted "/provider login" in
+            // the input box. Reset the readline line buffer so the prompt starts empty.
+            const rli = rl as unknown as { line?: string; cursor?: number };
+            rli.line = "";
+            rli.cursor = 0;
           }
           continue;
         }
-        const cfgNow = await readGlobalConfig();
-        const statuses = await describeAllProviders(cfgNow);
-        if (!name) {
-          if (process.stdin.isTTY && process.stdout.isTTY) {
-            // gjc-style interactive picker (grouped ready / needs-setup, current marked)
-            // instead of a static text dump — arrows + Enter switch, Esc cancels.
-            const current = (await describeModel(sessionModel || cfgNow.defaultModel, cfgNow)).provider;
-            const items = buildProviderChoices(statuses, true, current).map(c => ({
-              value: c.value as string,
-              label: c.label,
-              hint: c.hint,
-              group: c.group,
-            }));
-            const picked = await pickFromOptions("Select a provider  ↑↓ move · Enter switch · Esc cancel", items);
-            if (!picked) { console.log("(switch cancelled)"); continue; }
-            name = picked.toLowerCase(); // fall through to the switch logic below
-          } else {
-            console.log("Providers (credential · base URL):");
-            logLines(formatProviderPanel(statuses));
-            console.log("Switch with: /provider <name> [model]  ·  choose models: /model");
+        // `/provider add --base-url <url> [--model <m>] [--compat openai]` → register an
+        // OpenAI-compatible endpoint (sets openaiBaseUrl). gjc flag style; bare positional
+        // URL/model still accepted for leniency. `/provider add clear` removes it.
+        if (name === "add") {
+          const rest = tokens.slice(1);
+          if ((rest[0] ?? "").toLowerCase() === "clear") {
+            await saveConfigPatch(() => ({ openaiBaseUrl: undefined }));
+            await refreshLiveModelsCache();
+            console.log("OpenAI-compatible base URL cleared — saved to ~/.jeo/config.json.");
             continue;
           }
-        }
-        if (!isProviderName(name)) {
-          console.log(`Unknown provider '${name}'. Known: ${statuses.map(s => s.name).join(", ")}.`);
-          continue;
-        }
-        const st = statuses.find(s => s.name === name);
-        if (st && !st.ready) {
-          console.log(`! ${name} is not ready (${st.label}) — set ${st.envVar ?? "the provider key"} or configure a compatible base URL. Switching anyway.`);
-        }
-        const live = await getLiveModels();
-        const forProvider = live.filter(r => r.provider === name);
-        const providerPick = flattenModels(forProvider);
-        const currentResolved = (await describeModel(sessionModel || cfgNow.defaultModel)).resolved;
-        let pickedFromPicker = false;
-        let target = explicitModel ?? PROVIDER_DEFAULT[name];
-        if (!explicitModel && providerPick.length && process.stdin.isTTY && process.stdout.isTTY) {
-          const picked = await pickLiveProviderModel(name, providerPick, currentResolved, st && !st.ready && !selectableThoughNotReady(st) ? [name] : []);
-          if (!picked) {
-            console.log("(cancelled)");
+          let baseUrl: string | undefined;
+          let modelArg: string | undefined;
+          let compat: string | undefined;
+          for (let i = 0; i < rest.length; i++) {
+            const t = rest[i]!;
+            if (t === "--base-url" || t === "--url") baseUrl = rest[++i];
+            else if (t === "--model") modelArg = rest[++i];
+            else if (t === "--compat") compat = (rest[++i] ?? "").toLowerCase();
+            else if (t === "--api-key-env" || t === "--provider") { i++; /* gjc-only: jeo has no named-provider registry — ignored */ }
+            else if (!t.startsWith("--") && baseUrl === undefined) baseUrl = t; // positional url
+            else if (!t.startsWith("--") && modelArg === undefined) modelArg = t; // positional model
+          }
+          if (compat && compat !== "openai") {
+            console.log(`Only --compat openai is supported (got '${compat}') — jeo registers a single OpenAI-compatible endpoint.`);
             continue;
           }
-          pickedFromPicker = true;
-          target = qualifyModelId(picked.model, picked.provider);
-        } else if (explicitModel && providerPick.length) {
-          const sel = resolveSelection(providerPick, explicitModel);
-          if (sel.kind === "index" || sel.kind === "match") {
-            target = qualifyModelId(sel.entry.model, sel.entry.provider);
-            if (st && !st.ready) {
-              if (selectableThoughNotReady(st)) {
-                console.log(notReadyWarning(st));
-              } else {
-                console.log(`Cannot select ${sel.entry.model}: ${name} is not ready (${st.label}). Set ${st.envVar ?? "the provider key"} first.`);
-                continue;
-              }
-            }
-          } else if (sel.kind === "ambiguous") {
-            console.log(`'${explicitModel}' matches ${sel.matches.length} ${name} models — be more specific:`);
-            for (const e of sel.matches.slice(0, 12)) console.log(`  #${e.index}  ${e.model} (${e.provider})`);
+          if (!baseUrl) {
+            const cur = (await readGlobalConfig()).openaiBaseUrl;
+            console.log(cur ? `OpenAI-compatible base URL: ${cur}` : "No OpenAI-compatible base URL set.");
+            console.log("Set one with: /provider add --base-url <url> [--model <model>]   ·   clear with: /provider add clear");
             continue;
-          } else if (sel.kind === "out-of-range") {
-            console.log(`#${explicitModel.slice(1)} is out of range for ${name} (1-${sel.max}).`);
+          }
+          const url = normalizeBaseUrl(baseUrl, "");
+          if (!url) {
+            console.log("Provide a base URL, e.g. /provider add --base-url http://localhost:1234/v1");
             continue;
           }
-        } else if (explicitModel?.startsWith("#")) {
-          console.log(`No numbered ${name} model list is available yet.`);
-          continue;
-        }
-        const { resolved, provider } = await describeModel(target);
-        if (explicitModel && provider !== name) {
-          console.log(`! '${target}' resolves to ${provider}, not ${name}. Pick a ${name} model from the live list below.`);
-          if (providerPick.length) logLines(formatPickListWithCapabilities(providerPick, { cap: 20 }));
+          await saveConfigPatch(() => ({ openaiBaseUrl: url }));
+          if (modelArg) {
+            const qualified = qualifyModelId(modelArg, "openai");
+            sessionModel = qualified;
+            await saveConfigPatch(raw => rememberModelPatch(raw, qualified));
+            console.log(`OpenAI-compatible endpoint set: ${url} · default model ${qualified} — saved to ~/.jeo/config.json.`);
+          } else {
+            console.log(`OpenAI-compatible endpoint set: ${url} — saved to ~/.jeo/config.json.`);
+          }
+          const live = await refreshLiveModelsCache();
+          const forProvider = live.filter(r => r.provider === "openai");
+          const pick = flattenModels(forProvider);
+          if (pick.length) {
+            lastPickIndex = pick;
+            console.log("Discovered models at this endpoint — select with /model #N:");
+            logLines(formatPickListWithCapabilities(pick, { cap: 12 }));
+          } else {
+            const failed = forProvider.find(r => !r.ok);
+            console.log(failed?.error ? `  could not list models: ${failed.error}` : "  no models discovered yet — the endpoint may need a key (set OPENAI_API_KEY).");
+          }
           continue;
         }
-        if (pickedFromPicker && await applyPickedModelWithTarget(target)) {
-          if (providerPick.length) lastPickIndex = providerPick;
+        // Bare `/provider` (or `help`): show readiness + the onboarding usage. No switching.
+        if (!name || name === "help") {
+          const cfgNow = await readGlobalConfig();
+          const statuses = await describeAllProviders(cfgNow);
+          console.log("Providers (credential · base URL):");
+          logLines(formatProviderPanel(statuses));
+          for (const line of providerOnboardingUsage()) console.log(line);
           continue;
         }
-        sessionModel = target;
-        // MRU persistence: a provider/model pick becomes the default for EVERY
-        // future session and the head of the recents rotation.
-        await saveConfigPatch(raw => rememberModelPatch(raw, target));
-        console.log(`Model set to ${formatModelLine({ label: target, resolved, provider, ready: st?.ready })} — saved as default`);
-        // Show the provider's live, credentialed catalog so the user can pick a concrete id.
-        if (providerPick.length) {
-          lastPickIndex = providerPick;
-          if (!pickedFromPicker) {
-            console.log(`Live ${name} models — select with /model #N, /provider ${name} #N, or rerun /provider ${name} and use arrows+Enter:`);
-            logLines(formatPickListWithCapabilities(lastPickIndex, { current: resolved }));
-          }
-        }
+        // Anything else (a provider name) used to switch the active provider — that moved
+        // to /model (gjc semantics: /provider onboards, /model selects).
+        console.log(`'/provider ${name}' no longer switches providers — provider/model selection moved to /model.`);
+        console.log("Run /model to pick any provider's model (or /model <id|#N>). /provider now only onboards — see /provider help.");
         continue;
       }
       if (input.startsWith("/logout") && (input === "/logout" || input[7] === " ")) {
@@ -3964,11 +3234,11 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
               for (const e of sel.matches.slice(0, 12)) console.log(`  #${e.index}  ${e.model} (${e.provider})`);
               continue;
             } else if (sel.kind === "out-of-range") {
-              console.log(`#${modelArg.slice(1)} is out of range (1-${sel.max}). Use /model or /provider <name> first.`);
+              console.log(`#${modelArg.slice(1)} is out of range (1-${sel.max}). Use /model first.`);
               continue;
             }
           } else if (modelArg.startsWith("#")) {
-            console.log("Use /model or /provider <name> first to build the numbered live model list.");
+            console.log("Use /model first to build the numbered live model list.");
             continue;
           }
           // Persist a per-role model override to ~/.jeo/config.json (consumed by 'jeo team').
@@ -4038,11 +3308,11 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
               for (const e of sel.matches.slice(0, 12)) console.log(`  #${e.index}  ${e.model} (${e.provider})`);
               continue;
             } else if (sel.kind === "out-of-range") {
-              console.log(`#${chosenModel.slice(1)} is out of range (1-${sel.max}). Use /model or /provider <name> first.`);
+              console.log(`#${chosenModel.slice(1)} is out of range (1-${sel.max}). Use /model first.`);
               continue;
             }
           } else if (chosenModel.startsWith("#")) {
-            console.log("Use /model or /provider <name> first to build the numbered live model list.");
+            console.log("Use /model first to build the numbered live model list.");
             continue;
           }
           await saveConfigPatch(raw => ({ roles: { ...(raw.roles ?? {}), [tier]: chosenModel } }));
@@ -4123,12 +3393,12 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
               for (const e of sel.matches.slice(0, 12)) console.log(`  #${e.index}  ${e.model} (${e.provider})`);
               continue;
             } else if (sel.kind === "out-of-range") {
-              console.log(`#${toSave.slice(1)} is out of range (1-${sel.max}). Use /model or /provider <name> first.`);
+              console.log(`#${toSave.slice(1)} is out of range (1-${sel.max}). Use /model first.`);
               continue;
             }
             // kind "none" → treat `toSave` as a literal model id/alias.
           } else if (toSave.startsWith("#")) {
-            console.log("Use /model or /provider <name> first to build the numbered list.");
+            console.log("Use /model first to build the numbered list.");
             continue;
           }
           // Fall back to the FRESH on-disk default (not the stale session-start snapshot) so a
@@ -4196,11 +3466,11 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
               for (const e of sel.matches.slice(0, 12)) console.log(`  #${e.index}  ${e.model} (${e.provider})`);
               continue;
             } else if (sel.kind === "out-of-range") {
-              console.log(`#${roleModelArg.slice(1)} is out of range (1-${sel.max}). Use /model or /provider <name> first.`);
+              console.log(`#${roleModelArg.slice(1)} is out of range (1-${sel.max}). Use /model first.`);
               continue;
             }
           } else if (roleModelArg.startsWith("#")) {
-            console.log("Use /model or /provider <name> first to build the numbered list.");
+            console.log("Use /model first to build the numbered list.");
             continue;
           }
           if (roleModelArg) {
@@ -4251,12 +3521,12 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
             for (const e of sel.matches.slice(0, 12)) console.log(`  #${e.index}  ${e.model} (${e.provider})`);
             continue;
           } else if (sel.kind === "out-of-range") {
-            console.log(`#${arg.slice(1)} is out of range (1-${sel.max}). Use /model or /provider <name> first.`);
+            console.log(`#${arg.slice(1)} is out of range (1-${sel.max}). Use /model first.`);
             continue;
           }
           // kind "none" → fall through and treat `arg` as a literal model id/alias.
         } else if (arg.startsWith("#")) {
-          console.log("Use /model or /provider <name> first to build the numbered list.");
+          console.log("Use /model first to build the numbered list.");
           continue;
         }
         const label = arg || (sessionModel || defaultModel);
@@ -4282,7 +3552,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           }
         }
         if (arg && liveModelsCache && resolved === label && !liveModelKnown(liveModelsCache, resolved)) {
-          console.log(`  (note: '${resolved}' is not in the live ${provider} catalog — use /model or /provider <name> to pick a valid id)`);
+          console.log(`  (note: '${resolved}' is not in the live ${provider} catalog — use /model to pick a valid id)`);
         }
         const meta = catalogMetadata(resolved);
         if (meta) console.log(`  ${formatCapabilityLine(meta)}`);
@@ -4450,7 +3720,9 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         if (m.length) {
           for (const line of formatSlashCommandList(input, skillSlashDetails)) console.log(line);
         } else {
-          console.log(`Unknown command '${input}'. Try /help.`);
+          const cmds = [...completionContext().slashCommands];
+          const near = suggestSlashCommands(input, cmds);
+          console.log(near.length ? `Unknown command '${input}'. Did you mean ${near.join(", ")}?` : `Unknown command '${input}'. Try /help.`);
         }
         continue;
       }