wyrm-mcp 7.2.0 → 7.2.2

package/dist/handlers/capture.js

@@ -1,1113 +1,77 @@
-/**
- * Capture domain — ToolSpec contract v2 (v7 F3 T026, hot-path extraction).
- *
- * The WRITE FUNNEL (spec FR-4): wyrm_capture + everything it absorbs per the
- * T022 mode map — wyrm_remember (mode=direct), wyrm_auto_capture (extract),
- * wyrm_distill (session), wyrm_harvest (artifacts), wyrm_import_git/pr/rules
- * (import source=…), wyrm_spec_register (spec), wyrm_scaffold_save
- * (checklist). All moved VERBATIM from the index.ts dispatch switch +
- * buildAllTools(); the capture shim (src/handlers/shims.ts) keeps resolving
- * each mode onto THESE names, and the registry is checked before the switch,
- * so the shim table needs zero changes. ALIASES ROUTE TO THE SAME HANDLER
- * CODE PATHS — these specs ARE those paths, never reimplementations.
- *
- * The v7 F2 (T012) daemonOr canonical write seams moved with their handlers
- * unchanged (artifact_add ×4, quest_add, truth_set — source-locked by
- * tests/daemon-writer.test.ts, repointed here in the same commit).
- *
- * @copyright 2026 Ghost Protocol (Pvt) Ltd.
- * @license AGPL-3.0-or-later — dual-licensed; commercial terms: ghosts.lk@proton.me. See LICENSE.
- */
-import { join as pathJoin } from 'path';
-import { TOOL_ANNOTATIONS } from '../tool-annotations.js';
-import { renderResult, withGlyph } from '../render.js';
-import { ValidationError, asEnum } from '../validate.js';
-import { daemonOr } from '../daemon-writer.js';
-import { classifyCapture } from '../capture.js';
-import { extractCandidates, candidateToArtifact, escapeLikePattern } from '../auto-capture.js';
-import { parseTrace, segmentsToText } from '../trace-harvest.js';
-import { getActor, runWithActor } from './boundary.js';
-import { harvestProjects } from '../harvest.js';
-import { readFileSync, readdirSync, statSync } from 'fs';
-import { join as pathJoin2 } from 'path';
-import { homedir } from 'os';
-import { readSpecDir, specTaskSignature } from '../spec-kit.js';
-export const captureToolSpecs = [
-    {
-        name: "wyrm_capture",
-        description: "Use to save anything worth keeping - the single write funnel. Auto-classifies notes, decisions, and lessons into quest, ground truth, or memory; risky writes queue for wyrm_review. mode=direct (store a proven pattern or lesson learned so future agents reuse it), extract (pull memories from a conversation transcript or freeform text), trace (harvest a session JSONL / tool-call log into run-tagged review candidates), session (close out a work session into reusable knowledge), artifacts (harvest a repo's READMEs and recent commits into durable facts), import source=git|pr|rules, spec (turn a tasks.md into tracked work items), checklist. Keywords: remember this, jot down, write down, future reference.",
-        // v7 F3 (T022): the WRITE FUNNEL (spec FR-4) — wyrm_capture absorbs
-        // remember/auto_capture/distill/harvest/import_*/spec_register/
-        // scaffold_save via mode=…; resolveShimCall (src/handlers/shims.ts)
-        // translates each mode onto the original dispatcher case (thin shim,
-        // same code path). The 6.x modes auto|quest|truth|memory keep their
-        // classification-override semantics on capture's own case; 'classify'
-        // is the spec name for 'auto'. mode=trace|debrief arrive with wyrm_run
-        // (T027) and are not advertised before they exist. `content` is only
-        // required by the classify path, so the schema-level required is
-        // relaxed (additive: every previously valid call stays valid);
-        // per-mode requirements are enforced by the underlying cases.
-        inputSchema: {
-            type: "object",
-            properties: {
-                // v7 F3 (T026): property prose compressed to fund the hot-path
-                // outputSchemas under the 8K default-surface pin (T022/T025 trade).
-                content: { type: "string", description: "classify/rules" },
-                project_id: { type: "number", description: "classify/import/spec" },
-                tags: { type: "array", items: { type: "string" } },
-                mode: { type: "string", enum: ["auto", "quest", "truth", "memory", "classify", "direct", "extract", "trace", "session", "artifacts", "import", "spec", "checklist"], description: "quest|truth|memory force the type" },
-                source: { type: "string", enum: ["git", "pr", "rules"], description: "import" },
-                projectPath: { type: "string", description: "non-classify" },
-                kind: { type: "string", description: "direct" },
-                problem: { type: "string", description: "direct" },
-                validatedFix: { type: "string", description: "direct" },
-                // T027 budget trim: whyItWorked/outcome (direct-mode niche) still
-                // pass through undeclared — the T022 lean-union rule.
-                text: { type: "string", description: "extract" },
-                sessionId: { type: "string", description: "session" },
-                candidates: { type: "array", items: { type: "object" }, description: "session" },
-                dryRun: { type: "boolean", description: "artifacts" },
-                commits: { type: "array", items: { type: "object" }, description: "import git" },
-                title: { type: "string", description: "import pr" },
-                body: { type: "string", description: "import pr" },
-                specDir: { type: "string", description: "spec" },
-                problemType: { type: "string", description: "checklist" },
-                whenToUse: { type: "string", description: "checklist" },
-                steps: { type: "array", items: { type: "string" }, description: "checklist" },
-            },
-            required: [],
-        },
-        outputSchema: {
-            type: "object",
-            properties: {
-                status: { type: "string", enum: ["captured", "queued_for_review"] },
-                type: { type: "string" },
-                subtype: { type: "string" },
-                confidence: { type: "number" },
-                reasoning: { type: "string" },
-                id: { type: "integer" },
-                ref: { type: "string" },
-                needs_review: { type: "boolean" },
-                reason: { type: "string" },
-                artifact_id: { type: "integer" },
-                conflicts_with: { type: "array" },
-                advisory_conflicts: { type: "array" },
-            },
-            required: ["status"],
-        },
-        annotations: TOOL_ANNOTATIONS.wyrm_capture,
-        aliases: [],
-        handler: async (args, { store, raw, memory, truths, cache }) => {
-            const { content: capContent, project_id: capProjId, tags: capTags, mode: capMode } = args;
-            // Determine classification
-            let classified = classifyCapture(capContent);
-            if (capMode && capMode !== 'auto') {
-                const subtypeMap = { quest: 'quest', truth: 'decision', memory: 'pattern' };
-                classified = {
-                    type: capMode,
-                    subtype: subtypeMap[capMode] ?? capMode,
-                    confidence: 100,
-                    reasoning: `Mode override: ${capMode}`,
-                };
-            }
-            const { type: capType, subtype: capSubtype, confidence: capConf, reasoning: capReasoning } = classified;
-            const effectiveProjId = capProjId ?? null;
-            let storedId = 0;
-            let typeShort = '';
-            let needsReview = false;
-            let advisoryConflicts;
-            if (capType === 'quest') {
-                if (effectiveProjId === null) {
-                    return { content: [{ type: "text", text: `Cannot capture quest without project_id. Please provide project_id.` }], isError: true };
-                }
-                // v7 F2 (T012): canonical write seam — capture's quest branch.
-                // Classification (classifyCapture) is deterministic and stays
-                // CLIENT-side; only the resulting write hops to the daemon.
-                const quest = await daemonOr('quest_add', effectiveProjId, { title: capContent.slice(0, 200), description: '', priority: 'medium', tags: capTags?.join(',') }, () => store.addQuest(effectiveProjId, capContent.slice(0, 200), '', 'medium', capTags?.join(',')));
-                storedId = quest.id;
-                typeShort = 'quest';
-                cache.invalidate('wyrm_all_quests');
-                cache.invalidate('wyrm_stats');
-            }
-            else if (capType === 'truth') {
-                if (effectiveProjId === null) {
-                    return { content: [{ type: "text", text: `Cannot capture truth without project_id. Please provide project_id.` }], isError: true };
-                }
-                // Structural contradiction check: same project + same category
-                if (capConf >= 80) {
-                    const capCategory = capSubtype ?? 'other';
-                    const existingTruths = truths.getCurrent(effectiveProjId);
-                    const sameCategory = existingTruths.filter(t => t.category === capCategory);
-                    if (sameCategory.length > 0) {
-                        // Route to review queue — possible supersession
-                        // v7 F2 (T012): canonical write seam (conflict-check stays a local READ).
-                        const conflictInput = {
-                            kind: 'pattern',
-                            problem: `Potential conflict with ${sameCategory.length} existing truth(s) in category "${capCategory}"`,
-                            validatedFix: capContent,
-                            whyItWorked: 'Pending review — possible supersession',
-                            tags: capTags ?? [],
-                            confidence: capConf / 100,
-                            needsReview: 1,
-                        };
-                        const conflictArtifact = await daemonOr('artifact_add', effectiveProjId, conflictInput, () => memory.add(effectiveProjId, conflictInput));
-                        // Machine-first outcome: the body IS the 6.x JSON payload; the
-                        // text channel is its serialization (templateless renderResult).
-                        return renderResult({
-                            status: 'queued_for_review',
-                            reason: 'conflict_check',
-                            artifact_id: conflictArtifact.id,
-                            conflicts_with: sameCategory.map(t => ({ id: t.id, content: t.value.slice(0, 80) })),
-                        });
-                    }
-                }
-                if (capMode !== 'truth' && capConf < 100) {
-                    // Store as artifact pending review
-                    // v7 F2 (T012): canonical write seam.
-                    const reviewInput = {
-                        kind: 'pattern',
-                        problem: capContent,
-                        validatedFix: '',
-                        whyItWorked: '',
-                        tags: capTags ?? [],
-                        confidence: capConf / 100,
-                        needsReview: 1,
-                    };
-                    const artifact = await daemonOr('artifact_add', effectiveProjId, reviewInput, () => memory.add(effectiveProjId, reviewInput));
-                    storedId = artifact.id;
-                    typeShort = 'mem';
-                    needsReview = true;
-                }
-                else {
-                    // v7 F2 (T012): canonical write seam — capture's truth branch.
-                    const capTruthInput = {
-                        category: 'decision',
-                        key: capContent.slice(0, 60),
-                        value: capContent,
-                    };
-                    const truth = await daemonOr('truth_set', effectiveProjId, capTruthInput, () => truths.set(effectiveProjId, capTruthInput));
-                    storedId = truth.id;
-                    typeShort = 'truth';
-                    cache.invalidate('wyrm_truth_get');
-                    cache.invalidate('wyrm_context_build');
-                }
-            }
-            else {
-                // memory
-                if (effectiveProjId === null) {
-                    return { content: [{ type: "text", text: `Cannot capture memory without project_id. Please provide project_id.` }], isError: true };
-                }
-                const shouldAutoCreate = capConf >= 75;
-                // v7 F2 (T012): canonical write seam — capture's memory branch.
-                const capMemInput = {
-                    kind: capSubtype,
-                    problem: capContent,
-                    validatedFix: '',
-                    whyItWorked: '',
-                    tags: capTags ?? [],
-                    confidence: capConf / 100,
-                    needsReview: shouldAutoCreate ? 0 : 1,
-                };
-                const artifact = await daemonOr('artifact_add', effectiveProjId, capMemInput, () => memory.add(effectiveProjId, capMemInput));
-                storedId = artifact.id;
-                typeShort = 'mem';
-                needsReview = !shouldAutoCreate;
-                // Advisory conflict check for heuristics (non-blocking)
-                if (capSubtype === 'heuristic' && capConf >= 75 && effectiveProjId !== null) {
-                    try {
-                        const sanitizedCap = capContent.replace(/['"*]/g, ' ').trim().split(/\s+/).slice(0, 5).join(' ');
-                        const heuristicConflicts = raw().prepare(`
+import{join as N}from"path";import{TOOL_ANNOTATIONS as E}from"../tool-annotations.js";import{renderResult as q,withGlyph as I}from"../render.js";import{ValidationError as U,asEnum as H}from"../validate.js";import{daemonOr as A}from"../daemon-writer.js";import{classifyCapture as B}from"../capture.js";import{extractCandidates as M,candidateToArtifact as L,escapeLikePattern as D}from"../auto-capture.js";import{parseTrace as K,segmentsToText as J}from"../trace-harvest.js";import{getActor as Y,runWithActor as Q}from"./boundary.js";import{harvestProjects as X}from"../harvest.js";import{readFileSync as W,readdirSync as G,statSync as R}from"fs";import{join as O}from"path";import{homedir as V}from"os";import{readSpecDir as z,specTaskSignature as Z}from"../spec-kit.js";const ye=[{name:"wyrm_capture",description:"Use to save anything worth keeping - the single write funnel. Auto-classifies notes, decisions, and lessons into quest, ground truth, or memory; risky writes queue for wyrm_review. mode=direct (store a proven pattern or lesson learned so future agents reuse it), extract (pull memories from a conversation transcript or freeform text), trace (harvest a session JSONL / tool-call log into run-tagged review candidates), session (close out a work session into reusable knowledge), artifacts (harvest a repo's READMEs and recent commits into durable facts), import source=git|pr|rules, spec (turn a tasks.md into tracked work items), checklist. Keywords: remember this, jot down, write down, future reference.",inputSchema:{type:"object",properties:{content:{type:"string",description:"classify/rules"},project_id:{type:"number",description:"classify/import/spec"},tags:{type:"array",items:{type:"string"}},mode:{type:"string",enum:["auto","quest","truth","memory","classify","direct","extract","trace","session","artifacts","import","spec","checklist"],description:"quest|truth|memory force the type"},source:{type:"string",enum:["git","pr","rules"],description:"import"},projectPath:{type:"string",description:"non-classify"},kind:{type:"string",description:"direct"},problem:{type:"string",description:"direct"},validatedFix:{type:"string",description:"direct"},text:{type:"string",description:"extract"},sessionId:{type:"string",description:"session"},candidates:{type:"array",items:{type:"object"},description:"session"},dryRun:{type:"boolean",description:"artifacts"},commits:{type:"array",items:{type:"object"},description:"import git"},title:{type:"string",description:"import pr"},body:{type:"string",description:"import pr"},specDir:{type:"string",description:"spec"},problemType:{type:"string",description:"checklist"},whenToUse:{type:"string",description:"checklist"},steps:{type:"array",items:{type:"string"},description:"checklist"}},required:[]},outputSchema:{type:"object",properties:{status:{type:"string",enum:["captured","queued_for_review"]},type:{type:"string"},subtype:{type:"string"},confidence:{type:"number"},reasoning:{type:"string"},id:{type:"integer"},ref:{type:"string"},needs_review:{type:"boolean"},reason:{type:"string"},artifact_id:{type:"integer"},conflicts_with:{type:"array"},advisory_conflicts:{type:"array"}},required:["status"]},annotations:E.wyrm_capture,aliases:[],handler:async(v,{store:w,raw:j,memory:m,truths:_,cache:g})=>{const{content:c,project_id:f,tags:i,mode:u}=v;let a=B(c);u&&u!=="auto"&&(a={type:u,subtype:{quest:"quest",truth:"decision",memory:"pattern"}[u]??u,confidence:100,reasoning:`Mode override: ${u}`});const{type:d,subtype:p,confidence:s,reasoning:b}=a,e=f??null;let t=0,l="",o=!1,h;if(d==="quest"){if(e===null)return{content:[{type:"text",text:"Cannot capture quest without project_id. Please provide project_id."}],isError:!0};t=(await A("quest_add",e,{title:c.slice(0,200),description:"",priority:"medium",tags:i?.join(",")},()=>w.addQuest(e,c.slice(0,200),"","medium",i?.join(",")))).id,l="quest",g.invalidate("wyrm_all_quests"),g.invalidate("wyrm_stats")}else if(d==="truth"){if(e===null)return{content:[{type:"text",text:"Cannot capture truth without project_id. Please provide project_id."}],isError:!0};if(s>=80){const n=p??"other",$=_.getCurrent(e).filter(k=>k.category===n);if($.length>0){const k={kind:"pattern",problem:`Potential conflict with ${$.length} existing truth(s) in category "${n}"`,validatedFix:c,whyItWorked:"Pending review \u2014 possible supersession",tags:i??[],confidence:s/100,needsReview:1},S=await A("artifact_add",e,k,()=>m.add(e,k));return q({status:"queued_for_review",reason:"conflict_check",artifact_id:S.id,conflicts_with:$.map(y=>({id:y.id,content:y.value.slice(0,80)}))})}}if(u!=="truth"&&s<100){const n={kind:"pattern",problem:c,validatedFix:"",whyItWorked:"",tags:i??[],confidence:s/100,needsReview:1};t=(await A("artifact_add",e,n,()=>m.add(e,n))).id,l="mem",o=!0}else{const n={category:"decision",key:c.slice(0,60),value:c};t=(await A("truth_set",e,n,()=>_.set(e,n))).id,l="truth",g.invalidate("wyrm_truth_get"),g.invalidate("wyrm_context_build")}}else{if(e===null)return{content:[{type:"text",text:"Cannot capture memory without project_id. Please provide project_id."}],isError:!0};const n=s>=75,x={kind:p,problem:c,validatedFix:"",whyItWorked:"",tags:i??[],confidence:s/100,needsReview:n?0:1};if(t=(await A("artifact_add",e,x,()=>m.add(e,x))).id,l="mem",o=!n,p==="heuristic"&&s>=75&&e!==null)try{const k=c.replace(/['"*]/g," ").trim().split(/\s+/).slice(0,5).join(" "),S=j().prepare(`
               SELECT a.id, a.problem FROM memory_artifacts a
               JOIN memory_artifacts_fts fts ON a.id = fts.rowid
               WHERE fts MATCH ? AND a.project_id = ? AND a.kind = 'heuristic' AND a.needs_review = 0
               LIMIT 3
-            `).all(sanitizedCap, effectiveProjId);
-                        if (heuristicConflicts.length > 0) {
-                            advisoryConflicts = heuristicConflicts.map(h => ({ id: h.id, content: h.problem.slice(0, 80) }));
-                        }
-                    }
-                    catch {
-                        // FTS may fail on short queries — advisory only, ignore
-                    }
-                }
-            }
-            const body = {
-                status: 'captured',
-                type: capType,
-                subtype: capSubtype,
-                confidence: capConf,
-                reasoning: capReasoning,
-                id: storedId,
-                ref: `${typeShort}:${storedId}`,
-                needs_review: needsReview,
-                ...(advisoryConflicts && advisoryConflicts.length > 0 ? { advisory_conflicts: advisoryConflicts } : {}),
-            };
-            return renderResult(body, (b, g) => {
-                let text = `Captured as ${b.type}: ${b.subtype}\nConfidence: ${b.confidence}% | ${b.reasoning}\nID: ${b.ref}`;
-                if (b.needs_review)
-                    text += '\n' + withGlyph(g.warn, 'Stored for review -- run `wyrm_review` to activate');
-                const adv = b.advisory_conflicts;
-                if (adv && adv.length > 0) {
-                    text += '\n\n' + withGlyph(g.warn, `Advisory: ${adv.length} similar heuristic(s) found:`) + '\n' +
-                        adv.map(c => `  ${g.bullet} [${c.id}] ${c.content}`).join('\n');
-                }
-                return text;
-            });
-        },
-    },
-    {
-        name: "wyrm_remember",
-        description: "Store a distilled knowledge artifact — proven patterns, lessons learned, anti-patterns, and reasoning traces. These are recalled automatically by wyrm_context_build to help AI models apply past knowledge to new tasks. Example: wyrm_remember({ projectPath: '/home/user/api', kind: 'anti_pattern', problem: 'Jest suite hung after adding the SSE server', validatedFix: 'close() the server in afterAll — its keep-alive timer held the event loop open', whyItWorked: 'open handles block jest exit', outcome: 'positive', tags: ['jest', 'sse'] })",
-        inputSchema: {
-            type: "object",
-            properties: {
-                projectPath: { type: "string", description: "Project this knowledge belongs to" },
-                kind: {
-                    type: "string",
-                    enum: ["reasoning_trace", "lesson", "pattern", "anti_pattern", "heuristic"],
-                    description: "reasoning_trace: a solved problem with steps; lesson: a general insight; pattern: a proven approach; anti_pattern: what NOT to do; heuristic: a rule of thumb",
-                },
-                problem: { type: "string", description: "What was being solved or observed (be specific and searchable)" },
-                constraints: { type: "string", description: "What conditions or constraints applied" },
-                validatedFix: { type: "string", description: "What actually worked — the validated solution or approach" },
-                whyItWorked: { type: "string", description: "The insight behind WHY this worked (key for transfer learning)" },
-                outcome: { type: "string", enum: ["positive", "negative", "neutral"], description: "Was this approach successful?" },
-                tags: { type: "array", items: { type: "string" }, description: "Searchable tags (e.g. ['auth', 'rate-limit', 'typescript'])" },
-                confidence: { type: "number", description: "Confidence level 0.0–1.0 (default: 1.0)" },
-                sourceSessionId: { type: "number", description: "Session ID where this was discovered (optional)" },
-            },
-            required: ["projectPath", "kind", "problem"],
-        },
-        outputSchema: {
-            type: "object",
-            properties: {
-                id: { type: "integer" },
-                kind: { type: "string", enum: ["reasoning_trace", "lesson", "pattern", "anti_pattern", "heuristic"] },
-                problem: { type: "string" },
-                validated_fix: { type: ["string", "null"] },
-                why_it_worked: { type: ["string", "null"] },
-                confidence: { type: "number" },
-                tags: { type: ["string", "null"] },
-            },
-            required: ["id", "kind", "problem", "validated_fix", "why_it_worked", "confidence", "tags"],
-        },
-        annotations: TOOL_ANNOTATIONS.wyrm_remember,
-        aliases: [],
-        handler: async (args, { store, memory }) => {
-            const { projectPath: rPath, kind: rKind, problem: rProblem, constraints: rConst, validatedFix: rFix, whyItWorked: rWhy, outcome: rOutcome, tags: rTags, confidence: rConf, sourceSessionId: rSessId } = args;
-            // Closed enum, mirrors the memory_artifacts.kind schema CHECK:
-            // boundary-enforced (the MCP SDK treats inputSchema as advisory) so a
-            // typo'd kind is a clean structured client error, never a daemon-side
-            // SQLITE_CONSTRAINT round trip.
-            const rSafeKind = asEnum('kind', rKind, ['reasoning_trace', 'lesson', 'pattern', 'anti_pattern', 'heuristic']);
-            if (rSafeKind === undefined)
-                throw new ValidationError('kind', 'is required');
-            const rProject = store.getProject(rPath);
-            if (!rProject)
-                return { content: [{ type: "text", text: `Project not found: ${rPath}` }], isError: true };
-            // v7 F2 (T012): canonical write seam (capture family). Project
-            // resolution above is a READ and stays local; only the write hops.
-            const rInput = {
-                kind: rSafeKind,
-                problem: rProblem,
-                constraints: rConst,
-                validatedFix: rFix,
-                whyItWorked: rWhy,
-                outcome: rOutcome,
-                tags: rTags,
-                confidence: rConf,
-                sourceSessionId: rSessId,
-            };
-            const artifact = await daemonOr('artifact_add', rProject.id, rInput, () => memory.add(rProject.id, rInput));
-            const body = {
-                id: artifact.id,
-                kind: artifact.kind,
-                problem: artifact.problem,
-                validated_fix: artifact.validated_fix ?? null,
-                why_it_worked: artifact.why_it_worked ?? null,
-                confidence: artifact.confidence,
-                tags: artifact.tags ?? null,
-            };
-            return renderResult(body, (b, g) => {
-                let text = withGlyph(g.brand, '**Memory Stored**') + '\n\n';
-                text += `${g.bullet} **Kind:** ${b.kind}\n`;
-                text += `${g.bullet} **ID:** ${b.id}\n`;
-                text += `${g.bullet} **Problem:** ${b.problem}\n`;
-                if (b.validated_fix)
-                    text += `${g.bullet} **Solution:** ${b.validated_fix}\n`;
-                if (b.why_it_worked)
-                    text += `${g.bullet} **Why it worked:** ${b.why_it_worked}\n`;
-                text += `${g.bullet} **Confidence:** ${(b.confidence * 100).toFixed(0)}%\n`;
-                if (b.tags)
-                    text += `${g.bullet} **Tags:** ${b.tags}\n`;
-                text += `\n_Use \`wyrm_recall\` to retrieve similar memories, or \`wyrm_context_build\` to assemble a task brief._`;
-                return text;
-            });
-        },
-    },
-    {
-        name: "wyrm_auto_capture",
-        description: "Auto-extract durable memories from freeform text (a session transcript, notes, a chat) into the REVIEW QUEUE. A LOCAL extractor — a configurable Ollama model (WYRM_EXTRACT_MODEL / the `model` arg) if set, else a deterministic heuristic — pulls out truths, failures, decisions, patterns, and lessons as needs_review candidates; approve/reject with wyrm_review (nothing auto-trusted). Closes the 'just talk, it remembers' gap without a cloud LLM. Deduped + idempotent. Example: wyrm_auto_capture({ projectPath: '/home/user/api', text: 'Deploy failed twice because wrangler.toml pointed at the old KV id; switched to the new binding and decided to pin binding names in CI.' })",
-        inputSchema: {
-            type: "object",
-            properties: {
-                projectPath: { type: "string", description: "Project to file the extracted candidates under" },
-                text: { type: "string", description: "Freeform text to extract durable memories from" },
-                model: { type: "string", description: "Optional Ollama model for extraction (overrides WYRM_EXTRACT_MODEL); omit for deterministic extraction" },
-            },
-            required: ["projectPath", "text"],
-        },
-        outputSchema: {
-            type: "object",
-            properties: {
-                method: { type: "string" },
-                model: { type: ["string", "null"] },
-                added: { type: "integer" },
-                skipped: { type: "integer" },
-                candidates: {
-                    type: "array",
-                    items: {
-                        type: "object",
-                        properties: { kind: { type: "string" }, text: { type: "string" } },
-                        required: ["kind", "text"],
-                    },
-                },
-            },
-            required: ["method", "model", "added", "skipped", "candidates"],
-        },
-        annotations: TOOL_ANNOTATIONS.wyrm_auto_capture,
-        aliases: [],
-        handler: async (args, { store, raw, memory, cache }) => {
-            const { projectPath: acPath, text: acText, model: acModel } = args;
-            const acProject = store.getProject(acPath);
-            if (!acProject)
-                return { content: [{ type: "text", text: `Project not found: ${acPath}` }], isError: true };
-            if (!acText || acText.trim().length < 20)
-                return { content: [{ type: "text", text: "Provide at least ~20 chars of text to extract from." }], isError: true };
-            const { candidates, method, model: usedModel } = await extractCandidates(acText, { model: acModel });
-            const rawDb = raw();
-            let added = 0, skipped = 0;
-            for (const c of candidates) {
-                const a = candidateToArtifact(c);
-                const sig = a.tags[a.tags.length - 1]; // the 'ax:' dedup signature
-                // Security pass #1: sig is text-derived — %/_ must be LITERAL in the
-                // dedup probe (escapeLikePattern + ESCAPE), or wildcard-bearing input
-                // broad-matches other ax: tags and silently suppresses capture.
-                if (rawDb.prepare("SELECT 1 FROM memory_artifacts WHERE project_id = ? AND tags LIKE ? ESCAPE '\\' LIMIT 1").get(acProject.id, '%' + escapeLikePattern(sig) + '%')) {
-                    skipped++;
-                    continue;
-                }
-                memory.add(acProject.id, { kind: a.kind, problem: a.problem, tags: a.tags, confidence: a.confidence, needsReview: 1, createdBy: 'auto-extract' });
-                added++;
-            }
-            if (added > 0)
-                cache.invalidate();
-            const body = {
-                method,
-                model: usedModel ?? null,
-                added,
-                skipped,
-                candidates: candidates.slice(0, 8).map((c) => ({ kind: c.kind, text: c.text.slice(0, 80) })),
-            };
-            return renderResult(body, (b, g) => {
-                const lines = b.candidates.map((c) => `   ${g.bullet} [${c.kind}] ${c.text}`).join('\n');
-                return withGlyph(g.brand, `Auto-capture (${b.method}${b.model ? ` - ${b.model}` : ''}) -- ${b.added} candidate(s) -> review queue, ${b.skipped} already present.`) +
-                    `\n${lines}\n\nApprove/reject with wyrm_review.`;
-            });
-        },
-    },
-    {
-        name: "wyrm_capture_trace",
-        description: "Harvest a harness's working trace into run-tagged review-queue candidates — OFFLINE. Ingests a Claude Code session transcript (JSONL), a ~/.dragon/traces file/dir, or WYRM_TRACE_TOOL_CALLS event output. The SAME local extractor as auto-capture (Ollama WYRM_EXTRACT_MODEL if set, else deterministic — never a cloud LLM) pulls durable truths/failures/decisions/patterns/lessons; secrets (API keys, tokens, passwords) are REDACTED before anything is stored; candidates land needs_review=1 stamped with the run_id (arg or ambient envelope). Approve/reject with wyrm_review; deduped + idempotent. Pass `trace` (inline text) OR `path` (a trace file or the ~/.dragon/traces dir). Reached via wyrm_capture({ mode: 'trace' }).",
-        inputSchema: {
-            type: "object",
-            properties: {
-                projectPath: { type: "string", description: "Project to file the candidates under" },
-                trace: { type: "string", description: "Inline trace text (JSONL transcript / dragon records / tool-call events)" },
-                path: { type: "string", description: "Path to a trace file, or the ~/.dragon/traces directory (newest file is read); omit ~ for absolute" },
-                format: { type: "string", enum: ["auto", "claude-jsonl", "dragon", "tool-calls"], description: "Trace format (default auto-detect)" },
-                run_id: { type: "string", description: "Tag candidates with this run (default: ambient envelope run_id)" },
-                model: { type: "string", description: "Optional Ollama model for extraction (overrides WYRM_EXTRACT_MODEL); omit for deterministic" },
-            },
-            required: ["projectPath"],
-        },
-        outputSchema: {
-            type: "object",
-            properties: {
-                method: { type: "string" },
-                model: { type: ["string", "null"] },
-                format: { type: "string" },
-                source: { type: "string" },
-                run_id: { type: ["string", "null"] },
-                segments: { type: "integer" },
-                added: { type: "integer" },
-                skipped: { type: "integer" },
-                candidates: {
-                    type: "array",
-                    items: {
-                        type: "object",
-                        properties: { kind: { type: "string" }, text: { type: "string" } },
-                        required: ["kind", "text"],
-                    },
-                },
-            },
-            required: ["method", "model", "format", "source", "run_id", "segments", "added", "skipped", "candidates"],
-        },
-        annotations: TOOL_ANNOTATIONS.wyrm_capture_trace,
-        aliases: [],
-        handler: async (args, { store, raw, memory, cache }) => {
-            const { projectPath: trPath, trace: trInline, path: trFilePath, format: trFormat, run_id: trRunArg, model: trModel } = args;
-            const trProject = store.getProject(trPath);
-            if (!trProject)
-                return { content: [{ type: "text", text: `Project not found: ${trPath}` }], isError: true };
-            // Run attribution (F2): explicit arg wins, else the ambient envelope.
-            const ambient = getActor();
-            const runId = (typeof trRunArg === 'string' && trRunArg.trim()) ? trRunArg.trim().slice(0, 64) : ambient.run_id;
-            // Resolve the trace BYTES: inline `trace` wins; else read `path`. A
-            // directory (the ~/.dragon/traces case) reads its NEWEST regular file.
-            // Article VII: path is operator-supplied; we only READ, never write/escape.
-            let rawTrace = '';
-            let source = 'inline';
-            if (typeof trInline === 'string' && trInline.trim()) {
-                rawTrace = trInline;
-                source = 'inline';
-            }
-            else if (typeof trFilePath === 'string' && trFilePath.trim()) {
-                // Expand a leading ~ to the home dir (the documented ~/.dragon/traces shape).
-                let resolved = trFilePath.trim();
-                if (resolved === '~' || resolved.startsWith('~/'))
-                    resolved = pathJoin2(homedir(), resolved.slice(1));
-                try {
-                    const st = statSync(resolved);
-                    if (st.isDirectory()) {
-                        const files = readdirSync(resolved)
-                            .map((f) => pathJoin2(resolved, f))
-                            .filter((p) => { try {
-                            return statSync(p).isFile();
-                        }
-                        catch {
-                            return false;
-                        } })
-                            .sort((a, b) => statSync(b).mtimeMs - statSync(a).mtimeMs);
-                        if (files.length === 0)
-                            return { content: [{ type: "text", text: `No trace files in directory: ${resolved}` }], isError: true };
-                        rawTrace = readFileSync(files[0], 'utf-8');
-                        source = files[0];
-                    }
-                    else {
-                        rawTrace = readFileSync(resolved, 'utf-8');
-                        source = resolved;
-                    }
-                }
-                catch (e) {
-                    return { content: [{ type: "text", text: `Could not read trace path "${resolved}": ${e.message}` }], isError: true };
-                }
-            }
-            else {
-                return { content: [{ type: "text", text: "Provide a `trace` (inline text) or a `path` (trace file or ~/.dragon/traces dir)." }], isError: true };
-            }
-            const { segments, format: usedFormat } = parseTrace(rawTrace, trFormat ?? 'auto');
-            const text = segmentsToText(segments);
-            if (text.trim().length < 20) {
-                const emptyBody = {
-                    method: 'deterministic', model: null, format: usedFormat, source,
-                    run_id: runId, segments: segments.length, added: 0, skipped: 0, candidates: [],
-                };
-                return renderResult(emptyBody, (b, g) => withGlyph(g.brand, `Trace harvest (${b.format}) -- no durable content extracted from ${b.segments} segment(s).`));
-            }
-            const { candidates, method, model: usedModel } = await extractCandidates(text, { model: trModel });
-            const rawDb = raw();
-            let added = 0, skipped = 0;
-            for (const c of candidates) {
-                const a = candidateToArtifact(c);
-                const sig = a.tags[a.tags.length - 1]; // the 'ax:' dedup signature
-                // Security pass #1: sig is trace-text-derived — %/_ must be LITERAL in
-                // the dedup probe (escapeLikePattern + ESCAPE), or a wildcard-bearing
-                // segment broad-matches other ax: tags and silently suppresses capture.
-                if (rawDb.prepare("SELECT 1 FROM memory_artifacts WHERE project_id = ? AND tags LIKE ? ESCAPE '\\' LIMIT 1").get(trProject.id, '%' + escapeLikePattern(sig) + '%')) {
-                    skipped++;
-                    continue;
-                }
-                // RUN-SCOPED candidate (T040): stamp the ambient/explicit run on the
-                // row (memory.add reads the envelope) and tag run:<id> + 'trace' so the
-                // review queue slices per run, mirroring the wyrm_run debrief shape.
-                const tags = runId ? [...a.tags, 'trace', `run:${runId}`] : [...a.tags, 'trace'];
-                runWithActor({ agent_id: ambient.agent_id, run_id: runId, source: runId ? 'param' : ambient.source }, () => memory.add(trProject.id, { kind: a.kind, problem: a.problem, tags, confidence: a.confidence, needsReview: 1, createdBy: 'trace-harvest' }));
-                added++;
-            }
-            if (added > 0)
-                cache.invalidate();
-            const body = {
-                method,
-                model: usedModel ?? null,
-                format: usedFormat,
-                source,
-                run_id: runId,
-                segments: segments.length,
-                added,
-                skipped,
-                candidates: candidates.slice(0, 8).map((c) => ({ kind: c.kind, text: c.text.slice(0, 80) })),
-            };
-            return renderResult(body, (b, g) => {
-                const lines = b.candidates.map((c) => `   ${g.bullet} [${c.kind}] ${c.text}`).join('\n');
-                return withGlyph(g.brand, `Trace harvest (${b.format}, ${b.method}${b.model ? ` - ${b.model}` : ''}) -- ${b.segments} segment(s) -> ${b.added} candidate(s) to review queue, ${b.skipped} already present${b.run_id ? ` [run:${b.run_id}]` : ''}.`) +
-                    (lines ? `\n${lines}` : '') + `\n\nApprove/reject with wyrm_review.`;
-            });
-        },
-    },
-    {
-        name: "wyrm_distill",
-        description: "Distill a work session into candidate memory artifacts for review. Parses the session's objectives, decisions, and outcomes into structured artifacts (lessons, patterns, anti-patterns) and queues them for approval via wyrm_review. Use at session end to extract institutional knowledge.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                projectPath: { type: "string", description: "Project root path" },
-                sessionId: { type: "string", description: "Session ID to distill" },
-                candidates: {
-                    type: "array",
-                    description: "Pre-parsed candidate artifacts to store for review",
-                    items: {
-                        type: "object",
-                        properties: {
-                            kind: { type: "string", enum: ["lesson", "pattern", "anti_pattern", "heuristic", "reasoning_trace"] },
-                            title: { type: "string" },
-                            content: { type: "string" },
-                            tags: { type: "array", items: { type: "string" } },
-                            confidence: { type: "number" },
-                        },
-                        required: ["kind", "title", "content"],
-                    },
-                },
-            },
-            required: ["projectPath", "candidates"],
-        },
-        outputSchema: {
-            type: "object",
-            properties: {
-                count: { type: "integer" },
-                artifacts: {
-                    type: "array",
-                    items: {
-                        type: "object",
-                        properties: {
-                            id: { type: "integer" },
-                            kind: { type: "string" },
-                            title: { type: "string" },
-                        },
-                        required: ["id", "kind", "title"],
-                    },
-                },
-            },
-            required: ["count", "artifacts"],
-        },
-        annotations: TOOL_ANNOTATIONS.wyrm_distill,
-        aliases: [],
-        handler: (args, { store, memory }) => {
-            const { projectPath: dPath, candidates } = args;
-            const dProject = store.getProject(dPath);
-            if (!dProject)
-                return { content: [{ type: "text", text: `Project not found: ${dPath}` }], isError: true };
-            if (!candidates || candidates.length === 0) {
-                return { content: [{ type: "text", text: `**Distill**\n\nNo candidates provided. Provide an array of candidate artifacts to distill.` }], isError: true };
-            }
-            const artifacts = [];
-            for (const c of candidates) {
-                const artifact = memory.add(dProject.id, {
-                    kind: c.kind,
-                    problem: c.title,
-                    validatedFix: c.content,
-                    tags: c.tags ?? [],
-                    confidence: c.confidence ?? 0.7,
-                    needsReview: 1,
-                });
-                artifacts.push({ id: artifact.id, kind: c.kind, title: c.title });
-            }
-            const body = { count: artifacts.length, artifacts };
-            return renderResult(body, (b, g) => {
-                let text = withGlyph(g.brand, `**Distillation Complete** -- ${b.count} artifact${b.count !== 1 ? 's' : ''} queued for review`) + '\n\n';
-                text += b.artifacts.map((a) => `${g.bullet} [#${a.id}] **${a.kind}**: ${a.title}`).join('\n');
-                text += `\n\nUse \`wyrm_review\` with each ID to approve or reject.`;
-                return text;
-            });
-        },
-    },
-    {
-        name: "wyrm_harvest",
-        description: "Auto-populate memory from artifacts you already produce. Walks a project (or ALL registered projects) and harvests durable facts from its docs (README/CLAUDE/AGENTS/ARCHITECTURE) plus recent commit subjects (git log) into the REVIEW QUEUE — approve/reject with wyrm_review, nothing is auto-trusted. Idempotent (re-runs skip what's already harvested). Use dryRun to preview. The fix for a thin corpus.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                projectPath: { type: "string", description: "Harvest one project; omit to harvest ALL registered projects" },
-                dryRun: { type: "boolean", description: "Preview what would be harvested without writing anything" },
-                gitLimit: { type: "number", description: "How many recent commits to scan per project (default 30, max 200)" },
-                includeCode: { type: "boolean", description: "Also harvest CODE: tech-stack facts from manifests (package.json/Cargo.toml/…) + TODO/FIXME markers into the review queue, AND index code symbols (functions/classes/types) for search. Heavier — scope to one project for the full code pass." },
-            },
-        },
-        outputSchema: {
-            type: "object",
-            properties: {
-                dry_run: { type: "boolean" },
-                projects_scanned: { type: "integer" },
-                added: { type: "integer" },
-                skipped: { type: "integer" },
-                top: {
-                    type: "array",
-                    items: {
-                        type: "object",
-                        properties: {
-                            project: { type: "string" },
-                            added: { type: "integer" },
-                            skipped: { type: "integer" },
-                        },
-                        required: ["project", "added", "skipped"],
-                    },
-                },
-                sample: { type: "array", items: { type: "string" } },
-                code_symbols: {
-                    type: ["object", "null"],
-                    properties: {
-                        symbols: { type: "integer" },
-                        projects: { type: "integer" },
-                        files: { type: "integer" },
-                    },
-                    required: ["symbols", "projects", "files"],
-                },
-            },
-            required: ["dry_run", "projects_scanned", "added", "skipped", "top", "sample", "code_symbols"],
-        },
-        annotations: TOOL_ANNOTATIONS.wyrm_harvest,
-        aliases: [],
-        handler: (args, { store, raw, memory, symbols, cache }) => {
-            const { projectPath, dryRun, gitLimit, includeCode } = args;
-            const rawDb = raw();
-            const deps = {
-                // Security pass #1: harvest sigs are doc/git-text-derived — same
-                // LIKE-escape rule as the ax: probe above.
-                existsBySig: (pid, sig) => !!rawDb.prepare("SELECT 1 FROM memory_artifacts WHERE project_id = ? AND tags LIKE ? ESCAPE '\\' LIMIT 1").get(pid, '%' + escapeLikePattern(sig) + '%'),
-                addCandidate: (pid, item) => {
-                    memory.add(pid, { kind: item.kind, problem: item.text, tags: [...item.tags, item.sig], confidence: item.confidence, needsReview: 1, createdBy: 'harvest' });
-                },
-            };
-            let projects;
-            if (projectPath) {
-                const p = store.getProject(projectPath);
-                if (!p)
-                    return { content: [{ type: "text", text: "Project not found" }], isError: true };
-                projects = [{ id: p.id, name: p.name, path: p.path }];
-            }
-            else {
-                projects = store.getAllProjects(500).map((p) => ({ id: p.id, name: p.name, path: p.path }));
-            }
-            const { reports, totalAdded, totalSkipped } = harvestProjects(deps, projects, { dryRun, gitLimit, includeCode });
-            if (!dryRun && totalAdded > 0)
-                cache.invalidate();
-            // Code STRUCTURE → symbol index (searchable functions/classes/types), not the review queue.
-            let codeSymbols = null;
-            if (includeCode && !dryRun) {
-                let files = 0, syms = 0, indexed = 0;
-                for (const p of projects) {
-                    try {
-                        const r = symbols.indexProject(p.id, p.path);
-                        files += r.files;
-                        syms += r.symbols;
-                        indexed++;
-                    }
-                    catch { /* skip unreadable */ }
-                }
-                codeSymbols = { symbols: syms, projects: indexed, files };
-            }
-            const top = reports.filter((r) => r.added > 0).sort((a, b) => b.added - a.added).slice(0, 15)
-                .map((r) => ({ project: r.project, added: r.added, skipped: r.skipped }));
-            const sample = reports.flatMap((r) => r.sample ?? []).slice(0, 6);
-            const body = {
-                dry_run: !!dryRun,
-                projects_scanned: projects.length,
-                added: totalAdded,
-                skipped: totalSkipped,
-                top,
-                sample,
-                code_symbols: codeSymbols,
-            };
-            return renderResult(body, (b, g) => {
-                const symbolNote = b.code_symbols
-                    ? `\nIndexed ${b.code_symbols.symbols} code symbols across ${b.code_symbols.projects} project(s) (${b.code_symbols.files} files) -> searchable via wyrm_symbol_search.`
-                    : '';
-                const topLines = b.top.map((r) => `  +${String(r.added).padStart(3)} (skip ${r.skipped})  ${r.project}`).join('\n');
-                const sampleLines = b.sample.map((s) => `   ${g.bullet} ${s}`).join('\n');
-                return withGlyph(g.brand, `Harvest ${b.dry_run ? '(dry run) ' : ''}-- ${b.added} candidate(s) -> review queue across ${b.projects_scanned} project(s); ${b.skipped} already present.`) +
-                    `${symbolNote}\n${topLines}` +
-                    (sampleLines ? `\n\nSample:\n${sampleLines}` : '') +
-                    `\n\nApprove/reject with wyrm_review.`;
-            });
-        },
-    },
-    {
-        name: "wyrm_import_git",
-        description: "Import a list of commits into the Wyrm memory review queue. Useful for onboarding a project's history or capturing recent work.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                project_id: { type: "number", description: "Project ID" },
-                commits: {
-                    type: "array",
-                    description: "Array of commit objects",
-                    items: {
-                        type: "object",
-                        properties: {
-                            message: { type: "string" },
-                            diff_summary: { type: "string" },
-                            author: { type: "string" },
-                            date: { type: "string" },
-                        },
-                        required: ["message"],
-                    },
-                },
-                auto_approve: { type: "boolean", description: "Skip review queue and activate immediately (default: false)" },
-            },
-            required: ["project_id", "commits"],
-        },
-        outputSchema: {
-            type: "object",
-            properties: {
-                captured: { type: "integer" },
-                skipped: { type: "integer" },
-                auto_approved: { type: "boolean" },
-            },
-            required: ["captured", "skipped", "auto_approved"],
-        },
-        annotations: TOOL_ANNOTATIONS.wyrm_import_git,
-        aliases: [],
-        handler: (args, { store, memory }) => {
-            const { project_id: gitProjId, commits: gitCommits, auto_approve: gitAutoApprove } = args;
-            const gitProject = store.getProjectById(gitProjId);
-            if (!gitProject)
-                return { content: [{ type: "text", text: `Project ID ${gitProjId} not found.` }], isError: true };
-            let captured = 0, skippedCount = 0;
-            for (const commit of gitCommits) {
-                const msg = commit.message ?? '';
-                if (/^Merge /i.test(msg)) {
-                    skippedCount++;
-                    continue;
-                }
-                if (/^(chore|bump|release|version)/i.test(msg)) {
-                    skippedCount++;
-                    continue;
-                }
-                let artifactKind = 'pattern';
-                if (/^fix(\(.+\))?:/i.test(msg))
-                    artifactKind = 'lesson';
-                else if (/^feat(\(.+\))?:/i.test(msg))
-                    artifactKind = 'pattern';
-                else if (/^refactor(\(.+\))?:/i.test(msg))
-                    artifactKind = 'heuristic';
-                const typePrefix = msg.split(':')[0] ?? 'commit';
-                memory.add(gitProjId, {
-                    kind: artifactKind,
-                    problem: msg,
-                    validatedFix: commit.diff_summary ?? '',
-                    whyItWorked: `Committed by ${commit.author ?? 'unknown'} on ${commit.date ?? 'unknown'}`,
-                    tags: ['git', 'commit', typePrefix.toLowerCase()],
-                    confidence: 0.6,
-                    needsReview: gitAutoApprove ? 0 : 1,
-                });
-                captured++;
-            }
-            const body = { captured, skipped: skippedCount, auto_approved: !!gitAutoApprove };
-            return renderResult(body, (b, g) => withGlyph(g.brand, '**Git Import Complete**') + '\n\n' +
-                `${g.bullet} **Captured:** ${b.captured}\n` +
-                `${g.bullet} **Skipped:** ${b.skipped} (merges/chores)\n` +
-                `${g.bullet} **Review needed:** ${b.auto_approved ? 'No (auto-approved)' : `Yes -- run \`wyrm_review\` to activate ${b.captured} artifact${b.captured !== 1 ? 's' : ''}`}`);
-        },
-    },
-    {
-        name: "wyrm_import_pr",
-        description: "Import a pull request (title, body, review comments) into the Wyrm memory review queue to extract patterns and heuristics.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                project_id: { type: "number", description: "Project ID" },
-                title: { type: "string", description: "PR title" },
-                body: { type: "string", description: "PR description / body" },
-                review_comments: { type: "array", items: { type: "string" }, description: "Review comment strings" },
-                auto_approve: { type: "boolean", description: "Skip review queue (default: false)" },
-            },
-            required: ["project_id", "title", "body"],
-        },
-        outputSchema: {
-            type: "object",
-            properties: {
-                created: { type: "integer" },
-                auto_approved: { type: "boolean" },
-            },
-            required: ["created", "auto_approved"],
-        },
-        annotations: TOOL_ANNOTATIONS.wyrm_import_pr,
-        aliases: [],
-        handler: (args, { store, memory }) => {
-            const { project_id: prProjId, title: prTitle, body: prBody, review_comments: prComments, auto_approve: prAutoApprove } = args;
-            const prProject = store.getProjectById(prProjId);
-            if (!prProject)
-                return { content: [{ type: "text", text: `Project ID ${prProjId} not found.` }], isError: true };
-            let prCreated = 0;
-            const prNeedsReview = prAutoApprove ? 0 : 1;
-            memory.add(prProjId, {
-                kind: 'pattern',
-                problem: `${prTitle}\n\n${prBody}`,
-                validatedFix: '',
-                whyItWorked: '',
-                tags: ['git', 'pr'],
-                confidence: 0.65,
-                needsReview: prNeedsReview,
-            });
-            prCreated++;
-            for (const comment of (prComments ?? [])) {
-                if (/\b(should|must|always|never|prefer|avoid|use|don't)\b/i.test(comment)) {
-                    memory.add(prProjId, {
-                        kind: 'heuristic',
-                        problem: comment,
-                        validatedFix: '',
-                        whyItWorked: '',
-                        tags: ['git', 'pr', 'review'],
-                        confidence: 0.65,
-                        needsReview: prNeedsReview,
-                    });
-                    prCreated++;
-                }
-            }
-            const body = { created: prCreated, auto_approved: !!prAutoApprove };
-            return renderResult(body, (b, g) => withGlyph(g.brand, '**PR Import Complete**') + '\n\n' +
-                `${g.bullet} **Artifacts created:** ${b.created}\n` +
-                `${g.bullet} **Review needed:** ${b.auto_approved ? 'No (auto-approved)' : 'Yes -- run `wyrm_review` to activate'}`);
-        },
-    },
-    {
-        name: "wyrm_import_rules",
-        description: "Import a .cursorrules / copilot-instructions file into Wyrm. Parses by section and creates ground truths (for constraint/rule language) or memory artifacts (for general guidelines).",
-        inputSchema: {
-            type: "object",
-            properties: {
-                project_id: { type: "number", description: "Project ID" },
-                content: { type: "string", description: "Full text of the rules file" },
-                format: { type: "string", enum: ["cursorrules", "copilot", "plain"], description: "Source format (default: plain)" },
-                source_file: { type: "string", description: "Filename for provenance (optional)" },
-            },
-            required: ["project_id", "content"],
-        },
-        outputSchema: {
-            type: "object",
-            properties: {
-                format: { type: "string" },
-                source: { type: "string" },
-                truths_created: { type: "integer" },
-                artifacts_created: { type: "integer" },
-            },
-            required: ["format", "source", "truths_created", "artifacts_created"],
-        },
-        annotations: TOOL_ANNOTATIONS.wyrm_import_rules,
-        aliases: [],
-        handler: (args, { store, memory, truths }) => {
-            const { project_id: ruleProjId, content: ruleContent, format: ruleFormat, source_file: ruleSrc } = args;
-            const rulesProject = store.getProjectById(ruleProjId);
-            if (!rulesProject)
-                return { content: [{ type: "text", text: `Project ID ${ruleProjId} not found.` }], isError: true };
-            const fmt = ruleFormat ?? 'plain';
-            const src = ruleSrc ?? 'rules';
-            const baseTags = ['imported', fmt, src];
-            // Section-based parsing: prefer markdown headings, fall back to paragraph breaks
-            const byHeadings = ruleContent.split(/\n(?=#)/);
-            const byParagraphs = ruleContent.split(/\n\n+/);
-            const chunks = (byHeadings.length >= byParagraphs.length ? byHeadings : byParagraphs)
-                .map((c) => c.trim())
-                .filter((c) => c.length >= 15);
-            let ruleTruthsCreated = 0, ruleArtifactsCreated = 0;
-            for (const chunk of chunks) {
-                if (/\b(always|never|must|use|don't|avoid|prefer)\b/i.test(chunk)) {
-                    truths.set(ruleProjId, {
-                        category: 'constraint',
-                        key: chunk.slice(0, 50).replace(/\n/g, ' '),
-                        value: chunk,
-                        source: src,
-                    });
-                    ruleTruthsCreated++;
-                }
-                else {
-                    memory.add(ruleProjId, {
-                        kind: 'heuristic',
-                        problem: chunk,
-                        validatedFix: '',
-                        whyItWorked: '',
-                        tags: baseTags,
-                        confidence: 0.7,
-                        needsReview: 1,
-                    });
-                    ruleArtifactsCreated++;
-                }
-            }
-            const body = { format: fmt, source: src, truths_created: ruleTruthsCreated, artifacts_created: ruleArtifactsCreated };
-            return renderResult(body, (b, g) => withGlyph(g.brand, `**Rules Import Complete** (${b.format})`) + '\n\n' +
-                `${g.bullet} **Ground truths created:** ${b.truths_created} (active immediately)\n` +
-                `${g.bullet} **Memory artifacts created:** ${b.artifacts_created} (pending review)\n` +
-                `${g.bullet} **Source:** ${b.source}\n\nRun \`wyrm_review\` to approve the memory artifacts.`);
-        },
-    },
-    {
-        name: "wyrm_spec_register",
-        description: "Make spec-kit Wyrm-native. Reads a spec directory (spec.md title/summary + tasks.md task list) and creates one Wyrm quest per task, linked to a project, with a stored spec→project link. Idempotent — re-running updates the same quests (deduped by a per-spec-task signature) instead of duplicating.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                specDir: { type: "string", description: "Absolute path to the spec directory (e.g. '.../dragon-platform/specs/001-ghostmesh')" },
-                projectPath: { type: "string", description: "Path of the Wyrm project to attach the spec + quests to (must already be registered)" },
-                priority: { type: "string", enum: ["critical", "high", "medium", "low"], description: "Priority for the generated quests (default 'medium')" },
-            },
-            required: ["specDir", "projectPath"],
-        },
-        outputSchema: {
-            type: "object",
-            properties: {
-                spec_dir: { type: "string" },
-                title: { type: ["string", "null"] },
-                project: { type: "string" },
-                tasks_parsed: { type: "integer" },
-                quests_created: { type: "integer" },
-                quests_updated: { type: "integer" },
-                quest_ids: { type: "array", items: { type: "integer" } },
-            },
-            required: ["spec_dir", "title", "project", "tasks_parsed", "quests_created", "quests_updated", "quest_ids"],
-        },
-        annotations: TOOL_ANNOTATIONS.wyrm_spec_register,
-        aliases: [],
-        handler: (args, { store, indexing }) => {
-            const { specDir, projectPath, priority } = args;
-            // 6.x dispatcher-level requireArgs(['specDir','projectPath']) moved
-            // inline with the handler (same blank-rejection semantics).
-            const missing = ['specDir', 'projectPath'].filter((f) => {
-                const v = args[f];
-                return !v && v !== 0 && v !== false;
-            });
-            if (missing.length > 0) {
-                return { content: [{ type: "text", text: `Missing required arguments: ${missing.join(', ')}` }], isError: true };
-            }
-            const project = store.getProject(projectPath);
-            if (!project) {
-                // T026: was a non-error advisory text in 6.x — domain not-founds are
-                // isError per the goals precedent (schema-exempt).
-                return { content: [{ type: "text", text: `**Spec Register**: Project not found at "${projectPath}". Register it first (wyrm_scan_projects / wyrm_session_start).` }], isError: true };
-            }
-            const parsed = readSpecDir(specDir);
-            if (parsed.tasks.length === 0) {
-                const body = {
-                    spec_dir: specDir, title: parsed.title ?? null, project: project.name,
-                    tasks_parsed: 0, quests_created: 0, quests_updated: 0, quest_ids: [],
-                };
-                return renderResult(body, (b, g) => withGlyph(g.brand, `**Spec Register**: No tasks found in ${pathJoin(b.spec_dir, 'tasks.md')}. Nothing to create.`));
-            }
-            const questPriority = priority || 'medium';
-            let created = 0;
-            let updated = 0;
-            const questIds = [];
-            for (const task of parsed.tasks) {
-                const signature = specTaskSignature(specDir, task.id);
-                const title = `${task.id}: ${task.title}`;
-                const tags = signature; // the dedupe signature lives in the quest tags
-                const existing = store.findQuestBySpecSignature(project.id, signature);
-                if (existing) {
-                    store.updateQuestFields(existing.id, { title, tags });
-                    questIds.push(existing.id);
-                    updated++;
-                }
-                else {
-                    const quest = store.addQuest(project.id, title, `spec-kit task from ${specDir}`, questPriority, tags);
-                    indexing()?.enqueue('quest', quest.id, project.id);
-                    questIds.push(quest.id);
-                    created++;
-                }
-            }
-            // Persist the spec→project link (idempotent upsert).
-            const spec = store.upsertSpec(project.id, specDir, parsed.title, parsed.summary, parsed.tasks.length);
-            const body = {
-                spec_dir: spec.spec_dir,
-                title: spec.title ?? null,
-                project: project.name,
-                tasks_parsed: parsed.tasks.length,
-                quests_created: created,
-                quests_updated: updated,
-                quest_ids: questIds,
-            };
-            return renderResult(body, (b, g) => {
-                let text = withGlyph(g.brand, '**Spec Registered**') + '\n\n';
-                text += `Spec: ${b.title || '(untitled)'}\n`;
-                if (spec.summary)
-                    text += `Summary: ${spec.summary}\n`;
-                text += `Dir: ${b.spec_dir}\n`;
-                text += `Project: ${b.project}\n`;
-                text += `Tasks parsed: ${b.tasks_parsed}\n`;
-                text += `Quests created: ${b.quests_created} - updated: ${b.quests_updated}\n`;
-                text += `\n\`\`\`json\n${JSON.stringify({
-                    spec: b.spec_dir,
-                    title: b.title,
-                    project: b.project,
-                    tasksParsed: b.tasks_parsed,
-                    questsCreated: b.quests_created,
-                    questsUpdated: b.quests_updated,
-                    questIds: b.quest_ids,
-                }, null, 2)}\n\`\`\``;
-                return text;
-            });
-        },
-    },
-    {
-        name: "wyrm_scaffold_save",
-        description: "Save a reasoning scaffold — a structured checklist that guides step-by-step thinking for a specific problem type. Scaffolds are automatically surfaced by wyrm_context_build when the task matches, helping AI models apply proven reasoning patterns.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                projectPath: { type: "string", description: "Project path (optional, null for global scaffolds)" },
-                problemType: { type: "string", description: "Short slug for the problem type (e.g. 'api-design', 'security-review', 'db-migration')" },
-                description: { type: "string", description: "What kind of task this scaffold helps with" },
-                whenToUse: { type: "string", description: "Conditions that indicate this scaffold should be applied" },
-                steps: { type: "array", items: { type: "string" }, description: "Ordered checklist steps to follow" },
-                verificationSteps: { type: "array", items: { type: "string" }, description: "Steps to verify the work is correct" },
-                doNotApplyIf: { type: "string", description: "Conditions where this scaffold does NOT apply" },
-                tags: { type: "array", items: { type: "string" }, description: "Searchable tags" },
-            },
-            required: ["problemType", "description", "whenToUse", "steps"],
-        },
-        outputSchema: {
-            type: "object",
-            properties: {
-                id: { type: "integer" },
-                problem_type: { type: "string" },
-                description: { type: "string" },
-                steps: { type: "integer" },
-            },
-            required: ["id", "problem_type", "description", "steps"],
-        },
-        annotations: TOOL_ANNOTATIONS.wyrm_scaffold_save,
-        aliases: [],
-        handler: (args, { store, scaffolds, cache }) => {
-            const { projectPath: spPath, problemType, description: spDesc, whenToUse, steps, verificationSteps, doNotApplyIf, tags: spTags } = args;
-            const spProjectId = spPath ? store.getProject(spPath)?.id ?? undefined : undefined;
-            const scaffold = scaffolds.save({
-                projectId: spProjectId,
-                problemType: problemType,
-                description: spDesc,
-                whenToUse: whenToUse,
-                steps,
-                verificationSteps: verificationSteps ?? undefined,
-                doNotApplyIf: doNotApplyIf ? [doNotApplyIf] : undefined,
-                tags: spTags ?? [],
-            });
-            cache.invalidate('wyrm_scaffold_get');
-            cache.invalidate('wyrm_context_build');
-            const body = { id: scaffold.id, problem_type: problemType, description: spDesc, steps: steps.length };
-            return renderResult(body, (b, g) => withGlyph(g.brand, '**Reasoning Scaffold Saved**') + '\n\n' +
-                `${g.bullet} **Problem Type:** ${b.problem_type}\n` +
-                `${g.bullet} **Description:** ${b.description}\n` +
-                `${g.bullet} **Steps:** ${b.steps} checklist items\n` +
-                `${g.bullet} **ID:** ${b.id}\n\n` +
-                `This scaffold will be surfaced by \`wyrm_context_build\` when tasks match "${b.problem_type}".`);
-        },
-    },
-];
-//# sourceMappingURL=capture.js.map
+            `).all(k,e);S.length>0&&(h=S.map(y=>({id:y.id,content:y.problem.slice(0,80)})))}catch{}}const r={status:"captured",type:d,subtype:p,confidence:s,reasoning:b,id:t,ref:`${l}:${t}`,needs_review:o,...h&&h.length>0?{advisory_conflicts:h}:{}};return q(r,(n,x)=>{let $=`Captured as ${n.type}: ${n.subtype}
+Confidence: ${n.confidence}% | ${n.reasoning}
+ID: ${n.ref}`;n.needs_review&&($+=`
+`+I(x.warn,"Stored for review -- run `wyrm_review` to activate"));const k=n.advisory_conflicts;return k&&k.length>0&&($+=`
+
+`+I(x.warn,`Advisory: ${k.length} similar heuristic(s) found:`)+`
+`+k.map(S=>`  ${x.bullet} [${S.id}] ${S.content}`).join(`
+`)),$})}},{name:"wyrm_remember",description:"Store a distilled knowledge artifact \u2014 proven patterns, lessons learned, anti-patterns, and reasoning traces. These are recalled automatically by wyrm_context_build to help AI models apply past knowledge to new tasks. Example: wyrm_remember({ projectPath: '/home/user/api', kind: 'anti_pattern', problem: 'Jest suite hung after adding the SSE server', validatedFix: 'close() the server in afterAll \u2014 its keep-alive timer held the event loop open', whyItWorked: 'open handles block jest exit', outcome: 'positive', tags: ['jest', 'sse'] })",inputSchema:{type:"object",properties:{projectPath:{type:"string",description:"Project this knowledge belongs to"},kind:{type:"string",enum:["reasoning_trace","lesson","pattern","anti_pattern","heuristic"],description:"reasoning_trace: a solved problem with steps; lesson: a general insight; pattern: a proven approach; anti_pattern: what NOT to do; heuristic: a rule of thumb"},problem:{type:"string",description:"What was being solved or observed (be specific and searchable)"},constraints:{type:"string",description:"What conditions or constraints applied"},validatedFix:{type:"string",description:"What actually worked \u2014 the validated solution or approach"},whyItWorked:{type:"string",description:"The insight behind WHY this worked (key for transfer learning)"},outcome:{type:"string",enum:["positive","negative","neutral"],description:"Was this approach successful?"},tags:{type:"array",items:{type:"string"},description:"Searchable tags (e.g. ['auth', 'rate-limit', 'typescript'])"},confidence:{type:"number",description:"Confidence level 0.0\u20131.0 (default: 1.0)"},sourceSessionId:{type:"number",description:"Session ID where this was discovered (optional)"}},required:["projectPath","kind","problem"]},outputSchema:{type:"object",properties:{id:{type:"integer"},kind:{type:"string",enum:["reasoning_trace","lesson","pattern","anti_pattern","heuristic"]},problem:{type:"string"},validated_fix:{type:["string","null"]},why_it_worked:{type:["string","null"]},confidence:{type:"number"},tags:{type:["string","null"]}},required:["id","kind","problem","validated_fix","why_it_worked","confidence","tags"]},annotations:E.wyrm_remember,aliases:[],handler:async(v,{store:w,memory:j})=>{const{projectPath:m,kind:_,problem:g,constraints:c,validatedFix:f,whyItWorked:i,outcome:u,tags:a,confidence:d,sourceSessionId:p}=v,s=H("kind",_,["reasoning_trace","lesson","pattern","anti_pattern","heuristic"]);if(s===void 0)throw new U("kind","is required");const b=w.getProject(m);if(!b)return{content:[{type:"text",text:`Project not found: ${m}`}],isError:!0};const e={kind:s,problem:g,constraints:c,validatedFix:f,whyItWorked:i,outcome:u,tags:a,confidence:d,sourceSessionId:p},t=await A("artifact_add",b.id,e,()=>j.add(b.id,e)),l={id:t.id,kind:t.kind,problem:t.problem,validated_fix:t.validated_fix??null,why_it_worked:t.why_it_worked??null,confidence:t.confidence,tags:t.tags??null};return q(l,(o,h)=>{let r=I(h.brand,"**Memory Stored**")+`
+
+`;return r+=`${h.bullet} **Kind:** ${o.kind}
+`,r+=`${h.bullet} **ID:** ${o.id}
+`,r+=`${h.bullet} **Problem:** ${o.problem}
+`,o.validated_fix&&(r+=`${h.bullet} **Solution:** ${o.validated_fix}
+`),o.why_it_worked&&(r+=`${h.bullet} **Why it worked:** ${o.why_it_worked}
+`),r+=`${h.bullet} **Confidence:** ${(o.confidence*100).toFixed(0)}%
+`,o.tags&&(r+=`${h.bullet} **Tags:** ${o.tags}
+`),r+="\n_Use `wyrm_recall` to retrieve similar memories, or `wyrm_context_build` to assemble a task brief._",r})}},{name:"wyrm_auto_capture",description:"Auto-extract durable memories from freeform text (a session transcript, notes, a chat) into the REVIEW QUEUE. A LOCAL extractor \u2014 a configurable Ollama model (WYRM_EXTRACT_MODEL / the `model` arg) if set, else a deterministic heuristic \u2014 pulls out truths, failures, decisions, patterns, and lessons as needs_review candidates; approve/reject with wyrm_review (nothing auto-trusted). Closes the 'just talk, it remembers' gap without a cloud LLM. Deduped + idempotent. Example: wyrm_auto_capture({ projectPath: '/home/user/api', text: 'Deploy failed twice because wrangler.toml pointed at the old KV id; switched to the new binding and decided to pin binding names in CI.' })",inputSchema:{type:"object",properties:{projectPath:{type:"string",description:"Project to file the extracted candidates under"},text:{type:"string",description:"Freeform text to extract durable memories from"},model:{type:"string",description:"Optional Ollama model for extraction (overrides WYRM_EXTRACT_MODEL); omit for deterministic extraction"}},required:["projectPath","text"]},outputSchema:{type:"object",properties:{method:{type:"string"},model:{type:["string","null"]},added:{type:"integer"},skipped:{type:"integer"},candidates:{type:"array",items:{type:"object",properties:{kind:{type:"string"},text:{type:"string"}},required:["kind","text"]}}},required:["method","model","added","skipped","candidates"]},annotations:E.wyrm_auto_capture,aliases:[],handler:async(v,{store:w,raw:j,memory:m,cache:_})=>{const{projectPath:g,text:c,model:f}=v,i=w.getProject(g);if(!i)return{content:[{type:"text",text:`Project not found: ${g}`}],isError:!0};if(!c||c.trim().length<20)return{content:[{type:"text",text:"Provide at least ~20 chars of text to extract from."}],isError:!0};const{candidates:u,method:a,model:d}=await M(c,{model:f}),p=j();let s=0,b=0;for(const t of u){const l=L(t),o=l.tags[l.tags.length-1];if(p.prepare("SELECT 1 FROM memory_artifacts WHERE project_id = ? AND tags LIKE ? ESCAPE '\\' LIMIT 1").get(i.id,"%"+D(o)+"%")){b++;continue}m.add(i.id,{kind:l.kind,problem:l.problem,tags:l.tags,confidence:l.confidence,needsReview:1,createdBy:"auto-extract"}),s++}s>0&&_.invalidate();const e={method:a,model:d??null,added:s,skipped:b,candidates:u.slice(0,8).map(t=>({kind:t.kind,text:t.text.slice(0,80)}))};return q(e,(t,l)=>{const o=t.candidates.map(h=>`   ${l.bullet} [${h.kind}] ${h.text}`).join(`
+`);return I(l.brand,`Auto-capture (${t.method}${t.model?` - ${t.model}`:""}) -- ${t.added} candidate(s) -> review queue, ${t.skipped} already present.`)+`
+${o}
+
+Approve/reject with wyrm_review.`})}},{name:"wyrm_capture_trace",description:"Harvest a harness's working trace into run-tagged review-queue candidates \u2014 OFFLINE. Ingests a Claude Code session transcript (JSONL), a ~/.dragon/traces file/dir, or WYRM_TRACE_TOOL_CALLS event output. The SAME local extractor as auto-capture (Ollama WYRM_EXTRACT_MODEL if set, else deterministic \u2014 never a cloud LLM) pulls durable truths/failures/decisions/patterns/lessons; secrets (API keys, tokens, passwords) are REDACTED before anything is stored; candidates land needs_review=1 stamped with the run_id (arg or ambient envelope). Approve/reject with wyrm_review; deduped + idempotent. Pass `trace` (inline text) OR `path` (a trace file or the ~/.dragon/traces dir). Reached via wyrm_capture({ mode: 'trace' }).",inputSchema:{type:"object",properties:{projectPath:{type:"string",description:"Project to file the candidates under"},trace:{type:"string",description:"Inline trace text (JSONL transcript / dragon records / tool-call events)"},path:{type:"string",description:"Path to a trace file, or the ~/.dragon/traces directory (newest file is read); omit ~ for absolute"},format:{type:"string",enum:["auto","claude-jsonl","dragon","tool-calls"],description:"Trace format (default auto-detect)"},run_id:{type:"string",description:"Tag candidates with this run (default: ambient envelope run_id)"},model:{type:"string",description:"Optional Ollama model for extraction (overrides WYRM_EXTRACT_MODEL); omit for deterministic"}},required:["projectPath"]},outputSchema:{type:"object",properties:{method:{type:"string"},model:{type:["string","null"]},format:{type:"string"},source:{type:"string"},run_id:{type:["string","null"]},segments:{type:"integer"},added:{type:"integer"},skipped:{type:"integer"},candidates:{type:"array",items:{type:"object",properties:{kind:{type:"string"},text:{type:"string"}},required:["kind","text"]}}},required:["method","model","format","source","run_id","segments","added","skipped","candidates"]},annotations:E.wyrm_capture_trace,aliases:[],handler:async(v,{store:w,raw:j,memory:m,cache:_})=>{const{projectPath:g,trace:c,path:f,format:i,run_id:u,model:a}=v,d=w.getProject(g);if(!d)return{content:[{type:"text",text:`Project not found: ${g}`}],isError:!0};const p=Y(),s=typeof u=="string"&&u.trim()?u.trim().slice(0,64):p.run_id;let b="",e="inline";if(typeof c=="string"&&c.trim())b=c,e="inline";else if(typeof f=="string"&&f.trim()){let y=f.trim();(y==="~"||y.startsWith("~/"))&&(y=O(V(),y.slice(1)));try{if(R(y).isDirectory()){const T=G(y).map(C=>O(y,C)).filter(C=>{try{return R(C).isFile()}catch{return!1}}).sort((C,F)=>R(F).mtimeMs-R(C).mtimeMs);if(T.length===0)return{content:[{type:"text",text:`No trace files in directory: ${y}`}],isError:!0};b=W(T[0],"utf-8"),e=T[0]}else b=W(y,"utf-8"),e=y}catch(P){return{content:[{type:"text",text:`Could not read trace path "${y}": ${P.message}`}],isError:!0}}}else return{content:[{type:"text",text:"Provide a `trace` (inline text) or a `path` (trace file or ~/.dragon/traces dir)."}],isError:!0};const{segments:t,format:l}=K(b,i??"auto"),o=J(t);if(o.trim().length<20){const y={method:"deterministic",model:null,format:l,source:e,run_id:s,segments:t.length,added:0,skipped:0,candidates:[]};return q(y,(P,T)=>I(T.brand,`Trace harvest (${P.format}) -- no durable content extracted from ${P.segments} segment(s).`))}const{candidates:h,method:r,model:n}=await M(o,{model:a}),x=j();let $=0,k=0;for(const y of h){const P=L(y),T=P.tags[P.tags.length-1];if(x.prepare("SELECT 1 FROM memory_artifacts WHERE project_id = ? AND tags LIKE ? ESCAPE '\\' LIMIT 1").get(d.id,"%"+D(T)+"%")){k++;continue}const C=s?[...P.tags,"trace",`run:${s}`]:[...P.tags,"trace"];Q({agent_id:p.agent_id,run_id:s,source:s?"param":p.source},()=>m.add(d.id,{kind:P.kind,problem:P.problem,tags:C,confidence:P.confidence,needsReview:1,createdBy:"trace-harvest"})),$++}$>0&&_.invalidate();const S={method:r,model:n??null,format:l,source:e,run_id:s,segments:t.length,added:$,skipped:k,candidates:h.slice(0,8).map(y=>({kind:y.kind,text:y.text.slice(0,80)}))};return q(S,(y,P)=>{const T=y.candidates.map(C=>`   ${P.bullet} [${C.kind}] ${C.text}`).join(`
+`);return I(P.brand,`Trace harvest (${y.format}, ${y.method}${y.model?` - ${y.model}`:""}) -- ${y.segments} segment(s) -> ${y.added} candidate(s) to review queue, ${y.skipped} already present${y.run_id?` [run:${y.run_id}]`:""}.`)+(T?`
+${T}`:"")+`
+
+Approve/reject with wyrm_review.`})}},{name:"wyrm_distill",description:"Distill a work session into candidate memory artifacts for review. Parses the session's objectives, decisions, and outcomes into structured artifacts (lessons, patterns, anti-patterns) and queues them for approval via wyrm_review. Use at session end to extract institutional knowledge.",inputSchema:{type:"object",properties:{projectPath:{type:"string",description:"Project root path"},sessionId:{type:"string",description:"Session ID to distill"},candidates:{type:"array",description:"Pre-parsed candidate artifacts to store for review",items:{type:"object",properties:{kind:{type:"string",enum:["lesson","pattern","anti_pattern","heuristic","reasoning_trace"]},title:{type:"string"},content:{type:"string"},tags:{type:"array",items:{type:"string"}},confidence:{type:"number"}},required:["kind","title","content"]}}},required:["projectPath","candidates"]},outputSchema:{type:"object",properties:{count:{type:"integer"},artifacts:{type:"array",items:{type:"object",properties:{id:{type:"integer"},kind:{type:"string"},title:{type:"string"}},required:["id","kind","title"]}}},required:["count","artifacts"]},annotations:E.wyrm_distill,aliases:[],handler:(v,{store:w,memory:j})=>{const{projectPath:m,candidates:_}=v,g=w.getProject(m);if(!g)return{content:[{type:"text",text:`Project not found: ${m}`}],isError:!0};if(!_||_.length===0)return{content:[{type:"text",text:`**Distill**
+
+No candidates provided. Provide an array of candidate artifacts to distill.`}],isError:!0};const c=[];for(const i of _){const u=j.add(g.id,{kind:i.kind,problem:i.title,validatedFix:i.content,tags:i.tags??[],confidence:i.confidence??.7,needsReview:1});c.push({id:u.id,kind:i.kind,title:i.title})}const f={count:c.length,artifacts:c};return q(f,(i,u)=>{let a=I(u.brand,`**Distillation Complete** -- ${i.count} artifact${i.count!==1?"s":""} queued for review`)+`
+
+`;return a+=i.artifacts.map(d=>`${u.bullet} [#${d.id}] **${d.kind}**: ${d.title}`).join(`
+`),a+="\n\nUse `wyrm_review` with each ID to approve or reject.",a})}},{name:"wyrm_harvest",description:"Auto-populate memory from artifacts you already produce. Walks a project (or ALL registered projects) and harvests durable facts from its docs (README/CLAUDE/AGENTS/ARCHITECTURE) plus recent commit subjects (git log) into the REVIEW QUEUE \u2014 approve/reject with wyrm_review, nothing is auto-trusted. Idempotent (re-runs skip what's already harvested). Use dryRun to preview. The fix for a thin corpus.",inputSchema:{type:"object",properties:{projectPath:{type:"string",description:"Harvest one project; omit to harvest ALL registered projects"},dryRun:{type:"boolean",description:"Preview what would be harvested without writing anything"},gitLimit:{type:"number",description:"How many recent commits to scan per project (default 30, max 200)"},includeCode:{type:"boolean",description:"Also harvest CODE: tech-stack facts from manifests (package.json/Cargo.toml/\u2026) + TODO/FIXME markers into the review queue, AND index code symbols (functions/classes/types) for search. Heavier \u2014 scope to one project for the full code pass."}}},outputSchema:{type:"object",properties:{dry_run:{type:"boolean"},projects_scanned:{type:"integer"},added:{type:"integer"},skipped:{type:"integer"},top:{type:"array",items:{type:"object",properties:{project:{type:"string"},added:{type:"integer"},skipped:{type:"integer"}},required:["project","added","skipped"]}},sample:{type:"array",items:{type:"string"}},code_symbols:{type:["object","null"],properties:{symbols:{type:"integer"},projects:{type:"integer"},files:{type:"integer"}},required:["symbols","projects","files"]}},required:["dry_run","projects_scanned","added","skipped","top","sample","code_symbols"]},annotations:E.wyrm_harvest,aliases:[],handler:(v,{store:w,raw:j,memory:m,symbols:_,cache:g})=>{const{projectPath:c,dryRun:f,gitLimit:i,includeCode:u}=v,a=j(),d={existsBySig:(r,n)=>!!a.prepare("SELECT 1 FROM memory_artifacts WHERE project_id = ? AND tags LIKE ? ESCAPE '\\' LIMIT 1").get(r,"%"+D(n)+"%"),addCandidate:(r,n)=>{m.add(r,{kind:n.kind,problem:n.text,tags:[...n.tags,n.sig],confidence:n.confidence,needsReview:1,createdBy:"harvest"})}};let p;if(c){const r=w.getProject(c);if(!r)return{content:[{type:"text",text:"Project not found"}],isError:!0};p=[{id:r.id,name:r.name,path:r.path}]}else p=w.getAllProjects(500).map(r=>({id:r.id,name:r.name,path:r.path}));const{reports:s,totalAdded:b,totalSkipped:e}=X(d,p,{dryRun:f,gitLimit:i,includeCode:u});!f&&b>0&&g.invalidate();let t=null;if(u&&!f){let r=0,n=0,x=0;for(const $ of p)try{const k=_.indexProject($.id,$.path);r+=k.files,n+=k.symbols,x++}catch{}t={symbols:n,projects:x,files:r}}const l=s.filter(r=>r.added>0).sort((r,n)=>n.added-r.added).slice(0,15).map(r=>({project:r.project,added:r.added,skipped:r.skipped})),o=s.flatMap(r=>r.sample??[]).slice(0,6),h={dry_run:!!f,projects_scanned:p.length,added:b,skipped:e,top:l,sample:o,code_symbols:t};return q(h,(r,n)=>{const x=r.code_symbols?`
+Indexed ${r.code_symbols.symbols} code symbols across ${r.code_symbols.projects} project(s) (${r.code_symbols.files} files) -> searchable via wyrm_symbol_search.`:"",$=r.top.map(S=>`  +${String(S.added).padStart(3)} (skip ${S.skipped})  ${S.project}`).join(`
+`),k=r.sample.map(S=>`   ${n.bullet} ${S}`).join(`
+`);return I(n.brand,`Harvest ${r.dry_run?"(dry run) ":""}-- ${r.added} candidate(s) -> review queue across ${r.projects_scanned} project(s); ${r.skipped} already present.`)+`${x}
+${$}`+(k?`
+
+Sample:
+${k}`:"")+`
+
+Approve/reject with wyrm_review.`})}},{name:"wyrm_import_git",description:"Import a list of commits into the Wyrm memory review queue. Useful for onboarding a project's history or capturing recent work.",inputSchema:{type:"object",properties:{project_id:{type:"number",description:"Project ID"},commits:{type:"array",description:"Array of commit objects",items:{type:"object",properties:{message:{type:"string"},diff_summary:{type:"string"},author:{type:"string"},date:{type:"string"}},required:["message"]}},auto_approve:{type:"boolean",description:"Skip review queue and activate immediately (default: false)"}},required:["project_id","commits"]},outputSchema:{type:"object",properties:{captured:{type:"integer"},skipped:{type:"integer"},auto_approved:{type:"boolean"}},required:["captured","skipped","auto_approved"]},annotations:E.wyrm_import_git,aliases:[],handler:(v,{store:w,memory:j})=>{const{project_id:m,commits:_,auto_approve:g}=v;if(!w.getProjectById(m))return{content:[{type:"text",text:`Project ID ${m} not found.`}],isError:!0};let f=0,i=0;for(const a of _){const d=a.message??"";if(/^Merge /i.test(d)){i++;continue}if(/^(chore|bump|release|version)/i.test(d)){i++;continue}let p="pattern";/^fix(\(.+\))?:/i.test(d)?p="lesson":/^feat(\(.+\))?:/i.test(d)?p="pattern":/^refactor(\(.+\))?:/i.test(d)&&(p="heuristic");const s=d.split(":")[0]??"commit";j.add(m,{kind:p,problem:d,validatedFix:a.diff_summary??"",whyItWorked:`Committed by ${a.author??"unknown"} on ${a.date??"unknown"}`,tags:["git","commit",s.toLowerCase()],confidence:.6,needsReview:g?0:1}),f++}return q({captured:f,skipped:i,auto_approved:!!g},(a,d)=>I(d.brand,"**Git Import Complete**")+`
+
+${d.bullet} **Captured:** ${a.captured}
+${d.bullet} **Skipped:** ${a.skipped} (merges/chores)
+${d.bullet} **Review needed:** ${a.auto_approved?"No (auto-approved)":`Yes -- run \`wyrm_review\` to activate ${a.captured} artifact${a.captured!==1?"s":""}`}`)}},{name:"wyrm_import_pr",description:"Import a pull request (title, body, review comments) into the Wyrm memory review queue to extract patterns and heuristics.",inputSchema:{type:"object",properties:{project_id:{type:"number",description:"Project ID"},title:{type:"string",description:"PR title"},body:{type:"string",description:"PR description / body"},review_comments:{type:"array",items:{type:"string"},description:"Review comment strings"},auto_approve:{type:"boolean",description:"Skip review queue (default: false)"}},required:["project_id","title","body"]},outputSchema:{type:"object",properties:{created:{type:"integer"},auto_approved:{type:"boolean"}},required:["created","auto_approved"]},annotations:E.wyrm_import_pr,aliases:[],handler:(v,{store:w,memory:j})=>{const{project_id:m,title:_,body:g,review_comments:c,auto_approve:f}=v;if(!w.getProjectById(m))return{content:[{type:"text",text:`Project ID ${m} not found.`}],isError:!0};let u=0;const a=f?0:1;j.add(m,{kind:"pattern",problem:`${_}
+
+${g}`,validatedFix:"",whyItWorked:"",tags:["git","pr"],confidence:.65,needsReview:a}),u++;for(const p of c??[])/\b(should|must|always|never|prefer|avoid|use|don't)\b/i.test(p)&&(j.add(m,{kind:"heuristic",problem:p,validatedFix:"",whyItWorked:"",tags:["git","pr","review"],confidence:.65,needsReview:a}),u++);return q({created:u,auto_approved:!!f},(p,s)=>I(s.brand,"**PR Import Complete**")+`
+
+${s.bullet} **Artifacts created:** ${p.created}
+${s.bullet} **Review needed:** ${p.auto_approved?"No (auto-approved)":"Yes -- run `wyrm_review` to activate"}`)}},{name:"wyrm_import_rules",description:"Import a .cursorrules / copilot-instructions file into Wyrm. Parses by section and creates ground truths (for constraint/rule language) or memory artifacts (for general guidelines).",inputSchema:{type:"object",properties:{project_id:{type:"number",description:"Project ID"},content:{type:"string",description:"Full text of the rules file"},format:{type:"string",enum:["cursorrules","copilot","plain"],description:"Source format (default: plain)"},source_file:{type:"string",description:"Filename for provenance (optional)"}},required:["project_id","content"]},outputSchema:{type:"object",properties:{format:{type:"string"},source:{type:"string"},truths_created:{type:"integer"},artifacts_created:{type:"integer"}},required:["format","source","truths_created","artifacts_created"]},annotations:E.wyrm_import_rules,aliases:[],handler:(v,{store:w,memory:j,truths:m})=>{const{project_id:_,content:g,format:c,source_file:f}=v;if(!w.getProjectById(_))return{content:[{type:"text",text:`Project ID ${_} not found.`}],isError:!0};const u=c??"plain",a=f??"rules",d=["imported",u,a],p=g.split(/\n(?=#)/),s=g.split(/\n\n+/),b=(p.length>=s.length?p:s).map(o=>o.trim()).filter(o=>o.length>=15);let e=0,t=0;for(const o of b)/\b(always|never|must|use|don't|avoid|prefer)\b/i.test(o)?(m.set(_,{category:"constraint",key:o.slice(0,50).replace(/\n/g," "),value:o,source:a}),e++):(j.add(_,{kind:"heuristic",problem:o,validatedFix:"",whyItWorked:"",tags:d,confidence:.7,needsReview:1}),t++);return q({format:u,source:a,truths_created:e,artifacts_created:t},(o,h)=>I(h.brand,`**Rules Import Complete** (${o.format})`)+`
+
+${h.bullet} **Ground truths created:** ${o.truths_created} (active immediately)
+${h.bullet} **Memory artifacts created:** ${o.artifacts_created} (pending review)
+${h.bullet} **Source:** ${o.source}
+
+Run \`wyrm_review\` to approve the memory artifacts.`)}},{name:"wyrm_spec_register",description:"Make spec-kit Wyrm-native. Reads a spec directory (spec.md title/summary + tasks.md task list) and creates one Wyrm quest per task, linked to a project, with a stored spec\u2192project link. Idempotent \u2014 re-running updates the same quests (deduped by a per-spec-task signature) instead of duplicating.",inputSchema:{type:"object",properties:{specDir:{type:"string",description:"Absolute path to the spec directory (e.g. '.../dragon-platform/specs/001-ghostmesh')"},projectPath:{type:"string",description:"Path of the Wyrm project to attach the spec + quests to (must already be registered)"},priority:{type:"string",enum:["critical","high","medium","low"],description:"Priority for the generated quests (default 'medium')"}},required:["specDir","projectPath"]},outputSchema:{type:"object",properties:{spec_dir:{type:"string"},title:{type:["string","null"]},project:{type:"string"},tasks_parsed:{type:"integer"},quests_created:{type:"integer"},quests_updated:{type:"integer"},quest_ids:{type:"array",items:{type:"integer"}}},required:["spec_dir","title","project","tasks_parsed","quests_created","quests_updated","quest_ids"]},annotations:E.wyrm_spec_register,aliases:[],handler:(v,{store:w,indexing:j})=>{const{specDir:m,projectPath:_,priority:g}=v,c=["specDir","projectPath"].filter(e=>{const t=v[e];return!t&&t!==0&&t!==!1});if(c.length>0)return{content:[{type:"text",text:`Missing required arguments: ${c.join(", ")}`}],isError:!0};const f=w.getProject(_);if(!f)return{content:[{type:"text",text:`**Spec Register**: Project not found at "${_}". Register it first (wyrm_scan_projects / wyrm_session_start).`}],isError:!0};const i=z(m);if(i.tasks.length===0){const e={spec_dir:m,title:i.title??null,project:f.name,tasks_parsed:0,quests_created:0,quests_updated:0,quest_ids:[]};return q(e,(t,l)=>I(l.brand,`**Spec Register**: No tasks found in ${N(t.spec_dir,"tasks.md")}. Nothing to create.`))}const u=g||"medium";let a=0,d=0;const p=[];for(const e of i.tasks){const t=Z(m,e.id),l=`${e.id}: ${e.title}`,o=t,h=w.findQuestBySpecSignature(f.id,t);if(h)w.updateQuestFields(h.id,{title:l,tags:o}),p.push(h.id),d++;else{const r=w.addQuest(f.id,l,`spec-kit task from ${m}`,u,o);j()?.enqueue("quest",r.id,f.id),p.push(r.id),a++}}const s=w.upsertSpec(f.id,m,i.title,i.summary,i.tasks.length),b={spec_dir:s.spec_dir,title:s.title??null,project:f.name,tasks_parsed:i.tasks.length,quests_created:a,quests_updated:d,quest_ids:p};return q(b,(e,t)=>{let l=I(t.brand,"**Spec Registered**")+`
+
+`;return l+=`Spec: ${e.title||"(untitled)"}
+`,s.summary&&(l+=`Summary: ${s.summary}
+`),l+=`Dir: ${e.spec_dir}
+`,l+=`Project: ${e.project}
+`,l+=`Tasks parsed: ${e.tasks_parsed}
+`,l+=`Quests created: ${e.quests_created} - updated: ${e.quests_updated}
+`,l+=`
+\`\`\`json
+${JSON.stringify({spec:e.spec_dir,title:e.title,project:e.project,tasksParsed:e.tasks_parsed,questsCreated:e.quests_created,questsUpdated:e.quests_updated,questIds:e.quest_ids},null,2)}
+\`\`\``,l})}},{name:"wyrm_scaffold_save",description:"Save a reasoning scaffold \u2014 a structured checklist that guides step-by-step thinking for a specific problem type. Scaffolds are automatically surfaced by wyrm_context_build when the task matches, helping AI models apply proven reasoning patterns.",inputSchema:{type:"object",properties:{projectPath:{type:"string",description:"Project path (optional, null for global scaffolds)"},problemType:{type:"string",description:"Short slug for the problem type (e.g. 'api-design', 'security-review', 'db-migration')"},description:{type:"string",description:"What kind of task this scaffold helps with"},whenToUse:{type:"string",description:"Conditions that indicate this scaffold should be applied"},steps:{type:"array",items:{type:"string"},description:"Ordered checklist steps to follow"},verificationSteps:{type:"array",items:{type:"string"},description:"Steps to verify the work is correct"},doNotApplyIf:{type:"string",description:"Conditions where this scaffold does NOT apply"},tags:{type:"array",items:{type:"string"},description:"Searchable tags"}},required:["problemType","description","whenToUse","steps"]},outputSchema:{type:"object",properties:{id:{type:"integer"},problem_type:{type:"string"},description:{type:"string"},steps:{type:"integer"}},required:["id","problem_type","description","steps"]},annotations:E.wyrm_scaffold_save,aliases:[],handler:(v,{store:w,scaffolds:j,cache:m})=>{const{projectPath:_,problemType:g,description:c,whenToUse:f,steps:i,verificationSteps:u,doNotApplyIf:a,tags:d}=v,p=_?w.getProject(_)?.id??void 0:void 0,s=j.save({projectId:p,problemType:g,description:c,whenToUse:f,steps:i,verificationSteps:u??void 0,doNotApplyIf:a?[a]:void 0,tags:d??[]});m.invalidate("wyrm_scaffold_get"),m.invalidate("wyrm_context_build");const b={id:s.id,problem_type:g,description:c,steps:i.length};return q(b,(e,t)=>I(t.brand,"**Reasoning Scaffold Saved**")+`
+
+${t.bullet} **Problem Type:** ${e.problem_type}
+${t.bullet} **Description:** ${e.description}
+${t.bullet} **Steps:** ${e.steps} checklist items
+${t.bullet} **ID:** ${e.id}
+
+This scaffold will be surfaced by \`wyrm_context_build\` when tasks match "${e.problem_type}".`)}}];export{ye as captureToolSpecs};