@phuetz/code-buddy 1.6.1 → 2.0.0

package/dist/protocols/a2a/index.js

@@ -53,6 +53,14 @@ export class A2AAgentServer extends EventEmitter {
         this.updateTaskStatus(task, TaskStatus.WORKING);
         try {
             const completed = await this.executor(task);
+            if (completed.status.status === TaskStatus.FAILED ||
+                completed.status.status === TaskStatus.CANCELED) {
+                this.emit('task:failed', {
+                    taskId: task.id,
+                    error: completed.status.message || completed.status.status,
+                });
+                return completed;
+            }
             this.updateTaskStatus(completed, TaskStatus.COMPLETED);
             this.emit('task:completed', { taskId: task.id });
             return completed;
@@ -132,6 +140,14 @@ export class A2AAgentServer extends EventEmitter {
         this.emit('task:resumed', { taskId });
         try {
             const completed = await this.executor(task);
+            if (completed.status.status === TaskStatus.FAILED ||
+                completed.status.status === TaskStatus.CANCELED) {
+                this.emit('task:failed', {
+                    taskId,
+                    error: completed.status.message || completed.status.status,
+                });
+                return completed;
+            }
             this.updateTaskStatus(completed, TaskStatus.COMPLETED);
             this.emit('task:completed', { taskId });
             return completed;
@@ -152,6 +168,19 @@ export class A2AAgentServer extends EventEmitter {
  * A2A Agent Client — sends tasks to other agents.
  * Used by an orchestrator to delegate work to specialist agents.
  */
+/**
+ * Spoke names that earn the "always-on" bonus. Spokes name themselves after their host
+ * (`ollama-<hostname>`), so the patterns must be configurable per deployment:
+ * `CODEBUDDY_A2A_ALWAYS_ON_SPOKES` (csv of case-insensitive substrings), default `hub,linux`.
+ */
+export function isAlwaysOnSpokeName(spokeName, env = process.env) {
+    const patterns = (env.CODEBUDDY_A2A_ALWAYS_ON_SPOKES ?? 'hub,linux')
+        .split(',')
+        .map((item) => item.trim().toLowerCase())
+        .filter((item) => item.length > 0);
+    const name = spokeName.toLowerCase();
+    return patterns.some((pattern) => name.includes(pattern));
+}
 export class A2AAgentClient {
     agents = new Map();
     remoteCards = new Map();
@@ -231,14 +260,14 @@ export class A2AAgentClient {
         return { error: 'Missing required field: `agent` or `skill`', status: 400 };
     }
     /** Score a spoke for a given skill (higher = better) */
-    scoreSpokeForSkill(spokeName, skillId) {
+    scoreSpokeForSkill(spokeName, _skillId) {
         const remote = this.remoteCards.get(spokeName);
         if (!remote)
             return 0;
         // Base score: has the skill
         let score = 10;
-        // Bonus for always-on spokes (assume names with "ministar" or "linux" are always-on)
-        if (spokeName.toLowerCase().includes('ministar') || spokeName.toLowerCase().includes('linux')) {
+        // Bonus for always-on spokes (assume names with "hub" or "linux" are always-on)
+        if (isAlwaysOnSpokeName(spokeName)) {
             score += 5;
         }
         // Bonus for fresh heartbeat (last registered < 1 min ago)

package/dist/protocols/acp/acp-agentic-runner.d.ts

@@ -27,7 +27,7 @@
  *     rejection fails the tool call instead of leaking content.
  *
  * Read-only tools are always exposed (`view_file`, `list_directory`,
- * `search`). `write_file` is exposed only when the editor advertises
+ * `search`, `restore_context`). `write_file` is exposed only when the editor advertises
  * `fs.writeTextFile`, and the write is routed through the editor permission
  * flow. Cancellation is honoured by checking `signal.aborted` on every loop
  * iteration and after every client round-trip.
@@ -41,8 +41,12 @@ export interface AcpAgenticRunnerOptions {
     chat: AcpChatFn;
     /** Max LLM rounds before returning `max_turn_requests`. Default 12. */
     maxRounds?: number;
-    /** Max bytes returned by a single read/search before truncation. */
+    /** Max bytes shown by a single read/search result before recoverable truncation. */
     maxToolOutputBytes?: number;
+    /** Model metadata used to allocate recoverable observation budgets. */
+    model?: string;
+    contextWindow?: number;
+    responseReserveTokens?: number;
 }
 /**
  * Build an injectable ACP prompt runner that performs a bounded,

package/dist/protocols/acp/acp-agentic-runner.js

@@ -27,16 +27,18 @@
  *     rejection fails the tool call instead of leaking content.
  *
  * Read-only tools are always exposed (`view_file`, `list_directory`,
- * `search`). `write_file` is exposed only when the editor advertises
+ * `search`, `restore_context`). `write_file` is exposed only when the editor advertises
  * `fs.writeTextFile`, and the write is routed through the editor permission
  * flow. Cancellation is honoured by checking `signal.aborted` on every loop
  * iteration and after every client round-trip.
  */
 import { spawn } from 'child_process';
-import { rgPath } from '@vscode/ripgrep';
+import { getRipgrepPath } from '../../utils/ripgrep-path.js';
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import { logger } from '../../utils/logger.js';
+import { formatToolResultForRecovery } from '../../context/restorable-compression.js';
+import { commandFromToolArguments, prepareToolObservationForPrompt, } from '../../agent/prompt-tool-observation.js';
 const DEFAULT_MAX_ROUNDS = 12;
 const DEFAULT_MAX_TOOL_OUTPUT_BYTES = 64 * 1024;
 const LIST_DIRECTORY_MAX_ENTRIES = 256;
@@ -75,6 +77,20 @@ const READONLY_TOOLS = [
             },
         },
     },
+    {
+        type: 'function',
+        function: {
+            name: 'restore_context',
+            description: 'Restore the exact raw output of an earlier tool call in this ACP turn by call ID.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    identifier: { type: 'string', description: 'Exact earlier tool call ID' },
+                },
+                required: ['identifier'],
+            },
+        },
+    },
     {
         type: 'function',
         function: {
@@ -110,6 +126,7 @@ const TOOL_KIND = {
     view_file: 'read',
     list_directory: 'read',
     search: 'search',
+    restore_context: 'read',
     write_file: 'edit',
 };
 /**
@@ -154,6 +171,10 @@ export function createAcpAgenticRunner(options) {
             { role: 'system', content: SYSTEM_PROMPT },
             { role: 'user', content: userText },
         ];
+        // Recovery is deliberately scoped to this ACP prompt turn. A model cannot
+        // use a guessed callId to read an observation belonging to another editor
+        // session, while RestorableCompressor still provides the disk-backed copy.
+        const rawToolObservations = new Map();
         const allTools = [...READONLY_TOOLS];
         if (ctx.canRequestClient('fs/write_text_file')) {
             allTools.push(WRITE_FILE_TOOL);
@@ -222,7 +243,19 @@ export function createAcpAgenticRunner(options) {
                     rawInput: args,
                 });
                 let result;
-                if (call.function.name.startsWith('mcp__') && mcpManager) {
+                if (call.function.name === 'restore_context') {
+                    const identifier = stringArg(args, 'identifier');
+                    const raw = identifier ? rawToolObservations.get(identifier) : undefined;
+                    result = raw === undefined
+                        ? {
+                            output: identifier
+                                ? `Tool call ${identifier} is not available in this ACP turn`
+                                : 'restore_context: missing string identifier',
+                            isError: true,
+                        }
+                        : { output: raw, isError: false };
+                }
+                else if (call.function.name.startsWith('mcp__') && mcpManager) {
                     try {
                         const mcpRes = await mcpManager.callTool(call.function.name, args);
                         const outputText = Array.isArray(mcpRes.content)
@@ -251,10 +284,43 @@ export function createAcpAgenticRunner(options) {
                     status: result.isError ? 'failed' : 'completed',
                     content: [{ type: 'content', content: { type: 'text', text: result.output } }],
                 });
+                const nativeOutput = result.rawOutput ?? result.output;
+                const recoveryContent = formatToolResultForRecovery({
+                    success: !result.isError,
+                    ...(result.isError ? { error: nativeOutput } : { output: nativeOutput }),
+                });
+                const displayContent = formatToolResultForRecovery({
+                    success: !result.isError,
+                    ...(result.isError ? { error: result.output } : { output: result.output }),
+                });
+                const observation = await prepareToolObservationForPrompt({
+                    toolName: call.function.name,
+                    toolCallId: call.id,
+                    content: recoveryContent,
+                    fallbackContent: displayContent === recoveryContent
+                        ? displayContent
+                        : `${displayContent}\n\n[ACP display was bounded; exact raw output: restore_context(identifier=${JSON.stringify(call.id)})]`,
+                    success: !result.isError,
+                    exitCode: result.isError ? 1 : 0,
+                    ...(result.isError ? { error: result.output } : {}),
+                    command: commandFromToolArguments(args),
+                    query: userText,
+                    workspaceRoot: ctx.cwd,
+                    sessionId: ctx.sessionId,
+                    model: options.model,
+                    messages,
+                    contextWindow: options.contextWindow,
+                    responseReserveTokens: options.responseReserveTokens,
+                    signal: ctx.signal,
+                    allowOptimization: true,
+                });
+                if (call.function.name !== 'restore_context') {
+                    rawToolObservations.set(call.id, observation.rawContent);
+                }
                 messages.push({
                     role: 'tool',
                     tool_call_id: call.id,
-                    content: result.output,
+                    content: observation.content,
                 });
             }
         }
@@ -271,12 +337,21 @@ async function executeAcpTool(input) {
     const { name, args, ctx, toolCallId, maxToolOutputBytes } = input;
     try {
         switch (name) {
-            case 'view_file':
-                return { output: await readFileViaClientOrDisk(args, ctx, toolCallId, maxToolOutputBytes), isError: false };
-            case 'list_directory':
-                return { output: await listDirectory(args, ctx.cwd), isError: false };
-            case 'search':
-                return { output: await searchWorkspace(args, ctx.cwd, maxToolOutputBytes), isError: false };
+            case 'view_file': {
+                const text = await readFileViaClientOrDisk(args, ctx, toolCallId, maxToolOutputBytes);
+                return { output: text.display, rawOutput: text.raw, isError: false };
+            }
+            case 'list_directory': {
+                const text = await listDirectory(args, ctx.cwd);
+                return { output: text.display, rawOutput: text.raw, isError: false };
+            }
+            case 'search': {
+                // ripgrep collection is intentionally bounded upstream (per-file and
+                // total result caps). The persisted value is exact for that collected
+                // observation, not a promise of an exhaustive workspace search.
+                const text = await searchWorkspace(args, ctx.cwd, maxToolOutputBytes);
+                return { output: text.display, rawOutput: text.raw, isError: false };
+            }
             case 'write_file':
                 return { output: await writeFileViaClientOrDisk(args, ctx, toolCallId), isError: false };
             default:
@@ -315,12 +390,12 @@ async function readFileViaClientOrDisk(args, ctx, toolCallId, maxBytes) {
         }
         const result = await ctx.requestClient('fs/read_text_file', { sessionId: ctx.sessionId, path: absolute });
         const content = extractClientReadContent(result);
-        return truncate(content, maxBytes);
+        return { raw: content, display: truncate(content, maxBytes) };
     }
     // Disk fallback, scoped to cwd.
     const resolved = resolveInsideCwd(rawPath, ctx.cwd);
     const content = await fs.readFile(resolved, 'utf-8');
-    return truncate(content, maxBytes);
+    return { raw: content, display: truncate(content, maxBytes) };
 }
 /**
  * Write a file through the editor client. There is deliberately no direct disk
@@ -395,7 +470,7 @@ async function listDirectory(args, cwd) {
     if (truncated) {
         visible.push(`... truncated after ${LIST_DIRECTORY_MAX_ENTRIES} entries (${lines.length} total)`);
     }
-    return visible.join('\n');
+    return { raw: lines.join('\n'), display: visible.join('\n') };
 }
 function searchWorkspace(args, cwd, maxBytes) {
     const query = stringArg(args, 'query') ?? stringArg(args, 'pattern');
@@ -405,7 +480,7 @@ function searchWorkspace(args, cwd, maxBytes) {
     const resolved = resolveInsideCwd(rawPath, cwd);
     return new Promise((resolve, reject) => {
         const rgArgs = ['--no-heading', '--line-number', '--color', 'never', '--max-count', '50', '--', query, resolved];
-        const proc = spawn(rgPath, rgArgs, { stdio: ['ignore', 'pipe', 'pipe'] });
+        const proc = spawn(getRipgrepPath(), rgArgs, { stdio: ['ignore', 'pipe', 'pipe'] });
         let stdout = '';
         let stderr = '';
         let lineCount = 0;
@@ -433,7 +508,8 @@ function searchWorkspace(args, cwd, maxBytes) {
             clearTimeout(timer);
             // 0 = matches, 1 = no matches (still ok), 2 = error.
             if (code === 0 || code === 1 || (code === null && stdout.length > 0)) {
-                resolve(truncate(stdout || '(no matches)', maxBytes));
+                const raw = stdout || '(no matches)';
+                resolve({ raw, display: truncate(raw, maxBytes) });
             }
             else {
                 reject(new Error(`search: ripgrep exited with code ${code}: ${stderr.trim()}`));

package/dist/protocols/acp/acp-session-store.js

@@ -3,6 +3,28 @@ import * as os from 'os';
 import * as path from 'path';
 import { withSessionLock } from '../../persistence/session-lock.js';
 import { logger } from '../../utils/logger.js';
+import { readJsonAtomic, writeJsonAtomic } from '../../utils/atomic-write.js';
+/**
+ * Atomic replace with a short retry: on Windows a rename onto a file that
+ * another handle still has open (a concurrent `load`, an indexer) fails with
+ * EPERM/EBUSY for a few milliseconds instead of succeeding as on POSIX.
+ */
+async function renameWithRetry(from, to) {
+    const delaysMs = [10, 25, 50, 100, 200];
+    for (let attempt = 0;; attempt++) {
+        try {
+            await fs.promises.rename(from, to);
+            return;
+        }
+        catch (err) {
+            const code = err.code;
+            const delay = delaysMs[attempt];
+            if ((code !== 'EPERM' && code !== 'EBUSY') || delay === undefined)
+                throw err;
+            await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+    }
+}
 export class AcpSessionStore {
     dir;
     constructor(config = {}) {
@@ -20,8 +42,11 @@ export class AcpSessionStore {
         if (!fs.existsSync(file))
             return null;
         try {
-            const raw = await fs.promises.readFile(file, 'utf-8');
-            return JSON.parse(raw);
+            return await readJsonAtomic(file, null, {
+                mode: 0o600,
+                isValid: (value) => Boolean(value && typeof value === 'object' && !Array.isArray(value) &&
+                    typeof value.sessionId === 'string'),
+            });
         }
         catch (err) {
             logger.warn?.('[acp-session-store] failed to read session', {
@@ -56,9 +81,7 @@ export class AcpSessionStore {
     }
     async writeUnlocked(session) {
         const file = this.fileFor(session.sessionId);
-        const temp = `${file}.tmp.${Date.now()}-${Math.random().toString(36).slice(2)}`;
-        await fs.promises.writeFile(temp, JSON.stringify(session, null, 2), 'utf-8');
-        await fs.promises.rename(temp, file);
+        await writeJsonAtomic(file, session, { mode: 0o600 });
     }
     fileFor(sessionId) {
         const safe = sessionId.replace(/[^a-zA-Z0-9_-]/g, '_');

package/dist/protocols/acp/acp-stdio-server.d.ts

@@ -92,6 +92,8 @@ export declare class AcpStdioServer {
     private readonly pendingClientRequests;
     private readonly store;
     private storeLoaded;
+    /** In-flight fire-and-forget persistSession() writes (see whenIdle()). */
+    private readonly pendingPersists;
     private clientCapabilities;
     private nextClientRequestId;
     private buffer;
@@ -104,7 +106,18 @@ export declare class AcpStdioServer {
     private write;
     private sendUpdate;
     private ensureStoreLoaded;
+    /**
+     * Fire-and-forget persistence (`void this.persistSession(...)`): a failed
+     * write must be logged, never surface as an unhandled rejection.
+     */
     private persistSession;
+    /**
+     * Resolves once every in-flight session write has settled (successfully or
+     * not). Callers that stop the server and then remove its store directory
+     * (tests, a tear-down) await this first: on Windows a write still holding
+     * `<id>.json.tmp` open makes the directory removal fail with ENOTEMPTY.
+     */
+    whenIdle(): Promise<void>;
     private requestClient;
     private handleLine;
     private dispatch;

package/dist/protocols/acp/acp-stdio-server.js

@@ -31,6 +31,7 @@
  */
 import { randomUUID } from 'crypto';
 import { AcpSessionStore } from './acp-session-store.js';
+import { logger } from '../../utils/logger.js';
 export const ACP_PROTOCOL_VERSION = 1;
 function asString(value) {
     return typeof value === 'string' && value.length > 0 ? value : undefined;
@@ -59,6 +60,8 @@ export class AcpStdioServer {
     pendingClientRequests = new Map();
     store;
     storeLoaded = false;
+    /** In-flight fire-and-forget persistSession() writes (see whenIdle()). */
+    pendingPersists = new Set();
     clientCapabilities = {};
     nextClientRequestId = 0;
     buffer = '';
@@ -130,18 +133,42 @@ export class AcpStdioServer {
             throw err;
         });
     }
-    async persistSession(sessionId) {
+    /**
+     * Fire-and-forget persistence (`void this.persistSession(...)`): a failed
+     * write must be logged, never surface as an unhandled rejection.
+     */
+    persistSession(sessionId) {
         const s = this.sessions.get(sessionId);
         if (!s)
-            return;
-        await this.store.save({
+            return Promise.resolve();
+        const snapshot = {
             sessionId,
             cwd: s.cwd,
             history: s.history,
             mcpServers: s.mcpServers,
             title: s.title,
             updatedAt: s.updatedAt,
+        };
+        const write = this.store.save(snapshot).catch((err) => {
+            logger.warn?.('[acp] failed to persist session', {
+                sessionId,
+                error: err instanceof Error ? err.message : String(err),
+            });
         });
+        this.pendingPersists.add(write);
+        void write.finally(() => this.pendingPersists.delete(write));
+        return write;
+    }
+    /**
+     * Resolves once every in-flight session write has settled (successfully or
+     * not). Callers that stop the server and then remove its store directory
+     * (tests, a tear-down) await this first: on Windows a write still holding
+     * `<id>.json.tmp` open makes the directory removal fail with ENOTEMPTY.
+     */
+    async whenIdle() {
+        while (this.pendingPersists.size > 0) {
+            await Promise.allSettled([...this.pendingPersists]);
+        }
     }
     requestClient(method, params = {}, options = {}) {
         const clientCapabilities = options.clientCapabilities ?? this.clientCapabilities;

package/dist/providers/active-llm-model-pool.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Active-LLM model pool — MULTIPLE models per active provider.
+ *
+ * `buildActiveLlmRegistry` deliberately exposes ONE resolved model per
+ * provider (that is what failover and `buddy llm` need). The council's
+ * capability routing, however, needs the real choice space: this module
+ * expands each ACTIVE provider to its curated catalog models (cloud) or its
+ * actually-installed models (local runtimes), inheriting the provider's
+ * resolved auth/baseURL/cost. The registry and its consumers are untouched.
+ *
+ * Dedup rules (deliberate, see council scoreboard):
+ *  - LOCAL models dedup on the bare model name across runtimes (Ollama
+ *    preferred over LM Studio) — the scoreboard and the council's
+ *    `displayName` are keyed on the model name, so seating the same model
+ *    twice via two runtimes would merge their learning and confuse the panel.
+ *  - CLOUD models dedup on `provider:model` (two providers may legitimately
+ *    serve models with different names; identical names across providers are
+ *    rare and acceptable — the scoreboard merges them by name).
+ *
+ * Cost note: expanded models inherit the provider-level approximate
+ * $/Mtok (the registry doesn't know per-model prices) — good enough for the
+ * council's cheap-bonus (which only needs "is it $0") and display.
+ *
+ * Kill-switch: `CODEBUDDY_COUNCIL_POOL=registry` reproduces the legacy
+ * one-model-per-provider pool.
+ *
+ * @module providers/active-llm-model-pool
+ */
+import { type ModelEgress } from './model-egress.js';
+export { classifyModelEgress } from './model-egress.js';
+export interface ActiveLlmModelPoolEntry {
+    provider: string;
+    model: string;
+    apiKey?: string;
+    baseURL?: string;
+    /** Real inference egress, not merely where a CLI process happens to run. */
+    egress: ModelEgress;
+    costInputUsdPerMtok: number;
+}
+export interface ListActiveLlmModelPoolOptions {
+    env?: Record<string, string | undefined>;
+    /** Cap on probed local models per runtime (an Ollama box can have dozens). */
+    maxLocalPerProvider?: number;
+}
+export declare function listActiveLlmModelPool(opts?: ListActiveLlmModelPoolOptions): Promise<ActiveLlmModelPoolEntry[]>;

package/dist/providers/active-llm-model-pool.js

@@ -0,0 +1,139 @@
+/**
+ * Active-LLM model pool — MULTIPLE models per active provider.
+ *
+ * `buildActiveLlmRegistry` deliberately exposes ONE resolved model per
+ * provider (that is what failover and `buddy llm` need). The council's
+ * capability routing, however, needs the real choice space: this module
+ * expands each ACTIVE provider to its curated catalog models (cloud) or its
+ * actually-installed models (local runtimes), inheriting the provider's
+ * resolved auth/baseURL/cost. The registry and its consumers are untouched.
+ *
+ * Dedup rules (deliberate, see council scoreboard):
+ *  - LOCAL models dedup on the bare model name across runtimes (Ollama
+ *    preferred over LM Studio) — the scoreboard and the council's
+ *    `displayName` are keyed on the model name, so seating the same model
+ *    twice via two runtimes would merge their learning and confuse the panel.
+ *  - CLOUD models dedup on `provider:model` (two providers may legitimately
+ *    serve models with different names; identical names across providers are
+ *    rare and acceptable — the scoreboard merges them by name).
+ *
+ * Cost note: expanded models inherit the provider-level approximate
+ * $/Mtok (the registry doesn't know per-model prices) — good enough for the
+ * council's cheap-bonus (which only needs "is it $0") and display.
+ *
+ * Kill-switch: `CODEBUDDY_COUNCIL_POOL=registry` reproduces the legacy
+ * one-model-per-provider pool.
+ *
+ * @module providers/active-llm-model-pool
+ */
+import { buildActiveLlmRegistry } from './active-llm-registry.js';
+import { findRuntimeProvider } from './provider-catalog.js';
+import { classifyProviderModelEgress } from './model-egress.js';
+export { classifyModelEgress } from './model-egress.js';
+const DEFAULT_MAX_LOCAL_PER_PROVIDER = 10;
+function toEntry(c) {
+    return {
+        provider: c.provider,
+        model: c.model ?? '',
+        ...(c.apiKey ? { apiKey: c.apiKey } : {}),
+        ...(c.baseURL ? { baseURL: c.baseURL } : {}),
+        egress: classifyProviderModelEgress(c.provider, c.baseURL, c.isLocal),
+        costInputUsdPerMtok: c.costInputUsdPerMtok,
+    };
+}
+function modelCost(active, model) {
+    if (active.provider === 'openrouter' &&
+        (model === 'openrouter/free' || model.endsWith(':free'))) {
+        return 0;
+    }
+    return active.costInputUsdPerMtok;
+}
+/** Local runtimes report 'lm-studio' from the capability probe, 'lmstudio' in the catalog. */
+function normalizeLocalProvider(provider) {
+    return provider === 'lm-studio' ? 'lmstudio' : provider;
+}
+async function probeSelectableModels() {
+    try {
+        const { getLocalCapabilities } = await import('../fleet/capability-registry.js');
+        const caps = await getLocalCapabilities({});
+        return caps.models
+            .filter((m) => m.provider === 'ollama' ||
+            m.provider === 'lm-studio' ||
+            m.provider === 'lemonade' ||
+            m.provider === 'agy-cli' ||
+            m.provider === 'omniroute')
+            .map((m) => ({ id: m.id, provider: normalizeLocalProvider(m.provider) }));
+    }
+    catch {
+        return [];
+    }
+}
+export async function listActiveLlmModelPool(opts = {}) {
+    const env = opts.env ?? process.env;
+    const registry = await buildActiveLlmRegistry({ env });
+    const base = registry.all.filter((c) => c.model);
+    const poolMode = (env.CODEBUDDY_COUNCIL_POOL ?? 'full').toLowerCase();
+    if (poolMode === 'registry') {
+        return base.map(toEntry);
+    }
+    const cloud = base.filter((c) => !c.isLocal);
+    // Ollama first so the bare-name dedup prefers it over LM Studio duplicates.
+    const locals = base
+        .filter((c) => c.isLocal)
+        .sort((a, b) => Number(b.provider === 'ollama') - Number(a.provider === 'ollama'));
+    const pool = [];
+    const seenCloud = new Set();
+    const seenLocalNames = new Set();
+    const maxLocal = Math.max(1, opts.maxLocalPerProvider ?? DEFAULT_MAX_LOCAL_PER_PROVIDER);
+    const discoveredModels = base.some((c) => c.isLocal || c.provider === 'agy-cli' || c.provider === 'omniroute')
+        ? await probeSelectableModels()
+        : [];
+    for (const active of cloud) {
+        const defaultEntry = toEntry(active);
+        // The registry's resolved default (env override included) always seats first.
+        const catalogModels = active.provider === 'agy-cli'
+            ? discoveredModels.filter((m) => m.provider === 'agy-cli').map((m) => m.id)
+            : active.provider === 'omniroute'
+                // OmniRoute: the curated `auto/*` routing combos first, then the ids the
+                // gateway actually serves (capped like a probed runtime — it can list 100+).
+                ? [
+                    ...(findRuntimeProvider('omniroute')?.models ?? []),
+                    ...discoveredModels
+                        .filter((m) => m.provider === 'omniroute')
+                        .map((m) => m.id)
+                        .slice(0, maxLocal),
+                ]
+                : (findRuntimeProvider(active.provider)?.models ?? []);
+        for (const model of [defaultEntry.model, ...catalogModels]) {
+            const key = `${active.provider}:${model}`.toLowerCase();
+            if (seenCloud.has(key))
+                continue;
+            seenCloud.add(key);
+            pool.push({
+                ...defaultEntry,
+                model,
+                costInputUsdPerMtok: modelCost(active, model),
+            });
+        }
+    }
+    for (const active of locals) {
+        const defaultEntry = toEntry(active);
+        const providerId = normalizeLocalProvider(active.provider);
+        let added = 0;
+        for (const model of [
+            defaultEntry.model,
+            ...discoveredModels.filter((m) => m.provider === providerId).map((m) => m.id),
+        ]) {
+            if (added >= maxLocal)
+                break;
+            const name = model.toLowerCase();
+            if (seenLocalNames.has(name))
+                continue;
+            seenLocalNames.add(name);
+            pool.push({ ...defaultEntry, model });
+            added++;
+        }
+    }
+    return pool;
+}
+//# sourceMappingURL=active-llm-model-pool.js.map