@merittdev/horus 0.12.2 → 0.12.3

package/dist/index.cjs

@@ -65880,8 +65880,8 @@ init_cjs_shims();
 
 // ../../packages/core/src/version.ts
 init_cjs_shims();
-var HORUS_VERSION = true ? "0.12.2" : "dev";
-var PINNED_SOURCE_VERSION = "2.0.1";
+var HORUS_VERSION = true ? "0.12.3" : "dev";
+var PINNED_SOURCE_VERSION = "2.0.2";
 
 // ../../packages/core/src/evidence.ts
 init_cjs_shims();
@@ -71127,6 +71127,42 @@ async function assertSourceVersionPinned() {
 function isAnalyzed(root) {
   return (0, import_node_fs3.existsSync)((0, import_node_path3.join)(root, ".horus", "source"));
 }
+var CURRENT_STORE_BACKEND = (process.env["HORUS_SOURCE_STORAGE_BACKEND"] ?? "sqlite").trim().toLowerCase();
+function readSourceMeta(root) {
+  try {
+    const raw = (0, import_node_fs3.readFileSync)((0, import_node_path3.join)(root, ".horus", "source", "meta.json"), "utf8");
+    const j3 = JSON.parse(raw);
+    const stats = j3["stats"] ?? void 0;
+    return {
+      storeBackend: typeof j3["store_backend"] === "string" ? j3["store_backend"].toLowerCase() : void 0,
+      embeddingsComplete: typeof j3["embeddings_complete"] === "boolean" ? j3["embeddings_complete"] : void 0,
+      stats: stats ? { symbols: stats["symbols"], embeddings: stats["embeddings"] } : void 0
+    };
+  } catch {
+    return null;
+  }
+}
+function metaHasEmbeddings(meta) {
+  if (meta.embeddingsComplete === false) return false;
+  const embeddings = meta.stats?.embeddings ?? 0;
+  const symbols = meta.stats?.symbols ?? 0;
+  return !(symbols > 0 && embeddings === 0);
+}
+function indexNeedsReanalyze(root) {
+  if (!isAnalyzed(root)) return null;
+  if (CURRENT_STORE_BACKEND !== "kuzu" && (0, import_node_fs3.existsSync)((0, import_node_path3.join)(root, ".horus", "source", "kuzu"))) {
+    return "legacy K\xF9zuDB store present";
+  }
+  const meta = readSourceMeta(root);
+  if (meta === null) return null;
+  if (meta.storeBackend && meta.storeBackend !== CURRENT_STORE_BACKEND) {
+    return `store backend changed (${meta.storeBackend} -> ${CURRENT_STORE_BACKEND})`;
+  }
+  if (!metaHasEmbeddings(meta)) {
+    return "index has no semantic embeddings (symbols present but 0 vectors)";
+  }
+  return null;
+}
 async function analyzeRepo(root) {
   const bin = await resolveSourceBin();
   if (!bin) throw new Error("horus-source not found on PATH. Install it: curl -fsSL https://horus.sh/install.sh | bash");
@@ -71457,7 +71493,7 @@ var SourceCodeProvider = class {
     if (n4.className) symbol.className = n4.className;
     if (n4.language) symbol.language = n4.language;
     const content = n4.content;
-    const snippet = typeof content === "string" ? content.slice(0, 600) : void 0;
+    const snippet2 = typeof content === "string" ? content.slice(0, 600) : void 0;
     const sourceBody = typeof content === "string" ? content.slice(0, 2e4) : void 0;
     const callees = (detail.callees ?? []).map((c4) => this.serializedToSymbol(c4.node));
     const callers = (detail.callers ?? []).map((c4) => this.serializedToSymbol(c4.node));
@@ -71471,7 +71507,7 @@ var SourceCodeProvider = class {
     }));
     return {
       symbol,
-      snippet,
+      snippet: snippet2,
       ...sourceBody !== void 0 ? { sourceBody } : {},
       callers,
       callees,
@@ -93004,7 +93040,13 @@ var MEMORY_RELS = /* @__PURE__ */ new Set([
 function isSymmetricRel(rel) {
   return rel === "recurs-with";
 }
-var INCIDENT_DERIVED_KINDS = /* @__PURE__ */ new Set(["confirmed-outcome", "incident-pattern"]);
+var INCIDENT_DERIVED_KINDS = /* @__PURE__ */ new Set([
+  "confirmed-outcome",
+  "incident-pattern",
+  // HOR-432: auto-captured investigation memories carry the same incident-family signature/tags so
+  // they participate in recurrence detection. CONTEXT-ONLY — never read by the scoring path.
+  "investigation"
+]);
 function normalizeStoredSignature(sig) {
   const s5 = (sig ?? "").trim();
   if (s5 === "" || /^\|*$/.test(s5)) return null;
@@ -93109,6 +93151,35 @@ function createLocalMemoryStore(db) {
       });
       return row;
     },
+    async update(id, patch, opts) {
+      const current = await getById(id);
+      if (current === null) throw new Error(`memory item not found: ${id}`);
+      const set = {};
+      if (patch.claim !== void 0) {
+        assertClaimClean(patch.claim);
+        set.claim = patch.claim;
+      }
+      if (patch.confidence !== void 0) set.confidence = patch.confidence;
+      if (patch.payload !== void 0) set.payload = patch.payload;
+      if (Object.keys(set).length > 0) {
+        await db.update(memoryItem).set(set).where(eq(memoryItem.id, id));
+      }
+      await appendAudit({
+        memoryId: id,
+        action: opts.action ?? "update",
+        actor: opts.audit.actor,
+        fromStatus: null,
+        toStatus: null,
+        note: opts.audit.note ?? null,
+        detail: {
+          ...opts.detection ? { detection: opts.detection } : {},
+          ...opts.detail ?? {}
+        }
+      });
+      const updated = await getById(id);
+      if (updated === null) throw new Error(`memory item vanished during update: ${id}`);
+      return updated;
+    },
     get: getById,
     async query(q2) {
       const repo = q2.repo.trim();
@@ -93296,6 +93367,395 @@ function createLocalMemoryStore(db) {
   };
 }
 
+// ../../packages/engine/src/auto-investigation-memory.ts
+init_cjs_shims();
+
+// ../../packages/engine/src/memory-detect.ts
+init_cjs_shims();
+var import_node_crypto3 = require("crypto");
+
+// ../../packages/engine/src/memory-store.ts
+init_cjs_shims();
+var HIDDEN_STATUSES = [
+  "forgotten",
+  "deprecated",
+  "contradicted"
+];
+function tokenize2(text2) {
+  const seen = /* @__PURE__ */ new Set();
+  const out2 = [];
+  for (const raw of text2.toLowerCase().split(/[^a-z0-9]+/)) {
+    if (raw !== "" && !seen.has(raw)) {
+      seen.add(raw);
+      out2.push(raw);
+    }
+  }
+  return out2;
+}
+function scopeSpecificity(scope) {
+  if (scope.startsWith("symbol:")) return 3;
+  if (scope.startsWith("module:")) return 2;
+  if (scope === "repo") return 1;
+  return 0;
+}
+var NoopVectorIndex = class {
+  entries = /* @__PURE__ */ new Map();
+  async upsert(i3) {
+    this.entries.set(i3.memoryId, {
+      memoryId: i3.memoryId,
+      repo: i3.repo,
+      scope: i3.scope,
+      tokens: tokenize2(i3.claim)
+    });
+  }
+  async search(i3) {
+    const repo = i3.repo.trim();
+    if (repo === "") return [];
+    const queryTokens = tokenize2(i3.query);
+    if (queryTokens.length === 0) return [];
+    const scored = [...this.entries.values()].filter((e) => e.repo === repo).map((e) => ({
+      memoryId: e.memoryId,
+      score: tagOverlap(queryTokens, e.tokens),
+      specificity: scopeSpecificity(e.scope)
+    })).filter((h3) => h3.score > 0).sort(
+      (a2, b5) => b5.score - a2.score || b5.specificity - a2.specificity || (a2.memoryId < b5.memoryId ? -1 : a2.memoryId > b5.memoryId ? 1 : 0)
+    );
+    const limit = Number.isFinite(i3.limit) && i3.limit > 0 ? Math.floor(i3.limit) : scored.length;
+    return scored.slice(0, limit).map((h3) => ({ memoryId: h3.memoryId, score: h3.score }));
+  }
+  async remove(memoryId) {
+    this.entries.delete(memoryId);
+  }
+};
+
+// ../../packages/engine/src/memory-detect.ts
+var TAG_OVERLAP_MIN = 0.6;
+var CLAIM_JACCARD_MIN = 0.6;
+var MIN_CLAIM_TOKENS = 4;
+var INCIDENT_DERIVED_KINDS2 = /* @__PURE__ */ new Set([
+  "confirmed-outcome",
+  "incident-pattern"
+]);
+function usableSignature(sig) {
+  const s5 = (sig ?? "").trim();
+  if (s5 === "" || /^\|*$/.test(s5)) return null;
+  const components = s5.split(/[|,]/).map((c4) => c4.trim()).filter((c4) => c4 !== "");
+  if (components.length === 0) return null;
+  if (components.every((c4) => isGenericTag(c4))) return null;
+  return s5;
+}
+function sharedNonGenericTags(a2, b5) {
+  const setB = new Set(b5);
+  const seen = /* @__PURE__ */ new Set();
+  const out2 = [];
+  for (const t2 of a2) {
+    if (setB.has(t2) && !isGenericTag(t2) && !seen.has(t2)) {
+      seen.add(t2);
+      out2.push(t2);
+    }
+  }
+  return out2;
+}
+function recurrenceEdgeId(idA, idB) {
+  const [lo, hi] = idA <= idB ? [idA, idB] : [idB, idA];
+  const h3 = (0, import_node_crypto3.createHash)("sha256").update(`recurs-with\0${lo}\0${hi}`).digest("hex");
+  return `lnk_recurs_${h3.slice(0, 32)}`;
+}
+function normalizeCause(s5) {
+  return (s5 ?? "").trim().toLowerCase().replace(/\s+/g, " ");
+}
+function outcomeConflict(a2, b5) {
+  const opposite = a2.resolved === "yes" && b5.resolved === "no" || a2.resolved === "no" && b5.resolved === "yes";
+  if (opposite) {
+    return `outcome verdicts disagree (${a2.resolved} vs ${b5.resolved})`;
+  }
+  const ca = normalizeCause(a2.confirmedCause);
+  const cb = normalizeCause(b5.confirmedCause);
+  if (ca !== "" && cb !== "" && ca !== cb) {
+    return `confirmed causes differ ("${a2.confirmedCause}" vs "${b5.confirmedCause}")`;
+  }
+  return null;
+}
+function recurrenceReason(a2, b5) {
+  const sigA = usableSignature(a2.signature);
+  const sigB = usableSignature(b5.signature);
+  if (sigA !== null && sigB !== null && sigA === sigB) {
+    return `identical incident signature "${sigA}"`;
+  }
+  const tagsA = a2.tags ?? [];
+  const tagsB = b5.tags ?? [];
+  const shared = sharedNonGenericTags(tagsA, tagsB);
+  const overlap = tagOverlap([...tagsA], [...tagsB]);
+  if (overlap >= TAG_OVERLAP_MIN && shared.length >= 1) {
+    return `tag overlap ${overlap.toFixed(2)} on [${shared.join(", ")}]`;
+  }
+  if (sigA === null && sigB === null && shared.length >= 1) {
+    const ta = tokenize2(a2.claim);
+    const tb = tokenize2(b5.claim);
+    if (ta.length >= MIN_CLAIM_TOKENS && tb.length >= MIN_CLAIM_TOKENS) {
+      const j3 = tagOverlap(ta, tb);
+      if (j3 >= CLAIM_JACCARD_MIN) {
+        return `claim similarity ${j3.toFixed(2)} corroborated by [${shared.join(", ")}]`;
+      }
+    }
+  }
+  return null;
+}
+function edgeKey(rel, from, to) {
+  if (rel === "recurs-with" || rel === "contradicts") {
+    const [lo, hi] = from <= to ? [from, to] : [to, from];
+    return `${rel}|${lo}|${hi}`;
+  }
+  return `${rel}|${from}|${to}`;
+}
+async function detectMemoryEdges(store, opts, deps = {}) {
+  const repo = opts.repo.trim();
+  if (repo === "") return [];
+  const items = await store.query({ repo, limit: opts.limit ?? 1e3 });
+  const candidates = items.filter((i3) => INCIDENT_DERIVED_KINDS2.has(i3.kind));
+  if (candidates.length < 2) return [];
+  const existing = /* @__PURE__ */ new Set();
+  const investigationOf = /* @__PURE__ */ new Map();
+  for (const item of candidates) {
+    const out2 = await store.links(item.id, { direction: "out" });
+    for (const l2 of out2) {
+      if (l2.toKind === "memory") {
+        existing.add(edgeKey(l2.rel, l2.fromMemoryId, l2.toRef));
+      } else if (l2.toKind === "incident" && l2.rel === "about-incident") {
+        if (!investigationOf.has(item.id)) investigationOf.set(item.id, l2.toRef);
+      }
+    }
+  }
+  const proposals = [];
+  const outcomeCache = /* @__PURE__ */ new Map();
+  const resolveOutcome = async (investigationId) => {
+    if (deps.outcomeFor === void 0) return null;
+    if (outcomeCache.has(investigationId)) return outcomeCache.get(investigationId) ?? null;
+    let v4 = null;
+    try {
+      v4 = await deps.outcomeFor(investigationId);
+    } catch {
+      v4 = null;
+    }
+    outcomeCache.set(investigationId, v4);
+    return v4;
+  };
+  for (let i3 = 0; i3 < candidates.length; i3++) {
+    const a2 = candidates[i3];
+    for (let j3 = i3 + 1; j3 < candidates.length; j3++) {
+      const b5 = candidates[j3];
+      if (!existing.has(edgeKey("recurs-with", a2.id, b5.id))) {
+        const reason = recurrenceReason(a2, b5);
+        if (reason !== null) {
+          const [lo, hi] = a2.id <= b5.id ? [a2.id, b5.id] : [b5.id, a2.id];
+          proposals.push({
+            id: recurrenceEdgeId(a2.id, b5.id),
+            fromMemoryId: lo,
+            toMemoryId: hi,
+            rel: "recurs-with",
+            detection: "auto:recurrence",
+            reason
+          });
+        }
+      }
+      if (deps.outcomeFor !== void 0 && a2.kind === "confirmed-outcome" && b5.kind === "confirmed-outcome" && !existing.has(edgeKey("contradicts", a2.id, b5.id))) {
+        const sigA = usableSignature(a2.signature);
+        const sigB = usableSignature(b5.signature);
+        const invA = investigationOf.get(a2.id);
+        const invB = investigationOf.get(b5.id);
+        if (sigA !== null && sigA === sigB && invA !== void 0 && invB !== void 0) {
+          const oa = await resolveOutcome(invA);
+          const ob = await resolveOutcome(invB);
+          if (oa !== null && ob !== null) {
+            const reason = outcomeConflict(oa, ob);
+            if (reason !== null) {
+              const [lo, hi] = a2.id <= b5.id ? [a2.id, b5.id] : [b5.id, a2.id];
+              const invLo = lo === a2.id ? invA : invB;
+              const invHi = lo === a2.id ? invB : invA;
+              proposals.push({
+                id: "",
+                // directional — the store mints the id
+                fromMemoryId: lo,
+                toMemoryId: hi,
+                rel: "contradicts",
+                detection: "auto:contradiction",
+                reason,
+                detail: { investigationIds: [invLo, invHi] }
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+  return proposals;
+}
+
+// ../../packages/engine/src/auto-investigation-memory.ts
+var RECURRENCE_SCAN_LIMIT = 100;
+var MAX_INVESTIGATION_IDS = 20;
+function snippet(text2, max = 140) {
+  const s5 = text2.trim().replace(/\s+/g, " ");
+  return s5.length > max ? `${s5.slice(0, max - 1)}\u2026` : s5;
+}
+function autoInvestigationMemoryEnabled() {
+  const v4 = (process.env.HORUS_AUTO_INVESTIGATION_MEMORY ?? "").trim().toLowerCase();
+  return v4 !== "0" && v4 !== "false" && v4 !== "off" && v4 !== "no";
+}
+function deriveInvestigationFields(report) {
+  const hint = report.input.hint;
+  const topHyp = report.hypotheses[0];
+  const headline = topHyp !== void 0 ? snippet(topHyp.statement || topHyp.category || report.summary) : snippet(report.summary || "(no leading hypothesis)");
+  return {
+    hint,
+    claim: `Investigation: ${snippet(hint)} -> ${headline}`,
+    confidence: report.confidence,
+    signature: deriveSignature(report),
+    tags: deriveTags(report),
+    topHypothesisCategory: topHyp !== void 0 ? topHyp.category ?? null : null
+  };
+}
+function recurrenceCountOf(payload) {
+  if (payload !== null && typeof payload === "object") {
+    const c4 = payload.recurrenceCount;
+    if (typeof c4 === "number" && Number.isFinite(c4) && c4 >= 1) return Math.floor(c4);
+  }
+  return 1;
+}
+async function createInvestigationMemory(store, investigationId, report, audit) {
+  const repo = report.input.repo?.trim() || null;
+  if (repo === null) return null;
+  const fields = deriveInvestigationFields(report);
+  const item = {
+    id: "",
+    kind: "investigation",
+    source: "investigation",
+    scope: "repo",
+    visibility: "private",
+    // HONEST confidence — the report's own value, never inflated.
+    confidence: fields.confidence,
+    claim: fields.claim,
+    repo,
+    evidence: [],
+    // Incident-family recall keys (same derivation as incident_memory) so this memory recurs.
+    signature: fields.signature,
+    tags: fields.tags,
+    payload: {
+      investigationId,
+      hint: fields.hint,
+      topHypothesis: fields.topHypothesisCategory,
+      // First sighting: a single investigation is "recurred 1×". Bumped on each later recurrence.
+      recurrenceCount: 1
+    }
+  };
+  const created = await store.add(item, audit);
+  if (investigationId !== null && investigationId.trim() !== "") {
+    await store.addLink(
+      {
+        id: "",
+        fromMemoryId: created.id,
+        rel: "about-incident",
+        toKind: "incident",
+        toRef: investigationId
+      },
+      { detection: "structural", audit }
+    );
+  }
+  return created;
+}
+async function detectRecurrence(store, probe2, repo) {
+  const r = repo.trim();
+  if (r === "") return null;
+  const existing = await store.query({
+    repo: r,
+    kind: ["investigation"],
+    limit: RECURRENCE_SCAN_LIMIT
+  });
+  for (const candidate of existing) {
+    if (recurrenceReason(candidate, probe2) !== null) return candidate;
+  }
+  return null;
+}
+async function consolidateRecurrence(store, existing, investigationId, fields, reportTime, audit) {
+  const prev = existing.payload ?? {};
+  const recurrenceCount = recurrenceCountOf(prev) + 1;
+  const prevIds = Array.isArray(prev.investigationIds) ? prev.investigationIds.filter((x4) => typeof x4 === "string") : [];
+  const seedIds = prevIds.length > 0 ? prevIds : typeof prev.investigationId === "string" ? [prev.investigationId] : [];
+  const thisId = investigationId !== null && investigationId.trim() !== "" ? investigationId : null;
+  const investigationIds = (thisId !== null ? [...seedIds, thisId] : seedIds).slice(
+    -MAX_INVESTIGATION_IDS
+  );
+  const payload = {
+    ...prev,
+    recurrenceCount,
+    lastSeenAt: reportTime.toISOString(),
+    investigationIds,
+    // Refresh the "latest finding" provenance; keep the original first-seen id for reference.
+    hint: fields.hint,
+    topHypothesis: fields.topHypothesisCategory,
+    investigationId: typeof prev.investigationId === "string" ? prev.investigationId : seedIds[0] ?? thisId
+  };
+  const updated = await store.update(
+    existing.id,
+    {
+      claim: fields.claim,
+      // HONEST: the LATEST report's confidence, verbatim — never inflated, never an average.
+      confidence: fields.confidence,
+      payload
+    },
+    {
+      audit,
+      action: "recurrence",
+      detection: "auto:recurrence-consolidate",
+      detail: { recurrenceCount, ...thisId !== null ? { investigationId: thisId } : {} }
+    }
+  );
+  if (thisId !== null) {
+    await store.addLink(
+      {
+        id: "",
+        fromMemoryId: existing.id,
+        rel: "about-incident",
+        toKind: "incident",
+        toRef: thisId
+      },
+      { detection: "structural", audit }
+    );
+  }
+  return updated;
+}
+async function captureInvestigationMemory(store, investigationId, report, reportTime, audit) {
+  const repo = report.input.repo?.trim() || null;
+  if (repo === null) return { action: "skipped", memoryId: null, recurrenceCount: 0 };
+  const fields = deriveInvestigationFields(report);
+  const existing = await detectRecurrence(
+    store,
+    { signature: fields.signature, tags: fields.tags, claim: fields.claim },
+    repo
+  );
+  if (existing !== null) {
+    const updated = await consolidateRecurrence(
+      store,
+      existing,
+      investigationId,
+      fields,
+      reportTime,
+      audit
+    );
+    return {
+      action: "consolidated",
+      memoryId: updated.id,
+      recurrenceCount: recurrenceCountOf(updated.payload)
+    };
+  }
+  const created = await createInvestigationMemory(store, investigationId, report, audit);
+  return {
+    action: created !== null ? "created" : "skipped",
+    memoryId: created?.id ?? null,
+    recurrenceCount: 1
+  };
+}
+
 // ../../packages/engine/src/gaps.ts
 init_cjs_shims();
 function detectMissingEvidence(r, connectors = {}, mode) {
@@ -94858,8 +95318,8 @@ async function investigate(input, deps) {
       // HOR-386 — empty-return: route to `search` for the right name (deterministic).
       nextSteps: route({ command: "investigate", empty: true, query: hint })
     };
-    const persistedId2 = await persist(db, input, report2);
-    if (persistedId2) report2.id = persistedId2;
+    const persistedEmpty = await persist(db, input, report2);
+    if (persistedEmpty) report2.id = persistedEmpty.id;
     return report2;
   }
   let label = input.service ?? hint;
@@ -96253,13 +96713,26 @@ async function investigate(input, deps) {
     query: hint
   });
   report.sourceStatus = buildRuntimeSourceStatus(evidence2, connectorFlags);
-  const persistedId = await persist(db, input, report);
-  if (persistedId) report.id = persistedId;
+  const persisted = await persist(db, input, report);
+  const persistedId = persisted?.id ?? null;
+  if (persistedId !== null) report.id = persistedId;
   report.persisted = persistedId !== null;
   if (persistedId !== null) {
     const tags = deriveTags(report);
     report.similarIncidents = await recallSimilar(db, tags, persistedId, input.repo ?? null);
     await storeIncidentMemory(db, persistedId, report);
+    const store = deps.store;
+    if (store !== void 0 && autoInvestigationMemoryEnabled()) {
+      try {
+        const audit = {
+          actor: { kind: "system" },
+          note: "auto: investigation memory (HOR-432)"
+        };
+        const reportTime = persisted?.createdAt ?? /* @__PURE__ */ new Date();
+        await captureInvestigationMemory(store, persistedId, report, reportTime, audit);
+      } catch {
+      }
+    }
   }
   if (persistedId !== null) {
     try {
@@ -96303,7 +96776,7 @@ async function persist(db, input, report) {
       incidentInput: input,
       status: "open",
       summary: report.summary
-    }).returning({ id: investigations.id });
+    }).returning({ id: investigations.id, createdAt: investigations.createdAt });
     const row = inserted[0];
     if (!row) return null;
     const investigationId = row.id;
@@ -96347,7 +96820,7 @@ async function persist(db, input, report) {
         }))
       );
     }
-    return investigationId;
+    return { id: investigationId, createdAt: row.createdAt ?? null };
   } catch {
     return null;
   }
@@ -97056,225 +97529,6 @@ function blastRadiusToJSON(r) {
   return JSON.stringify(r, null, 2);
 }
 
-// ../../packages/engine/src/memory-store.ts
-init_cjs_shims();
-var HIDDEN_STATUSES = [
-  "forgotten",
-  "deprecated",
-  "contradicted"
-];
-function tokenize2(text2) {
-  const seen = /* @__PURE__ */ new Set();
-  const out2 = [];
-  for (const raw of text2.toLowerCase().split(/[^a-z0-9]+/)) {
-    if (raw !== "" && !seen.has(raw)) {
-      seen.add(raw);
-      out2.push(raw);
-    }
-  }
-  return out2;
-}
-function scopeSpecificity(scope) {
-  if (scope.startsWith("symbol:")) return 3;
-  if (scope.startsWith("module:")) return 2;
-  if (scope === "repo") return 1;
-  return 0;
-}
-var NoopVectorIndex = class {
-  entries = /* @__PURE__ */ new Map();
-  async upsert(i3) {
-    this.entries.set(i3.memoryId, {
-      memoryId: i3.memoryId,
-      repo: i3.repo,
-      scope: i3.scope,
-      tokens: tokenize2(i3.claim)
-    });
-  }
-  async search(i3) {
-    const repo = i3.repo.trim();
-    if (repo === "") return [];
-    const queryTokens = tokenize2(i3.query);
-    if (queryTokens.length === 0) return [];
-    const scored = [...this.entries.values()].filter((e) => e.repo === repo).map((e) => ({
-      memoryId: e.memoryId,
-      score: tagOverlap(queryTokens, e.tokens),
-      specificity: scopeSpecificity(e.scope)
-    })).filter((h3) => h3.score > 0).sort(
-      (a2, b5) => b5.score - a2.score || b5.specificity - a2.specificity || (a2.memoryId < b5.memoryId ? -1 : a2.memoryId > b5.memoryId ? 1 : 0)
-    );
-    const limit = Number.isFinite(i3.limit) && i3.limit > 0 ? Math.floor(i3.limit) : scored.length;
-    return scored.slice(0, limit).map((h3) => ({ memoryId: h3.memoryId, score: h3.score }));
-  }
-  async remove(memoryId) {
-    this.entries.delete(memoryId);
-  }
-};
-
-// ../../packages/engine/src/memory-detect.ts
-init_cjs_shims();
-var import_node_crypto3 = require("crypto");
-var TAG_OVERLAP_MIN = 0.6;
-var CLAIM_JACCARD_MIN = 0.6;
-var MIN_CLAIM_TOKENS = 4;
-var INCIDENT_DERIVED_KINDS2 = /* @__PURE__ */ new Set([
-  "confirmed-outcome",
-  "incident-pattern"
-]);
-function usableSignature(sig) {
-  const s5 = (sig ?? "").trim();
-  if (s5 === "" || /^\|*$/.test(s5)) return null;
-  const components = s5.split(/[|,]/).map((c4) => c4.trim()).filter((c4) => c4 !== "");
-  if (components.length === 0) return null;
-  if (components.every((c4) => isGenericTag(c4))) return null;
-  return s5;
-}
-function sharedNonGenericTags(a2, b5) {
-  const setB = new Set(b5);
-  const seen = /* @__PURE__ */ new Set();
-  const out2 = [];
-  for (const t2 of a2) {
-    if (setB.has(t2) && !isGenericTag(t2) && !seen.has(t2)) {
-      seen.add(t2);
-      out2.push(t2);
-    }
-  }
-  return out2;
-}
-function recurrenceEdgeId(idA, idB) {
-  const [lo, hi] = idA <= idB ? [idA, idB] : [idB, idA];
-  const h3 = (0, import_node_crypto3.createHash)("sha256").update(`recurs-with\0${lo}\0${hi}`).digest("hex");
-  return `lnk_recurs_${h3.slice(0, 32)}`;
-}
-function normalizeCause(s5) {
-  return (s5 ?? "").trim().toLowerCase().replace(/\s+/g, " ");
-}
-function outcomeConflict(a2, b5) {
-  const opposite = a2.resolved === "yes" && b5.resolved === "no" || a2.resolved === "no" && b5.resolved === "yes";
-  if (opposite) {
-    return `outcome verdicts disagree (${a2.resolved} vs ${b5.resolved})`;
-  }
-  const ca = normalizeCause(a2.confirmedCause);
-  const cb = normalizeCause(b5.confirmedCause);
-  if (ca !== "" && cb !== "" && ca !== cb) {
-    return `confirmed causes differ ("${a2.confirmedCause}" vs "${b5.confirmedCause}")`;
-  }
-  return null;
-}
-function recurrenceReason(a2, b5) {
-  const sigA = usableSignature(a2.signature);
-  const sigB = usableSignature(b5.signature);
-  if (sigA !== null && sigB !== null && sigA === sigB) {
-    return `identical incident signature "${sigA}"`;
-  }
-  const tagsA = a2.tags ?? [];
-  const tagsB = b5.tags ?? [];
-  const shared = sharedNonGenericTags(tagsA, tagsB);
-  const overlap = tagOverlap([...tagsA], [...tagsB]);
-  if (overlap >= TAG_OVERLAP_MIN && shared.length >= 1) {
-    return `tag overlap ${overlap.toFixed(2)} on [${shared.join(", ")}]`;
-  }
-  if (sigA === null && sigB === null && shared.length >= 1) {
-    const ta = tokenize2(a2.claim);
-    const tb = tokenize2(b5.claim);
-    if (ta.length >= MIN_CLAIM_TOKENS && tb.length >= MIN_CLAIM_TOKENS) {
-      const j3 = tagOverlap(ta, tb);
-      if (j3 >= CLAIM_JACCARD_MIN) {
-        return `claim similarity ${j3.toFixed(2)} corroborated by [${shared.join(", ")}]`;
-      }
-    }
-  }
-  return null;
-}
-function edgeKey(rel, from, to) {
-  if (rel === "recurs-with" || rel === "contradicts") {
-    const [lo, hi] = from <= to ? [from, to] : [to, from];
-    return `${rel}|${lo}|${hi}`;
-  }
-  return `${rel}|${from}|${to}`;
-}
-async function detectMemoryEdges(store, opts, deps = {}) {
-  const repo = opts.repo.trim();
-  if (repo === "") return [];
-  const items = await store.query({ repo, limit: opts.limit ?? 1e3 });
-  const candidates = items.filter((i3) => INCIDENT_DERIVED_KINDS2.has(i3.kind));
-  if (candidates.length < 2) return [];
-  const existing = /* @__PURE__ */ new Set();
-  const investigationOf = /* @__PURE__ */ new Map();
-  for (const item of candidates) {
-    const out2 = await store.links(item.id, { direction: "out" });
-    for (const l2 of out2) {
-      if (l2.toKind === "memory") {
-        existing.add(edgeKey(l2.rel, l2.fromMemoryId, l2.toRef));
-      } else if (l2.toKind === "incident" && l2.rel === "about-incident") {
-        if (!investigationOf.has(item.id)) investigationOf.set(item.id, l2.toRef);
-      }
-    }
-  }
-  const proposals = [];
-  const outcomeCache = /* @__PURE__ */ new Map();
-  const resolveOutcome = async (investigationId) => {
-    if (deps.outcomeFor === void 0) return null;
-    if (outcomeCache.has(investigationId)) return outcomeCache.get(investigationId) ?? null;
-    let v4 = null;
-    try {
-      v4 = await deps.outcomeFor(investigationId);
-    } catch {
-      v4 = null;
-    }
-    outcomeCache.set(investigationId, v4);
-    return v4;
-  };
-  for (let i3 = 0; i3 < candidates.length; i3++) {
-    const a2 = candidates[i3];
-    for (let j3 = i3 + 1; j3 < candidates.length; j3++) {
-      const b5 = candidates[j3];
-      if (!existing.has(edgeKey("recurs-with", a2.id, b5.id))) {
-        const reason = recurrenceReason(a2, b5);
-        if (reason !== null) {
-          const [lo, hi] = a2.id <= b5.id ? [a2.id, b5.id] : [b5.id, a2.id];
-          proposals.push({
-            id: recurrenceEdgeId(a2.id, b5.id),
-            fromMemoryId: lo,
-            toMemoryId: hi,
-            rel: "recurs-with",
-            detection: "auto:recurrence",
-            reason
-          });
-        }
-      }
-      if (deps.outcomeFor !== void 0 && a2.kind === "confirmed-outcome" && b5.kind === "confirmed-outcome" && !existing.has(edgeKey("contradicts", a2.id, b5.id))) {
-        const sigA = usableSignature(a2.signature);
-        const sigB = usableSignature(b5.signature);
-        const invA = investigationOf.get(a2.id);
-        const invB = investigationOf.get(b5.id);
-        if (sigA !== null && sigA === sigB && invA !== void 0 && invB !== void 0) {
-          const oa = await resolveOutcome(invA);
-          const ob = await resolveOutcome(invB);
-          if (oa !== null && ob !== null) {
-            const reason = outcomeConflict(oa, ob);
-            if (reason !== null) {
-              const [lo, hi] = a2.id <= b5.id ? [a2.id, b5.id] : [b5.id, a2.id];
-              const invLo = lo === a2.id ? invA : invB;
-              const invHi = lo === a2.id ? invB : invA;
-              proposals.push({
-                id: "",
-                // directional — the store mints the id
-                fromMemoryId: lo,
-                toMemoryId: hi,
-                rel: "contradicts",
-                detection: "auto:contradiction",
-                reason,
-                detail: { investigationIds: [invLo, invHi] }
-              });
-            }
-          }
-        }
-      }
-    }
-  }
-  return proposals;
-}
-
 // ../../packages/engine/src/memory-recall.ts
 init_cjs_shims();
 var import_node_crypto4 = require("crypto");
@@ -101915,8 +102169,13 @@ async function runIndex(opts) {
         console.error(import_picocolors6.default.red(`  ${err2.message}`));
         return 1;
       }
-      if (!isAnalyzed(root)) {
-        console.log(import_picocolors6.default.dim("  analyzing with source-intelligence backend (first time \u2014 this can take a while)\u2026"));
+      const staleReason = isAnalyzed(root) ? indexNeedsReanalyze(root) : null;
+      if (!isAnalyzed(root) || staleReason) {
+        console.log(
+          import_picocolors6.default.dim(
+            staleReason ? `  existing index is stale (${staleReason}) \u2014 re-analyzing with source-intelligence backend\u2026` : "  analyzing with source-intelligence backend (first time \u2014 this can take a while)\u2026"
+          )
+        );
         try {
           await analyzeRepo(root);
         } catch (err2) {
@@ -115375,6 +115634,9 @@ async function runOneInvestigation(input, ctx, opts = {}) {
     {
       code: ctx.code,
       db: ctx.dbHandle.db,
+      // HOR-432 — the authored-memory store so every investigation auto-captures a recurrence-aware
+      // memory. Best-effort + CONTEXT-ONLY in the engine (never feeds scoring, never blocks delivery).
+      store: createLocalMemoryStore(ctx.dbHandle.db),
       logs: ctx.logs,
       mongo: ctx.mongo,
       postgres: ctx.postgres,
@@ -117432,6 +117694,39 @@ function createCloudMemoryStore(client, cfg) {
         tags: null
       };
     },
+    // HOR-432 consolidation mirror: refresh the scalar fields the cloud accepts (claim/confidence).
+    // PRIVACY: `payload` NEVER leaves the device (it can stash a vector) — it is intentionally dropped
+    // here, exactly like `add`/`toSyncInput`. The return is the server echo (or a synthesized stub) and
+    // is only consumed by the dual-write wrapper, which discards it; reads always come from local.
+    async update(id, patch, _opts) {
+      const input = { clientId: id };
+      if (patch.claim !== void 0) input.claim = patch.claim;
+      if (patch.confidence !== void 0) input.confidence = patch.confidence;
+      const res = await client.syncMemoryItems(projectId, { items: [input] });
+      const record2 = res.items?.find((r) => r.clientId === id);
+      if (record2) return fromWire(record2, repoFallback);
+      return {
+        id,
+        kind: "investigation",
+        claim: patch.claim ?? "",
+        scope: "repo",
+        source: "investigation",
+        evidence: [],
+        confidence: patch.confidence ?? 0,
+        status: "fresh",
+        createdAt: /* @__PURE__ */ new Date(),
+        lastVerifiedAt: null,
+        lastVerifiedHash: null,
+        orgId: null,
+        workspaceId: null,
+        repo: repoFallback,
+        userId: null,
+        visibility: "private",
+        payload: null,
+        signature: null,
+        tags: null
+      };
+    },
     async get(id) {
       try {
         return await findInList(id);
@@ -117539,6 +117834,14 @@ function dualWriteMemoryStore(local, cloud, onCloudError = () => {
       });
       return row;
     },
+    async update(id, patch, opts) {
+      const row = await local.update(id, patch, opts);
+      await mirror(async () => {
+        await cloud.update(id, patch, opts);
+        await mirrorLatestAudit(id);
+      });
+      return row;
+    },
     async setStatus(id, status, audit) {
       await local.setStatus(id, status, audit);
       await mirror(async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@merittdev/horus",
-  "version": "0.12.2",
+  "version": "0.12.3",
   "description": "Local-first, source-aware production-incident investigation engine",
   "type": "module",
   "bin": {