@phuetz/code-buddy 1.6.1 → 2.1.0

package/dist/fleet/consolidation/thalamus.js

@@ -0,0 +1,151 @@
+/**
+ * Le thalamus cognitif — porte d'attention sur les rapports d'une flotte.
+ *
+ * Transposition de `buddy-sense/src/bus.rs` à l'étage cognitif. Trois principes repris tels
+ * quels, un ajouté.
+ *
+ * REPRIS — un seuil d'escalade au-delà duquel rien n'est retenu ni fusionné ; un lot d'attention
+ * BORNÉ (on ne remonte pas cinquante choses, on en remonte quelques-unes) ; les plus saillants
+ * servis d'abord, l'ordre d'arrivée préservé à saillance égale.
+ *
+ * AJOUTÉ — dans un cerveau, deux capteurs qui signalent la même chose renforcent le signal ; ils
+ * ne l'annulent pas. C'est aussi ce que fait le graphe de connaissance collectif : « un fait sur
+ * lequel des agents indépendants s'accordent gagne en confiance ». Ici, un défaut trouvé par
+ * DEUX ANGLES DIFFÉRENTS est donc plus saillant, pas moins — la coalescence fusionne la
+ * répétition et ÉLÈVE le survivant.
+ *
+ * La corroboration ne compte qu'entre lignées de modèles distinctes : deux modèles du même
+ * entraîneur se trompent souvent ensemble, les compter deux fois fabriquerait de la fausse
+ * confiance.
+ *
+ * @module fleet/consolidation/thalamus
+ */
+/** Au-delà, un constat remonte immédiatement et n'est jamais fusionné ni retenu. */
+export const SEUIL_ESCALADE = 128;
+/** Combien de constats non escaladés remontent au plus dans un digest. */
+export const LOT_ATTENTION = 12;
+/** Saillance de base, par ce que le défaut COÛTE. */
+const POIDS = {
+    'regression-securite': 150,
+    'corruption-donnees': 140,
+    'perte-silencieuse': 110,
+    'promesse-non-tenue': 70,
+    plantage: 60,
+    friction: 35,
+    cosmetique: 10,
+};
+/** Ce qu'ajoute chaque confirmation indépendante. Plafonné : trois avis ne valent pas dix. */
+const BONUS_CORROBORATION = 25;
+const MAX_CORROBORATION = 2;
+/**
+ * Un constat SUSPECTÉ ne peut pas escalader, quelle que soit sa gravité annoncée.
+ *
+ * Sans cette règle, une flotte de treize moteurs produit treize alarmes : il suffit qu'un
+ * modèle écrive « faille critique possible » pour réveiller quelqu'un. La gravité annoncée
+ * n'est pas une mesure ; la reproduction en est une.
+ */
+const PLAFOND_NON_REPRODUIT = SEUIL_ESCALADE - 1;
+/**
+ * Deux constats décrivent-ils le même défaut ?
+ *
+ * Une clé exacte ne suffit pas : deux moteurs qui trouvent la MÊME chose la formulent
+ * différemment. Mesuré sur la moisson réelle du 25/08 — « le ledger jsonl est écrit par deux
+ * processus sans atomicité garantie » et « le ledger jsonl est écrit sans atomicité par le
+ * moteur rust » sont le même défaut, et une clé par mots triés les séparait. Zéro fusion sur
+ * douze constats dont quatre étaient des doublons : la corroboration ne se déclenchait jamais,
+ * donc la partie la plus utile du thalamus était morte.
+ *
+ * On compare donc par recouvrement de vocabulaire (Jaccard), avec un seuil, et on exige que le
+ * lieu concorde quand les deux le renseignent — sinon deux défauts voisins dans des fichiers
+ * différents fusionneraient à tort.
+ */
+function motsUtiles(texte) {
+    return new Set(texte
+        .toLowerCase()
+        .normalize('NFD')
+        .replace(/[̀-ͯ]/g, '')
+        .replace(/[^a-z0-9 ]/g, ' ')
+        .split(/\s+/)
+        .filter((m) => m.length > 3));
+}
+/** Au-dessous, ce sont deux défauts distincts. Réglé sur la moisson réelle. */
+const SEUIL_SIMILARITE = 0.45;
+function memeDefaut(a, b) {
+    const la = (a.ou ?? '').trim().toLowerCase();
+    const lb = (b.ou ?? '').trim().toLowerCase();
+    // Deux lieux connus et différents : jamais le même défaut, quelle que soit la formulation.
+    if (la && lb && la !== lb)
+        return false;
+    const ma = motsUtiles(a.resume);
+    const mb = motsUtiles(b.resume);
+    if (ma.size === 0 || mb.size === 0)
+        return false;
+    let communs = 0;
+    for (const m of ma)
+        if (mb.has(m))
+            communs += 1;
+    const union = ma.size + mb.size - communs;
+    return union > 0 && communs / union >= SEUIL_SIMILARITE;
+}
+function saillance(c, corroborations) {
+    const base = POIDS[c.consequence];
+    const bonus = Math.min(corroborations, MAX_CORROBORATION) * BONUS_CORROBORATION;
+    const brute = base + bonus;
+    return c.reproduit ? brute : Math.min(brute, PLAFOND_NON_REPRODUIT);
+}
+/**
+ * Passe une moisson de constats par la porte d'attention.
+ *
+ * Rend ce qui doit interrompre maintenant (`escalades`), ce qui mérite d'être lu ensuite
+ * (`admis`, borné au lot d'attention), et de quoi savoir ce qu'on n'a pas lu (`coalesces`,
+ * `par_angle`, `par_consequence`) — car un digest qui cache ce qu'il a écarté ment par omission.
+ */
+export function consolider(constats) {
+    // Regroupement par similarité : chaque constat rejoint le premier groupe dont il partage
+    // le défaut. L'ordre d'arrivée est conservé, ce qui garde le tri stable plus bas.
+    const groupes = [];
+    for (const c of constats) {
+        const g = groupes.find((groupe) => groupe.some((autre) => memeDefaut(autre, c)));
+        if (g)
+            g.push(c);
+        else
+            groupes.push([c]);
+    }
+    const admis = [];
+    let coalesces = 0;
+    for (const groupe of groupes) {
+        coalesces += groupe.length - 1;
+        // Le représentant est celui qui apporte la meilleure preuve : reproduit d'abord,
+        // puis conséquence la plus lourde. Fusionner en gardant le plus vague perdrait la preuve.
+        const tri = [...groupe].sort((a, b) => Number(b.reproduit) - Number(a.reproduit) || POIDS[b.consequence] - POIDS[a.consequence]);
+        const chef = tri[0];
+        const lignees = new Set(groupe.map((c) => c.lignee));
+        const corroborations = Math.max(0, lignees.size - 1);
+        const s = saillance(chef, corroborations);
+        admis.push({
+            ...chef,
+            saillance: s,
+            corrobore_par: groupe.filter((c) => c !== chef).map((c) => c.mission),
+            escalade: s >= SEUIL_ESCALADE,
+        });
+    }
+    // Les plus saillants d'abord ; à saillance égale, l'ordre d'arrivée est conservé —
+    // `sort` est stable, et `admis` suit l'ordre des groupes, lui-même l'ordre d'insertion.
+    admis.sort((a, b) => b.saillance - a.saillance);
+    const escalades = admis.filter((c) => c.escalade);
+    const reste = admis.filter((c) => !c.escalade).slice(0, LOT_ATTENTION);
+    const compter = (cle) => {
+        const m = {};
+        for (const c of admis)
+            m[cle(c)] = (m[cle(c)] ?? 0) + 1;
+        return m;
+    };
+    return {
+        escalades,
+        admis: reste,
+        coalesces,
+        par_angle: compter((c) => c.angle),
+        par_consequence: compter((c) => c.consequence),
+    };
+}
+//# sourceMappingURL=thalamus.js.map

