jeo-code 0.1.0 → 0.4.5

package/src/util/AGENTS.md

@@ -0,0 +1,39 @@
+<!-- Parent: ../AGENTS.md -->
+<!-- Generated: 2026-06-11 | Updated: 2026-06-11 -->
+
+# util
+
+## Purpose
+General utilities, helper functions, and shared types used across the application.
+
+## Key Files
+| File | Description |
+|------|-------------|
+| `update-check.ts` | Async check for newer npm versions |
+| `retry.ts` | Rate-limit backoff and generic retry mechanisms |
+| `provider-error.ts` | Error normalization helpers |
+
+## Subdirectories
+*(None)*
+
+## For AI Agents
+
+### Working In This Directory
+- Keep utilities pure and stateless where possible.
+- Avoid circular dependencies.
+
+### Testing Requirements
+- High unit test coverage expected.
+
+### Common Patterns
+- Retry loops use exponential backoff respecting `Retry-After` headers.
+
+## Dependencies
+
+### Internal
+- Used globally.
+
+### External
+*(None)*
+
+<!-- MANUAL: -->

package/src/util/clipboard-image.ts

@@ -0,0 +1,118 @@
+/**
+ * Cross-platform clipboard IMAGE reader for the REPL's Ctrl+V image paste.
+ *
+ * Terminals only deliver *text* paste through stdin, so pasting a copied
+ * image (screenshot, browser right-click copy, …) needs an explicit OS
+ * clipboard query. Strategy per platform, all via short-lived subprocesses:
+ *  - macOS: `pngpaste -` when installed (fast), else an `osascript` fallback
+ *    that writes the clipboard's «class PNGf» data to a temp file.
+ *  - Linux: `wl-paste -t image/png` (Wayland), else `xclip -t image/png -o` (X11).
+ *  - Windows: PowerShell `[Windows.Forms.Clipboard]::GetImage()` → temp PNG.
+ *
+ * Returns null when the clipboard holds no image (or no tool is available) —
+ * callers treat null as "not an image paste" and fall through silently.
+ */
+import * as os from "node:os";
+import * as path from "node:path";
+import { unlink, readFile } from "node:fs/promises";
+import type { ImageAttachment } from "../ai/types";
+
+/** PNG magic bytes — every backend below produces PNG. */
+const PNG_MAGIC = Buffer.from([0x89, 0x50, 0x4e, 0x47]);
+
+export function looksLikePng(buf: Uint8Array): boolean {
+  return buf.length > 8 && Buffer.from(buf.slice(0, 4)).equals(PNG_MAGIC);
+}
+
+/** Build the attachment from raw image bytes; null when the bytes are not a PNG. */
+export function attachmentFromBytes(bytes: Uint8Array): ImageAttachment | null {
+  if (!looksLikePng(bytes)) return null;
+  return { mediaType: "image/png", data: Buffer.from(bytes).toString("base64") };
+}
+
+async function runCapture(cmd: string[], timeoutMs = 4000): Promise<Uint8Array | null> {
+  try {
+    const proc = Bun.spawn(cmd, { stdout: "pipe", stderr: "ignore", stdin: "ignore" });
+    const timer = setTimeout(() => proc.kill(), timeoutMs);
+    const bytes = new Uint8Array(await new Response(proc.stdout).arrayBuffer());
+    const code = await proc.exited;
+    clearTimeout(timer);
+    return code === 0 && bytes.length > 0 ? bytes : null;
+  } catch {
+    return null;
+  }
+}
+
+async function macClipboardImage(): Promise<Uint8Array | null> {
+  // Fast path: pngpaste (brew install pngpaste) streams PNG to stdout.
+  if (Bun.which("pngpaste")) {
+    const bytes = await runCapture(["pngpaste", "-"]);
+    if (bytes) return bytes;
+  }
+  if (!Bun.which("osascript")) return null;
+  // Fallback: AppleScript writes «class PNGf» clipboard data to a temp file.
+  const tmp = path.join(os.tmpdir(), `jeo-paste-${Date.now()}-${process.pid}.png`);
+  const script =
+    `set pngData to the clipboard as «class PNGf»\n` +
+    `set f to open for access POSIX file ${JSON.stringify(tmp)} with write permission\n` +
+    `write pngData to f\nclose access f`;
+  try {
+    const proc = Bun.spawn(["osascript", "-e", script], { stdout: "ignore", stderr: "ignore", stdin: "ignore" });
+    const timer = setTimeout(() => proc.kill(), 4000);
+    const code = await proc.exited;
+    clearTimeout(timer);
+    if (code !== 0) return null;
+    return new Uint8Array(await readFile(tmp));
+  } catch {
+    return null;
+  } finally {
+    unlink(tmp).catch(() => {});
+  }
+}
+
+async function linuxClipboardImage(): Promise<Uint8Array | null> {
+  if (process.env.WAYLAND_DISPLAY && Bun.which("wl-paste")) {
+    const bytes = await runCapture(["wl-paste", "-t", "image/png"]);
+    if (bytes) return bytes;
+  }
+  if (Bun.which("xclip")) {
+    return runCapture(["xclip", "-selection", "clipboard", "-t", "image/png", "-o"]);
+  }
+  return null;
+}
+
+async function windowsClipboardImage(): Promise<Uint8Array | null> {
+  if (!Bun.which("powershell.exe") && !Bun.which("powershell")) return null;
+  const tmp = path.join(os.tmpdir(), `jeo-paste-${Date.now()}-${process.pid}.png`);
+  const ps =
+    `Add-Type -AssemblyName System.Windows.Forms; ` +
+    `$img = [System.Windows.Forms.Clipboard]::GetImage(); ` +
+    `if ($img -eq $null) { exit 1 }; ` +
+    `$img.Save('${tmp.replace(/\\/g, "\\\\").replace(/'/g, "''")}', [System.Drawing.Imaging.ImageFormat]::Png)`;
+  try {
+    const exe = Bun.which("powershell.exe") ? "powershell.exe" : "powershell";
+    const proc = Bun.spawn([exe, "-NoProfile", "-STA", "-Command", ps], { stdout: "ignore", stderr: "ignore", stdin: "ignore" });
+    const timer = setTimeout(() => proc.kill(), 6000);
+    const code = await proc.exited;
+    clearTimeout(timer);
+    if (code !== 0) return null;
+    return new Uint8Array(await readFile(tmp));
+  } catch {
+    return null;
+  } finally {
+    unlink(tmp).catch(() => {});
+  }
+}
+
+/**
+ * Read an image from the system clipboard, or null when none is present.
+ * Never throws; never blocks longer than a few seconds.
+ */
+export async function readClipboardImage(): Promise<ImageAttachment | null> {
+  const bytes =
+    process.platform === "darwin" ? await macClipboardImage()
+    : process.platform === "win32" ? await windowsClipboardImage()
+    : await linuxClipboardImage();
+  if (!bytes) return null;
+  return attachmentFromBytes(bytes);
+}

