wyrm-mcp 7.3.2 → 7.3.3

package/dist/capabilities.js

@@ -1,4 +1,25 @@
-import{homedir as n}from"os";import{join as o,dirname as l}from"path";import{readFileSync as c,existsSync as m}from"fs";import{fileURLToPath as y}from"url";const h=y(import.meta.url),a=l(h),d=`Wyrm is not "AI memory" in the file-write sense. It's a layered intelligence
+/**
+ * Capabilities self-description.
+ *
+ * Returns a structured pitch the AI can read at session start so it knows
+ * exactly what Wyrm offers beyond "store and recall". The categories are
+ * grouped by *what the operator gets*, not by table or module — the AI
+ * should be able to read this once and immediately reach for the right
+ * tool without re-discovering the surface.
+ *
+ * Also used as the body of the `wyrm_capabilities` MCP tool, the
+ * `wyrm_inject_prompt` block, and the postinstall pitch.
+ *
+ * @copyright 2026 Ghost Protocol (Pvt) Ltd.
+ * @license Proprietary — (c) 2026 Ghost Protocol (Pvt) Ltd. All rights reserved. See LICENSE.
+ */
+import { homedir } from 'os';
+import { join, dirname } from 'path';
+import { readFileSync, existsSync } from 'fs';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const PITCH = `Wyrm is not "AI memory" in the file-write sense. It's a layered intelligence
 substrate that solves the four specific problems AI assistants share:
 
   1. Amnesia.    Sessions inherit prior state via lossless rehydration.
@@ -11,5 +32,164 @@ substrate that solves the four specific problems AI assistants share:
 Every Wyrm session is local-first SQLite with FTS5 + hybrid semantic search.
 Encryption is operator-controlled. Federation is opt-in per row. The audit
 log is hash-chained and Ed25519-signable for SOC2/HIPAA scenarios. None of
