agentic-qe 3.15.15 → 3.15.17

package/dist/routing/routing-feedback.js

@@ -10,6 +10,7 @@ import { QE_AGENT_REGISTRY } from './qe-agent-registry.js';
 import { getUnifiedMemory } from '../kernel/unified-memory.js';
 import { safeJsonParse } from '../shared/safe-json.js';
 import { toErrorMessage } from '../shared/error-utils.js';
+import { isBusyError } from '../learning/dream/dream-lock-retry.js';
 import { EMACalibrator } from './calibration/index.js';
 import { AutoEscalationTracker } from './escalation/index.js';
 import { ensureRoutingOutcomesAdr095Columns } from './routing-outcomes-migration.js';
@@ -141,10 +142,11 @@ export class RoutingFeedbackCollector {
      * Persist a single outcome to the database
      */
     persistOutcome(outcome) {
-        if (!this.db)
-            return;
-        try {
-            const database = this.db.getDatabase();
+        const modelTier = this.inferTier(outcome.usedAgent);
+        const advisorJson = outcome.advisorConsultation
+            ? JSON.stringify(outcome.advisorConsultation)
+            : null;
+        this.persistInBackground('outcome', (database) => {
             // Ensure schema columns exist for databases created before ADR-092
             // and ADR-095. Runs once per process via the flag; new databases have
             // columns from unified-memory-schemas.ts CREATE TABLE.
@@ -156,17 +158,17 @@ export class RoutingFeedbackCollector {
                     try {
                         database.prepare(col).run();
                     }
-                    catch { /* column already exists */ }
+                    catch (error) {
+                        // Column already exists. A locked database is retried instead (#1274).
+                        if (isBusyError(error))
+                            throw error;
+                    }
                 }
                 // ADR-095: routing exploration columns via shared helper so all
                 // writer paths agree on the column set.
                 ensureRoutingOutcomesAdr095Columns(database);
                 RoutingFeedbackCollector.schemaMigrated = true;
             }
-            const modelTier = this.inferTier(outcome.usedAgent);
-            const advisorJson = outcome.advisorConsultation
-                ? JSON.stringify(outcome.advisorConsultation)
-                : null;
             database.prepare(`
         INSERT OR REPLACE INTO routing_outcomes (
           id, task_json, decision_json, used_agent,
@@ -174,13 +176,30 @@ export class RoutingFeedbackCollector {
           duration_ms, error, model_tier, advisor_consultation_json
         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       `).run(outcome.id, JSON.stringify(outcome.task), JSON.stringify(outcome.decision), outcome.usedAgent, outcome.followedRecommendation ? 1 : 0, outcome.outcome.success ? 1 : 0, outcome.outcome.qualityScore, outcome.outcome.durationMs, outcome.outcome.error || null, modelTier, advisorJson);
+        }, () => {
             this.persistCount++;
             if (this.persistCount % RoutingFeedbackCollector.RETENTION_CLEANUP_INTERVAL === 0) {
-                this.enforceRetention(database);
+                this.enforceRetention();
             }
+        });
+    }
+    /**
+     * Queue a write on the shared connection without blocking the caller
+     * (#1274). recordOutcome runs after every routed task, so a locked
+     * memory.db must not freeze the MCP server's event loop. Writes keep their
+     * call order and the connection's full busy_timeout budget; with the
+     * database unlocked and nothing queued the write runs at once, as before.
+     */
+    persistInBackground(what, write, onPersisted) {
+        if (!this.db)
+            return;
+        const warn = (error) => console.warn(`[RoutingFeedbackCollector] Failed to persist ${what}:`, toErrorMessage(error));
+        try {
+            const database = this.db.getDatabase();
+            this.db.writeWhenUnlocked(() => write(database)).then(onPersisted, warn);
         }
         catch (error) {
-            console.warn('[RoutingFeedbackCollector] Failed to persist outcome:', toErrorMessage(error));
+            warn(error);
         }
     }
     /**
@@ -228,18 +247,15 @@ export class RoutingFeedbackCollector {
     /**
      * Delete oldest rows beyond retention limit
      */
-    enforceRetention(database) {
-        try {
-            const maxRows = this.maxOutcomes * 2;
+    enforceRetention() {
+        const maxRows = this.maxOutcomes * 2;
+        this.persistInBackground('retention cleanup', (database) => {
             database.prepare(`
         DELETE FROM routing_outcomes WHERE id NOT IN (
           SELECT id FROM routing_outcomes ORDER BY created_at DESC LIMIT ?
         )
       `).run(maxRows);
-        }
-        catch (error) {
-            console.warn('[RoutingFeedbackCollector] Retention cleanup failed:', toErrorMessage(error));
-        }
+        });
     }
     /**
      * Load persisted EMA calibrator state from the database
@@ -268,14 +284,17 @@ export class RoutingFeedbackCollector {
     persistCalibratorState() {
         if (!this.db || !this.calibrator)
             return;
+        let serialized;
         try {
-            const database = this.db.getDatabase();
-            const serialized = JSON.stringify(this.calibrator.serialize());
-            database.prepare(`INSERT OR REPLACE INTO kv_store (key, value, updated_at) VALUES (?, ?, datetime('now'))`).run('routing:ema_calibrator_state', serialized);
+            serialized = JSON.stringify(this.calibrator.serialize());
         }
         catch (error) {
             console.warn('[RoutingFeedbackCollector] Failed to persist calibrator state:', toErrorMessage(error));
+            return;
         }
+        this.persistInBackground('calibrator state', (database) => {
+            database.prepare(`INSERT OR REPLACE INTO kv_store (key, value, updated_at) VALUES (?, ?, datetime('now'))`).run('routing:ema_calibrator_state', serialized);
+        });
     }
     /**
      * Load persisted economic routing state from the database
@@ -304,14 +323,17 @@ export class RoutingFeedbackCollector {
     persistEconomicState() {
         if (!this.db || !this.economicModel)
             return;
+        let serialized;
         try {
-            const database = this.db.getDatabase();
-            const serialized = JSON.stringify(this.economicModel.serializeEstimates());
-            database.prepare(`INSERT OR REPLACE INTO kv_store (key, value, updated_at) VALUES (?, ?, datetime('now'))`).run('routing:economic_quality_estimates', serialized);
+            serialized = JSON.stringify(this.economicModel.serializeEstimates());
         }
         catch (error) {
             console.warn('[RoutingFeedbackCollector] Failed to persist economic state:', toErrorMessage(error));
+            return;
         }
+        this.persistInBackground('economic state', (database) => {
+            database.prepare(`INSERT OR REPLACE INTO kv_store (key, value, updated_at) VALUES (?, ?, datetime('now'))`).run('routing:economic_quality_estimates', serialized);
+        });
     }
     /**
      * Connect to router for automatic performance updates

package/dist/routing/routing-outcomes-migration.js

@@ -13,6 +13,7 @@
  * Callers run this before INSERTing rows that reference the new columns.
  * A process-local flag prevents repeated migration attempts.
  */
+import { isBusyError } from '../learning/dream/dream-lock-retry.js';
 let migrated = false;
 /**
  * Add the ADR-095 columns to routing_outcomes if they don't already exist.
@@ -34,11 +35,15 @@ export function ensureRoutingOutcomesAdr095Columns(db) {
         try {
             db.prepare(stmt).run();
         }
-        catch {
+        catch (error) {
             // Column already exists, or table doesn't exist yet. Both are
             // acceptable — ALTER is additive, and a missing table means the
             // unified schema hasn't been applied yet (caller's INSERT will fail
-            // separately with a clearer error).
+            // separately with a clearer error). A locked database is not (#1274):
+            // rethrow so a retrying caller migrates on its next attempt instead of
+            // marking the migration done without the columns.
+            if (isBusyError(error))
+                throw error;
         }
     }
     // Index on exploration for the bucket-comparison queries used by

package/dist/shared/embeddings/index.d.ts

@@ -28,8 +28,8 @@
  */
 export { NomicEmbedder, createNomicEmbedder } from './nomic-embedder';
 export type { NomicEmbedderConfig } from './nomic-embedder';
-export { OllamaClient } from './ollama-client';
+export { OllamaClient, isConfiguredOllamaModel } from './ollama-client';
 export { EmbeddingCache } from './embedding-cache';
-export type { CodeChunk, EmbeddingResult, EmbeddingBatchResult, OllamaEmbeddingRequest, OllamaEmbeddingResponse, OllamaHealthResponse, CacheStats, EmbeddingCacheEntry, BatchProgress, ProgressCallback, IEmbeddingProvider, } from './types';
+export type { CodeChunk, EmbeddingResult, EmbeddingBatchResult, OllamaEmbeddingRequest, OllamaEmbeddingResponse, OllamaHealthResponse, OllamaModelStatus, CacheStats, EmbeddingCacheEntry, BatchProgress, ProgressCallback, IEmbeddingProvider, } from './types';
 export { EMBEDDING_CONFIG } from './types';
 //# sourceMappingURL=index.d.ts.map

package/dist/shared/embeddings/index.js

@@ -27,7 +27,7 @@
  * ```
  */
 export { NomicEmbedder, createNomicEmbedder } from './nomic-embedder.js';
-export { OllamaClient } from './ollama-client.js';
+export { OllamaClient, isConfiguredOllamaModel } from './ollama-client.js';
 export { EmbeddingCache } from './embedding-cache.js';
 export { EMBEDDING_CONFIG } from './types.js';
 //# sourceMappingURL=index.js.map

package/dist/shared/embeddings/nomic-embedder.d.ts

@@ -11,13 +11,15 @@
  * - Error handling and retries
  */
 import { EmbeddingCache } from './embedding-cache';
-import { CodeChunk, EmbeddingBatchResult, ProgressCallback, CacheStats, IEmbeddingProvider } from './types';
+import { CodeChunk, EmbeddingBatchResult, ProgressCallback, CacheStats, IEmbeddingProvider, OllamaModelStatus } from './types';
 /**
  * Configuration for NomicEmbedder
  */
 export interface NomicEmbedderConfig {
     /** Ollama base URL (default: http://localhost:11434) */
     ollamaBaseUrl?: string;
+    /** #1229: installed Ollama model to use (default: AQE_OLLAMA_EMBEDDING_MODEL, else found by name) */
+    ollamaModel?: string;
     /** Batch size for processing (default: 100) */
     batchSize?: number;
     /** Maximum cache size (default: 10000) */
@@ -100,6 +102,10 @@ export declare class NomicEmbedder implements IEmbeddingProvider {
      * Verify Ollama connection and model availability
      */
     healthCheck(): Promise<boolean>;
+    /** #1229: the installed Ollama model, or why there is none. */
+    checkModel(): Promise<OllamaModelStatus>;
+    /** Identifies the embedding space of this embedder's vectors (ADR-097). */
+    getModelId(): string;
     /**
      * Get Ollama server information
      */
@@ -112,7 +118,7 @@ export declare class NomicEmbedder implements IEmbeddingProvider {
      * Get configuration info
      */
     getConfig(): {
-        model: "all-MiniLM-L6-v2";
+        model: string;
         dimensions: 384;
         contextWindow: 8192;
         batchSize: number;

package/dist/shared/embeddings/nomic-embedder.js

@@ -17,7 +17,7 @@ import { EMBEDDING_CONFIG, } from './types.js';
 const PSEUDO_EMBEDDING_MODEL = 'pseudo-embedding';
 // Unversioned real-model entries may predate fallback provenance separation.
 const VERIFIED_MODEL_CACHE_NAMESPACE = 'verified-backend-v1';
-const cacheNamespace = (model) => model === EMBEDDING_CONFIG.MODEL ? VERIFIED_MODEL_CACHE_NAMESPACE : undefined;
+const cacheNamespace = (model) => model === PSEUDO_EMBEDDING_MODEL ? undefined : VERIFIED_MODEL_CACHE_NAMESPACE;
 /**
  * Nomic Embedder for generating code embeddings via Ollama
  */
@@ -45,7 +45,7 @@ export class NomicEmbedder {
      * ```
      */
     constructor(config = {}) {
-        this.client = new OllamaClient(config.ollamaBaseUrl);
+        this.client = new OllamaClient(config.ollamaBaseUrl, undefined, undefined, undefined, config.ollamaModel);
         this.cache = config.cache ?? new EmbeddingCache(config.maxCacheSize);
         this.batchSize = config.batchSize ?? EMBEDDING_CONFIG.BATCH_SIZE;
         this.enableFallback = config.enableFallback ?? true;
@@ -56,9 +56,9 @@ export class NomicEmbedder {
     async embed(text) {
         // Prefer genuine cached vectors, then select the active backend before a
         // single counted lookup so alternate namespaces do not inflate misses.
-        let model = this.cache.has(text, EMBEDDING_CONFIG.MODEL, VERIFIED_MODEL_CACHE_NAMESPACE) ||
+        let model = this.cache.has(text, this.getModelId(), VERIFIED_MODEL_CACHE_NAMESPACE) ||
             await this.isOllamaAvailable() || !this.enableFallback
-            ? EMBEDDING_CONFIG.MODEL : PSEUDO_EMBEDDING_MODEL;
+            ? this.getModelId() : PSEUDO_EMBEDDING_MODEL;
         const cached = this.cache.get(text, model, cacheNamespace(model));
         if (cached) {
             return cached;
@@ -66,7 +66,7 @@ export class NomicEmbedder {
         // Try Ollama first, fall back to pseudo-embedding if unavailable
         let embedding;
         if (await this.isOllamaAvailable()) {
-            model = EMBEDDING_CONFIG.MODEL;
+            model = this.getModelId();
             embedding = await this.client.generateEmbedding(text);
         }
         else if (this.enableFallback) {
@@ -75,7 +75,7 @@ export class NomicEmbedder {
         }
         else {
             throw new Error(`Ollama is not available and fallback is disabled. ` +
-                `Please run: ollama pull ${EMBEDDING_CONFIG.MODEL}`);
+                `Please run: ollama pull ${EMBEDDING_CONFIG.OLLAMA_PULL_NAME}`);
         }
         // Cache result
         this.cache.set(text, model, embedding, cacheNamespace(model));
@@ -137,7 +137,7 @@ export class NomicEmbedder {
         }
         else if (!this.enableFallback) {
             throw new Error(`Ollama is not available and fallback is disabled. ` +
-                `Please run: ollama pull ${EMBEDDING_CONFIG.MODEL}`);
+                `Please run: ollama pull ${EMBEDDING_CONFIG.OLLAMA_PULL_NAME}`);
         }
         // Process in batches
         for (let i = 0; i < chunks.length; i += this.batchSize) {
@@ -191,8 +191,8 @@ export class NomicEmbedder {
             const formattedText = this.formatForEmbedding(chunk);
             const chunkStartTime = Date.now();
             // Check cache
-            const cachedModel = useOllama || this.cache.has(formattedText, EMBEDDING_CONFIG.MODEL, VERIFIED_MODEL_CACHE_NAMESPACE)
-                ? EMBEDDING_CONFIG.MODEL : PSEUDO_EMBEDDING_MODEL;
+            const cachedModel = useOllama || this.cache.has(formattedText, this.getModelId(), VERIFIED_MODEL_CACHE_NAMESPACE)
+                ? this.getModelId() : PSEUDO_EMBEDDING_MODEL;
             const cachedEmbedding = this.cache.get(formattedText, cachedModel, cacheNamespace(cachedModel));
             if (cachedEmbedding) {
                 return {
@@ -213,7 +213,7 @@ export class NomicEmbedder {
                     embedding = this.generatePseudoEmbedding(formattedText);
                 }
                 // Cache the result
-                const model = useOllama ? EMBEDDING_CONFIG.MODEL : PSEUDO_EMBEDDING_MODEL;
+                const model = useOllama ? this.getModelId() : PSEUDO_EMBEDDING_MODEL;
                 this.cache.set(formattedText, model, embedding, cacheNamespace(model));
                 return {
                     chunkId: chunk.id,
@@ -300,6 +300,14 @@ export class NomicEmbedder {
     async healthCheck() {
         return await this.client.healthCheck();
     }
+    /** #1229: the installed Ollama model, or why there is none. */
+    async checkModel() {
+        return await this.client.checkModel();
+    }
+    /** Identifies the embedding space of this embedder's vectors (ADR-097). */
+    getModelId() {
+        return this.client.getModelId();
+    }
     /**
      * Get Ollama server information
      */
@@ -317,7 +325,7 @@ export class NomicEmbedder {
      */
     getConfig() {
         return {
-            model: EMBEDDING_CONFIG.MODEL,
+            model: this.getModelId(),
             dimensions: EMBEDDING_CONFIG.DIMENSIONS,
             contextWindow: EMBEDDING_CONFIG.CONTEXT_WINDOW,
             batchSize: this.batchSize,

package/dist/shared/embeddings/ollama-client.d.ts

@@ -2,7 +2,16 @@
  * Agentic QE v3 - Ollama API Client
  * Client for Ollama embeddings API with retry logic
  */
-import { OllamaHealthResponse } from './types';
+import { OllamaHealthResponse, OllamaModelStatus } from './types';
+/**
+ * #1229: whether an installed Ollama model is EMBEDDING_CONFIG.MODEL. Accepts
+ * the exact name with any namespace and tag (`Xenova/all-MiniLM-L6-v2:latest`)
+ * and Ollama's library name `all-minilm` with an L6 tag (`all-minilm:22m`).
+ * Other models are rejected, even 384-dimensional ones such as
+ * `all-minilm:33m` (all-MiniLM-L12-v2): their vectors are in another
+ * embedding space (ADR-097).
+ */
+export declare function isConfiguredOllamaModel(listed: string): boolean;
 /**
  * Client for Ollama API
  */
@@ -11,11 +20,28 @@ export declare class OllamaClient {
     private maxRetries;
     private retryDelayMs;
     private timeoutMs;
-    constructor(baseUrl?: string, maxRetries?: number, retryDelayMs?: number, timeoutMs?: number);
+    /** #1229: the Ollama model named by the user (AQE_OLLAMA_EMBEDDING_MODEL), if any. */
+    private readonly requestedModel?;
+    /** The installed Ollama model found by the last successful check. */
+    private installedModel;
+    constructor(baseUrl?: string, maxRetries?: number, retryDelayMs?: number, timeoutMs?: number, ollamaModel?: string | undefined);
+    /** The Ollama server this client talks to. */
+    getBaseUrl(): string;
+    /**
+     * Identifies the embedding space of this client's vectors. A model named by
+     * AQE_OLLAMA_EMBEDDING_MODEL that is not EMBEDDING_CONFIG.MODEL gets its own
+     * id, so its vectors are never compared with stored MiniLM vectors (ADR-097).
+     */
+    getModelId(): string;
     /**
      * Check if Ollama is running and the configured embedding model is available
      */
     healthCheck(): Promise<boolean>;
+    /**
+     * #1229: find the installed Ollama model to embed with, or say why there is
+     * none (Ollama unreachable, or reachable without the model).
+     */
+    checkModel(): Promise<OllamaModelStatus>;
     /**
      * Generate embedding for a single text prompt
      */

package/dist/shared/embeddings/ollama-client.js

@@ -5,6 +5,30 @@
 import { toError } from '../error-utils.js';
 import { EMBEDDING_CONFIG, } from './types.js';
 import { resolveOllamaBaseUrl } from '../llm/ollama-url.js';
+/** Tags of Ollama's `all-minilm` that are all-MiniLM-L6-v2 (33m / l12-v2 is the L12 model). */
+const ALL_MINILM_L6_TAG = /^(latest|22m(-.*)?|l6-v2(-.*)?)?$/i;
+/** Splits `namespace/name:tag` into the name part and the tag ('' when untagged). */
+function splitTag(listed) {
+    const colon = listed.lastIndexOf(':');
+    return colon > listed.lastIndexOf('/')
+        ? { base: listed.slice(0, colon), tag: listed.slice(colon + 1) }
+        : { base: listed, tag: '' };
+}
+/**
+ * #1229: whether an installed Ollama model is EMBEDDING_CONFIG.MODEL. Accepts
+ * the exact name with any namespace and tag (`Xenova/all-MiniLM-L6-v2:latest`)
+ * and Ollama's library name `all-minilm` with an L6 tag (`all-minilm:22m`).
+ * Other models are rejected, even 384-dimensional ones such as
+ * `all-minilm:33m` (all-MiniLM-L12-v2): their vectors are in another
+ * embedding space (ADR-097).
+ */
+export function isConfiguredOllamaModel(listed) {
+    const { base, tag } = splitTag(listed);
+    const name = base.slice(base.lastIndexOf('/') + 1).toLowerCase();
+    if (name === EMBEDDING_CONFIG.MODEL.toLowerCase())
+        return true;
+    return base.toLowerCase() === 'all-minilm' && ALL_MINILM_L6_TAG.test(tag);
+}
 /**
  * Client for Ollama API
  */
@@ -13,46 +37,85 @@ export class OllamaClient {
     maxRetries;
     retryDelayMs;
     timeoutMs;
-    constructor(baseUrl = resolveOllamaBaseUrl(EMBEDDING_CONFIG.DEFAULT_OLLAMA_URL), maxRetries = EMBEDDING_CONFIG.MAX_RETRIES, retryDelayMs = EMBEDDING_CONFIG.RETRY_DELAY_MS, timeoutMs = EMBEDDING_CONFIG.TIMEOUT_MS) {
+    /** #1229: the Ollama model named by the user (AQE_OLLAMA_EMBEDDING_MODEL), if any. */
+    requestedModel;
+    /** The installed Ollama model found by the last successful check. */
+    installedModel = null;
+    constructor(baseUrl = resolveOllamaBaseUrl(EMBEDDING_CONFIG.DEFAULT_OLLAMA_URL), maxRetries = EMBEDDING_CONFIG.MAX_RETRIES, retryDelayMs = EMBEDDING_CONFIG.RETRY_DELAY_MS, timeoutMs = EMBEDDING_CONFIG.TIMEOUT_MS, ollamaModel = process.env[EMBEDDING_CONFIG.OLLAMA_MODEL_ENV]) {
         this.baseUrl = baseUrl.replace(/\/$/, ''); // Remove trailing slash
         this.maxRetries = maxRetries;
         this.retryDelayMs = retryDelayMs;
         this.timeoutMs = timeoutMs;
+        this.requestedModel = ollamaModel?.trim() || undefined;
+    }
+    /** The Ollama server this client talks to. */
+    getBaseUrl() {
+        return this.baseUrl;
+    }
+    /**
+     * Identifies the embedding space of this client's vectors. A model named by
+     * AQE_OLLAMA_EMBEDDING_MODEL that is not EMBEDDING_CONFIG.MODEL gets its own
+     * id, so its vectors are never compared with stored MiniLM vectors (ADR-097).
+     */
+    getModelId() {
+        return !this.requestedModel || isConfiguredOllamaModel(this.requestedModel)
+            ? EMBEDDING_CONFIG.MODEL
+            : `ollama:${this.requestedModel}`;
     }
     /**
      * Check if Ollama is running and the configured embedding model is available
      */
     async healthCheck() {
+        return (await this.checkModel()).status === 'available';
+    }
+    /**
+     * #1229: find the installed Ollama model to embed with, or say why there is
+     * none (Ollama unreachable, or reachable without the model).
+     */
+    async checkModel() {
+        const wanted = this.requestedModel ?? EMBEDDING_CONFIG.MODEL;
+        let data;
         try {
-            return await this.fetchWithTimeout(`${this.baseUrl}/api/tags`, {
+            data = await this.fetchWithTimeout(`${this.baseUrl}/api/tags`, {
                 method: 'GET',
                 headers: { 'Content-Type': 'application/json' },
             }, 5000, // Shorter timeout for health check
-            async (response) => {
-                if (!response.ok)
-                    return false;
-                const data = await response.json();
-                // Check if configured embedding model is available
-                // Match the configured model exactly, allowing its existing tag suffix.
-                if (data.models) {
-                    return data.models.some((model) => model.name === EMBEDDING_CONFIG.MODEL ||
-                        model.name?.startsWith(`${EMBEDDING_CONFIG.MODEL}:`) ||
-                        model.model === EMBEDDING_CONFIG.MODEL ||
-                        model.model?.startsWith(`${EMBEDDING_CONFIG.MODEL}:`));
-                }
-                return false;
-            });
+            async (response) => response.ok
+                ? await response.json()
+                : { httpStatus: response.status });
         }
         catch {
-            return false;
+            return { status: 'unreachable', reason: `Ollama at ${this.baseUrl} is not reachable` };
         }
+        if (data && 'httpStatus' in data) {
+            return {
+                status: 'unreachable',
+                reason: `Ollama at ${this.baseUrl} answered HTTP ${data.httpStatus} when listing models`,
+            };
+        }
+        const requested = this.requestedModel;
+        const matches = requested
+            ? (listed) => listed === requested || (!splitTag(requested).tag && listed === `${requested}:latest`)
+            : isConfiguredOllamaModel;
+        for (const model of data?.models ?? []) {
+            const found = [model.name, model.model].find((listed) => !!listed && matches(listed));
+            if (found) {
+                this.installedModel = found;
+                return { status: 'available', model: found };
+            }
+        }
+        return {
+            status: 'missing',
+            reason: `model '${wanted}' not installed in Ollama at ${this.baseUrl}; ` +
+                `install it with: ollama pull ${requested ?? EMBEDDING_CONFIG.OLLAMA_PULL_NAME}`,
+        };
     }
     /**
      * Generate embedding for a single text prompt
      */
     async generateEmbedding(prompt) {
         const request = {
-            model: EMBEDDING_CONFIG.MODEL,
+            model: this.installedModel ?? this.requestedModel ?? EMBEDDING_CONFIG.MODEL,
             prompt,
         };
         let lastError = null;
@@ -133,10 +196,9 @@ export class OllamaClient {
      * Verify model is available and throw if not
      */
     async ensureModelAvailable() {
-        const isHealthy = await this.healthCheck();
-        if (!isHealthy) {
-            throw new Error(`Ollama model '${EMBEDDING_CONFIG.MODEL}' is not available. ` +
-                `Please run: ollama pull ${EMBEDDING_CONFIG.MODEL}`);
+        const check = await this.checkModel();
+        if (check.status !== 'available') {
+            throw new Error(`Ollama model '${this.requestedModel ?? EMBEDDING_CONFIG.MODEL}' is not available: ${check.reason}`);
         }
     }
 }

package/dist/shared/embeddings/types.d.ts

@@ -120,6 +120,21 @@ export declare const EMBEDDING_CONFIG: {
     readonly TIMEOUT_MS: 30000;
     /** Default Ollama URL */
     readonly DEFAULT_OLLAMA_URL: "http://localhost:11434";
+    /** #1229: Ollama library name of MODEL, used in install hints */
+    readonly OLLAMA_PULL_NAME: "all-minilm:22m";
+    /** #1229: env var naming the installed Ollama model to use for MODEL */
+    readonly OLLAMA_MODEL_ENV: "AQE_OLLAMA_EMBEDDING_MODEL";
+};
+/**
+ * #1229: whether Ollama has the configured embedding model. `reason` says why
+ * not: Ollama did not answer, or it answered without the model.
+ */
+export type OllamaModelStatus = {
+    status: 'available';
+    model: string;
+} | {
+    status: 'missing' | 'unreachable';
+    reason: string;
 };
 /**
  * Interface for embedding providers

package/dist/shared/embeddings/types.js

@@ -22,5 +22,9 @@ export const EMBEDDING_CONFIG = {
     TIMEOUT_MS: 30000,
     /** Default Ollama URL */
     DEFAULT_OLLAMA_URL: 'http://localhost:11434',
+    /** #1229: Ollama library name of MODEL, used in install hints */
+    OLLAMA_PULL_NAME: 'all-minilm:22m',
+    /** #1229: env var naming the installed Ollama model to use for MODEL */
+    OLLAMA_MODEL_ENV: 'AQE_OLLAMA_EMBEDDING_MODEL',
 };
 //# sourceMappingURL=types.js.map

package/dist/shared/llm/spend-ledger.d.ts

@@ -64,8 +64,17 @@ export declare class SqliteSpendLedger implements SpendLedger {
      * drop ALL spend — bypassing the budget cap (the #557 class).
      */
     private hasAgentColumn;
+    /**
+     * Charges queued but not yet in the table (#1283). record() queues its
+     * INSERT so a locked memory.db does not freeze the MCP server; until the row
+     * lands, the spend reads below count it from here, so the ADR-123 budget cap
+     * never under-counts. Each entry leaves this set in the same synchronous
+     * step that inserts its row, so a charge is never counted twice.
+     */
+    private readonly pending;
     constructor(db: DatabaseType);
     record(entry: SpendEntry): void;
+    private insert;
     spentSince(windowMs: number, nowMs?: number): number;
     spentByAgentSince(windowMs: number, nowMs?: number): Record<string, number>;
 }