package/dist/fleet/consolidation/types.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Le thalamus cognitif — types.
+ *
+ * `buddy-sense/src/bus.rs` fait cela pour les sens : des organes émettent en parallèle sur des
+ * canaux bornés, le thalamus COALESCE ce qui est répétitif et peu saillant, laisse passer sans
+ * jamais le retenir ce qui dépasse `ESCALATE_SALIENCE`, sert les plus saillants d'abord dans
+ * chaque lot d'attention, et diffuse le reste au « global workspace ».
+ *
+ * Le même problème existe un étage plus haut. Quand douze moteurs explorent un dépôt en
+ * parallèle, ils produisent douze rapports qu'UNE SEULE instance lit, séquentiellement. Le
+ * goulot se déplace de la découverte vers la consolidation — mesuré le 25/08/2026 : 14 défauts
+ * trouvés par 12 lignées de modèles, tous lus avec la même attention alors qu'UN SEUL méritait
+ * une interruption (un test qui restait vert quand on supprimait l'application de la posture de
+ * permission).
+ *
+ * Dans un cerveau, personne ne lit tous les rapports : les signaux se disputent l'accès au
+ * workspace, et la saillance tranche.
+ *
+ * @module fleet/consolidation/types
+ */
+/** Ce qu'une mission d'exploration rapporte : un constat, pas une opinion. */
+export interface Constat {
+    /** Identifiant de la mission qui l'a produit (`CB4`, `V1`…). */
+    readonly mission: string;
+    /** L'angle exploré — l'équivalent de la modalité sensorielle. */
+    readonly angle: string;
+    /** Le modèle qui a produit le constat. Deux constats de la MÊME lignée ne se corroborent pas. */
+    readonly lignee: string;
+    /** Une phrase : ce qui ne va pas. */
+    readonly resume: string;
+    /** Où, au format `fichier:ligne` quand c'est connu. */
+    readonly ou?: string;
+    /** La conséquence, qui commande la saillance de base. */
+    readonly consequence: Consequence;
+    /**
+     * Reproduit, ou seulement suspecté. Un constat non reproduit ne peut PAS escalader :
+     * c'est la règle qui empêche une flotte de treize moteurs de produire treize alarmes.
+     */
+    readonly reproduit: boolean;
+    /** La commande ou le test qui le démontre. Vide si `reproduit` est faux. */
+    readonly preuve?: string;
+}
+/**
+ * Ce que le défaut coûte, non ce qu'il coûte à réparer.
+ *
+ * L'ordre est délibéré : une donnée fausse est pire qu'un plantage, parce qu'un plantage se
+ * voit. C'est la hiérarchie déjà retenue pour le pipeline média (« une vidéo fausse publiée >
+ * une dépense inutile > un plantage »).
+ */
+export type Consequence = 'regression-securite' | 'corruption-donnees' | 'perte-silencieuse' | 'promesse-non-tenue' | 'plantage' | 'friction' | 'cosmetique';
+/** Un constat après passage du thalamus : saillance calculée, doublons fusionnés. */
+export interface ConstatAdmis extends Constat {
+    readonly saillance: number;
+    /** Les autres missions qui ont trouvé la même chose, d'une lignée DIFFÉRENTE. */
+    readonly corrobore_par: readonly string[];
+    /** Vrai si la saillance dépasse le seuil : remonte immédiatement, n'attend pas le digest. */
+    readonly escalade: boolean;
+}
+/** Ce que le thalamus rend : ce qui remonte maintenant, et ce qui attend. */
+export interface Digest {
+    readonly escalades: readonly ConstatAdmis[];
+    readonly admis: readonly ConstatAdmis[];
+    readonly coalesces: number;
+    readonly par_angle: Readonly<Record<string, number>>;
+    readonly par_consequence: Readonly<Record<string, number>>;
+}

