discoclaw 0.5.1 → 0.5.2

package/.context/memory.md

@@ -33,7 +33,10 @@ Bot:             We've been working through your Express → Fastify migration.
 
 Structured store of user facts. Each item has a kind (fact, preference, project,
 constraint, person, tool, workflow), deduplication by content hash, and a 200-item
-cap per user. Injected into every prompt.
+cap per user. Items track `hitCount` (incremented each time the item is selected
+for prompt injection) and `lastHitAt` (timestamp of most recent selection).
+Injected into every prompt using a blended score of recency and usage frequency
+rather than raw `updatedAt` alone.
 
 **What the user sees:**
 - The bot knows your preferences, projects, and key facts across all conversations.
@@ -53,7 +56,7 @@ Bot:   Given your preference for Rust in systems work, I'd lean that way —
 
 #### Consolidation
 
-When the active item count for a user crosses a threshold (`DISCOCLAW_DURABLE_CONSOLIDATION_THRESHOLD`, default `100`), consolidation can be triggered to prune and merge the list. A single `fast`-tier model call receives all active items and is asked to return a revised list — removing exact duplicates, merging near-duplicates, dropping clearly stale items, and preserving everything that is still plausibly useful. The model must not invent new facts or change the meaning of existing ones.
+When the active item count for a user crosses a threshold (`DISCOCLAW_DURABLE_CONSOLIDATION_THRESHOLD`, default `100`), consolidation can be triggered to prune and merge the list. A single `fast`-tier model call receives all active items and is asked to return a revised list — removing exact duplicates, merging near-duplicates, dropping clearly stale items, and preserving everything that is still plausibly useful. The model must not invent new facts or change the meaning of existing ones. Items with low `hitCount` and stale `lastHitAt` are natural eviction candidates — the blended score surfaces which items the AI actually uses versus those that were added once and never referenced again.
 
 The revised list is applied atomically: items absent from the model's output are deprecated via `deprecateItems()`; new or rewritten items are written via `addItem()`. Items present verbatim in the output are left untouched (no unnecessary writes).
 
@@ -183,7 +186,7 @@ no separator). The three memory builders run in `Promise.all` so they add no lat
 
 | Layer | Default budget | Default state | How it stays within budget |
 |-------|---------------|---------------|---------------------------|
-| Durable memory | 2000 chars | on | Sorts active items by recency, adds one at a time, stops when next line would exceed budget. Older facts silently excluded. |
+| Durable memory | 2000 chars | on | Ranks active items by blended score (recency + hit frequency), adds one at a time, stops when next line would exceed budget. Low-scoring items silently excluded. |
 | Rolling summary | 2000 chars | on | The `fast`-tier model is prompted with `"Keep the summary under {maxChars} characters"`. Replaces itself each update rather than growing. |
 | Message history | 3000 chars | on | Fetches up to 10 messages, walks backward from newest. Bot messages truncated to fit; user messages that don't fit cause a hard stop. |
 | Short-term memory | 1000 chars | **on** | Filters by max age (default 6h), sorts newest-first, accumulates lines until budget hit. |
@@ -202,7 +205,7 @@ might add ~500 chars total. Sections with no data produce zero overhead.
 
 ### Where the budgets are enforced
 
-- **Durable**: `selectItemsForInjection()` in `durable-memory.ts:152`
+- **Durable**: `selectItemsForInjection()` in `durable-memory.ts:152` — scores items using `hitCount`, `lastHitAt`, and `updatedAt`; increments hit counters on selected items
 - **Short-term**: `selectEntriesForInjection()` in `shortterm-memory.ts:113`
 - **Summary**: `fast`-tier prompt constraint in `summarizer.ts:63`
 - **History**: `fetchMessageHistory()` in `message-history.ts:38`

package/dist/discord/actions-memory.js

