clementine-agent 1.0.1 → 1.0.3

package/README.md

@@ -85,6 +85,8 @@ bash install.sh
 
 The install script handles everything: system dependencies (redis, libomp, build tools), npm packages, TypeScript build, global CLI install, and launches the setup wizard. Safe to re-run — skips anything already installed.
 
+The setup wizard auto-generates a Discord bot invite URL from your token and offers to open it in your browser — no need to visit the Developer Portal manually.
+
 After setup:
 
 ```bash
@@ -324,6 +326,11 @@ clementine tools               List available MCP tools, plugins, and channels
 clementine config setup        Interactive configuration wizard
 clementine config set KEY VAL  Set a single config value
 clementine config get KEY      Read a config value
+clementine config edit         Open .env in your editor ($EDITOR)
+clementine memory search <q>   Search memory from the terminal (FTS5)
+clementine projects list       Show all linked projects
+clementine projects add <path> Link a project directory (-d desc, -k keywords)
+clementine projects remove <p> Unlink a project directory
 clementine cron list           List all cron jobs and last run status
 clementine cron run <job>      Run a specific cron job
 clementine cron run-due        Run all due jobs (for OS scheduler)

package/dist/agent/assistant.d.ts

@@ -26,6 +26,10 @@ export interface ProjectMeta {
 export declare function findProjectByName(query: string): ProjectMeta | null;
 /** Get all linked projects. */
 export declare function getLinkedProjects(): ProjectMeta[];
+/** Add a project to the linked projects list. */
+export declare function addProject(projectPath: string, description?: string, keywords?: string[]): void;
+/** Remove a project from the linked projects list. Returns true if removed. */
+export declare function removeProject(projectPath: string): boolean;
 export declare class PersonalAssistant {
     static readonly MAX_SESSION_EXCHANGES = 40;
     private sessions;
@@ -50,6 +54,8 @@ export declare class PersonalAssistant {
     /** Per-session stall nudge — set after a query shows stall signals, consumed on the next query. */
     private stallNudges;
     private _compactedSessions;
+    /** Last auto-matched project per session — exposed for CLI display. */
+    private _lastMatchedProject;
     /** Hot correction buffer — explicit behavioral corrections applied before nightly SI. */
     private hotCorrections;
     constructor();
@@ -113,6 +119,11 @@ export declare class PersonalAssistant {
      * No LLM call — uses buildLocalSummary for instant summarization.
      */
     private compactContext;
+    /**
+     * Expire sessions inactive for more than 24 hours.
+     * Called periodically from chat() to prevent unbounded map growth.
+     */
+    private expireOldSessions;
     /**
      * Build an instant local summary from in-memory exchange history.
      * No LLM call — returns immediately. Used during session rotation
@@ -220,6 +231,8 @@ export declare class PersonalAssistant {
         content: string;
     }>>;
     clearSession(sessionKey: string): void;
+    /** Get the last auto-matched project for a session (for CLI display). */
+    getLastMatchedProject(sessionKey: string): ProjectMeta | null;
     getProfileManager(): AgentManager;
 }
 //# sourceMappingURL=assistant.d.ts.map

package/dist/agent/assistant.js

@@ -469,6 +469,33 @@ export function findProjectByName(query) {
 export function getLinkedProjects() {
     return loadProjectsMeta();
 }
+/** Add a project to the linked projects list. */
+export function addProject(projectPath, description, keywords) {
+    const resolved = path.resolve(projectPath);
+    const projects = loadProjectsMeta();
+    // Avoid duplicates
+    if (projects.some(p => path.resolve(p.path) === resolved))
+        return;
+    const entry = { path: resolved };
+    if (description)
+        entry.description = description;
+    if (keywords?.length)
+        entry.keywords = keywords;
+    projects.push(entry);
+    fs.writeFileSync(PROJECTS_META_FILE, JSON.stringify(projects, null, 4));
+    _projectsMetaCacheTime = 0; // invalidate cache
+}
+/** Remove a project from the linked projects list. Returns true if removed. */
+export function removeProject(projectPath) {
+    const resolved = path.resolve(projectPath);
+    const projects = loadProjectsMeta();
+    const filtered = projects.filter(p => path.resolve(p.path) !== resolved);
+    if (filtered.length === projects.length)
+        return false;
+    fs.writeFileSync(PROJECTS_META_FILE, JSON.stringify(filtered, null, 4));
+    _projectsMetaCacheTime = 0; // invalidate cache
+    return true;
+}
 // ── PersonalAssistant ───────────────────────────────────────────────
 export class PersonalAssistant {
     static MAX_SESSION_EXCHANGES = MAX_SESSION_EXCHANGES;
@@ -494,6 +521,8 @@ export class PersonalAssistant {
     /** Per-session stall nudge — set after a query shows stall signals, consumed on the next query. */
     stallNudges = new Map();
     _compactedSessions = new Set();
+    /** Last auto-matched project per session — exposed for CLI display. */
+    _lastMatchedProject = new Map();
     /** Hot correction buffer — explicit behavioral corrections applied before nightly SI. */
     hotCorrections = [];
     constructor() {
@@ -1482,6 +1511,8 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
         const key = sessionKey ?? undefined;
         this._lastUserMessage = text;
         let sessionRotated = false;
+        // Periodic cleanup: expire all sessions older than 24 hours
+        this.expireOldSessions();
         // Expire old sessions (4 hours)
         if (key && this.sessionTimestamps.has(key)) {
             const elapsed = Date.now() - this.sessionTimestamps.get(key).getTime();
@@ -1735,6 +1766,9 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
         setSendPolicy(profile?.sendPolicy ?? null, profile?.slug ?? null);
         setAgentDir(profile?.agentDir ?? null);
         setInteractionSource(inferInteractionSource(sessionKey));
+        // Track the matched project for CLI display
+        if (sessionKey)
+            this._lastMatchedProject.set(sessionKey, matchedProject);
         if (matchedProject) {
             logger.info({ project: matchedProject.path }, 'Auto-matched project from message');
             const projName = path.basename(matchedProject.path);
@@ -2133,13 +2167,17 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
             return;
         // Build compaction block for working memory
         const exchangeCount = this.exchangeCounts.get(sessionKey) ?? 0;
+        const COMPACTION_START = '<!-- COMPACTION_START -->';
+        const COMPACTION_END = '<!-- COMPACTION_END -->';
         const compactionBlock = [
+            COMPACTION_START,
             `## Session Compaction (auto-generated)`,
             `Session ${sessionKey} compacted at ${exchangeCount} exchanges.`,
             ``,
             summary,
             ``,
             `*Continue from where this conversation left off.*`,
