@nxuss/lemma 1.12.0 → 1.15.0

package/dist/esm/mcp/tools.js

@@ -1,7 +1,7 @@
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import fs from "fs";
 import path from "path";
-import { execSync, execFileSync, spawnSync } from "child_process";
+import { execSync, execFileSync, spawn } from "child_process";
 import os from "os";
 import axios from "axios";
 import * as ts from "typescript";
@@ -36,6 +36,7 @@ import { lookupStateHash, storeStateHash } from "../utils/StateHashCache.js";
 import { recordReceiptEvent, getReceiptSummary, getLedgerLength } from "../utils/TokenReceipt.js";
 import { distillCommandOutput, buildDistillFooter, readRegion } from "../utils/CommandOutputDistiller.js";
 import { findMatch, reindentReplacement } from "../utils/PatchMatcher.js";
+import { registerTaskHandlers, runAsTask, TASK_CAPABLE_TOOLS } from "./tasks.js";
 import { searchWorkspace, groupSearchResults, parseExtensionFilter } from "../utils/WorkspaceSearch.js";
 import { rankCandidates } from "../utils/LocalPrefilter.js";
 import { checkAlreadySent, recordSent, getLastEmitted } from "../utils/ReadWorkspaceCache.js";
@@ -44,7 +45,7 @@ import { ledgerKey, checkOutput, recordOutput as recordLedgerOutput } from "../u
 import { buildDepGraphMap, bfsDepGraph } from "../utils/DepGraph.js";
 import { getOrExtractSymbols } from "../utils/AstSymbolCache.js";
 import { warmNeighbors, registerSymbolExtractor } from "../utils/SpeculativeWarmer.js";
-import { findAffectedTests, formatAffectedTests } from "../utils/AffectedTests.js";
+import { findAffectedTests, formatAffectedTests, changedFilesFromGit } from "../utils/AffectedTests.js";
 import { mapSqueezedToOriginal, withLineNumbers, sequentialNumbers } from "../utils/LineNumberMap.js";
 import { fileOutline, formatOutline } from "../utils/FileOutline.js";
 import { getCachedSearch, setCachedSearch } from "../utils/SearchCache.js";
