agenr 0.9.93 → 0.9.95

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## [0.9.95] - 2026-03-15
+
+### Added
+
+- Added a full Phase 3 structured-memory spine for canonical claims, including support accumulation, explicit `current_state` and `prior_state` anchors, and explicit committed `state_transition` anchors for replacement/migration changes.
+- Added bounded and then broader structured retrieval support over the new state fields, including direct structured lookup, subject-key recovery from weak footholds, hybrid candidate assembly, and structure-aware embedding composition so canonical anchors can win semantically as well as lexically.
+- Added pre-rebuild alignment work for consolidation, maintenance, conflicts, and runtime prompt guidance so rebuild-time operation follows the new canonical brain model instead of the legacy blob-brain assumptions.
+
+### Fixed
+
+- Fixed live recall crash behavior around retired related-entry hydration by making relation-neighbor expansion safe in the presence of retired superseded source rows, then removed active-to-retired `relations.supersedes` residue as a write-time invariant rather than leaving retrieval to tolerate it forever.
+- Fixed consolidation and maintenance behavior to preserve Phase 3 canonical invariants: same-identity structured claims now reinforce deterministically instead of synthesizing blob merges, current/prior/transition anchors remain distinct, canonical structured claims are protected from generic retirement/reflection demotion, and superseded cleanup distinguishes true supersession from expiry residue.
+- Fixed prompt/runtime alignment so extraction, dedup, consolidation, reflection, and rebuild-oriented prompt paths now encode the new structured-claim, role-aware, rebuild-required model instead of lagging behind older assumptions.
+
+## [0.9.94] - 2026-03-14
+
+### Added
+
+- Added a Phase 2 query-normalization and retrieval-mode layer that interprets raw recall phrasing together with explicit `agenr_recall` parameters, making current-state, historical, decision, preference/policy/workflow, change/transition, and abstain-or-narrow routing explicit and traceable.
+- Added noisy conversational/currentness/transition/param-interaction eval coverage plus surfaced-set diagnostics that measure what users actually see, including output-alignment reasons and bounded transition/currentness support shaping.
+
+### Fixed
+
+- Fixed recall precision and surface behavior across the full Phase 1/Phase 2 brain-quality tranche: adjacent-wrong suppression, lexical candidate survival, generic lookup query-shape handling, selected-support-only surfacing, abstain-or-narrow trust behavior, historical clear-winner qualification, and currentness/transition before-after pair handling.
+- Fixed explicit migration/replacement transition queries in both isolated eval and realistic snapshot/live-brain paths so prior-state rows remain available for bounded before/after answers without reopening broad stale-history retrieval.
+
 ## [0.9.93] - 2026-03-13
 
 ### Added

package/dist/{chunk-LQRZWCMN.js → chunk-3SQJQUIE.js}

