agenr 1.6.0 → 1.7.0

package/CHANGELOG.md

@@ -1,5 +1,50 @@
 # Changelog
 
+## [1.7.0] - 2026-04-04
+
+Claim-key quality foundations, recall integration, auto-supersession, surgeon quality passes, and OpenClaw plugin publishing polish.
+
+### Added
+
+- **Claim-key Phase 2a foundation.** Shared normalization/validation pipeline for claim keys, stronger post-extraction validation, and explicit claim-key preservation work for re-ingest flows.
+- **Claim-key Phase 2b extraction quality.** Improved extraction quality with better prompting/hints and related quality tuning for missing-key backfill.
+- **Claim-key Phase 2c recall integration.** Recall lineage expansion now uses claim keys as a structural signal.
+- **Claim-key Phase 2d store-time auto-supersession.** New entries can auto-link to prior siblings on the same claim key under safety gates.
+- **Claim-key Phase 2e surgeon quality pass.** New surgeon claim-key quality pass with missing-key backfill, supported promotion lanes, compaction, grounded-family promotion, stable-slot promotion refinement, and entity-family convergence scaffolding.
+- **Shadow-mode sibling-slot-resonance instrumentation.** Deterministic diagnostic instrumentation for threshold-only supported cohorts, persisted in surgeon run details and summaries without changing live auto-apply behavior.
+
+### Changed
+
+- **Claim-key quality promotion policy.** Rebalanced supported promotion, compact canonicalization, grounded backfill behavior, and grounded-family/stable-slot promotion rules to surface stronger candidates while preserving unresolved boundaries.
+- **Surgeon progress/liveness reporting.** Improved preview concurrency and progress reporting during claim-key-quality runs.
+- **Planning and review docs.** Added and updated internal plan/review docs covering claim-key quality sequencing, grounded-family promotion analysis, threshold-only cohort audit, and shadow-mode follow-up.
+
+### Validation
+
+Changes since last push to `origin/master`:
+
+- feat: add historical-state recall routing
+- Add unified recall path to recall eval seam
+- feat: make historical recall lineage-aware
+- fix: phase 2a claim key foundation
+- feat: improve claim-key extraction quality
+- fix: tighten agenr_store durable memory guidance
+- feat: use claim keys in recall lineage expansion
+- feat: add store-time claim-key auto-supersession
+- feat: add surgeon claim-key quality pass
+- Improve surgeon liveness progress reporting
+- Improve claim-key-quality preview concurrency
+- fix: tune claim-key-quality missing-key backfill
+- fix: improve grounded claim-key backfill quality
+- fix: promote supported claim-key proposals
+- fix: compact canonical claim-key candidates
+- fix: rebalance post-compaction claim-key promotion
+- feat: add claim-key entity family convergence
+- fix: promote grounded family missing-key candidates
+- docs: add threshold-only supported cohort audit
+- feat: add shadow sibling-slot resonance instrumentation
+- Align surgeon presets with claim-key quality plan
+
 ## [1.6.0] - 2026-04-02
 
 Store nudge, memory guidance improvements, plugin rename, and dead code cleanup.

package/dist/{chunk-6SJBRIGC.js → chunk-IMQOPTQX.js}

@@ -1,7 +1,7 @@
 import {
   buildLexicalPlan,
   cosineSimilarity
-} from "./chunk-EUPZHNOY.js";
+} from "./chunk-RRLX4WCN.js";
 
 // src/adapters/db/client.ts
 import fs from "fs/promises";
@@ -905,7 +905,26 @@ async function getDistinctClaimKeyPrefixes(executor) {
     return typeof prefix === "string" && prefix.length > 0 ? [prefix] : [];
   });
 }