@@ -67,7 +68,7 @@ function isProUser() {
 }
 const FREE_TOOLS = new Set([
     // Cache & Memory — the hook that shows instant value
-    "smarter_cache", "state_hash_cache", "token_receipt", "search_memory", "store_memory", "get_project_history",
+    "smarter_cache", "state_hash_cache", "token_receipt", "search_memory", "store_memory", "downvote_memory", "verify_memory", "get_project_history",
     // Token optimization — shows what they're saving
     "token_budget", "squeeze_prompt", "turbosqueeze",
     // Utility — just enough to function
@@ -137,6 +138,45 @@ async function tryElicitConfirmation(summary) {
         return { supported: false, confirmed: true };
     }
 }
+/**
+ * Ask the client to pick one of several candidates via a typed (oneOf) elicitation form,
+ * instead of the plain confirm/deny shape tryElicitConfirmation uses. Same defensive
+ * contract: no support, a decline, or a malformed response all just mean "couldn't
+ * resolve it this way" — the caller falls back to its own error/default behavior, never
+ * blocks or throws.
+ */
+async function tryElicitChoice(message, options) {
+    if (!mcpServerRef || options.length === 0)
+        return { supported: false, index: null };
+    try {
+        const result = await mcpServerRef.elicitInput({
+            message,
+            requestedSchema: {
+                type: "object",
+                properties: {
+                    choice: {
+                        type: "string",
+                        title: "Which one?",
+                        oneOf: options.map((opt, i) => ({ const: String(i), title: opt.title })),
+                    },
+                },
+                required: ["choice"],
+            },
+        });
+        if (result.action !== "accept" || !result.content) {
+            return { supported: true, index: null };
+        }
+        const idx = Number(result.content.choice);
+        if (!Number.isInteger(idx) || idx < 0 || idx >= options.length) {
+            return { supported: true, index: null };
+        }
+        return { supported: true, index: idx };
+    }
+    catch (err) {
+        logWarn("elicitation", "Client does not support elicitation (or the request failed) — no choice made");
+        return { supported: false, index: null };
+    }
+}
 const toolDefinitions = [
     {
         name: "scrub_privacy",
@@ -153,7 +193,7 @@ const toolDefinitions = [
     {
         name: "search_memory",
         annotations: { readOnlyHint: true, openWorldHint: false },
-        description: "Search Lemma's semantic memory (The Brain) before investigating something from scratch — retrieves past solutions, fixes, and context from ALL your projects globally. Results are split into 'fresh' (safe to reuse — either untracked general knowledge, or every file it depended on still hashes the same) and 'stale' (a similar question was answered before, but a tracked file changed since — re-verify against current state before reusing). Never treat a stale result as current.",
+        description: "Search Lemma's semantic memory (The Brain) before investigating something from scratch — retrieves past solutions, fixes, and context from ALL your projects globally. Results split into 'fresh' (safe to reuse) and 'stale' (a tracked file changed since — re-verify before reusing). Never treat a stale result as current. If a returned memory turns out wrong once acted on, call downvote_memory with its id.",
         inputSchema: {
             type: "object",
             properties: {
@@ -164,6 +204,15 @@ const toolDefinitions = [
                     description: "Similarity floor (0.0-1.0) a memory must clear to be returned. Lowering this surfaces loosely related memories that are usually noise — leave it alone unless a known-relevant memory is being filtered out.",
                     default: 0.75,
                 },
+                domain: {
+                    type: "string",
+                    description: "Prefer memories tagged with this domain (e.g. 'auth', 'billing' — matches cognitive_map domains). Soft preference, not a filter: an untagged or cross-domain memory can still be the best match.",
+                },
+                semanticDiff: {
+                    type: "boolean",
+                    description: "Don't count a comment/whitespace-only change as stale.",
+                    default: false,
+                },
             },
             required: ["query"],
         },
@@ -171,7 +220,7 @@ const toolDefinitions = [
     {
         name: "store_memory",
         annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
-        description: "Persist a technical solution, bug fix, architecture decision, or key fact into Lemma's Brain — so future questions on the same topic (even phrased differently) don't require re-investigating the repo. Pass filePaths for anything derived from specific files (e.g. 'where is X implemented', 'how does Y work') so the memory auto-invalidates the moment those files change, instead of risking a stale answer being reused. If the answer is really about one function/class rather than the whole file, pass `symbols` instead (or in addition) so an unrelated edit elsewhere in that file doesn't stale it out. Pass outcome='failed' for an approach that was tried and did NOT work — that's just as worth remembering as a fix, so the Brain can warn 'already tried, didn't work' instead of only ever suggesting reuse.",
+        description: "Persist a technical solution, bug fix, architecture decision, or key fact into Lemma's Brain — so future questions on the same topic (even phrased differently) don't require re-investigating the repo. Pass filePaths for anything derived from specific files so the memory auto-invalidates the moment those files change. If the answer is really about one function/class, pass `symbols` instead (or in addition) so an unrelated edit elsewhere in that file doesn't stale it out. Pass outcome='failed' for an approach that was tried and did NOT work.",
         inputSchema: {
             type: "object",
             properties: {
@@ -216,10 +265,48 @@ const toolDefinitions = [
                     },
                     description: "Split `response` into independently-verifiable sub-claims when it makes more than one assertion about different parts of the code. Each claim tracks its own filePaths/symbols, so one claim going stale (e.g. one function changed) doesn't discard the others that are still true. Skip this for a single-fact response — plain filePaths/symbols above already covers that case.",
                 },
+                domain: {
+                    type: "string",
+                    description: "Tag this memory with a domain (e.g. 'auth', 'billing' — matches cognitive_map domains) so domain-scoped searches prefer it. Optional: when omitted and filePaths is set, Lemma auto-derives a domain from the first file via cognitive_map (or a lightweight path heuristic if the map was never built).",
+                },
+                derivedFrom: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Ids of memories this one depends on; stale if they go stale.",
+                },
             },
             required: ["query", "response"],
         },
     },
+    {
+        name: "verify_memory",
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
+        description: "Cheaply revalidate ids from a prior search_memory/store_memory result — batch hash-compare, no BM25/re-search. Each id comes back 'fresh', 'stale', or 'unknown' (purged/renamed, never reported as fresh). Accepts entry ids and claim ids together.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                ids: { type: "array", items: { type: "string" }, description: "Entry and/or claim ids to revalidate, from a prior search_memory/store_memory result." },
+                semanticDiff: {
+                    type: "boolean",
+                    description: "Don't count a comment/whitespace-only change as stale.",
+                    default: false,
+                },
+            },
+            required: ["ids"],
+        },
+    },
+    {
+        name: "downvote_memory",
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+        description: "Tell the Brain a specific memory from a prior search_memory result was wrong or misleading in practice — not just irrelevant to skip, but actually acted on and it didn't hold up. Lowers that memory's future ranking and moves it toward eviction sooner, without deleting it (it may still be right for a different query later). Use the `id` from the search_memory result you're downvoting.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                id: { type: "string", description: "The memory's id, from a prior search_memory result." },
+            },
+            required: ["id"],
+        },
+    },
     {
         name: "get_routing_advice",
         annotations: { readOnlyHint: true, openWorldHint: false },
@@ -314,6 +401,7 @@ const toolDefinitions = [
     {
         name: "run_workspace_command",
         annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
+        execution: { taskSupport: "optional" },
         description: "Execute a bash command in the workspace root. Default timeout 120s — raise it with timeoutMs for a full test or build run (max 600s). Captures both stdout and stderr, and returns whatever was produced even if the command times out. Long test/build/lint output is distilled deterministically — for jest, vitest and tsc it returns the failing tests or diagnostics with their locations and reasons, dropping code frames and node_modules stack frames; anything else falls back to head/tail plus error-matching lines. The complete output is always stored first and the reply carries a handle: nothing is lost, use output_region to retrieve any part verbatim. Pass raw:true to skip distillation.",
         inputSchema: {
             type: "object",
@@ -1347,6 +1435,8 @@ const toolHandlers = {
     scrub_privacy: handleScrubPrivacy,
     search_memory: handleSearchMemory,
     store_memory: handleStoreMemory,
+    downvote_memory: handleDownvoteMemory,
+    verify_memory: handleVerifyMemory,
     get_routing_advice: handleGetRoutingAdvice,
     auto_heal: handleAutoHeal,
     read_workspace_file: handleReadWorkspaceFile,
@@ -1496,7 +1586,7 @@ export function setupToolsHandlers(server, onToolCall) {
     server.setRequestHandler(ListToolsRequestSchema, async () => ({
         tools: toolDefinitionsArray,
     }));
-    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
         const { name, arguments: args } = request.params;
         const startTime = Date.now();
         // ── Pro License Gate (granular: free tools work without license) ────────
@@ -1525,6 +1615,39 @@ export function setupToolsHandlers(server, onToolCall) {
             });
             throw new Error(`Unknown tool: ${name}`);
         }
+        // ── Task-augmented call: hand off to tasks.ts instead of awaiting inline ────
+        // A task-unaware client never sends `request.params.task`, so this only triggers when
+        // the caller actually asked for it — today's synchronous behavior is unchanged otherwise.
+        if (request.params.task && TASK_CAPABLE_TOOLS.has(name)) {
+            const ledgerBefore = getLedgerLength();
+            return runAsTask(name, (args || {}), request, extra.requestId, handler, (result, error) => {
+                if (error) {
+                    onToolCall?.({
+                        tool: name,
+                        args: args || {},
+                        result: "ERROR",
+                        latency: Date.now() - startTime,
+                        error: error instanceof Error ? error.message.substring(0, 100) : String(error).substring(0, 100),
+                    });
+                    return;
+                }
+                if (getLedgerLength() === ledgerBefore) {
+                    recordReceiptEvent(receiptTypeForTool(name), name, {
+                        tool: name,
+                        ...receiptLabelMeta(name, args),
+                    });
+                }
+                const tokensImpact = estimateTokensFromResult(result);
+                onToolCall?.({
+                    tool: name,
+                    args: args || {},
+                    result: "OK",
+                    latency: Date.now() - startTime,
+                    tokensImpact,
+                });
+                reportCost({ source: "toolResult", tokens: tokensImpact, toolName: name });
+            });
+        }
         try {
             // Sampled around the handler so a tool that logs its own, more specific event
             // (a cache hit, a miss) isn't double-counted by the generic entry below.
@@ -1560,6 +1683,9 @@ export function setupToolsHandlers(server, onToolCall) {
             throw error;
         }
     });
+    // Registered after ListTools/CallTool: tests and other callers that assume "ListTools is
+    // first, CallTool is second" (see tests/unit/tool-regressions.test.ts) key off that order.
+    registerTaskHandlers(server);
 }
 // ── Tool Implementations ────────────────────────────────────────────
 async function handleScrubPrivacy(args) {
@@ -1583,11 +1709,13 @@ async function handleSearchMemory(args) {
     // formatting below then presents it as a reusable memory. Match smarter_cache's
     // threshold so both paths agree on what counts as a hit.
     const minSimilarity = typeof args?.minSimilarity === "number" ? args.minSimilarity : DEFAULT_MEMORY_SIMILARITY_FLOOR;
+    const domain = typeof args?.domain === "string" && args.domain.trim() ? args.domain.trim() : undefined;
+    const semanticDiff = args?.semanticDiff === true;
     if (!query)
         throw new Error("Query is required");
     try {
         const brain = getBrain();
-        const results = brain.search(query, limit, minSimilarity, { projectId: deriveProjectId() });
+        const results = brain.search(query, limit, minSimilarity, { projectId: deriveProjectId(), domain, semanticDiff });
         if (results.length === 0) {
             recordReceiptEvent("reasoning", query.substring(0, 100), {
                 tool: "search_memory",
@@ -1611,7 +1739,9 @@ async function handleSearchMemory(args) {
             const staleCount = r.claims.filter((c) => !c.fresh).length;
             return `\nClaims (${r.claims.length - staleCount}/${r.claims.length} still fresh — trust only the ✓ ones):\n${lines.join("\n")}`;
         };
-        const formatResult = (r, i) => `Result ${i + 1} (Similarity: ${(r.similarity * 100).toFixed(1)}%)${r.outcome === "failed" ? "\n⚠️ TAGGED AS A FAILED ATTEMPT — this was tried before and did NOT work. Do not repeat it; treat this as a warning, not a suggestion." : ""}\nPrompt: ${r.query.substring(0, 300)}...\nResponse: ${typeof r.response === "string" ? r.response : JSON.stringify(r.response, null, 2)}${formatClaims(r)}`;
+        const formatResult = (r, i) => `Result ${i + 1} (id: ${r.id}, Similarity: ${(r.similarity * 100).toFixed(1)}%)${r.outcome === "failed" ? "\n⚠️ TAGGED AS A FAILED ATTEMPT — this was tried before and did NOT work. Do not repeat it; treat this as a warning, not a suggestion." : ""}\nPrompt: ${r.query.substring(0, 300)}...\nResponse: ${typeof r.response === "string" ? r.response : JSON.stringify(r.response, null, 2)}${formatClaims(r)}${Array.isArray(r.cosmeticChanges) && r.cosmeticChanges.length > 0
+            ? `\n(comment/whitespace-only change, ignored under semanticDiff: ${r.cosmeticChanges.join(", ")})`
+            : ""}`;
         if (fresh.length > 0) {
             // Only a fresh hit (or an untracked, purely conceptual entry) counts as a real
             // avoided re-investigation — this is the only case worth crediting as savings.
@@ -1659,11 +1789,18 @@ async function handleStoreMemory(args) {
     const claims = Array.isArray(args?.claims)
         ? args.claims.filter((c) => c?.text)
         : undefined;
+    const explicitDomain = typeof args?.domain === "string" && args.domain.trim() ? args.domain.trim() : undefined;
+    // Auto-derive from the first tracked file when the caller didn't say — see
+    // deriveDomainForFile for why this is a best-effort tag, not a hard classification.
+    const domain = explicitDomain || (filePaths && filePaths.length > 0 ? deriveDomainForFile(filePaths[0]) : undefined);
+    const derivedFrom = Array.isArray(args?.derivedFrom)
+        ? args.derivedFrom.filter((id) => typeof id === "string" && id)
+        : undefined;
     if (!query || !responseText)
         throw new Error("Query and response are required");
     try {
         const brain = getBrain();
-        const storeRes = brain.store(query, responseText, provider, 0.92, filePaths, undefined, outcome, symbols, claims);
+        const storeRes = brain.store(query, responseText, provider, 0.92, filePaths, undefined, outcome, symbols, claims, domain, derivedFrom);
         // Storing a memory saves nothing — it only creates the chance of a saving later.
         // Crediting tokens here inflated the ledger on write and then credited the same
         // answer again on every read. The saving is booked by search_memory on a fresh hit.
@@ -1676,13 +1813,63 @@ async function handleStoreMemory(args) {
         const symbolNote = symbols && symbols.length > 0 ? ` Tracking freshness against ${symbols.length} symbol(s) specifically — unrelated edits elsewhere in those files won't stale this out.` : "";
         const outcomeNote = outcome === "failed" ? " Tagged as a FAILED attempt — future searches will surface it as a warning, not a suggestion." : "";
         const claimsNote = claims && claims.length > 0 ? ` Split into ${claims.length} independently-verifiable claim(s) — a future search can trust the ones still fresh even if another goes stale.` : "";
-        return { content: [{ type: "text", text: `Success: Memory stored. ${storeRes.reason}${trackingNote}${symbolNote}${outcomeNote}${claimsNote}` }] };
+        const domainNote = domain
+            ? ` Tagged with domain '${domain}'${explicitDomain ? "" : " (auto-derived from filePaths)"} — domain-scoped searches will prefer it.`
+            : "";
+        const derivedFromNote = derivedFrom && derivedFrom.length > 0
+            ? ` Derived from ${derivedFrom.length} prior memor${derivedFrom.length === 1 ? "y" : "ies"} — this one goes stale too if any of those do.`
+            : "";
+        const conflictsNote = storeRes.conflicts && storeRes.conflicts.length > 0
+            ? `\n\n⚠️ ${storeRes.conflicts.length} existing ${storeRes.conflicts.length === 1 ? "memory shares" : "memories share"} a symbol with this one but disagree on outcome — review before trusting either:\n` +
+                storeRes.conflicts.map((c) => `  - [${c.outcome}] ${c.id}: ${c.query.substring(0, 120)}`).join("\n")
+            : "";
+        return { content: [{ type: "text", text: `Success: Memory stored. ${storeRes.reason}${trackingNote}${symbolNote}${outcomeNote}${claimsNote}${domainNote}${derivedFromNote}${conflictsNote}` }] };
     }
     catch (e) {
         logError("store_memory", e);
         return { content: [{ type: "text", text: `Failed to store memory in local Brain: ${e.message}` }] };
     }
 }
+async function handleDownvoteMemory(args) {
+    const id = args?.id;
+    if (!id)
+        throw new Error("id is required");
+    try {
+        const result = getBrain().downvote(id);
+        return { content: [{ type: "text", text: result.message }] };
+    }
+    catch (e) {
+        logError("downvote_memory", e);
+        return { content: [{ type: "text", text: `Failed to downvote memory: ${e.message}` }] };
+    }
+}
+async function handleVerifyMemory(args) {
+    const ids = Array.isArray(args?.ids) ? args.ids.filter((id) => typeof id === "string" && id) : [];
+    const semanticDiff = args?.semanticDiff === true;
+    if (ids.length === 0)
+        throw new Error("ids is required and must be a non-empty array");
+    try {
+        const results = getBrain().verifyByIds(ids, { semanticDiff });
+        const fresh = results.filter((r) => r.status === "fresh");
+        const stale = results.filter((r) => r.status === "stale");
+        const unknown = results.filter((r) => r.status === "unknown");
+        const formatOne = (r) => {
+            const staleNote = r.staleFiles && r.staleFiles.length > 0 ? ` (changed: ${r.staleFiles.join(", ")})` : "";
+            const cosmeticNote = r.cosmeticChanges && r.cosmeticChanges.length > 0 ? ` (cosmetic only, ignored: ${r.cosmeticChanges.join(", ")})` : "";
+            const claimsNote = r.claimBreakdown && r.claimBreakdown.length > 0
+                ? `\n  Claims: ${r.claimBreakdown.map((c) => `${c.fresh ? "✓" : "✗"} ${c.text}`).join(" | ")}`
+                : "";
+            return `${r.id}: ${r.status}${staleNote}${cosmeticNote}${claimsNote}`;
+        };
+        const summary = `${fresh.length} fresh, ${stale.length} stale, ${unknown.length} unknown (of ${results.length} checked).`;
+        const lines = results.map(formatOne).join("\n");
+        return { content: [{ type: "text", text: `${summary}\n${lines}` }] };
+    }
+    catch (e) {
+        logError("verify_memory", e);
+        return { content: [{ type: "text", text: `Failed to verify memory: ${e.message}` }] };
+    }
+}
 async function handleGetRoutingAdvice(args) {
     const prompt = args?.prompt;
     const intendedModel = args?.intended_model;
@@ -1921,6 +2108,30 @@ function stripLineNumberGutter(text) {
         return text;
     return lines.map((l) => l.replace(GUTTER, "")).join("\n");
 }
+// Splices one resolved match into the file and writes it. Shared by the normal
+// single-match path and the ambiguous-match-resolved-via-elicitation path below.
+async function applyMatch(match, filePath, resolved, originalContent, searchContent, replaceContent) {
+    let updatedContent;
+    if (match.strategy === "exact" && match.charStart !== undefined && match.charEnd !== undefined) {
+        // Splice by character offset — the search block may be a mid-line fragment, and
+        // a whole-line splice would discard everything else sharing that line.
+        updatedContent = originalContent.slice(0, match.charStart) + replaceContent + originalContent.slice(match.charEnd);
+    }
+    else {
+        const contentLines = originalContent.split("\n");
+        const finalReplace = reindentReplacement(replaceContent, searchContent, contentLines[match.startLine]);
+        const updatedLines = [...contentLines.slice(0, match.startLine), ...finalReplace.split("\n"), ...contentLines.slice(match.endLine + 1)];
+        updatedContent = updatedLines.join("\n");
+    }
+    const elicited = await tryElicitConfirmation(`Apply a patch to ${filePath}? This replaces ${searchContent.length} char(s) with ${replaceContent.length} char(s) ` +
+        `starting at line ${match.startLine + 1}.`);
+    if (elicited.supported && !elicited.confirmed) {
+        return { content: [{ type: "text", text: `Patch to ${filePath} was not applied: declined during confirmation.` }] };
+    }
+    fs.writeFileSync(resolved, updatedContent, "utf8");
+    const note = match.strategy === "exact" ? "" : ` (matched via ${match.strategy}, score ${match.score.toFixed(2)})`;
+    return { content: [{ type: "text", text: `Success: Patch successfully applied to ${filePath}${note}` }] };
+}
 async function handleApplyWorkspacePatch(args) {
     const filePath = args?.filePath;
     const rawSearch = args?.searchContent;
@@ -1943,6 +2154,15 @@ async function handleApplyWorkspacePatch(args) {
         const matchResult = findMatch(originalContent, searchContent);
         if (!Array.isArray(matchResult)) {
             if (matchResult.reason === "ambiguous") {
+                const candidates = matchResult.candidates ?? [];
+                if (candidates.length > 0) {
+                    const chosen = await tryElicitChoice(`${candidates.length} equally good matches found for the search content in ${filePath}. Which one should be patched?`, candidates.map((c) => ({
+                        title: `line ${c.startLine + 1}: ${c.matchedText.split("\n")[0].slice(0, 80)}`,
+                    })));
+                    if (chosen.index !== null) {
+                        return applyMatch(candidates[chosen.index], filePath, resolved, originalContent, searchContent, replaceContent);
+                    }
+                }
                 return {
                     content: [
                         {
@@ -1971,33 +2191,71 @@ async function handleApplyWorkspacePatch(args) {
                 ],
             };
         }
-        const match = matchResult[0];
-        let updatedContent;
-        if (match.strategy === "exact" && match.charStart !== undefined && match.charEnd !== undefined) {
-            // Splice by character offset — the search block may be a mid-line fragment, and
-            // a whole-line splice would discard everything else sharing that line.
-            updatedContent = originalContent.slice(0, match.charStart) + replaceContent + originalContent.slice(match.charEnd);
-        }
-        else {
-            const contentLines = originalContent.split("\n");
-            const finalReplace = reindentReplacement(replaceContent, searchContent, contentLines[match.startLine]);
-            const updatedLines = [...contentLines.slice(0, match.startLine), ...finalReplace.split("\n"), ...contentLines.slice(match.endLine + 1)];
-            updatedContent = updatedLines.join("\n");
-        }
-        const elicited = await tryElicitConfirmation(`Apply a patch to ${filePath}? This replaces ${searchContent.length} char(s) with ${replaceContent.length} char(s) ` +
-            `starting at line ${match.startLine + 1}.`);
-        if (elicited.supported && !elicited.confirmed) {
-            return { content: [{ type: "text", text: `Patch to ${filePath} was not applied: declined during confirmation.` }] };
-        }
-        fs.writeFileSync(resolved, updatedContent, "utf8");
-        const note = match.strategy === "exact" ? "" : ` (matched via ${match.strategy}, score ${match.score.toFixed(2)})`;
-        return { content: [{ type: "text", text: `Success: Patch successfully applied to ${filePath}${note}` }] };
+        return applyMatch(matchResult[0], filePath, resolved, originalContent, searchContent, replaceContent);
     }
     catch (err) {
         logError("apply_workspace_patch", err);
         return { content: [{ type: "text", text: `Error applying patch: ${err.message}` }] };
     }
 }
+// Async replacement for spawnSync: a blocking syscall inside a `tools/call` handler
+// freezes the whole (single-threaded) MCP server for the run's entire duration — including
+// task-status polls for THIS run once it's task-augmented (see runAsTask in tasks.ts), which
+// would otherwise defeat the point of making the tool pollable. `spawn` keeps the event loop
+// free while the command runs. Shape of the resolved value mirrors spawnSync's return value
+// on the fields the caller actually reads, so the rest of handleRunWorkspaceCommand is unchanged.
+function spawnCollect(command, cwd, timeoutMs) {
+    return new Promise((resolve) => {
+        const child = spawn(command, {
+            cwd,
+            shell: true,
+            env: { ...process.env },
+            // spawnSync closed stdin immediately (no `input` option given), so a command reading
+            // from stdin (e.g. `sed` with no file argument) saw EOF right away. Plain `spawn`
+            // leaves stdin as an open pipe by default — nothing ever writes to or closes it — so
+            // the same command hangs until the timeout kills it. "ignore" reproduces the old,
+            // immediate-EOF behavior.
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        let stdoutBytes = 0;
+        let stderrBytes = 0;
+        const MAX_BUFFER = 20 * 1024 * 1024;
+        let timedOut = false;
+        let settled = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill("SIGTERM");
+        }, timeoutMs);
+        child.stdout?.on("data", (chunk) => {
+            if (stdoutBytes >= MAX_BUFFER)
+                return;
+            stdoutBytes += chunk.length;
+            stdout += chunk.toString("utf8");
+        });
+        child.stderr?.on("data", (chunk) => {
+            if (stderrBytes >= MAX_BUFFER)
+                return;
+            stderrBytes += chunk.length;
+            stderr += chunk.toString("utf8");
+        });
+        child.on("error", (err) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve({ stdout, stderr, status: null, timedOut, error: err });
+        });
+        child.on("close", (code) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve({ stdout, stderr, status: code, timedOut });
+        });
+    });
+}
 async function handleRunWorkspaceCommand(args) {
     const command = args?.command;
     if (!command)
@@ -2027,10 +2285,10 @@ async function handleRunWorkspaceCommand(args) {
     // ── End allowlist check ────────────────────────────────────────────────
     const workspaceRoot = process.cwd();
     try {
-        // spawnSync rather than execSync: execSync leaves stderr attached to the parent unless
-        // stdio is overridden, which silently dropped the output of every tool that reports on
-        // stderr (jest and tsc both do) on a successful run. It also gives us stdout, stderr and
-        // the exit code through one code path instead of a throw-on-failure split.
+        // spawn (via spawnCollect above) rather than execSync: execSync leaves stderr attached to
+        // the parent unless stdio is overridden, which silently dropped the output of every tool
+        // that reports on stderr (jest and tsc both do) on a successful run. It also gives us
+        // stdout, stderr and the exit code through one code path instead of a throw-on-failure split.
         // 15s was below the runtime of the commands this tool exists for: a real `npm test` or
         // `tsc --noEmit` always tripped it, so the distillation pipeline never ran on the output
         // it was built for and the call was pure overhead before falling back to a plain shell.
@@ -2042,15 +2300,8 @@ async function handleRunWorkspaceCommand(args) {
         if (elicited.supported && !elicited.confirmed) {
             return { content: [{ type: "text", text: `Command was not run: declined during confirmation.\n\nCommand: ${command}` }] };
         }
-        const result = spawnSync(command, {
-            cwd: workspaceRoot,
-            shell: true,
-            encoding: "utf8",
-            timeout: timeoutMs,
-            maxBuffer: 20 * 1024 * 1024,
-            env: { ...process.env },
-        });
-        const timedOut = !!result.error && result.error.code === "ETIMEDOUT";
+        const result = await spawnCollect(command, workspaceRoot, timeoutMs);
+        const timedOut = result.timedOut;
         if (result.error && !timedOut) {
             return {
                 content: [{ type: "text", text: `Command could not be executed: ${result.error.message}` }],
@@ -4963,6 +5214,37 @@ async function handleSmartFileSlice(args) {
     }
 }
 // ── Test Oracle ──────────────────────────────────────────────────────
+/**
+ * Auto-capture a green test run into the Brain, tagged `outcome: 'confirmed'` and tracked
+ * against the files actually changed. This is the auto-store hook: today store_memory only
+ * fires when the agent remembers to call it, so working fixes routinely go uncaptured. A
+ * passing suite over an uncommitted diff is real, cheap evidence something worked — reusing
+ * it costs nothing store_memory wouldn't have cost anyway, and store()'s own dedup guard
+ * means re-running the same green suite repeatedly just no-ops instead of piling up entries.
+ *
+ * Silent on a clean tree (nothing changed, nothing to attribute the pass to) or when the
+ * repo isn't git-tracked. Returns a short suffix for resultText — this must never happen
+ * invisibly, or a future search_memory hit would look reasoned-from-scratch instead of
+ * traced back to an automated test run.
+ */
+function autoStoreGreenTests(command, workspaceRoot) {
+    try {
+        const changed = changedFilesFromGit(workspaceRoot);
+        if (changed.length === 0)
+            return "";
+        const domain = deriveDomainForFile(changed[0]);
+        const query = `tests passing after changes to ${changed.slice(0, 5).join(", ")}${changed.length > 5 ? ` and ${changed.length - 5} more file(s)` : ""}`;
+        const response = `\`${command}\` passed with these files changed (uncommitted at capture time):\n${changed.join("\n")}`;
+        const storeRes = getBrain().store(query, response, "test_oracle_auto", 0.92, changed, undefined, "confirmed", undefined, undefined, domain);
+        if (!storeRes.stored)
+            return "";
+        return `\n\n[Lemma] Auto-captured this green state in Brain (${changed.length} file(s), tagged confirmed) — search_memory will surface it, and will flag it stale the moment any of these files change again.`;
+    }
+    catch {
+        // Never let auto-capture break the actual test result the caller asked for.
+        return "";
+    }
+}
 async function handleTestOracle(args) {
     const command = args.command || "npm test";
     const workspaceRoot = process.cwd();
@@ -4973,6 +5255,7 @@ async function handleTestOracle(args) {
     try {
         const out = execSync(command, { cwd: workspaceRoot, encoding: "utf8", timeout: 30000 });
         resultText = `All tests passed!\n\nOutput:\n${out.substring(0, 1000)}`;
+        resultText += autoStoreGreenTests(command, workspaceRoot);
     }
     catch (e) {
         const stdout = e.stdout || "";
@@ -5288,6 +5571,41 @@ async function handleFileIntentIndex(args) {
     }
 }
 const COG_MAP_FILE = path.join(os.homedir(), ".lemma-cache", "cog_map.json");
+/**
+ * Best-effort domain for a repo-relative file path, so store_memory and the test-oracle
+ * auto-store below don't require a human to type `domain` by hand every time.
+ *
+ * Prefers the persisted Cognitive Map (built via `cognitive_map` action "build") when it
+ * has this exact file listed — that reflects an actual workspace scan. Falls back to the
+ * same lightweight substring heuristic "build" uses, so a project that never ran "build"
+ * still gets a reasonable tag instead of none at all. Returns undefined rather than
+ * "general" when nothing matches — an absent domain stays visible to every domain-scoped
+ * search (see BrainEntry.domain), while a wrong guess would actively mislead one.
+ */
+function deriveDomainForFile(relPath) {
+    const norm = relPath.replace(/^\//, "");
+    if (fs.existsSync(COG_MAP_FILE)) {
+        try {
+            const map = JSON.parse(fs.readFileSync(COG_MAP_FILE, "utf8"));
+            for (const node of Object.values(map.nodes || {})) {
+                if (node.files.includes(norm))
+                    return node.domain;
+            }
+        }
+        catch { /* fall through to heuristic */ }
+    }
+    if (norm.includes("mcp"))
+        return "mcp";
+    if (norm.includes("subconscious") || norm.includes("brain"))
+        return "memory";
+    if (norm.includes("security") || norm.includes("scrubber"))
+        return "security";
+    if (norm.includes("pr-review"))
+        return "pr-review";
+    if (norm.includes("utils"))
+        return "utils";
+    return undefined;
+}
 async function handleCognitiveMap(args) {
     const action = args.action;
     const domain = args.domain;