clementine-agent 1.0.33 → 1.0.34

package/dist/memory/context-assembler.js

@@ -33,14 +33,15 @@ export async function assembleContext(options) {
             priority: 0,
             maxChars: 500,
             minRemainingBudget: 0,
-            resolve: () => {
+            resolve: (budget) => {
                 if (!fs.existsSync(idPath))
                     return '';
                 try {
                     const content = fs.readFileSync(idPath, 'utf-8').trim();
                     if (!content)
                         return '';
-                    return `## Identity\n\n${content}`;
+                    const block = `## Identity\n\n${content}`;
+                    return block.length > budget ? block.slice(0, budget) : block;
                 }
                 catch {
                     return '';
@@ -56,14 +57,15 @@ export async function assembleContext(options) {
             priority: 1,
             maxChars: isAutonomous ? 1000 : 2000,
             minRemainingBudget: 0,
-            resolve: () => {
+            resolve: (budget) => {
                 if (!fs.existsSync(wmPath))
                     return '';
                 try {
                     const content = fs.readFileSync(wmPath, 'utf-8').trim();
                     if (!content)
                         return '';
-                    return `## Working Memory (scratchpad)\n\n${content}`;
+                    const block = `## Working Memory (scratchpad)\n\n${content}`;
+                    return block.length > budget ? block.slice(0, budget) : block;
                 }
                 catch {
                     return '';
@@ -79,10 +81,15 @@ export async function assembleContext(options) {
             priority: 2,
             maxChars: isAutonomous ? 1000 : 2000,
             minRemainingBudget: 500,
-            resolve: () => skillCtx,
+            resolve: (budget) => skillCtx.length > budget ? skillCtx.slice(0, budget) : skillCtx,
         });
     }
     // Slot 3: Memory search results (core recall)
+    // formatResultsForPrompt respects the effective budget and breaks on
+    // entry boundaries (not mid-string), so we don't need the outer
+    // slice-truncation to kick in here. Previously this slot was double-
+    // truncated: formatter used its own 8000 cap, then the outer loop cut
+    // further by Math.min(maxChars, remaining), chopping entries in half.
     if (options.memoryResults && options.memoryResults.length > 0) {
         const results = options.memoryResults;
         slots.push({
@@ -90,10 +97,7 @@ export async function assembleContext(options) {
             priority: 3,
             maxChars: isAutonomous ? 2000 : 8000,
             minRemainingBudget: 200,
-            resolve: () => {
-                // formatResultsForPrompt already handles truncation within its own budget
-                return formatResultsForPrompt(results, isAutonomous ? 2000 : 8000);
-            },
+            resolve: (budget) => formatResultsForPrompt(results, budget),
         });
     }
     // Slot 4: Graph relationships (supplementary)
@@ -104,7 +108,7 @@ export async function assembleContext(options) {
             priority: 4,
             maxChars: 2000,
             minRemainingBudget: 500,
-            resolve: () => graphCtx,
+            resolve: (budget) => graphCtx.length > budget ? graphCtx.slice(0, budget) : graphCtx,
         });
     }
     // Sort by priority (lower number = higher priority)
@@ -121,18 +125,27 @@ export async function assembleContext(options) {
             continue;
         }
         try {
-            let content = await slot.resolve();
+            // The slot's effective budget is the smaller of its own maxChars and
+            // what's actually remaining across all slots. Passed into resolve so
+            // the slot produces right-sized content up front, not a mid-entry
+            // truncation after the fact.
+            const effectiveBudget = Math.min(slot.maxChars, remaining);
+            const content = await slot.resolve(effectiveBudget);
             if (!content) {
                 skipped.push(slot.name);
                 continue;
             }
-            // Truncate to the smaller of slot max and remaining budget
-            const limit = Math.min(slot.maxChars, remaining);
-            if (content.length > limit) {
-                content = content.slice(0, limit) + '\n...(truncated)';
+            // Safety net: if resolve() ignored the budget and returned too much,
+            // clip at a line boundary rather than a character boundary so we don't
+            // leave a malformed half-block in the prompt.
+            let finalContent = content;
+            if (content.length > effectiveBudget) {
+                const trimmed = content.slice(0, effectiveBudget);
+                const lastNewline = trimmed.lastIndexOf('\n');
+                finalContent = (lastNewline > 0 ? trimmed.slice(0, lastNewline) : trimmed) + '\n...(truncated)';
             }
-            parts.push(content);
-            remaining -= content.length;
+            parts.push(finalContent);
+            remaining -= finalContent.length;
             included.push(slot.name);
         }
         catch {

package/dist/memory/graph-store.d.ts

@@ -61,6 +61,22 @@ export declare class GraphStore {
     syncFromVault(vaultDir: string, agentsDir: string): Promise<GraphSyncStats>;
     extractAndStoreRelationships(triplets: RelationshipTriplet[]): Promise<void>;
     enrichWithGraphContext(entityIds: string[], _maxHops?: number): Promise<string>;
+    /**
+     * Drop Note nodes whose slug isn't in the caller-provided set of valid IDs.
+     * Wikilinks into deleted vault files leave dangling Note nodes with
+     * MENTIONS edges pointing at them — this cleans those up.
+     *
+     * Deliberately NOT auto-scheduled: blast radius is significant, and the
+     * caller (dashboard action, MCP tool, manual script) should supply the
+     * authoritative valid-IDs set. Runs DETACH DELETE so incoming edges go
+     * with the node.
+     *
+     * Returns counts of what was removed.
+     */
+    invalidateOrphanedNotes(validIds: Set<string>): Promise<{
+        scanned: number;
+        deleted: number;
+    }>;
 }
 export declare function getSharedGraphStore(persistenceDir: string): Promise<GraphStore | null>;
 //# sourceMappingURL=graph-store.d.ts.map

package/dist/memory/graph-store.js

@@ -580,6 +580,53 @@ export class GraphStore {
             return '';
         return '\n## Relationship Context\n' + lines.join('\n');
     }
+    /**
+     * Drop Note nodes whose slug isn't in the caller-provided set of valid IDs.
+     * Wikilinks into deleted vault files leave dangling Note nodes with
+     * MENTIONS edges pointing at them — this cleans those up.
+     *
+     * Deliberately NOT auto-scheduled: blast radius is significant, and the
+     * caller (dashboard action, MCP tool, manual script) should supply the
+     * authoritative valid-IDs set. Runs DETACH DELETE so incoming edges go
+     * with the node.
+     *
+     * Returns counts of what was removed.
+     */
+    async invalidateOrphanedNotes(validIds) {
+        if (!this.available)
+            return { scanned: 0, deleted: 0 };
+        if (validIds.size === 0) {
+            // Defense: refuse to run with an empty set — would delete every Note.
+            logger.warn('invalidateOrphanedNotes called with empty validIds — refusing to run');
+            return { scanned: 0, deleted: 0 };
+        }
+        let scanned = 0;
+        let deleted = 0;
+        try {
+            const res = await this.graph.query('MATCH (n:Note) RETURN n.id AS id');
+            const rows = (res.data ?? []);
+            scanned = rows.length;
+            for (const row of rows) {
+                const id = row.id;
+                if (!id || validIds.has(id))
+                    continue;
+                try {
+                    await this.graph.query('MATCH (n:Note {id: $id}) DETACH DELETE n', { params: { id } });
+                    deleted++;
+                }
+                catch (err) {
+                    logger.debug({ err, id }, 'Orphan Note deletion failed');
+                }
+            }
+        }
+        catch (err) {
+            logger.warn({ err }, 'invalidateOrphanedNotes query failed');
+        }
+        if (deleted > 0) {
+            logger.info({ scanned, deleted, validIdsSize: validIds.size }, 'Invalidated orphan Note nodes');
+        }
+        return { scanned, deleted };
+    }
 }
 // ── Shared Client Helper ───────────────────────────────────────────────
 /**

package/dist/memory/store.js

@@ -14,6 +14,7 @@ import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statS
 import path from 'node:path';
 import Database from 'better-sqlite3';
 import { BASE_DIR } from '../config.js';
+import { temporalDecay } from './search.js';
 import * as embeddingsModule from './embeddings.js';
 import { chunkFile } from './chunker.js';
 import { mmrRerank } from './mmr.js';
@@ -733,20 +734,30 @@ export class MemoryStore {
      * Get the most recently updated chunks.
      */
     getRecentChunks(limit = 5, agentSlug, filters, strict = false) {
-        const mapRow = (row) => ({
-            sourceFile: row.source_file,
-            section: row.section,
-            content: row.content,
-            score: 0,
-            chunkType: row.chunk_type,
-            matchType: 'recency',
-            lastUpdated: row.updated_at ?? '',
-            chunkId: row.id,
-            salience: row.salience ?? 0,
-            agentSlug: row.agent_slug ?? null,
-            category: row.category,
-            topic: row.topic,
-        });
+        const now = Date.now();
+        const mapRow = (row) => {
+            // Score recency by exponential decay (half-life 30 days). Previously
+            // every recent row got score=0, which meant MMR's min-max normalization
+            // ranked them at the floor — a two-day-old chunk and a six-month-old
+            // chunk were indistinguishable. Decay lets recent results actually
+            // compete with FTS and vector matches during rerank.
+            const daysOld = row.updated_at ? (now - Date.parse(row.updated_at)) / 86_400_000 : 0;
+            const decayed = temporalDecay(daysOld);
+            return {
+                sourceFile: row.source_file,
+                section: row.section,
+                content: row.content,
+                score: decayed,
+                chunkType: row.chunk_type,
+                matchType: 'recency',
+                lastUpdated: row.updated_at ?? '',
+                chunkId: row.id,
+                salience: row.salience ?? 0,
+                agentSlug: row.agent_slug ?? null,
+                category: row.category,
+                topic: row.topic,
+            };
+        };
         // Build optional WHERE clauses for category/topic
         let filterSql = '';
         const filterParams = [];

package/package.json

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