bilmem 0.1.0

package/dist/scanner/index.js

@@ -0,0 +1,3829 @@
+// src/scanner/filesystem.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+
+// src/core/knowledge.ts
+import { createHash } from "crypto";
+
+// src/core/quarantine.ts
+function determineInitialStage(knowledge) {
+  if (knowledge.type === "fact" || knowledge.type === "architecture" || knowledge.confidenceTier === "high" || knowledge.confidence !== void 0 && knowledge.confidence >= 0.85) {
+    return "active";
+  }
+  if (knowledge.type === "rule" && ((knowledge.evidence?.length ?? 0) >= 2 || knowledge.confidence !== void 0 && knowledge.confidence >= 0.75)) {
+    return "probation";
+  }
+  if (knowledge.confidence !== void 0 && knowledge.confidence >= 0.7) {
+    return "probation";
+  }
+  return "candidate";
+}
+function evaluatePromotion(knowledge) {
+  const stage = knowledge.stage ?? "candidate";
+  const supportCount = knowledge.metrics.support_count;
+  const reuseCount = knowledge.metrics.reuse_count;
+  const successCount = Math.max(knowledge.outcomesSummary?.successful ?? 0, knowledge.metrics.successful_outcomes ?? 0);
+  const misleadingCount = Math.max(knowledge.outcomesSummary?.misleading ?? 0, knowledge.metrics.failed_outcomes ?? 0);
+  if (stage === "candidate") {
+    if (supportCount >= 2 || knowledge.evidence && knowledge.evidence.length >= 2 || knowledge.confidence >= 0.85) {
+      return {
+        promoted: true,
+        newStage: "probation",
+        reason: `Supported by ${supportCount} sources / ${knowledge.evidence.length} evidence nodes`
+      };
+    }
+  } else if (stage === "probation") {
+    if (successCount > 0 && misleadingCount === 0 || reuseCount >= 2 && misleadingCount === 0) {
+      return {
+        promoted: true,
+        newStage: "active",
+        reason: `Verified by ${successCount} successful task outcomes and ${reuseCount} reuses`
+      };
+    }
+  }
+  return { promoted: false, newStage: stage };
+}
+function calculateKnowledgeValue(knowledge) {
+  const reuse = knowledge.metrics.reuse_count;
+  const success = knowledge.outcomesSummary?.successful ?? knowledge.metrics.successful_outcomes;
+  const misleading = knowledge.outcomesSummary?.misleading ?? knowledge.metrics.failed_outcomes;
+  const evidenceCount = Math.min(knowledge.evidence.length, 6);
+  const confidence = knowledge.confidence;
+  let value = reuse * 2.5 + success * 4 + evidenceCount * 1.5 + confidence * 2 - misleading * 5;
+  if (knowledge.status === "active") value += 5;
+  if (knowledge.status === "needs_revalidation") value -= 3;
+  if (knowledge.status === "contradicted") value -= 8;
+  if (knowledge.status === "stale") value -= 4;
+  if (knowledge.stage === "active") value += 3;
+  if (knowledge.stage === "candidate") value -= 1;
+  return Math.round(value * 10) / 10;
+}
+
+// src/core/knowledge.ts
+function tierToConfidence(tier) {
+  switch (tier) {
+    case "low":
+      return 0.5;
+    case "medium":
+      return 0.75;
+    case "high":
+      return 0.95;
+  }
+}
+function confidenceToTier(score) {
+  if (score >= 0.85) return "high";
+  if (score >= 0.65) return "medium";
+  return "low";
+}
+function hashString(input) {
+  return createHash("sha256").update(input.trim().toLowerCase()).digest("hex").slice(0, 16);
+}
+function createObservation(params) {
+  const provenance = params.provenance ?? {
+    type: "file",
+    path: params.source,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const contentForHash = `${params.source}:${params.claim}:${provenance.commit || provenance.timestamp || Date.now()}`;
+  const id = `obs_${hashString(contentForHash)}`;
+  return {
+    id,
+    source: params.source,
+    claim: params.claim.trim(),
+    provenance,
+    confidence: Math.min(1, Math.max(0, params.confidence ?? 0.8)),
+    positive: Array.from(new Set(params.positive?.map((p) => p.trim().toLowerCase()) ?? [])),
+    negative: Array.from(new Set(params.negative?.map((n) => n.trim().toLowerCase()) ?? [])),
+    details: params.details,
+    recordedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function createEvidence(observation, type = "supports") {
+  const sourceHash = hashString(observation.source);
+  const id = `evi_${sourceHash}`;
+  return {
+    id,
+    source: observation.source,
+    sourceHash,
+    observationIds: [observation.id],
+    type,
+    claim: observation.claim,
+    provenance: observation.provenance,
+    weight: 1,
+    firstObservedAt: observation.recordedAt,
+    lastObservedAt: observation.recordedAt
+  };
+}
+function createKnowledge(params) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const confidenceTier = params.confidenceTier ?? (params.confidence !== void 0 ? confidenceToTier(params.confidence) : void 0);
+  const confidence = params.confidence !== void 0 ? params.confidence : confidenceTier ? tierToConfidence(confidenceTier) : 0.85;
+  const dependsOn = new Set(params.depends_on ?? []);
+  if (params.evidence) {
+    for (const ev of params.evidence) {
+      if (ev.startsWith("file:") || ev.startsWith("test:") || ev.startsWith("code:")) {
+        dependsOn.add(ev);
+      } else if (ev.includes("/") || ev.endsWith(".json") || ev.endsWith(".yaml") || ev.endsWith(".yml")) {
+        dependsOn.add(`file:${ev}`);
+      }
+    }
+  }
+  const initialStage = params.stage ?? determineInitialStage({
+    type: params.type ?? "lesson",
+    evidence: params.evidence ?? [],
+    confidence
+  });
+  const status = params.status ?? (initialStage === "candidate" ? "candidate" : "active");
+  const history = params.history ?? [
+    {
+      timestamp: now,
+      stage: initialStage,
+      status,
+      reason: `Initial knowledge recorded (${params.type ?? "lesson"})`,
+      source: params.evidence?.[0]
+    }
+  ];
+  const knowledgeItem = {
+    id: params.id.trim(),
+    type: params.type ?? "lesson",
+    status,
+    stage: initialStage,
+    statement: params.statement.trim(),
+    positive: Array.from(new Set(params.positive?.map((p) => p.trim().toLowerCase()) ?? [])),
+    negative: Array.from(new Set(params.negative?.map((n) => n.trim().toLowerCase()) ?? [])),
+    relations: Array.from(new Set(params.relations?.map((r) => r.trim()) ?? [])),
+    depends_on: Array.from(dependsOn),
+    resolves: params.resolves ? Array.from(new Set(params.resolves.map((r) => r.trim()))) : void 0,
+    question: params.question?.trim(),
+    confidence: Math.min(1, Math.max(0, confidence)),
+    confidenceTier,
+    evidence: Array.from(new Set(params.evidence ?? [])),
+    scope: params.scope ?? "project",
+    tags: Array.from(new Set(params.tags?.map((t) => t.trim().toLowerCase()) ?? [])),
+    temporal: {
+      revision: 1
+    },
+    metrics: {
+      reuse_count: 0,
+      support_count: 1,
+      contradiction_count: 0,
+      successful_outcomes: 0,
+      failed_outcomes: 0
+    },
+    outcomesSummary: params.outcomesSummary ?? {
+      applied: 0,
+      successful: 0,
+      misleading: 0,
+      neutral: 0
+    },
+    history,
+    value: 0,
+    createdAt: now,
+    updatedAt: now
+  };
+  knowledgeItem.value = calculateKnowledgeValue(knowledgeItem);
+  return knowledgeItem;
+}
+function calculateEffectiveConfidence(knowledge) {
+  const m = knowledge.metrics;
+  const base = knowledge.confidence;
+  const evRatio = (m.support_count + 1) / (m.support_count + 3 * m.contradiction_count + 1);
+  const totalOutcomes = m.successful_outcomes + m.failed_outcomes;
+  let outRatio = 1;
+  let evWeight = 0.6;
+  let outWeight = 0.4;
+  if (totalOutcomes === 0) {
+    evWeight = 0.85;
+    outWeight = 0.15;
+  } else {
+    outRatio = (m.successful_outcomes + 1) / (totalOutcomes + 1);
+  }
+  const effective = base * (evWeight * evRatio + outWeight * outRatio);
+  return Math.round(Math.min(1, Math.max(0.05, effective)) * 100) / 100;
+}
+var knowledgeTokenCache = /* @__PURE__ */ new WeakMap();
+function tokenize(text) {
+  return new Set(
+    text.toLowerCase().replace(/[^a-z0-9_-]/g, " ").split(/\s+/).filter((t) => t.length > 2)
+  );
+}
+function getCachedTokens(k) {
+  let tokens = knowledgeTokenCache.get(k);
+  if (!tokens) {
+    tokens = tokenize(k.statement);
+    knowledgeTokenCache.set(k, tokens);
+  }
+  return tokens;
+}
+function jaccardSimilarity(setA, setB) {
+  if (setA.size === 0 && setB.size === 0) return 1;
+  let intersection = 0;
+  for (const item of setA) {
+    if (setB.has(item)) intersection++;
+  }
+  const union = setA.size + setB.size - intersection;
+  return union === 0 ? 0 : intersection / union;
+}
+var POLAR_ANTONYMS = [
+  ["enabled", "disabled"],
+  ["enable", "disable"],
+  ["active", "inactive"],
+  ["true", "false"],
+  ["on", "off"],
+  ["yes", "no"],
+  ["allowed", "disallowed"],
+  ["allowed", "prohibited"],
+  ["allowed", "forbidden"],
+  ["permit", "deny"],
+  ["allow", "forbid"],
+  ["allow", "prohibit"],
+  ["always", "never"],
+  ["should", "should not"],
+  ["must", "must not"],
+  ["required", "optional"],
+  ["required", "forbidden"],
+  ["valid", "invalid"],
+  ["safe", "unsafe"],
+  ["sync", "async"],
+  ["synchronous", "asynchronous"],
+  ["public", "private"]
+];
+var NEGATION_PATTERNS = [
+  /\bnot\b/i,
+  /\bnever\b/i,
+  /\bno\b/i,
+  /\bcannot\b/i,
+  /\bwithout\b/i,
+  /\bdisallow\b/i,
+  /\bforbid\b/i,
+  /\bprohibit\b/i,
+  /\bavoid\b/i
+];
+function detectPolarContradiction(stmtA, stmtB) {
+  const lowerA = stmtA.toLowerCase();
+  const lowerB = stmtB.toLowerCase();
+  for (const [pos, neg] of POLAR_ANTONYMS) {
+    const aHasPos = new RegExp(`\\b${pos}\\b`, "i").test(lowerA);
+    const aHasNeg = new RegExp(`\\b${neg}\\b`, "i").test(lowerA);
+    const bHasPos = new RegExp(`\\b${pos}\\b`, "i").test(lowerB);
+    const bHasNeg = new RegExp(`\\b${neg}\\b`, "i").test(lowerB);
+    if (aHasPos && bHasNeg || aHasNeg && bHasPos) {
+      return {
+        contradicted: true,
+        reason: `Polar opposite terms detected: '${pos}' vs '${neg}'`
+      };
+    }
+  }
+  const aHasNegation = NEGATION_PATTERNS.some((p) => p.test(lowerA));
+  const bHasNegation = NEGATION_PATTERNS.some((p) => p.test(lowerB));
+  if (aHasNegation !== bHasNegation) {
+    return {
+      contradicted: true,
+      reason: "Asymmetric negation detected (one statement asserts, the other negates)"
+    };
+  }
+  return { contradicted: false };
+}
+function reconcileKnowledge(candidate, existingList) {
+  const candidateId = candidate.id?.trim();
+  const candidateStmt = candidate.statement.trim();
+  const candidateTokens = tokenize(candidateStmt);
+  const candidatePos = new Set((candidate.positive ?? []).map((p) => p.trim().toLowerCase()));
+  if (candidateId) {
+    const directMatch = existingList.find((k) => k.id === candidateId);
+    if (directMatch) {
+      if (directMatch.statement.trim().toLowerCase() === candidateStmt.toLowerCase()) {
+        const hasNewEvidence = (candidate.evidence ?? []).some((e) => !directMatch.evidence.includes(e));
+        if (!hasNewEvidence) {
+          return {
+            action: "IGNORE",
+            targetId: directMatch.id,
+            knowledge: directMatch,
+            reason: "Identical statement and evidence already recorded"
+          };
+        }
+        return {
+          action: "SUPPORT",
+          targetId: directMatch.id,
+          knowledge: directMatch,
+          reason: "Confirms existing knowledge with new evidence source"
+        };
+      }
+      const opposingPositive = (candidate.negative ?? []).some((n) => directMatch.positive.includes(n));
+      const opposingNegative = (candidate.positive ?? []).some((p) => directMatch.negative.includes(p));
+      const polarCheck = detectPolarContradiction(candidateStmt, directMatch.statement);
+      if (opposingPositive || opposingNegative || polarCheck.contradicted) {
+        const distinctCues = Array.from(candidatePos).filter((c) => !directMatch.positive.includes(c));
+        const mentionsEnvA = /(development|dev|local|staging|test)/i.test(candidateStmt);
+        const mentionsEnvB = /(production|prod)/i.test(directMatch.statement);
+        const mentionsEnvBDev = /(development|dev|local|staging|test)/i.test(directMatch.statement);
+        const mentionsEnvAProd = /(production|prod)/i.test(candidateStmt);
+        if (distinctCues.length > 0 || mentionsEnvA && mentionsEnvB || mentionsEnvBDev && mentionsEnvAProd) {
+          return {
+            action: "SPECIALIZE",
+            targetId: directMatch.id,
+            knowledge: directMatch,
+            reason: `Conflicting claim applies under specialized context cues: [${distinctCues.join(", ")}] (${polarCheck.reason || "opposing polarity"})`
+          };
+        }
+        return {
+          action: "CONTRADICT",
+          targetId: directMatch.id,
+          knowledge: directMatch,
+          reason: `Contradicts existing statement (${polarCheck.reason || "opposing polarity"}) for ID "${directMatch.id}"`
+        };
+      }
+      return {
+        action: "UPDATE",
+        targetId: directMatch.id,
+        knowledge: directMatch,
+        reason: "Refines or updates existing knowledge statement"
+      };
+    }
+  }
+  let bestMatch = null;
+  let bestSim = 0;
+  let bestPolarCheck = { contradicted: false };
+  for (const existing of existingList) {
+    const existingTokens = getCachedTokens(existing);
+    const sim = jaccardSimilarity(candidateTokens, existingTokens);
+    const polarCheck = detectPolarContradiction(candidateStmt, existing.statement);
+    if (polarCheck.contradicted) {
+      let sharedCount = 0;
+      for (const t of candidateTokens) {
+        if (existingTokens.has(t)) sharedCount++;
+      }
+      const sharedCues = (candidate.positive ?? []).filter((p) => existing.positive.includes(p));
+      if (sharedCount >= 2 || sharedCues.length >= 1 && sim >= 0.35 || sim >= 0.4) {
+        bestMatch = existing;
+        bestSim = Math.max(sim, 0.85);
+        bestPolarCheck = polarCheck;
+        break;
+      }
+    }
+    if (sim > bestSim) {
+      bestSim = sim;
+      bestMatch = existing;
+      bestPolarCheck = polarCheck;
+    }
+  }
+  if (bestMatch && bestSim >= 0.7) {
+    const polarCheck = bestPolarCheck.contradicted ? bestPolarCheck : detectPolarContradiction(candidateStmt, bestMatch.statement);
+    const hasOpposingCues = (candidate.negative ?? []).some((n) => bestMatch.positive.includes(n)) || (candidate.positive ?? []).some((p) => bestMatch.negative.includes(p));
+    if (polarCheck.contradicted || hasOpposingCues) {
+      const distinctCues = Array.from(candidatePos).filter((c) => !bestMatch.positive.includes(c));
+      const mentionsEnvA = /(development|dev|local|staging|test)/i.test(candidateStmt);
+      const mentionsEnvB = /(production|prod)/i.test(bestMatch.statement);
+      const mentionsEnvBDev = /(development|dev|local|staging|test)/i.test(bestMatch.statement);
+      const mentionsEnvAProd = /(production|prod)/i.test(candidateStmt);
+      if (distinctCues.length > 0 || mentionsEnvA && mentionsEnvB || mentionsEnvBDev && mentionsEnvAProd) {
+        return {
+          action: "SPECIALIZE",
+          targetId: bestMatch.id,
+          knowledge: bestMatch,
+          reason: `High textual similarity (${Math.round(bestSim * 100)}%) with polar distinction across contexts (${polarCheck.reason || "opposing cues"})`,
+          score: bestSim
+        };
+      }
+      return {
+        action: "CONTRADICT",
+        targetId: bestMatch.id,
+        knowledge: bestMatch,
+        reason: `Contradicting statement (${polarCheck.reason || "opposing cues"}) despite high textual similarity (${Math.round(bestSim * 100)}%)`,
+        score: bestSim
+      };
+    }
+    if (bestSim >= 0.9) {
+      return {
+        action: "MERGE",
+        targetId: bestMatch.id,
+        knowledge: bestMatch,
+        reason: `Nearly identical statement (${Math.round(bestSim * 100)}% match) with compatible polarity; merging cues and evidence`,
+        score: bestSim
+      };
+    }
+    return {
+      action: "SUPPORT",
+      targetId: bestMatch.id,
+      knowledge: bestMatch,
+      reason: `Supports existing knowledge (${Math.round(bestSim * 100)}% similarity) with compatible polarity`,
+      score: bestSim
+    };
+  }
+  return {
+    action: "NEW",
+    reason: "No conflicting or matching knowledge found; creating new knowledge entry"
+  };
+}
+function applyReconciliation(reconciliation, candidate, existingList, storage) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  switch (reconciliation.action) {
+    case "SUPPORT": {
+      const target = existingList.find((k) => k.id === reconciliation.targetId);
+      target.metrics.support_count++;
+      target.metrics.last_used = now;
+      storage?.appendMetricEvent({
+        type: "knowledge_strengthened",
+        knowledgeId: target.id,
+        timestamp: Date.now()
+      });
+      if (candidate.evidence) {
+        for (const e of candidate.evidence) {
+          if (!target.evidence.includes(e)) {
+            target.evidence.push(e);
+          }
+        }
+      }
+      if (candidate.positive) {
+        for (const p of candidate.positive) {
+          const lp = p.trim().toLowerCase();
+          if (!target.positive.includes(lp)) target.positive.push(lp);
+        }
+      }
+      if (!target.history) {
+        target.history = [
+          {
+            timestamp: target.createdAt || now,
+            stage: target.stage,
+            status: target.status,
+            reason: "Initial knowledge recorded",
+            source: target.evidence?.[0]
+          }
+        ];
+      }
+      const promotion = evaluatePromotion(target);
+      if (promotion.promoted && promotion.newStage) {
+        target.stage = promotion.newStage;
+        if (target.stage === "active" && target.status === "candidate") {
+          target.status = "active";
+        }
+        target.history.push({
+          timestamp: now,
+          stage: target.stage,
+          status: target.status,
+          reason: promotion.reason || `Promoted to ${target.stage}`,
+          source: candidate.evidence?.[0]
+        });
+      } else {
+        target.history.push({
+          timestamp: now,
+          stage: target.stage,
+          status: target.status,
+          reason: reconciliation.reason || "Confirmed with supporting evidence",
+          source: candidate.evidence?.[0]
+        });
+      }
+      target.confidence = calculateEffectiveConfidence(target);
+      target.value = calculateKnowledgeValue(target);
+      target.updatedAt = now;
+      return { updatedKnowledge: target, action: "SUPPORT", createdId: target.id };
+    }
+    case "MERGE": {
+      const target = existingList.find((k) => k.id === reconciliation.targetId);
+      target.metrics.support_count++;
+      target.metrics.last_used = now;
+      storage?.appendMetricEvent({
+        type: "knowledge_merged",
+        knowledgeId: target.id,
+        targetId: reconciliation.targetId,
+        timestamp: Date.now()
+      });
+      if (candidate.evidence) {
+        for (const e of candidate.evidence) {
+          if (!target.evidence.includes(e)) target.evidence.push(e);
+        }
+      }
+      if (candidate.positive) {
+        for (const p of candidate.positive) {
+          const lp = p.trim().toLowerCase();
+          if (!target.positive.includes(lp)) target.positive.push(lp);
+        }
+      }
+      if (candidate.negative) {
+        for (const n of candidate.negative) {
+          const ln = n.trim().toLowerCase();
+          if (!target.negative.includes(ln)) target.negative.push(ln);
+        }
+      }
+      if (!target.history) {
+        target.history = [
+          {
+            timestamp: target.createdAt || now,
+            stage: target.stage,
+            status: target.status,
+            reason: "Initial knowledge recorded",
+            source: target.evidence?.[0]
+          }
+        ];
+      }
+      const promotion = evaluatePromotion(target);
+      if (promotion.promoted && promotion.newStage) {
+        target.stage = promotion.newStage;
+        if (target.stage === "active" && target.status === "candidate") {
+          target.status = "active";
+        }
+        target.history.push({
+          timestamp: now,
+          stage: target.stage,
+          status: target.status,
+          reason: promotion.reason || `Promoted to ${target.stage}`,
+          source: candidate.evidence?.[0]
+        });
+      } else {
+        target.history.push({
+          timestamp: now,
+          stage: target.stage,
+          status: target.status,
+          reason: reconciliation.reason || "Merged with compatible knowledge candidate",
+          source: candidate.evidence?.[0]
+        });
+      }
+      target.confidence = calculateEffectiveConfidence(target);
+      target.value = calculateKnowledgeValue(target);
+      target.updatedAt = now;
+      return { updatedKnowledge: target, action: "MERGE", createdId: target.id };
+    }
+    case "UPDATE": {
+      const target = existingList.find((k) => k.id === reconciliation.targetId);
+      target.statement = candidate.statement;
+      if (candidate.type) target.type = candidate.type;
+      if (candidate.positive) {
+        target.positive = Array.from(/* @__PURE__ */ new Set([...target.positive, ...candidate.positive.map((p) => p.toLowerCase())]));
+      }
+      if (candidate.negative) {
+        target.negative = Array.from(/* @__PURE__ */ new Set([...target.negative, ...candidate.negative.map((n) => n.toLowerCase())]));
+      }
+      if (candidate.evidence) {
+        target.evidence = Array.from(/* @__PURE__ */ new Set([...target.evidence, ...candidate.evidence]));
+      }
+      target.temporal = {
+        revision: (target.temporal?.revision ?? 1) + 1,
+        valid_from: { timestamp: now }
+      };
+      if (!target.history) {
+        target.history = [
+          {
+            timestamp: target.createdAt || now,
+            stage: target.stage,
+            status: target.status,
+            reason: "Initial knowledge recorded",
+            source: target.evidence?.[0]
+          }
+        ];
+      }
+      target.history.push({
+        timestamp: now,
+        stage: target.stage,
+        status: target.status,
+        reason: reconciliation.reason || "Updated statement and context",
+        source: candidate.evidence?.[0]
+      });
+      target.updatedAt = now;
+      target.confidence = calculateEffectiveConfidence(target);
+      target.value = calculateKnowledgeValue(target);
+      storage?.appendMetricEvent({
+        type: "knowledge_strengthened",
+        knowledgeId: target.id,
+        timestamp: Date.now()
+      });
+      return { updatedKnowledge: target, action: "UPDATE", createdId: target.id };
+    }
+    case "CONTRADICT": {
+      const target = existingList.find((k) => k.id === reconciliation.targetId);
+      target.metrics.contradiction_count++;
+      if (candidate.evidence) {
+        for (const e of candidate.evidence) {
+          if (!target.evidence.includes(e)) target.evidence.push(e);
+        }
+      }
+      if (target.metrics.contradiction_count > target.metrics.support_count) {
+        target.status = "contradicted";
+      }
+      if (!target.history) {
+        target.history = [
+          {
+            timestamp: target.createdAt || now,
+            stage: target.stage,
+            status: target.status,
+            reason: "Initial knowledge recorded",
+            source: target.evidence?.[0]
+          }
+        ];
+      }
+      target.history.push({
+        timestamp: now,
+        stage: target.stage,
+        status: target.status,
+        reason: reconciliation.reason || "Contradicted by opposing claim",
+        source: candidate.evidence?.[0]
+      });
+      target.confidence = calculateEffectiveConfidence(target);
+      target.value = calculateKnowledgeValue(target);
+      target.updatedAt = now;
+      storage?.appendMetricEvent({
+        type: "contradiction_detected",
+        knowledgeId: target.id,
+        timestamp: Date.now()
+      });
+      return { updatedKnowledge: target, action: "CONTRADICT", createdId: target.id };
+    }
+    case "SPECIALIZE": {
+      const parent = existingList.find((k) => k.id === reconciliation.targetId);
+      const subContext = candidate.positive?.[0] || "specialized";
+      const newId = candidate.id && candidate.id !== parent?.id ? candidate.id : `${parent ? parent.id : "knowledge"}.${subContext}`;
+      const created = createKnowledge({
+        id: newId,
+        type: candidate.type ?? parent?.type ?? "lesson",
+        statement: candidate.statement,
+        positive: candidate.positive ?? [],
+        negative: candidate.negative ?? [],
+        relations: parent ? [parent.id, ...candidate.relations ?? []] : candidate.relations ?? [],
+        confidence: candidate.confidence ?? 0.85,
+        evidence: candidate.evidence ?? [],
+        scope: candidate.scope ?? parent?.scope ?? "project",
+        tags: candidate.tags ?? parent?.tags ?? []
+      });
+      if (parent) {
+        if (!parent.relations.includes(newId)) {
+          parent.relations.push(newId);
+        }
+        if (!parent.history) {
+          parent.history = [
+            {
+              timestamp: parent.createdAt || now,
+              stage: parent.stage,
+              status: parent.status,
+              reason: "Initial knowledge recorded"
+            }
+          ];
+        }
+        parent.history.push({
+          timestamp: now,
+          stage: parent.stage,
+          status: parent.status,
+          reason: `Specialized into contextual branch ${newId}`
+        });
+      }
+      storage?.appendMetricEvent({
+        type: "knowledge_specialized",
+        knowledgeId: created.id,
+        timestamp: Date.now()
+      });
+      return { updatedKnowledge: created, action: "SPECIALIZE", createdId: created.id };
+    }
+    case "IGNORE": {
+      const target = existingList.find((k) => k.id === reconciliation.targetId);
+      storage?.appendMetricEvent({
+        type: "duplicate_ignored",
+        timestamp: Date.now()
+      });
+      return { updatedKnowledge: target, action: "IGNORE", createdId: target.id };
+    }
+    case "NEW":
+    default: {
+      const newId = candidate.id || `kn_${hashString(candidate.statement)}`;
+      const created = createKnowledge({
+        id: newId,
+        type: candidate.type,
+        statement: candidate.statement,
+        positive: candidate.positive,
+        negative: candidate.negative,
+        relations: candidate.relations,
+        confidence: candidate.confidence,
+        evidence: candidate.evidence,
+        scope: candidate.scope,
+        tags: candidate.tags
+      });
+      storage?.appendMetricEvent({
+        type: "knowledge_created",
+        knowledgeId: created.id,
+        timestamp: Date.now()
+      });
+      return { updatedKnowledge: created, action: "NEW", createdId: created.id };
+    }
+  }
+}
+
+// src/scanner/filesystem.ts
+var DEFAULT_IGNORED_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  ".bilmem",
+  "node_modules",
+  "dist",
+  "build",
+  "target",
+  "vendor",
+  ".cache",
+  ".idea",
+  ".vscode",
+  "coverage",
+  ".next",
+  ".nuxt",
+  ".turbo",
+  ".output",
+  "tmp",
+  "temp"
+]);
+function normalizeRelPath(rel) {
+  return rel.split(path.sep).join("/");
+}
+async function loadGitignorePatterns(rootDir) {
+  try {
+    const gitignorePath = path.join(rootDir, ".gitignore");
+    const content = await fs.readFile(gitignorePath, "utf-8");
+    const regexes = [];
+    for (const rawLine of content.split("\n")) {
+      const line = rawLine.trim();
+      if (!line || line.startsWith("#")) continue;
+      let pattern = line.replace(/^\//, "").replace(/\/$/, "");
+      if (!pattern) continue;
+      pattern = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+      pattern = pattern.replace(/\*\*/g, ".*");
+      pattern = pattern.replace(/\*/g, "[^/]*");
+      pattern = pattern.replace(/\?/g, "[^/]");
+      try {
+        regexes.push(new RegExp(`(^|/)${pattern}($|/)`));
+      } catch {
+      }
+    }
+    return regexes;
+  } catch {
+    return [];
+  }
+}
+async function walkDirectory(dir, optionsOrRoot, legacyFileList) {
+  let root;
+  let options;
+  if (typeof optionsOrRoot === "string") {
+    root = optionsOrRoot;
+    options = {};
+  } else {
+    options = optionsOrRoot ?? {};
+    root = dir;
+  }
+  const fileList = legacyFileList ?? [];
+  const maxDepth = options.maxDepth ?? 15;
+  const maxFiles = options.maxFiles ?? 25e3;
+  const includeHidden = options.includeHidden ?? false;
+  const ignoredDirs = new Set(DEFAULT_IGNORED_DIRS);
+  if (options.ignoredDirs) {
+    for (const d of options.ignoredDirs) {
+      ignoredDirs.add(d.toLowerCase());
+    }
+  }
+  const gitignoreRules = options.readGitignore !== false ? await loadGitignorePatterns(root) : [];
+  const visitedRealPaths = /* @__PURE__ */ new Set();
+  async function walk(currentDir, currentDepth) {
+    if (currentDepth > maxDepth || fileList.length >= maxFiles) {
+      return;
+    }
+    try {
+      const real = await fs.realpath(currentDir);
+      if (visitedRealPaths.has(real)) {
+        return;
+      }
+      visitedRealPaths.add(real);
+    } catch {
+      return;
+    }
+    let entries;
+    try {
+      entries = await fs.readdir(currentDir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (fileList.length >= maxFiles) break;
+      const fullPath = path.join(currentDir, entry.name);
+      const rawRelPath = path.relative(root, fullPath);
+      const relPath = normalizeRelPath(rawRelPath);
+      const lowerName = entry.name.toLowerCase();
+      if (gitignoreRules.some((rule) => rule.test(relPath))) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        if (ignoredDirs.has(lowerName)) continue;
+        if (!includeHidden && entry.name.startsWith(".") && lowerName !== ".github") {
+          continue;
+        }
+        await walk(fullPath, currentDepth + 1);
+      } else if (entry.isFile()) {
+        if (!includeHidden && entry.name.startsWith(".") && lowerName !== ".env.example") {
+          continue;
+        }
+        const ext = path.extname(entry.name).toLowerCase();
+        try {
+          const stat3 = await fs.stat(fullPath);
+          const fileInfo = {
+            path: fullPath,
+            relativePath: relPath,
+            name: entry.name,
+            ext,
+            size: stat3.size,
+            mtimeMs: stat3.mtimeMs,
+            isDirectory: false
+          };
+          if (!options.filter || options.filter(fileInfo)) {
+            fileList.push(fileInfo);
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  await walk(dir, 0);
+  return fileList;
+}
+var ProjectContext = class {
+  rootDir;
+  files;
+  relPathSet;
+  fileNameSet;
+  textCache = /* @__PURE__ */ new Map();
+  jsonCache = /* @__PURE__ */ new Map();
+  constructor(files, rootDir) {
+    this.rootDir = rootDir;
+    this.files = files;
+    this.relPathSet = new Set(files.map((f) => f.relativePath.toLowerCase()));
+    this.fileNameSet = new Set(files.map((f) => f.name.toLowerCase()));
+  }
+  hasFile(nameOrRelPath) {
+    const lower = normalizeRelPath(nameOrRelPath).toLowerCase();
+    return this.fileNameSet.has(lower) || this.relPathSet.has(lower);
+  }
+  hasDirectory(dirNameOrRelPath) {
+    const prefix = normalizeRelPath(dirNameOrRelPath).toLowerCase().replace(/\/$/, "") + "/";
+    return Array.from(this.relPathSet).some((p) => p.startsWith(prefix));
+  }
+  findFiles(predicate) {
+    return this.files.filter(predicate);
+  }
+  async readText(relativePath, maxBytes = 64 * 1024) {
+    const key = normalizeRelPath(relativePath).toLowerCase();
+    if (this.textCache.has(key)) {
+      return this.textCache.get(key);
+    }
+    const fullPath = path.resolve(this.rootDir, relativePath);
+    try {
+      const handle = await fs.open(fullPath, "r");
+      const buffer = Buffer.alloc(maxBytes);
+      const { bytesRead } = await handle.read(buffer, 0, maxBytes, 0);
+      await handle.close();
+      const content = buffer.toString("utf-8", 0, bytesRead);
+      this.textCache.set(key, content);
+      return content;
+    } catch {
+      this.textCache.set(key, null);
+      return null;
+    }
+  }
+  async readJson(relativePath) {
+    const key = normalizeRelPath(relativePath).toLowerCase();
+    if (this.jsonCache.has(key)) {
+      return this.jsonCache.get(key);
+    }
+    const text = await this.readText(relativePath);
+    if (!text) {
+      this.jsonCache.set(key, null);
+      return null;
+    }
+    try {
+      const parsed = JSON.parse(text);
+      this.jsonCache.set(key, parsed);
+      return parsed;
+    } catch {
+      this.jsonCache.set(key, null);
+      return null;
+    }
+  }
+};
+var ConventionRegistry = class {
+  detectors = /* @__PURE__ */ new Map();
+  register(detector) {
+    this.detectors.set(detector.id, detector);
+    return this;
+  }
+  unregister(id) {
+    return this.detectors.delete(id);
+  }
+  get(id) {
+    return this.detectors.get(id);
+  }
+  list() {
+    return Array.from(this.detectors.values());
+  }
+  async run(ctx) {
+    const observations = [];
+    for (const detector of this.detectors.values()) {
+      try {
+        const result = await detector.detect(ctx);
+        if (result) {
+          if (Array.isArray(result)) {
+            observations.push(...result);
+          } else {
+            observations.push(result);
+          }
+        }
+      } catch {
+      }
+    }
+    return observations;
+  }
+};
+var BUILTIN_DETECTORS = [
+  // 1. Node.js & package.json
+  {
+    id: "node-manifest",
+    name: "Node.js Manifest Detector",
+    category: "runtime",
+    async detect(ctx) {
+      if (!ctx.hasFile("package.json")) return null;
+      const pkg = await ctx.readJson("package.json");
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const scripts = pkg?.scripts ? Object.keys(pkg.scripts) : [];
+      const isEsm = pkg?.type === "module";
+      const scriptSummary = scripts.length > 0 ? ` with scripts: ${scripts.slice(0, 5).join(", ")}` : "";
+      const moduleType = isEsm ? " (ESM module)" : " (CommonJS)";
+      return createObservation({
+        source: "filesystem:package.json",
+        claim: `Project utilizes Node.js ecosystem with package.json manifest${moduleType}${scriptSummary}`,
+        provenance: { type: "file", path: "package.json", timestamp: now },
+        confidence: 0.99,
+        positive: ["node", "npm", "javascript", isEsm ? "esm" : "cjs", ...pkg?.name ? [pkg.name.toLowerCase()] : []],
+        details: {
+          ecosystem: "node",
+          name: pkg?.name,
+          version: pkg?.version,
+          type: pkg?.type,
+          scripts
+        }
+      });
+    }
+  },
+  // 2. Package Manager
+  {
+    id: "package-manager",
+    name: "Package Manager Detector",
+    category: "package-manager",
+    detect(ctx) {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      if (ctx.hasFile("pnpm-lock.yaml")) {
+        return createObservation({
+          source: "filesystem:pnpm-lock.yaml",
+          claim: "Project utilizes pnpm as the package manager",
+          provenance: { type: "file", path: "pnpm-lock.yaml", timestamp: now },
+          confidence: 0.99,
+          positive: ["pnpm", "package-manager", "node"]
+        });
+      }
+      if (ctx.hasFile("bun.lockb") || ctx.hasFile("bun.lock")) {
+        return createObservation({
+          source: "filesystem:bun.lock",
+          claim: "Project utilizes Bun runtime and package manager",
+          provenance: { type: "file", path: "bun.lock", timestamp: now },
+          confidence: 0.99,
+          positive: ["bun", "package-manager"]
+        });
+      }
+      if (ctx.hasFile("yarn.lock")) {
+        return createObservation({
+          source: "filesystem:yarn.lock",
+          claim: "Project utilizes Yarn package manager",
+          provenance: { type: "file", path: "yarn.lock", timestamp: now },
+          confidence: 0.99,
+          positive: ["yarn", "package-manager", "node"]
+        });
+      }
+      if (ctx.hasFile("package-lock.json")) {
+        return createObservation({
+          source: "filesystem:package-lock.json",
+          claim: "Project utilizes npm as package manager with package-lock.json",
+          provenance: { type: "file", path: "package-lock.json", timestamp: now },
+          confidence: 0.95,
+          positive: ["npm", "package-manager", "node"]
+        });
+      }
+      return null;
+    }
+  },
+  // 3. TypeScript Configuration
+  {
+    id: "typescript-config",
+    name: "TypeScript Compiler Detector",
+    category: "language",
+    async detect(ctx) {
+      if (!ctx.hasFile("tsconfig.json")) return null;
+      const tsconfig = await ctx.readJson("tsconfig.json");
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const opts = tsconfig?.compilerOptions;
+      const targetStr = opts?.target ? ` target ${opts.target}` : "";
+      const strictStr = opts?.strict ? " with strict mode" : "";
+      return createObservation({
+        source: "filesystem:tsconfig.json",
+        claim: `Project is configured for TypeScript compilation${targetStr}${strictStr}`,
+        provenance: { type: "file", path: "tsconfig.json", timestamp: now },
+        confidence: 0.99,
+        positive: ["typescript", "ts", ...opts?.target ? [opts.target.toLowerCase()] : []],
+        details: { language: "typescript", target: opts?.target, strict: opts?.strict }
+      });
+    }
+  },
+  // 4. Rust & Cargo
+  {
+    id: "rust-cargo",
+    name: "Rust & Cargo Detector",
+    category: "language",
+    async detect(ctx) {
+      if (!ctx.hasFile("cargo.toml")) return null;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const cargoText = await ctx.readText("Cargo.toml");
+      const isWorkspace = cargoText?.includes("[workspace]") ?? false;
+      const claim = isWorkspace ? "Project utilizes Rust with Cargo workspace configuration" : "Project utilizes Rust and Cargo";
+      return createObservation({
+        source: "filesystem:cargo.toml",
+        claim,
+        provenance: { type: "file", path: "Cargo.toml", timestamp: now },
+        confidence: 0.99,
+        positive: ["rust", "cargo", ...isWorkspace ? ["workspace"] : []],
+        details: { ecosystem: "rust", isWorkspace }
+      });
+    }
+  },
+  // 5. Go Modules
+  {
+    id: "go-module",
+    name: "Go Modules Detector",
+    category: "language",
+    async detect(ctx) {
+      if (!ctx.hasFile("go.mod")) return null;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const goModText = await ctx.readText("go.mod");
+      const modMatch = goModText?.match(/^module\s+([^\s]+)/m);
+      const modName = modMatch ? ` (${modMatch[1]})` : "";
+      return createObservation({
+        source: "filesystem:go.mod",
+        claim: `Project utilizes Go modules${modName}`,
+        provenance: { type: "file", path: "go.mod", timestamp: now },
+        confidence: 0.99,
+        positive: ["go", "golang"],
+        details: { ecosystem: "go", module: modMatch ? modMatch[1] : void 0 }
+      });
+    }
+  },
+  // 6. Python Environment
+  {
+    id: "python-project",
+    name: "Python Environment Detector",
+    category: "language",
+    detect(ctx) {
+      const hasPyproject = ctx.hasFile("pyproject.toml");
+      const hasReqs = ctx.hasFile("requirements.txt");
+      const hasPipfile = ctx.hasFile("pipfile");
+      const hasUvLock = ctx.hasFile("uv.lock");
+      const hasPoetry = ctx.hasFile("poetry.lock");
+      if (!hasPyproject && !hasReqs && !hasPipfile && !hasUvLock && !hasPoetry) {
+        return null;
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const tools = [];
+      if (hasUvLock) tools.push("uv");
+      if (hasPoetry) tools.push("poetry");
+      if (hasPyproject) tools.push("pyproject.toml");
+      if (hasReqs) tools.push("requirements.txt");
+      return createObservation({
+        source: "filesystem:python",
+        claim: `Project contains Python dependencies (${tools.join(", ")})`,
+        provenance: {
+          type: "file",
+          path: hasPyproject ? "pyproject.toml" : hasReqs ? "requirements.txt" : "uv.lock",
+          timestamp: now
+        },
+        confidence: 0.95,
+        positive: ["python", "py", ...tools],
+        details: { ecosystem: "python", tools }
+      });
+    }
+  },
+  // 7. Monorepo & Workspaces
+  {
+    id: "monorepo",
+    name: "Monorepo Workspace Detector",
+    category: "monorepo",
+    detect(ctx) {
+      const hasTurbo = ctx.hasFile("turbo.json");
+      const hasNx = ctx.hasFile("nx.json");
+      const hasPnpmWs = ctx.hasFile("pnpm-workspace.yaml");
+      const hasLerna = ctx.hasFile("lerna.json");
+      if (!hasTurbo && !hasNx && !hasPnpmWs && !hasLerna) {
+        return null;
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const tools = [];
+      if (hasTurbo) tools.push("turborepo");
+      if (hasNx) tools.push("nx");
+      if (hasPnpmWs) tools.push("pnpm-workspaces");
+      if (hasLerna) tools.push("lerna");
+      return createObservation({
+        source: "filesystem:monorepo",
+        claim: `Project is structured as a monorepo workspace managed by ${tools.join(", ")}`,
+        provenance: { type: "file", path: hasTurbo ? "turbo.json" : hasPnpmWs ? "pnpm-workspace.yaml" : "nx.json", timestamp: now },
+        confidence: 0.95,
+        positive: ["monorepo", "workspace", ...tools]
+      });
+    }
+  },
+  // 8. Testing Suites
+  {
+    id: "testing-suite",
+    name: "Testing Suite & Framework Detector",
+    category: "testing",
+    detect(ctx) {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const hasVitest = ctx.hasFile("vitest.config.ts") || ctx.hasFile("vitest.config.js") || ctx.hasFile("vitest.config.mts");
+      const hasJest = ctx.hasFile("jest.config.js") || ctx.hasFile("jest.config.ts");
+      const hasPlaywright = ctx.hasFile("playwright.config.ts") || ctx.hasFile("playwright.config.js");
+      const hasPytest = ctx.hasFile("pytest.ini") || ctx.hasFile("conftest.py");
+      const testFiles = ctx.findFiles(
+        (f) => f.relativePath.includes("test") || f.relativePath.includes("spec") || f.name.endsWith(".test.ts") || f.name.endsWith(".spec.ts") || f.name.endsWith(".test.js") || f.name.endsWith("_test.go") || f.name.startsWith("test_")
+      );
+      if (!hasVitest && !hasJest && !hasPlaywright && !hasPytest && testFiles.length === 0) {
+        return null;
+      }
+      const frameworks = [];
+      if (hasVitest) frameworks.push("Vitest");
+      if (hasJest) frameworks.push("Jest");
+      if (hasPlaywright) frameworks.push("Playwright");
+      if (hasPytest) frameworks.push("Pytest");
+      const fwStr = frameworks.length > 0 ? ` (${frameworks.join(", ")})` : "";
+      return createObservation({
+        source: "filesystem:tests",
+        claim: `Project includes automated test suite${fwStr} with ${testFiles.length} test files detected`,
+        provenance: { type: "file", path: "test", timestamp: now },
+        confidence: 0.95,
+        positive: ["tests", "testing", "qa", ...frameworks.map((f) => f.toLowerCase())],
+        details: { testFilesCount: testFiles.length, frameworks }
+      });
+    }
+  },
+  // 9. Database & ORM
+  {
+    id: "database-orm",
+    name: "Database & Schema Detector",
+    category: "database",
+    detect(ctx) {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const hasPrisma = ctx.hasFile("schema.prisma") || ctx.hasDirectory("prisma");
+      const hasDrizzle = ctx.hasFile("drizzle.config.ts") || ctx.hasFile("drizzle.config.js");
+      const hasMigrations = ctx.hasDirectory("migrations") || ctx.hasDirectory("db/migrations");
+      if (!hasPrisma && !hasDrizzle && !hasMigrations) {
+        return null;
+      }
+      const tools = [];
+      if (hasPrisma) tools.push("Prisma");
+      if (hasDrizzle) tools.push("Drizzle");
+      if (hasMigrations) tools.push("SQL Migrations");
+      return createObservation({
+        source: "filesystem:database",
+        claim: `Project includes database schema and migration tooling: ${tools.join(", ")}`,
+        provenance: { type: "file", path: hasPrisma ? "prisma/schema.prisma" : "migrations", timestamp: now },
+        confidence: 0.92,
+        positive: ["database", "orm", "migrations", ...tools.map((t) => t.toLowerCase())]
+      });
+    }
+  },
+  // 10. Container & DevOps
+  {
+    id: "container-devops",
+    name: "Container & Docker Detector",
+    category: "tooling",
+    detect(ctx) {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const hasDockerfile = ctx.hasFile("dockerfile");
+      const hasCompose = ctx.hasFile("docker-compose.yml") || ctx.hasFile("compose.yaml") || ctx.hasFile("docker-compose.yaml");
+      if (!hasDockerfile && !hasCompose) return null;
+      return createObservation({
+        source: "filesystem:docker",
+        claim: "Project includes Docker container configuration",
+        provenance: { type: "file", path: hasDockerfile ? "Dockerfile" : "docker-compose.yml", timestamp: now },
+        confidence: 0.95,
+        positive: ["docker", "containers", "devops"]
+      });
+    }
+  },
+  // 11. CI/CD Workflows
+  {
+    id: "ci-cd",
+    name: "CI/CD Workflow Detector",
+    category: "ci-cd",
+    detect(ctx) {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const ghWorkflows = ctx.findFiles((f) => f.relativePath.startsWith(".github/workflows/"));
+      const hasGitlab = ctx.hasFile(".gitlab-ci.yml");
+      if (ghWorkflows.length === 0 && !hasGitlab) return null;
+      const claim = ghWorkflows.length > 0 ? `Project configures GitHub Actions CI/CD workflows (${ghWorkflows.length} workflow files)` : "Project configures GitLab CI pipeline";
+      return createObservation({
+        source: "filesystem:ci",
+        claim,
+        provenance: { type: "file", path: ghWorkflows.length > 0 ? ".github/workflows" : ".gitlab-ci.yml", timestamp: now },
+        confidence: 0.95,
+        positive: ["ci", "github-actions", "automation"]
+      });
+    }
+  },
+  // 12. Documentation
+  {
+    id: "documentation",
+    name: "Project Documentation Detector",
+    category: "documentation",
+    detect(ctx) {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const hasReadme = ctx.hasFile("readme.md");
+      const hasDocs = ctx.hasDirectory("docs");
+      const hasContributing = ctx.hasFile("contributing.md");
+      if (!hasReadme && !hasDocs && !hasContributing) return null;
+      return createObservation({
+        source: "filesystem:readme.md",
+        claim: "Root README.md is present for project documentation",
+        provenance: { type: "file", path: "README.md", timestamp: now },
+        confidence: 0.95,
+        positive: ["documentation", "readme"]
+      });
+    }
+  },
+  // 13. Architecture & Code Layout
+  {
+    id: "code-layout",
+    name: "Architecture & Layout Pattern Detector",
+    category: "architecture",
+    detect(ctx) {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const isCleanArch = (ctx.hasDirectory("src/domain") || ctx.hasDirectory("domain")) && (ctx.hasDirectory("src/application") || ctx.hasDirectory("application"));
+      if (isCleanArch) {
+        return createObservation({
+          source: "filesystem:architecture",
+          claim: "Project follows Clean / Hexagonal Architecture layout (domain, application, infrastructure)",
+          provenance: { type: "file", path: "src", timestamp: now },
+          confidence: 0.88,
+          positive: ["clean-architecture", "domain-driven", "hexagonal"]
+        });
+      }
+      const isFeatureSliced = ctx.hasDirectory("src/features") || ctx.hasDirectory("src/modules");
+      if (isFeatureSliced) {
+        return createObservation({
+          source: "filesystem:architecture",
+          claim: "Project follows Feature-sliced or modular directory architecture",
+          provenance: { type: "file", path: "src", timestamp: now },
+          confidence: 0.85,
+          positive: ["feature-sliced", "modular-architecture"]
+        });
+      }
+      return null;
+    }
+  }
+];
+var defaultRegistry = new ConventionRegistry();
+for (const detector of BUILTIN_DETECTORS) {
+  defaultRegistry.register(detector);
+}
+function registerConventionDetector(detector) {
+  defaultRegistry.register(detector);
+}
+async function analyzeProjectStructure(files, rootDir, registry = defaultRegistry) {
+  const ctx = new ProjectContext(files, rootDir);
+  return registry.run(ctx);
+}
+
+// src/scanner/markdown.ts
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+import YAML from "yaml";
+function parseMarkdownDocument(content, filePath, relativePath) {
+  const lines = content.split("\n");
+  const baseName = path2.basename(relativePath, ".md").toLowerCase();
+  let frontmatter = {};
+  const headings = [];
+  const alerts = [];
+  const codeBlocks = [];
+  const tables = [];
+  const taskItems = [];
+  const links = [];
+  const prohibitions = [];
+  let currentHeadingText = "";
+  let inCodeBlock = false;
+  let codeBlockLang = "";
+  let codeBlockLines = [];
+  let codeBlockStart = 0;
+  let inTable = false;
+  let tableHeaders = [];
+  let tableRows = [];
+  let tableStartLine = 0;
+  let inFrontmatter = false;
+  let frontmatterLines = [];
+  let bodyStartIndex = 0;
+  if (lines.length > 0 && lines[0].trim() === "---") {
+    inFrontmatter = true;
+    for (let i = 1; i < lines.length; i++) {
+      if (lines[i].trim() === "---") {
+        inFrontmatter = false;
+        bodyStartIndex = i + 1;
+        try {
+          const yamlText = frontmatterLines.join("\n");
+          const parsed = YAML.parse(yamlText);
+          if (parsed && typeof parsed === "object") {
+            frontmatter = parsed;
+          }
+        } catch {
+        }
+        break;
+      }
+      frontmatterLines.push(lines[i]);
+    }
+  }
+  function commitTable() {
+    if (inTable && tableHeaders.length > 0) {
+      tables.push({
+        headers: tableHeaders,
+        rows: tableRows,
+        line: tableStartLine,
+        heading: currentHeadingText || void 0
+      });
+      inTable = false;
+      tableHeaders = [];
+      tableRows = [];
+    }
+  }
+  for (let i = bodyStartIndex; i < lines.length; i++) {
+    const rawLine = lines[i];
+    const line = rawLine.trim();
+    const codeMatch = line.match(/^```([a-zA-Z0-9_-]*)/);
+    if (codeMatch) {
+      if (!inCodeBlock) {
+        commitTable();
+        inCodeBlock = true;
+        codeBlockLang = codeMatch[1] || "";
+        codeBlockLines = [];
+        codeBlockStart = i + 1;
+      } else {
+        inCodeBlock = false;
+        codeBlocks.push({
+          language: codeBlockLang,
+          code: codeBlockLines.join("\n"),
+          startLine: codeBlockStart,
+          endLine: i + 1,
+          heading: currentHeadingText || void 0
+        });
+      }
+      continue;
+    }
+    if (inCodeBlock) {
+      codeBlockLines.push(rawLine);
+      continue;
+    }
+    if (line.startsWith("|") && line.endsWith("|")) {
+      const cells = line.split("|").slice(1, -1).map((c) => c.trim());
+      const isDelimiter = cells.every((c) => /^:?-+:?$/.test(c));
+      if (!inTable) {
+        commitTable();
+        inTable = true;
+        tableHeaders = cells;
+        tableRows = [];
+        tableStartLine = i + 1;
+      } else if (!isDelimiter) {
+        tableRows.push(cells);
+      }
+      continue;
+    } else {
+      commitTable();
+    }
+    const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    if (headingMatch) {
+      const level = headingMatch[1].length;
+      currentHeadingText = headingMatch[2].trim();
+      headings.push({
+        level,
+        text: currentHeadingText,
+        line: i + 1
+      });
+      continue;
+    }
+    const alertMatch = line.match(/^>\s*\[!(WARNING|CAUTION|IMPORTANT|NOTE|TIP)\]/i);
+    if (alertMatch) {
+      const alertStartLine = i + 1;
+      const alertType = alertMatch[1].toUpperCase();
+      const alertLines = [];
+      let j = i + 1;
+      while (j < lines.length && lines[j].trim().startsWith(">")) {
+        alertLines.push(lines[j].trim().replace(/^>\s*/, ""));
+        j++;
+      }
+      i = j - 1;
+      alerts.push({
+        type: alertType,
+        body: alertLines.join(" ").trim(),
+        line: alertStartLine,
+        heading: currentHeadingText || void 0
+      });
+      continue;
+    }
+    const taskMatch = line.match(/^[-*]\s*\[([ xX])\]\s*(.+)$/);
+    if (taskMatch) {
+      const completed = taskMatch[1].toLowerCase() === "x";
+      const text = taskMatch[2].trim();
+      taskItems.push({
+        completed,
+        text,
+        line: i + 1,
+        heading: currentHeadingText || void 0
+      });
+      continue;
+    }
+    const linkRegex = /\[([^\]]+)\]\(([^)]+)\)/g;
+    let match;
+    while ((match = linkRegex.exec(line)) !== null) {
+      const linkText = match[1].trim();
+      const linkTarget = match[2].trim();
+      if (!linkTarget.startsWith("#")) {
+        links.push({
+          text: linkText,
+          target: linkTarget,
+          line: i + 1
+        });
+      }
+    }
+    const prohibMatch = line.match(/\b(Never|Must not|Do not|Cannot|Avoid)\s+([^.!?]+[.!?]?)/i);
+    if (prohibMatch && !line.startsWith(">")) {
+      prohibitions.push({
+        rule: `${prohibMatch[1]} ${prohibMatch[2].trim()}`,
+        line: i + 1,
+        heading: currentHeadingText || void 0
+      });
+    }
+  }
+  commitTable();
+  const sections = [];
+  for (let idx = 0; idx < headings.length; idx++) {
+    const h = headings[idx];
+    const nextH = headings[idx + 1];
+    const startLine = h.line;
+    const endLine = nextH ? nextH.line - 1 : lines.length;
+    const secLines = lines.slice(startLine - 1, endLine);
+    sections.push({
+      heading: h,
+      content: secLines.join("\n").trim(),
+      lines: secLines,
+      startLine,
+      endLine
+    });
+  }
+  return {
+    filePath,
+    relativePath,
+    baseName,
+    raw: content,
+    lines,
+    frontmatter,
+    headings,
+    sections,
+    alerts,
+    codeBlocks,
+    tables,
+    taskItems,
+    links,
+    prohibitions
+  };
+}
+var BUILTIN_MARKDOWN_EXTRACTORS = [
+  // 1. Frontmatter Extractor
+  {
+    id: "frontmatter",
+    name: "YAML Frontmatter Extractor",
+    extract(doc) {
+      const observations = [];
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const fm = doc.frontmatter;
+      for (const [key, val] of Object.entries(fm)) {
+        if (!val || typeof val === "object" && !Array.isArray(val)) continue;
+        const valStr = Array.isArray(val) ? val.join(", ") : String(val);
+        const lowerKey = key.toLowerCase();
+        observations.push(
+          createObservation({
+            source: `doc:${doc.relativePath}:frontmatter:${lowerKey}`,
+            claim: `Document metadata (${lowerKey}): ${valStr}`,
+            provenance: { type: "doc", path: doc.relativePath, line: 1, timestamp: now },
+            confidence: 0.92,
+            positive: [doc.baseName, lowerKey, ...Array.isArray(val) ? val.map(String) : []],
+            details: { frontmatterKey: lowerKey, value: val }
+          })
+        );
+      }
+      return { observations };
+    }
+  },
+  // 2. GitHub Alerts Extractor (> [!WARNING], etc.)
+  {
+    id: "github-alerts",
+    name: "GitHub Callouts & Alerts Extractor",
+    extract(doc) {
+      const observations = [];
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      for (const alert of doc.alerts) {
+        if (!alert.body) continue;
+        const isCritical = alert.type === "WARNING" || alert.type === "CAUTION";
+        observations.push(
+          createObservation({
+            source: `doc:${doc.relativePath}#L${alert.line}`,
+            claim: `[${alert.type}] ${alert.body}`,
+            provenance: { type: "doc", path: doc.relativePath, line: alert.line, timestamp: now },
+            confidence: isCritical ? 0.96 : 0.88,
+            positive: [doc.baseName, alert.type.toLowerCase(), ...alert.heading ? [alert.heading.toLowerCase()] : []],
+            details: { alertType: alert.type, heading: alert.heading, line: alert.line }
+          })
+        );
+      }
+      return { observations };
+    }
+  },
+  // 3. ADR & Architectural Decisions Extractor
+  {
+    id: "adr-decisions",
+    name: "Architecture Decision Record (ADR/MADR) Extractor",
+    extract(doc) {
+      const observations = [];
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      let hasContext = false;
+      let decision = "";
+      let status = "";
+      let adrLine = 1;
+      for (const sec of doc.sections) {
+        const lowerHead = sec.heading.text.toLowerCase();
+        if (lowerHead.includes("context")) {
+          hasContext = true;
+        }
+        if (lowerHead.includes("decision") && !lowerHead.includes("options")) {
+          for (const line of sec.lines) {
+            const clean = line.replace(/^#{1,6}\s+/, "").trim();
+            if (clean && clean.length > 5 && !clean.toLowerCase().includes("decision")) {
+              decision = clean;
+              adrLine = sec.heading.line;
+              break;
+            }
+          }
+        }
+        if (lowerHead.includes("status")) {
+          for (const line of sec.lines) {
+            const clean = line.replace(/^#{1,6}\s+/, "").trim();
+            if (clean && clean.length > 2 && !clean.toLowerCase().includes("status")) {
+              status = clean;
+              break;
+            }
+          }
+        }
+      }
+      if (hasContext && decision) {
+        observations.push(
+          createObservation({
+            source: `doc:${doc.relativePath}:adr#L${adrLine}`,
+            claim: `Architectural Decision in ${doc.relativePath}: ${decision}`,
+            provenance: { type: "doc", path: doc.relativePath, line: adrLine, timestamp: now },
+            confidence: 0.95,
+            positive: ["adr", "architecture", "decision", doc.baseName],
+            details: { status: status || "Accepted", decision }
+          })
+        );
+      }
+      return { observations };
+    }
+  },
+  // 4. Task Lists Extractor (- [ ] and - [x])
+  {
+    id: "task-items",
+    name: "Task Items & TODOs Extractor",
+    extract(doc) {
+      const observations = [];
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      for (const item of doc.taskItems) {
+        const tag = item.completed ? "DONE" : "TODO";
+        observations.push(
+          createObservation({
+            source: `doc:${doc.relativePath}#L${item.line}:todo`,
+            claim: `[${tag}] ${item.text}`,
+            provenance: { type: "doc", path: doc.relativePath, line: item.line, timestamp: now },
+            confidence: item.completed ? 0.7 : 0.82,
+            positive: ["todo", doc.baseName, ...item.heading ? [item.heading.toLowerCase()] : []],
+            details: { completed: item.completed, heading: item.heading, line: item.line }
+          })
+        );
+      }
+      return { observations };
+    }
+  },
+  // 5. Code Block Commands & Configurations
+  {
+    id: "code-blocks",
+    name: "Code Block Commands Extractor",
+    extract(doc) {
+      const observations = [];
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      for (const cb of doc.codeBlocks) {
+        const lang = cb.language.toLowerCase();
+        if (lang === "bash" || lang === "sh" || lang === "shell" || lang === "zsh") {
+          const lines = cb.code.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
+          for (const line of lines.slice(0, 3)) {
+            if (/^(npm|pnpm|yarn|bun|cargo|go|docker|make|npx)\b/.test(line)) {
+              observations.push(
+                createObservation({
+                  source: `doc:${doc.relativePath}#L${cb.startLine}:cli`,
+                  claim: `Documented CLI command in ${doc.baseName}: ${line}`,
+                  provenance: { type: "doc", path: doc.relativePath, line: cb.startLine, timestamp: now },
+                  confidence: 0.88,
+                  positive: ["command", "cli", doc.baseName],
+                  details: { command: line, language: lang }
+                })
+              );
+            }
+          }
+        }
+      }
+      return { observations };
+    }
+  },
+  // 6. Markdown Tables (Configurations & Environment Variables)
+  {
+    id: "markdown-tables",
+    name: "Markdown Table Key-Value Extractor",
+    extract(doc) {
+      const observations = [];
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      for (const table of doc.tables) {
+        if (table.headers.length < 2 || table.rows.length === 0) continue;
+        const lowerHeaders = table.headers.map((h) => h.toLowerCase());
+        const isConfigTable = lowerHeaders.some(
+          (h) => h.includes("variable") || h.includes("env") || h.includes("setting") || h.includes("option") || h.includes("command") || h.includes("param") || h.includes("flag") || h.includes("property") || h.includes("key") || h.includes("config")
+        );
+        if (isConfigTable) {
+          for (const row of table.rows.slice(0, 10)) {
+            const key = row[0];
+            const val = row[1];
+            const desc = row[2] ? ` (${row[2]})` : "";
+            if (key && val) {
+              observations.push(
+                createObservation({
+                  source: `doc:${doc.relativePath}#L${table.line}:table:${key}`,
+                  claim: `Configuration in ${doc.baseName}: ${key} = ${val}${desc}`,
+                  provenance: { type: "doc", path: doc.relativePath, line: table.line, timestamp: now },
+                  confidence: 0.88,
+                  positive: ["config", key.toLowerCase(), doc.baseName],
+                  details: { key, value: val, heading: table.heading }
+                })
+              );
+            }
+          }
+        }
+      }
+      return { observations };
+    }
+  },
+  // 7. Normative Rules & Prohibitions ("Never", "Do not", "Must not")
+  {
+    id: "rules-and-prohibitions",
+    name: "Normative Rules & Prohibitions Extractor",
+    extract(doc) {
+      const observations = [];
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      for (const p of doc.prohibitions) {
+        observations.push(
+          createObservation({
+            source: `doc:${doc.relativePath}#L${p.line}:rule`,
+            claim: `[RULE] in ${doc.baseName}: ${p.rule}`,
+            provenance: { type: "doc", path: doc.relativePath, line: p.line, timestamp: now },
+            confidence: 0.9,
+            positive: ["rule", "constraint", doc.baseName],
+            details: { rule: p.rule, heading: p.heading, line: p.line }
+          })
+        );
+      }
+      return { observations };
+    }
+  },
+  // 8. Cross-Reference File Links
+  {
+    id: "file-links",
+    name: "Cross-Reference File Links Extractor",
+    extract(doc) {
+      const relations = [];
+      for (const link of doc.links) {
+        const target = link.target;
+        if (!target.startsWith("http://") && !target.startsWith("https://") && !target.startsWith("mailto:") && (target.startsWith(".") || target.includes("/") || /\.(md|ts|js|json|ya?ml|toml|rs|go|py)$/i.test(target))) {
+          const rawTarget = target.split("#")[0].split("?")[0].trim();
+          if (rawTarget) {
+            const dir = path2.dirname(doc.relativePath);
+            const resolved = dir === "." || path2.isAbsolute(rawTarget) ? rawTarget.replace(/^\.\//, "") : path2.normalize(path2.join(dir, rawTarget));
+            relations.push({
+              from: doc.relativePath,
+              to: resolved,
+              type: "DOCUMENTS"
+            });
+          }
+        }
+      }
+      return { observations: [], relations };
+    }
+  }
+];
+var MarkdownRegistry = class {
+  extractors = /* @__PURE__ */ new Map();
+  register(extractor) {
+    this.extractors.set(extractor.id, extractor);
+    return this;
+  }
+  unregister(id) {
+    return this.extractors.delete(id);
+  }
+  get(id) {
+    return this.extractors.get(id);
+  }
+  list() {
+    return Array.from(this.extractors.values());
+  }
+  async run(doc) {
+    const observations = [];
+    const relations = [];
+    for (const extractor of this.extractors.values()) {
+      try {
+        const result = await extractor.extract(doc);
+        if (result.observations && result.observations.length > 0) {
+          observations.push(...result.observations);
+        }
+        if (result.relations && result.relations.length > 0) {
+          relations.push(...result.relations);
+        }
+      } catch {
+      }
+    }
+    return { observations, relations };
+  }
+};
+var defaultMarkdownRegistry = new MarkdownRegistry();
+for (const ext of BUILTIN_MARKDOWN_EXTRACTORS) {
+  defaultMarkdownRegistry.register(ext);
+}
+function registerMarkdownExtractor(extractor) {
+  defaultMarkdownRegistry.register(extractor);
+}
+async function parseMarkdownFile(filePath, relativePath, registry = defaultMarkdownRegistry) {
+  let content = "";
+  try {
+    content = await fs2.readFile(filePath, "utf-8");
+  } catch {
+    return { observations: [], relations: [] };
+  }
+  const doc = parseMarkdownDocument(content, filePath, relativePath);
+  return registry.run(doc);
+}
+
+// src/scanner/git.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function runGit(args, cwd) {
+  const { stdout } = await execFileAsync("git", args, {
+    cwd,
+    maxBuffer: 10 * 1024 * 1024
+  });
+  return stdout.trim();
+}
+async function isGitRepository(cwd) {
+  try {
+    const res = await runGit(["rev-parse", "--is-inside-work-tree"], cwd);
+    return res === "true";
+  } catch {
+    return false;
+  }
+}
+async function scanGitHistory(cwd, options = {}) {
+  const isRepo = await isGitRepository(cwd);
+  if (!isRepo) {
+    return {
+      isGitRepo: false,
+      commitsScanned: 0,
+      observations: [],
+      relations: []
+    };
+  }
+  let headCommit = "";
+  try {
+    headCommit = await runGit(["rev-parse", "HEAD"], cwd);
+  } catch {
+    return {
+      isGitRepo: true,
+      commitsScanned: 0,
+      observations: [],
+      relations: []
+    };
+  }
+  let revisionRange = [];
+  if (options.lastScanCommit && options.lastScanCommit !== headCommit) {
+    try {
+      await runGit(["cat-file", "-e", `${options.lastScanCommit}^{commit}`], cwd);
+      revisionRange = [`${options.lastScanCommit}..HEAD`];
+    } catch {
+      revisionRange = ["-n", String(options.maxCommits ?? 100), "HEAD"];
+    }
+  } else {
+    revisionRange = ["-n", String(options.maxCommits ?? 100), "HEAD"];
+  }
+  const logArgs = [
+    "log",
+    ...revisionRange,
+    "--name-only",
+    "--pretty=format:COMMIT:%H|%an|%aI|%s"
+  ];
+  let rawLog = "";
+  try {
+    rawLog = await runGit(logArgs, cwd);
+  } catch {
+    return {
+      isGitRepo: true,
+      headCommit,
+      commitsScanned: 0,
+      observations: [],
+      relations: []
+    };
+  }
+  const commits = [];
+  const lines = rawLog.split("\n");
+  let currentCommit = null;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (trimmed.startsWith("COMMIT:")) {
+      if (currentCommit) commits.push(currentCommit);
+      const parts = trimmed.substring("COMMIT:".length).split("|");
+      currentCommit = {
+        hash: parts[0] || "",
+        author: parts[1] || "",
+        date: parts[2] || "",
+        subject: parts.slice(3).join("|"),
+        files: [],
+        isMerge: false
+      };
+    } else if (currentCommit) {
+      currentCommit.files.push(trimmed);
+    }
+  }
+  if (currentCommit) commits.push(currentCommit);
+  const observations = [];
+  const relations = [];
+  const coChangeMap = /* @__PURE__ */ new Map();
+  const fileFixCount = /* @__PURE__ */ new Map();
+  for (const commit of commits) {
+    if (commit.files.length > 15) {
+      commit.isMerge = true;
+      continue;
+    }
+    const lowerSubject = commit.subject.toLowerCase();
+    const isRevert = lowerSubject.startsWith("revert") || lowerSubject.includes("reverting");
+    const isFix = lowerSubject.startsWith("fix") || lowerSubject.startsWith("hotfix") || lowerSubject.startsWith("bugfix") || lowerSubject.includes("fix:");
+    if (isRevert && commit.files.length > 0) {
+      observations.push(
+        createObservation({
+          source: `git:${commit.hash}`,
+          claim: `Revert recorded in git: "${commit.subject}" affecting [${commit.files.slice(0, 5).join(", ")}]`,
+          provenance: {
+            type: "git",
+            commit: commit.hash,
+            author: commit.author,
+            timestamp: commit.date
+          },
+          confidence: 0.95,
+          positive: ["revert", ...commit.files.map((f) => f.split("/").pop()?.toLowerCase() || f)],
+          negative: ["fragile-change"],
+          details: { commit: commit.hash, files: commit.files }
+        })
+      );
+    }
+    if (isFix && commit.files.length > 1) {
+      const testFiles = commit.files.filter((f) => f.includes("test") || f.includes("spec"));
+      const srcFiles = commit.files.filter((f) => !f.includes("test") && !f.includes("spec"));
+      if (testFiles.length > 0 && srcFiles.length > 0) {
+        observations.push(
+          createObservation({
+            source: `git:${commit.hash}:bugfix-test`,
+            claim: `Bugfix "${commit.subject}" included test verification in ${testFiles.join(", ")}`,
+            provenance: {
+              type: "git",
+              commit: commit.hash,
+              author: commit.author,
+              timestamp: commit.date
+            },
+            confidence: 0.92,
+            positive: ["bugfix", "test-added", ...srcFiles.map((f) => f.split("/").pop()?.toLowerCase() || f)],
+            details: { srcFiles, testFiles }
+          })
+        );
+      }
+    }
+    if (isFix) {
+      for (const file of commit.files) {
+        fileFixCount.set(file, (fileFixCount.get(file) ?? 0) + 1);
+      }
+    }
+    if (commit.files.length >= 2 && commit.files.length <= 8) {
+      for (let i = 0; i < commit.files.length; i++) {
+        for (let j = i + 1; j < commit.files.length; j++) {
+          const a = commit.files[i];
+          const b = commit.files[j];
+          const key = a < b ? `${a} <-> ${b}` : `${b} <-> ${a}`;
+          coChangeMap.set(key, (coChangeMap.get(key) ?? 0) + 1);
+        }
+      }
+    }
+  }
+  for (const [file, count] of fileFixCount.entries()) {
+    if (count >= 3) {
+      observations.push(
+        createObservation({
+          source: `git:hotspot:${file}`,
+          claim: `Fragile hotspot: "${file}" required ${count} fixes in recent history`,
+          provenance: { type: "git", path: file, timestamp: (/* @__PURE__ */ new Date()).toISOString() },
+          confidence: 0.88,
+          positive: ["hotspot", "fragile", file.split("/").pop()?.toLowerCase() || file],
+          details: { fixCount: count }
+        })
+      );
+    }
+  }
+  for (const [key, count] of coChangeMap.entries()) {
+    if (count >= 2) {
+      const [from, to] = key.split(" <-> ");
+      relations.push({
+        from,
+        to,
+        type: "CO_CHANGED",
+        weight: count
+      });
+      relations.push({
+        from: to,
+        to: from,
+        type: "CO_CHANGED",
+        weight: count
+      });
+    }
+  }
+  return {
+    isGitRepo: true,
+    headCommit,
+    commitsScanned: commits.length,
+    observations,
+    relations
+  };
+}
+
+// src/scanner/source.ts
+import * as fs3 from "fs/promises";
+import * as fsSync from "fs";
+import * as path3 from "path";
+import { createRequire } from "module";
+import Parser from "web-tree-sitter";
+var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".go",
+  ".rs",
+  ".java",
+  ".c",
+  ".cpp",
+  ".h",
+  ".hpp",
+  ".rb",
+  ".php",
+  ".cs",
+  ".swift",
+  ".kt",
+  ".scala",
+  ".sh",
+  ".bash",
+  ".zsh",
+  ".sql"
+]);
+function isSourceFile(ext) {
+  return SOURCE_EXTENSIONS.has(ext.toLowerCase());
+}
+var EXT_TO_WASM = {
+  ".ts": "tree-sitter-typescript.wasm",
+  ".mts": "tree-sitter-typescript.wasm",
+  ".cts": "tree-sitter-typescript.wasm",
+  ".tsx": "tree-sitter-tsx.wasm",
+  ".js": "tree-sitter-javascript.wasm",
+  ".mjs": "tree-sitter-javascript.wasm",
+  ".cjs": "tree-sitter-javascript.wasm",
+  ".jsx": "tree-sitter-javascript.wasm",
+  ".py": "tree-sitter-python.wasm",
+  ".go": "tree-sitter-go.wasm",
+  ".rs": "tree-sitter-rust.wasm"
+};
+var wasmBaseDir = null;
+var parserInitialized = false;
+var parserInstance = null;
+var languageCache = /* @__PURE__ */ new Map();
+function getWasmDir() {
+  if (wasmBaseDir) return wasmBaseDir;
+  try {
+    const req = createRequire(import.meta.url);
+    const pkgJson = req.resolve("tree-sitter-wasms/package.json");
+    const outDir = path3.join(path3.dirname(pkgJson), "out");
+    if (fsSync.existsSync(outDir)) {
+      wasmBaseDir = outDir;
+      return wasmBaseDir;
+    }
+  } catch {
+  }
+  const candidateDirs = [
+    path3.resolve(process.cwd(), "node_modules/tree-sitter-wasms/out"),
+    path3.resolve(process.cwd(), "../node_modules/tree-sitter-wasms/out")
+  ];
+  for (const dir of candidateDirs) {
+    if (fsSync.existsSync(dir)) {
+      wasmBaseDir = dir;
+      return wasmBaseDir;
+    }
+  }
+  return null;
+}
+async function getParserForWasm(wasmName) {
+  const wasmDir = getWasmDir();
+  if (!wasmDir) return null;
+  const wasmPath = path3.join(wasmDir, wasmName);
+  if (!fsSync.existsSync(wasmPath)) return null;
+  try {
+    if (!parserInitialized) {
+      await Parser.init();
+      parserInitialized = true;
+    }
+    if (!parserInstance) {
+      parserInstance = new Parser();
+    }
+    let lang = languageCache.get(wasmName);
+    if (!lang) {
+      lang = await Parser.Language.load(wasmPath);
+      languageCache.set(wasmName, lang);
+    }
+    parserInstance.setLanguage(lang);
+    return parserInstance;
+  } catch {
+    return null;
+  }
+}
+function cleanQuote(str) {
+  return str.replace(/^['"`]|['"`]$/g, "").trim();
+}
+function getEnclosingScope(node) {
+  let curr = node.parent;
+  const parts = [];
+  while (curr) {
+    if (curr.type === "class_declaration" || curr.type === "class_definition" || curr.type === "function_declaration" || curr.type === "function_definition" || curr.type === "method_definition" || curr.type === "interface_declaration" || curr.type === "struct_item" || curr.type === "impl_item") {
+      const name = curr.childForFieldName("name")?.text;
+      if (name) parts.unshift(name);
+    }
+    curr = curr.parent;
+  }
+  return parts.length > 0 ? parts.join(".") : void 0;
+}
+function extractCommentObservation(node, relativePath, baseName, now) {
+  const text = node.text;
+  const match = text.match(/\b(TODO|FIXME|HACK|DEPRECATED|WARN|NOTE|BUG)\b:?\s*(.*)$/i);
+  if (!match) return null;
+  const tag = match[1].toUpperCase();
+  const commentText = match[2].trim() || "Unspecified";
+  const scope = getEnclosingScope(node);
+  const line = node.startPosition.row + 1;
+  const scopePrefix = scope ? ` in ${scope}` : "";
+  const positive = [tag.toLowerCase(), baseName.toLowerCase()];
+  if (scope) {
+    for (const part of scope.split(".")) {
+      if (part) positive.push(part.toLowerCase());
+    }
+  }
+  const confidence = tag === "DEPRECATED" || tag === "FIXME" || tag === "BUG" ? 0.9 : 0.8;
+  return createObservation({
+    source: `code:${relativePath}#L${line}`,
+    claim: `[${tag}${scopePrefix}] in ${baseName}: ${commentText}`,
+    provenance: { type: "code", path: relativePath, line, timestamp: now },
+    confidence,
+    positive,
+    details: { tag, text: commentText, scope, line }
+  });
+}
+function extractFromTsJs(root, relativePath, baseName, now, observations, relations) {
+  function walk(node) {
+    if (node.type === "import_statement") {
+      const source = node.childForFieldName("source");
+      if (source) {
+        const target = cleanQuote(source.text);
+        relations.push({ from: relativePath, to: target, type: "IMPORTS" });
+      }
+    }
+    if (node.type === "call_expression") {
+      const fn = node.childForFieldName("function");
+      if (fn && (fn.text === "require" || fn.text === "import")) {
+        const args = node.childForFieldName("arguments");
+        if (args && args.namedChildCount > 0) {
+          const firstArg = args.namedChild(0);
+          if (firstArg && (firstArg.type === "string" || firstArg.type === "template_string")) {
+            const target = cleanQuote(firstArg.text);
+            if (target) {
+              relations.push({ from: relativePath, to: target, type: "IMPORTS" });
+            }
+          }
+        }
+      }
+    }
+    if (node.type === "export_statement") {
+      const source = node.childForFieldName("source");
+      if (source) {
+        const target = cleanQuote(source.text);
+        relations.push({ from: relativePath, to: target, type: "IMPORTS" });
+      }
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (!child) continue;
+        if (child.type === "function_declaration" || child.type === "class_declaration" || child.type === "interface_declaration" || child.type === "type_alias_declaration" || child.type === "enum_declaration") {
+          const name = child.childForFieldName("name")?.text;
+          const kind = child.type.replace("_declaration", "");
+          const line = child.startPosition.row + 1;
+          if (name) {
+            observations.push(
+              createObservation({
+                source: `code:${relativePath}#L${line}`,
+                claim: `[export ${kind}] ${name} in ${baseName}`,
+                provenance: { type: "code", path: relativePath, line, timestamp: now },
+                confidence: 0.85,
+                positive: [name.toLowerCase(), kind, baseName.toLowerCase()],
+                details: { kind, name, exported: true, line }
+              })
+            );
+            relations.push({
+              from: relativePath,
+              to: `${relativePath}#${name}`,
+              type: "DEFINES"
+            });
+          }
+        } else if (child.type === "lexical_declaration") {
+          for (let j = 0; j < child.namedChildCount; j++) {
+            const decl = child.namedChild(j);
+            if (decl && decl.type === "variable_declarator") {
+              const name = decl.childForFieldName("name")?.text;
+              const line = decl.startPosition.row + 1;
+              if (name) {
+                observations.push(
+                  createObservation({
+                    source: `code:${relativePath}#L${line}`,
+                    claim: `[export const] ${name} in ${baseName}`,
+                    provenance: { type: "code", path: relativePath, line, timestamp: now },
+                    confidence: 0.8,
+                    positive: [name.toLowerCase(), "const", baseName.toLowerCase()],
+                    details: { kind: "const", name, exported: true, line }
+                  })
+                );
+                relations.push({
+                  from: relativePath,
+                  to: `${relativePath}#${name}`,
+                  type: "DEFINES"
+                });
+              }
+            }
+          }
+        }
+      }
+    }
+    if (node.type === "comment") {
+      const obs = extractCommentObservation(node, relativePath, baseName, now);
+      if (obs) observations.push(obs);
+    }
+    for (let i = 0; i < node.childCount; i++) {
+      const ch = node.child(i);
+      if (ch) walk(ch);
+    }
+  }
+  walk(root);
+}
+function extractFromPython(root, relativePath, baseName, now, observations, relations) {
+  function walk(node) {
+    if (node.type === "import_statement") {
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child && (child.type === "dotted_name" || child.type === "aliased_import")) {
+          const target = child.type === "aliased_import" ? child.childForFieldName("name")?.text : child.text;
+          if (target) {
+            relations.push({ from: relativePath, to: target, type: "IMPORTS" });
+          }
+        }
+      }
+    }
+    if (node.type === "import_from_statement") {
+      const moduleName = node.childForFieldName("module_name")?.text;
+      if (moduleName) {
+        relations.push({ from: relativePath, to: moduleName, type: "IMPORTS" });
+      }
+    }
+    if (node.type === "class_definition" || node.type === "function_definition") {
+      const name = node.childForFieldName("name")?.text;
+      const kind = node.type === "class_definition" ? "class" : "def";
+      const line = node.startPosition.row + 1;
+      if (name && (node.parent?.type === "module" || node.type === "class_definition")) {
+        observations.push(
+          createObservation({
+            source: `code:${relativePath}#L${line}`,
+            claim: `[${kind}] ${name} in ${baseName}`,
+            provenance: { type: "code", path: relativePath, line, timestamp: now },
+            confidence: 0.85,
+            positive: [name.toLowerCase(), kind, baseName.toLowerCase()],
+            details: { kind, name, line }
+          })
+        );
+        relations.push({
+          from: relativePath,
+          to: `${relativePath}#${name}`,
+          type: "DEFINES"
+        });
+      }
+    }
+    if (node.type === "comment") {
+      const obs = extractCommentObservation(node, relativePath, baseName, now);
+      if (obs) observations.push(obs);
+    }
+    for (let i = 0; i < node.childCount; i++) {
+      const ch = node.child(i);
+      if (ch) walk(ch);
+    }
+  }
+  walk(root);
+}
+function extractFromGo(root, relativePath, baseName, now, observations, relations) {
+  function walk(node) {
+    if (node.type === "import_spec") {
+      const pathNode = node.childForFieldName("path");
+      if (pathNode) {
+        const target = cleanQuote(pathNode.text);
+        relations.push({ from: relativePath, to: target, type: "IMPORTS" });
+      }
+    }
+    if (node.type === "function_declaration" || node.type === "method_declaration") {
+      const name = node.childForFieldName("name")?.text;
+      const line = node.startPosition.row + 1;
+      if (name) {
+        observations.push(
+          createObservation({
+            source: `code:${relativePath}#L${line}`,
+            claim: `[func] ${name} in ${baseName}`,
+            provenance: { type: "code", path: relativePath, line, timestamp: now },
+            confidence: 0.85,
+            positive: [name.toLowerCase(), "func", baseName.toLowerCase()],
+            details: { kind: "func", name, line }
+          })
+        );
+        relations.push({
+          from: relativePath,
+          to: `${relativePath}#${name}`,
+          type: "DEFINES"
+        });
+      }
+    }
+    if (node.type === "type_spec") {
+      const name = node.childForFieldName("name")?.text;
+      const line = node.startPosition.row + 1;
+      if (name) {
+        observations.push(
+          createObservation({
+            source: `code:${relativePath}#L${line}`,
+            claim: `[type] ${name} in ${baseName}`,
+            provenance: { type: "code", path: relativePath, line, timestamp: now },
+            confidence: 0.85,
+            positive: [name.toLowerCase(), "type", baseName.toLowerCase()],
+            details: { kind: "type", name, line }
+          })
+        );
+        relations.push({
+          from: relativePath,
+          to: `${relativePath}#${name}`,
+          type: "DEFINES"
+        });
+      }
+    }
+    if (node.type === "comment") {
+      const obs = extractCommentObservation(node, relativePath, baseName, now);
+      if (obs) observations.push(obs);
+    }
+    for (let i = 0; i < node.childCount; i++) {
+      const ch = node.child(i);
+      if (ch) walk(ch);
+    }
+  }
+  walk(root);
+}
+function extractFromRust(root, relativePath, baseName, now, observations, relations) {
+  function walk(node) {
+    if (node.type === "use_declaration") {
+      const text = node.text.replace(/^use\s+/, "").replace(/;$/, "").trim();
+      const rootCrate = text.split("::")[0];
+      if (rootCrate) {
+        relations.push({ from: relativePath, to: rootCrate, type: "IMPORTS" });
+      }
+    }
+    if (node.type === "function_item" || node.type === "struct_item" || node.type === "enum_item" || node.type === "trait_item") {
+      const name = node.childForFieldName("name")?.text;
+      const kind = node.type.replace("_item", "");
+      const line = node.startPosition.row + 1;
+      if (name) {
+        observations.push(
+          createObservation({
+            source: `code:${relativePath}#L${line}`,
+            claim: `[${kind}] ${name} in ${baseName}`,
+            provenance: { type: "code", path: relativePath, line, timestamp: now },
+            confidence: 0.85,
+            positive: [name.toLowerCase(), kind, baseName.toLowerCase()],
+            details: { kind, name, line }
+          })
+        );
+        relations.push({
+          from: relativePath,
+          to: `${relativePath}#${name}`,
+          type: "DEFINES"
+        });
+      }
+    }
+    if (node.type === "line_comment" || node.type === "block_comment") {
+      const obs = extractCommentObservation(node, relativePath, baseName, now);
+      if (obs) observations.push(obs);
+    }
+    for (let i = 0; i < node.childCount; i++) {
+      const ch = node.child(i);
+      if (ch) walk(ch);
+    }
+  }
+  walk(root);
+}
+function analyzeSourceLexical(content, relativePath, baseName, now) {
+  const observations = [];
+  const relations = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (!line) continue;
+    const jsImportMatch = line.match(/(?:import\s+.*?\s+from\s+['"]([^'"]+)['"]|require\s*\(\s*['"]([^'"]+)['"]\s*\))/);
+    if (jsImportMatch) {
+      const target = jsImportMatch[1] || jsImportMatch[2];
+      relations.push({ from: relativePath, to: target, type: "IMPORTS" });
+    }
+    const pyImportMatch = line.match(/^(?:from\s+([a-zA-Z0-9_.]+)\s+import|import\s+([a-zA-Z0-9_.]+))/);
+    if (pyImportMatch && relativePath.endsWith(".py")) {
+      const target = pyImportMatch[1] || pyImportMatch[2];
+      relations.push({ from: relativePath, to: target, type: "IMPORTS" });
+    }
+    const rustUseMatch = line.match(/^use\s+([a-zA-Z0-9_]+)::/);
+    if (rustUseMatch && relativePath.endsWith(".rs")) {
+      relations.push({ from: relativePath, to: rustUseMatch[1], type: "IMPORTS" });
+    }
+    const goImportMatch = line.match(/^import\s+["']([^"']+)["']/);
+    if (goImportMatch && relativePath.endsWith(".go")) {
+      relations.push({ from: relativePath, to: goImportMatch[1], type: "IMPORTS" });
+    }
+    const commentMatch = line.match(/\b(TODO|FIXME|HACK|DEPRECATED|WARN|NOTE|BUG)\b:?\s*(.*)$/i);
+    if (commentMatch) {
+      const tag = commentMatch[1].toUpperCase();
+      const text = commentMatch[2].trim() || "Unspecified";
+      const confidence = tag === "DEPRECATED" || tag === "FIXME" || tag === "BUG" ? 0.9 : 0.8;
+      observations.push(
+        createObservation({
+          source: `code:${relativePath}#L${i + 1}`,
+          claim: `[${tag}] in ${baseName}: ${text}`,
+          provenance: { type: "code", path: relativePath, line: i + 1, timestamp: now },
+          confidence,
+          positive: [tag.toLowerCase(), baseName.toLowerCase()],
+          details: { tag, text, line: i + 1 }
+        })
+      );
+    }
+  }
+  return { observations, relations };
+}
+async function analyzeSourceFile(filePath, relativePath) {
+  const observations = [];
+  const relations = [];
+  let content = "";
+  try {
+    content = await fs3.readFile(filePath, "utf-8");
+  } catch {
+    return { observations, relations };
+  }
+  if (content.length > 500 * 1024) {
+    return { observations, relations };
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const baseName = path3.basename(relativePath);
+  const ext = path3.extname(relativePath).toLowerCase();
+  const wasmName = EXT_TO_WASM[ext];
+  if (wasmName) {
+    try {
+      const parser = await getParserForWasm(wasmName);
+      if (parser) {
+        const tree = parser.parse(content);
+        const root = tree.rootNode;
+        if (ext === ".ts" || ext === ".mts" || ext === ".cts" || ext === ".tsx" || ext === ".js" || ext === ".jsx" || ext === ".mjs" || ext === ".cjs") {
+          extractFromTsJs(root, relativePath, baseName, now, observations, relations);
+        } else if (ext === ".py") {
+          extractFromPython(root, relativePath, baseName, now, observations, relations);
+        } else if (ext === ".go") {
+          extractFromGo(root, relativePath, baseName, now, observations, relations);
+        } else if (ext === ".rs") {
+          extractFromRust(root, relativePath, baseName, now, observations, relations);
+        }
+        return { observations, relations };
+      }
+    } catch {
+    }
+  }
+  return analyzeSourceLexical(content, relativePath, baseName, now);
+}
+
+// src/scanner/engine.ts
+import * as path7 from "path";
+
+// src/core/unknown.ts
+function createUnknown(params) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: params.id.trim(),
+    state: params.state ?? "UNKNOWN",
+    reason: params.reason ?? "NOT_OBSERVED",
+    statement: params.statement?.trim(),
+    checked: Array.from(new Set(params.checked?.map((c) => c.trim()) ?? [])),
+    next: params.next,
+    scope: params.scope ?? "project",
+    createdAt: now,
+    updatedAt: now
+  };
+}
+
+// src/core/relations.ts
+var EvidenceGraph = class _EvidenceGraph {
+  fromMap = /* @__PURE__ */ new Map();
+  toMap = /* @__PURE__ */ new Map();
+  constructor(relations = []) {
+    for (const rel of relations) {
+      this.addRelation(rel);
+    }
+  }
+  addRelation(relation) {
+    if (!relation || !relation.from || !relation.to || !relation.type) {
+      return;
+    }
+    const existing = this.getRelationsBetween(relation.from, relation.to);
+    const dup = existing.find((r) => r.type === relation.type);
+    if (dup) {
+      dup.weight = (dup.weight ?? 1) + (relation.weight ?? 1);
+      return;
+    }
+    const fromList = this.fromMap.get(relation.from) ?? [];
+    fromList.push(relation);
+    this.fromMap.set(relation.from, fromList);
+    const toList = this.toMap.get(relation.to) ?? [];
+    toList.push(relation);
+    this.toMap.set(relation.to, toList);
+  }
+  getRelationsFrom(fromId) {
+    return this.fromMap.get(fromId) ?? [];
+  }
+  getRelationsTo(toId) {
+    return this.toMap.get(toId) ?? [];
+  }
+  getRelationsBetween(fromId, toId) {
+    const fromList = this.fromMap.get(fromId);
+    if (!fromList) return [];
+    return fromList.filter((r) => r.to === toId);
+  }
+  getAllRelations() {
+    const all = [];
+    for (const list of this.fromMap.values()) {
+      all.push(...list);
+    }
+    return all;
+  }
+  findCoChanged(file, threshold = 1) {
+    const relations = this.getRelationsFrom(file).filter((r) => r.type === "CO_CHANGED");
+    const result = [];
+    for (const rel of relations) {
+      const w = rel.weight ?? 1;
+      if (w >= threshold) {
+        result.push({ file: rel.to, weight: w });
+      }
+    }
+    return result.sort((a, b) => b.weight - a.weight);
+  }
+  findConnected(id, maxDepth = 2) {
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [{ node: id, depth: 0 }];
+    while (queue.length > 0) {
+      const { node, depth } = queue.shift();
+      if (visited.has(node)) continue;
+      visited.add(node);
+      if (depth < maxDepth) {
+        const outRels = this.getRelationsFrom(node);
+        for (const r of outRels) {
+          if (!visited.has(r.to)) {
+            queue.push({ node: r.to, depth: depth + 1 });
+          }
+        }
+        const inRels = this.getRelationsTo(node);
+        for (const r of inRels) {
+          if (!visited.has(r.from)) {
+            queue.push({ node: r.from, depth: depth + 1 });
+          }
+        }
+      }
+    }
+    visited.delete(id);
+    return Array.from(visited);
+  }
+  toJSON() {
+    return this.getAllRelations();
+  }
+  static fromJSON(relations) {
+    return new _EvidenceGraph(relations);
+  }
+};
+
+// src/storage/canonical.ts
+import * as fs6 from "fs/promises";
+import * as path6 from "path";
+
+// src/rules/loader.ts
+import YAML2 from "yaml";
+import * as fs4 from "fs/promises";
+import * as path4 from "path";
+function validateRuleDefinition(rule, index = 0) {
+  const errors = [];
+  if (!rule || typeof rule !== "object") {
+    errors.push(`Rule at index ${index} must be an object.`);
+    return errors;
+  }
+  const r = rule;
+  if (!r.id || typeof r.id !== "string" || !r.id.trim()) {
+    errors.push(`Rule at index ${index} requires a non-empty string 'id'.`);
+  }
+  if (!r.statement || typeof r.statement !== "string" || !r.statement.trim()) {
+    errors.push(`Rule '${r.id || index}' requires a non-empty string 'statement'.`);
+  }
+  if (r.type) {
+    const validTypes = [
+      "rule",
+      "convention",
+      "decision",
+      "lesson",
+      "architecture",
+      "fact"
+    ];
+    if (!validTypes.includes(r.type)) {
+      errors.push(`Rule '${r.id || index}' has invalid type '${r.type}'. Allowed: ${validTypes.join(", ")}.`);
+    }
+  }
+  if (r.confidence !== void 0) {
+    if (typeof r.confidence !== "number" || r.confidence < 0 || r.confidence > 1) {
+      errors.push(`Rule '${r.id || index}' confidence must be a number between 0.0 and 1.0.`);
+    }
+  }
+  if (r.positive !== void 0 && !Array.isArray(r.positive)) {
+    errors.push(`Rule '${r.id || index}' positive cues must be an array of strings.`);
+  }
+  if (r.negative !== void 0 && !Array.isArray(r.negative)) {
+    errors.push(`Rule '${r.id || index}' negative cues must be an array of strings.`);
+  }
+  return errors;
+}
+function validateRuleSet(data) {
+  const errors = [];
+  if (!data || typeof data !== "object") {
+    return { valid: false, errors: ["RuleSet content must be an object or an array of rules."] };
+  }
+  let rules = [];
+  if (Array.isArray(data)) {
+    rules = data;
+  } else if ("rules" in data && Array.isArray(data.rules)) {
+    rules = data.rules;
+  } else if ("id" in data && "statement" in data) {
+    rules = [data];
+  } else {
+    return { valid: false, errors: ['RuleSet must contain a "rules" array or be a list of rule definitions.'] };
+  }
+  if (rules.length === 0) {
+    errors.push("RuleSet contains no rules.");
+  }
+  rules.forEach((rule, idx) => {
+    errors.push(...validateRuleDefinition(rule, idx));
+  });
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function parseRuleSetYaml(content, sourcePath = "inline.yml") {
+  let parsed;
+  try {
+    parsed = YAML2.parse(content);
+  } catch (err) {
+    throw new Error(`YAML syntax error in ${sourcePath}: ${err.message}`);
+  }
+  const validation = validateRuleSet(parsed);
+  if (!validation.valid) {
+    throw new Error(`Invalid RuleSet in ${sourcePath}:
+- ${validation.errors.join("\n- ")}`);
+  }
+  if (Array.isArray(parsed)) {
+    return {
+      name: path4.basename(sourcePath, path4.extname(sourcePath)),
+      rules: parsed
+    };
+  }
+  if ("id" in parsed && "statement" in parsed && !("rules" in parsed)) {
+    return {
+      name: parsed.id,
+      rules: [parsed]
+    };
+  }
+  const set = parsed;
+  return {
+    name: set.name ?? path4.basename(sourcePath, path4.extname(sourcePath)),
+    version: set.version ?? 1,
+    scope: set.scope ?? "project",
+    description: set.description,
+    rules: set.rules
+  };
+}
+function stringifyRuleSetYaml(ruleSet) {
+  const payload = {};
+  if (ruleSet.name) payload.name = ruleSet.name;
+  if (ruleSet.version !== void 0) payload.version = ruleSet.version;
+  if (ruleSet.scope) payload.scope = ruleSet.scope;
+  if (ruleSet.description) payload.description = ruleSet.description;
+  payload.rules = ruleSet.rules.map((r) => {
+    const ruleObj = {
+      id: r.id
+    };
+    if (r.name) ruleObj.name = r.name;
+    ruleObj.statement = r.statement;
+    if (r.type && r.type !== "rule") ruleObj.type = r.type;
+    if (r.confidence !== void 0 && r.confidence !== 0.95) ruleObj.confidence = r.confidence;
+    if (r.scope && r.scope !== "project") ruleObj.scope = r.scope;
+    if (r.positive && r.positive.length > 0) ruleObj.positive = r.positive;
+    if (r.negative && r.negative.length > 0) ruleObj.negative = r.negative;
+    if (r.tags && r.tags.length > 0) ruleObj.tags = r.tags;
+    if (r.when && Object.keys(r.when).length > 0) ruleObj.when = r.when;
+    if (r.details && Object.keys(r.details).length > 0) ruleObj.details = r.details;
+    return ruleObj;
+  });
+  return YAML2.stringify(payload, { indent: 2, lineWidth: 100 });
+}
+async function loadRuleSetFile(filePath) {
+  const content = await fs4.readFile(filePath, "utf-8");
+  return parseRuleSetYaml(content, filePath);
+}
+async function findRuleFiles(rootDir, storageRulesDir) {
+  const candidates = [];
+  const rulesDir = storageRulesDir || path4.resolve(rootDir, ".bilmem", "rules");
+  try {
+    const entries = await fs4.readdir(rulesDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile() && (entry.name.endsWith(".yml") || entry.name.endsWith(".yaml"))) {
+        candidates.push(path4.join(rulesDir, entry.name));
+      }
+    }
+  } catch {
+  }
+  for (const name of ["rules.yml", "rules.yaml"]) {
+    const p = path4.resolve(rootDir, ".bilmem", name);
+    try {
+      const st = await fs4.stat(p);
+      if (st.isFile()) candidates.push(p);
+    } catch {
+    }
+  }
+  for (const name of ["bilmem.rules.yml", "bilmem.rules.yaml", "rules.yml", "rules.yaml"]) {
+    const p = path4.resolve(rootDir, name);
+    try {
+      const st = await fs4.stat(p);
+      if (st.isFile()) candidates.push(p);
+    } catch {
+    }
+  }
+  return Array.from(new Set(candidates));
+}
+async function loadAllProjectRuleSets(rootDir, storageRulesDir) {
+  const files = await findRuleFiles(rootDir, storageRulesDir);
+  const ruleSets = [];
+  const loadedFiles = [];
+  for (const file of files) {
+    try {
+      const set = await loadRuleSetFile(file);
+      ruleSets.push(set);
+      loadedFiles.push(file);
+    } catch (err) {
+      console.warn(`[bilmem] Warning: Failed to load rule set from ${file}: ${err.message}`);
+    }
+  }
+  return { ruleSets, sourceFiles: loadedFiles };
+}
+
+// src/stats/events.ts
+import * as fs5 from "fs/promises";
+import * as path5 from "path";
+function getEventsFilePath(rootDir) {
+  return path5.join(rootDir, ".bilmem", "events.jsonl");
+}
+async function readMetricEvents(rootDir, filter) {
+  const filePath = getEventsFilePath(rootDir);
+  let raw;
+  try {
+    raw = await fs5.readFile(filePath, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return [];
+    }
+    return [];
+  }
+  const lines = raw.split("\n");
+  const events = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (!parsed || typeof parsed !== "object" || typeof parsed.type !== "string") {
+        continue;
+      }
+      if (typeof parsed.timestamp !== "number") {
+        continue;
+      }
+      if (filter?.sinceTimestamp !== void 0 && parsed.timestamp < filter.sinceTimestamp) {
+        continue;
+      }
+      if (filter?.knowledgeId !== void 0) {
+        const kid = parsed.knowledgeId;
+        if (kid !== filter.knowledgeId) {
+          continue;
+        }
+      }
+      events.push(parsed);
+    } catch {
+      continue;
+    }
+  }
+  return events;
+}
+async function resetMetricEvents(rootDir) {
+  const filePath = getEventsFilePath(rootDir);
+  try {
+    await fs5.mkdir(path5.dirname(filePath), { recursive: true });
+    await fs5.writeFile(filePath, "", "utf-8");
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+}
+
+// src/storage/canonical.ts
+function sanitizeFileName(id) {
+  return encodeURIComponent(id).replace(/%/g, "_");
+}
+var Storage = class {
+  baseDir;
+  knowledgeDir;
+  evidenceDir;
+  observationDir;
+  unknownDir;
+  rulesDir;
+  configFile;
+  relationsFile;
+  outcomesFile;
+  metricsFile;
+  revisionsFile;
+  knowledgeJsonlFile;
+  evidenceJsonlFile;
+  observationJsonlFile;
+  unknownsJsonlFile;
+  receiptsDir;
+  receiptsJsonlFile;
+  eventsFile;
+  constructor(rootDir = process.cwd()) {
+    this.baseDir = path6.resolve(rootDir, ".bilmem");
+    this.knowledgeDir = path6.join(this.baseDir, "knowledge");
+    this.evidenceDir = path6.join(this.baseDir, "evidence");
+    this.observationDir = path6.join(this.baseDir, "observations");
+    this.unknownDir = path6.join(this.baseDir, "unknowns");
+    this.rulesDir = path6.join(this.baseDir, "rules");
+    this.receiptsDir = path6.join(this.baseDir, "receipts");
+    this.configFile = path6.join(this.baseDir, "config.json");
+    this.relationsFile = path6.join(this.baseDir, "relations.json");
+    this.outcomesFile = path6.join(this.baseDir, "outcomes.jsonl");
+    this.metricsFile = path6.join(this.baseDir, "metrics.json");
+    this.revisionsFile = path6.join(this.baseDir, "revisions.jsonl");
+    this.knowledgeJsonlFile = path6.join(this.baseDir, "knowledge.jsonl");
+    this.evidenceJsonlFile = path6.join(this.baseDir, "evidence.jsonl");
+    this.observationJsonlFile = path6.join(this.baseDir, "observations.jsonl");
+    this.unknownsJsonlFile = path6.join(this.baseDir, "unknowns.jsonl");
+    this.receiptsJsonlFile = path6.join(this.baseDir, "receipts.jsonl");
+    this.eventsFile = path6.join(this.baseDir, "events.jsonl");
+  }
+  getBaseDir() {
+    return this.baseDir;
+  }
+  async isInitialized() {
+    try {
+      await fs6.access(this.configFile);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async init(options = {}) {
+    await fs6.mkdir(this.knowledgeDir, { recursive: true });
+    await fs6.mkdir(this.evidenceDir, { recursive: true });
+    await fs6.mkdir(this.observationDir, { recursive: true });
+    await fs6.mkdir(this.unknownDir, { recursive: true });
+    await fs6.mkdir(this.rulesDir, { recursive: true });
+    await fs6.mkdir(this.receiptsDir, { recursive: true });
+    let config;
+    if (await this.isInitialized()) {
+      config = await this.getConfig();
+    } else {
+      config = {
+        schemaVersion: 1,
+        projectName: options.projectName ?? path6.basename(path6.dirname(this.baseDir)) ?? "project",
+        defaultScope: options.defaultScope ?? "project",
+        dataDir: this.baseDir
+      };
+      await this.saveConfig(config);
+    }
+    try {
+      await fs6.access(this.relationsFile);
+    } catch {
+      await fs6.writeFile(this.relationsFile, JSON.stringify([], null, 2), "utf-8");
+    }
+    try {
+      await fs6.access(this.metricsFile);
+    } catch {
+      const defaultMetrics = {
+        knowledgeHits: 0,
+        knowledgeMisses: 0,
+        knowledgeReused: 0,
+        unknownsResolved: 0,
+        repeatedInvestigationsPrevented: 0,
+        candidateKnowledgeMerged: 0,
+        staleKnowledgeDetected: 0,
+        contradictionsDetected: 0,
+        knowledgePromoted: 0,
+        knowledgeSuperseded: 0
+      };
+      await fs6.writeFile(this.metricsFile, JSON.stringify(defaultMetrics, null, 2), "utf-8");
+    }
+    return config;
+  }
+  // --- Config ---
+  async getConfig() {
+    const raw = await fs6.readFile(this.configFile, "utf-8");
+    return JSON.parse(raw);
+  }
+  async saveConfig(config) {
+    await fs6.writeFile(this.configFile, JSON.stringify(config, null, 2), "utf-8");
+  }
+  async updateConfig(updates) {
+    const current = await this.getConfig();
+    const updated = { ...current, ...updates };
+    await this.saveConfig(updated);
+    return updated;
+  }
+  // --- Knowledge ---
+  async saveKnowledge(knowledge) {
+    await fs6.mkdir(this.knowledgeDir, { recursive: true });
+    const filename = `${sanitizeFileName(knowledge.id)}.json`;
+    const filePath = path6.join(this.knowledgeDir, filename);
+    await fs6.writeFile(filePath, JSON.stringify(knowledge, null, 2), "utf-8");
+    await fs6.appendFile(this.knowledgeJsonlFile, JSON.stringify(knowledge) + "\n", "utf-8");
+  }
+  async getKnowledge(id) {
+    const filename = `${sanitizeFileName(id)}.json`;
+    const filePath = path6.join(this.knowledgeDir, filename);
+    try {
+      const raw = await fs6.readFile(filePath, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+  async getAllKnowledge() {
+    try {
+      const files = await fs6.readdir(this.knowledgeDir);
+      const items = [];
+      for (const file of files) {
+        if (!file.endsWith(".json")) continue;
+        const raw = await fs6.readFile(path6.join(this.knowledgeDir, file), "utf-8");
+        try {
+          items.push(JSON.parse(raw));
+        } catch {
+        }
+      }
+      return items;
+    } catch {
+      return [];
+    }
+  }
+  async deleteKnowledge(id) {
+    const filename = `${sanitizeFileName(id)}.json`;
+    const filePath = path6.join(this.knowledgeDir, filename);
+    try {
+      await fs6.unlink(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // --- Evidence ---
+  async saveEvidence(evidence) {
+    await fs6.mkdir(this.evidenceDir, { recursive: true });
+    const filename = `${sanitizeFileName(evidence.id)}.json`;
+    const filePath = path6.join(this.evidenceDir, filename);
+    await fs6.writeFile(filePath, JSON.stringify(evidence, null, 2), "utf-8");
+    await fs6.appendFile(this.evidenceJsonlFile, JSON.stringify(evidence) + "\n", "utf-8");
+  }
+  async getEvidence(id) {
+    const filename = `${sanitizeFileName(id)}.json`;
+    const filePath = path6.join(this.evidenceDir, filename);
+    try {
+      const raw = await fs6.readFile(filePath, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+  async getAllEvidence() {
+    try {
+      const files = await fs6.readdir(this.evidenceDir);
+      const items = [];
+      for (const file of files) {
+        if (!file.endsWith(".json")) continue;
+        const raw = await fs6.readFile(path6.join(this.evidenceDir, file), "utf-8");
+        try {
+          items.push(JSON.parse(raw));
+        } catch {
+        }
+      }
+      return items;
+    } catch {
+      return [];
+    }
+  }
+  // --- Observations ---
+  async saveObservation(obs) {
+    await fs6.mkdir(this.observationDir, { recursive: true });
+    const filename = `${sanitizeFileName(obs.id)}.json`;
+    const filePath = path6.join(this.observationDir, filename);
+    await fs6.writeFile(filePath, JSON.stringify(obs, null, 2), "utf-8");
+    await fs6.appendFile(this.observationJsonlFile, JSON.stringify(obs) + "\n", "utf-8");
+  }
+  async getObservation(id) {
+    const filename = `${sanitizeFileName(id)}.json`;
+    const filePath = path6.join(this.observationDir, filename);
+    try {
+      const raw = await fs6.readFile(filePath, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+  async getAllObservations() {
+    try {
+      const files = await fs6.readdir(this.observationDir);
+      const items = [];
+      for (const file of files) {
+        if (!file.endsWith(".json")) continue;
+        const raw = await fs6.readFile(path6.join(this.observationDir, file), "utf-8");
+        try {
+          items.push(JSON.parse(raw));
+        } catch {
+        }
+      }
+      return items;
+    } catch {
+      return [];
+    }
+  }
+  async deleteObservation(id) {
+    const filename = `${sanitizeFileName(id)}.json`;
+    const filePath = path6.join(this.observationDir, filename);
+    try {
+      await fs6.unlink(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // --- Unknowns ---
+  async saveUnknown(record) {
+    await fs6.mkdir(this.unknownDir, { recursive: true });
+    const filename = `${sanitizeFileName(record.id)}.json`;
+    const filePath = path6.join(this.unknownDir, filename);
+    await fs6.writeFile(filePath, JSON.stringify(record, null, 2), "utf-8");
+    await fs6.appendFile(this.unknownsJsonlFile, JSON.stringify(record) + "\n", "utf-8");
+  }
+  async getUnknown(id) {
+    const filename = `${sanitizeFileName(id)}.json`;
+    const filePath = path6.join(this.unknownDir, filename);
+    try {
+      const raw = await fs6.readFile(filePath, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+  async getAllUnknowns() {
+    try {
+      const files = await fs6.readdir(this.unknownDir);
+      const items = [];
+      for (const file of files) {
+        if (!file.endsWith(".json")) continue;
+        const raw = await fs6.readFile(path6.join(this.unknownDir, file), "utf-8");
+        try {
+          items.push(JSON.parse(raw));
+        } catch {
+        }
+      }
+      return items;
+    } catch {
+      return [];
+    }
+  }
+  async deleteUnknown(id) {
+    const filename = `${sanitizeFileName(id)}.json`;
+    const filePath = path6.join(this.unknownDir, filename);
+    try {
+      await fs6.unlink(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // --- Outcomes (Append-oriented log) ---
+  async appendOutcome(outcome) {
+    const line = JSON.stringify(outcome) + "\n";
+    await fs6.appendFile(this.outcomesFile, line, "utf-8");
+    if (outcome.knowledgeId) {
+      await this.appendMetricEvent({
+        type: "outcome",
+        knowledgeId: outcome.knowledgeId,
+        result: outcome.result,
+        timestamp: Date.now()
+      });
+      if (outcome.result === "success") {
+        await this.appendMetricEvent({
+          type: "question_resolved",
+          questionId: outcome.knowledgeId,
+          timestamp: Date.now()
+        });
+      }
+    }
+  }
+  async getAllOutcomes() {
+    try {
+      const raw = await fs6.readFile(this.outcomesFile, "utf-8");
+      const lines = raw.split("\n").filter((l) => l.trim().length > 0);
+      return lines.map((l) => JSON.parse(l));
+    } catch {
+      return [];
+    }
+  }
+  // --- Metric Events (Append-only local log) ---
+  async appendMetricEvent(event) {
+    try {
+      await fs6.mkdir(this.baseDir, { recursive: true });
+      await fs6.appendFile(this.eventsFile, JSON.stringify(event) + "\n", "utf-8");
+    } catch {
+    }
+  }
+  async getMetricEvents(filter) {
+    return readMetricEvents(path6.dirname(this.baseDir), filter);
+  }
+  async resetMetricEvents() {
+    return resetMetricEvents(path6.dirname(this.baseDir));
+  }
+  // --- Investigation Receipts ---
+  async saveReceipt(receipt) {
+    await fs6.mkdir(this.receiptsDir, { recursive: true });
+    const filename = `${sanitizeFileName(receipt.id)}.json`;
+    const filePath = path6.join(this.receiptsDir, filename);
+    await fs6.writeFile(filePath, JSON.stringify(receipt, null, 2), "utf-8");
+    await fs6.appendFile(this.receiptsJsonlFile, JSON.stringify(receipt) + "\n", "utf-8");
+  }
+  async getReceipt(id) {
+    const filename = `${sanitizeFileName(id)}.json`;
+    const filePath = path6.join(this.receiptsDir, filename);
+    try {
+      const raw = await fs6.readFile(filePath, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+  async getAllReceipts() {
+    try {
+      const files = await fs6.readdir(this.receiptsDir);
+      const items = [];
+      for (const file of files) {
+        if (!file.endsWith(".json")) continue;
+        const raw = await fs6.readFile(path6.join(this.receiptsDir, file), "utf-8");
+        try {
+          items.push(JSON.parse(raw));
+        } catch {
+        }
+      }
+      return items;
+    } catch {
+      return [];
+    }
+  }
+  // --- Relations ---
+  async getRelations() {
+    try {
+      const raw = await fs6.readFile(this.relationsFile, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return [];
+    }
+  }
+  async saveRelations(relations) {
+    await fs6.writeFile(this.relationsFile, JSON.stringify(relations, null, 2), "utf-8");
+  }
+  // --- Metrics ---
+  async getMetrics() {
+    try {
+      const raw = await fs6.readFile(this.metricsFile, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return {
+        knowledgeHits: 0,
+        knowledgeMisses: 0,
+        knowledgeReused: 0,
+        unknownsResolved: 0,
+        repeatedInvestigationsPrevented: 0,
+        candidateKnowledgeMerged: 0,
+        staleKnowledgeDetected: 0,
+        contradictionsDetected: 0,
+        knowledgePromoted: 0,
+        knowledgeSuperseded: 0
+      };
+    }
+  }
+  async saveMetrics(metrics) {
+    await fs6.writeFile(this.metricsFile, JSON.stringify(metrics, null, 2), "utf-8");
+  }
+  // --- Rules ---
+  getRulesDir() {
+    return this.rulesDir;
+  }
+  async loadRuleSets() {
+    const files = await findRuleFiles(path6.dirname(this.baseDir), this.rulesDir);
+    const sets = [];
+    for (const f of files) {
+      try {
+        sets.push(await loadRuleSetFile(f));
+      } catch {
+      }
+    }
+    return sets;
+  }
+  async saveRuleSet(ruleSet, fileName = "default.yml") {
+    await fs6.mkdir(this.rulesDir, { recursive: true });
+    const cleanName = fileName.endsWith(".yml") || fileName.endsWith(".yaml") ? fileName : `${fileName}.yml`;
+    const targetPath = path6.join(this.rulesDir, cleanName);
+    const yaml = stringifyRuleSetYaml(ruleSet);
+    await fs6.writeFile(targetPath, yaml, "utf-8");
+    return targetPath;
+  }
+  async addRule(rule, fileName = "default.yml") {
+    await fs6.mkdir(this.rulesDir, { recursive: true });
+    const cleanName = fileName.endsWith(".yml") || fileName.endsWith(".yaml") ? fileName : `${fileName}.yml`;
+    const targetPath = path6.join(this.rulesDir, cleanName);
+    let existingSet;
+    try {
+      existingSet = await loadRuleSetFile(targetPath);
+    } catch {
+      existingSet = {
+        name: path6.basename(cleanName, path6.extname(cleanName)),
+        rules: []
+      };
+    }
+    const existingIdx = existingSet.rules.findIndex((r) => r.id === rule.id);
+    if (existingIdx >= 0) {
+      existingSet.rules[existingIdx] = rule;
+    } else {
+      existingSet.rules.push(rule);
+    }
+    const yaml = stringifyRuleSetYaml(existingSet);
+    await fs6.writeFile(targetPath, yaml, "utf-8");
+    return targetPath;
+  }
+  // --- Revisions & Incremental Learning Diff ---
+  async appendRevision(snapshot) {
+    const line = JSON.stringify(snapshot) + "\n";
+    await fs6.appendFile(this.revisionsFile, line, "utf-8");
+  }
+  async getRevisions() {
+    try {
+      const raw = await fs6.readFile(this.revisionsFile, "utf-8");
+      const lines = raw.split("\n").filter((l) => l.trim().length > 0);
+      return lines.map((l) => JSON.parse(l));
+    } catch {
+      return [];
+    }
+  }
+  async getLatestRevision() {
+    const revs = await this.getRevisions();
+    return revs.length > 0 ? revs[revs.length - 1] : void 0;
+  }
+  async getDiff(sinceRef) {
+    const revisions = await this.getRevisions();
+    let baselineSnapshot;
+    let targetSnapshot;
+    if (sinceRef && sinceRef.includes("..")) {
+      const [startRef, endRef] = sinceRef.split("..").map((s) => s.trim().toLowerCase());
+      baselineSnapshot = revisions.find(
+        (r) => r.id.toLowerCase() === startRef || r.commit?.toLowerCase() === startRef || r.commit?.toLowerCase().startsWith(startRef) || r.id.toLowerCase().startsWith(startRef)
+      );
+      targetSnapshot = revisions.find(
+        (r) => r.id.toLowerCase() === endRef || r.commit?.toLowerCase() === endRef || r.commit?.toLowerCase().startsWith(endRef) || r.id.toLowerCase().startsWith(endRef)
+      );
+    } else if (sinceRef) {
+      const cleanRef = sinceRef.trim().toLowerCase();
+      baselineSnapshot = revisions.find(
+        (r) => r.id.toLowerCase() === cleanRef || r.commit?.toLowerCase() === cleanRef || r.commit?.toLowerCase().startsWith(cleanRef) || r.id.toLowerCase().startsWith(cleanRef)
+      );
+    } else {
+      if (revisions.length >= 2) {
+        baselineSnapshot = revisions[revisions.length - 2];
+      } else if (revisions.length === 1) {
+        baselineSnapshot = revisions[0];
+      }
+    }
+    const baselineTimestamp = baselineSnapshot?.timestamp ?? "1970-01-01T00:00:00.000Z";
+    const baselineTime = new Date(baselineTimestamp).getTime();
+    const targetTime = targetSnapshot ? new Date(targetSnapshot.timestamp).getTime() : Date.now();
+    const inWindow = (time) => time >= baselineTime && time <= targetTime;
+    const allObservations = await this.getAllObservations();
+    const allKnowledge = await this.getAllKnowledge();
+    const allUnknowns = await this.getAllUnknowns();
+    let observationsAdded = 0;
+    for (const obs of allObservations) {
+      const obsTime = new Date(obs.recordedAt || obs.provenance?.timestamp || 0).getTime();
+      if (inWindow(obsTime)) {
+        observationsAdded++;
+      }
+    }
+    let candidatesAdded = 0;
+    let strengthenedCount = 0;
+    let revisedCount = 0;
+    let contradictionCount = 0;
+    let invalidatedCount = 0;
+    let needsRevalidationCount = 0;
+    const strengthened = [];
+    const revised = [];
+    const contradictions = [];
+    const invalidated = [];
+    const needsRevalidation = [];
+    for (const k of allKnowledge) {
+      const createdTime = new Date(k.createdAt).getTime();
+      const updatedTime = new Date(k.updatedAt).getTime();
+      if ((k.status === "invalid" || k.status === "invalidated") && inWindow(updatedTime)) {
+        invalidatedCount++;
+        invalidated.push(k.id);
+        continue;
+      }
+      if (k.status === "contradicted" && inWindow(updatedTime)) {
+        contradictionCount++;
+        contradictions.push(k.id);
+        continue;
+      }
+      if ((k.status === "needs_revalidation" || k.status === "stale") && inWindow(updatedTime)) {
+        needsRevalidationCount++;
+        needsRevalidation.push(k.id);
+        continue;
+      }
+      if (inWindow(createdTime)) {
+        candidatesAdded++;
+      } else if (inWindow(updatedTime)) {
+        if (k.metrics.support_count > 1 || k.confidence >= 0.85 || k.metrics.successful_outcomes > 0) {
+          strengthenedCount++;
+          strengthened.push(k.id);
+        } else {
+          revisedCount++;
+          revised.push(k.id);
+        }
+      }
+    }
+    let unknownsCount = 0;
+    const unknownsList = [];
+    for (const u of allUnknowns) {
+      const uTime = new Date(u.createdAt || u.updatedAt || 0).getTime();
+      if (inWindow(uTime)) {
+        unknownsCount++;
+        unknownsList.push(u.id);
+      }
+    }
+    const refLabel = sinceRef ?? (baselineSnapshot ? baselineSnapshot.commit?.slice(0, 7) || baselineSnapshot.id.slice(0, 7) : void 0);
+    return {
+      sinceRef: refLabel,
+      observationsAdded,
+      candidatesAdded,
+      strengthenedCount,
+      revisedCount,
+      contradictionCount,
+      unknownsCount,
+      needsRevalidationCount,
+      invalidatedCount,
+      details: {
+        strengthened,
+        revised,
+        contradictions,
+        unknowns: unknownsList,
+        needsRevalidation,
+        invalidated
+      }
+    };
+  }
+};
+
+// src/search/indexer.ts
+import { create, insert, remove, search } from "@orama/orama";
+var SearchIndex = class {
+  db = null;
+  idToDocId = /* @__PURE__ */ new Map();
+  async init() {
+    this.db = await create({
+      schema: {
+        id: "string",
+        statement: "string",
+        type: "string",
+        scope: "string",
+        status: "string",
+        positive: "string[]",
+        negative: "string[]",
+        tags: "string[]"
+      }
+    });
+    this.idToDocId.clear();
+  }
+  async buildIndex(knowledgeList) {
+    await this.init();
+    for (const item of knowledgeList) {
+      await this.upsert(item);
+    }
+  }
+  async upsert(item) {
+    if (!this.db) {
+      await this.init();
+    }
+    const existingDocId = this.idToDocId.get(item.id);
+    if (existingDocId) {
+      try {
+        await remove(this.db, existingDocId);
+      } catch {
+      }
+      this.idToDocId.delete(item.id);
+    }
+    const docId = await insert(this.db, {
+      id: item.id,
+      statement: item.statement,
+      type: item.type,
+      scope: item.scope,
+      status: item.status,
+      positive: item.positive,
+      negative: item.negative,
+      tags: item.tags ?? []
+    });
+    this.idToDocId.set(item.id, docId);
+  }
+  async delete(id) {
+    if (!this.db) return;
+    const docId = this.idToDocId.get(id);
+    if (docId) {
+      try {
+        await remove(this.db, docId);
+      } catch {
+      }
+      this.idToDocId.delete(id);
+    }
+  }
+  async searchCandidates(term, limit = 25) {
+    if (!this.db) {
+      return [];
+    }
+    const cleanTerm = term.trim();
+    if (!cleanTerm) {
+      return Array.from(this.idToDocId.keys()).slice(0, limit);
+    }
+    try {
+      const results = await search(this.db, {
+        term: cleanTerm,
+        limit,
+        threshold: 0.2
+      });
+      return results.hits.map((h) => h.document.id);
+    } catch {
+      return Array.from(this.idToDocId.keys()).slice(0, limit);
+    }
+  }
+  size() {
+    return this.idToDocId.size;
+  }
+};
+
+// src/rules/evaluator.ts
+function globToRegex(glob) {
+  let pattern = glob.trim().replace(/^\//, "").replace(/\/$/, "");
+  pattern = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  pattern = pattern.replace(/\*\*/g, ".*");
+  pattern = pattern.replace(/\*/g, "[^/]*");
+  pattern = pattern.replace(/\?/g, "[^/]");
+  return new RegExp(`(^|/)${pattern}$`, "i");
+}
+async function evaluateRule(rule, context) {
+  const cond = rule.when;
+  if (!cond || Object.keys(cond).length === 0) {
+    return {
+      rule,
+      matched: true,
+      reason: "Always active project rule"
+    };
+  }
+  const matchedFiles = [];
+  if (cond.has_file) {
+    const files = Array.isArray(cond.has_file) ? cond.has_file : [cond.has_file];
+    for (const f of files) {
+      if (!context.hasFile(f)) {
+        return {
+          rule,
+          matched: false,
+          reason: `Required file '${f}' not found in project`
+        };
+      }
+      matchedFiles.push(f);
+    }
+  }
+  if (cond.missing_file) {
+    const files = Array.isArray(cond.missing_file) ? cond.missing_file : [cond.missing_file];
+    for (const f of files) {
+      if (context.hasFile(f)) {
+        return {
+          rule,
+          matched: false,
+          reason: `Prohibited file '${f}' is present in project`
+        };
+      }
+    }
+  }
+  if (cond.any_file && cond.any_file.length > 0) {
+    let anyFound = false;
+    for (const f of cond.any_file) {
+      if (context.hasFile(f)) {
+        anyFound = true;
+        matchedFiles.push(f);
+        break;
+      }
+    }
+    if (!anyFound) {
+      return {
+        rule,
+        matched: false,
+        reason: `None of the expected files were found: ${cond.any_file.join(", ")}`
+      };
+    }
+  }
+  if (cond.file_pattern) {
+    const regex = globToRegex(cond.file_pattern);
+    const matches = context.files.filter(
+      (f) => regex.test(f.relativePath) || regex.test(f.name)
+    );
+    if (matches.length === 0) {
+      return {
+        rule,
+        matched: false,
+        reason: `No files matched pattern '${cond.file_pattern}'`
+      };
+    }
+    matchedFiles.push(...matches.slice(0, 5).map((m) => m.relativePath));
+  }
+  if (cond.content_match) {
+    const { files: targetFile, pattern } = cond.content_match;
+    const regex = new RegExp(pattern, "m");
+    if (targetFile) {
+      const content = await context.readText(targetFile);
+      if (!content || !regex.test(content)) {
+        return {
+          rule,
+          matched: false,
+          reason: `Pattern '${pattern}' was not found in file '${targetFile}'`
+        };
+      }
+      matchedFiles.push(targetFile);
+    } else {
+      let contentFound = false;
+      for (const file of context.files.slice(0, 20)) {
+        const content = await context.readText(file.relativePath);
+        if (content && regex.test(content)) {
+          contentFound = true;
+          matchedFiles.push(file.relativePath);
+          break;
+        }
+      }
+      if (!contentFound) {
+        return {
+          rule,
+          matched: false,
+          reason: `Pattern '${pattern}' was not found in project files`
+        };
+      }
+    }
+  }
+  return {
+    rule,
+    matched: true,
+    reason: "Rule condition matched repository structure",
+    matchedFiles: matchedFiles.length > 0 ? Array.from(new Set(matchedFiles)) : void 0
+  };
+}
+function ruleToObservation(rule, evaluated, sourceFile) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const ruleType = rule.type ?? "rule";
+  const positive = [
+    ...rule.positive ?? [],
+    rule.id,
+    ruleType,
+    ...rule.tags ?? []
+  ];
+  return createObservation({
+    source: `rule:${rule.id}`,
+    claim: rule.statement,
+    confidence: rule.confidence ?? 0.95,
+    provenance: {
+      type: "file",
+      path: sourceFile,
+      timestamp: now
+    },
+    positive: Array.from(new Set(positive)),
+    negative: rule.negative ? [...rule.negative] : [],
+    details: {
+      ruleId: rule.id,
+      ruleName: rule.name,
+      ruleType,
+      matchedReason: evaluated.reason,
+      matchedFiles: evaluated.matchedFiles,
+      scope: rule.scope ?? "project",
+      ...rule.details ?? {}
+    }
+  });
+}
+function ruleToCandidateLesson(rule, evaluated, obsSource) {
+  const ruleType = rule.type ?? "rule";
+  const positive = [
+    ...rule.positive ?? [],
+    rule.id,
+    ruleType,
+    ...rule.tags ?? []
+  ];
+  return {
+    id: `rule.${rule.id}`,
+    type: ruleType,
+    statement: rule.statement,
+    positive: Array.from(new Set(positive)),
+    negative: rule.negative ? [...rule.negative] : [],
+    confidence: rule.confidence ?? 0.95,
+    evidence: [obsSource],
+    scope: rule.scope ?? "project",
+    tags: rule.tags ? [...rule.tags] : []
+  };
+}
+
+// src/scanner/engine.ts
+async function scanRepository(rootDir = process.cwd(), options = {}) {
+  const storage = new Storage(rootDir);
+  const dryRun = options.dryRun ?? false;
+  const plannedActions = [];
+  const config = dryRun ? await storage.isInitialized() ? await storage.getConfig() : {
+    schemaVersion: 1,
+    projectName: path7.basename(rootDir),
+    defaultScope: "project",
+    dataDir: path7.join(rootDir, ".bilmem")
+  } : await storage.init();
+  const incremental = options.incremental ?? false;
+  const lastScanCommit = incremental ? config.lastScanCommit : void 0;
+  const scannedFiles = await walkDirectory(rootDir);
+  const fsObs = await analyzeProjectStructure(scannedFiles, rootDir);
+  const projectContext = new ProjectContext(scannedFiles, rootDir);
+  const ruleObs = [];
+  const ruleCandidateLessons = [];
+  const { ruleSets, sourceFiles } = await loadAllProjectRuleSets(rootDir, storage.getRulesDir());
+  for (let idx = 0; idx < ruleSets.length; idx++) {
+    const set = ruleSets[idx];
+    const sourceFile = sourceFiles[idx] || "rules.yml";
+    for (const rule of set.rules) {
+      const evalResult = await evaluateRule(rule, projectContext);
+      if (evalResult.matched) {
+        const obs = ruleToObservation(rule, evalResult, sourceFile);
+        ruleObs.push(obs);
+        ruleCandidateLessons.push(ruleToCandidateLesson(rule, evalResult, obs.source));
+      }
+    }
+  }
+  const mdObs = [];
+  const srcObs = [];
+  const relations = [];
+  for (const file of scannedFiles) {
+    if (file.ext === ".md") {
+      const res = await parseMarkdownFile(file.path, file.relativePath);
+      mdObs.push(...res.observations);
+      if (res.relations && res.relations.length > 0) {
+        relations.push(...res.relations);
+      }
+    } else if (isSourceFile(file.ext)) {
+      const res = await analyzeSourceFile(file.path, file.relativePath);
+      srcObs.push(...res.observations);
+      relations.push(...res.relations);
+    }
+  }
+  const gitResult = await scanGitHistory(rootDir, {
+    lastScanCommit,
+    maxCommits: options.maxCommits ?? 100
+  });
+  relations.push(...gitResult.relations);
+  const allObs = [...fsObs, ...ruleObs, ...mdObs, ...srcObs, ...gitResult.observations];
+  if (!dryRun) {
+    for (const obs of allObs) {
+      await storage.saveObservation(obs);
+    }
+    const graph = new EvidenceGraph(await storage.getRelations());
+    for (const r of relations) {
+      graph.addRelation(r);
+    }
+    await storage.saveRelations(graph.getAllRelations());
+  } else {
+    plannedActions.push(`Would persist ${allObs.length} observations`);
+    plannedActions.push(`Would record ${relations.length} evidence relations`);
+  }
+  const evidenceNodes = [];
+  for (const obs of allObs) {
+    const ev = createEvidence(obs, "supports");
+    if (!dryRun) {
+      await storage.saveEvidence(ev);
+    }
+    evidenceNodes.push(ev);
+  }
+  if (dryRun) {
+    plannedActions.push(`Would create ${evidenceNodes.length} evidence nodes`);
+  }
+  const candidateLessons = [
+    ...ruleCandidateLessons
+  ];
+  for (const o of mdObs) {
+    if (o.source.includes(":adr") || o.claim.startsWith("[WARNING]") || o.claim.startsWith("[CAUTION]")) {
+      const id = `decision.${path7.basename(o.provenance.path || "doc", ".md")}.${o.provenance.line || "adr"}`;
+      candidateLessons.push({
+        id,
+        type: "decision",
+        statement: o.claim,
+        positive: o.positive ?? [],
+        negative: o.negative ?? [],
+        confidence: o.confidence,
+        evidence: [o.source],
+        scope: "project"
+      });
+    }
+  }
+  for (const o of gitResult.observations) {
+    if (o.positive?.includes("revert")) {
+      candidateLessons.push({
+        id: `git.lesson.${o.provenance.commit || "revert"}`,
+        type: "lesson",
+        statement: `Caution: ${o.claim}`,
+        positive: o.positive,
+        negative: ["untested-assumption"],
+        confidence: o.confidence,
+        evidence: [o.source],
+        scope: "project"
+      });
+    }
+  }
+  const relPaths = new Set(scannedFiles.map((f) => f.relativePath.toLowerCase()));
+  const hasMigrations = Array.from(relPaths).some((p) => p.includes("migration") || p.includes("migrate"));
+  const hasDb = Array.from(relPaths).some((p) => p.includes("db") || p.includes("database") || p.includes("sql"));
+  let unknownCount = 0;
+  if (hasDb && !hasMigrations) {
+    unknownCount++;
+    const unknownRec = createUnknown({
+      id: "project.database.migration",
+      state: "UNKNOWN",
+      reason: "UNRESOLVABLE_LOCALLY",
+      statement: "Database directory exists, but no explicit migration tool or folder was found locally.",
+      checked: ["package.json", "src/db/**", "scripts/**"],
+      next: {
+        type: "ask",
+        question: "How are database migrations performed in this project?"
+      },
+      scope: "project"
+    });
+    if (!dryRun) {
+      await storage.saveUnknown(unknownRec);
+    } else {
+      plannedActions.push(`Would register unknown: "${unknownRec.statement}"`);
+    }
+  }
+  const existingKnowledge = await storage.getAllKnowledge();
+  let createdCount = 0;
+  let updatedCount = 0;
+  for (const cand of candidateLessons) {
+    const rec = reconcileKnowledge(cand, existingKnowledge);
+    if (!dryRun) {
+      const { updatedKnowledge, action } = applyReconciliation(rec, cand, existingKnowledge, storage);
+      await storage.saveKnowledge(updatedKnowledge);
+      if (action === "NEW" || action === "SPECIALIZE") {
+        createdCount++;
+        existingKnowledge.push(updatedKnowledge);
+      } else if (action === "SUPPORT" || action === "UPDATE" || action === "MERGE" || action === "CONTRADICT") {
+        updatedCount++;
+      }
+    } else {
+      plannedActions.push(`Would reconcile [${rec.action}]: "${cand.statement}" (${rec.reason})`);
+      if (rec.action === "NEW" || rec.action === "SPECIALIZE") {
+        createdCount++;
+      } else if (rec.action !== "IGNORE") {
+        updatedCount++;
+      }
+    }
+  }
+  if (!dryRun) {
+    const index = new SearchIndex();
+    await index.buildIndex(existingKnowledge);
+    await storage.updateConfig({
+      lastScanCommit: gitResult.headCommit ?? config.lastScanCommit,
+      lastScanTimestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    await storage.appendRevision({
+      id: `rev_${Date.now().toString(36)}`,
+      commit: gitResult.headCommit,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      action: "scan",
+      observationCount: allObs.length,
+      evidenceCount: evidenceNodes.length,
+      knowledgeCount: existingKnowledge.length,
+      activeCount: existingKnowledge.filter((k) => k.status === "active").length,
+      contradictedCount: existingKnowledge.filter((k) => k.status === "contradicted").length,
+      staleCount: existingKnowledge.filter((k) => k.status === "stale").length,
+      changesSummary: `Scanned ${scannedFiles.length} files: +${allObs.length} obs, +${createdCount} candidates, ~${updatedCount} updated.`
+    });
+  }
+  const unknowns = dryRun ? [] : await storage.getAllUnknowns();
+  return {
+    filesScanned: scannedFiles.length,
+    observationsCreated: allObs.length,
+    evidenceCreated: evidenceNodes.length,
+    knowledgeCreated: createdCount,
+    knowledgeUpdated: updatedCount,
+    unknownsCount: dryRun ? unknownCount : unknowns.length,
+    gitCommitsScanned: gitResult.commitsScanned,
+    headCommit: gitResult.headCommit,
+    incremental,
+    dryRun,
+    plannedActions: dryRun ? plannedActions : void 0
+  };
+}
+export {
+  BUILTIN_DETECTORS,
+  BUILTIN_MARKDOWN_EXTRACTORS,
+  ConventionRegistry,
+  MarkdownRegistry,
+  ProjectContext,
+  analyzeProjectStructure,
+  analyzeSourceFile,
+  defaultMarkdownRegistry,
+  defaultRegistry,
+  isGitRepository,
+  isSourceFile,
+  parseMarkdownDocument,
+  parseMarkdownFile,
+  registerConventionDetector,
+  registerMarkdownExtractor,
+  scanGitHistory,
+  scanRepository,
+  walkDirectory
+};
+//# sourceMappingURL=index.js.map