@poolzin/pool-bot 2026.2.10 → 2026.2.17

package/dist/config/zod-schema.agent-defaults.js

@@ -125,6 +125,20 @@ export const AgentDefaultsSchema = z
     subagents: z
         .object({
         maxConcurrent: z.number().int().positive().optional(),
+        maxSpawnDepth: z
+            .number()
+            .int()
+            .min(1)
+            .max(5)
+            .optional()
+            .describe("Maximum nesting depth for sub-agent spawning. 1 = no nesting (default), 2 = sub-agents can spawn sub-sub-agents."),
+        maxChildrenPerAgent: z
+            .number()
+            .int()
+            .min(1)
+            .max(20)
+            .optional()
+            .describe("Maximum active children a single requester session may spawn. Default: 5."),
         archiveAfterMinutes: z.number().int().positive().optional(),
         model: z
             .union([

package/dist/config/zod-schema.agent-runtime.js

@@ -372,6 +372,20 @@ export const MemorySearchSchema = z
             vectorWeight: z.number().min(0).max(1).optional(),
             textWeight: z.number().min(0).max(1).optional(),
             candidateMultiplier: z.number().int().positive().optional(),
+            mmr: z
+                .object({
+                enabled: z.boolean().optional(),
+                lambda: z.number().min(0).max(1).optional(),
+            })
+                .strict()
+                .optional(),
+            temporalDecay: z
+                .object({
+                enabled: z.boolean().optional(),
+                halfLifeDays: z.number().int().positive().optional(),
+            })
+                .strict()
+                .optional(),
         })
             .strict()
             .optional(),

package/dist/infra/path-safety.js

@@ -0,0 +1,16 @@
+import path from "node:path";
+export function resolveSafeBaseDir(rootDir) {
+    const resolved = path.resolve(rootDir);
+    return resolved.endsWith(path.sep) ? resolved : `${resolved}${path.sep}`;
+}
+export function isWithinDir(rootDir, targetPath) {
+    const resolvedRoot = path.resolve(rootDir);
+    const resolvedTarget = path.resolve(targetPath);
+    // Windows paths are effectively case-insensitive; normalize to avoid false negatives.
+    if (process.platform === "win32") {
+        const relative = path.win32.relative(resolvedRoot.toLowerCase(), resolvedTarget.toLowerCase());
+        return relative === "" || (!relative.startsWith("..") && !path.win32.isAbsolute(relative));
+    }
+    const relative = path.relative(resolvedRoot, resolvedTarget);
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}

package/dist/logging/diagnostic-session-state.js

@@ -0,0 +1,73 @@
+export const diagnosticSessionStates = new Map();
+const SESSION_STATE_TTL_MS = 30 * 60 * 1000;
+const SESSION_STATE_PRUNE_INTERVAL_MS = 60 * 1000;
+const SESSION_STATE_MAX_ENTRIES = 2000;
+let lastSessionPruneAt = 0;
+export function pruneDiagnosticSessionStates(now = Date.now(), force = false) {
+    const shouldPruneForSize = diagnosticSessionStates.size > SESSION_STATE_MAX_ENTRIES;
+    if (!force && !shouldPruneForSize && now - lastSessionPruneAt < SESSION_STATE_PRUNE_INTERVAL_MS) {
+        return;
+    }
+    lastSessionPruneAt = now;
+    for (const [key, state] of diagnosticSessionStates.entries()) {
+        const ageMs = now - state.lastActivity;
+        const isIdle = state.state === "idle";
+        if (isIdle && state.queueDepth <= 0 && ageMs > SESSION_STATE_TTL_MS) {
+            diagnosticSessionStates.delete(key);
+        }
+    }
+    if (diagnosticSessionStates.size <= SESSION_STATE_MAX_ENTRIES) {
+        return;
+    }
+    const excess = diagnosticSessionStates.size - SESSION_STATE_MAX_ENTRIES;
+    const ordered = Array.from(diagnosticSessionStates.entries()).toSorted((a, b) => a[1].lastActivity - b[1].lastActivity);
+    for (let i = 0; i < excess; i += 1) {
+        const key = ordered[i]?.[0];
+        if (!key) {
+            break;
+        }
+        diagnosticSessionStates.delete(key);
+    }
+}
+function resolveSessionKey({ sessionKey, sessionId }) {
+    return sessionKey ?? sessionId ?? "unknown";
+}
+function findStateBySessionId(sessionId) {
+    for (const state of diagnosticSessionStates.values()) {
+        if (state.sessionId === sessionId) {
+            return state;
+        }
+    }
+    return undefined;
+}
+export function getDiagnosticSessionState(ref) {
+    pruneDiagnosticSessionStates();
+    const key = resolveSessionKey(ref);
+    const existing = diagnosticSessionStates.get(key) ?? (ref.sessionId && findStateBySessionId(ref.sessionId));
+    if (existing) {
+        if (ref.sessionId) {
+            existing.sessionId = ref.sessionId;
+        }
+        if (ref.sessionKey) {
+            existing.sessionKey = ref.sessionKey;
+        }
+        return existing;
+    }
+    const created = {
+        sessionId: ref.sessionId,
+        sessionKey: ref.sessionKey,
+        lastActivity: Date.now(),
+        state: "idle",
+        queueDepth: 0,
+    };
+    diagnosticSessionStates.set(key, created);
+    pruneDiagnosticSessionStates(Date.now(), true);
+    return created;
+}
+export function getDiagnosticSessionStateCountForTest() {
+    return diagnosticSessionStates.size;
+}
+export function resetDiagnosticSessionStateForTest() {
+    diagnosticSessionStates.clear();
+    lastSessionPruneAt = 0;
+}

package/dist/logging/diagnostic.js

@@ -165,6 +165,28 @@ export function logLaneDequeue(lane, waitMs, queueSize) {
     });
     markActivity();
 }