package/src/util/env.ts

@@ -0,0 +1,12 @@
+/**
+ * Branded environment-variable lookup for jeo runtime flags.
+ *
+ * Runtime flags use the canonical `JEO_*` spelling only.
+ * `env` is injectable for tests.
+ */
+export function jeoEnv(
+  suffix: string,
+  env: Record<string, string | undefined> = process.env,
+): string | undefined {
+  return env[`JEO_${suffix}`];
+}

package/src/util/provider-error.ts

@@ -0,0 +1,78 @@
+/**
+ * Map a raw provider error (rate limit / auth / generic) to a concise, actionable
+ * one-line message for the user. Provider adapters throw `ProviderHttpError`
+ * (carrying `.status` and a body), and the agent loop surfaces failures both as a
+ * thrown error and as a `doneReason`, so this lives in a shared util used by both.
+ */
+import { isUsageLimitError } from "./retry";
+
+/** Provider-authoritative context-overflow signal (HTTP 400/413 family). The
+ *  local token estimate can drift under the real count (images, tokenizer
+ *  mismatch) — when the PROVIDER says the prompt doesn't fit, the loop can react
+ *  (reactive trim + one retry) instead of dying on an opaque 400 (round-6 #4). */
+export function isContextOverflowError(err: unknown): boolean {
+  const msg = (err as Error)?.message ?? String(err);
+  const status = (err as { status?: number })?.status;
+  const pattern = /context[ _-]?length|context window|prompt is too long|input is too long|too many tokens|maximum (input|context)|exceeds.{0,30}(context|token)/i;
+  if (pattern.test(msg)) return true;
+  return status === 413; // payload-too-large is always an overflow signal
+}
+
+/** Provider safety-refusal signal: an HTTP-200 completion that returned NO
+ *  content because the model/provider declined (Anthropic `stop_reason=refusal`,
+ *  OpenAI `finish_reason=content_filter`, Gemini `SAFETY`/`PROHIBITED_CONTENT`
+ *  block reasons). On routine coding work these are usually transient
+ *  false-positives — the engine retries the step (bounded) instead of killing
+ *  the turn with a dead "Error: … returned no content". */
+export function isRefusalError(err: unknown): boolean {
+  const msg = (err as Error)?.message ?? String(err);
+  return /stop_reason=refusal|finish_reason=content_filter|\(content_filter\)|\(SAFETY\)|\(PROHIBITED_CONTENT\)|\(BLOCKLIST\)/i.test(msg);
+}
+
+function formatDuration(ms: number): string {
+  const totalSeconds = Math.ceil(ms / 1000);
+  if (totalSeconds < 60) return `${totalSeconds}s`;
+  const minutes = Math.ceil(totalSeconds / 60);
+  if (minutes < 60) return `~${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  const rem = minutes % 60;
+  return rem ? `~${hours}h ${rem}m` : `~${hours}h`;
+}
+
+export function friendlyProviderError(err: unknown): string {
+  const msg = (err as Error)?.message ?? String(err);
+  const status = (err as { status?: number })?.status;
+  const provider = /antigravity/i.test(msg)
+    ? "Antigravity"
+    : /anthropic/i.test(msg)
+      ? "Anthropic"
+      : /openai/i.test(msg)
+        ? "OpenAI"
+        : /gemini|google/i.test(msg)
+          ? "Gemini"
+          : "the provider";
+
+  if (isUsageLimitError(err)) {
+    return `${provider} usage/quota limit reached — this window will not clear in seconds, so auto-retry was skipped. Switch model with /model (e.g. a local ollama model), use another provider, or wait for the limit window to reset.`;
+  }
+  if (status === 429 || /\b429\b/.test(msg) || /rate[ _]?limit/i.test(msg)) {
+    const retryAfterMs = (err as { retryAfterMs?: number })?.retryAfterMs;
+    const retry = typeof retryAfterMs === "number" && Number.isFinite(retryAfterMs) && retryAfterMs > 0
+      ? ` Server requested retry after ${formatDuration(retryAfterMs)}.`
+      : "";
+    return `Rate limited by ${provider} (HTTP 429).${retry} Auto-retry cannot clear this window right now — slow your request rate, wait for the reset, or switch model with /model (a local ollama model never rate-limits).`;
+  }
+  if (status === 401 || status === 403 || /\b40[13]\b/.test(msg)) {
+    return `${provider} rejected the credential (HTTP ${status ?? "401/403"}). Run 'jeo auth status', re-login with /provider login <name>, and for Antigravity prefer '/provider login antigravity' (gemini login only works when the Cloud Code Assist backend authorizes that token).`;
+  }
+  if (isContextOverflowError(err)) {
+    return `${provider} rejected the request: the conversation no longer fits the model's context window. Run /compact, drop large attachments, or start a fresh session.`;
+  }
+  if (isRefusalError(err)) {
+    return `${provider} declined to answer (safety refusal — no content returned) even after automatic retries with a context reset. Usually a content classifier tripped on recently read file/search content: /retry once more, /compact or /new to drop the triggering context, or switch model with /model. If this persists on a Claude subscription (OAuth) login, Anthropic restricts third-party OAuth clients — set ANTHROPIC_API_KEY or use another provider.`;
+  }
+  if (status === 404) {
+    return `${provider} does not recognize the requested model (HTTP 404). The id may be retired, gated, or mistyped — pick another with /model.`;
+  }
+  return msg;
+}

