jeo-code 0.7.31 → 0.7.32

package/src/agent/ts-language-service.ts

@@ -0,0 +1,173 @@
+/**
+ * In-process TypeScript "language service" host (gjc `lsp` parity for TS/JS/TSX/JSX
+ * ONLY — no external `typescript-language-server` process, no other languages).
+ * Built directly on the `typescript` compiler API's `ts.LanguageService`, which is
+ * the exact engine `tsserver`/most TS editor integrations run on top of — so
+ * definition/references/hover/rename here match what a real TS language server
+ * would report, just without the LSP wire protocol or multi-language support.
+ *
+ * One `ts.LanguageService` is cached per project root (`cwd`) and reused across
+ * calls within a turn. `getScriptVersion` stats the file on every call (no manual
+ * invalidation needed) so edits made by `write`/`edit`/`ast_edit` earlier in the
+ * same turn are picked up on the next `lsp` call. A file outside the project's
+ * `tsconfig.json` "include" set is added to the tracked root set on first use.
+ */
+import * as ts from "typescript";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { resolveTargetFiles } from "./ast-file-scan";
+
+interface CachedService {
+  service: ts.LanguageService;
+  extraFiles: Set<string>;
+}
+
+const serviceCache = new Map<string, CachedService>();
+
+function fileVersion(absPath: string): string {
+  try {
+    const st = fs.statSync(absPath);
+    return `${st.mtimeMs}:${st.size}`;
+  } catch {
+    return "missing";
+  }
+}
+
+const DEFAULT_COMPILER_OPTIONS: ts.CompilerOptions = {
+  target: ts.ScriptTarget.Latest,
+  module: ts.ModuleKind.ESNext,
+  moduleResolution: ts.ModuleResolutionKind.Bundler,
+  jsx: ts.JsxEmit.ReactJSX,
+  allowJs: true,
+  checkJs: false,
+  esModuleInterop: true,
+  resolveJsonModule: true,
+  strict: false,
+};
+
+function loadProjectFiles(cwd: string): { options: ts.CompilerOptions; fileNames: string[] } {
+  const configPath = ts.findConfigFile(cwd, ts.sys.fileExists, "tsconfig.json");
+  if (configPath) {
+    const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+    if (!configFile.error) {
+      const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path.dirname(configPath));
+      if (parsed.fileNames.length > 0) return { options: parsed.options, fileNames: parsed.fileNames };
+    }
+  }
+  return { options: DEFAULT_COMPILER_OPTIONS, fileNames: [] };
+}
+
+/** Get (or lazily create) the cached `ts.LanguageService` for a project root. */
+async function getCached(cwd: string): Promise<CachedService> {
+  const existing = serviceCache.get(cwd);
+  if (existing) return existing;
+
+  const fromConfig = loadProjectFiles(cwd);
+  // No tsconfig.json (or it named zero files) — scan the whole project tree for
+  // supported TS/JS files instead of starting with an EMPTY root set. Without this,
+  // "references"/"rename" starting from a declaration would only ever see the ONE
+  // file explicitly queried: TS's own module resolution pulls in files a root file
+  // IMPORTS, never the reverse (files that import a root file), so a project with
+  // no tsconfig would silently miss every cross-file usage.
+  const fileNames = fromConfig.fileNames.length > 0 ? fromConfig.fileNames : await resolveTargetFiles(["**/*"], cwd);
+  const options = fromConfig.options;
+  const rootFiles = new Set(fileNames);
+  const extraFiles = new Set<string>();
+
+  const host: ts.LanguageServiceHost = {
+    getScriptFileNames: () => [...rootFiles, ...extraFiles],
+    getScriptVersion: fileVersion,
+    getScriptSnapshot: (fileName) => {
+      try {
+        return ts.ScriptSnapshot.fromString(fs.readFileSync(fileName, "utf-8"));
+      } catch {
+        return undefined;
+      }
+    },
+    getCurrentDirectory: () => cwd,
+    getCompilationSettings: () => options,
+    getDefaultLibFileName: (opts) => ts.getDefaultLibFilePath(opts),
+    fileExists: ts.sys.fileExists,
+    readFile: ts.sys.readFile,
+    readDirectory: ts.sys.readDirectory,
+    directoryExists: ts.sys.directoryExists,
+    getDirectories: ts.sys.getDirectories,
+  };
+
+  const service = ts.createLanguageService(host, ts.createDocumentRegistry());
+  const cached: CachedService = { service, extraFiles };
+  serviceCache.set(cwd, cached);
+  return cached;
+}
+
+/** Get the language service for `cwd`, ensuring `absPath` is tracked (added to the
+ *  root set if the project's tsconfig didn't already include it). */
+export async function languageServiceFor(cwd: string, absPath: string): Promise<ts.LanguageService> {
+  const cached = await getCached(cwd);
+  if (!cached.extraFiles.has(absPath)) cached.extraFiles.add(absPath);
+  return cached.service;
+}
+
+/** Drop a cached language service (tests / long-running sessions that need a
+ *  clean project graph after large structural changes). */
+export function resetLanguageServiceCache(cwd?: string): void {
+  if (cwd) serviceCache.delete(cwd);
+  else serviceCache.clear();
+}
+
+export interface SymbolSelector { text: string; occurrence: number }
+
+/** Parse a loose `"name"` or `"name#N"` selector (1-indexed occurrence, default 1). */
+export function parseSymbolSelector(input: string | undefined): SymbolSelector | undefined {
+  if (!input) return undefined;
+  const m = /^(.*)#(\d+)$/.exec(input);
+  if (m) return { text: m[1]!, occurrence: Math.max(1, parseInt(m[2]!, 10)) };
+  return { text: input, occurrence: 1 };
+}
+
+export type PositionResult = { position: number } | { error: string };
+
+/** Resolve a 1-indexed `line` (+ optional symbol substring selector) to an absolute
+ *  character offset in `fileText`, using the TS compiler's own line map (so CRLF
+ *  files are handled correctly, unlike naive `split("\n")` offset arithmetic). */
+export function resolvePosition(fileText: string, line1: number, symbol?: SymbolSelector): PositionResult {
+  const sf = ts.createSourceFile("__pos__.tsx", fileText, ts.ScriptTarget.Latest, false, ts.ScriptKind.TSX);
+  const lineCount = sf.getLineStarts().length;
+  if (line1 < 1 || line1 > lineCount) {
+    return { error: `line ${line1} is out of range (file has ${lineCount} lines)` };
+  }
+  const lineStart = sf.getPositionOfLineAndCharacter(line1 - 1, 0);
+  const lineEnd = line1 < lineCount ? sf.getPositionOfLineAndCharacter(line1, 0) : fileText.length;
+  const lineText = fileText.slice(lineStart, lineEnd).replace(/\r?\n$/, "");
+
+  if (!symbol) return { position: lineStart };
+
+  let idx = -1;
+  let from = 0;
+  for (let i = 0; i < symbol.occurrence; i++) {
+    idx = lineText.indexOf(symbol.text, from);
+    if (idx === -1) break;
+    from = idx + 1;
+  }
+  if (idx === -1) {
+    return { error: `symbol '${symbol.text}' (occurrence ${symbol.occurrence}) not found on line ${line1}: ${lineText.trim().slice(0, 120)}` };
+  }
+  return { position: lineStart + idx + Math.max(0, Math.floor(symbol.text.length / 2)) };
+}
+
+/** One line of a file, 1-indexed, trimmed for display. */
+export function lineTextAt(fileText: string, line1: number): string {
+  const lines = fileText.split(/\r?\n/);
+  return (lines[line1 - 1] ?? "").trim();
+}
+
+/** Convert a 0-indexed TS `position` in `fileText` to a 1-indexed line number. */
+export function lineOfPosition(fileText: string, position: number): number {
+  const sf = ts.createSourceFile("__pos__.tsx", fileText, ts.ScriptTarget.Latest, false, ts.ScriptKind.TSX);
+  return sf.getLineAndCharacterOfPosition(position).line + 1;
+}
+
+/** A short, uniform `path:line: text` result line. */
+export function formatLocation(relPath: string, line1: number, text: string): string {
+  return `${relPath}:${line1}: ${text.length > 160 ? text.slice(0, 159) + "…" : text}`;
+}

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