+export function logToolLoopAction(params) {
+    const payload = `tool loop: sessionId=${params.sessionId ?? "unknown"} sessionKey=${params.sessionKey ?? "unknown"} tool=${params.toolName} level=${params.level} action=${params.action} detector=${params.detector} count=${params.count}${params.pairedToolName ? ` pairedTool=${params.pairedToolName}` : ""} message="${params.message}"`;
+    if (params.level === "critical") {
+        diag.error(payload);
+    }
+    else {
+        diag.warn(payload);
+    }
+    emitDiagnosticEvent({
+        type: "tool.loop",
+        sessionId: params.sessionId,
+        sessionKey: params.sessionKey,
+        toolName: params.toolName,
+        level: params.level,
+        action: params.action,
+        detector: params.detector,
+        count: params.count,
+        message: params.message,
+        pairedToolName: params.pairedToolName,
+    });
+    markActivity();
+}
 export function logRunAttempt(params) {
     diag.debug(`run attempt: sessionId=${params.sessionId ?? "unknown"} sessionKey=${params.sessionKey ?? "unknown"} runId=${params.runId} attempt=${params.attempt}`);
     emitDiagnosticEvent({

package/dist/memory/embeddings.js

@@ -13,6 +13,7 @@ function sanitizeAndNormalizeEmbedding(vec) {
     }
     return sanitized.map((value) => value / magnitude);
 }
+const REMOTE_EMBEDDING_PROVIDER_IDS = ["openai", "gemini", "voyage"];
 export const DEFAULT_LOCAL_MODEL = "hf:ggml-org/embeddinggemma-300m-qat-q8_0-GGUF/embeddinggemma-300m-qat-Q8_0.gguf";
 function canAutoSelectLocal(options) {
     const modelPath = options.local?.modelPath?.trim();
@@ -105,7 +106,7 @@ export async function createEmbeddingProvider(options) {
                 localError = formatLocalSetupError(err);
             }
         }
-        for (const provider of ["openai", "gemini", "voyage"]) {
+        for (const provider of REMOTE_EMBEDDING_PROVIDER_IDS) {
             try {
                 const result = await createProvider(provider);
                 return { ...result, requestedProvider };
@@ -116,14 +117,18 @@ export async function createEmbeddingProvider(options) {
                     missingKeyErrors.push(message);
                     continue;
                 }
+                // Non-auth errors (e.g., network) are still fatal
                 throw new Error(message, { cause: err });
             }
         }
+        // All providers failed due to missing API keys - return null provider for FTS-only mode
         const details = [...missingKeyErrors, localError].filter(Boolean);
-        if (details.length > 0) {
-            throw new Error(details.join("\n\n"));
-        }
-        throw new Error("No embeddings provider available.");
+        const reason = details.length > 0 ? details.join("\n\n") : "No embeddings provider available.";
+        return {
+            provider: null,
+            requestedProvider,
+            providerUnavailableReason: reason,
+        };
     }
     try {
         const primary = await createProvider(requestedProvider);
@@ -142,15 +147,38 @@ export async function createEmbeddingProvider(options) {
                 };
             }
             catch (fallbackErr) {
-                throw new Error(`${reason}\n\nFallback to ${fallback} failed: ${formatErrorMessage(fallbackErr)}`, { cause: fallbackErr });
+                // Both primary and fallback failed - check if it's auth-related
+                const fallbackReason = formatErrorMessage(fallbackErr);
+                const combinedReason = `${reason}\n\nFallback to ${fallback} failed: ${fallbackReason}`;
+                if (isMissingApiKeyError(primaryErr) && isMissingApiKeyError(fallbackErr)) {
+                    // Both failed due to missing API keys - return null for FTS-only mode
+                    return {
+                        provider: null,
+                        requestedProvider,
+                        fallbackFrom: requestedProvider,
+                        fallbackReason: reason,
+                        providerUnavailableReason: combinedReason,
+                    };
+                }
+                // Non-auth errors are still fatal
+                throw new Error(combinedReason, { cause: fallbackErr });
             }
         }
+        // No fallback configured - check if we should degrade to FTS-only
+        if (isMissingApiKeyError(primaryErr)) {
+            return {
+                provider: null,
+                requestedProvider,
+                providerUnavailableReason: reason,
+            };
+        }
         throw new Error(reason, { cause: primaryErr });
     }
 }
 function isNodeLlamaCppMissing(err) {
-    if (!(err instanceof Error))
+    if (!(err instanceof Error)) {
         return false;
+    }
     const code = err.code;
     if (code === "ERR_MODULE_NOT_FOUND") {
         return err.message.includes("node-llama-cpp");
@@ -174,8 +202,7 @@ function formatLocalSetupError(err) {
             ? "2) Reinstall Poolbot (this should install node-llama-cpp): npm i -g poolbot@latest"
             : null,
         "3) If you use pnpm: pnpm approve-builds (select node-llama-cpp), then pnpm rebuild node-llama-cpp",
-        'Or set agents.defaults.memorySearch.provider = "openai" (remote).',
-        'Or set agents.defaults.memorySearch.provider = "voyage" (remote).',
+        ...REMOTE_EMBEDDING_PROVIDER_IDS.map((provider) => `Or set agents.defaults.memorySearch.provider = "${provider}" (remote).`),
     ]
         .filter(Boolean)
         .join("\n");

package/dist/memory/hybrid.js

@@ -1,10 +1,15 @@
+import { applyMMRToHybridResults, DEFAULT_MMR_CONFIG } from "./mmr.js";
+import { applyTemporalDecayToHybridResults, DEFAULT_TEMPORAL_DECAY_CONFIG, } from "./temporal-decay.js";
+export { DEFAULT_MMR_CONFIG };
+export { DEFAULT_TEMPORAL_DECAY_CONFIG };
 export function buildFtsQuery(raw) {
     const tokens = raw
-        .match(/[A-Za-z0-9_]+/g)
+        .match(/[\p{L}\p{N}_]+/gu)
         ?.map((t) => t.trim())
         .filter(Boolean) ?? [];
-    if (tokens.length === 0)
+    if (tokens.length === 0) {
         return null;
+    }
     const quoted = tokens.map((t) => `"${t.replaceAll('"', "")}"`);
     return quoted.join(" AND ");
 }
@@ -12,7 +17,7 @@ export function bm25RankToScore(rank) {
     const normalized = Number.isFinite(rank) ? Math.max(0, rank) : 999;
     return 1 / (1 + normalized);
 }
-export function mergeHybridResults(params) {
+export async function mergeHybridResults(params) {
     const byId = new Map();
     for (const r of params.vector) {
         byId.set(r.id, {
@@ -30,8 +35,9 @@ export function mergeHybridResults(params) {
         const existing = byId.get(r.id);
         if (existing) {
             existing.textScore = r.textScore;
-            if (r.snippet && r.snippet.length > 0)
+            if (r.snippet && r.snippet.length > 0) {
                 existing.snippet = r.snippet;
+            }
         }
         else {
             byId.set(r.id, {
@@ -57,5 +63,18 @@ export function mergeHybridResults(params) {
             source: entry.source,
         };
     });
-    return merged.sort((a, b) => b.score - a.score);
+    const temporalDecayConfig = { ...DEFAULT_TEMPORAL_DECAY_CONFIG, ...params.temporalDecay };
+    const decayed = await applyTemporalDecayToHybridResults({
+        results: merged,
+        temporalDecay: temporalDecayConfig,
+        workspaceDir: params.workspaceDir,
+        nowMs: params.nowMs,
+    });
+    const sorted = decayed.toSorted((a, b) => b.score - a.score);
+    // Apply MMR re-ranking if enabled
+    const mmrConfig = { ...DEFAULT_MMR_CONFIG, ...params.mmr };
+    if (mmrConfig.enabled) {
+        return applyMMRToHybridResults(sorted, mmrConfig);
+    }
+    return sorted;
 }

package/dist/memory/manager.js

@@ -20,6 +20,7 @@ import { buildFileEntry, chunkMarkdown, ensureDir, hashText, isMemoryPath, listM
 import { bm25RankToScore, buildFtsQuery, mergeHybridResults } from "./hybrid.js";
 import { searchKeyword, searchVector } from "./manager-search.js";
 import { ensureMemoryIndexSchema } from "./memory-schema.js";
+import { extractKeywords } from "./query-expansion.js";
 import { requireNodeSqlite } from "./sqlite.js";
 import { loadSqliteVecExtension } from "./sqlite-vec.js";
 const META_KEY = "memory_index_meta_v1";
@@ -54,6 +55,7 @@ export class MemoryIndexManager {
     requestedProvider;
     fallbackFrom;
     fallbackReason;
+    providerUnavailableReason;
     openAi;
     gemini;
     voyage;
@@ -108,6 +110,7 @@ export class MemoryIndexManager {
             workspaceDir,
             settings,
             providerResult,
+            purpose: params.purpose,
         });
         INDEX_CACHE.set(key, manager);
         return manager;
@@ -122,6 +125,7 @@ export class MemoryIndexManager {
         this.requestedProvider = params.providerResult.requestedProvider;
         this.fallbackFrom = params.providerResult.fallbackFrom;
         this.fallbackReason = params.providerResult.fallbackReason;
+        this.providerUnavailableReason = params.providerResult.providerUnavailableReason;
         this.openAi = params.providerResult.openAi;
         this.gemini = params.providerResult.gemini;
         this.voyage = params.providerResult.voyage;
@@ -146,7 +150,8 @@ export class MemoryIndexManager {
         this.ensureWatcher();
         this.ensureSessionListener();
         this.ensureIntervalSync();
-        this.dirty = this.sources.has("memory");
+        const statusOnly = params.purpose === "status";
+        this.dirty = this.sources.has("memory") && (statusOnly ? !meta : true);
         this.batch = this.resolveBatchConfig();
     }
     async warmSession(sessionKey) {
@@ -175,6 +180,30 @@ export class MemoryIndexManager {
         const maxResults = opts?.maxResults ?? this.settings.query.maxResults;
         const hybrid = this.settings.query.hybrid;
         const candidates = Math.min(200, Math.max(1, Math.floor(maxResults * hybrid.candidateMultiplier)));
+        // FTS-only mode: no embedding provider available
+        if (!this.provider) {
+            if (!this.fts.enabled || !this.fts.available) {
+                log.warn("memory search: no provider and FTS unavailable");
+                return [];
+            }
+            const keywords = extractKeywords(cleaned);
+            const searchTerms = keywords.length > 0 ? keywords : [cleaned];
+            const resultSets = await Promise.all(searchTerms.map((term) => this.searchKeyword(term, candidates).catch(() => [])));
+            const seenIds = new Map();
+            for (const results of resultSets) {
+                for (const result of results) {
+                    const existing = seenIds.get(result.id);
+                    if (!existing || result.score > existing.score) {
+                        seenIds.set(result.id, result);
+                    }
+                }
+            }
+            const merged = [...seenIds.values()]
+                .toSorted((a, b) => b.score - a.score)
+                .filter((entry) => entry.score >= minScore)
+                .slice(0, maxResults);
+            return merged;
+        }
         const keywordResults = hybrid.enabled
             ? await this.searchKeyword(cleaned, candidates).catch(() => [])
             : [];
@@ -186,15 +215,19 @@ export class MemoryIndexManager {
         if (!hybrid.enabled) {
             return vectorResults.filter((entry) => entry.score >= minScore).slice(0, maxResults);
         }
-        const merged = this.mergeHybridResults({
+        const merged = await this.mergeHybridResults({
             vector: vectorResults,
             keyword: keywordResults,
             vectorWeight: hybrid.vectorWeight,
             textWeight: hybrid.textWeight,
+            mmr: hybrid.mmr,
+            temporalDecay: hybrid.temporalDecay,
         });
         return merged.filter((entry) => entry.score >= minScore).slice(0, maxResults);
     }
     async searchVector(queryVec, limit) {
+        if (!this.provider)
+            return [];
         const results = await searchVector({
             db: this.db,
             vectorTable: VECTOR_TABLE,
@@ -218,7 +251,7 @@ export class MemoryIndexManager {
         const results = await searchKeyword({
             db: this.db,
             ftsTable: FTS_TABLE,
-            providerModel: this.provider.model,
+            providerModel: this.provider?.model ?? "fts-only",
             query,
             limit,
             snippetMaxChars: SNIPPET_MAX_CHARS,
@@ -228,8 +261,8 @@ export class MemoryIndexManager {
         });
         return results.map((entry) => entry);
     }
-    mergeHybridResults(params) {
-        const merged = mergeHybridResults({
+    async mergeHybridResults(params) {
+        const merged = await mergeHybridResults({
             vector: params.vector.map((r) => ({
                 id: r.id,
                 path: r.path,
@@ -250,6 +283,9 @@ export class MemoryIndexManager {
             })),
             vectorWeight: params.vectorWeight,
             textWeight: params.textWeight,
+            workspaceDir: this.workspaceDir,
+            mmr: params.mmr,
+            temporalDecay: params.temporalDecay,
         });
         return merged.map((entry) => entry);
     }
@@ -359,8 +395,8 @@ export class MemoryIndexManager {
             dirty: this.dirty || this.sessionsDirty,
             workspaceDir: this.workspaceDir,
             dbPath: this.settings.store.path,
-            provider: this.provider.id,
-            model: this.provider.model,
+            provider: this.provider?.id ?? "none",
+            model: this.provider?.model,
             requestedProvider: this.requestedProvider,
             sources: Array.from(this.sources),
             extraPaths: this.settings.extraPaths,
@@ -882,7 +918,7 @@ export class MemoryIndexManager {
                 try {
                     this.db
                         .prepare(`DELETE FROM ${FTS_TABLE} WHERE path = ? AND source = ? AND model = ?`)
-                        .run(stale.path, "memory", this.provider.model);
+                        .run(stale.path, "memory", this.provider?.model ?? "fts-only");
                 }
                 catch { }
             }
@@ -976,7 +1012,7 @@ export class MemoryIndexManager {
                 try {
                     this.db
                         .prepare(`DELETE FROM ${FTS_TABLE} WHERE path = ? AND source = ? AND model = ?`)
-                        .run(stale.path, "sessions", this.provider.model);
+                        .run(stale.path, "sessions", this.provider?.model ?? "fts-only");
                 }
                 catch { }
             }
@@ -1015,8 +1051,8 @@ export class MemoryIndexManager {
         const meta = this.readMeta();
         const needsFullReindex = params?.force ||
             !meta ||
-            meta.model !== this.provider.model ||
-            meta.provider !== this.provider.id ||
+            meta.model !== this.provider?.model ||
+            meta.provider !== this.provider?.id ||
             meta.providerKey !== this.providerKey ||
             meta.chunkTokens !== this.settings.chunking.tokens ||
             meta.chunkOverlap !== this.settings.chunking.overlap ||
@@ -1068,9 +1104,9 @@ export class MemoryIndexManager {
     resolveBatchConfig() {
         const batch = this.settings.remote?.batch;
         const enabled = Boolean(batch?.enabled &&
-            ((this.openAi && this.provider.id === "openai") ||
-                (this.gemini && this.provider.id === "gemini") ||
-                (this.voyage && this.provider.id === "voyage")));
+            ((this.openAi && this.provider?.id === "openai") ||
+                (this.gemini && this.provider?.id === "gemini") ||
+                (this.voyage && this.provider?.id === "voyage")));
         return {
             enabled,
             wait: batch?.wait ?? true,
@@ -1081,7 +1117,7 @@ export class MemoryIndexManager {
     }
     async activateFallbackProvider(reason) {
         const fallback = this.settings.fallback;
-        if (!fallback || fallback === "none" || fallback === this.provider.id)
+        if (!fallback || fallback === "none" || !this.provider || fallback === this.provider.id)
             return false;
         if (this.fallbackFrom)
             return false;
@@ -1170,8 +1206,8 @@ export class MemoryIndexManager {
                 this.sessionsDirty = false;
             }
             nextMeta = {
-                model: this.provider.model,
-                provider: this.provider.id,
+                model: this.provider?.model ?? "fts-only",
+                provider: this.provider?.id ?? "none",
                 providerKey: this.providerKey,
                 chunkTokens: this.settings.chunking.tokens,
                 chunkOverlap: this.settings.chunking.overlap,
@@ -1371,7 +1407,11 @@ export class MemoryIndexManager {
         if (unique.length === 0)
             return new Map();
         const out = new Map();
-        const baseParams = [this.provider.id, this.provider.model, this.providerKey];
+        const baseParams = [
+            this.provider?.id ?? "none",
+            this.provider?.model ?? "fts-only",
+            this.providerKey,
+        ];
         const batchSize = 400;
         for (let start = 0; start < unique.length; start += batchSize) {
             const batch = unique.slice(start, start + batchSize);
@@ -1387,7 +1427,7 @@ export class MemoryIndexManager {
         return out;
     }
     upsertEmbeddingCache(entries) {
-        if (!this.cache.enabled)
+        if (!this.cache.enabled || !this.provider)
             return;
         if (entries.length === 0)
             return;
@@ -1461,6 +1501,9 @@ export class MemoryIndexManager {
         return embeddings;
     }
     computeProviderKey() {
+        if (!this.provider) {
+            return hashText(JSON.stringify({ provider: "none", model: "fts-only" }));
+        }
         if (this.provider.id === "openai" && this.openAi) {
             const entries = Object.entries(this.openAi.headers)
                 .filter(([key]) => key.toLowerCase() !== "authorization")
@@ -1491,13 +1534,13 @@ export class MemoryIndexManager {
         return hashText(JSON.stringify({ provider: this.provider.id, model: this.provider.model }));
     }
     async embedChunksWithBatch(chunks, entry, source) {
-        if (this.provider.id === "openai" && this.openAi) {
+        if (this.provider?.id === "openai" && this.openAi) {
             return this.embedChunksWithOpenAiBatch(chunks, entry, source);
         }
-        if (this.provider.id === "gemini" && this.gemini) {
+        if (this.provider?.id === "gemini" && this.gemini) {
             return this.embedChunksWithGeminiBatch(chunks, entry, source);
         }
-        if (this.provider.id === "voyage" && this.voyage) {
+        if (this.provider?.id === "voyage" && this.voyage) {
             return this.embedChunksWithVoyageBatch(chunks, entry, source);
         }
         return this.embedChunksInBatches(chunks);
@@ -1602,7 +1645,7 @@ export class MemoryIndexManager {
                 method: "POST",
                 url: OPENAI_BATCH_ENDPOINT,
                 body: {
-                    model: this.openAi?.model ?? this.provider.model,
+                    model: this.openAi?.model ?? this.provider?.model ?? "fts-only",
                     input: chunk.text,
                 },
             });
@@ -1700,6 +1743,8 @@ export class MemoryIndexManager {
     async embedBatchWithRetry(texts) {
         if (texts.length === 0)
             return [];
+        if (!this.provider)
+            throw new Error("embedding provider unavailable");
         let attempt = 0;
         let delayMs = EMBEDDING_RETRY_BASE_DELAY_MS;
         while (true) {
@@ -1729,13 +1774,15 @@ export class MemoryIndexManager {
         return /(rate[_ ]limit|too many requests|429|resource has been exhausted|5\d\d|cloudflare)/i.test(message);
     }
     resolveEmbeddingTimeout(kind) {
-        const isLocal = this.provider.id === "local";
+        const isLocal = this.provider?.id === "local";
         if (kind === "query") {
             return isLocal ? EMBEDDING_QUERY_TIMEOUT_LOCAL_MS : EMBEDDING_QUERY_TIMEOUT_REMOTE_MS;
         }
         return isLocal ? EMBEDDING_BATCH_TIMEOUT_LOCAL_MS : EMBEDDING_BATCH_TIMEOUT_REMOTE_MS;
     }
     async embedQueryWithTimeout(text) {
+        if (!this.provider)
+            throw new Error("embedding provider unavailable");
         const timeoutMs = this.resolveEmbeddingTimeout("query");
         log.debug("memory embeddings: query start", { provider: this.provider.id, timeoutMs });
         return await this.withTimeout(this.provider.embedQuery(text), timeoutMs, `memory embeddings query timed out after ${Math.round(timeoutMs / 1000)}s`);
@@ -1873,7 +1920,7 @@ export class MemoryIndexManager {
             try {
                 this.db
                     .prepare(`DELETE FROM ${FTS_TABLE} WHERE path = ? AND source = ? AND model = ?`)
-                    .run(entry.path, options.source, this.provider.model);
+                    .run(entry.path, options.source, this.provider?.model ?? "fts-only");
             }
             catch { }
         }
@@ -1883,7 +1930,8 @@ export class MemoryIndexManager {
         for (let i = 0; i < chunks.length; i++) {
             const chunk = chunks[i];
             const embedding = embeddings[i] ?? [];
-            const id = hashText(`${options.source}:${entry.path}:${chunk.startLine}:${chunk.endLine}:${chunk.hash}:${this.provider.model}`);
+            const providerModel = this.provider?.model ?? "fts-only";
+            const id = hashText(`${options.source}:${entry.path}:${chunk.startLine}:${chunk.endLine}:${chunk.hash}:${providerModel}`);
             this.db
                 .prepare(`INSERT INTO chunks (id, path, source, start_line, end_line, hash, model, text, embedding, updated_at)
            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
@@ -1893,7 +1941,7 @@ export class MemoryIndexManager {
              text=excluded.text,
              embedding=excluded.embedding,
              updated_at=excluded.updated_at`)
-                .run(id, entry.path, options.source, chunk.startLine, chunk.endLine, chunk.hash, this.provider.model, chunk.text, JSON.stringify(embedding), now);
+                .run(id, entry.path, options.source, chunk.startLine, chunk.endLine, chunk.hash, providerModel, chunk.text, JSON.stringify(embedding), now);
             if (vectorReady && embedding.length > 0) {
                 try {
                     this.db.prepare(`DELETE FROM ${VECTOR_TABLE} WHERE id = ?`).run(id);
@@ -1907,7 +1955,7 @@ export class MemoryIndexManager {
                 this.db
                     .prepare(`INSERT INTO ${FTS_TABLE} (text, id, path, source, model, start_line, end_line)\n` +
                     ` VALUES (?, ?, ?, ?, ?, ?, ?)`)
-                    .run(chunk.text, id, entry.path, options.source, this.provider.model, chunk.startLine, chunk.endLine);
+                    .run(chunk.text, id, entry.path, options.source, providerModel, chunk.startLine, chunk.endLine);
             }
         }
         this.db