@agenr/agenr-plugin 1.7.3 → 1.8.0

package/dist/chunk-6CEKKEFZ.js

@@ -0,0 +1,4954 @@
+import {
+  EMBEDDING_DIMENSIONS,
+  ENTRY_SELECT_COLUMNS,
+  ENTRY_TYPES,
+  EPISODE_ACTIVITY_LEVELS,
+  EXPIRY_LEVELS,
+  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 {
+  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 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;
+    }
+    const parsed = parseJsonObjectLineWithDiagnostics(line, index + 1);
+    if (parsed.diagnostic) {
+      diagnostics.push(parsed.diagnostic);
+      continue;
+    }
+    if (parsed.record) {
+      onRecord(parsed.record, index + 1);
+    }
+  }
+  return {
+    diagnostics
+  };
+}
+
+// src/adapters/openclaw/transcript/tool-summarization.ts
+var DEFAULT_TOOL_RESULT_DROP_NAMES = ["read", "web_fetch", "browser", "screenshot", "snapshot", "canvas", "tts"];
+var DEFAULT_TOOL_RESULT_KEEP_NAMES = ["web_search", "memory_search", "memory_get", "image"];
+var DEFAULT_TOOL_RESULT_DROP_NAME_SET = new Set(DEFAULT_TOOL_RESULT_DROP_NAMES);
+var DEFAULT_TOOL_RESULT_KEEP_NAME_SET = new Set(DEFAULT_TOOL_RESULT_KEEP_NAMES);
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function getString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function truncateInline(value, max) {
+  if (value.length <= max) {
+    return value;
+  }
+  return value.slice(0, max);
+}
+function firstStringArgValue(args, max) {
+  for (const value of Object.values(args)) {
+    if (typeof value === "string" && value.trim().length > 0) {
+      return truncateInline(value.trim(), max);
+    }
+  }
+  return void 0;
+}
+function extractAgenrStoreEntries(args) {
+  const nestedEntries = Array.isArray(args.entries) ? args.entries.flatMap((entry) => {
+    const record = asRecord(entry);
+    return record ? [record] : [];
+  }) : [];
+  if (nestedEntries.length > 0) {
+    return nestedEntries;
+  }
+  if (getString(args.type) || getString(args.subject) || getString(args.content) || getString(args.claimKey) || getString(args.claim_key) || getString(args.supersedes)) {
+    return [args];
+  }
+  return [];
+}
+function summarizeAgenrStoreEntry(entry) {
+  const type = getString(entry.type) ?? "unknown";
+  const subject = getString(entry.subject) ?? "(no subject)";
+  const claimKey = getString(entry.claimKey) ?? getString(entry.claim_key);
+  const claimKeySuffix = claimKey ? ` claim_key=${JSON.stringify(truncateInline(claimKey.trim(), 120))}` : "";
+  return `${type}: "${truncateInline(subject, 60)}"${claimKeySuffix}`;
+}
+function toolIdentifier(toolName, args) {
+  const normalizedToolName = toolName.trim().toLowerCase();
+  if (normalizedToolName === "read" || normalizedToolName === "edit" || normalizedToolName === "write") {
+    return getString(args.file_path) ?? getString(args.path) ?? getString(args.file) ?? "(unknown file)";
+  }
+  if (normalizedToolName === "exec") {
+    const command = getString(args.command) ?? getString(args.cmd) ?? "(unknown command)";
+    return truncateInline(command, 100);
+  }
+  if (normalizedToolName === "web_fetch") {
+    return getString(args.url) ?? "(unknown url)";
+  }
+  if (normalizedToolName === "web_search") {
+    return getString(args.query) ?? "(unknown query)";
+  }
+  if (normalizedToolName === "browser") {
+    const action = getString(args.action) ?? "(unknown action)";
+    const targetUrl = getString(args.targetUrl) ?? getString(args.url);
+    return targetUrl ? `${action} ${targetUrl}` : action;
+  }
+  if (normalizedToolName === "agenr_store") {
+    const entries = extractAgenrStoreEntries(args);
+    return `${entries.length} entr${entries.length === 1 ? "y" : "ies"}`;
+  }
+  if (normalizedToolName === "agenr_recall") {
+    const query = getString(args.query) ?? "(no query)";
+    return `"${truncateInline(query, 80)}"`;
+  }
+  if (normalizedToolName === "message") {
+    const action = getString(args.action) ?? "(unknown action)";
+    const target = getString(args.target) ?? getString(args.to) ?? "(unknown target)";
+    return `${truncateInline(action, 80)} to ${truncateInline(target, 80)}`;
+  }
+  if (normalizedToolName === "sessions_spawn") {
+    return getString(args.label) ?? getString(args.task)?.slice(0, 60) ?? "(unknown task)";
+  }
+  if (normalizedToolName === "image") {
+    return getString(args.image) ?? getString(args.url) ?? getString(args.path) ?? "(unknown image)";
+  }
+  if (normalizedToolName === "canvas") {
+    return getString(args.action) ?? "(unknown action)";
+  }
+  if (normalizedToolName === "tts") {
+    const text = getString(args.text) ?? "(unknown text)";
+    return truncateInline(text, 50);
+  }
+  return firstStringArgValue(args, 80) ?? "(unknown)";
+}
+function extractToolCallBlocks(content) {
+  if (!Array.isArray(content)) {
+    return [];
+  }
+  const toolCalls = [];
+  for (const block of content) {
+    const record = asRecord(block);
+    if (!record) {
+      continue;
+    }
+    const type = typeof record.type === "string" ? record.type.trim().toLowerCase() : "";
+    const name = getString(record.name) ?? getString(record.tool) ?? getString(record.tool_name);
+    const args = asRecord(record.arguments) ?? asRecord(record.args) ?? asRecord(record.input) ?? {};
+    const id = getString(record.id) ?? getString(record.toolCallId) ?? getString(record.tool_call_id) ?? getString(record.call_id);
+    if ((type === "toolcall" || type === "tool_call" || type === "tool_use" || type === "tooluse") && name) {
+      toolCalls.push({ name, args, id });
+      continue;
+    }
+    if (!type && name && ("arguments" in record || "args" in record || "input" in record)) {
+      toolCalls.push({ name, args, id });
+    }
+  }
+  return toolCalls;
+}
+function summarizeToolCall(call, options) {
+  const normalizedToolName = call.name.trim().toLowerCase();
+  const override = options?.overrides?.[normalizedToolName];
+  if (override) {
+    const summary = override(call);
+    if (summary) {
+      return summary;
+    }
+  }
+  const args = call.args;
+  const filePath = getString(args.file_path) ?? getString(args.path) ?? getString(args.file);
+  if (normalizedToolName === "read") {
+    return `[called Read: ${filePath ?? "(unknown file)"}]`;
+  }
+  if (normalizedToolName === "write") {
+    const content = getString(args.content) ?? getString(args.text) ?? "";
+    return `[called Write: ${filePath ?? "(unknown file)"} - ${content.length} chars]`;
+  }
+  if (normalizedToolName === "edit") {
+    const oldText = getString(args.oldText) ?? getString(args.old_string) ?? "";
+    return `[called Edit: ${filePath ?? "(unknown file)"} - replaced ${oldText.length} chars]`;
+  }
+  if (normalizedToolName === "exec") {
+    const command = getString(args.command) ?? getString(args.cmd) ?? "(unknown command)";
+    return `[called exec: ${truncateInline(command, 200)}]`;
+  }
+  if (normalizedToolName === "web_search") {
+    const query = getString(args.query) ?? "(unknown query)";
+    return `[called web_search: ${truncateInline(query, 200)}]`;
+  }
+  if (normalizedToolName === "web_fetch") {
+    const url = getString(args.url) ?? "(unknown url)";
+    return `[called web_fetch: ${truncateInline(url, 200)}]`;
+  }
+  if (normalizedToolName === "browser") {
+    const action = getString(args.action) ?? "(unknown action)";
+    return `[called browser: ${truncateInline(action, 200)}]`;
+  }
+  if (normalizedToolName === "message") {
+    const action = getString(args.action) ?? "(unknown action)";
+    const target = getString(args.target) ?? getString(args.to) ?? "(unknown target)";
+    return `[called message: ${truncateInline(action, 200)} to ${truncateInline(target, 200)}]`;
+  }
+  if (normalizedToolName === "agenr_store") {
+    const entries = extractAgenrStoreEntries(args);
+    if (entries.length === 0) {
+      return "[attempted brain store: (empty)]";
+    }
+    const summaries = entries.slice(0, 3).map(summarizeAgenrStoreEntry);
+    const countSuffix = entries.length > 3 ? ` (+${entries.length - 3} more)` : "";
+    return `[attempted brain store: ${summaries.join(", ")}${countSuffix}]`;
+  }
+  if (normalizedToolName === "agenr_recall") {
+    const query = getString(args.query) ?? "(no query)";
+    return `[recalled from brain: "${truncateInline(query, 100)}"]`;
+  }
+  if (normalizedToolName === "sessions_spawn") {
+    const label = getString(args.label);
+    const mode = getString(args.mode) ?? "run";
+    const model = getString(args.model);
+    const modelSuffix = model ? ` model=${model}` : "";
+    if (label) {
+      return `[spawned sub-agent: ${label} (${mode}${modelSuffix})]`;
+    }
+    const task = getString(args.task) ?? "(no task)";
+    return `[spawned sub-agent: ${truncateInline(task, 80)} (${mode}${modelSuffix})]`;
+  }
+  const relevantArgValue = firstStringArgValue(
+    Object.fromEntries(
+      Object.entries(args).filter(
+        ([key]) => !["buffer", "content", "data", "newText", "new_string", "oldText", "old_string"].includes(key) && !(normalizedToolName === "write" && key === "text")
+      )
+    ),
+    80
+  ) ?? "(no args)";
+  return `[called ${call.name}: ${relevantArgValue}]`;
+}
+function toolResultPlaceholder(toolName, args) {
+  const normalizedToolName = toolName.trim().length > 0 ? toolName.trim() : "unknown";
+  const identifier = toolIdentifier(normalizedToolName, args);
+  return `[tool result from ${normalizedToolName}: ${identifier} - filtered]`;
+}
+function shouldKeepToolResult(toolName, text, policy) {
+  const normalizedToolName = (toolName ?? "").trim().toLowerCase();
+  const dropToolNames = policy?.dropToolNames ?? DEFAULT_TOOL_RESULT_DROP_NAME_SET;
+  const keepToolNames = policy?.keepToolNames ?? DEFAULT_TOOL_RESULT_KEEP_NAME_SET;
+  if (normalizedToolName && dropToolNames.has(normalizedToolName)) {
+    return { keep: false };
+  }
+  if (normalizedToolName && keepToolNames.has(normalizedToolName)) {
+    return { keep: true, truncateTo: 2e3 };
+  }
+  if (normalizedToolName === "exec") {
+    if (text.length < 1e3) {
+      return { keep: true, truncateTo: 2e3 };
+    }
+    if (/(error|failed|fail)/i.test(text)) {
+      return { keep: true, truncateTo: 2e3 };
+    }
+    return { keep: false };
+  }
+  if (text.length < 500) {
+    return { keep: true, truncateTo: 2e3 };
+  }
+  return { keep: false };
+}
+
+// src/adapters/openclaw/transcript/message-content.ts
+var TEXT_BLOCK_TYPES = /* @__PURE__ */ new Set(["input_text", "output_text", "text"]);
+function normalizeWhitespace(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function extractTextBlocks(content) {
+  if (typeof content === "string") {
+    const normalized = normalizeWhitespace(content);
+    return normalized ? [normalized] : [];
+  }
+  if (!Array.isArray(content)) {
+    return [];
+  }
+  const textBlocks = [];
+  let nonTextBlockCount = 0;
+  for (const block of content) {
+    if (typeof block === "string") {
+      const normalized = normalizeWhitespace(block);
+      if (normalized) {
+        textBlocks.push(normalized);
+      }
+      continue;
+    }
+    const record = asRecord(block);
+    if (!record) {
+      continue;
+    }
+    if (typeof record.text === "string") {
+      const normalized = normalizeWhitespace(record.text);
+      if (normalized) {
+        textBlocks.push(normalized);
+      }
+      continue;
+    }
+    const type = typeof record.type === "string" ? record.type.trim().toLowerCase() : "";
+    if (typeof record.content === "string" && TEXT_BLOCK_TYPES.has(type)) {
+      const normalized = normalizeWhitespace(record.content);
+      if (normalized) {
+        textBlocks.push(normalized);
+      }
+      continue;
+    }
+    nonTextBlockCount += 1;
+  }
+  if (textBlocks.length === 0 && nonTextBlockCount > 0) {
+    textBlocks.push(`[non-text content omitted: ${nonTextBlockCount} block${nonTextBlockCount === 1 ? "" : "s"}]`);
+  }
+  return textBlocks;
+}
+function extractRawTextBlocks(content) {
+  if (typeof content === "string") {
+    return [content];
+  }
+  if (!Array.isArray(content)) {
+    return [];
+  }
+  const textBlocks = [];
+  for (const block of content) {
+    if (typeof block === "string") {
+      textBlocks.push(block);
+      continue;
+    }
+    const record = asRecord(block);
+    if (!record) {
+      continue;
+    }
+    if (typeof record.text === "string") {
+      textBlocks.push(record.text);
+      continue;
+    }
+    const type = typeof record.type === "string" ? record.type.trim().toLowerCase() : "";
+    if (typeof record.content === "string" && TEXT_BLOCK_TYPES.has(type)) {
+      textBlocks.push(record.content);
+    }
+  }
+  return textBlocks;
+}
+function normalizeLabel(value) {
+  return value.trim().toLowerCase().replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function normalizeMessageText(content) {
+  return normalizeWhitespace(extractTextBlocks(content).join("\n"));
+}
+function normalizeOpenClawRole(value) {
+  if (typeof value !== "string") {
+    return "unknown";
+  }
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "user" || normalized === "human") {
+    return "user";
+  }
+  if (normalized === "assistant" || normalized === "ai" || normalized === "developer") {
+    return "assistant";
+  }
+  if (normalized === "system") {
+    return "system";
+  }
+  if (normalized === "tool" || normalized === "toolresult" || normalized === "tool_result") {
+    return "toolResult";
+  }
+  return "unknown";
+}
+function truncateWithMarker(text, maxChars) {
+  if (text.length <= maxChars) {
+    return text;
+  }
+  return `${text.slice(0, maxChars)}
+[...truncated]`;
+}
+function isPureBase64(text) {
+  const trimmed = text.trim();
+  if (trimmed.length < 500) {
+    return false;
+  }
+  if (!/[+/=]/.test(trimmed)) {
+    return false;
+  }
+  return /^[A-Za-z0-9+/=\s]{500,}$/.test(trimmed);
+}
+function normalizeSessionLabel(value) {
+  const normalized = normalizeLabel(value);
+  return normalized.length > 0 ? normalized : void 0;
+}
+function extractConversationLabel(content) {
+  const rawTextBlocks = extractRawTextBlocks(content);
+  for (const block of rawTextBlocks) {
+    const matches = block.matchAll(/```(?:json)?\s*([\s\S]*?)\s*```/gi);
+    for (const match of matches) {
+      const candidate = match[1];
+      if (!candidate) {
+        continue;
+      }
+      try {
+        const parsed = JSON.parse(candidate);
+        const record = asRecord(parsed);
+        const conversationLabel = record ? getString(record.conversation_label) : void 0;
+        const normalizedLabel = conversationLabel ? normalizeSessionLabel(conversationLabel) : void 0;
+        if (normalizedLabel) {
+          return normalizedLabel;
+        }
+      } catch {
+      }
+    }
+  }
+  return void 0;
+}
+function extractAssistantTextParts(content) {
+  if (typeof content === "string") {
+    const normalized = normalizeWhitespace(content);
+    return normalized ? [normalized] : [];
+  }
+  if (!Array.isArray(content)) {
+    return [];
+  }
+  const textParts = [];
+  for (const block of content) {
+    if (typeof block === "string") {
+      const normalized = normalizeWhitespace(block);
+      if (normalized) {
+        textParts.push(normalized);
+      }
+      continue;
+    }
+    const record = asRecord(block);
+    if (!record) {
+      continue;
+    }
+    if (typeof record.text === "string") {
+      const normalized = normalizeWhitespace(record.text);
+      if (normalized) {
+        textParts.push(normalized);
+      }
+      continue;
+    }
+    const type = typeof record.type === "string" ? record.type.trim().toLowerCase() : "";
+    if (typeof record.content === "string" && TEXT_BLOCK_TYPES.has(type)) {
+      const normalized = normalizeWhitespace(record.content);
+      if (normalized) {
+        textParts.push(normalized);
+      }
+    }
+  }
+  return textParts;
+}
+function pushMessage(messages, role, text, timestamp) {
+  messages.push({
+    index: messages.length,
+    role,
+    text,
+    timestamp
+  });
+}
+
+// src/adapters/openclaw/transcript/timestamps.ts
+import * as fs from "fs/promises";
+function parseTimestampValue(value) {
+  if (typeof value === "string" && value.trim().length > 0) {
+    const parsed = new Date(value);
+    if (!Number.isNaN(parsed.getTime())) {
+      return parsed.toISOString();
+    }
+  }
+  if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+    const milliseconds = value > 1e12 ? value : value * 1e3;
+    const parsed = new Date(milliseconds);
+    if (!Number.isNaN(parsed.getTime())) {
+      return parsed.toISOString();
+    }
+  }
+  return void 0;
+}
+function extractTimestamp(record) {
+  for (const field of ["timestamp", "ts", "created_at", "createdAt", "time", "date"]) {
+    const parsed = parseTimestampValue(record[field]);
+    if (parsed) {
+      return parsed;
+    }
+  }
+  return void 0;
+}
+async function getFileMtimeTimestamp(filePath) {
+  try {
+    const stat2 = await fs.stat(filePath);
+    return parseTimestampValue(stat2.mtime.toISOString());
+  } catch {
+    return void 0;
+  }
+}
+async function resolveTimestampFallback(filePath, ...candidates) {
+  for (const candidate of candidates) {
+    const parsed = parseTimestampValue(candidate);
+    if (parsed) {
+      return parsed;
+    }
+  }
+  const fileMtime = await getFileMtimeTimestamp(filePath);
+  if (fileMtime) {
+    return fileMtime;
+  }
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+async function applyMessageTimestampFallbacks(filePath, messages, options) {
+  const fallbackTimestamp = await resolveTimestampFallback(filePath, options?.sessionTimestamp);
+  for (const message of messages) {
+    message.timestamp = parseTimestampValue(message.timestamp) ?? fallbackTimestamp;
+  }
+  return fallbackTimestamp;
+}
+
+// src/adapters/openclaw/transcript/parser.ts
+var SKIPPED_RECORD_TYPES = /* @__PURE__ */ new Set(["compaction", "custom", "thinking_level_change"]);
+var TOOL_RESULT_POLICY = {
+  dropToolNames: /* @__PURE__ */ new Set([...DEFAULT_TOOL_RESULT_DROP_NAMES, "agenr_recall", "image"]),
+  keepToolNames: new Set(DEFAULT_TOOL_RESULT_KEEP_NAMES.filter((name) => name !== "image"))
+};
+var RAW_TEXT_BLOCK_TYPES = /* @__PURE__ */ new Set(["input_text", "output_text", "text"]);
+var SENDER_METADATA_SENTINEL = "Sender (untrusted metadata):";
+var CONVERSATION_INFO_SENTINEL = "Conversation info (untrusted metadata):";
+var USER_METADATA_PREFIX_SENTINELS = /* @__PURE__ */ new Set([
+  SENDER_METADATA_SENTINEL,
+  CONVERSATION_INFO_SENTINEL,
+  "Thread starter (untrusted, for context):",
+  "Replied message (untrusted, for context):",
+  "Forwarded message context (untrusted metadata):",
+  "Chat history since last reply (untrusted, for context):"
+]);
+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: [],
+    messages: [],
+    stats: {
+      totalMessageRecords: 0,
+      systemDropped: 0,
+      base64Dropped: 0,
+      skippedRecordTypes: 0,
+      toolResultsDropped: 0,
+      toolResultsKept: 0
+    },
+    modelsUsed: [],
+    modelsUsedSet: /* @__PURE__ */ new Set(),
+    pendingToolCalls: [],
+    pendingToolCallsById: /* @__PURE__ */ new Map(),
+    detectedSurface: null,
+    surfaceDetected: false,
+    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;
+  }
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  const blocks = [];
+  for (const block of content) {
+    if (typeof block === "string") {
+      blocks.push(block);
+      continue;
+    }
+    const record = asRecord(block);
+    if (!record) {
+      continue;
+    }
+    if (typeof record.text === "string") {
+      blocks.push(record.text);
+      continue;
+    }
+    const type = typeof record.type === "string" ? record.type.trim().toLowerCase() : "";
+    if (typeof record.content === "string" && RAW_TEXT_BLOCK_TYPES.has(type)) {
+      blocks.push(record.content);
+    }
+  }
+  return blocks.join("\n");
+}
+function stripOpenClawUserMetadata(content) {
+  const normalizedText = normalizeMessageText(content);
+  if (normalizedText.length === 0) {
+    return normalizedText;
+  }
+  const rawText = extractRawMessageText(content);
+  if (rawText.length === 0 || !USER_METADATA_SENTINELS.some((sentinel) => rawText.includes(sentinel))) {
+    return normalizedText;
+  }
+  return normalizeMessageText(stripMetadataBlocks(rawText));
+}
+function stripMetadataBlocks(text) {
+  const lines = text.split(/\r?\n/u);
+  let index = 0;
+  while (index < lines.length) {
+    while (index < lines.length && lines[index]?.trim().length === 0) {
+      index += 1;
+    }
+    if (index >= lines.length) {
+      return "";
+    }
+    const line = lines[index]?.trim();
+    if (line === USER_METADATA_SUFFIX_SENTINEL) {
+      return "";
+    }
+    if (!line || !USER_METADATA_PREFIX_SENTINELS.has(line)) {
+      break;
+    }
+    const nextIndex = skipMetadataJsonFence(lines, index);
+    if (nextIndex === index) {
+      break;
+    }
+    index = nextIndex;
+  }
+  const suffixIndex = lines.findIndex((line, lineIndex) => lineIndex >= index && line.trim() === USER_METADATA_SUFFIX_SENTINEL);
+  const body = suffixIndex >= 0 ? lines.slice(index, suffixIndex) : lines.slice(index);
+  return body.join("\n").trim();
+}
+function skipMetadataJsonFence(lines, startIndex) {
+  let index = startIndex + 1;
+  while (index < lines.length && lines[index]?.trim().length === 0) {
+    index += 1;
+  }
+  if (index >= lines.length || !/^```(?:json)?\s*$/iu.test(lines[index]?.trim() ?? "")) {
+    return startIndex;
+  }
+  index += 1;
+  while (index < lines.length && !/^```\s*$/u.test(lines[index]?.trim() ?? "")) {
+    index += 1;
+  }
+  if (index >= lines.length) {
+    return startIndex;
+  }
+  index += 1;
+  while (index < lines.length && lines[index]?.trim().length === 0) {
+    index += 1;
+  }
+  return index;
+}
+function addModelUsed(state, value) {
+  const modelId = getString(value);
+  if (!modelId || state.modelsUsedSet.has(modelId)) {
+    return;
+  }
+  state.modelsUsedSet.add(modelId);
+  state.modelsUsed.push(modelId);
+}
+function setDetectedSurface(state, surface) {
+  if (state.surfaceDetected || !surface) {
+    return;
+  }
+  state.detectedSurface = surface;
+  state.surfaceDetected = true;
+}
+function readInboundSurface(record) {
+  const inboundMeta = asRecord(record.inbound_meta);
+  const surface = getString(inboundMeta?.surface)?.trim().toLowerCase();
+  return surface || null;
+}
+function extractMetadataPayload(rawText, sentinel) {
+  const lines = rawText.split(/\r?\n/u);
+  for (let index = 0; index < lines.length; index += 1) {
+    if (lines[index]?.trim() !== sentinel) {
+      continue;
+    }
+    let fenceIndex = index + 1;
+    while (fenceIndex < lines.length && lines[fenceIndex]?.trim().length === 0) {
+      fenceIndex += 1;
+    }
+    if (fenceIndex >= lines.length || !/^```(?:json)?\s*$/iu.test(lines[fenceIndex]?.trim() ?? "")) {
+      continue;
+    }
+    fenceIndex += 1;
+    const jsonLines = [];
+    while (fenceIndex < lines.length && !/^```\s*$/u.test(lines[fenceIndex]?.trim() ?? "")) {
+      jsonLines.push(lines[fenceIndex] ?? "");
+      fenceIndex += 1;
+    }
+    if (fenceIndex >= lines.length) {
+      continue;
+    }
+    try {
+      const parsed = JSON.parse(jsonLines.join("\n").trim());
+      return asRecord(parsed);
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function mapKnownSurface(value) {
+  if (!value) {
+    return null;
+  }
+  if (value.includes("telegram")) {
+    return "telegram";
+  }
+  if (value.includes("signal")) {
+    return "signal";
+  }
+  if (value.includes("discord")) {
+    return "discord";
+  }
+  if (value.includes("openclaw-tui")) {
+    return "tui";
+  }
+  if (value.includes("gateway-client") || value.includes("openclaw-control-ui") || value.includes("webchat")) {
+    return "webchat";
+  }
+  return null;
+}
+function extractSenderSurface(rawText) {
+  const payload = extractMetadataPayload(rawText, SENDER_METADATA_SENTINEL);
+  if (!payload) {
+    return null;
+  }
+  const label = getString(payload.label)?.trim().toLowerCase() ?? getString(payload.id)?.trim().toLowerCase() ?? "";
+  return mapKnownSurface(label);
+}
+function extractConversationInfoSurface(rawText) {
+  const payload = extractMetadataPayload(rawText, CONVERSATION_INFO_SENTINEL);
+  if (!payload) {
+    return null;
+  }
+  const senderId = getString(payload.sender_id)?.trim().toLowerCase() ?? "";
+  return mapKnownSurface(senderId);
+}
+function inferSurfaceFromContent(firstUserRawText) {
+  const normalized = firstUserRawText?.trim().toLowerCase() ?? "";
+  if (!normalized) {
+    return null;
+  }
+  if (normalized.includes("[subagent context]")) {
+    return "subagent";
+  }
+  if (normalized.includes("heartbeat.md")) {
+    return "heartbeat";
+  }
+  return null;
+}
+function resolveToolContext(state, message) {
+  const toolCallId = getString(message.toolCallId) ?? getString(message.tool_call_id) ?? getString(message.call_id) ?? getString(message.id);
+  if (toolCallId && state.pendingToolCallsById.has(toolCallId)) {
+    const context = state.pendingToolCallsById.get(toolCallId) ?? null;
+    state.pendingToolCallsById.delete(toolCallId);
+    if (context) {
+      const queuedIndex = state.pendingToolCalls.findIndex((toolCall) => toolCall.id === toolCallId);
+      if (queuedIndex >= 0) {
+        state.pendingToolCalls.splice(queuedIndex, 1);
+      }
+    }
+    return context;
+  }
+  return state.pendingToolCalls.shift() ?? null;
+}
+function handleMessageRecord(state, record, message) {
+  state.stats.totalMessageRecords += 1;
+  const role = normalizeOpenClawRole(message.role);
+  if (!state.surfaceDetected) {
+    setDetectedSurface(state, readInboundSurface(message));
+  }
+  if (!state.surfaceDetected && role === "user") {
+    const rawText = extractRawMessageText(message.content);
+    if (state.firstUserRawText === null) {
+      state.firstUserRawText = rawText;
+    }
+    setDetectedSurface(state, extractSenderSurface(rawText));
+    if (!state.surfaceDetected) {
+      setDetectedSurface(state, extractConversationInfoSurface(rawText));
+    }
+  }
+  if (role === "system") {
+    state.stats.systemDropped += 1;
+    return "known_skip";
+  }
+  const timestamp = extractTimestamp(record) ?? extractTimestamp(message);
+  if (role === "user") {
+    const extractedLabel = extractConversationLabel(message.content);
+    if (extractedLabel) {
+      state.sessionLabel = extractedLabel;
+    }
+    const text = stripOpenClawUserMetadata(message.content);
+    if (!text) {
+      return "known_skip";
+    }
+    if (isPureBase64(text)) {
+      state.stats.base64Dropped += 1;
+      return "known_skip";
+    }
+    pushMessage(state.messages, "user", text, timestamp);
+    return "accepted";
+  }
+  if (role === "assistant") {
+    const toolCalls = extractToolCallBlocks(message.content);
+    for (const toolCall of toolCalls) {
+      state.pendingToolCalls.push(toolCall);
+      if (toolCall.id) {
+        state.pendingToolCallsById.set(toolCall.id, toolCall);
+      }
+    }
+    const assistantText = [...extractAssistantTextParts(message.content), ...toolCalls.map((toolCall) => summarizeToolCall(toolCall))].join(" ").trim();
+    addModelUsed(state, message.model);
+    if (!assistantText) {
+      return "known_skip";
+    }
+    if (isPureBase64(assistantText)) {
+      state.stats.base64Dropped += 1;
+      return "known_skip";
+    }
+    pushMessage(state.messages, "assistant", truncateWithMarker(assistantText, 5e3), timestamp);
+    return "accepted";
+  }
+  if (role !== "toolResult") {
+    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 "known_skip";
+  }
+  if (isPureBase64(toolText)) {
+    state.stats.base64Dropped += 1;
+    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 "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 "accepted";
+  }
+  if (!state.surfaceDetected) {
+    setDetectedSurface(state, readInboundSurface(record));
+  }
+  if (record.type === "model_change") {
+    addModelUsed(state, record.modelId);
+    state.stats.skippedRecordTypes += 1;
+    return "known_skip";
+  }
+  if (typeof record.type === "string" && SKIPPED_RECORD_TYPES.has(record.type)) {
+    state.stats.skippedRecordTypes += 1;
+    return "known_skip";
+  }
+  const message = asRecord(record.message);
+  if (!message) {
+    return "structurally_invalid";
+  }
+  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.
+   *
+   * @param filePath - Absolute or relative path to the transcript file.
+   * @param options - Optional parser flags for verbose diagnostics.
+   * @returns Parsed transcript messages, warnings, and metadata.
+   */
+  async parseFile(filePath, options) {
+    const raw = await readTranscriptFileStrict(filePath);
+    const verbose = options?.verbose === true;
+    const state = createParseState();
+    const transcriptHash = createHash("sha256").update(raw).digest("hex");
+    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));
+    }
+    const fallbackTimestamp = state.messages.length > 0 ? await applyMessageTimestampFallbacks(filePath, state.messages, { sessionTimestamp: state.sessionTimestamp }) : await resolveTimestampFallback(filePath, state.sessionTimestamp);
+    if (verbose) {
+      state.warnings.push(buildFilterWarning(state.stats));
+    }
+    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,
+      metadata: {
+        sessionId: state.sessionId,
+        sessionLabel: state.sessionLabel,
+        startedAt,
+        endedAt,
+        messageCount: state.messages.length,
+        transcriptHash,
+        modelsUsed: state.modelsUsed.length > 0 ? state.modelsUsed : void 0,
+        reconstructedSurface: state.detectedSurface,
+        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/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",
+  "branch",
+  "build",
+  "cluster",
+  "daemon",
+  "device",
+  "env",
+  "environment",
+  "gateway",
+  "host",
+  "machine",
+  "node",
+  "plugin",
+  "project",
+  "repo",
+  "repository",
+  "server",
+  "service",
+  "session",
+  "system",
+  "workspace"
+]);
+function detectClaimKeyEntityFamilyCandidates(entries) {
+  const profiles = buildTrustedClaimKeyEntityProfiles(entries);
+  if (profiles.size < 2) {
+    return [];
+  }
+  const pairSupport = buildPairSupport(profiles);
+  if (pairSupport.length === 0) {
+    return [];
+  }
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const support of pairSupport) {
+    const [leftEntity, rightEntity] = support.entityPrefixes;
+    getOrCreateSet(adjacency, leftEntity).add(rightEntity);
+    getOrCreateSet(adjacency, rightEntity).add(leftEntity);
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const families = [];
+  for (const entityPrefix of adjacency.keys()) {
+    if (visited.has(entityPrefix)) {
+      continue;
+    }
+    const component = collectConnectedEntityComponent(entityPrefix, adjacency, visited);
+    if (component.length < 2) {
+      continue;
+    }
+    const componentSet = new Set(component);
+    const componentSupport = pairSupport.filter((support) => {
+      const [leftEntity, rightEntity] = support.entityPrefixes;
+      return componentSet.has(leftEntity) && componentSet.has(rightEntity);
+    });
+    const canonicalSelection = selectCanonicalEntityPrefix(component, componentSupport, profiles);
+    const canonicalEntityPrefix = canonicalSelection.canonicalEntityPrefix;
+    const autoConverge = canonicalEntityPrefix !== null && component.filter((entity) => entity !== canonicalEntityPrefix).every((entity) => {
+      const support = findPairSupport(componentSupport, canonicalEntityPrefix, entity);
+      return support?.autoSafe === true;
+    });
+    const componentProfiles = component.map((entity) => profiles.get(entity)).filter((profile) => Boolean(profile));
+    const 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);
+      })
+    });
+  }
+  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);
+  }
+  return [...counts.values()].sort((left, right) => {
+    if (right.activeEntryCount !== left.activeEntryCount) {
+      return right.activeEntryCount - left.activeEntryCount;
+    }
+    if (right.trustedEntryCount !== left.trustedEntryCount) {
+      return right.trustedEntryCount - left.trustedEntryCount;
+    }
+    return left.entityPrefix.localeCompare(right.entityPrefix);
+  });
+}
+function detectClaimKeySingletonAliasCandidates(observations) {
+  return detectClaimKeySingletonAliasCandidatesFromStats(summarizeClaimKeyEntityPrefixStats(observations));
+}
+function detectClaimKeySingletonAliasCandidatesFromStats(stats) {
+  const candidatesByAlias = /* @__PURE__ */ new Map();
+  const dominantFamilies = stats.filter((profile) => profile.trustedEntryCount >= SINGLETON_ALIAS_MIN_DOMINANT_TRUSTED_COUNT);
+  const aliasFamilies = stats.filter((profile) => {
+    return profile.activeEntryCount > 0 && profile.activeEntryCount <= SINGLETON_ALIAS_MAX_FAMILY_SIZE && profile.trustedEntryCount < profile.activeEntryCount && buildLowTrustEntryCount(profile) >= 1;
+  });
+  for (const aliasProfile of aliasFamilies) {
+    for (const dominantProfile of dominantFamilies) {
+      if (aliasProfile.entityPrefix === dominantProfile.entityPrefix || dominantProfile.activeEntryCount <= aliasProfile.activeEntryCount) {
+        continue;
+      }
+      const candidate = evaluateSingletonAliasCandidate(aliasProfile, dominantProfile);
+      if (!candidate) {
+        continue;
+      }
+      const existing = candidatesByAlias.get(aliasProfile.entityPrefix) ?? [];
+      existing.push(candidate);
+      candidatesByAlias.set(aliasProfile.entityPrefix, existing);
+    }
+  }
+  return [...candidatesByAlias.values()].flatMap(selectBestSingletonAliasCandidate).sort((left, right) => right.confidence - left.confidence || left.aliasEntityPrefix.localeCompare(right.aliasEntityPrefix));
+}
+function buildTrustedClaimKeyEntityProfiles(entries) {
+  const profiles = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const rawClaimKey = entry.claim_key?.trim();
+    if (!rawClaimKey) {
+      continue;
+    }
+    const inspection = inspectClaimKey(rawClaimKey);
+    if (!inspection.canonical || !inspection.normalized || inspection.suspectReasons.length > 0) {
+      continue;
+    }
+    const entityPrefix = inspection.normalized.entity;
+    const attribute = inspection.normalized.attribute;
+    const profile = getOrCreateProfile(profiles, entityPrefix);
+    profile.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 evaluateEntityFamilyPairSupport(leftProfile, rightProfile) {
+  const sharedAttributes = intersectSets(leftProfile.attributeSet, rightProfile.attributeSet);
+  if (sharedAttributes.length === 0) {
+    return null;
+  }
+  const sharedAttributeHeads = intersectSets(leftProfile.attributeHeadSet, rightProfile.attributeHeadSet);
+  const sharedTags = intersectSets(leftProfile.tags, rightProfile.tags);
+  const sharedSourceContextTokens = intersectSets(leftProfile.sourceContextTokens, rightProfile.sourceContextTokens);
+  const sharedSubjectTokens = intersectSets(leftProfile.subjectTokens, rightProfile.subjectTokens);
+  const lexicalRelation = evaluateEntityLexicalRelation(leftProfile, rightProfile);
+  const groundingScore = (sharedTags.length > 0 ? 1 : 0) + (sharedSourceContextTokens.length >= 3 ? 1 : 0) + (sharedSubjectTokens.length >= 2 ? 1 : 0);
+  const groundingAnchorCount = (sharedTags.length > 0 ? 1 : 0) + (sharedSourceContextTokens.length >= 3 ? 1 : 0);
+  const qualifies = sharedAttributes.length >= 3 || sharedAttributes.length >= 2 && (lexicalRelation.kind !== null || groundingAnchorCount >= 1) || sharedAttributes.length === 1 && lexicalRelation.kind !== null && groundingAnchorCount >= 1;
+  if (!qualifies) {
+    return null;
+  }
+  const evidence = [
+    {
+      kind: "shared_attribute_overlap",
+      detail: `Shared attributes: ${sharedAttributes.slice(0, MAX_EVIDENCE_VALUES).join(", ")}`
+    }
+  ];
+  if (sharedAttributeHeads.length >= 2) {
+    evidence.push({
+      kind: "shared_attribute_head_overlap",
+      detail: `Shared attribute families: ${sharedAttributeHeads.slice(0, MAX_EVIDENCE_VALUES).join(", ")}`
+    });
+  }
+  if (sharedTags.length > 0) {
+    evidence.push({
+      kind: "shared_tag_grounding",
+      detail: `Shared tags: ${sharedTags.slice(0, MAX_EVIDENCE_VALUES).join(", ")}`
+    });
+  }
+  if (sharedSourceContextTokens.length >= 2) {
+    evidence.push({
+      kind: "shared_source_context_grounding",
+      detail: `Shared source-context tokens: ${sharedSourceContextTokens.slice(0, MAX_EVIDENCE_VALUES).join(", ")}`
+    });
+  }
+  if (sharedSubjectTokens.length >= 2) {
+    evidence.push({
+      kind: "shared_subject_grounding",
+      detail: `Shared subject tokens: ${sharedSubjectTokens.slice(0, MAX_EVIDENCE_VALUES).join(", ")}`
+    });
+  }
+  if (lexicalRelation.kind && lexicalRelation.detail) {
+    evidence.push({
+      kind: lexicalRelation.kind,
+      detail: lexicalRelation.detail
+    });
+  }
+  const confidence = Math.min(
+    0.98,
+    0.48 + Math.min(sharedAttributes.length, 3) * 0.12 + Math.min(groundingScore, 3) * 0.08 + lexicalRelation.strengthScore * 0.05
+  );
+  return {
+    entityPrefixes: [leftProfile.entityPrefix, rightProfile.entityPrefix],
+    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 evaluateEntityLexicalRelation(leftProfile, rightProfile) {
+  const leftTokens = leftProfile.tokenList;
+  const rightTokens = rightProfile.tokenList;
+  if (leftProfile.compactSignature === rightProfile.compactSignature && leftProfile.entityPrefix !== rightProfile.entityPrefix) {
+    const preferredCanonicalEntityPrefix = leftTokens.length === rightTokens.length ? null : leftTokens.length > rightTokens.length ? leftProfile.entityPrefix : rightProfile.entityPrefix;
+    return {
+      kind: "lexical_separator_variant",
+      detail: preferredCanonicalEntityPrefix === null ? "Entity prefixes collapse to the same compact lexical form." : `Entity prefixes collapse to the same compact lexical form; "${preferredCanonicalEntityPrefix}" preserves clearer token boundaries.`,
+      autoSafe: true,
+      preferredCanonicalEntityPrefix,
+      strengthScore: 3
+    };
+  }
+  if (leftProfile.sortedTokenSignature.length > 0 && leftProfile.sortedTokenSignature === rightProfile.sortedTokenSignature && leftProfile.entityPrefix !== rightProfile.entityPrefix) {
+    return {
+      kind: "lexical_token_reordering",
+      detail: "Entity prefixes use the same lexical tokens in a different order.",
+      autoSafe: true,
+      preferredCanonicalEntityPrefix: null,
+      strengthScore: 2
+    };
+  }
+  const leftInitialism = buildInitialism(leftTokens);
+  const rightInitialism = buildInitialism(rightTokens);
+  if (leftInitialism.length >= 2 && leftInitialism === rightProfile.entityPrefix) {
+    return {
+      kind: "lexical_initialism_expansion",
+      detail: `Entity prefix "${rightProfile.entityPrefix}" matches the initialism of "${leftProfile.entityPrefix}".`,
+      autoSafe: false,
+      preferredCanonicalEntityPrefix: leftProfile.entityPrefix,
+      strengthScore: 1
+    };
+  }
+  if (rightInitialism.length >= 2 && rightInitialism === leftProfile.entityPrefix) {
+    return {
+      kind: "lexical_initialism_expansion",
+      detail: `Entity prefix "${leftProfile.entityPrefix}" matches the initialism of "${rightProfile.entityPrefix}".`,
+      autoSafe: false,
+      preferredCanonicalEntityPrefix: rightProfile.entityPrefix,
+      strengthScore: 1
+    };
+  }
+  if (isTokenSubset(leftTokens, rightTokens)) {
+    return {
+      kind: "lexical_token_subset",
+      detail: `"${leftProfile.entityPrefix}" is a lexical subset of "${rightProfile.entityPrefix}".`,
+      autoSafe: false,
+      preferredCanonicalEntityPrefix: rightProfile.entityPrefix,
+      strengthScore: 1
+    };
+  }
+  if (isTokenSubset(rightTokens, leftTokens)) {
+    return {
+      kind: "lexical_token_subset",
+      detail: `"${rightProfile.entityPrefix}" is a lexical subset of "${leftProfile.entityPrefix}".`,
+      autoSafe: false,
+      preferredCanonicalEntityPrefix: leftProfile.entityPrefix,
+      strengthScore: 1
+    };
+  }
+  return {
+    kind: null,
+    detail: null,
+    autoSafe: false,
+    preferredCanonicalEntityPrefix: null,
+    strengthScore: 0
+  };
+}
+function selectCanonicalEntityPrefix(entityPrefixes, pairSupport, profiles) {
+  const scoreByEntity = /* @__PURE__ */ new Map();
+  const reasonsByEntity = /* @__PURE__ */ new Map();
+  for (const entityPrefix of entityPrefixes) {
+    const profile = profiles.get(entityPrefix);
+    if (!profile) {
+      continue;
+    }
+    let score = Math.min(profile.attributeSet.size, 6) * 2 + Math.min(profile.entryCount, 6) + Math.round(profile.totalQualityScore / Math.max(profile.entryCount, 1));
+    const reasons = [];
+    if (profile.attributeSet.size >= 2) {
+      reasons.push("broader trusted attribute coverage");
+    }
+    for (const support of pairSupport) {
+      if (support.preferredCanonicalEntityPrefix === entityPrefix) {
+        score += 4;
+      } else if (support.preferredCanonicalEntityPrefix !== null) {
+        score -= 2;
+      }
+    }
+    const formSpecificity = scoreEntityFormSpecificity(entityPrefix, entityPrefixes, profiles);
+    score += formSpecificity.score;
+    if (formSpecificity.reason) {
+      reasons.push(formSpecificity.reason);
+    }
+    const lexicalVotes2 = pairSupport.filter((support) => support.preferredCanonicalEntityPrefix === entityPrefix).length;
+    if (lexicalVotes2 > 0) {
+      reasons.push(`lexical alias evidence prefers "${entityPrefix}"`);
+    }
+    scoreByEntity.set(entityPrefix, score);
+    reasonsByEntity.set(entityPrefix, normalizeStringArray(reasons));
+  }
+  const ranked = [...scoreByEntity.entries()].sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]));
+  const [bestCandidate, secondCandidate] = ranked;
+  if (!bestCandidate) {
+    return {
+      canonicalEntityPrefix: null,
+      reasons: [],
+      unresolvedReason: "No canonical entity prefix could be selected from the detected family."
+    };
+  }
+  const [bestEntityPrefix, bestScore] = bestCandidate;
+  const secondScore = secondCandidate?.[1] ?? Number.NEGATIVE_INFINITY;
+  const bestProfile = profiles.get(bestEntityPrefix);
+  if (!bestProfile) {
+    return {
+      canonicalEntityPrefix: null,
+      reasons: [],
+      unresolvedReason: "No canonical entity prefix could be selected from the detected family."
+    };
+  }
+  const directPeerSupport = entityPrefixes.filter((entityPrefix) => entityPrefix !== bestEntityPrefix).map((entityPrefix) => findPairSupport(pairSupport, bestEntityPrefix, entityPrefix));
+  const hasDirectSupportToAllPeers = directPeerSupport.every((support) => support !== null);
+  const hasLexicalSupportToAllPeers = directPeerSupport.every((support) => support?.evidence.some((evidence) => evidence.kind.startsWith("lexical_")) === true);
+  const lexicalVotes = pairSupport.filter((support) => support.preferredCanonicalEntityPrefix === bestEntityPrefix).length;
+  if (!hasDirectSupportToAllPeers || !hasLexicalSupportToAllPeers || lexicalVotes === 0 || bestScore - secondScore < CANONICAL_SELECTION_MARGIN) {
+    return {
+      canonicalEntityPrefix: null,
+      reasons: [],
+      unresolvedReason: "Multiple plausible canonical entity prefixes remain after conservative scoring."
+    };
+  }
+  return {
+    canonicalEntityPrefix: bestEntityPrefix,
+    reasons: reasonsByEntity.get(bestEntityPrefix) ?? [],
+    unresolvedReason: null
+  };
+}
+function scoreEntityFormSpecificity(entityPrefix, entityPrefixes, profiles) {
+  const profile = profiles.get(entityPrefix);
+  if (!profile) {
+    return { score: 0, reason: null };
+  }
+  let score = 0;
+  let reason = null;
+  const compactPeers = entityPrefixes.filter((peerEntityPrefix) => peerEntityPrefix !== entityPrefix).map((peerEntityPrefix) => profiles.get(peerEntityPrefix)).filter((peerProfile) => Boolean(peerProfile)).filter((peerProfile) => peerProfile.compactSignature === profile.compactSignature);
+  if (profile.tokenList.length >= 2 && compactPeers.some((peerProfile) => peerProfile.tokenList.length < profile.tokenList.length)) {
+    score += 2;
+    reason = "less abbreviated lexical form";
+  }
+  if (entityPrefix.length <= 3 && compactPeers.length === 0) {
+    score -= 1;
+  }
+  return { score, reason };
+}
+function collectConnectedEntityComponent(startingEntityPrefix, adjacency, visited) {
+  const queue = [startingEntityPrefix];
+  const component = [];
+  visited.add(startingEntityPrefix);
+  while (queue.length > 0) {
+    const entityPrefix = queue.shift();
+    if (!entityPrefix) {
+      continue;
+    }
+    component.push(entityPrefix);
+    const peers = adjacency.get(entityPrefix);
+    if (!peers) {
+      continue;
+    }
+    for (const peer of peers) {
+      if (visited.has(peer)) {
+        continue;
+      }
+      visited.add(peer);
+      queue.push(peer);
+    }
+  }
+  return component;
+}
+function findPairSupport(pairSupport, leftEntityPrefix, rightEntityPrefix) {
+  for (const support of pairSupport) {
+    const [leftEntity, rightEntity] = support.entityPrefixes;
+    if (leftEntity === leftEntityPrefix && rightEntity === rightEntityPrefix || leftEntity === rightEntityPrefix && rightEntity === leftEntityPrefix) {
+      return support;
+    }
+  }
+  return null;
+}
+function evaluateSingletonAliasCandidate(aliasProfile, dominantProfile) {
+  const lexicalRelation = evaluateSingletonAliasLexicalRelation(aliasProfile.entityPrefix, dominantProfile.entityPrefix);
+  if (!lexicalRelation.kind || !lexicalRelation.detail || lexicalRelation.scopeLike) {
+    return null;
+  }
+  const dominantTrustedCount = dominantProfile.trustedEntryCount;
+  if (dominantTrustedCount < SINGLETON_ALIAS_MIN_DOMINANT_TRUSTED_COUNT) {
+    return null;
+  }
+  const aliasLowTrustCount = buildLowTrustEntryCount(aliasProfile);
+  if (aliasLowTrustCount === 0) {
+    return null;
+  }
+  const evidence = [
+    {
+      kind: "singleton_family_size",
+      detail: `"${aliasProfile.entityPrefix}" has ${aliasProfile.activeEntryCount} active keyed ${pluralize(aliasProfile.activeEntryCount, "entry")}.`
+    },
+    {
+      kind: "dominant_trusted_family",
+      detail: `"${dominantProfile.entityPrefix}" already has ${dominantTrustedCount} trusted ${pluralize(dominantTrustedCount, "entry")}.`
+    },
+    {
+      kind: "low_trust_creation_path",
+      detail: describeLowTrustAliasFamily(aliasProfile)
+    },
+    {
+      kind: lexicalRelation.kind,
+      detail: lexicalRelation.detail
+    }
+  ];
+  const confidence = Math.min(
+    0.98,
+    0.58 + Math.min(dominantTrustedCount, 6) * 0.05 + Math.min(aliasLowTrustCount, 2) * 0.05 + Math.min(dominantProfile.activeEntryCount - aliasProfile.activeEntryCount, 6) * 0.02 + lexicalRelation.strengthScore * 0.08
+  );
+  return {
+    aliasEntityPrefix: aliasProfile.entityPrefix,
+    dominantEntityPrefix: dominantProfile.entityPrefix,
+    aliasFamilySize: aliasProfile.activeEntryCount,
+    dominantFamilySize: dominantProfile.activeEntryCount,
+    dominantTrustedCount,
+    aliasLowTrustCount,
+    confidence,
+    canonicalReuseSafe: lexicalRelation.canonicalReuseSafe && aliasProfile.activeEntryCount === 1 && aliasLowTrustCount === aliasProfile.activeEntryCount && dominantTrustedCount >= SINGLETON_ALIAS_MIN_DOMINANT_TRUSTED_COUNT,
+    evidence
+  };
+}
+function selectBestSingletonAliasCandidate(candidates) {
+  const ranked = [...candidates].sort(
+    (left, right) => right.confidence - left.confidence || left.dominantEntityPrefix.localeCompare(right.dominantEntityPrefix)
+  );
+  const [best, runnerUp] = ranked;
+  if (!best) {
+    return [];
+  }
+  if (runnerUp && best.confidence - runnerUp.confidence < SINGLETON_ALIAS_MIN_CONFIDENCE_DELTA) {
+    return [];
+  }
+  return [best];
+}
+function evaluateSingletonAliasLexicalRelation(aliasEntityPrefix, dominantEntityPrefix) {
+  const aliasTokens = aliasEntityPrefix.split("_").filter((token) => token.length > 0);
+  const dominantTokens = dominantEntityPrefix.split("_").filter((token) => token.length > 0);
+  const aliasCompactSignature = aliasTokens.join("");
+  const dominantCompactSignature = dominantTokens.join("");
+  if (aliasCompactSignature === dominantCompactSignature && aliasEntityPrefix !== dominantEntityPrefix) {
+    return {
+      kind: "lexical_separator_variant",
+      detail: `Entity prefixes "${aliasEntityPrefix}" and "${dominantEntityPrefix}" collapse to the same compact lexical form.`,
+      canonicalReuseSafe: true,
+      scopeLike: false,
+      strengthScore: 3
+    };
+  }
+  if (!isTokenSubset(dominantTokens, aliasTokens)) {
+    return {
+      kind: null,
+      detail: null,
+      canonicalReuseSafe: false,
+      scopeLike: false,
+      strengthScore: 0
+    };
+  }
+  const dominantTokenSet = new Set(dominantTokens);
+  const addedTokens = aliasTokens.filter((token) => !dominantTokenSet.has(token));
+  const scopeLike = addedTokens.length !== 1 || addedTokens.some((token) => SINGLETON_ALIAS_SCOPE_TOKENS.has(token));
+  if (scopeLike) {
+    return {
+      kind: null,
+      detail: null,
+      canonicalReuseSafe: false,
+      scopeLike: true,
+      strengthScore: 0
+    };
+  }
+  return {
+    kind: "lexical_token_subset",
+    detail: `"${aliasEntityPrefix}" extends "${dominantEntityPrefix}" by the added token "${addedTokens[0]}".`,
+    canonicalReuseSafe: true,
+    scopeLike: false,
+    strengthScore: 2
+  };
+}
+function buildLowTrustEntryCount(profile) {
+  const deterministicOnlyCount = Math.max(0, profile.deterministicRepairEntryCount - profile.tentativeEntryCount);
+  return profile.tentativeEntryCount + profile.unresolvedEntryCount + deterministicOnlyCount;
+}
+function describeLowTrustAliasFamily(profile) {
+  const reasons = [];
+  if (profile.deterministicRepairEntryCount > 0) {
+    reasons.push(`${profile.deterministicRepairEntryCount} deterministic repair ${pluralize(profile.deterministicRepairEntryCount, "entry")}`);
+  }
+  if (profile.tentativeEntryCount > 0) {
+    reasons.push(`${profile.tentativeEntryCount} tentative ${pluralize(profile.tentativeEntryCount, "entry")}`);
+  }
+  if (profile.unresolvedEntryCount > 0) {
+    reasons.push(`${profile.unresolvedEntryCount} unresolved ${pluralize(profile.unresolvedEntryCount, "entry")}`);
+  }
+  if (reasons.length === 0) {
+    return `"${profile.entityPrefix}" is not fully trusted yet.`;
+  }
+  return `"${profile.entityPrefix}" is low-trust because it has ${reasons.join(", ")}.`;
+}
+function buildInitialism(tokens) {
+  if (tokens.length < 2) {
+    return "";
+  }
+  return tokens.map((token) => token[0] ?? "").join("");
+}
+function isTokenSubset(subsetTokens, supersetTokens) {
+  if (subsetTokens.length === 0 || subsetTokens.length >= supersetTokens.length) {
+    return false;
+  }
+  const superset = new Set(supersetTokens);
+  return subsetTokens.every((token) => superset.has(token));
+}
+function tokenizeGrounding(value) {
+  if (!value) {
+    return [];
+  }
+  const normalized = normalizeClaimKeySegment(value);
+  if (!normalized) {
+    return [];
+  }
+  return normalized.split("_").filter((token) => token.length >= 2 && !ENTITY_FAMILY_GROUNDING_STOP_TOKENS.has(token));
+}
+function intersectSets(left, right) {
+  const intersection = [];
+  const [small, large] = left.size <= right.size ? [left, right] : [right, left];
+  for (const value of small) {
+    if (large.has(value)) {
+      intersection.push(value);
+    }
+  }
+  return intersection.sort((first, second) => first.localeCompare(second));
+}
+function normalizeStringArray(values) {
+  return Array.from(new Set(values.map((value) => value.trim()).filter((value) => value.length > 0)));
+}
+function buildPairKey(leftEntityPrefix, rightEntityPrefix) {
+  return [leftEntityPrefix, rightEntityPrefix].sort((left, right) => left.localeCompare(right)).join("::");
+}
+function getOrCreateSet(map, key) {
+  const existing = map.get(key);
+  if (existing) {
+    return existing;
+  }
+  const created = /* @__PURE__ */ new Set();
+  map.set(key, created);
+  return created;
+}
+function pluralize(count, noun) {
+  return count === 1 ? noun : `${noun}s`;
+}
+
+// src/core/claim-key-support.ts
+var MAX_AUTO_APPLY_ATTRIBUTE_TOKENS = 4;
+var GROUNDING_STOP_TOKENS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "as",
+  "at",
+  "be",
+  "by",
+  "for",
+  "from",
+  "how",
+  "in",
+  "into",
+  "is",
+  "it",
+  "of",
+  "on",
+  "or",
+  "our",
+  "that",
+  "the",
+  "their",
+  "this",
+  "to",
+  "we",
+  "with"
+]);
+var AWKWARD_AUTO_APPLY_ATTRIBUTE_TOKENS = /* @__PURE__ */ new Set(["to", "for", "from", "with", "about", "into", "onto", "between", "during"]);
+var POLICY_TEMPLATE_ATTRIBUTE_TOKENS = /* @__PURE__ */ new Set(["policy", "default", "workflow", "process", "strategy", "guardrail", "rule", "boundary"]);
+var AUTHORITATIVE_TEMPLATE_ATTRIBUTE_TOKENS = /* @__PURE__ */ new Set(["source", "truth", "guide", "runbook", "reference"]);
+var ARCHITECTURE_TEMPLATE_ATTRIBUTE_TOKENS = /* @__PURE__ */ new Set([
+  "adapter",
+  "boundary",
+  "architecture",
+  "backend",
+  "storage",
+  "model",
+  "support",
+  "contract",
+  "interface",
+  "surface"
+]);
+var STABLE_FAMILY_SLOT_ATTRIBUTE_HEADS = /* @__PURE__ */ new Set([
+  "access",
+  "boundary",
+  "condition",
+  "contract",
+  "dependency",
+  "mode",
+  "owner",
+  "order",
+  "path",
+  "policy",
+  "preference",
+  "preservation",
+  "process",
+  "requirement",
+  "role",
+  "rule",
+  "schedule",
+  "sequencing",
+  "setting",
+  "status",
+  "strategy",
+  "support",
+  "surface",
+  "timezone",
+  "version",
+  "window",
+  "workflow",
+  "workspace"
+]);
+function buildTrustedClaimKeySupportSeed(entries) {
+  const claimKeyStats = /* @__PURE__ */ new Map();
+  const trustedEntries = [];
+  for (const entry of entries) {
+    const claimKey = entry.claim_key?.trim();
+    if (!claimKey || !isTrustedClaimKeyForCleanup(claimKey)) {
+      continue;
+    }
+    const inspection = inspectClaimKey(claimKey);
+    if (!inspection.normalized) {
+      continue;
+    }
+    const existing = claimKeyStats.get(claimKey);
+    if (existing) {
+      existing.count += 1;
+      existing.maxImportance = Math.max(existing.maxImportance, entry.importance);
+      existing.latestCreatedAt = existing.latestCreatedAt.localeCompare(entry.created_at) >= 0 ? existing.latestCreatedAt : entry.created_at;
+      continue;
+    }
+    claimKeyStats.set(claimKey, {
+      count: 1,
+      maxImportance: entry.importance,
+      latestCreatedAt: entry.created_at
+    });
+    trustedEntries.push({
+      id: entry.id,
+      claimKey: inspection.normalized.claimKey,
+      entity: inspection.normalized.entity,
+      attribute: inspection.normalized.attribute,
+      type: entry.type,
+      tags: normalizeGroundingTags(entry.tags),
+      sourceContextTokens: tokenizeGroundingText(entry.source_context),
+      subjectTokens: tokenizeGroundingText(entry.subject),
+      createdAt: entry.created_at
+    });
+  }
+  const orderedClaimKeys = [...claimKeyStats.entries()].sort((left, right) => {
+    const countDelta = right[1].count - left[1].count;
+    if (countDelta !== 0) {
+      return countDelta;
+    }
+    const importanceDelta = right[1].maxImportance - left[1].maxImportance;
+    if (importanceDelta !== 0) {
+      return importanceDelta;
+    }
+    const createdAtDelta = right[1].latestCreatedAt.localeCompare(left[1].latestCreatedAt);
+    if (createdAtDelta !== 0) {
+      return createdAtDelta;
+    }
+    return left[0].localeCompare(right[0]);
+  }).map(([claimKey]) => claimKey);
+  const orderedEntries = orderedClaimKeys.flatMap(
+    (claimKey) => trustedEntries.filter((entry) => entry.claimKey === claimKey).sort((left, right) => {
+      const createdAtDelta = right.createdAt.localeCompare(left.createdAt);
+      if (createdAtDelta !== 0) {
+        return createdAtDelta;
+      }
+      return left.id.localeCompare(right.id);
+    })
+  );
+  return {
+    entries: orderedEntries
+  };
+}
+function buildClaimKeySupportSeedFromExamples(claimKeys) {
+  const entries = claimKeys.flatMap((claimKey, index) => {
+    const inspection = inspectClaimKey(claimKey);
+    if (!inspection.normalized || !isTrustedClaimKeyForCleanup(inspection.normalized.claimKey)) {
+      return [];
+    }
+    return [
+      {
+        id: `example:${index + 1}`,
+        claimKey: inspection.normalized.claimKey,
+        entity: inspection.normalized.entity,
+        attribute: inspection.normalized.attribute,
+        tags: [],
+        sourceContextTokens: [],
+        subjectTokens: [],
+        createdAt: "1970-01-01T00:00:00.000Z"
+      }
+    ];
+  });
+  return { entries };
+}
+function evaluateClaimKeySupport(entry, targetClaimKey, trustedHints) {
+  const inspection = inspectClaimKey(targetClaimKey);
+  const normalized = inspection.normalized;
+  if (!normalized) {
+    return createEmptyClaimKeySupportEvaluation();
+  }
+  const entryTagSet = new Set(normalizeGroundingTags(entry.tags));
+  const entrySourceTokens = new Set(tokenizeGroundingText(entry.source_context));
+  const relevantEntries = trustedHints.entries.filter((trustedEntry) => {
+    if (entry.id && trustedEntry.id === entry.id) {
+      return false;
+    }
+    return trustedEntry.claimKey === normalized.claimKey || trustedEntry.entity === normalized.entity;
+  });
+  const exactReuseEntries = relevantEntries.filter((trustedEntry) => trustedEntry.claimKey === normalized.claimKey);
+  const familyReuseEntries = relevantEntries.filter(
+    (trustedEntry) => trustedEntry.claimKey !== normalized.claimKey && trustedEntry.entity === normalized.entity
+  );
+  const groundedExactReuseEntries = exactReuseEntries.filter((trustedEntry) => {
+    const grounding = inspectGroundingOverlap(entryTagSet, entrySourceTokens, trustedEntry);
+    return grounding.tagGrounding || grounding.sourceContextGrounding;
+  });
+  const groundedFamilyReuseEntries = familyReuseEntries.filter((trustedEntry) => {
+    const grounding = inspectGroundingOverlap(entryTagSet, entrySourceTokens, trustedEntry);
+    return grounding.tagGrounding || grounding.sourceContextGrounding;
+  });
+  const tagGrounding = relevantEntries.some((trustedEntry) => inspectGroundingOverlap(entryTagSet, entrySourceTokens, trustedEntry).tagGrounding);
+  const sourceContextGrounding = relevantEntries.some(
+    (trustedEntry) => inspectGroundingOverlap(entryTagSet, entrySourceTokens, trustedEntry).sourceContextGrounding
+  );
+  const localGrounding = tagGrounding || sourceContextGrounding;
+  const lexicalAlignment = inspectCandidateLexicalAlignment(entry, normalized.entity, normalized.attribute);
+  const templateSupport = matchesConservativeTemplateSupport(entry, normalized.attribute);
+  const stableSlotSupport = matchesStableFamilySlotSupport(normalized.attribute);
+  const trustedExactReuse = exactReuseEntries.length > 0 && (groundedExactReuseEntries.length > 0 || exactReuseEntries.every((candidate) => candidate.id.startsWith("example:")));
+  const trustedEntityFamilyReuse = groundedFamilyReuseEntries.length > 0 || familyReuseEntries.some((candidate) => candidate.id.startsWith("example:"));
+  const promotionSupport = resolveClaimKeyPromotionSupport({
+    exactReuseCount: trustedExactReuse ? Math.max(1, groundedExactReuseEntries.length) : 0,
+    familyReuseCount: familyReuseEntries.length,
+    groundedFamilyReuseCount: groundedFamilyReuseEntries.length > 0 ? groundedFamilyReuseEntries.length : familyReuseEntries.some((candidate) => candidate.id.startsWith("example:")) ? familyReuseEntries.length : 0,
+    localGrounding: localGrounding || familyReuseEntries.some((candidate) => candidate.id.startsWith("example:")),
+    templateSupport,
+    stableSlotSupport,
+    lexicalAlignment
+  });
+  const supportedProposal = lexicalAlignment.any && (templateSupport || stableSlotSupport || trustedExactReuse || trustedEntityFamilyReuse || localGrounding);
+  const supportEvidence = [
+    trustedExactReuse ? "trusted_exact_reuse" : null,
+    trustedEntityFamilyReuse ? "trusted_entity_family_reuse" : null,
+    tagGrounding ? "tag_grounding" : null,
+    sourceContextGrounding ? "source_context_grounding" : null,
+    lexicalAlignment.entity ? "entity_lexical_alignment" : null,
+    lexicalAlignment.attribute ? "attribute_lexical_alignment" : null,
+    lexicalAlignment.strongEntityAttribute ? "strong_entity_attribute_lexical_alignment" : null,
+    templateSupport ? "template_support" : null,
+    stableSlotSupport ? "stable_slot_support" : null,
+    promotionSupport.relaxedStableSlotFamilyGate ? "single_grounded_family_sibling" : null
+  ].filter((value) => value !== null);
+  const rationaleFragments = [
+    trustedExactReuse ? `trusted exact reuse from ${Math.max(1, groundedExactReuseEntries.length)} matching entr${Math.max(1, groundedExactReuseEntries.length) === 1 ? "y" : "ies"}` : null,
+    trustedEntityFamilyReuse ? `trusted ${normalized.entity} family reuse from ${Math.max(1, groundedFamilyReuseEntries.length || familyReuseEntries.length)} supporting entr${Math.max(1, groundedFamilyReuseEntries.length || familyReuseEntries.length) === 1 ? "y" : "ies"}` : null,
+    tagGrounding ? "overlapping tags with trusted corpus entries" : null,
+    sourceContextGrounding ? "overlapping source_context with trusted corpus entries" : null,
+    lexicalAlignment.strongEntityAttribute ? "strong entity and slot lexical alignment" : null,
+    lexicalAlignment.attribute ? lexicalAlignment.strongEntityAttribute ? null : "clear lexical alignment to the proposed slot" : lexicalAlignment.entity ? "clear lexical alignment to the proposed entity" : null,
+    templateSupport ? "a conservative policy/default/source-of-truth template match" : null,
+    stableSlotSupport ? "a stable compact slot head in a well-established entity family" : null,
+    promotionSupport.relaxedStableSlotFamilyGate ? "one grounded family sibling cleared the stable-slot family gate" : null
+  ].filter((value) => value !== null);
+  return {
+    autoApplyClass: promotionSupport.autoApplyClass,
+    supportedProposal,
+    trustedExactReuse,
+    trustedEntityFamilyReuse,
+    tagGrounding,
+    sourceContextGrounding,
+    localGrounding,
+    entityLexicalAlignment: lexicalAlignment.entity,
+    attributeLexicalAlignment: lexicalAlignment.attribute,
+    strongEntityAttributeLexicalAlignment: lexicalAlignment.strongEntityAttribute,
+    lexicalAlignment: lexicalAlignment.any,
+    templateSupport,
+    stableSlotSupport,
+    familyReuseCount: familyReuseEntries.length,
+    groundedFamilyReuseCount: groundedFamilyReuseEntries.length,
+    relaxedStableSlotFamilyGate: promotionSupport.relaxedStableSlotFamilyGate,
+    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 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 evaluateClaimKeyCompactness(claimKey, prior) {
+  const compacted = compactClaimKey(claimKey);
+  if (!compacted) {
+    return {
+      claimKey,
+      compactedFrom: null,
+      compactionReason: null,
+      compactEnoughForAutoApply: false,
+      blockerReason: "invalid_claim_key"
+    };
+  }
+  const attributeTokens = compacted.attribute.split("_").filter((token) => token.length > 0);
+  const compactEnoughForAutoApply = attributeTokens.length > 0 && attributeTokens.length <= MAX_AUTO_APPLY_ATTRIBUTE_TOKENS && !attributeTokens.some((token) => AWKWARD_AUTO_APPLY_ATTRIBUTE_TOKENS.has(token));
+  const compactedFrom = compacted.compactedFrom ?? prior?.priorCompactedFrom ?? null;
+  const compactionReason = compacted.reason && prior?.priorCompactionReason ? `${prior.priorCompactionReason} and ${compacted.reason}` : compacted.reason ?? prior?.priorCompactionReason ?? null;
+  return {
+    claimKey: compacted.claimKey,
+    compactedFrom,
+    compactionReason,
+    compactEnoughForAutoApply,
+    blockerReason: compactEnoughForAutoApply ? null : "non_compact_canonical_slot"
+  };
+}
+function normalizeGroundingTags(tags) {
+  return normalizeStringArray2((tags ?? []).map((tag) => normalizeClaimKeySegment(tag)).filter((tag) => tag.length > 0));
+}
+function tokenizeGroundingText(value) {
+  if (!value) {
+    return [];
+  }
+  return normalizeStringArray2(
+    value.split(/[^a-zA-Z0-9]+/u).map((token) => normalizeClaimKeySegment(token)).filter((token) => token.length > 2 && !GROUNDING_STOP_TOKENS.has(token))
+  );
+}
+function buildEntryLocalLexicalTokens(entry) {
+  return normalizeStringArray2([
+    ...tokenizeGroundingText(entry.subject),
+    ...tokenizeGroundingText(entry.content),
+    ...tokenizeGroundingText(entry.source_context),
+    ...normalizeGroundingTags(entry.tags)
+  ]);
+}
+function resolveClaimKeyPromotionSupport(input) {
+  if (input.exactReuseCount > 0 && (input.lexicalAlignment.attribute || input.templateSupport)) {
+    return {
+      autoApplyClass: "trusted_exact_reuse_grounded",
+      relaxedStableSlotFamilyGate: false
+    };
+  }
+  if (input.templateSupport && input.localGrounding && input.familyReuseCount > 0 && (input.lexicalAlignment.attribute || input.lexicalAlignment.entity)) {
+    return {
+      autoApplyClass: "trusted_family_template_grounded",
+      relaxedStableSlotFamilyGate: false
+    };
+  }
+  const relaxedStableSlotFamilyGate = input.stableSlotSupport && input.localGrounding && input.groundedFamilyReuseCount > 0 && input.familyReuseCount === 1 && input.lexicalAlignment.strongEntityAttribute;
+  if (input.stableSlotSupport && input.localGrounding && input.groundedFamilyReuseCount > 0 && (input.familyReuseCount >= 2 || relaxedStableSlotFamilyGate) && input.lexicalAlignment.attribute) {
+    return {
+      autoApplyClass: "trusted_family_stable_slot",
+      relaxedStableSlotFamilyGate
+    };
+  }
+  if (input.localGrounding && input.groundedFamilyReuseCount > 0 && input.lexicalAlignment.strongEntityAttribute) {
+    return {
+      autoApplyClass: "trusted_family_grounded_alignment",
+      relaxedStableSlotFamilyGate: false
+    };
+  }
+  return {
+    autoApplyClass: null,
+    relaxedStableSlotFamilyGate: false
+  };
+}
+function inspectGroundingOverlap(entryTagSet, entrySourceTokens, trustedEntry) {
+  return {
+    tagGrounding: countSetOverlap(entryTagSet, trustedEntry.tags) > 0,
+    sourceContextGrounding: countSetOverlap(entrySourceTokens, trustedEntry.sourceContextTokens) > 0
+  };
+}
+function inspectCandidateLexicalAlignment(entry, entity, attribute) {
+  const lexicalTokens = new Set(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_ENTITIES = /* @__PURE__ */ new Set(["i", "me", "the_user", "myself", "user", "we", "our_team", "the_project", "this_project"]);
+var USER_REFERENTIAL_ENTITIES = /* @__PURE__ */ new Set(["i", "me", "myself", "the_user", "user"]);
+var PROJECT_REFERENTIAL_ENTITIES = /* @__PURE__ */ new Set(["the_project", "this_project"]);
+var DETERMINISTIC_ATTRIBUTE_HEADS = /* @__PURE__ */ new Set([
+  "budget",
+  "city",
+  "config",
+  "deadline",
+  "email",
+  "employer",
+  "language",
+  "limit",
+  "location",
+  "mode",
+  "model",
+  "name",
+  "owner",
+  "plan",
+  "policy",
+  "preference",
+  "priority",
+  "quota",
+  "region",
+  "role",
+  "schedule",
+  "setting",
+  "status",
+  "strategy",
+  "team",
+  "theme",
+  "timezone",
+  "version",
+  "window"
+]);
+var MAX_ENTITY_HINTS = 12;
+var MAX_CLAIM_KEY_EXAMPLES = 8;
+var MAX_SUPPORT_CLAIM_KEY_EXAMPLES = 128;
+var DEFAULT_REPAIR_CONFIDENCE = 0.86;
+var HIGH_CONFIDENCE_BACKFILL_THRESHOLD = 0.92;
+var SUPPORTED_INGEST_AUTO_APPLY_THRESHOLD = 0.72;
+var COMPACTED_SUPPORTED_INGEST_AUTO_APPLY_THRESHOLD = 0.74;
+var PROPOSAL_CONFIDENCE_THRESHOLD = 0.75;
+var SUPPORTED_PROPOSAL_CONFIDENCE_THRESHOLD = 0.65;
+function applyClaimExtractionResultToEntry(entry, extracted) {
+  const lifecycle = buildExtractedClaimKeyLifecycle(extracted, buildInferredIngestClaimKeySupportContext(entry));
+  if (!lifecycle) {
+    return;
+  }
+  applyClaimKeyLifecycle(entry, lifecycle);
+}
+async function previewClaimKeyExtraction(entry, llm, config, options = {}) {
+  if (!config.enabled || !config.eligibleTypes.includes(entry.type)) {
+    return null;
+  }
+  const normalizedHints = normalizeClaimExtractionHints(options.hints ?? {});
+  let attempt;
+  try {
+    attempt = await attemptClaimExtraction(entry, normalizedHints, llm);
+  } catch (error) {
+    const repaired = tryDeterministicClaimKeyRepair(entry, normalizedHints);
+    if (repaired) {
+      return repaired;
+    }
+    throw error;
+  }
+  if (attempt.response.no_claim === true) {
+    options.onPreviewOutcome?.(buildPreviewOutcome("no_claim", attempt));
+    return null;
+  }
+  const candidate = buildClaimExtractionCandidate(entry, attempt.response, normalizedHints, options.onWarning);
+  if (candidate) {
+    options.onPreviewOutcome?.({
+      outcome: "candidate",
+      confidence: candidate.confidence,
+      rawEntity: candidate.rawEntity,
+      rawAttribute: candidate.rawAttribute,
+      path: attempt.path
+    });
+    return {
+      claimKey: candidate.claimKey,
+      confidence: candidate.confidence,
+      rawEntity: candidate.rawEntity,
+      rawAttribute: candidate.rawAttribute,
+      path: attempt.path,
+      ...candidate.compactedFrom ? {
+        compactedFrom: candidate.compactedFrom,
+        compactionReason: candidate.compactionReason
+      } : {}
+    };
+  }
+  options.onPreviewOutcome?.(buildPreviewOutcome("rejected_candidate", attempt));
+  return tryDeterministicClaimKeyRepair(entry, normalizedHints);
+}
+async function extractClaimKeyDecision(entry, llm, config, options = {}) {
+  if (!config.enabled || !config.eligibleTypes.includes(entry.type)) {
+    return {
+      result: null,
+      diagnostic: {
+        outcome: "ineligible_type",
+        confidence: null,
+        path: null,
+        warning: null,
+        suggestedClaimKey: null,
+        reviewable: false,
+        supportEvidence: [],
+        rationale: "entry type is not eligible for claim-key extraction"
+      }
+    };
+  }
+  const normalizedHints = normalizeClaimExtractionHints(options.hints ?? {});
+  let attempt;
+  try {
+    attempt = await attemptClaimExtraction(entry, normalizedHints, llm);
+  } catch (error) {
+    const repaired2 = tryDeterministicClaimKeyRepair(entry, normalizedHints);
+    if (repaired2) {
+      return finalizeDeterministicRepairDecision(repaired2, options.entityPrefixStats);
+    }
+    const warning = formatClaimExtractionError(error);
+    options.onWarning?.(`Claim extraction failed for "${entry.subject}": ${warning}`);
+    return {
+      result: null,
+      diagnostic: {
+        outcome: "extraction_failure",
+        confidence: null,
+        path: null,
+        warning,
+        suggestedClaimKey: null,
+        reviewable: false,
+        supportEvidence: [],
+        rationale: "claim extraction failed before a safe candidate could be produced"
+      }
+    };
+  }
+  if (attempt.response.no_claim === true) {
+    return {
+      result: null,
+      diagnostic: {
+        outcome: "no_claim",
+        confidence: normalizeConfidence(attempt.response.confidence),
+        path: attempt.path,
+        warning: null,
+        suggestedClaimKey: null,
+        reviewable: false,
+        supportEvidence: [],
+        rationale: "model explicitly returned no_claim"
+      }
+    };
+  }
+  const warnings = [];
+  const candidate = buildClaimExtractionCandidate(entry, attempt.response, normalizedHints, (warning) => {
+    warnings.push(warning);
+    options.onWarning?.(warning);
+  });
+  if (!candidate) {
+    const repaired2 = tryDeterministicClaimKeyRepair(entry, normalizedHints);
+    if (repaired2) {
+      return finalizeDeterministicRepairDecision(repaired2, options.entityPrefixStats);
+    }
+    return {
+      result: null,
+      diagnostic: {
+        outcome: "rejected_candidate",
+        confidence: normalizeConfidence(attempt.response.confidence),
+        path: attempt.path,
+        warning: warnings[0] ?? null,
+        suggestedClaimKey: null,
+        reviewable: false,
+        supportEvidence: [],
+        rationale: "model proposed a structurally unsafe or non-canonical claim key"
+      }
+    };
+  }
+  const result = toClaimExtractionResult(candidate, attempt.path);
+  if (result.confidence >= config.confidenceThreshold) {
+    return {
+      result,
+      diagnostic: buildAcceptedDiagnostic(result, result.confidence >= config.confidenceThreshold ? "candidate met the ingest confidence threshold" : null)
+    };
+  }
+  const support = evaluateClaimKeySupport(
+    {
+      subject: entry.subject,
+      content: entry.content,
+      type: entry.type,
+      tags: entry.tags,
+      source_context: entry.source_context
+    },
+    result.claimKey ?? "",
+    buildClaimKeySupportSeedFromExamples(options.supportClaimKeys ?? [])
+  );
+  const compactness = evaluateClaimKeyCompactness(result.claimKey ?? "", {
+    priorCompactedFrom: result.compactedFrom ?? null,
+    priorCompactionReason: result.compactionReason ?? null
+  });
+  const autoApplyThreshold = support.autoApplyClass !== null && compactness.compactedFrom ? COMPACTED_SUPPORTED_INGEST_AUTO_APPLY_THRESHOLD : support.autoApplyClass !== null ? SUPPORTED_INGEST_AUTO_APPLY_THRESHOLD : HIGH_CONFIDENCE_BACKFILL_THRESHOLD;
+  const proposalThreshold = support.supportedProposal ? SUPPORTED_PROPOSAL_CONFIDENCE_THRESHOLD : PROPOSAL_CONFIDENCE_THRESHOLD;
+  if (compactness.claimKey !== result.claimKey) {
+    result.claimKey = compactness.claimKey;
+    result.compactedFrom = compactness.compactedFrom;
+    result.compactionReason = compactness.compactionReason;
+  }
+  if (result.confidence >= autoApplyThreshold && compactness.compactEnoughForAutoApply) {
+    result.acceptanceRationale = support.autoApplyClass !== null ? `accepted below the default threshold via ${describeSupportPromotionClass(support)}` : "accepted as a high-confidence preview";
+    return {
+      result,
+      diagnostic: buildAcceptedDiagnostic(
+        result,
+        support.autoApplyClass !== null ? `supported near-miss candidate cleared the conservative auto-apply threshold via ${describeSupportPromotionClass(support)}` : `candidate cleared the conservative high-confidence threshold of ${autoApplyThreshold.toFixed(2)}`
+      )
+    };
+  }
+  const repaired = tryDeterministicClaimKeyRepair(entry, normalizedHints);
+  if (repaired && (!result.claimKey || repaired.claimKey === result.claimKey)) {
+    return finalizeDeterministicRepairDecision(repaired, options.entityPrefixStats);
+  }
+  if (result.confidence >= proposalThreshold) {
+    return {
+      result: null,
+      diagnostic: {
+        outcome: "low_confidence_candidate",
+        confidence: result.confidence,
+        path: result.path,
+        warning: warnings[0] ?? null,
+        suggestedClaimKey: result.claimKey,
+        reviewable: true,
+        supportEvidence: support.supportEvidence,
+        rationale: support.rationaleFragments.length > 0 ? `candidate stayed below the auto-apply threshold but has structured support from ${support.rationaleFragments.join(", ")}` : `candidate stayed below the auto-apply threshold of ${autoApplyThreshold.toFixed(2)}`
+      }
+    };
+  }
+  return {
+    result: null,
+    diagnostic: {
+      outcome: "low_confidence_candidate",
+      confidence: result.confidence,
+      path: result.path,
+      warning: warnings[0] ?? null,
+      suggestedClaimKey: result.claimKey,
+      reviewable: false,
+      supportEvidence: support.supportEvidence,
+      rationale: "candidate stayed below both the conservative auto-apply and review thresholds"
+    }
+  };
+}
+async function getEntityHints(db) {
+  return db.getDistinctClaimKeyPrefixes();
+}
+async function runBatchClaimExtraction(results, ports, config, _concurrency = 10, onWarning, onDiagnostic) {
+  if (!config.enabled) {
+    return /* @__PURE__ */ new Map();
+  }
+  const hintState = await loadClaimExtractionHintState(ports.db);
+  const llm = ports.createLlm();
+  const extractedEntries = /* @__PURE__ */ new Map();
+  const diagnostics = /* @__PURE__ */ new Map();
+  const retryEntries = [];
+  for (const result of results) {
+    for (const entry of result.entries) {
+      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;
+      }
+      const decision = await extractBatchClaimKeyDecision(entry, llm, config, hintState, onWarning);
+      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 (const entry of retryEntries) {
+      if (entry.claim_key) {
+        continue;
+      }
+      const decision = await extractBatchClaimKeyDecision(entry, llm, config, hintState, onWarning);
+      diagnostics.set(entry, decision.diagnostic);
+      if (!decision.result?.claimKey) {
+        continue;
+      }
+      applyClaimExtractionResultToEntry(entry, decision.result);
+      recordClaimKeyHint(hintState, decision.result.claimKey);
+      extractedEntries.set(entry, decision.result);
+    }
+  }
+  for (const result of results) {
+    for (const entry of result.entries) {
+      const diagnostic = diagnostics.get(entry);
+      if (diagnostic) {
+        onDiagnostic?.(entry, diagnostic);
+      }
+    }
+  }
+  return extractedEntries;
+}
+async function extractBatchClaimKeyDecision(entry, llm, config, hintState, 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: buildEntryHints(hintState, entry),
+        onWarning,
+        supportClaimKeys: [...hintState.supportClaimKeys],
+        entityPrefixStats: hintState.entityPrefixStats
+      }
+    );
+  } catch {
+    return {
+      result: null,
+      diagnostic: {
+        outcome: "extraction_failure",
+        confidence: null,
+        path: null,
+        warning: "claim extraction failed unexpectedly",
+        suggestedClaimKey: null,
+        reviewable: false,
+        supportEvidence: [],
+        rationale: "claim extraction failed unexpectedly"
+      }
+    };
+  }
+}
+function buildClaimExtractionSystemPrompt(hints, promptMode) {
+  const metadataHints = [hints.userEntity ? `user_id=${hints.userEntity}` : null, hints.projectEntity ? `project=${hints.projectEntity}` : null].filter(
+    (value) => value !== null
+  );
+  const groundingHints = [
+    hints.tags.length > 0 ? `tags=${hints.tags.join(", ")}` : null,
+    hints.sourceContext ? `source_context=${hints.sourceContext}` : null
+  ].filter((value) => value !== null);
+  const retryInstructions = promptMode === "json_retry" ? [
+    "",
+    "Your previous answer was invalid JSON.",
+    "Reply with exactly one JSON object and nothing else.",
+    "Do not use markdown fences, commentary, or trailing text."
+  ] : [];
+  return [
+    "You are a knowledge entry classifier. Extract one stable claim key for a durable knowledge entry.",
+    "A claim key names the durable slot this entry updates: entity/attribute in lowercase snake_case.",
+    "The goal is stable slot naming, not a paraphrase of the current value.",
+    "",
+    "Stability rules:",
+    "- Prefer stable slot names over transient wording.",
+    "- Choose attribute names that still make sense if the value changes.",
+    "- Prefer short noun-like slot names over sentence-like attribute phrases.",
+    "- When a candidate sounds like a rule or explanation sentence, compress it into the reusable slot it governs.",
+    "- Prefer concrete entities over pronouns, deictic phrases, or self-referential placeholders.",
+    "- Reuse an existing entity or full claim-key example when it clearly matches the same slot.",
+    "- Stay domain-general. The same rules apply to people, devices, services, projects, places, organizations, products, datasets, policies, and preferences.",
+    "- If the entry states a durable rule, default, workflow, guardrail, source-of-truth rule, architecture boundary, or process constraint plus rationale, extract the primary durable slot rather than the supporting rationale.",
+    "- Do not return no_claim just because the entry explains why the rule exists. The durable policy or system slot is usually still the target.",
+    "- Avoid full action clauses like requires_x_to_y, preserves_x_across_y, or x_precedes_y when a shorter stable slot such as trigger_condition, context_preservation, source_of_truth, or handoff_order would carry the same durable meaning.",
+    "",
+    "Return no_claim when:",
+    "- The entry is narrative, multi-fact, or mostly a story about what happened.",
+    "- The entry is an event or milestone without one continuing slot.",
+    "- The entity is ambiguous or can only be named with a pronoun or vague placeholder.",
+    "- The entry does not express one durable property, preference, decision, configuration, relationship, or other stable slot.",
+    "- When unsure, prefer no_claim over inventing a weak key.",
+    "",
+    "Positive examples:",
+    `- "Jim's timezone is America/Chicago." -> jim/timezone`,
+    '- "Jim prefers oat milk in coffee." -> jim/coffee_preference',
+    '- "Pixel 8 is set to dark mode." -> pixel_8/theme_mode',
+    '- "Postgres max_connections is 200." -> postgres/max_connections',
+    '- "Agenr defaults to gpt-5.4-mini." -> agenr/default_model',
+    '- "Mac mini updates should stay manual so debugging stays predictable." -> mac_mini/manual_update_policy',
+    '- "Use the warehouse inventory sheet as the source of truth for stock counts." -> stock_counts/source_of_truth',
+    '- "The repo workflow is defined by AGENTS.md, even when older notes disagree." -> repo_workflow/source_of_truth',
+    '- "Agenr keeps pure logic in src/core and adapters outside it so future hosts can plug in cleanly." -> agenr/core_adapter_boundary',
+    '- "The before-prompt-build hook only triggers after a real agent turn or message." -> before_prompt_build_hook/trigger_condition',
+    '- "Durable memory preserves context across sessions." -> durable_memory/context_preservation',
+    '- "SQLite in this environment supports window functions." -> sqlite/window_function_support',
+    '- "Meeting-recorder transcripts need manual cleanup before durable ingest." -> meeting_recorder/transcript_cleanup_workflow',
+    '- "Reflection synthesis can hallucinate when it summarizes from partial notes." -> reflection_synthesis/hallucination_risk',
+    "",
+    "Negative examples:",
+    "- Bad: jim/america_chicago -> Good: jim/timezone",
+    "- Bad: project_x/details -> Good: project_x/deploy_strategy",
+    "- Bad: we/deployment_process -> Good: platform_team/deploy_strategy",
+    "- Bad: jim/oat_milk -> Good: jim/coffee_preference",
+    "- Bad: release_notes/because_rollbacks_are_hard -> Good: release_process/source_of_truth",
+    "- Bad: openclaw/requires_real_agent_turn_or_message_to_trigger -> Good: openclaw/trigger_condition",
+    "- Bad: session_continuity/durable_memory_preserves_context_across_sessions -> Good: session_continuity/context_preservation",
+    "- Bad: incident_story/we_spent_two_hours_debugging -> Good: no_claim",
+    "",
+    "Field rules:",
+    "- entity: the main concrete thing being described. It can be a person, device, service, product, organization, workflow area, or other durable system/process anchor.",
+    "- attribute: the narrow stable slot on that entity. For policy/process entries, name the governing slot such as source_of_truth, default_mode, update_policy, architecture_boundary, deploy_strategy, or escalation_workflow.",
+    "- Confidence: 0.0 to 1.0. Use 0.9+ only when the slot is unambiguous and durable.",
+    "",
+    `Known entity hints: ${hints.entityHints.length > 0 ? hints.entityHints.join(", ") : "(none)"}`,
+    `Known claim-key examples: ${hints.claimKeyExamples.length > 0 ? hints.claimKeyExamples.join(", ") : "(none)"}`,
+    `Current entry metadata hints: ${metadataHints.length > 0 ? metadataHints.join(", ") : "(none)"}`,
+    `Current entry grounding clues: ${groundingHints.length > 0 ? groundingHints.join(", ") : "(none)"}`,
+    'If project metadata is present, it may resolve phrases like "the project" when that mapping is obvious.',
+    'If user metadata is present, it may resolve phrases like "the user", "I", or "me" when that mapping is obvious.',
+    "Tags and source_context are local grounding clues, not proof. Use them to pick the right durable slot only when the entry content already supports that slot.",
+    ...retryInstructions,
+    "",
+    'Respond with JSON: { "entity": string, "attribute": string, "confidence": number, "no_claim"?: boolean }'
+  ].join("\n");
+}
+function buildClaimExtractionUserPrompt(entry) {
+  return [`Entry type: ${entry.type}`, `Subject: ${entry.subject}`, `Content: ${entry.content}`].join("\n");
+}
+async function attemptClaimExtraction(entry, hints, llm) {
+  const userPrompt = buildClaimExtractionUserPrompt(entry);
+  try {
+    return {
+      path: "model",
+      response: await llm.completeJson(buildClaimExtractionSystemPrompt(hints, "standard"), userPrompt)
+    };
+  } catch (error) {
+    if (!isMalformedJsonError(error)) {
+      throw error;
+    }
+  }
+  return {
+    path: "json_retry",
+    response: await llm.completeJson(buildClaimExtractionSystemPrompt(hints, "json_retry"), userPrompt)
+  };
+}
+function buildClaimExtractionCandidate(entry, response, hints, onWarning) {
+  const confidence = normalizeConfidence(response.confidence);
+  const rawEntity = typeof response.entity === "string" ? response.entity.trim() : "";
+  const rawAttribute = typeof response.attribute === "string" ? response.attribute.trim() : "";
+  const entity = normalizeEntity(rawEntity, hints);
+  const attribute = normalizeClaimKeySegment(rawAttribute);
+  const normalizedClaimKey = normalizeClaimKey(`${entity}/${attribute}`);
+  if (!normalizedClaimKey.ok) {
+    onWarning?.(`Claim extraction dropped claim key for "${entry.subject}": ${describeClaimKeyNormalizationFailure(normalizedClaimKey.reason)}.`);
+    return null;
+  }
+  const compactedClaimKey = compactClaimKey(normalizedClaimKey.value.claimKey);
+  if (!compactedClaimKey) {
+    onWarning?.(`Claim extraction dropped claim key for "${entry.subject}": claim key could not be compacted safely.`);
+    return null;
+  }
+  const validatedClaimKey = validateExtractedClaimKey(compactedClaimKey);
+  if (!validatedClaimKey.ok) {
+    onWarning?.(
+      `Claim extraction rejected "${validatedClaimKey.value.claimKey}" for "${entry.subject}": ${describeExtractedClaimKeyRejection(validatedClaimKey.reason, validatedClaimKey.value)}.`
+    );
+    return null;
+  }
+  return {
+    claimKey: validatedClaimKey.value.claimKey,
+    confidence,
+    rawEntity,
+    rawAttribute,
+    compactedFrom: compactedClaimKey.compactedFrom,
+    compactionReason: compactedClaimKey.reason
+  };
+}
+function toClaimExtractionResult(candidate, 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) {
+    return null;
+  }
+  const attribute = normalizeClaimKeySegment(repaired.attribute);
+  if (!looksLikeDeterministicAttribute(attribute)) {
+    return null;
+  }
+  const entity = normalizeEntity(repaired.entity, hints);
+  const normalizedClaimKey = normalizeClaimKey(`${entity}/${attribute}`);
+  if (!normalizedClaimKey.ok) {
+    return null;
+  }
+  const validatedClaimKey = validateExtractedClaimKey(normalizedClaimKey.value);
+  if (!validatedClaimKey.ok) {
+    return null;
+  }
+  return {
+    claimKey: validatedClaimKey.value.claimKey,
+    confidence: DEFAULT_REPAIR_CONFIDENCE,
+    rawEntity: repaired.entity,
+    rawAttribute: repaired.attribute,
+    path: "deterministic_repair"
+  };
+}
+async function loadClaimExtractionHintState(db) {
+  const [entityHintResult, promptClaimKeyExampleResult, supportClaimKeyExampleResult, entityPrefixStatsResult] = await Promise.allSettled([
+    getEntityHints(db),
+    getClaimKeyExamples(db, MAX_CLAIM_KEY_EXAMPLES),
+    getClaimKeyExamples(db, MAX_SUPPORT_CLAIM_KEY_EXAMPLES),
+    getClaimKeyEntityPrefixStats(db)
+  ]);
+  return createHintState({
+    entityHints: entityHintResult.status === "fulfilled" ? entityHintResult.value : [],
+    claimKeyExamples: promptClaimKeyExampleResult.status === "fulfilled" ? promptClaimKeyExampleResult.value : [],
+    supportClaimKeys: supportClaimKeyExampleResult.status === "fulfilled" ? supportClaimKeyExampleResult.value : [],
+    entityPrefixStats: entityPrefixStatsResult.status === "fulfilled" ? entityPrefixStatsResult.value : []
+  });
+}
+async function getClaimKeyExamples(db, limit) {
+  if (typeof db.getClaimKeyExamples !== "function") {
+    return [];
+  }
+  return db.getClaimKeyExamples(limit);
+}
+async function getClaimKeyEntityPrefixStats(db) {
+  if (typeof db.getClaimKeyEntityPrefixStats !== "function") {
+    return [];
+  }
+  return db.getClaimKeyEntityPrefixStats();
+}
+function createHintState(input) {
+  const claimKeyExamples = normalizeClaimKeyExamples(input.claimKeyExamples ?? []);
+  const supportClaimKeys = normalizeSupportClaimKeys(input.supportClaimKeys ?? []);
+  const entityHints = limitUnique(
+    [
+      ...normalizeEntityHints(input.entityHints ?? []),
+      ...supportClaimKeys.flatMap((claimKey) => {
+        const normalizedClaimKey = normalizeClaimKey(claimKey);
+        return normalizedClaimKey.ok ? [normalizedClaimKey.value.entity] : [];
+      })
+    ],
+    MAX_ENTITY_HINTS
+  );
+  return {
+    entityHints,
+    claimKeyExamples,
+    supportClaimKeys,
+    entityPrefixStats: input.entityPrefixStats ?? []
+  };
+}
+function buildEntryHints(state, entry) {
+  return {
+    entityHints: [...state.entityHints],
+    claimKeyExamples: [...state.claimKeyExamples],
+    userId: entry.user_id,
+    project: entry.project,
+    tags: entry.tags,
+    sourceContext: entry.source_context
+  };
+}
+function recordClaimKeyHint(state, claimKey) {
+  const normalizedClaimKey = normalizeClaimKey(claimKey);
+  if (!normalizedClaimKey.ok) {
+    return;
+  }
+  state.claimKeyExamples = prependUnique(state.claimKeyExamples, normalizedClaimKey.value.claimKey, MAX_CLAIM_KEY_EXAMPLES);
+  state.supportClaimKeys = prependUnique(state.supportClaimKeys, normalizedClaimKey.value.claimKey, MAX_SUPPORT_CLAIM_KEY_EXAMPLES);
+  state.entityHints = prependUnique(state.entityHints, normalizedClaimKey.value.entity, MAX_ENTITY_HINTS);
+}
+function normalizeClaimExtractionHints(hints) {
+  const claimKeyExamples = normalizeClaimKeyExamples(hints.claimKeyExamples ?? []);
+  return {
+    entityHints: limitUnique(
+      [
+        ...normalizeEntityHints(hints.entityHints ?? []),
+        ...claimKeyExamples.flatMap((claimKey) => {
+          const normalizedClaimKey = normalizeClaimKey(claimKey);
+          return normalizedClaimKey.ok ? [normalizedClaimKey.value.entity] : [];
+        })
+      ],
+      MAX_ENTITY_HINTS
+    ),
+    claimKeyExamples,
+    userEntity: normalizeMetadataEntity(hints.userId),
+    projectEntity: normalizeMetadataEntity(hints.project),
+    tags: normalizeHintTags(hints.tags ?? []),
+    sourceContext: normalizeSourceContextHint(hints.sourceContext)
+  };
+}
+function buildPreviewOutcome(outcome, attempt) {
+  return {
+    outcome,
+    confidence: normalizeConfidence(attempt.response.confidence),
+    rawEntity: typeof attempt.response.entity === "string" ? attempt.response.entity.trim() : "",
+    rawAttribute: typeof attempt.response.attribute === "string" ? attempt.response.attribute.trim() : "",
+    path: attempt.path
+  };
+}
+function normalizeConfidence(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return 0;
+  }
+  return Math.min(1, Math.max(0, value));
+}
+function normalizeEntity(value, hints) {
+  const normalizedValue = normalizeClaimKeySegment(value);
+  if (normalizedValue.length === 0) {
+    return "";
+  }
+  if (!SELF_REFERENTIAL_ENTITIES.has(normalizedValue)) {
+    return normalizedValue;
+  }
+  if (USER_REFERENTIAL_ENTITIES.has(normalizedValue) && hints.userEntity) {
+    return hints.userEntity;
+  }
+  if (PROJECT_REFERENTIAL_ENTITIES.has(normalizedValue) && hints.projectEntity) {
+    return hints.projectEntity;
+  }
+  const concreteCandidates = limitUnique(
+    [hints.projectEntity, hints.userEntity, ...hints.entityHints].filter(
+      (candidate) => typeof candidate === "string" && candidate.length > 0
+    ),
+    MAX_ENTITY_HINTS
+  );
+  if (concreteCandidates.length === 1) {
+    return concreteCandidates[0] ?? normalizedValue;
+  }
+  if (hints.entityHints.length === 1) {
+    return hints.entityHints[0] ?? normalizedValue;
+  }
+  return normalizedValue;
+}
+function normalizeEntityHints(entityHints) {
+  return limitUnique(
+    entityHints.map((entityHint) => normalizeClaimKeySegment(entityHint)).filter((entityHint) => entityHint.length > 0 && !SELF_REFERENTIAL_ENTITIES.has(entityHint)),
+    MAX_ENTITY_HINTS
+  );
+}
+function normalizeClaimKeyExamples(claimKeyExamples) {
+  return limitUnique(
+    claimKeyExamples.flatMap((claimKeyExample) => {
+      const normalizedClaimKey = normalizeClaimKey(claimKeyExample);
+      return normalizedClaimKey.ok ? [normalizedClaimKey.value.claimKey] : [];
+    }),
+    MAX_CLAIM_KEY_EXAMPLES
+  );
+}
+function normalizeSupportClaimKeys(claimKeys) {
+  return limitUnique(
+    claimKeys.flatMap((claimKey) => {
+      const normalizedClaimKey = normalizeClaimKey(claimKey);
+      return normalizedClaimKey.ok ? [normalizedClaimKey.value.claimKey] : [];
+    }),
+    MAX_SUPPORT_CLAIM_KEY_EXAMPLES
+  );
+}
+function normalizeMetadataEntity(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = normalizeClaimKeySegment(value);
+  if (normalized.length === 0 || SELF_REFERENTIAL_ENTITIES.has(normalized) || !/[a-z]/u.test(normalized)) {
+    return void 0;
+  }
+  return normalized;
+}
+function normalizeHintTags(tags) {
+  return limitUnique(
+    tags.map((tag) => normalizeClaimKeySegment(tag)).filter((tag) => tag.length > 0),
+    8
+  );
+}
+function normalizeSourceContextHint(value) {
+  const trimmed = value?.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  return trimmed.length <= 160 ? trimmed : `${trimmed.slice(0, 157).trimEnd()}...`;
+}
+function isMalformedJsonError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /json|unexpected token|unexpected end|unexpected non-whitespace|unterminated|position \d+/iu.test(message);
+}
+function parsePossessiveClaim(subject) {
+  const match = /^\s*(?<entity>[^.!?\n]+?)[’']s\s+(?<attribute>[^.!?\n]+?)\s*$/iu.exec(subject);
+  if (!match?.groups) {
+    return null;
+  }
+  return {
+    entity: stripTrailingPunctuation(match.groups.entity),
+    attribute: stripTrailingPunctuation(match.groups.attribute)
+  };
+}
+function parsePossessiveStatement(content) {
+  const match = /^\s*(?<entity>[^.!?\n]+?)[’']s\s+(?<attribute>[^.!?\n]+?)\s+(?:is|are|was|were)\b/iu.exec(content);
+  if (!match?.groups) {
+    return null;
+  }
+  return {
+    entity: stripTrailingPunctuation(match.groups.entity),
+    attribute: stripTrailingPunctuation(match.groups.attribute)
+  };
+}
+function stripTrailingPunctuation(value) {
+  return value.trim().replace(/[\s"'“”‘’.,:;!?]+$/gu, "").trim();
+}
+function looksLikeDeterministicAttribute(attribute) {
+  const parts = attribute.split("_").filter((part) => part.length > 0);
+  if (parts.length === 0 || parts.length > 4) {
+    return false;
+  }
+  const head = parts[parts.length - 1];
+  return typeof head === "string" && DETERMINISTIC_ATTRIBUTE_HEADS.has(head);
+}
+function prependUnique(values, value, limit) {
+  return limitUnique([value, ...values], limit);
+}
+function limitUnique(values, limit) {
+  return Array.from(new Set(values.filter((value) => value.length > 0))).slice(0, limit);
+}
+
+// src/core/store/hashing.ts
+import { createHash as createHash2 } from "crypto";
+function computeContentHash(content, sourceFile) {
+  const input = sourceFile ? `${sourceFile}
+${content}` : content;
+  return createHash2("sha256").update(input).digest("hex");
+}
+function computeNormContentHash(content) {
+  const normalized = content.toLowerCase().replace(/\s+/g, " ").trim().replace(/[^\w\s]/g, "");
+  return createHash2("sha256").update(normalized).digest("hex");
+}
+
+// src/core/store/validation.ts
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
+function validateEntriesWithIndexes(inputs) {
+  const valid = [];
+  const errors = [];
+  const warnings = [];
+  const rejectedInputIndexes = [];
+  for (const [index, input] of inputs.entries()) {
+    const subject = normalizeString(input.subject);
+    const content = normalizeString(input.content);
+    if (!ENTRY_TYPES.includes(input.type)) {
+      errors.push(`Entry ${index} has an invalid type.`);
+      rejectedInputIndexes.push(index);
+      continue;
+    }
+    if (subject.length === 0) {
+      errors.push(`Entry ${index} is missing a subject.`);
+      rejectedInputIndexes.push(index);
+      continue;
+    }
+    if (content.length === 0) {
+      errors.push(`Entry ${index} is missing content.`);
+      rejectedInputIndexes.push(index);
+      continue;
+    }
+    if (input.expiry !== void 0 && !EXPIRY_LEVELS.includes(input.expiry)) {
+      errors.push(`Entry ${index} has an invalid expiry.`);
+      rejectedInputIndexes.push(index);
+      continue;
+    }
+    if (input.tags !== void 0 && !areValidTags(input.tags)) {
+      errors.push(`Entry ${index} has invalid tags.`);
+      rejectedInputIndexes.push(index);
+      continue;
+    }
+    if (input.importance !== void 0 && !Number.isFinite(input.importance)) {
+      errors.push(`Entry ${index} has an invalid importance.`);
+      rejectedInputIndexes.push(index);
+      continue;
+    }
+    if (input.supersedes !== void 0 && !isUuid(input.supersedes)) {
+      errors.push(`Entry ${index} has an invalid supersedes id.`);
+      rejectedInputIndexes.push(index);
+      continue;
+    }
+    const temporalValidity = validateTemporalValidityRange(input.valid_from, input.valid_to);
+    if (!temporalValidity.ok) {
+      errors.push(`Entry ${index} ${temporalValidity.message}`);
+      rejectedInputIndexes.push(index);
+      continue;
+    }
+    let normalizedClaimKey;
+    if (input.claim_key !== void 0) {
+      if (typeof input.claim_key !== "string") {
+        warnings.push(`Entry ${index} provided a non-string claim key and it was dropped.`);
+      } else {
+        const claimKey = normalizeClaimKey(input.claim_key);
+        if (claimKey.ok) {
+          normalizedClaimKey = claimKey.value.claimKey;
+        } else {
+          warnings.push(
+            `Entry ${index} provided invalid claim key ${JSON.stringify(input.claim_key)} and it was dropped: ${describeClaimKeyNormalizationFailure(claimKey.reason)}.`
+          );
+        }
+      }
+    }
+    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: {
+        type: input.type,
+        subject,
+        content,
+        importance: clampImportance(input.importance),
+        expiry: input.expiry ?? "temporary",
+        tags: normalizeTags(input.tags),
+        source_file: normalizeOptionalString(input.source_file),
+        source_context: normalizeOptionalString(input.source_context),
+        user_id: normalizeOptionalString(input.user_id),
+        project: normalizeOptionalString(input.project),
+        created_at: normalizeOptionalString(input.created_at),
+        supersedes: normalizeOptionalString(input.supersedes),
+        claim_key: normalizedClaimKey,
+        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
+      }
+    });
+  }
+  return {
+    valid,
+    rejected: errors.length,
+    rejectedInputIndexes,
+    errors,
+    warnings
+  };
+}
+function clampImportance(value) {
+  if (value === void 0) {
+    return 7;
+  }
+  return Math.min(10, Math.max(1, Math.round(value)));
+}
+function normalizeString(value) {
+  return value.trim();
+}
+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");
+}
+function normalizeTags(tags) {
+  if (!tags) {
+    return [];
+  }
+  return tags.map((tag) => tag.trim()).filter((tag) => tag.length > 0);
+}
+function isUuid(value) {
+  return UUID_PATTERN.test(value.trim());
+}
+function isIsoTimestamp(value) {
+  const normalized = value.trim();
+  return normalized.length > 0 && normalized.includes("T") && !Number.isNaN(Date.parse(normalized));
+}
+
+// src/core/store/pipeline.ts
+var AUTO_SUPERSESSION_MIN_EXTRACTED_CONFIDENCE = 0.9;
+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: [] };
+  }
+  const plan = await buildStorePlan(inputs, db);
+  for (const warning of plan.warnings) {
+    options.onWarning?.(warning);
+  }
+  if (plan.pendingEntries.length === 0) {
+    return {
+      stored: 0,
+      skipped: plan.skipped,
+      rejected: plan.rejected,
+      details: sortStoreDetails(plan.details)
+    };
+  }
+  if (options.dryRun === true) {
+    return {
+      stored: 0,
+      skipped: plan.skipped,
+      rejected: plan.rejected,
+      details: sortStoreDetails([
+        ...plan.details,
+        ...plan.pendingEntries.map((entry) => ({
+          inputIndex: entry.inputIndex,
+          outcome: "dry_run",
+          reason: "dry_run"
+        }))
+      ])
+    };
+  }
+  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 {
+    stored: pendingEntries.length,
+    skipped: plan.skipped,
+    rejected: plan.rejected,
+    details: sortStoreDetails([
+      ...plan.details,
+      ...pendingEntries.map((entry) => ({
+        inputIndex: entry.inputIndex,
+        outcome: "stored"
+      }))
+    ])
+  };
+}
+async function resolvePendingEmbeddings(inputs, entries, embedding, precomputedEmbeddings) {
+  if (!precomputedEmbeddings) {
+    return embedPendingEntries(entries, embedding);
+  }
+  if (precomputedEmbeddings.length !== inputs.length) {
+    throw new Error(`Precomputed embedding length mismatch: expected ${inputs.length}, received ${precomputedEmbeddings.length}.`);
+  }
+  return entries.map((entry) => {
+    const vector = precomputedEmbeddings[entry.inputIndex];
+    if (!vector) {
+      throw new Error(`Missing precomputed embedding for input index ${entry.inputIndex}.`);
+    }
+    return vector;
+  });
+}
+async function embedPendingEntries(entries, embedding) {
+  const texts = entries.map(({ input }) => composeEmbeddingText(input));
+  const vectors = await embedding.embed(texts);
+  if (vectors.length !== entries.length) {
+    throw new Error(`Embedding length mismatch: expected ${entries.length}, received ${vectors.length}.`);
+  }
+  return vectors;
+}
+async function persistEntries(db, preparedEntries, embeddings, extractedClaimKeys, claimExtractionConfig, onWarning) {
+  const writeBatch = async (targetDb) => {
+    let stored = 0;
+    const autoSupersessionPlans = await planAutoSupersession(targetDb, preparedEntries, extractedClaimKeys, claimExtractionConfig);
+    const emittedWarnings = /* @__PURE__ */ new Set();
+    for (const [index, preparedEntry] of preparedEntries.entries()) {
+      const embedding = embeddings[index] ?? [];
+      const entry = buildEntry(preparedEntry, embedding);
+      const entryId = await targetDb.insertEntry(entry, embedding, preparedEntry.contentHash);
+      const supersededEntryId = preparedEntry.input.supersedes;
+      if (supersededEntryId) {
+        const superseded = await targetDb.supersedeEntry(supersededEntryId, entryId, "update");
+        if (!superseded) {
+          onWarning?.(`Stored entry ${entryId} but could not supersede ${supersededEntryId} because the target was missing or inactive.`);
+        }
+      }
+      const autoSupersessionPlan = autoSupersessionPlans.get(preparedEntry.inputIndex);
+      if (autoSupersessionPlan?.kind === "link" && autoSupersessionPlan.oldEntryId) {
+        const superseded = await targetDb.supersedeEntry(autoSupersessionPlan.oldEntryId, entryId, "update");
+        if (!superseded) {
+          onWarning?.(
+            `Stored entry ${entryId} with claim_key "${preparedEntry.input.claim_key}" but could not auto-supersede ${autoSupersessionPlan.oldEntryId} because the target was missing or inactive.`
+          );
+        }
+      }
+      if (autoSupersessionPlan?.warning && !emittedWarnings.has(autoSupersessionPlan.warning)) {
+        emittedWarnings.add(autoSupersessionPlan.warning);
+        onWarning?.(autoSupersessionPlan.warning);
+      }
+      stored += 1;
+    }
+    return stored;
+  };
+  if (hasTransactionSupport(db) && preparedEntries.some((entry) => entry.input.supersedes !== void 0 || entry.input.claim_key !== void 0)) {
+    return db.withTransaction(writeBatch);
+  }
+  if (hasTransactionSupport(db) && preparedEntries.length > 1) {
+    return db.withTransaction(writeBatch);
+  }
+  return writeBatch(db);
+}
+function buildEntry(preparedEntry, embedding) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const acceptedClaimKey = preparedEntry.claimKey;
+  return {
+    id: randomUUID(),
+    type: preparedEntry.input.type,
+    subject: preparedEntry.input.subject,
+    content: preparedEntry.input.content,
+    importance: preparedEntry.input.importance ?? 7,
+    expiry: preparedEntry.input.expiry ?? "temporary",
+    tags: preparedEntry.input.tags ?? [],
+    source_file: preparedEntry.input.source_file,
+    source_context: preparedEntry.input.source_context,
+    user_id: preparedEntry.input.user_id,
+    project: preparedEntry.input.project,
+    embedding,
+    content_hash: preparedEntry.contentHash,
+    norm_content_hash: preparedEntry.normContentHash,
+    quality_score: 0.5,
+    recall_count: 0,
+    valid_from: preparedEntry.input.valid_from,
+    valid_to: preparedEntry.input.valid_to,
+    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
+  };
+}
+async function maybeExtractClaimKeys(preparedEntries, options) {
+  const claimExtraction = options.claimExtraction;
+  if (!claimExtraction || preparedEntries.length === 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  try {
+    const extractedEntries = await runBatchClaimExtraction(
+      [
+        {
+          entries: preparedEntries.map((preparedEntry) => preparedEntry.input)
+        }
+      ],
+      {
+        createLlm: () => claimExtraction.llm,
+        db: claimExtraction.db
+      },
+      claimExtraction.config,
+      1,
+      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) {
+      const extracted = extractedEntries.get(preparedEntry.input);
+      if (extracted) {
+        extractedClaimKeys.set(preparedEntry.inputIndex, extracted);
+      }
+    }
+    return extractedClaimKeys;
+  } catch (error) {
+    const subject = preparedEntries[0]?.input.subject ?? "batch";
+    options.onWarning?.(`Claim extraction failed for "${subject}": ${formatPipelineError(error)}`);
+    return /* @__PURE__ */ new Map();
+  }
+}
+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.claimKey?.claim_key ?? preparedEntry.input.claim_key;
+    if (!claimKey || preparedEntry.input.supersedes) {
+      continue;
+    }
+    const siblings = await getClaimKeySiblings(db, siblingCache, claimKey);
+    if (siblings.length === 0) {
+      continue;
+    }
+    const batchSiblingCount = preparedEntriesByClaimKey.get(claimKey)?.length ?? 0;
+    if (batchSiblingCount > 1) {
+      plans.set(preparedEntry.inputIndex, {
+        kind: "skip",
+        warning: `Skipped auto-supersession for claim_key "${claimKey}" because this store batch contains ${batchSiblingCount} entries for the same slot.`
+      });
+      continue;
+    }
+    if (siblings.length > 1) {
+      plans.set(preparedEntry.inputIndex, {
+        kind: "skip",
+        warning: `Skipped auto-supersession for claim_key "${claimKey}" because ${siblings.length} active siblings already exist for that slot.`
+      });
+      continue;
+    }
+    const sibling = siblings[0];
+    if (!sibling) {
+      continue;
+    }
+    if (!isAutoSupersessionEligible(preparedEntry.claimKey, claimExtractionConfig)) {
+      plans.set(preparedEntry.inputIndex, {
+        kind: "skip",
+        warning: buildAutoSupersessionEligibilityWarning(preparedEntry)
+      });
+      continue;
+    }
+    const supersessionValidation = validateSupersessionRules(sibling, {
+      type: preparedEntry.input.type,
+      expiry: preparedEntry.input.expiry ?? "temporary"
+    });
+    if (!supersessionValidation.ok) {
+      plans.set(preparedEntry.inputIndex, {
+        kind: "skip",
+        warning: buildAutoSupersessionRuleWarning(preparedEntry, sibling, supersessionValidation.reason)
+      });
+      continue;
+    }
+    plans.set(preparedEntry.inputIndex, {
+      kind: "link",
+      oldEntryId: sibling.id
+    });
+  }
+  return plans;
+}
+function groupPreparedEntriesByClaimKey(preparedEntries) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const preparedEntry of preparedEntries) {
+    const claimKey = preparedEntry.claimKey?.claim_key ?? preparedEntry.input.claim_key;
+    if (!claimKey) {
+      continue;
+    }
+    const existing = grouped.get(claimKey) ?? [];
+    existing.push(preparedEntry);
+    grouped.set(claimKey, existing);
+  }
+  return grouped;
+}
+async function getClaimKeySiblings(db, cache, claimKey) {
+  const cached = cache.get(claimKey);
+  if (cached) {
+    return cached;
+  }
+  const siblings = await db.findActiveEntriesByClaimKey(claimKey);
+  cache.set(claimKey, siblings);
+  return siblings;
+}
+function isAutoSupersessionEligible(claimKey, claimExtractionConfig) {
+  if (!claimKey || claimKey.claim_key_status !== "trusted") {
+    return false;
+  }
+  if (claimKey.claim_key_source === "manual") {
+    return true;
+  }
+  if (!AUTO_SUPERSESSION_ELIGIBLE_SOURCES.has(claimKey.claim_key_source) || !claimExtractionConfig) {
+    return false;
+  }
+  return claimKey.claim_key_confidence >= Math.max(claimExtractionConfig.confidenceThreshold, AUTO_SUPERSESSION_MIN_EXTRACTED_CONFIDENCE);
+}
+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 (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 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") {
+    return `Stored entry "${preparedEntry.input.subject}" with claim_key "${preparedEntry.input.claim_key}" but skipped auto-supersession because the matching active entry is type "${sibling.type}" and the new entry is type "${preparedEntry.input.type}". ${describeSupersessionRuleFailure(reason)}`;
+  }
+  return `Stored entry "${preparedEntry.input.subject}" with claim_key "${preparedEntry.input.claim_key}" but skipped auto-supersession: ${describeSupersessionRuleFailure(reason)}`;
+}
+async function buildStorePlan(inputs, db) {
+  const validation = validateEntriesWithIndexes(inputs);
+  const details = validation.rejectedInputIndexes.map((inputIndex) => ({
+    inputIndex,
+    outcome: "rejected",
+    reason: "validation"
+  }));
+  const preparedEntries = validation.valid.map(({ input, inputIndex }) => ({
+    input,
+    inputIndex,
+    contentHash: computeContentHash(input.content, input.source_file),
+    normContentHash: computeNormContentHash(input.content),
+    claimKey: buildManualAcceptedClaimKey(inputs[inputIndex], input)
+  }));
+  const afterBatchContentHash = dedupePreparedEntries(preparedEntries, "contentHash", "content_hash", details);
+  const existingHashes = await db.findExistingHashes(afterBatchContentHash.map((entry) => entry.contentHash));
+  const afterExistingContentHash = filterExistingPreparedEntries(afterBatchContentHash, existingHashes, "contentHash", "content_hash", details);
+  const afterBatchNormHash = dedupePreparedEntries(afterExistingContentHash, "normContentHash", "norm_content_hash", details);
+  const existingNormHashes = await db.findExistingNormHashes(afterBatchNormHash.map((entry) => entry.normContentHash));
+  const pendingEntries = filterExistingPreparedEntries(afterBatchNormHash, existingNormHashes, "normContentHash", "norm_content_hash", details);
+  return {
+    pendingEntries,
+    skipped: details.filter((detail) => detail.outcome === "skipped").length,
+    rejected: validation.rejected,
+    details,
+    warnings: validation.warnings
+  };
+}
+function dedupePreparedEntries(entries, field, reason, details) {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const entry of entries) {
+    const key = entry[field];
+    if (seen.has(key)) {
+      details.push({
+        inputIndex: entry.inputIndex,
+        outcome: "skipped",
+        reason
+      });
+      continue;
+    }
+    seen.add(key);
+    deduped.push(entry);
+  }
+  return deduped;
+}
+function filterExistingPreparedEntries(entries, existing, field, reason, details) {
+  return entries.filter((entry) => {
+    if (!existing.has(entry[field])) {
+      return true;
+    }
+    details.push({
+      inputIndex: entry.inputIndex,
+      outcome: "skipped",
+      reason
+    });
+    return false;
+  });
+}
+function formatPipelineError(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(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 = [
+  "You write strict JSON episode summaries for historical recall.",
+  "The transcript can be about any topic - technical work, casual conversation, planning, research, creative projects, life events, or anything else.",
+  "Do not assume any particular domain.",
+  "Describe only what happened in this session.",
+  "Do not carry inherited context or open loops forward unless the session actively worked on them.",
+  "Return exactly one JSON object with this shape:",
+  '{ "summary": string, "tags": string[], "activityLevel": "substantial" | "minimal" | "none", "project": string | null }',
+  "Requirements:",
+  "- summary must be 100 to 300 words in plain prose (roughly 4 to 10 sentences)",
+  "- describe what was discussed, decided, or accomplished - not a turn-by-turn replay",
+  "- this is a narrative overview for historical recall, not a verbatim record",
+  "- preserve concrete details worth remembering: names, places, dates, specific decisions, key topics, and notable specifics that would help someone recall this session months later",
+  "- tags must be 3 to 8 short lowercase anchors drawn from the actual session content",
+  "- project should be null when no clear project scope appears",
+  "- activityLevel: use substantial when meaningful discussion or work occurred, minimal when the session was brief or lightweight, none when essentially nothing happened",
+  "- do not include Markdown fences or extra commentary"
+].join("\n");
+function buildEpisodeSummaryPrompt(transcript) {
+  return [
+    "Produce a historical episodic summary for this completed session.",
+    "Describe what was discussed, decided, or accomplished during this transcript window.",
+    "",
+    "Transcript:",
+    transcript
+  ].join("\n");
+}
+function parseEpisodeSummaryResponse(value) {
+  const parsed = parseJsonObject(value);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return null;
+  }
+  const parsedRecord = parsed;
+  const summary = normalizeSummary(parsedRecord.summary);
+  const activityLevel = normalizeActivityLevel(parsedRecord.activityLevel);
+  if (!summary || !activityLevel) {
+    return null;
+  }
+  return {
+    summary,
+    tags: normalizeTags2(parsedRecord.tags),
+    activityLevel,
+    ...normalizeProject(parsedRecord.project) ? { project: normalizeProject(parsedRecord.project) } : {}
+  };
+}
+function normalizeSummary(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const normalized = value.replace(/\s+/gu, " ").trim();
+  return normalized ? normalized : null;
+}
+function normalizeActivityLevel(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const normalized = value.trim().toLowerCase();
+  return EPISODE_ACTIVITY_LEVELS.includes(normalized) ? normalized : null;
+}
+function normalizeTags2(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return Array.from(
+    new Set(
+      value.filter((tag) => typeof tag === "string").map((tag) => tag.trim().toLowerCase()).filter((tag) => tag.length > 0)
+    )
+  ).slice(0, 8);
+}
+function normalizeProject(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = value.replace(/\s+/gu, " ").trim();
+  return normalized ? normalized : void 0;
+}
+function parseJsonObject(value) {
+  const candidates = collectJsonCandidates(value);
+  for (const candidate of candidates) {
+    try {
+      return JSON.parse(candidate);
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function collectJsonCandidates(value) {
+  const trimmed = value.trim();
+  const candidates = /* @__PURE__ */ new Set();
+  if (trimmed) {
+    candidates.add(trimmed);
+  }
+  const fencedMatches = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/giu) ?? [];
+  for (const match of fencedMatches) {
+    const normalized = match.replace(/```(?:json)?/iu, "").replace(/```/gu, "").trim();
+    if (normalized) {
+      candidates.add(normalized);
+    }
+  }
+  const objectStart = trimmed.indexOf("{");
+  const objectEnd = trimmed.lastIndexOf("}");
+  if (objectStart >= 0 && objectEnd > objectStart) {
+    candidates.add(trimmed.slice(objectStart, objectEnd + 1));
+  }
+  return [...candidates];
+}
+
+// src/core/episode/summary-generator.ts
+async function generateEpisodeSummary(transcript, llm) {
+  const response = await llm.complete(EPISODE_SUMMARY_SYSTEM_PROMPT, buildEpisodeSummaryPrompt(transcript));
+  return parseEpisodeSummaryResponse(response);
+}
+
+// src/app/episode-ingest/service/preflight.ts
+import path2 from "path";
+
+// src/core/episode/transcript-render.ts
+var MIN_EPISODE_MESSAGES = 4;
+var MAX_EPISODE_TRANSCRIPT_CHARS = 14e3;
+function renderTranscript(messages) {
+  return messages.map((message) => `${message.role === "user" ? "User" : "Assistant"}: ${message.text.trim()}`).join("\n");
+}
+function capEpisodeTranscript(transcript, maxChars) {
+  if (transcript.length <= maxChars) {
+    return transcript;
+  }
+  const omissionMarker = "\n\n[Earlier middle transcript omitted for brevity]\n\n";
+  const headBudget = Math.max(0, Math.floor((maxChars - omissionMarker.length) * 0.35));
+  const tailBudget = Math.max(0, maxChars - omissionMarker.length - headBudget);
+  const head = trimToBoundary(transcript.slice(0, headBudget), false);
+  const tail = trimToBoundary(transcript.slice(-tailBudget), true);
+  return `${head}${omissionMarker}${tail}`.trim();
+}
+function trimToBoundary(value, fromStart) {
+  if (value.length === 0) {
+    return value;
+  }
+  if (fromStart) {
+    const boundary = value.search(/\s/u);
+    return boundary >= 0 ? value.slice(boundary).trimStart() : value.trim();
+  }
+  const reversedBoundary = value.trimEnd().search(/\s\S*$/u);
+  return reversedBoundary >= 0 ? value.slice(0, reversedBoundary).trimEnd() : value.trim();
+}
+
+// src/app/episode-ingest/service/shared.ts
+var CHARS_PER_TOKEN_ESTIMATE = 4;
+function estimateInputTokens(renderedTranscript) {
+  return Math.max(1, Math.ceil(renderedTranscript.length / CHARS_PER_TOKEN_ESTIMATE));
+}
+function estimateEpisodeSummaryInputTokens(renderedTranscript) {
+  return estimateInputTokens(EPISODE_SUMMARY_SYSTEM_PROMPT) + estimateInputTokens(buildEpisodeSummaryPrompt(renderedTranscript));
+}
+async function embedEpisodeSummary(summary, ports) {
+  if (ports.embedSummary) {
+    try {
+      return normalizeEmbeddingVector(await ports.embedSummary(summary));
+    } catch {
+      return void 0;
+    }
+  }
+  return embedEpisodeSummaryWithPort(summary, ports.embedding);
+}
+async function embedEpisodeSummaryWithPort(summary, embeddingPort) {
+  if (!embeddingPort) {
+    return void 0;
+  }
+  try {
+    const vectors = await embeddingPort.embed([summary]);
+    return normalizeEmbeddingVector(vectors[0]);
+  } catch {
+    return void 0;
+  }
+}
+function parseCandidateEndedAt(endedAt) {
+  if (!endedAt) {
+    return void 0;
+  }
+  const parsed = new Date(endedAt);
+  return Number.isNaN(parsed.getTime()) ? void 0 : parsed;
+}
+function createSerializedExecutor() {
+  let pending = Promise.resolve();
+  return async (task) => {
+    const current = pending.then(task, task);
+    pending = current.then(
+      () => void 0,
+      () => void 0
+    );
+    return current;
+  };
+}
+function createEmptyUsageStats() {
+  return {
+    calls: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    totalTokens: 0,
+    totalCost: 0
+  };
+}
+function cloneUsageStats(usage) {
+  return {
+    calls: usage.calls,
+    inputTokens: usage.inputTokens,
+    outputTokens: usage.outputTokens,
+    cacheReadTokens: usage.cacheReadTokens,
+    cacheWriteTokens: usage.cacheWriteTokens,
+    totalTokens: usage.totalTokens,
+    totalCost: usage.totalCost
+  };
+}
+function addUsageStats(total, usage) {
+  total.calls += usage.calls;
+  total.inputTokens += usage.inputTokens;
+  total.outputTokens += usage.outputTokens;
+  total.cacheReadTokens += usage.cacheReadTokens;
+  total.cacheWriteTokens += usage.cacheWriteTokens;
+  total.totalTokens += usage.totalTokens;
+  total.totalCost += usage.totalCost;
+  return total;
+}
+function trimOptionalString(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
+}
+function formatExecutionError(error) {
+  if (error instanceof Error) {
+    return error.message || error.name;
+  }
+  return String(error);
+}
+function compareCandidatesByEndedAt(left, right) {
+  const leftTime = left.endedAt ? new Date(left.endedAt).getTime() : Number.NEGATIVE_INFINITY;
+  const rightTime = right.endedAt ? new Date(right.endedAt).getTime() : Number.NEGATIVE_INFINITY;
+  if (leftTime !== rightTime) {
+    return rightTime - leftTime;
+  }
+  return left.filePath.localeCompare(right.filePath);
+}
+function normalizeEmbeddingVector(vector) {
+  const normalized = vector?.map((value) => Number.isFinite(value) ? value : 0);
+  return normalized && normalized.length > 0 ? normalized : void 0;
+}
+
+// src/app/episode-ingest/service/preflight.ts
+var ACTIVE_SESSION_WINDOW_MS = 5 * 60 * 1e3;
+async function prepareEpisodeIngest(targetPath, ports, options = {}) {
+  const files = await ports.files.discoverFiles(targetPath);
+  if (files.length === 0) {
+    return createEmptyPreflightResult();
+  }
+  if (ports.sessionRegistry) {
+    await ports.sessionRegistry.listSessions();
+  }
+  const requestedPreflightConcurrency = options.preflightConcurrency ?? 20;
+  const preflightConcurrency = Number.isFinite(requestedPreflightConcurrency) ? Math.max(1, Math.trunc(requestedPreflightConcurrency)) : 20;
+  const workerCount = Math.min(preflightConcurrency, files.length);
+  const skippedByIndex = new Array(files.length);
+  const invalidByIndex = new Array(files.length);
+  const candidatesByIndex = new Array(files.length);
+  const referenceNow = options.now ?? /* @__PURE__ */ new Date();
+  let nextIndex = 0;
+  let completed = 0;
+  await Promise.all(
+    Array.from({ length: workerCount }, async () => {
+      while (true) {
+        const currentIndex = nextIndex;
+        nextIndex += 1;
+        if (currentIndex >= files.length) {
+          return;
+        }
+        const filePath = files[currentIndex];
+        if (!filePath) {
+          return;
+        }
+        const result = await classifyPreflightTranscript(filePath, ports, {
+          referenceNow,
+          regenerate: options.regenerate === true
+        });
+        if (result.kind === "candidate") {
+          candidatesByIndex[currentIndex] = result.value;
+        } else if (result.kind === "skipped") {
+          skippedByIndex[currentIndex] = result.value;
+        } else {
+          invalidByIndex[currentIndex] = result.value;
+        }
+        completed += 1;
+        options.onPreflightProgress?.(completed, files.length);
+      }
+    })
+  );
+  const skipped = skippedByIndex.flatMap((entry) => entry ? [entry] : []);
+  const invalid = invalidByIndex.flatMap((entry) => entry ? [entry] : []);
+  const candidates = candidatesByIndex.flatMap((entry) => entry ? [entry] : []);
+  candidates.sort(compareCandidatesByEndedAt);
+  return {
+    files,
+    candidates,
+    skipped,
+    invalid,
+    totals: {
+      discovered: files.length,
+      candidates: candidates.length,
+      skipped: skipped.length,
+      invalid: invalid.length,
+      skippedShort: skipped.filter((entry) => entry.reason === "skipped_short").length,
+      skippedActive: skipped.filter((entry) => entry.reason === "skipped_active").length,
+      skippedExists: skipped.filter((entry) => entry.reason === "skipped_exists").length
+    }
+  };
+}
+async function classifyPreflightTranscript(filePath, ports, options) {
+  const parsedTranscript = await ports.transcript.parseFile(filePath);
+  const cleanedMessages = parsedTranscript.messages.filter((message) => message.text.trim().length > 0);
+  const parsedSessionId = parsedTranscript.metadata.sessionId?.trim() || void 0;
+  const registryMeta = parsedSessionId ? await ports.sessionRegistry?.getSessionMeta(parsedSessionId) : void 0;
+  const reconstructedMeta = registryMeta ? void 0 : {
+    surface: parsedTranscript.metadata.reconstructedSurface ?? null,
+    metadataSource: parsedTranscript.metadata.surfaceReconstructionSource ?? "none"
+  };
+  const resolvedMeta = resolveSessionMeta(filePath, parsedSessionId, registryMeta, reconstructedMeta);
+  if (!resolvedMeta.sessionId && cleanedMessages.length === 0) {
+    return {
+      kind: "invalid",
+      value: {
+        filePath,
+        sessionId: void 0,
+        transcriptHash: parsedTranscript.metadata.transcriptHash,
+        messageCount: 0,
+        metadataSource: resolvedMeta.metadataSource
+      }
+    };
+  }
+  const existingEpisode = await findExistingEpisode(ports, resolvedMeta.sessionId, parsedTranscript.metadata.transcriptHash);
+  if (existingEpisode && options.regenerate !== true) {
+    return {
+      kind: "skipped",
+      value: {
+        filePath,
+        reason: "skipped_exists",
+        sessionId: resolvedMeta.sessionId,
+        transcriptHash: parsedTranscript.metadata.transcriptHash,
+        messageCount: cleanedMessages.length,
+        startedAt: parsedTranscript.metadata.startedAt,
+        endedAt: parsedTranscript.metadata.endedAt,
+        agentId: resolvedMeta.agentId,
+        surface: resolvedMeta.surface,
+        metadataSource: resolvedMeta.metadataSource,
+        existingEpisode
+      }
+    };
+  }
+  if (cleanedMessages.length < MIN_EPISODE_MESSAGES) {
+    return {
+      kind: "skipped",
+      value: {
+        filePath,
+        reason: "skipped_short",
+        sessionId: resolvedMeta.sessionId,
+        transcriptHash: parsedTranscript.metadata.transcriptHash,
+        messageCount: cleanedMessages.length,
+        startedAt: parsedTranscript.metadata.startedAt,
+        endedAt: parsedTranscript.metadata.endedAt,
+        agentId: resolvedMeta.agentId,
+        surface: resolvedMeta.surface,
+        metadataSource: resolvedMeta.metadataSource
+      }
+    };
+  }
+  if (options.skipActiveSessionCheck !== true && isActiveSession(parsedTranscript.metadata.endedAt, options.referenceNow)) {
+    return {
+      kind: "skipped",
+      value: {
+        filePath,
+        reason: "skipped_active",
+        sessionId: resolvedMeta.sessionId,
+        transcriptHash: parsedTranscript.metadata.transcriptHash,
+        messageCount: cleanedMessages.length,
+        startedAt: parsedTranscript.metadata.startedAt,
+        endedAt: parsedTranscript.metadata.endedAt,
+        agentId: resolvedMeta.agentId,
+        surface: resolvedMeta.surface,
+        metadataSource: resolvedMeta.metadataSource
+      }
+    };
+  }
+  const renderedTranscript = capEpisodeTranscript(renderTranscript(cleanedMessages), MAX_EPISODE_TRANSCRIPT_CHARS);
+  return {
+    kind: "candidate",
+    value: {
+      filePath,
+      sessionId: resolvedMeta.sessionId,
+      sourceRef: resolvedMeta.sourceRef,
+      transcriptHash: parsedTranscript.metadata.transcriptHash,
+      startedAt: parsedTranscript.metadata.startedAt,
+      endedAt: parsedTranscript.metadata.endedAt,
+      messageCount: cleanedMessages.length,
+      agentId: resolvedMeta.agentId,
+      surface: resolvedMeta.surface,
+      metadataSource: resolvedMeta.metadataSource,
+      renderedTranscript,
+      estimatedInputTokens: estimateInputTokens(renderedTranscript),
+      ...existingEpisode ? { existingEpisode } : {}
+    }
+  };
+}
+function createEmptyPreflightResult() {
+  return {
+    files: [],
+    candidates: [],
+    skipped: [],
+    invalid: [],
+    totals: {
+      discovered: 0,
+      candidates: 0,
+      skipped: 0,
+      invalid: 0,
+      skippedShort: 0,
+      skippedActive: 0,
+      skippedExists: 0
+    }
+  };
+}
+function resolveSessionMeta(filePath, parsedSessionId, registryMeta, reconstructedMeta) {
+  if (registryMeta) {
+    return {
+      sessionId: parsedSessionId ?? registryMeta.sessionId,
+      sourceRef: registryMeta.sourceRef,
+      agentId: registryMeta.agentId,
+      surface: registryMeta.surface,
+      metadataSource: "registry"
+    };
+  }
+  return {
+    sessionId: parsedSessionId,
+    sourceRef: filePath,
+    agentId: deriveAgentIdFromPath(filePath),
+    surface: reconstructedMeta?.surface ?? null,
+    metadataSource: reconstructedMeta?.metadataSource ?? "none"
+  };
+}
+function deriveAgentIdFromPath(filePath) {
+  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;
+  }
+  const candidate = grandparent.trim();
+  if (!candidate || candidate === "." || candidate === "/") {
+    return null;
+  }
+  return candidate;
+}
+function isActiveSession(endedAt, now) {
+  if (!endedAt) {
+    return false;
+  }
+  const endedAtDate = new Date(endedAt);
+  if (Number.isNaN(endedAtDate.getTime())) {
+    return false;
+  }
+  return endedAtDate.getTime() > now.getTime() - ACTIVE_SESSION_WINDOW_MS;
+}
+async function findExistingEpisode(ports, sessionId, transcriptHash) {
+  const bySourceId = sessionId ? await ports.episodes.getEpisodeBySourceId("openclaw", sessionId) : null;
+  if (bySourceId) {
+    return bySourceId;
+  }
+  return ports.episodes.getEpisodeByTranscriptHash("openclaw", transcriptHash);
+}
+
+// src/app/episode-ingest/service/execute.ts
+async function ingestEpisodeTranscript(filePath, ports, options) {
+  const createSummaryLlm = ports.createSummaryLlm;
+  if (!createSummaryLlm) {
+    throw new Error("Episode transcript ingest requires createSummaryLlm().");
+  }
+  const classification = await classifyPreflightTranscript(filePath, ports, {
+    referenceNow: options.now ?? /* @__PURE__ */ new Date(),
+    regenerate: options.regenerate === true,
+    skipActiveSessionCheck: options.skipActiveSessionCheck === true
+  });
+  if (classification.kind === "skipped") {
+    return {
+      kind: "skipped",
+      skipped: classification.value
+    };
+  }
+  if (classification.kind === "invalid") {
+    return {
+      kind: "invalid",
+      invalid: classification.value
+    };
+  }
+  const candidate = applyCandidateOverrides(classification.value, options.candidateOverrides);
+  const session = await executeEpisodeCandidate(candidate, createSummaryLlm, ports, options.genVersion, async (task) => task());
+  return {
+    kind: "executed",
+    candidate,
+    session
+  };
+}
+async function executeEpisodeIngestPlan(plan, ports, options) {
+  const createSummaryLlm = ports.createSummaryLlm;
+  if (!createSummaryLlm) {
+    throw new Error("Episode ingest execution requires createSummaryLlm().");
+  }
+  if (!Number.isFinite(options.concurrency) || Math.trunc(options.concurrency) <= 0) {
+    throw new Error(`Episode ingest concurrency must be a positive integer. Received: ${options.concurrency}.`);
+  }
+  if (plan.candidates.length === 0) {
+    return {
+      sessions: [],
+      usage: createEmptyUsageStats(),
+      modelRef: plan.model.modelRef,
+      totals: {
+        attempted: 0,
+        written: 0,
+        updated: 0,
+        unchanged: 0,
+        failed: 0
+      }
+    };
+  }
+  const results = new Array(plan.candidates.length);
+  let nextIndex = 0;
+  let completed = 0;
+  const workerCount = Math.min(Math.trunc(options.concurrency), plan.candidates.length);
+  const runSerializedWrite = createSerializedExecutor();
+  await Promise.all(
+    Array.from({ length: workerCount }, async () => {
+      while (true) {
+        const currentIndex = nextIndex;
+        nextIndex += 1;
+        if (currentIndex >= plan.candidates.length) {
+          return;
+        }
+        const candidate = plan.candidates[currentIndex];
+        if (!candidate) {
+          return;
+        }
+        const result = await executeEpisodeCandidate(candidate, createSummaryLlm, ports, options.genVersion, runSerializedWrite);
+        results[currentIndex] = result;
+        completed += 1;
+        options.onProgress?.(completed, plan.candidates.length, result);
+      }
+    })
+  );
+  const usage = results.reduce((total, result) => addUsageStats(total, result.usage), createEmptyUsageStats());
+  return {
+    sessions: results,
+    usage,
+    modelRef: plan.model.modelRef,
+    totals: {
+      attempted: results.length,
+      written: results.filter((result) => result.action === "written").length,
+      updated: results.filter((result) => result.action === "updated").length,
+      unchanged: results.filter((result) => result.action === "unchanged").length,
+      failed: results.filter((result) => result.action === "failed").length
+    }
+  };
+}
+async function executeEpisodeCandidate(candidate, createSummaryLlm, ports, genVersion, runSerializedWrite) {
+  const startedAt = trimOptionalString(candidate.startedAt) ?? trimOptionalString(candidate.existingEpisode?.startedAt);
+  const endedAt = trimOptionalString(candidate.endedAt) ?? trimOptionalString(candidate.existingEpisode?.endedAt);
+  if (!startedAt) {
+    return {
+      action: "failed",
+      filePath: candidate.filePath,
+      ...candidate.sessionId ? { sessionId: candidate.sessionId } : {},
+      error: "missing_started_at",
+      usage: createEmptyUsageStats()
+    };
+  }
+  const llm = createSummaryLlm();
+  try {
+    const structured = await generateEpisodeSummary(candidate.renderedTranscript, llm);
+    if (!structured) {
+      return {
+        action: "failed",
+        filePath: candidate.filePath,
+        ...candidate.sessionId ? { sessionId: candidate.sessionId } : {},
+        error: "invalid_response",
+        usage: cloneUsageStats(llm.metadata.usage)
+      };
+    }
+    const existingEpisode = candidate.existingEpisode;
+    const embedding = await embedEpisodeSummary(structured.summary, ports);
+    const writeResult = await runSerializedWrite(
+      async () => ports.episodes.upsertEpisode({
+        source: "openclaw",
+        ...candidate.sessionId ? { sourceId: candidate.sessionId } : {},
+        sourceRef: candidate.metadataSource === "registry" || !existingEpisode?.sourceRef ? candidate.sourceRef : existingEpisode.sourceRef,
+        transcriptHash: candidate.transcriptHash,
+        ...trimOptionalString(candidate.agentId) ?? trimOptionalString(existingEpisode?.agentId) ? { agentId: trimOptionalString(candidate.agentId) ?? trimOptionalString(existingEpisode?.agentId) } : {},
+        ...trimOptionalString(candidate.surface) ?? trimOptionalString(existingEpisode?.surface) ? { surface: trimOptionalString(candidate.surface) ?? trimOptionalString(existingEpisode?.surface) } : {},
+        startedAt,
+        ...endedAt ? { endedAt } : {},
+        summary: structured.summary,
+        tags: structured.tags,
+        activityLevel: structured.activityLevel,
+        ...structured.project ? { project: structured.project } : {},
+        genModel: llm.metadata.modelRef,
+        genVersion,
+        messageCount: candidate.messageCount,
+        ...embedding ? { embedding } : {}
+      })
+    );
+    return {
+      action: mapWriteAction(writeResult.action),
+      filePath: candidate.filePath,
+      ...candidate.sessionId ? { sessionId: candidate.sessionId } : {},
+      activityLevel: structured.activityLevel,
+      episodeId: writeResult.episode.id,
+      usage: cloneUsageStats(llm.metadata.usage)
+    };
+  } catch (error) {
+    return {
+      action: "failed",
+      filePath: candidate.filePath,
+      ...candidate.sessionId ? { sessionId: candidate.sessionId } : {},
+      error: formatExecutionError(error),
+      usage: cloneUsageStats(llm.metadata.usage)
+    };
+  }
+}
+function applyCandidateOverrides(candidate, overrides) {
+  if (!overrides) {
+    return candidate;
+  }
+  return {
+    ...candidate,
+    ...overrides.sessionId !== void 0 ? { sessionId: overrides.sessionId } : {},
+    ...overrides.sourceRef !== void 0 ? { sourceRef: overrides.sourceRef } : {},
+    ..."agentId" in overrides ? { agentId: overrides.agentId ?? null } : {},
+    ..."surface" in overrides ? { surface: overrides.surface ?? null } : {},
+    ...overrides.metadataSource !== void 0 ? { metadataSource: overrides.metadataSource } : {}
+  };
+}
+function mapWriteAction(action) {
+  if (action === "inserted") {
+    return "written";
+  }
+  return action;
+}
+
+// src/app/episode-ingest/service/backfill.ts
+async function backfillEpisodeEmbeddings(ports, options) {
+  const embedding = ports.embedding;
+  if (!embedding) {
+    throw new Error("Episode embedding backfill requires an embedding provider.");
+  }
+  if (!Number.isFinite(options.concurrency) || Math.trunc(options.concurrency) <= 0) {
+    throw new Error(`Episode embedding backfill concurrency must be a positive integer. Received: ${options.concurrency}.`);
+  }
+  const pendingEpisodes = await ports.episodes.listEpisodesWithoutEmbeddings();
+  if (pendingEpisodes.length === 0) {
+    return {
+      totalMissing: 0,
+      attempted: 0,
+      embedded: 0,
+      failed: 0,
+      estimatedInputTokens: 0
+    };
+  }
+  const estimatedInputTokens = pendingEpisodes.reduce((total, episode) => total + estimateInputTokens(episode.summary), 0);
+  const workerCount = Math.min(Math.trunc(options.concurrency), pendingEpisodes.length);
+  let nextIndex = 0;
+  let completed = 0;
+  let embeddedCount = 0;
+  let failedCount = 0;
+  await Promise.all(
+    Array.from({ length: workerCount }, async () => {
+      while (true) {
+        const currentIndex = nextIndex;
+        nextIndex += 1;
+        if (currentIndex >= pendingEpisodes.length) {
+          return;
+        }
+        const episode = pendingEpisodes[currentIndex];
+        if (!episode) {
+          return;
+        }
+        let status = "failed";
+        try {
+          const vector = await embedEpisodeSummaryWithPort(episode.summary, embedding);
+          if (vector) {
+            await ports.episodes.updateEpisodeEmbedding(episode.id, vector);
+            embeddedCount += 1;
+            status = "embedded";
+          } else {
+            failedCount += 1;
+          }
+        } catch {
+          failedCount += 1;
+        }
+        completed += 1;
+        options.onProgress?.(completed, pendingEpisodes.length, episode, status);
+      }
+    })
+  );
+  return {
+    totalMissing: pendingEpisodes.length,
+    attempted: pendingEpisodes.length,
+    embedded: embeddedCount,
+    failed: failedCount,
+    estimatedInputTokens
+  };
+}
+
+// src/app/episode-ingest/service/plan.ts
+function createEpisodeIngestPlan(preflight, model, options = {}) {
+  const cutoff = resolveRecentCutoff(options.recent, options.now);
+  let excludedByRecent = 0;
+  let excludedUndated = 0;
+  const candidates = preflight.candidates.flatMap((candidate) => {
+    const estimatedInputTokens = estimateEpisodeSummaryInputTokens(candidate.renderedTranscript);
+    const plannedCandidate = {
+      ...candidate,
+      estimatedInputTokens
+    };
+    if (!cutoff) {
+      return [plannedCandidate];
+    }
+    const endedAt = parseCandidateEndedAt(candidate.endedAt);
+    if (!endedAt) {
+      excludedByRecent += 1;
+      excludedUndated += 1;
+      return [];
+    }
+    if (endedAt.getTime() < cutoff.getTime()) {
+      excludedByRecent += 1;
+      return [];
+    }
+    return [plannedCandidate];
+  });
+  const inputTokens = candidates.reduce((total, candidate) => total + candidate.estimatedInputTokens, 0);
+  const outputTokens = candidates.length * 500;
+  const estimatedCostUsd = inputTokens / 1e6 * model.pricing.input + outputTokens / 1e6 * model.pricing.output;
+  return {
+    candidates,
+    model,
+    estimate: {
+      candidateCount: candidates.length,
+      inputTokens,
+      outputTokens,
+      totalTokens: inputTokens + outputTokens,
+      estimatedCostUsd
+    },
+    ...options.recent?.trim() ? { recent: options.recent.trim() } : {},
+    ...cutoff ? { recentCutoff: cutoff.toISOString() } : {},
+    totals: {
+      preflightCandidates: preflight.candidates.length,
+      selectedCandidates: candidates.length,
+      excludedByRecent,
+      excludedUndated
+    }
+  };
+}
+function resolveRecentCutoff(recent, now) {
+  const trimmedRecent = recent?.trim();
+  if (!trimmedRecent) {
+    return void 0;
+  }
+  const cutoff = parseRelativeDate(trimmedRecent, now ?? /* @__PURE__ */ new Date());
+  if (!cutoff) {
+    throw new Error(`Unsupported recent value "${trimmedRecent}". Use day shorthand like 30d or an ISO timestamp.`);
+  }
+  return cutoff;
+}
+
+// src/adapters/openclaw/session/sessions-store-reader.ts
+import * as fs3 from "fs/promises";
+import path3 from "path";
+async function readOpenClawSessionsStore(sessionsDir, logger) {
+  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)) {
+      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) {
+        continue;
+      }
+      if (!isRecord(value)) {
+        continue;
+      }
+      const sessionId = asTrimmedString(value["sessionId"]);
+      const sessionFile = asTrimmedString(value["sessionFile"]);
+      const origin = isRecord(value["origin"]) ? value["origin"] : void 0;
+      const surface = asTrimmedString(origin?.["surface"]);
+      const provider = asTrimmedString(origin?.["provider"]);
+      const chatType = asTrimmedString(value["chatType"]);
+      const updatedAt = asFiniteNumber(value["updatedAt"]);
+      entries.push({
+        sessionKey: normalizedSessionKey,
+        ...sessionId ? { sessionId } : {},
+        ...sessionFile ? { sessionFile: resolveSessionStorePath(sessionFile, resolvedSessionsDir) } : {},
+        ...surface ? { surface } : {},
+        ...provider ? { provider } : {},
+        ...chatType ? { chatType } : {},
+        ...updatedAt !== void 0 ? { updatedAt } : {}
+      });
+    }
+    return {
+      entries,
+      diagnostics: []
+    };
+  } catch (error) {
+    if (isFileNotFound2(error)) {
+      return {
+        entries: [],
+        diagnostics: [
+          {
+            kind: "missing_file",
+            message: `sessions.json missing at ${sessionsJsonPath}`,
+            path: sessionsJsonPath
+          }
+        ]
+      };
+    }
+    if (error instanceof SyntaxError) {
+      return {
+        entries: [],
+        diagnostics: [
+          {
+            kind: "malformed_json",
+            message: `sessions.json parse failed at ${sessionsJsonPath}: ${error.message}`,
+            path: sessionsJsonPath
+          }
+        ]
+      };
+    }
+    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 && !Array.isArray(value);
+}
+function asTrimmedString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function asFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function debugLog2(logger, subsystem, message) {
+  logger?.debug?.(`[agenr] ${subsystem}: ${message}`);
+}
+function isFileNotFound2(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function formatErrorMessage2(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+
+// src/adapters/openclaw/session/tui-lane.ts
+var TUI_SESSION_KEY_PATTERN = /^agent:([^:]+):([^:]+)$/i;
+var TUI_UUID_LANE_PATTERN = /^tui[a-z0-9]*-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var TUI_UUID_SUFFIX_PATTERN = /-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function parseTuiSessionKey(sessionKey) {
+  const normalizedSessionKey = sessionKey.trim();
+  if (normalizedSessionKey.length === 0) {
+    return null;
+  }
+  const match = TUI_SESSION_KEY_PATTERN.exec(normalizedSessionKey);
+  if (!match) {
+    return null;
+  }
+  const [, agentId, instanceLane] = match;
+  const normalizedAgentId = agentId?.trim();
+  const normalizedInstanceLane = instanceLane?.trim();
+  if (!normalizedAgentId || !normalizedInstanceLane || !normalizedInstanceLane.toLowerCase().startsWith("tui")) {
+    return null;
+  }
+  const stableLane = TUI_UUID_LANE_PATTERN.test(normalizedInstanceLane) ? normalizedInstanceLane.replace(TUI_UUID_SUFFIX_PATTERN, "") : normalizedInstanceLane;
+  return {
+    agentId: normalizedAgentId,
+    stableLane,
+    instanceLane: normalizedInstanceLane
+  };
+}
+
+export {
+  detectClaimKeyEntityFamilyCandidates,
+  detectClaimKeySingletonAliasCandidates,
+  buildTrustedClaimKeySupportSeed,
+  evaluateClaimKeySupport,
+  evaluateClaimKeyCompactness,
+  normalizeGroundingTags,
+  tokenizeGroundingText,
+  buildEntryLocalLexicalTokens,
+  applyClaimExtractionResultToEntry,
+  previewClaimKeyExtraction,
+  runBatchClaimExtraction,
+  validateSupersessionRules,
+  describeSupersessionRuleFailure,
+  computeContentHash,
+  computeNormContentHash,
+  validateEntriesWithIndexes,
+  storeEntriesDetailed,
+  deriveOpenClawSessionIdFromFilePath,
+  OpenClawTranscriptParser,
+  openClawTranscriptParser,
+  readOpenClawSessionsStore,
+  parseTuiSessionKey,
+  backfillEpisodeEmbeddings,
+  prepareEpisodeIngest,
+  ingestEpisodeTranscript,
+  executeEpisodeIngestPlan,
+  createEpisodeIngestPlan,
+  createOpenClawRepository
+};