@guidobuilds/forge-ai 0.8.0 → 0.9.0

package/CHANGELOG.md

@@ -9,6 +9,40 @@ Versions prior to 0.3.0 are not reconstructed here; see git history for earlier
 
 ## [Unreleased]
 
+## [0.9.0] - 2026-09-05
+
+### Added
+
+- **Dynamic model discovery.** The per-agent model prompt (`install` and `configure`) now discovers
+  the models each harness's own CLI reports for that user, instead of relying only on curated lists,
+  via a shared `src/model-discovery.ts` module:
+  - one `ModelDiscoveryRunner` contract + `defaultRunner` (spawnSync + `resolveExecutable`, absolute-
+    path allowlist, no `cwd` passthrough), shared caps (5s timeout, 1 MB stdout, 500 models), a pure
+    `mergeLiveWithCurated(live, curated)` live-first/stable-order dedupe helper, and a
+    `discoverModels(platform, cwd)` dispatcher that returns `string[] | undefined` on any failure
+    (never throws). `src/opencode-discovery.ts` is now a backward-compatible re-export shim.
+  - **OpenCode** — unchanged behavior, now under the shared module + caps (`opencode`/`opencode2 models`).
+  - **Codex** — `codex debug models` JSON is parsed for `visibility === 'list'` slugs (`hide` entries
+    like `gpt-reserve`/`codex-auto-review` excluded), each slug trimmed + re-validated; curated
+    fallback on failure.
+  - **Grok** — `grok models` output is parsed for the `*` (default) / `-` (available) lines, ignoring
+    the `You are not authenticated.` banner; curated Forge aliases (`grok-build`, `grok-build-plan`,
+    `grok-composer-2.5-fast`, `inherit`) are merged in as extras on a successful live query.
+  - **Claude** — documented as having no CLI model-enumeration command; `discoverClaudeModels` always
+    returns `undefined`, so Claude stays curated + free text, never an empty/spurious list.
+- `modelChoicesFor(platform, discovered)` — a discovery-aware per-platform funnel (live-first,
+  curated-fallback, never an empty list) and `withLiveLabels(values, liveSet)` — a pure helper that
+  suffixes a live-derived option's *label* with ` (live)` while keeping the select value bare.
+- A single info diagnostic on non-Claude discovery failure
+  (`forge: model discovery for <platform> failed; using curated fallback.`), rendered inside the
+  clack frame when interactive, `console.error` otherwise.
+
+### Changed
+
+- The curated `knownCodexModels` offline fallback now matches the observed list-visible
+  `codex debug models` catalog (`gpt-5.6-sol`, `gpt-5.6-terra`, `gpt-5.6-luna`, `gpt-5.5`,
+  `gpt-5.4-mini`) — suggestions-only, never a validation gate, updated only from fresh live evidence.
+
 ## [0.8.0] - 2026-09-03
 
 ### Added

package/README.md

@@ -100,7 +100,7 @@ Install with the npm CLI:
 npx @guidobuilds/forge-ai install
 ```
 
-The installer prompts for the target agent platform, whether Forge should be installed globally for your user or locally for the current project, and — interactively — which model each agent should use: keep each agent's recommended default, or choose per agent. For OpenCode, the per-agent prompt shows the models you actually have configured (via `opencode models`, falling back to free-text entry if that command isn't available), not a generic list.
+The installer prompts for the target agent platform, whether Forge should be installed globally for your user or locally for the current project, and — interactively — which model each agent should use: keep each agent's recommended default, or choose per agent. For OpenCode, Codex, and Grok, the per-agent prompt shows the models you actually have configured (via `opencode models`, `codex debug models`, or `grok models`, falling back to a curated list or free-text entry if the command isn't available), not a generic list.
 
 To choose models non-interactively (requires an explicit single `--platform` — model ids aren't portable across platforms):
 
@@ -298,7 +298,7 @@ Prints every recorded install — the user-scope one, if any, plus one line per
 npx @guidobuilds/forge-ai configure --platform claude --scope user
 ```
 