package/dist/fleet/consolidation/types.js

@@ -0,0 +1,22 @@
+/**
+ * Le thalamus cognitif — types.
+ *
+ * `buddy-sense/src/bus.rs` fait cela pour les sens : des organes émettent en parallèle sur des
+ * canaux bornés, le thalamus COALESCE ce qui est répétitif et peu saillant, laisse passer sans
+ * jamais le retenir ce qui dépasse `ESCALATE_SALIENCE`, sert les plus saillants d'abord dans
+ * chaque lot d'attention, et diffuse le reste au « global workspace ».
+ *
+ * Le même problème existe un étage plus haut. Quand douze moteurs explorent un dépôt en
+ * parallèle, ils produisent douze rapports qu'UNE SEULE instance lit, séquentiellement. Le
+ * goulot se déplace de la découverte vers la consolidation — mesuré le 25/08/2026 : 14 défauts
+ * trouvés par 12 lignées de modèles, tous lus avec la même attention alors qu'UN SEUL méritait
+ * une interruption (un test qui restait vert quand on supprimait l'application de la posture de
+ * permission).
+ *
+ * Dans un cerveau, personne ne lit tous les rapports : les signaux se disputent l'accès au
+ * workspace, et la saillance tranche.
+ *
+ * @module fleet/consolidation/types
+ */
+export {};
+//# sourceMappingURL=types.js.map

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

@@ -53,6 +53,12 @@ export interface BudgetCheck {
     /** Remaining headroom in USD if ok=true. */
     remainingUsd?: number;
 }
+export interface BudgetDecision {
+    allowed: boolean;
+    reason?: string;
+    /** Remaining headroom across the applicable daily and saga caps. */
+    remainingUsd?: number;
+}
 export declare class CostTracker {
     private readonly file;
     private cached;
@@ -70,6 +76,11 @@ export declare class CostTracker {
      * either cap. Pure function — does NOT charge.
      */
     canSpend(estimatedUsd: number, sagaId: string | undefined, budget?: CostBudget): Promise<BudgetCheck>;
+    /**
+     * Incoming-call budget API. Keeps the historical `canSpend` method intact
+     * while exposing the allow/deny vocabulary used by fleet bridges.
+     */
+    isWithinBudget(estimatedUsd: number, budget?: CostBudget, sagaId?: string): Promise<BudgetDecision>;
     /** Drop entries older than `retentionDays`. Defaults to 30 days. */
     vacuum(retentionDays?: number): Promise<number>;
     /** Test-only — resets cached + on-disk ledger. */

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>;