-this requires you to leave your laptop.`,w=[{name:"Counter-pattern memory",what:"Records failed approaches with (scope, target, description) and blocks the same suggestion next time.",why:"Other memory tools learn only from success. Wyrm refuses to repeat mistakes \u2014 saves the most expensive class of tokens (the regenerated wrong answer).",tools:["wyrm_failure_record","wyrm_failure_check","wyrm_failure_list","wyrm_failure_resolve"]},{name:"Ground truths (versioned, cascade-aware)",what:"Validated project facts (architecture, constraints, decisions) \u2014 each truth carries a version, last-verified timestamp, and outbound decision links.",why:"Truths are injected first into every wyrm_context_build call so the AI never works from contradicted assumptions. When a truth changes, dependent decisions auto-invalidate.",tools:["wyrm_truth_set","wyrm_truth_get","wyrm_decided_because","wyrm_decision_upstream","wyrm_decision_downstream","wyrm_decision_invalidate"]},{name:"Reasoning scaffolds",what:'Saved step-by-step checklists for problem types ("debug a slow query", "ship a migration") that surface automatically when a task description matches.',why:"Replaces ad-hoc rediscovery of process knowledge with structured prompts. Cheaper than re-explaining the playbook every session.",tools:["wyrm_scaffold_save","wyrm_scaffold_get"]},{name:"Lossless session rehydration",what:"wyrm_session_rehydrate produces a complete briefing markdown a fresh AI ingests to inherit prior state \u2014 decisions, open quests, failures, recent commits, files touched.",why:"Cross-session continuity without re-exploration. The single biggest token-saver in the toolkit.",tools:["wyrm_session_rehydrate","wyrm_session_prime","wyrm_session_start","wyrm_session_update"]},{name:"Distillation queue",what:"Candidate memory artifacts extracted from sessions land in a review queue; the operator approves or rejects each.",why:"Bayesian confidence updates after each review \u2014 Wyrm gets sharper with use without auto-trusting noise.",tools:["wyrm_distill","wyrm_review","wyrm_remember","wyrm_recall","wyrm_feedback"]},{name:"Knowledge graph",what:"Named entities + typed directional relationships, neighborhood traversal, shortest-path queries.",why:'When the AI asks "how does X relate to Y?", Wyrm answers in O(log n) instead of grepping the corpus.',tools:["wyrm_entity_add","wyrm_entity_link","wyrm_entity_search","wyrm_entity_graph","wyrm_entity_path","wyrm_entity_merge"]},{name:"Cross-repo symbol index",what:"Workspace-wide function/class/type index across TS/JS/Python/Rust/Go/PHP/Ruby with caller resolution.",why:`Symbol lookups don't require re-grepping every project. "Who calls handleAuth?" answers immediately.`,tools:["wyrm_symbol_index","wyrm_symbol_search","wyrm_symbol_callers","wyrm_symbol_stats"]},{name:"OODA agent loop (autonomous goals)",what:"wyrm_goal_set persists an objective with success criteria. The wyrm-loop daemon runs Observe\u2192Orient\u2192Decide\u2192Act every interval, dispatching whitelisted tools. Replayable, capped, auditable.",why:"Lets you hand the AI a multi-step objective and walk away. No data-exfil tools accessible from inside the loop.",tools:["wyrm_goal_set","wyrm_goal_list","wyrm_goal_pause","wyrm_goal_resume","wyrm_goal_complete","wyrm_goal_abandon","wyrm_goal_iterations","wyrm_act","wyrm_agent_init","wyrm_agent_status","wyrm_agent_stop","wyrm_agent_restart"]},{name:"Outbound MCP client",what:"Wyrm calls other MCP servers (GitHub, Slack, Linear, \u2026) over stdio. The agent loop dispatches them like internal tools.",why:"Composability: Wyrm becomes the orchestration layer over your entire MCP stack instead of a sibling.",tools:["wyrm_mcp_register","wyrm_mcp_list","wyrm_mcp_disable","wyrm_mcp_tools","wyrm_call_external"]},{name:"Hybrid semantic search",what:"wyrm_search fuses FTS5 keyword candidates with vector candidates (Ollama nomic-embed-text by default; OpenAI optional) via Reciprocal Rank Fusion.",why:`Catches both "exact term" and "semantically similar" hits in one call. Silently falls back to FTS5-only if Ollama isn't running.`,tools:["wyrm_search","wyrm_vector_setup"]},{name:"Multi-agent presence + work-stealing",what:"Claude, Copilot, Cursor, and Codex announce themselves via TTL heartbeats. Quests can be claimed exclusively.",why:"No two agents step on the same quest. The work-stealing semantics scale to teams.",tools:["wyrm_presence_announce","wyrm_presence_list","wyrm_presence_release","wyrm_quest_claim","wyrm_quest_release"]},{name:"Federated team sync",what:"Per-row is_shared flag, /sync/push endpoint, conflict-as-quest semantics. PII never leaves the box unless explicitly shared.",why:"Team memory without a SaaS. No silent overwrites \u2014 every conflict becomes a quest the operator resolves.",tools:["wyrm_share","wyrm_unshare","wyrm_sync","wyrm_sync_export","wyrm_sync_import","wyrm_sync_conflicts","wyrm_sync_resolve"]},{name:"Compliance audit trail",what:"Hash-chained audit log with optional Ed25519 signatures. wyrm_audit_export produces tamper-evident bundles.",why:"SOC2/HIPAA reviewers get a real artifact. The hash chain detects any tampering after the fact.",tools:["wyrm_audit_log","wyrm_audit_export","wyrm_audit_verify"]},{name:"Hour ledger + invoice generation",what:"Derives billable hours from session content and emits markdown invoices.",why:"For solo operators and small teams: Wyrm is also the time tracker. No second tool to keep in sync.",tools:["wyrm_hours_report","wyrm_invoice_generate","wyrm_cost_report"]},{name:"Self-improvement analytics",what:"Per-tool error rate, p50/p95 latency, cost-per-tool. Wyrm watches Wyrm.",why:"Lets you spot which tools are hot, which are slow, which fail \u2014 input for both ops tuning and product decisions.",tools:["wyrm_analytics_dashboard","wyrm_tool_analytics","wyrm_usage","wyrm_stats"]}];function u(){try{const t=[o(a,"..","package.json"),o(a,"..","..","package.json")];for(const e of t)if(m(e))return JSON.parse(c(e,"utf-8")).version??"unknown"}catch{}return"unknown"}function v(t,e,s){const i=process.env.WYRM_DB_PATH??o(n(),".wyrm","wyrm.db"),r=s.isAgentRunning();return{product:"Wyrm",version:u(),pitch:d,install:{dbPath:i,nodeVersion:process.version,platform:`${process.platform}-${process.arch}`},runtime:{vectorProvider:s.detectVectorProvider(),encryption:s.hasEncryption(),federation:s.isFederationEnabled(),agentLoop:r===null?"unknown":r?"running":"stopped"},features:w,toolCount:e}}function b(t){const e=[];e.push(`# \u{F115D} ${t.product} ${t.version} \u2014 Capability Briefing`),e.push(""),e.push(t.pitch),e.push(""),e.push(`**Runtime:** ${t.toolCount} MCP tools \xB7 ${t.runtime.vectorProvider} embeddings \xB7 ${t.runtime.encryption?"encryption ON":"encryption off"} \xB7 agent ${t.runtime.agentLoop}`),e.push(`**Install:** ${t.install.platform} \xB7 Node ${t.install.nodeVersion} \xB7 DB ${t.install.dbPath}`),e.push(""),e.push('## What Wyrm gives you beyond "AI memory"'),e.push("");for(const s of t.features)e.push(`### ${s.name}`),e.push(`- **What:** ${s.what}`),e.push(`- **Why:** ${s.why}`),e.push(`- **Tools:** \`${s.tools.join("`, `")}\``),e.push("");return e.join(`
-`)}export{v as getCapabilities,b as renderCapabilityBriefing};
+this requires you to leave your laptop.`;
+const FEATURES = [
+    {
+        name: 'Counter-pattern memory',
+        what: 'Records failed approaches with (scope, target, description) and blocks the same suggestion next time.',
+        why: 'Other memory tools learn only from success. Wyrm refuses to repeat mistakes — saves the most expensive class of tokens (the regenerated wrong answer).',
+        tools: ['wyrm_failure_record', 'wyrm_failure_check', 'wyrm_failure_list', 'wyrm_failure_resolve'],
+    },
+    {
+        name: 'Ground truths (versioned, cascade-aware)',
+        what: 'Validated project facts (architecture, constraints, decisions) — each truth carries a version, last-verified timestamp, and outbound decision links.',
+        why: 'Truths are injected first into every wyrm_context_build call so the AI never works from contradicted assumptions. When a truth changes, dependent decisions auto-invalidate.',
+        tools: ['wyrm_truth_set', 'wyrm_truth_get', 'wyrm_decided_because', 'wyrm_decision_upstream', 'wyrm_decision_downstream', 'wyrm_decision_invalidate'],
+    },
+    {
+        name: 'Reasoning scaffolds',
+        what: 'Saved step-by-step checklists for problem types ("debug a slow query", "ship a migration") that surface automatically when a task description matches.',
+        why: 'Replaces ad-hoc rediscovery of process knowledge with structured prompts. Cheaper than re-explaining the playbook every session.',
+        tools: ['wyrm_scaffold_save', 'wyrm_scaffold_get'],
+    },
+    {
+        name: 'Lossless session rehydration',
+        what: 'wyrm_session_rehydrate produces a complete briefing markdown a fresh AI ingests to inherit prior state — decisions, open quests, failures, recent commits, files touched.',
+        why: 'Cross-session continuity without re-exploration. The single biggest token-saver in the toolkit.',
+        tools: ['wyrm_session_rehydrate', 'wyrm_session_prime', 'wyrm_session_start', 'wyrm_session_update'],
+    },
+    {
+        name: 'Distillation queue',
+        what: 'Candidate memory artifacts extracted from sessions land in a review queue; the operator approves or rejects each.',
+        why: 'Bayesian confidence updates after each review — Wyrm gets sharper with use without auto-trusting noise.',
+        tools: ['wyrm_distill', 'wyrm_review', 'wyrm_remember', 'wyrm_recall', 'wyrm_feedback'],
+    },
+    {
+        name: 'Knowledge graph',
+        what: 'Named entities + typed directional relationships, neighborhood traversal, shortest-path queries.',
+        why: 'When the AI asks "how does X relate to Y?", Wyrm answers in O(log n) instead of grepping the corpus.',
+        tools: ['wyrm_entity_add', 'wyrm_entity_link', 'wyrm_entity_search', 'wyrm_entity_graph', 'wyrm_entity_path', 'wyrm_entity_merge'],
+    },
+    {
+        name: 'Cross-repo symbol index',
+        what: 'Workspace-wide function/class/type index across TS/JS/Python/Rust/Go/PHP/Ruby with caller resolution.',
+        why: 'Symbol lookups don\'t require re-grepping every project. "Who calls handleAuth?" answers immediately.',
+        tools: ['wyrm_symbol_index', 'wyrm_symbol_search', 'wyrm_symbol_callers', 'wyrm_symbol_stats'],
+    },
+    {
+        name: 'OODA agent loop (autonomous goals)',
+        what: 'wyrm_goal_set persists an objective with success criteria. The wyrm-loop daemon runs Observe→Orient→Decide→Act every interval, dispatching whitelisted tools. Replayable, capped, auditable.',
+        why: 'Lets you hand the AI a multi-step objective and walk away. No data-exfil tools accessible from inside the loop.',
+        tools: ['wyrm_goal_set', 'wyrm_goal_list', 'wyrm_goal_pause', 'wyrm_goal_resume', 'wyrm_goal_complete', 'wyrm_goal_abandon', 'wyrm_goal_iterations', 'wyrm_act', 'wyrm_agent_init', 'wyrm_agent_status', 'wyrm_agent_stop', 'wyrm_agent_restart'],
+    },
+    {
+        name: 'Outbound MCP client',
+        what: 'Wyrm calls other MCP servers (GitHub, Slack, Linear, …) over stdio. The agent loop dispatches them like internal tools.',
+        why: 'Composability: Wyrm becomes the orchestration layer over your entire MCP stack instead of a sibling.',
+        tools: ['wyrm_mcp_register', 'wyrm_mcp_list', 'wyrm_mcp_disable', 'wyrm_mcp_tools', 'wyrm_call_external'],
+    },
+    {
+        name: 'Hybrid semantic search',
+        what: 'wyrm_search fuses FTS5 keyword candidates with vector candidates (Ollama nomic-embed-text by default; OpenAI optional) via Reciprocal Rank Fusion.',
+        why: 'Catches both "exact term" and "semantically similar" hits in one call. Silently falls back to FTS5-only if Ollama isn\'t running.',
+        tools: ['wyrm_search', 'wyrm_vector_setup'],
+    },
+    {
+        name: 'Multi-agent presence + work-stealing',
+        what: 'Claude, Copilot, Cursor, and Codex announce themselves via TTL heartbeats. Quests can be claimed exclusively.',
+        why: 'No two agents step on the same quest. The work-stealing semantics scale to teams.',
+        tools: ['wyrm_presence_announce', 'wyrm_presence_list', 'wyrm_presence_release', 'wyrm_quest_claim', 'wyrm_quest_release'],
+    },
+    {
+        name: 'Federated team sync',
+        what: 'Per-row is_shared flag, /sync/push endpoint, conflict-as-quest semantics. PII never leaves the box unless explicitly shared.',
+        why: 'Team memory without a SaaS. No silent overwrites — every conflict becomes a quest the operator resolves.',
+        tools: ['wyrm_share', 'wyrm_unshare', 'wyrm_sync', 'wyrm_sync_export', 'wyrm_sync_import', 'wyrm_sync_conflicts', 'wyrm_sync_resolve'],
+    },
+    {
+        name: 'Compliance audit trail',
+        what: 'Hash-chained audit log with optional Ed25519 signatures. wyrm_audit_export produces tamper-evident bundles.',
+        why: 'SOC2/HIPAA reviewers get a real artifact. The hash chain detects any tampering after the fact.',
+        tools: ['wyrm_audit_log', 'wyrm_audit_export', 'wyrm_audit_verify'],
+    },
+    {
+        name: 'Hour ledger + invoice generation',
+        what: 'Derives billable hours from session content and emits markdown invoices.',
+        why: 'For solo operators and small teams: Wyrm is also the time tracker. No second tool to keep in sync.',
+        tools: ['wyrm_hours_report', 'wyrm_invoice_generate', 'wyrm_cost_report'],
+    },
+    {
+        name: 'Self-improvement analytics',
+        what: 'Per-tool error rate, p50/p95 latency, cost-per-tool. Wyrm watches Wyrm.',
+        why: 'Lets you spot which tools are hot, which are slow, which fail — input for both ops tuning and product decisions.',
+        tools: ['wyrm_analytics_dashboard', 'wyrm_tool_analytics', 'wyrm_usage', 'wyrm_stats'],
+    },
+];
+function readPackageVersion() {
+    try {
+        // Resolve relative to this file. After tsc compile, this lives at
+        // dist/capabilities.js, so package.json is one dir up.
+        const candidates = [
+            join(__dirname, '..', 'package.json'),
+            join(__dirname, '..', '..', 'package.json'),
+        ];
+        for (const p of candidates) {
+            if (existsSync(p)) {
+                return JSON.parse(readFileSync(p, 'utf-8')).version ?? 'unknown';
+            }
+        }
+    }
+    catch {
+        // fall through
+    }
+    return 'unknown';
+}
+export function getCapabilities(db, toolCount, probe) {
+    void db; // reserved — future versions may surface runtime DB stats here
+    const dbPath = process.env.WYRM_DB_PATH ?? join(homedir(), '.wyrm', 'wyrm.db');
+    const agentState = probe.isAgentRunning();
+    return {
+        product: 'Wyrm',
+        version: readPackageVersion(),
+        pitch: PITCH,
+        install: {
+            dbPath,
+            nodeVersion: process.version,
+            platform: `${process.platform}-${process.arch}`,
+        },
+        runtime: {
+            vectorProvider: probe.detectVectorProvider(),
+            encryption: probe.hasEncryption(),
+            federation: probe.isFederationEnabled(),
+            agentLoop: agentState === null ? 'unknown' : agentState ? 'running' : 'stopped',
+        },
+        features: FEATURES,
+        toolCount,
+    };
+}
+/**
+ * Render the capability report as a markdown briefing the AI can drop into a
+ * session-prime answer or a user-facing reply. Keeps the structure stable so
+ * the model can predict where to look.
+ */
+export function renderCapabilityBriefing(report) {
+    const lines = [];
+    lines.push(`# 󱅝 ${report.product} ${report.version} — Capability Briefing`);
+    lines.push('');
+    lines.push(report.pitch);
+    lines.push('');
+    lines.push(`**Runtime:** ${report.toolCount} MCP tools · ${report.runtime.vectorProvider} embeddings · ${report.runtime.encryption ? 'encryption ON' : 'encryption off'} · agent ${report.runtime.agentLoop}`);
+    lines.push(`**Install:** ${report.install.platform} · Node ${report.install.nodeVersion} · DB ${report.install.dbPath}`);
+    lines.push('');
+    lines.push('## What Wyrm gives you beyond "AI memory"');
+    lines.push('');
+    for (const f of report.features) {
+        lines.push(`### ${f.name}`);
+        lines.push(`- **What:** ${f.what}`);
+        lines.push(`- **Why:** ${f.why}`);
+        lines.push(`- **Tools:** \`${f.tools.join('`, `')}\``);
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=capabilities.js.map

package/dist/capture.js

@@ -1 +1,56 @@
-function t(e){return/^(TODO|TASK|QUEST|implement|build|fix|add|create|refactor|migrate|update|remove)\b/i.test(e)?{type:"quest",subtype:"quest",confidence:85,reasoning:"Starts with action/task keyword -- classified as a quest"}:/\b(always|never|must not|we use|we decided|architecture decision|constraint:|rule:|standard:)\b/i.test(e)?{type:"truth",subtype:"decision",confidence:80,reasoning:"Contains ground-truth / decision marker -- classified as truth"}:/\b(learned|lesson|anti-pattern|mistake|bug was|root cause|turned out|retrospective)\b/i.test(e)?{type:"memory",subtype:"lesson",confidence:80,reasoning:"Contains lesson / retrospective marker -- classified as lesson"}:/\b(when.*use|if.*then|prefer.*over|avoid|guideline|best practice)\b/i.test(e)?{type:"memory",subtype:"heuristic",confidence:75,reasoning:"Contains guideline / heuristic marker -- classified as heuristic"}:{type:"memory",subtype:"pattern",confidence:60,reasoning:"No specific marker detected -- stored as general pattern"}}export{t as classifyCapture};
+/**
+ * Wyrm Capture Helpers — Classification logic for unified auto-capture.
+ *
+ * @copyright 2026 Ghost Protocol (Pvt) Ltd.
+ * @license Proprietary — (c) 2026 Ghost Protocol (Pvt) Ltd. All rights reserved. See LICENSE.
+ */
+/**
+ * Classify a piece of content into quest/truth/memory using heuristic patterns.
+ * Patterns are applied in priority order; first match wins.
+ */
+export function classifyCapture(content) {
+    // Pattern 1: quest — action-oriented task starters
+    if (/^(TODO|TASK|QUEST|implement|build|fix|add|create|refactor|migrate|update|remove)\b/i.test(content)) {
+        return {
+            type: 'quest',
+            subtype: 'quest',
+            confidence: 85,
+            reasoning: 'Starts with action/task keyword -- classified as a quest',
+        };
+    }
+    // Pattern 2: truth — architectural decisions / constraints
+    if (/\b(always|never|must not|we use|we decided|architecture decision|constraint:|rule:|standard:)\b/i.test(content)) {
+        return {
+            type: 'truth',
+            subtype: 'decision',
+            confidence: 80,
+            reasoning: 'Contains ground-truth / decision marker -- classified as truth',
+        };
+    }
+    // Pattern 3: lesson — retrospective / root-cause learning
+    if (/\b(learned|lesson|anti-pattern|mistake|bug was|root cause|turned out|retrospective)\b/i.test(content)) {
+        return {
+            type: 'memory',
+            subtype: 'lesson',
+            confidence: 80,
+            reasoning: 'Contains lesson / retrospective marker -- classified as lesson',
+        };
+    }
+    // Pattern 4: heuristic — guidelines / conditional rules
+    if (/\b(when.*use|if.*then|prefer.*over|avoid|guideline|best practice)\b/i.test(content)) {
+        return {
+            type: 'memory',
+            subtype: 'heuristic',
+            confidence: 75,
+            reasoning: 'Contains guideline / heuristic marker -- classified as heuristic',
+        };
+    }
+    // Pattern 5: pattern — default fallback
+    return {
+        type: 'memory',
+        subtype: 'pattern',
+        confidence: 60,
+        reasoning: 'No specific marker detected -- stored as general pattern',
+    };
+}
+//# sourceMappingURL=capture.js.map

package/dist/causality.js

@@ -1,29 +1,169 @@
-import{emitEvent as f}from"./events.js";import{getActor as E}from"./handlers/boundary.js";function g(c){if(c.length===0)return"";const e=c.map(r=>`${r.to_kind} #${r.to_id} (${r.reason})`).join(", "),t=c.length===1;return`[STALE FOUNDATION] this decision rests on ${t?"a foundation that has":`${c.length} foundations that have`} since been ${t?c[0].reason:"invalidated"} -- ${e}. Re-evaluate before relying on it (wyrm_decision_invalidate to cascade, or re-decide).`}class p{db;constructor(e){this.db=e}link(e){const t=E(),r=this.db.prepare(`
+/**
+ * Causality — decision chains + downstream invalidation.
+ *
+ * "We chose Postgres because Y" → "Y turned out to be wrong" → flag every
+ * downstream decision built on Y for re-evaluation.
+ *
+ * Edges link a `(kind, id)` pair to another `(kind, id)` pair with a
+ * relation (`because_of`, `supersedes`, `refutes`, `verifies`). When a
+ * ground truth flips to stale or gets superseded, the invalidation
+ * cascade walks the edge graph and flags downstream decisions.
+ *
+ * @copyright 2026 Ghost Protocol (Pvt) Ltd.
+ * @license Proprietary — (c) 2026 Ghost Protocol (Pvt) Ltd. All rights reserved. See LICENSE.
+ */
+import { emitEvent } from './events.js';
+import { getActor } from './handlers/boundary.js';
+/**
+ * Warn-at-recall: render the read-time interrupt for a decision whose recalled
+ * foundations have gone stale. ASCII-only (render-contract glyph law). Empty
+ * string when nothing is stale, so callers can append unconditionally.
+ */
+export function staleFoundationWarning(stale) {
+    if (stale.length === 0)
+        return '';
+    const items = stale.map((s) => `${s.to_kind} #${s.to_id} (${s.reason})`).join(', ');
+    const one = stale.length === 1;
+    return (`[STALE FOUNDATION] this decision rests on ${one ? 'a foundation that has' : `${stale.length} foundations that have`} ` +
+        `since been ${one ? stale[0].reason : 'invalidated'} -- ${items}. ` +
+        `Re-evaluate before relying on it (wyrm_decision_invalidate to cascade, or re-decide).`);
+}
+export class Causality {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    /** Record that `from` was decided BECAUSE OF `to` (or other relation). */
+    link(input) {
+        // v7 F2 (T009): stamp the writing actor (NULL outside a fleet context).
+        const ambient = getActor();
+        const info = this.db.prepare(`
       INSERT INTO decision_edges
         (project_id, from_kind, from_id, to_kind, to_id, relation, rationale, confidence, agent_id, run_id)
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(e.project_id,e.from_kind,e.from_id,e.to_kind,e.to_id,e.relation??"because_of",e.rationale??null,e.confidence??1,t.agent_id,t.run_id),n=this.get(r.lastInsertRowid);return f(this.db,{projectId:e.project_id,kind:"decision",refTable:"decision_edges",refId:n.id,isShared:!!n.is_shared}),n}get(e){return this.db.prepare("SELECT * FROM decision_edges WHERE id = ?").get(e)??null}downstreamOf(e,t){return this.db.prepare(`
+    `).run(input.project_id, input.from_kind, input.from_id, input.to_kind, input.to_id, input.relation ?? 'because_of', input.rationale ?? null, input.confidence ?? 1.0, ambient.agent_id, ambient.run_id);
+        const edge = this.get(info.lastInsertRowid);
+        emitEvent(this.db, {
+            projectId: input.project_id, kind: 'decision', refTable: 'decision_edges', refId: edge.id,
+            isShared: !!edge.is_shared,
+        });
+        return edge;
+    }
+    get(id) {
+        return this.db.prepare('SELECT * FROM decision_edges WHERE id = ?').get(id) ?? null;
+    }
+    /** All decisions that depend on the given source (outgoing edges from source). */
+    downstreamOf(kind, id) {
+        return this.db.prepare(`
       SELECT * FROM decision_edges
       WHERE to_kind = ? AND to_id = ? AND invalidated_at IS NULL
       ORDER BY created_at DESC
-    `).all(e,t)}upstreamOf(e,t){return this.db.prepare(`
+    `).all(kind, id);
+    }
+    /** All sources that the given decision was based on (incoming edges to decision). */
+    upstreamOf(kind, id) {
+        return this.db.prepare(`
       SELECT * FROM decision_edges
       WHERE from_kind = ? AND from_id = ? AND invalidated_at IS NULL
       ORDER BY created_at DESC
-    `).all(e,t)}staleFoundations(e,t){const r=this.db.prepare(`
+    `).all(kind, id);
+    }
+    /**
+     * Warn-at-recall engine: the decision's `because_of` foundations that have
+     * gone stale — a foundation truth that was SUPERSEDED (is_current=0) or
+     * REFUTED (a live `refutes` edge targets it). Read-only, deterministic, the
+     * basis of the read-time interrupt surfaced by wyrm_decision_upstream.
+     */
+    staleFoundations(kind, id) {
+        const foundations = this.db.prepare(`
       SELECT to_kind, to_id FROM decision_edges
       WHERE from_kind = ? AND from_id = ? AND relation = 'because_of' AND invalidated_at IS NULL
-    `).all(e,t),n=this.db.prepare("SELECT is_current FROM ground_truths WHERE id = ?"),s=this.db.prepare(`
+    `).all(kind, id);
+        const truthCurrent = this.db.prepare(`SELECT is_current FROM ground_truths WHERE id = ?`);
+        const refutes = this.db.prepare(`
       SELECT 1 FROM decision_edges
       WHERE to_kind = ? AND to_id = ? AND relation = 'refutes' AND invalidated_at IS NULL LIMIT 1
-    `),i=[];for(const o of r){let d=null;if(o.to_kind==="truth"){const a=n.get(o.to_id);a&&a.is_current===0&&(d="superseded")}!d&&s.get(o.to_kind,o.to_id)&&(d="refuted"),d&&i.push({to_kind:o.to_kind,to_id:o.to_id,reason:d})}return i}invalidateDownstream(e,t,r){const n=[],s=new Set,i=[{kind:e,id:t}],o=this.db.prepare(`
+    `);
+        const out = [];
+        for (const f of foundations) {
+            let reason = null;
+            if (f.to_kind === 'truth') {
+                const t = truthCurrent.get(f.to_id);
+                if (t && t.is_current === 0)
+                    reason = 'superseded';
+            }
+            if (!reason && refutes.get(f.to_kind, f.to_id))
+                reason = 'refuted';
+            if (reason)
+                out.push({ to_kind: f.to_kind, to_id: f.to_id, reason });
+        }
+        return out;
+    }
+    /** Walk downstream from a source, depth-first, marking dependent decisions.
+     * Returns the set of (kind, id) pairs affected. Idempotent — already-
+     * invalidated edges are skipped. */
+    invalidateDownstream(kind, id, reason) {
+        const affected = [];
+        const seen = new Set();
+        const queue = [{ kind, id }];
+        const markEdge = this.db.prepare(`
       UPDATE decision_edges
       SET invalidated_at = datetime('now'),
           rationale = COALESCE(?, rationale)
       WHERE id = ?
-    `);for(;i.length>0;){const d=i.shift(),a=`${d.kind}:${d.id}`;if(s.has(a))continue;s.add(a);const l=this.downstreamOf(d.kind,d.id);for(const _ of l)o.run(r??null,_.id),n.push({kind:_.from_kind,id:_.from_id,edge_id:_.id,rationale:_.rationale}),i.push({kind:_.from_kind,id:_.from_id})}return{invalidated:n.length,affected:n}}pathTo(e,t,r=6){const n=new Set,s=[{node:e,path:[]}];for(;s.length>0;){const{node:i,path:o}=s.pop(),d=`${i.kind}:${i.id}`;if(!(n.has(d)||o.length>r)){if(n.add(d),i.kind===t.kind&&i.id===t.id)return o;for(const a of this.upstreamOf(i.kind,i.id))s.push({node:{kind:a.to_kind,id:a.to_id},path:[...o,a]})}}return[]}invalidatedInProject(e,t=50){return this.db.prepare(`
+    `);
+        while (queue.length > 0) {
+            const node = queue.shift();
+            const key = `${node.kind}:${node.id}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            const edges = this.downstreamOf(node.kind, node.id);
+            for (const edge of edges) {
+                markEdge.run(reason ?? null, edge.id);
+                affected.push({
+                    kind: edge.from_kind,
+                    id: edge.from_id,
+                    edge_id: edge.id,
+                    rationale: edge.rationale,
+                });
+                queue.push({ kind: edge.from_kind, id: edge.from_id });
+            }
+        }
+        return { invalidated: affected.length, affected };
+    }
+    /** Path query: list edges forming the decision chain from `from` back to `to`,
+     * walking upstream up to maxDepth. Returns empty if no path. */
+    pathTo(from, to, maxDepth = 6) {
+        const visited = new Set();
+        const stack = [
+            { node: from, path: [] },
+        ];
+        while (stack.length > 0) {
+            const { node, path } = stack.pop();
+            const key = `${node.kind}:${node.id}`;
+            if (visited.has(key) || path.length > maxDepth)
+                continue;
+            visited.add(key);
+            if (node.kind === to.kind && node.id === to.id)
+                return path;
+            for (const edge of this.upstreamOf(node.kind, node.id)) {
+                stack.push({
+                    node: { kind: edge.to_kind, id: edge.to_id },
+                    path: [...path, edge],
+                });
+            }
+        }
+        return [];
+    }
+    /** List all currently-invalidated edges that touch a project. */
+    invalidatedInProject(projectId, limit = 50) {
+        return this.db.prepare(`
       SELECT * FROM decision_edges
       WHERE project_id = ? AND invalidated_at IS NOT NULL
       ORDER BY invalidated_at DESC
       LIMIT ?
-    `).all(e,t)}}export{p as Causality,g as staleFoundationWarning};
+    `).all(projectId, limit);
+    }
+}
+//# sourceMappingURL=causality.js.map