bilmem 0.1.0

package/dist/core/index.js

@@ -0,0 +1,1975 @@
+// 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/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;
+}
+function recordOutcomeOnKnowledge(knowledge, outcome) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const summary = knowledge.outcomesSummary ?? {
+    applied: 0,
+    successful: 0,
+    misleading: 0,
+    neutral: 0
+  };
+  summary.applied++;
+  let actionTaken;
+  if (outcome.result === "success") {
+    summary.successful++;
+    knowledge.metrics.successful_outcomes++;
+    knowledge.metrics.reuse_count++;
+    const promo = evaluatePromotion({ ...knowledge, outcomesSummary: summary });
+    if (promo.promoted) {
+      knowledge.stage = promo.newStage;
+      actionTaken = `Promoted to ${promo.newStage} (${promo.reason})`;
+      const history = knowledge.history ?? [];
+      history.push({
+        timestamp: now,
+        status: knowledge.status,
+        action: "promote",
+        reason: promo.reason
+      });
+      knowledge.history = history;
+    }
+  } else if (outcome.result === "failure" || outcome.result === "reverted") {
+    summary.misleading++;
+    knowledge.metrics.failed_outcomes++;
+    if (summary.misleading >= 2 && summary.misleading > summary.successful) {
+      knowledge.status = "needs_revalidation";
+      actionTaken = `Marked needs_revalidation: ${summary.misleading} misleading outcomes recorded`;
+      const history = knowledge.history ?? [];
+      history.push({
+        timestamp: now,
+        status: "needs_revalidation",
+        action: "demote",
+        reason: actionTaken
+      });
+      knowledge.history = history;
+    }
+  } else {
+    summary.neutral++;
+  }
+  knowledge.outcomesSummary = summary;
+  knowledge.value = calculateKnowledgeValue(knowledge);
+  knowledge.updatedAt = now;
+  return { updatedKnowledge: knowledge, actionTaken };
+}
+function enforceKnowledgeBudget(knowledgeList, budget) {
+  if (!budget || !budget.active || budget.active <= 0) {
+    return { modifiedList: knowledgeList, demotedCount: 0 };
+  }
+  const activeItems = knowledgeList.filter((k) => k.status === "active" && k.stage === "active");
+  if (activeItems.length <= budget.active) {
+    return { modifiedList: knowledgeList, demotedCount: 0 };
+  }
+  activeItems.sort((a, b) => calculateKnowledgeValue(a) - calculateKnowledgeValue(b));
+  const excessCount = activeItems.length - budget.active;
+  const toDemote = new Set(activeItems.slice(0, excessCount).map((k) => k.id));
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const modifiedList = knowledgeList.map((k) => {
+    if (toDemote.has(k.id)) {
+      const history = k.history ?? [];
+      k.stage = "probation";
+      k.status = "probation";
+      k.updatedAt = now;
+      k.history = [
+        ...history,
+        {
+          timestamp: now,
+          stage: "probation",
+          status: "probation",
+          action: "budget_demotion",
+          reason: `Active items exceeded budget (${budget.active}). Demoted to probation based on knowledge value.`
+        }
+      ];
+      return k;
+    }
+    return k;
+  });
+  return { modifiedList, demotedCount: excessCount };
+}
+
+// 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/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
+  };
+}
+function hasBeenInvestigated(unknowns, target) {
+  const normalizedTarget = target.trim().toLowerCase();
+  for (const record of unknowns) {
+    if (record.id.toLowerCase() === normalizedTarget) {
+      return { investigated: true, record, reason: record.reason };
+    }
+    const checkedMatch = record.checked.some((c) => {
+      const nc = c.toLowerCase();
+      return nc === normalizedTarget || normalizedTarget.startsWith(nc.replace("/**", ""));
+    });
+    if (checkedMatch) {
+      return { investigated: true, record, reason: record.reason };
+    }
+  }
+  return { investigated: false };
+}
+function updateUnknown(record, updates) {
+  const checked = new Set(record.checked);
+  if (updates.addChecked) {
+    for (const c of updates.addChecked) {
+      checked.add(c.trim());
+    }
+  }
+  return {
+    ...record,
+    state: updates.state ?? record.state,
+    reason: updates.reason ?? record.reason,
+    statement: updates.statement !== void 0 ? updates.statement : record.statement,
+    checked: Array.from(checked),
+    next: updates.next !== void 0 ? updates.next : record.next,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/core/outcome.ts
+function createOutcome(params) {
+  const content = `${params.knowledgeId || "none"}:${params.result}:${Date.now()}`;
+  return {
+    id: `out_${hashString(content)}`,
+    knowledgeId: params.knowledgeId,
+    taskId: params.taskId,
+    result: params.result,
+    context: params.context,
+    feedback: params.feedback,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function applyOutcomeToKnowledge(knowledge, outcome) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  knowledge.metrics.reuse_count++;
+  knowledge.metrics.last_used = now;
+  if (outcome.result === "success") {
+    knowledge.metrics.successful_outcomes++;
+  } else if (outcome.result === "failure" || outcome.result === "reverted") {
+    knowledge.metrics.failed_outcomes++;
+  }
+  knowledge.confidence = calculateEffectiveConfidence(knowledge);
+  knowledge.updatedAt = now;
+  return knowledge;
+}
+var MetricsTracker = class {
+  metrics = {
+    knowledgeHits: 0,
+    knowledgeMisses: 0,
+    knowledgeReused: 0,
+    unknownsResolved: 0,
+    repeatedInvestigationsPrevented: 0,
+    candidateKnowledgeMerged: 0,
+    staleKnowledgeDetected: 0,
+    contradictionsDetected: 0,
+    knowledgePromoted: 0,
+    knowledgeSuperseded: 0
+  };
+  constructor(initial) {
+    if (initial) {
+      this.metrics = { ...this.metrics, ...initial };
+    }
+  }
+  recordHit() {
+    this.metrics.knowledgeHits++;
+  }
+  recordMiss() {
+    this.metrics.knowledgeMisses++;
+  }
+  recordReused() {
+    this.metrics.knowledgeReused++;
+  }
+  recordUnknownResolved() {
+    this.metrics.unknownsResolved++;
+  }
+  recordInvestigationPrevented() {
+    this.metrics.repeatedInvestigationsPrevented++;
+  }
+  recordCandidateMerged() {
+    this.metrics.candidateKnowledgeMerged++;
+  }
+  recordStaleDetected() {
+    this.metrics.staleKnowledgeDetected++;
+  }
+  recordContradiction() {
+    this.metrics.contradictionsDetected++;
+  }
+  recordPromoted() {
+    this.metrics.knowledgePromoted++;
+  }
+  recordSuperseded() {
+    this.metrics.knowledgeSuperseded++;
+  }
+  getMetrics() {
+    return { ...this.metrics };
+  }
+  toJSON() {
+    return this.metrics;
+  }
+};
+
+// src/core/learn.ts
+import { createHash as createHash2 } from "crypto";
+function distillTrajectory(trajectory) {
+  const events = trajectory.events || [];
+  if (events.length === 0) return null;
+  const failures = events.filter((e) => e.type === "failure" || e.type === "revert");
+  const successes = events.filter((e) => e.type === "success");
+  const corrections = events.filter((e) => e.type === "user_correction");
+  if (successes.length === 0 && corrections.length === 0 && failures.length === 0) {
+    return null;
+  }
+  const positiveSignals = /* @__PURE__ */ new Set();
+  const negativeSignals = /* @__PURE__ */ new Set();
+  const tags = /* @__PURE__ */ new Set(["lesson", "trajectory"]);
+  for (const f of failures) {
+    negativeSignals.add(f.description.toLowerCase().replace(/[^a-z0-9_-]/g, "-"));
+    if (f.path) negativeSignals.add(f.path.toLowerCase());
+  }
+  for (const s of successes) {
+    positiveSignals.add(s.description.toLowerCase().replace(/[^a-z0-9_-]/g, "-"));
+    if (s.path) positiveSignals.add(s.path.toLowerCase());
+  }
+  for (const c of corrections) {
+    positiveSignals.add(c.description.toLowerCase().replace(/[^a-z0-9_-]/g, "-"));
+    tags.add("user-correction");
+  }
+  const goalTokens = trajectory.goal.toLowerCase().replace(/[^a-z0-9_-]/g, " ").split(/\s+/).filter((w) => w.length > 3);
+  for (const t of goalTokens) {
+    positiveSignals.add(t);
+  }
+  let statement = "";
+  let reasoning = "";
+  if (corrections.length > 0) {
+    const lastCorr = corrections[corrections.length - 1];
+    statement = `Corrected approach for "${trajectory.goal}": ${lastCorr.description}`;
+    reasoning = `Based on user correction during task ${trajectory.taskId}`;
+  } else if (successes.length > 0) {
+    const lastSuccess = successes[successes.length - 1];
+    if (failures.length > 0) {
+      const firstFailure = failures[0];
+      statement = `When addressing "${trajectory.goal}": prefer ${lastSuccess.description} over ${firstFailure.description}`;
+      reasoning = `Initial attempt (${firstFailure.description}) failed/reverted; resolved by ${lastSuccess.description}`;
+    } else {
+      statement = `Effective pattern for "${trajectory.goal}": ${lastSuccess.description}`;
+      reasoning = `Directly succeeded in task ${trajectory.taskId}`;
+    }
+  } else if (failures.length > 0) {
+    const failureList = failures.map((f) => f.description).join(", ");
+    statement = `Avoid for "${trajectory.goal}": approaches [${failureList}] failed`;
+    reasoning = `Recorded ${failures.length} failed attempts in task ${trajectory.taskId}`;
+  }
+  const hash = createHash2("sha256").update(`${trajectory.goal}:${statement}`).digest("hex").slice(0, 12);
+  const id = `lesson.${trajectory.taskId || hash}`;
+  return {
+    id,
+    statement,
+    positive: Array.from(positiveSignals).slice(0, 8),
+    negative: Array.from(negativeSignals).slice(0, 8),
+    confidence: corrections.length > 0 ? 0.95 : successes.length > 0 ? 0.85 : 0.65,
+    evidence: [`trajectory:${trajectory.taskId}`],
+    tags: Array.from(tags),
+    reasoning
+  };
+}
+function learnFromTrajectory(trajectory, existingKnowledge = [], options = {}) {
+  const dryRun = options.dryRun ?? false;
+  const storage = options.storage;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const taskId = trajectory.taskId || `task_${Date.now()}`;
+  const events = trajectory.events || [];
+  const observations = [];
+  events.forEach((event, idx) => {
+    let obsType = "agent";
+    let confidence = 0.75;
+    const positive = [taskId, event.type];
+    const negative = [];
+    if (event.type === "user_correction") {
+      obsType = "user";
+      confidence = 0.98;
+    } else if (event.type === "failure" || event.type === "revert") {
+      obsType = "test";
+      confidence = 0.95;
+      negative.push(event.description.toLowerCase().replace(/[^a-z0-9_-]/g, "-"));
+    } else if (event.type === "success") {
+      obsType = "agent";
+      confidence = 0.95;
+      positive.push(event.description.toLowerCase().replace(/[^a-z0-9_-]/g, "-"));
+    } else if (event.type === "hypothesis") {
+      confidence = 0.5;
+    }
+    if (event.path) positive.push(event.path.toLowerCase());
+    observations.push(
+      createObservation({
+        source: `trajectory:${taskId}:${event.type}:${idx}`,
+        claim: `[${event.type.toUpperCase()}] ${event.description}`,
+        provenance: {
+          type: obsType,
+          path: event.path,
+          timestamp: event.timestamp || now
+        },
+        confidence,
+        positive,
+        negative: negative.length > 0 ? negative : void 0,
+        details: { taskId, eventIndex: idx, eventType: event.type, ...event.data || {} }
+      })
+    );
+  });
+  const evidence = observations.map((obs) => {
+    const isFailure = obs.claim.startsWith("[FAILURE]") || obs.claim.startsWith("[REVERT]");
+    return createEvidence(obs, isFailure ? "contradicts" : "supports");
+  });
+  const distilled = distillTrajectory(trajectory);
+  const candidateLessons = [];
+  if (distilled) {
+    candidateLessons.push({
+      id: distilled.id,
+      type: "lesson",
+      statement: distilled.statement,
+      positive: distilled.positive,
+      negative: distilled.negative,
+      confidence: distilled.confidence,
+      evidence: evidence.map((e) => e.source),
+      tags: distilled.tags,
+      scope: "project"
+    });
+  }
+  const reconciliations = [];
+  const currentKnowledgeList = [...existingKnowledge];
+  for (const candidate of candidateLessons) {
+    const recResult = reconcileKnowledge(candidate, currentKnowledgeList);
+    if (dryRun) {
+      reconciliations.push({
+        candidate,
+        result: recResult,
+        action: recResult.action
+      });
+    } else {
+      const { updatedKnowledge, action } = applyReconciliation(
+        recResult,
+        candidate,
+        currentKnowledgeList,
+        storage
+      );
+      reconciliations.push({
+        candidate,
+        result: recResult,
+        appliedKnowledge: updatedKnowledge,
+        action
+      });
+    }
+  }
+  return {
+    taskId,
+    observations,
+    evidence,
+    candidateLessons,
+    reconciliations,
+    dryRun
+  };
+}
+function processUserCorrection(params) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const prov = {
+    type: "user",
+    timestamp: now,
+    ...params.author ? { author: params.author } : {}
+  };
+  const claim = `User correction on ${params.topic}: ${params.correctFact} (supersedes assumption: ${params.incorrectAssumption})`;
+  const observation = createObservation({
+    source: `user:correction:${params.topic.toLowerCase()}`,
+    claim,
+    provenance: prov,
+    confidence: 1,
+    positive: [params.topic.toLowerCase(), ...params.context ?? []],
+    negative: [params.incorrectAssumption.toLowerCase()]
+  });
+  const evidence = createEvidence(observation, "supports");
+  const knowledge = createKnowledge({
+    id: `correction.${params.topic.toLowerCase().replace(/[^a-z0-9_-]/g, ".")}`,
+    type: "rule",
+    status: "active",
+    statement: params.correctFact,
+    positive: [params.topic.toLowerCase(), ...params.context ?? []],
+    negative: [params.incorrectAssumption.toLowerCase()],
+    confidence: 1,
+    confidenceTier: "high",
+    evidence: [evidence.id, observation.source],
+    tags: ["user-correction", params.topic.toLowerCase()]
+  });
+  return { observation, knowledge };
+}
+
+// src/core/dependencies.ts
+function normalizeSourceKey(source) {
+  return source.replace(/^(file|code|test|doc):/, "").trim().toLowerCase();
+}
+function buildDependencyIndex(knowledgeList) {
+  const sourceToKnowledge = /* @__PURE__ */ new Map();
+  for (const k of knowledgeList) {
+    const allDependencies = /* @__PURE__ */ new Set();
+    if (k.depends_on) {
+      for (const d of k.depends_on) {
+        allDependencies.add(normalizeSourceKey(d));
+      }
+    }
+    if (k.evidence) {
+      for (const ev of k.evidence) {
+        allDependencies.add(normalizeSourceKey(ev));
+      }
+    }
+    for (const dep of allDependencies) {
+      if (!dep) continue;
+      let set = sourceToKnowledge.get(dep);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        sourceToKnowledge.set(dep, set);
+      }
+      set.add(k.id);
+    }
+  }
+  return { sourceToKnowledge };
+}
+function checkKnowledgeStaleness(knowledge, changedSources) {
+  const normChanged = new Set(changedSources.map(normalizeSourceKey));
+  const allDeps = [
+    ...(knowledge.depends_on ?? []).map(normalizeSourceKey),
+    ...knowledge.evidence.map(normalizeSourceKey)
+  ];
+  const changed = [];
+  const unchanged = [];
+  for (const dep of allDeps) {
+    if (!dep) continue;
+    const isChanged = normChanged.has(dep) || Array.from(normChanged).some((c) => dep.includes(c) || c.includes(dep));
+    if (isChanged) {
+      changed.push(dep);
+    } else {
+      unchanged.push(dep);
+    }
+  }
+  if (changed.length > 0) {
+    const reason = `Supporting dependency changed: ${changed.join(", ")}. Unchanged evidence: ${unchanged.join(", ") || "none"}`;
+    return {
+      knowledgeId: knowledge.id,
+      affected: true,
+      status: "needs_revalidation",
+      changedSources: changed,
+      unchangedSources: unchanged,
+      reason
+    };
+  }
+  return {
+    knowledgeId: knowledge.id,
+    affected: false,
+    status: knowledge.status,
+    changedSources: [],
+    unchangedSources: allDeps
+  };
+}
+function markStaleKnowledge(knowledgeList, changedSources) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let affectedCount = 0;
+  const updatedKnowledge = [];
+  for (const k of knowledgeList) {
+    if (k.status === "superseded" || k.status === "invalid" || k.status === "invalidated") {
+      updatedKnowledge.push(k);
+      continue;
+    }
+    const res = checkKnowledgeStaleness(k, changedSources);
+    if (res.affected) {
+      affectedCount++;
+      const history = k.history ?? [];
+      const updated = {
+        ...k,
+        status: "needs_revalidation",
+        updatedAt: now,
+        history: [
+          ...history,
+          {
+            timestamp: now,
+            status: "needs_revalidation",
+            action: "source_changed",
+            reason: res.reason
+          }
+        ]
+      };
+      updatedKnowledge.push(updated);
+    } else {
+      updatedKnowledge.push(k);
+    }
+  }
+  return { updatedKnowledge, affectedCount };
+}
+function checkKnowledgeListStaleness(knowledgeList, changedSources) {
+  const { updatedKnowledge, affectedCount } = markStaleKnowledge(knowledgeList, changedSources);
+  const affectedKnowledge = updatedKnowledge.filter((k) => k.status === "needs_revalidation");
+  return { affectedKnowledge, updatedKnowledge, affectedCount };
+}
+
+// src/jev/scorer.ts
+var statementTokenCache = /* @__PURE__ */ new WeakMap();
+function extractTokens(text) {
+  if (!text) return /* @__PURE__ */ new Set();
+  return new Set(
+    text.toLowerCase().replace(/[^a-z0-9_-]/g, " ").split(/\s+/).filter((t) => t.length > 2)
+  );
+}
+function getKnowledgeStatementTokens(k) {
+  let tokens = statementTokenCache.get(k);
+  if (!tokens) {
+    tokens = extractTokens(k.statement);
+    statementTokenCache.set(k, tokens);
+  }
+  return tokens;
+}
+function evaluateJev(knowledge, context) {
+  const queryTokens = extractTokens(context.query);
+  const contextPos = new Set((context.positive ?? []).map((p) => p.trim().toLowerCase()));
+  const contextNeg = new Set((context.negative ?? []).map((n) => n.trim().toLowerCase()));
+  const knowPos = new Set((knowledge.positive ?? []).map((p) => p.trim().toLowerCase()));
+  const knowNeg = new Set((knowledge.negative ?? []).map((n) => n.trim().toLowerCase()));
+  const negativeConflicts = [];
+  for (const n of knowNeg) {
+    if (contextPos.has(n) || queryTokens.has(n)) {
+      negativeConflicts.push(`Knowledge forbids "${n}", which was present in context`);
+    }
+  }
+  for (const p of knowPos) {
+    if (contextNeg.has(p)) {
+      negativeConflicts.push(`Context forbids "${p}", which is required by knowledge`);
+    }
+  }
+  const positiveMatches = [];
+  for (const p of knowPos) {
+    if (contextPos.has(p)) {
+      positiveMatches.push(`Context cue: ${p}`);
+    } else {
+      for (const q of queryTokens) {
+        if (p === q || p.startsWith(q) || q.startsWith(p)) {
+          positiveMatches.push(`Query term match: ${p}`);
+          break;
+        }
+      }
+    }
+  }
+  const stmtTokens = getKnowledgeStatementTokens(knowledge);
+  let queryOverlapCount = 0;
+  for (const q of queryTokens) {
+    let matched = false;
+    for (const st of stmtTokens) {
+      if (q === st || q.startsWith(st) || st.startsWith(q)) {
+        matched = true;
+        break;
+      }
+    }
+    if (matched) {
+      queryOverlapCount++;
+      positiveMatches.push(`Statement term: ${q}`);
+    }
+  }
+  const totalCues = Math.max(1, knowPos.size);
+  const matchedCuesCount = positiveMatches.filter((m2) => m2.startsWith("Context cue") || m2.startsWith("Query term")).length;
+  const cueMatchRatio = matchedCuesCount / totalCues;
+  const tokenOverlapScore = queryTokens.size > 0 ? queryOverlapCount / Math.max(1, queryTokens.size) : 0;
+  const rawPositiveScore = 0.65 * cueMatchRatio + 0.35 * tokenOverlapScore;
+  let scopeMultiplier = 1;
+  const targetScope = (context.scope ?? "project").toLowerCase();
+  const knowScope = (knowledge.scope ?? "project").toLowerCase();
+  if (targetScope === knowScope) {
+    scopeMultiplier = 1;
+  } else if (knowScope === "global" || targetScope.startsWith(knowScope)) {
+    scopeMultiplier = 0.85;
+  } else if (knowScope === "project" && targetScope.startsWith("branch:")) {
+    scopeMultiplier = 0.9;
+  } else {
+    scopeMultiplier = 0.3;
+  }
+  const m = knowledge.metrics;
+  const evRatio = (m.support_count + 1) / (m.support_count + 2 * m.contradiction_count + 1);
+  const confidenceFactor = knowledge.confidence * evRatio;
+  let outcomeAdjustment = 0;
+  if (m.successful_outcomes > 0) {
+    outcomeAdjustment += Math.min(0.1, m.successful_outcomes * 0.03);
+  }
+  if (m.failed_outcomes > 0) {
+    outcomeAdjustment -= Math.min(0.2, m.failed_outcomes * 0.05);
+  }
+  let score = (rawPositiveScore * 0.45 + confidenceFactor * 0.4 + outcomeAdjustment) * scopeMultiplier;
+  if (knowledge.status === "stale") {
+    score *= 0.6;
+  } else if (knowledge.status === "contradicted") {
+    score *= 0.3;
+  } else if (knowledge.status === "invalid" || knowledge.status === "superseded") {
+    score *= 0.1;
+  }
+  let status = "POSSIBLE";
+  const reasons = [];
+  if (negativeConflicts.length > 0) {
+    score = Math.max(0.01, score * 0.2);
+    status = "REJECT";
+    reasons.push(`Rejected due to ${negativeConflicts.length} negative contextual conflicts.`);
+  } else if (score >= 0.45 && positiveMatches.length > 0) {
+    status = "MATCH";
+    reasons.push(`Strong contextual match with ${positiveMatches.length} matching signals.`);
+  } else if (score >= 0.25) {
+    status = "POSSIBLE";
+    reasons.push(`Potential match; partial contextual overlap.`);
+  } else {
+    status = "REJECT";
+    reasons.push(`Insufficient contextual match score (${score.toFixed(2)} < 0.25).`);
+  }
+  const finalScore = Math.round(Math.min(1, Math.max(0, score)) * 100) / 100;
+  const explanation = {
+    positiveMatches,
+    negativeConflicts,
+    score: finalScore,
+    confidence: knowledge.confidence,
+    status,
+    reasons
+  };
+  return {
+    knowledge,
+    status,
+    score: finalScore,
+    explanation
+  };
+}
+
+// src/jev/matcher.ts
+function rerankCandidates(candidates, context) {
+  const results = [];
+  for (const candidate of candidates) {
+    const res = evaluateJev(candidate, context);
+    results.push(res);
+  }
+  const statusPriority = {
+    MATCH: 3,
+    POSSIBLE: 2,
+    REJECT: 1
+  };
+  results.sort((a, b) => {
+    const prioDiff = (statusPriority[b.status] ?? 0) - (statusPriority[a.status] ?? 0);
+    if (prioDiff !== 0) return prioDiff;
+    const scoreDiff = b.score - a.score;
+    if (Math.abs(scoreDiff) > 1e-3) return scoreDiff;
+    return b.knowledge.confidence - a.knowledge.confidence;
+  });
+  return results;
+}
+
+// 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/search/retriever.ts
+var Retriever = class {
+  constructor(index, store) {
+    this.index = index;
+    this.store = store;
+  }
+  index;
+  store;
+  /**
+   * Executes the full Bilmem retrieval pipeline:
+   * 1. Query / Context
+   * 2. Candidate retrieval (small candidate set)
+   * 3. JEV contextual reranking
+   * 4. MATCH / POSSIBLE / REJECT classification with explanations
+   */
+  async lookup(options = {}) {
+    const limit = options.limit ?? 5;
+    const query = options.query?.trim() ?? "";
+    const positive = options.positive ?? [];
+    const negative = options.negative ?? [];
+    const scope = options.scope ?? "project";
+    const searchTerms = [];
+    if (query) searchTerms.push(query);
+    if (positive.length > 0) searchTerms.push(...positive.slice(0, 3));
+    const searchTerm = searchTerms.join(" ").trim();
+    let candidateIds = await this.index.searchCandidates(searchTerm, 30);
+    let candidates = [];
+    if (candidateIds.length === 0) {
+      const all = await this.store.getAllKnowledge();
+      candidates = all.filter((k) => k.status !== "invalid" && k.status !== "superseded");
+    } else {
+      for (const id of candidateIds) {
+        const item = await this.store.getKnowledge(id);
+        if (item && item.status !== "invalid" && item.status !== "superseded") {
+          candidates.push(item);
+        }
+      }
+      if (candidates.length < 5) {
+        const all = await this.store.getAllKnowledge();
+        for (const k of all) {
+          if (!candidateIds.includes(k.id) && k.status !== "invalid" && k.status !== "superseded") {
+            candidates.push(k);
+            if (candidates.length >= 20) break;
+          }
+        }
+      }
+    }
+    const queryContext = {
+      query,
+      positive,
+      negative,
+      scope
+    };
+    const reranked = rerankCandidates(candidates, queryContext);
+    const filtered = options.includeRejected ? reranked : reranked.filter((r) => r.status !== "REJECT");
+    return filtered.slice(0, limit);
+  }
+};
+
+// src/core/resolver.ts
+var RELATIVE_COSTS = {
+  USE_KNOWLEDGE: 1,
+  INSPECT_TEST: 2,
+  INSPECT_FILE: 2,
+  INSPECT_SYMBOL: 2.5,
+  CHECK_DOCUMENTATION: 2.5,
+  CHECK_GIT: 3,
+  SEARCH_REPOSITORY: 4,
+  ASK_USER: 3.5,
+  // Context-dependent; cheaper than broad scan when specifically targeted
+  STOP: 1
+};
+function tokenize2(text) {
+  return text.toLowerCase().replace(/[^a-z0-9_-]/g, " ").split(/\s+/).filter((t) => t.length > 2);
+}
+async function resolveEpistemicQuery(options, storage, retriever) {
+  const question = options.question.trim();
+  const positive = (options.positive ?? []).map((p) => p.trim().toLowerCase());
+  const negative = (options.negative ?? []).map((n) => n.trim().toLowerCase());
+  const scope = options.scope ?? "project";
+  const queryTokens = tokenize2(question);
+  const contextualCues = Array.from(/* @__PURE__ */ new Set([...positive, ...queryTokens]));
+  const allKnowledge = await storage.getAllKnowledge();
+  let jevResults;
+  if (retriever instanceof Retriever) {
+    jevResults = await retriever.lookup({
+      query: question,
+      positive: options.positive,
+      negative: options.negative,
+      scope,
+      limit: options.limit ?? 25,
+      includeRejected: true
+    });
+  } else {
+    let candidatePool = [];
+    if (retriever instanceof SearchIndex) {
+      const queryTerm = queryTokens.slice(0, 5).join(" ");
+      const ids = await retriever.searchCandidates(queryTerm, 30);
+      for (const id of ids) {
+        const item = await storage.getKnowledge(id);
+        if (item) candidatePool.push(item);
+      }
+    }
+    if (candidatePool.length === 0) {
+      candidatePool = allKnowledge;
+    }
+    for (const k of allKnowledge) {
+      if (!candidatePool.some((c) => c.id === k.id) && k.positive.some((p) => contextualCues.includes(p))) {
+        candidatePool.push(k);
+      }
+    }
+    jevResults = rerankCandidates(candidatePool, {
+      positive: options.positive,
+      negative: options.negative,
+      scope
+    });
+  }
+  const matchingItems = [];
+  const rejectedItems = [];
+  for (const res of jevResults) {
+    let jevReason = "INSUFFICIENT_CONTEXT";
+    if (res.explanation.negativeConflicts.length > 0) {
+      jevReason = "HARD_NEGATIVE";
+    } else if (res.explanation.reasons.some((r) => r.toLowerCase().includes("scope"))) {
+      jevReason = "SCOPE_MISMATCH";
+    } else if (res.knowledge.status === "stale" || res.knowledge.status === "needs_revalidation") {
+      jevReason = "STALE_KNOWLEDGE";
+    }
+    await storage.appendMetricEvent({
+      type: "jev_result",
+      knowledgeId: res.knowledge.id,
+      result: res.status,
+      reason: jevReason,
+      timestamp: Date.now()
+    });
+    if (jevReason === "HARD_NEGATIVE") {
+      await storage.appendMetricEvent({
+        type: "jev_hard_negative",
+        knowledgeId: res.knowledge.id,
+        timestamp: Date.now()
+      });
+    }
+    if (res.status === "REJECT") {
+      const conflictMsg = res.explanation.negativeConflicts.length > 0 ? `${res.explanation.negativeConflicts.join(", ")} conflicts with current context` : res.explanation.reasons[0] || "Context mismatch";
+      rejectedItems.push({
+        id: res.knowledge.id,
+        reason: conflictMsg
+      });
+    } else if (res.status === "MATCH" || res.status === "POSSIBLE") {
+      matchingItems.push(res.knowledge);
+    }
+  }
+  const receipts = await storage.getAllReceipts();
+  const previouslyChecked = /* @__PURE__ */ new Set();
+  const previouslyRejectedTargets = /* @__PURE__ */ new Map();
+  for (const r of receipts) {
+    const qOverlap = tokenize2(r.question).filter((t) => queryTokens.includes(t));
+    if (qOverlap.length >= 2 || r.positive && r.positive.some((p) => contextualCues.includes(p))) {
+      await storage.appendMetricEvent({
+        type: "investigation_reused",
+        investigationId: r.id,
+        timestamp: Date.now()
+      });
+      for (const c of r.checked) {
+        previouslyChecked.add(c);
+      }
+      for (const rej of r.rejected) {
+        previouslyRejectedTargets.set(rej.target, rej.reason);
+      }
+    }
+  }
+  for (const m of matchingItems) {
+    for (const ev of m.evidence) {
+      previouslyChecked.add(ev.replace(/^(code|file|test|doc):/, ""));
+    }
+    if (m.depends_on) {
+      for (const dep of m.depends_on) {
+        previouslyChecked.add(dep.replace(/^(code|file|test|doc):/, ""));
+      }
+    }
+  }
+  const staleCandidates = matchingItems.filter((k) => k.status === "needs_revalidation" || k.status === "stale");
+  const contradictedCandidates = matchingItems.filter((k) => k.status === "contradicted");
+  const activeCandidates = matchingItems.filter(
+    (k) => (k.status === "active" || k.stage === "active" || k.stage === "probation") && k.status !== "needs_revalidation" && k.status !== "stale" && k.status !== "contradicted" && k.status !== "invalid" && k.status !== "superseded"
+  );
+  const questionKnowledge = allKnowledge.filter((k) => k.type === "question");
+  let learnedQuestionToAsk;
+  for (const qk of questionKnowledge) {
+    const matchesCues = qk.positive.some((p) => contextualCues.includes(p));
+    const conflicts = qk.negative.some((n) => negative.includes(n));
+    if (matchesCues && !conflicts && qk.question) {
+      learnedQuestionToAsk = {
+        question: qk.question,
+        targetTopic: qk.resolves?.[0] || "uncertainty",
+        reason: `Learned question for [${qk.positive.join(", ")}] uncertainty`
+      };
+      break;
+    }
+  }
+  const coveredTokens = /* @__PURE__ */ new Set();
+  for (const k of activeCandidates) {
+    for (const t of tokenize2(k.statement)) coveredTokens.add(t);
+    for (const p of k.positive) coveredTokens.add(p);
+  }
+  const missingAspects = [];
+  for (const qt of queryTokens) {
+    if (!["how", "what", "why", "when", "where", "are", "the", "for", "with", "does", "from"].includes(qt)) {
+      if (!coveredTokens.has(qt)) {
+        missingAspects.push(qt);
+      }
+    }
+  }
+  let state = "UNKNOWN";
+  let reason;
+  if (activeCandidates.length === 0 && staleCandidates.length > 0) {
+    state = "STALE";
+    reason = "STALE_EVIDENCE";
+  } else if (activeCandidates.length === 0 && contradictedCandidates.length > 0) {
+    state = "CONFLICTED";
+    reason = "CONFLICTING_EVIDENCE";
+  } else if (activeCandidates.length === 0) {
+    state = "UNKNOWN";
+    reason = rejectedItems.length > 0 && matchingItems.length === 0 ? "CONTEXT_MISMATCH" : "NOT_OBSERVED";
+  } else if (missingAspects.length === 0 && activeCandidates.some((k) => k.confidence >= 0.85)) {
+    state = "KNOWN";
+  } else {
+    state = "PARTIALLY_KNOWN";
+    reason = "INSUFFICIENT_EVIDENCE";
+  }
+  const checkedArray = Array.from(previouslyChecked);
+  let nextAction;
+  let fallback;
+  if (state === "KNOWN") {
+    nextAction = {
+      type: "USE_KNOWLEDGE",
+      target: activeCandidates[0].id,
+      reason: `Sufficient high-confidence knowledge available (${activeCandidates[0].id})`,
+      relativeCost: RELATIVE_COSTS.USE_KNOWLEDGE,
+      expectedInfoGain: 0.95
+    };
+  } else if (state === "CONFLICTED") {
+    nextAction = {
+      type: "ASK_USER",
+      reason: "Opposing credible knowledge requires contextual disambiguation",
+      relativeCost: RELATIVE_COSTS.ASK_USER,
+      expectedInfoGain: 0.9
+    };
+    fallback = {
+      type: "ask",
+      question: `Conflicting conventions exist for "${question}". Which context applies?`
+    };
+  } else if (state === "STALE") {
+    const staleItem = staleCandidates[0];
+    const targetSource = staleItem.depends_on?.[0] || staleItem.evidence[0] || "source";
+    nextAction = {
+      type: "INSPECT_FILE",
+      target: targetSource.replace(/^(code|file|test|doc):/, ""),
+      reason: `Revalidate stale knowledge (${staleItem.id}) whose dependencies changed`,
+      relativeCost: RELATIVE_COSTS.INSPECT_FILE,
+      expectedInfoGain: 0.85
+    };
+  } else {
+    if (learnedQuestionToAsk) {
+      nextAction = {
+        type: "ASK_USER",
+        reason: learnedQuestionToAsk.reason,
+        relativeCost: RELATIVE_COSTS.ASK_USER,
+        expectedInfoGain: 0.9
+      };
+      fallback = {
+        type: "ask",
+        question: learnedQuestionToAsk.question
+      };
+    } else {
+      const testCandidates = [
+        `tests/${queryTokens[0] || "module"}.test.ts`,
+        `test/${queryTokens[0] || "module"}.test.ts`,
+        `tests/session-refresh.test.ts`
+      ];
+      const uninspectedTest = testCandidates.find(
+        (t) => !previouslyChecked.has(t) && !previouslyRejectedTargets.has(t)
+      );
+      const fileCandidates = [
+        `src/${queryTokens[0] || "auth"}/${queryTokens[1] || "index"}.ts`,
+        `src/${queryTokens[0] || "index"}.ts`
+      ];
+      const uninspectedFile = fileCandidates.find(
+        (f) => !previouslyChecked.has(f) && !previouslyRejectedTargets.has(f)
+      );
+      for (const t of testCandidates) {
+        if (previouslyChecked.has(t)) {
+          await storage.appendMetricEvent({
+            type: "source_read_avoided",
+            source: t,
+            timestamp: Date.now()
+          });
+        }
+      }
+      for (const f of fileCandidates) {
+        if (previouslyChecked.has(f)) {
+          await storage.appendMetricEvent({
+            type: "source_read_avoided",
+            source: f,
+            timestamp: Date.now()
+          });
+        }
+      }
+      if (uninspectedTest && missingAspects.some((m) => m.includes("order") || m.includes("test") || m.includes("behavior"))) {
+        nextAction = {
+          type: "INSPECT_TEST",
+          target: uninspectedTest,
+          reason: `Targeted test inspection for unconfirmed aspect: ${missingAspects.join(", ")}`,
+          relativeCost: RELATIVE_COSTS.INSPECT_TEST,
+          expectedInfoGain: 0.8
+        };
+      } else if (uninspectedFile) {
+        nextAction = {
+          type: "INSPECT_FILE",
+          target: uninspectedFile,
+          reason: `Direct source inspection for missing context: ${missingAspects.join(", ")}`,
+          relativeCost: RELATIVE_COSTS.INSPECT_FILE,
+          expectedInfoGain: 0.75
+        };
+      } else {
+        nextAction = {
+          type: "SEARCH_REPOSITORY",
+          target: missingAspects.slice(0, 3).join(" ") || question,
+          reason: `Targeted search for unobserved aspects: ${missingAspects.join(", ")}`,
+          relativeCost: RELATIVE_COSTS.SEARCH_REPOSITORY,
+          expectedInfoGain: 0.6
+        };
+      }
+      fallback = {
+        type: "ask",
+        question: `Could you clarify: ${question}? (Missing: ${missingAspects.join(", ") || "specifics"})`
+      };
+    }
+  }
+  if (state === "KNOWN" || nextAction && nextAction.type !== "SEARCH_REPOSITORY" && nextAction.type !== "STOP") {
+    await storage.appendMetricEvent({
+      type: "broad_search_avoided",
+      targetAction: nextAction?.type,
+      timestamp: Date.now()
+    });
+  }
+  for (const k of activeCandidates) {
+    await storage.appendMetricEvent({
+      type: "knowledge_reused",
+      knowledgeId: k.id,
+      timestamp: Date.now()
+    });
+  }
+  if (learnedQuestionToAsk || fallback?.type === "ask") {
+    await storage.appendMetricEvent({
+      type: "question_suggested",
+      question: learnedQuestionToAsk?.question || fallback?.question,
+      timestamp: Date.now()
+    });
+  }
+  await storage.appendMetricEvent({
+    type: "resolve",
+    state,
+    action: nextAction?.type,
+    question,
+    timestamp: Date.now()
+  });
+  const receiptId = `receipt_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 6)}`;
+  const receipt = {
+    id: receiptId,
+    question,
+    checked: checkedArray,
+    findings: activeCandidates.map((c) => c.statement),
+    rejected: rejectedItems.map((r) => ({ target: r.id, reason: r.reason })),
+    missing: missingAspects,
+    next: nextAction,
+    status: state === "KNOWN" ? "resolved" : "unresolved",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    positive,
+    negative
+  };
+  await storage.saveReceipt(receipt);
+  return {
+    state,
+    reason,
+    known: activeCandidates.map((k) => ({
+      id: k.id,
+      statement: k.statement,
+      confidence: k.confidenceTier ?? k.confidence,
+      confidenceTier: k.confidenceTier,
+      stage: k.stage
+    })),
+    applicable: positive.length > 0 ? positive : contextualCues.slice(0, 5),
+    rejected: rejectedItems,
+    missing: missingAspects,
+    checked: checkedArray,
+    next: nextAction,
+    fallback,
+    receiptId
+  };
+}
+export {
+  EvidenceGraph,
+  MetricsTracker,
+  RELATIVE_COSTS,
+  applyOutcomeToKnowledge,
+  applyReconciliation,
+  buildDependencyIndex,
+  calculateEffectiveConfidence,
+  calculateKnowledgeValue,
+  checkKnowledgeListStaleness,
+  checkKnowledgeStaleness,
+  confidenceToTier,
+  createEvidence,
+  createKnowledge,
+  createObservation,
+  createOutcome,
+  createUnknown,
+  detectPolarContradiction,
+  determineInitialStage,
+  distillTrajectory,
+  enforceKnowledgeBudget,
+  evaluatePromotion,
+  hasBeenInvestigated,
+  hashString,
+  learnFromTrajectory,
+  markStaleKnowledge,
+  normalizeSourceKey,
+  processUserCorrection,
+  reconcileKnowledge,
+  recordOutcomeOnKnowledge,
+  resolveEpistemicQuery,
+  tierToConfidence,
+  updateUnknown
+};
+//# sourceMappingURL=index.js.map