package/src/util/retry.ts

@@ -5,7 +5,22 @@ export interface RetryOptions {
   isRetryable?: (err: unknown, attempt: number) => boolean;
   sleep?: (ms: number) => Promise<void>;   // injectable for tests (default real setTimeout)
   random?: () => number;   // injectable RNG for jitter (default Math.random); equal-jitter in [0.5x, 1x]
-  onRetry?: (attempt: number, err: unknown) => void;
+  /** Notified before each backoff wait; `delayMs` is the wait actually applied. */
+  onRetry?: (attempt: number, err: unknown, delayMs: number) => void;
+  /** Minimum backoff (ms) applied specifically to rate-limit (429) errors. The floor
+   *  ESCALATES per attempt (floor × 2^(attempt-1), capped at RETRY_AFTER_CAP_MS) because a
+   *  rate-limit window rarely clears in <1s and often needs tens of seconds — a flat
+   *  sub-second retry cadence just burns the budget; default 0 (no floor) preserves
+   *  generic behavior. */
+  rateLimitMinDelayMs?: number;
+  /** Total attempt cap used specifically when the current error is a rate limit (429).
+   *  When higher than `retries`, rate-limit errors get extra attempts so a transient
+   *  per-minute window can reset; non-rate-limit errors still use `retries`. */
+  rateLimitRetries?: number;
+  /** If a 429 carries a server-directed retry delay above this budget, fail fast
+   * instead of capping the wait and replaying a request the server already said
+   * cannot succeed soon. */
+  rateLimitMaxServerDelayMs?: number;
 }
 
 // Default retryable predicate: true for transient network errors, transient/overload