-Change which model an already-installed agent uses without a full reinstall. Interactively, it walks every agent on the given scope/platform that supports a model (using OpenCode's live `opencode models` output where applicable, same as `install`). Non-interactively, pass `--model <id>` or `--model-map name=model,...` (same rules as `install`: an explicit single `--platform`, no `--force`/`--yes` — the point of the command is to make a choice, not skip one). Only the affected files are rewritten; the manifest and every other installed platform are left untouched.
+Change which model an already-installed agent uses without a full reinstall. Interactively, it walks every agent on the given scope/platform that supports a model (using each platform's live model discovery where applicable, same as `install`). Non-interactively, pass `--model <id>` or `--model-map name=model,...` (same rules as `install`: an explicit single `--platform`, no `--force`/`--yes` — the point of the command is to make a choice, not skip one). Only the affected files are rewritten; the manifest and every other installed platform are left untouched.
 
 ## Project Status
 

package/dist/src/adapters/claude-known.js

@@ -24,6 +24,12 @@ export const agentAllowlistPattern = /^Agent\([A-Za-z0-9_-]+(?:,\s*[A-Za-z0-9_-]
 export function isKnownClaudeTool(name) {
     return knownClaudeTools.has(name) || mcpToolPattern.test(name) || agentAllowlistPattern.test(name);
 }
+// Claude Code has NO CLI model-enumeration command: `claude --help` exposes only `--model` /
+// `--fallback-model` flags and a non-scriptable in-TUI `/model`. There is no `claude models` /
+// `claude list`. So `discoverClaudeModels` always returns undefined (see src/model-discovery.ts) and
+// the model-choice funnel always falls back to this curated set plus the free-text `Custom…` escape —
+// never an empty/spurious list. Do NOT add a fake dynamic source here; the `discoverModels` dispatch
+// keeps a `claude` branch so a real source could be added later without touching callers.
 export const knownClaudeModels = new Set([
     'sonnet',
     'opus',

package/dist/src/adapters/codex-known.js

@@ -1,8 +1,23 @@
-// Codex's current model-id list was not verified against live docs at the time this was written
-// (unlike Claude/Grok/OpenCode, which have a confirmed format). Rather than invent a shape we
-// haven't checked, this accepts any non-empty, whitespace-free value and lets Codex itself be the
-// real check — the same "don't guess" discipline this codebase applies elsewhere. Tighten this
-// once Codex's actual model-id format is verified against its docs.
+// Codex's model-id set changes over time and is account/plan dependent, so `isKnownCodexModel`
+// stays deliberately permissive: it accepts any non-empty, whitespace-free value and lets Codex
+// itself be the real check — the same "don't guess" discipline this codebase applies elsewhere.
+// This is a safety net against empty/whitespace values, NOT a validation gate on the model list.
+//
+// `knownCodexModels` is the OFFLINE FALLBACK presented only when live `codex debug models` discovery
+// fails (absent binary / non-zero exit / non-JSON / over-cap / timeout, or always on Windows fail-
+// closed). It is suggestions-only (the prompt also offers a `Custom…` free-text escape) and is NOT a
+// validation gate. Its ids are the list-visible, user-selectable catalog observed from a real
+// `codex debug models` run on the reference machine (explore.md §2 / verification.md):
+//   gpt-5.6-sol, gpt-5.6-terra, gpt-5.6-luna, gpt-5.5, gpt-5.4-mini
+// If the fallback drifts to ids outside this observed set, a failed live discovery degrades to models
+// the installed codex may not recognize — update it only from fresh live evidence, never by guessing.
+export const knownCodexModels = new Set([
+    'gpt-5.6-sol',
+    'gpt-5.6-terra',
+    'gpt-5.6-luna',
+    'gpt-5.5',
+    'gpt-5.4-mini'
+]);
 const codexModelPattern = /^\S+$/;
 export function isKnownCodexModel(value) {
     return codexModelPattern.test(value);

package/dist/src/adapters/grok-known.js

@@ -24,6 +24,10 @@ export const knownGrokTools = new Set([
 export function isKnownGrokTool(name) {
     return knownGrokTools.has(name);
 }
+// These Forge-specific aliases are NOT advertised by `grok models` — the live catalog only lists the
+// binary's known set (e.g. `grok-4.6`, `grok-4.5`). They are valid config values today, so dynamic
+// discovery (see src/model-discovery.ts::discoverGrokModels) merges them in as extras on a successful
+// live query and uses them as the whole fallback on failure. They must never be silently dropped.
 export const knownGrokModels = new Set([
     'inherit',
     'grok-build',

package/dist/src/cli.js

@@ -7,11 +7,12 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { rm } from 'node:fs/promises';
 import { knownClaudeModels } from './adapters/claude-known.js';
+import { knownCodexModels } from './adapters/codex-known.js';
 import { knownGrokModels } from './adapters/grok-known.js';
 import { formatDiagnostic, hasErrors } from './diagnostics.js';
 import { buildManifest, classifyPruneEntries, detectLegacyStateDrift, listInstalls, loadManifest, pruneEntries, resolveBackupPath, resolveBackupRoot, resolveManifestLocation, saveManifest, stateRoot, staleEntries } from './manifest.js';
 import { getModelPreference, loadModelPreferences, modelPreferencesPath, saveModelPreferences, setModelPreference } from './model-preferences.js';
-import { discoverOpenCodeModels } from './opencode-discovery.js';
+import { discoverModels, mergeLiveWithCurated } from './model-discovery.js';
 import { allowedInstallRoots } from './paths.js';
 import { supportsModel } from './platform-capabilities.js';
 import { buildWritePlan, discoverArtifacts, parsePlatform, parseScope, resolvePlatforms } from './processor.js';
@@ -394,10 +395,11 @@ async function promptForModelSelection(options, promptIO, cwd, home) {
     }
     const manifestLocation = await resolveManifestLocation(options.scope, cwd, home);
     let preferences = await loadModelPreferences(modelPreferencesPath(manifestLocation));
-    const discoveredOpenCodeModels = targetPlatforms.includes('opencode') ? discoverOpenCodeModels(cwd) : undefined;
+    const modelablePlatforms = [...new Set(pairs.map((pair) => pair.platform))];
+    const discovered = discoverModelChoices(modelablePlatforms, cwd, promptIO);
     for (const { platform, artifact } of pairs) {
         const current = getModelPreference(preferences, platform, artifact.name) ?? artifact[platform]?.model;
-        const chosen = await promptForModelValue(platform, artifact.name, current, discoveredOpenCodeModels, promptIO);
+        const chosen = await promptForModelValue(platform, artifact.name, current, discovered, promptIO);
         if (chosen === undefined)
             return false;
         preferences = setModelPreference(preferences, platform, artifact.name, chosen);
@@ -406,18 +408,45 @@ async function promptForModelSelection(options, promptIO, cwd, home) {
     return true;
 }
 const CUSTOM_MODEL_VALUE = '__custom__';
-async function promptForModelValue(platform, artifactName, current, discoveredOpenCodeModels, promptIO) {
+// Pure label helper: suffixes a live-derived value's *label* with ` (live)` so the user can tell live
+// options from curated/merged extras. The select **value** stays the bare model id, so stored
+// preferences and `initialValue` matching are unchanged. Curated extras and the `Custom…` escape are
+// never in the live set, so they are never suffixed.
+export function withLiveLabels(values, liveSet) {
+    return values.map((value) => ({ value, label: liveSet.has(value) ? `${value} (live)` : value }));
+}
+// Curated model suggestions for the interactive per-agent model prompt, or undefined when there is
+// no fixed list (the prompt then falls back to free text). Discovery results are live-first, highest
+// priority. Each platform is an explicit branch — a missing branch fails loudly rather than silently
+// producing a "no choices" path (see the codex-model-options regression in .forge/lessons.md):
+//   opencode: live, else free-text (undefined) — no curated set.
+//   codex:    live, NO merge (the live catalog is the real account-filtered set; merging stale curated
+//             suggestions would present ids the user may not be able to select); curated on failure.
+//   grok:     live + curated extras merged (dedupe, stable order) — `grok models` doesn't advertise the
+//             Forge-specific aliases, so they must survive a successful live query; curated on failure.
+//   claude:   curated always — no dynamic source, never empty/undefined.
+export function modelChoicesFor(platform, discovered = {}) {
+    const live = discovered[platform];
+    if (platform === 'opencode')
+        return live && live.length > 0 ? live : undefined;
+    if (platform === 'claude')
+        return [...knownClaudeModels];
+    if (platform === 'codex')
+        return live && live.length > 0 ? live : [...knownCodexModels];
+    if (platform === 'grok')
+        return live && live.length > 0 ? mergeLiveWithCurated(live, knownGrokModels) : [...knownGrokModels];
+    return undefined;
+}
+async function promptForModelValue(platform, artifactName, current, discovered, promptIO) {
     const io = clackIO(promptIO);
-    const knownChoices = platform === 'opencode' && discoveredOpenCodeModels ? discoveredOpenCodeModels
-        : platform === 'claude' ? [...knownClaudeModels]
-            : platform === 'grok' ? [...knownGrokModels]
-                : undefined;
+    const knownChoices = modelChoicesFor(platform, discovered);
     if (knownChoices && knownChoices.length > 0) {
         const initialValue = current && knownChoices.includes(current) ? current : knownChoices[0];
+        const liveSet = new Set(discovered[platform] ?? []);
         const choice = await p.select({
             message: `Model for \`${artifactName}\` (${platform})`,
             initialValue,
-            options: [...knownChoices.map((value) => ({ value, label: value })), { value: CUSTOM_MODEL_VALUE, label: 'Custom…' }],
+            options: [...withLiveLabels(knownChoices, liveSet), { value: CUSTOM_MODEL_VALUE, label: 'Custom…' }],
             ...io
         });
         if (p.isCancel(choice))
@@ -435,6 +464,31 @@ async function promptForModelValue(platform, artifactName, current, discoveredOp
         return undefined;
     return text;
 }
+// Compute the per-platform discovery map once per CLI run, scoped to the deduped set of platforms that
+// actually have a modelable pair in this run (so e.g. `install --platform all` with no Codex agent
+// artifact never sparks a needless `codex debug models` spawn). Discovery is synchronous (spawnSync).
+// A failed non-claude discovery emits a single info diagnostic. `claude` is skipped because it has no
+// dynamic source by design (not because it failed). The diagnostic is rendered inside the clack frame
+// (p.log.warn) when the run is interactive so it doesn't corrupt the TUI (raw console.error writes to
+// stderr, the same terminal clack draws on, which clack does not redraw/clear — see lessons.md
+// dynamic-model-discovery); console.error is only the non-interactive fallback.
+function discoverModelChoices(platforms, cwd, promptIO) {
+    const discovered = {};
+    for (const platform of platforms) {
+        const models = discoverModels(platform, cwd);
+        if (models && models.length > 0) {
+            discovered[platform] = models;
+        }
+        else if (platform !== 'claude') {
+            const note = `forge: model discovery for ${platform} failed; using curated fallback.`;
+            if (isInteractivePrompt(promptIO))
+                p.log.warn(note, clackIO(promptIO));
+            else
+                console.error(note);
+        }
+    }
+    return discovered;
+}
 function parseModelMap(value) {
     const result = {};
     for (const pair of value.split(',')) {
@@ -723,10 +777,11 @@ async function runConfigure(options, promptIO) {
             console.log('No installed agent on the selected scope supports a configurable model.');
             return 0;
         }
-        const discoveredOpenCodeModels = targetPlatforms.includes('opencode') ? discoverOpenCodeModels(cwd) : undefined;
+        const modelablePlatforms = [...new Set(pairs.map((pair) => pair.platform))];
+        const discovered = discoverModelChoices(modelablePlatforms, cwd, promptIO);
         for (const { platform, artifact } of pairs) {
             const current = getModelPreference(preferences, platform, artifact.name) ?? artifact[platform]?.model;
-            const chosen = await promptForModelValue(platform, artifact.name, current, discoveredOpenCodeModels, promptIO);
+            const chosen = await promptForModelValue(platform, artifact.name, current, discovered, promptIO);
             if (chosen === undefined) {
                 p.cancel('Cancelled', clackIO(promptIO));
                 return 1;

package/dist/src/model-discovery.js

@@ -0,0 +1,200 @@
+import { spawnSync } from 'node:child_process';
+import { resolveExecutable } from './executable-resolution.js';
+import { isKnownCodexModel } from './adapters/codex-known.js';
+import { isKnownGrokModel } from './adapters/grok-known.js';
+export const MODEL_DISCOVERY_TIMEOUT_MS = 5000;
+export const MODEL_DISCOVERY_MAX_STDOUT_BYTES = 1024 * 1024; // Codex live is ~327 KB — 1 MB headroom.
+export const MODEL_DISCOVERY_MAX_MODELS = 500;
+// defaultRunner: spawnSync + resolveExecutable (moved here from opencode-discovery so the module graph
+// stays acyclic and the runner/caps live in one place). Binaries are resolved to absolute paths and
+// any candidate inside cwd (a repo-local shim) is rejected by resolveExecutable. On Windows there is
+// no PATHEXT, so `.cmd`/`.bat`/`.exe` wrappers won't resolve and discovery degrades to the curated
+// fallback — fail-closed, documented, not fixed here.
+export const defaultRunner = (command, args, options) => {
+    const resolved = resolveExecutable(command, { cwd: options.cwd });
+    if (!resolved)
+        return { status: null, stdout: '' };
+    try {
+        const result = spawnSync(resolved, args, { timeout: options.timeoutMs, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+        return { status: result.error ? null : result.status, stdout: result.stdout ?? '' };
+    }
+    catch {
+        return { status: null, stdout: '' };
+    }
+};
+function exceedsStdoutCap(stdout) {
+    // Byte-accurate: compare Buffer.byteLength (UTF-8 bytes), not `.length` (UTF-16 code units).
+    return Buffer.byteLength(stdout, 'utf8') > MODEL_DISCOVERY_MAX_STDOUT_BYTES;
+}
+function dedupeStable(values) {
+    const seen = new Set();
+    const out = [];
+    for (const value of values) {
+        if (!seen.has(value)) {
+            seen.add(value);
+            out.push(value);
+        }
+    }
+    return out;
+}
+// ============================================================================
+// OpenCode — `opencode` / `opencode2 models` (preserved behavior, caps added)
+// ============================================================================
+// `opencode models` prints exactly the models this user can actually pick — filtered to whichever
+// providers have credentials (env var, stored auth, or a config/plugin-declared provider), not the
+// full models.dev catalog. This is deliberately NOT config-file parsing: OpenCode's config schema
+// differs between v1 (`provider`, singular) and the v2 preview (`providers`, plural), env-var- and
+// credential-connected providers appear in neither file, and OPENCODE_CONFIG_DIR can relocate the
+// whole config tree — the CLI itself is the only thing that resolves all of that correctly.
+// Tries `opencode` (v1) then `opencode2` (v2 preview). v2 gained a real `models` command in
+// `anomalyco/opencode` commit 30d14000 (2026-08-06); any v2 build older than that has no such
+// subcommand and treats `models` as a positional `<directory>` (crash) — caught here regardless.
+const modelLinePattern = /^[A-Za-z0-9][A-Za-z0-9._-]*\/\S+$/;
+export function discoverOpenCodeModels(cwd, timeoutMs = MODEL_DISCOVERY_TIMEOUT_MS, runner = defaultRunner) {
+    for (const command of ['opencode', 'opencode2']) {
+        const result = runner(command, ['models'], { cwd, timeoutMs });
+        if (result.status !== 0)
+            continue;
+        if (exceedsStdoutCap(result.stdout))
+            return undefined;
+        const lines = result.stdout
+            .split('\n')
+            .map((line) => line.trim())
+            .filter((line) => modelLinePattern.test(line));
+        if (lines.length > 0)
+            return lines.slice(0, MODEL_DISCOVERY_MAX_MODELS);
+    }
+    return undefined;
+}
+// ============================================================================
+// Codex — `codex debug models` (merged catalog; `--bundled` deferred, documented)
+// ============================================================================
+// Codex has no stable offline model enum. `codex debug models` prints the *merged* catalog (the
+// remote-refreshed set Codex sees, ~327 KB) as JSON `{ "models": [...] }`; each entry has `slug`,
+// `display_name`, `visibility` (`list` | `hide`), `context_window`, `priority`, `description`, and
+// `supported_reasoning_levels`. User-selectable ids are `visibility === 'list'`; each slug is then
+// trimmed and re-validated through `isKnownCodexModel` so empty/whitespace ids can never leak through.
+//
+// Bundled-vs-merged decision: we default to the MERGED catalog (remote refresh) under the shared
+// timeout because it is closer to what the user can actually select. `--bundled` (offline-deterministic,
+// skips the remote refresh) is a documented follow-up, NOT built: a `--bundled` re-run on timeout would
+// double latency, and the curated `knownCodexModels` offline fallback already covers the deterministic
+// case. Caveat (openai/codex issue 33146): the merged catalog can diverge from the TUI `/model` picker
+// (stale `~/.codex/models_cache.json`) — mitigated by suggestions-only UX + the `Custom…` free-text
+// escape. `supported_reasoning_levels` is deliberately discarded (model-id-only selection).
+export function discoverCodexModels(cwd, timeoutMs = MODEL_DISCOVERY_TIMEOUT_MS, runner = defaultRunner) {
+    const result = runner('codex', ['debug', 'models'], { cwd, timeoutMs });
+    if (result.status !== 0)
+        return undefined;
+    if (exceedsStdoutCap(result.stdout))
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(result.stdout);
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
+        return undefined;
+    const models = parsed.models;
+    if (!Array.isArray(models))
+        return undefined;
+    const slugs = [];
+    for (const entry of models) {
+        if (typeof entry !== 'object' || entry === null)
+            continue;
+        const candidate = entry;
+        if (candidate.visibility !== 'list')
+            continue;
+        if (typeof candidate.slug !== 'string')
+            continue;
+        // Trim and re-validate each slug through the permissive per-platform validator, mirroring the grok
+        // parser's discipline (explore.md §4): an empty/whitespace-only id must never leak into the choices.
+        const id = candidate.slug.trim();
+        if (!isKnownCodexModel(id))
+            continue;
+        slugs.push(id);
+    }
+    const deduped = dedupeStable(slugs);
+    if (deduped.length === 0)
+        return undefined;
+    return deduped.slice(0, MODEL_DISCOVERY_MAX_MODELS);
+}
+// ============================================================================
+// Grok — `grok models` (banner-ignoring, `isKnownGrokModel`-validated)
+// ============================================================================
+// `grok models` output can carry a `You are not authenticated.` banner before the model list; the list
+// uses `* <model> (default)` for the default and `- <model>` for available. The banner is noise and
+// never a model line.
+//
+// Fusion policy: `grok models` advertises the binary's known catalog (e.g. `grok-4.6`, `grok-4.5`) but
+// does NOT advertise the Forge-specific aliases the curated set carries (`grok-build`, `grok-build-plan`,
+// `grok-composer-2.5-fast`, `inherit`). Those are valid config values today, so on a successful live
+// query they are merged in as extras (live-first, deduped, stable order via `mergeLiveWithCurated`); on
+// failure the curated set is the whole fallback. We must not silently drop them on a live query.
+const grokModelLinePattern = /^[*\-]\s+(\S+)/;
+export function discoverGrokModels(cwd, timeoutMs = MODEL_DISCOVERY_TIMEOUT_MS, runner = defaultRunner) {
+    const result = runner('grok', ['models'], { cwd, timeoutMs });
+    if (result.status !== 0)
+        return undefined;
+    if (exceedsStdoutCap(result.stdout))
+        return undefined;
+    const out = [];
+    const seen = new Set();
+    for (const line of result.stdout.split('\n')) {
+        const match = grokModelLinePattern.exec(line.trim());
+        if (!match)
+            continue;
+        const id = match[1];
+        if (!isKnownGrokModel(id))
+            continue;
+        if (!seen.has(id)) {
+            seen.add(id);
+            out.push(id);
+        }
+    }
+    if (out.length === 0)
+        return undefined;
+    return out.slice(0, MODEL_DISCOVERY_MAX_MODELS);
+}
+// ============================================================================
+// Claude — no dynamic source (honest undefined)
+// ============================================================================
+// Claude Code has NO CLI model-enumeration command: `claude --help` exposes only `--model` /
+// `--fallback-model` flags and a non-scriptable in-TUI `/model`. There is no `claude models` /
+// `claude list`. So this always returns undefined by design — the curated `knownClaudeModels` set plus
+// the free-text `Custom…` escape is the honest fallback. Do NOT add a fake dynamic source here; the
+// `discoverModels` dispatch keeps a `claude` branch so a real source could be added later without
+// touching the caller.
+export function discoverClaudeModels(cwd, timeoutMs = MODEL_DISCOVERY_TIMEOUT_MS, runner = defaultRunner) {
+    return undefined;
+}
+// ============================================================================
+// Dispatcher — one call per platform. Returns undefined on ANY failure → caller falls back.
+// ============================================================================
+export function discoverModels(platform, cwd, runner = defaultRunner, timeoutMs = MODEL_DISCOVERY_TIMEOUT_MS) {
+    switch (platform) {
+        case 'opencode': return discoverOpenCodeModels(cwd, timeoutMs, runner);
+        case 'codex': return discoverCodexModels(cwd, timeoutMs, runner);
+        case 'grok': return discoverGrokModels(cwd, timeoutMs, runner);
+        case 'claude': return discoverClaudeModels(cwd, timeoutMs, runner);
+        default: return undefined;
+    }
+}
+// ============================================================================
+// Fusion helper — live-first, then curated extras not already present, deduped,
+// order preserved. Generic over the curated iterable so this module does not
+// depend on any particular curated set.
+// ============================================================================
+export function mergeLiveWithCurated(live, curated) {
+    const seen = new Set(live);
+    const out = [...live];
+    for (const item of curated) {
+        if (!seen.has(item)) {
+            seen.add(item);
+            out.push(item);
+        }
+    }
+    return out;
+}

package/dist/src/opencode-discovery.js

@@ -1,32 +1,5 @@
-import { spawnSync } from 'node:child_process';
-import { resolveExecutable } from './executable-resolution.js';
-const defaultRunner = (command, args, options) => {
-    const resolved = resolveExecutable(command, { cwd: options.cwd });
-    if (!resolved)
-        return { status: null, stdout: '' };
-    try {
-        const result = spawnSync(resolved, args, { timeout: options.timeoutMs, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
-        return { status: result.error ? null : result.status, stdout: result.stdout ?? '' };
-    }
-    catch {
-        return { status: null, stdout: '' };
-    }
-};
-const modelLinePattern = /^[A-Za-z0-9][A-Za-z0-9._-]*\/\S+$/;
-// Returns undefined (not an empty array) on any failure — binary absent, non-zero exit, or no
-// parseable lines — so callers can fall back to a free-text prompt instead of showing an empty
-// choice list.
-export function discoverOpenCodeModels(cwd, timeoutMs = 5000, runner = defaultRunner) {
-    for (const command of ['opencode', 'opencode2']) {
-        const result = runner(command, ['models'], { cwd, timeoutMs });
-        if (result.status !== 0)
-            continue;
-        const lines = result.stdout
-            .split('\n')
-            .map((line) => line.trim())
-            .filter((line) => modelLinePattern.test(line));
-        if (lines.length > 0)
-            return lines;
-    }
-    return undefined;
-}
+// Backward-compatible re-export shim. The canonical discovery module is `src/model-discovery.ts`;
+// this file exists only to preserve the stable `src/opencode-discovery.js` import path used by
+// `src/cli.ts` and the tests. The runner abstraction, shared caps, `discoverOpenCodeModels`, and the
+// platform dispatcher now live in `src/model-discovery.ts`.
+export { defaultRunner, discoverOpenCodeModels, MODEL_DISCOVERY_TIMEOUT_MS, MODEL_DISCOVERY_MAX_STDOUT_BYTES, MODEL_DISCOVERY_MAX_MODELS } from './model-discovery.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guidobuilds/forge-ai",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Forge AI framework",
   "license": "MIT",
   "type": "module",