@@ -1,4 +1,4 @@
-import { loadDurableMemory, saveDurableMemory, addItem, deprecateItems, selectItemsForInjection, formatDurableSection, } from './durable-memory.js';
+import { loadDurableMemory, saveDurableMemory, addItem, deprecateItems, selectItemsForInjection, formatDurableSection, CURRENT_VERSION, } from './durable-memory.js';
 import { durableWriteQueue } from './durable-write-queue.js';
 const MEMORY_TYPE_MAP = {
     memoryRemember: true,
@@ -71,7 +71,7 @@ export async function executeMemoryAction(action, _ctx, memCtx) {
 // ---------------------------------------------------------------------------
 async function loadOrCreate(dir, userId) {
     const store = await loadDurableMemory(dir, userId);
-    return store ?? { version: 1, updatedAt: 0, items: [] };
+    return store ?? { version: CURRENT_VERSION, updatedAt: 0, items: [] };
 }
 // ---------------------------------------------------------------------------
 // Prompt section

package/dist/discord/durable-memory.js

@@ -1,14 +1,19 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import crypto from 'node:crypto';
-export const CURRENT_VERSION = 1;
+export const CURRENT_VERSION = 2;
 export function emptyStore() {
     return { version: CURRENT_VERSION, updatedAt: Date.now(), items: [] };
 }
 function migrateStore(store) {
     // Migration blocks run first, then the unknown-version guard.
-    // Future migrations follow the run-stats.ts pattern:
-    //   if (store.version === 1) { /* transform fields */; store.version = 2; }
+    if (store.version === 1) {
+        for (const item of store.items) {
+            item.hitCount = item.hitCount ?? 0;
+            item.lastHitAt = item.lastHitAt ?? 0;
+        }
+        store.version = 2;
+    }
     if (store.version !== CURRENT_VERSION) {
         // Unrecognized (future) version — caller will create a fresh store.
         return null;
@@ -56,6 +61,31 @@ export function deriveItemId(kind, text) {
     const normalized = kind + ':' + text.trim().toLowerCase().replace(/\s+/g, ' ');
     return 'durable-' + crypto.createHash('sha256').update(normalized).digest('hex').slice(0, 8);
 }
+function recencyWeight(timestamp, now) {
+    const daysSince = Math.max(0, now - timestamp) / (1000 * 60 * 60 * 24);
+    return 1 / (1 + daysSince / 30);
+}
+export function scoreItem(item, now) {
+    if (item.hitCount === 0)
+        return 0;
+    return item.hitCount * recencyWeight(item.lastHitAt, now);
+}
+export function blendedInjectionScore(item, now) {
+    const hitBoost = 0.5;
+    return recencyWeight(item.updatedAt, now) + hitBoost * item.hitCount * recencyWeight(item.lastHitAt, now);
+}
+export function recordHits(store, itemIds) {
+    const idSet = new Set(itemIds);
+    const now = Date.now();
+    for (const item of store.items) {
+        if (idSet.has(item.id)) {
+            item.hitCount += 1;
+            item.lastHitAt = now;
+        }
+    }
+    if (idSet.size > 0)
+        store.updatedAt = now;
+}
 export function addItem(store, text, source, maxItems, kind = 'fact') {
     const now = Date.now();
     const id = deriveItemId(kind, text);
@@ -77,25 +107,27 @@ export function addItem(store, text, source, maxItems, kind = 'fact') {
         source,
         createdAt: now,
         updatedAt: now,
+        hitCount: 0,
+        lastHitAt: 0,
     };
     store.items.push(item);
     store.updatedAt = now;
     // Enforce maxItems cap.
     while (store.items.length > maxItems) {
-        // Drop oldest deprecated first.
+        // Drop lowest-scored deprecated first.
         const deprecatedIdx = store.items
             .map((it, i) => ({ it, i }))
             .filter(({ it }) => it.status === 'deprecated')
-            .sort((a, b) => a.it.updatedAt - b.it.updatedAt)[0];
+            .sort((a, b) => scoreItem(a.it, now) - scoreItem(b.it, now))[0];
         if (deprecatedIdx) {
             store.items.splice(deprecatedIdx.i, 1);
         }
         else {
-            // Drop oldest active.
+            // Drop lowest-scored active.
             const activeIdx = store.items
                 .map((it, i) => ({ it, i }))
                 .filter(({ it }) => it.status === 'active')
-                .sort((a, b) => a.it.updatedAt - b.it.updatedAt)[0];
+                .sort((a, b) => scoreItem(a.it, now) - scoreItem(b.it, now))[0];
             if (activeIdx) {
                 store.items.splice(activeIdx.i, 1);
             }
@@ -126,9 +158,10 @@ export function deprecateItems(store, substring) {
     return { store, deprecatedCount };
 }
 export function selectItemsForInjection(store, maxChars) {
+    const now = Date.now();
     const active = store.items
         .filter((item) => item.status === 'active')
-        .sort((a, b) => b.updatedAt - a.updatedAt);
+        .sort((a, b) => blendedInjectionScore(b, now) - blendedInjectionScore(a, now));
     const selected = [];
     let chars = 0;
     for (const item of active) {

package/dist/discord/durable-memory.test.js

@@ -2,12 +2,12 @@ import { describe, expect, it } from 'vitest';
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
-import { loadDurableMemory, saveDurableMemory, deriveItemId, addItem, deprecateItems, selectItemsForInjection, formatDurableSection, CURRENT_VERSION, } from './durable-memory.js';
+import { loadDurableMemory, saveDurableMemory, deriveItemId, addItem, deprecateItems, selectItemsForInjection, formatDurableSection, scoreItem, blendedInjectionScore, recordHits, CURRENT_VERSION, } from './durable-memory.js';
 async function makeTmpDir() {
     return fs.mkdtemp(path.join(os.tmpdir(), 'durable-memory-test-'));
 }
 function emptyStore() {
-    return { version: 1, updatedAt: 0, items: [] };
+    return { version: 2, updatedAt: 0, items: [] };
 }
 function makeItem(overrides = {}) {
     return {
@@ -19,6 +19,8 @@ function makeItem(overrides = {}) {
         source: { type: 'manual' },
         createdAt: 1000,
         updatedAt: 1000,
+        hitCount: 0,
+        lastHitAt: 0,
         ...overrides,
     };
 }
@@ -30,7 +32,7 @@ describe('loadDurableMemory', () => {
     });
     it('parses valid store', async () => {
         const dir = await makeTmpDir();
-        const store = { version: 1, updatedAt: 1000, items: [] };
+        const store = { version: 2, updatedAt: 1000, items: [] };
         await fs.writeFile(path.join(dir, '12345.json'), JSON.stringify(store), 'utf8');
         const result = await loadDurableMemory(dir, '12345');
         expect(result).toEqual(store);
@@ -45,12 +47,31 @@ describe('loadDurableMemory', () => {
         const dir = await makeTmpDir();
         await expect(loadDurableMemory(dir, '../evil')).rejects.toThrow(/Invalid userId/);
     });
-    it('returns store unchanged for version-1 store (migration no-op)', async () => {
+    it('migrates v1 store to v2 with hitCount and lastHitAt backfilled', async () => {
         const dir = await makeTmpDir();
-        const store = { version: 1, updatedAt: 1000, items: [] };
-        await fs.writeFile(path.join(dir, 'user1.json'), JSON.stringify(store), 'utf8');
+        const v1Store = {
+            version: 1,
+            updatedAt: 1000,
+            items: [
+                {
+                    id: 'durable-abc12345',
+                    kind: 'fact',
+                    text: 'test item',
+                    tags: [],
+                    status: 'active',
+                    source: { type: 'manual' },
+                    createdAt: 500,
+                    updatedAt: 1000,
+                },
+            ],
+        };
+        await fs.writeFile(path.join(dir, 'user1.json'), JSON.stringify(v1Store), 'utf8');
         const result = await loadDurableMemory(dir, 'user1');
-        expect(result).toEqual(store);
+        expect(result).not.toBeNull();
+        expect(result.version).toBe(2);
+        expect(result.items).toHaveLength(1);
+        expect(result.items[0].hitCount).toBe(0);
+        expect(result.items[0].lastHitAt).toBe(0);
     });
     it('returns empty store for unsupported version', async () => {
         const dir = await makeTmpDir();
@@ -279,3 +300,81 @@ describe('formatDurableSection', () => {
         expect(result).toMatch(/src: manual, updated/);
     });
 });
+describe('scoreItem', () => {
+    it('returns 0 when hitCount is 0', () => {
+        const item = makeItem({ hitCount: 0, lastHitAt: 1000 });
+        expect(scoreItem(item, Date.now())).toBe(0);
+    });
+    it('scores higher with recent lastHitAt than distant lastHitAt', () => {
+        const now = Date.now();
+        const recent = makeItem({ hitCount: 5, lastHitAt: now - 1000 });
+        const distant = makeItem({ hitCount: 5, lastHitAt: now - 90 * 24 * 60 * 60 * 1000 });
+        expect(scoreItem(recent, now)).toBeGreaterThan(scoreItem(distant, now));
+    });
+    it('scores higher with more hits', () => {
+        const now = Date.now();
+        const manyHits = makeItem({ hitCount: 10, lastHitAt: now - 1000 });
+        const fewHits = makeItem({ hitCount: 2, lastHitAt: now - 1000 });
+        expect(scoreItem(manyHits, now)).toBeGreaterThan(scoreItem(fewHits, now));
+    });
+});
+describe('blendedInjectionScore', () => {
+    it('recently-updated + frequently-hit item scores above old + never-hit item', () => {
+        const now = Date.now();
+        const hotItem = makeItem({
+            updatedAt: now - 1000,
+            hitCount: 10,
+            lastHitAt: now - 1000,
+        });
+        const coldItem = makeItem({
+            updatedAt: now - 60 * 24 * 60 * 60 * 1000,
+            hitCount: 0,
+            lastHitAt: 0,
+        });
+        expect(blendedInjectionScore(hotItem, now)).toBeGreaterThan(blendedInjectionScore(coldItem, now));
+    });
+});
+describe('addItem — eviction with hit tracking', () => {
+    it('evicts never-hit item before frequently-hit item of same age', () => {
+        const store = emptyStore();
+        const now = Date.now();
+        store.items.push(makeItem({ id: 'never-hit', status: 'active', text: 'never hit', updatedAt: now - 1000, hitCount: 0, lastHitAt: 0 }), makeItem({ id: 'freq-hit', status: 'active', text: 'frequently hit', updatedAt: now - 1000, hitCount: 10, lastHitAt: now - 500 }));
+        addItem(store, 'new item', { type: 'manual' }, 2);
+        expect(store.items).toHaveLength(2);
+        expect(store.items.find((it) => it.id === 'never-hit')).toBeUndefined();
+        expect(store.items.find((it) => it.id === 'freq-hit')).toBeDefined();
+    });
+    it('evicts deprecated never-hit item before active never-hit item', () => {
+        const store = emptyStore();
+        const now = Date.now();
+        store.items.push(makeItem({ id: 'dep-no-hit', status: 'deprecated', text: 'deprecated no hit', updatedAt: now - 1000, hitCount: 0, lastHitAt: 0 }), makeItem({ id: 'active-no-hit', status: 'active', text: 'active no hit', updatedAt: now - 1000, hitCount: 0, lastHitAt: 0 }));
+        addItem(store, 'new item', { type: 'manual' }, 2);
+        expect(store.items).toHaveLength(2);
+        expect(store.items.find((it) => it.id === 'dep-no-hit')).toBeUndefined();
+        expect(store.items.find((it) => it.id === 'active-no-hit')).toBeDefined();
+    });
+});
+describe('selectItemsForInjection — blended scoring', () => {
+    it('orders by blended score, not just updatedAt', () => {
+        const now = Date.now();
+        const store = emptyStore();
+        store.items.push(makeItem({ id: 'old-hot', text: 'old but popular', status: 'active', updatedAt: now - 30 * 24 * 60 * 60 * 1000, hitCount: 20, lastHitAt: now - 1000 }), makeItem({ id: 'new-cold', text: 'new but ignored', status: 'active', updatedAt: now - 1000, hitCount: 0, lastHitAt: 0 }));
+        const items = selectItemsForInjection(store, 10000);
+        expect(items).toHaveLength(2);
+        expect(items[0].id).toBe('old-hot');
+        expect(items[1].id).toBe('new-cold');
+    });
+});
+describe('recordHits', () => {
+    it('bumps hitCount and lastHitAt on matching IDs, leaves others untouched', () => {
+        const store = emptyStore();
+        store.items.push(makeItem({ id: 'hit-me', hitCount: 3, lastHitAt: 500 }), makeItem({ id: 'leave-me', hitCount: 1, lastHitAt: 400 }));
+        const before = store.items[1].hitCount;
+        const beforeLastHit = store.items[1].lastHitAt;
+        recordHits(store, ['hit-me']);
+        expect(store.items[0].hitCount).toBe(4);
+        expect(store.items[0].lastHitAt).toBeGreaterThan(500);
+        expect(store.items[1].hitCount).toBe(before);
+        expect(store.items[1].lastHitAt).toBe(beforeLastHit);
+    });
+});

package/dist/discord/prompt-common.js

@@ -1,7 +1,8 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { buildPromptPreamble as buildRootPolicyPreamble } from '../root-policy.js';
-import { formatDurableSection, loadDurableMemory, selectItemsForInjection } from './durable-memory.js';
+import { formatDurableSection, loadDurableMemory, saveDurableMemory, selectItemsForInjection, recordHits } from './durable-memory.js';
+import { durableWriteQueue } from './durable-write-queue.js';
 import { buildShortTermMemorySection } from './shortterm-memory.js';
 import { loadWorkspacePermissions, resolveTools } from '../workspace-permissions.js';
 import { isOnboardingComplete } from '../workspace-bootstrap.js';
@@ -121,6 +122,19 @@ export async function buildDurableMemorySection(opts) {
         const items = selectItemsForInjection(store, opts.durableInjectMaxChars);
         if (items.length === 0)
             return '';
+        // Record hits on injected items so frequently-used items accumulate
+        // a Hebbian signal for scoring and eviction.  Fire-and-forget — the
+        // background write doesn't block prompt assembly.
+        const itemIds = items.map((it) => it.id);
+        durableWriteQueue.run(opts.userId, async () => {
+            const freshStore = await loadDurableMemory(opts.durableDataDir, opts.userId);
+            if (!freshStore)
+                return;
+            recordHits(freshStore, itemIds);
+            await saveDurableMemory(opts.durableDataDir, opts.userId, freshStore);
+        }).catch((err) => {
+            opts.log?.warn({ err, userId: opts.userId }, 'durable memory hit recording failed');
+        });
         return formatDurableSection(items);
     }
     catch (err) {

package/dist/discord/reaction-handler.test.js

@@ -321,7 +321,7 @@ describe('createReactionAddHandler', () => {
         const prompt = invokeSpy.mock.calls[0][0].prompt;
         expect(prompt).toContain('Durable memory');
         expect(prompt).toContain('User loves TypeScript');
-        await fsP.rm(tmpDir, { recursive: true });
+        await fsP.rm(tmpDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
     });
     it('prompt includes open-tasks section when taskCtx has open tasks', async () => {
         const { TaskStore } = await import('../tasks/store.js');

package/dist/discord/user-turn-to-durable.js

@@ -1,4 +1,4 @@
-import { loadDurableMemory, saveDurableMemory, addItem, deprecateItems, selectItemsForInjection } from './durable-memory.js';
+import { loadDurableMemory, saveDurableMemory, addItem, deprecateItems, selectItemsForInjection, CURRENT_VERSION } from './durable-memory.js';
 import { durableWriteQueue } from './durable-write-queue.js';
 import { extractFirstJsonValue } from './json-extract.js';
 const VALID_KINDS = new Set([
@@ -120,7 +120,7 @@ export async function applyUserTurnToDurable(opts) {
         return;
     await durableWriteQueue.run(opts.userId, async () => {
         const store = (await loadDurableMemory(opts.durableDataDir, opts.userId)) ?? {
-            version: 1,
+            version: CURRENT_VERSION,
             updatedAt: 0,
             items: [],
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discoclaw",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "description": "Minimal Discord bridge routing messages to AI runtimes",
   "license": "MIT",
   "repository": {