@@ -16,6 +31,13 @@ export function defaultRetryable(err: unknown): boolean {
   if (!err) {
     return false;
   }
+  // Persistent usage/quota limits (e.g. a subscription window exhausted) never clear
+  // within a retry budget — fail fast so the caller can switch model/provider instead
+  // of sitting through the whole backoff ladder (gjc parity: QUOTA_EXHAUSTED is not
+  // retried like a per-minute 429).
+  if (isUsageLimitError(err)) {
+    return false;
+  }
 
   let message = "";
   if (err instanceof Error) {
@@ -59,11 +81,14 @@ export function defaultRetryable(err: unknown): boolean {
 
 // Server-directed `Retry-After` is honored but capped so a CLI never hangs on a hostile header.
 const RETRY_AFTER_CAP_MS = 30_000;
+// Long account/subscription windows should be reported, not silently compressed to 30s.
 
 // Run fn; on a retryable error, back off and retry up to `retries` attempts. Backoff is
 // exponential (baseDelay * 2^(attempt-1), capped at maxDelay) with equal jitter (the wait lands in
 // [0.5x, 1x] of that cap), unless the error carries a `retryAfterMs` (server `Retry-After`), which
-// takes precedence (capped at RETRY_AFTER_CAP_MS). Re-throws the last error when exhausted.
+// takes precedence (capped at RETRY_AFTER_CAP_MS). A 429 with a server delay beyond
+// `rateLimitMaxServerDelayMs` is not retried because the provider has identified a
+// long account-wide window; callers can surface the reset time instead of hanging.
 export async function withRetry<T>(fn: () => Promise<T>, opts?: RetryOptions): Promise<T> {
   const retries = opts?.retries ?? 3;
   const baseDelayMs = opts?.baseDelayMs ?? 250;
@@ -72,24 +97,51 @@ export async function withRetry<T>(fn: () => Promise<T>, opts?: RetryOptions): P
   const sleep = opts?.sleep ?? ((ms: number) => new Promise<void>(resolve => setTimeout(resolve, ms)));
   const random = opts?.random ?? Math.random;
   const onRetry = opts?.onRetry;
+  const rateLimitMinDelayMs = opts?.rateLimitMinDelayMs ?? 0;
+  const rateLimitRetries = opts?.rateLimitRetries;
+  const rateLimitMaxServerDelayMs = opts?.rateLimitMaxServerDelayMs;
 
   let attempt = 1;
   while (true) {
     try {
       return await fn();
     } catch (err) {
-      if (attempt >= retries || !isRetryable(err, attempt)) {
+      // Rate-limit (429) errors may use a higher attempt cap so a transient
+      // per-minute window can reset before we surface the failure. If the server
+      // says the window is much longer than our retry budget, fail fast with the
+      // original error so the UI can show the real reset delay.
+      const rateLimited = isRateLimitError(err);
+      const serverDelay = retryAfterOf(err);
+      if (
+        rateLimited &&
+        typeof rateLimitMaxServerDelayMs === "number" &&
+        serverDelay !== undefined &&
+        serverDelay > rateLimitMaxServerDelayMs
+      ) {
+        throw err;
+      }
+      const cap = rateLimited && typeof rateLimitRetries === "number" ? Math.max(retries, rateLimitRetries) : retries;
+      if (attempt >= cap || !isRetryable(err, attempt)) {
         throw err;
       }
 
       const capped = Math.min(baseDelayMs * Math.pow(2, attempt - 1), maxDelayMs);
       // Equal jitter: half fixed + half random → [0.5x, 1x] of the capped backoff.
       const jittered = capped / 2 + random() * (capped / 2);
-      const serverDelay = retryAfterOf(err);
-      const delay = serverDelay !== undefined ? Math.min(serverDelay, RETRY_AFTER_CAP_MS) : jittered;
+      // Server `Retry-After` wins (capped); else jitter. For rate limits, apply the
+      // floor in BOTH cases so a 0/near-0 Retry-After (or sub-second jitter) doesn't
+      // burn the 429 budget back-to-back with no real pause. The floor escalates per
+      // attempt (×2 each retry, capped) so the total wait across the 429 budget spans
+      // a realistic rate-limit window (~a minute) instead of ~8s.
+      const cappedServer = serverDelay !== undefined ? Math.min(serverDelay, RETRY_AFTER_CAP_MS) : undefined;
+      const base = cappedServer !== undefined ? cappedServer : jittered;
+      const floor = rateLimited
+        ? Math.min(rateLimitMinDelayMs * Math.pow(2, attempt - 1), RETRY_AFTER_CAP_MS)
+        : 0;
+      const delay = Math.max(base, floor);
 
       if (onRetry) {
-        onRetry(attempt, err);
+        onRetry(attempt, err, delay);
       }
 
       await sleep(delay);
@@ -106,3 +158,36 @@ function retryAfterOf(err: unknown): number | undefined {
   }
   return undefined;
 }
+
+// True when an error is an HTTP 429 / rate-limit (structured `.status` or message text).
+export function isRateLimitError(err: unknown): boolean {
+  if (typeof err === "object" && err !== null) {
+    const status = (err as { status?: unknown }).status;
+    const n = typeof status === "number" ? status : typeof status === "string" ? Number(status) : NaN;
+    if (n === 429) return true;
+  }
+  const message = err instanceof Error ? err.message : typeof err === "string" ? err : "";
+  return /\b429\b/.test(message) || /rate[ _]?limit/i.test(message);
+}
+
+/** Message text of an unknown error (Error / string / object with message). */
+function errorMessageOf(err: unknown): string {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "string") return err;
+  if (typeof err === "object" && err !== null && typeof (err as { message?: unknown }).message === "string") {
+    return (err as { message: string }).message;
+  }
+  return "";
+}
+
+/**
+ * Persistent usage/quota-limit detection (gjc parity: `isUsageLimitError`). These are
+ * subscription/window limits ("usage limit reached", "quota exceeded") that need a model
+ * or credential switch — retrying within seconds is pure waste, unlike a per-minute 429.
+ * Deliberately excludes the ambiguous "resource exhausted" (Gemini uses it for windows
+ * that often DO clear within a retry budget).
+ */
+const USAGE_LIMIT_PATTERN = /usage.?limit|usage_limit_reached|usage_not_included|limit_reached|quota.?exceeded|exceeded your/i;
+export function isUsageLimitError(err: unknown): boolean {
+  return USAGE_LIMIT_PATTERN.test(errorMessageOf(err));
+}

package/src/util/update-check.ts

@@ -0,0 +1,64 @@
+import pkg from "../../package.json";
+import { compareVersions } from "../commands/update";
+
+export interface UpdateCheckResult {
+  current: string;
+  latest: string;
+  updateAvailable: boolean;
+}
+
+export interface UpdateCheckDeps {
+  fetchJson?: (url: string, opts?: { signal?: AbortSignal }) => Promise<any>;
+  localVersion?: () => string;
+  timeoutMs?: number;
+}
+
+export async function checkForUpdate(deps?: UpdateCheckDeps): Promise<UpdateCheckResult | null> {
+  try {
+    const fetchJson = deps?.fetchJson ?? (async (url, opts) => {
+      const res = await fetch(url, opts);
+      if (!res.ok) {
+        throw new Error(`HTTP error ${res.status}`);
+      }
+      return res.json();
+    });
+
+    const localVersion = deps?.localVersion ?? (() => pkg.version);
+    const timeoutMs = deps?.timeoutMs ?? 2500;
+
+    const controller = new AbortController();
+    const id = setTimeout(() => controller.abort(), timeoutMs);
+
+    try {
+      const current = localVersion();
+      if (typeof current !== "string" || !current) {
+        clearTimeout(id);
+        return null;
+      }
+
+      const data = await fetchJson("https://registry.npmjs.org/jeo-code/latest", {
+        signal: controller.signal,
+      });
+
+      clearTimeout(id);
+
+      if (!data || typeof data.version !== "string") {
+        return null;
+      }
+
+      const latest = data.version;
+      const updateAvailable = compareVersions(current, latest) < 0;
+
+      return {
+        current,
+        latest,
+        updateAvailable,
+      };
+    } catch (err) {
+      clearTimeout(id);
+      return null;
+    }
+  } catch (err) {
+    return null;
+  }
+}

package/src/commands/models.ts

@@ -1,104 +0,0 @@
-import { readGlobalConfig } from "../agent/state";
-import { listAliases, resolveModelId } from "../ai/model-registry";
-import { resolveProvider, resolveRoleModel } from "../ai/model-manager";
-import { describeAllProviders } from "../ai/provider-status";
-import { discoverModels } from "../ai/model-discovery";
-import { formatLiveModels, formatCatalogTable, formatEnrichedModels } from "../tui/components/config-panel";
-import { MODEL_CATALOG, fuzzyMatchCatalog, type ThinkLevel } from "../ai/model-catalog";
-import { enrichAll, filterCapable, sortByCapability, knownCount } from "../ai/model-enrich";
-
-async function probeOllama(baseUrl: string): Promise<string[]> {
-  try {
-    const r = await fetch(`${baseUrl.replace(/\/$/, "")}/api/tags`, { signal: AbortSignal.timeout(2500) });
-    if (!r.ok) return [];
-    const data = (await r.json()) as { models?: { name: string }[] };
-    return (data.models ?? []).map(m => `ollama/${m.name}`);
-  } catch {
-    return [];
-  }
-}
-
-async function probeOpenAiCompat(baseUrl: string): Promise<string[]> {
-  try {
-    const r = await fetch(`${baseUrl.replace(/\/$/, "")}/models`, { signal: AbortSignal.timeout(2500) });
-    if (!r.ok) return [];
-    const data = (await r.json()) as { data?: { id: string }[] };
-    return (data.data ?? []).map(m => `openai/${m.id}`);
-  } catch {
-    return [];
-  }
-}
-
-export async function runModelsCommand(args: string[] = []): Promise<void> {
-  const checkMode = args.includes("--check");
-  const providerFilter = args.find(a => ["anthropic", "openai", "gemini", "ollama"].includes(a.toLowerCase()))?.toLowerCase();
-  if (args.includes("--catalog")) {
-    const query = args.find(a => !a.startsWith("--") && !["anthropic", "openai", "gemini", "ollama"].includes(a.toLowerCase()));
-    const rows = query ? fuzzyMatchCatalog(query) : [...MODEL_CATALOG];
-    console.log("\n=== joc models --catalog ===");
-    console.log(`Known model capabilities${query ? ` matching '${query}'` : ""}:`);
-    for (const line of formatCatalogTable(rows)) console.log(line);
-    return;
-  }
-  if (args.includes("--caps")) {
-    const cfg = await readGlobalConfig();
-    const def = await resolveModelId(cfg.defaultModel);
-    const thinkArg = args.find(a => a.startsWith("--thinking="))?.split("=")[1] as ThinkLevel | undefined;
-    const filter = {
-      thinking: thinkArg,
-      images: args.includes("--images") ? true : undefined,
-      minContext: args.includes("--long") ? 200_000 : undefined,
-    };
-    console.log("\n=== joc models --caps (live + capabilities) ===");
-    const live = await discoverModels({ config: cfg, timeoutMs: 4000 });
-    const enriched = sortByCapability(filterCapable(enrichAll(live), filter));
-    const { known, unknown } = knownCount(enriched);
-    for (const line of formatEnrichedModels(enriched, { current: def })) console.log(line);
-    console.log(`\n${known} with known capabilities, ${unknown} unknown.`);
-    return;
-  }
-  const config = await readGlobalConfig();
-  console.log("\n=== joc models ===");
-  const resolved = await resolveModelId(config.defaultModel);
-  console.log(`Default model: ${config.defaultModel}${resolved !== config.defaultModel ? ` → ${resolved}` : ""} → ${resolveProvider(resolved)}`);
-  console.log(`Role tiers: smol=${resolveRoleModel("smol", config)} · slow=${resolveRoleModel("slow", config)} · plan=${resolveRoleModel("plan", config)}`);
-
-  const aliases = await listAliases();
-  console.log("\nAliases (use as the model id; config overrides built-ins):");
-  for (const [alias, target] of Object.entries(aliases)) {
-    console.log(`  ${alias.padEnd(10)} → ${target.padEnd(22)} (${resolveProvider(target)})`);
-  }
-
-  const ollamaBase = config.ollamaBaseUrl ?? "http://localhost:11434";
-  const ollama = await probeOllama(ollamaBase);
-  console.log(`\nLocal Ollama (${ollamaBase}):`);
-  if (ollama.length) for (const m of ollama.slice(0, 30)) console.log(`  ${m}`);
-  else console.log("  (none reachable)");
-
-  if (config.openaiBaseUrl) {
-    const compat = await probeOpenAiCompat(config.openaiBaseUrl);
-    console.log(`\nOpenAI-compatible (${config.openaiBaseUrl}):`);
-    if (compat.length) for (const m of compat.slice(0, 30)) console.log(`  ${m}`);
-    else console.log("  (none reachable)");
-  }
-  console.log("\nProvider credentials:");
-  for (const status of await describeAllProviders(config)) {
-    const base = status.baseUrl ? `  [${status.baseUrl}]` : "";
-    console.log(`  ${status.name.padEnd(10)} ${status.ready ? "✓" : "·"} ${status.label}${base}`);
-  }
-
-  console.log("\nLive models (logged-in providers):");
-  let live = await discoverModels({ config, timeoutMs: 4000 });
-  if (providerFilter) live = live.filter(r => r.provider === providerFilter);
-  if (checkMode) {
-    for (const r of live) {
-      const mark = r.ok ? "✓" : "✗";
-      const detail = r.ok ? `${r.models.length} models (${r.source})` : `${r.error} (${r.source})`;
-      console.log(`  ${mark} ${r.provider.padEnd(10)} ${detail}`);
-    }
-    return;
-  }
-  for (const line of formatLiveModels(live, { current: resolved, perProvider: 20 })) console.log(line);
-
-  console.log("\nSet a default with 'joc setup' or JOC_DEFAULT_MODEL=<id>.");
-}