@agenr/openclaw-plugin 3.3.0 → 2026.6.3

package/dist/chunk-SOQW7356.js

@@ -0,0 +1,2416 @@
+import {
+  applyClaimKeyLifecycle,
+  buildExtractedClaimKeyLifecycle,
+  buildInferredIngestClaimKeySupportContext
+} from "./chunk-VTHBPXDQ.js";
+import {
+  assertKeyedDurableHasLifecycle,
+  compactClaimKey,
+  describeClaimKeyNormalizationFailure,
+  describeExtractedClaimKeyRejection,
+  inspectClaimKey,
+  isTrustedClaimKeyForCleanup,
+  normalizeClaimKey,
+  normalizeClaimKeySegment,
+  validateExtractedClaimKey
+} from "./chunk-VBPYU7GO.js";
+
+// src/app/dreaming/concurrency.ts
+import { randomUUID } from "crypto";
+var DREAMING_RUN_LEASE_BRAND = /* @__PURE__ */ Symbol("DreamingRunLease");
+var inProcessRunLocks = /* @__PURE__ */ new Map();
+var episodeWriteRefcounts = /* @__PURE__ */ new Map();
+var DEFAULT_LOCK_HEARTBEAT_INTERVAL_MS = 5 * 60 * 1e3;
+var DEFAULT_LOCK_WAIT_TIMEOUT_MS = 60 * 1e3;
+var DEFAULT_LOCK_WAIT_POLL_MS = 500;
+function resolveDreamingLockKey(dbPath) {
+  const trimmed = dbPath?.trim();
+  return trimmed && trimmed.length > 0 ? trimmed : ":memory:";
+}
+async function tryAcquireDreamingRunLock(port, dbPath) {
+  const lockKey = resolveDreamingLockKey(dbPath);
+  if (inProcessRunLocks.has(lockKey)) {
+    return null;
+  }
+  const token = randomUUID();
+  const acquired = await port.tryAcquireRunLock(token);
+  if (!acquired) {
+    return null;
+  }
+  inProcessRunLocks.set(lockKey, token);
+  return createDreamingRunLease(port, lockKey, token);
+}
+async function withDreamingRunLock(port, dbPath, fn) {
+  const lease = await tryAcquireDreamingRunLock(port, dbPath);
+  if (!lease) {
+    throw new Error("Dreaming run already in progress.");
+  }
+  return withHeldDreamingRunLock(lease, fn);
+}
+async function withHeldDreamingRunLock(lease, fn) {
+  let callbackError;
+  let result;
+  const stopHeartbeat = startDreamingRunLockHeartbeat(lease);
+  try {
+    await lease.heartbeat();
+    result = await fn(lease);
+  } catch (error) {
+    callbackError = error;
+  }
+  let cleanupError;
+  try {
+    await stopHeartbeat();
+  } catch (error) {
+    cleanupError = error;
+  }
+  try {
+    await lease.release();
+  } catch (error) {
+    if (cleanupError === void 0) {
+      cleanupError = error;
+    }
+  }
+  if (callbackError !== void 0) {
+    throw callbackError;
+  }
+  if (cleanupError !== void 0) {
+    throw cleanupError;
+  }
+  return result;
+}
+async function withEpisodeWriteGuard(input, fn) {
+  beginEpisodeWrite(input.dbPath);
+  try {
+    const lease = await waitForDreamingRunLock(input.port, input.dbPath, {
+      timeoutMs: input.waitTimeoutMs,
+      pollMs: input.waitPollMs
+    });
+    return await withHeldDreamingRunLock(lease, async () => fn());
+  } finally {
+    endEpisodeWrite(input.dbPath);
+  }
+}
+function beginEpisodeWrite(dbPath) {
+  const lockKey = resolveDreamingLockKey(dbPath);
+  episodeWriteRefcounts.set(lockKey, (episodeWriteRefcounts.get(lockKey) ?? 0) + 1);
+}
+function endEpisodeWrite(dbPath) {
+  const lockKey = resolveDreamingLockKey(dbPath);
+  const next = (episodeWriteRefcounts.get(lockKey) ?? 0) - 1;
+  if (next <= 0) {
+    episodeWriteRefcounts.delete(lockKey);
+    return;
+  }
+  episodeWriteRefcounts.set(lockKey, next);
+}
+function isEpisodeWriteInProgress(dbPath) {
+  return (episodeWriteRefcounts.get(resolveDreamingLockKey(dbPath)) ?? 0) > 0;
+}
+function createDreamingRunLease(port, lockKey, token) {
+  let released = false;
+  return {
+    token,
+    [DREAMING_RUN_LEASE_BRAND]: true,
+    async heartbeat() {
+      if (released) {
+        return;
+      }
+      if (inProcessRunLocks.get(lockKey) !== token) {
+        throw new Error("Dreaming run lock was lost in this process.");
+      }
+      const retained = await port.heartbeatRunLock(token);
+      if (!retained) {
+        throw new Error("Dreaming run lock was lost.");
+      }
+    },
+    async release() {
+      if (released) {
+        return;
+      }
+      released = true;
+      if (inProcessRunLocks.get(lockKey) === token) {
+        inProcessRunLocks.delete(lockKey);
+      }
+      await port.releaseRunLock(token);
+    }
+  };
+}
+function startDreamingRunLockHeartbeat(lease) {
+  let heartbeatError;
+  let pendingHeartbeat = null;
+  const timer = setInterval(() => {
+    pendingHeartbeat = lease.heartbeat().catch((error) => {
+      heartbeatError = error;
+    });
+  }, DEFAULT_LOCK_HEARTBEAT_INTERVAL_MS);
+  timer.unref?.();
+  return async () => {
+    clearInterval(timer);
+    if (pendingHeartbeat) {
+      await pendingHeartbeat;
+    }
+    if (heartbeatError !== void 0) {
+      throw heartbeatError;
+    }
+  };
+}
+async function waitForDreamingRunLock(port, dbPath, options) {
+  const timeoutMs = options.timeoutMs ?? DEFAULT_LOCK_WAIT_TIMEOUT_MS;
+  const pollMs = options.pollMs ?? DEFAULT_LOCK_WAIT_POLL_MS;
+  const deadline = Date.now() + timeoutMs;
+  while (true) {
+    const lease = await tryAcquireDreamingRunLock(port, dbPath);
+    if (lease) {
+      return lease;
+    }
+    if (Date.now() >= deadline) {
+      throw new Error("Timed out waiting for dreaming run lock before episode write.");
+    }
+    await sleep(Math.min(pollMs, Math.max(1, deadline - Date.now())));
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+// src/core/claim-key-entity-family.ts
+var ENTITY_FAMILY_GROUNDING_STOP_TOKENS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "as",
+  "at",
+  "be",
+  "by",
+  "for",
+  "from",
+  "in",
+  "into",
+  "is",
+  "it",
+  "of",
+  "on",
+  "or",
+  "that",
+  "the",
+  "their",
+  "this",
+  "to",
+  "was",
+  "with"
+]);
+var MAX_ATTRIBUTE_BUCKET_SIZE = 12;
+var MAX_EVIDENCE_VALUES = 6;
+var CANONICAL_SELECTION_MARGIN = 3;
+var SINGLETON_ALIAS_MAX_FAMILY_SIZE = 2;
+var SINGLETON_ALIAS_MIN_DOMINANT_TRUSTED_COUNT = 3;
+var SINGLETON_ALIAS_MIN_CONFIDENCE_DELTA = 0.05;
+var SINGLETON_ALIAS_SCOPE_TOKENS = /* @__PURE__ */ new Set([
+  "agent",
+  "app",
+  "branch",
+  "build",
+  "cluster",
+  "daemon",
+  "device",
+  "env",
+  "environment",
+  "gateway",
+  "host",
+  "machine",
+  "node",
+  "plugin",
+  "project",
+  "repo",
+  "repository",
+  "server",
+  "service",
+  "session",
+  "system",
+  "workspace"
+]);
+function detectClaimKeyEntityFamilyCandidates(entries) {
+  const profiles = buildTrustedClaimKeyEntityProfiles(entries);
+  if (profiles.size < 2) {
+    return [];
+  }
+  const pairSupport = buildPairSupport(profiles);
+  if (pairSupport.length === 0) {
+    return [];
+  }
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const support of pairSupport) {
+    const [leftEntity, rightEntity] = support.entityPrefixes;
+    getOrCreateSet(adjacency, leftEntity).add(rightEntity);
+    getOrCreateSet(adjacency, rightEntity).add(leftEntity);
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const families = [];
+  for (const entityPrefix of adjacency.keys()) {
+    if (visited.has(entityPrefix)) {
+      continue;
+    }
+    const component = collectConnectedEntityComponent(entityPrefix, adjacency, visited);
+    if (component.length < 2) {
+      continue;
+    }
+    const componentSet = new Set(component);
+    const componentSupport = pairSupport.filter((support) => {
+      const [leftEntity, rightEntity] = support.entityPrefixes;
+      return componentSet.has(leftEntity) && componentSet.has(rightEntity);
+    });
+    const canonicalSelection = selectCanonicalEntityPrefix(component, componentSupport, profiles);
+    const canonicalEntityPrefix = canonicalSelection.canonicalEntityPrefix;
+    const autoConverge = canonicalEntityPrefix !== null && component.filter((entity) => entity !== canonicalEntityPrefix).every((entity) => {
+      const support = findPairSupport(componentSupport, canonicalEntityPrefix, entity);
+      return support?.autoSafe === true;
+    });
+    const componentProfiles = component.map((entity) => profiles.get(entity)).filter((profile) => Boolean(profile));
+    const durableIds = normalizeStringArray(componentProfiles.flatMap((profile) => [...profile.durableIds]));
+    const claimKeys = normalizeStringArray(componentProfiles.flatMap((profile) => [...profile.claimKeys]));
+    const confidence = componentSupport.length > 0 ? Math.max(...componentSupport.map((support) => support.confidence)) : 0.75;
+    families.push({
+      entityPrefixes: [...component].sort((left, right) => left.localeCompare(right)),
+      durableIds,
+      claimKeys,
+      canonicalEntityPrefix,
+      canonicalSelectionReasons: canonicalSelection.reasons,
+      confidence,
+      autoConverge,
+      unresolvedReason: canonicalSelection.unresolvedReason ?? (autoConverge ? null : "Entity-family evidence is strong enough to stage, but not every alias mapping is low-risk."),
+      pairSupport: componentSupport.sort((left, right) => {
+        const leftKey = left.entityPrefixes.join("::");
+        const rightKey = right.entityPrefixes.join("::");
+        return leftKey.localeCompare(rightKey);
+      })
+    });
+  }
+  return families.sort((left, right) => {
+    if (right.confidence !== left.confidence) {
+      return right.confidence - left.confidence;
+    }
+    const leftKey = left.entityPrefixes.join("::");
+    const rightKey = right.entityPrefixes.join("::");
+    return leftKey.localeCompare(rightKey);
+  });
+}
+function summarizeClaimKeyEntityPrefixStats(observations) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const observation of observations) {
+    const rawClaimKey = observation.claim_key?.trim();
+    if (!rawClaimKey) {
+      continue;
+    }
+    const inspection = inspectClaimKey(rawClaimKey);
+    if (!inspection.normalized) {
+      continue;
+    }
+    assertKeyedDurableHasLifecycle(observation);
+    const entityPrefix = inspection.normalized.entity;
+    const existing = counts.get(entityPrefix) ?? {
+      entityPrefix,
+      activeEntryCount: 0,
+      trustedEntryCount: 0,
+      tentativeEntryCount: 0,
+      unresolvedEntryCount: 0,
+      deterministicRepairEntryCount: 0,
+      manualEntryCount: 0,
+      modelEntryCount: 0,
+      jsonRetryEntryCount: 0,
+      dreamingFamilyReuseDurableCount: 0
+    };
+    existing.activeEntryCount += 1;
+    switch (observation.claim_key_status) {
+      case "trusted":
+        existing.trustedEntryCount += 1;
+        break;
+      case "tentative":
+        existing.tentativeEntryCount += 1;
+        break;
+      case "unresolved":
+        existing.unresolvedEntryCount += 1;
+        break;
+    }
+    switch (observation.claim_key_source) {
+      case "deterministic_repair":
+        existing.deterministicRepairEntryCount += 1;
+        break;
+      case "manual":
+        existing.manualEntryCount += 1;
+        break;
+      case "model":
+        existing.modelEntryCount += 1;
+        break;
+      case "json_retry":
+        existing.jsonRetryEntryCount += 1;
+        break;
+      case "dreaming_reconcile":
+        existing.dreamingFamilyReuseDurableCount += 1;
+        break;
+      default:
+        break;
+    }
+    counts.set(entityPrefix, existing);
+  }
+  return [...counts.values()].sort((left, right) => {
+    if (right.activeEntryCount !== left.activeEntryCount) {
+      return right.activeEntryCount - left.activeEntryCount;
+    }
+    if (right.trustedEntryCount !== left.trustedEntryCount) {
+      return right.trustedEntryCount - left.trustedEntryCount;
+    }
+    return left.entityPrefix.localeCompare(right.entityPrefix);
+  });
+}
+function detectClaimKeySingletonAliasCandidates(observations) {
+  return detectClaimKeySingletonAliasCandidatesFromStats(summarizeClaimKeyEntityPrefixStats(observations));
+}
+function detectClaimKeySingletonAliasCandidatesFromStats(stats) {
+  const candidatesByAlias = /* @__PURE__ */ new Map();
+  const dominantFamilies = stats.filter((profile) => profile.trustedEntryCount >= SINGLETON_ALIAS_MIN_DOMINANT_TRUSTED_COUNT);
+  const aliasFamilies = stats.filter((profile) => {
+    return profile.activeEntryCount > 0 && profile.activeEntryCount <= SINGLETON_ALIAS_MAX_FAMILY_SIZE && profile.trustedEntryCount < profile.activeEntryCount && buildLowTrustEntryCount(profile) >= 1;
+  });
+  for (const aliasProfile of aliasFamilies) {
+    for (const dominantProfile of dominantFamilies) {
+      if (aliasProfile.entityPrefix === dominantProfile.entityPrefix || dominantProfile.activeEntryCount <= aliasProfile.activeEntryCount) {
+        continue;
+      }
+      const candidate = evaluateSingletonAliasCandidate(aliasProfile, dominantProfile);
+      if (!candidate) {
+        continue;
+      }
+      const existing = candidatesByAlias.get(aliasProfile.entityPrefix) ?? [];
+      existing.push(candidate);
+      candidatesByAlias.set(aliasProfile.entityPrefix, existing);
+    }
+  }
+  return [...candidatesByAlias.values()].flatMap(selectBestSingletonAliasCandidate).sort((left, right) => right.confidence - left.confidence || left.aliasEntityPrefix.localeCompare(right.aliasEntityPrefix));
+}
+function buildTrustedClaimKeyEntityProfiles(entries) {
+  const profiles = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const rawClaimKey = entry.claim_key?.trim();
+    if (!rawClaimKey) {
+      continue;
+    }
+    const inspection = inspectClaimKey(rawClaimKey);
+    if (!inspection.canonical || !inspection.normalized || inspection.suspectReasons.length > 0) {
+      continue;
+    }
+    const entityPrefix = inspection.normalized.entity;
+    const attribute = inspection.normalized.attribute;
+    const profile = getOrCreateProfile(profiles, entityPrefix);
+    profile.durableIds.add(entry.id);
+    profile.claimKeys.add(inspection.normalized.claimKey);
+    profile.attributeSet.add(attribute);
+    const [attributeHead = attribute] = attribute.split("_");
+    if (attributeHead) {
+      profile.attributeHeadSet.add(attributeHead);
+    }
+    for (const tag of entry.tags) {
+      const normalizedTag = normalizeClaimKeySegment(tag);
+      if (normalizedTag) {
+        profile.tags.add(normalizedTag);
+      }
+    }
+    for (const token of tokenizeGrounding(entry.source_context)) {
+      profile.sourceContextTokens.add(token);
+    }
+    for (const token of tokenizeGrounding(entry.subject)) {
+      profile.subjectTokens.add(token);
+    }
+    profile.entryCount += 1;
+    profile.totalQualityScore += entry.quality_score;
+  }
+  return profiles;
+}
+function getOrCreateProfile(profiles, entityPrefix) {
+  const existing = profiles.get(entityPrefix);
+  if (existing) {
+    return existing;
+  }
+  const tokenList = entityPrefix.split("_").filter((token) => token.length > 0);
+  const created = {
+    entityPrefix,
+    durableIds: /* @__PURE__ */ new Set(),
+    claimKeys: /* @__PURE__ */ new Set(),
+    attributeSet: /* @__PURE__ */ new Set(),
+    attributeHeadSet: /* @__PURE__ */ new Set(),
+    tags: /* @__PURE__ */ new Set(),
+    sourceContextTokens: /* @__PURE__ */ new Set(),
+    subjectTokens: /* @__PURE__ */ new Set(),
+    entryCount: 0,
+    totalQualityScore: 0,
+    tokenList,
+    sortedTokenSignature: [...tokenList].sort().join("_"),
+    compactSignature: tokenList.join("")
+  };
+  profiles.set(entityPrefix, created);
+  return created;
+}
+function buildPairSupport(profiles) {
+  const candidatePairs = /* @__PURE__ */ new Set();
+  const attributeBuckets = /* @__PURE__ */ new Map();
+  for (const profile of profiles.values()) {
+    for (const attribute of profile.attributeSet) {
+      const bucket = attributeBuckets.get(attribute);
+      if (bucket) {
+        bucket.push(profile.entityPrefix);
+      } else {
+        attributeBuckets.set(attribute, [profile.entityPrefix]);
+      }
+    }
+  }
+  for (const entities of attributeBuckets.values()) {
+    const normalizedEntities = normalizeStringArray(entities);
+    if (normalizedEntities.length < 2 || normalizedEntities.length > MAX_ATTRIBUTE_BUCKET_SIZE) {
+      continue;
+    }
+    for (let index = 0; index < normalizedEntities.length; index += 1) {
+      const leftEntity = normalizedEntities[index];
+      if (!leftEntity) {
+        continue;
+      }
+      for (let peerIndex = index + 1; peerIndex < normalizedEntities.length; peerIndex += 1) {
+        const rightEntity = normalizedEntities[peerIndex];
+        if (!rightEntity) {
+          continue;
+        }
+        candidatePairs.add(buildPairKey(leftEntity, rightEntity));
+      }
+    }
+  }
+  const support = [];
+  for (const pairKey of candidatePairs) {
+    const [leftEntity = "", rightEntity = ""] = pairKey.split("::");
+    const leftProfile = profiles.get(leftEntity);
+    const rightProfile = profiles.get(rightEntity);
+    if (!leftProfile || !rightProfile) {
+      continue;
+    }
+    const pairSupport = evaluateEntityFamilyPairSupport(leftProfile, rightProfile);
+    if (pairSupport) {
+      support.push(pairSupport);
+    }
+  }
+  return support;
+}
+function evaluateEntityFamilyPairSupport(leftProfile, rightProfile) {
+  const sharedAttributes = intersectSets(leftProfile.attributeSet, rightProfile.attributeSet);
+  if (sharedAttributes.length === 0) {
+    return null;
+  }
+  const sharedAttributeHeads = intersectSets(leftProfile.attributeHeadSet, rightProfile.attributeHeadSet);
+  const sharedTags = intersectSets(leftProfile.tags, rightProfile.tags);
+  const sharedSourceContextTokens = intersectSets(leftProfile.sourceContextTokens, rightProfile.sourceContextTokens);
+  const sharedSubjectTokens = intersectSets(leftProfile.subjectTokens, rightProfile.subjectTokens);
+  const lexicalRelation = evaluateEntityLexicalRelation(leftProfile, rightProfile);
+  const groundingScore = (sharedTags.length > 0 ? 1 : 0) + (sharedSourceContextTokens.length >= 3 ? 1 : 0) + (sharedSubjectTokens.length >= 2 ? 1 : 0);
+  const groundingAnchorCount = (sharedTags.length > 0 ? 1 : 0) + (sharedSourceContextTokens.length >= 3 ? 1 : 0);
+  const qualifies = sharedAttributes.length >= 3 || sharedAttributes.length >= 2 && (lexicalRelation.kind !== null || groundingAnchorCount >= 1) || sharedAttributes.length === 1 && lexicalRelation.kind !== null && groundingAnchorCount >= 1;
+  if (!qualifies) {
+    return null;
+  }
+  const evidence = [
+    {
+      kind: "shared_attribute_overlap",
+      detail: `Shared attributes: ${sharedAttributes.slice(0, MAX_EVIDENCE_VALUES).join(", ")}`
+    }
+  ];
+  if (sharedAttributeHeads.length >= 2) {
+    evidence.push({
+      kind: "shared_attribute_head_overlap",
+      detail: `Shared attribute families: ${sharedAttributeHeads.slice(0, MAX_EVIDENCE_VALUES).join(", ")}`
+    });
+  }
+  if (sharedTags.length > 0) {
+    evidence.push({
+      kind: "shared_tag_grounding",
+      detail: `Shared tags: ${sharedTags.slice(0, MAX_EVIDENCE_VALUES).join(", ")}`
+    });
+  }
+  if (sharedSourceContextTokens.length >= 2) {
+    evidence.push({
+      kind: "shared_source_context_grounding",
+      detail: `Shared source-context tokens: ${sharedSourceContextTokens.slice(0, MAX_EVIDENCE_VALUES).join(", ")}`
+    });
+  }
+  if (sharedSubjectTokens.length >= 2) {
+    evidence.push({
+      kind: "shared_subject_grounding",
+      detail: `Shared subject tokens: ${sharedSubjectTokens.slice(0, MAX_EVIDENCE_VALUES).join(", ")}`
+    });
+  }
+  if (lexicalRelation.kind && lexicalRelation.detail) {
+    evidence.push({
+      kind: lexicalRelation.kind,
+      detail: lexicalRelation.detail
+    });
+  }
+  const confidence = Math.min(
+    0.98,
+    0.48 + Math.min(sharedAttributes.length, 3) * 0.12 + Math.min(groundingScore, 3) * 0.08 + lexicalRelation.strengthScore * 0.05
+  );
+  return {
+    entityPrefixes: [leftProfile.entityPrefix, rightProfile.entityPrefix],
+    supportingDurableIds: normalizeStringArray([...leftProfile.durableIds, ...rightProfile.durableIds]),
+    sharedAttributes,
+    confidence,
+    autoSafe: lexicalRelation.autoSafe && (sharedAttributes.length >= 2 || sharedAttributes.length === 1 && groundingAnchorCount >= 1 && groundingScore >= 2),
+    preferredCanonicalEntityPrefix: lexicalRelation.preferredCanonicalEntityPrefix,
+    evidence
+  };
+}
+function evaluateEntityLexicalRelation(leftProfile, rightProfile) {
+  const leftTokens = leftProfile.tokenList;
+  const rightTokens = rightProfile.tokenList;
+  if (leftProfile.compactSignature === rightProfile.compactSignature && leftProfile.entityPrefix !== rightProfile.entityPrefix) {
+    const preferredCanonicalEntityPrefix = leftTokens.length === rightTokens.length ? null : leftTokens.length > rightTokens.length ? leftProfile.entityPrefix : rightProfile.entityPrefix;
+    return {
+      kind: "lexical_separator_variant",
+      detail: preferredCanonicalEntityPrefix === null ? "Entity prefixes collapse to the same compact lexical form." : `Entity prefixes collapse to the same compact lexical form; "${preferredCanonicalEntityPrefix}" preserves clearer token boundaries.`,
+      autoSafe: true,
+      preferredCanonicalEntityPrefix,
+      strengthScore: 3
+    };
+  }
+  if (leftProfile.sortedTokenSignature.length > 0 && leftProfile.sortedTokenSignature === rightProfile.sortedTokenSignature && leftProfile.entityPrefix !== rightProfile.entityPrefix) {
+    return {
+      kind: "lexical_token_reordering",
+      detail: "Entity prefixes use the same lexical tokens in a different order.",
+      autoSafe: true,
+      preferredCanonicalEntityPrefix: null,
+      strengthScore: 2
+    };
+  }
+  const leftInitialism = buildInitialism(leftTokens);
+  const rightInitialism = buildInitialism(rightTokens);
+  if (leftInitialism.length >= 2 && leftInitialism === rightProfile.entityPrefix) {
+    return {
+      kind: "lexical_initialism_expansion",
+      detail: `Entity prefix "${rightProfile.entityPrefix}" matches the initialism of "${leftProfile.entityPrefix}".`,
+      autoSafe: false,
+      preferredCanonicalEntityPrefix: leftProfile.entityPrefix,
+      strengthScore: 1
+    };
+  }
+  if (rightInitialism.length >= 2 && rightInitialism === leftProfile.entityPrefix) {
+    return {
+      kind: "lexical_initialism_expansion",
+      detail: `Entity prefix "${leftProfile.entityPrefix}" matches the initialism of "${rightProfile.entityPrefix}".`,
+      autoSafe: false,
+      preferredCanonicalEntityPrefix: rightProfile.entityPrefix,
+      strengthScore: 1
+    };
+  }
+  if (isTokenSubset(leftTokens, rightTokens)) {
+    return {
+      kind: "lexical_token_subset",
+      detail: `"${leftProfile.entityPrefix}" is a lexical subset of "${rightProfile.entityPrefix}".`,
+      autoSafe: false,
+      preferredCanonicalEntityPrefix: rightProfile.entityPrefix,
+      strengthScore: 1
+    };
+  }
+  if (isTokenSubset(rightTokens, leftTokens)) {
+    return {
+      kind: "lexical_token_subset",
+      detail: `"${rightProfile.entityPrefix}" is a lexical subset of "${leftProfile.entityPrefix}".`,
+      autoSafe: false,
+      preferredCanonicalEntityPrefix: leftProfile.entityPrefix,
+      strengthScore: 1
+    };
+  }
+  return {
+    kind: null,
+    detail: null,
+    autoSafe: false,
+    preferredCanonicalEntityPrefix: null,
+    strengthScore: 0
+  };
+}
+function selectCanonicalEntityPrefix(entityPrefixes, pairSupport, profiles) {
+  const scoreByEntity = /* @__PURE__ */ new Map();
+  const reasonsByEntity = /* @__PURE__ */ new Map();
+  for (const entityPrefix of entityPrefixes) {
+    const profile = profiles.get(entityPrefix);
+    if (!profile) {
+      continue;
+    }
+    let score = Math.min(profile.attributeSet.size, 6) * 2 + Math.min(profile.entryCount, 6) + Math.round(profile.totalQualityScore / Math.max(profile.entryCount, 1));
+    const reasons = [];
+    if (profile.attributeSet.size >= 2) {
+      reasons.push("broader trusted attribute coverage");
+    }
+    for (const support of pairSupport) {
+      if (support.preferredCanonicalEntityPrefix === entityPrefix) {
+        score += 4;
+      } else if (support.preferredCanonicalEntityPrefix !== null) {
+        score -= 2;
+      }
+    }
+    const formSpecificity = scoreEntityFormSpecificity(entityPrefix, entityPrefixes, profiles);
+    score += formSpecificity.score;
+    if (formSpecificity.reason) {
+      reasons.push(formSpecificity.reason);
+    }
+    const lexicalVotes2 = pairSupport.filter((support) => support.preferredCanonicalEntityPrefix === entityPrefix).length;
+    if (lexicalVotes2 > 0) {
+      reasons.push(`lexical alias evidence prefers "${entityPrefix}"`);
+    }
+    scoreByEntity.set(entityPrefix, score);
+    reasonsByEntity.set(entityPrefix, normalizeStringArray(reasons));
+  }
+  const ranked = [...scoreByEntity.entries()].sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]));
+  const [bestCandidate, secondCandidate] = ranked;
+  if (!bestCandidate) {
+    return {
+      canonicalEntityPrefix: null,
+      reasons: [],
+      unresolvedReason: "No canonical entity prefix could be selected from the detected family."
+    };
+  }
+  const [bestEntityPrefix, bestScore] = bestCandidate;
+  const secondScore = secondCandidate?.[1] ?? Number.NEGATIVE_INFINITY;
+  const bestProfile = profiles.get(bestEntityPrefix);
+  if (!bestProfile) {
+    return {
+      canonicalEntityPrefix: null,
+      reasons: [],
+      unresolvedReason: "No canonical entity prefix could be selected from the detected family."
+    };
+  }
+  const directPeerSupport = entityPrefixes.filter((entityPrefix) => entityPrefix !== bestEntityPrefix).map((entityPrefix) => findPairSupport(pairSupport, bestEntityPrefix, entityPrefix));
+  const hasDirectSupportToAllPeers = directPeerSupport.every((support) => support !== null);
+  const hasLexicalSupportToAllPeers = directPeerSupport.every((support) => support?.evidence.some((evidence) => evidence.kind.startsWith("lexical_")) === true);
+  const lexicalVotes = pairSupport.filter((support) => support.preferredCanonicalEntityPrefix === bestEntityPrefix).length;
+  if (!hasDirectSupportToAllPeers || !hasLexicalSupportToAllPeers || lexicalVotes === 0 || bestScore - secondScore < CANONICAL_SELECTION_MARGIN) {
+    return {
+      canonicalEntityPrefix: null,
+      reasons: [],
+      unresolvedReason: "Multiple plausible canonical entity prefixes remain after conservative scoring."
+    };
+  }
+  return {
+    canonicalEntityPrefix: bestEntityPrefix,
+    reasons: reasonsByEntity.get(bestEntityPrefix) ?? [],
+    unresolvedReason: null
+  };
+}
+function scoreEntityFormSpecificity(entityPrefix, entityPrefixes, profiles) {
+  const profile = profiles.get(entityPrefix);
+  if (!profile) {
+    return { score: 0, reason: null };
+  }
+  let score = 0;
+  let reason = null;
+  const compactPeers = entityPrefixes.filter((peerEntityPrefix) => peerEntityPrefix !== entityPrefix).map((peerEntityPrefix) => profiles.get(peerEntityPrefix)).filter((peerProfile) => Boolean(peerProfile)).filter((peerProfile) => peerProfile.compactSignature === profile.compactSignature);
+  if (profile.tokenList.length >= 2 && compactPeers.some((peerProfile) => peerProfile.tokenList.length < profile.tokenList.length)) {
+    score += 2;
+    reason = "less abbreviated lexical form";
+  }
+  if (entityPrefix.length <= 3 && compactPeers.length === 0) {
+    score -= 1;
+  }
+  return { score, reason };
+}
+function collectConnectedEntityComponent(startingEntityPrefix, adjacency, visited) {
+  const queue = [startingEntityPrefix];
+  const component = [];
+  visited.add(startingEntityPrefix);
+  while (queue.length > 0) {
+    const entityPrefix = queue.shift();
+    if (!entityPrefix) {
+      continue;
+    }
+    component.push(entityPrefix);
+    const peers = adjacency.get(entityPrefix);
+    if (!peers) {
+      continue;
+    }
+    for (const peer of peers) {
+      if (visited.has(peer)) {
+        continue;
+      }
+      visited.add(peer);
+      queue.push(peer);
+    }
+  }
+  return component;
+}
+function findPairSupport(pairSupport, leftEntityPrefix, rightEntityPrefix) {
+  for (const support of pairSupport) {
+    const [leftEntity, rightEntity] = support.entityPrefixes;
+    if (leftEntity === leftEntityPrefix && rightEntity === rightEntityPrefix || leftEntity === rightEntityPrefix && rightEntity === leftEntityPrefix) {
+      return support;
+    }
+  }
+  return null;
+}
+function evaluateSingletonAliasCandidate(aliasProfile, dominantProfile) {
+  const lexicalRelation = evaluateSingletonAliasLexicalRelation(aliasProfile.entityPrefix, dominantProfile.entityPrefix);
+  if (!lexicalRelation.kind || !lexicalRelation.detail || lexicalRelation.scopeLike) {
+    return null;
+  }
+  const dominantTrustedCount = dominantProfile.trustedEntryCount;
+  if (dominantTrustedCount < SINGLETON_ALIAS_MIN_DOMINANT_TRUSTED_COUNT) {
+    return null;
+  }
+  const aliasLowTrustCount = buildLowTrustEntryCount(aliasProfile);
+  if (aliasLowTrustCount === 0) {
+    return null;
+  }
+  const evidence = [
+    {
+      kind: "singleton_family_size",
+      detail: `"${aliasProfile.entityPrefix}" has ${aliasProfile.activeEntryCount} active keyed ${pluralize(aliasProfile.activeEntryCount, "entry")}.`
+    },
+    {
+      kind: "dominant_trusted_family",
+      detail: `"${dominantProfile.entityPrefix}" already has ${dominantTrustedCount} trusted ${pluralize(dominantTrustedCount, "entry")}.`
+    },
+    {
+      kind: "low_trust_creation_path",
+      detail: describeLowTrustAliasFamily(aliasProfile)
+    },
+    {
+      kind: lexicalRelation.kind,
+      detail: lexicalRelation.detail
+    }
+  ];
+  const confidence = Math.min(
+    0.98,
+    0.58 + Math.min(dominantTrustedCount, 6) * 0.05 + Math.min(aliasLowTrustCount, 2) * 0.05 + Math.min(dominantProfile.activeEntryCount - aliasProfile.activeEntryCount, 6) * 0.02 + lexicalRelation.strengthScore * 0.08
+  );
+  return {
+    aliasEntityPrefix: aliasProfile.entityPrefix,
+    dominantEntityPrefix: dominantProfile.entityPrefix,
+    aliasFamilySize: aliasProfile.activeEntryCount,
+    dominantFamilySize: dominantProfile.activeEntryCount,
+    dominantTrustedCount,
+    aliasLowTrustCount,
+    confidence,
+    canonicalReuseSafe: lexicalRelation.canonicalReuseSafe && aliasProfile.activeEntryCount === 1 && aliasLowTrustCount === aliasProfile.activeEntryCount && dominantTrustedCount >= SINGLETON_ALIAS_MIN_DOMINANT_TRUSTED_COUNT,
+    evidence
+  };
+}
+function selectBestSingletonAliasCandidate(candidates) {
+  const ranked = [...candidates].sort(
+    (left, right) => right.confidence - left.confidence || left.dominantEntityPrefix.localeCompare(right.dominantEntityPrefix)
+  );
+  const [best, runnerUp] = ranked;
+  if (!best) {
+    return [];
+  }
+  if (runnerUp && best.confidence - runnerUp.confidence < SINGLETON_ALIAS_MIN_CONFIDENCE_DELTA) {
+    return [];
+  }
+  return [best];
+}
+function evaluateSingletonAliasLexicalRelation(aliasEntityPrefix, dominantEntityPrefix) {
+  const aliasTokens = aliasEntityPrefix.split("_").filter((token) => token.length > 0);
+  const dominantTokens = dominantEntityPrefix.split("_").filter((token) => token.length > 0);
+  const aliasCompactSignature = aliasTokens.join("");
+  const dominantCompactSignature = dominantTokens.join("");
+  if (aliasCompactSignature === dominantCompactSignature && aliasEntityPrefix !== dominantEntityPrefix) {
+    return {
+      kind: "lexical_separator_variant",
+      detail: `Entity prefixes "${aliasEntityPrefix}" and "${dominantEntityPrefix}" collapse to the same compact lexical form.`,
+      canonicalReuseSafe: true,
+      scopeLike: false,
+      strengthScore: 3
+    };
+  }
+  if (!isTokenSubset(dominantTokens, aliasTokens)) {
+    return {
+      kind: null,
+      detail: null,
+      canonicalReuseSafe: false,
+      scopeLike: false,
+      strengthScore: 0
+    };
+  }
+  const dominantTokenSet = new Set(dominantTokens);
+  const addedTokens = aliasTokens.filter((token) => !dominantTokenSet.has(token));
+  const scopeLike = addedTokens.length !== 1 || addedTokens.some((token) => SINGLETON_ALIAS_SCOPE_TOKENS.has(token));
+  if (scopeLike) {
+    return {
+      kind: null,
+      detail: null,
+      canonicalReuseSafe: false,
+      scopeLike: true,
+      strengthScore: 0
+    };
+  }
+  return {
+    kind: "lexical_token_subset",
+    detail: `"${aliasEntityPrefix}" extends "${dominantEntityPrefix}" by the added token "${addedTokens[0]}".`,
+    canonicalReuseSafe: true,
+    scopeLike: false,
+    strengthScore: 2
+  };
+}
+function buildLowTrustEntryCount(profile) {
+  const deterministicOnlyCount = Math.max(0, profile.deterministicRepairEntryCount - profile.tentativeEntryCount);
+  return profile.tentativeEntryCount + profile.unresolvedEntryCount + deterministicOnlyCount;
+}
+function describeLowTrustAliasFamily(profile) {
+  const reasons = [];
+  if (profile.deterministicRepairEntryCount > 0) {
+    reasons.push(`${profile.deterministicRepairEntryCount} deterministic repair ${pluralize(profile.deterministicRepairEntryCount, "entry")}`);
+  }
+  if (profile.tentativeEntryCount > 0) {
+    reasons.push(`${profile.tentativeEntryCount} tentative ${pluralize(profile.tentativeEntryCount, "entry")}`);
+  }
+  if (profile.unresolvedEntryCount > 0) {
+    reasons.push(`${profile.unresolvedEntryCount} unresolved ${pluralize(profile.unresolvedEntryCount, "entry")}`);
+  }
+  if (reasons.length === 0) {
+    return `"${profile.entityPrefix}" is not fully trusted yet.`;
+  }
+  return `"${profile.entityPrefix}" is low-trust because it has ${reasons.join(", ")}.`;
+}
+function buildInitialism(tokens) {
+  if (tokens.length < 2) {
+    return "";
+  }
+  return tokens.map((token) => token[0] ?? "").join("");
+}
+function isTokenSubset(subsetTokens, supersetTokens) {
+  if (subsetTokens.length === 0 || subsetTokens.length >= supersetTokens.length) {
+    return false;
+  }
+  const superset = new Set(supersetTokens);
+  return subsetTokens.every((token) => superset.has(token));
+}
+function tokenizeGrounding(value) {
+  if (!value) {
+    return [];
+  }
+  const normalized = normalizeClaimKeySegment(value);
+  if (!normalized) {
+    return [];
+  }
+  return normalized.split("_").filter((token) => token.length >= 2 && !ENTITY_FAMILY_GROUNDING_STOP_TOKENS.has(token));
+}
+function intersectSets(left, right) {
+  const intersection = [];
+  const [small, large] = left.size <= right.size ? [left, right] : [right, left];
+  for (const value of small) {
+    if (large.has(value)) {
+      intersection.push(value);
+    }
+  }
+  return intersection.sort((first, second) => first.localeCompare(second));
+}
+function normalizeStringArray(values) {
+  return Array.from(new Set(values.map((value) => value.trim()).filter((value) => value.length > 0)));
+}
+function buildPairKey(leftEntityPrefix, rightEntityPrefix) {
+  return [leftEntityPrefix, rightEntityPrefix].sort((left, right) => left.localeCompare(right)).join("::");
+}
+function getOrCreateSet(map, key) {
+  const existing = map.get(key);
+  if (existing) {
+    return existing;
+  }
+  const created = /* @__PURE__ */ new Set();
+  map.set(key, created);
+  return created;
+}
+function pluralize(count, noun) {
+  return count === 1 ? noun : `${noun}s`;
+}
+
+// src/core/supersession.ts
+function validateSupersessionRules(oldEntry, newEntry) {
+  if (oldEntry.type !== newEntry.type) {
+    return {
+      ok: false,
+      reason: "type_mismatch"
+    };
+  }
+  if (oldEntry.type === "milestone") {
+    return {
+      ok: false,
+      reason: "milestone"
+    };
+  }
+  if (oldEntry.expiry === "core") {
+    return {
+      ok: false,
+      reason: "core_expiry"
+    };
+  }
+  return {
+    ok: true
+  };
+}
+function describeSupersessionRuleFailure(reason) {
+  switch (reason) {
+    case "type_mismatch":
+      return "Supersession requires both entries to have the same type.";
+    case "milestone":
+      return "Milestone entries are never superseded automatically.";
+    case "core_expiry":
+      return "Core-expiry entries are never superseded automatically.";
+  }
+}
+
+// src/core/store/hashing.ts
+import { createHash } from "crypto";
+function computeContentHash(content, sourceFile) {
+  const input = sourceFile ? `${sourceFile}
+${content}` : content;
+  return createHash("sha256").update(input).digest("hex");
+}
+function computeNormContentHash(content) {
+  const normalized = content.toLowerCase().replace(/\s+/g, " ").trim().replace(/[^\w\s]/g, "");
+  return createHash("sha256").update(normalized).digest("hex");
+}
+
+// src/core/store/project-scope.ts
+import path from "path";
+var IGNORED_PROJECT_DIRECTORY_NAMES = /* @__PURE__ */ new Set(["", ".", "..", "users", "user", "home", "tmp", "var"]);
+function resolveDurableProjectScope(entry, context = {}) {
+  const entryProject = normalizeOptionalString(entry.project);
+  if (entryProject) {
+    return entryProject;
+  }
+  const sessionWorkspace = normalizeOptionalString(context.sessionWorkspace ?? void 0);
+  if (sessionWorkspace) {
+    if (claimKeySuggestsProjectScope(entry.claim_key, sessionWorkspace) || entryContainsProjectSignal(entry, sessionWorkspace)) {
+      return sessionWorkspace;
+    }
+  }
+  const workingDirectoryProject = deriveWorkingDirectoryProject(context.workingDirectory);
+  if (workingDirectoryProject && entryContainsProjectSignal(entry, workingDirectoryProject)) {
+    return workingDirectoryProject;
+  }
+  return void 0;
+}
+function claimKeySuggestsProjectScope(claimKey, project) {
+  const entity = normalizeMetadataIdentifier(claimKey?.split("/")[0]);
+  const normalizedProject = normalizeMetadataIdentifier(project);
+  if (!entity || !normalizedProject) {
+    return false;
+  }
+  return entity === normalizedProject;
+}
+function deriveWorkingDirectoryProject(workingDirectory) {
+  const normalizedWorkingDirectory = normalizeOptionalString(workingDirectory ?? void 0);
+  if (!normalizedWorkingDirectory) {
+    return void 0;
+  }
+  const candidate = normalizeMetadataIdentifier(path.basename(normalizedWorkingDirectory));
+  if (!candidate || IGNORED_PROJECT_DIRECTORY_NAMES.has(candidate)) {
+    return void 0;
+  }
+  return candidate;
+}
+function entryContainsProjectSignal(entry, project) {
+  const projectTokens = project.split("_").filter((token) => token.length > 0);
+  if (projectTokens.length === 0) {
+    return false;
+  }
+  return [entry.subject, entry.source_context, ...entry.tags ?? []].some((value) => {
+    const tokens = tokenizeText(value);
+    return projectTokens.every((token) => tokens.has(token));
+  });
+}
+function normalizeMetadataIdentifier(value) {
+  const normalized = normalizeOptionalString(value)?.toLowerCase().replace(/[^a-z0-9]+/gu, "_").replace(/^_+|_+$/gu, "");
+  return normalized && normalized.length > 0 ? normalized : void 0;
+}
+function tokenizeText(value) {
+  return new Set(
+    (value ?? "").toLowerCase().split(/[^a-z0-9]+/u).map((token) => token.trim()).filter((token) => token.length > 0)
+  );
+}
+function normalizeOptionalString(value) {
+  const normalized = value?.trim();
+  return normalized && normalized.length > 0 ? normalized : void 0;
+}
+
+// src/core/claim-key-support.ts
+var MAX_AUTO_APPLY_ATTRIBUTE_TOKENS = 4;
+var GROUNDING_STOP_TOKENS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "as",
+  "at",
+  "be",
+  "by",
+  "for",
+  "from",
+  "how",
+  "in",
+  "into",
+  "is",
+  "it",
+  "of",
+  "on",
+  "or",
+  "our",
+  "that",
+  "the",
+  "their",
+  "this",
+  "to",
+  "we",
+  "with"
+]);
+var AWKWARD_AUTO_APPLY_ATTRIBUTE_TOKENS = /* @__PURE__ */ new Set(["to", "for", "from", "with", "about", "into", "onto", "between", "during"]);
+var POLICY_TEMPLATE_ATTRIBUTE_TOKENS = /* @__PURE__ */ new Set(["policy", "default", "workflow", "process", "strategy", "guardrail", "rule", "boundary"]);
+var AUTHORITATIVE_TEMPLATE_ATTRIBUTE_TOKENS = /* @__PURE__ */ new Set(["source", "truth", "guide", "runbook", "reference"]);
+var ARCHITECTURE_TEMPLATE_ATTRIBUTE_TOKENS = /* @__PURE__ */ new Set([
+  "adapter",
+  "boundary",
+  "architecture",
+  "backend",
+  "storage",
+  "model",
+  "support",
+  "contract",
+  "interface",
+  "surface"
+]);
+var STABLE_FAMILY_SLOT_ATTRIBUTE_HEADS = /* @__PURE__ */ new Set([
+  "access",
+  "boundary",
+  "condition",
+  "contract",
+  "dependency",
+  "mode",
+  "owner",
+  "order",
+  "path",
+  "policy",
+  "preference",
+  "preservation",
+  "process",
+  "requirement",
+  "role",
+  "rule",
+  "schedule",
+  "sequencing",
+  "setting",
+  "status",
+  "strategy",
+  "support",
+  "surface",
+  "timezone",
+  "version",
+  "window",
+  "workflow",
+  "workspace"
+]);
+function buildTrustedClaimKeySupportSeed(entries) {
+  const claimKeyStats = /* @__PURE__ */ new Map();
+  const trustedEntries = [];
+  for (const entry of entries) {
+    const claimKey = entry.claim_key?.trim();
+    if (!claimKey || !isTrustedClaimKeyForCleanup(claimKey)) {
+      continue;
+    }
+    const inspection = inspectClaimKey(claimKey);
+    if (!inspection.normalized) {
+      continue;
+    }
+    const existing = claimKeyStats.get(claimKey);
+    if (existing) {
+      existing.count += 1;
+      existing.maxImportance = Math.max(existing.maxImportance, entry.importance);
+      existing.latestCreatedAt = existing.latestCreatedAt.localeCompare(entry.created_at) >= 0 ? existing.latestCreatedAt : entry.created_at;
+      continue;
+    }
+    claimKeyStats.set(claimKey, {
+      count: 1,
+      maxImportance: entry.importance,
+      latestCreatedAt: entry.created_at
+    });
+    trustedEntries.push({
+      id: entry.id,
+      claimKey: inspection.normalized.claimKey,
+      entity: inspection.normalized.entity,
+      attribute: inspection.normalized.attribute,
+      type: entry.type,
+      tags: normalizeGroundingTags(entry.tags),
+      sourceContextTokens: tokenizeGroundingText(entry.source_context),
+      subjectTokens: tokenizeGroundingText(entry.subject),
+      createdAt: entry.created_at
+    });
+  }
+  const orderedClaimKeys = [...claimKeyStats.entries()].sort((left, right) => {
+    const countDelta = right[1].count - left[1].count;
+    if (countDelta !== 0) {
+      return countDelta;
+    }
+    const importanceDelta = right[1].maxImportance - left[1].maxImportance;
+    if (importanceDelta !== 0) {
+      return importanceDelta;
+    }
+    const createdAtDelta = right[1].latestCreatedAt.localeCompare(left[1].latestCreatedAt);
+    if (createdAtDelta !== 0) {
+      return createdAtDelta;
+    }
+    return left[0].localeCompare(right[0]);
+  }).map(([claimKey]) => claimKey);
+  const orderedEntries = orderedClaimKeys.flatMap(
+    (claimKey) => trustedEntries.filter((entry) => entry.claimKey === claimKey).sort((left, right) => {
+      const createdAtDelta = right.createdAt.localeCompare(left.createdAt);
+      if (createdAtDelta !== 0) {
+        return createdAtDelta;
+      }
+      return left.id.localeCompare(right.id);
+    })
+  );
+  return {
+    entries: orderedEntries
+  };
+}
+function buildClaimKeySupportSeedFromExamples(claimKeys) {
+  const entries = claimKeys.flatMap((claimKey, index) => {
+    const inspection = inspectClaimKey(claimKey);
+    if (!inspection.normalized || !isTrustedClaimKeyForCleanup(inspection.normalized.claimKey)) {
+      return [];
+    }
+    return [
+      {
+        id: `example:${index + 1}`,
+        claimKey: inspection.normalized.claimKey,
+        entity: inspection.normalized.entity,
+        attribute: inspection.normalized.attribute,
+        tags: [],
+        sourceContextTokens: [],
+        subjectTokens: [],
+        createdAt: "1970-01-01T00:00:00.000Z"
+      }
+    ];
+  });
+  return { entries };
+}
+function evaluateClaimKeySupport(entry, targetClaimKey, trustedHints) {
+  const inspection = inspectClaimKey(targetClaimKey);
+  const normalized = inspection.normalized;
+  if (!normalized) {
+    return createEmptyClaimKeySupportEvaluation();
+  }
+  const entryTagSet = new Set(normalizeGroundingTags(entry.tags));
+  const entrySourceTokens = new Set(tokenizeGroundingText(entry.source_context));
+  const relevantEntries = trustedHints.entries.filter((trustedEntry) => {
+    if (entry.id && trustedEntry.id === entry.id) {
+      return false;
+    }
+    return trustedEntry.claimKey === normalized.claimKey || trustedEntry.entity === normalized.entity;
+  });
+  const exactReuseEntries = relevantEntries.filter((trustedEntry) => trustedEntry.claimKey === normalized.claimKey);
+  const familyReuseEntries = relevantEntries.filter(
+    (trustedEntry) => trustedEntry.claimKey !== normalized.claimKey && trustedEntry.entity === normalized.entity
+  );
+  const groundedExactReuseEntries = exactReuseEntries.filter((trustedEntry) => {
+    const grounding = inspectGroundingOverlap(entryTagSet, entrySourceTokens, trustedEntry);
+    return grounding.tagGrounding || grounding.sourceContextGrounding;
+  });
+  const groundedFamilyReuseEntries = familyReuseEntries.filter((trustedEntry) => {
+    const grounding = inspectGroundingOverlap(entryTagSet, entrySourceTokens, trustedEntry);
+    return grounding.tagGrounding || grounding.sourceContextGrounding;
+  });
+  const tagGrounding = relevantEntries.some((trustedEntry) => inspectGroundingOverlap(entryTagSet, entrySourceTokens, trustedEntry).tagGrounding);
+  const sourceContextGrounding = relevantEntries.some(
+    (trustedEntry) => inspectGroundingOverlap(entryTagSet, entrySourceTokens, trustedEntry).sourceContextGrounding
+  );
+  const localGrounding = tagGrounding || sourceContextGrounding;
+  const lexicalAlignment = inspectCandidateLexicalAlignment(entry, normalized.entity, normalized.attribute);
+  const templateSupport = matchesConservativeTemplateSupport(entry, normalized.attribute);
+  const stableSlotSupport = matchesStableFamilySlotSupport(normalized.attribute);
+  const trustedExactReuse = exactReuseEntries.length > 0 && (groundedExactReuseEntries.length > 0 || exactReuseEntries.every((candidate) => candidate.id.startsWith("example:")));
+  const trustedEntityFamilyReuse = groundedFamilyReuseEntries.length > 0 || familyReuseEntries.some((candidate) => candidate.id.startsWith("example:"));
+  const promotionSupport = resolveClaimKeyPromotionSupport({
+    exactReuseCount: trustedExactReuse ? Math.max(1, groundedExactReuseEntries.length) : 0,
+    familyReuseCount: familyReuseEntries.length,
+    groundedFamilyReuseCount: groundedFamilyReuseEntries.length > 0 ? groundedFamilyReuseEntries.length : familyReuseEntries.some((candidate) => candidate.id.startsWith("example:")) ? familyReuseEntries.length : 0,
+    localGrounding: localGrounding || familyReuseEntries.some((candidate) => candidate.id.startsWith("example:")),
+    templateSupport,
+    stableSlotSupport,
+    lexicalAlignment
+  });
+  const supportedProposal = lexicalAlignment.any && (templateSupport || stableSlotSupport || trustedExactReuse || trustedEntityFamilyReuse || localGrounding);
+  const supportEvidence = [
+    trustedExactReuse ? "trusted_exact_reuse" : null,
+    trustedEntityFamilyReuse ? "trusted_entity_family_reuse" : null,
+    tagGrounding ? "tag_grounding" : null,
+    sourceContextGrounding ? "source_context_grounding" : null,
+    lexicalAlignment.entity ? "entity_lexical_alignment" : null,
+    lexicalAlignment.attribute ? "attribute_lexical_alignment" : null,
+    lexicalAlignment.strongEntityAttribute ? "strong_entity_attribute_lexical_alignment" : null,
+    templateSupport ? "template_support" : null,
+    stableSlotSupport ? "stable_slot_support" : null,
+    promotionSupport.relaxedStableSlotFamilyGate ? "single_grounded_family_sibling" : null
+  ].filter((value) => value !== null);
+  const rationaleFragments = [
+    trustedExactReuse ? `trusted exact reuse from ${Math.max(1, groundedExactReuseEntries.length)} matching entr${Math.max(1, groundedExactReuseEntries.length) === 1 ? "y" : "ies"}` : null,
+    trustedEntityFamilyReuse ? `trusted ${normalized.entity} family reuse from ${Math.max(1, groundedFamilyReuseEntries.length || familyReuseEntries.length)} supporting entr${Math.max(1, groundedFamilyReuseEntries.length || familyReuseEntries.length) === 1 ? "y" : "ies"}` : null,
+    tagGrounding ? "overlapping tags with trusted corpus entries" : null,
+    sourceContextGrounding ? "overlapping source_context with trusted corpus entries" : null,
+    lexicalAlignment.strongEntityAttribute ? "strong entity and slot lexical alignment" : null,
+    lexicalAlignment.attribute ? lexicalAlignment.strongEntityAttribute ? null : "clear lexical alignment to the proposed slot" : lexicalAlignment.entity ? "clear lexical alignment to the proposed entity" : null,
+    templateSupport ? "a conservative policy/default/source-of-truth template match" : null,
+    stableSlotSupport ? "a stable compact slot head in a well-established entity family" : null,
+    promotionSupport.relaxedStableSlotFamilyGate ? "one grounded family sibling cleared the stable-slot family gate" : null
+  ].filter((value) => value !== null);
+  return {
+    autoApplyClass: promotionSupport.autoApplyClass,
+    supportedProposal,
+    trustedExactReuse,
+    trustedEntityFamilyReuse,
+    tagGrounding,
+    sourceContextGrounding,
+    localGrounding,
+    entityLexicalAlignment: lexicalAlignment.entity,
+    attributeLexicalAlignment: lexicalAlignment.attribute,
+    strongEntityAttributeLexicalAlignment: lexicalAlignment.strongEntityAttribute,
+    lexicalAlignment: lexicalAlignment.any,
+    templateSupport,
+    stableSlotSupport,
+    familyReuseCount: familyReuseEntries.length,
+    groundedFamilyReuseCount: groundedFamilyReuseEntries.length,
+    relaxedStableSlotFamilyGate: promotionSupport.relaxedStableSlotFamilyGate,
+    supportingDurableIds: normalizeStringArray2([
+      ...groundedExactReuseEntries.map((candidate) => candidate.id),
+      ...groundedFamilyReuseEntries.map((candidate) => candidate.id),
+      ...familyReuseEntries.filter((candidate) => candidate.id.startsWith("example:")).map((candidate) => candidate.id)
+    ]),
+    supportEvidence,
+    rationaleFragments
+  };
+}
+function createEmptyClaimKeySupportEvaluation() {
+  return {
+    autoApplyClass: null,
+    supportedProposal: false,
+    trustedExactReuse: false,
+    trustedEntityFamilyReuse: false,
+    tagGrounding: false,
+    sourceContextGrounding: false,
+    localGrounding: false,
+    entityLexicalAlignment: false,
+    attributeLexicalAlignment: false,
+    strongEntityAttributeLexicalAlignment: false,
+    lexicalAlignment: false,
+    templateSupport: false,
+    stableSlotSupport: false,
+    familyReuseCount: 0,
+    groundedFamilyReuseCount: 0,
+    relaxedStableSlotFamilyGate: false,
+    supportingDurableIds: [],
+    supportEvidence: [],
+    rationaleFragments: []
+  };
+}
+function evaluateClaimKeyCompactness(claimKey, prior) {
+  const compacted = compactClaimKey(claimKey);
+  if (!compacted) {
+    return {
+      claimKey,
+      compactedFrom: null,
+      compactionReason: null,
+      compactEnoughForAutoApply: false,
+      blockerReason: "invalid_claim_key"
+    };
+  }
+  const attributeTokens = compacted.attribute.split("_").filter((token) => token.length > 0);
+  const compactEnoughForAutoApply = attributeTokens.length > 0 && attributeTokens.length <= MAX_AUTO_APPLY_ATTRIBUTE_TOKENS && !attributeTokens.some((token) => AWKWARD_AUTO_APPLY_ATTRIBUTE_TOKENS.has(token));
+  const compactedFrom = compacted.compactedFrom ?? prior?.priorCompactedFrom ?? null;
+  const compactionReason = compacted.reason && prior?.priorCompactionReason ? `${prior.priorCompactionReason} and ${compacted.reason}` : compacted.reason ?? prior?.priorCompactionReason ?? null;
+  return {
+    claimKey: compacted.claimKey,
+    compactedFrom,
+    compactionReason,
+    compactEnoughForAutoApply,
+    blockerReason: compactEnoughForAutoApply ? null : "non_compact_canonical_slot"
+  };
+}
+function normalizeGroundingTags(tags) {
+  return normalizeStringArray2((tags ?? []).map((tag) => normalizeClaimKeySegment(tag)).filter((tag) => tag.length > 0));
+}
+function tokenizeGroundingText(value) {
+  if (!value) {
+    return [];
+  }
+  return normalizeStringArray2(
+    value.split(/[^a-zA-Z0-9]+/u).map((token) => normalizeClaimKeySegment(token)).filter((token) => token.length > 2 && !GROUNDING_STOP_TOKENS.has(token))
+  );
+}
+function buildDurableLocalLexicalTokens(entry) {
+  return normalizeStringArray2([
+    ...tokenizeGroundingText(entry.subject),
+    ...tokenizeGroundingText(entry.content),
+    ...tokenizeGroundingText(entry.source_context),
+    ...normalizeGroundingTags(entry.tags)
+  ]);
+}
+function resolveClaimKeyPromotionSupport(input) {
+  if (input.exactReuseCount > 0 && (input.lexicalAlignment.attribute || input.templateSupport)) {
+    return {
+      autoApplyClass: "trusted_exact_reuse_grounded",
+      relaxedStableSlotFamilyGate: false
+    };
+  }
+  if (input.templateSupport && input.localGrounding && input.familyReuseCount > 0 && (input.lexicalAlignment.attribute || input.lexicalAlignment.entity)) {
+    return {
+      autoApplyClass: "trusted_family_template_grounded",
+      relaxedStableSlotFamilyGate: false
+    };
+  }
+  const relaxedStableSlotFamilyGate = input.stableSlotSupport && input.localGrounding && input.groundedFamilyReuseCount > 0 && input.familyReuseCount === 1 && input.lexicalAlignment.strongEntityAttribute;
+  if (input.stableSlotSupport && input.localGrounding && input.groundedFamilyReuseCount > 0 && (input.familyReuseCount >= 2 || relaxedStableSlotFamilyGate) && input.lexicalAlignment.attribute) {
+    return {
+      autoApplyClass: "trusted_family_stable_slot",
+      relaxedStableSlotFamilyGate
+    };
+  }
+  if (input.localGrounding && input.groundedFamilyReuseCount > 0 && input.lexicalAlignment.strongEntityAttribute) {
+    return {
+      autoApplyClass: "trusted_family_grounded_alignment",
+      relaxedStableSlotFamilyGate: false
+    };
+  }
+  return {
+    autoApplyClass: null,
+    relaxedStableSlotFamilyGate: false
+  };
+}
+function inspectGroundingOverlap(entryTagSet, entrySourceTokens, trustedEntry) {
+  return {
+    tagGrounding: countSetOverlap(entryTagSet, trustedEntry.tags) > 0,
+    sourceContextGrounding: countSetOverlap(entrySourceTokens, trustedEntry.sourceContextTokens) > 0
+  };
+}
+function inspectCandidateLexicalAlignment(entry, entity, attribute) {
+  const lexicalTokens = new Set(buildDurableLocalLexicalTokens(entry));
+  const entityTokens = entity.split("_").filter((token) => token.length > 0);
+  const attributeTokens = attribute.split("_").filter((token) => token.length > 0 && !GROUNDING_STOP_TOKENS.has(token));
+  const entityOverlapCount = countSetOverlap(lexicalTokens, entityTokens);
+  const attributeOverlapCount = countSetOverlap(lexicalTokens, attributeTokens);
+  const entityAlignment = entityOverlapCount > 0;
+  const attributeAlignment = attributeOverlapCount > 0;
+  const strongAttributeAlignment = attributeTokens.length > 0 && attributeOverlapCount >= Math.min(attributeTokens.length, 2);
+  return {
+    entity: entityAlignment,
+    attribute: attributeAlignment,
+    any: entityAlignment || attributeAlignment,
+    strongEntityAttribute: entityAlignment && strongAttributeAlignment,
+    entityOverlapCount,
+    attributeOverlapCount
+  };
+}
+function matchesConservativeTemplateSupport(entry, attribute) {
+  const attributeTokens = new Set(attribute.split("_").filter((token) => token.length > 0));
+  const subjectText = entry.subject.toLowerCase();
+  const contentText = entry.content.toLowerCase();
+  const combinedText = `${subjectText}
+${contentText}`;
+  const authoritativePattern = /\b(authoritative|source of truth|source of record|canonical guide|canonical reference|primary guide|runbook)\b/u.test(
+    combinedText
+  );
+  if (authoritativePattern && intersects(attributeTokens, AUTHORITATIVE_TEMPLATE_ATTRIBUTE_TOKENS)) {
+    return true;
+  }
+  const policyPattern = /\b(should|must|should stay|must stay|always|never|default(?:s)? to|default(?:s)?|policy|guardrail|required|preference|prefers?)\b/u.test(combinedText);
+  if (policyPattern && intersects(attributeTokens, POLICY_TEMPLATE_ATTRIBUTE_TOKENS)) {
+    return true;
+  }
+  const architecturePattern = /\b(uses|supports|backed by|architecture|boundary|workflow|process|pipeline|adapter|layer|contract|interface|surface)\b/u.test(
+    combinedText
+  );
+  return architecturePattern && intersects(attributeTokens, ARCHITECTURE_TEMPLATE_ATTRIBUTE_TOKENS);
+}
+function matchesStableFamilySlotSupport(attribute) {
+  const tokens = attribute.split("_").filter((token) => token.length > 0);
+  if (tokens.length === 0 || tokens.length > MAX_AUTO_APPLY_ATTRIBUTE_TOKENS) {
+    return false;
+  }
+  const head = tokens[tokens.length - 1];
+  return typeof head === "string" && STABLE_FAMILY_SLOT_ATTRIBUTE_HEADS.has(head);
+}
+function countSetOverlap(left, right) {
+  let count = 0;
+  for (const value of right) {
+    if (left.has(value)) {
+      count += 1;
+    }
+  }
+  return count;
+}
+function intersects(left, right) {
+  for (const value of left) {
+    if (right.has(value)) {
+      return true;
+    }
+  }
+  return false;
+}
+function normalizeStringArray2(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const normalized = [];
+  for (const value of values) {
+    if (!value || seen.has(value)) {
+      continue;
+    }
+    seen.add(value);
+    normalized.push(value);
+  }
+  return normalized;
+}
+
+// src/core/store/claim-extraction.ts
+var SELF_REFERENTIAL_ENTITIES = /* @__PURE__ */ new Set(["i", "me", "the_user", "myself", "user", "we", "our_team", "the_project", "this_project"]);
+var USER_REFERENTIAL_ENTITIES = /* @__PURE__ */ new Set(["i", "me", "myself", "the_user", "user"]);
+var PROJECT_REFERENTIAL_ENTITIES = /* @__PURE__ */ new Set(["the_project", "this_project"]);
+var DETERMINISTIC_ATTRIBUTE_HEADS = /* @__PURE__ */ new Set([
+  "budget",
+  "city",
+  "config",
+  "deadline",
+  "email",
+  "employer",
+  "language",
+  "limit",
+  "location",
+  "mode",
+  "model",
+  "name",
+  "owner",
+  "plan",
+  "policy",
+  "preference",
+  "priority",
+  "quota",
+  "region",
+  "role",
+  "schedule",
+  "setting",
+  "status",
+  "strategy",
+  "team",
+  "theme",
+  "timezone",
+  "version",
+  "window"
+]);
+var MAX_ENTITY_HINTS = 12;
+var MAX_CLAIM_KEY_EXAMPLES = 8;
+var MAX_SUPPORT_CLAIM_KEY_EXAMPLES = 128;
+var DEFAULT_REPAIR_CONFIDENCE = 0.86;
+var HIGH_CONFIDENCE_BACKFILL_THRESHOLD = 0.92;
+var SUPPORTED_INGEST_AUTO_APPLY_THRESHOLD = 0.72;
+var COMPACTED_SUPPORTED_INGEST_AUTO_APPLY_THRESHOLD = 0.74;
+var PROPOSAL_CONFIDENCE_THRESHOLD = 0.75;
+var SUPPORTED_PROPOSAL_CONFIDENCE_THRESHOLD = 0.65;
+function applyClaimExtractionResultToEntry(entry, extracted) {
+  const lifecycle = buildExtractedClaimKeyLifecycle(extracted, buildInferredIngestClaimKeySupportContext(entry));
+  if (!lifecycle) {
+    return;
+  }
+  applyClaimKeyLifecycle(entry, lifecycle);
+}
+async function previewClaimKeyExtraction(entry, llm, config, options = {}) {
+  if (!config.enabled || !config.eligibleTypes.includes(entry.type)) {
+    return null;
+  }
+  const normalizedHints = normalizeClaimExtractionHints(options.hints ?? {});
+  let attempt;
+  try {
+    attempt = await attemptClaimExtraction(entry, normalizedHints, llm);
+  } catch (error) {
+    const repaired = tryDeterministicClaimKeyRepair(entry, normalizedHints);
+    if (repaired) {
+      return repaired;
+    }
+    throw error;
+  }
+  if (attempt.response.no_claim === true) {
+    options.onPreviewOutcome?.(buildPreviewOutcome("no_claim", attempt));
+    return null;
+  }
+  const candidate = buildClaimExtractionCandidate(entry, attempt.response, normalizedHints, options.onWarning);
+  if (candidate) {
+    options.onPreviewOutcome?.({
+      outcome: "candidate",
+      confidence: candidate.confidence,
+      rawEntity: candidate.rawEntity,
+      rawAttribute: candidate.rawAttribute,
+      path: attempt.path
+    });
+    return {
+      claimKey: candidate.claimKey,
+      confidence: candidate.confidence,
+      rawEntity: candidate.rawEntity,
+      rawAttribute: candidate.rawAttribute,
+      path: attempt.path,
+      ...candidate.compactedFrom ? {
+        compactedFrom: candidate.compactedFrom,
+        compactionReason: candidate.compactionReason
+      } : {}
+    };
+  }
+  options.onPreviewOutcome?.(buildPreviewOutcome("rejected_candidate", attempt));
+  return tryDeterministicClaimKeyRepair(entry, normalizedHints);
+}
+async function extractClaimKeyDecision(entry, llm, config, options = {}) {
+  if (!config.enabled || !config.eligibleTypes.includes(entry.type)) {
+    return {
+      result: null,
+      diagnostic: {
+        outcome: "ineligible_type",
+        confidence: null,
+        path: null,
+        warning: null,
+        suggestedClaimKey: null,
+        reviewable: false,
+        supportEvidence: [],
+        rationale: "entry type is not eligible for claim-key extraction"
+      }
+    };
+  }
+  const normalizedHints = normalizeClaimExtractionHints(options.hints ?? {});
+  let attempt;
+  try {
+    attempt = await attemptClaimExtraction(entry, normalizedHints, llm);
+  } catch (error) {
+    const repaired2 = tryDeterministicClaimKeyRepair(entry, normalizedHints);
+    if (repaired2) {
+      return finalizeDeterministicRepairDecision(repaired2, options.entityPrefixStats);
+    }
+    const warning = formatClaimExtractionError(error);
+    options.onWarning?.(`Claim extraction failed for "${entry.subject}": ${warning}`);
+    return {
+      result: null,
+      diagnostic: {
+        outcome: "extraction_failure",
+        confidence: null,
+        path: null,
+        warning,
+        suggestedClaimKey: null,
+        reviewable: false,
+        supportEvidence: [],
+        rationale: "claim extraction failed before a safe candidate could be produced"
+      }
+    };
+  }
+  if (attempt.response.no_claim === true) {
+    return {
+      result: null,
+      diagnostic: {
+        outcome: "no_claim",
+        confidence: normalizeConfidence(attempt.response.confidence),
+        path: attempt.path,
+        warning: null,
+        suggestedClaimKey: null,
+        reviewable: false,
+        supportEvidence: [],
+        rationale: "model explicitly returned no_claim"
+      }
+    };
+  }
+  const warnings = [];
+  const candidate = buildClaimExtractionCandidate(entry, attempt.response, normalizedHints, (warning) => {
+    warnings.push(warning);
+    options.onWarning?.(warning);
+  });
+  if (!candidate) {
+    const repaired2 = tryDeterministicClaimKeyRepair(entry, normalizedHints);
+    if (repaired2) {
+      return finalizeDeterministicRepairDecision(repaired2, options.entityPrefixStats);
+    }
+    return {
+      result: null,
+      diagnostic: {
+        outcome: "rejected_candidate",
+        confidence: normalizeConfidence(attempt.response.confidence),
+        path: attempt.path,
+        warning: warnings[0] ?? null,
+        suggestedClaimKey: null,
+        reviewable: false,
+        supportEvidence: [],
+        rationale: "model proposed a structurally unsafe or non-canonical claim key"
+      }
+    };
+  }
+  const result = toClaimExtractionResult(candidate, attempt.path);
+  if (result.confidence >= config.confidenceThreshold) {
+    return {
+      result,
+      diagnostic: buildAcceptedDiagnostic(result, result.confidence >= config.confidenceThreshold ? "candidate met the ingest confidence threshold" : null)
+    };
+  }
+  const support = evaluateClaimKeySupport(
+    {
+      subject: entry.subject,
+      content: entry.content,
+      type: entry.type,
+      tags: entry.tags,
+      source_context: entry.source_context
+    },
+    result.claimKey ?? "",
+    buildClaimKeySupportSeedFromExamples(options.supportClaimKeys ?? [])
+  );
+  const compactness = evaluateClaimKeyCompactness(result.claimKey ?? "", {
+    priorCompactedFrom: result.compactedFrom ?? null,
+    priorCompactionReason: result.compactionReason ?? null
+  });
+  const autoApplyThreshold = support.autoApplyClass !== null && compactness.compactedFrom ? COMPACTED_SUPPORTED_INGEST_AUTO_APPLY_THRESHOLD : support.autoApplyClass !== null ? SUPPORTED_INGEST_AUTO_APPLY_THRESHOLD : HIGH_CONFIDENCE_BACKFILL_THRESHOLD;
+  const proposalThreshold = support.supportedProposal ? SUPPORTED_PROPOSAL_CONFIDENCE_THRESHOLD : PROPOSAL_CONFIDENCE_THRESHOLD;
+  if (compactness.claimKey !== result.claimKey) {
+    result.claimKey = compactness.claimKey;
+    result.compactedFrom = compactness.compactedFrom;
+    result.compactionReason = compactness.compactionReason;
+  }
+  if (result.confidence >= autoApplyThreshold && compactness.compactEnoughForAutoApply) {
+    result.acceptanceRationale = support.autoApplyClass !== null ? `accepted below the default threshold via ${describeSupportPromotionClass(support)}` : "accepted as a high-confidence preview";
+    return {
+      result,
+      diagnostic: buildAcceptedDiagnostic(
+        result,
+        support.autoApplyClass !== null ? `supported near-miss candidate cleared the conservative auto-apply threshold via ${describeSupportPromotionClass(support)}` : `candidate cleared the conservative high-confidence threshold of ${autoApplyThreshold.toFixed(2)}`
+      )
+    };
+  }
+  const repaired = tryDeterministicClaimKeyRepair(entry, normalizedHints);
+  if (repaired && (!result.claimKey || repaired.claimKey === result.claimKey)) {
+    return finalizeDeterministicRepairDecision(repaired, options.entityPrefixStats);
+  }
+  if (result.confidence >= proposalThreshold) {
+    return {
+      result: null,
+      diagnostic: {
+        outcome: "low_confidence_candidate",
+        confidence: result.confidence,
+        path: result.path,
+        warning: warnings[0] ?? null,
+        suggestedClaimKey: result.claimKey,
+        reviewable: true,
+        supportEvidence: support.supportEvidence,
+        rationale: support.rationaleFragments.length > 0 ? `candidate stayed below the auto-apply threshold but has structured support from ${support.rationaleFragments.join(", ")}` : `candidate stayed below the auto-apply threshold of ${autoApplyThreshold.toFixed(2)}`
+      }
+    };
+  }
+  return {
+    result: null,
+    diagnostic: {
+      outcome: "low_confidence_candidate",
+      confidence: result.confidence,
+      path: result.path,
+      warning: warnings[0] ?? null,
+      suggestedClaimKey: result.claimKey,
+      reviewable: false,
+      supportEvidence: support.supportEvidence,
+      rationale: "candidate stayed below both the conservative auto-apply and review thresholds"
+    }
+  };
+}
+async function getEntityHints(db) {
+  return db.getDistinctClaimKeyPrefixes();
+}
+async function runBatchClaimExtraction(results, ports, config, concurrency = 10, onWarning, onDiagnostic, onProgress) {
+  if (!config.enabled) {
+    return /* @__PURE__ */ new Map();
+  }
+  const hintState = await loadClaimExtractionHintState(ports.db);
+  const llm = ports.createLlm();
+  const extractedEntries = /* @__PURE__ */ new Map();
+  const diagnostics = /* @__PURE__ */ new Map();
+  const retryEntries = [];
+  const stageSize = normalizeClaimExtractionConcurrency(concurrency);
+  const orderedEntries = results.flatMap((result) => result.entries);
+  const totalEligibleEntries = orderedEntries.filter((entry) => !entry.claim_key && config.eligibleTypes.includes(entry.type)).length;
+  let completedPrimaryEntries = 0;
+  for (let stageStart = 0; stageStart < orderedEntries.length; stageStart += stageSize) {
+    const stageEntries = orderedEntries.slice(stageStart, stageStart + stageSize);
+    const stageRequests = [];
+    for (const entry of stageEntries) {
+      if (entry.claim_key) {
+        recordClaimKeyHint(hintState, entry.claim_key);
+        continue;
+      }
+      if (!config.eligibleTypes.includes(entry.type)) {
+        diagnostics.set(entry, {
+          outcome: "ineligible_type",
+          confidence: null,
+          path: null,
+          warning: null,
+          suggestedClaimKey: null,
+          reviewable: false,
+          supportEvidence: [],
+          rationale: "entry type is not eligible for claim-key extraction"
+        });
+        continue;
+      }
+      stageRequests.push({
+        entry,
+        hintSnapshot: buildClaimExtractionHintSnapshot(hintState, entry)
+      });
+    }
+    const stageDecisions = await executeClaimExtractionStageRequests(
+      stageRequests,
+      llm,
+      config,
+      onWarning,
+      completedPrimaryEntries,
+      totalEligibleEntries,
+      (completedEntries, totalEntries) => {
+        completedPrimaryEntries = completedEntries;
+        onProgress?.({
+          phase: "primary",
+          completedEntries,
+          totalEntries,
+          totalEligibleEntries
+        });
+      }
+    );
+    for (const { entry, decision } of stageDecisions) {
+      diagnostics.set(entry, decision.diagnostic);
+      if (decision.result?.claimKey) {
+        applyClaimExtractionResultToEntry(entry, decision.result);
+        recordClaimKeyHint(hintState, decision.result.claimKey);
+        extractedEntries.set(entry, decision.result);
+        continue;
+      }
+      retryEntries.push(entry);
+    }
+  }
+  if (retryEntries.length > 0 && extractedEntries.size > 0) {
+    const retryEligibleEntries = retryEntries.filter((entry) => !entry.claim_key);
+    const totalRetryEntries = retryEligibleEntries.length;
+    let completedRetryEntries = 0;
+    for (let stageStart = 0; stageStart < retryEligibleEntries.length; stageStart += stageSize) {
+      const stageRequests = retryEligibleEntries.slice(stageStart, stageStart + stageSize).map((entry) => ({
+        entry,
+        hintSnapshot: buildClaimExtractionHintSnapshot(hintState, entry)
+      }));
+      const stageDecisions = await executeClaimExtractionStageRequests(
+        stageRequests,
+        llm,
+        config,
+        onWarning,
+        completedRetryEntries,
+        totalRetryEntries,
+        (completedEntries, totalEntries) => {
+          completedRetryEntries = completedEntries;
+          onProgress?.({
+            phase: "retry",
+            completedEntries,
+            totalEntries,
+            totalEligibleEntries
+          });
+        }
+      );
+      for (const { entry, decision } of stageDecisions) {
+        diagnostics.set(entry, decision.diagnostic);
+        if (!decision.result?.claimKey) {
+          continue;
+        }
+        applyClaimExtractionResultToEntry(entry, decision.result);
+        recordClaimKeyHint(hintState, decision.result.claimKey);
+        extractedEntries.set(entry, decision.result);
+      }
+    }
+  }
+  for (const result of results) {
+    for (const entry of result.entries) {
+      const diagnostic = diagnostics.get(entry);
+      if (diagnostic) {
+        onDiagnostic?.(entry, diagnostic);
+      }
+    }
+  }
+  return extractedEntries;
+}
+async function executeClaimExtractionStageRequests(stageRequests, llm, config, onWarning, initialCompletedEntries, totalEntries, onProgress) {
+  let completedEntries = initialCompletedEntries;
+  return Promise.all(
+    stageRequests.map(async ({ entry, hintSnapshot }) => {
+      const decision = await extractBatchClaimKeyDecision(entry, llm, config, hintSnapshot, onWarning);
+      completedEntries += 1;
+      onProgress(completedEntries, totalEntries);
+      return {
+        entry,
+        decision
+      };
+    })
+  );
+}
+function normalizeClaimExtractionConcurrency(value) {
+  if (!Number.isInteger(value) || value <= 0) {
+    return 10;
+  }
+  return value;
+}
+function buildClaimExtractionHintSnapshot(hintState, entry) {
+  return {
+    hints: buildEntryHints(hintState, entry),
+    supportClaimKeys: [...hintState.supportClaimKeys],
+    entityPrefixStats: hintState.entityPrefixStats
+  };
+}
+async function extractBatchClaimKeyDecision(entry, llm, config, hintSnapshot, onWarning) {
+  try {
+    return await extractClaimKeyDecision(
+      {
+        type: entry.type,
+        subject: entry.subject,
+        content: entry.content,
+        tags: entry.tags,
+        source_context: entry.source_context
+      },
+      llm,
+      config,
+      {
+        hints: hintSnapshot.hints,
+        onWarning,
+        supportClaimKeys: hintSnapshot.supportClaimKeys,
+        entityPrefixStats: hintSnapshot.entityPrefixStats
+      }
+    );
+  } catch {
+    return {
+      result: null,
+      diagnostic: {
+        outcome: "extraction_failure",
+        confidence: null,
+        path: null,
+        warning: "claim extraction failed unexpectedly",
+        suggestedClaimKey: null,
+        reviewable: false,
+        supportEvidence: [],
+        rationale: "claim extraction failed unexpectedly"
+      }
+    };
+  }
+}
+function buildClaimExtractionSystemPrompt(hints, promptMode) {
+  const metadataHints = [hints.userEntity ? `user_id=${hints.userEntity}` : null, hints.projectEntity ? `project=${hints.projectEntity}` : null].filter(
+    (value) => value !== null
+  );
+  const groundingHints = [
+    hints.tags.length > 0 ? `tags=${hints.tags.join(", ")}` : null,
+    hints.sourceContext ? `source_context=${hints.sourceContext}` : null
+  ].filter((value) => value !== null);
+  const retryInstructions = promptMode === "json_retry" ? [
+    "",
+    "Your previous answer was invalid JSON.",
+    "Reply with exactly one JSON object and nothing else.",
+    "Do not use markdown fences, commentary, or trailing text."
+  ] : [];
+  return [
+    "You are a knowledge entry classifier. Extract one stable claim key for a durable knowledge entry.",
+    "A claim key names the durable slot this entry updates: entity/attribute in lowercase snake_case.",
+    "The goal is stable slot naming, not a paraphrase of the current value.",
+    "",
+    "Stability rules:",
+    "- Prefer stable slot names over transient wording.",
+    "- Choose attribute names that still make sense if the value changes.",
+    "- Prefer short noun-like slot names over sentence-like attribute phrases.",
+    "- When a candidate sounds like a rule or explanation sentence, compress it into the reusable slot it governs.",
+    "- Prefer concrete entities over pronouns, deictic phrases, or self-referential placeholders.",
+    "- Reuse an existing entity or full claim-key example when it clearly matches the same slot.",
+    "- Stay domain-general. The same rules apply to people, devices, services, projects, places, organizations, products, datasets, policies, and preferences.",
+    "- If the entry states a durable rule, default, workflow, guardrail, source-of-truth rule, architecture boundary, or process constraint plus rationale, extract the primary durable slot rather than the supporting rationale.",
+    "- Do not return no_claim just because the entry explains why the rule exists. The durable policy or system slot is usually still the target.",
+    "- Avoid full action clauses like requires_x_to_y, preserves_x_across_y, or x_precedes_y when a shorter stable slot such as trigger_condition, context_preservation, source_of_truth, or handoff_order would carry the same durable meaning.",
+    "",
+    "Return no_claim when:",
+    "- The entry is narrative, multi-fact, or mostly a story about what happened.",
+    "- The entry is an event or milestone without one continuing slot.",
+    "- The entity is ambiguous or can only be named with a pronoun or vague placeholder.",
+    "- The entry does not express one durable property, preference, decision, configuration, relationship, or other stable slot.",
+    "- When unsure, prefer no_claim over inventing a weak key.",
+    "",
+    "Positive examples:",
+    `- "Jim's timezone is America/Chicago." -> jim/timezone`,
+    '- "Jim prefers oat milk in coffee." -> jim/coffee_preference',
+    '- "Pixel 8 is set to dark mode." -> pixel_8/theme_mode',
+    '- "Postgres max_connections is 200." -> postgres/max_connections',
+    '- "Agenr defaults to gpt-5.4-mini." -> agenr/default_model',
+    '- "Mac mini updates should stay manual so debugging stays predictable." -> mac_mini/manual_update_policy',
+    '- "Use the warehouse inventory sheet as the source of truth for stock counts." -> stock_counts/source_of_truth',
+    '- "The repo workflow is defined by AGENTS.md, even when older notes disagree." -> repo_workflow/source_of_truth',
+    '- "Agenr keeps pure logic in src/core and adapters outside it so future hosts can plug in cleanly." -> agenr/core_adapter_boundary',
+    '- "The before-prompt-build hook only triggers after a real agent turn or message." -> before_prompt_build_hook/trigger_condition',
+    '- "Durable memory preserves context across sessions." -> durable_memory/context_preservation',
+    '- "SQLite in this environment supports window functions." -> sqlite/window_function_support',
+    '- "Meeting-recorder transcripts need manual cleanup before durable ingest." -> meeting_recorder/transcript_cleanup_workflow',
+    '- "Reflection synthesis can hallucinate when it summarizes from partial notes." -> reflection_synthesis/hallucination_risk',
+    "",
+    "Negative examples:",
+    "- Bad: jim/america_chicago -> Good: jim/timezone",
+    "- Bad: project_x/details -> Good: project_x/deploy_strategy",
+    "- Bad: we/deployment_process -> Good: platform_team/deploy_strategy",
+    "- Bad: jim/oat_milk -> Good: jim/coffee_preference",
+    "- Bad: release_notes/because_rollbacks_are_hard -> Good: release_process/source_of_truth",
+    "- Bad: openclaw/requires_real_agent_turn_or_message_to_trigger -> Good: openclaw/trigger_condition",
+    "- Bad: session_continuity/durable_memory_preserves_context_across_sessions -> Good: session_continuity/context_preservation",
+    "- Bad: incident_story/we_spent_two_hours_debugging -> Good: no_claim",
+    "",
+    "Field rules:",
+    "- entity: the main concrete thing being described. It can be a person, device, service, product, organization, workflow area, or other durable system/process anchor.",
+    "- attribute: the narrow stable slot on that entity. For policy/process entries, name the governing slot such as source_of_truth, default_mode, update_policy, architecture_boundary, deploy_strategy, or escalation_workflow.",
+    "- Confidence: 0.0 to 1.0. Use 0.9+ only when the slot is unambiguous and durable.",
+    "",
+    `Known entity hints: ${hints.entityHints.length > 0 ? hints.entityHints.join(", ") : "(none)"}`,
+    `Known claim-key examples: ${hints.claimKeyExamples.length > 0 ? hints.claimKeyExamples.join(", ") : "(none)"}`,
+    `Current entry metadata hints: ${metadataHints.length > 0 ? metadataHints.join(", ") : "(none)"}`,
+    `Current entry grounding clues: ${groundingHints.length > 0 ? groundingHints.join(", ") : "(none)"}`,
+    'If project metadata is present, it may resolve phrases like "the project" when that mapping is obvious.',
+    'If user metadata is present, it may resolve phrases like "the user", "I", or "me" when that mapping is obvious.',
+    "Tags and source_context are local grounding clues, not proof. Use them to pick the right durable slot only when the entry content already supports that slot.",
+    ...retryInstructions,
+    "",
+    'Respond with JSON: { "entity": string, "attribute": string, "confidence": number, "no_claim"?: boolean }'
+  ].join("\n");
+}
+function buildClaimExtractionUserPrompt(entry) {
+  return [`Entry type: ${entry.type}`, `Subject: ${entry.subject}`, `Content: ${entry.content}`].join("\n");
+}
+async function attemptClaimExtraction(entry, hints, llm) {
+  const userPrompt = buildClaimExtractionUserPrompt(entry);
+  try {
+    return {
+      path: "model",
+      response: await llm.completeJson(buildClaimExtractionSystemPrompt(hints, "standard"), userPrompt)
+    };
+  } catch (error) {
+    if (!isMalformedJsonError(error)) {
+      throw error;
+    }
+  }
+  return {
+    path: "json_retry",
+    response: await llm.completeJson(buildClaimExtractionSystemPrompt(hints, "json_retry"), userPrompt)
+  };
+}
+function buildClaimExtractionCandidate(entry, response, hints, onWarning) {
+  const confidence = normalizeConfidence(response.confidence);
+  const rawEntity = typeof response.entity === "string" ? response.entity.trim() : "";
+  const rawAttribute = typeof response.attribute === "string" ? response.attribute.trim() : "";
+  const entity = normalizeEntity(rawEntity, hints);
+  const attribute = normalizeClaimKeySegment(rawAttribute);
+  const normalizedClaimKey = normalizeClaimKey(`${entity}/${attribute}`);
+  if (!normalizedClaimKey.ok) {
+    onWarning?.(`Claim extraction dropped claim key for "${entry.subject}": ${describeClaimKeyNormalizationFailure(normalizedClaimKey.reason)}.`);
+    return null;
+  }
+  const compactedClaimKey = compactClaimKey(normalizedClaimKey.value.claimKey);
+  if (!compactedClaimKey) {
+    onWarning?.(`Claim extraction dropped claim key for "${entry.subject}": claim key could not be compacted safely.`);
+    return null;
+  }
+  const validatedClaimKey = validateExtractedClaimKey(compactedClaimKey);
+  if (!validatedClaimKey.ok) {
+    onWarning?.(
+      `Claim extraction rejected "${validatedClaimKey.value.claimKey}" for "${entry.subject}": ${describeExtractedClaimKeyRejection(validatedClaimKey.reason, validatedClaimKey.value)}.`
+    );
+    return null;
+  }
+  return {
+    claimKey: validatedClaimKey.value.claimKey,
+    confidence,
+    rawEntity,
+    rawAttribute,
+    compactedFrom: compactedClaimKey.compactedFrom,
+    compactionReason: compactedClaimKey.reason
+  };
+}
+function toClaimExtractionResult(candidate, path2) {
+  return {
+    claimKey: candidate.claimKey,
+    confidence: candidate.confidence,
+    rawEntity: candidate.rawEntity,
+    rawAttribute: candidate.rawAttribute,
+    path: path2,
+    ...candidate.compactedFrom ? {
+      compactedFrom: candidate.compactedFrom,
+      compactionReason: candidate.compactionReason
+    } : {}
+  };
+}
+function buildAcceptedDiagnostic(result, rationale) {
+  return {
+    outcome: "accepted",
+    confidence: result.confidence,
+    path: result.path,
+    warning: null,
+    suggestedClaimKey: result.claimKey,
+    reviewable: false,
+    supportEvidence: [],
+    rationale
+  };
+}
+function finalizeDeterministicRepairDecision(repaired, entityPrefixStats) {
+  const aliasCandidate = findSingletonAliasReuseCandidate(repaired, entityPrefixStats);
+  if (!aliasCandidate) {
+    return {
+      result: repaired,
+      diagnostic: buildAcceptedDiagnostic(repaired, "deterministic possessive-slot repair recovered the missing claim key")
+    };
+  }
+  if (aliasCandidate.canonicalReuseSafe) {
+    const reusedResult = rewriteClaimKeyEntityPrefix(repaired, aliasCandidate.dominantEntityPrefix);
+    reusedResult.acceptanceRationale = `reused dominant entity family "${aliasCandidate.dominantEntityPrefix}" instead of minting singleton alias "${aliasCandidate.aliasEntityPrefix}"`;
+    return {
+      result: reusedResult,
+      diagnostic: buildAcceptedDiagnostic(
+        reusedResult,
+        `deterministic repair reused dominant family "${aliasCandidate.dominantEntityPrefix}" instead of new singleton alias "${aliasCandidate.aliasEntityPrefix}"`
+      )
+    };
+  }
+  const suggestedClaimKey = rewriteClaimKeyEntityPrefix(repaired, aliasCandidate.dominantEntityPrefix).claimKey;
+  return {
+    result: null,
+    diagnostic: {
+      outcome: "low_confidence_candidate",
+      confidence: repaired.confidence,
+      path: repaired.path,
+      warning: null,
+      suggestedClaimKey,
+      reviewable: true,
+      supportEvidence: aliasCandidate.evidence.map((evidence) => evidence.kind),
+      rationale: `deterministic repair would create singleton alias "${aliasCandidate.aliasEntityPrefix}" next to dominant trusted family "${aliasCandidate.dominantEntityPrefix}", so the new namespace was staged for review`
+    }
+  };
+}
+function findSingletonAliasReuseCandidate(repaired, entityPrefixStats) {
+  const claimKey = repaired.claimKey;
+  if (!claimKey || !entityPrefixStats || entityPrefixStats.length === 0) {
+    return null;
+  }
+  const [entityPrefix = ""] = claimKey.split("/", 1);
+  if (!entityPrefix) {
+    return null;
+  }
+  const augmentedStats = summarizeAugmentedEntityPrefixStats(entityPrefixStats, entityPrefix);
+  return detectClaimKeySingletonAliasCandidatesFromStats(augmentedStats).find((candidate) => candidate.aliasEntityPrefix === entityPrefix) ?? null;
+}
+function summarizeAugmentedEntityPrefixStats(entityPrefixStats, entityPrefix) {
+  const existing = entityPrefixStats.find((profile) => profile.entityPrefix === entityPrefix);
+  if (existing) {
+    return entityPrefixStats;
+  }
+  return [
+    ...entityPrefixStats,
+    {
+      entityPrefix,
+      activeEntryCount: 1,
+      trustedEntryCount: 0,
+      tentativeEntryCount: 1,
+      unresolvedEntryCount: 0,
+      deterministicRepairEntryCount: 1,
+      manualEntryCount: 0,
+      modelEntryCount: 0,
+      jsonRetryEntryCount: 0,
+      dreamingFamilyReuseDurableCount: 0
+    }
+  ];
+}
+function rewriteClaimKeyEntityPrefix(result, entityPrefix) {
+  const claimKey = result.claimKey;
+  if (!claimKey) {
+    return result;
+  }
+  const [, attribute = ""] = claimKey.split("/", 2);
+  return {
+    ...result,
+    claimKey: `${entityPrefix}/${attribute}`
+  };
+}
+function formatClaimExtractionError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function describeSupportPromotionClass(support) {
+  switch (support.autoApplyClass) {
+    case "trusted_exact_reuse_grounded":
+      return "trusted exact-key reuse with local grounding";
+    case "trusted_family_template_grounded":
+      return "trusted family reuse plus grounded template support";
+    case "trusted_family_stable_slot":
+      return "trusted family reuse plus a stable compact slot";
+    case "trusted_family_grounded_alignment":
+      return "trusted family reuse plus grounded dual lexical alignment";
+    default:
+      return "structural support";
+  }
+}
+function tryDeterministicClaimKeyRepair(entry, hints) {
+  const repaired = parsePossessiveClaim(entry.subject) ?? parsePossessiveStatement(entry.content);
+  if (!repaired) {
+    return null;
+  }
+  const attribute = normalizeClaimKeySegment(repaired.attribute);
+  if (!looksLikeDeterministicAttribute(attribute)) {
+    return null;
+  }
+  const entity = normalizeEntity(repaired.entity, hints);
+  const normalizedClaimKey = normalizeClaimKey(`${entity}/${attribute}`);
+  if (!normalizedClaimKey.ok) {
+    return null;
+  }
+  const validatedClaimKey = validateExtractedClaimKey(normalizedClaimKey.value);
+  if (!validatedClaimKey.ok) {
+    return null;
+  }
+  return {
+    claimKey: validatedClaimKey.value.claimKey,
+    confidence: DEFAULT_REPAIR_CONFIDENCE,
+    rawEntity: repaired.entity,
+    rawAttribute: repaired.attribute,
+    path: "deterministic_repair"
+  };
+}
+async function loadClaimExtractionHintState(db) {
+  const [entityHintResult, promptClaimKeyExampleResult, supportClaimKeyExampleResult, entityPrefixStatsResult] = await Promise.allSettled([
+    getEntityHints(db),
+    getClaimKeyExamples(db, MAX_CLAIM_KEY_EXAMPLES),
+    getClaimKeyExamples(db, MAX_SUPPORT_CLAIM_KEY_EXAMPLES),
+    getClaimKeyEntityPrefixStats(db)
+  ]);
+  return createHintState({
+    entityHints: entityHintResult.status === "fulfilled" ? entityHintResult.value : [],
+    claimKeyExamples: promptClaimKeyExampleResult.status === "fulfilled" ? promptClaimKeyExampleResult.value : [],
+    supportClaimKeys: supportClaimKeyExampleResult.status === "fulfilled" ? supportClaimKeyExampleResult.value : [],
+    entityPrefixStats: entityPrefixStatsResult.status === "fulfilled" ? entityPrefixStatsResult.value : []
+  });
+}
+async function getClaimKeyExamples(db, limit) {
+  if (typeof db.getClaimKeyExamples !== "function") {
+    return [];
+  }
+  return db.getClaimKeyExamples(limit);
+}
+async function getClaimKeyEntityPrefixStats(db) {
+  if (typeof db.getClaimKeyEntityPrefixStats !== "function") {
+    return [];
+  }
+  return db.getClaimKeyEntityPrefixStats();
+}
+function createHintState(input) {
+  const claimKeyExamples = normalizeClaimKeyExamples(input.claimKeyExamples ?? []);
+  const supportClaimKeys = normalizeSupportClaimKeys(input.supportClaimKeys ?? []);
+  const entityHints = limitUnique(
+    [
+      ...normalizeEntityHints(input.entityHints ?? []),
+      ...supportClaimKeys.flatMap((claimKey) => {
+        const normalizedClaimKey = normalizeClaimKey(claimKey);
+        return normalizedClaimKey.ok ? [normalizedClaimKey.value.entity] : [];
+      })
+    ],
+    MAX_ENTITY_HINTS
+  );
+  return {
+    entityHints,
+    claimKeyExamples,
+    supportClaimKeys,
+    entityPrefixStats: input.entityPrefixStats ?? []
+  };
+}
+function buildEntryHints(state, entry) {
+  return {
+    entityHints: [...state.entityHints],
+    claimKeyExamples: [...state.claimKeyExamples],
+    userId: entry.user_id,
+    project: entry.project,
+    tags: entry.tags,
+    sourceContext: entry.source_context
+  };
+}
+function recordClaimKeyHint(state, claimKey) {
+  const normalizedClaimKey = normalizeClaimKey(claimKey);
+  if (!normalizedClaimKey.ok) {
+    return;
+  }
+  state.claimKeyExamples = prependUnique(state.claimKeyExamples, normalizedClaimKey.value.claimKey, MAX_CLAIM_KEY_EXAMPLES);
+  state.supportClaimKeys = prependUnique(state.supportClaimKeys, normalizedClaimKey.value.claimKey, MAX_SUPPORT_CLAIM_KEY_EXAMPLES);
+  state.entityHints = prependUnique(state.entityHints, normalizedClaimKey.value.entity, MAX_ENTITY_HINTS);
+}
+function normalizeClaimExtractionHints(hints) {
+  const claimKeyExamples = normalizeClaimKeyExamples(hints.claimKeyExamples ?? []);
+  return {
+    entityHints: limitUnique(
+      [
+        ...normalizeEntityHints(hints.entityHints ?? []),
+        ...claimKeyExamples.flatMap((claimKey) => {
+          const normalizedClaimKey = normalizeClaimKey(claimKey);
+          return normalizedClaimKey.ok ? [normalizedClaimKey.value.entity] : [];
+        })
+      ],
+      MAX_ENTITY_HINTS
+    ),
+    claimKeyExamples,
+    userEntity: normalizeMetadataEntity(hints.userId),
+    projectEntity: normalizeMetadataEntity(hints.project),
+    tags: normalizeHintTags(hints.tags ?? []),
+    sourceContext: normalizeSourceContextHint(hints.sourceContext)
+  };
+}
+function buildPreviewOutcome(outcome, attempt) {
+  return {
+    outcome,
+    confidence: normalizeConfidence(attempt.response.confidence),
+    rawEntity: typeof attempt.response.entity === "string" ? attempt.response.entity.trim() : "",
+    rawAttribute: typeof attempt.response.attribute === "string" ? attempt.response.attribute.trim() : "",
+    path: attempt.path
+  };
+}
+function normalizeConfidence(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return 0;
+  }
+  return Math.min(1, Math.max(0, value));
+}
+function normalizeEntity(value, hints) {
+  const normalizedValue = normalizeClaimKeySegment(value);
+  if (normalizedValue.length === 0) {
+    return "";
+  }
+  if (!SELF_REFERENTIAL_ENTITIES.has(normalizedValue)) {
+    return normalizedValue;
+  }
+  if (USER_REFERENTIAL_ENTITIES.has(normalizedValue) && hints.userEntity) {
+    return hints.userEntity;
+  }
+  if (PROJECT_REFERENTIAL_ENTITIES.has(normalizedValue) && hints.projectEntity) {
+    return hints.projectEntity;
+  }
+  const concreteCandidates = limitUnique(
+    [hints.projectEntity, hints.userEntity, ...hints.entityHints].filter(
+      (candidate) => typeof candidate === "string" && candidate.length > 0
+    ),
+    MAX_ENTITY_HINTS
+  );
+  if (concreteCandidates.length === 1) {
+    return concreteCandidates[0] ?? normalizedValue;
+  }
+  if (hints.entityHints.length === 1) {
+    return hints.entityHints[0] ?? normalizedValue;
+  }
+  return normalizedValue;
+}
+function normalizeEntityHints(entityHints) {
+  return limitUnique(
+    entityHints.map((entityHint) => normalizeClaimKeySegment(entityHint)).filter((entityHint) => entityHint.length > 0 && !SELF_REFERENTIAL_ENTITIES.has(entityHint)),
+    MAX_ENTITY_HINTS
+  );
+}
+function normalizeClaimKeyExamples(claimKeyExamples) {
+  return limitUnique(
+    claimKeyExamples.flatMap((claimKeyExample) => {
+      const normalizedClaimKey = normalizeClaimKey(claimKeyExample);
+      return normalizedClaimKey.ok ? [normalizedClaimKey.value.claimKey] : [];
+    }),
+    MAX_CLAIM_KEY_EXAMPLES
+  );
+}
+function normalizeSupportClaimKeys(claimKeys) {
+  return limitUnique(
+    claimKeys.flatMap((claimKey) => {
+      const normalizedClaimKey = normalizeClaimKey(claimKey);
+      return normalizedClaimKey.ok ? [normalizedClaimKey.value.claimKey] : [];
+    }),
+    MAX_SUPPORT_CLAIM_KEY_EXAMPLES
+  );
+}
+function normalizeMetadataEntity(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = normalizeClaimKeySegment(value);
+  if (normalized.length === 0 || SELF_REFERENTIAL_ENTITIES.has(normalized) || !/[a-z]/u.test(normalized)) {
+    return void 0;
+  }
+  return normalized;
+}
+function normalizeHintTags(tags) {
+  return limitUnique(
+    tags.map((tag) => normalizeClaimKeySegment(tag)).filter((tag) => tag.length > 0),
+    8
+  );
+}
+function normalizeSourceContextHint(value) {
+  const trimmed = value?.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  return trimmed.length <= 160 ? trimmed : `${trimmed.slice(0, 157).trimEnd()}...`;
+}
+function isMalformedJsonError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /json|unexpected token|unexpected end|unexpected non-whitespace|unterminated|position \d+/iu.test(message);
+}
+function parsePossessiveClaim(subject) {
+  const match = /^\s*(?<entity>[^.!?\n]+?)[’']s\s+(?<attribute>[^.!?\n]+?)\s*$/iu.exec(subject);
+  if (!match?.groups) {
+    return null;
+  }
+  return {
+    entity: stripTrailingPunctuation(match.groups.entity),
+    attribute: stripTrailingPunctuation(match.groups.attribute)
+  };
+}
+function parsePossessiveStatement(content) {
+  const match = /^\s*(?<entity>[^.!?\n]+?)[’']s\s+(?<attribute>[^.!?\n]+?)\s+(?:is|are|was|were)\b/iu.exec(content);
+  if (!match?.groups) {
+    return null;
+  }
+  return {
+    entity: stripTrailingPunctuation(match.groups.entity),
+    attribute: stripTrailingPunctuation(match.groups.attribute)
+  };
+}
+function stripTrailingPunctuation(value) {
+  return value.trim().replace(/[\s"'“”‘’.,:;!?]+$/gu, "").trim();
+}
+function looksLikeDeterministicAttribute(attribute) {
+  const parts = attribute.split("_").filter((part) => part.length > 0);
+  if (parts.length === 0 || parts.length > 4) {
+    return false;
+  }
+  const head = parts[parts.length - 1];
+  return typeof head === "string" && DETERMINISTIC_ATTRIBUTE_HEADS.has(head);
+}
+function prependUnique(values, value, limit) {
+  return limitUnique([value, ...values], limit);
+}
+function limitUnique(values, limit) {
+  return Array.from(new Set(values.filter((value) => value.length > 0))).slice(0, limit);
+}
+
+export {
+  detectClaimKeyEntityFamilyCandidates,
+  detectClaimKeySingletonAliasCandidates,
+  buildTrustedClaimKeySupportSeed,
+  evaluateClaimKeySupport,
+  evaluateClaimKeyCompactness,
+  normalizeGroundingTags,
+  tokenizeGroundingText,
+  buildDurableLocalLexicalTokens,
+  applyClaimExtractionResultToEntry,
+  previewClaimKeyExtraction,
+  runBatchClaimExtraction,
+  validateSupersessionRules,
+  describeSupersessionRuleFailure,
+  computeContentHash,
+  computeNormContentHash,
+  resolveDurableProjectScope,
+  tryAcquireDreamingRunLock,
+  withDreamingRunLock,
+  withHeldDreamingRunLock,
+  withEpisodeWriteGuard,
+  isEpisodeWriteInProgress
+};