@jini-ai/agent-runtime 0.4.0 → 0.4.2

package/dist/defs/shared.d.ts

@@ -7,10 +7,6 @@
  * `../pi-models.ts` for why these are ports, not direct lifts), and two
  * small generic parsers (`clampCodexReasoning`, `parseLineSeparatedModels`).
  *
- * Ported from OD's `apps/daemon/src/runtimes/defs/shared.ts` — the origin
- * imported `detectAcpModels` from `../../acp.js` and `parsePiModels` from
- * `../../pi-rpc.js` directly; here they come from this package's own
- * port/vendor modules instead. See `archived provenance ledger`.
  */
 import { detectAcpModels } from '../acp-model-probe.js';
 import { parsePiModels } from '../pi-models.js';
@@ -28,10 +24,9 @@ export { detectAcpModels, parsePiModels, execAgentFile, DEFAULT_MODEL_OPTION };
  * surface, which is why it declared the strategy at all. Both current declarers (`claude`,
  * `codebuddy`) call this; a third would too, instead of copying the branch.
  *
- * Why explicit rather than auto-discovery: confirmed live (2026-07-30) that auto-discovery of a
- * project `.mcp.json` requires an interactive trust prompt a headless daemon-spawned child has no
- * TTY to answer — the MCP server connection sat at `"pending"` forever and none of its tools ever
- * reached the model. The identical config passed via `--mcp-config` connected immediately.
+ * Explicit config bypasses project .mcp.json auto-discovery's interactive trust prompt: a
+ * headless daemon child has no TTY to answer it, leaving the MCP connection pending indefinitely.
+ * Passing the staged file via --mcp-config makes it available without that prompt.
  *
  * `--strict-mcp-config` is paired with it deliberately, not for symmetry: it makes the CLI load
  * ONLY this config, closing the separate "spawned CLI inherits the interactive developer's own

package/dist/defs/shared.js

@@ -7,10 +7,6 @@
  * `../pi-models.ts` for why these are ports, not direct lifts), and two
  * small generic parsers (`clampCodexReasoning`, `parseLineSeparatedModels`).
  *
- * Ported from OD's `apps/daemon/src/runtimes/defs/shared.ts` — the origin
- * imported `detectAcpModels` from `../../acp.js` and `parsePiModels` from
- * `../../pi-rpc.js` directly; here they come from this package's own
- * port/vendor modules instead. See `archived provenance ledger`.
  */
 import { detectAcpModels } from '../acp-model-probe.js';
 import { parsePiModels } from '../pi-models.js';
@@ -27,10 +23,9 @@ export { detectAcpModels, parsePiModels, execAgentFile, DEFAULT_MODEL_OPTION };
  * surface, which is why it declared the strategy at all. Both current declarers (`claude`,
  * `codebuddy`) call this; a third would too, instead of copying the branch.
  *
- * Why explicit rather than auto-discovery: confirmed live (2026-07-30) that auto-discovery of a
- * project `.mcp.json` requires an interactive trust prompt a headless daemon-spawned child has no
- * TTY to answer — the MCP server connection sat at `"pending"` forever and none of its tools ever
- * reached the model. The identical config passed via `--mcp-config` connected immediately.
+ * Explicit config bypasses project .mcp.json auto-discovery's interactive trust prompt: a
+ * headless daemon child has no TTY to answer it, leaving the MCP connection pending indefinitely.
+ * Passing the staged file via --mcp-config makes it available without that prompt.
  *
  * `--strict-mcp-config` is paired with it deliberately, not for symmetry: it makes the CLI load
  * ONLY this config, closing the separate "spawned CLI inherits the interactive developer's own

package/dist/defs/trae-cli.d.ts

@@ -21,5 +21,20 @@ export declare const traeCliAgentDef: {
     mcpDiscovery: string;
     externalMcpInjection: "acp-merge";
     imageDelivery: "native";
+    discoverModels(requiredArgs: {
+        context: import("../model-discovery-types.js").ModelDiscoveryContext;
+    }, optionalArgs?: {
+        signal?: AbortSignal;
+        force?: boolean;
+        staleWhileRevalidate?: boolean;
+        deps?: import("../model-discovery-types.js").ModelDiscoveryDeps;
+    }): Promise<import("../model-discovery-types.js").ModelCatalogSnapshot>;
+    resolveDefaultModel(requiredArgs: {
+        context: import("../model-discovery-types.js").ModelDiscoveryContext;
+        catalog: import("../model-discovery-types.js").ModelCatalogSnapshot;
+    }, optionalArgs?: {
+        signal?: AbortSignal;
+        deps?: import("../model-discovery-types.js").ModelDiscoveryDeps;
+    }): Promise<import("../model-discovery-types.js").DefaultModelResolution>;
 };
 //# sourceMappingURL=trae-cli.d.ts.map