-async function updateEntry(executor, id, fields) {
+async function getClaimKeyExamples(executor, limit = 8) {
+  const normalizedLimit = Number.isFinite(limit) ? Math.max(1, Math.floor(limit)) : 8;
+  const result = await executor.execute({
+    sql: `
+      SELECT claim_key
+      FROM entries
+      WHERE claim_key IS NOT NULL
+        AND ${ACTIVE_ENTRY_CLAUSE}
+      GROUP BY claim_key
+      ORDER BY COUNT(*) DESC, MAX(importance) DESC, MAX(created_at) DESC, claim_key ASC
+      LIMIT ?
+    `,
+    args: [normalizedLimit]
+  });
+  return result.rows.flatMap((row) => {
+    const claimKey = row.claim_key;
+    return typeof claimKey === "string" && claimKey.length > 0 ? [claimKey] : [];
+  });
+}
+async function updateEntry(executor, id, fields, options) {
   const assignments = [];
   const args = [];
   if (fields.importance !== void 0) {
@@ -939,7 +958,7 @@ async function updateEntry(executor, id, fields) {
       UPDATE entries
       SET ${assignments.join(", ")}
       WHERE id = ?
-        AND ${ACTIVE_ENTRY_CLAUSE}
+        AND ${options?.includeInactive === true ? "1 = 1" : ACTIVE_ENTRY_CLAUSE}
     `,
     args
   });
@@ -1041,7 +1060,7 @@ function normalizeInteger(value, fallback) {
 }
 
 // src/adapters/db/schema.ts
-var SCHEMA_VERSION = "6";
+var SCHEMA_VERSION = "7";
 var VECTOR_INDEX_NAME = "idx_entries_embedding";
 var EPISODE_VECTOR_INDEX_NAME = "idx_episodes_embedding";
 var BULK_WRITE_STATE_META_KEY = "bulk_write_state";
@@ -1190,6 +1209,7 @@ var CREATE_SURGEON_RUN_ACTIONS_TABLE_SQL = `
     entry_ids TEXT NOT NULL DEFAULT '[]',
     reasoning TEXT NOT NULL DEFAULT '',
     recall_delta TEXT,
+    details_json TEXT,
     created_at TEXT NOT NULL
   )
 `;
@@ -1205,6 +1225,35 @@ var CREATE_SURGEON_RUN_ACTIONS_CREATED_AT_INDEX_SQL = `
   CREATE INDEX IF NOT EXISTS idx_surgeon_run_actions_created_at
   ON surgeon_run_actions(created_at)
 `;
+var CREATE_SURGEON_RUN_PROPOSALS_TABLE_SQL = `
+  CREATE TABLE IF NOT EXISTS surgeon_run_proposals (
+    id TEXT PRIMARY KEY,
+    run_id TEXT NOT NULL REFERENCES surgeon_runs(id),
+    group_id TEXT NOT NULL,
+    issue_kind TEXT NOT NULL,
+    scope TEXT NOT NULL,
+    entry_ids TEXT NOT NULL DEFAULT '[]',
+    current_claim_keys TEXT NOT NULL DEFAULT '[]',
+    proposed_claim_keys TEXT NOT NULL DEFAULT '[]',
+    rationale TEXT NOT NULL DEFAULT '',
+    confidence REAL NOT NULL DEFAULT 0,
+    source TEXT NOT NULL DEFAULT '',
+    eligible_for_apply INTEGER NOT NULL DEFAULT 0,
+    created_at TEXT NOT NULL
+  )
+`;
+var CREATE_SURGEON_RUN_PROPOSALS_RUN_ID_INDEX_SQL = `
+  CREATE INDEX IF NOT EXISTS idx_surgeon_run_proposals_run_id
+  ON surgeon_run_proposals(run_id)
+`;
+var CREATE_SURGEON_RUN_PROPOSALS_GROUP_ID_INDEX_SQL = `
+  CREATE INDEX IF NOT EXISTS idx_surgeon_run_proposals_group_id
+  ON surgeon_run_proposals(group_id)
+`;
+var CREATE_SURGEON_RUN_PROPOSALS_CREATED_AT_INDEX_SQL = `
+  CREATE INDEX IF NOT EXISTS idx_surgeon_run_proposals_created_at
+  ON surgeon_run_proposals(created_at)
+`;
 var CREATE_META_TABLE_SQL = `
   CREATE TABLE IF NOT EXISTS _meta (
     key TEXT PRIMARY KEY,
@@ -1323,6 +1372,10 @@ var SCHEMA_STATEMENTS = [
   CREATE_SURGEON_RUN_ACTIONS_RUN_ID_INDEX_SQL,
   CREATE_SURGEON_RUN_ACTIONS_ENTRY_ID_INDEX_SQL,
   CREATE_SURGEON_RUN_ACTIONS_CREATED_AT_INDEX_SQL,
+  CREATE_SURGEON_RUN_PROPOSALS_TABLE_SQL,
+  CREATE_SURGEON_RUN_PROPOSALS_RUN_ID_INDEX_SQL,
+  CREATE_SURGEON_RUN_PROPOSALS_GROUP_ID_INDEX_SQL,
+  CREATE_SURGEON_RUN_PROPOSALS_CREATED_AT_INDEX_SQL,
   CREATE_META_TABLE_SQL,
   CREATE_ENTRIES_CONTENT_HASH_INDEX_SQL,
   CREATE_ENTRIES_NORM_CONTENT_HASH_INDEX_SQL,
@@ -1344,10 +1397,15 @@ var SCHEMA_STATEMENTS = [
 ];
 async function initSchema(db) {
   await db.execute("PRAGMA foreign_keys = ON");
-  const currentVersion = await getSchemaVersion(db);
+  let currentVersion = await getSchemaVersion(db);
   await assertSupportedSchemaState(db, currentVersion);
   if (currentVersion === "5") {
     await migrateV5ToV6(db);
+    currentVersion = "6";
+  }
+  if (currentVersion === "6") {
+    await migrateV6ToV7(db);
+    currentVersion = "7";
   }
   const hadEntriesFts = await tableExists(db, "entries_fts");
   for (const statement of SCHEMA_STATEMENTS) {
@@ -1371,7 +1429,7 @@ async function initSchema(db) {
   await ensureVectorIndexes(db);
 }
 async function assertSupportedSchemaState(db, currentVersion) {
-  if (currentVersion && currentVersion !== "5" && currentVersion !== SCHEMA_VERSION) {
+  if (currentVersion && currentVersion !== "5" && currentVersion !== "6" && currentVersion !== SCHEMA_VERSION) {
     throw new Error(
       `Unsupported agenr database schema version "${currentVersion}". This build only supports schema version ${SCHEMA_VERSION}. Create a fresh database with \`agenr db reset\` or manually migrate the data into a new database.`
     );
@@ -1399,6 +1457,21 @@ async function migrateV5ToV6(db) {
     }
   }
 }
+async function migrateV6ToV7(db) {
+  if (await tableExists(db, "surgeon_run_actions")) {
+    try {
+      await db.execute("ALTER TABLE surgeon_run_actions ADD COLUMN details_json TEXT");
+    } catch (error) {
+      if (!(error instanceof Error && /duplicate column/i.test(error.message))) {
+        throw error;
+      }
+    }
+  }
+  await db.execute(CREATE_SURGEON_RUN_PROPOSALS_TABLE_SQL);
+  await db.execute(CREATE_SURGEON_RUN_PROPOSALS_RUN_ID_INDEX_SQL);
+  await db.execute(CREATE_SURGEON_RUN_PROPOSALS_GROUP_ID_INDEX_SQL);
+  await db.execute(CREATE_SURGEON_RUN_PROPOSALS_CREATED_AT_INDEX_SQL);
+}
 async function rebuildFts(db) {
   await db.execute("INSERT INTO entries_fts(entries_fts) VALUES ('rebuild')");
 }
@@ -1628,6 +1701,10 @@ var LibsqlDatabase = class _LibsqlDatabase {
   async getDistinctClaimKeyPrefixes() {
     return getDistinctClaimKeyPrefixes(this.executor);
   }
+  /** Lists bounded full claim-key examples ordered for extraction hinting. */
+  async getClaimKeyExamples(limit) {
+    return getClaimKeyExamples(this.executor, limit);
+  }
   /** Updates mutable entry fields such as importance, expiry, and temporal metadata. */
   async updateEntry(id, fields) {
     return updateEntry(this.executor, id, fields);
@@ -1765,8 +1842,9 @@ var DEFAULT_SURGEON_CONTEXT_LIMIT = 0;
 var DEFAULT_SURGEON_RETIREMENT_PROTECT_RECALLED_DAYS = 14;
 var DEFAULT_SURGEON_RETIREMENT_PROTECT_MIN_IMPORTANCE = 9;
 var DEFAULT_SURGEON_SKIP_RECENTLY_EVALUATED_DAYS = 7;
+var DEFAULT_CLAIM_EXTRACTION_CONCURRENCY = 10;
 var DEFAULT_CLAIM_EXTRACTION_CONFIDENCE_THRESHOLD = 0.8;
-var DEFAULT_CLAIM_EXTRACTION_ELIGIBLE_TYPES = ["fact", "preference", "decision"];
+var DEFAULT_CLAIM_EXTRACTION_ELIGIBLE_TYPES = ["fact", "preference", "decision", "lesson"];
 function isAgenrAuthMethod(value) {
   return AUTH_METHOD_SET.has(value);
 }
@@ -1809,7 +1887,8 @@ function resolveClaimExtractionConfig(config) {
   return {
     enabled: config?.claimExtraction?.enabled ?? true,
     confidenceThreshold: normalizeClaimExtractionConfidence(config?.claimExtraction?.confidenceThreshold),
-    eligibleTypes: normalizeClaimExtractionEligibleTypes(config?.claimExtraction?.eligibleTypes)
+    eligibleTypes: normalizeClaimExtractionEligibleTypes(config?.claimExtraction?.eligibleTypes),
+    concurrency: normalizeClaimExtractionConcurrency(config?.claimExtraction?.concurrency)
   };
 }
 function readConfig(options = {}) {
@@ -1905,6 +1984,13 @@ function normalizeClaimExtractionEligibleTypes(value) {
   const normalized = Array.from(new Set(value.filter((candidate) => ENTRY_TYPES.includes(candidate))));
   return normalized.length > 0 ? normalized : [...DEFAULT_CLAIM_EXTRACTION_ELIGIBLE_TYPES];
 }
+function normalizeClaimExtractionConcurrency(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return DEFAULT_CLAIM_EXTRACTION_CONCURRENCY;
+  }
+  const normalized = Math.trunc(value);
+  return normalized > 0 ? normalized : DEFAULT_CLAIM_EXTRACTION_CONCURRENCY;
+}
 
 // src/core/store/embedding-text.ts
 function composeEmbeddingText(entry) {
@@ -2121,9 +2207,14 @@ var RECALL_CANDIDATE_SELECT_COLUMNS = `
   e.importance,
   e.expiry,
   e.embedding,
+  e.superseded_by,
+  e.claim_key,
+  e.retired,
   e.created_at
 `;
 var FTS_TIERS = ["exact", "all_tokens", "any_tokens"];
+var PREDECESSOR_EXPANSION_LIMIT_PER_SEED = 8;
+var PREDECESSOR_EXPANSION_MAX_RESULTS = 40;
 function createRecallAdapter(executor, embeddingPort) {
   return new LibsqlRecallAdapter(executor, embeddingPort);
 }
@@ -2223,6 +2314,74 @@ var LibsqlRecallAdapter = class {
     }
     return Array.from(matches.values()).sort((left, right) => compareFtsCandidates(left, right)).slice(0, params.limit);
   }
+  /**
+   * Finds historical predecessors scoped to a seed set of active candidate IDs.
+   *
+   * Direct supersession links are preferred. Same-claim-key siblings are used as
+   * the structural lineage path, with retired same-subject entries preserved as
+   * a weaker fallback when explicit slot identity is unavailable.
+   */
+  async fetchPredecessors(params) {
+    const normalizedIds = normalizeStrings(params.activeEntryIds);
+    if (normalizedIds.length === 0) {
+      return [];
+    }
+    const placeholders = normalizedIds.map(() => "?").join(", ");
+    const expansionLimit = normalizePredecessorExpansionLimit(normalizedIds.length);
+    const result = await this.executor.execute({
+      sql: `
+        WITH seed AS (
+          SELECT id, subject, claim_key
+          FROM entries
+          WHERE id IN (${placeholders})
+        ),
+        seed_subjects AS (
+          SELECT DISTINCT subject
+          FROM seed
+          WHERE TRIM(subject) <> ''
+        ),
+        seed_claim_keys AS (
+          SELECT DISTINCT claim_key
+          FROM seed
+          WHERE claim_key IS NOT NULL
+        ),
+        lineage AS (
+          SELECT
+            ${RECALL_CANDIDATE_SELECT_COLUMNS},
+            CASE
+              WHEN e.superseded_by IN (SELECT id FROM seed) THEN 0
+              WHEN e.claim_key IS NOT NULL
+                AND e.claim_key IN (SELECT claim_key FROM seed_claim_keys)
+                AND (e.retired = 1 OR e.superseded_by IS NOT NULL) THEN 1
+              WHEN e.claim_key IS NOT NULL
+                AND e.claim_key IN (SELECT claim_key FROM seed_claim_keys) THEN 2
+              WHEN e.retired = 1
+                AND e.subject IN (SELECT subject FROM seed_subjects) THEN 3
+              ELSE 4
+            END AS lineage_priority
+          FROM entries AS e
+          WHERE e.id NOT IN (SELECT id FROM seed)
+            AND (
+              e.superseded_by IN (SELECT id FROM seed)
+              OR (
+                e.claim_key IS NOT NULL
+                AND e.claim_key IN (SELECT claim_key FROM seed_claim_keys)
+              )
+              OR (
+                e.retired = 1
+                AND e.subject IN (SELECT subject FROM seed_subjects)
+              )
+            )
+        )
+        SELECT *
+        FROM lineage
+        ORDER BY lineage_priority ASC, created_at ASC, id ASC
+        LIMIT ?
+      `,
+      args: [...normalizedIds, expansionLimit]
+    });
+    return result.rows.map((row) => mapRecallCandidateRow(row));
+  }
   /** Hydrates full entries for the final ranked result set. */
   async hydrateEntries(ids) {
     const normalizedIds = normalizeStrings(ids);
@@ -2235,8 +2394,7 @@ var LibsqlRecallAdapter = class {
         SELECT
           ${ENTRY_SELECT_COLUMNS}
         FROM entries AS e
-        WHERE ${buildActiveEntryClause("e")}
-          AND e.id IN (${placeholders})
+        WHERE e.id IN (${placeholders})
       `,
       args: normalizedIds
     });
@@ -2327,9 +2485,15 @@ function mapRecallCandidateRow(row) {
     importance: readNumber(row, "importance", 0),
     expiry,
     embedding: readEmbedding(row, "embedding"),
+    superseded_by: readOptionalString(row, "superseded_by"),
+    claim_key: readOptionalString(row, "claim_key"),
+    retired: readBoolean(row, "retired"),
     created_at: readRequiredString(row, "created_at")
   };
 }
+function normalizePredecessorExpansionLimit(seedCount) {
+  return Math.min(PREDECESSOR_EXPANSION_MAX_RESULTS, seedCount * PREDECESSOR_EXPANSION_LIMIT_PER_SEED);
+}
 function wrapVectorError(error) {
   const message = error instanceof Error ? error.message : String(error);
   return new Error(`Vector search is unavailable: ${message}`);
@@ -2358,6 +2522,7 @@ export {
   DEFAULT_SURGEON_RETIREMENT_PROTECT_RECALLED_DAYS,
   DEFAULT_SURGEON_RETIREMENT_PROTECT_MIN_IMPORTANCE,
   DEFAULT_SURGEON_SKIP_RECENTLY_EVALUATED_DAYS,
+  DEFAULT_CLAIM_EXTRACTION_CONCURRENCY,
   isAgenrAuthMethod,
   authMethodToProvider,
   getAuthMethodDefinition,

package/dist/{chunk-EUPZHNOY.js → chunk-RRLX4WCN.js}

@@ -370,6 +370,12 @@ function createNoopRecallTraceSink() {
 
 // src/core/recall/search.ts
 var MIN_VECTOR_ONLY_EVIDENCE = 0.3;
+var HISTORICAL_STATE_FLAT_RECENCY = 0.5;
+var HISTORICAL_PREDECESSOR_BOOST = 0.08;
+var HISTORICAL_RETIRED_PREDECESSOR_BOOST = 0.06;
+var HISTORICAL_OLDER_STATE_BOOST = 0.08;
+var HISTORICAL_TOPIC_SHARED_PREFIX_MIN = 2;
+var HISTORICAL_TOPIC_PREFIX_OF_CANDIDATE_MIN = 0.6;
 async function recall(query, ports, options = {}) {
   const text = query.text.trim();
   const limit = normalizeLimit(query.limit);
@@ -421,10 +427,26 @@ async function recall(query, ports, options = {}) {
     ]);
     const mergeStartedAt = Date.now();
     const mergedCandidates = mergeCandidates(vectorCandidates, ftsCandidates);
+    await expandHistoricalCandidates(mergedCandidates, queryEmbedding, ports, {
+      activeEntryIds: Array.from(mergedCandidates.keys()),
+      rankingProfile: query.rankingProfile
+    });
     summary.candidateCounts.merged = mergedCandidates.size;
     summary.timings.mergeCandidatesMs = elapsedMs(mergeStartedAt);
     const scoreStartedAt = Date.now();
-    const scored = Array.from(mergedCandidates.values()).map((candidate) => scoreMergedCandidate(candidate, text, queryEmbedding, aroundDate, query.aroundRadius)).sort((left, right) => right.score - left.score);
+    const scored = applyHistoricalLineageBoosts(
+      Array.from(mergedCandidates.values()).map(
+        (candidate) => scoreMergedCandidate(candidate, text, queryEmbedding, {
+          aroundDate,
+          aroundRadius: query.aroundRadius,
+          rankingProfile: query.rankingProfile
+        })
+      ),
+      {
+        aroundDate,
+        rankingProfile: query.rankingProfile
+      }
+    ).sort((left, right) => right.score - left.score);
     summary.timings.scoreCandidatesMs = elapsedMs(scoreStartedAt);
     const thresholdStartedAt = Date.now();
     const thresholded = scored.filter((result) => hasSufficientReturnEvidence(result) && result.score >= threshold);
@@ -520,10 +542,10 @@ function finishRecallTrace(summary, trace, noResultReason) {
   }
   trace.reportSummary(summary);
 }
-function scoreMergedCandidate(candidate, queryText, queryEmbedding, aroundDate, aroundRadius) {
+function scoreMergedCandidate(candidate, queryText, queryEmbedding, params) {
   const vector = candidate.vectorSim ?? cosineSimilarity(candidate.entry.embedding ?? [], queryEmbedding);
   const lexical = computeLexicalScore(queryText, candidate.entry.subject, candidate.entry.content);
-  const recency = aroundDate ? gaussianRecency(candidate.entry.created_at, aroundDate, normalizeAroundRadius(aroundRadius)) : recencyScore(candidate.entry.created_at, candidate.entry.expiry);
+  const recency = resolveRecencyScore(candidate.entry, params);
   const importance = importanceScore(candidate.entry.importance);
   const scored = scoreCandidate({
     vectorSim: vector,
@@ -537,6 +559,97 @@ function scoreMergedCandidate(candidate, queryText, queryEmbedding, aroundDate,
     scores: scored.scores
   };
 }
+async function expandHistoricalCandidates(mergedCandidates, queryEmbedding, ports, params) {
+  if (params.rankingProfile !== "historical_state" || mergedCandidates.size === 0 || !ports.fetchPredecessors) {
+    return;
+  }
+  const predecessors = await ports.fetchPredecessors({
+    activeEntryIds: params.activeEntryIds
+  });
+  for (const entry of predecessors) {
+    if (mergedCandidates.has(entry.id)) {
+      continue;
+    }
+    mergedCandidates.set(entry.id, {
+      entry,
+      vectorSim: cosineSimilarity(entry.embedding ?? [], queryEmbedding)
+    });
+  }
+}
+function resolveRecencyScore(entry, params) {
+  if (params.aroundDate) {
+    return gaussianRecency(entry.created_at, params.aroundDate, normalizeAroundRadius(params.aroundRadius));
+  }
+  if (params.rankingProfile === "historical_state") {
+    return HISTORICAL_STATE_FLAT_RECENCY;
+  }
+  return recencyScore(entry.created_at, entry.expiry);
+}
+function applyHistoricalLineageBoosts(candidates, params) {
+  if (params.rankingProfile !== "historical_state") {
+    return candidates;
+  }
+  const entries = candidates.map((candidate) => candidate.entry);
+  return candidates.map((candidate) => {
+    const bonus = resolveHistoricalLineageBonus(candidate.entry, entries, params.aroundDate);
+    if (bonus <= 0) {
+      return candidate;
+    }
+    return {
+      ...candidate,
+      score: Math.min(1, candidate.score + bonus)
+    };
+  });
+}
+function resolveHistoricalLineageBonus(entry, entries, aroundDate) {
+  if (entries.some((peer) => peer.id !== entry.id && entry.superseded_by === peer.id)) {
+    return HISTORICAL_PREDECESSOR_BOOST;
+  }
+  if (aroundDate) {
+    return 0;
+  }
+  const activePeers = entries.filter((peer) => peer.id !== entry.id && isPotentialCurrentPeer(peer) && isOlderHistoricalPeer(entry, peer));
+  if (activePeers.length === 0) {
+    return 0;
+  }
+  return entry.retired ? HISTORICAL_RETIRED_PREDECESSOR_BOOST : HISTORICAL_OLDER_STATE_BOOST;
+}
+function isPotentialCurrentPeer(entry) {
+  return !entry.retired && entry.superseded_by === void 0;
+}
+function isOlderHistoricalPeer(left, right) {
+  return createdAtMs(left.created_at) < createdAtMs(right.created_at) && sharesHistoricalLineage(left, right);
+}
+function sharesHistoricalLineage(left, right) {
+  if (left.claim_key && right.claim_key && left.claim_key === right.claim_key) {
+    return true;
+  }
+  return sharesHistoricalTopic(left, right);
+}
+function sharesHistoricalTopic(left, right) {
+  const leftTokens = tokenize(left.subject);
+  const rightTokens = tokenize(right.subject);
+  if (leftTokens.length === 0 || rightTokens.length === 0) {
+    return false;
+  }
+  const sharedPrefixCount = countSharedPrefixTokens(leftTokens, rightTokens);
+  return sharedPrefixCount >= HISTORICAL_TOPIC_SHARED_PREFIX_MIN && sharedPrefixCount / leftTokens.length >= HISTORICAL_TOPIC_PREFIX_OF_CANDIDATE_MIN;
+}
+function createdAtMs(value) {
+  const timestamp = new Date(value).getTime();
+  return Number.isFinite(timestamp) ? timestamp : 0;
+}
+function countSharedPrefixTokens(leftTokens, rightTokens) {
+  const length = Math.min(leftTokens.length, rightTokens.length);
+  let sharedPrefixCount = 0;
+  for (let index = 0; index < length; index += 1) {
+    if (leftTokens[index] !== rightTokens[index]) {
+      break;
+    }
+    sharedPrefixCount += 1;
+  }
+  return sharedPrefixCount;
+}
 function hasSufficientReturnEvidence(candidate) {
   if (candidate.scores.lexical > 0) {
     return true;