discoclaw 0.5.7 → 0.5.8

package/README.md

@@ -221,17 +221,12 @@ Full step-by-step guide: [docs/discord-bot-setup.md](docs/discord-bot-setup.md)
    npm install -g discoclaw
    ```
 
-   > **Fedora 43+ / GCC 14+ — `@discordjs/opus` build failure**
+   > **Fedora 43+ / GCC 14+ — `@discordjs/opus` build failure (resolved)**
    >
-   > GCC 14 promotes `-Wincompatible-pointer-types` to a hard error by default. The upstream opus C source triggers this, causing `npm install` to fail with an error like:
-   > ```
-   > error: incompatible pointer types passing ...
-   > ```
-   > **Workaround** — set the flag before installing:
+   > This was fixed upstream in `@discordjs/opus` 0.10.0. If you are pinned to an older version, set the flag before installing:
    > ```bash
    > CFLAGS="-Wno-error=incompatible-pointer-types" npm install -g discoclaw
    > ```
-   > This is a known upstream issue in the `@discordjs/opus` native addon. It only requires the flag override at install time; runtime behavior is unaffected.
 
 2. **Run the interactive setup wizard** (creates `.env` and scaffolds your workspace):
    ```bash

package/dist/config.js

@@ -377,6 +377,7 @@ export function parseConfig(env) {
             summaryMaxChars: parseNonNegativeInt(env, 'DISCOCLAW_SUMMARY_MAX_CHARS', 2000),
             summaryEveryNTurns: parsePositiveInt(env, 'DISCOCLAW_SUMMARY_EVERY_N_TURNS', 5),
             summaryDataDirOverride: parseTrimmedString(env, 'DISCOCLAW_SUMMARY_DATA_DIR'),
+            summaryArchiveDirOverride: parseTrimmedString(env, 'DISCOCLAW_SUMMARY_ARCHIVE_DIR'),
             durableMemoryEnabled: parseBoolean(env, 'DISCOCLAW_DURABLE_MEMORY_ENABLED', true),
             durableDataDirOverride: parseTrimmedString(env, 'DISCOCLAW_DURABLE_DATA_DIR'),
             durableInjectMaxChars: parsePositiveInt(env, 'DISCOCLAW_DURABLE_INJECT_MAX_CHARS', 2000),

package/dist/discord/actions-forge.js

@@ -96,7 +96,7 @@ export async function executeForgeAction(action, ctx, forgeCtx) {
             if (!orch?.isRunning) {
                 return { ok: false, error: 'No forge is currently running.' };
             }
-            orch.requestCancel();
+            orch.requestCancel('forgeCancel action');
             const activeId = getActiveForgeId();
             return { ok: true, summary: `Cancel requested${activeId ? ` for ${activeId}` : ''}` };
         }

package/dist/discord/actions-messaging.js

@@ -3,6 +3,29 @@ import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { resolveChannel, fmtTime, findChannelRaw, describeChannelType } from './action-utils.js';
 import { NO_MENTIONS } from './allowed-mentions.js';
+/** Serialize Discord embeds into a compact text representation. */
+function formatEmbeds(embeds, truncate) {
+    if (!embeds?.length)
+        return '';
+    const parts = [];
+    for (const e of embeds) {
+        const lines = [];
+        if (e.title)
+            lines.push(`Title: ${e.title}`);
+        if (e.description)
+            lines.push(`Description: ${e.description}`);
+        if (e.url)
+            lines.push(`URL: ${e.url}`);
+        for (const f of e.fields) {
+            lines.push(`${f.name}: ${f.value}`);
+        }
+        if (e.footer?.text)
+            lines.push(`Footer: ${e.footer.text}`);
+        parts.push(lines.join('\n'));
+    }
+    const full = parts.join('\n---\n');
+    return truncate ? full.slice(0, truncate) : full;
+}
 const MESSAGING_TYPE_MAP = {
     sendMessage: true, react: true, unreact: true, readMessages: true, fetchMessage: true,
     editMessage: true, deleteMessage: true, bulkDelete: true, crosspost: true, threadCreate: true,
@@ -138,7 +161,10 @@ export async function executeMessagingAction(action, ctx) {
             const lines = sorted.map((m) => {
                 const author = m.author?.username ?? 'Unknown';
                 const time = fmtTime(m.createdAt);
-                const text = (m.content || '(no text)').slice(0, 200);
+                const content = m.content || '';
+                const embed = formatEmbeds(m.embeds, 200);
+                const combined = content || embed || '(no text)';
+                const text = (content && embed ? `${content} [Embed: ${embed}]` : combined).slice(0, 300);
                 return `[${author}] ${text} (${time}, id:${m.id})`;
             });
             return { ok: true, summary: `Messages in #${channel.name}:\n${lines.join('\n')}` };
@@ -155,7 +181,11 @@ export async function executeMessagingAction(action, ctx) {
             const message = await messageChannel.messages.fetch(action.messageId);
             const author = message.author?.username ?? 'Unknown';
             const time = fmtTime(message.createdAt);
-            const text = action.full ? (message.content || '(no text)') : (message.content || '(no text)').slice(0, 500);
+            const contentText = message.content || '';
+            const embedText = formatEmbeds(message.embeds, action.full ? undefined : 2000);
+            const body = contentText || embedText || '(no text)';
+            const combined = contentText && embedText ? `${contentText}\n[Embeds]\n${embedText}` : body;
+            const text = action.full ? combined : combined.slice(0, 2000);
             return { ok: true, summary: `[${author}]: ${text} (${time}, #${messageChannel.name}, id:${message.id})` };
         }
         case 'editMessage': {
@@ -296,7 +326,10 @@ export async function executeMessagingAction(action, ctx) {
             }
             const lines = [...pinned.values()].map((m) => {
                 const author = m.author?.username ?? 'Unknown';
-                const text = (m.content || '(no text)').slice(0, 200);
+                const content = m.content || '';
+                const embed = formatEmbeds(m.embeds, 200);
+                const combined = content || embed || '(no text)';
+                const text = (content && embed ? `${content} [Embed: ${embed}]` : combined).slice(0, 300);
                 return `[${author}] ${text} (id:${m.id})`;
             });
             return { ok: true, summary: `Pinned messages in #${channel.name}:\n${lines.join('\n')}` };
@@ -400,7 +433,7 @@ export function messagingActionsPromptSection() {
 \`\`\`
 <discord-action>{"type":"fetchMessage","channelId":"123","messageId":"456","full":true}</discord-action>
 \`\`\`
-- \`full\` (optional): When true, returns the complete message content without truncation. Default: false (content truncated to 500 chars).
+- \`full\` (optional): When true, returns the complete message content without truncation. Default: false (content truncated to 2000 chars).
 
 **editMessage** — Edit a bot message:
 \`\`\`

package/dist/discord/actions-messaging.test.js

@@ -35,11 +35,21 @@ function makeMockChannel(overrides = {}) {
         ...(overrides.extraProps ?? {}),
     };
 }
+function makeEmbed(overrides = {}) {
+    return {
+        title: overrides.title ?? null,
+        description: overrides.description ?? null,
+        url: overrides.url ?? null,
+        fields: overrides.fields ?? [],
+        footer: overrides.footer ?? null,
+    };
+}
 function makeMockMessage(id, overrides = {}) {
     const { author: authorName, ...rest } = overrides;
     return {
         id,
         content: rest.content ?? 'Hello',
+        embeds: rest.embeds ?? [],
         author: { username: authorName ?? 'testuser' },
         createdAt: new Date('2025-01-15T12:00:00Z'),
         createdTimestamp: new Date('2025-01-15T12:00:00Z').getTime(),
@@ -391,6 +401,37 @@ describe('readMessages', () => {
         expect(result.error).toContain('forum channel');
         expect(result.error).not.toContain('not found');
     });
+    it('shows embed text instead of "(no text)" for embed-only messages', async () => {
+        const msg = makeMockMessage('m1', {
+            content: '',
+            author: 'alice',
+            embeds: [makeEmbed({ title: 'Cron Prompt', description: 'Check the weather' })],
+        });
+        const fetchedMessages = new Map([['m1', msg]]);
+        const ch = makeMockChannel({ name: 'general', fetchedMessages });
+        const ctx = makeCtx([ch]);
+        const result = await executeMessagingAction({ type: 'readMessages', channel: '#general', limit: 5 }, ctx);
+        expect(result.ok).toBe(true);
+        const summary = result.summary;
+        expect(summary).toContain('Title: Cron Prompt');
+        expect(summary).toContain('Description: Check the weather');
+        expect(summary).not.toContain('(no text)');
+    });
+    it('shows content with [Embed: ...] when both content and embeds present', async () => {
+        const msg = makeMockMessage('m1', {
+            content: 'Hello world',
+            author: 'alice',
+            embeds: [makeEmbed({ title: 'Link Preview', description: 'A website' })],
+        });
+        const fetchedMessages = new Map([['m1', msg]]);
+        const ch = makeMockChannel({ name: 'general', fetchedMessages });
+        const ctx = makeCtx([ch]);
+        const result = await executeMessagingAction({ type: 'readMessages', channel: '#general', limit: 5 }, ctx);
+        expect(result.ok).toBe(true);
+        const summary = result.summary;
+        expect(summary).toContain('Hello world [Embed:');
+        expect(summary).toContain('Title: Link Preview');
+    });
     it('clamps limit to 20', async () => {
         const ch = makeMockChannel({ name: 'general', fetchedMessages: new Map() });
         const ctx = makeCtx([ch]);
@@ -419,16 +460,16 @@ describe('fetchMessage', () => {
         const result = await executeMessagingAction({ type: 'fetchMessage', channelId: 'ch1', messageId: '' }, ctx);
         expect(result).toEqual({ ok: false, error: 'fetchMessage requires a non-empty messageId' });
     });
-    it('truncates content to 500 chars by default', async () => {
-        const longContent = 'x'.repeat(600);
+    it('truncates content to 2000 chars by default', async () => {
+        const longContent = 'x'.repeat(2500);
         const msg = makeMockMessage('msg1', { content: longContent, author: 'alice' });
         const ch = makeMockChannel({ id: 'ch1', name: 'general' });
         ch.messages.fetch = vi.fn(async () => msg);
         const ctx = makeCtx([ch]);
         const result = await executeMessagingAction({ type: 'fetchMessage', channelId: 'ch1', messageId: 'msg1' }, ctx);
         expect(result.ok).toBe(true);
-        expect(result.summary).not.toContain('x'.repeat(600));
-        expect(result.summary).toContain('x'.repeat(500));
+        expect(result.summary).not.toContain('x'.repeat(2500));
+        expect(result.summary).toContain('x'.repeat(2000));
     });
     it('returns full content when full flag is true', async () => {
         const longContent = 'x'.repeat(600);
@@ -440,6 +481,148 @@ describe('fetchMessage', () => {
         expect(result.ok).toBe(true);
         expect(result.summary).toContain(longContent);
     });
+    it('surfaces embed text for embed-only message', async () => {
+        const msg = makeMockMessage('msg1', {
+            content: '',
+            author: 'alice',
+            embeds: [makeEmbed({ title: 'Cron Prompt', description: 'Check the weather' })],
+        });
+        const ch = makeMockChannel({ id: 'ch1', name: 'general' });
+        ch.messages.fetch = vi.fn(async () => msg);
+        const ctx = makeCtx([ch]);
+        const result = await executeMessagingAction({ type: 'fetchMessage', channelId: 'ch1', messageId: 'msg1' }, ctx);
+        expect(result.ok).toBe(true);
+        const summary = result.summary;
+        expect(summary).toContain('Title: Cron Prompt');
+        expect(summary).toContain('Description: Check the weather');
+        expect(summary).not.toContain('(no text)');
+    });
+    it('shows content with [Embeds] section when both content and embeds present', async () => {
+        const msg = makeMockMessage('msg1', {
+            content: 'Hello world',
+            author: 'alice',
+            embeds: [makeEmbed({ title: 'Link Preview' })],
+        });
+        const ch = makeMockChannel({ id: 'ch1', name: 'general' });
+        ch.messages.fetch = vi.fn(async () => msg);
+        const ctx = makeCtx([ch]);
+        const result = await executeMessagingAction({ type: 'fetchMessage', channelId: 'ch1', messageId: 'msg1' }, ctx);
+        expect(result.ok).toBe(true);
+        const summary = result.summary;
+        expect(summary).toContain('Hello world');
+        expect(summary).toContain('[Embeds]');
+        expect(summary).toContain('Title: Link Preview');
+    });
+    it('returns untruncated embed text when full is true', async () => {
+        const longDesc = 'x'.repeat(3000);
+        const msg = makeMockMessage('msg1', {
+            content: '',
+            author: 'alice',
+            embeds: [makeEmbed({ title: 'Big Embed', description: longDesc })],
+        });
+        const ch = makeMockChannel({ id: 'ch1', name: 'general' });
+        ch.messages.fetch = vi.fn(async () => msg);
+        const ctx = makeCtx([ch]);
+        const result = await executeMessagingAction({ type: 'fetchMessage', channelId: 'ch1', messageId: 'msg1', full: true }, ctx);
+        expect(result.ok).toBe(true);
+        const summary = result.summary;
+        expect(summary).toContain(longDesc);
+    });
+    it('formats embed with title and description', async () => {
+        const msg = makeMockMessage('msg1', {
+            content: '',
+            author: 'alice',
+            embeds: [makeEmbed({ title: 'My Title', description: 'My Description' })],
+        });
+        const ch = makeMockChannel({ id: 'ch1', name: 'general' });
+        ch.messages.fetch = vi.fn(async () => msg);
+        const ctx = makeCtx([ch]);
+        const result = await executeMessagingAction({ type: 'fetchMessage', channelId: 'ch1', messageId: 'msg1', full: true }, ctx);
+        const summary = result.summary;
+        expect(summary).toContain('Title: My Title');
+        expect(summary).toContain('Description: My Description');
+    });
+    it('formats embed fields', async () => {
+        const msg = makeMockMessage('msg1', {
+            content: '',
+            author: 'alice',
+            embeds: [makeEmbed({
+                    fields: [
+                        { name: 'Status', value: 'Active' },
+                        { name: 'Priority', value: 'High' },
+                    ],
+                })],
+        });
+        const ch = makeMockChannel({ id: 'ch1', name: 'general' });
+        ch.messages.fetch = vi.fn(async () => msg);
+        const ctx = makeCtx([ch]);
+        const result = await executeMessagingAction({ type: 'fetchMessage', channelId: 'ch1', messageId: 'msg1', full: true }, ctx);
+        const summary = result.summary;
+        expect(summary).toContain('Status: Active');
+        expect(summary).toContain('Priority: High');
+    });
+    it('formats embed footer and URL', async () => {
+        const msg = makeMockMessage('msg1', {
+            content: '',
+            author: 'alice',
+            embeds: [makeEmbed({
+                    url: 'https://example.com',
+                    footer: { text: 'Footer text' },
+                })],
+        });
+        const ch = makeMockChannel({ id: 'ch1', name: 'general' });
+        ch.messages.fetch = vi.fn(async () => msg);
+        const ctx = makeCtx([ch]);
+        const result = await executeMessagingAction({ type: 'fetchMessage', channelId: 'ch1', messageId: 'msg1', full: true }, ctx);
+        const summary = result.summary;
+        expect(summary).toContain('URL: https://example.com');
+        expect(summary).toContain('Footer: Footer text');
+    });
+    it('separates multiple embeds with ---', async () => {
+        const msg = makeMockMessage('msg1', {
+            content: '',
+            author: 'alice',
+            embeds: [
+                makeEmbed({ title: 'First' }),
+                makeEmbed({ title: 'Second' }),
+            ],
+        });
+        const ch = makeMockChannel({ id: 'ch1', name: 'general' });
+        ch.messages.fetch = vi.fn(async () => msg);
+        const ctx = makeCtx([ch]);
+        const result = await executeMessagingAction({ type: 'fetchMessage', channelId: 'ch1', messageId: 'msg1', full: true }, ctx);
+        const summary = result.summary;
+        expect(summary).toContain('Title: First');
+        expect(summary).toContain('---');
+        expect(summary).toContain('Title: Second');
+    });
+    it('shows "(no text)" for message with no content and no embeds', async () => {
+        const msg = makeMockMessage('msg1', {
+            content: '',
+            author: 'alice',
+            embeds: [],
+        });
+        const ch = makeMockChannel({ id: 'ch1', name: 'general' });
+        ch.messages.fetch = vi.fn(async () => msg);
+        const ctx = makeCtx([ch]);
+        const result = await executeMessagingAction({ type: 'fetchMessage', channelId: 'ch1', messageId: 'msg1' }, ctx);
+        const summary = result.summary;
+        expect(summary).toContain('(no text)');
+    });
+    it('truncates embed text when full is false', async () => {
+        const longDesc = 'x'.repeat(3000);
+        const msg = makeMockMessage('msg1', {
+            content: '',
+            author: 'alice',
+            embeds: [makeEmbed({ description: longDesc })],
+        });
+        const ch = makeMockChannel({ id: 'ch1', name: 'general' });
+        ch.messages.fetch = vi.fn(async () => msg);
+        const ctx = makeCtx([ch]);
+        const result = await executeMessagingAction({ type: 'fetchMessage', channelId: 'ch1', messageId: 'msg1' }, ctx);
+        const summary = result.summary;
+        expect(summary).not.toContain('x'.repeat(3000));
+    });
 });
 describe('editMessage', () => {
     it('edits a message', async () => {
@@ -661,6 +844,38 @@ describe('listPins', () => {
         expect(result.error).toContain('forum channel');
         expect(result.error).not.toContain('not found');
     });
+    it('surfaces embed text for pinned embed-only message', async () => {
+        const pinned = new Map([
+            ['p1', makeMockMessage('p1', {
+                    content: '',
+                    author: 'alice',
+                    embeds: [makeEmbed({ title: 'Pinned Embed', description: 'Important info' })],
+                })],
+        ]);
+        const ch = makeMockChannel({ name: 'general', pinnedMessages: pinned });
+        const ctx = makeCtx([ch]);
+        const result = await executeMessagingAction({ type: 'listPins', channel: '#general' }, ctx);
+        expect(result.ok).toBe(true);
+        const summary = result.summary;
+        expect(summary).toContain('Title: Pinned Embed');
+        expect(summary).not.toContain('(no text)');
+    });
+    it('shows combined content and embed for pinned message with both', async () => {
+        const pinned = new Map([
+            ['p1', makeMockMessage('p1', {
+                    content: 'Check this out',
+                    author: 'alice',
+                    embeds: [makeEmbed({ title: 'Link Preview' })],
+                })],
+        ]);
+        const ch = makeMockChannel({ name: 'general', pinnedMessages: pinned });
+        const ctx = makeCtx([ch]);
+        const result = await executeMessagingAction({ type: 'listPins', channel: '#general' }, ctx);
+        expect(result.ok).toBe(true);
+        const summary = result.summary;
+        expect(summary).toContain('Check this out [Embed:');
+        expect(summary).toContain('Title: Link Preview');
+    });
     it('returns empty message when no pins', async () => {
         const ch = makeMockChannel({ name: 'general' });
         const ctx = makeCtx([ch]);

package/dist/discord/durable-memory.js

@@ -157,11 +157,54 @@ export function deprecateItems(store, substring) {
         store.updatedAt = now;
     return { store, deprecatedCount };
 }
-export function selectItemsForInjection(store, maxChars) {
+const STOP_WORDS = new Set([
+    'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
+    'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could',
+    'should', 'may', 'might', 'can', 'shall', 'to', 'of', 'in', 'for',
+    'on', 'with', 'at', 'by', 'from', 'as', 'into', 'about', 'but',
+    'not', 'or', 'and', 'if', 'then', 'so', 'that', 'this', 'it',
+    'its', 'my', 'your', 'our', 'their', 'his', 'her', 'what', 'which',
+    'who', 'how', 'when', 'where', 'why',
+]);
+export function tokenize(text) {
+    const tokens = text
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter((t) => t.length >= 3 && !STOP_WORDS.has(t));
+    return new Set(tokens);
+}
+export function keywordRelevance(queryTokens, itemText, itemTags) {
+    if (queryTokens.size === 0)
+        return 0;
+    const itemTokens = tokenize(itemText + ' ' + itemTags.join(' '));
+    let matches = 0;
+    for (const token of queryTokens) {
+        if (itemTokens.has(token))
+            matches++;
+    }
+    return matches / queryTokens.size;
+}
+const QUERY_BOOST_WEIGHT = 2.0;
+export function selectItemsForInjection(store, maxChars, query) {
     const now = Date.now();
-    const active = store.items
-        .filter((item) => item.status === 'active')
-        .sort((a, b) => blendedInjectionScore(b, now) - blendedInjectionScore(a, now));
+    const queryTokens = query ? tokenize(query) : new Set();
+    const activeItems = store.items.filter((item) => item.status === 'active');
+    // Pre-compute blended scores and find max for normalization.
+    const blendedScores = new Map();
+    let maxBlended = 0;
+    for (const item of activeItems) {
+        const score = blendedInjectionScore(item, now);
+        blendedScores.set(item.id, score);
+        if (score > maxBlended)
+            maxBlended = score;
+    }
+    const active = activeItems.sort((a, b) => {
+        const normA = maxBlended > 0 ? (blendedScores.get(a.id) ?? 0) / maxBlended : 0;
+        const normB = maxBlended > 0 ? (blendedScores.get(b.id) ?? 0) / maxBlended : 0;
+        const scoreA = normA + QUERY_BOOST_WEIGHT * keywordRelevance(queryTokens, a.text, a.tags);
+        const scoreB = normB + QUERY_BOOST_WEIGHT * keywordRelevance(queryTokens, b.text, b.tags);
+        return scoreB - scoreA;
+    });
     const selected = [];
     let chars = 0;
     for (const item of active) {

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

@@ -2,7 +2,7 @@ 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, scoreItem, blendedInjectionScore, recordHits, CURRENT_VERSION, } from './durable-memory.js';
+import { loadDurableMemory, saveDurableMemory, deriveItemId, addItem, deprecateItems, selectItemsForInjection, formatDurableSection, scoreItem, blendedInjectionScore, recordHits, tokenize, keywordRelevance, CURRENT_VERSION, } from './durable-memory.js';
 async function makeTmpDir() {
     return fs.mkdtemp(path.join(os.tmpdir(), 'durable-memory-test-'));
 }
@@ -378,3 +378,139 @@ describe('recordHits', () => {
         expect(store.items[1].lastHitAt).toBe(beforeLastHit);
     });
 });
+describe('tokenize', () => {
+    it('lowercases and splits on non-alphanumeric boundaries', () => {
+        const tokens = tokenize('Hello World! TypeScript is great.');
+        expect(tokens.has('hello')).toBe(true);
+        expect(tokens.has('world')).toBe(true);
+        expect(tokens.has('typescript')).toBe(true);
+        expect(tokens.has('great')).toBe(true);
+    });
+    it('filters out stop words', () => {
+        const tokens = tokenize('the quick brown fox is not a dog');
+        expect(tokens.has('the')).toBe(false);
+        expect(tokens.has('not')).toBe(false);
+        expect(tokens.has('quick')).toBe(true);
+        expect(tokens.has('brown')).toBe(true);
+        expect(tokens.has('fox')).toBe(true);
+        expect(tokens.has('dog')).toBe(true);
+    });
+    it('filters out tokens shorter than 3 characters', () => {
+        const tokens = tokenize('I am ok go run typescript');
+        expect(tokens.has('ok')).toBe(false);
+        expect(tokens.has('go')).toBe(false);
+        expect(tokens.has('am')).toBe(false);
+        expect(tokens.has('run')).toBe(true);
+        expect(tokens.has('typescript')).toBe(true);
+    });
+    it('returns empty set for empty input', () => {
+        expect(tokenize('').size).toBe(0);
+    });
+    it('deduplicates tokens', () => {
+        const tokens = tokenize('rust rust rust');
+        expect(tokens.size).toBe(1);
+        expect(tokens.has('rust')).toBe(true);
+    });
+});
+describe('keywordRelevance', () => {
+    it('returns 1.0 for perfect overlap', () => {
+        const queryTokens = tokenize('typescript projects');
+        const score = keywordRelevance(queryTokens, 'User loves TypeScript projects', []);
+        expect(score).toBe(1.0);
+    });
+    it('returns 0 for no overlap', () => {
+        const queryTokens = tokenize('python machine learning');
+        const score = keywordRelevance(queryTokens, 'User prefers Rust for systems', []);
+        expect(score).toBe(0);
+    });
+    it('returns partial score for partial overlap', () => {
+        const queryTokens = tokenize('typescript react projects');
+        const score = keywordRelevance(queryTokens, 'User likes TypeScript and Vue', []);
+        expect(score).toBeGreaterThan(0);
+        expect(score).toBeLessThan(1);
+        // 1 out of 3 non-stop tokens match: typescript
+        expect(score).toBeCloseTo(1 / 3);
+    });
+    it('returns 0 when query has no meaningful tokens', () => {
+        const queryTokens = tokenize('is a the');
+        const score = keywordRelevance(queryTokens, 'some text here', []);
+        expect(score).toBe(0);
+    });
+    it('includes tags in matching', () => {
+        const queryTokens = tokenize('kubernetes deployment');
+        const score = keywordRelevance(queryTokens, 'Uses containers for services', ['kubernetes', 'deployment']);
+        expect(score).toBe(1.0);
+    });
+});
+describe('selectItemsForInjection — query-aware boosting', () => {
+    it('boosts items with keyword overlap above non-matching items', () => {
+        const now = Date.now();
+        const store = emptyStore();
+        store.items.push(makeItem({
+            id: 'irrelevant',
+            text: 'User prefers dark mode in all editors',
+            status: 'active',
+            updatedAt: now - 1000,
+            hitCount: 10,
+            lastHitAt: now - 1000,
+        }), makeItem({
+            id: 'relevant',
+            text: 'User uses TypeScript for all projects',
+            status: 'active',
+            updatedAt: now - 30 * 24 * 60 * 60 * 1000,
+            hitCount: 1,
+            lastHitAt: now - 30 * 24 * 60 * 60 * 1000,
+        }));
+        // Without query, 'irrelevant' (higher blended score) would rank first
+        const withoutQuery = selectItemsForInjection(store, 10000);
+        expect(withoutQuery[0].id).toBe('irrelevant');
+        // With query about TypeScript, 'relevant' should be boosted above 'irrelevant'
+        const withQuery = selectItemsForInjection(store, 10000, 'Tell me about TypeScript');
+        expect(withQuery[0].id).toBe('relevant');
+        expect(withQuery[1].id).toBe('irrelevant');
+    });
+    it('falls back to blended score when query has no meaningful tokens', () => {
+        const now = Date.now();
+        const store = emptyStore();
+        store.items.push(makeItem({ id: 'a', text: 'first item', status: 'active', updatedAt: now - 1000, hitCount: 5, lastHitAt: now - 500 }), makeItem({ id: 'b', text: 'second item', status: 'active', updatedAt: now - 60 * 24 * 60 * 60 * 1000, hitCount: 0, lastHitAt: 0 }));
+        const items = selectItemsForInjection(store, 10000, 'is the a');
+        expect(items[0].id).toBe('a');
+    });
+    it('preserves existing behavior when query is undefined', () => {
+        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[0].id).toBe('old-hot');
+    });
+    it('boosts items matching via tags', () => {
+        const now = Date.now();
+        const store = emptyStore();
+        store.items.push(makeItem({
+            id: 'no-tag-match',
+            text: 'User enjoys hiking on weekends',
+            status: 'active',
+            updatedAt: now - 1000,
+            hitCount: 5,
+            lastHitAt: now - 1000,
+        }), makeItem({
+            id: 'tag-match',
+            text: 'Deploys services regularly',
+            tags: ['kubernetes', 'docker'],
+            status: 'active',
+            updatedAt: now - 60 * 24 * 60 * 60 * 1000,
+            hitCount: 0,
+            lastHitAt: 0,
+        }));
+        // Query has 2 tokens matching tags (kubernetes, docker) out of 3 total
+        const items = selectItemsForInjection(store, 10000, 'kubernetes docker containers');
+        expect(items[0].id).toBe('tag-match');
+    });
+    it('still respects char budget with query', () => {
+        const store = emptyStore();
+        const now = Date.now();
+        store.items.push(makeItem({ id: 'a', text: 'TypeScript project config', status: 'active', updatedAt: now - 1000 }), makeItem({ id: 'b', text: 'TypeScript compiler options reference', status: 'active', updatedAt: now - 2000 }));
+        const items = selectItemsForInjection(store, 80, 'TypeScript');
+        expect(items).toHaveLength(1);
+    });
+});