@phuetz/code-buddy 1.6.1 → 2.0.0

package/dist/fleet/cost-tracker.js

@@ -14,7 +14,7 @@
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
-import { logger } from '../utils/logger.js';
+import { readJsonAtomic, writeJsonAtomic } from '../utils/atomic-write.js';
 export const DEFAULT_BUDGET = {
     maxDailyUsd: 5,
     maxSagaUsd: 1,
@@ -28,6 +28,9 @@ export class CostTracker {
     }
     /** Append a new charge to the ledger and refresh the cache. */
     async charge(entry) {
+        if (!isCostEntry(entry)) {
+            throw new Error('FLEET_COST_INVALID_ENTRY: refusing to persist an invalid charge');
+        }
         const ledger = await this.load();
         ledger.push(entry);
         this.cached = ledger;
@@ -39,21 +42,17 @@ export class CostTracker {
             return this.cached;
         if (!fs.existsSync(this.file)) {
             this.cached = [];
-            return [];
-        }
-        try {
-            const raw = await fs.promises.readFile(this.file, 'utf-8');
-            const parsed = JSON.parse(raw);
-            this.cached = Array.isArray(parsed) ? parsed : [];
             return this.cached;
         }
-        catch (err) {
-            logger.warn?.('[cost-tracker] failed to read ledger', {
-                err: err instanceof Error ? err.message : String(err),
-            });
-            this.cached = [];
-            return [];
+        const parsed = await readJsonAtomic(this.file, null, {
+            mode: 0o600,
+            isValid: (value) => Array.isArray(value) && value.every(isCostEntry),
+        });
+        if (!parsed) {
+            throw new Error('FLEET_COST_LEDGER_UNAVAILABLE: ledger is empty, unreadable, or malformed');
         }
+        this.cached = parsed;
+        return this.cached;
     }
     /** Aggregate today's spend + 7-day total + per-provider/peer. */
     async summary() {
@@ -81,6 +80,12 @@ export class CostTracker {
      * either cap. Pure function — does NOT charge.
      */
     async canSpend(estimatedUsd, sagaId, budget = DEFAULT_BUDGET) {
+        if (!isNonNegativeFinite(estimatedUsd)) {
+            return { ok: false, reason: 'Invalid estimated fleet cost' };
+        }
+        if (!isValidBudget(budget)) {
+            return { ok: false, reason: 'Invalid fleet cost budget' };
+        }
         const summary = await this.summary();
         if (summary.todayUsd + estimatedUsd > budget.maxDailyUsd) {
             return {
@@ -88,6 +93,7 @@ export class CostTracker {
                 reason: `Daily cap reached: today ${summary.todayUsd.toFixed(2)}$ + ${estimatedUsd.toFixed(2)}$ > cap ${budget.maxDailyUsd}$`,
             };
         }
+        let sagaRemainingUsd = Number.POSITIVE_INFINITY;
         if (sagaId) {
             const ledger = await this.load();
             const sagaSpend = ledger
@@ -99,10 +105,23 @@ export class CostTracker {
                     reason: `Per-saga cap reached: saga ${sagaSpend.toFixed(2)}$ + ${estimatedUsd.toFixed(2)}$ > cap ${budget.maxSagaUsd}$`,
                 };
             }
+            sagaRemainingUsd = budget.maxSagaUsd - sagaSpend - estimatedUsd;
         }
         return {
             ok: true,
-            remainingUsd: Math.max(0, budget.maxDailyUsd - summary.todayUsd - estimatedUsd),
+            remainingUsd: Math.max(0, Math.min(budget.maxDailyUsd - summary.todayUsd - estimatedUsd, sagaRemainingUsd)),
+        };
+    }
+    /**
+     * Incoming-call budget API. Keeps the historical `canSpend` method intact
+     * while exposing the allow/deny vocabulary used by fleet bridges.
+     */
+    async isWithinBudget(estimatedUsd, budget = DEFAULT_BUDGET, sagaId) {
+        const check = await this.canSpend(estimatedUsd, sagaId, budget);
+        return {
+            allowed: check.ok,
+            ...(check.reason ? { reason: check.reason } : {}),
+            ...(check.remainingUsd !== undefined ? { remainingUsd: check.remainingUsd } : {}),
         };
     }
     /** Drop entries older than `retentionDays`. Defaults to 30 days. */
@@ -126,6 +145,12 @@ export class CostTracker {
     }
     // ─────── internals ───────
     defaultFile() {
+        // Bridge tests exercise the real budget gate. Keep those charges active
+        // and persistent for the worker lifetime without polluting the developer's
+        // real fleet ledger in ~/.codebuddy.
+        if (process.env.NODE_ENV === 'test') {
+            return path.join(os.tmpdir(), `codebuddy-fleet-cost-ledger-${process.pid}.json`);
+        }
         const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
         return path.join(home, '.codebuddy', 'fleet-cost-ledger.json');
     }
@@ -136,11 +161,33 @@ export class CostTracker {
         }
     }
     async persist(ledger) {
-        const tmp = `${this.file}.tmp.${process.pid}`;
-        await fs.promises.writeFile(tmp, JSON.stringify(ledger, null, 2));
-        await fs.promises.rename(tmp, this.file);
+        await writeJsonAtomic(this.file, ledger, { mode: 0o600 });
     }
 }
+function isNonNegativeFinite(value) {
+    return Number.isFinite(value) && value >= 0;
+}
+function isValidBudget(value) {
+    return isNonNegativeFinite(value.maxDailyUsd) && isNonNegativeFinite(value.maxSagaUsd);
+}
+function isCostEntry(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const entry = value;
+    return (typeof entry.at === 'string' &&
+        Number.isFinite(Date.parse(entry.at)) &&
+        typeof entry.peerId === 'string' &&
+        typeof entry.provider === 'string' &&
+        typeof entry.model === 'string' &&
+        typeof entry.usd === 'number' &&
+        isNonNegativeFinite(entry.usd) &&
+        (entry.sagaId === undefined || typeof entry.sagaId === 'string') &&
+        (entry.runId === undefined || typeof entry.runId === 'string') &&
+        (entry.tokensIn === undefined ||
+            (typeof entry.tokensIn === 'number' && isNonNegativeFinite(entry.tokensIn))) &&
+        (entry.tokensOut === undefined ||
+            (typeof entry.tokensOut === 'number' && isNonNegativeFinite(entry.tokensOut))));
+}
 let cachedTracker = null;
 export function getCostTracker() {
     if (!cachedTracker)

package/dist/fleet/fleet-cost-cap.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Shared fail-closed cost gate for inbound fleet LLM calls.
+ *
+ * Budget check, LLM invocation, and ledger charge are serialised so parallel
+ * peer requests cannot all observe the same stale budget headroom.
+ */
+import type { CodeBuddyClient } from '../codebuddy/client.js';
+import { type CostBudget } from './cost-tracker.js';
+export declare const DEFAULT_FLEET_MAX_TOKENS_PER_CALL = 4096;
+interface FleetUsage {
+    prompt_tokens?: number;
+    completion_tokens?: number;
+}
+interface FleetCallResponse {
+    usage?: FleetUsage;
+}
+export interface CostCappedFleetCall<T extends FleetCallResponse> {
+    peerId: string;
+    provider?: string;
+    model?: string;
+    sagaId: string;
+    runId?: string;
+    requestedMaxTokens: unknown;
+    /** Full request text, including history, used for a conservative input estimate. */
+    inputText: string;
+    client: CodeBuddyClient;
+    invoke: (maxTokens: number) => Promise<T>;
+}
+export declare function resolveFleetMaxTokens(requested: unknown): number;
+export declare function resolveFleetCostBudget(): CostBudget;
+/**
+ * Run an inbound fleet LLM call under the shared token and dollar caps.
+ * A tracker/check/charge failure rejects the RPC instead of bypassing the cap.
+ */
+export declare function executeCostCappedFleetCall<T extends FleetCallResponse>(input: CostCappedFleetCall<T>): Promise<T>;
+export {};

package/dist/fleet/fleet-cost-cap.js

@@ -0,0 +1,175 @@
+/**
+ * Shared fail-closed cost gate for inbound fleet LLM calls.
+ *
+ * Budget check, LLM invocation, and ledger charge are serialised so parallel
+ * peer requests cannot all observe the same stale budget headroom.
+ */
+import { getModelPricing } from '../config/model-pricing.js';
+import { logger } from '../utils/logger.js';
+import { DEFAULT_BUDGET, getCostTracker, } from './cost-tracker.js';
+export const DEFAULT_FLEET_MAX_TOKENS_PER_CALL = 4096;
+let costGateTail = Promise.resolve();
+export function resolveFleetMaxTokens(requested) {
+    const cap = positiveIntegerEnv('CODEBUDDY_FLEET_MAX_TOKENS_PER_CALL', DEFAULT_FLEET_MAX_TOKENS_PER_CALL);
+    if (requested === undefined)
+        return cap;
+    if (typeof requested !== 'number' || !Number.isSafeInteger(requested) || requested <= 0) {
+        throw new Error('INVALID_MAX_TOKENS: maxTokens must be a positive integer');
+    }
+    return Math.min(requested, cap);
+}
+export function resolveFleetCostBudget() {
+    return {
+        maxDailyUsd: nonNegativeNumberEnv('CODEBUDDY_FLEET_MAX_DAILY_USD', DEFAULT_BUDGET.maxDailyUsd),
+        maxSagaUsd: nonNegativeNumberEnv('CODEBUDDY_FLEET_MAX_SAGA_USD', DEFAULT_BUDGET.maxSagaUsd),
+    };
+}
+/**
+ * Run an inbound fleet LLM call under the shared token and dollar caps.
+ * A tracker/check/charge failure rejects the RPC instead of bypassing the cap.
+ */
+export async function executeCostCappedFleetCall(input) {
+    const previous = costGateTail;
+    let releaseGate;
+    costGateTail = new Promise((resolve) => {
+        releaseGate = resolve;
+    });
+    await previous;
+    try {
+        const maxTokens = resolveFleetMaxTokens(input.requestedMaxTokens);
+        const budget = resolveFleetCostBudget();
+        const model = resolveModel(input.model, input.client);
+        const provider = input.provider ?? 'unknown';
+        const estimatedTokensIn = Math.max(1, Buffer.byteLength(input.inputText, 'utf8'));
+        const estimatedUsd = calculateFleetCost(estimatedTokensIn, maxTokens, model, provider);
+        const tracker = getCostTracker();
+        let check;
+        try {
+            check = await tracker.isWithinBudget(estimatedUsd, budget, input.sagaId);
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            logger.warn('[fleet-cost-cap] budget check failed closed', {
+                peer: input.peerId,
+                provider,
+                model,
+                estimatedUsd,
+                reason,
+            });
+            throw new Error(`FLEET_BUDGET_CHECK_FAILED: ${reason}`);
+        }
+        if (!check.allowed) {
+            const reason = check.reason ?? 'fleet cost budget has no remaining headroom';
+            logger.warn('[fleet-cost-cap] request refused', {
+                peer: input.peerId,
+                provider,
+                model,
+                estimatedUsd,
+                remainingUsd: check.remainingUsd ?? 0,
+                reason,
+            });
+            throw new Error(`FLEET_BUDGET_EXCEEDED: ${reason}`);
+        }
+        const response = await input.invoke(maxTokens);
+        const tokensIn = validTokenCount(response.usage?.prompt_tokens) ?? estimatedTokensIn;
+        const tokensOut = validTokenCount(response.usage?.completion_tokens) ?? maxTokens;
+        const usd = calculateFleetCost(tokensIn, tokensOut, model, provider);
+        try {
+            await tracker.charge({
+                at: new Date().toISOString(),
+                peerId: input.peerId,
+                provider,
+                model,
+                usd,
+                sagaId: input.sagaId,
+                ...(input.runId ? { runId: input.runId } : {}),
+                tokensIn,
+                tokensOut,
+            });
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            logger.error('[fleet-cost-cap] charge failed closed', {
+                peer: input.peerId,
+                provider,
+                model,
+                usd,
+                reason,
+            });
+            throw new Error(`FLEET_COST_CHARGE_FAILED: ${reason}`);
+        }
+        const remainingUsd = Math.max(0, (check.remainingUsd ?? Math.min(budget.maxDailyUsd, budget.maxSagaUsd)) +
+            estimatedUsd -
+            usd);
+        logger.info('[fleet-cost-cap] charge recorded', {
+            peer: input.peerId,
+            provider,
+            model,
+            usd,
+            tokensIn,
+            tokensOut,
+            remainingUsd,
+        });
+        return response;
+    }
+    finally {
+        releaseGate?.();
+    }
+}
+function resolveModel(model, client) {
+    if (model)
+        return model;
+    if (typeof client.getCurrentModel === 'function') {
+        const current = client.getCurrentModel();
+        if (typeof current === 'string' && current.length > 0)
+            return current;
+    }
+    return 'unknown';
+}
+function calculateFleetCost(tokensIn, tokensOut, model, provider) {
+    if (isUnmeteredProvider(provider))
+        return 0;
+    const pricing = getModelPricing(model);
+    return ((tokensIn * pricing.inputPerMillion + tokensOut * pricing.outputPerMillion) /
+        1_000_000);
+}
+function isUnmeteredProvider(provider) {
+    return (provider === 'ollama' ||
+        provider === 'lmstudio' ||
+        provider === 'lemonade' ||
+        provider === 'chatgpt-oauth' ||
+        provider === 'gemini-cli' ||
+        provider === 'agy-cli');
+}
+function validTokenCount(value) {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0)
+        return undefined;
+    return value;
+}
+function positiveIntegerEnv(name, fallback) {
+    const raw = process.env[name];
+    if (raw === undefined)
+        return fallback;
+    const parsed = Number(raw);
+    if (raw.trim() !== '' && Number.isSafeInteger(parsed) && parsed > 0)
+        return parsed;
+    logger.warn('[fleet-cost-cap] invalid environment value; using conservative default', {
+        name,
+        fallback,
+    });
+    return fallback;
+}
+function nonNegativeNumberEnv(name, fallback) {
+    const raw = process.env[name];
+    if (raw === undefined)
+        return fallback;
+    const parsed = Number(raw);
+    if (raw.trim() !== '' && Number.isFinite(parsed) && parsed >= 0)
+        return parsed;
+    logger.warn('[fleet-cost-cap] invalid environment value; using conservative default', {
+        name,
+        fallback,
+    });
+    return fallback;
+}
+//# sourceMappingURL=fleet-cost-cap.js.map

package/dist/fleet/fleet-http-surface.d.ts

@@ -0,0 +1,24 @@
+/**
+ * HTTP surface for Fleet peer methods.
+ *
+ * Only two Express routes exist (`GET /api/fleet/status`,
+ * `GET /api/fleet/describe`). Every other `peer.*` method is WebSocket-only
+ * until an explicit product decision adds an HTTP wrapper. This catalog is
+ * the source of truth that tests the existing routes and names the gap.
+ */
+/** Peer methods that have an HTTP wrapper under /api/fleet/. */
+export declare const FLEET_HTTP_PEER_METHODS: readonly ["peer.describe"];
+/** Diagnostic HTTP routes that are not peer-method wrappers. */
+export declare const FLEET_HTTP_DIAGNOSTIC_ROUTES: readonly ["/api/fleet/status"];
+/**
+ * Peer methods registered at boot that have no HTTP wrapper.
+ * Listed so a new method cannot stay silently WS-only.
+ */
+export declare const FLEET_WS_ONLY_PEER_METHODS: readonly ["peer.ping", "peer.echo", "peer.dispatch", "peer.dispatchStatus", "peer.chat", "peer.chat-stream", "peer.chat-session.start", "peer.chat-session.continue", "peer.chat-session.continue-stream", "peer.chat-session.list", "peer.chat-session.goal", "peer.chat-session.end", "peer.tool.invoke", "peer.tool.invoke.stream", "peer.ckg.sync", "peer.mission-exchange.describe", "peer.mission-exchange.offer", "peer.mission-exchange.rank"];
+/**
+ * HTTP paths a client might try for WS-only peer methods. None of these
+ * are served — they exist so tests can probe the gap instead of only
+ * `/chat`, `/tool`, and `/ckg`.
+ */
+export declare function fleetWsOnlyHttpPaths(): string[];
+export declare function fleetHttpDescribeEnvelope(description: Record<string, unknown>): Record<string, unknown>;

package/dist/fleet/fleet-http-surface.js

@@ -0,0 +1,72 @@
+/**
+ * HTTP surface for Fleet peer methods.
+ *
+ * Only two Express routes exist (`GET /api/fleet/status`,
+ * `GET /api/fleet/describe`). Every other `peer.*` method is WebSocket-only
+ * until an explicit product decision adds an HTTP wrapper. This catalog is
+ * the source of truth that tests the existing routes and names the gap.
+ */
+/** Peer methods that have an HTTP wrapper under /api/fleet/. */
+export const FLEET_HTTP_PEER_METHODS = ['peer.describe'];
+/** Diagnostic HTTP routes that are not peer-method wrappers. */
+export const FLEET_HTTP_DIAGNOSTIC_ROUTES = ['/api/fleet/status'];
+/**
+ * Peer methods registered at boot that have no HTTP wrapper.
+ * Listed so a new method cannot stay silently WS-only.
+ */
+export const FLEET_WS_ONLY_PEER_METHODS = [
+    'peer.ping',
+    'peer.echo',
+    'peer.dispatch',
+    'peer.dispatchStatus',
+    'peer.chat',
+    'peer.chat-stream',
+    'peer.chat-session.start',
+    'peer.chat-session.continue',
+    'peer.chat-session.continue-stream',
+    'peer.chat-session.list',
+    'peer.chat-session.goal',
+    'peer.chat-session.end',
+    'peer.tool.invoke',
+    'peer.tool.invoke.stream',
+    'peer.ckg.sync',
+    'peer.mission-exchange.describe',
+    'peer.mission-exchange.offer',
+    'peer.mission-exchange.rank',
+];
+/**
+ * HTTP paths a client might try for WS-only peer methods. None of these
+ * are served — they exist so tests can probe the gap instead of only
+ * `/chat`, `/tool`, and `/ckg`.
+ */
+export function fleetWsOnlyHttpPaths() {
+    const paths = new Set();
+    for (const method of FLEET_WS_ONLY_PEER_METHODS) {
+        const rest = method.slice('peer.'.length);
+        if (rest === 'tool.invoke' || rest === 'tool.invoke.stream') {
+            paths.add('/api/fleet/tool');
+            paths.add(`/api/fleet/${rest.replace(/\./g, '/')}`);
+            continue;
+        }
+        if (rest === 'ckg.sync') {
+            paths.add('/api/fleet/ckg');
+            paths.add('/api/fleet/ckg/sync');
+            continue;
+        }
+        if (rest === 'chat') {
+            paths.add('/api/fleet/chat');
+            continue;
+        }
+        paths.add(`/api/fleet/${rest.replace(/\./g, '/')}`);
+    }
+    return [...paths];
+}
+export function fleetHttpDescribeEnvelope(description) {
+    return {
+        ...description,
+        httpMethods: [...FLEET_HTTP_PEER_METHODS],
+        wsOnlyMethods: [...FLEET_WS_ONLY_PEER_METHODS],
+        wsOnlyHttpPaths: fleetWsOnlyHttpPaths(),
+    };
+}
+//# sourceMappingURL=fleet-http-surface.js.map

package/dist/fleet/fleet-listener.d.ts

@@ -48,7 +48,7 @@
 import { EventEmitter } from 'events';
 import { type ReconnectionConfig } from '../channels/reconnection-manager.js';
 export interface FleetListenerOptions {
-    /** Peer Gateway WS URL, e.g. ws://100.98.18.76:3000/ws */
+    /** Peer Gateway WS URL, e.g. ws://203.0.113.10:3000/ws */
     url: string;
     /** API key with `fleet:listen` scope on the peer. Either this or jwt. */
     apiKey?: string;

package/dist/fleet/fleet-listener.js

@@ -221,6 +221,10 @@ export class FleetListener extends EventEmitter {
                 this.connected = false;
                 this.authenticated = false;
                 this.emit('disconnected');
+                // Responses sent to the old socket can never arrive on a replacement
+                // connection. Reject immediately instead of leaving callers blocked
+                // until their individual request timeouts expire.
+                this.rejectPendingRequests('connection closed');
                 // If we never settled, the connection died before auth — reject.
                 settle(new Error('Connection closed before authentication'));
                 // Phase (d).6 — schedule auto-reconnect only if:

package/dist/fleet/model-capability-heuristics.d.ts

@@ -0,0 +1,31 @@
+/**
+ * "Which LLM is good at what" — shared by the council
+ * (`src/council/council-engine.ts`) and the latency-aware selector
+ * (`model-selector.ts`). Kept in `fleet/` (not in the command) so the selector
+ * doesn't pull the whole council → CodeBuddyClient graph just to classify a
+ * model name, and so the dependency direction stays command → fleet.
+ *
+ * `inferStrengths` is a thin delegate to `getModelStrengths()` in
+ * `config/model-tools.ts` — the single source of truth for per-model
+ * capabilities (it used to be an independent regex layer that contradicted
+ * the config booleans; see that module for the precedence rules).
+ *
+ * @module fleet/model-capability-heuristics
+ */
+import { type TaskType } from '../council/task-types.js';
+import type { ModelStrength } from './types.js';
+export type { KnownTaskType, TaskType } from '../council/task-types.js';
+/** Derive a model's likely strengths from its id (config-backed, see model-tools.ts). */
+export declare function inferStrengths(model: string): ModelStrength[];
+/**
+ * Classify a task from its text. Literary categories are checked first;
+ * generic code/reasoning/language categories remain backward-compatible.
+ *
+ * Accents indicate the LANGUAGE of the task, not its TYPE: a technical task
+ * written in French must route `code` (Architect/Implementer/Reviewer roles),
+ * not `french` — observed live: "…sessions en fichiers JSON… migrer vers
+ * SQLite ?" was classified `french` because 'SQLite' missed the old `\bsql\b`
+ * and none of the technical vocabulary was French. The accent fallback stays,
+ * but LAST, and only after a broadened bilingual technical vocabulary.
+ */
+export declare function inferTaskType(task: string): TaskType;

package/dist/fleet/model-capability-heuristics.js

@@ -0,0 +1,49 @@
+/**
+ * "Which LLM is good at what" — shared by the council
+ * (`src/council/council-engine.ts`) and the latency-aware selector
+ * (`model-selector.ts`). Kept in `fleet/` (not in the command) so the selector
+ * doesn't pull the whole council → CodeBuddyClient graph just to classify a
+ * model name, and so the dependency direction stays command → fleet.
+ *
+ * `inferStrengths` is a thin delegate to `getModelStrengths()` in
+ * `config/model-tools.ts` — the single source of truth for per-model
+ * capabilities (it used to be an independent regex layer that contradicted
+ * the config booleans; see that module for the precedence rules).
+ *
+ * @module fleet/model-capability-heuristics
+ */
+import { getModelStrengths } from '../config/model-tools.js';
+import { inferLiteraryTaskType } from '../council/task-types.js';
+/** Derive a model's likely strengths from its id (config-backed, see model-tools.ts). */
+export function inferStrengths(model) {
+    return getModelStrengths(model);
+}
+/**
+ * Classify a task from its text. Literary categories are checked first;
+ * generic code/reasoning/language categories remain backward-compatible.
+ *
+ * Accents indicate the LANGUAGE of the task, not its TYPE: a technical task
+ * written in French must route `code` (Architect/Implementer/Reviewer roles),
+ * not `french` — observed live: "…sessions en fichiers JSON… migrer vers
+ * SQLite ?" was classified `french` because 'SQLite' missed the old `\bsql\b`
+ * and none of the technical vocabulary was French. The accent fallback stays,
+ * but LAST, and only after a broadened bilingual technical vocabulary.
+ */
+export function inferTaskType(task) {
+    const literary = inferLiteraryTaskType(task);
+    if (literary)
+        return literary;
+    const t = task.toLowerCase();
+    if (/\b(code|coder|fonction|function|bug|refactor|impl[ée]ment\w*|classe|class|api|script|compile|regex|sql\w*|json|ya?ml|cli|node(\.js)?|npm|git|docker|typescript|javascript|python|rust|serveur|server|backend|frontend|endpoint|database|db|bdd|stockage|storage|migr(er|ation)|d[ée]ploi\w*|deploy\w*|fichier\w*)\b/.test(t))
+        return 'code';
+    if (/\bbase de donn[ée]es\b/.test(t))
+        return 'code';
+    if (/\b(prouve|d[ée]montre|raisonn\w*|reason\w*|prove|analyse|strat[ée]gie|pourquoi|math|calcul|optimi\w*)\b/.test(t))
+        return 'reasoning';
+    if (/\b(image|photo|capture|screenshot|diagram|graph)\b/.test(t))
+        return 'vision';
+    if (/[éèàçùêîô]/.test(task) || /\b(fran[çc]ais|france|french)\b/.test(t))
+        return 'french';
+    return 'general';
+}
+//# sourceMappingURL=model-capability-heuristics.js.map

package/dist/fleet/model-inventory.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Fleet model inventory.
+ *
+ * Builds a runtime view of "what models are actually available right now"
+ * across the current machine and the Tailnet peers it can see. The goal is to
+ * keep model discovery out of hardcoded lists and attach enough metadata for
+ * routing/UI decisions: source machine, launch hint, capability profile, and
+ * benchmark score.
+ */
+import type { FleetProvider, ModelStrength } from './types.js';
+export type ModelExecutionLocation = 'local' | 'lan' | 'cloud';
+export interface ModelInventoryEntry {
+    provider: FleetProvider;
+    runtimeProvider: string;
+    model: string;
+    baseURL?: string;
+    machineLabel: string;
+    machineSpec?: {
+        cpu?: string;
+        gpu?: string;
+        ramGb?: number;
+    };
+    executionLocation: ModelExecutionLocation;
+    launchHint: string;
+    contextWindow: number;
+    maxOutputTokens: number;
+    supportsReasoning: boolean;
+    supportsToolCalls: boolean;
+    supportsVision: boolean;
+    strengths: ModelStrength[];
+    benchmarkScore?: number;
+    bestFor: string[];
+    source: 'local-capability' | 'tailnet-peer' | 'catalog';
+}
+export interface ModelInventorySnapshot {
+    updatedAt: string;
+    machineLabel: string;
+    entries: ModelInventoryEntry[];
+}
+export interface BuildModelInventoryOptions {
+    env?: NodeJS.ProcessEnv;
+    includeTailnetPeers?: boolean;
+    forceCapabilityRefresh?: boolean;
+}
+export declare function buildModelInventory(options?: BuildModelInventoryOptions): Promise<ModelInventorySnapshot>;
+export declare function summarizeInventoryByProvider(snapshot: ModelInventorySnapshot): Record<string, ModelInventoryEntry[]>;