@agenr/agenr-plugin 1.7.4 → 1.8.1

package/dist/{chunk-NXCCTZ4G.js → chunk-O45JQ6O3.js}

@@ -1,37 +1,115 @@
 import {
+  EMBEDDING_DIMENSIONS,
+  ENTRY_SELECT_COLUMNS,
   ENTRY_TYPES,
   EPISODE_ACTIVITY_LEVELS,
   EXPIRY_LEVELS,
-  composeEmbeddingText
-} from "./chunk-NIQKTINU.js";
+  VECTOR_INDEX_NAME,
+  applyClaimKeyLifecycle,
+  buildActiveEntryClause,
+  buildExtractedClaimKeyLifecycle,
+  buildInferredIngestClaimKeySupportContext,
+  buildManualClaimKeyLifecycle,
+  buildPrecomputedClaimKeyLifecycle,
+  composeEmbeddingText,
+  hasPrecomputedClaimKeyLifecycleFields,
+  mapEntryRow,
+  parseClaimKeyConfidence,
+  parseClaimKeySource,
+  parseClaimKeyStatus,
+  parseClaimSupportMode,
+  readNumber,
+  readOptionalString,
+  readRequiredString,
+  validateTemporalValidityRange
+} from "./chunk-LVDQXSHP.js";
 import {
-  parseRelativeDate
-} from "./chunk-7WL5EAQZ.js";
+  compactClaimKey,
+  describeClaimKeyNormalizationFailure,
+  describeExtractedClaimKeyRejection,
+  inspectClaimKey,
+  isTrustedClaimKeyForCleanup,
+  normalizeClaimKey,
+  normalizeClaimKeySegment,
+  parseRelativeDate,
+  resolveClaimSlotPolicy,
+  validateExtractedClaimKey
+} from "./chunk-GUDCFFRV.js";
 
 // src/adapters/openclaw/transcript/parser.ts
 import { createHash } from "crypto";
 import * as fs2 from "fs/promises";
 
+// src/adapters/openclaw/session/session-id.ts
+import path from "path";
+function deriveOpenClawSessionIdFromFilePath(sessionFile, logger) {
+  const normalizedSessionFile = sessionFile.trim();
+  if (normalizedSessionFile.length === 0) {
+    debugLog(logger, "session-id", "cannot derive session id from empty session file path");
+    return void 0;
+  }
+  const fileName = path.basename(normalizedSessionFile);
+  const sessionId = fileName.replace(/\.jsonl(?:\..*)?$/i, "").trim();
+  debugLog(logger, "session-id", `derived session id "${sessionId || "<empty>"}" from file=${normalizedSessionFile}`);
+  return sessionId.length > 0 ? sessionId : void 0;
+}
+function debugLog(logger, subsystem, message) {
+  logger?.debug?.(`[agenr] ${subsystem}: ${message}`);
+}
+
 // src/adapters/openclaw/transcript/jsonl.ts