+            COMPACTION_END,
         ].join('\n');
         // Write to working memory so the next session picks it up via system prompt
         try {
@@ -2150,11 +2188,23 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
             const existing = fs.existsSync(compactionWmFile)
                 ? fs.readFileSync(compactionWmFile, 'utf-8')
                 : '';
-            // Replace any prior compaction block, or append
-            const compactionRegex = /## Session Compaction \(auto-generated\)[\s\S]*?\*Continue from where this conversation left off\.\*/;
-            const updated = compactionRegex.test(existing)
-                ? existing.replace(compactionRegex, compactionBlock)
-                : existing.trimEnd() + '\n\n' + compactionBlock;
+            // Replace any prior compaction block (try new sentinel format first, then legacy)
+            const sentinelRegex = /<!-- COMPACTION_START -->[\s\S]*?<!-- COMPACTION_END -->/;
+            const legacyRegex = /## Session Compaction \(auto-generated\)[\s\S]*?\*Continue from where this conversation left off\.\*/;
+            let updated;
+            if (sentinelRegex.test(existing)) {
+                updated = existing.replace(sentinelRegex, compactionBlock);
+            }
+            else if (legacyRegex.test(existing)) {
+                updated = existing.replace(legacyRegex, compactionBlock);
+            }
+            else {
+                updated = existing.trimEnd() + '\n\n' + compactionBlock;
+            }
+            // Size guard: if working memory exceeds 10KB, keep only the compaction block
+            if (Buffer.byteLength(updated) > 10_240) {
+                updated = compactionBlock;
+            }
             fs.writeFileSync(compactionWmFile, updated);
         }
         catch {
@@ -2164,8 +2214,24 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
         // The working memory summary will provide continuity
         this.sessions.delete(sessionKey);
         this.exchangeCounts.set(sessionKey, 0);
+        this.lastExchanges.delete(sessionKey);
+        this.sessionTimestamps.delete(sessionKey);
+        this.stallNudges.delete(sessionKey);
         this.saveSessions();
     }
