jeo-code 0.7.31 → 0.7.33

package/src/commands/launch/flags.ts

@@ -6,6 +6,9 @@ export interface LaunchFlags {
   list: boolean;
   resume: boolean;
   resumeId?: string;
+  /** True when `--resume`/`-r` was given with NO value at cold startup (gjc-parity):
+   *  triggers the interactive session picker instead of silently resuming latest. */
+  resumeInteractive: boolean;
   noSession: boolean;
   noTui: boolean;
   /** Explicit step cap from --max-steps; 0 = dynamic (process-driven budget that
@@ -63,9 +66,9 @@ export function fastThinkingLevelForModel(modelId: string): ThinkLevel | undefin
 }
 
 export function parseFlags(args: string[], cwd: string = process.cwd()): LaunchFlags {
-  const flags: LaunchFlags = { list: false, resume: false, noSession: false, noTui: false, maxSteps: 0, message: "", tmux: false, errors: [], print: false, noSkills: false, noTools: false };
+  const flags: LaunchFlags = { list: false, resume: false, resumeInteractive: 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 === "--") {
@@ -115,22 +118,37 @@ export function parseFlags(args: string[], cwd: string = process.cwd()): LaunchF
       i = nextIndex;
     } else if (a === "--smol" || a === "--slow" || a === "--plan") {
       flags.modelRole = a.slice(2) as ModelRole;
-    } else if (a === "--resume" || a === "--continue" || a === "-c") {
+    } else if (a === "--continue" || a === "-c") {
+      // Always silently resume the MOST RECENT session (gjc-parity: no picker for --continue/-c).
       flags.resume = true;
+      flags.resumeInteractive = false;
       const next = args[i + 1];
-      if (next && UUID_REGEX.test(next)) {
+      if (next && !next.startsWith("-")) {
         flags.resumeId = next;
         i++;
       }
-    } else if (a.startsWith("--resume=") || a.startsWith("--continue=") || a.startsWith("-c=")) {
+    } else if (a.startsWith("--continue=") || a.startsWith("-c=")) {
       flags.resume = true;
+      flags.resumeInteractive = false;
       const eqIdx = a.indexOf("=");
-      const val = a.slice(eqIdx + 1);
-      if (UUID_REGEX.test(val)) {
-        flags.resumeId = val;
+      flags.resumeId = a.slice(eqIdx + 1);
+    } else if (a === "--resume" || a === "-r") {
+      // gjc-parity: value present -> resolve as id/prefix directly; no value -> interactive picker.
+      flags.resume = true;
+      const next = args[i + 1];
+      if (next && !next.startsWith("-")) {
+        flags.resumeId = next;
+        flags.resumeInteractive = false;
+        i++;
       } else {
-        rest.push(val);
+        flags.resumeId = undefined;
+        flags.resumeInteractive = true;
       }
+    } else if (a.startsWith("--resume=")) {
+      flags.resume = true;
+      flags.resumeInteractive = false;
+      const eqIdx = a.indexOf("=");
+      flags.resumeId = a.slice(eqIdx + 1);
     } else if (a === "--append-system-prompt" || a.startsWith("--append-system-prompt=")) {
       const { value, nextIndex } = takeValue(args, i, "--append-system-prompt=");
       if (value) flags.appendSystemPromptRaw = value;

package/src/commands/launch/model-slash.ts

@@ -0,0 +1,290 @@
+/**
+ * `/model` slash-command handler extracted from launch.ts.
+ *
+ * Handles `/model [id|#N|save [id]|thinking <level>|subagent <role> [model|#N]]`
+ * (default: interactive live-model picker on a TTY, else prints the current
+ * model + a numbered pick list). This block shares mutable REPL state with
+ * still-inline commands (`/agents`, `/roles`, `/provider` also read/write
+ * `lastPickIndex`; `/thinking` reads/writes `sessionThinking`), so the caller
+ * passes the current values in via an explicit context object and reads back
+ * a result object instead of this function closing over REPL state directly.
+ */
+
+import { readGlobalConfig, saveConfigPatch } from "../../agent/state";
+import { rememberModelPatch, recentModelsForDisplay } from "../../agent/model-recency";
+import {
+  describeModel,
+  describeAllProviders,
+  thinkingMaxTokens,
+  flattenModels,
+  resolveSelection,
+  catalogMetadata,
+  CODEX_MODELS,
+  qualifyModelId,
+} from "../../ai";
+import type { ProviderModelsResult, PickEntry, ProviderName, ThinkLevel } from "../../ai";
+import { getSubagentRole, resolveSubagentModel, withSubagentSetting } from "../../agent/subagents";
+import { formatModelLine, liveModelKnown, formatPickListWithCapabilities, formatCapabilityLine } from "../../tui/components/config-panel";
+import { isThinkingLevel } from "./flags";
+
+// Antigravity with ANY Google OAuth (own login or the gemini-cli fallback) stays
+// SELECTABLE in pickers even when not call-ready: picking the model is how users
+// reach the flow, and the auth layer gives actionable login guidance on the first
+// call if the fallback token is rejected (403). Refusing selection was a dead end.
+// Pure predicate — mirrors the identically-named REPL-local const in launch.ts.
+const selectableThoughNotReady = (st?: { name: string; kind: string }): boolean =>
+  !!st && st.name === "antigravity" && st.kind === "oauth";
+
+export interface ModelSlashCtx {
+  sessionModel: string | undefined;
+  sessionThinking: ThinkLevel | undefined;
+  defaultModel: string;
+  lastPickIndex: PickEntry[];
+  liveModelsCache: ProviderModelsResult[] | null;
+  isTTY: boolean;
+  getLiveModels: (force?: boolean) => Promise<ProviderModelsResult[]>;
+  applyPickedModelWithTarget: (target: string) => Promise<boolean>;
+  persistSessionModel: () => Promise<void>;
+  /**
+   * REPL's interactive live-model picker menu (raw-mode keypress loop +
+   * repaint). Not a pure module export — it closes over `runSelectPicker`
+   * and `modelPickerAssignments` (which itself reads `sessionModel`), so the
+   * caller threads it through like the other REPL hooks.
+   */
+  pickLiveProviderModel: (
+    providerName: string,
+    entries: PickEntry[],
+    current?: string,
+    disabledProviders?: readonly ProviderName[],
+  ) => Promise<PickEntry | undefined>;
+}
+
+export interface ModelSlashResult {
+  /** Present only when changed. */
+  sessionModel?: string;
+  /** Present only when changed. */
+  sessionThinking?: ThinkLevel;
+  /** Present only when the block builds/refreshes a pick list. */
+  lastPickIndex?: PickEntry[];
+}
+
+/**
+ * Handle `/model [id|#N|save|thinking <level>|subagent <role> ...]`. Extracted
+ * verbatim from launch.ts's inline REPL branch — the caller keeps the
+ * `input.startsWith("/model") && (input === "/model" || input[6] === " ")`
+ * guard and just calls this function.
+ */
+export async function runModelSlash(input: string, ctx: ModelSlashCtx): Promise<ModelSlashResult> {
+  const { defaultModel, isTTY, getLiveModels, applyPickedModelWithTarget, persistSessionModel, pickLiveProviderModel } = ctx;
+  let sessionModel = ctx.sessionModel;
+  let sessionModelChanged = false;
+  let sessionThinking = ctx.sessionThinking;
+  let sessionThinkingChanged = false;
+  let lastPickIndex = ctx.lastPickIndex;
+  let lastPickIndexChanged = false;
+  const liveModelsCache = ctx.liveModelsCache;
+
+  const result = (): ModelSlashResult => ({
+    ...(sessionModelChanged ? { sessionModel } : {}),
+    ...(sessionThinkingChanged ? { sessionThinking } : {}),
+    ...(lastPickIndexChanged ? { lastPickIndex } : {}),
+  });
+
+  let arg = input.substring(6).trim();
+  // `/model save [id]` → persist the (session or given) model as the config default.
+  if (arg === "save" || arg.startsWith("save ")) {
+    let toSave = arg.slice(4).trim();
+    // Resolve `#N`/fuzzy through the same pick-list logic as `/model #N`, so we never
+    // persist a literal token like "#2" as defaultModel (which then fails to route).
+    if (toSave && lastPickIndex.length) {
+      const sel = resolveSelection(lastPickIndex, toSave);
+      if (sel.kind === "index" || sel.kind === "match") toSave = qualifyModelId(sel.entry.model, sel.entry.provider);
+      else if (sel.kind === "ambiguous") {
+        console.log(`'${toSave}' matches ${sel.matches.length} models — be more specific:`);
+        for (const e of sel.matches.slice(0, 12)) console.log(`  #${e.index}  ${e.model} (${e.provider})`);
+        return result();
+      } else if (sel.kind === "out-of-range") {
+        console.log(`#${toSave.slice(1)} is out of range (1-${sel.max}). Use /model first.`);
+        return result();
+      }
+      // kind "none" → treat `toSave` as a literal model id/alias.
+    } else if (toSave.startsWith("#")) {
+      console.log("Use /model first to build the numbered list.");
+      return result();
+    }
+    // Fall back to the FRESH on-disk default (not the stale session-start snapshot) so a
+    // bare `/model save` after a prior `/model save <id>` never reverts the saved default.
+    const finalSave = toSave || sessionModel || (await readGlobalConfig()).defaultModel;
+    await saveConfigPatch(raw => rememberModelPatch(raw, finalSave));
+    const { resolved, provider } = await describeModel(finalSave);
+    console.log(`Default model saved: ${formatModelLine({ label: finalSave, resolved, provider })} → ~/.jeo/config.json`);
+    return result();
+  }
+  const modelThinking = /^(?:thinking|think)(?:\s+(\S+))?$/i.exec(arg);
+  if (modelThinking) {
+    const level = (modelThinking[1] ?? "").toLowerCase();
+    if (!isThinkingLevel(level)) {
+      console.log("Usage: /model thinking <minimal|low|medium|high|xhigh>");
+      return result();
+    }
+    sessionThinking = level;
+    sessionThinkingChanged = true;
+    await saveConfigPatch(() => ({ thinkingLevel: level }));
+    console.log(`Default thinking set to ${level} (~${thinkingMaxTokens(level)} max tokens/step) → ~/.jeo/config.json`);
+    return result();
+  }
+  const statuses = await describeAllProviders();
+  const disabledModelProviders = statuses.filter(s => !s.ready && !selectableThoughNotReady(s)).map(s => s.name);
+  const roleMatch = /^(subagent|role)\s+(\S+)(?:\s+(.+))?$/i.exec(arg);
+  if (roleMatch) {
+    const role = getSubagentRole(roleMatch[2] ?? "", await readGlobalConfig());
+    if (!role) {
+      console.log("Usage: /model subagent <executor|planner|architect|critic> [model|#N]");
+      return result();
+    }
+    let roleModelArg = (roleMatch[3] ?? "").trim();
+    const roleThinking = /^(?:thinking|think)(?:\s+(\S+))?$/i.exec(roleModelArg);
+    if (roleThinking) {
+      console.log(`Subagent thinking is set via /agents — try: /agents ${role.id} thinking ${roleThinking[1] ?? "<level|inherit>"}  (or /agents edit). /model only sets the default thinking.`);
+      return result();
+    }
+
+    if (!roleModelArg && isTTY) {
+      const live = await getLiveModels();
+      lastPickIndex = flattenModels(live);
+      lastPickIndexChanged = true;
+      if (lastPickIndex.length) {
+        const currentResolved = (await describeModel(resolveSubagentModel(role.id, await readGlobalConfig()))).resolved;
+        const picked = await pickLiveProviderModel(role.id, lastPickIndex, currentResolved, disabledModelProviders);
+        if (!picked) {
+          console.log("(cancelled)");
+          return result();
+        }
+        roleModelArg = qualifyModelId(picked.model, picked.provider);
+
+      }
+    }
+    if (roleModelArg && lastPickIndex.length) {
+      const sel = resolveSelection(lastPickIndex, roleModelArg);
+      if (sel.kind === "index" || sel.kind === "match") {
+        if (disabledModelProviders.includes(sel.entry.provider)) {
+          const bad = statuses.find(s => s.name === sel.entry.provider);
+          console.log(`Cannot select ${sel.entry.model}: ${sel.entry.provider} is not ready (${bad?.label ?? "not ready"}). Set ${bad?.envVar ?? "the provider key"} first.`);
+          return result();
+        }
+        roleModelArg = qualifyModelId(sel.entry.model, sel.entry.provider);
+
+      } else if (sel.kind === "ambiguous") {
+        console.log(`'${roleModelArg}' matches ${sel.matches.length} models — be more specific:`);
+        for (const e of sel.matches.slice(0, 12)) console.log(`  #${e.index}  ${e.model} (${e.provider})`);
+        return result();
+      } else if (sel.kind === "out-of-range") {
+        console.log(`#${roleModelArg.slice(1)} is out of range (1-${sel.max}). Use /model first.`);
+        return result();
+      }
+    } else if (roleModelArg.startsWith("#")) {
+      console.log("Use /model first to build the numbered list.");
+      return result();
+    }
+    if (roleModelArg) {
+      await saveConfigPatch(raw => ({ subagents: withSubagentSetting(raw, role.id, { model: roleModelArg }) }));
+      const { provider } = await describeModel(roleModelArg);
+      console.log(`${role.title} model set to ${roleModelArg} (${provider}) — saved to ~/.jeo/config.json. Set its thinking via /agents ${role.id} thinking <level> (or /agents edit).`);
+    } else {
+      const current = resolveSubagentModel(role.id, await readGlobalConfig());
+      const { resolved, provider } = await describeModel(current);
+      console.log(`${role.title} model: ${formatModelLine({ label: current, resolved, provider })}`);
+      const live = await getLiveModels();
+      lastPickIndex = flattenModels(live);
+      lastPickIndexChanged = true;
+      if (lastPickIndex.length) {
+        console.log(`Live models for ${role.title} — set with /model subagent ${role.id} #N:`);
+        for (const line of formatPickListWithCapabilities(lastPickIndex, { current: resolved, cap: 20 })) console.log(line);
+      }
+    }
+    return result();
+  }
+  let modelPickedFromSelector = false;
+  if (!arg && isTTY) {
+    const live = await getLiveModels();
+    lastPickIndex = flattenModels(live);
+    lastPickIndexChanged = true;
+    if (lastPickIndex.length) {
+      const currentResolved = (await describeModel(sessionModel || defaultModel)).resolved;
+      const picked = await pickLiveProviderModel("live", lastPickIndex, currentResolved, disabledModelProviders);
+      if (!picked) {
+        console.log("(cancelled)");
+        return result();
+      }
+      arg = qualifyModelId(picked.model, picked.provider);
+      modelPickedFromSelector = true;
+    }
+  }
+  // Selection from the last numbered pick list (`#N`) or a fuzzy substring.
+  if (arg && lastPickIndex.length) {
+    const sel = resolveSelection(lastPickIndex, arg);
+    if (sel.kind === "index" || sel.kind === "match") {
+      if (disabledModelProviders.includes(sel.entry.provider)) {
+        const bad = statuses.find(s => s.name === sel.entry.provider);
+        console.log(`Cannot select ${sel.entry.model}: ${sel.entry.provider} is not ready (${bad?.label ?? "not ready"}). Set ${bad?.envVar ?? "the provider key"} first.`);
+        return result();
+      }
+      arg = qualifyModelId(sel.entry.model, sel.entry.provider);
+      modelPickedFromSelector = true;
+    } else if (sel.kind === "ambiguous") {
+      console.log(`'${arg}' matches ${sel.matches.length} models — be more specific:`);
+      for (const e of sel.matches.slice(0, 12)) console.log(`  #${e.index}  ${e.model} (${e.provider})`);
+      return result();
+    } else if (sel.kind === "out-of-range") {
+      console.log(`#${arg.slice(1)} is out of range (1-${sel.max}). Use /model first.`);
+      return result();
+    }
+    // kind "none" → fall through and treat `arg` as a literal model id/alias.
+  } else if (arg.startsWith("#")) {
+    console.log("Use /model first to build the numbered list.");
+    return result();
+  }
+  const label = arg || (sessionModel || defaultModel);
+  if (arg && modelPickedFromSelector && await applyPickedModelWithTarget(arg)) {
+    return result();
+  }
+  if (arg) {
+    sessionModel = arg;
+    sessionModelChanged = true;
+    // MRU persistence: picking a model IS saving it — the newest pick wins
+    // as the global default; recents keep the rotation for every session.
+    await saveConfigPatch(raw => rememberModelPatch(raw, arg));
+    await persistSessionModel();
+  }
+  const { resolved, provider } = await describeModel(label);
+  const st = statuses.find(s => s.name === provider);
+  console.log(`${arg ? "Model set to" : "Current model"}: ${formatModelLine({ label, resolved, provider, ready: st?.ready })}${arg ? " — saved as default" : ""}`);
+  if (st && !st.ready) console.log(`  ! ${provider} is not ready (${st.label}) — set ${st.envVar ?? "the provider key"} or run 'jeo setup'.`);
+  // ChatGPT OAuth only serves the Codex models; warn before the turn fails if the user
+  // pins a non-Codex id with no local base URL to fall back to (gjc-parity readiness guard).
+  if (arg && provider === "openai" && st?.kind === "oauth" && !CODEX_MODELS.includes(resolved)) {
+    const hasLocalBase = !!((await readGlobalConfig()).openaiBaseUrl || process.env.OPENAI_BASE_URL);
+    if (!hasLocalBase) {
+      console.log(`  ! ChatGPT OAuth serves only Codex models (${CODEX_MODELS.join(", ")}); '${resolved}' will be rejected at runtime — pick one of those, or set OPENAI_API_KEY / OPENAI_BASE_URL.`);
+    }
+  }
+  if (arg && liveModelsCache && resolved === label && !liveModelKnown(liveModelsCache, resolved)) {
+    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)}`);
+  if (!arg) {
+    const recents = recentModelsForDisplay(await readGlobalConfig());
+    if (recents.length > 1) {
+      console.log("Recent models (newest first):");
+      recents.slice(0, 5).forEach((m, i) => console.log(`  ${i + 1}. ${m}${i === 0 ? "  ◀ default" : ""}`));
+    }
+    const live = await getLiveModels();
+    lastPickIndex = flattenModels(live);
+    lastPickIndexChanged = true;
+    console.log("Live models (logged-in providers) — set with /model #N:");
+    for (const line of formatPickListWithCapabilities(lastPickIndex, { current: resolved, cap: 20 })) console.log(line);
+  }
+  console.log("  (model picks persist automatically — newest selection is the default everywhere)");
+  return result();
+}

package/src/commands/launch/session-slash.ts

@@ -0,0 +1,305 @@
+/**
+ * `/session` slash-command handler extracted from launch.ts.
+ *
+ * Handles `/session [new|drop|delete|rename <title>|resume [id]|list|info]`
+ * (default: list saved sessions + current-session summary). This block has
+ * real mutable-state entanglement with the REPL's giant closure — sessionId,
+ * sessionModel, lastUserInput, and lastReply are all reassigned inside it —
+ * so the caller passes an explicit context object in and reads a result
+ * object back out instead of this function closing over REPL state directly.
+ */
+
+import type { Message } from "../../agent/loop";
+import { createSession, deleteSession, renameSession, loadSession, listSessions, sessionPath, resolveSessionRef } from "../../agent/session";
+import { SessionPicker, renderSessionPicker } from "../../tui/components/session-picker";
+import { formatTranscript } from "../../tui/components/transcript";
+
+export interface SessionSlashCtx {
+  cwd: string;
+  /** Mutated in place (length reset + push) — same array reference the caller holds. */
+  history: Message[];
+  noSession: boolean;
+  sessionId: string | undefined;
+  sessionModel: string | undefined;
+  /** readline interface; only accessed via `(rl as unknown as {history?: string[]})`. */
+  rl: unknown;
+  advanceSessionBoxColor: () => void;
+  disarmPreview: () => void;
+  clearScreen: () => string;
+  freshWelcomeLines: () => string[];
+  logLines: (lines: string[]) => void;
+  /**
+   * REPL's interactive list-picker runner (raw-mode keypress loop + repaint).
+   * Not a pure module export — it closes over terminal/readline state owned
+   * by the REPL, so the caller threads it through like the other REPL hooks.
+   */
+  runSelectPicker: (
+    render: (cols: number, rows: number) => string[],
+    onKey: (ch: string, key: { name?: string; ctrl?: boolean; meta?: boolean; shift?: boolean } | undefined) => boolean | undefined,
+  ) => Promise<void>;
+}
+
+export interface SessionSlashResult {
+  sessionId: string | undefined;
+  /** Present only when changed (by `/session resume` restoring header.model). */
+  sessionModel?: string;
+  /** Present only when changed (by `/session resume` re-seeding retry state). */
+  lastUserInput?: string;
+  /** Present only when changed (by `/session resume` re-seeding retry state). */
+  lastReply?: string;
+}
+
+/**
+ * Handle `/session [new|drop|delete|rename <title>|resume [id]|list|info]`
+ * (default: list + current-session summary). Extracted verbatim from
+ * launch.ts's inline REPL branch — the caller keeps the `input === "/session"`
+ * guard and just calls this function.
+ */
+export async function runSessionSlash(input: string, ctx: SessionSlashCtx): Promise<SessionSlashResult> {
+  const { cwd, history, noSession, rl, advanceSessionBoxColor, disarmPreview, clearScreen, freshWelcomeLines, logLines, runSelectPicker } = ctx;
+  let sessionId = ctx.sessionId;
+  let sessionModel = ctx.sessionModel;
+  let sessionModelChanged = false;
+  let lastUserInput: string | undefined;
+  let lastReply: string | undefined;
+
+  const result = (): SessionSlashResult => ({
+    sessionId,
+    ...(sessionModelChanged ? { sessionModel } : {}),
+    ...(lastUserInput !== undefined ? { lastUserInput } : {}),
+    ...(lastReply !== undefined ? { lastReply } : {}),
+  });
+
+  const tokens = input.substring(8).trim().split(/\s+/).filter(Boolean);
+  const sub = (tokens[0] ?? "").toLowerCase();
+
+  const startFreshSession = async (verb: string): Promise<void> => {
+    history.length = 1;
+    if (!noSession) {
+      sessionId = (await createSession(cwd, undefined, sessionModel)).id;
+      advanceSessionBoxColor(); // distinct input-box hue per newly opened session
+      console.log(`(${verb} — new session ${sessionId})`);
+    } else {
+      sessionId = undefined;
+      console.log(`(${verb} — sessions disabled)`);
+    }
+  };
+
+  if (sub === "new") {
+    await startFreshSession("started fresh");
+    return result();
+  }
+  if (sub === "drop" || sub === "delete") {
+    if (sessionId) {
+      const removed = await deleteSession(sessionId, cwd);
+      console.log(removed ? `(deleted session ${sessionId})` : `(session ${sessionId} already gone)`);
+    }
+    await startFreshSession("dropped");
+    return result();
+  }
+  if (sub === "rename") {
+    const title = tokens.slice(1).join(" ").trim();
+    if (!title) {
+      console.log("Usage: /session rename <title>");
+      return result();
+    }
+    if (!sessionId) {
+      console.log("(sessions are disabled — nothing to rename)");
+      return result();
+    }
+    try {
+      await renameSession(sessionId, title, cwd);
+      console.log(`(session renamed to '${title}')`);
+    } catch (err) {
+      console.log(`! rename failed: ${(err as Error).message}`);
+    }
+    return result();
+  }
+  if (sub === "resume") {
+    const arg = tokens.slice(1).join(" ").trim();
+    const applyResume = async (rid: string): Promise<void> => {
+      try {
+        const { header, messages } = await loadSession(rid, cwd);
+        history.length = 1;
+        for (const m of messages) history.push(m);
+        sessionId = rid;
+        // Restore the model this session was last using (per-session model).
+        if (header.model) { sessionModel = header.model; sessionModelChanged = true; }
+        // Seed /retry + reply marker from the last user/assistant turn.
+        lastUserInput = ""; lastReply = "";
+        for (let k = history.length - 1; k >= 1; k--) {
+          if (history[k]!.role === "user" && !lastUserInput) lastUserInput = String(history[k]!.content ?? "");
+          if (history[k]!.role === "assistant" && !lastReply) lastReply = String(history[k]!.content ?? "");
+          if (lastUserInput && lastReply) break;
+        }
+        // Seed readline's input history so ↑ in the prompt recalls THIS session's
+        // prior prompts (not just lines typed in the current run). readline history
+        // is newest-first; unshift in chronological order so the session's newest
+        // prompt lands at the front (first ↑). Skip injected/framed messages.
+        const rli = rl as unknown as { history?: string[] };
+        if (Array.isArray(rli.history)) {
+          const priorPrompts = history
+            .filter(m => m.role === "user")
+            .map(m => String(m.content ?? "").trim())
+            .filter(c => c && !c.startsWith("Tool [") && !c.startsWith("[mid-turn steering") && !c.startsWith("[Earlier conversation summary]"));
+          for (const p of priorPrompts) {
+            if (rli.history[0] !== p) rli.history.unshift(p);
+          }
+        }
+        // Clean restore: wipe the screen + scrollback BEFORE replaying the
+        // transcript so it can't collide with picker remnants, the prior
+        // conversation, or the live input frame — the "/resume corrupts the
+        // TUI" fix. Same proven path as /clear; re-render the welcome banner
+        // so the resumed view reads like a fresh, intact screen.
+        if (process.stdout.isTTY) {
+          disarmPreview();
+          process.stdout.write(clearScreen());
+          console.log(freshWelcomeLines().join("\n"));
+        }
+        const sep = "─".repeat(Math.min(48, Math.max(20, (process.stdout.columns ?? 80) - 1)));
+        logLines([
+          sep,
+          `resumed session ${rid} · ${messages.length} message(s) (/history all for the full transcript)`,
+          sep,
+          ...formatTranscript(history, { maxTurns: 6, color: true, unicode: true }),
+          sep,
+        ]);
+      } catch (err) {
+        console.log(`! ${(err as Error).message}`);
+      }
+    };
+    if (arg) {
+      // gjc-parity: resolve `arg` as a full id OR a short id prefix before resuming.
+      const resolved = await resolveSessionRef(arg, cwd);
+      if (resolved.kind === "ambiguous") {
+        console.log(`Ambiguous session id '${arg}' — matches: ${resolved.matches.slice(0, 5).join(", ")}${resolved.matches.length > 5 ? " …" : ""}. Use more characters or run with --resume (no value) to pick interactively.`);
+        return result();
+      }
+      // "not-found" falls through with the raw arg so loadSession's existing
+      // catch-driven "session not found" error message behavior is unchanged.
+      await applyResume(resolved.kind === "ok" ? resolved.id : arg);
+      return result();
+    }
+    // No id → only sessions with a real conversation are resumable (every launch
+    // creates an empty session; those are noise).
+    let pool = (await listSessions(cwd)).filter(s => s.messageCount > 0);
+    if (pool.length === 0) {
+      console.log("(no saved sessions with history)");
+      return result();
+    }
+    // Interactive gjc-style picker on a TTY: type to filter, ↑↓/PgUp/PgDn to
+    // move, Enter resumes, Del deletes (press Del twice to confirm), Esc cancels.
+    if (process.stdin.isTTY && process.stdout.isTTY) {
+      // Loop so a delete refreshes the list and re-opens the picker in place.
+      for (;;) {
+        const picker = new SessionPicker(pool);
+        let action: { kind: "resume" | "delete"; id: string } | undefined;
+        let confirmDeleteId: string | undefined;
+        await runSelectPicker(
+          (cols, rows) => renderSessionPicker(picker, {
+            title: "Resume a session",
+            cols,
+            rows: Math.max(8, rows),
+            unicode: true,
+            color: true,
+            confirmDeleteId,
+          }),
+          (ch, key) => {
+            if (key?.name === "up") { confirmDeleteId = undefined; picker.up(); return false; }
+            if (key?.name === "down") { confirmDeleteId = undefined; picker.down(); return false; }
+            if (key?.name === "pageup") { confirmDeleteId = undefined; picker.page(-1); return false; }
+            if (key?.name === "pagedown") { confirmDeleteId = undefined; picker.page(1); return false; }
+            if (key?.name === "escape" || (key?.ctrl && key.name === "c")) return true;
+            if (key?.name === "delete") {
+              const sel = picker.selected();
+              if (!sel) return false;
+              if (confirmDeleteId === sel.id) { action = { kind: "delete", id: sel.id }; return true; }
+              confirmDeleteId = sel.id;
+              return false;
+            }
+            if (key?.name === "return" || key?.name === "enter") {
+              const sel = picker.selected();
+              if (sel) { action = { kind: "resume", id: sel.id }; return true; }
+              return false;
+            }
+            confirmDeleteId = undefined;
+            if (key?.name === "backspace") { picker.backspace(); return false; }
+            if (ch && ch >= " " && !key?.ctrl && !key?.meta) picker.typeChar(ch);
+            return false;
+          },
+        );
+        if (!action) { console.log("(resume cancelled)"); break; }
+        if (action.kind === "resume") { await applyResume(action.id); break; }
+        // Delete: drop the file, refresh the pool, and re-open the picker.
+        const delId = action.id;
+        try {
+          const removed = await deleteSession(delId, cwd);
+          console.log(removed ? `(deleted session ${delId})` : `(session ${delId} already gone)`);
+        } catch (err) {
+          console.log(`! delete failed: ${(err as Error).message}`);
+        }
+        if (delId === sessionId) await startFreshSession("dropped current session");
+        pool = pool.filter(s => s.id !== delId);
+        if (pool.length === 0) { console.log("(no saved sessions with history)"); break; }
+      }
+      return result();
+    }
+    // Non-TTY fallback: static list (resume with /session resume <id>).
+    console.log("Saved sessions — resume with /session resume <id>:");
+    for (const s of pool.slice(0, 15)) {
+      const marker = s.id === sessionId ? "*" : " ";
+      console.log(` ${marker}${s.id}  (${s.messageCount} msgs)  ${s.title ? `[${s.title}] ` : ""}${s.preview}`);
+    }
+    return result();
+  }
+  if (sub === "list") {
+    const sessions = await listSessions(cwd);
+    if (sessions.length === 0) console.log("(no saved sessions)");
+    for (const s of sessions) {
+      const marker = s.id === sessionId ? "*" : " ";
+      const title = s.title ? `[${s.title}] ` : "";
+      console.log(` ${marker}${s.id}  (${s.messageCount} msgs)  ${title}${s.preview}`);
+    }
+    return result();
+  }
+  if (sub === "info") {
+    if (!sessionId) {
+      console.log("Session: disabled (--no-session)");
+      return result();
+    }
+    const all = await listSessions(cwd);
+    const current = all.find(s => s.id === sessionId);
+    console.log("Session info:");
+    console.log(`  id        ${sessionId}`);
+    if (current?.title) console.log(`  title     ${current.title}`);
+    console.log(`  file      ${sessionPath(sessionId, cwd)}`);
+    console.log(`  started   ${current?.timestamp ?? "(this run)"}`);
+    console.log(`  messages  ${current?.messageCount ?? Math.max(0, history.length - 1)} persisted · ${history.length - 1} in context`);
+    console.log(`  workspace ${cwd}`);
+    return result();
+  }
+  if (sub && sub !== "info") {
+    console.log("Usage: /session [list|info|new|drop|rename <title>|resume [id]]");
+    return result();
+  }
+
+  // Default: list sessions AND show current session info
+  const sessions = await listSessions(cwd);
+  if (sessions.length === 0) {
+    console.log("(no saved sessions)");
+  } else {
+    console.log("Saved sessions:");
+    for (const s of sessions) {
+      const marker = s.id === sessionId ? "*" : " ";
+      const title = s.title ? `[${s.title}] ` : "";
+      console.log(` ${marker}${s.id}  (${s.messageCount} msgs)  ${title}${s.preview}`);
+    }
+  }
+  if (sessionId) {
+    const current = sessions.find(s => s.id === sessionId);
+    console.log(`\nCurrent session: ${sessionId}${current?.title ? ` [${current.title}]` : ""}`);
+  } else {
+    console.log("\nCurrent session: disabled (--no-session)");
+  }
+  return result();
+}