memorix 1.0.8 → 1.0.9

package/dist/index.js

@@ -675,6 +675,13 @@ var init_persistence = __esm({
 });
 
 // src/store/graph-store.ts
+var graph_store_exports = {};
+__export(graph_store_exports, {
+  GraphSqliteStore: () => GraphSqliteStore,
+  getGraphStore: () => getGraphStore,
+  initGraphStore: () => initGraphStore,
+  resetGraphStore: () => resetGraphStore
+});
 import path6 from "path";
 import fs5 from "fs";
 function safeJsonParse(val, fallback) {
@@ -710,6 +717,16 @@ function getGraphStore() {
   if (!_graphStore) throw new Error("[memorix] GraphStore not initialized \u2014 call initGraphStore() first");
   return _graphStore;
 }
+function resetGraphStore() {
+  if (_graphStore) {
+    try {
+      _graphStore.close();
+    } catch {
+    }
+  }
+  _graphStore = null;
+  _graphDataDir = null;
+}
 var GraphSqliteStore, _graphStore, _graphDataDir;
 var init_graph_store = __esm({
   "src/store/graph-store.ts"() {
@@ -1041,7 +1058,8 @@ var init_types = __esm({
       "why-it-exists": "[WHY]",
       "decision": "[DECISION]",
       "trade-off": "[TRADEOFF]",
-      "reasoning": "[REASONING]"
+      "reasoning": "[REASONING]",
+      "probe": "[PROBE]"
     };
     TOPIC_KEY_FAMILIES = {
       "architecture": ["architecture", "design", "adr", "structure", "pattern"],
@@ -1055,6 +1073,15 @@ var init_types = __esm({
 });
 
 // src/store/mini-skill-store.ts
+var mini_skill_store_exports = {};
+__export(mini_skill_store_exports, {
+  MiniSkillGracefulDegrade: () => MiniSkillGracefulDegrade,
+  MiniSkillSqliteStore: () => MiniSkillSqliteStore,
+  getMiniSkillStore: () => getMiniSkillStore,
+  initMiniSkillStore: () => initMiniSkillStore,
+  isMiniSkillStoreInitialized: () => isMiniSkillStoreInitialized,
+  resetMiniSkillStore: () => resetMiniSkillStore
+});
 import path7 from "path";
 import fs6 from "fs";
 function skillToRow(skill) {
@@ -1108,6 +1135,10 @@ function getMiniSkillStore() {
   }
   return _store;
 }
+function resetMiniSkillStore() {
+  _store = null;
+  _storeDataDir = null;
+}
 async function initMiniSkillStore(dataDir) {
   if (_store && _storeDataDir === dataDir) return _store;
   _store = null;
@@ -1354,6 +1385,12 @@ async function promoteToMiniSkill(projectDir2, projectId, observations2, options
       `Cannot promote: ${nonActive.length} observation(s) are not active. Blocked: ${nonActive.map((o) => `#${o.id} (${o.status ?? "unknown"})`).join(", ")}. Only active observations can be promoted to permanent knowledge.`
     );
   }
+  const probes = observations2.filter((o) => o.type === "probe");
+  if (probes.length > 0) {
+    throw new Error(
+      `Cannot promote probe observations \u2014 they are operational heartbeats, not durable knowledge. Blocked: ${probes.map((o) => `#${o.id} "${o.title.substring(0, 60)}"`).join(", ")}.`
+    );
+  }
   if (!options?.force) {
     const commandLogs = observations2.filter((o) => COMMAND_LOG_TITLE.test(o.title));
     if (commandLogs.length > 0) {
@@ -4407,6 +4444,10 @@ async function searchObservations(options) {
     if (statusFilter === "all") return true;
     const doc = hit.document;
     return (doc.status || "active") === statusFilter;
+  }).filter((hit) => {
+    if (options.type === "probe") return true;
+    const doc = hit.document;
+    return doc.type !== "probe";
   }).map((hit) => {
     const doc = hit.document;
     const obsType = doc.type;
@@ -6788,6 +6829,11 @@ function hasContradiction(oldText, newText) {
   ];
   return negationPatterns.some((p) => p.test(newText));
 }
+function normalizedSearchSimilarity(score) {
+  if (!Number.isFinite(score) || score <= 0) return 0;
+  if (score <= 1) return score;
+  return 0;
+}
 function mergeNarratives(oldNarrative, newNarrative) {
   if (newNarrative.length > oldNarrative.length * 1.5) return newNarrative;
   if (oldNarrative.length > newNarrative.length * 1.5) return oldNarrative;
@@ -6878,12 +6924,13 @@ function scoreCandidate(extracted, candidate) {
     `${extracted.title} ${extracted.narrative}`,
     `${candidate.title} ${candidate.narrative}`
   );
-  const score = candidate.score * 0.6 + (entityMatch ? 0.2 : 0) + contentOverlap * 0.2;
+  const searchSimilarity = normalizedSearchSimilarity(candidate.score);
+  const score = searchSimilarity * 0.6 + (entityMatch ? 0.2 : 0) + contentOverlap * 0.2;
   const newLength = extracted.narrative.length + extracted.facts.join(" ").length;
   const oldLength = candidate.narrative.length + candidate.facts.length;
   const richer = newLength > oldLength * 1.15;
   const contradiction = hasContradiction(candidate.narrative, extracted.narrative);
-  return { score, entityMatch, richer, contradiction };
+  return { score, searchSimilarity, entityMatch, richer, contradiction };
 }
 async function runResolve(extracted, projectId, searchMemories, getObservation2, useLLM = false) {
   const query = `${extracted.title} ${extracted.narrative.substring(0, 200)}`;
@@ -6906,7 +6953,7 @@ async function runResolve(extracted, projectId, searchMemories, getObservation2,
   }));
   scored.sort((a, b) => b.score - a.score);
   const best = scored[0];
-  if (best.hit.score >= SIMILARITY_DUPLICATE) {
+  if (best.searchSimilarity >= SIMILARITY_DUPLICATE) {
     if (best.richer) {
       const existing = getObservation2(best.hit.observationId);
       const oldFacts = existing?.facts ?? best.hit.facts.split("\n").filter(Boolean);
@@ -7093,7 +7140,8 @@ var init_evaluate = __esm({
       "how-it-works": 0.6,
       "discovery": 0.55,
       "what-changed": 0.45,
-      "session-request": 0.4
+      "session-request": 0.4,
+      "probe": 0.1
     };
     SPECIFICITY_PATTERNS = [
       /\b\d+\.\d+\.\d+\b/,
@@ -7557,6 +7605,9 @@ function scoreObservationForSessionContext(obs, projectTokens, now = Date.now())
   if (obs.valueCategory === "core") {
     score += 2;
   }
+  if (obs.type === "probe") {
+    score -= 100;
+  }
   return score;
 }
 async function startSession(projectDir2, projectId, opts) {
@@ -7765,7 +7816,8 @@ var init_session = __esm({
       "how-it-works": "[INFO]",
       "what-changed": "[CHANGE]",
       "why-it-exists": "[DECISION]",
-      "session-request": "[SESSION]"
+      "session-request": "[SESSION]",
+      "probe": "[PROBE]"
     };
     TYPE_WEIGHTS2 = {
       "gotcha": 6,
@@ -7844,11 +7896,17 @@ function getValueCategoryMultiplier(doc) {
   return 1;
 }
 function getEffectiveRetentionDays(doc) {
+  const typeOverride = TYPE_RETENTION_OVERRIDE[doc.type];
+  if (typeOverride !== void 0) {
+    const raw2 = typeOverride * getSourceRetentionMultiplier(doc);
+    return Math.max(MIN_RETENTION_DAYS, raw2);
+  }
   const importance = getImportanceLevel(doc);
   const raw = RETENTION_DAYS[importance] * getSourceRetentionMultiplier(doc) * getValueCategoryMultiplier(doc);
   return Math.max(MIN_RETENTION_DAYS, raw);
 }
 function isImmune(doc) {
+  if (doc.type === "probe") return false;
   if (doc.valueCategory === "core") return true;
   const importance = getImportanceLevel(doc);
   if (importance === "critical") return true;
@@ -7857,6 +7915,7 @@ function isImmune(doc) {
   return concepts.some((c) => PROTECTED_TAGS.has(c));
 }
 function getImmunityReason(doc) {
+  if (doc.type === "probe") return null;
   if (doc.valueCategory === "core") return "core valueCategory (formation-classified)";
   const importance = getImportanceLevel(doc);
   if (importance === "critical") return "critical importance";
@@ -8013,7 +8072,7 @@ async function archiveExpired(projectDir2, referenceTime, accessMap) {
     return { archived: archivedCount, remaining: activeObs.length - archivedCount };
   });
 }
-var RETENTION_DAYS, BASE_IMPORTANCE, TYPE_IMPORTANCE, PROTECTED_TAGS, MIN_ACCESS_FOR_IMMUNITY, MIN_RETENTION_DAYS;
+var RETENTION_DAYS, BASE_IMPORTANCE, TYPE_IMPORTANCE, TYPE_RETENTION_OVERRIDE, PROTECTED_TAGS, MIN_ACCESS_FOR_IMMUNITY, MIN_RETENTION_DAYS;
 var init_retention = __esm({
   "src/memory/retention.ts"() {
     "use strict";
@@ -8041,7 +8100,12 @@ var init_retention = __esm({
       "what-changed": "low",
       "why-it-exists": "medium",
       discovery: "low",
-      "session-request": "low"
+      "session-request": "low",
+      probe: "low"
+    };
+    TYPE_RETENTION_OVERRIDE = {
+      probe: 7
+      // Operational heartbeats: expire after ~7 days regardless of source/valueCategory
     };
     PROTECTED_TAGS = /* @__PURE__ */ new Set(["keep", "important", "pinned", "critical"]);
     MIN_ACCESS_FOR_IMMUNITY = 3;
@@ -9769,6 +9833,449 @@ var init_project_classification = __esm({
   }
 });
 
+// src/wiki/generator.ts
+var generator_exports = {};
+__export(generator_exports, {
+  contextualHasSubstance: () => contextualHasSubstance,
+  generateKnowledgeBase: () => generateKnowledgeBase,
+  isCommandLog: () => isCommandLog,
+  isEligible: () => isEligible,
+  isExcludedType: () => isExcludedType
+});
+function isExcludedType(o) {
+  return o.type === "probe";
+}
+function isCommandLog(o) {
+  return COMMAND_LOG_TITLE3.test(o.title || "");
+}
+function isInactive(o) {
+  const status = o.status ?? "active";
+  return status !== "active";
+}
+function isOtherProject(o, projectId) {
+  return o.projectId !== projectId;
+}
+function contextualHasSubstance(o) {
+  if (o.valueCategory !== "contextual") return true;
+  const hasFacts = (o.facts?.length ?? 0) > 0;
+  const hasConcepts = (o.concepts?.length ?? 0) > 0;
+  const hasFiles = (o.filesModified?.length ?? 0) > 0;
+  const hasEntity = !!(o.entityName && o.entityName !== "quick-note" && o.entityName !== "unknown");
+  return hasFacts || hasConcepts || hasFiles || hasEntity;
+}
+function isEligible(o, projectId) {
+  if (isExcludedType(o)) return false;
+  if (isCommandLog(o)) return false;
+  if (isInactive(o)) return false;
+  if (isOtherProject(o, projectId)) return false;
+  if (o.valueCategory === "ephemeral") return false;
+  if (!contextualHasSubstance(o)) return false;
+  return true;
+}
+function obsToItem(o) {
+  const ref = {
+    kind: o.source === "git" ? "git" : "observation",
+    id: `obs:${o.id}`,
+    title: o.title
+  };
+  return {
+    title: o.title,
+    summary: o.narrative?.slice(0, 200) || "",
+    type: o.type,
+    entityName: o.entityName || void 0,
+    refs: [ref]
+  };
+}
+function skillToItem(s) {
+  const ref = {
+    kind: "mini-skill",
+    id: `skill:${s.id}`,
+    title: s.title
+  };
+  const obsRefs = s.sourceObservationIds.map(
+    (oid) => ({ kind: "observation", id: `obs:${oid}` })
+  );
+  return {
+    title: s.title,
+    summary: s.instruction?.slice(0, 200) || "",
+    type: "mini-skill",
+    entityName: s.sourceEntity || void 0,
+    refs: [ref, ...obsRefs]
+  };
+}
+function buildGitSection(observations2) {
+  const gitObs = observations2.filter(
+    (o) => o.source === "git" && o.sourceDetail === "git-ingest"
+  );
+  const items = gitObs.map(obsToItem);
+  return {
+    id: "git-backed-facts",
+    title: "Git-backed Facts",
+    items,
+    empty: items.length === 0
+  };
+}
+function buildSkillsSection(skills) {
+  const items = skills.map(skillToItem);
+  return {
+    id: "promoted-skills",
+    title: "Promoted Skills",
+    items,
+    empty: items.length === 0
+  };
+}
+function buildProjectOverview(projectId, eligibleObs, skills) {
+  const refs = [
+    ...eligibleObs.slice(0, 5).map((o) => ({
+      kind: o.source === "git" ? "git" : "observation",
+      id: `obs:${o.id}`,
+      title: o.title
+    })),
+    ...skills.slice(0, 5).map((s) => ({
+      kind: "mini-skill",
+      id: `skill:${s.id}`,
+      title: s.title
+    }))
+  ];
+  if (refs.length === 0) {
+    return {
+      id: "project-overview",
+      title: "Project Overview",
+      items: [],
+      empty: true
+    };
+  }
+  const lines = [];
+  lines.push(`Project: ${projectId}`);
+  lines.push(`Observations in KB: ${eligibleObs.length}`);
+  lines.push(`Promoted skills: ${skills.length}`);
+  const entityCounts = /* @__PURE__ */ new Map();
+  for (const o of eligibleObs) {
+    if (o.entityName) {
+      entityCounts.set(o.entityName, (entityCounts.get(o.entityName) || 0) + 1);
+    }
+  }
+  const topEntities = [...entityCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5);
+  if (topEntities.length > 0) {
+    lines.push(`Top entities: ${topEntities.map(([name, count2]) => `${name} (${count2})`).join(", ")}`);
+  }
+  return {
+    id: "project-overview",
+    title: "Project Overview",
+    items: [{
+      title: projectId,
+      summary: lines.join("\n"),
+      type: "overview",
+      refs
+    }]
+  };
+}
+function generateKnowledgeBase(options) {
+  const { projectId, observations: observations2, miniSkills } = options;
+  const eligible = observations2.filter((o) => isEligible(o, projectId));
+  const scopedMiniSkills = miniSkills.filter((s) => s.projectId === projectId);
+  const typedSections = SECTION_DEFS.map((def) => {
+    const matched = eligible.filter(def.typeMatch);
+    const items = matched.map(obsToItem);
+    return {
+      id: def.id,
+      title: def.title,
+      items,
+      empty: items.length === 0
+    };
+  });
+  const projectOverview = buildProjectOverview(projectId, eligible, scopedMiniSkills);
+  const gitSection = buildGitSection(eligible);
+  const skillsSection = buildSkillsSection(scopedMiniSkills);
+  const sections = [
+    projectOverview,
+    ...typedSections,
+    gitSection,
+    skillsSection
+  ];
+  const allRefs = sections.flatMap((s) => s.items.flatMap((i) => i.refs));
+  const obsRefCount = allRefs.filter((r) => r.kind === "observation" || r.kind === "git").length;
+  const skillRefCount = allRefs.filter((r) => r.kind === "mini-skill").length;
+  return {
+    title: "Knowledge Base",
+    subtitle: "LLM Wiki",
+    projectId,
+    generatedAt: options.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    sections,
+    stats: {
+      observationsUsed: eligible.length,
+      miniSkillsUsed: scopedMiniSkills.length,
+      refs: obsRefCount + skillRefCount
+    }
+  };
+}
+var COMMAND_LOG_TITLE3, SECTION_DEFS;
+var init_generator = __esm({
+  "src/wiki/generator.ts"() {
+    "use strict";
+    init_esm_shims();
+    COMMAND_LOG_TITLE3 = /^(Ran:|Command:|Executed:)\s/i;
+    SECTION_DEFS = [
+      {
+        id: "core-decisions",
+        title: "Core Decisions",
+        typeMatch: (o) => o.type === "decision" || o.type === "trade-off" || o.type === "reasoning"
+      },
+      {
+        id: "operational-knowledge",
+        title: "Operational Knowledge",
+        typeMatch: (o) => o.type === "how-it-works" || o.type === "what-changed" || o.type === "why-it-exists" || o.type === "discovery" || o.type === "session-request"
+      },
+      {
+        id: "known-gotchas",
+        title: "Known Gotchas",
+        typeMatch: (o) => o.type === "gotcha" || o.type === "problem-solution"
+      }
+    ];
+  }
+});
+
+// src/wiki/knowledge-graph.ts
+var knowledge_graph_exports = {};
+__export(knowledge_graph_exports, {
+  generateKnowledgeGraph: () => generateKnowledgeGraph
+});
+function inferEdges(nodes, entityNameIndex) {
+  const edges = [];
+  const seen = /* @__PURE__ */ new Set();
+  const maxRelatesEdgesPerEntitySection = 8;
+  function addEdge(source, target, edgeType) {
+    const key = `${source}:${edgeType}:${target}`;
+    if (seen.has(key)) return;
+    if (source === target) return;
+    seen.add(key);
+    edges.push({
+      id: `e_${edges.length}_${source}_${target}`,
+      source,
+      target,
+      edgeType
+    });
+  }
+  function rankNodesForEntity(a, b) {
+    const evidenceDiff = (b.evidenceCount || 0) - (a.evidenceCount || 0);
+    if (evidenceDiff !== 0) return evidenceDiff;
+    return a.id.localeCompare(b.id);
+  }
+  for (const [, group] of entityNameIndex) {
+    if (group.length < 2) continue;
+    const bySection = /* @__PURE__ */ new Map();
+    for (const node of group) {
+      const sectionGroup = bySection.get(node.sectionId) || [];
+      sectionGroup.push(node);
+      bySection.set(node.sectionId, sectionGroup);
+    }
+    for (const sectionGroup of bySection.values()) {
+      const ranked = [...sectionGroup].sort(rankNodesForEntity);
+      if (ranked.length === 2) {
+        addEdge(ranked[0].id, ranked[1].id, "relates_to");
+        addEdge(ranked[1].id, ranked[0].id, "relates_to");
+        continue;
+      }
+      const anchor = ranked[0];
+      for (const node of ranked.slice(1, maxRelatesEdgesPerEntitySection + 1)) {
+        addEdge(anchor.id, node.id, "relates_to");
+      }
+    }
+    const sectionAnchors = [...bySection.entries()].map(([sectionId, sectionGroup]) => ({
+      sectionId,
+      anchor: [...sectionGroup].sort(rankNodesForEntity)[0]
+    })).sort((a, b) => sectionPriority(a.sectionId) - sectionPriority(b.sectionId));
+    for (let i = 0; i < sectionAnchors.length; i++) {
+      for (let j = i + 1; j < sectionAnchors.length; j++) {
+        const from = sectionAnchors[i].anchor;
+        const to = sectionAnchors[j].anchor;
+        const edgeType = sectionPriority(sectionAnchors[i].sectionId) === sectionPriority(sectionAnchors[j].sectionId) ? "relates_to" : "supports";
+        addEdge(from.id, to.id, edgeType);
+      }
+    }
+  }
+  return edges;
+}
+function sectionPriority(sectionId) {
+  const order = ["core-decisions", "known-gotchas", "operational-knowledge", "git-backed-facts", "promoted-skills"];
+  const idx = order.indexOf(sectionId);
+  return idx >= 0 ? idx : order.length;
+}
+function sectionIdForObs(o) {
+  if (GIT_SECTION.typeMatch(o)) return GIT_SECTION.id;
+  for (const def of SECTION_DEFS2) {
+    if (def.typeMatch(o)) return def.id;
+  }
+  return "operational-knowledge";
+}
+function mapRelationType(relationType) {
+  const lower = relationType.toLowerCase();
+  if (lower.includes("support") || lower.includes("depend")) return "supports";
+  if (lower.includes("relat") || lower.includes("connect") || lower.includes("associat")) return "relates_to";
+  if (lower.includes("mention") || lower.includes("refer")) return "mentions";
+  if (lower.includes("deriv") || lower.includes("origin") || lower.includes("source")) return "derived_from";
+  return "relates_to";
+}
+function generateKnowledgeGraph(options) {
+  const { projectId, observations: observations2, miniSkills, graphEntities, graphRelations } = options;
+  const eligible = observations2.filter((o) => isEligible(o, projectId));
+  const scopedMiniSkills = miniSkills.filter((s) => s.projectId === projectId);
+  const nodes = [];
+  const entityNameIndex = /* @__PURE__ */ new Map();
+  for (const o of eligible) {
+    const sectionId = sectionIdForObs(o);
+    const ref = {
+      kind: o.source === "git" ? "git" : "observation",
+      id: `obs:${o.id}`,
+      title: o.title
+    };
+    const node = {
+      id: `obs:${o.id}`,
+      label: o.title,
+      nodeType: o.type,
+      sectionId,
+      entityName: o.entityName || void 0,
+      evidenceCount: (o.facts?.length ?? 0) + (o.concepts?.length ?? 0) + (o.filesModified?.length ?? 0),
+      summary: o.narrative?.slice(0, 200) || "",
+      refs: [ref]
+    };
+    nodes.push(node);
+    if (o.entityName) {
+      const group = entityNameIndex.get(o.entityName) || [];
+      group.push(node);
+      entityNameIndex.set(o.entityName, group);
+    }
+  }
+  for (const s of scopedMiniSkills) {
+    const ref = {
+      kind: "mini-skill",
+      id: `skill:${s.id}`,
+      title: s.title
+    };
+    const obsRefs = s.sourceObservationIds.map(
+      (oid) => ({ kind: "observation", id: `obs:${oid}` })
+    );
+    const node = {
+      id: `skill:${s.id}`,
+      label: s.title,
+      nodeType: "mini-skill",
+      sectionId: "promoted-skills",
+      entityName: s.sourceEntity || void 0,
+      evidenceCount: obsRefs.length,
+      summary: s.instruction?.slice(0, 200) || "",
+      refs: [ref, ...obsRefs]
+    };
+    nodes.push(node);
+    if (s.sourceEntity) {
+      const group = entityNameIndex.get(s.sourceEntity) || [];
+      group.push(node);
+      entityNameIndex.set(s.sourceEntity, group);
+    }
+  }
+  const edges = inferEdges(nodes, entityNameIndex);
+  for (const s of scopedMiniSkills) {
+    const skillNodeId = `skill:${s.id}`;
+    for (const oid of s.sourceObservationIds) {
+      const obsNodeId = `obs:${oid}`;
+      if (nodes.some((n) => n.id === obsNodeId)) {
+        edges.push({
+          id: `e_${edges.length}_${skillNodeId}_${obsNodeId}`,
+          source: skillNodeId,
+          target: obsNodeId,
+          edgeType: "derived_from"
+        });
+      }
+    }
+  }
+  if (graphRelations && graphRelations.length > 0) {
+    const entityNodeMap = /* @__PURE__ */ new Map();
+    for (const n of nodes) {
+      if (n.entityName && !entityNodeMap.has(n.entityName)) {
+        entityNodeMap.set(n.entityName, n.id);
+      }
+    }
+    const seen = new Set(edges.map((e) => `${e.source}:${e.edgeType}:${e.target}`));
+    for (const rel of graphRelations) {
+      const srcId = entityNodeMap.get(rel.from);
+      const tgtId = entityNodeMap.get(rel.to);
+      if (!srcId || !tgtId) continue;
+      if (srcId === tgtId) continue;
+      const edgeType = mapRelationType(rel.relationType);
+      const key = `${srcId}:${edgeType}:${tgtId}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      edges.push({
+        id: `e_gr_${edges.length}_${srcId}_${tgtId}`,
+        source: srcId,
+        target: tgtId,
+        edgeType
+      });
+    }
+  }
+  const sectionCounts = {};
+  for (const n of nodes) {
+    sectionCounts[n.sectionId] = (sectionCounts[n.sectionId] || 0) + 1;
+  }
+  const clusters = ALL_SECTIONS.filter((def) => (sectionCounts[def.id] ?? 0) > 0).map((def) => ({
+    id: `cluster:${def.id}`,
+    label: def.label,
+    sectionId: def.id,
+    nodeCount: sectionCounts[def.id] ?? 0
+  }));
+  const stats = {
+    totalNodes: nodes.length,
+    totalEdges: edges.length,
+    clusterCount: clusters.length,
+    sectionCounts
+  };
+  return {
+    title: "Knowledge Graph",
+    projectId,
+    generatedAt: options.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    nodes,
+    edges,
+    clusters,
+    stats
+  };
+}
+var SECTION_DEFS2, GIT_SECTION, SKILLS_SECTION, ALL_SECTIONS;
+var init_knowledge_graph = __esm({
+  "src/wiki/knowledge-graph.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_generator();
+    SECTION_DEFS2 = [
+      {
+        id: "core-decisions",
+        label: "Core Decisions",
+        typeMatch: (o) => o.type === "decision" || o.type === "trade-off" || o.type === "reasoning"
+      },
+      {
+        id: "operational-knowledge",
+        label: "Operational Knowledge",
+        typeMatch: (o) => o.type === "how-it-works" || o.type === "what-changed" || o.type === "why-it-exists" || o.type === "discovery" || o.type === "session-request"
+      },
+      {
+        id: "known-gotchas",
+        label: "Known Gotchas",
+        typeMatch: (o) => o.type === "gotcha" || o.type === "problem-solution"
+      }
+    ];
+    GIT_SECTION = {
+      id: "git-backed-facts",
+      label: "Git-backed Facts",
+      typeMatch: (o) => o.source === "git" && o.sourceDetail === "git-ingest"
+    };
+    SKILLS_SECTION = {
+      id: "promoted-skills",
+      label: "Promoted Skills",
+      typeMatch: () => false
+      // skills handled separately
+    };
+    ALL_SECTIONS = [...SECTION_DEFS2, GIT_SECTION, SKILLS_SECTION];
+  }
+});
+
 // src/dashboard/server.ts
 var server_exports = {};
 __export(server_exports, {
@@ -9910,6 +10417,7 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
         const typeCounts = {};
         for (const obs of observations2) {
           const t = obs.type || "unknown";
+          if (t === "probe") continue;
           typeCounts[t] = (typeCounts[t] || 0) + 1;
         }
         const sourceCounts = { git: 0, agent: 0, manual: 0 };
@@ -9951,7 +10459,7 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
           else if (score >= 1) retentionSummary.stale++;
           else retentionSummary.archive++;
         }
-        const sorted = [...observations2].sort((a, b) => (b.id || 0) - (a.id || 0)).slice(0, 10);
+        const sorted = [...observations2].filter((o) => o.type !== "probe").sort((a, b) => (b.id || 0) - (a.id || 0)).slice(0, 10);
         let embeddingStatus = { enabled: false, provider: "", dimensions: 0 };
         try {
           const { getEmbeddingProvider: getEmbeddingProvider2 } = await Promise.resolve().then(() => (init_provider(), provider_exports));
@@ -9991,7 +10499,7 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
         const allObs = await getObservationStore().loadAll();
         const observations2 = filterActiveByProject(allObs, effectiveProjectId);
         const now = Date.now();
-        const scored = observations2.map((obs) => {
+        const scored = observations2.filter((obs) => obs.type !== "probe").map((obs) => {
           const age = now - new Date(obs.createdAt || now).getTime();
           const ageHours = age / (1e3 * 60 * 60);
           const importance = obs.importance ?? 5;
@@ -10023,6 +10531,50 @@ async function handleApi(req, res, dataDir, projectId, projectName, baseDir, pro
         });
         break;
       }
+      case "/knowledge": {
+        const { generateKnowledgeBase: generateKnowledgeBase2 } = await Promise.resolve().then(() => (init_generator(), generator_exports));
+        const { initObservations: initObservations2, getAllObservations: getAllObservations2 } = await Promise.resolve().then(() => (init_observations(), observations_exports));
+        const { initMiniSkillStore: initMiniSkillStore2, getMiniSkillStore: getMiniSkillStore2 } = await Promise.resolve().then(() => (init_mini_skill_store(), mini_skill_store_exports));
+        await initObservations2(effectiveDataDir);
+        await initMiniSkillStore2(effectiveDataDir);
+        const allObs = getAllObservations2();
+        const skills = await getMiniSkillStore2().loadByProject(effectiveProjectId);
+        const overview = generateKnowledgeBase2({
+          projectId: effectiveProjectId,
+          observations: allObs,
+          miniSkills: skills
+        });
+        sendJson(res, overview);
+        break;
+      }
+      case "/knowledge-graph": {
+        const { generateKnowledgeGraph: generateKnowledgeGraph2 } = await Promise.resolve().then(() => (init_knowledge_graph(), knowledge_graph_exports));
+        const { initObservations: initObservations2, getAllObservations: getAllObservations2 } = await Promise.resolve().then(() => (init_observations(), observations_exports));
+        const { initMiniSkillStore: initMiniSkillStore2, getMiniSkillStore: getMiniSkillStore2 } = await Promise.resolve().then(() => (init_mini_skill_store(), mini_skill_store_exports));
+        const { initGraphStore: initGraphStore2, getGraphStore: getGraphStore2 } = await Promise.resolve().then(() => (init_graph_store(), graph_store_exports));
+        await initObservations2(effectiveDataDir);
+        await initMiniSkillStore2(effectiveDataDir);
+        await initGraphStore2(effectiveDataDir);
+        const allObs = getAllObservations2();
+        const skills = await getMiniSkillStore2().loadByProject(effectiveProjectId);
+        const fullGraph = { entities: getGraphStore2().loadEntities(), relations: getGraphStore2().loadRelations() };
+        const graphObs = await getObservationStore().loadAll();
+        const projectEntityNames = new Set(
+          graphObs.filter((o) => o.projectId === effectiveProjectId && (o.status ?? "active") === "active" && o.entityName).map((o) => o.entityName)
+        );
+        const scopedEntities = fullGraph.entities.filter((e) => projectEntityNames.has(e.name));
+        const scopedEntityNameSet = new Set(scopedEntities.map((e) => e.name));
+        const scopedRelations = fullGraph.relations.filter((r) => scopedEntityNameSet.has(r.from) && scopedEntityNameSet.has(r.to));
+        const graph = generateKnowledgeGraph2({
+          projectId: effectiveProjectId,
+          observations: allObs,
+          miniSkills: skills,
+          graphEntities: scopedEntities,
+          graphRelations: scopedRelations
+        });
+        sendJson(res, graph);
+        break;
+      }
       case "/config": {
         const os4 = await import("os");
         const { existsSync: existsSync10 } = await import("fs");
@@ -10259,13 +10811,20 @@ async function serveStatic(req, res, staticDir) {
     const ext = path14.extname(filePath);
     res.writeHead(200, {
       "Content-Type": MIME_TYPES[ext] || "application/octet-stream",
-      "Cache-Control": "no-cache"
+      "Cache-Control": "no-store, no-cache, must-revalidate, max-age=0",
+      "Pragma": "no-cache",
+      "Expires": "0"
     });
     res.end(data);
   } catch {
     try {
       const indexData = await fs12.readFile(path14.join(staticDir, "index.html"));
-      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.writeHead(200, {
+        "Content-Type": "text/html; charset=utf-8",
+        "Cache-Control": "no-store, no-cache, must-revalidate, max-age=0",
+        "Pragma": "no-cache",
+        "Expires": "0"
+      });
       res.end(indexData);
     } catch {
       sendError(res, "Not found", 404);
@@ -11736,6 +12295,8 @@ import { spawnSync } from 'node:child_process';
 export const MemorixPlugin = async ({ project, client, $, directory, worktree }) => {
   // Generate a stable session ID for this plugin lifetime
   const sessionId = \`opencode-\${Date.now().toString(36)}-\${Math.random().toString(36).slice(2, 8)}\`;
+  let pendingAssistantResponse = null;
+  let lastDeliveredAssistantKey = '';
 
   /**
    * Send event JSON to \`memorix hook\` via child_process.spawnSync.
@@ -11768,6 +12329,33 @@ export const MemorixPlugin = async ({ project, client, $, directory, worktree })
     }
   }
 
+  function extractMessageInfo(input) {
+    if (input && typeof input === 'object') {
+      if (input.info && typeof input.info === 'object') return input.info;
+      if (input.message && typeof input.message === 'object') return input.message;
+      if (input.properties && typeof input.properties === 'object') {
+        if (input.properties.info && typeof input.properties.info === 'object') return input.properties.info;
+        if (input.properties.message && typeof input.properties.message === 'object') return input.properties.message;
+      }
+    }
+    return input;
+  }
+
+  function extractMessageText(message) {
+    if (!message || typeof message !== 'object') return '';
+    if (typeof message.content === 'string') return message.content.trim();
+    const parts = Array.isArray(message.parts) ? message.parts : [];
+    return parts
+      .map((part) => {
+        if (!part || typeof part !== 'object') return '';
+        if (typeof part.text === 'string') return part.text;
+        if (typeof part.content === 'string') return part.content;
+        return '';
+      })
+      .join('')
+      .trim();
+  }
+
   return {
     /** Session created \u2014 record session start */
     'session.created': async ({ session }) => {
@@ -11780,6 +12368,21 @@ export const MemorixPlugin = async ({ project, client, $, directory, worktree })
 
     /** Session idle \u2014 record session end */
     'session.idle': async ({ session }) => {
+      if (pendingAssistantResponse?.text) {
+        const deliveryKey = pendingAssistantResponse.id
+          ? \`\${pendingAssistantResponse.id}:\${pendingAssistantResponse.text}\`
+          : pendingAssistantResponse.text;
+        if (deliveryKey !== lastDeliveredAssistantKey) {
+          runHook({
+            agent: 'opencode',
+            hook_event_name: 'message.updated',
+            ai_response: pendingAssistantResponse.text,
+            message_id: pendingAssistantResponse.id,
+            cwd: directory,
+          });
+          lastDeliveredAssistantKey = deliveryKey;
+        }
+      }
       runHook({
         agent: 'opencode',
         hook_event_name: 'session.idle',
@@ -11808,6 +12411,19 @@ export const MemorixPlugin = async ({ project, client, $, directory, worktree })
       });
     },
 
+    /** Message updated \u2014 cache the latest assistant response until session.idle */
+    'message.updated': async (input, output) => {
+      const message = extractMessageInfo(input);
+      const role = message?.role ?? input?.role ?? input?.info?.role;
+      if (role !== 'assistant') return;
+      const text = extractMessageText(message);
+      if (!text) return;
+      pendingAssistantResponse = {
+        id: message?.id ?? input?.id ?? input?.messageID,
+        text,
+      };
+    },
+
     /** Session compacted \u2014 record post-compact event */
     'session.compacted': async ({ session }) => {
       runHook({
@@ -12057,7 +12673,7 @@ async function installHooks(agent, projectRoot, global = false) {
       return {
         agent,
         configPath: pluginPath,
-        events: ["session_start", "session_end", "post_tool", "post_edit", "post_compact", "post_command"],
+        events: ["session_start", "session_end", "post_tool", "post_edit", "post_compact", "post_command", "post_response"],
         generated: { note: "OpenCode plugin installed at " + pluginPath }
       };
     }
@@ -12515,7 +13131,7 @@ var init_installers = __esm({
   "src/hooks/installers/index.ts"() {
     "use strict";
     init_esm_shims();
-    OPENCODE_PLUGIN_VERSION = 5;
+    OPENCODE_PLUGIN_VERSION = 6;
   }
 });
 
@@ -13046,7 +13662,8 @@ function getTypeIcon(type) {
     "why-it-exists": "[WHY]",
     "decision": "[DECISION]",
     "trade-off": "[TRADEOFF]",
-    "reasoning": "[REASONING]"
+    "reasoning": "[REASONING]",
+    "probe": "[PROBE]"
   };
   return icons[type] ?? "[UNKNOWN]";
 }
@@ -15545,7 +16162,8 @@ var OBSERVATION_TYPES = [
   "discovery",
   "why-it-exists",
   "decision",
-  "trade-off"
+  "trade-off",
+  "probe"
 ];
 function coerceNumberArray(val) {
   if (Array.isArray(val)) return val.map(Number);
@@ -15774,7 +16392,7 @@ The path should point to a directory containing a .git folder.`
   };
   const server = existingServer ?? new McpServer({
     name: "memorix",
-    version: true ? "1.0.8" : "1.0.1"
+    version: true ? "1.0.9" : "1.0.1"
   });
   const originalRegisterTool = server.registerTool.bind(server);
   server.registerTool = ((name, ...args) => {