+    /**
+     * Expire sessions inactive for more than 24 hours.
+     * Called periodically from chat() to prevent unbounded map growth.
+     */
+    expireOldSessions() {
+        const MAX_AGE_MS = 24 * 60 * 60 * 1000;
+        const now = Date.now();
+        for (const [key, ts] of this.sessionTimestamps) {
+            if (now - ts.getTime() > MAX_AGE_MS) {
+                this.clearSession(key);
+            }
+        }
+    }
     // ── Session Summarization ─────────────────────────────────────────
     /**
      * Build an instant local summary from in-memory exchange history.
@@ -3879,8 +3945,13 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
         this.sessionTimestamps.delete(sessionKey);
         this.lastExchanges.delete(sessionKey);
         this.stallNudges.delete(sessionKey);
+        this._lastMatchedProject.delete(sessionKey);
         this.saveSessions();
     }
+    /** Get the last auto-matched project for a session (for CLI display). */
+    getLastMatchedProject(sessionKey) {
+        return this._lastMatchedProject.get(sessionKey) ?? null;
+    }
     getProfileManager() {
         return this.profileManager;
     }

package/dist/cli/chat.js

@@ -198,12 +198,35 @@ export async function cmdChat(opts) {
         }
         // ── Send message ──────────────────────────────────────────
         process.stdout.write(`\n${DIM}thinking...${RESET}\r`);