@@ -1,12 +1,16 @@
 import {
   CREATE_IDX_ENTRIES_EMBEDDING_SQL,
   KNOWLEDGE_TYPES,
+  STATE_ANCHOR_PREDICATE,
+  STATE_TRANSITION_PREDICATE,
   buildProjectFilter,
+  buildStructuredClaimIdentity,
+  classifyStructuredConflictPair,
   coerceExpiry,
   composeEmbeddingText,
   createLogger,
-  createRelation,
   deleteCoRecallEdgesForEntryIds,
+  deleteSupersedesRelationsToInactiveTargets,
   embed,
   getClusterSummary,
   hashEntrySourceContent,
@@ -17,13 +21,15 @@ import {
   normalizeExpiry,
   normalizePositiveInt,
   recency,
+  recordEntrySupport,
   resolveConflictLog,
   resolveHigherExpiry,
   resolveHighestExpiry,
   runSimpleStream,
+  structuredClaimIdentityEquals,
   toErrorMessage,
   walCheckpoint
-} from "./chunk-JTQXI332.js";
+} from "./chunk-VW6ZN3RY.js";
 import {
   MILLISECONDS_PER_DAY,
   parseDaysBetween,
@@ -76,6 +82,83 @@ async function rebuildVectorIndex(db, options) {
   return { embeddingCount, durationMs };
 }
 
+// src/consolidate/structured.ts
+function normalizeSubject(value) {
+  return value.trim().toLowerCase();
+}
+function toIdentityEntry(entry) {
+  return {
+    type: entry.type,
+    subject: entry.subject,
+    content: entry.content,
+    importance: entry.importance ?? 5,
+    expiry: entry.expiry,
+    tags: entry.tags ?? [],
+    source: {
+      file: entry.sourceFile ?? "agenr",
+      context: entry.sourceContext ?? "consolidate"
+    },
+    ...entry.subjectEntity ? { subjectEntity: entry.subjectEntity } : {},
+    ...entry.subjectAttribute ? { subjectAttribute: entry.subjectAttribute } : {},
+    ...entry.subjectKey ? { subjectKey: entry.subjectKey } : {},
+    ...entry.claimPredicate ? { claimPredicate: entry.claimPredicate } : {},
+    ...entry.claimObject ? { claimObject: entry.claimObject } : {},
+    ...entry.claimRole ? { claimRole: entry.claimRole } : {},
+    ...typeof entry.claimConfidence === "number" ? { claimConfidence: entry.claimConfidence } : {}
+  };
+}
+function isProtectedStructuredIdentity(identity) {
+  return identity.predicate === STATE_ANCHOR_PREDICATE || identity.predicate === STATE_TRANSITION_PREDICATE;
+}
+function sharesStructuredSpine(left, right, leftIdentity) {
+  return normalizeSubject(left.subject) === normalizeSubject(right.subject) || Boolean(leftIdentity.subjectKey) && leftIdentity.subjectKey === (right.subjectKey?.trim().toLowerCase() ?? "");
+}
+function getStructuredConsolidationIdentity(entry) {
+  return buildStructuredClaimIdentity(toIdentityEntry(entry));
+}
+function classifyStructuredConsolidationPair(left, right) {
+  const leftIdentity = getStructuredConsolidationIdentity(left);
+  const rightIdentity = getStructuredConsolidationIdentity(right);
+  if (!leftIdentity && !rightIdentity) {
+    return "generic";
+  }
+  if (leftIdentity && rightIdentity) {
+    if (structuredClaimIdentityEquals(leftIdentity, rightIdentity)) {
+      return "same_claim";
+    }
+    return "keep_distinct";
+  }
+  const structuredIdentity = leftIdentity ?? rightIdentity;
+  const structuredEntry = leftIdentity ? left : right;
+  const genericEntry = leftIdentity ? right : left;
+  if (!structuredIdentity) {
+    return "generic";
+  }
+  if (isProtectedStructuredIdentity(structuredIdentity) && sharesStructuredSpine(structuredEntry, genericEntry, structuredIdentity)) {
+    return "keep_distinct";
+  }
+  if (structuredEntry.type === "decision" && sharesStructuredSpine(structuredEntry, genericEntry, structuredIdentity)) {
+    return "keep_distinct";
+  }
+  return "generic";
+}
+function clusterStructuredIdentity(entries) {
+  if (entries.length === 0) {
+    return null;
+  }
+  const firstIdentity = getStructuredConsolidationIdentity(entries[0]);
+  if (!firstIdentity) {
+    return null;
+  }
+  for (let index = 1; index < entries.length; index += 1) {
+    const nextIdentity = getStructuredConsolidationIdentity(entries[index]);
+    if (!nextIdentity || !structuredClaimIdentityEquals(firstIdentity, nextIdentity)) {
+      return null;
+    }
+  }
+  return firstIdentity;
+}
+
 // src/consolidate/util.ts
 var UnionFind = class {
   parent = /* @__PURE__ */ new Map();
@@ -186,7 +269,7 @@ function toProjectValue(value) {
   const s = toStringValue(value).trim();
   return s ? s.toLowerCase() : null;
 }
-function normalizeSubject(value) {
+function normalizeSubject2(value) {
   return value.trim().toLowerCase();
 }
 function collapsePreview(text, maxLength = 80) {
@@ -414,6 +497,16 @@ async function mergeNearExactDuplicates(db, options) {
       expiry,
       importance,
       embedding,
+      content_hash,
+      source_file,
+      source_context,
+      subject_entity,
+      subject_attribute,
+      subject_key,
+      claim_predicate,
+      claim_object,
+      claim_role,
+      claim_confidence,
       confirmations,
       COALESCE(re_counts.recall_count, 0) AS recall_count,
       entries.created_at
@@ -440,6 +533,16 @@ async function mergeNearExactDuplicates(db, options) {
     expiry: coerceExpiry(row.expiry),
     importance: Number.isFinite(toNumber(row.importance)) ? toNumber(row.importance) : 5,
     embedding: mapBufferToVector(row.embedding),
+    contentHash: toStringValue(row.content_hash) || void 0,
+    sourceFile: toStringValue(row.source_file) || void 0,
+    sourceContext: toStringValue(row.source_context) || void 0,
+    subjectEntity: toStringValue(row.subject_entity).trim() || void 0,
+    subjectAttribute: toStringValue(row.subject_attribute).trim() || void 0,
+    subjectKey: toStringValue(row.subject_key).trim() || void 0,
+    claimPredicate: toStringValue(row.claim_predicate).trim() || void 0,
+    claimObject: toStringValue(row.claim_object).trim() || void 0,
+    claimRole: toStringValue(row.claim_role).trim() === "current_state" || toStringValue(row.claim_role).trim() === "prior_state" ? toStringValue(row.claim_role).trim() : void 0,
+    claimConfidence: Number.isFinite(toNumber(row.claim_confidence)) ? toNumber(row.claim_confidence) : void 0,
     confirmations: Number.isFinite(toNumber(row.confirmations)) ? toNumber(row.confirmations) : 0,
     recallCount: Number.isFinite(toNumber(row.recall_count)) ? toNumber(row.recall_count) : 0,
     createdAt: toStringValue(row.created_at)
@@ -464,6 +567,14 @@ async function mergeNearExactDuplicates(db, options) {
     for (let j = i + 1; j < entries.length; j += 1) {
       const candidate = entries[j];
       checkedPairs += 1;
+      const structuredDecision = classifyStructuredConsolidationPair(entry, candidate);
+      if (structuredDecision === "keep_distinct") {
+        continue;
+      }
+      if (structuredDecision === "same_claim") {
+        unionFind.union(entry.id, candidate.id);
+        continue;
+      }
       const similarity = cosineSim(entry.embedding, candidate.embedding);
       if (similarity <= MERGE_SIMILARITY_THRESHOLD) {
         continue;
@@ -471,7 +582,7 @@ async function mergeNearExactDuplicates(db, options) {
       if (entry.type !== candidate.type) {
         continue;
       }
-      if (normalizeSubject(entry.subject) !== normalizeSubject(candidate.subject)) {
+      if (normalizeSubject2(entry.subject) !== normalizeSubject2(candidate.subject)) {
         continue;
       }
       if ((entry.project ?? null) !== (candidate.project ?? null)) {
@@ -512,6 +623,7 @@ async function mergeNearExactDuplicates(db, options) {
     if (!keeper) {
       continue;
     }
+    const keeperIdentity = getStructuredConsolidationIdentity(keeper);
     const sources = sorted.slice(1);
     mergedCount += sources.length;
     if (options.verbose) {
@@ -552,7 +664,17 @@ async function mergeNearExactDuplicates(db, options) {
         sql: "UPDATE entries SET superseded_by = ? WHERE id = ?",
         args: [keeper.id, source.id]
       });
-      await createRelation(db, keeper.id, source.id, "supersedes");
+      const sourceIdentity = getStructuredConsolidationIdentity(source);
+      if (keeperIdentity && sourceIdentity && keeperIdentity.type === sourceIdentity.type && keeperIdentity.subjectKey === sourceIdentity.subjectKey && keeperIdentity.predicate === sourceIdentity.predicate && keeperIdentity.object === sourceIdentity.object && keeperIdentity.role === sourceIdentity.role && source.contentHash) {
+        await recordEntrySupport(db, {
+          entryId: keeper.id,
+          sourceContentHash: source.contentHash,
+          sourceFile: source.sourceFile,
+          sourceContext: source.sourceContext,
+          sourceCreatedAt: source.createdAt,
+          claimConfidence: source.claimConfidence
+        });
+      }
       await db.execute({
         sql: `
           INSERT OR IGNORE INTO tags (entry_id, tag)
@@ -590,8 +712,10 @@ async function mergeNearExactDuplicates(db, options) {
 }
 async function cleanOrphanedRelations(db, dryRun) {
   const orphanedCount = await countOrphanedRelations(db);
-  if (dryRun || orphanedCount === 0) {
-    return orphanedCount;
+  const supersedesResidueCount = await countInactiveSupersedesRelations(db);
+  const total = orphanedCount + supersedesResidueCount;
+  if (dryRun || total === 0) {
+    return total;
   }
   await db.execute({
     sql: `
@@ -604,7 +728,26 @@ async function cleanOrphanedRelations(db, dryRun) {
     `,
     args: []
   });
-  return orphanedCount;
+  await deleteSupersedesRelationsToInactiveTargets(db);
+  return total;
+}
+async function countInactiveSupersedesRelations(db) {
+  const result = await db.execute({
+    sql: `
+      SELECT COUNT(*) AS count
+      FROM relations
+      WHERE relation_type = 'supersedes'
+        AND target_id IN (
+          SELECT id
+          FROM entries
+          WHERE superseded_by IS NOT NULL
+             OR retired = 1
+        )
+    `,
+    args: []
+  });
+  const count = toNumber(result.rows[0]?.count);
+  return Number.isFinite(count) ? count : 0;
 }
 async function ensureExpiredSentinel(db) {
   await db.execute({
@@ -787,17 +930,41 @@ var LLM_DEDUP_BATCH_TOOL = {
   description: "Return dedup results for all pairs",
   parameters: LLM_DEDUP_BATCH_TOOL_SCHEMA
 };
+function formatEntry(label, entry) {
+  const lines = [`${label}:`, `  Content: ${entry.content}`];
+  if (entry.type?.trim()) {
+    lines.push(`  Type: ${entry.type}`);
+  }
+  if (entry.subject?.trim()) {
+    lines.push(`  Subject: ${entry.subject}`);
+  }
+  if (entry.subjectKey?.trim()) {
+    lines.push(`  Subject key: ${entry.subjectKey}`);
+  }
+  if (entry.claimPredicate?.trim()) {
+    lines.push(`  Claim predicate: ${entry.claimPredicate}`);
+  }
+  if (entry.claimObject?.trim()) {
+    lines.push(`  Claim object: ${entry.claimObject}`);
+  }
+  if (entry.claimRole?.trim()) {
+    lines.push(`  Claim role: ${entry.claimRole}`);
+  }
+  return lines.join("\n");
+}
 function buildLlmDedupBatchContext(pairs) {
   const systemPrompt = [
     "You are a deduplication assistant for knowledge entries.",
     "For each numbered pair, decide if they express the same knowledge.",
+    "Same structured identity or same durable claim in different wording means same=true.",
+    "Different claim roles, different transition directions, or different durable values mean same=false even when the topic is shared.",
     "Call batch_dedup_check once with your results."
   ].join("\n");
   const pairBlocks = pairs.map(
     (pair, index) => [
       `Pair ${index + 1}:`,
-      `  Entry A: ${pair.entry.content}`,
-      `  Entry B: ${pair.candidate.content}`
+      formatEntry("Entry A", pair.entry),
+      formatEntry("Entry B", pair.candidate)
     ].join("\n")
   ).join("\n\n");
   return {
@@ -824,7 +991,7 @@ var DEFAULT_NEIGHBOR_LIMIT = 20;
 var MAX_ACTIVE_EMBEDDED_ENTRIES2 = 2e4;
 var LLM_DEDUP_BATCH_SIZE = 10;
 var LLM_DEDUP_CONCURRENCY = 5;
-function normalizeSubject2(value) {
+function normalizeSubject3(value) {
   return value.trim().toLowerCase();
 }
 function pairKey(a, b) {
@@ -925,6 +1092,16 @@ function mapActiveEmbeddedEntry(row) {
     expiry: coerceExpiry(row.expiry),
     importance: Number.isFinite(toNumber(row.importance)) ? toNumber(row.importance) : 5,
     embedding,
+    contentHash: toStringValue(row.content_hash) || void 0,
+    sourceFile: toStringValue(row.source_file) || void 0,
+    sourceContext: toStringValue(row.source_context) || void 0,
+    subjectEntity: toStringValue(row.subject_entity).trim() || void 0,
+    subjectAttribute: toStringValue(row.subject_attribute).trim() || void 0,
+    subjectKey: toStringValue(row.subject_key).trim() || void 0,
+    claimPredicate: toStringValue(row.claim_predicate).trim() || void 0,
+    claimObject: toStringValue(row.claim_object).trim() || void 0,
+    claimRole: toStringValue(row.claim_role).trim() === "current_state" || toStringValue(row.claim_role).trim() === "prior_state" ? toStringValue(row.claim_role).trim() : void 0,
+    claimConfidence: Number.isFinite(toNumber(row.claim_confidence)) ? toNumber(row.claim_confidence) : void 0,
     confirmations: Number.isFinite(toNumber(row.confirmations)) ? toNumber(row.confirmations) : 0,
     recallCount: Number.isFinite(toNumber(row.recall_count)) ? toNumber(row.recall_count) : 0,
     createdAt: toStringValue(row.created_at),
@@ -974,6 +1151,16 @@ async function buildClusters(db, options = {}) {
       e.expiry,
       e.importance,
       e.embedding,
+      e.content_hash,
+      e.source_file,
+      e.source_context,
+      e.subject_entity,
+      e.subject_attribute,
+      e.subject_key,
+      e.claim_predicate,
+      e.claim_object,
+      e.claim_role,
+      e.claim_confidence,
       e.confirmations,
       COALESCE(re_counts.recall_count, 0) AS recall_count,
       e.created_at,
@@ -1022,10 +1209,18 @@ async function buildClusters(db, options = {}) {
     const entry = candidates[i];
     for (let j = i + 1; j < candidates.length; j += 1) {
       const candidate = candidates[j];
+      const structuredDecision = classifyStructuredConsolidationPair(entry, candidate);
+      if (structuredDecision === "keep_distinct") {
+        continue;
+      }
+      if (structuredDecision === "same_claim") {
+        unionFind.union(entry.id, candidate.id);
+        continue;
+      }
       const similarity = cosineSim(entry.embedding, candidate.embedding);
       const key = pairKey(entry.id, candidate.id);
       const sameType = entry.type === candidate.type;
-      const sameSubject = normalizeSubject2(entry.subject) === normalizeSubject2(candidate.subject);
+      const sameSubject = normalizeSubject3(entry.subject) === normalizeSubject3(candidate.subject);
       if (sameType && similarity >= simThreshold || sameSubject && similarity >= CROSS_TYPE_SUBJECT_THRESHOLD) {
         unionFind.union(entry.id, candidate.id);
         continue;
@@ -1099,6 +1294,10 @@ async function buildClusters(db, options = {}) {
     if (group.length < minCluster) {
       continue;
     }
+    if (clusterStructuredIdentity(group)) {
+      clusters.push({ entries: group });
+      continue;
+    }
     let usedLooseUnion = false;
     for (let i = 0; i < group.length && !usedLooseUnion; i += 1) {
       for (let j = i + 1; j < group.length; j += 1) {
@@ -1184,7 +1383,12 @@ function formatClusterEntries(cluster, contentLimit) {
       `- confirmations: ${entry.confirmations}`,
       `- created_at: ${entry.createdAt}`,
       `- content: ${content}`,
-      `- tags: ${(entry.tags ?? []).join(", ") || "(none)"}`
+      `- tags: ${(entry.tags ?? []).join(", ") || "(none)"}`,
+      ...entry.subjectKey ? [`- subject_key: ${entry.subjectKey}`] : [],
+      ...entry.claimPredicate ? [`- claim_predicate: ${entry.claimPredicate}`] : [],
+      ...entry.claimObject ? [`- claim_object: ${entry.claimObject}`] : [],
+      ...entry.claimRole ? [`- claim_role: ${entry.claimRole}`] : [],
+      ...typeof entry.claimConfidence === "number" && Number.isFinite(entry.claimConfidence) ? [`- claim_confidence: ${entry.claimConfidence.toFixed(3)}`] : []
     ].join("\n");
   }).join("\n\n");
 }
@@ -1193,11 +1397,13 @@ function buildMergeContext(cluster) {
     "You are a knowledge consolidation engine.",
     "Merge the provided related entries into one or more canonical entries.",
     "Only include information explicitly stated in the source entries. Do not infer or add details not present.",
-    "Prefer preserving temporal changes in the merged narrative.",
+    "Do not turn distinct structured identities, role distinctions, or changed durable values into one blended blob summary.",
+    "current_state, prior_state, and state_transition anchors must remain distinct. Split them into separate outputs when needed.",
+    "If entries share one underlying claim, keep the merged output narrow and canonical rather than writing a broad synthesis narrative.",
     "The merged entry's importance must not exceed the highest importance of its source entries. Merging entries does not make them more important - it makes them more concise. Do not inflate importance.",
     "Each merged entry's content must be under 600 characters.",
     "If the source entries cover distinct sub-topics that cannot be combined under 600 characters, call merge_entries multiple times - once for each focused sub-topic entry.",
-    "Prefer splitting into focused entries over producing one large combined entry.",
+    "Prefer splitting into focused entries over producing one large combined entry, especially when state roles or values differ.",
     "Call merge_entries once per final merged entry.",
     'expiry must be exactly the string "permanent" or "temporary" -- never a date, timestamp, or other value.'
   ].join("\n");
@@ -1397,6 +1603,143 @@ function chooseDominantType(cluster) {
   });
   return sorted[0]?.[0] ?? "fact";
 }
+function compareKeeperPriority(a, b) {
+  const scoreA = a.confirmations + a.recallCount;
+  const scoreB = b.confirmations + b.recallCount;
+  if (scoreB !== scoreA) {
+    return scoreB - scoreA;
+  }
+  const createdA = Date.parse(a.createdAt);
+  const createdB = Date.parse(b.createdAt);
+  const safeA = Number.isFinite(createdA) ? createdA : 0;
+  const safeB = Number.isFinite(createdB) ? createdB : 0;
+  return safeB - safeA;
+}
+async function reinforceStructuredCluster(db, cluster, options = {}) {
+  const sourceIds = cluster.entries.map((entry) => entry.id);
+  if (options.dryRun) {
+    const keeper2 = [...cluster.entries].sort(compareKeeperPriority)[0];
+    return {
+      mergedEntryId: keeper2?.id ?? "DRY_RUN",
+      sourceIds,
+      flagged: false
+    };
+  }
+  const sorted = [...cluster.entries].sort(compareKeeperPriority);
+  const keeper = sorted[0];
+  if (!keeper) {
+    throw new Error("[consolidate] Missing keeper for structured reinforcement cluster");
+  }
+  const sources = sorted.slice(1);
+  const totalConfirmations = sorted.reduce((sum, entry) => sum + entry.confirmations, 0);
+  const maxImportance = sorted.reduce((max, entry) => Math.max(max, entry.importance ?? 5), 0);
+  const highestExpiry = resolveHighestExpiry(sorted.map((entry) => entry.expiry));
+  const oldestCreatedAt = sorted.map((entry) => entry.createdAt).filter((date) => Boolean(date) && date.length > 0).sort()[0];
+  const retiredAt = (/* @__PURE__ */ new Date()).toISOString();
+  await db.execute("BEGIN IMMEDIATE");
+  try {
+    for (const source of sources) {
+      await db.execute({
+        sql: `
+          INSERT INTO entry_sources (
+            merged_entry_id,
+            source_entry_id,
+            original_confirmations,
+            original_recall_count,
+            original_created_at
+          )
+          VALUES (?, ?, ?, ?, ?)
+        `,
+        args: [keeper.id, source.id, source.confirmations, source.recallCount, source.createdAt]
+      });
+      await db.execute({
+        sql: `
+          UPDATE entries
+          SET superseded_by = ?,
+              retired = 1,
+              retired_at = ?,
+              retired_reason = ?
+          WHERE id = ?
+            AND retired = 0
+        `,
+        args: [keeper.id, retiredAt, "superseded", source.id]
+      });
+      await db.execute({
+        sql: `
+          UPDATE entries
+          SET superseded_by = ?
+          WHERE id = ?
+            AND retired = 1
+            AND superseded_by IS NULL
+        `,
+        args: [keeper.id, source.id]
+      });
+      await db.execute({
+        sql: "UPDATE recall_events SET entry_id = ? WHERE entry_id = ?",
+        args: [keeper.id, source.id]
+      });
+      await db.execute({
+        sql: `
+          INSERT OR IGNORE INTO tags (entry_id, tag)
+          SELECT ?, tag
+          FROM tags
+          WHERE entry_id = ?
+        `,
+        args: [keeper.id, source.id]
+      });
+      if (source.contentHash) {
+        await recordEntrySupport(db, {
+          entryId: keeper.id,
+          sourceContentHash: source.contentHash,
+          sourceFile: source.sourceFile,
+          sourceContext: source.sourceContext,
+          sourceCreatedAt: source.createdAt,
+          claimConfidence: source.claimConfidence
+        });
+      }
+    }
+    await deleteCoRecallEdgesForEntryIds(db, sources.map((source) => source.id));
+    await db.execute({
+      sql: `
+        UPDATE entries
+        SET merged_from = COALESCE(merged_from, 0) + ?,
+            consolidated_at = datetime('now'),
+            confirmations = ?,
+            expiry = ?,
+            importance = CASE WHEN importance < ? THEN ? ELSE importance END,
+            created_at = CASE WHEN created_at > ? THEN ? ELSE created_at END
+        WHERE id = ?
+      `,
+      args: [
+        sources.length,
+        totalConfirmations,
+        highestExpiry,
+        maxImportance,
+        maxImportance,
+        oldestCreatedAt ?? keeper.createdAt,
+        oldestCreatedAt ?? keeper.createdAt,
+        keeper.id
+      ]
+    });
+    await db.execute("COMMIT");
+  } catch (error) {
+    try {
+      await db.execute("ROLLBACK");
+    } catch {
+    }
+    throw error;
+  }
+  if (options.verbose) {
+    (options.onLog ?? (() => void 0))(
+      `[merge] reinforced=${keeper.id} sources=${sources.map((source) => source.id).join(",")}`
+    );
+  }
+  return {
+    mergedEntryId: keeper.id,
+    sourceIds,
+    flagged: false
+  };
+}
 async function mergeCluster(db, cluster, llmClient, apiKey, options = {}) {
   const sourceIds = cluster.entries.map((entry) => entry.id);
   const onLog = options.onLog ?? (() => void 0);
@@ -1421,6 +1764,9 @@ async function mergeCluster(db, cluster, llmClient, apiKey, options = {}) {
   onLog(
     `[merge-llm] Merging cluster of ${cluster.entries.length} entries (subject: "${subjectPreview || "unknown"}")`
   );
+  if (clusterStructuredIdentity(cluster.entries)) {
+    return reinforceStructuredCluster(db, cluster, options);
+  }
   const sourceContents = cluster.entries.map((entry) => entry.content);
   const queueFlaggedMerge = async (result, reason) => {
     if (options.dryRun) {
@@ -1615,7 +1961,6 @@ async function mergeCluster(db, cluster, llmClient, apiKey, options = {}) {
           `,
           args: [mergedEntryId, source.id, source.confirmations, originalRecallCount, source.createdAt]
         });
-        await createRelation(db, mergedEntryId, source.id, "supersedes");
       }
     }
     for (const source of cluster.entries) {
@@ -2908,13 +3253,21 @@ function toConflictLogRow(row) {
 }
 function toConflictEntry(row) {
   const importance = toNumber(row.importance);
+  const claimConfidence = toNumber(row.claim_confidence);
+  const claimRole = toStringValue(row.claim_role);
   return {
     id: toStringValue(row.id),
     type: toStringValue(row.type),
     subject: toStringValue(row.subject),
     content: toStringValue(row.content),
     importance: Number.isFinite(importance) ? importance : 0,
+    subjectEntity: toStringValue(row.subject_entity) || null,
+    subjectAttribute: toStringValue(row.subject_attribute) || null,
     subjectKey: toStringValue(row.subject_key) || null,
+    claimPredicate: toStringValue(row.claim_predicate) || null,
+    claimObject: toStringValue(row.claim_object) || null,
+    claimRole: claimRole === "current_state" || claimRole === "prior_state" ? claimRole : null,
+    claimConfidence: Number.isFinite(claimConfidence) ? claimConfidence : null,
     createdAt: toStringValue(row.created_at)
   };
 }
@@ -2929,7 +3282,20 @@ async function getEntriesByIds(db, entryIds) {
     const placeholders = chunk.map(() => "?").join(", ");
     const rows = await db.execute({
       sql: `
-        SELECT id, type, subject, content, importance, subject_key, created_at
+        SELECT
+          id,
+          type,
+          subject,
+          content,
+          importance,
+          subject_entity,
+          subject_attribute,
+          subject_key,
+          claim_predicate,
+          claim_object,
+          claim_role,
+          claim_confidence,
+          created_at
         FROM entries
         WHERE id IN (${placeholders})
       `,
@@ -3016,7 +3382,7 @@ async function getPendingConflictsWithEntries(db, options) {
 async function resolveConflict(opts) {
   const { db, conflictId, resolution } = opts;
   const resolvedBy = opts.resolvedBy ?? "user";
-  const reasoning = opts.reasoning ?? null;
+  let reasoning = opts.reasoning ?? null;
   log2.info(`Resolving conflict ${conflictId} as ${resolution} by ${resolvedBy}`);
   try {
     const conflictRow = await getConflictRowById(db, conflictId);
@@ -3034,10 +3400,20 @@ async function resolveConflict(opts) {
     log2.info(
       `Conflict: ${conflict.relation} between "${conflict.entryA.subject}" and "${conflict.entryB.subject}" (confidence: ${conflict.confidence})`
     );
+    const structuredGuard = classifyStructuredConflictPair(
+      conflict.entryA,
+      conflict.entryB
+    );
+    const effectiveResolution = structuredGuard.decision === "keep_both" && (resolution === "keep-new" || resolution === "keep-old") ? "keep-both" : resolution;
+    if (effectiveResolution !== resolution) {
+      const guardReason = `Protected canonical structured pair: ${structuredGuard.reason}.`;
+      reasoning = reasoning ? `${reasoning} ${guardReason}` : guardReason;
+      log2.info(`Conflict ${conflictId}: overriding ${resolution} to keep-both (${structuredGuard.reason})`);
+    }
     let retiredEntryId = null;
-    if (resolution === "keep-new") {
+    if (effectiveResolution === "keep-new") {
       retiredEntryId = conflictRow.existingEntryId;
-    } else if (resolution === "keep-old") {
+    } else if (effectiveResolution === "keep-old") {
       retiredEntryId = conflictRow.newEntryId;
     }
     const transaction = await db.transaction("write");
@@ -3062,7 +3438,7 @@ async function resolveConflict(opts) {
           args: [retiredEntryId]
         });
       }
-      await resolveConflictLog(transaction, conflictId, resolution, { reasoning, resolvedBy });
+      await resolveConflictLog(transaction, conflictId, effectiveResolution, { reasoning, resolvedBy });
       await transaction.commit();
     } catch (error) {
       try {
@@ -3072,11 +3448,11 @@ async function resolveConflict(opts) {
       throw error;
     }
     log2.info(
-      `Resolved: ${resolution}, retired entry: ${retiredEntryId ?? "none"}, reasoning length: ${reasoning?.length ?? 0}`
+      `Resolved: ${effectiveResolution}, retired entry: ${retiredEntryId ?? "none"}, reasoning length: ${reasoning?.length ?? 0}`
     );
     return {
       conflictId,
-      resolution,
+      resolution: effectiveResolution,
       resolvedBy,
       reasoning,
       retiredEntryId