context-mode 1.0.53 → 1.0.54

package/build/executor.js

@@ -1,4 +1,4 @@
-import { spawn, execSync } from "node:child_process";
+import { spawn, execSync, execFileSync } from "node:child_process";
 import { mkdtempSync, writeFileSync, rmSync, existsSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { tmpdir } from "node:os";
@@ -50,7 +50,7 @@ export class PolyglotExecutor {
     }
     async execute(opts) {
         const { language, code, timeout = 30_000, background = false } = opts;
-        const tmpDir = mkdtempSync(join(tmpdir(), "ctx-mode-"));
+        const tmpDir = mkdtempSync(join(tmpdir(), ".ctx-mode-"));
         try {
             const filePath = this.#writeScript(tmpDir, code, language);
             const cmd = buildCommand(this.#runtimes, language, filePath);
@@ -127,7 +127,7 @@ export class PolyglotExecutor {
         const binPath = srcPath.replace(/\.rs$/, "") + binSuffix;
         // Compile
         try {
-            execSync(`rustc ${srcPath} -o ${binPath}`, {
+            execFileSync("rustc", [srcPath, "-o", binPath], {
                 cwd,
                 timeout: Math.min(timeout, 60_000),
                 encoding: "utf-8",

package/build/openclaw-plugin.js

@@ -130,17 +130,17 @@ export default {
         catch {
             // best effort
         }
-        // Async init: load routing module + write AGENTS.md. Hooks await this.
+        // Async init: load routing module. Hooks await this.
+        // NOTE: writeRoutingInstructions is intentionally NOT called here.
+        // process.cwd() at plugin load time is the gateway's working directory, not
+        // the agent's workspace. Writing AGENTS.md to cwd() caused the file to be
+        // created in arbitrary directories (repo roots, config dirs, $HOME, etc.).
+        // The write is now deferred to session_start where the real workspace path
+        // is known via the sessionKey → workspace mapping.
         const initPromise = (async () => {
             const routingPath = resolve(buildDir, "..", "hooks", "core", "routing.mjs");
             const routing = await import(pathToFileURL(routingPath).href);
             await routing.initSecurity(buildDir);
-            try {
-                new OpenClawAdapter().writeRoutingInstructions(projectDir, pluginRoot);
-            }
-            catch {
-                // best effort — never break plugin init
-            }
             return { routing };
         })();
         // ── 1. tool_call:before — Routing enforcement ──────────
@@ -315,6 +315,33 @@ export default {
                     workspaceRouter.registerSession(key, sessionId);
                 }
                 resumeInjected = false;
+                // Write routing instructions (AGENTS.md) now that we know the real
+                // workspace. Derive the workspace directory from the sessionKey so we
+                // only write into recognised /.openclaw/workspace* paths, never into
+                // the gateway's cwd or any other arbitrary directory.
+                if (key) {
+                    try {
+                        const adapter = new OpenClawAdapter();
+                        const openclawBase = resolve(homedir(), ".openclaw");
+                        // Resolve workspace dir from sessionKey (pattern: agent:<name>:*)
+                        // Restrict agent name to safe characters to prevent path traversal (#183)
+                        const wsMatch = key.match(/^agent:([a-zA-Z0-9_-]+):/);
+                        let wsDir;
+                        if (wsMatch) {
+                            wsDir = resolve(openclawBase, `workspace-${wsMatch[1]}`);
+                        }
+                        else {
+                            wsDir = resolve(openclawBase, "workspace");
+                        }
+                        // Containment check: never write outside ~/.openclaw/
+                        if (wsDir.startsWith(openclawBase)) {
+                            adapter.writeRoutingInstructions(wsDir, pluginRoot);
+                        }
+                    }
+                    catch {
+                        // best effort — never break session start
+                    }
+                }
             }
             catch {
                 // best effort — never break session start
@@ -402,7 +429,7 @@ export default {
             info: {
                 id: "context-mode",
                 name: "Context Mode",
-                ownsCompaction: true,
+                ownsCompaction: false,
             },
             async ingest() {
                 return { ingested: true };
@@ -410,31 +437,12 @@ export default {
             async assemble({ messages }) {
                 return { messages, estimatedTokens: 0 };
             },
-            async compact({ currentTokenCount } = {}) {
-                try {
-                    const sid = sessionId;
-                    const events = db.getEvents(sid);
-                    if (events.length === 0)
-                        return { ok: true, compacted: false };
-                    const stats = db.getSessionStats(sid);
-                    const compactCount = (stats?.compact_count ?? 0) + 1;
-                    const snapshot = buildResumeSnapshot(events, { compactCount });
-                    db.upsertResume(sid, snapshot, events.length);
-                    db.incrementCompactCount(sid);
-                    return {
-                        ok: true,
-                        compacted: true,
-                        result: {
-                            summary: snapshot,
-                            firstKeptEntryId: "", // clear all history before this compaction
-                            tokensBefore: currentTokenCount ?? 0,
-                            tokensAfter: 0,
-                        },
-                    };
-                }
-                catch {
-                    return { ok: false, compacted: false };
-                }
+            async compact() {
+                // No-op: session continuity is handled by before_compaction / after_compaction hooks.
+                // Returning ownsCompaction: false + compacted: false lets the host platform (OpenClaw)
+                // manage conversation truncation, preserving Anthropic thinking/redacted_thinking blocks.
+                // See: https://github.com/mksglu/context-mode/issues/191
+                return { ok: true, compacted: false };
             },
         }));
         // ── 10. Auto-reply commands — ctx slash commands ──────

package/build/opencode-plugin.js

@@ -23,8 +23,11 @@ import { extractEvents } from "./session/extract.js";
 import { buildResumeSnapshot } from "./session/snapshot.js";
 import { OpenCodeAdapter } from "./adapters/opencode/index.js";
 // ── Helpers ───────────────────────────────────────────────
+function getPlatform() {
+    return process.env.KILO ? "kilo" : "opencode";
+}
 function getSessionDir() {
-    const dir = join(homedir(), ".config", "opencode", "context-mode", "sessions");
+    const dir = join(homedir(), ".config", getPlatform(), "context-mode", "sessions");
     mkdirSync(dir, { recursive: true });
     return dir;
 }
@@ -54,7 +57,7 @@ export const ContextModePlugin = async (ctx) => {
     db.ensureSession(sessionId, projectDir);
     // Auto-write AGENTS.md on startup for OpenCode projects
     try {
-        new OpenCodeAdapter().writeRoutingInstructions(projectDir, resolve(buildDir, ".."));
+        new OpenCodeAdapter(getPlatform()).writeRoutingInstructions(projectDir, resolve(buildDir, ".."));
     }
     catch {
         // best effort — never break plugin init

package/build/runtime.js

@@ -11,6 +11,23 @@ function commandExists(cmd) {
         return false;
     }
 }
+function bunExists() {
+    if (commandExists("bun"))
+        return true;
+    // Bun installs to ~/.bun/bin which may not be in PATH in MCP server environments
+    if (!isWindows) {
+        const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+        if (home && existsSync(`${home}/.bun/bin/bun`))
+            return true;
+    }
+    return false;
+}
+function bunCommand() {
+    if (commandExists("bun"))
+        return "bun";
+    const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+    return `${home}/.bun/bin/bun`;
+}
 /**
  * On Windows, resolve the first non-WSL bash in PATH.
  * WSL bash (C:\Windows\System32\bash.exe) cannot handle Windows paths,
@@ -59,11 +76,12 @@ function getVersion(cmd) {
     }
 }
 export function detectRuntimes() {
-    const hasBun = commandExists("bun");
+    const hasBun = bunExists();
+    const bun = hasBun ? bunCommand() : null;
     return {
-        javascript: hasBun ? "bun" : "node",
-        typescript: hasBun
-            ? "bun"
+        javascript: bun ?? process.execPath,
+        typescript: bun
+            ? bun
             : commandExists("tsx")
                 ? "tsx"
                 : commandExists("ts-node")
@@ -91,11 +109,11 @@ export function detectRuntimes() {
     };
 }
 export function hasBunRuntime() {
-    return commandExists("bun");
+    return bunExists();
 }
 export function getRuntimeSummary(runtimes) {
     const lines = [];
-    const bunPreferred = runtimes.javascript === "bun";
+    const bunPreferred = runtimes.javascript?.endsWith("bun") ?? false;
     lines.push(`  JavaScript: ${runtimes.javascript} (${getVersion(runtimes.javascript)})${bunPreferred ? " ⚡" : ""}`);
     if (runtimes.typescript) {
         lines.push(`  TypeScript: ${runtimes.typescript} (${getVersion(runtimes.typescript)})`);
@@ -156,15 +174,15 @@ export function getAvailableLanguages(runtimes) {
 export function buildCommand(runtimes, language, filePath) {
     switch (language) {
         case "javascript":
-            return runtimes.javascript === "bun"
-                ? ["bun", "run", filePath]
-                : ["node", filePath];
+            return runtimes.javascript.endsWith("bun")
+                ? [runtimes.javascript, "run", filePath]
+                : [runtimes.javascript, filePath];
         case "typescript":
             if (!runtimes.typescript) {
                 throw new Error("No TypeScript runtime available. Install one of: bun (recommended), tsx (npm i -g tsx), or ts-node.");
             }
-            if (runtimes.typescript === "bun")
-                return ["bun", "run", filePath];
+            if (runtimes.typescript?.endsWith("bun"))
+                return [runtimes.typescript, "run", filePath];
             if (runtimes.typescript === "tsx")
                 return ["tsx", filePath];
             return ["ts-node", filePath];

package/build/server.d.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { ContentStore } from "./store.js";
 /**
  * Parse FTS5 highlight markers to find match positions in the
  * original (marker-free) text. Returns character offsets into the
@@ -6,3 +7,4 @@
  */
 export declare function positionsFromHighlight(highlighted: string): number[];
 export declare function extractSnippet(content: string, query: string, maxLen?: number, highlighted?: string): string;
+export declare function formatBatchQueryResults(store: ContentStore, queries: string[], source: string, maxOutput?: number): string[];

package/build/server.js

@@ -321,6 +321,33 @@ export function extractSnippet(content, query, maxLen = 1500, highlighted) {
     }
     return parts.join("\n\n");
 }
+export function formatBatchQueryResults(store, queries, source, maxOutput = 80 * 1024) {
+    const sections = [];
+    let outputSize = 0;
+    for (const query of queries) {
+        if (outputSize > maxOutput) {
+            sections.push(`## ${query}\n(output cap reached — use search(queries: ["${query}"]) for details)\n`);
+            continue;
+        }
+        const results = store.searchWithFallback(query, 3, source, undefined, "exact");
+        sections.push(`## ${query}`);
+        sections.push("");
+        if (results.length > 0) {
+            for (const result of results) {
+                const snippet = extractSnippet(result.content, query, 3000, result.highlighted);
+                sections.push(`### ${result.title}`);
+                sections.push(snippet);
+                sections.push("");
+                outputSize += snippet.length + result.title.length;
+            }
+            continue;
+        }
+        sections.push("No matching sections found.");
+        sections.push("");
+    }
+    sections.push(`\n> **Tip:** Results are scoped to this batch only. To search across all indexed sources, use \`ctx_search(queries: [...])\`.`);
+    return sections;
+}
 // ─────────────────────────────────────────────────────────
 // Tool: execute
 // ─────────────────────────────────────────────────────────
@@ -1272,45 +1299,9 @@ server.registerTool("ctx_batch_execute", {
             inventory.push(`- ${s.title} (${(bytes / 1024).toFixed(1)}KB)`);
             sectionTitles.push(s.title);
         }
-        // Run all search queries — 3 results each, smart snippets
-        // Three-tier fallback: scoped → boosted → global
-        const MAX_OUTPUT = 80 * 1024; // 80KB total output cap
-        const queryResults = [];
-        let outputSize = 0;
-        for (const query of queries) {
-            if (outputSize > MAX_OUTPUT) {
-                queryResults.push(`## ${query}\n(output cap reached — use search(queries: ["${query}"]) for details)\n`);
-                continue;
-            }
-            // Tier 1: scoped search with fallback (porter → trigram → fuzzy)
-            let results = store.searchWithFallback(query, 3, source);
-            let crossSource = false;
-            // Tier 2: global fallback (no source filter) — warn about cross-source (Issue #61)
-            if (results.length === 0) {
-                results = store.searchWithFallback(query, 3);
-                crossSource = results.length > 0;
-            }
-            queryResults.push(`## ${query}`);
-            if (crossSource) {
-                queryResults.push(`> **Note:** No results in current batch output. Showing results from previously indexed content.`);
-            }
-            queryResults.push("");
-            if (results.length > 0) {
-                for (const r of results) {
-                    // Use larger snippet (3KB) for batch_execute to reduce tiny-fragment issue (Issue #61)
-                    const snippet = extractSnippet(r.content, query, 3000, r.highlighted);
-                    const sourceTag = crossSource ? ` _(source: ${r.source})_` : "";
-                    queryResults.push(`### ${r.title}${sourceTag}`);
-                    queryResults.push(snippet);
-                    queryResults.push("");
-                    outputSize += snippet.length + r.title.length;
-                }
-            }
-            else {
-                queryResults.push("No matching sections found.");
-                queryResults.push("");
-            }
-        }
+        // Run all search queries — source scoped only.
+        // Cross-source search remains available via explicit search().
+        const queryResults = formatBatchQueryResults(store, queries, source);
         // Get searchable terms for edge cases where follow-up is needed
         const distinctiveTerms = store.getDistinctiveTerms
             ? store.getDistinctiveTerms(indexed.sourceId)
@@ -1608,7 +1599,7 @@ server.registerTool("ctx_upgrade", {
         // Write inline script to a temp .mjs file — avoids quote-escaping issues
         // across cmd.exe, PowerShell, and bash (node -e '...' breaks on Windows).
         const scriptLines = [
-            `import{execSync}from"node:child_process";`,
+            `import{execFileSync}from"node:child_process";`,
             `import{cpSync,rmSync,existsSync,mkdtempSync}from"node:fs";`,
             `import{join}from"node:path";`,
             `import{tmpdir}from"node:os";`,
@@ -1616,15 +1607,15 @@ server.registerTool("ctx_upgrade", {
             `const T=mkdtempSync(join(tmpdir(),"ctx-upgrade-"));`,
             `try{`,
             `console.log("- [x] Starting inline upgrade (no CLI found)");`,
-            `execSync("git clone --depth 1 ${repoUrl} \\""+T+"\\"",{stdio:"inherit"});`,
+            `execFileSync("git",["clone","--depth","1","${repoUrl}",T],{stdio:"inherit"});`,
             `console.log("- [x] Cloned latest source");`,
-            `execSync("npm install",{cwd:T,stdio:"inherit"});`,
-            `execSync("npm run build",{cwd:T,stdio:"inherit"});`,
+            `execFileSync("npm",["install"],{cwd:T,stdio:"inherit"});`,
+            `execFileSync("npm",["run","build"],{cwd:T,stdio:"inherit"});`,
             `console.log("- [x] Built from source");`,
             ...copyDirs.map((d) => `if(existsSync(join(T,${JSON.stringify(d)})))cpSync(join(T,${JSON.stringify(d)}),join(P,${JSON.stringify(d)}),{recursive:true,force:true});`),
             ...copyFiles.map((f) => `if(existsSync(join(T,${JSON.stringify(f)})))cpSync(join(T,${JSON.stringify(f)}),join(P,${JSON.stringify(f)}),{force:true});`),
             `console.log("- [x] Copied build artifacts");`,
-            `execSync("npm install --production",{cwd:P,stdio:"inherit"});`,
+            `execFileSync("npm",["install","--production"],{cwd:P,stdio:"inherit"});`,
             `console.log("- [x] Installed production dependencies");`,
             `console.log("## context-mode upgrade complete");`,
             `}catch(e){`,

package/build/store.d.ts

@@ -7,6 +7,7 @@
  * Use for documentation, API references, and any content where
  * you need EXACT text later — not summaries.
  */
+type SourceMatchMode = "like" | "exact";
 import type { IndexResult, SearchResult, StoreStats } from "./types.js";
 export type { IndexResult, SearchResult, StoreStats } from "./types.js";
 /**
@@ -42,10 +43,10 @@ export declare class ContentStore {
      * Falls back to `indexPlainText` if the content is not valid JSON.
      */
     indexJSON(content: string, source: string, maxChunkBytes?: number): IndexResult;
-    search(query: string, limit?: number, source?: string, mode?: "AND" | "OR", contentType?: "code" | "prose"): SearchResult[];
-    searchTrigram(query: string, limit?: number, source?: string, mode?: "AND" | "OR", contentType?: "code" | "prose"): SearchResult[];
+    search(query: string, limit?: number, source?: string, mode?: "AND" | "OR", contentType?: "code" | "prose", sourceMatchMode?: SourceMatchMode): SearchResult[];
+    searchTrigram(query: string, limit?: number, source?: string, mode?: "AND" | "OR", contentType?: "code" | "prose", sourceMatchMode?: SourceMatchMode): SearchResult[];
     fuzzyCorrect(query: string): string | null;
-    searchWithFallback(query: string, limit?: number, source?: string, contentType?: "code" | "prose"): SearchResult[];
+    searchWithFallback(query: string, limit?: number, source?: string, contentType?: "code" | "prose", sourceMatchMode?: SourceMatchMode): SearchResult[];
     getSourceMeta(label: string): {
         label: string;
         chunkCount: number;

package/build/store.js

@@ -212,13 +212,17 @@ export class ContentStore {
     // Search path (hot)
     #stmtSearchPorter;
     #stmtSearchPorterFiltered;
+    #stmtSearchPorterExact;
     #stmtSearchTrigram;
     #stmtSearchTrigramFiltered;
+    #stmtSearchTrigramExact;
     #stmtFuzzyVocab;
     #stmtSearchPorterContentType;
     #stmtSearchPorterFilteredContentType;
+    #stmtSearchPorterExactContentType;
     #stmtSearchTrigramContentType;
     #stmtSearchTrigramFilteredContentType;
+    #stmtSearchTrigramExactContentType;
     // Read path
     #stmtListSources;
     #stmtChunksBySource;
@@ -278,6 +282,8 @@ export class ContentStore {
       CREATE TABLE IF NOT EXISTS vocabulary (
         word TEXT PRIMARY KEY
       );
+
+      CREATE INDEX IF NOT EXISTS idx_sources_label ON sources(label);
     `);
     }
     #prepareStatements() {
@@ -320,6 +326,20 @@ export class ContentStore {
       WHERE chunks MATCH ? AND sources.label LIKE ?
       ORDER BY rank
       LIMIT ?
+    `);
+        this.#stmtSearchPorterExact = this.#db.prepare(`
+      SELECT
+        chunks.title,
+        chunks.content,
+        chunks.content_type,
+        sources.label,
+        bm25(chunks, 5.0, 1.0) AS rank,
+        highlight(chunks, 1, char(2), char(3)) AS highlighted
+      FROM chunks
+      JOIN sources ON sources.id = chunks.source_id
+      WHERE chunks MATCH ? AND sources.label = ?
+      ORDER BY rank
+      LIMIT ?
     `);
         this.#stmtSearchTrigram = this.#db.prepare(`
       SELECT
@@ -348,6 +368,20 @@ export class ContentStore {
       WHERE chunks_trigram MATCH ? AND sources.label LIKE ?
       ORDER BY rank
       LIMIT ?
+    `);
+        this.#stmtSearchTrigramExact = this.#db.prepare(`
+      SELECT
+        chunks_trigram.title,
+        chunks_trigram.content,
+        chunks_trigram.content_type,
+        sources.label,
+        bm25(chunks_trigram, 5.0, 1.0) AS rank,
+        highlight(chunks_trigram, 1, char(2), char(3)) AS highlighted
+      FROM chunks_trigram
+      JOIN sources ON sources.id = chunks_trigram.source_id
+      WHERE chunks_trigram MATCH ? AND sources.label = ?
+      ORDER BY rank
+      LIMIT ?
     `);
         // Content-type filtered variants
         this.#stmtSearchPorterContentType = this.#db.prepare(`
@@ -377,6 +411,20 @@ export class ContentStore {
       WHERE chunks MATCH ? AND sources.label LIKE ? AND chunks.content_type = ?
       ORDER BY rank
       LIMIT ?
+    `);
+        this.#stmtSearchPorterExactContentType = this.#db.prepare(`
+      SELECT
+        chunks.title,
+        chunks.content,
+        chunks.content_type,
+        sources.label,
+        bm25(chunks, 5.0, 1.0) AS rank,
+        highlight(chunks, 1, char(2), char(3)) AS highlighted
+      FROM chunks
+      JOIN sources ON sources.id = chunks.source_id
+      WHERE chunks MATCH ? AND sources.label = ? AND chunks.content_type = ?
+      ORDER BY rank
+      LIMIT ?
     `);
         this.#stmtSearchTrigramContentType = this.#db.prepare(`
       SELECT
@@ -405,6 +453,20 @@ export class ContentStore {
       WHERE chunks_trigram MATCH ? AND sources.label LIKE ? AND chunks_trigram.content_type = ?
       ORDER BY rank
       LIMIT ?
+    `);
+        this.#stmtSearchTrigramExactContentType = this.#db.prepare(`
+      SELECT
+        chunks_trigram.title,
+        chunks_trigram.content,
+        chunks_trigram.content_type,
+        sources.label,
+        bm25(chunks_trigram, 5.0, 1.0) AS rank,
+        highlight(chunks_trigram, 1, char(2), char(3)) AS highlighted
+      FROM chunks_trigram
+      JOIN sources ON sources.id = chunks_trigram.source_id
+      WHERE chunks_trigram MATCH ? AND sources.label = ? AND chunks_trigram.content_type = ?
+      ORDER BY rank
+      LIMIT ?
     `);
         // Fuzzy path
         this.#stmtFuzzyVocab = this.#db.prepare("SELECT word FROM vocabulary WHERE length(word) BETWEEN ? AND ?");
@@ -514,17 +576,34 @@ export class ContentStore {
         };
     }
     // ── Search ──
-    search(query, limit = 3, source, mode = "AND", contentType) {
+    #mapSearchRows(rows) {
+        return rows.map((r) => ({
+            title: r.title,
+            content: r.content,
+            source: r.label,
+            rank: r.rank,
+            contentType: r.content_type,
+            highlighted: r.highlighted,
+        }));
+    }
+    #sourceFilterParam(source, sourceMatchMode) {
+        return sourceMatchMode === "exact" ? source : `%${source}%`;
+    }
+    search(query, limit = 3, source, mode = "AND", contentType, sourceMatchMode = "like") {
         const sanitized = sanitizeQuery(query, mode);
         let stmt;
         let params;
         if (source && contentType) {
-            stmt = this.#stmtSearchPorterFilteredContentType;
-            params = [sanitized, `%${source}%`, contentType, limit];
+            stmt = sourceMatchMode === "exact"
+                ? this.#stmtSearchPorterExactContentType
+                : this.#stmtSearchPorterFilteredContentType;
+            params = [sanitized, this.#sourceFilterParam(source, sourceMatchMode), contentType, limit];
         }
         else if (source) {
-            stmt = this.#stmtSearchPorterFiltered;
-            params = [sanitized, `%${source}%`, limit];
+            stmt = sourceMatchMode === "exact"
+                ? this.#stmtSearchPorterExact
+                : this.#stmtSearchPorterFiltered;
+            params = [sanitized, this.#sourceFilterParam(source, sourceMatchMode), limit];
         }
         else if (contentType) {
             stmt = this.#stmtSearchPorterContentType;
@@ -534,30 +613,26 @@ export class ContentStore {
             stmt = this.#stmtSearchPorter;
             params = [sanitized, limit];
         }
-        const rows = stmt.all(...params);
-        return rows.map((r) => ({
-            title: r.title,
-            content: r.content,
-            source: r.label,
-            rank: r.rank,
-            contentType: r.content_type,
-            highlighted: r.highlighted,
-        }));
+        return this.#mapSearchRows(stmt.all(...params));
     }
     // ── Trigram Search (Layer 2) ──
-    searchTrigram(query, limit = 3, source, mode = "AND", contentType) {
+    searchTrigram(query, limit = 3, source, mode = "AND", contentType, sourceMatchMode = "like") {
         const sanitized = sanitizeTrigramQuery(query, mode);
         if (!sanitized)
             return [];
         let stmt;
         let params;
         if (source && contentType) {
-            stmt = this.#stmtSearchTrigramFilteredContentType;
-            params = [sanitized, `%${source}%`, contentType, limit];
+            stmt = sourceMatchMode === "exact"
+                ? this.#stmtSearchTrigramExactContentType
+                : this.#stmtSearchTrigramFilteredContentType;
+            params = [sanitized, this.#sourceFilterParam(source, sourceMatchMode), contentType, limit];
         }
         else if (source) {
-            stmt = this.#stmtSearchTrigramFiltered;
-            params = [sanitized, `%${source}%`, limit];
+            stmt = sourceMatchMode === "exact"
+                ? this.#stmtSearchTrigramExact
+                : this.#stmtSearchTrigramFiltered;
+            params = [sanitized, this.#sourceFilterParam(source, sourceMatchMode), limit];
         }
         else if (contentType) {
             stmt = this.#stmtSearchTrigramContentType;
@@ -567,15 +642,7 @@ export class ContentStore {
             stmt = this.#stmtSearchTrigram;
             params = [sanitized, limit];
         }
-        const rows = stmt.all(...params);
-        return rows.map((r) => ({
-            title: r.title,
-            content: r.content,
-            source: r.label,
-            rank: r.rank,
-            contentType: r.content_type,
-            highlighted: r.highlighted,
-        }));
+        return this.#mapSearchRows(stmt.all(...params));
     }
     // ── Fuzzy Correction (Layer 3) ──
     fuzzyCorrect(query) {
@@ -598,11 +665,11 @@ export class ContentStore {
         return bestDist <= maxDist ? bestWord : null;
     }
     // ── Reciprocal Rank Fusion (Cormack et al. 2009) ──
-    #rrfSearch(query, limit, source, contentType) {
+    #rrfSearch(query, limit, source, contentType, sourceMatchMode = "like") {
         const K = 60; // Standard RRF constant
         const fetchLimit = Math.max(limit * 2, 10);
-        const porterResults = this.search(query, fetchLimit, source, "OR", contentType);
-        const trigramResults = this.searchTrigram(query, fetchLimit, source, "OR", contentType);
+        const porterResults = this.search(query, fetchLimit, source, "OR", contentType, sourceMatchMode);
+        const trigramResults = this.searchTrigram(query, fetchLimit, source, "OR", contentType, sourceMatchMode);
         const scoreMap = new Map();
         const key = (r) => `${r.source}::${r.title}`;
         for (const [i, r] of porterResults.entries()) {
@@ -655,9 +722,9 @@ export class ContentStore {
             .map(({ result }) => result);
     }
     // ── Unified Fallback Search ──
-    searchWithFallback(query, limit = 3, source, contentType) {
+    searchWithFallback(query, limit = 3, source, contentType, sourceMatchMode = "like") {
         // Step 1: RRF fusion (porter OR + trigram OR → merge)
-        const rrfResults = this.#rrfSearch(query, limit, source, contentType);
+        const rrfResults = this.#rrfSearch(query, limit, source, contentType, sourceMatchMode);
         if (rrfResults.length > 0) {
             const reranked = this.#applyProximityReranking(rrfResults, query);
             return reranked.map((r) => ({ ...r, matchLayer: "rrf" }));
@@ -672,7 +739,7 @@ export class ContentStore {
         const correctedWords = words.map((w) => this.fuzzyCorrect(w) ?? w);
         const correctedQuery = correctedWords.join(" ");
         if (correctedQuery !== original) {
-            const fuzzyResults = this.#rrfSearch(correctedQuery, limit, source, contentType);
+            const fuzzyResults = this.#rrfSearch(correctedQuery, limit, source, contentType, sourceMatchMode);
             if (fuzzyResults.length > 0) {
                 const reranked = this.#applyProximityReranking(fuzzyResults, correctedQuery);
                 return reranked.map((r) => ({ ...r, matchLayer: "rrf-fuzzy" }));