package/dist/defs/trae-cli.js

@@ -1,6 +1,8 @@
-/** Ported verbatim from OD's `apps/daemon/src/runtimes/defs/trae-cli.ts` (import path adjusted only). See `archived provenance ledger`. */
+import { createAgentModelDiscovery } from '../model-discovery.js';
 import { detectAcpModels, DEFAULT_MODEL_OPTION } from './shared.js';
 export const traeCliAgentDef = {
+    // UNVERIFIED live integration locally; source/category and limits are documented in model-discovery-adapters.ts.
+    ...createAgentModelDiscovery('trae-cli', { fallbackModels: () => traeCliAgentDef.fallbackModels }),
     id: 'trae-cli',
     name: 'Trae CLI',
     bin: 'traecli',

package/dist/defs/vibe.d.ts

@@ -12,5 +12,20 @@ export declare const vibeAgentDef: {
     streamFormat: string;
     externalMcpInjection: "acp-merge";
     imageDelivery: "native";
+    discoverModels(requiredArgs: {
+        context: import("../model-discovery-types.js").ModelDiscoveryContext;
+    }, optionalArgs?: {
+        signal?: AbortSignal;
+        force?: boolean;
+        staleWhileRevalidate?: boolean;
+        deps?: import("../model-discovery-types.js").ModelDiscoveryDeps;
+    }): Promise<import("../model-discovery-types.js").ModelCatalogSnapshot>;
+    resolveDefaultModel(requiredArgs: {
+        context: import("../model-discovery-types.js").ModelDiscoveryContext;
+        catalog: import("../model-discovery-types.js").ModelCatalogSnapshot;
+    }, optionalArgs?: {
+        signal?: AbortSignal;
+        deps?: import("../model-discovery-types.js").ModelDiscoveryDeps;
+    }): Promise<import("../model-discovery-types.js").DefaultModelResolution>;
 };
 //# sourceMappingURL=vibe.d.ts.map

package/dist/defs/vibe.js

@@ -1,6 +1,8 @@
-/** Ported verbatim from OD's `apps/daemon/src/runtimes/defs/vibe.ts` (import path adjusted only). See `archived provenance ledger`. */
+import { createAgentModelDiscovery } from '../model-discovery.js';
 import { detectAcpModels, DEFAULT_MODEL_OPTION } from './shared.js';
 export const vibeAgentDef = {
+    // UNVERIFIED live integration locally; source/category and limits are documented in model-discovery-adapters.ts.
+    ...createAgentModelDiscovery('vibe', { fallbackModels: () => vibeAgentDef.fallbackModels }),
     id: 'vibe',
     name: 'Mistral Vibe CLI',
     bin: 'vibe-acp',

package/dist/detection.d.ts

@@ -1,8 +1,11 @@
+import type { ModelDiscoveryContext, ModelDiscoveryDeps, ModelCatalogSnapshot, DefaultModelResolution } from './model-discovery-types.js';
 import { type AmrProfileResolver } from './amr-profile-resolver.js';
 import type { AgentDiagnostic, DetectedAgent, RuntimeAgentDef, RuntimeModelSource, RuntimeModelOption } from './types.js';
 type FetchedRuntimeModels = {
     models: RuntimeModelOption[];
     source: RuntimeModelSource;
+    catalog?: ModelCatalogSnapshot;
+    defaultModelResolution?: DefaultModelResolution;
 };
 /**
  * Makes sure `agentCapabilities` holds this def's `--help`-probed flags before its `buildArgs` runs.
@@ -44,16 +47,29 @@ export type ProbedAgentModels = FetchedRuntimeModels;
  */
 export declare function probeAgentModels({ def }: {
     def: RuntimeAgentDef;
-}, { configuredEnv, amrProfileResolver }?: {
+}, { configuredEnv, amrProfileResolver, context, deps, force }?: {
     configuredEnv?: Record<string, string>;
     amrProfileResolver?: AmrProfileResolver;
+    context?: ModelDiscoveryContext;
+    deps?: ModelDiscoveryDeps;
+    force?: boolean;
 }): Promise<ProbedAgentModels>;
-export declare function detectAgents({}: {}, { configuredEnvByAgent, amrProfileResolver }?: {
+export interface AgentDetectionModelOptions {
+    context?: ModelDiscoveryContext;
+    deps?: ModelDiscoveryDeps;
+    force?: boolean;
+}
+export declare function detectAgents({}: {}, { configuredEnvByAgent, amrProfileResolver, modelContextByAgent, modelDiscoveryDeps, force }?: {
     configuredEnvByAgent?: Record<string, Record<string, string>>;
     amrProfileResolver?: AmrProfileResolver;
-}): Promise<(Omit<RuntimeAgentDef, "buildArgs" | "listModels" | "fetchModels" | "deriveReasoningOptions" | "fallbackModels" | "fallbackModelsAssertedAt" | "helpArgs" | "capabilityFlags" | "fallbackBins" | "versionProbeTimeoutMs" | "maxPromptArgBytes" | "env" | "inactivityTimeoutMs" | "authProbe" | "needsAgentLogFile" | "stdoutPolicy" | "runtimeLock"> & {
+    modelContextByAgent?: Record<string, ModelDiscoveryContext>;
+    modelDiscoveryDeps?: ModelDiscoveryDeps;
+    force?: boolean;
+}): Promise<(Omit<RuntimeAgentDef, "discoverModels" | "resolveDefaultModel" | "buildArgs" | "listModels" | "fetchModels" | "deriveReasoningOptions" | "fallbackModels" | "fallbackModelsAssertedAt" | "helpArgs" | "capabilityFlags" | "fallbackBins" | "versionProbeTimeoutMs" | "maxPromptArgBytes" | "env" | "inactivityTimeoutMs" | "authProbe" | "needsAgentLogFile" | "stdoutPolicy" | "runtimeLock"> & {
     models: RuntimeModelOption[];
     modelsSource: RuntimeModelSource;
+    modelCatalog?: ModelCatalogSnapshot;
+    defaultModelResolution?: DefaultModelResolution;
     available: boolean;
     authStatus?: "ok" | "missing" | "unknown";
     authMessage?: string;
@@ -61,9 +77,12 @@ export declare function detectAgents({}: {}, { configuredEnvByAgent, amrProfileR
     version?: string | null;
     diagnostics?: AgentDiagnostic[];
 })[]>;
-export declare function detectAgentsStream({}: {}, { configuredEnvByAgent, amrProfileResolver }?: {
+export declare function detectAgentsStream({}: {}, { configuredEnvByAgent, amrProfileResolver, modelContextByAgent, modelDiscoveryDeps, force }?: {
     configuredEnvByAgent?: Record<string, Record<string, string>>;
     amrProfileResolver?: AmrProfileResolver;
+    modelContextByAgent?: Record<string, ModelDiscoveryContext>;
+    modelDiscoveryDeps?: ModelDiscoveryDeps;
+    force?: boolean;
 }): AsyncGenerator<DetectedAgent>;
 export {};
 //# sourceMappingURL=detection.d.ts.map

package/dist/detection.js

@@ -12,7 +12,8 @@
  * `archived provenance ledger`.
  */
 import { execAgentFile } from './invocation.js';
-import { getRememberedLiveModels, rememberLiveModels } from './models.js';
+import { offlineSnapshot, modelDiscoveryForDef } from './model-discovery.js';
+import { rememberLiveModels } from './models.js';
 import { agentCapabilities } from './capabilities.js';
 import { installMetaForAgent } from './metadata.js';
 import { AGENT_DEFS } from './registry.js';
@@ -25,50 +26,23 @@ function amrModelScopeFromEnv(env, amrProfileResolver) {
     return amrProfileResolver.resolveProfile({ env: env });
 }
 function withRememberedAmrModels(def, env, modelResult, amrProfileResolver) {
-    if (def.id !== 'amr' || modelResult.models.length > 0)
-        return modelResult;
-    const rememberedModels = getRememberedLiveModels({ agentId: def.id }, { scope: amrModelScopeFromEnv(env, amrProfileResolver) });
-    if (rememberedModels.length === 0)
-        return modelResult;
-    return { models: rememberedModels, source: 'live' };
+    // The old remembered AMR list had no age/launch fingerprint. Scoped snapshots now own
+    // last-good recovery; never present unscoped remembered rows as live.
+    void def;
+    void env;
+    void amrProfileResolver;
+    return modelResult;
 }
-async function fetchModels(def, resolvedBin, env) {
-    if (typeof def.fetchModels === 'function') {
-        try {
-            const parsed = await def.fetchModels({ resolvedBin: resolvedBin, env: env });
-            if (!parsed || parsed.length === 0) {
-                return { models: def.fallbackModels, source: 'fallback' };
-            }
-            return { models: parsed, source: 'live' };
-        }
-        catch {
-            return { models: def.fallbackModels, source: 'fallback' };
-        }
-    }
-    if (!def.listModels) {
-        return { models: def.fallbackModels, source: 'fallback' };
-    }
-    try {
-        const { stdout } = await execAgentFile({ command: resolvedBin, args: def.listModels.args }, { options: {
-                env,
-                timeout: def.listModels.timeoutMs,
-                // Models lists from popular CLIs (e.g. opencode) easily exceed the
-                // default 1MB buffer once you include every openrouter model. Bump
-                // it so we don't truncate the listing.
-                maxBuffer: 8 * 1024 * 1024,
-            } });
-        const parsed = def.listModels.parse({ stdout: String(stdout) });
-        // Empty / null parse result means the CLI didn't actually return a
-        // usable list (e.g. cursor-agent's "No models available"); fall back
-        // to the static hint so the picker isn't stuck on Default-only.
-        if (!parsed || parsed.length === 0) {
-            return { models: def.fallbackModels, source: 'fallback' };
-        }
-        return { models: parsed, source: 'live' };
-    }
-    catch {
-        return { models: def.fallbackModels, source: 'fallback' };
-    }
+async function fetchModels(def, resolvedBin, env, optional = {}) {
+    const context = optional.context ?? { executable: resolvedBin, env, cwd: optional.cwd ?? process.cwd(), ...(optional.version !== undefined ? { version: optional.version } : {}) };
+    const options = { ...(optional.deps ? { deps: optional.deps } : {}), ...(optional.force ? { force: true } : {}) };
+    const discovery = modelDiscoveryForDef(def);
+    const catalog = await discovery.discoverModels({ context }, options);
+    const defaultModelResolution = await discovery.resolveDefaultModel({ context, catalog }, options);
+    // Models lists can exceed 1MB (e.g. opencode's OpenRouter catalog); the shared process port
+    // retains the existing 8MB bound. Empty/unusable metadata falls back with explicit provenance,
+    // so a failed CLI never silently empties the picker or labels packaged hints as live.
+    return { models: catalog.models, source: catalog.freshness === 'fresh' ? 'live' : 'fallback', catalog, defaultModelResolution };
 }
 /**
  * Run the agent's `--version` probe and classify the result. The probe
@@ -124,7 +98,9 @@ function unavailableAgent(def, diagnostics = []) {
         ...stripFns(def),
         // `fallbackModels` is a required field on `RuntimeAgentDef`, never
         // `undefined` for a well-typed def.
-        models: def.fallbackModels,
+        models: offlineSnapshot('', Date.now(), def.fallbackModels).models,
+        modelCatalog: offlineSnapshot('', Date.now(), def.fallbackModels),
+        defaultModelResolution: { status: 'unresolved', reason: 'Agent executable is unavailable.' },
         modelsSource: 'fallback',
         available: false,
         ...(diagnostics.length > 0 ? { diagnostics } : {}),
@@ -213,6 +189,10 @@ function derivedReasoningOverride(def, models) {
 function probeEnvForLaunch(def, configuredEnv, launch) {
     return applyAgentLaunchEnv({ env: spawnEnvForAgent({ agentId: def.id, baseEnv: { ...process.env, ...(def.env || {}) } }, { configuredEnv: configuredEnv, hooks: {} }), launch: launch });
 }
+function unavailableModels(def) {
+    const catalog = offlineSnapshot('', Date.now(), def.fallbackModels);
+    return { models: catalog.models, source: 'fallback', catalog, defaultModelResolution: { status: 'unresolved', reason: 'Agent executable is unavailable.' } };
+}
 /**
  * The model half of {@link detectAgents} for ONE def, without the `--version`/`--help`/auth probes:
  * resolves the launch path, builds the same probe env, runs the def's `fetchModels`/`listModels`,
@@ -225,22 +205,22 @@ function probeEnvForLaunch(def, configuredEnv, launch) {
  * `source: 'fallback'` (including when the binary is not found). Never rejects.
  * @complexity At most one model-listing spawn, bounded by the def's own timeout.
  */
-export async function probeAgentModels({ def }, { configuredEnv = {}, amrProfileResolver = noopAmrProfileResolver } = {}) {
+export async function probeAgentModels({ def }, { configuredEnv = {}, amrProfileResolver = noopAmrProfileResolver, context, deps, force = false } = {}) {
     try {
         const launch = resolveAgentLaunch({ def: def }, { configuredEnv: configuredEnv });
         if (!launch.launchPath)
-            return { models: def.fallbackModels, source: 'fallback' };
+            return unavailableModels(def);
         const probeEnv = probeEnvForLaunch(def, configuredEnv, launch);
-        const fetched = await fetchModels(def, launch.launchPath, probeEnv);
+        const fetched = await fetchModels(def, launch.launchPath, probeEnv, { ...(context ? { context } : {}), ...(deps ? { deps } : {}), force });
         const result = withRememberedAmrModels(def, probeEnv, fetched, amrProfileResolver);
         rememberDetectedModelList(def, configuredEnv, result.models, amrProfileResolver);
         return result;
     }
     catch {
-        return { models: def.fallbackModels, source: 'fallback' };
+        return unavailableModels(def);
     }
 }
-async function probe(def, configuredEnv = {}, amrProfileResolver) {
+async function probe(def, configuredEnv = {}, amrProfileResolver, options = {}) {
     // Detection must probe the exact path the runtime will spawn, not just
     // the PATH-visible shim. This is load-bearing under nvm/fnm/mise: the
     // discovered entry is often a `#!/usr/bin/env node` wrapper that is not
@@ -265,7 +245,7 @@ async function probe(def, configuredEnv = {}, amrProfileResolver) {
     // cached on `agentCapabilities` for buildArgs to consult.
     const [caps, modelResult, auth] = await Promise.all([
         probeCapabilities(def, launch.launchPath, probeEnv),
-        fetchModels(def, launch.launchPath, probeEnv),
+        fetchModels(def, launch.launchPath, probeEnv, { version: outcome.version, ...options }),
         probeAgentAuthStatus({ def: def, resolvedBin: launch.launchPath, env: probeEnv }),
     ]);
     const surfacedModelResult = withRememberedAmrModels(def, probeEnv, modelResult, amrProfileResolver);
@@ -278,6 +258,8 @@ async function probe(def, configuredEnv = {}, amrProfileResolver) {
         ...derivedReasoningOverride(def, surfacedModelResult.models),
         models: surfacedModelResult.models,
         modelsSource: surfacedModelResult.source,
+        ...(surfacedModelResult.catalog ? { modelCatalog: surfacedModelResult.catalog } : {}),
+        ...(surfacedModelResult.defaultModelResolution ? { defaultModelResolution: surfacedModelResult.defaultModelResolution } : {}),
         available: true,
         path: launch.selectedPath,
         version: outcome.version,
@@ -305,12 +287,12 @@ function stripFns(def) {
     // matter extra because they carry closures — `JSON.stringify` would drop
     // the functions but keep their enclosing objects, publishing a misleading
     // `{"buffering":"until-close"}` / `{}` instead of omitting them.
-    const { buildArgs: _buildArgs, listModels: _listModels, fetchModels: _fetchModels, deriveReasoningOptions: _deriveReasoningOptions, fallbackModels: _fallbackModels, fallbackModelsAssertedAt: _fallbackModelsAssertedAt, helpArgs: _helpArgs, capabilityFlags: _capabilityFlags, fallbackBins: _fallbackBins, versionProbeTimeoutMs: _versionProbeTimeoutMs, maxPromptArgBytes: _maxPromptArgBytes, env: _env, inactivityTimeoutMs: _inactivityTimeoutMs, authProbe: _authProbe, needsAgentLogFile: _needsAgentLogFile, stdoutPolicy: _stdoutPolicy, runtimeLock: _runtimeLock, ...rest } = def;
+    const { discoverModels: _discoverModels, resolveDefaultModel: _resolveDefaultModel, buildArgs: _buildArgs, listModels: _listModels, fetchModels: _fetchModels, deriveReasoningOptions: _deriveReasoningOptions, fallbackModels: _fallbackModels, fallbackModelsAssertedAt: _fallbackModelsAssertedAt, helpArgs: _helpArgs, capabilityFlags: _capabilityFlags, fallbackBins: _fallbackBins, versionProbeTimeoutMs: _versionProbeTimeoutMs, maxPromptArgBytes: _maxPromptArgBytes, env: _env, inactivityTimeoutMs: _inactivityTimeoutMs, authProbe: _authProbe, needsAgentLogFile: _needsAgentLogFile, stdoutPolicy: _stdoutPolicy, runtimeLock: _runtimeLock, ...rest } = def;
     return rest;
 }
-async function safeProbe(def, configuredEnv = {}, amrProfileResolver) {
+async function safeProbe(def, configuredEnv = {}, amrProfileResolver, options = {}) {
     try {
-        return await probe(def, configuredEnv, amrProfileResolver);
+        return await probe(def, configuredEnv, amrProfileResolver, options);
     }
     catch {
         // Fault isolation: one adapter's probe blowing up — e.g. a
@@ -329,10 +311,10 @@ function rememberDetectedModelList(def, configuredEnv, models, amrProfileResolve
     const scope = def.id === 'amr'
         ? amrModelScopeFromEnv({ ...process.env, ...(def.env || {}), ...configuredEnv }, amrProfileResolver)
         : null;
-    rememberLiveModels({ agentId: def.id, models: models }, { scope: scope });
+    rememberLiveModels({ agentId: def.id, models: models.filter((row) => row.identityKind !== 'routing-mode') }, { scope: scope });
 }
-export async function detectAgents({}, { configuredEnvByAgent = {}, amrProfileResolver = noopAmrProfileResolver } = {}) {
-    const results = await Promise.all(AGENT_DEFS.map((def) => safeProbe(def, configuredEnvByAgent?.[def.id] ?? {}, amrProfileResolver)));
+export async function detectAgents({}, { configuredEnvByAgent = {}, amrProfileResolver = noopAmrProfileResolver, modelContextByAgent = {}, modelDiscoveryDeps, force = false } = {}) {
+    const results = await Promise.all(AGENT_DEFS.map((def) => safeProbe(def, configuredEnvByAgent?.[def.id] ?? {}, amrProfileResolver, { ...(modelContextByAgent[def.id] ? { context: modelContextByAgent[def.id] } : {}), ...(modelDiscoveryDeps ? { deps: modelDiscoveryDeps } : {}), force })));
     // Refresh the validation cache from whatever we just surfaced to the UI
     // so a chat endpoint can accept any model the user could have just
     // picked, including ones that only showed up after a CLI re-auth.
@@ -351,8 +333,8 @@ export async function detectAgents({}, { configuredEnvByAgent = {}, amrProfileRe
 // validation cache is refreshed per-agent (same effect as the batch path,
 // just incrementally). `detectAgents` keeps the array contract for callers
 // that don't care about incremental delivery.
-export async function* detectAgentsStream({}, { configuredEnvByAgent = {}, amrProfileResolver = noopAmrProfileResolver } = {}) {
-    const tagged = AGENT_DEFS.map((def, index) => safeProbe(def, configuredEnvByAgent?.[def.id] ?? {}, amrProfileResolver).then((agent) => {
+export async function* detectAgentsStream({}, { configuredEnvByAgent = {}, amrProfileResolver = noopAmrProfileResolver, modelContextByAgent = {}, modelDiscoveryDeps, force = false } = {}) {
+    const tagged = AGENT_DEFS.map((def, index) => safeProbe(def, configuredEnvByAgent?.[def.id] ?? {}, amrProfileResolver, { ...(modelContextByAgent[def.id] ? { context: modelContextByAgent[def.id] } : {}), ...(modelDiscoveryDeps ? { deps: modelDiscoveryDeps } : {}), force }).then((agent) => {
         rememberDetectedLiveModels(def, configuredEnvByAgent?.[def.id] ?? {}, agent, amrProfileResolver);
         return { index, agent };
     }));

package/dist/diagnostics.js

@@ -1,14 +1,6 @@
 /**
  * @module diagnostics
- *
- * Builds the `AgentDiagnostic` explaining why a CLI isn't invocable, for
- * the three failure classes detection distinguishes: not resolvable at
- * all, resolved but not invocable, and invocable but not authenticated.
- *
- * Ported verbatim from OD's
- * `apps/daemon/src/runtimes/detection/diagnostics.ts`, with `AgentDiagnostic`
- * / `AgentFixIntent` now imported from this package's own `types.ts`
- * (vendored from OD's contracts workspace package, not a dependency on it).
+ * Explain three detection failures: unresolved executable, uninvocable executable or missing authentication.
  */
 import { agentBinEnvKey, agentSearchDirs } from './executables.js';
 // Cap on how many searched dirs we attach to a `not-on-path` diagnostic.

package/dist/env.js

@@ -1,36 +1,10 @@
 /**
  * @module env
- *
- * Builds the environment passed to `spawn()` for a given agent adapter:
- * proxy-aware merge of the inherited launch env with per-agent configured
- * overrides, plus a couple of per-CLI housekeeping tweaks (OpenCode/MiMo
- * project-config-discovery, which would otherwise walk up from cwd and run
- * an install step that can corrupt a pnpm workspace it's spawned inside).
- *
- * Heavily de-branded from OD's `apps/daemon/src/runtimes/env.ts`. The
- * origin file was far more coupled than r1b's "supporting generic file"
- * classification anticipated — it read OD's own app-config subsystem, OD's
- * sandbox-mode subsystem, and vela/AMR-specific env forwarding including a
- * literal product-name identity value and two product-prefixed env var
- * names (see `archived provenance ledger` for the exact originals). None of that is
- * ported:
- *
- * - `mergeProxyAwareEnv` / `resolveSystemProxyEnv` now come from
- *   `@jini-ai/platform` (the same functions, already verbatim-lifted there).
- * - AMR/vela-specific env injection and OD's app-config-driven analytics
- *   identity env are replaced by an optional `perAgentEnv` hook — a plain
- *   `(agentId, env) => NodeJS.ProcessEnv | void` the host can supply to add
- *   its own per-agent env logic (vela profile forwarding, analytics ids,
- *   …) without this package needing to know about vela or app-config.
- * - Sandbox-mode env application is replaced by an optional
- *   `sandboxOverlay` hook with the same shape, for the same reason.
- * - OD's AMR trace-env helper (emitting a product-prefixed run-id/attempt/
- *   session-id triad) is dropped entirely — it is OD/vela-adapter-owned
- *   trace-correlation env, not a generic runtime concern, and its own name
- *   was itself product-branded. A host that needs equivalent trace
- *   correlation can build it as a `perAgentEnv` hook.
- *
- * See `archived provenance ledger` for the full accounting.
+ * Build proxy-aware spawn environment from inherited and per-agent configured values. Disable
+ * OpenCode/MiMo project-config discovery so an automatic install cannot corrupt the host workspace.
+ * The shared platform helpers own proxy merging. Host-specific profile forwarding, analytics
+ * identity and trace correlation enter through perAgentEnv; sandbox wiring enters through
+ * sandboxOverlay. The engine must not import a product's config/sandbox subsystems or env names.
  */
 import os from 'node:os';
 import { mergeProxyAwareEnv, resolveSystemProxyEnv } from '@jini-ai/platform';

package/dist/executables.js

@@ -39,7 +39,6 @@ const AGENT_BIN_ENV_KEYS = new Map([
     ['deepseek', 'DEEPSEEK_BIN'],
     ['devin', 'DEVIN_BIN'],
     ['droid', 'DROID_BIN'],
-    ['gemini', 'GEMINI_BIN'],
     ['goose', 'GOOSE_BIN'],
     ['hermes', 'HERMES_BIN'],
     ['kimi', 'KIMI_BIN'],