@jini-ai/agent-runtime 0.4.0 → 0.4.2

package/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 0.4.2 — 2026-10-08
+
+- Tovu clean-up release: code Tovu moved into Jini, plus the Jini clean-up (see the commit log).
+
+## 0.4.1 — 2026-10-06
+
+- Tool turns accept message `images` (`{ mimeType, data }`) and deliver them to providers as image content.
+- Runtime `@jini-ai/*` deps are `workspace:^` (pack as caret ranges).
+
 # @jini-ai/agent-runtime
 
 ## 0.4.0 — 2026-10-02

package/dist/acp-model-probe.d.ts

@@ -1,30 +1,9 @@
 /**
  * @module acp-model-probe
- *
- * Port replacing OD's `detectAcpModels` import
- * (`apps/daemon/src/acp.js`) inside `defs/shared.ts`. Eight of this
- * package's def literals (devin, hermes, kilo, kimi, kiro, reasonix,
- * trae-cli, vibe) fetch their live model list by speaking a session/new →
- * session/list_models-shaped ACP JSON-RPC handshake to the spawned CLI.
- *
- * That handshake lives in OD's `acp.ts` (1744 lines) — the full ACP
- * subprocess transport, which r1's recon classifies as its own separate
- * GENERIC-ENGINE zone (`agent-protocol/`, 17 files) and a *later*
- * extraction task, not this one. Porting it here would blow this task's
- * scope far past "harvest wholesale" for what is genuinely a large,
- * separate subsystem.
- *
- * So `detectAcpModels` becomes an injectable port: an `AcpModelProbe` with
- * a single `detectModels(requiredArgs, optionalArgs)` method, matching the real call shape
- * every ACP-based def literal already uses. The default implementation is
- * a no-op that resolves to `[]`, which makes `detection.ts`'s `fetchModels`
- * step treat the live-fetch as "returned nothing" and fall back to the
- * def's static `fallbackModels` — the same behavior OD gets when the vela
- * probe times out or errors. A future task that ports the ACP transport
- * (or the OD adapter, sooner) calls `setAcpModelProbe()` once at startup to
- * wire in the real implementation; every def literal that calls
- * `detectAcpModels(...)` picks it up automatically, no per-def changes
- * needed.
+ * Replaceable live-model probe for ACP-based runtime defs. The default uses the native,
+ * prompt-free initialize/session-new handshake; setAcpModelProbe installs a host implementation
+ * and null restores native transport. noopAcpModelProbe is an explicit opt-out that returns no
+ * live models, allowing detection to fall back to the def's static catalog.
  */
 import type { RuntimeEnv, RuntimeModelOption } from './types.js';
 export interface AcpModelProbeRequest {
@@ -41,10 +20,10 @@ export interface AcpModelProbe {
     detectModels(requiredArgs: Pick<AcpModelProbeRequest, 'bin' | 'args'>, optionalArgs?: Omit<AcpModelProbeRequest, 'bin' | 'args'>): Promise<RuntimeModelOption[]>;
 }
 export declare const noopAcpModelProbe: AcpModelProbe;
-/** Install the real ACP transport (or a test double). Pass `null` to restore the no-op default. */
+/** Install a transport/test double. Pass `null` to restore the native transport. */
 export declare function setAcpModelProbe({ probe }: {
     probe: AcpModelProbe | null;
 }): void;
-/** Drop-in replacement for OD's `detectAcpModels` — delegates to whatever probe is currently installed. */
+/** Delegate to the currently installed probe. */
 export declare function detectAcpModels(requiredArgs: Pick<AcpModelProbeRequest, "bin" | "args">, optionalArgs?: Omit<AcpModelProbeRequest, "bin" | "args">): Promise<RuntimeModelOption[]>;
 //# sourceMappingURL=acp-model-probe.d.ts.map

package/dist/acp-model-probe.js

@@ -1,14 +1,16 @@
+import { detectAcpModels as probeNativeModels } from './agent-protocol/acp/models.js';
 export const noopAcpModelProbe = {
     async detectModels() {
         return [];
     },
 };
-let activeAcpModelProbe = noopAcpModelProbe;
-/** Install the real ACP transport (or a test double). Pass `null` to restore the no-op default. */
+const nativeAcpModelProbe = { detectModels: (required, optional = {}) => probeNativeModels(required, { ...optional, ...(optional.env ? { env: optional.env } : {}) }) };
+let activeAcpModelProbe = nativeAcpModelProbe;
+/** Install a transport/test double. Pass `null` to restore the native transport. */
 export function setAcpModelProbe({ probe }) {
-    activeAcpModelProbe = probe ?? noopAcpModelProbe;
+    activeAcpModelProbe = probe ?? nativeAcpModelProbe;
 }
-/** Drop-in replacement for OD's `detectAcpModels` — delegates to whatever probe is currently installed. */
+/** Delegate to the currently installed probe. */
 export async function detectAcpModels(requiredArgs, optionalArgs = {}) {
     return activeAcpModelProbe.detectModels(requiredArgs, optionalArgs);
 }

package/dist/agent-protocol/acp/models.d.ts

@@ -20,6 +20,8 @@ export interface DetectAcpModelsOptions {
     clientName?: string;
     clientVersion?: string;
     defaultModelOption?: ModelOption;
+    signal?: AbortSignal;
+    onSessionResult?: (result: UnknownRecord) => void;
 }
 /**
  * Normalises a raw config-option field value to a lowercase, whitespace- and
@@ -114,4 +116,10 @@ export declare function currentModelFromSessionResult(result: UnknownRecord): st
  * @returns A promise resolving to the available `ModelOption[]`.
  */
 export declare function detectAcpModels(requiredArgs: Pick<DetectAcpModelsOptions, "bin" | "args">, optionalArgs?: Omit<DetectAcpModelsOptions, "bin" | "args">): Promise<ModelOption[]>;
+/** Retains native current selection. Session creation can write CLI state/start services;
+ * this metadata probe never sends session/prompt. The old array API remains compatible. */
+export declare function detectAcpModelMetadata(requiredArgs: Pick<DetectAcpModelsOptions, 'bin' | 'args'>, optionalArgs?: Omit<DetectAcpModelsOptions, 'bin' | 'args'>): Promise<{
+    models: ModelOption[];
+    currentModelId: string | null;
+}>;
 //# sourceMappingURL=models.d.ts.map

package/dist/agent-protocol/acp/models.js

@@ -191,7 +191,7 @@ export function currentModelFromSessionResult(result) {
  * @returns A promise resolving to the available `ModelOption[]`.
  */
 export async function detectAcpModels(requiredArgs, optionalArgs = {}) {
-    const { bin, args, cwd = process.cwd(), env = process.env, timeoutMs = DEFAULT_TIMEOUT_MS, clientName = 'agent-runtime-detect', clientVersion = 'runtime-adapter', defaultModelOption = { id: 'default', label: 'Default (CLI config)' }, } = { ...optionalArgs, ...requiredArgs };
+    const { bin, args, cwd = process.cwd(), env = process.env, timeoutMs = DEFAULT_TIMEOUT_MS, clientName = 'agent-runtime-detect', clientVersion = 'runtime-adapter', defaultModelOption = { id: 'default', label: 'Default (CLI config)' }, signal, onSessionResult, } = { ...optionalArgs, ...requiredArgs };
     const effectiveTimeoutMs = resolveAcpTimeoutMs(env, timeoutMs);
     return await new Promise((resolve, reject) => {
         const child = spawn(bin, args, {
@@ -203,6 +203,7 @@ export async function detectAcpModels(requiredArgs, optionalArgs = {}) {
         child.stderr.setEncoding('utf8');
         let settled = false;
         let stderrBuf = '';
+        let stdoutBytes = 0;
         let expectedId = 1;
         let nextId = 2;
         let timer = null;
@@ -212,17 +213,27 @@ export async function detectAcpModels(requiredArgs, optionalArgs = {}) {
             settled = true;
             if (timer)
                 clearTimeout(timer);
+            signal?.removeEventListener('abort', abort);
             try {
                 child.stdin.end();
             }
             catch { }
+            if (!child.killed)
+                child.kill('SIGTERM');
+            const killTimer = setTimeout(() => { if (child.exitCode === null)
+                child.kill('SIGKILL'); }, 250);
+            killTimer.unref();
             fn(value);
         };
         const fail = (message) => {
             finish(reject, new Error(message));
-            if (!child.killed)
-                child.kill('SIGTERM');
         };
+        const abort = () => fail('ACP model detection aborted');
+        signal?.addEventListener('abort', abort, { once: true });
+        if (signal?.aborted) {
+            abort();
+            return;
+        }
         const writeRpc = (id, method, params) => {
             try {
                 sendRpc(child.stdin, id, method, params);
@@ -258,13 +269,19 @@ export async function detectAcpModels(requiredArgs, optionalArgs = {}) {
                     return;
                 }
                 if (expectedId === 2) {
+                    onSessionResult?.(result);
                     const models = normalizeModels({ models: result.models, defaultModelOption: defaultModelOption }, { configOptions: result.configOptions });
                     finish(resolve, models);
-                    if (!child.killed)
-                        child.kill('SIGTERM');
                 }
             } });
-        child.stdout.on('data', (chunk) => parser.feed({ chunk: chunk }));
+        child.stdout.on('data', (chunk) => {
+            stdoutBytes += Buffer.byteLength(String(chunk), 'utf8');
+            if (stdoutBytes > 8 * 1024 * 1024) {
+                fail('ACP metadata output exceeded its limit');
+                return;
+            }
+            parser.feed({ chunk: chunk });
+        });
         child.stdout.on('close', () => parser.flush());
         child.stdin.on('error', (err) => fail(`stdin error: ${err.message}`));
         child.stderr.on('data', (chunk) => {
@@ -291,4 +308,19 @@ export async function detectAcpModels(requiredArgs, optionalArgs = {}) {
         });
     });
 }
+/** Retains native current selection. Session creation can write CLI state/start services;
+ * this metadata probe never sends session/prompt. The old array API remains compatible. */
+export async function detectAcpModelMetadata(requiredArgs, optionalArgs = {}) {
+    let currentModelId = null;
+    const models = await detectAcpModels(requiredArgs, { ...optionalArgs, onSessionResult: (result) => {
+            currentModelId = currentModelFromSessionResult(result);
+            optionalArgs.onSessionResult?.(result);
+        } });
+    return { models: models.filter((model) => model.id !== 'default').map((model) => {
+            const label = model.label.replace(/ • current$/, '');
+            const suffix = ` (${model.id})`;
+            // Remove only our ID annotation; native display-name capability suffixes are meaningful.
+            return { ...model, label: label.endsWith(suffix) ? label.slice(0, -suffix.length) : label };
+        }), currentModelId };
+}
 //# sourceMappingURL=models.js.map

package/dist/agent-protocol/acp/session.js

@@ -72,7 +72,8 @@ function resolveModelConfigId(modelConfig) {
 export function handleRpcError({ state, effects, obj, error, rpcErr, }) {
     if (obj.id === state.setModelRequestId &&
         modelSelectionErrorIsRecoverable(error?.code) &&
-        state.promptRequestId === null) {
+        state.promptRequestId === null &&
+        (!effects.model || effects.model === 'default')) {
         effects.recoverFromModelSelectionError();
         return;
     }
@@ -299,6 +300,13 @@ export function handleToolCallUpdate({ state, effects, update, }) {
 }
 /** Top-level `session/update` dispatcher: emits a generic status for non-streaming update kinds, then routes to the matching per-kind handler. */
 export function handleSessionUpdate({ state, effects, update, }) {
+    // Model/config updates are authoritative protocol metadata, not assistant self-report.
+    const changedModel = currentModelFromSessionResult(update)
+        ?? (update.sessionUpdate === 'current_model_update' && typeof update.currentModelId === 'string' ? update.currentModelId : null);
+    if (changedModel && changedModel !== state.activeModel) {
+        state.activeModel = changedModel;
+        effects.send({ event: 'agent', payload: { type: 'status', label: 'model', model: changedModel } });
+    }
     if (effects.modelUnavailableErrorCode && tryPromoteAmrRetryStatus({ effects, update }))
         return;
     if (update.sessionUpdate !== 'agent_message_chunk' && update.sessionUpdate !== 'agent_thought_chunk') {
@@ -337,6 +345,11 @@ export function handleInitializeAck({ state, effects }) {
 export function triggerSetModelIfNeeded({ state, effects, }) {
     if (!state.sessionId || !effects.model || effects.model === 'default')
         return false;
+    // Hosts now pin the concrete starting model on every run. When session/new already reports that
+    // model, a set_model round-trip is redundant, and a CLI without set_model support would turn it
+    // into a fatal explicit-model rejection.
+    if (state.activeModel === effects.model)
+        return false;
     state.setModelRequestId = state.nextId;
     state.expectedId = state.nextId;
     const setModelMethod = state.modelConfigId ? 'session/set_config_option' : 'session/set_model';
@@ -357,7 +370,7 @@ export function handleSessionNewAck({ state, effects, result, rawLine, }) {
         notifySessionInit(effects);
     state.modelConfigId = resolveModelConfigId(findModelConfigOption(result.configOptions));
     state.activeModel = currentModelFromSessionResult(result);
-    if (state.sessionId && state.activeModel) {
+    if (state.sessionId && state.activeModel && (!effects.model || effects.model === state.activeModel)) {
         effects.send({ event: 'agent', payload: { type: 'status', label: 'model', model: state.activeModel } });
     }
     if (triggerSetModelIfNeeded({ state, effects }))

package/dist/agent-protocol/pi-rpc/events.js

@@ -197,6 +197,10 @@ const PI_RPC_EVENT_HANDLERS = {
  * @returns `'agent_end'` on run completion, `null` otherwise.
  */
 export function mapPiRpcEvent({ raw, send, ctx }) {
+    const message = getRecord(raw.message);
+    if (message?.role === 'assistant' && typeof message.model === 'string' && typeof message.provider === 'string') {
+        send({ event: 'agent', payload: { type: 'status', label: 'model', model: `${message.provider}/${message.model}` } });
+    }
     const handler = typeof raw.type === 'string' ? PI_RPC_EVENT_HANDLERS[raw.type] : undefined;
     return handler ? handler(raw, send, ctx) : null;
 }

package/dist/amr-model-cache.d.ts

@@ -1,17 +1,7 @@
 /**
  * @module amr-model-cache
- *
- * A live-model-catalog cache that returns a cached remote list instantly
- * while refreshing in the background, falling back to a static preset
- * list on cold start. Ported verbatim from OD's
- * `apps/daemon/src/runtimes/amr/amr-model-cache.ts` with one change: the
- * `AmrModelsResponse` return type is now vendored locally (a small,
- * self-contained shape) instead of imported from OD's contracts workspace
- * package.
- *
- * Named for its origin use (the AMR/vela agent's live model list), but the
- * caching pattern itself is generic to any agent with a similarly-shaped
- * "cheap static preset + slower authoritative remote list" catalog.
+ * Return cached remote models while refreshing, with static presets on cold start. This caching
+ * pattern also serves other agents with cheap presets and slower authoritative remote catalogs.
  */
 import type { RuntimeModelOption } from './types.js';
 export type AmrModelsResponse = {

package/dist/amr-profile-resolver.d.ts

@@ -1,17 +1,6 @@
-/**
- * @module amr-profile-resolver
- *
- * Port replacing OD's `resolveAmrProfile` import
- * (`apps/daemon/src/integrations/vela.js`) inside `detection.ts`. OD uses
- * this to scope the remembered-live-models cache for the `amr` agent id by
- * "profile" — an AMR/vela-vendor concept (which OpenRouter-compatible
- * account/link config is active) that has no generic runtime meaning.
- *
- * `detection.ts` accepts an `AmrProfileResolver` and calls it only for the
- * `amr` def id; every other agent's scoping is unaffected. The default
- * no-op resolver returns a constant scope (equivalent to "no profile
- * scoping"), so a non-OD consumer's AMR-model cache degrades gracefully —
- * it just doesn't split by profile — until it supplies a real resolver.
+/** @module amr-profile-resolver
+ * Profile scoping is an AMR/vela account/link concept, not a generic runtime rule. detection.ts
+ * consults this host port only for amr; the default constant scope leaves its cache unsplit.
  */
 export interface AmrProfileResolver {
     /** Return a scope key for the `amr` agent's remembered-live-models cache, derived from the spawn env. */

package/dist/anthropic-live-models.d.ts

@@ -41,5 +41,5 @@ export declare function mergeLiveModels(fallback: readonly RuntimeModelOption[],
  * @complexity O(1) plus, at most, one cached outbound HTTPS call bounded by
  * {@link LIVE_MODEL_TIMEOUT_MS}.
  */
-export declare function loadAnthropicLiveModels(env: RuntimeEnv, fallbackModels: readonly RuntimeModelOption[], now?: () => number): Promise<RuntimeModelOption[] | null>;
+export declare function loadAnthropicLiveModels(env: RuntimeEnv, _fallbackModels: readonly RuntimeModelOption[], now?: () => number): Promise<RuntimeModelOption[] | null>;
 //# sourceMappingURL=anthropic-live-models.d.ts.map

package/dist/artifact-taxonomy.d.ts

@@ -1,20 +1,6 @@
-/**
- * @module artifact-taxonomy
- *
- * Port replacing the classification half of OD's
- * `runtimes/runs/run-artifacts.ts` (`isArtifactPath`, `isDesignSystemFile`,
- * `isPreviewModulePath`, `didRunCreateDesignSystemFile`,
- * `countDesignSystemPreviewModules`). That file's real behavior is entirely
- * OD-product classification (HTML-prototype/SVG/design-system-file
- * taxonomy feeding PostHog `run_finished.artifact_count` /
- * `design_system_created` analytics) plus OD-specific imports into OD's own
- * analytics-contracts and question-form-detection modules — none of it is
- * ported.
- *
- * Per r1b §1b, only the taxonomy/classification *interface* belongs to
- * this package. `ArtifactTaxonomy`'s companion `ArtifactStore` (actual
- * read/write persistence) is explicitly a later storage/sqlite task's
- * concern — not defined here.
+/** @module artifact-taxonomy
+ * Hosts define artifact classification and opaque analytics buckets; product file-kind taxonomy
+ * cannot enter the runtime. Artifact persistence belongs to ArtifactStore, not this classifier.
  */
 export interface ArtifactTaxonomy {
     /** Does this file path count as a user-facing artifact? (OD: html/svg/prototype/live-artifact.) */

package/dist/auth.d.ts

@@ -23,9 +23,6 @@ export declare function reasonixAuthGuidance({}: {}, { hostName }?: {
 export declare function claudeAuthGuidance({}: {}, { hostName }?: {
     hostName?: string;
 }): string;
-export declare function geminiAuthGuidance({}: {}, { hostName }?: {
-    hostName?: string;
-}): string;
 export declare function isCursorAuthFailureText({ text }: {
     text: string;
 }): boolean;
@@ -41,9 +38,6 @@ export declare function isReasonixAuthFailureText({ text }: {
 export declare function isClaudeAuthFailureText({ text }: {
     text: string;
 }): boolean;
-export declare function isGeminiAuthFailureText({ text }: {
-    text: string;
-}): boolean;
 export declare function classifyAgentAuthFailure({ agentId, text }: {
     agentId: string;
     text: string;

package/dist/auth.js

@@ -55,17 +55,6 @@ function reasonixAuthGuidanceText(hostName) {
 function claudeAuthGuidanceText(hostName) {
     return `Claude Code is installed but is not authenticated. Run \`claude auth login\` or open \`claude\` and complete login in a terminal, then rescan. If ${hostName} was launched outside an interactive shell, your shell rc files (e.g. ~/.zshrc) may not be loaded into its environment.`;
 }
-// Gemini CLI has two distinct sign-in failures, and one fix covers both. With no auth method
-// configured, headless mode exits with "Please set an Auth method in your <settings.json> or
-// specify one of the following environment variables before running: GEMINI_API_KEY,
-// GOOGLE_GENAI_USE_VERTEXAI, GOOGLE_GENAI_USE_GCA". With "Login with Google" on a free / Google AI
-// Pro / Ultra account it dies with `IneligibleTierError: This client is no longer supported for
-// Gemini Code Assist for individuals` (Google stopped serving those tiers on 2026-06-18; API keys,
-// Vertex AI and Code Assist licenses still work). Signing in again cannot fix the second one, so
-// the guidance points at an API key or Antigravity instead of a re-login.
-function geminiAuthGuidanceText(hostName) {
-    return `Gemini CLI is installed but has no usable sign-in. Google no longer serves Gemini CLI's "Login with Google" for free, Google AI Pro or Ultra accounts. Use a Gemini API key instead: run \`gemini\` in a terminal, type /auth, choose "Use Gemini API key", and make GEMINI_API_KEY available to ${hostName}'s process environment (or configure Vertex AI). Google's replacement for individual accounts is Antigravity (\`agy\`), which you can pick here instead.`;
-}
 export function cursorAuthGuidance({}, { hostName = DEFAULT_HOST_NAME } = {}) {
     return cursorAuthGuidanceText(hostName);
 }
@@ -84,9 +73,6 @@ export function reasonixAuthGuidance({}, { hostName = DEFAULT_HOST_NAME } = {})
 export function claudeAuthGuidance({}, { hostName = DEFAULT_HOST_NAME } = {}) {
     return claudeAuthGuidanceText(hostName);
 }
-export function geminiAuthGuidance({}, { hostName = DEFAULT_HOST_NAME } = {}) {
-    return geminiAuthGuidanceText(hostName);
-}
 export function isCursorAuthFailureText({ text }) {
     const value = String(text || '');
     if (!value.trim())
@@ -159,16 +145,6 @@ export function isClaudeAuthFailureText({ text }) {
         /authentication required/i.test(value) ||
         /please (?:sign|log)[ _-]?in/i.test(value));
 }
-export function isGeminiAuthFailureText({ text }) {
-    const value = String(text || '');
-    if (!value.trim())
-        return false;
-    return (/please set an auth method/i.test(value) ||
-        /IneligibleTierError/.test(value) ||
-        /no longer supported for gemini code assist/i.test(value) ||
-        /error authenticating/i.test(value) ||
-        /api key not valid/i.test(value));
-}
 export function classifyAgentAuthFailure({ agentId, text }, { hostName = DEFAULT_HOST_NAME } = {}) {
     if (agentId === 'claude') {
         if (!isClaudeAuthFailureText({ text: text }))
@@ -195,11 +171,6 @@ export function classifyAgentAuthFailure({ agentId, text }, { hostName = DEFAULT
             return null;
         return { status: 'missing', message: reasonixAuthGuidance({}, { hostName: hostName }) };
     }
-    if (agentId === 'gemini') {
-        if (!isGeminiAuthFailureText({ text: text }))
-            return null;
-        return { status: 'missing', message: geminiAuthGuidance({}, { hostName: hostName }) };
-    }
     return null;
 }
 // A bare HTTP status number (`500`, `429`, …) is too noisy to trust on its own
@@ -279,7 +250,7 @@ function genericAuthGuidance(agentName, hostName) {
 // regex (e.g. cursor-agent's healthy `status` output mentions "login" in
 // ways the generic matcher would misread). The generic classifier is only a
 // fallback for adapters with no tailored classifier of their own.
-const TAILORED_AUTH_AGENTS = new Set(['claude', 'cursor-agent', 'deepseek', 'antigravity', 'reasonix', 'gemini']);
+const TAILORED_AUTH_AGENTS = new Set(['claude', 'cursor-agent', 'deepseek', 'antigravity', 'reasonix']);
 function hasNonEmptyEnv(env, keys) {
     return keys.some((key) => {
         const value = env[key];

package/dist/claude-code-models.d.ts

@@ -49,15 +49,14 @@ export interface ClaudeCodeModelIo {
 /** Test-only: install fake I/O (or `null` to restore the real one) and clear the process cache. */
 export declare function setClaudeCodeModelIoForTesting(io: ClaudeCodeModelIo | null): void;
 /**
- * Returns the `claude` model list with the CLI's own picker catalog merged in, or `null` when there
- * is nothing to merge. Needs no API key.
+ * Returns the `claude` model list from the CLI's own picker catalog, or `null` when discovery fails. Needs no API key.
  *
  * @param bin - The resolved `claude` (or fork) binary detection found.
  * @param env - The composed environment for the agent — what a spawn would actually see.
- * @param fallbackModels - The def's static list; always fully present, in order, in a non-null result.
+ * @param _fallbackModels - Compatibility argument; packaged rows are offline fallback only.
  * @param now - Injectable clock for TTL tests.
  * @complexity O(f + l) plus, at most once per {@link CLAUDE_CODE_MODEL_CACHE_TTL_MS} per cache key,
  * one CLI spawn bounded by {@link CLAUDE_CODE_INIT_TIMEOUT_MS} and one file read.
  */
-export declare function loadClaudeCodeModels(bin: string, env: RuntimeEnv, fallbackModels: readonly RuntimeModelOption[], now?: () => number): Promise<RuntimeModelOption[] | null>;
+export declare function loadClaudeCodeModels(bin: string, env: RuntimeEnv, _fallbackModels: readonly RuntimeModelOption[], now?: () => number): Promise<RuntimeModelOption[] | null>;
 //# sourceMappingURL=claude-code-models.d.ts.map

package/dist/claude-code-models.js

@@ -27,7 +27,7 @@
  *      older CLI without the control protocol, a fork bin (`openclaude`), a timeout.
  *
  * **Enrichment, never a gate.** Every failure resolves to `null` ("nothing to add"), and a non-null
- * result is always `mergeLiveModels(fallback, live)` — the static list is fully present, in order.
+ * result contains only discovered rows. Packaged fallback rows are kept separate by the snapshot layer.
  *
  * The cache-file parser ({@link parseClaudeCodePickerCache}) is shared with
  * `scripts/check-model-fallback-freshness.ts` so the freshness guard and the runtime can never
@@ -39,7 +39,6 @@ import { readFile } from 'node:fs/promises';
 import os from 'node:os';
 import { join } from 'node:path';
 import { createCommandInvocation } from '@jini-ai/platform';
-import { mergeLiveModels } from './anthropic-live-models.js';
 import { sanitizeCustomModel } from './models.js';
 /** A spawn costs ~2.5s and the picker list only moves when Claude Code updates or the server's
  *  "additional" options change, so one answer is trusted for this long per process. Failures are
@@ -229,17 +228,16 @@ async function discoverClaudeCodeModels(bin, env) {
     }
 }
 /**
- * Returns the `claude` model list with the CLI's own picker catalog merged in, or `null` when there
- * is nothing to merge. Needs no API key.
+ * Returns the `claude` model list from the CLI's own picker catalog, or `null` when discovery fails. Needs no API key.
  *
  * @param bin - The resolved `claude` (or fork) binary detection found.
  * @param env - The composed environment for the agent — what a spawn would actually see.
- * @param fallbackModels - The def's static list; always fully present, in order, in a non-null result.
+ * @param _fallbackModels - Compatibility argument; packaged rows are offline fallback only.
  * @param now - Injectable clock for TTL tests.
  * @complexity O(f + l) plus, at most once per {@link CLAUDE_CODE_MODEL_CACHE_TTL_MS} per cache key,
  * one CLI spawn bounded by {@link CLAUDE_CODE_INIT_TIMEOUT_MS} and one file read.
  */
-export async function loadClaudeCodeModels(bin, env, fallbackModels, now = Date.now) {
+export async function loadClaudeCodeModels(bin, env, _fallbackModels, now = Date.now) {
     const key = cacheKeyFor(bin, env);
     const cached = cache.get(key);
     const pending = cached && cached.expiresAt > now() ? cached.value : null;
@@ -247,6 +245,6 @@ export async function loadClaudeCodeModels(bin, env, fallbackModels, now = Date.
     if (!pending)
         cache.set(key, { expiresAt: now() + CLAUDE_CODE_MODEL_CACHE_TTL_MS, value });
     const live = await value;
-    return live && live.length > 0 ? mergeLiveModels(fallbackModels, live) : null;
+    return live && live.length > 0 ? [...live] : null;
 }
 //# sourceMappingURL=claude-code-models.js.map

package/dist/claude-stream.d.ts

@@ -1,10 +1,6 @@
 /**
  * @module claude-stream
  *
- * Ported verbatim from OD's `apps/daemon/src/runtimes/claude-stream.ts`
- * (only the `role-marker-guard` import path changed — it now resolves
- * within this package instead of two directories up). See `archived provenance ledger`.
- *
  * Parses Claude Code's `--output-format stream-json --verbose` JSONL stream
  * (with or without `--include-partial-messages`) into a small set of
  * UI-friendly events. With partial messages on, text arrives as

package/dist/claude-stream.js

@@ -1,10 +1,6 @@
 /**
  * @module claude-stream
  *
- * Ported verbatim from OD's `apps/daemon/src/runtimes/claude-stream.ts`
- * (only the `role-marker-guard` import path changed — it now resolves
- * within this package instead of two directories up). See `archived provenance ledger`.
- *
  * Parses Claude Code's `--output-format stream-json --verbose` JSONL stream
  * (with or without `--include-partial-messages`) into a small set of
  * UI-friendly events. With partial messages on, text arrives as
@@ -626,6 +622,8 @@ export function createClaudeStreamHandler({ onEvent }, options = {}) {
         const message = obj.message;
         if (!isRecord(message) || !Array.isArray(message.content))
             return;
+        if (typeof message.model === 'string')
+            onEvent({ type: 'status', label: 'model', model: message.model });
         const { textMsgId, thinkingMsgId, textAlreadyStreamed, thinkingAlreadyStreamed } = resolveAssistantMessageIds(message);
         // Per-turn `stop_reason` is emitted as `turn_end` AFTER the content
         // blocks have been processed (see below). When `--include-partial-
@@ -695,6 +693,8 @@ export function createClaudeStreamHandler({ onEvent }, options = {}) {
         }
     }
     function handleMessageStart(ev) {
+        if (isRecord(ev.message) && typeof ev.message.model === 'string')
+            onEvent({ type: 'status', label: 'model', model: ev.message.model });
         flushPendingArtifactText();
         // Clean up per-message role-marker guard from the previous message.
         if (currentMessageId)

package/dist/copilot-stream.d.ts

@@ -1,11 +1,6 @@
 /**
  * @module copilot-stream
  *
- * Ported verbatim from OD's top-level `apps/daemon/src/copilot-stream.ts`
- * (relocated under `runtimes/` in Jini's daemon per r1's recon; grouped
- * with the other stream parsers here). Self-contained — no imports, no
- * product coupling. See `archived provenance ledger`.
- *
  * Parses GitHub Copilot CLI's `--output-format json` JSONL stream into the
  * same UI-friendly events that claude-stream.js emits, so the chat panel
  * can render Copilot's thinking / tool calls / text the same way it does

package/dist/copilot-stream.js

@@ -1,11 +1,6 @@
 /**
  * @module copilot-stream
  *
- * Ported verbatim from OD's top-level `apps/daemon/src/copilot-stream.ts`
- * (relocated under `runtimes/` in Jini's daemon per r1's recon; grouped
- * with the other stream parsers here). Self-contained — no imports, no
- * product coupling. See `archived provenance ledger`.
- *
  * Parses GitHub Copilot CLI's `--output-format json` JSONL stream into the
  * same UI-friendly events that claude-stream.js emits, so the chat panel
  * can render Copilot's thinking / tool calls / text the same way it does

package/dist/defs/aider.d.ts

@@ -17,5 +17,20 @@ export declare const aiderAgentDef: {
     streamFormat: string;
     installUrl: string;
     docsUrl: string;
+    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=aider.d.ts.map

package/dist/defs/aider.js

@@ -1,6 +1,8 @@
-/** Ported from OD's `apps/daemon/src/runtimes/defs/aider.ts` (one de-branded comment; see `archived provenance ledger`). */
+import { createAgentModelDiscovery } from '../model-discovery.js';
 import { DEFAULT_MODEL_OPTION } from './shared.js';
 export const aiderAgentDef = {
+    // UNVERIFIED live integration locally; source/category and limits are documented in model-discovery-adapters.ts.
+    ...createAgentModelDiscovery('aider', { fallbackModels: () => aiderAgentDef.fallbackModels }),
     id: 'aider',
     name: 'Aider',
     bin: 'aider',
@@ -30,7 +32,7 @@ export const aiderAgentDef = {
     // Aider's one-shot mode requires the prompt as `--message <text>` on
     // argv; neither `--message` nor `--message-file` accept `-` as a stdin
     // sentinel (it is treated as a literal filename), so we cannot pipe
-    // the prompt in the way qwen/gemini do. Mirror the DeepSeek TUI
+    // the prompt in the way qwen does. Mirror the DeepSeek TUI
     // pattern: ship the prompt as argv with a conservative byte budget so
     // the /api/chat spawn path emits an actionable error before hitting
     // Windows' ~32 KB CreateProcess limit or Linux MAX_ARG_STRLEN.

package/dist/defs/amp.d.ts

@@ -5,6 +5,7 @@ export declare const ampAgentDef: {
     versionArgs: string[];
     fallbackModels: import("../types.js").RuntimeModelOption[];
     supportsCustomModel: false;
+    supportsConcreteModelSelection: false;
     buildArgs: ({ prompt: _prompt, imagePaths: _imagePaths }: {
         prompt: string;
         imagePaths: string[];
@@ -15,5 +16,20 @@ export declare const ampAgentDef: {
     } | undefined) => string[];
     promptViaStdin: true;
     streamFormat: string;
+    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=amp.d.ts.map