@@ -0,0 +1,489 @@
+/**
+ * `/agents`, `/roles`, `/fast`, and `/thinking` slash-command handlers
+ * extracted from launch.ts.
+ *
+ * These four commands share mutable REPL state with each other and with the
+ * already-extracted `/model` (model-slash.ts): `/agents` and `/roles` read
+ * and write `lastPickIndex`; `/fast` and `/thinking` read and write
+ * `sessionThinking` (which `/model thinking <level>` also writes). The
+ * caller threads the current values in via an explicit context object and
+ * reads back a result object instead of these functions closing over REPL
+ * state directly.
+ */
+
+import { readGlobalConfig, saveConfigPatch } from "../../agent/state";
+import {
+  describeModel,
+  describeAllProviders,
+  thinkingMaxTokens,
+  flattenModels,
+  resolveSelection,
+  resolveRoleModel,
+  catalogByProvider,
+  qualifyModelId,
+} from "../../ai";
+import type { ProviderModelsResult, PickEntry, ProviderName, ThinkLevel } from "../../ai";
+import {
+  allSubagentRoles,
+  getSubagentRole,
+  resolveSubagentModel,
+  resolveSubagentMaxSteps,
+  resolveSubagentThinking,
+  parseMaxSteps,
+  withSubagentSetting,
+  clearSubagentSetting,
+} from "../../agent/subagents";
+import {
+  formatModelLine,
+  liveModelKnown,
+  formatPickListWithCapabilities,
+  formatAgentsPanel,
+  formatAgentDetail,
+} from "../../tui/components/config-panel";
+import type { SelectItem } from "../../tui/components/select-list";
+import { openaiCompatDef } from "../../ai/providers/openai-compatible-catalog";
+import { isProviderName, fastThinkingLevelForModel } from "./flags";
+
+// Per-provider starting model for provider pinning. Catalog OpenAI-compatible
+// providers supply their own default; built-ins use this map.
+// Pure data — mirrors the identically-named REPL-local const in launch.ts.
+const STATIC_PROVIDER_DEFAULT: Partial<Record<ProviderName, string>> = { anthropic: "sonnet", openai: "gpt-5.5", gemini: "flash", antigravity: "antigravity/gemini-3-pro-high", ollama: "fast", lmstudio: "lmstudio/local-model", xai: "grok-4.3", kimi: "kimi-k2-0711-preview" };
+
+// Pure function — mirrors the identically-named REPL-local const in launch.ts.
+function providerDefaultModel(p: ProviderName): string {
+  return openaiCompatDef(p)?.defaultModel ?? STATIC_PROVIDER_DEFAULT[p] ?? "";
+}
+
+// Pick-list entries for ONE provider, with static fallbacks so the list is
+// never empty. Pure function — mirrors launch.ts's exported `providerPickEntries`
+// (duplicated here rather than imported to avoid a launch.ts <-> launch/*.ts cycle).
+function providerPickEntries(live: ProviderModelsResult[], want: ProviderName): PickEntry[] {
+  const fromLive = flattenModels(live.filter(r => r.provider === want));
+  if (fromLive.length) return fromLive;
+  const catalog = catalogByProvider(want);
+  if (catalog.length) {
+    return catalog.map((m, i) => ({ index: i + 1, provider: want, model: qualifyModelId(m.providerModel, want) }));
+  }
+  const def = openaiCompatDef(want);
+  if (def) {
+    const ids = [def.defaultModel, ...(def.knownModels ?? [])].map(m => qualifyModelId(m, want));
+    const seen = new Set<string>();
+    const entries: PickEntry[] = [];
+    for (const model of ids) {
+      if (seen.has(model)) continue;
+      seen.add(model);
+      entries.push({ index: entries.length + 1, provider: want, model });
+    }
+    if (entries.length) return entries;
+  }
+  const fallback = providerDefaultModel(want);
+  return fallback ? [{ index: 1, provider: want, model: qualifyModelId(fallback, want) }] : [];
+}
+
+// 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";
+
+// Pure function — mirrors the identically-named REPL-local const in launch.ts.
+const notReadyWarning = (st: { name: string; label: string }): string =>
+  `  ! ${st.name} is not call-ready yet (${st.label}) — run /provider login antigravity before the first turn.`;
+
+export interface AgentsSlashCtx {
+  sessionModel: string | undefined;
+  sessionThinking: ThinkLevel | undefined;
+  lastPickIndex: PickEntry[];
+  getLiveModels: (force?: boolean) => Promise<ProviderModelsResult[]>;
+  /**
+   * 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>;
+  /**
+   * Sets (or clears) a subagent role's thinking override, printing the
+   * confirmation itself. Closes over `readGlobalConfig`/`saveConfigPatch`
+   * REPL-local wiring, so the caller threads it through.
+   */
+  setRoleThinking: (roleId: string, rawLevel: string | undefined) => Promise<boolean>;
+  /** Generic arrows+Enter option picker (role / action menus). REPL-local closure. */
+  pickFromOptions: (title: string, options: SelectItem<string>[]) => Promise<string | undefined>;
+  /** Arrows+Enter thinking-level picker built on `pickFromOptions`. REPL-local closure. */
+  pickThinkingLevel: (
+    title: string,
+    current: ThinkLevel | undefined,
+    inheritLabel?: string,
+  ) => Promise<ThinkLevel | "inherit" | undefined>;
+}
+
+export interface AgentsSlashResult {
+  /** Present only when changed. */
+  sessionThinking?: ThinkLevel;
+  /** Present only when the block builds/refreshes a pick list. */
+  lastPickIndex?: PickEntry[];
+}
+
+/**
+ * Handle `/agents [edit|role] [model|#N|thinking L|maxSteps N|reset]`.
+ * Extracted verbatim from launch.ts's inline REPL branch — the caller keeps
+ * the `input === "/agents" || input.startsWith("/agents ")` guard and just
+ * calls this function.
+ */
+export async function runAgentsSlash(input: string, ctx: AgentsSlashCtx): Promise<AgentsSlashResult> {
+  const { getLiveModels, pickLiveProviderModel, setRoleThinking, pickFromOptions, pickThinkingLevel } = ctx;
+  let lastPickIndex = ctx.lastPickIndex;
+  let lastPickIndexChanged = false;
+
+  const result = (): AgentsSlashResult => ({
+    ...(lastPickIndexChanged ? { lastPickIndex } : {}),
+  });
+
+  const agentsCommand = "/agents";
+  const tokens = input.substring(agentsCommand.length).trim().split(/\s+/).filter(Boolean);
+  const roleArg = tokens[0];
+  const modelArg = tokens[1];
+  const cfgNow = await readGlobalConfig();
+  const subcommand = roleArg?.toLowerCase();
+  const printRoster = () => {
+    console.log("Subagent roles (used by 'jeo team'):");
+    for (const line of formatAgentsPanel(allSubagentRoles(cfgNow), r => ({
+      model: resolveSubagentModel(r.id, cfgNow),
+      maxSteps: resolveSubagentMaxSteps(r.id, cfgNow),
+      thinking: resolveSubagentThinking(r.id, cfgNow),
+    }))) console.log(line);
+    console.log("Detail: /agents <role>  ·  set model: /agents <role> <model|#N>  ·  provider: /agents <role> provider <name> [model]  ·  thinking: /agents <role> thinking <level|inherit>  ·  steps: /agents <role> maxSteps <N>  ·  picker: /agents edit");
+    console.log("Tip: primary model flow: /model → pick model → choose default or subagent role → choose thinking level");
+    console.log(`Available: ${allSubagentRoles(cfgNow).map(r => r.id).join(", ")} (declare custom roles in config.subagents)`);
+    console.log("Subcommands: edit, <role> <model|#N>, <role> thinking <level|inherit>, <role> provider <name> [model], <role> maxSteps <N>, <role> reset");
+  };
+  if (!roleArg || roleArg === "/" || roleArg === "?" || subcommand === "help") {
+    printRoster();
+    return result();
+  }
+  if (subcommand === "edit" || subcommand === "picker") {
+    printRoster();
+    // Interactive editor (TTY): role picker → action picker → live model /
+    // thinking / reset — the arrows+Enter way to CHANGE an existing setting.
+    const rolePick = await pickFromOptions(
+      "Edit a subagent role (ESC to skip)",
+      allSubagentRoles(cfgNow).map(r => ({
+        value: r.id,
+        label: `${r.id} — ${r.title}`,
+        hint: `${resolveSubagentModel(r.id, cfgNow)} · ${resolveSubagentMaxSteps(r.id, cfgNow)} steps${cfgNow.subagents?.[r.id]?.model ? "" : " (default)"}`,
+      })),
+    );
+    const editRole = rolePick ? getSubagentRole(rolePick, cfgNow) : undefined;
+    if (!editRole) return result();
+    const action = await pickFromOptions(`${editRole.title} — choose action`, [
+      { value: "model", label: "change model", hint: resolveSubagentModel(editRole.id, cfgNow) },
+      { value: "thinking", label: "change thinking", hint: resolveSubagentThinking(editRole.id, cfgNow) ?? `inherit (${cfgNow.thinkingLevel ?? "medium"})` },
+      { value: "reset", label: "reset to defaults", hint: "clears model + maxSteps + thinking override" },
+    ]);
+    if (action === "reset") {
+      await saveConfigPatch(raw => ({ subagents: clearSubagentSetting(raw, editRole.id) }));
+      console.log(`${editRole.title} settings reset to defaults → ~/.jeo/config.json`);
+    } else if (action === "model") {
+      const live = await getLiveModels();
+      const entries = flattenModels(live);
+      const picked = await pickLiveProviderModel(`${editRole.id}`, entries, resolveSubagentModel(editRole.id, cfgNow));
+      if (picked) {
+        const pinned = qualifyModelId(picked.model, picked.provider);
+        await saveConfigPatch(raw => ({ subagents: withSubagentSetting(raw, editRole.id, { model: pinned }) }));
+        console.log(`Subagent '${editRole.id}' model set to ${pinned} → ~/.jeo/config.json`);
+      }
+    } else if (action === "thinking") {
+      const lvl = await pickThinkingLevel(
+        `Reasoning for ${editRole.title}`,
+        cfgNow.subagents?.[editRole.id]?.thinking,
+        `inherit — follow default (${cfgNow.thinkingLevel ?? "medium"})`,
+      );
+      if (lvl) await setRoleThinking(editRole.id, lvl);
+    }
+    return result();
+  }
+  const role = getSubagentRole(roleArg, cfgNow);
+  if (!role) {
+    console.log(`Unknown role '${roleArg}'. Known: ${allSubagentRoles(cfgNow).map(r => r.id).join(", ")}.`);
+    return result();
+  }
+  if (modelArg?.toLowerCase() === "reset") {
+    await saveConfigPatch(raw => ({ subagents: clearSubagentSetting(raw, role.id) }));
+    console.log(`${role.title} settings reset to defaults → ~/.jeo/config.json`);
+    return result();
+  }
+  if (modelArg?.toLowerCase() === "maxsteps" || modelArg?.toLowerCase() === "steps") {
+    const maxSteps = parseMaxSteps(tokens[2]);
+    if (!maxSteps) {
+      console.log(`Usage: /agents ${role.id} maxSteps <positive-number>`);
+      return result();
+    }
+    await saveConfigPatch(raw => ({ subagents: withSubagentSetting(raw, role.id, { maxSteps }) }));
+    console.log(`${role.title} maxSteps set to ${maxSteps} → ~/.jeo/config.json`);
+    return result();
+  }
+  if (modelArg?.toLowerCase() === "thinking" || modelArg?.toLowerCase() === "think") {
+    await setRoleThinking(role.id, tokens[2]);
+    return result();
+  }
+  if (modelArg?.toLowerCase() === "provider") {
+    const want = (tokens[2] ?? "").toLowerCase();
+    if (!isProviderName(want)) {
+      console.log(`Usage: /agents ${role.id} provider <name> [model|#N] — e.g. anthropic, openai, gemini, groq, deepseek, openrouter (any configured provider)`);
+      return result();
+    }
+    const st = (await describeAllProviders()).find(s => s.name === want);
+    if (st && !st.ready) {
+      if (selectableThoughNotReady(st)) {
+        console.log(notReadyWarning(st));
+      } else {
+        console.log(`Cannot pin ${role.title} to ${want}: not ready (${st.label}). Set ${st.envVar ?? "the provider key"} first.`);
+        return result();
+      }
+    }
+    const live = await getLiveModels();
+    const forProvider = providerPickEntries(live, want);
+    const liveForProvider = live.some(r => r.ok && r.provider === want && r.models.length > 0);
+    const explicit = tokens[3];
+    let chosenModel: string;
+    if (explicit && forProvider.length) {
+      const sel = resolveSelection(forProvider, explicit);
+      if (sel.kind === "index" || sel.kind === "match") chosenModel = qualifyModelId(sel.entry.model, want);
+      else if (sel.kind === "ambiguous") {
+        console.log(`'${explicit}' matches ${sel.matches.length} ${want} models — be more specific:`);
+        for (const e of sel.matches.slice(0, 12)) console.log(`  #${e.index}  ${e.model}`);
+        return result();
+      } else if (sel.kind === "out-of-range") {
+        console.log(`#${explicit.slice(1)} is out of range for ${want} (1-${sel.max}).`);
+        return result();
+      } else {
+        chosenModel = qualifyModelId(explicit, want);
+      }
+    } else if (explicit) {
+      chosenModel = qualifyModelId(explicit, want);
+    } else if (forProvider.length) {
+      // No model given → the provider's first known model, provider-qualified.
+      chosenModel = qualifyModelId(forProvider[0]!.model, want);
+    } else {
+      chosenModel = providerDefaultModel(want);
+    }
+    await saveConfigPatch(raw => ({ subagents: withSubagentSetting(raw, role.id, { model: chosenModel }) }));
+    console.log(`${role.title} pinned to ${want} via model ${chosenModel} — saved to ~/.jeo/config.json`);
+    if (forProvider.length) {
+      lastPickIndex = forProvider;
+      lastPickIndexChanged = true;
+      const sourceNote = liveForProvider ? "Live" : "Catalog";
+      const tail = liveForProvider ? "" : " (log in to list live models)";
+      console.log(`${sourceNote} ${want} models — refine with /agents ${role.id} #N:${tail}`);
+      for (const line of formatPickListWithCapabilities(lastPickIndex, { current: chosenModel, cap: 12 })) console.log(line);
+    }
+    return result();
+  }
+  if (modelArg) {
+    let chosenModel = modelArg;
+    let entries = lastPickIndex;
+    if (modelArg.startsWith("#") && entries.length === 0) {
+      const live = await getLiveModels();
+      entries = flattenModels(live);
+    }
+    if (entries.length) {
+      const sel = resolveSelection(entries, modelArg);
+      if (sel.kind === "index" || sel.kind === "match") {
+        chosenModel = qualifyModelId(sel.entry.model, sel.entry.provider);
+        const bad = (await describeAllProviders()).find(s => s.name === sel.entry.provider && !s.ready);
+        if (bad) {
+          if (selectableThoughNotReady(bad)) {
+            console.log(notReadyWarning(bad));
+          } else {
+            console.log(`Cannot pin ${sel.entry.model}: ${sel.entry.provider} is not ready (${bad.label}). Set ${bad.envVar ?? "the provider key"} first.`);
+            return result();
+          }
+        }
+      } else if (sel.kind === "ambiguous") {
+        console.log(`'${modelArg}' matches ${sel.matches.length} live 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(`#${modelArg.slice(1)} is out of range (1-${sel.max}). Use /model first.`);
+        return result();
+      }
+    } else if (modelArg.startsWith("#")) {
+      console.log("Use /model first to build the numbered live model list.");
+      return result();
+    }
+    // Persist a per-role model override to ~/.jeo/config.json (consumed by 'jeo team').
+    await saveConfigPatch(raw => ({ subagents: withSubagentSetting(raw, role.id, { model: chosenModel }) }));
+    const { provider } = await describeModel(chosenModel);
+    console.log(`${role.title} model set to ${chosenModel} (${provider}) — saved to ~/.jeo/config.json`);
+    const live = await getLiveModels();
+    if (!liveModelKnown(live, chosenModel)) {
+      console.log(`  (note: '${chosenModel}' is not in any live model list — verify it is valid for ${provider})`);
+    }
+    return result();
+  }
+  for (const line of formatAgentDetail(role, {
+    model: resolveSubagentModel(role.id, cfgNow),
+    maxSteps: resolveSubagentMaxSteps(role.id, cfgNow),
+    thinking: resolveSubagentThinking(role.id, cfgNow),
+  })) console.log(line);
+  const live = await getLiveModels();
+  const agentPick = flattenModels(live);
+  if (agentPick.length) {
+    lastPickIndex = agentPick;
+    lastPickIndexChanged = true;
+    console.log(`Live models for ${role.title} — pin with /agents ${role.id} #N:`);
+    for (const line of formatPickListWithCapabilities(lastPickIndex, { current: resolveSubagentModel(role.id, cfgNow), cap: 20 })) console.log(line);
+  }
+  return result();
+}
+
+const ROLE_TIERS = ["smol", "slow", "plan"] as const;
+
+/**
+ * Handle `/roles [tier model]`. Extracted verbatim from launch.ts's inline
+ * REPL branch — the caller keeps the `input.startsWith("/roles") &&
+ * (input === "/roles" || input[6] === " ")` guard and just calls this
+ * function.
+ */
+export async function runRolesSlash(input: string, ctx: AgentsSlashCtx): Promise<AgentsSlashResult> {
+  const { getLiveModels } = ctx;
+  let lastPickIndex = ctx.lastPickIndex;
+  let lastPickIndexChanged = false;
+
+  const result = (): AgentsSlashResult => ({
+    ...(lastPickIndexChanged ? { lastPickIndex } : {}),
+  });
+
+  const tokens = input.substring(6).trim().split(/\s+/).filter(Boolean);
+  const cfgNow = await readGlobalConfig();
+  if (tokens.length >= 2 && (ROLE_TIERS as readonly string[]).includes(tokens[0])) {
+    const tier = tokens[0] as (typeof ROLE_TIERS)[number];
+    let chosenModel = tokens[1]!;
+    let entries = lastPickIndex;
+    if (chosenModel.startsWith("#") && entries.length === 0) {
+      const live = await getLiveModels();
+      entries = flattenModels(live);
+    }
+    if (entries.length) {
+      const sel = resolveSelection(entries, chosenModel);
+      if (sel.kind === "index" || sel.kind === "match") {
+        chosenModel = qualifyModelId(sel.entry.model, sel.entry.provider);
+        const bad = (await describeAllProviders()).find(s => s.name === sel.entry.provider && !s.ready);
+        if (bad) {
+          console.log(`Cannot set role ${tier} to ${sel.entry.model}: ${sel.entry.provider} is not ready (${bad.label}). Set ${bad.envVar ?? "the provider key"} first.`);
+          return result();
+        }
+      } else if (sel.kind === "ambiguous") {
+        console.log(`'${chosenModel}' matches ${sel.matches.length} live 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(`#${chosenModel.slice(1)} is out of range (1-${sel.max}). Use /model first.`);
+        return result();
+      }
+    } else if (chosenModel.startsWith("#")) {
+      console.log("Use /model first to build the numbered live model list.");
+      return result();
+    }
+    await saveConfigPatch(raw => ({ roles: { ...(raw.roles ?? {}), [tier]: chosenModel } }));
+    console.log(`Role '${tier}' model set to ${chosenModel} → ~/.jeo/config.json`);
+    return result();
+  }
+  console.log("Model role tiers (fall back to the default model):");
+  for (const tier of ROLE_TIERS) {
+    const { provider } = await describeModel(resolveRoleModel(tier, cfgNow));
+    console.log(`  ${tier.padEnd(5)} ${resolveRoleModel(tier, cfgNow)} (${provider})`);
+  }
+  console.log("Set a tier: /roles <smol|slow|plan> <model>");
+  const live = await getLiveModels();
+  const rolePick = flattenModels(live);
+  if (rolePick.length) {
+    lastPickIndex = rolePick;
+    lastPickIndexChanged = true;
+    console.log("Live models for role tiers — set with /roles <tier> #N:");
+    for (const line of formatPickListWithCapabilities(lastPickIndex, { cap: 15 })) console.log(line);
+  }
+  return result();
+}
+
+/**
+ * Handle `/fast [on|off|status]`. Extracted verbatim from launch.ts's inline
+ * REPL branch — the caller keeps the `input.startsWith("/fast") && (input
+ * === "/fast" || input[5] === " ")` guard and just calls this function.
+ */
+export async function runFastSlash(input: string, ctx: AgentsSlashCtx): Promise<AgentsSlashResult> {
+  let sessionThinking = ctx.sessionThinking;
+  let sessionThinkingChanged = false;
+
+  const result = (): AgentsSlashResult => ({
+    ...(sessionThinkingChanged ? { sessionThinking } : {}),
+  });
+
+  const arg = input.substring(5).trim().toLowerCase() || "status";
+  const cfgNow = await readGlobalConfig();
+  const currentModel = ctx.sessionModel || cfgNow.defaultModel;
+  const { resolved, provider } = await describeModel(currentModel);
+  const fastLevel = fastThinkingLevelForModel(resolved);
+  const currentThinking = sessionThinking ?? cfgNow.thinkingLevel ?? "medium";
+  const status = fastLevel && currentThinking === fastLevel ? "on" : "off";
+  if (arg === "status") {
+    const support = fastLevel ? `supported (thinking ${fastLevel})` : "unsupported";
+    console.log(`Fast mode: ${status} · ${support} · ${formatModelLine({ label: currentModel, resolved, provider })} · current thinking ${currentThinking}`);
+    return result();
+  }
+  if (arg === "on") {
+    if (!fastLevel) {
+      console.log(`Fast mode is not advertised for ${formatModelLine({ label: currentModel, resolved, provider })}; pick a thinking-capable model with /model.`);
+      return result();
+    }
+    sessionThinking = fastLevel;
+    sessionThinkingChanged = true;
+    console.log(`Fast mode on: ${formatModelLine({ label: currentModel, resolved, provider })} · thinking ${fastLevel} (~${thinkingMaxTokens(fastLevel)} max tokens/step)`);
+    return result();
+  }
+  if (arg === "off") {
+    sessionThinking = cfgNow.thinkingLevel ?? "medium";
+    sessionThinkingChanged = true;
+    console.log(`Fast mode off: restored thinking ${sessionThinking} (~${thinkingMaxTokens(sessionThinking)} max tokens/step)`);
+    return result();
+  }
+  console.log("Usage: /fast [on|off|status]");
+  return result();
+}
+
+/**
+ * Handle `/thinking [level]`. Extracted verbatim from launch.ts's inline
+ * REPL branch — the caller keeps the `input.startsWith("/thinking") &&
+ * (input === "/thinking" || input[9] === " ")` guard and just calls this
+ * function.
+ */
+export async function runThinkingSlash(input: string, ctx: AgentsSlashCtx): Promise<AgentsSlashResult> {
+  let sessionThinking = ctx.sessionThinking;
+  let sessionThinkingChanged = false;
+
+  const result = (): AgentsSlashResult => ({
+    ...(sessionThinkingChanged ? { sessionThinking } : {}),
+  });
+
+  const arg = input.substring(9).trim().toLowerCase();
+  if (!arg) {
+    console.log(`Thinking level: ${sessionThinking ?? "medium"} (~${thinkingMaxTokens(sessionThinking)} max tokens/step)`);
+    return result();
+  }
+  if (arg === "minimal" || arg === "low" || arg === "medium" || arg === "high" || arg === "xhigh") {
+    sessionThinking = arg;
+    sessionThinkingChanged = true;
+    console.log(`Thinking set to ${arg} (~${thinkingMaxTokens(arg)} max tokens/step)`);
+  } else {
+    console.log(`Invalid level '${arg}'. Use: minimal | low | medium | high | xhigh.`);
+  }
+  return result();
+}