+        let firstToken = true;
+        let streamedLen = 0;
         try {
-            const response = await gateway.handleMessage(sessionKey, effectiveText, undefined, oneOffModel);
-            // Clear "thinking..." line
-            process.stdout.write('\x1b[2K\r');
-            console.log(renderMarkdown(response));
-            console.log();
+            const response = await gateway.handleMessage(sessionKey, effectiveText, async (token) => {
+                if (firstToken) {
+                    // Clear "thinking..." and show project context on first real token
+                    process.stdout.write('\x1b[2K\r');
+                    const matched = gateway.getLastMatchedProject(sessionKey);
+                    if (matched) {
+                        process.stdout.write(`${DIM}[project: ${path.basename(matched.path)}]${RESET}\n`);
+                    }
+                    firstToken = false;
+                }
+                process.stdout.write(token);
+                streamedLen += token.length;
+            }, oneOffModel);
+            // If we streamed, just add a newline. Otherwise fall back to full render.
+            if (streamedLen > 0) {
+                process.stdout.write('\n\n');
+            }
+            else {
+                process.stdout.write('\x1b[2K\r');
+                const matched = gateway.getLastMatchedProject(sessionKey);
+                if (matched) {
+                    console.log(`${DIM}[project: ${path.basename(matched.path)}]${RESET}`);
+                }
+                console.log(renderMarkdown(response));
+                console.log();
+            }
         }
         catch (err) {
             process.stdout.write('\x1b[2K\r');

package/dist/cli/index.js

@@ -1295,6 +1295,131 @@ configCmd
     .command('list')
     .description('List all config values')
     .action(cmdConfigList);
+configCmd
+    .command('edit')
+    .description('Open .env in your editor')
+    .action(() => {
+    if (!existsSync(ENV_PATH)) {
+        console.log('  No .env file found. Run: clementine config setup');
+        process.exit(1);
+    }
+    const editor = process.env.EDITOR || process.env.VISUAL || 'vi';
+    try {
+        execSync(`${editor} "${ENV_PATH}"`, { stdio: 'inherit' });
+    }
+    catch {
+        console.error(`  Failed to open editor: ${editor}`);
+    }
+});
+// ── Memory commands ─────────────────────────────────────────────────
+const memoryCmd = program
+    .command('memory')
+    .description('Search and manage memory');
+memoryCmd
+    .command('search <query>')
+    .description('Search memory (full-text)')
+    .option('-n, --limit <n>', 'Max results', '10')
+    .action(async (query, opts) => {
+    const DIM = '\x1b[0;90m';
+    const BOLD = '\x1b[1m';
+    const CYAN = '\x1b[0;36m';
+    const RESET = '\x1b[0m';
+    try {
+        const { MemoryStore } = await import('../memory/store.js');
+        const VAULT_DIR = path.join(BASE_DIR, 'vault');
+        const DB_PATH = path.join(VAULT_DIR, '.memory.db');
+        const store = new MemoryStore(DB_PATH, VAULT_DIR);
+        const results = store.searchFts(query, parseInt(opts.limit, 10));
+        if (results.length === 0) {
+            console.log(`  No results for "${query}".`);
+            return;
+        }
+        console.log();
+        for (const r of results) {
+            const source = r.sourceFile ? path.basename(r.sourceFile) : 'unknown';
+            const section = r.section || '';
+            const snippet = r.content.replace(/\n/g, ' ').slice(0, 120);
+            console.log(`  ${BOLD}${source}${RESET}${section ? ` › ${CYAN}${section}${RESET}` : ''}`);
+            console.log(`  ${DIM}${snippet}${snippet.length >= 120 ? '…' : ''}${RESET}`);
+            console.log();
+        }
+    }
+    catch (err) {
+        console.error(`  Error searching memory: ${err}`);
+    }
+});
+// ── Projects commands ───────────────────────────────────────────────
+const projectsCmd = program
+    .command('projects')
+    .description('Manage linked projects');
+projectsCmd
+    .command('list')
+    .description('Show all linked projects')
+    .action(async () => {
+    const DIM = '\x1b[0;90m';
+    const BOLD = '\x1b[1m';
+    const RESET = '\x1b[0m';
+    try {
+        const { getLinkedProjects } = await import('../agent/assistant.js');
+        const projects = getLinkedProjects();
+        if (projects.length === 0) {
+            console.log('  No projects linked. Use: clementine projects add <path>');
+            return;
+        }
+        console.log();
+        for (const p of projects) {
+            console.log(`  ${BOLD}${path.basename(p.path)}${RESET}`);
+            console.log(`  ${DIM}${p.path}${RESET}`);
+            if (p.description)
+                console.log(`  ${p.description}`);
+            if (p.keywords?.length)
+                console.log(`  ${DIM}Keywords: ${p.keywords.join(', ')}${RESET}`);
+            console.log();
+        }
+    }
+    catch (err) {
+        console.error(`  Error listing projects: ${err}`);
+    }
+});
+projectsCmd
+    .command('add <path>')
+    .description('Link a project directory')
+    .option('-d, --description <desc>', 'Project description')
+    .option('-k, --keywords <kw>', 'Comma-separated keywords')
+    .action(async (projectPath, opts) => {
+    const resolved = path.resolve(projectPath);
+    if (!existsSync(resolved) || !statSync(resolved).isDirectory()) {
+        console.error(`  Not a directory: ${resolved}`);
+        process.exit(1);
+    }
+    try {
+        const { addProject } = await import('../agent/assistant.js');
+        const keywords = opts.keywords?.split(',').map(k => k.trim()).filter(Boolean);
+        addProject(resolved, opts.description, keywords);
+        console.log(`  Linked: ${resolved}`);
+    }
+    catch (err) {
+        console.error(`  Error adding project: ${err}`);
+    }
+});
+projectsCmd
+    .command('remove <path>')
+    .description('Unlink a project directory')
+    .action(async (projectPath) => {
+    const resolved = path.resolve(projectPath);
+    try {
+        const { removeProject } = await import('../agent/assistant.js');
+        if (removeProject(resolved)) {
+            console.log(`  Removed: ${resolved}`);
+        }
+        else {
+            console.log(`  Not found: ${resolved}`);
+        }
+    }
+    catch (err) {
+        console.error(`  Error removing project: ${err}`);
+    }
+});
 // ── Update command ──────────────────────────────────────────────────
 async function cmdUpdate(options) {
     const DIM = '\x1b[0;90m';

package/dist/config.d.ts

@@ -117,8 +117,8 @@ export declare const LINK_EXTRACT_MAX_URLS = 3;
 export declare const LINK_EXTRACT_MAX_CHARS = 4000;
 export declare const MEMORY_DB_PATH: string;
 export declare const GRAPH_DB_DIR: string;
-export declare const SEARCH_CONTEXT_LIMIT = 3;
-export declare const SEARCH_RECENCY_LIMIT = 3;
+export declare const SEARCH_CONTEXT_LIMIT = 6;
+export declare const SEARCH_RECENCY_LIMIT = 4;
 export declare const SYSTEM_PROMPT_MAX_CONTEXT_CHARS = 12000;
 export declare const SESSION_EXCHANGE_HISTORY_SIZE = 10;
 export declare const SESSION_EXCHANGE_MAX_CHARS = 2000;

package/dist/config.js

@@ -239,8 +239,8 @@ export const LINK_EXTRACT_MAX_CHARS = 4000;
 // ── Memory / Search ──────────────────────────────────────────────────
 export const MEMORY_DB_PATH = path.join(VAULT_DIR, '.memory.db');
 export const GRAPH_DB_DIR = path.join(BASE_DIR, '.graph.db');
-export const SEARCH_CONTEXT_LIMIT = 3;
-export const SEARCH_RECENCY_LIMIT = 3;
+export const SEARCH_CONTEXT_LIMIT = 6;
+export const SEARCH_RECENCY_LIMIT = 4;
 export const SYSTEM_PROMPT_MAX_CONTEXT_CHARS = 12000;
 // ── Session Persistence ──────────────────────────────────────────────
 export const SESSION_EXCHANGE_HISTORY_SIZE = 10;

package/dist/gateway/router.d.ts

@@ -196,6 +196,11 @@ export declare class Gateway {
         memoryCount: number;
     };
     clearSession(sessionKey: string): void;
+    /** Get the last auto-matched project for a session. */
+    getLastMatchedProject(sessionKey: string): {
+        path: string;
+        description?: string;
+    } | null;
     /** Evict stale session entries (no activity in 48h, no active lock). */
     evictStaleSessions(): number;
     /** Get all active session provenance entries (for dashboard/monitoring). */

package/dist/gateway/router.js

@@ -1195,6 +1195,10 @@ export class Gateway {
         this.assistant.clearSession(sessionKey);
         this.sessions.delete(sessionKey);
     }
+    /** Get the last auto-matched project for a session. */
+    getLastMatchedProject(sessionKey) {
+        return this.assistant.getLastMatchedProject(sessionKey);
+    }
     /** Evict stale session entries (no activity in 48h, no active lock). */
     evictStaleSessions() {
         const cutoff = Date.now() - 48 * 60 * 60 * 1000;

package/dist/index.js

@@ -545,6 +545,33 @@ async function asyncMain() {
     // Agent layer
     const { PersonalAssistant } = await import('./agent/assistant.js');
     const assistant = new PersonalAssistant();
+    // Memory maintenance — startup + periodic (non-blocking)
+    let maintenanceInterval;
+    {
+        const memStore = assistant.getMemoryStore();
+        if (memStore) {
+            const { runStartupMaintenance, startPeriodicMaintenance } = await import('./memory/maintenance.js');
+            // Fire-and-forget startup maintenance
+            runStartupMaintenance(memStore).catch(() => { });
+            // Periodic maintenance every 6 hours (consolidation needs an LLM caller)
+            const { query } = await import('@anthropic-ai/claude-agent-sdk');
+            const llmCall = async (prompt) => {
+                try {
+                    let result = '';
+                    const stream = query({ prompt, options: { model: 'claude-haiku-4-5-20251001', maxTurns: 1, systemPrompt: 'You are a memory consolidation assistant. Be concise.' } });
+                    for await (const msg of stream) {
+                        if (msg.type === 'result')
+                            result = msg.result ?? '';
+                    }
+                    return result;
+                }
+                catch {
+                    return '';
+                }
+            };
+            maintenanceInterval = startPeriodicMaintenance(memStore, llmCall);
+        }
+    }
     // Gateway layer
     const { Gateway } = await import('./gateway/router.js');
     const gateway = new Gateway(assistant);
@@ -833,6 +860,8 @@ async function asyncMain() {
     clearInterval(timerInterval);
     clearInterval(teamDeliveryInterval);
     clearInterval(sourceEditInterval);
+    if (maintenanceInterval)
+        clearInterval(maintenanceInterval);
     // Close graph store FIRST — FalkorDBLite's cleanup.js registers an
     // uncaughtException handler that re-throws errors.  If a Redis socket
     // drops during the drain wait, that handler crashes the process.

package/dist/memory/maintenance.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Clementine TypeScript — Automatic Memory Maintenance.
+ *
+ * Runs startup and periodic maintenance so the memory store stays healthy
+ * without manual intervention. New users get this out of the box.
+ *
+ * Startup: decay salience, prune stale data, backfill embeddings
+ * Periodic (every 6h): full consolidation cycle + embedding rebuild
+ */
+/**
+ * Run one-time maintenance at daemon startup.
+ * Non-blocking — errors are logged but never thrown.
+ */
+export declare function runStartupMaintenance(store: any): Promise<void>;
+/**
+ * Start periodic maintenance on a 6-hour interval.
+ * Returns the interval handle for cleanup on shutdown.
+ */
+export declare function startPeriodicMaintenance(store: any, llmCall?: (prompt: string) => Promise<string>): ReturnType<typeof setInterval>;
+//# sourceMappingURL=maintenance.d.ts.map

package/dist/memory/maintenance.js

@@ -0,0 +1,121 @@
+/**
+ * Clementine TypeScript — Automatic Memory Maintenance.
+ *
+ * Runs startup and periodic maintenance so the memory store stays healthy
+ * without manual intervention. New users get this out of the box.
+ *
+ * Startup: decay salience, prune stale data, backfill embeddings
+ * Periodic (every 6h): full consolidation cycle + embedding rebuild
+ */
+import pino from 'pino';
+const logger = pino({ name: 'clementine.maintenance' });
+const PERIODIC_INTERVAL_MS = 6 * 60 * 60 * 1000; // 6 hours
+/**
+ * Run one-time maintenance at daemon startup.
+ * Non-blocking — errors are logged but never thrown.
+ */
+export async function runStartupMaintenance(store) {
+    const start = Date.now();
+    logger.info('Starting memory maintenance (startup)');
+    try {
+        const decayed = store.decaySalience?.();
+        if (decayed)
+            logger.info({ decayed }, 'Salience decay applied');
+    }
+    catch (err) {
+        logger.warn({ err }, 'Salience decay failed');
+    }
+    try {
+        const pruned = store.pruneStaleData?.();
+        if (pruned)
+            logger.info(pruned, 'Stale data pruned');
+    }
+    catch (err) {
+        logger.warn({ err }, 'Stale data pruning failed');
+    }
+    try {
+        const embedded = store.buildEmbeddings?.();
+        if (embedded)
+            logger.info(embedded, 'Embeddings built/backfilled');
+    }
+    catch (err) {
+        logger.warn({ err }, 'Embedding backfill failed');
+    }
+    // Prune old extraction logs (keep active extractions regardless of age)
+    try {
+        const conn = store.conn;
+        if (conn) {
+            const result = conn.prepare(`DELETE FROM memory_extractions
+         WHERE extracted_at < datetime('now', '-90 days')
+         AND status != 'active'`).run();
+            if (result.changes > 0) {
+                logger.info({ pruned: result.changes }, 'Old extraction logs pruned');
+            }
+        }
+    }
+    catch {
+        // Table may not exist yet — non-fatal
+    }
+    logger.info({ durationMs: Date.now() - start }, 'Startup maintenance complete');
+}
+/**
+ * Start periodic maintenance on a 6-hour interval.
+ * Returns the interval handle for cleanup on shutdown.
+ */
+export function startPeriodicMaintenance(store, llmCall) {
+    const runCycle = async () => {
+        const start = Date.now();
+        logger.info('Starting periodic memory maintenance');
+        // 1. Decay + prune
+        try {
+            store.decaySalience?.();
+        }
+        catch (err) {
+            logger.warn({ err }, 'Periodic decay failed');
+        }
+        try {
+            store.pruneStaleData?.();
+        }
+        catch (err) {
+            logger.warn({ err }, 'Periodic prune failed');
+        }
+        // 2. Rebuild vocab + backfill embeddings
+        try {
+            store.buildEmbeddings?.();
+        }
+        catch (err) {
+            logger.warn({ err }, 'Periodic embedding build failed');
+        }
+        // 3. Consolidation (dedup, summarize, extract principles)
+        if (llmCall) {
+            try {
+                const { runConsolidation } = await import('./consolidation.js');
+                const result = await runConsolidation(store, llmCall);
+                logger.info(result, 'Consolidation cycle complete');
+            }
+            catch (err) {
+                logger.warn({ err }, 'Consolidation failed');
+            }
+            // 4. Re-backfill embeddings for any new summary chunks from consolidation
+            try {
+                store.buildEmbeddings?.();
+            }
+            catch (err) {
+                logger.warn({ err }, 'Post-consolidation embedding build failed');
+            }
+        }
+        // 5. Extraction log pruning
+        try {
+            const conn = store.conn;
+            if (conn) {
+                conn.prepare(`DELETE FROM memory_extractions
+           WHERE extracted_at < datetime('now', '-90 days')
+           AND status != 'active'`).run();
+            }
+        }
+        catch { /* non-fatal */ }
+        logger.info({ durationMs: Date.now() - start }, 'Periodic maintenance complete');
+    };
+    return setInterval(runCycle, PERIODIC_INTERVAL_MS);
+}
+//# sourceMappingURL=maintenance.js.map

package/dist/memory/store.js

@@ -748,9 +748,7 @@ export class MemoryStore {
         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 AND consolidated = 0
-         ORDER BY updated_at DESC
-         LIMIT 500`)
+         WHERE embedding IS NOT NULL`)
             .all();
         const scored = [];
         for (const row of rows) {
@@ -1616,10 +1614,18 @@ export class MemoryStore {
      */
     insertSummaryChunk(sourceFile, section, content) {
         const hash = createHash('sha256').update(content).digest('hex').slice(0, 16);
-        this.conn
+        const result = this.conn
             .prepare(`INSERT INTO chunks (source_file, section, content, chunk_type, content_hash, salience, consolidated)
          VALUES (?, ?, ?, 'summary', ?, 0.8, 0)`)
             .run(sourceFile, section, content, hash);
+        // Immediately compute embedding so the summary is vector-searchable right away
+        if (embeddingsModule.isReady()) {
+            const vec = embeddingsModule.embed(content);
+            if (vec) {
+                this.conn.prepare('UPDATE chunks SET embedding = ? WHERE id = ?')
+                    .run(embeddingsModule.serializeEmbedding(vec), result.lastInsertRowid);
+            }
+        }
     }
     // ── SDR Operational Data ─────────────────────────────────────────
     // -- Leads --
@@ -1912,17 +1918,17 @@ export class MemoryStore {
     buildEmbeddings() {
         // Gather all chunk contents for vocabulary building
         const rows = this.conn
-            .prepare('SELECT id, content FROM chunks WHERE consolidated = 0')
+            .prepare('SELECT id, content FROM chunks')
             .all();
         if (rows.length === 0)
             return { vocabSize: 0, backfilled: 0 };
-        // Build vocabulary from corpus
+        // Build vocabulary from entire corpus (including consolidated summaries)
         embeddingsModule.buildVocab(rows.map((r) => r.content));
         if (!embeddingsModule.isReady())
             return { vocabSize: 0, backfilled: 0 };
-        // Backfill embeddings for chunks that don't have one
+        // Backfill embeddings for all chunks that don't have one
         const missing = this.conn
-            .prepare('SELECT id, content FROM chunks WHERE embedding IS NULL AND consolidated = 0')
+            .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;

package/package.json

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