clementine-agent 1.0.31 → 1.0.33

package/dist/agent/complexity-classifier.d.ts

@@ -13,6 +13,13 @@
  */
 export interface ComplexityVerdict {
     complex: boolean;
+    /**
+     * High-confidence subset of `complex`. When true, the task is ambitious
+     * enough that the gateway should route it straight to deep/background
+     * execution instead of running a main-agent turn that would almost
+     * certainly get auto-escalated after burning tool calls.
+     */
+    deepWorthy: boolean;
     reason: string;
     signals: string[];
 }

package/dist/agent/complexity-classifier.js

@@ -11,6 +11,19 @@
  * what "plan" means — but much more consistent than a generic
  * SOUL.md directive that the model ignores half the time.
  */
+/**
+ * Explicit phrasings that essentially request a long-running background job.
+ * Triggers deepWorthy on their own, regardless of other signals.
+ */
+const DEEP_MODE_ASKS = [
+    /\b(deeply|extensively|thoroughly)\s+(research|analy[sz]e|investigate|audit|review)\b/i,
+    /\bcomprehensive(ly)?\s+(research|analy[sz]is|report|audit)\b/i,
+    /\bgo\s+(do|handle|tackle)\s+this\b/i,
+    /\brun\s+in\s+the\s+background\b/i,
+    /\bdeep\s+(mode|dive|work)\b/i,
+    /\bbackground\s+(task|work|job)\b/i,
+    /\btake\s+your\s+time\b/i,
+];
 /**
  * Action verbs that signal the user is asking Clementine to DO things
  * (as opposed to asking questions or making small talk). Multiple
@@ -82,18 +95,24 @@ function countEntities(text) {
  */
 export function classifyComplexity(text) {
     if (!text || typeof text !== 'string')
-        return { complex: false, reason: 'empty', signals: [] };
+        return { complex: false, deepWorthy: false, reason: 'empty', signals: [] };
     const trimmed = text.trim();
     // Skip commands and very short messages
     if (trimmed.length < 30)
-        return { complex: false, reason: 'too short', signals: [] };
+        return { complex: false, deepWorthy: false, reason: 'too short', signals: [] };
     if (trimmed.startsWith('!') || trimmed.startsWith('/'))
-        return { complex: false, reason: 'command', signals: [] };
+        return { complex: false, deepWorthy: false, reason: 'command', signals: [] };
+    // Signal 0: explicit deep-mode ask — short-circuits both gates.
+    for (const re of DEEP_MODE_ASKS) {
+        if (re.test(trimmed)) {
+            return { complex: true, deepWorthy: true, reason: 'explicit deep-mode ask', signals: ['deep-mode-ask'] };
+        }
+    }
     const signals = [];
     // Signal 1: explicit ask for plan-first
     for (const re of EXPLICIT_PLAN_ASKS) {
         if (re.test(trimmed)) {
-            return { complex: true, reason: 'user explicitly asked for a plan', signals: ['explicit-plan-ask'] };
+            return { complex: true, deepWorthy: false, reason: 'user explicitly asked for a plan', signals: ['explicit-plan-ask'] };
         }
     }
     // Signal 2: multiple action verbs
@@ -101,9 +120,11 @@ export function classifyComplexity(text) {
     if (verbs >= 3)
         signals.push(`${verbs} action verbs`);
     // Signal 3: chain markers
+    let hasChain = false;
     for (const re of CHAIN_MARKERS) {
         if (re.test(trimmed)) {
             signals.push('chain marker');
+            hasChain = true;
             break;
         }
     }
@@ -112,21 +133,31 @@ export function classifyComplexity(text) {
     if (entities >= 3)
         signals.push(`${entities} entities`);
     // Signal 5: long message with at least one action verb (big scope, not just a question)
-    if (trimmed.length > 400 && verbs >= 1)
+    const isLong = trimmed.length > 400 && verbs >= 1;
+    if (isLong)
         signals.push('long + action');
     // Gate: at least 2 signals fire, OR a single high-confidence signal
     // (chain markers, explicit-plan-ask, or 3+ action verbs).
-    const highConfidenceSingles = [
+    const highConfidenceSingles = [verbs >= 3, hasChain];
+    const complex = highConfidenceSingles.some(Boolean) || signals.length >= 2;
+    // deepWorthy raises the bar: multiple strong signals AND sustained scope.
+    // Specifically, any TWO of {3+ verbs, chain marker, long+action, 3+ entities}.
+    const strongCount = [
         verbs >= 3,
-        signals.includes('chain marker'),
-    ];
-    if (highConfidenceSingles.some(Boolean)) {
-        return { complex: true, reason: 'strong single signal', signals };
-    }
-    if (signals.length >= 2) {
-        return { complex: true, reason: 'multiple signals', signals };
+        hasChain,
+        isLong,
+        entities >= 3,
+    ].filter(Boolean).length;
+    const deepWorthy = strongCount >= 2;
+    if (complex) {
+        return {
+            complex: true,
+            deepWorthy,
+            reason: deepWorthy ? 'deep-worthy: multiple strong signals' : (highConfidenceSingles.some(Boolean) ? 'strong single signal' : 'multiple signals'),
+            signals,
+        };
     }
-    return { complex: false, reason: 'below threshold', signals };
+    return { complex: false, deepWorthy: false, reason: 'below threshold', signals };
 }
 /**
  * Build a system-prompt directive to inject when a complex message is

package/dist/agent/skill-extractor.js

@@ -17,6 +17,7 @@ import path from 'node:path';
 import matter from 'gray-matter';
 import pino from 'pino';
 import { VAULT_DIR, AGENTS_DIR, PENDING_SKILLS_DIR } from '../config.js';
+import { embed as embedText, cosineSimilarity, isReady as embeddingsReady } from '../memory/embeddings.js';
 const logger = pino({ name: 'clementine.skills' });
 const GLOBAL_SKILLS_DIR = path.join(VAULT_DIR, '00-System', 'skills');
 function agentSkillsDir(agentSlug) {
@@ -316,6 +317,25 @@ async function mergeSkill(assistant, existing, incoming) {
         return null;
     }
 }
+/**
+ * Cache of skill embeddings so we don't re-embed every skill's frontmatter
+ * on every query. Keyed by the absolute path of the skill file; invalidated
+ * implicitly (the cache stays in memory for the daemon's lifetime — skill
+ * edits require a restart, same as the rest of the skill pipeline).
+ */
+const skillEmbeddingCache = new Map();
+function getSkillEmbedding(filePath, triggers, title, description) {
+    const cached = skillEmbeddingCache.get(filePath);
+    if (cached)
+        return cached;
+    const corpus = [title, description, triggers.join(' ')].filter(Boolean).join(' ');
+    if (!corpus)
+        return null;
+    const vec = embedText(corpus);
+    if (vec)
+        skillEmbeddingCache.set(filePath, vec);
+    return vec;
+}
 export function searchSkills(query, limit = 3, agentSlug, opts) {
     const dirs = [];
     // Agent-scoped skills get priority (boost=2)
@@ -333,6 +353,11 @@ export function searchSkills(query, limit = 3, agentSlug, opts) {
     const results = [];
     const seen = new Set();
     const suppressed = opts?.suppressedNames;
+    // Semantic matching is optional — only engages if the vault has built an
+    // embedding vocabulary (MemoryStore.buildEmbeddings). Falls back to pure
+    // keyword scoring for fresh installs.
+    const useSemantic = embeddingsReady();
+    const queryVec = useSemantic ? embedText(query) : null;
     for (const { dir, boost } of dirs) {
         const files = readdirSync(dir).filter(f => f.endsWith('.md'));
         for (const file of files) {
@@ -344,8 +369,9 @@ export function searchSkills(query, limit = 3, agentSlug, opts) {
             // negative user feedback (see store.getSkillsToSuppress).
             if (suppressed?.has(name))
                 continue;
+            const filePath = path.join(dir, file);
             try {
-                const raw = readFileSync(path.join(dir, file), 'utf-8');
+                const raw = readFileSync(filePath, 'utf-8');
                 const parsed = matter(raw);
                 const triggers = parsed.data.triggers ?? [];
                 const title = parsed.data.title ?? '';
@@ -368,12 +394,27 @@ export function searchSkills(query, limit = 3, agentSlug, opts) {
                     if (description.toLowerCase().includes(word))
                         score += 1;
                 }
-                if (score > 0) {
+                // Semantic bonus: add cosine similarity × 4 so a strong semantic
+                // match (cos ~ 0.7+) contributes like a single keyword hit, and
+                // very close matches (cos ~ 0.9+) surface as a solid lead even
+                // when the user's phrasing doesn't share vocabulary with the
+                // skill's triggers. Keyword hits still dominate when present.
+                let semanticScore = 0;
+                if (queryVec) {
+                    const skillVec = getSkillEmbedding(filePath, triggerLower, title, description);
+                    if (skillVec) {
+                        const cos = cosineSimilarity(queryVec, skillVec);
+                        if (cos > 0.3)
+                            semanticScore = cos * 4;
+                    }
+                }
+                const totalScore = score + semanticScore;
+                if (totalScore > 0) {
                     results.push({
                         name,
                         title,
                         content: parsed.content.slice(0, 1500),
-                        score: score + boost,
+                        score: totalScore + boost,
                         toolsUsed: parsed.data.toolsUsed ?? [],
                         attachments: parsed.data.attachments ?? [],
                         skillDir: dir,

package/dist/gateway/router.js

@@ -872,10 +872,43 @@ export class Gateway {
                 const isInteractive = isOwnerDm
                     || sessionKey.startsWith('dashboard:')
                     || sessionKey.startsWith('cli:');
-                if (isInteractive && !isInternalMsg && !text.startsWith('!')) {
+                if (isInteractive && !isInternalMsg && !text.startsWith('!') && !sess?.deepTask) {
                     try {
                         const { classifyComplexity, planFirstDirective } = await import('../agent/complexity-classifier.js');
                         const verdict = classifyComplexity(text);
+                        // deepWorthy: skip the main-agent turn entirely and route
+                        // straight to background execution. Saves the turn that would
+                        // almost certainly get auto-escalated after burning 3+ tool
+                        // calls (see the post-flight auto-escalation path below).
+                        if (verdict.deepWorthy) {
+                            logger.info({ sessionKey, signals: verdict.signals, reason: verdict.reason }, 'Pre-flight deep-mode gate fired — spawning background task');
+                            const currentSess = this.getSession(sessionKey);
+                            const jobName = `deep-${Date.now()}`;
+                            currentSess.deepTask = { jobName, taskDesc: text.slice(0, 200), startedAt: new Date().toISOString() };
+                            const preflightAgentSlug = this._agentSlugFromSessionKey(sessionKey);
+                            this.assistant.runUnleashedTask(jobName, `The user asked: ${text}\n\nThis was routed straight to background execution because it looks like sustained multi-step work. Complete the task thoroughly and return a conversational summary.`, 2, // tier 2 (Bash/Write/Edit enabled)
+                            undefined, // default maxTurns
+                            undefined, // default model
+                            undefined, // default work_dir
+                            1, // maxHours
+                            preflightAgentSlug).then(async (result) => {
+                                logger.info({ sessionKey, jobName, resultLen: result?.length ?? 0 }, 'Pre-flight deep-mode task completed');
+                                if (result && result !== '__NOTHING__') {
+                                    this.assistant.injectPendingContext(sessionKey, text, result);
+                                    await this._deliverDeepResult(sessionKey, `[DEEP_MODE_RESULT] You just completed background work for this user request. Summarize conversationally — lead with what matters.\n\nTask: ${text.slice(0, 500)}\n\nResult:\n${result.slice(0, 3000)}`, result);
+                                }
+                            }).catch(async (err) => {
+                                logger.error({ err, sessionKey, jobName }, 'Pre-flight deep-mode task failed');
+                                const failMsg = `Background work failed: ${String(err).slice(0, 200)}`;
+                                this.assistant.injectPendingContext(sessionKey, text, failMsg);
+                                await this._deliverDeepResult(sessionKey, `[DEEP_MODE_RESULT] The background task failed: ${failMsg}. Let the user know and suggest next steps. Be brief.`, `Background task failed: ${failMsg}`);
+                            }).finally(() => {
+                                const s = this.sessions.get(sessionKey);
+                                if (s?.deepTask?.jobName === jobName)
+                                    delete s.deepTask;
+                            });
+                            return `On it — this looks like real work. Running it in the background; I'll follow up when it's done. Reply "cancel" to stop or "status" to check in.`;
+                        }
                         if (verdict.complex) {
                             logger.info({ sessionKey, signals: verdict.signals, reason: verdict.reason }, 'Pre-flight planning directive injected');
                             enrichedText = `${planFirstDirective()}\n\n---\n\n${text}`;

package/dist/memory/embeddings.d.ts

@@ -35,4 +35,11 @@ export declare function deserializeEmbedding(buf: Buffer): Float32Array;
  * Check if the embedding system is ready (vocabulary loaded with sufficient words).
  */
 export declare function isReady(): boolean;
+/**
+ * Stable hash of the current vocabulary's word→dimension mapping. When this
+ * changes, previously-stored embedding vectors become silently incorrect
+ * because dimension N now represents a different word. Callers (MemoryStore
+ * backfill) use this hash to detect staleness and invalidate stored vectors.
+ */
+export declare function getVocabHash(): string;
 //# sourceMappingURL=embeddings.d.ts.map

package/dist/memory/embeddings.js

@@ -9,6 +9,7 @@
  * Query-time: embed the query, compute cosine similarity against stored vectors.
  */
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
 import path from 'node:path';
 import pino from 'pino';
 import { BASE_DIR } from '../config.js';
@@ -163,6 +164,19 @@ export function isReady() {
     loadVocab();
     return vocabWords.length >= 50; // need at least 50 vocab words
 }
+/**
+ * Stable hash of the current vocabulary's word→dimension mapping. When this
+ * changes, previously-stored embedding vectors become silently incorrect
+ * because dimension N now represents a different word. Callers (MemoryStore
+ * backfill) use this hash to detect staleness and invalidate stored vectors.
+ */
+export function getVocabHash() {
+    loadVocab();
+    if (vocabWords.length === 0)
+        return '';
+    // Order-sensitive: dimension assignment depends on insertion order.
+    return createHash('sha1').update(vocabWords.join('|')).digest('hex').slice(0, 16);
+}
 const STOP_WORDS = new Set([
     'the', 'be', 'to', 'of', 'and', 'in', 'that', 'have', 'it', 'for',
     'not', 'on', 'with', 'he', 'as', 'you', 'do', 'at', 'this', 'but',

package/dist/memory/store.d.ts

@@ -174,10 +174,15 @@ export declare class MemoryStore {
         salienceThreshold?: number;
         accessLogRetentionDays?: number;
         transcriptRetentionDays?: number;
+        behavioralRetentionDays?: number;
     }): {
         episodicPruned: number;
         accessLogPruned: number;
         transcriptsPruned: number;
+        skillUsagePruned: number;
+        feedbackPruned: number;
+        reflectionsPruned: number;
+        usageLogPruned: number;
     };
     /**
      * Get chunks within a date range, ordered chronologically.
@@ -533,6 +538,7 @@ export declare class MemoryStore {
     buildEmbeddings(): {
         vocabSize: number;
         backfilled: number;
+        invalidated: number;
     };
     /**
      * Delete all chunks, wikilinks, file hash, and access log for a given file.

package/dist/memory/store.js

@@ -10,9 +10,10 @@
  * (single-user, one MCP subprocess handles all writes).
  */
 import { createHash } from 'node:crypto';
-import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import Database from 'better-sqlite3';
+import { BASE_DIR } from '../config.js';
 import * as embeddingsModule from './embeddings.js';
 import { chunkFile } from './chunker.js';
 import { mmrRerank } from './mmr.js';
@@ -184,6 +185,24 @@ export class MemoryStore {
         catch {
             // Index already exists
         }
+        // Hot-path indices: every chat turn sorts/filters chunks by updated_at
+        // (recency) and by (agent_slug, updated_at) for agent-scoped recent
+        // context. Without these the queries do full table scans.
+        try {
+            this.conn.exec('CREATE INDEX idx_chunks_updated_at ON chunks(updated_at DESC)');
+        }
+        catch { /* already exists */ }
+        try {
+            this.conn.exec('CREATE INDEX idx_chunks_agent_updated ON chunks(agent_slug, updated_at DESC)');
+        }
+        catch { /* already exists */ }
+        // Embedding filter — searchByEmbedding's base predicate is
+        // `embedding IS NOT NULL`; a partial index turns that into an
+        // index-only scan for the candidate set.
+        try {
+            this.conn.exec('CREATE INDEX idx_chunks_has_embedding ON chunks(id) WHERE embedding IS NOT NULL');
+        }
+        catch { /* already exists */ }
         // Access log table for salience tracking
         this.conn.exec(`
       CREATE TABLE IF NOT EXISTS access_log (
@@ -581,32 +600,35 @@ export class MemoryStore {
                 stats.filesDeleted++;
             }
         }
-        // Process changed/new files
-        for (const filePath of filesToUpdate) {
+        // Process changed/new files inside a single transaction so a 1000-file
+        // sync produces one WAL commit instead of 1000+. Prepared statements are
+        // hoisted out of the loop — better-sqlite3 caches by SQL text anyway, but
+        // the explicit handle avoids re-parsing and makes the intent clear.
+        const insertStmt = this.conn.prepare(`INSERT INTO chunks
+       (source_file, section, content, chunk_type, frontmatter_json, content_hash, category, topic)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`);
+        const upsertHashStmt = this.conn.prepare(`INSERT OR REPLACE INTO file_hashes (rel_path, content_hash, last_synced)
+       VALUES (?, ?, datetime('now'))`);
+        const processFile = (filePath) => {
             const rel = path.relative(this.vaultDir, filePath);
             const chunks = chunkFile(filePath, this.vaultDir);
             if (chunks.length === 0)
-                continue;
-            // Delete old chunks for this file
+                return;
             this.deleteFileChunks(rel);
-            // Insert new chunks
-            const insertStmt = this.conn.prepare(`INSERT INTO chunks
-         (source_file, section, content, chunk_type, frontmatter_json, content_hash, category, topic)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`);
             for (const chunk of chunks) {
                 insertStmt.run(chunk.sourceFile, chunk.section, chunk.content, chunk.chunkType, chunk.frontmatterJson, chunk.contentHash, chunk.category ?? null, chunk.topic ?? null);
             }
-            // Parse and index wikilinks
             this.indexWikilinks(rel, filePath);
-            // Update file hash
             const bytes = readFileSync(filePath);
             const fileHash = createHash('sha256').update(bytes).digest('hex').slice(0, 16);
-            this.conn
-                .prepare(`INSERT OR REPLACE INTO file_hashes (rel_path, content_hash, last_synced)
-           VALUES (?, ?, datetime('now'))`)
-                .run(rel, fileHash);
+            upsertHashStmt.run(rel, fileHash);
             stats.filesUpdated++;
-        }
+        };
+        const processAll = this.conn.transaction((files) => {
+            for (const f of files)
+                processFile(f);
+        });
+        processAll(filesToUpdate);
         // Count total chunks
         const countRow = this.conn
             .prepare('SELECT COUNT(*) as cnt FROM chunks')
@@ -838,17 +860,20 @@ export class MemoryStore {
      * Scans chunks that have stored embeddings and returns top matches.
      */
     searchByEmbedding(queryVec, limit, agentSlug, strict = false) {
-        const rows = this.conn
-            .prepare(`SELECT id, source_file, section, content, chunk_type, embedding, salience, agent_slug, updated_at, category, topic
-         FROM chunks
-         WHERE embedding IS NOT NULL`)
-            .all();
+        // Push agent-isolation into SQL so we don't deserialize embeddings for
+        // rows we'd immediately reject. Soft isolation (non-strict) still loads
+        // all embeddings because the boost is applied post-scoring, but at
+        // least strict mode no longer scans foreign-agent chunks.
+        let sql = 'SELECT id, source_file, section, content, chunk_type, embedding, salience, agent_slug, updated_at, category, topic FROM chunks WHERE embedding IS NOT NULL';
+        const params = [];
+        if (strict && agentSlug) {
+            sql += ' AND (agent_slug IS NULL OR agent_slug = ?)';
+            params.push(agentSlug);
+        }
+        const rows = this.conn.prepare(sql).all(...params);
         const scored = [];
         for (const row of rows) {
             try {
-                // Hard isolation: skip chunks from other agents (allow own + global)
-                if (strict && agentSlug && row.agent_slug !== null && row.agent_slug !== agentSlug)
-                    continue;
                 const vec = embeddingsModule.deserializeEmbedding(row.embedding);
                 const sim = embeddingsModule.cosineSimilarity(queryVec, vec);
                 if (sim < 0.15)
@@ -1148,6 +1173,10 @@ export class MemoryStore {
         const threshold = opts.salienceThreshold ?? 0.01;
         const accessRetention = opts.accessLogRetentionDays ?? 60;
         const transcriptRetention = opts.transcriptRetentionDays ?? 90;
+        // Behavioral telemetry kept longer than transcripts so the feedback loop
+        // (getFeedbackStats, getBehavioralPatterns, getSkillsToSuppress) has a
+        // wide enough window to aggregate meaningful signal.
+        const behavioralRetention = opts.behavioralRetentionDays ?? 180;
         // Prune stale episodic chunks (not vault-sourced content)
         const episodicResult = this.conn
             .prepare(`DELETE FROM chunks
@@ -1167,10 +1196,30 @@ export class MemoryStore {
             .prepare(`DELETE FROM transcripts
          WHERE created_at < datetime('now', ?)`)
             .run(`-${transcriptRetention} days`);
+        // Behavioral telemetry pruning — these tables were previously unbounded.
+        // Each is append-only, so a rolling window is safe; aggregate stats
+        // consume the window directly rather than historical totals.
+        const skillUsageResult = this.conn
+            .prepare(`DELETE FROM skill_usage WHERE retrieved_at < datetime('now', ?)`)
+            .run(`-${behavioralRetention} days`);
+        const feedbackResult = this.conn
+            .prepare(`DELETE FROM feedback WHERE created_at < datetime('now', ?)`)
+            .run(`-${behavioralRetention} days`);
+        const reflectionsResult = this.conn
+            .prepare(`DELETE FROM session_reflections WHERE created_at < datetime('now', ?)`)
+            .run(`-${behavioralRetention} days`);
+        // Usage log is denser (per-exchange) — keep a shorter window.
+        const usageResult = this.conn
+            .prepare(`DELETE FROM usage_log WHERE created_at < datetime('now', ?)`)
+            .run(`-${Math.min(behavioralRetention, 90)} days`);
         return {
             episodicPruned: episodicResult.changes,
             accessLogPruned: accessResult.changes,
             transcriptsPruned: transcriptResult.changes,
+            skillUsagePruned: skillUsageResult.changes,
+            feedbackPruned: feedbackResult.changes,
+            reflectionsPruned: reflectionsResult.changes,
+            usageLogPruned: usageResult.changes,
         };
     }
     // ── Timeline Query ─────────────────────────────────────────────
@@ -2045,25 +2094,55 @@ export class MemoryStore {
             .prepare('SELECT id, content FROM chunks')
             .all();
         if (rows.length === 0)
-            return { vocabSize: 0, backfilled: 0 };
+            return { vocabSize: 0, backfilled: 0, invalidated: 0 };
+        // Capture prior vocab hash BEFORE rebuild. If buildVocab produces a
+        // different word→dimension mapping, previously-stored embedding vectors
+        // become silently wrong (dimension N now represents a different word).
+        const hashFile = path.join(BASE_DIR, '.embedding-vocab.hash');
+        let priorHash = '';
+        try {
+            if (existsSync(hashFile))
+                priorHash = readFileSync(hashFile, 'utf-8').trim();
+        }
+        catch { /* first run */ }
         // Build vocabulary from entire corpus (including consolidated summaries)
         embeddingsModule.buildVocab(rows.map((r) => r.content));
         if (!embeddingsModule.isReady())
-            return { vocabSize: 0, backfilled: 0 };
+            return { vocabSize: 0, backfilled: 0, invalidated: 0 };
+        // If the vocab shifted, invalidate every stored vector so they re-embed
+        // against the new word→dim mapping. Without this, old vectors silently
+        // mismatch query vectors and cosine similarity returns nonsense.
+        const newHash = embeddingsModule.getVocabHash();
+        let invalidated = 0;
+        if (priorHash && priorHash !== newHash) {
+            const res = this.conn.prepare('UPDATE chunks SET embedding = NULL WHERE embedding IS NOT NULL').run();
+            invalidated = res.changes;
+            // Count is returned in the result object — callers (maintenance cycle)
+            // log it there. No local logger in this file to avoid the import.
+        }
+        try {
+            writeFileSync(hashFile, newHash);
+        }
+        catch { /* non-fatal */ }
         // Backfill embeddings for all chunks that don't have one
         const missing = this.conn
             .prepare('SELECT id, content FROM chunks WHERE embedding IS NULL')
             .all();
         const updateStmt = this.conn.prepare('UPDATE chunks SET embedding = ? WHERE id = ?');
         let backfilled = 0;
-        for (const row of missing) {
-            const vec = embeddingsModule.embed(row.content);
-            if (vec) {
-                updateStmt.run(embeddingsModule.serializeEmbedding(vec), row.id);
-                backfilled++;
+        // Wrap backfill in a transaction — potentially thousands of UPDATEs
+        // per vocab shift, and a single WAL commit is dramatically faster.
+        const backfillAll = this.conn.transaction((items) => {
+            for (const row of items) {
+                const vec = embeddingsModule.embed(row.content);
+                if (vec) {
+                    updateStmt.run(embeddingsModule.serializeEmbedding(vec), row.id);
+                    backfilled++;
+                }
             }
-        }
-        return { vocabSize: rows.length, backfilled };
+        });
+        backfillAll(missing);
+        return { vocabSize: rows.length, backfilled, invalidated };
     }
     // ── Helpers ───────────────────────────────────────────────────────
     /**

package/dist/tools/shared.d.ts

@@ -86,10 +86,15 @@ export type MemoryStoreType = {
         salienceThreshold?: number;
         accessLogRetentionDays?: number;
         transcriptRetentionDays?: number;
+        behavioralRetentionDays?: number;
     }): {
         episodicPruned: number;
         accessLogPruned: number;
         transcriptsPruned: number;
+        skillUsagePruned: number;
+        feedbackPruned: number;
+        reflectionsPruned: number;
+        usageLogPruned: number;
     };
     checkDuplicate(content: string, sourceFile?: string): {
         isDuplicate: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clementine-agent",
-  "version": "1.0.31",
+  "version": "1.0.33",
   "description": "Clementine — Personal AI Assistant (TypeScript)",
   "type": "module",
   "main": "dist/index.js",