clementine-agent 1.2.1 → 1.2.3

package/dist/config.d.ts

@@ -59,6 +59,15 @@ export declare const BUDGET: {
     summarization: undefined;
     reflection: undefined;
 };
+export declare const MEMORY_JANITOR: {
+    consolidatedExpireDays: number;
+    consolidatedSalienceFloor: number;
+    softDeleteGraceDays: number;
+    auxRetentionDays: number;
+    extractionsMaxRows: number;
+    vacuumIntervalDays: number;
+    vacuumIdleSeconds: number;
+};
 export declare const TASK_BUDGET_TOKENS: {
     heartbeat: number | undefined;
     cronT1: number | undefined;
@@ -159,6 +168,8 @@ export declare const VAULT_MIGRATIONS_STATE: string;
 export declare const PLANS_DIR: string;
 export declare const ADVISOR_LOG_PATH: string;
 export declare const REMOTE_ACCESS_CONFIG: string;
+/** Persistent session store for the dashboard /auth flow (mode 0600 enforced on write). */
+export declare const SESSIONS_FILE: string;
 export declare const STAGING_DIR: string;
 export declare const ALLOW_SOURCE_EDITS: boolean;
 export declare const ADVISOR_RULES_LOADER: 'off' | 'shadow' | 'primary';

package/dist/config.js

@@ -195,6 +195,20 @@ export const BUDGET = {
     summarization: undefined,
     reflection: undefined,
 };
+// ── Memory janitor (bounded-growth maintenance) ─────────────────────
+// Two-phase delete: consolidated chunks with low salience and no recent
+// access get soft-deleted, then physically deleted after a grace period.
+// Aux tables (recall_traces, access_log, outcomes) cap at a rolling window.
+// VACUUM runs at most once per N days, only when daemon is idle.
+export const MEMORY_JANITOR = {
+    consolidatedExpireDays: getEnvOrJsonNumber('MEMORY_CONSOLIDATED_EXPIRE_DAYS', undefined, 60),
+    consolidatedSalienceFloor: getEnvOrJsonNumber('MEMORY_CONSOLIDATED_SALIENCE_FLOOR', undefined, 0.2),
+    softDeleteGraceDays: getEnvOrJsonNumber('MEMORY_SOFT_DELETE_GRACE_DAYS', undefined, 14),
+    auxRetentionDays: getEnvOrJsonNumber('MEMORY_AUX_RETENTION_DAYS', undefined, 30),
+    extractionsMaxRows: getEnvOrJsonNumber('MEMORY_EXTRACTIONS_MAX_ROWS', undefined, 50000),
+    vacuumIntervalDays: getEnvOrJsonNumber('MEMORY_VACUUM_INTERVAL_DAYS', undefined, 7),
+    vacuumIdleSeconds: getEnvOrJsonNumber('MEMORY_VACUUM_IDLE_SECONDS', undefined, 300),
+};
 // ── Task budget caps (tokens per query) ──────────────────────────────
 // Passed to the Claude Agent SDK as `taskBudget: { total }`. The model is
 // told its remaining token budget so it can pace tool use and wrap up
@@ -383,6 +397,8 @@ export const PLANS_DIR = path.join(BASE_DIR, 'plans');
 export const ADVISOR_LOG_PATH = path.join(BASE_DIR, 'cron', 'advisor-decisions.jsonl');
 // ── Remote Access ──────────────────────────────────────────────────
 export const REMOTE_ACCESS_CONFIG = path.join(BASE_DIR, 'remote-access.json');
+/** Persistent session store for the dashboard /auth flow (mode 0600 enforced on write). */
+export const SESSIONS_FILE = path.join(BASE_DIR, '.sessions.json');
 // ── Source Self-Edit Staging ─────────────────────────────────────────
 export const STAGING_DIR = path.join(BASE_DIR, 'staging');
 // Source self-editing is deprecated. The data-driven path (advisor rules,

package/dist/index.js

@@ -608,6 +608,15 @@ async function asyncMain() {
     {
         const memStore = assistant.getMemoryStore();
         if (memStore) {
+            // Async write queue: route transcript saves, recall traces, outcomes,
+            // and access-log inserts off the request thread. ~250ms flush window;
+            // drained on shutdown below. Idempotent — safe if called twice.
+            try {
+                memStore.enableWriteQueue();
+            }
+            catch (err) {
+                logger.warn({ err }, 'Failed to enable memory write queue — falling back to sync writes');
+            }
             const { runStartupMaintenance, startPeriodicMaintenance } = await import('./memory/maintenance.js');
             // Fire-and-forget startup maintenance
             runStartupMaintenance(memStore).catch(() => { });
@@ -999,6 +1008,17 @@ async function asyncMain() {
     catch (err) {
         logger.warn({ err }, 'Session flush on shutdown failed');
     }
+    // Drain the memory write queue so transcripts/recall traces/outcomes/access
+    // logs that were enqueued in the last <250ms make it to SQLite.
+    try {
+        const memStore = assistant.getMemoryStore();
+        if (memStore && typeof memStore.flushWrites === 'function') {
+            await memStore.flushWrites();
+        }
+    }
+    catch (err) {
+        logger.warn({ err }, 'Memory write queue drain failed');
+    }
     // Now safe to tear down remaining infrastructure
     heartbeat.stop();
     cronScheduler.stop();

package/dist/memory/chunker.js

@@ -22,6 +22,13 @@ const DIR_CATEGORY_MAP = {
     '05-Tasks': 'advice',
     '07-Inbox': 'events',
 };
+/**
+ * Procedural memory: learned workflows live in 00-System/procedures/.
+ * Frontmatter `triggers: [verb-phrases]` is parsed separately by the store
+ * and used at retrieval time to boost the chunk when a query mentions one
+ * of the trigger verbs. Pattern adopted from Mem0's v1.0.0 procedural tier.
+ */
+const PROCEDURE_DIR = '00-System/procedures';
 /** Content keyword patterns for category detection (used as fallback). */
 const CATEGORY_KEYWORDS = [
     [/\b(prefer|always use|never use|i like|i don'?t like|i hate)\b/i, 'preferences'],
@@ -37,11 +44,15 @@ function detectCategoryAndTopic(relPath, frontmatter, content) {
     // 1. Explicit frontmatter category
     if (frontmatter.category) {
         const fm = String(frontmatter.category).toLowerCase();
-        if (['facts', 'events', 'discoveries', 'preferences', 'advice'].includes(fm)) {
+        if (['facts', 'events', 'discoveries', 'preferences', 'advice', 'procedure'].includes(fm)) {
             category = fm;
         }
     }
-    // 2. Directory-based
+    // 2. Procedure directory (overrides directory map below).
+    if (!category && relPath.startsWith(PROCEDURE_DIR)) {
+        category = 'procedure';
+    }
+    // 3. Directory-based
     if (!category) {
         const topDir = relPath.split('/')[0];
         category = DIR_CATEGORY_MAP[topDir] ?? null;

package/dist/memory/hot-cache.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Tiny in-process LRU for hot chunk-row reads.
+ *
+ * Use case: searchContext + recall-trace expansion + dashboard chunk view all
+ * funnel through getChunksByIds, which often touches the same hot rows
+ * many times within a session. SQLite reads are already fast (microseconds),
+ * but the LRU eliminates the per-query overhead and lets us amortize the
+ * row-shape unpacking that getChunksByIds does.
+ *
+ * Bounded: capacity ~1000 by default (~1MB at 1KB/chunk). Map preserves
+ * insertion order, so we delete-then-set on access to keep most-recent at
+ * the tail and evict from the head.
+ *
+ * Concurrency: single-process daemon, single thread — no locking needed.
+ */
+export declare class HotCache<K, V> {
+    private map;
+    private capacity;
+    private hits;
+    private misses;
+    private evictions;
+    constructor(capacity?: number);
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+    delete(key: K): boolean;
+    /** Drop all entries — call when bulk-rebuilding the underlying store. */
+    clear(): void;
+    size(): number;
+    stats(): {
+        hits: number;
+        misses: number;
+        evictions: number;
+        size: number;
+        capacity: number;
+        hitRate: number;
+    };
+}
+//# sourceMappingURL=hot-cache.d.ts.map

package/dist/memory/hot-cache.js

@@ -0,0 +1,73 @@
+/**
+ * Tiny in-process LRU for hot chunk-row reads.
+ *
+ * Use case: searchContext + recall-trace expansion + dashboard chunk view all
+ * funnel through getChunksByIds, which often touches the same hot rows
+ * many times within a session. SQLite reads are already fast (microseconds),
+ * but the LRU eliminates the per-query overhead and lets us amortize the
+ * row-shape unpacking that getChunksByIds does.
+ *
+ * Bounded: capacity ~1000 by default (~1MB at 1KB/chunk). Map preserves
+ * insertion order, so we delete-then-set on access to keep most-recent at
+ * the tail and evict from the head.
+ *
+ * Concurrency: single-process daemon, single thread — no locking needed.
+ */
+export class HotCache {
+    map = new Map();
+    capacity;
+    hits = 0;
+    misses = 0;
+    evictions = 0;
+    constructor(capacity = 1000) {
+        this.capacity = capacity;
+    }
+    get(key) {
+        const v = this.map.get(key);
+        if (v === undefined) {
+            this.misses++;
+            return undefined;
+        }
+        // Bump to most-recent.
+        this.map.delete(key);
+        this.map.set(key, v);
+        this.hits++;
+        return v;
+    }
+    set(key, value) {
+        if (this.map.has(key)) {
+            this.map.delete(key);
+        }
+        else if (this.map.size >= this.capacity) {
+            // Evict oldest (first inserted).
+            const oldestKey = this.map.keys().next().value;
+            if (oldestKey !== undefined) {
+                this.map.delete(oldestKey);
+                this.evictions++;
+            }
+        }
+        this.map.set(key, value);
+    }
+    delete(key) {
+        return this.map.delete(key);
+    }
+    /** Drop all entries — call when bulk-rebuilding the underlying store. */
+    clear() {
+        this.map.clear();
+    }
+    size() {
+        return this.map.size;
+    }
+    stats() {
+        const total = this.hits + this.misses;
+        return {
+            hits: this.hits,
+            misses: this.misses,
+            evictions: this.evictions,
+            size: this.map.size,
+            capacity: this.capacity,
+            hitRate: total > 0 ? this.hits / total : 0,
+        };
+    }
+}
+//# sourceMappingURL=hot-cache.js.map

package/dist/memory/integrity.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Memory store integrity probes — self-healing checks that run on the
+ * janitor's periodic cycle. Each probe is independent and conservative:
+ *  - reports what it found,
+ *  - repairs only when the fix is non-destructive,
+ *  - never throws (logs and continues).
+ *
+ * Three checks today (the cheap, high-value ones):
+ *   1. FTS5 contentless-table integrity → auto-rebuild on failure
+ *   2. derived_from references to deleted chunks → nullify the dangling refs
+ *   3. chunks with content but no embedding → return count for backfill
+ *
+ * Graph reachability is intentionally NOT probed here — it lives in
+ * graph-store.ts's own health probe, which auto-restarts FalkorDB.
+ */
+export interface IntegrityReport {
+    ftsOk: boolean;
+    ftsRebuilt: boolean;
+    orphanRefsNulled: number;
+    missingEmbeddings: number;
+}
+/**
+ * Run all probes and apply safe repairs. Returns a report; never throws.
+ * The store argument is typed loose so this module can be called from
+ * maintenance.ts without an import cycle.
+ */
+export declare function runIntegrityProbes(store: any): IntegrityReport;
+//# sourceMappingURL=integrity.d.ts.map

package/dist/memory/integrity.js

@@ -0,0 +1,119 @@
+/**
+ * Memory store integrity probes — self-healing checks that run on the
+ * janitor's periodic cycle. Each probe is independent and conservative:
+ *  - reports what it found,
+ *  - repairs only when the fix is non-destructive,
+ *  - never throws (logs and continues).
+ *
+ * Three checks today (the cheap, high-value ones):
+ *   1. FTS5 contentless-table integrity → auto-rebuild on failure
+ *   2. derived_from references to deleted chunks → nullify the dangling refs
+ *   3. chunks with content but no embedding → return count for backfill
+ *
+ * Graph reachability is intentionally NOT probed here — it lives in
+ * graph-store.ts's own health probe, which auto-restarts FalkorDB.
+ */
+import pino from 'pino';
+const logger = pino({ name: 'clementine.integrity' });
+/**
+ * Run all probes and apply safe repairs. Returns a report; never throws.
+ * The store argument is typed loose so this module can be called from
+ * maintenance.ts without an import cycle.
+ */
+export function runIntegrityProbes(store) {
+    const report = {
+        ftsOk: true,
+        ftsRebuilt: false,
+        orphanRefsNulled: 0,
+        missingEmbeddings: 0,
+    };
+    // 1. FTS5 integrity. Contentless tables can corrupt under specific failure
+    //    modes (process kill mid-trigger, manual SQL on chunks_fts, etc.).
+    //    integrity-check returns 'ok' on success; rebuild is the standard fix.
+    try {
+        const conn = store.conn;
+        if (conn) {
+            try {
+                const row = conn.prepare(`INSERT INTO chunks_fts(chunks_fts) VALUES('integrity-check') RETURNING ''`).get();
+                // 'integrity-check' is a no-op insert that throws on failure. If we
+                // got a row back, FTS is fine. (Some SQLite builds don't support the
+                // RETURNING form on virtual tables — fall back to plain run().)
+                void row;
+            }
+            catch (innerErr) {
+                // Try the plain form before declaring failure.
+                try {
+                    conn.prepare(`INSERT INTO chunks_fts(chunks_fts) VALUES('integrity-check')`).run();
+                }
+                catch {
+                    report.ftsOk = false;
+                    logger.warn({ err: innerErr }, 'FTS5 integrity check failed — rebuilding');
+                    try {
+                        conn.prepare(`INSERT INTO chunks_fts(chunks_fts) VALUES('rebuild')`).run();
+                        report.ftsRebuilt = true;
+                    }
+                    catch (rebuildErr) {
+                        logger.warn({ err: rebuildErr }, 'FTS5 rebuild failed');
+                    }
+                }
+            }
+        }
+    }
+    catch (err) {
+        logger.warn({ err }, 'FTS integrity probe error');
+    }
+    // 2. derived_from dangling references. Phase-2 janitor deletes a chunk
+    //    that was a source for a summary; we keep the summary but the JSON
+    //    array of source ids may now contain ids that no longer exist. Walk
+    //    summary chunks, prune missing ids; fully empty array → null.
+    try {
+        const conn = store.conn;
+        if (conn) {
+            const summaries = conn.prepare(`SELECT id, derived_from FROM chunks
+         WHERE derived_from IS NOT NULL AND derived_from != ''`).all();
+            const liveCheck = conn.prepare('SELECT 1 FROM chunks WHERE id = ?');
+            const updateStmt = conn.prepare('UPDATE chunks SET derived_from = ? WHERE id = ?');
+            for (const s of summaries) {
+                let ids;
+                try {
+                    ids = JSON.parse(s.derived_from);
+                }
+                catch {
+                    continue;
+                }
+                if (!Array.isArray(ids))
+                    continue;
+                const live = ids.filter((id) => {
+                    if (typeof id !== 'number')
+                        return false;
+                    return !!liveCheck.get(id);
+                });
+                if (live.length !== ids.length) {
+                    updateStmt.run(live.length === 0 ? null : JSON.stringify(live), s.id);
+                    report.orphanRefsNulled++;
+                }
+            }
+        }
+    }
+    catch (err) {
+        logger.warn({ err }, 'derived_from orphan probe failed');
+    }
+    // 3. Missing dense embeddings — a counter for the dashboard / next backfill
+    //    cycle. Doesn't repair (backfill is async + heavy); just surfaces.
+    try {
+        const conn = store.conn;
+        if (conn) {
+            const row = conn.prepare(`SELECT COUNT(*) AS c FROM chunks c
+         LEFT JOIN chunk_soft_deletes sd ON sd.chunk_id = c.id
+         WHERE sd.chunk_id IS NULL
+           AND c.embedding_dense IS NULL
+           AND length(c.content) > 0`).get();
+            report.missingEmbeddings = row.c;
+        }
+    }
+    catch (err) {
+        logger.warn({ err }, 'Missing-embedding probe failed');
+    }
+    return report;
+}
+//# sourceMappingURL=integrity.js.map

package/dist/memory/maintenance.d.ts

@@ -4,9 +4,30 @@
  * 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
+ * Startup: decay salience, prune stale data, backfill embeddings, run janitor
+ * Periodic (every 6h): full consolidation cycle + embedding rebuild + janitor
+ *                      + idle-gated VACUUM at most once per week
  */
+/**
+ * Janitor pass — keeps the store bounded. Safe to call repeatedly.
+ * Idempotent within a single run; surfaces totals for logging.
+ */
+export declare function runJanitor(store: any): {
+    softDeleted: number;
+    physicallyDeleted: number;
+    outcomesPruned: number;
+    extractionsCapped: number;
+};
+/**
+ * Run VACUUM if (a) it's been more than vacuumIntervalDays since the last
+ * one and (b) the store has been idle for at least vacuumIdleSeconds.
+ * Returns null when skipped, otherwise the size delta.
+ */
+export declare function maybeVacuum(store: any): {
+    sizeBeforeBytes: number;
+    sizeAfterBytes: number;
+    durationMs: number;
+} | null;
 /**
  * Run one-time maintenance at daemon startup.
  * Non-blocking — errors are logged but never thrown.

package/dist/memory/maintenance.js

@@ -4,12 +4,82 @@
  * 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
+ * Startup: decay salience, prune stale data, backfill embeddings, run janitor
+ * Periodic (every 6h): full consolidation cycle + embedding rebuild + janitor
+ *                      + idle-gated VACUUM at most once per week
  */
 import pino from 'pino';
+import { MEMORY_JANITOR } from '../config.js';
+import { runIntegrityProbes } from './integrity.js';
 const logger = pino({ name: 'clementine.maintenance' });
 const PERIODIC_INTERVAL_MS = 6 * 60 * 60 * 1000; // 6 hours
+const VACUUM_META_KEY = 'last_vacuum_at';
+/**
+ * Janitor pass — keeps the store bounded. Safe to call repeatedly.
+ * Idempotent within a single run; surfaces totals for logging.
+ */
+export function runJanitor(store) {
+    let softDeleted = 0;
+    let physicallyDeleted = 0;
+    try {
+        const result = store.expireConsolidated?.({
+            expireDays: MEMORY_JANITOR.consolidatedExpireDays,
+            salienceFloor: MEMORY_JANITOR.consolidatedSalienceFloor,
+            graceDays: MEMORY_JANITOR.softDeleteGraceDays,
+        });
+        if (result) {
+            softDeleted = result.softDeleted;
+            physicallyDeleted = result.physicallyDeleted;
+        }
+    }
+    catch (err) {
+        logger.warn({ err }, 'expireConsolidated failed');
+    }
+    let outcomesPruned = 0;
+    try {
+        outcomesPruned = store.pruneOutcomes?.(MEMORY_JANITOR.auxRetentionDays) ?? 0;
+    }
+    catch (err) {
+        logger.warn({ err }, 'pruneOutcomes failed');
+    }
+    let extractionsCapped = 0;
+    try {
+        extractionsCapped = store.capExtractions?.(MEMORY_JANITOR.extractionsMaxRows) ?? 0;
+    }
+    catch (err) {
+        logger.warn({ err }, 'capExtractions failed');
+    }
+    return { softDeleted, physicallyDeleted, outcomesPruned, extractionsCapped };
+}
+/**
+ * Run VACUUM if (a) it's been more than vacuumIntervalDays since the last
+ * one and (b) the store has been idle for at least vacuumIdleSeconds.
+ * Returns null when skipped, otherwise the size delta.
+ */
+export function maybeVacuum(store) {
+    try {
+        const lastIso = store.getMaintenanceMeta?.(VACUUM_META_KEY);
+        if (lastIso) {
+            const last = new Date(lastIso).getTime();
+            const ageMs = Date.now() - last;
+            if (ageMs < MEMORY_JANITOR.vacuumIntervalDays * 86_400_000)
+                return null;
+        }
+        const lastActivity = store.lastActivityAt?.();
+        if (lastActivity !== null && lastActivity !== undefined) {
+            const idleMs = Date.now() - lastActivity;
+            if (idleMs < MEMORY_JANITOR.vacuumIdleSeconds * 1000)
+                return null;
+        }
+        const result = store.vacuum?.();
+        store.setMaintenanceMeta?.(VACUUM_META_KEY, new Date().toISOString());
+        return result ?? null;
+    }
+    catch (err) {
+        logger.warn({ err }, 'VACUUM failed');
+        return null;
+    }
+}
 /**
  * Run one-time maintenance at daemon startup.
  * Non-blocking — errors are logged but never thrown.
@@ -56,6 +126,32 @@ export async function runStartupMaintenance(store) {
     catch {
         // Table may not exist yet — non-fatal
     }
+    // Janitor — bounded growth pass.
+    try {
+        const result = runJanitor(store);
+        if (result.softDeleted || result.physicallyDeleted || result.outcomesPruned || result.extractionsCapped) {
+            logger.info(result, 'Janitor pass complete');
+        }
+    }
+    catch (err) {
+        logger.warn({ err }, 'Startup janitor failed');
+    }
+    // Embedding warm-up — pre-embed the most-cited chunks in the background so
+    // the first retrievals after startup don't pay cold-start latency. Fire
+    // and forget; never blocks startup.
+    if (typeof store.warmDenseEmbeddings === 'function') {
+        void (async () => {
+            try {
+                const result = await store.warmDenseEmbeddings(200);
+                if (result.warmed > 0) {
+                    logger.info(result, 'Embedding warm-up complete');
+                }
+            }
+            catch (err) {
+                logger.warn({ err }, 'Embedding warm-up failed');
+            }
+        })();
+    }
     logger.info({ durationMs: Date.now() - start }, 'Startup maintenance complete');
 }
 /**
@@ -104,7 +200,7 @@ export function startPeriodicMaintenance(store, llmCall) {
                 logger.warn({ err }, 'Post-consolidation embedding build failed');
             }
         }
-        // 5. Extraction log pruning
+        // 5. Extraction log pruning (legacy 90-day rule retained alongside cap)
         try {
             const conn = store.conn;
             if (conn) {
@@ -114,6 +210,47 @@ export function startPeriodicMaintenance(store, llmCall) {
             }
         }
         catch { /* non-fatal */ }
+        // 6. Janitor — bounded growth.
+        try {
+            const result = runJanitor(store);
+            if (result.softDeleted || result.physicallyDeleted || result.outcomesPruned || result.extractionsCapped) {
+                logger.info(result, 'Janitor pass complete');
+            }
+        }
+        catch (err) {
+            logger.warn({ err }, 'Periodic janitor failed');
+        }
+        // 6b. Integrity probes — FTS health, orphan derived_from, embedding gaps.
+        try {
+            const report = runIntegrityProbes(store);
+            // Persist for the dashboard so the "last integrity check" surface
+            // doesn't depend on log scraping.
+            try {
+                store.setMaintenanceMeta?.('last_integrity_report', JSON.stringify({ ...report, ranAt: new Date().toISOString() }));
+            }
+            catch { /* meta write is best-effort */ }
+            if (!report.ftsOk || report.ftsRebuilt || report.orphanRefsNulled > 0 || report.missingEmbeddings > 0) {
+                logger.info(report, 'Integrity probes complete');
+            }
+        }
+        catch (err) {
+            logger.warn({ err }, 'Integrity probes failed');
+        }
+        // 7. VACUUM — idle-gated, at most once per vacuumIntervalDays.
+        try {
+            const vac = maybeVacuum(store);
+            if (vac) {
+                logger.info({
+                    sizeBeforeBytes: vac.sizeBeforeBytes,
+                    sizeAfterBytes: vac.sizeAfterBytes,
+                    reclaimedBytes: vac.sizeBeforeBytes - vac.sizeAfterBytes,
+                    durationMs: vac.durationMs,
+                }, 'VACUUM complete');
+            }
+        }
+        catch (err) {
+            logger.warn({ err }, 'Periodic VACUUM failed');
+        }
         logger.info({ durationMs: Date.now() - start }, 'Periodic maintenance complete');
     };
     return setInterval(runCycle, PERIODIC_INTERVAL_MS);

package/dist/memory/seed-user-model.d.ts

@@ -33,6 +33,8 @@ export interface UserModelProposals {
     /** Raw model output, for debugging. */
     rawResponse?: string;
 }
-export declare function seedUserModelFromMemory(store: SeedSourceStore, llmCall: (prompt: string) => Promise<string>): Promise<UserModelProposals>;
+export declare function seedUserModelFromMemory(store: SeedSourceStore, llmCall: (prompt: string) => Promise<string>, opts?: {
+    memoryFilePath?: string;
+}): Promise<UserModelProposals>;
 export {};
 //# sourceMappingURL=seed-user-model.d.ts.map

package/dist/memory/seed-user-model.js

@@ -18,13 +18,13 @@ const logger = pino({ name: 'clementine.seed-user-model' });
 const MAX_MEMORY_MD_CHARS = 4000;
 const MAX_CHUNK_CHARS = 4000;
 const MAX_SUMMARIES_CHARS = 1500;
-function gatherCorpus(store) {
+function gatherCorpus(store, memoryFilePath) {
     const parts = [];
     let sourceCount = 0;
     // 1. MEMORY.md — highest-signal source, the agent's curated profile note
-    if (existsSync(MEMORY_FILE)) {
+    if (existsSync(memoryFilePath)) {
         try {
-            const md = readFileSync(MEMORY_FILE, 'utf-8').slice(0, MAX_MEMORY_MD_CHARS);
+            const md = readFileSync(memoryFilePath, 'utf-8').slice(0, MAX_MEMORY_MD_CHARS);
             if (md.trim()) {
                 parts.push(`## MEMORY.md\n${md}`);
                 sourceCount++;
@@ -147,8 +147,9 @@ function parseProposals(raw) {
     }
     return out;
 }
-export async function seedUserModelFromMemory(store, llmCall) {
-    const { corpus, sourceCount } = gatherCorpus(store);
+export async function seedUserModelFromMemory(store, llmCall, opts = {}) {
+    const memFile = opts.memoryFilePath ?? MEMORY_FILE;
+    const { corpus, sourceCount } = gatherCorpus(store, memFile);
     if (!corpus.trim() || sourceCount === 0) {
         return {
             user_facts: '', goals: '', relationships: '', agent_persona: '',