-function parseJsonlLines(raw, warnings, onRecord) {
+function parseJsonObjectLineWithDiagnostics(line, lineNumber = 1) {
+  if (!line || line.trim().length === 0) {
+    return {
+      record: null
+    };
+  }
+  try {
+    const parsed = JSON.parse(line);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return {
+        record: parsed
+      };
+    }
+    return {
+      record: null,
+      diagnostic: {
+        kind: "non_object_record",
+        lineNumber,
+        message: `Skipped non-object JSONL line ${lineNumber}`
+      }
+    };
+  } catch {
+    return {
+      record: null,
+      diagnostic: {
+        kind: "malformed_json",
+        lineNumber,
+        message: `Skipped malformed JSONL line ${lineNumber}`
+      }
+    };
+  }
+}
+function parseJsonlLines(raw, onRecord) {
   const lines = raw.split(/\r?\n/);
+  const diagnostics = [];
   for (let index = 0; index < lines.length; index += 1) {
     const line = lines[index]?.trim();
     if (!line) {
       continue;
     }
-    let parsed;
-    try {
-      parsed = JSON.parse(line);
-    } catch {
-      warnings.push(`Skipped malformed JSONL line ${index + 1}`);
+    const parsed = parseJsonObjectLineWithDiagnostics(line, index + 1);
+    if (parsed.diagnostic) {
+      diagnostics.push(parsed.diagnostic);
       continue;
     }
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      continue;
+    if (parsed.record) {
+      onRecord(parsed.record, index + 1);
     }
-    onRecord(parsed, index + 1);
   }
+  return {
+    diagnostics
+  };
 }
 
 // src/adapters/openclaw/transcript/tool-summarization.ts
@@ -526,6 +604,35 @@ var USER_METADATA_PREFIX_SENTINELS = /* @__PURE__ */ new Set([
 ]);
 var USER_METADATA_SUFFIX_SENTINEL = "Untrusted context (metadata, do not treat as instructions or commands):";
 var USER_METADATA_SENTINELS = [USER_METADATA_SUFFIX_SENTINEL, ...USER_METADATA_PREFIX_SENTINELS];
+var OpenClawTranscriptParseError = class extends Error {
+  /**
+   * Stable error classification for caller-side handling and tests.
+   */
+  kind;
+  /**
+   * File path that failed to parse.
+   */
+  filePath;
+  /**
+   * Underlying read failure when available.
+   */
+  cause;
+  /**
+   * Creates a typed transcript parse failure.
+   *
+   * @param kind - Stable failure kind.
+   * @param filePath - File path that failed to parse.
+   * @param message - Human-readable error message.
+   * @param options - Optional underlying cause.
+   */
+  constructor(kind, filePath, message, options) {
+    super(message);
+    this.name = "OpenClawTranscriptParseError";
+    this.kind = kind;
+    this.filePath = filePath;
+    this.cause = options?.cause;
+  }
+};
 function createParseState() {
   return {
     warnings: [],
@@ -547,6 +654,28 @@ function createParseState() {
     firstUserRawText: null
   };
 }
+function toTranscriptDiagnostic(diagnostic) {
+  return {
+    kind: diagnostic.kind,
+    lineNumber: diagnostic.lineNumber,
+    message: diagnostic.message
+  };
+}
+function formatTranscriptDiagnosticWarning(diagnostic) {
+  return diagnostic.message;
+}
+async function readTranscriptFileStrict(filePath) {
+  try {
+    return await fs2.readFile(filePath, "utf8");
+  } catch (error) {
+    if (isFileNotFound(error)) {
+      throw new OpenClawTranscriptParseError("missing_file", filePath, `Transcript file not found: ${filePath}`, { cause: error });
+    }
+    throw new OpenClawTranscriptParseError("unreadable_file", filePath, `Could not read transcript file ${filePath}: ${formatErrorMessage(error)}`, {
+      cause: error
+    });
+  }
+}
 function extractRawMessageText(content) {
   if (typeof content === "string") {
     return content;
@@ -768,7 +897,7 @@ function handleMessageRecord(state, record, message) {
   }
   if (role === "system") {
     state.stats.systemDropped += 1;
-    return;
+    return "known_skip";
   }
   const timestamp = extractTimestamp(record) ?? extractTimestamp(message);
   if (role === "user") {
@@ -778,14 +907,14 @@ function handleMessageRecord(state, record, message) {
     }
     const text = stripOpenClawUserMetadata(message.content);
     if (!text) {
-      return;
+      return "known_skip";
     }
     if (isPureBase64(text)) {
       state.stats.base64Dropped += 1;
-      return;
+      return "known_skip";
     }
     pushMessage(state.messages, "user", text, timestamp);
-    return;
+    return "accepted";
   }
   if (role === "assistant") {
     const toolCalls = extractToolCallBlocks(message.content);
@@ -798,48 +927,50 @@ function handleMessageRecord(state, record, message) {
     const assistantText = [...extractAssistantTextParts(message.content), ...toolCalls.map((toolCall) => summarizeToolCall(toolCall))].join(" ").trim();
     addModelUsed(state, message.model);
     if (!assistantText) {
-      return;
+      return "known_skip";
     }
     if (isPureBase64(assistantText)) {
       state.stats.base64Dropped += 1;
-      return;
+      return "known_skip";
     }
     pushMessage(state.messages, "assistant", truncateWithMarker(assistantText, 5e3), timestamp);
-    return;
+    return "accepted";
   }
   if (role !== "toolResult") {
-    return;
+    return "structurally_invalid";
   }
   const toolContext = resolveToolContext(state, message);
   const toolName = getString(message.name) ?? getString(message.tool) ?? getString(record.name) ?? getString(record.tool) ?? toolContext?.name;
   const toolArgs = toolContext?.args ?? {};
   const toolText = normalizeMessageText(message.content);
   if (!toolText) {
-    return;
+    return "known_skip";
   }
   if (isPureBase64(toolText)) {
     state.stats.base64Dropped += 1;
-    return;
+    return "known_skip";
   }
   const decision = shouldKeepToolResult(toolName, toolText, TOOL_RESULT_POLICY);
   if (decision.keep) {
     state.stats.toolResultsKept += 1;
     pushMessage(state.messages, "assistant", decision.truncateTo ? truncateWithMarker(toolText, decision.truncateTo) : toolText, timestamp);
-    return;
+    return "accepted";
   }
   state.stats.toolResultsDropped += 1;
   pushMessage(state.messages, "assistant", toolResultPlaceholder(toolName ?? "unknown", toolArgs), timestamp);
+  return "accepted";
 }
 function handleRecord(state, record) {
   if (record.type === "session") {
     state.sessionId = getString(record.id) ?? state.sessionId;
     state.sessionTimestamp = extractTimestamp(record) ?? state.sessionTimestamp;
     state.sessionLabel = normalizeSessionLabel(getString(record.conversation_label) ?? "") ?? state.sessionLabel;
+    state.workingDirectory = getString(record.cwd) ?? state.workingDirectory;
     addModelUsed(state, record.model);
     if (!state.surfaceDetected) {
       setDetectedSurface(state, readInboundSurface(record));
     }
-    return;
+    return "accepted";
   }
   if (!state.surfaceDetected) {
     setDetectedSurface(state, readInboundSurface(record));
@@ -847,21 +978,30 @@ function handleRecord(state, record) {
   if (record.type === "model_change") {
     addModelUsed(state, record.modelId);
     state.stats.skippedRecordTypes += 1;
-    return;
+    return "known_skip";
   }
   if (typeof record.type === "string" && SKIPPED_RECORD_TYPES.has(record.type)) {
     state.stats.skippedRecordTypes += 1;
-    return;
+    return "known_skip";
   }
   const message = asRecord(record.message);
   if (!message) {
-    return;
+    return "structurally_invalid";
   }
-  handleMessageRecord(state, record, message);
+  return handleMessageRecord(state, record, message);
 }
 function buildFilterWarning(stats) {
   return `Filtered transcript: ${stats.toolResultsDropped} tool results dropped, ${stats.toolResultsKept} kept, ${stats.systemDropped} system dropped, ${stats.base64Dropped} base64 dropped.`;
 }
+function isFileNotFound(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function formatErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
 var OpenClawTranscriptParser = class {
   /**
    * Parses an OpenClaw JSONL transcript file into agenr transcript data.
@@ -871,13 +1011,23 @@ var OpenClawTranscriptParser = class {
    * @returns Parsed transcript messages, warnings, and metadata.
    */
   async parseFile(filePath, options) {
-    const raw = await fs2.readFile(filePath, "utf8");
+    const raw = await readTranscriptFileStrict(filePath);
     const verbose = options?.verbose === true;
     const state = createParseState();
     const transcriptHash = createHash("sha256").update(raw).digest("hex");
-    parseJsonlLines(raw, state.warnings, (record) => {
-      handleRecord(state, record);
+    const diagnostics = [];
+    const jsonlResult = parseJsonlLines(raw, (record, lineNumber) => {
+      const outcome = handleRecord(state, record);
+      if (outcome === "structurally_invalid") {
+        diagnostics.push({
+          kind: "structurally_invalid_record",
+          lineNumber,
+          message: `Skipped structurally invalid transcript record on line ${lineNumber}`
+        });
+      }
     });
+    diagnostics.push(...jsonlResult.diagnostics.map(toTranscriptDiagnostic));
+    state.warnings.push(...diagnostics.map(formatTranscriptDiagnosticWarning));
     if (!state.surfaceDetected && state.firstUserRawText) {
       setDetectedSurface(state, inferSurfaceFromContent(state.firstUserRawText));
     }
@@ -887,6 +1037,7 @@ var OpenClawTranscriptParser = class {
     }
     const startedAt = state.sessionTimestamp ?? state.messages[0]?.timestamp ?? fallbackTimestamp;
     const endedAt = state.messages[state.messages.length - 1]?.timestamp ?? state.sessionTimestamp ?? fallbackTimestamp;
+    const stableSessionId = state.sessionId ?? deriveOpenClawSessionIdFromFilePath(filePath);
     return {
       messages: state.messages,
       warnings: state.warnings,
@@ -899,515 +1050,1446 @@ var OpenClawTranscriptParser = class {
         transcriptHash,
         modelsUsed: state.modelsUsed.length > 0 ? state.modelsUsed : void 0,
         reconstructedSurface: state.detectedSurface,
-        surfaceReconstructionSource: state.surfaceDetected ? "reconstructed" : "none"
+        surfaceReconstructionSource: state.surfaceDetected ? "reconstructed" : "none",
+        sourceIdentity: stableSessionId ? `openclaw-session:${stableSessionId}` : void 0,
+        sourceIdentityKind: stableSessionId ? "openclaw_session" : void 0,
+        workingDirectory: state.workingDirectory
       }
     };
   }
 };
 var openClawTranscriptParser = new OpenClawTranscriptParser();
 
-// src/core/claim-key.ts
-var UNKNOWN_SEGMENT = "unknown";
-var SELF_REFERENTIAL_ENTITIES = /* @__PURE__ */ new Set(["i", "me", "myself", "the_user", "user", "we", "our_team", "the_project", "this_project"]);
-var GENERIC_ENTITIES = /* @__PURE__ */ new Set([
+// src/adapters/db/openclaw-repository.ts
+var ZERO_VECTOR = JSON.stringify(Array.from({ length: EMBEDDING_DIMENSIONS }, () => 0));
+function createOpenClawRepository(executor, options = {}) {
+  return {
+    listCoreEntries: async (limit) => listCoreEntries(executor, limit),
+    findEntryBySubject: async (subject) => findEntryBySubject(executor, subject),
+    findMostRecentEntry: async () => findMostRecentEntry(executor),
+    getEntryTrace: async (entryId) => getEntryTrace(executor, entryId, options.claimSlotPolicyConfig),
+    getMemoryStatusSnapshot: async () => getMemoryStatusSnapshot(executor),
+    probeVectorAvailability: async () => probeVectorAvailability(executor)
+  };
+}
+async function listCoreEntries(executor, limit) {
+  if (limit <= 0) {
+    return [];
+  }
+  const result = await executor.execute({
+    sql: `
+      SELECT
+        ${ENTRY_SELECT_COLUMNS}
+      FROM entries
+      WHERE ${buildActiveEntryClause()}
+        AND expiry = 'core'
+      ORDER BY importance DESC, created_at DESC
+      LIMIT ?
+    `,
+    args: [limit]
+  });
+  return result.rows.map((row) => mapEntryRow(row));
+}
+async function findEntryBySubject(executor, subject) {
+  const normalizedSubject = subject.trim();
+  if (normalizedSubject.length === 0) {
+    return null;
+  }
+  const result = await executor.execute({
+    sql: `
+      SELECT
+        ${ENTRY_SELECT_COLUMNS},
+        CASE
+          WHEN lower(subject) = lower(?) THEN 0
+          WHEN lower(subject) LIKE lower(?) THEN 1
+          ELSE 2
+        END AS match_rank
+      FROM entries
+      WHERE lower(subject) = lower(?)
+         OR lower(subject) LIKE lower(?)
+      ORDER BY match_rank ASC, created_at DESC
+      LIMIT 1
+    `,
+    args: [normalizedSubject, `%${normalizedSubject}%`, normalizedSubject, `%${normalizedSubject}%`]
+  });
+  const row = result.rows[0];
+  return row ? mapEntryRow(row) : null;
+}
+async function findMostRecentEntry(executor) {
+  const result = await executor.execute({
+    sql: `
+      SELECT
+        ${ENTRY_SELECT_COLUMNS}
+      FROM entries
+      ORDER BY created_at DESC
+      LIMIT 1
+    `
+  });
+  const row = result.rows[0];
+  return row ? mapEntryRow(row) : null;
+}
+async function getEntryTrace(executor, entryId, claimSlotPolicyConfig) {
+  const entry = await getEntryByIdIncludingInactive(executor, entryId);
+  if (!entry) {
+    return null;
+  }
+  const [supersededBy, supersedes, claimFamily, recallEvents] = await Promise.all([
+    entry.superseded_by ? getEntryByIdIncludingInactive(executor, entry.superseded_by) : Promise.resolve(null),
+    listSupersededEntries(executor, entry.id),
+    entry.claim_key ? getClaimFamily(executor, entry.claim_key, claimSlotPolicyConfig) : Promise.resolve(void 0),
+    listRecallEvents(executor, entry.id)
+  ]);
+  return {
+    entry,
+    ...supersededBy ? { supersededBy } : {},
+    supersedes,
+    ...claimFamily ? { claimFamily } : {},
+    recallEvents
+  };
+}
+async function getMemoryStatusSnapshot(executor) {
+  const result = await executor.execute({
+    sql: `
+      SELECT
+        COUNT(*) AS active_entries,
+        SUM(CASE WHEN expiry = 'core' THEN 1 ELSE 0 END) AS core_entries,
+        COUNT(DISTINCT source_file) AS source_files
+      FROM entries
+      WHERE ${buildActiveEntryClause()}
+    `
+  });
+  const row = result.rows[0];
+  if (!row) {
+    return {
+      activeEntries: 0,
+      coreEntries: 0,
+      sourceFiles: 0
+    };
+  }
+  return {
+    activeEntries: readNumber(row, "active_entries", 0),
+    coreEntries: readNumber(row, "core_entries", 0),
+    sourceFiles: readNumber(row, "source_files", 0)
+  };
+}
+async function probeVectorAvailability(executor) {
+  try {
+    await executor.execute({
+      sql: `
+        SELECT COUNT(*) AS matches
+        FROM vector_top_k('${VECTOR_INDEX_NAME}', vector32(?), ?) AS matches
+      `,
+      args: [ZERO_VECTOR, 1]
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getEntryByIdIncludingInactive(executor, entryId) {
+  const normalizedId = entryId.trim();
+  if (normalizedId.length === 0) {
+    return null;
+  }
+  const result = await executor.execute({
+    sql: `
+      SELECT
+        ${ENTRY_SELECT_COLUMNS}
+      FROM entries
+      WHERE id = ?
+      LIMIT 1
+    `,
+    args: [normalizedId]
+  });
+  const row = result.rows[0];
+  return row ? mapEntryRow(row) : null;
+}
+async function listSupersededEntries(executor, entryId) {
+  const result = await executor.execute({
+    sql: `
+      SELECT
+        ${ENTRY_SELECT_COLUMNS}
+      FROM entries
+      WHERE superseded_by = ?
+      ORDER BY created_at DESC
+    `,
+    args: [entryId]
+  });
+  return result.rows.map((row) => mapEntryRow(row));
+}
+async function getClaimFamily(executor, claimKey, claimSlotPolicyConfig) {
+  const normalizedClaimKey = claimKey.trim();
+  if (normalizedClaimKey.length === 0) {
+    return void 0;
+  }
+  const result = await executor.execute({
+    sql: `
+      SELECT
+        ${ENTRY_SELECT_COLUMNS}
+      FROM entries
+      WHERE claim_key = ?
+      ORDER BY created_at ASC, id ASC
+    `,
+    args: [normalizedClaimKey]
+  });
+  const entries = result.rows.map((row) => mapEntryRow(row));
+  const slotPolicy = resolveClaimSlotPolicy(normalizedClaimKey, claimSlotPolicyConfig);
+  return {
+    claimKey: normalizedClaimKey,
+    slotPolicy: slotPolicy.policy,
+    slotPolicyReason: slotPolicy.reason,
+    entries
+  };
+}
+async function listRecallEvents(executor, entryId) {
+  const result = await executor.execute({
+    sql: `
+      SELECT
+        query,
+        session_key,
+        recalled_at
+      FROM recall_events
+      WHERE entry_id = ?
+      ORDER BY recalled_at DESC
+      LIMIT 10
+    `,
+    args: [entryId]
+  });
+  return result.rows.map((row) => ({
+    query: readOptionalString(row, "query"),
+    sessionKey: readOptionalString(row, "session_key"),
+    recalledAt: readRequiredString(row, "recalled_at")
+  }));
+}
+
+// src/core/store/pipeline.ts
+import { randomUUID } from "crypto";
+
+// 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/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",
-  "company",
-  "config",
-  "data",
+  "branch",
+  "build",
+  "cluster",
+  "daemon",
   "device",
-  "entity",
+  "env",
   "environment",
-  "item",
-  "organization",
-  "person",
-  "place",
+  "gateway",
+  "host",
+  "machine",
+  "node",
+  "plugin",
   "project",
+  "repo",
+  "repository",
+  "server",
   "service",
-  "setting",
+  "session",
   "system",
-  "team",
-  "thing",
-  "user",
   "workspace"
 ]);
-var GENERIC_ATTRIBUTES = /* @__PURE__ */ new Set(["info", "details", "config", "stuff", "thing", "data"]);
-var COMPACTION_RELATION_TOKENS = /* @__PURE__ */ new Set([
-  "after",
-  "before",
-  "depend",
-  "depends",
-  "follows",
-  "follow",
-  "keep",
-  "keeps",
-  "maintain",
-  "maintains",
-  "need",
-  "needs",
-  "precede",
-  "precedes",
-  "preserve",
-  "preserves",
-  "require",
-  "required",
-  "requires",
-  "retain",
-  "retains"
-]);
-var COMPACTION_BREAK_TOKENS = /* @__PURE__ */ new Set(["about", "across", "and", "between", "during", "for", "from", "into", "onto", "or", "to", "with"]);
-var COMPACTION_WEAK_LEADING_TOKENS = /* @__PURE__ */ new Set(["actual", "authoritative", "canonical", "concrete", "current", "durable", "existing", "real"]);
-var ACTION_CONDITION_TOKENS = /* @__PURE__ */ new Set(["activate", "activation", "apply", "fire", "launch", "run", "start", "trigger"]);
-var TRAILING_OBJECT_COMPACTION_PREPOSITIONS = /* @__PURE__ */ new Set(["about", "for", "from", "into", "onto", "to", "with"]);
-var TRAILING_OBJECT_TRANSFER_HEADS = /* @__PURE__ */ new Set([
-  "access",
-  "boundary",
-  "condition",
-  "contract",
-  "guide",
-  "path",
-  "policy",
-  "preference",
-  "process",
-  "rule",
-  "schedule",
-  "support",
-  "surface",
-  "window",
-  "workflow"
-]);
-var STABLE_ATTRIBUTE_HEADS = /* @__PURE__ */ new Set([
-  "access",
-  "boundary",
-  "condition",
-  "contract",
-  "default",
-  "dependency",
-  "guide",
-  "mode",
-  "order",
-  "path",
-  "policy",
-  "preference",
-  "preservation",
-  "process",
-  "requirement",
-  "rule",
-  "schedule",
-  "setting",
-  "status",
-  "strategy",
-  "support",
-  "surface",
-  "timezone",
-  "truth",
-  "version",
-  "window",
-  "workflow"
-]);
-function normalizeClaimKeySegment(value) {
-  return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
-}
-function normalizeClaimKey(value) {
-  const trimmed = value.trim();
-  if (trimmed.length === 0) {
-    return { ok: false, reason: "empty" };
+function detectClaimKeyEntityFamilyCandidates(entries) {
+  const profiles = buildTrustedClaimKeyEntityProfiles(entries);
+  if (profiles.size < 2) {
+    return [];
   }
-  const slashCount = Array.from(trimmed).filter((character) => character === "/").length;
-  if (slashCount === 0) {
-    return { ok: false, reason: "missing_separator" };
+  const pairSupport = buildPairSupport(profiles);
+  if (pairSupport.length === 0) {
+    return [];
   }
-  if (slashCount !== 1) {
-    return { ok: false, reason: "too_many_segments" };
+  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 [rawEntity = "", rawAttribute = ""] = trimmed.split("/");
-  const entity = normalizeClaimKeySegment(rawEntity);
-  if (entity.length === 0) {
-    return { ok: false, reason: "empty_entity" };
+  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 entryIds = normalizeStringArray(componentProfiles.flatMap((profile) => [...profile.entryIds]));
+    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)),
+      entryIds,
+      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);
+      })
+    });
   }
-  const attribute = normalizeClaimKeySegment(rawAttribute);
-  if (attribute.length === 0) {
-    return { ok: false, reason: "empty_attribute" };
+  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;
+    }
+    const entityPrefix = inspection.normalized.entity;
+    const existing = counts.get(entityPrefix) ?? {
+      entityPrefix,
+      activeEntryCount: 0,
+      trustedEntryCount: 0,
+      tentativeEntryCount: 0,
+      unresolvedEntryCount: 0,
+      legacyEntryCount: 0,
+      deterministicRepairEntryCount: 0,
+      manualEntryCount: 0,
+      modelEntryCount: 0,
+      jsonRetryEntryCount: 0,
+      surgeonFamilyReuseEntryCount: 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;
+      default:
+        existing.legacyEntryCount += 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 "surgeon_family_reuse":
+        existing.surgeonFamilyReuseEntryCount += 1;
+        break;
+      default:
+        break;
+    }
+    counts.set(entityPrefix, existing);
   }
-  if (entity === UNKNOWN_SEGMENT && attribute === UNKNOWN_SEGMENT) {
-    return { ok: false, reason: "unknown_pair" };
+  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 {
-    ok: true,
-    value: {
-      claimKey: `${entity}/${attribute}`,
-      entity,
-      attribute
+  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.entryIds.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,
+    entryIds: /* @__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 compactClaimKey(claimKey) {
-  const normalized = normalizeClaimKey(claimKey);
-  if (!normalized.ok) {
+function evaluateEntityFamilyPairSupport(leftProfile, rightProfile) {
+  const sharedAttributes = intersectSets(leftProfile.attributeSet, rightProfile.attributeSet);
+  if (sharedAttributes.length === 0) {
     return null;
   }
-  let attributeTokens = normalized.value.attribute.split("_").filter((token) => token.length > 0);
-  const entityTokens = normalized.value.entity.split("_").filter((token) => token.length > 0);
-  const reasons = [];
-  if (entityTokens.length > 0 && startsWithTokens(attributeTokens, entityTokens) && attributeTokens.length > entityTokens.length) {
-    attributeTokens = attributeTokens.slice(entityTokens.length);
-    reasons.push("removed duplicated entity prefix from attribute");
-  }
-  if (entityTokens.length > 0 && attributeTokens.length > entityTokens.length + 1 && endsWithTokens(attributeTokens, entityTokens) && TRAILING_OBJECT_COMPACTION_PREPOSITIONS.has(attributeTokens[attributeTokens.length - entityTokens.length - 1] ?? "")) {
-    attributeTokens = attributeTokens.slice(0, attributeTokens.length - entityTokens.length - 1);
-    reasons.push("removed duplicated entity suffix from attribute");
-  }
-  const sourceOfTruthCompaction = compactSourceOfTruthAttribute(attributeTokens);
-  if (sourceOfTruthCompaction) {
-    attributeTokens = sourceOfTruthCompaction.attributeTokens;
-    reasons.push(sourceOfTruthCompaction.reason);
-  } else {
-    const relationCompaction = compactRelationAttribute(attributeTokens);
-    if (relationCompaction) {
-      attributeTokens = relationCompaction.attributeTokens;
-      reasons.push(relationCompaction.reason);
-    } else {
-      const trailingObjectCompaction = compactTrailingObjectAttribute(attributeTokens);
-      if (trailingObjectCompaction) {
-        attributeTokens = trailingObjectCompaction.attributeTokens;
-        reasons.push(trailingObjectCompaction.reason);
-      }
+  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(", ")}`
+    });
   }
-  const attribute = attributeTokens.join("_");
-  if (attribute.length === 0) {
-    return {
-      claimKey: normalized.value.claimKey,
-      entity: normalized.value.entity,
-      attribute: normalized.value.attribute,
-      compactedFrom: null,
-      reason: null
-    };
+  if (sharedTags.length > 0) {
+    evidence.push({
+      kind: "shared_tag_grounding",
+      detail: `Shared tags: ${sharedTags.slice(0, MAX_EVIDENCE_VALUES).join(", ")}`
+    });
   }
-  const compactedClaimKey = `${normalized.value.entity}/${attribute}`;
+  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 {
-    claimKey: compactedClaimKey,
-    entity: normalized.value.entity,
-    attribute,
-    compactedFrom: compactedClaimKey !== normalized.value.claimKey ? normalized.value.claimKey : null,
-    reason: reasons.length > 0 ? joinCompactionReasons(reasons) : null
+    entityPrefixes: [leftProfile.entityPrefix, rightProfile.entityPrefix],
+    supportingEntryIds: normalizeStringArray([...leftProfile.entryIds, ...rightProfile.entryIds]),
+    sharedAttributes,
+    confidence,
+    autoSafe: lexicalRelation.autoSafe && (sharedAttributes.length >= 2 || sharedAttributes.length === 1 && groundingAnchorCount >= 1 && groundingScore >= 2),
+    preferredCanonicalEntityPrefix: lexicalRelation.preferredCanonicalEntityPrefix,
+    evidence
   };
 }
-function validateExtractedClaimKey(claimKey) {
-  if (SELF_REFERENTIAL_ENTITIES.has(claimKey.entity)) {
+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 {
-      ok: false,
-      reason: "self_referential_entity",
-      value: claimKey
+      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 (GENERIC_ATTRIBUTES.has(claimKey.attribute)) {
+  if (leftProfile.sortedTokenSignature.length > 0 && leftProfile.sortedTokenSignature === rightProfile.sortedTokenSignature && leftProfile.entityPrefix !== rightProfile.entityPrefix) {
     return {
-      ok: false,
-      reason: "generic_attribute",
-      value: claimKey
+      kind: "lexical_token_reordering",
+      detail: "Entity prefixes use the same lexical tokens in a different order.",
+      autoSafe: true,
+      preferredCanonicalEntityPrefix: null,
+      strengthScore: 2
     };
   }
-  if (isValueShapedAttribute(claimKey.attribute)) {
+  const leftInitialism = buildInitialism(leftTokens);
+  const rightInitialism = buildInitialism(rightTokens);
+  if (leftInitialism.length >= 2 && leftInitialism === rightProfile.entityPrefix) {
     return {
-      ok: false,
-      reason: "value_shaped_attribute",
-      value: claimKey
+      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 {
-    ok: true,
-    value: claimKey
+    kind: null,
+    detail: null,
+    autoSafe: false,
+    preferredCanonicalEntityPrefix: null,
+    strengthScore: 0
   };
 }
-function inspectClaimKey(value) {
-  const rawClaimKey = value.trim();
-  const normalized = normalizeClaimKey(rawClaimKey);
-  if (!normalized.ok) {
+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 {
-      rawClaimKey,
-      canonical: false,
-      normalizationFailure: normalized.reason,
-      suspectReasons: []
+      canonicalEntityPrefix: null,
+      reasons: [],
+      unresolvedReason: "No canonical entity prefix could be selected from the detected family."
     };
   }
-  const suspectReasons = /* @__PURE__ */ new Set();
-  const validation = validateExtractedClaimKey(normalized.value);
-  if (!validation.ok) {
-    suspectReasons.add(validation.reason);
+  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."
+    };
   }
-  if (GENERIC_ENTITIES.has(normalized.value.entity)) {
-    suspectReasons.add("generic_entity");
+  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 {
-    rawClaimKey,
-    canonical: normalized.value.claimKey === rawClaimKey,
-    normalized: normalized.value,
-    suspectReasons: [...suspectReasons]
+    canonicalEntityPrefix: bestEntityPrefix,
+    reasons: reasonsByEntity.get(bestEntityPrefix) ?? [],
+    unresolvedReason: null
   };
 }
-function isTrustedClaimKeyForCleanup(value) {
-  const inspection = inspectClaimKey(value);
-  return Boolean(inspection.canonical && inspection.normalized && inspection.suspectReasons.length === 0);
-}
-function describeClaimKeyNormalizationFailure(reason) {
-  switch (reason) {
-    case "empty":
-      return "claim key was empty";
-    case "missing_separator":
-      return "claim key must contain exactly one '/'";
-    case "too_many_segments":
-      return "claim key must contain exactly one '/'";
-    case "empty_entity":
-      return "claim key entity was empty after normalization";
-    case "empty_attribute":
-      return "claim key attribute was empty after normalization";
-    case "unknown_pair":
-      return 'claim key "unknown/unknown" is not allowed';
-  }
-}
-function describeExtractedClaimKeyRejection(reason, claimKey) {
-  switch (reason) {
-    case "self_referential_entity":
-      return `entity "${claimKey.entity}" is self-referential`;
-    case "generic_attribute":
-      return `attribute "${claimKey.attribute}" is too generic`;
-    case "value_shaped_attribute":
-      return `attribute "${claimKey.attribute}" looks value-shaped`;
+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 describeClaimKeySuspicion(reason, claimKey) {
-  switch (reason) {
-    case "generic_entity":
-      return `entity "${claimKey.entity}" is too generic`;
-    case "self_referential_entity":
-    case "generic_attribute":
-    case "value_shaped_attribute":
-      return describeExtractedClaimKeyRejection(reason, claimKey);
+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 isValueShapedAttribute(attribute) {
-  return /^\d+(?:_\d+)*$/u.test(attribute) || /^v\d+(?:_\d+)*$/u.test(attribute);
-}
-function compactSourceOfTruthAttribute(attributeTokens) {
-  const sourceOfTruthIndex = findSourceOfTruthPhraseIndex(attributeTokens);
-  if (sourceOfTruthIndex === -1) {
+function evaluateSingletonAliasCandidate(aliasProfile, dominantProfile) {
+  const lexicalRelation = evaluateSingletonAliasLexicalRelation(aliasProfile.entityPrefix, dominantProfile.entityPrefix);
+  if (!lexicalRelation.kind || !lexicalRelation.detail || lexicalRelation.scopeLike) {
     return null;
   }
-  const normalizedPhrase = ["source", "of", "truth"];
-  if (attributeTokens.length === normalizedPhrase.length && startsWithTokens(attributeTokens, normalizedPhrase)) {
+  const dominantTrustedCount = dominantProfile.trustedEntryCount;
+  if (dominantTrustedCount < SINGLETON_ALIAS_MIN_DOMINANT_TRUSTED_COUNT) {
     return null;
   }
-  const before = attributeTokens.slice(0, sourceOfTruthIndex);
-  const after = attributeTokens.slice(sourceOfTruthIndex + normalizedPhrase.length);
-  const leadingAllowed = before.every((token) => COMPACTION_WEAK_LEADING_TOKENS.has(token));
-  const hasMixedStableFamily = before.some((token) => STABLE_ATTRIBUTE_HEADS.has(token)) || after.some((token) => STABLE_ATTRIBUTE_HEADS.has(token));
-  const hasConjunctionNoise = before.includes("and") || before.includes("or") || after.includes("and") || after.includes("or");
-  if (!leadingAllowed || hasMixedStableFamily || hasConjunctionNoise) {
+  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 {
-    attributeTokens: normalizedPhrase,
-    reason: "collapsed source-of-truth phrasing into the stable canonical slot"
+    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 compactRelationAttribute(attributeTokens) {
-  const relationIndex = attributeTokens.findIndex((token) => COMPACTION_RELATION_TOKENS.has(token));
-  if (relationIndex === -1) {
-    return null;
+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 [];
   }
-  const relation = attributeTokens[relationIndex] ?? "";
-  const left = attributeTokens.slice(0, relationIndex);
-  const right = attributeTokens.slice(relationIndex + 1);
-  if (left.length === 0 && right.length === 0) {
-    return null;
+  if (runnerUp && best.confidence - runnerUp.confidence < SINGLETON_ALIAS_MIN_CONFIDENCE_DELTA) {
+    return [];
   }
-  if (isRequirementRelation(relation)) {
-    const conditionAction = extractConditionAction(right);
-    if (conditionAction) {
-      return {
-        attributeTokens: [conditionAction, "condition"],
-        reason: `collapsed a sentence-like ${conditionAction} requirement into a stable condition slot`
-      };
-    }
-    const requirementFocus = extractCompactionFocus(right, 2) ?? extractCompactionFocus(left, 2);
-    if (!requirementFocus) {
-      return null;
-    }
+  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 {
-      attributeTokens: [...requirementFocus, "requirement"],
-      reason: "collapsed a sentence-like requirement phrase into a stable requirement slot"
+      kind: "lexical_separator_variant",
+      detail: `Entity prefixes "${aliasEntityPrefix}" and "${dominantEntityPrefix}" collapse to the same compact lexical form.`,
+      canonicalReuseSafe: true,
+      scopeLike: false,
+      strengthScore: 3
     };
   }
-  if (isOrderingRelation(relation)) {
-    const orderingFocus = extractCompactionFocus(right, 2) ?? extractCompactionFocus(left, 2);
-    if (!orderingFocus) {
-      return null;
-    }
+  if (!isTokenSubset(dominantTokens, aliasTokens)) {
     return {
-      attributeTokens: [...orderingFocus, "order"],
-      reason: "collapsed a sentence-like ordering phrase into a stable order slot"
+      kind: null,
+      detail: null,
+      canonicalReuseSafe: false,
+      scopeLike: false,
+      strengthScore: 0
     };
   }
-  if (isPreservationRelation(relation)) {
-    const preservationFocus = extractCompactionFocus(right, 2) ?? extractCompactionFocus(left, 2);
-    if (!preservationFocus) {
-      return null;
-    }
+  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 {
-      attributeTokens: [...preservationFocus, "preservation"],
-      reason: "collapsed a sentence-like preservation phrase into a stable preservation slot"
+      kind: null,
+      detail: null,
+      canonicalReuseSafe: false,
+      scopeLike: true,
+      strengthScore: 0
     };
   }
-  return null;
+  return {
+    kind: "lexical_token_subset",
+    detail: `"${aliasEntityPrefix}" extends "${dominantEntityPrefix}" by the added token "${addedTokens[0]}".`,
+    canonicalReuseSafe: true,
+    scopeLike: false,
+    strengthScore: 2
+  };
 }
-function compactTrailingObjectAttribute(attributeTokens) {
-  const prepositionIndex = attributeTokens.findIndex((token) => TRAILING_OBJECT_COMPACTION_PREPOSITIONS.has(token));
-  if (prepositionIndex <= 0 || prepositionIndex >= attributeTokens.length - 1) {
-    return null;
+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")}`);
   }
-  const left = trimWeakLeadingTokens(attributeTokens.slice(0, prepositionIndex));
-  const right = attributeTokens.slice(prepositionIndex + 1);
-  if (left.length === 0 || left.length > 3 || left.includes("and") || left.includes("or") || left.some((token) => COMPACTION_RELATION_TOKENS.has(token))) {
-    return null;
+  if (profile.tentativeEntryCount > 0) {
+    reasons.push(`${profile.tentativeEntryCount} tentative ${pluralize(profile.tentativeEntryCount, "entry")}`);
   }
-  const head = left[left.length - 1];
-  if (!head || !TRAILING_OBJECT_TRANSFER_HEADS.has(head)) {
-    return null;
+  if (profile.unresolvedEntryCount > 0) {
+    reasons.push(`${profile.unresolvedEntryCount} unresolved ${pluralize(profile.unresolvedEntryCount, "entry")}`);
   }
-  const objectFocus = extractCompactionFocus(right, 2);
-  if (!objectFocus) {
-    return null;
+  if (reasons.length === 0) {
+    return `"${profile.entityPrefix}" is not fully trusted yet.`;
   }
-  const headCore = extractStableHeadCore(left, 2);
-  if (!headCore) {
-    return null;
+  return `"${profile.entityPrefix}" is low-trust because it has ${reasons.join(", ")}.`;
+}
+function buildInitialism(tokens) {
+  if (tokens.length < 2) {
+    return "";
   }
-  return {
-    attributeTokens: [...objectFocus, ...headCore],
-    reason: "collapsed a trailing object phrase into a compact stable slot name"
-  };
+  return tokens.map((token) => token[0] ?? "").join("");
 }
-function findSourceOfTruthPhraseIndex(tokens) {
-  for (let index = 0; index <= tokens.length - 3; index += 1) {
-    if (tokens[index] === "source" && tokens[index + 1] === "of" && tokens[index + 2] === "truth") {
-      return index;
-    }
+function isTokenSubset(subsetTokens, supersetTokens) {
+  if (subsetTokens.length === 0 || subsetTokens.length >= supersetTokens.length) {
+    return false;
   }
-  return -1;
+  const superset = new Set(supersetTokens);
+  return subsetTokens.every((token) => superset.has(token));
 }
-function extractConditionAction(tokens) {
-  for (let index = tokens.length - 1; index >= 0; index -= 1) {
-    const token = tokens[index];
-    if (token && ACTION_CONDITION_TOKENS.has(token)) {
-      return token;
-    }
+function tokenizeGrounding(value) {
+  if (!value) {
+    return [];
   }
-  return null;
+  const normalized = normalizeClaimKeySegment(value);
+  if (!normalized) {
+    return [];
+  }
+  return normalized.split("_").filter((token) => token.length >= 2 && !ENTITY_FAMILY_GROUNDING_STOP_TOKENS.has(token));
 }
-function extractCompactionFocus(tokens, limit) {
-  const compactable = trimWeakLeadingTokens(tokens).filter((token) => token.length > 0);
-  const segments = splitTokensOnBreaks(compactable).filter((segment) => segment.length > 0);
-  const preferredSegment = segments[0];
-  if (!preferredSegment || preferredSegment.length === 0) {
-    return null;
+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 preferredSegment.slice(0, limit);
+  return intersection.sort((first, second) => first.localeCompare(second));
 }
-function extractStableHeadCore(tokens, limit) {
-  const compactable = trimWeakLeadingTokens(tokens).filter((token) => token.length > 0);
-  const head = compactable[compactable.length - 1];
-  if (!head || !STABLE_ATTRIBUTE_HEADS.has(head)) {
-    return null;
+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;
   }
-  return compactable.slice(Math.max(0, compactable.length - limit));
+  const created = /* @__PURE__ */ new Set();
+  map.set(key, created);
+  return created;
 }
-function splitTokensOnBreaks(tokens) {
-  const segments = [];
-  let current = [];
-  for (const token of tokens) {
-    if (COMPACTION_BREAK_TOKENS.has(token)) {
-      if (current.length > 0) {
-        segments.push(current);
-        current = [];
-      }
+function pluralize(count, noun) {
+  return count === 1 ? noun : `${noun}s`;
+}
+
+// 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;
     }
-    current.push(token);
-  }
-  if (current.length > 0) {
-    segments.push(current);
+    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
+    });
   }
-  return segments;
+  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 trimWeakLeadingTokens(tokens) {
-  let start = 0;
-  while (start < tokens.length && COMPACTION_WEAK_LEADING_TOKENS.has(tokens[start] ?? "")) {
-    start += 1;
-  }
-  return tokens.slice(start);
+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 joinCompactionReasons(reasons) {
-  if (reasons.length <= 1) {
-    return reasons[0] ?? "";
+function evaluateClaimKeySupport(entry, targetClaimKey, trustedHints) {
+  const inspection = inspectClaimKey(targetClaimKey);
+  const normalized = inspection.normalized;
+  if (!normalized) {
+    return createEmptyClaimKeySupportEvaluation();
   }
-  return `${reasons.slice(0, -1).join(", ")} and ${reasons[reasons.length - 1]}`;
+  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,
+    supportingEntryIds: 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 isRequirementRelation(token) {
-  return token === "depend" || token === "depends" || token === "need" || token === "needs" || token === "required" || token === "require" || token === "requires";
+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,
+    supportingEntryIds: [],
+    supportEvidence: [],
+    rationaleFragments: []
+  };
 }
-function isOrderingRelation(token) {
-  return token === "after" || token === "before" || token === "follow" || token === "follows" || token === "precede" || token === "precedes";
+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 isPreservationRelation(token) {
-  return token === "keep" || token === "keeps" || token === "maintain" || token === "maintains" || token === "preserve" || token === "preserves" || token === "retain" || token === "retains";
+function normalizeGroundingTags(tags) {
+  return normalizeStringArray2((tags ?? []).map((tag) => normalizeClaimKeySegment(tag)).filter((tag) => tag.length > 0));
 }
-function startsWithTokens(tokens, prefix) {
-  return prefix.every((token, index) => tokens[index] === token);
+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 endsWithTokens(tokens, suffix) {
-  return suffix.every((token, index) => tokens[tokens.length - suffix.length + index] === token);
+function buildEntryLocalLexicalTokens(entry) {
+  return normalizeStringArray2([
+    ...tokenizeGroundingText(entry.subject),
+    ...tokenizeGroundingText(entry.content),
+    ...tokenizeGroundingText(entry.source_context),
+    ...normalizeGroundingTags(entry.tags)
+  ]);
 }
-
-// src/core/store/pipeline.ts
-import { randomUUID } from "crypto";
-
-// src/core/supersession.ts
-function validateSupersessionRules(oldEntry, newEntry) {
-  if (oldEntry.type !== newEntry.type) {
+function resolveClaimKeyPromotionSupport(input) {
+  if (input.exactReuseCount > 0 && (input.lexicalAlignment.attribute || input.templateSupport)) {
     return {
-      ok: false,
-      reason: "type_mismatch"
+      autoApplyClass: "trusted_exact_reuse_grounded",
+      relaxedStableSlotFamilyGate: false
     };
   }
-  if (oldEntry.type === "milestone") {
+  if (input.templateSupport && input.localGrounding && input.familyReuseCount > 0 && (input.lexicalAlignment.attribute || input.lexicalAlignment.entity)) {
     return {
-      ok: false,
-      reason: "milestone"
+      autoApplyClass: "trusted_family_template_grounded",
+      relaxedStableSlotFamilyGate: false
     };
   }
-  if (oldEntry.expiry === "core") {
+  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 {
-      ok: false,
-      reason: "core_expiry"
+      autoApplyClass: "trusted_family_stable_slot",
+      relaxedStableSlotFamilyGate
+    };
+  }
+  if (input.localGrounding && input.groundedFamilyReuseCount > 0 && input.lexicalAlignment.strongEntityAttribute) {
+    return {
+      autoApplyClass: "trusted_family_grounded_alignment",
+      relaxedStableSlotFamilyGate: false
     };
   }
   return {
-    ok: true
+    autoApplyClass: null,
+    relaxedStableSlotFamilyGate: false
   };
 }
-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.";
+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(buildEntryLocalLexicalTokens(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_ENTITIES2 = /* @__PURE__ */ new Set(["i", "me", "the_user", "myself", "user", "we", "our_team", "the_project", "this_project"]);
+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([
@@ -1443,7 +2525,20 @@ var DETERMINISTIC_ATTRIBUTE_HEADS = /* @__PURE__ */ new Set([
 ]);
 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;
@@ -1487,64 +2582,296 @@ async function previewClaimKeyExtraction(entry, llm, config, options = {}) {
   options.onPreviewOutcome?.(buildPreviewOutcome("rejected_candidate", attempt));
   return tryDeterministicClaimKeyRepair(entry, normalizedHints);
 }
-async function extractClaimKey(entry, llm, config, options = {}) {
-  const preview = await previewClaimKeyExtraction(entry, llm, config, options);
-  if (!preview) {
-    return null;
+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"
+      }
+    };
   }
-  if (preview.path === "deterministic_repair" || preview.confidence >= config.confidenceThreshold) {
-    return preview;
+  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"
+      }
+    };
   }
-  const deterministicRepair = tryDeterministicClaimKeyRepair(entry, normalizeClaimExtractionHints(options.hints ?? {}));
-  if (deterministicRepair) {
-    return deterministicRepair;
+  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"
+      }
+    };
   }
-  return null;
+  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) {
+async function runBatchClaimExtraction(results, ports, config, concurrency = 10, onWarning, onDiagnostic) {
   if (!config.enabled) {
     return /* @__PURE__ */ new Map();
   }
   const hintState = await loadClaimExtractionHintState(ports.db);
   const llm = ports.createLlm();
   const extractedEntries = /* @__PURE__ */ new Map();
-  for (const result of results) {
-    for (const entry of result.entries) {
+  const diagnostics = /* @__PURE__ */ new Map();
+  const retryEntries = [];
+  const stageSize = normalizeClaimExtractionConcurrency(concurrency);
+  const orderedEntries = results.flatMap((result) => result.entries);
+  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;
       }
-      try {
-        const extracted = await extractClaimKey(
-          {
-            type: entry.type,
-            subject: entry.subject,
-            content: entry.content
-          },
-          llm,
-          config,
-          {
-            hints: buildEntryHints(hintState, entry),
-            onWarning
-          }
-        );
-        if (extracted?.claimKey) {
-          entry.claim_key = extracted.claimKey;
-          recordClaimKeyHint(hintState, extracted.claimKey);
-          extractedEntries.set(entry, extracted);
+      stageRequests.push({
+        entry,
+        hintSnapshot: buildClaimExtractionHintSnapshot(hintState, entry)
+      });
+    }
+    const stageDecisions = await Promise.all(
+      stageRequests.map(async ({ entry, hintSnapshot }) => ({
+        entry,
+        decision: await extractBatchClaimKeyDecision(entry, llm, config, hintSnapshot, onWarning)
+      }))
+    );
+    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) {
+    for (let stageStart = 0; stageStart < retryEntries.length; stageStart += stageSize) {
+      const stageRequests = retryEntries.slice(stageStart, stageStart + stageSize).filter((entry) => !entry.claim_key).map((entry) => ({
+        entry,
+        hintSnapshot: buildClaimExtractionHintSnapshot(hintState, entry)
+      }));
+      const stageDecisions = await Promise.all(
+        stageRequests.map(async ({ entry, hintSnapshot }) => ({
+          entry,
+          decision: await extractBatchClaimKeyDecision(entry, llm, config, hintSnapshot, onWarning)
+        }))
+      );
+      for (const { entry, decision } of stageDecisions) {
+        diagnostics.set(entry, decision.diagnostic);
+        if (!decision.result?.claimKey) {
+          continue;
         }
-      } catch {
+        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;
 }
+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
@@ -1595,6 +2922,9 @@ function buildClaimExtractionSystemPrompt(hints, promptMode) {
     '- "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",
@@ -1675,6 +3005,127 @@ function buildClaimExtractionCandidate(entry, response, hints, onWarning) {
     compactionReason: compactedClaimKey.reason
   };
 }
+function toClaimExtractionResult(candidate, path4) {
+  return {
+    claimKey: candidate.claimKey,
+    confidence: candidate.confidence,
+    rawEntity: candidate.rawEntity,
+    rawAttribute: candidate.rawAttribute,
+    path: path4,
+    ...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,
+      legacyEntryCount: 0,
+      deterministicRepairEntryCount: 1,
+      manualEntryCount: 0,
+      modelEntryCount: 0,
+      jsonRetryEntryCount: 0,
+      surgeonFamilyReuseEntryCount: 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) {
@@ -1702,24 +3153,38 @@ function tryDeterministicClaimKeyRepair(entry, hints) {
   };
 }
 async function loadClaimExtractionHintState(db) {
-  const [entityHintResult, claimKeyExampleResult] = await Promise.allSettled([getEntityHints(db), getClaimKeyExamples(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: claimKeyExampleResult.status === "fulfilled" ? claimKeyExampleResult.value : []
+    claimKeyExamples: promptClaimKeyExampleResult.status === "fulfilled" ? promptClaimKeyExampleResult.value : [],
+    supportClaimKeys: supportClaimKeyExampleResult.status === "fulfilled" ? supportClaimKeyExampleResult.value : [],
+    entityPrefixStats: entityPrefixStatsResult.status === "fulfilled" ? entityPrefixStatsResult.value : []
   });
 }
-async function getClaimKeyExamples(db) {
+async function getClaimKeyExamples(db, limit) {
   if (typeof db.getClaimKeyExamples !== "function") {
     return [];
   }
-  return db.getClaimKeyExamples(MAX_CLAIM_KEY_EXAMPLES);
+  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 ?? []),
-      ...claimKeyExamples.flatMap((claimKey) => {
+      ...supportClaimKeys.flatMap((claimKey) => {
         const normalizedClaimKey = normalizeClaimKey(claimKey);
         return normalizedClaimKey.ok ? [normalizedClaimKey.value.entity] : [];
       })
@@ -1728,7 +3193,9 @@ function createHintState(input) {
   );
   return {
     entityHints,
-    claimKeyExamples
+    claimKeyExamples,
+    supportClaimKeys,
+    entityPrefixStats: input.entityPrefixStats ?? []
   };
 }
 function buildEntryHints(state, entry) {
@@ -1747,6 +3214,7 @@ function recordClaimKeyHint(state, claimKey) {
     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) {
@@ -1789,7 +3257,7 @@ function normalizeEntity(value, hints) {
   if (normalizedValue.length === 0) {
     return "";
   }
-  if (!SELF_REFERENTIAL_ENTITIES2.has(normalizedValue)) {
+  if (!SELF_REFERENTIAL_ENTITIES.has(normalizedValue)) {
     return normalizedValue;
   }
   if (USER_REFERENTIAL_ENTITIES.has(normalizedValue) && hints.userEntity) {
@@ -1814,7 +3282,7 @@ function normalizeEntity(value, hints) {
 }
 function normalizeEntityHints(entityHints) {
   return limitUnique(
-    entityHints.map((entityHint) => normalizeClaimKeySegment(entityHint)).filter((entityHint) => entityHint.length > 0 && !SELF_REFERENTIAL_ENTITIES2.has(entityHint)),
+    entityHints.map((entityHint) => normalizeClaimKeySegment(entityHint)).filter((entityHint) => entityHint.length > 0 && !SELF_REFERENTIAL_ENTITIES.has(entityHint)),
     MAX_ENTITY_HINTS
   );
 }
@@ -1827,12 +3295,21 @@ function normalizeClaimKeyExamples(claimKeyExamples) {
     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_ENTITIES2.has(normalized) || !/[a-z]/u.test(normalized)) {
+  if (normalized.length === 0 || SELF_REFERENTIAL_ENTITIES.has(normalized) || !/[a-z]/u.test(normalized)) {
     return void 0;
   }
   return normalized;
@@ -1949,13 +3426,9 @@ function validateEntriesWithIndexes(inputs) {
       rejectedInputIndexes.push(index);
       continue;
     }
-    if (input.valid_from !== void 0 && !isIsoTimestamp(input.valid_from)) {
-      errors.push(`Entry ${index} has an invalid valid_from timestamp.`);
-      rejectedInputIndexes.push(index);
-      continue;
-    }
-    if (input.valid_to !== void 0 && !isIsoTimestamp(input.valid_to)) {
-      errors.push(`Entry ${index} has an invalid valid_to timestamp.`);
+    const temporalValidity = validateTemporalValidityRange(input.valid_from, input.valid_to);
+    if (!temporalValidity.ok) {
+      errors.push(`Entry ${index} ${temporalValidity.message}`);
       rejectedInputIndexes.push(index);
       continue;
     }
@@ -1974,6 +3447,42 @@ function validateEntriesWithIndexes(inputs) {
         }
       }
     }
+    const claimKeyRaw = normalizedClaimKey ? normalizeOptionalString(input.claim_key_raw) : void 0;
+    const claimKeyStatus = normalizedClaimKey ? normalizeClaimKeyStatus(input.claim_key_status, index, warnings) : void 0;
+    const claimKeySource = normalizedClaimKey ? normalizeClaimKeySource(input.claim_key_source, index, warnings) : void 0;
+    const claimKeyConfidence = normalizedClaimKey ? normalizeClaimKeyConfidence(input.claim_key_confidence, index, warnings) : void 0;
+    const claimKeyRationale = normalizedClaimKey ? normalizeOptionalString(input.claim_key_rationale) : void 0;
+    const claimSupportSourceKind = normalizedClaimKey ? normalizeOptionalString(input.claim_support_source_kind) : void 0;
+    const claimSupportLocator = normalizedClaimKey ? normalizeOptionalString(input.claim_support_locator) : void 0;
+    const claimSupportObservedAt = normalizedClaimKey && input.claim_support_observed_at !== void 0 ? normalizeClaimSupportObservedAt(input.claim_support_observed_at, index, warnings) : void 0;
+    const claimSupportMode = normalizedClaimKey && input.claim_support_mode !== void 0 ? normalizeClaimSupportMode(input.claim_support_mode, index, warnings) : void 0;
+    const hasPrecomputedLifecycleFields = hasPrecomputedClaimKeyLifecycleFields(input);
+    const resolvedPrecomputedLifecycle = normalizedClaimKey && hasPrecomputedLifecycleFields ? buildPrecomputedClaimKeyLifecycle({
+      claim_key: normalizedClaimKey,
+      claim_key_raw: claimKeyRaw,
+      claim_key_status: claimKeyStatus,
+      claim_key_source: claimKeySource,
+      claim_key_confidence: claimKeyConfidence,
+      claim_key_rationale: claimKeyRationale,
+      claim_support_source_kind: claimSupportSourceKind,
+      claim_support_locator: claimSupportLocator,
+      claim_support_observed_at: claimSupportObservedAt,
+      claim_support_mode: claimSupportMode
+    }) : void 0;
+    if (hasPrecomputedLifecycleFields) {
+      if (!normalizedClaimKey) {
+        errors.push(`Entry ${index} provided claim-key lifecycle metadata without a valid claim key.`);
+        rejectedInputIndexes.push(index);
+        continue;
+      }
+      if (!resolvedPrecomputedLifecycle) {
+        errors.push(
+          `Entry ${index} provided partial or invalid claim-key lifecycle metadata. Complete bundles require claim_key_status, claim_key_source, claim_key_confidence, and claim_key_rationale.`
+        );
+        rejectedInputIndexes.push(index);
+        continue;
+      }
+    }
     valid.push({
       inputIndex: index,
       input: {
@@ -1990,8 +3499,17 @@ function validateEntriesWithIndexes(inputs) {
         created_at: normalizeOptionalString(input.created_at),
         supersedes: normalizeOptionalString(input.supersedes),
         claim_key: normalizedClaimKey,
-        valid_from: normalizeOptionalString(input.valid_from),
-        valid_to: normalizeOptionalString(input.valid_to)
+        claim_key_raw: resolvedPrecomputedLifecycle?.claim_key_raw ?? claimKeyRaw,
+        claim_key_status: resolvedPrecomputedLifecycle?.claim_key_status,
+        claim_key_source: resolvedPrecomputedLifecycle?.claim_key_source,
+        claim_key_confidence: resolvedPrecomputedLifecycle?.claim_key_confidence,
+        claim_key_rationale: resolvedPrecomputedLifecycle?.claim_key_rationale,
+        claim_support_source_kind: resolvedPrecomputedLifecycle?.claim_support_source_kind ?? claimSupportSourceKind,
+        claim_support_locator: resolvedPrecomputedLifecycle?.claim_support_locator ?? claimSupportLocator,
+        claim_support_observed_at: resolvedPrecomputedLifecycle?.claim_support_observed_at ?? claimSupportObservedAt,
+        claim_support_mode: resolvedPrecomputedLifecycle?.claim_support_mode ?? claimSupportMode,
+        valid_from: temporalValidity.value.validFrom,
+        valid_to: temporalValidity.value.validTo
       }
     });
   }
@@ -2016,6 +3534,56 @@ function normalizeOptionalString(value) {
   const normalized = value?.trim();
   return normalized && normalized.length > 0 ? normalized : void 0;
 }
+function normalizeClaimSupportObservedAt(value, index, warnings) {
+  const normalized = normalizeOptionalString(value);
+  if (!normalized) {
+    return void 0;
+  }
+  if (!isIsoTimestamp(normalized)) {
+    warnings.push(`Entry ${index} provided invalid claim_support_observed_at ${JSON.stringify(value)} and it was dropped.`);
+    return void 0;
+  }
+  return normalized;
+}
+function normalizeClaimKeyStatus(value, index, warnings) {
+  const parsed = parseClaimKeyStatus(value);
+  if (parsed) {
+    return parsed;
+  }
+  if (value !== void 0) {
+    warnings.push(`Entry ${index} provided invalid claim_key_status ${JSON.stringify(value)} and it was dropped.`);
+  }
+  return void 0;
+}
+function normalizeClaimKeySource(value, index, warnings) {
+  const parsed = parseClaimKeySource(value);
+  if (parsed) {
+    return parsed;
+  }
+  if (value !== void 0) {
+    warnings.push(`Entry ${index} provided invalid claim_key_source ${JSON.stringify(value)} and it was dropped.`);
+  }
+  return void 0;
+}
+function normalizeClaimKeyConfidence(value, index, warnings) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const parsed = parseClaimKeyConfidence(value);
+  if (parsed !== void 0) {
+    return parsed;
+  }
+  warnings.push(`Entry ${index} provided invalid claim_key_confidence ${JSON.stringify(value)} and it was dropped.`);
+  return void 0;
+}
+function normalizeClaimSupportMode(value, index, warnings) {
+  const parsed = parseClaimSupportMode(value);
+  if (parsed) {
+    return parsed;
+  }
+  warnings.push(`Entry ${index} provided invalid claim_support_mode ${JSON.stringify(value)} and it was dropped.`);
+  return void 0;
+}
 function areValidTags(value) {
   return Array.isArray(value) && value.every((tag) => typeof tag === "string");
 }
@@ -2035,7 +3603,7 @@ function isIsoTimestamp(value) {
 
 // src/core/store/pipeline.ts
 var AUTO_SUPERSESSION_MIN_EXTRACTED_CONFIDENCE = 0.9;
-var AUTO_SUPERSESSION_ELIGIBLE_PATHS = /* @__PURE__ */ new Set(["model", "json_retry"]);
+var AUTO_SUPERSESSION_ELIGIBLE_SOURCES = /* @__PURE__ */ new Set(["model", "json_retry"]);
 async function storeEntriesDetailed(inputs, db, embedding, options = {}) {
   if (inputs.length === 0) {
     return { stored: 0, skipped: 0, rejected: 0, details: [] };
@@ -2069,6 +3637,7 @@ async function storeEntriesDetailed(inputs, db, embedding, options = {}) {
   }
   const pendingEntries = plan.pendingEntries;
   const extractedClaimKeys = await maybeExtractClaimKeys(pendingEntries, options);
+  applyExtractedClaimKeyMetadata(pendingEntries, extractedClaimKeys);
   const embeddings = await resolvePendingEmbeddings(inputs, pendingEntries, embedding, options.precomputedEmbeddings);
   await persistEntries(db, pendingEntries, embeddings, extractedClaimKeys, options.claimExtraction?.config, options.onWarning);
   return {
@@ -2150,6 +3719,7 @@ async function persistEntries(db, preparedEntries, embeddings, extractedClaimKey
 }
 function buildEntry(preparedEntry, embedding) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
+  const acceptedClaimKey = preparedEntry.claimKey;
   return {
     id: randomUUID(),
     type: preparedEntry.input.type,
@@ -2169,7 +3739,16 @@ function buildEntry(preparedEntry, embedding) {
     recall_count: 0,
     valid_from: preparedEntry.input.valid_from,
     valid_to: preparedEntry.input.valid_to,
-    claim_key: preparedEntry.input.claim_key,
+    claim_key: acceptedClaimKey?.claim_key ?? preparedEntry.input.claim_key,
+    claim_key_raw: acceptedClaimKey?.claim_key_raw,
+    claim_key_status: acceptedClaimKey?.claim_key_status,
+    claim_key_source: acceptedClaimKey?.claim_key_source,
+    claim_key_confidence: acceptedClaimKey?.claim_key_confidence,
+    claim_key_rationale: acceptedClaimKey?.claim_key_rationale,
+    claim_support_source_kind: acceptedClaimKey?.claim_support_source_kind,
+    claim_support_locator: acceptedClaimKey?.claim_support_locator,
+    claim_support_observed_at: acceptedClaimKey?.claim_support_observed_at,
+    claim_support_mode: acceptedClaimKey?.claim_support_mode,
     retired: false,
     created_at: preparedEntry.input.created_at ?? now,
     updated_at: now
@@ -2192,8 +3771,14 @@ async function maybeExtractClaimKeys(preparedEntries, options) {
         db: claimExtraction.db
       },
       claimExtraction.config,
-      1,
-      options.onWarning
+      claimExtraction.config.concurrency ?? 10,
+      options.onWarning,
+      (entry, diagnostic) => {
+        const preparedEntry = preparedEntries.find((candidate) => candidate.input === entry);
+        if (preparedEntry) {
+          options.onClaimExtractionDiagnostic?.(preparedEntry.inputIndex, diagnostic);
+        }
+      }
     );
     const extractedClaimKeys = /* @__PURE__ */ new Map();
     for (const preparedEntry of preparedEntries) {
@@ -2212,12 +3797,26 @@ async function maybeExtractClaimKeys(preparedEntries, options) {
 function hasTransactionSupport(db) {
   return typeof db.withTransaction === "function";
 }
+function applyExtractedClaimKeyMetadata(preparedEntries, extractedClaimKeys) {
+  for (const preparedEntry of preparedEntries) {
+    if (preparedEntry.claimKey) {
+      continue;
+    }
+    const extractedClaimKey = extractedClaimKeys.get(preparedEntry.inputIndex);
+    const acceptedClaimKey = buildPrecomputedClaimKeyLifecycle(preparedEntry.input) ?? (extractedClaimKey ? buildExtractedClaimKeyLifecycle(extractedClaimKey, buildInferredIngestClaimKeySupportContext(preparedEntry.input)) : void 0);
+    if (!acceptedClaimKey) {
+      continue;
+    }
+    preparedEntry.claimKey = acceptedClaimKey;
+    applyClaimKeyLifecycle(preparedEntry.input, acceptedClaimKey);
+  }
+}
 async function planAutoSupersession(db, preparedEntries, extractedClaimKeys, claimExtractionConfig) {
   const plans = /* @__PURE__ */ new Map();
   const preparedEntriesByClaimKey = groupPreparedEntriesByClaimKey(preparedEntries);
   const siblingCache = /* @__PURE__ */ new Map();
   for (const preparedEntry of preparedEntries) {
-    const claimKey = preparedEntry.input.claim_key;
+    const claimKey = preparedEntry.claimKey?.claim_key ?? preparedEntry.input.claim_key;
     if (!claimKey || preparedEntry.input.supersedes) {
       continue;
     }
@@ -2244,10 +3843,10 @@ async function planAutoSupersession(db, preparedEntries, extractedClaimKeys, cla
     if (!sibling) {
       continue;
     }
-    if (!isAutoSupersessionEligible(preparedEntry, extractedClaimKeys, claimExtractionConfig)) {
+    if (!isAutoSupersessionEligible(preparedEntry.claimKey, claimExtractionConfig)) {
       plans.set(preparedEntry.inputIndex, {
         kind: "skip",
-        warning: buildAutoSupersessionEligibilityWarning(preparedEntry, extractedClaimKeys.get(preparedEntry.inputIndex))
+        warning: buildAutoSupersessionEligibilityWarning(preparedEntry)
       });
       continue;
     }
@@ -2272,7 +3871,7 @@ async function planAutoSupersession(db, preparedEntries, extractedClaimKeys, cla
 function groupPreparedEntriesByClaimKey(preparedEntries) {
   const grouped = /* @__PURE__ */ new Map();
   for (const preparedEntry of preparedEntries) {
-    const claimKey = preparedEntry.input.claim_key;
+    const claimKey = preparedEntry.claimKey?.claim_key ?? preparedEntry.input.claim_key;
     if (!claimKey) {
       continue;
     }
@@ -2291,28 +3890,31 @@ async function getClaimKeySiblings(db, cache, claimKey) {
   cache.set(claimKey, siblings);
   return siblings;
 }
-function isAutoSupersessionEligible(preparedEntry, extractedClaimKeys, claimExtractionConfig) {
-  if (preparedEntry.claimKeySource === "manual") {
-    return true;
-  }
-  const extractedClaimKey = extractedClaimKeys.get(preparedEntry.inputIndex);
-  if (!extractedClaimKey || !claimExtractionConfig) {
+function isAutoSupersessionEligible(claimKey, claimExtractionConfig) {
+  if (!claimKey || claimKey.claim_key_status !== "trusted") {
     return false;
   }
-  if (!AUTO_SUPERSESSION_ELIGIBLE_PATHS.has(extractedClaimKey.path)) {
+  if (claimKey.claim_key_source === "manual") {
+    return true;
+  }
+  if (!AUTO_SUPERSESSION_ELIGIBLE_SOURCES.has(claimKey.claim_key_source) || !claimExtractionConfig) {
     return false;
   }
-  return extractedClaimKey.confidence >= Math.max(claimExtractionConfig.confidenceThreshold, AUTO_SUPERSESSION_MIN_EXTRACTED_CONFIDENCE);
+  return claimKey.claim_key_confidence >= Math.max(claimExtractionConfig.confidenceThreshold, AUTO_SUPERSESSION_MIN_EXTRACTED_CONFIDENCE);
 }
-function buildAutoSupersessionEligibilityWarning(preparedEntry, extractedClaimKey) {
-  const claimKey = preparedEntry.input.claim_key ?? "(missing)";
-  if (preparedEntry.claimKeySource === "manual") {
+function buildAutoSupersessionEligibilityWarning(preparedEntry) {
+  const acceptedClaimKey = preparedEntry.claimKey;
+  const claimKey = acceptedClaimKey?.claim_key ?? preparedEntry.input.claim_key ?? "(missing)";
+  if (!acceptedClaimKey) {
+    return `Stored entry "${preparedEntry.input.subject}" with claim_key "${claimKey}" but skipped auto-supersession because the claim-key provenance was not explicit or a tracked high-confidence extraction.`;
+  }
+  if (acceptedClaimKey.claim_key_source === "manual") {
     return `Stored entry "${preparedEntry.input.subject}" with claim_key "${claimKey}" but skipped auto-supersession because the claim-key provenance was not eligible for automatic linking.`;
   }
-  if (extractedClaimKey) {
-    return `Stored entry "${preparedEntry.input.subject}" with claim_key "${claimKey}" but skipped auto-supersession because the extracted claim key came from ${extractedClaimKey.path} at confidence ${extractedClaimKey.confidence.toFixed(2)}. Only explicit/manual claim keys or model-extracted keys at ${AUTO_SUPERSESSION_MIN_EXTRACTED_CONFIDENCE.toFixed(2)}+ auto-link.`;
+  if (acceptedClaimKey.claim_key_status !== "trusted") {
+    return `Stored entry "${preparedEntry.input.subject}" with claim_key "${claimKey}" but skipped auto-supersession because the accepted claim key is ${acceptedClaimKey.claim_key_status} from ${acceptedClaimKey.claim_key_source} at confidence ${acceptedClaimKey.claim_key_confidence.toFixed(2)}. Only explicit/manual claim keys or model-extracted keys at ${AUTO_SUPERSESSION_MIN_EXTRACTED_CONFIDENCE.toFixed(2)}+ auto-link.`;
   }
-  return `Stored entry "${preparedEntry.input.subject}" with claim_key "${claimKey}" but skipped auto-supersession because the claim-key provenance was not explicit or a tracked high-confidence extraction.`;
+  return `Stored entry "${preparedEntry.input.subject}" with claim_key "${claimKey}" but skipped auto-supersession because the extracted claim key came from ${acceptedClaimKey.claim_key_source} at confidence ${acceptedClaimKey.claim_key_confidence.toFixed(2)}. Only explicit/manual claim keys or model-extracted keys at ${AUTO_SUPERSESSION_MIN_EXTRACTED_CONFIDENCE.toFixed(2)}+ auto-link.`;
 }
 function buildAutoSupersessionRuleWarning(preparedEntry, sibling, reason) {
   if (reason === "type_mismatch") {
@@ -2332,7 +3934,7 @@ async function buildStorePlan(inputs, db) {
     inputIndex,
     contentHash: computeContentHash(input.content, input.source_file),
     normContentHash: computeNormContentHash(input.content),
-    claimKeySource: input.claim_key ? "manual" : void 0
+    claimKey: buildManualAcceptedClaimKey(inputs[inputIndex], input)
   }));
   const afterBatchContentHash = dedupePreparedEntries(preparedEntries, "contentHash", "content_hash", details);
   const existingHashes = await db.findExistingHashes(afterBatchContentHash.map((entry) => entry.contentHash));
@@ -2388,6 +3990,31 @@ function formatPipelineError(error) {
 function sortStoreDetails(details) {
   return [...details].sort((left, right) => left.inputIndex - right.inputIndex);
 }
+function buildManualAcceptedClaimKey(rawInput, normalizedInput) {
+  const canonicalClaimKey = normalizedInput.claim_key;
+  if (!canonicalClaimKey) {
+    return void 0;
+  }
+  const precomputedAcceptedClaimKey = buildPrecomputedClaimKeyLifecycle(normalizedInput);
+  if (precomputedAcceptedClaimKey) {
+    return precomputedAcceptedClaimKey;
+  }
+  if (rawInput && hasPrecomputedClaimKeyLifecycleFields(rawInput)) {
+    throw new Error("Store inputs with claim-key lifecycle metadata must provide a complete valid lifecycle bundle.");
+  }
+  return buildManualClaimKeyLifecycle({
+    claimKey: canonicalClaimKey,
+    rawClaimKey: normalizedInput.claim_key_raw ?? normalizeOptionalString2(rawInput?.claim_key),
+    supportSourceKind: normalizedInput.claim_support_source_kind,
+    supportLocator: normalizedInput.claim_support_locator,
+    supportObservedAt: normalizedInput.claim_support_observed_at,
+    supportMode: normalizedInput.claim_support_mode
+  });
+}
+function normalizeOptionalString2(value) {
+  const normalized = value?.trim();
+  return normalized && normalized.length > 0 ? normalized : void 0;
+}
 
 // src/core/episode/summary-prompt.ts
 var EPISODE_SUMMARY_SYSTEM_PROMPT = [
@@ -2505,7 +4132,7 @@ async function generateEpisodeSummary(transcript, llm) {
 }
 
 // src/app/episode-ingest/service/preflight.ts
-import path from "path";
+import path2 from "path";
 
 // src/core/episode/transcript-render.ts
 var MIN_EPISODE_MESSAGES = 4;
@@ -2836,9 +4463,9 @@ function resolveSessionMeta(filePath, parsedSessionId, registryMeta, reconstruct
   };
 }
 function deriveAgentIdFromPath(filePath) {
-  const resolved = path.resolve(filePath);
-  const parent = path.basename(path.dirname(resolved));
-  const grandparent = path.basename(path.dirname(path.dirname(resolved)));
+  const resolved = path2.resolve(filePath);
+  const parent = path2.basename(path2.dirname(resolved));
+  const grandparent = path2.basename(path2.dirname(path2.dirname(resolved)));
   if (parent !== "sessions") {
     return null;
   }
@@ -3166,50 +4793,59 @@ function resolveRecentCutoff(recent, now) {
   return cutoff;
 }
 
-// src/adapters/openclaw/session/session-id.ts
-import path2 from "path";
-function deriveOpenClawSessionIdFromFilePath(sessionFile, logger) {
-  const normalizedSessionFile = sessionFile.trim();
-  if (normalizedSessionFile.length === 0) {
-    debugLog(logger, "session-id", "cannot derive session id from empty session file path");
-    return void 0;
-  }
-  const fileName = path2.basename(normalizedSessionFile);
-  const sessionId = fileName.replace(/\.jsonl(?:\..*)?$/i, "").trim();
-  debugLog(logger, "session-id", `derived session id "${sessionId || "<empty>"}" from file=${normalizedSessionFile}`);
-  return sessionId.length > 0 ? sessionId : void 0;
-}
-function debugLog(logger, subsystem, message) {
-  logger?.debug?.(`[agenr] ${subsystem}: ${message}`);
-}
-
 // src/adapters/openclaw/session/sessions-store-reader.ts
 import * as fs3 from "fs/promises";
 import path3 from "path";
 async function readOpenClawSessionsStore(sessionsDir, logger) {
-  const normalizedSessionsDir = sessionsDir.trim();
-  if (normalizedSessionsDir.length === 0) {
+  if (sessionsDir.trim().length === 0) {
     debugLog2(logger, "sessions-store-reader", "skipping sessions.json read because sessionsDir is empty");
     return [];
   }
+  const result = await readOpenClawSessionsStoreWithDiagnostics(sessionsDir);
+  for (const diagnostic of result.diagnostics) {
+    debugLog2(logger, "sessions-store-reader", diagnostic.message);
+  }
+  if (result.diagnostics.length === 0) {
+    debugLog2(
+      logger,
+      "sessions-store-reader",
+      `loaded sessions.json entries=${result.entries.length} path=${path3.join(path3.resolve(sessionsDir.trim()), "sessions.json")}`
+    );
+  }
+  return result.entries;
+}
+async function readOpenClawSessionsStoreWithDiagnostics(sessionsDir) {
+  const normalizedSessionsDir = sessionsDir.trim();
+  if (normalizedSessionsDir.length === 0) {
+    return {
+      entries: [],
+      diagnostics: []
+    };
+  }
   const resolvedSessionsDir = path3.resolve(normalizedSessionsDir);
   const sessionsJsonPath = path3.join(resolvedSessionsDir, "sessions.json");
   try {
     const raw = await fs3.readFile(sessionsJsonPath, "utf8");
     const parsed = JSON.parse(raw);
     if (!isRecord(parsed)) {
-      debugLog2(logger, "sessions-store-reader", `sessions.json did not contain an object: path=${sessionsJsonPath}`);
-      return [];
+      return {
+        entries: [],
+        diagnostics: [
+          {
+            kind: "structurally_invalid_file",
+            message: `sessions.json did not contain an object: path=${sessionsJsonPath}`,
+            path: sessionsJsonPath
+          }
+        ]
+      };
     }
     const entries = [];
     for (const [sessionKey, value] of Object.entries(parsed)) {
       const normalizedSessionKey = sessionKey.trim();
       if (normalizedSessionKey.length === 0) {
-        debugLog2(logger, "sessions-store-reader", `skipping blank session key in ${sessionsJsonPath}`);
         continue;
       }
       if (!isRecord(value)) {
-        debugLog2(logger, "sessions-store-reader", `skipping non-object entry for key=${normalizedSessionKey}`);
         continue;
       }
       const sessionId = asTrimmedString(value["sessionId"]);
@@ -3229,26 +4865,52 @@ async function readOpenClawSessionsStore(sessionsDir, logger) {
         ...updatedAt !== void 0 ? { updatedAt } : {}
       });
     }
-    debugLog2(logger, "sessions-store-reader", `loaded sessions.json entries=${entries.length} path=${sessionsJsonPath}`);
-    return entries;
+    return {
+      entries,
+      diagnostics: []
+    };
   } catch (error) {
-    if (isFileNotFound(error)) {
-      debugLog2(logger, "sessions-store-reader", `sessions.json missing at ${sessionsJsonPath}`);
-      return [];
+    if (isFileNotFound2(error)) {
+      return {
+        entries: [],
+        diagnostics: [
+          {
+            kind: "missing_file",
+            message: `sessions.json missing at ${sessionsJsonPath}`,
+            path: sessionsJsonPath
+          }
+        ]
+      };
     }
     if (error instanceof SyntaxError) {
-      debugLog2(logger, "sessions-store-reader", `sessions.json parse failed at ${sessionsJsonPath}: ${error.message}`);
-      return [];
+      return {
+        entries: [],
+        diagnostics: [
+          {
+            kind: "malformed_json",
+            message: `sessions.json parse failed at ${sessionsJsonPath}: ${error.message}`,
+            path: sessionsJsonPath
+          }
+        ]
+      };
     }
-    debugLog2(logger, "sessions-store-reader", `sessions.json read failed at ${sessionsJsonPath}: ${formatErrorMessage(error)}`);
-    return [];
+    return {
+      entries: [],
+      diagnostics: [
+        {
+          kind: "unreadable_file",
+          message: `sessions.json read failed at ${sessionsJsonPath}: ${formatErrorMessage2(error)}`,
+          path: sessionsJsonPath
+        }
+      ]
+    };
   }
 }
 function resolveSessionStorePath(candidatePath, sessionsDir) {
   return path3.isAbsolute(candidatePath) ? path3.resolve(candidatePath) : path3.resolve(sessionsDir, candidatePath);
 }
 function isRecord(value) {
-  return typeof value === "object" && value !== null;
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function asTrimmedString(value) {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
@@ -3259,10 +4921,10 @@ function asFiniteNumber(value) {
 function debugLog2(logger, subsystem, message) {
   logger?.debug?.(`[agenr] ${subsystem}: ${message}`);
 }
-function isFileNotFound(error) {
+function isFileNotFound2(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
-function formatErrorMessage(error) {
+function formatErrorMessage2(error) {
   if (error instanceof Error) {
     return error.message;
   }
@@ -3297,26 +4959,32 @@ function parseTuiSessionKey(sessionKey) {
 }
 
 export {
-  normalizeClaimKeySegment,
-  normalizeClaimKey,
-  compactClaimKey,
-  inspectClaimKey,
-  isTrustedClaimKeyForCleanup,
-  describeClaimKeyNormalizationFailure,
-  describeClaimKeySuspicion,
+  detectClaimKeyEntityFamilyCandidates,
+  detectClaimKeySingletonAliasCandidates,
+  buildTrustedClaimKeySupportSeed,
+  evaluateClaimKeySupport,
+  evaluateClaimKeyCompactness,
+  normalizeGroundingTags,
+  tokenizeGroundingText,
+  buildEntryLocalLexicalTokens,
+  applyClaimExtractionResultToEntry,
   previewClaimKeyExtraction,
   runBatchClaimExtraction,
   validateSupersessionRules,
   describeSupersessionRuleFailure,
+  computeContentHash,
+  computeNormContentHash,
+  validateEntriesWithIndexes,
   storeEntriesDetailed,
+  deriveOpenClawSessionIdFromFilePath,
   OpenClawTranscriptParser,
   openClawTranscriptParser,
-  deriveOpenClawSessionIdFromFilePath,
   readOpenClawSessionsStore,
   parseTuiSessionKey,
   backfillEpisodeEmbeddings,
   prepareEpisodeIngest,
   ingestEpisodeTranscript,
   executeEpisodeIngestPlan,
-  createEpisodeIngestPlan
+  createEpisodeIngestPlan,
+  createOpenClawRepository
 };