@agenr/skeln-plugin 3.3.0 → 2026.6.3

package/dist/chunk-U74RE3L7.js

@@ -0,0 +1,3233 @@
+import {
+  DURABLE_SELECT_COLUMNS,
+  DURABLE_VECTOR_INDEX_NAME,
+  EMBEDDING_DIMENSIONS,
+  buildActiveDurableClause,
+  buildActiveEpisodeClause,
+  closeDurableValidity,
+  completeDreamRun,
+  createDreamRun,
+  createProfileSnapshot,
+  findActiveDurablesByClaimKey,
+  findExistingNormHashes,
+  getDailyDreamCost,
+  getDurable,
+  getDurables,
+  insertDurable,
+  mapActionRow,
+  mapDurableRow,
+  mapProposalRow,
+  mapRunRow,
+  normalizeDurableIds,
+  normalizeInteger,
+  normalizeNumber,
+  normalizeOptionalString,
+  normalizeStringArray,
+  normalizeTimestamp,
+  parseJsonStringArray,
+  parseStoredDreamRunStatus,
+  parseStoredDreamTier,
+  readBoolean,
+  readNumber,
+  readOptionalString,
+  readRequiredString,
+  reviewDreamProposal,
+  runImmediateTransaction,
+  supersedeDurable,
+  truncate,
+  updateDreamState,
+  updateDurable
+} from "./chunk-5TIP2EPP.js";
+import {
+  parseRelativeDate,
+  resolveClaimSlotPolicy
+} from "./chunk-GAERET5Q.js";
+import {
+  computeContentHash,
+  computeNormContentHash,
+  describeSupersessionRuleFailure,
+  runBatchClaimExtraction,
+  validateSupersessionRules
+} from "./chunk-SOQW7356.js";
+import {
+  DURABLE_KINDS,
+  EPISODE_ACTIVITY_LEVELS,
+  EXPIRY_LEVELS,
+  MEMORY_DIRECTIVE_CLAIM_KEY_PREFIX,
+  applyClaimKeyLifecycle,
+  buildExtractedClaimKeyLifecycle,
+  buildInferredIngestClaimKeySupportContext,
+  buildManualClaimKeyLifecycle,
+  buildPrecomputedClaimKeyLifecycle,
+  composeEmbeddingText,
+  defaultDirectiveTrigger,
+  hasPrecomputedClaimKeyLifecycleFields,
+  normalizeMemoryDirectiveClaimKey,
+  parseClaimKeyConfidence,
+  parseClaimKeySource,
+  parseClaimKeyStatus,
+  parseClaimSupportMode,
+  parseDirectivePolarity,
+  parseDirectiveTrigger
+} from "./chunk-VTHBPXDQ.js";
+import {
+  describeClaimKeyNormalizationFailure,
+  normalizeClaimKey,
+  validateTemporalValidityRange
+} from "./chunk-VBPYU7GO.js";
+
+// src/adapters/shared/errors.ts
+function formatErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/adapters/shared/memory-prompt-doctrine.ts
+var CLAIM_KEY_SLOT_GUIDANCE = 'exactly two segments: entity/attribute with one slash. Do not use nested paths like project/category/item; collapse extra words into snake_case on either side, for example "skeln/codebase_layout", "postgres/max_connections", or "project_name/deploy_strategy".';
+var CLAIM_KEY_DIRECTIVE_GUIDANCE = 'For directive entries only (type=directive), use the three-segment family user/memory_directive/<name>, for example "user/memory_directive/weekly_goals".';
+var CLAIM_KEY_DESCRIPTION = `Slot-like durables use ${CLAIM_KEY_SLOT_GUIDANCE} ${CLAIM_KEY_DIRECTIVE_GUIDANCE} Entries with the same claim key are candidates for supersession. Invalid claim keys on agenr_store are dropped with a warning; on agenr_update they reject the call.`;
+var MEMORY_RECALL_SECTION_HEADER = "## Memory Recall";
+var RECALL_FIRST = "Before answering anything about prior work, decisions, preferences, people, dates, unfinished work, or past sessions, call agenr_recall first. Session-start recall is automatic, and conservative before-turn recall may also appear as injected background context; use agenr_recall mid-session when you need context you do not already have.";
+var RECALL_MODES = "agenr_recall supports exact fact recall plus historical and episodic recall behind one tool: use mode=durables for exact facts, decisions, thresholds, and versions; use mode=auto for prior-state questions like what was the previous approach, what did we use before, or what changed from X to Y; use mode=episodes when you explicitly want session narrative recall.";
+var RECALL_TRUNCATED_PREVIEWS = "agenr_recall returns truncated durable previews with ids, scores, and preview_truncated flags.";
+var FETCH_WHEN_TRUNCATED = "Call agenr_fetch with id when preview_truncated=true or exact stored wording is required.";
+var RECALL_INJECTED_CONTEXT = "When Agenr injects memory automatically, treat it as non-user background context and use it silently when relevant rather than forcing it into the reply.";
+var RECALL_MODE_SCHEMA_DESCRIPTION = "Recall mode: auto routes between exact durable recall, historical-state recall, procedural recall, and episodes; durables forces exact durable recall; episodes forces temporal or semantic session recall; procedures forces procedural recall.";
+var STORE_FUTURE_SESSION_QUESTION = "will a fresh future session make a better decision because this was stored, or are you just recording that something happened?";
+var STORE_CANONICAL_RECORD = "If another system already holds the canonical record - such as version control, a task or ticket tracker, a calendar, a signed document, a chat or email thread, or a database/CRM - usually do not store that record. Store only the durable takeaway: the standing rule, implication, lesson, preference, risk, or relationship.";
+var STORE_DO_NOT_PROGRESS_OR_CANONICAL = "Do not store progress logs, plans, or data already canonical in git, tickets, calendars, signed docs, chat/email, or databases.";
+var STORE_TAKEAWAY_NOT_ACTIVITY = "Store the durable takeaway, standing rule, preference, risk, lesson, or relationship instead of raw activity.";
+var STORE_CLAIM_KEY_SLOT_USAGE = "Use claimKey for slot-like facts that may be superseded later, such as versions, strategies, owners, or limits.";
+var CLAIM_KEY_PROMPT_LINE = `When storing slot-like facts, pass claimKey as ${CLAIM_KEY_SLOT_GUIDANCE}`;
+var CLAIM_KEY_STORE_GUIDELINE = `Format claimKey for slot-like durables as ${CLAIM_KEY_SLOT_GUIDANCE}`;
+var DURABLE_TYPE_DEFINITIONS_PROMPT = [
+  { name: "fact", definition: "durable truth about a person, system, place, or how something works" },
+  { name: "decision", definition: "standing rule, constraint, policy, or chosen approach future sessions should follow" },
+  { name: "preference", definition: "what someone likes, wants, values, or wants avoided" },
+  { name: "lesson", definition: "non-obvious takeaway from experience that should change future behavior" },
+  { name: "milestone", definition: "rare one-time event with durable future significance, not ordinary task completion" }
+];
+var DURABLE_TYPE_DEFINITIONS_TOOL = [
+  { name: "fact", definition: "durable truth about a person, system, place, or how something works" },
+  { name: "decision", definition: "a standing rule, constraint, policy, or chosen approach future sessions should follow" },
+  { name: "preference", definition: "what someone likes, wants, values, or wants avoided" },
+  { name: "lesson", definition: "a non-obvious takeaway learned from experience that should change future behavior" },
+  { name: "milestone", definition: "a rare one-time event with durable future significance, not ordinary execution progress" },
+  { name: "relationship", definition: "a meaningful durable connection between people, groups, or systems" }
+];
+var STORE_NEGATIVE_EXAMPLES = [
+  "I merged PR #123.",
+  "I filed a support ticket.",
+  "We had a meeting at 3 PM.",
+  "I sent the contract for signature.",
+  "We spent two hours debugging the outage."
+];
+var STORE_POSITIVE_EXAMPLES = [
+  { quote: "Always use the structured export path because raw sync corrupts timestamps.", label: "decision or lesson" },
+  { quote: "Jim prefers text-first updates and dislikes surprise calls.", label: "preference" },
+  { quote: "Service restarts fail unless config Y is enabled.", label: "lesson" },
+  { quote: "The office Wi-Fi name is Acorn-5G.", label: "fact" }
+];
+var STORE_DECISION_CATCH_ALL = "Do not use decision as a catch-all for important activity updates.";
+var STORE_ANTI_PATTERNS_TOOL = "Do not store plans, checklists, speculative future state, progress snapshots, session narration, or rephrased recalled material.";
+var STORE_PROGRESS_SNAPSHOTS = "Do not store progress snapshots or current-state narration about what is happening right now as durable memory.";
+var STORE_PLANS_AND_SPECULATION = "Do not store plans, checklists, or speculative future state as facts or decisions.";
+var STORE_NO_RESTORING_RECALL = "Do not re-store recalled durables, episode summaries, continuity text, or conversation summaries as new evidence.";
+var STORE_NO_META_NARRATION = "Do not store meta narration about the current session.";
+var STORE_LIFETIMES = "Use memory lifetimes deliberately: core is injected at every session start and should be rare, permanent is durable recall-on-demand memory, and temporary is short-horizon. Importance is 1 to 10; 7 is normal durable memory and 9 to 10 is rare and critical.";
+var STORE_SUPERSEDES_TOOL = "When replacing an existing fact, pass `supersedes` with the old entry's ID. When storing a slot-like fact (for example, a library version or a rollout strategy), pass `claimKey` to enable future supersession detection.";
+var STORE_ASK_BEFORE_STORING = "Do not ask before storing - but do ask whether future-you actually needs it.";
+var STORE_OPENCLAW_NOT_LOGGING = `Use agenr_store for durable memory, not for logging. Apply the future-session test: ${STORE_FUTURE_SESSION_QUESTION}`;
+var STORE_SKELN_NOT_LOGGING = "Use agenr_store for durable memory, not for logging. Store only the durable takeaway, standing rule, preference, risk, lesson, or relationship - not progress logs or data already canonical elsewhere.";
+var UPDATE_VS_SUPERSEDES = "Use agenr_update to correct metadata on an existing durable. Use agenr_store with supersedes for substantive content replacement.";
+var UPDATE_CONTRADICTED_BY_EVIDENCE = "When memory is contradicted by live evidence, fix it with agenr_update instead of silently working around it.";
+var UPDATE_TARGET_SELECTOR = "Provide exactly one target selector: id or subject.";
+var UPDATE_SUBSTANTIVE_REPLACEMENT = "Use agenr_store with supersedes for substantive content replacement.";
+var UPDATE_METADATA_DESCRIPTION = "Update an existing memory entry in place. Supports metadata corrections: importance, expiry, claimKey, validFrom, validTo, and project.";
+var FETCH_PREFER_ID = "Prefer id from agenr_recall when preview_truncated=true or when exact wording matters.";
+var SKELN_RECALL_TOOL_GUIDELINES = [
+  "Use focused natural-language queries instead of broad 'everything' searches.",
+  "Use mode=procedures for how-to or checklist questions, and mode=episodes for what-happened questions tied to time or sessions.",
+  "Use asOf when the user asks what was true at an earlier point in time."
+];
+var MEMORY_DOCTRINE = {
+  recall: {
+    first: RECALL_FIRST,
+    modes: RECALL_MODES,
+    truncatedPreviews: RECALL_TRUNCATED_PREVIEWS,
+    fetchWhenTruncated: FETCH_WHEN_TRUNCATED,
+    truncatedPreviewsWithFetch: `${RECALL_TRUNCATED_PREVIEWS} ${FETCH_WHEN_TRUNCATED}`,
+    injectedContext: RECALL_INJECTED_CONTEXT,
+    modeSchema: RECALL_MODE_SCHEMA_DESCRIPTION
+  },
+  store: {
+    futureSessionQuestion: STORE_FUTURE_SESSION_QUESTION,
+    canonicalRecord: STORE_CANONICAL_RECORD,
+    claimKeyPromptLine: CLAIM_KEY_PROMPT_LINE,
+    claimKeyStoreGuideline: CLAIM_KEY_STORE_GUIDELINE,
+    claimKeySlotUsage: STORE_CLAIM_KEY_SLOT_USAGE,
+    openClawNotLogging: STORE_OPENCLAW_NOT_LOGGING,
+    skelnNotLogging: STORE_SKELN_NOT_LOGGING,
+    decisionCatchAll: STORE_DECISION_CATCH_ALL,
+    lifetimes: STORE_LIFETIMES
+  },
+  update: {
+    vsSupersedes: UPDATE_VS_SUPERSEDES,
+    contradictedByEvidence: UPDATE_CONTRADICTED_BY_EVIDENCE,
+    targetSelector: UPDATE_TARGET_SELECTOR,
+    substantiveReplacement: UPDATE_SUBSTANTIVE_REPLACEMENT
+  },
+  fetch: {
+    preferId: FETCH_PREFER_ID
+  }
+};
+function formatDurableTypeGuide(definitions, separator) {
+  const clauses = definitions.map((entry) => `${entry.name} = ${entry.definition}`);
+  return `Type guide: ${clauses.join(separator)}`;
+}
+function formatUsuallyDoNotStoreLine() {
+  const leading = STORE_NEGATIVE_EXAMPLES.slice(0, -1).map((example) => `'${example}'`).join(", ");
+  const last = STORE_NEGATIVE_EXAMPLES[STORE_NEGATIVE_EXAMPLES.length - 1];
+  return `Usually do not store: ${leading}, or '${last}'`;
+}
+function formatDoStoreTakeawayPromptLine() {
+  const examples = STORE_POSITIVE_EXAMPLES.map((example) => `'${example.quote}' (${example.label})`).join(", ");
+  return `Do store the durable takeaway instead: ${examples}.`;
+}
+function formatStoreExamplesToolParagraph() {
+  const negative = formatUsuallyDoNotStoreLine();
+  const positiveQuotes = STORE_POSITIVE_EXAMPLES.map((example) => `'${example.quote}'`).join(" ");
+  return `${negative} Do store the takeaway instead: ${positiveQuotes}`;
+}
+function formatStoreAntiPatternsToolParagraph() {
+  return `${STORE_DECISION_CATCH_ALL} ${STORE_ANTI_PATTERNS_TOOL}`;
+}
+function buildStoreToolGuidelines() {
+  return [STORE_DO_NOT_PROGRESS_OR_CANONICAL, STORE_TAKEAWAY_NOT_ACTIVITY, STORE_CLAIM_KEY_SLOT_USAGE, CLAIM_KEY_STORE_GUIDELINE];
+}
+function buildUpdateToolGuidelines() {
+  return [UPDATE_TARGET_SELECTOR, UPDATE_SUBSTANTIVE_REPLACEMENT];
+}
+function buildSkelnRecallToolGuidelines() {
+  return [...SKELN_RECALL_TOOL_GUIDELINES];
+}
+function buildOpenClawStorePromptLines() {
+  return [
+    STORE_OPENCLAW_NOT_LOGGING,
+    STORE_CANONICAL_RECORD,
+    formatDurableTypeGuide(DURABLE_TYPE_DEFINITIONS_PROMPT, "; "),
+    STORE_DECISION_CATCH_ALL,
+    formatUsuallyDoNotStoreLine(),
+    formatDoStoreTakeawayPromptLine(),
+    STORE_PROGRESS_SNAPSHOTS,
+    STORE_PLANS_AND_SPECULATION,
+    STORE_NO_RESTORING_RECALL,
+    STORE_NO_META_NARRATION,
+    STORE_LIFETIMES,
+    CLAIM_KEY_PROMPT_LINE
+  ];
+}
+function buildOpenClawStoreToolDescription() {
+  return [
+    `Store a new durable memory entry in agenr. Apply the future-session test first: ${STORE_FUTURE_SESSION_QUESTION}`,
+    ...buildStoreToolGuidelines(),
+    STORE_CANONICAL_RECORD,
+    formatDurableTypeGuide(DURABLE_TYPE_DEFINITIONS_TOOL, ". "),
+    formatStoreExamplesToolParagraph(),
+    formatStoreAntiPatternsToolParagraph(),
+    `${STORE_SUPERSEDES_TOOL} ${CLAIM_KEY_STORE_GUIDELINE}`,
+    STORE_ASK_BEFORE_STORING
+  ].join("\n\n");
+}
+function buildSkelnStoreToolDescription() {
+  return "Store a new durable memory entry in agenr. Store only durable facts, decisions, preferences, lessons, milestones, and relationships that help a future Skeln session make a better decision.";
+}
+function buildOpenClawRecallToolDescription() {
+  return "Retrieve knowledge from agenr long-term memory. Use mode=auto for the normal path, including historical-state questions like what was the previous approach or what changed from X to Y and procedural questions like how to do something or what steps to follow; use mode=durables for exact facts and decisions; use mode=episodes for time-bounded 'what happened' questions; use mode=procedures for canonical methods and checklists. Time periods are parsed from the query text. Session-start recall is already handled automatically.";
+}
+function buildSkelnRecallToolDescription() {
+  return "Retrieve knowledge from agenr long-term memory. Use mode=auto for normal use, including exact facts, historical-state questions, time-bounded episode questions, and procedural questions.";
+}
+function buildUpdateToolDescription() {
+  return [UPDATE_METADATA_DESCRIPTION, ...buildUpdateToolGuidelines()].join(" ");
+}
+
+// src/adapters/shared/entry-tools.ts
+var ENTRY_TYPE_DESCRIPTION = "Knowledge type to store. Use fact for durable truth about a person, system, place, or how something works. Use decision for a standing rule, constraint, policy, or chosen approach future sessions should follow - not a progress update or completed action. Use preference for what someone likes, wants, values, or wants avoided. Use lesson for a non-obvious takeaway learned from experience that should change future behavior. Use milestone for a rare one-time event with durable future significance - not ordinary execution progress. Use relationship for a meaningful durable connection between people, groups, or systems. Use directive for first-class memory behavior instructions under claim key user/memory_directive/<name>.";
+var EXPIRY_DESCRIPTION = "Lifetime bucket: core (always injected at session start, use sparingly), permanent (durable and recalled on demand), or temporary (short-horizon).";
+var UPDATE_EXPIRY_DESCRIPTION = `${EXPIRY_DESCRIPTION} Accepted values: ${EXPIRY_LEVELS.join(", ")}.`;
+var RECALL_MODES2 = ["auto", "durables", "episodes", "procedures"];
+function asRecord(value) {
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    return value;
+  }
+  throw new Error("Tool parameters must be an object.");
+}
+function parseExpiry(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (EXPIRY_LEVELS.includes(value)) {
+    return value;
+  }
+  throw new Error(`Unsupported expiry "${value}".`);
+}
+function parseDurableKinds(values) {
+  return normalizeStringArray2(values).map((value) => parseDurableKind(value));
+}
+function parseDurableKind(value) {
+  if (DURABLE_KINDS.includes(value)) {
+    return value;
+  }
+  throw new Error(`Unsupported entry type "${value}".`);
+}
+function parseRecallMode(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (RECALL_MODES2.includes(value)) {
+    return value;
+  }
+  throw new Error(`Unsupported recall mode "${value}".`);
+}
+function normalizeStringArray2(values) {
+  if (!values) {
+    return [];
+  }
+  return Array.from(new Set(values.map((value) => value.trim()).filter((value) => value.length > 0)));
+}
+function formatTargetSelector(id, subject) {
+  if (id) {
+    return `id:${JSON.stringify(id)}`;
+  }
+  if (subject) {
+    return `subject:${JSON.stringify(subject)}`;
+  }
+  return "unknown";
+}
+function formatTargetSelectorFromParams(params, options = {}) {
+  const id = readTrimmedOptionalStringParam(params, "id");
+  const subject = readTrimmedOptionalStringParam(params, "subject");
+  const maxValueChars = options.maxValueChars;
+  return formatTargetSelector(
+    id && maxValueChars !== void 0 ? truncate(id, maxValueChars) : id,
+    subject && maxValueChars !== void 0 ? truncate(subject, maxValueChars) : subject
+  );
+}
+function readTrimmedOptionalStringParam(params, key) {
+  const value = params[key];
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new Error(`${key} must be a string.`);
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function sanitizeUpdateToolParams(params) {
+  return {
+    ...params.id ? { id: params.id } : {},
+    ...params.subject ? { subject: params.subject } : {},
+    ...params.importance !== void 0 ? { importance: params.importance } : {},
+    ...params.expiry !== void 0 ? { expiry: params.expiry } : {},
+    ...params.claimKey !== void 0 ? { hasClaimKey: true } : {},
+    ...params.validFrom !== void 0 ? { hasValidFrom: true } : {},
+    ...params.validTo !== void 0 ? { hasValidTo: true } : {},
+    ...params.project !== void 0 ? { hasProject: true } : {}
+  };
+}
+function sanitizeFetchToolParams(params) {
+  return {
+    ...params.id ? { id: params.id } : {},
+    ...params.subject ? { subject: params.subject } : {}
+  };
+}
+
+// src/app/episode-ingest/single-transcript.ts
+function createSingleTranscriptDiscoveryPort(filePath) {
+  return {
+    async discoverFiles(_targetPath) {
+      return [filePath];
+    }
+  };
+}
+
+// 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: normalizeTags(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 normalizeTags(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/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/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/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 path from "path";
+
+// src/app/episode-ingest/activity-threshold.ts
+function resolveEpisodeActivityEligibility(materialTurns, startedAt, endedAt, threshold) {
+  const durationMs = resolveTranscriptDurationMs(startedAt, endedAt);
+  if (materialTurns >= threshold.minMaterialTurns || durationMs >= threshold.minDurationMs) {
+    return {
+      eligible: true,
+      materialTurns,
+      durationMs
+    };
+  }
+  return {
+    eligible: false,
+    reason: "below_activity_threshold",
+    materialTurns,
+    durationMs
+  };
+}
+function resolveTranscriptDurationMs(startedAt, endedAt) {
+  if (!startedAt || !endedAt) {
+    return 0;
+  }
+  const started = Date.parse(startedAt);
+  const ended = Date.parse(endedAt);
+  return Number.isFinite(started) && Number.isFinite(ended) && ended > started ? ended - started : 0;
+}
+
+// src/core/episode/transcript-render.ts
+var MIN_EPISODE_MESSAGES = 4;
+var MAX_EPISODE_TRANSCRIPT_CHARS = 14e3;
+function countMaterialTranscriptTurns(messages) {
+  return messages.filter((message) => message.text.trim().length > 0).length;
+}
+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/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 materialTurns = countMaterialTranscriptTurns(parsedTranscript.messages);
+  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.activityThreshold) {
+    const eligibility = resolveEpisodeActivityEligibility(
+      materialTurns,
+      parsedTranscript.metadata.startedAt,
+      parsedTranscript.metadata.endedAt,
+      options.activityThreshold
+    );
+    if (!eligibility.eligible) {
+      return {
+        kind: "skipped",
+        value: {
+          filePath,
+          reason: eligibility.reason,
+          sessionId: resolvedMeta.sessionId,
+          transcriptHash: parsedTranscript.metadata.transcriptHash,
+          messageCount: eligibility.materialTurns,
+          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 = path.resolve(filePath);
+  const parent = path.basename(path.dirname(resolved));
+  const grandparent = path.basename(path.dirname(path.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,
+    activityThreshold: options.activityThreshold
+  });
+  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,
+    {
+      source: options.source ?? DEFAULT_EPISODE_SOURCE,
+      genVersion: 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,
+          {
+            source: options.source ?? DEFAULT_EPISODE_SOURCE,
+            genVersion: 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, writeOptions, 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: writeOptions.source,
+        ...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: writeOptions.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)
+    };
+  }
+}
+var DEFAULT_EPISODE_SOURCE = "openclaw";
+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/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/db/dreaming-run-log.ts
+import { randomUUID } from "crypto";
+
+// src/core/dreaming/domain/proposal-review.ts
+function normalizeDreamProposalIssueIdentity(input) {
+  return {
+    groupId: input.groupId.trim(),
+    issueKind: input.issueKind.trim()
+  };
+}
+function buildDreamProposalReviewReason(proposal, reviewReason) {
+  return `Approved dreaming proposal ${proposal.id}: ${proposal.rationale} Review note: ${reviewReason}`.trim();
+}
+function resolveDreamProposalApplyTarget(proposal) {
+  if (!proposal.eligibleForApply) {
+    throw new Error(`Proposal ${proposal.id} is reviewable but not eligible for direct apply.`);
+  }
+  if (proposal.proposedClaimKeys.length !== 1) {
+    throw new Error(`Proposal ${proposal.id} cannot be applied automatically because it does not resolve to exactly one proposed claim key.`);
+  }
+  const targetClaimKey = proposal.proposedClaimKeys[0]?.trim();
+  if (!targetClaimKey) {
+    throw new Error(`Proposal ${proposal.id} is missing a valid proposed claim key.`);
+  }
+  return targetClaimKey;
+}
+
+// src/adapters/db/dreaming-run-read.ts
+async function getActiveProfileSnapshot(executor) {
+  const result = await executor.execute({
+    sql: `
+      SELECT
+        p.id,
+        p.durable_ids,
+        p.directive_ids,
+        p.as_of,
+        p.content_hash,
+        p.run_id,
+        p.created_at
+      FROM dream_state AS s
+      JOIN profile_snapshots AS p ON p.id = s.active_profile_snapshot_id
+      WHERE s.id = 'default'
+      LIMIT 1
+    `
+  });
+  const row = result.rows[0];
+  if (!row) {
+    return null;
+  }
+  return {
+    id: readRequiredString(row, "id"),
+    durableIds: parseJsonStringArray(readOptionalString(row, "durable_ids")),
+    directiveIds: parseJsonStringArray(readOptionalString(row, "directive_ids")),
+    asOf: readRequiredString(row, "as_of"),
+    contentHash: readRequiredString(row, "content_hash"),
+    runId: readOptionalString(row, "run_id") ?? null,
+    createdAt: readRequiredString(row, "created_at")
+  };
+}
+async function getDreamRunHistory(executor, limit = 10) {
+  const safeLimit = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 10;
+  const result = await executor.execute({
+    sql: `
+      SELECT
+        id,
+        tier,
+        project,
+        started_at,
+        completed_at,
+        status,
+        input_tokens,
+        output_tokens,
+        estimated_cost_usd,
+        model,
+        actions_taken,
+        actions_skipped,
+        durables_staled,
+        summary_json,
+        error,
+        dry_run,
+        config_json
+      FROM dream_runs
+      ORDER BY started_at DESC
+      LIMIT ?
+    `,
+    args: [safeLimit]
+  });
+  return result.rows.map((row) => mapRunRow(row));
+}
+async function getRecentAppliedLightRuns(executor, limit) {
+  const safeLimit = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 5;
+  const result = await executor.execute({
+    sql: `
+      SELECT
+        id,
+        tier,
+        project,
+        started_at,
+        completed_at,
+        status,
+        input_tokens,
+        output_tokens,
+        estimated_cost_usd,
+        model,
+        actions_taken,
+        actions_skipped,
+        durables_staled,
+        summary_json,
+        error,
+        dry_run,
+        config_json
+      FROM dream_runs
+      WHERE tier = 'light' AND dry_run = 0
+      ORDER BY started_at DESC
+      LIMIT ?
+    `,
+    args: [safeLimit]
+  });
+  return result.rows.map((row) => mapRunRow(row));
+}
+async function getLastDreamRun(executor) {
+  const [run] = await getDreamRunHistory(executor, 1);
+  return run ?? null;
+}
+async function getDreamRunActions(executor, runId) {
+  const result = await executor.execute({
+    sql: `
+      SELECT
+        id,
+        run_id,
+        action_type,
+        durable_ids,
+        reasoning,
+        details_json,
+        created_at
+      FROM dream_run_actions
+      WHERE run_id = ?
+      ORDER BY created_at ASC
+    `,
+    args: [runId.trim()]
+  });
+  return result.rows.map((row) => mapActionRow(row));
+}
+async function getDreamRunProposals(executor, runId) {
+  const result = await executor.execute({
+    sql: `
+      SELECT
+        id,
+        run_id,
+        group_id,
+        issue_kind,
+        scope,
+        durable_ids,
+        current_claim_keys,
+        proposed_claim_keys,
+        rationale,
+        confidence,
+        source,
+        eligible_for_apply,
+        review_status,
+        reviewed_at,
+        review_reason,
+        applied_action_count,
+        created_at
+      FROM dream_proposals
+      WHERE run_id = ?
+      ORDER BY created_at ASC
+    `,
+    args: [runId.trim()]
+  });
+  return result.rows.map((row) => mapProposalRow(row));
+}
+async function getDreamProposal(executor, proposalId) {
+  const result = await executor.execute({
+    sql: `
+      SELECT
+        id,
+        run_id,
+        group_id,
+        issue_kind,
+        scope,
+        durable_ids,
+        current_claim_keys,
+        proposed_claim_keys,
+        rationale,
+        confidence,
+        source,
+        eligible_for_apply,
+        review_status,
+        reviewed_at,
+        review_reason,
+        applied_action_count,
+        created_at
+      FROM dream_proposals
+      WHERE id = ?
+      LIMIT 1
+    `,
+    args: [proposalId.trim()]
+  });
+  const row = result.rows[0];
+  return row ? mapProposalRow(row) : null;
+}
+async function listDreamProposalBacklog(executor, query = {}) {
+  const clauses = [];
+  const args = [];
+  if (query.state && query.state !== "all") {
+    clauses.push("p.review_status = ?");
+    args.push(query.state);
+  }
+  if (query.issueKind) {
+    clauses.push("p.issue_kind = ?");
+    args.push(query.issueKind.trim());
+  }
+  if (query.eligibleOnly) {
+    clauses.push("p.eligible_for_apply = 1");
+  }
+  if (query.durableId) {
+    clauses.push("EXISTS (SELECT 1 FROM json_each(p.durable_ids) AS je WHERE je.value = ?)");
+    args.push(query.durableId.trim());
+  }
+  const limit = Number.isFinite(query.limit) && (query.limit ?? 0) > 0 ? Math.floor(query.limit) : 25;
+  const offset = Number.isFinite(query.offset) && (query.offset ?? 0) >= 0 ? Math.floor(query.offset) : 0;
+  const dedupeClause = "(p.review_status <> 'open' OR p.open_issue_rank = 1)";
+  const whereClause = [dedupeClause, ...clauses].join(" AND ");
+  const result = await executor.execute({
+    sql: `
+      WITH ranked_proposals AS (
+        SELECT
+          proposal.*,
+          CASE
+            WHEN proposal.review_status = 'open' THEN MIN(proposal.created_at) OVER (PARTITION BY proposal.group_id, proposal.issue_kind)
+            ELSE proposal.created_at
+          END AS logical_created_at,
+          CASE
+            WHEN proposal.review_status = 'open'
+              THEN ROW_NUMBER() OVER (PARTITION BY proposal.group_id, proposal.issue_kind ORDER BY proposal.created_at DESC, proposal.id DESC)
+            ELSE 1
+          END AS open_issue_rank
+        FROM dream_proposals AS proposal
+      )
+      SELECT
+        p.id,
+        p.run_id,
+        p.group_id,
+        p.issue_kind,
+        p.scope,
+        p.durable_ids,
+        p.current_claim_keys,
+        p.proposed_claim_keys,
+        p.rationale,
+        p.confidence,
+        p.source,
+        p.eligible_for_apply,
+        p.review_status,
+        p.reviewed_at,
+        p.review_reason,
+        p.applied_action_count,
+        p.logical_created_at AS created_at,
+        r.tier AS run_tier,
+        r.started_at AS run_started_at,
+        r.status AS run_status,
+        r.dry_run AS run_dry_run
+      FROM ranked_proposals AS p
+      JOIN dream_runs AS r ON r.id = p.run_id
+      WHERE ${whereClause}
+      ORDER BY
+        CASE WHEN p.review_status = 'open' THEN 0 ELSE 1 END ASC,
+        CASE WHEN p.review_status = 'open' THEN p.logical_created_at END ASC,
+        CASE WHEN p.review_status <> 'open' THEN p.reviewed_at END DESC,
+        p.logical_created_at DESC
+      LIMIT ?
+      OFFSET ?
+    `,
+    args: [...args, limit, offset]
+  });
+  return result.rows.map((row) => ({
+    proposal: mapProposalRow(row),
+    runPassType: parseStoredDreamTier(readOptionalString(row, "run_tier")),
+    runStartedAt: readRequiredString(row, "run_started_at"),
+    runStatus: parseStoredDreamRunStatus(readOptionalString(row, "run_status")),
+    runDryRun: readBoolean(row, "run_dry_run")
+  }));
+}
+
+// src/adapters/db/dreaming-run-log.ts
+async function logDreamAction(executor, action) {
+  const durableIds = normalizeDurableIds(action.durableIds);
+  await assertDurablesExist(executor, durableIds);
+  await executor.execute({
+    sql: `
+      INSERT INTO dream_run_actions (
+        id,
+        run_id,
+        action_type,
+        durable_id,
+        durable_ids,
+        reasoning,
+        details_json,
+        created_at
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `,
+    args: [
+      action.id.trim().length > 0 ? action.id.trim() : randomUUID(),
+      action.runId.trim(),
+      action.actionType,
+      durableIds[0] ?? null,
+      JSON.stringify(durableIds),
+      action.reasoning,
+      JSON.stringify(action.details ?? null),
+      normalizeTimestamp(action.createdAt) ?? (/* @__PURE__ */ new Date()).toISOString()
+    ]
+  });
+}
+async function logDreamProposal(executor, proposal) {
+  const reviewStatus = "reviewStatus" in proposal ? proposal.reviewStatus : "open";
+  const reviewedAt = "reviewedAt" in proposal ? proposal.reviewedAt : null;
+  const reviewReason = "reviewReason" in proposal ? proposal.reviewReason : null;
+  const appliedActionCount = "appliedActionCount" in proposal ? proposal.appliedActionCount : 0;
+  const logicalIssue = normalizeDreamProposalIssueIdentity({
+    groupId: proposal.groupId,
+    issueKind: proposal.issueKind
+  });
+  if (reviewStatus === "open") {
+    const existingOpenProposal = await findOpenProposalIssue(executor, {
+      groupId: logicalIssue.groupId,
+      issueKind: logicalIssue.issueKind
+    });
+    if (existingOpenProposal) {
+      await executor.execute({
+        sql: `
+          UPDATE dream_proposals
+          SET run_id = ?,
+              scope = ?,
+              durable_ids = ?,
+              current_claim_keys = ?,
+              proposed_claim_keys = ?,
+              rationale = ?,
+              confidence = ?,
+              source = ?,
+              eligible_for_apply = ?,
+              review_status = 'open',
+              reviewed_at = NULL,
+              review_reason = NULL,
+              applied_action_count = 0
+          WHERE id = ?
+        `,
+        args: [
+          proposal.runId.trim(),
+          proposal.scope,
+          JSON.stringify(normalizeDurableIds(proposal.durableIds)),
+          JSON.stringify(normalizeStringArray(proposal.currentClaimKeys)),
+          JSON.stringify(normalizeStringArray(proposal.proposedClaimKeys)),
+          proposal.rationale,
+          normalizeNumber(proposal.confidence),
+          proposal.source.trim(),
+          proposal.eligibleForApply ? 1 : 0,
+          existingOpenProposal.id
+        ]
+      });
+      return;
+    }
+  }
+  await executor.execute({
+    sql: `
+      INSERT INTO dream_proposals (
+        id,
+        run_id,
+        group_id,
+        issue_kind,
+        scope,
+        durable_ids,
+        current_claim_keys,
+        proposed_claim_keys,
+        rationale,
+        confidence,
+        source,
+        eligible_for_apply,
+        review_status,
+        reviewed_at,
+        review_reason,
+        applied_action_count,
+        created_at
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `,
+    args: [
+      proposal.id.trim().length > 0 ? proposal.id.trim() : randomUUID(),
+      proposal.runId.trim(),
+      logicalIssue.groupId,
+      logicalIssue.issueKind,
+      proposal.scope,
+      JSON.stringify(normalizeDurableIds(proposal.durableIds)),
+      JSON.stringify(normalizeStringArray(proposal.currentClaimKeys)),
+      JSON.stringify(normalizeStringArray(proposal.proposedClaimKeys)),
+      proposal.rationale,
+      normalizeNumber(proposal.confidence),
+      proposal.source.trim(),
+      proposal.eligibleForApply ? 1 : 0,
+      reviewStatus,
+      normalizeTimestamp(reviewedAt ?? void 0),
+      normalizeOptionalString(reviewReason ?? void 0),
+      normalizeInteger(appliedActionCount ?? 0),
+      normalizeTimestamp(proposal.createdAt) ?? (/* @__PURE__ */ new Date()).toISOString()
+    ]
+  });
+}
+async function assertDurablesExist(executor, durableIds) {
+  if (durableIds.length === 0) {
+    return;
+  }
+  const result = await executor.execute({
+    sql: `SELECT id FROM durables WHERE id IN (${durableIds.map(() => "?").join(", ")})`,
+    args: durableIds
+  });
+  const existingIds = new Set(result.rows.map((row) => String(row.id ?? "")));
+  const missingDurableIds = durableIds.filter((durableId) => !existingIds.has(durableId));
+  if (missingDurableIds.length > 0) {
+    throw new Error(`Cannot persist dreaming action for unknown durable${missingDurableIds.length === 1 ? "" : "s"}: ${missingDurableIds.join(", ")}.`);
+  }
+}
+async function findOpenProposalIssue(executor, input) {
+  const result = await executor.execute({
+    sql: `
+      SELECT id
+      FROM dream_proposals
+      WHERE group_id = ?
+        AND issue_kind = ?
+        AND review_status = 'open'
+      ORDER BY created_at DESC, id DESC
+      LIMIT 1
+    `,
+    args: [input.groupId, input.issueKind]
+  });
+  const row = result.rows[0];
+  return row ? { id: readRequiredString(row, "id") } : null;
+}
+
+// src/adapters/db/dreaming-run-lock.ts
+var DREAMING_RUN_LOCK_STALE_MS = 60 * 60 * 1e3;
+async function tryAcquireDreamStateRunLock(executor, holderToken, now) {
+  const nowIso = now.toISOString();
+  const staleBefore = new Date(now.getTime() - DREAMING_RUN_LOCK_STALE_MS).toISOString();
+  await executor.execute("BEGIN IMMEDIATE");
+  try {
+    const result = await executor.execute({
+      sql: `
+        UPDATE dream_state
+        SET run_lock_holder = ?, run_lock_heartbeat_at = ?, updated_at = ?
+        WHERE id = 'default'
+          AND (
+            run_lock_holder IS NULL
+            OR run_lock_holder = ''
+            OR COALESCE(run_lock_heartbeat_at, updated_at) < ?
+          )
+      `,
+      args: [holderToken, nowIso, nowIso, staleBefore]
+    });
+    await executor.execute("COMMIT");
+    return result.rowsAffected > 0;
+  } catch (error) {
+    await executor.execute("ROLLBACK").catch(() => void 0);
+    throw error;
+  }
+}
+async function heartbeatDreamStateRunLock(executor, holderToken, now) {
+  const nowIso = now.toISOString();
+  const result = await executor.execute({
+    sql: `
+      UPDATE dream_state
+      SET run_lock_heartbeat_at = ?, updated_at = ?
+      WHERE id = 'default' AND run_lock_holder = ?
+    `,
+    args: [nowIso, nowIso, holderToken]
+  });
+  return result.rowsAffected > 0;
+}
+async function releaseDreamStateRunLock(executor, holderToken, now) {
+  await executor.execute("BEGIN IMMEDIATE");
+  try {
+    await executor.execute({
+      sql: `
+        UPDATE dream_state
+        SET run_lock_holder = NULL, run_lock_heartbeat_at = NULL, updated_at = ?
+        WHERE id = 'default' AND run_lock_holder = ?
+      `,
+      args: [now.toISOString(), holderToken]
+    });
+    await executor.execute("COMMIT");
+  } catch (error) {
+    await executor.execute("ROLLBACK").catch(() => void 0);
+    throw error;
+  }
+}
+
+// src/adapters/db/dreaming-queries.ts
+var DAY_MS = 24 * 60 * 60 * 1e3;
+async function getDreamHealthStats(executor, now = /* @__PURE__ */ new Date()) {
+  const last7Cutoff = new Date(now.getTime() - 7 * DAY_MS).toISOString();
+  const last30Cutoff = new Date(now.getTime() - 30 * DAY_MS).toISOString();
+  const last90Cutoff = new Date(now.getTime() - 90 * DAY_MS).toISOString();
+  const [totalResult, byTypeResult, lifecycleResult, proposalBacklogResult, recencyResult, recallResult, qualityResult] = await Promise.all([
+    executor.execute({
+      sql: `
+        SELECT COUNT(*) AS total
+        FROM durables AS e
+        WHERE ${buildActiveDurableClause("e")}
+      `
+    }),
+    executor.execute({
+      sql: `
+        SELECT e.type, COUNT(*) AS durable_count
+        FROM durables AS e
+        WHERE ${buildActiveDurableClause("e")}
+        GROUP BY e.type
+      `
+    }),
+    executor.execute({
+      sql: `
+        SELECT
+          COALESCE(SUM(CASE WHEN e.claim_key_status = 'trusted' THEN 1 ELSE 0 END), 0) AS trusted_count,
+          COALESCE(SUM(CASE WHEN e.claim_key_status = 'tentative' THEN 1 ELSE 0 END), 0) AS tentative_count,
+          COALESCE(SUM(CASE WHEN e.claim_key_status = 'unresolved' THEN 1 ELSE 0 END), 0) AS unresolved_count,
+          COALESCE(SUM(CASE WHEN e.claim_key IS NULL OR TRIM(e.claim_key) = '' THEN 1 ELSE 0 END), 0) AS no_key_count
+        FROM durables AS e
+        WHERE ${buildActiveDurableClause("e")}
+      `
+    }),
+    executor.execute({
+      sql: `
+        SELECT
+          COALESCE(COUNT(*), 0) AS proposal_backlog_count,
+          COALESCE(SUM(CASE WHEN eligible_for_apply = 1 THEN 1 ELSE 0 END), 0) AS eligible_proposal_backlog_count,
+          MIN(created_at) AS oldest_open_proposal_created_at
+        FROM (
+          SELECT
+            group_id,
+            issue_kind,
+            MIN(created_at) AS created_at,
+            MAX(eligible_for_apply) AS eligible_for_apply
+          FROM dream_proposals
+          WHERE review_status = 'open'
+          GROUP BY group_id, issue_kind
+        ) AS open_issue_backlog
+      `
+    }),
+    executor.execute({
+      sql: `
+        SELECT
+          COALESCE(SUM(CASE WHEN e.created_at >= ? THEN 1 ELSE 0 END), 0) AS last7,
+          COALESCE(SUM(CASE WHEN e.created_at < ? AND e.created_at >= ? THEN 1 ELSE 0 END), 0) AS last30,
+          COALESCE(SUM(CASE WHEN e.created_at < ? AND e.created_at >= ? THEN 1 ELSE 0 END), 0) AS d30_to_90,
+          COALESCE(SUM(CASE WHEN e.created_at < ? THEN 1 ELSE 0 END), 0) AS d90_plus
+        FROM durables AS e
+        WHERE ${buildActiveDurableClause("e")}
+      `,
+      args: [last7Cutoff, last7Cutoff, last30Cutoff, last30Cutoff, last90Cutoff, last90Cutoff]
+    }),
+    executor.execute({
+      sql: `
+        SELECT
+          COALESCE(SUM(CASE WHEN COALESCE(e.recall_count, 0) = 0 THEN 1 ELSE 0 END), 0) AS never_count,
+          COALESCE(SUM(CASE WHEN COALESCE(e.recall_count, 0) BETWEEN 1 AND 5 THEN 1 ELSE 0 END), 0) AS one_to_five_count,
+          COALESCE(SUM(CASE WHEN COALESCE(e.recall_count, 0) > 5 THEN 1 ELSE 0 END), 0) AS five_plus_count
+        FROM durables AS e
+        WHERE ${buildActiveDurableClause("e")}
+      `
+    }),
+    executor.execute({
+      sql: `
+        SELECT
+          COALESCE(SUM(CASE WHEN COALESCE(e.quality_score, 0.5) >= 0.7 THEN 1 ELSE 0 END), 0) AS high_count,
+          COALESCE(SUM(CASE WHEN COALESCE(e.quality_score, 0.5) >= 0.4 AND COALESCE(e.quality_score, 0.5) < 0.7 THEN 1 ELSE 0 END), 0) AS medium_count,
+          COALESCE(SUM(CASE WHEN COALESCE(e.quality_score, 0.5) < 0.4 THEN 1 ELSE 0 END), 0) AS low_count,
+          COALESCE(AVG(COALESCE(e.quality_score, 0.5)), 0) AS average_score
+        FROM durables AS e
+        WHERE ${buildActiveDurableClause("e")}
+      `
+    })
+  ]);
+  const totalRow = totalResult.rows[0];
+  const lifecycleRow = lifecycleResult.rows[0];
+  const proposalBacklogRow = proposalBacklogResult.rows[0];
+  const recencyRow = recencyResult.rows[0];
+  const recallRow = recallResult.rows[0];
+  const qualityRow = qualityResult.rows[0];
+  const byType = {};
+  for (const row of byTypeResult.rows) {
+    byType[readRequiredString(row, "type")] = readNumber(row, "durable_count", 0);
+  }
+  return {
+    total: totalRow ? readNumber(totalRow, "total", 0) : 0,
+    byType,
+    claimKeyLifecycle: {
+      trusted: lifecycleRow ? readNumber(lifecycleRow, "trusted_count", 0) : 0,
+      tentative: lifecycleRow ? readNumber(lifecycleRow, "tentative_count", 0) : 0,
+      unresolved: lifecycleRow ? readNumber(lifecycleRow, "unresolved_count", 0) : 0,
+      noKey: lifecycleRow ? readNumber(lifecycleRow, "no_key_count", 0) : 0
+    },
+    proposalBacklogCount: proposalBacklogRow ? readNumber(proposalBacklogRow, "proposal_backlog_count", 0) : 0,
+    eligibleProposalBacklogCount: proposalBacklogRow ? readNumber(proposalBacklogRow, "eligible_proposal_backlog_count", 0) : 0,
+    oldestOpenProposalCreatedAt: proposalBacklogRow ? readOptionalString(proposalBacklogRow, "oldest_open_proposal_created_at") ?? null : null,
+    recency: {
+      last7: recencyRow ? readNumber(recencyRow, "last7", 0) : 0,
+      last30: recencyRow ? readNumber(recencyRow, "last30", 0) : 0,
+      d30To90: recencyRow ? readNumber(recencyRow, "d30_to_90", 0) : 0,
+      d90Plus: recencyRow ? readNumber(recencyRow, "d90_plus", 0) : 0
+    },
+    recall: {
+      never: recallRow ? readNumber(recallRow, "never_count", 0) : 0,
+      oneToFive: recallRow ? readNumber(recallRow, "one_to_five_count", 0) : 0,
+      fivePlus: recallRow ? readNumber(recallRow, "five_plus_count", 0) : 0
+    },
+    quality: {
+      high: qualityRow ? readNumber(qualityRow, "high_count", 0) : 0,
+      medium: qualityRow ? readNumber(qualityRow, "medium_count", 0) : 0,
+      low: qualityRow ? readNumber(qualityRow, "low_count", 0) : 0,
+      average: qualityRow ? readNumber(qualityRow, "average_score", 0) : 0
+    }
+  };
+}
+async function listReconcileDurables(executor, query) {
+  const whereClauses = [query.includeInactive === true ? "1 = 1" : buildActiveDurableClause("e")];
+  const args = [];
+  const project = normalizeOptionalString2(query.project);
+  if (project) {
+    whereClauses.push(`(e.project = ? OR ${buildTagContainsClause("e")})`);
+    args.push(project, project);
+  }
+  const type = normalizeOptionalString2(query.type);
+  if (type) {
+    whereClauses.push("e.type = ?");
+    args.push(type);
+  }
+  const claimKeyPrefix = normalizeOptionalString2(query.claimKeyPrefix);
+  if (claimKeyPrefix) {
+    whereClauses.push("e.claim_key LIKE ?");
+    args.push(`${claimKeyPrefix}/%`);
+  }
+  const normalizedDurableIds = normalizeStringArray3(query.durableIds ?? []);
+  if (normalizedDurableIds.length > 0) {
+    const placeholders = normalizedDurableIds.map(() => "?").join(", ");
+    whereClauses.push(`e.id IN (${placeholders})`);
+    args.push(...normalizedDurableIds);
+  }
+  const result = await executor.execute({
+    sql: `
+      SELECT
+        ${DURABLE_SELECT_COLUMNS}
+      FROM durables AS e
+      WHERE ${whereClauses.join("\n        AND ")}
+      ORDER BY
+        CASE WHEN ${buildActiveDurableClause("e")} THEN 0 ELSE 1 END ASC,
+        COALESCE(e.claim_key, '') ASC,
+        e.created_at ASC,
+        e.id ASC
+    `,
+    args
+  });
+  return result.rows.map((row) => mapDurableRow(row));
+}
+async function listEpisodeEvidenceSince(executor, since, options = {}) {
+  const args = [since];
+  let projectClause = "";
+  const project = options.project?.trim();
+  if (project) {
+    projectClause = " AND project = ?";
+    args.push(project);
+  }
+  const limit = Number.isFinite(options.limit) && (options.limit ?? 0) > 0 ? Math.floor(options.limit) : 50;
+  args.push(limit);
+  const result = await executor.execute({
+    sql: `
+      SELECT
+        id,
+        summary,
+        started_at,
+        ended_at,
+        source_id,
+        project
+      FROM episodes
+      WHERE created_at >= ?
+        AND ${buildActiveEpisodeClause()}
+        ${projectClause}
+      ORDER BY started_at ASC, id ASC
+      LIMIT ?
+    `,
+    args
+  });
+  return result.rows.map((row) => ({
+    id: readRequiredString(row, "id"),
+    summary: readRequiredString(row, "summary"),
+    startedAt: readRequiredString(row, "started_at"),
+    endedAt: readOptionalString(row, "ended_at") ?? null,
+    sessionId: readOptionalString(row, "source_id") ?? null,
+    project: readOptionalString(row, "project") ?? null
+  }));
+}
+var HOST_STORE_SOURCE_CLAUSE = `(source_file LIKE 'skeln-session:%' OR source_file LIKE 'openclaw-session:%')`;
+async function listSessionHostStoreDurables(executor, sessionId, startedAt, endedAt) {
+  const normalizedSessionId = sessionId.trim();
+  if (normalizedSessionId.length === 0) {
+    return [];
+  }
+  const result = await executor.execute({
+    sql: `
+      SELECT ${DURABLE_SELECT_COLUMNS}
+      FROM durables
+      WHERE created_at >= ?
+        AND created_at <= ?
+        AND ${HOST_STORE_SOURCE_CLAUSE}
+        AND source_file LIKE ?
+        AND ${buildActiveDurableClause()}
+      ORDER BY created_at ASC, id ASC
+    `,
+    args: [startedAt, endedAt, `%${normalizedSessionId}%`]
+  });
+  return result.rows.map((row) => mapDurableRow(row));
+}
+async function countEpisodesSince(executor, since, project) {
+  const args = [since];
+  let projectClause = "";
+  if (project?.trim()) {
+    projectClause = " AND project = ?";
+    args.push(project.trim());
+  }
+  const result = await executor.execute({
+    sql: `
+      SELECT COUNT(*) AS total
+      FROM episodes
+      WHERE created_at >= ?
+        AND ${buildActiveEpisodeClause()}
+        ${projectClause}
+    `,
+    args
+  });
+  const row = result.rows[0];
+  return row ? readNumber(row, "total", 0) : 0;
+}
+async function countIngestFilesSince(executor, since) {
+  const result = await executor.execute({
+    sql: `
+      SELECT COUNT(*) AS total
+      FROM ingest_log
+      WHERE ingested_at >= ?
+    `,
+    args: [since]
+  });
+  const row = result.rows[0];
+  return row ? readNumber(row, "total", 0) : 0;
+}
+async function countDurablesCreatedSince(executor, since, project) {
+  const args = [since];
+  let projectClause = "";
+  if (project?.trim()) {
+    projectClause = " AND project = ?";
+    args.push(project.trim());
+  }
+  const result = await executor.execute({
+    sql: `
+      SELECT COUNT(*) AS total
+      FROM durables
+      WHERE created_at >= ?
+        ${projectClause}
+    `,
+    args
+  });
+  const row = result.rows[0];
+  return row ? readNumber(row, "total", 0) : 0;
+}
+async function sumDurableImportanceCreatedSince(executor, since, project) {
+  const args = [since];
+  let projectClause = "";
+  if (project?.trim()) {
+    projectClause = " AND project = ?";
+    args.push(project.trim());
+  }
+  const result = await executor.execute({
+    sql: `
+      SELECT COALESCE(SUM(COALESCE(importance, 0)), 0) AS total
+      FROM durables
+      WHERE created_at >= ?
+        AND ${buildActiveDurableClause("durables")}
+        ${projectClause}
+    `,
+    args
+  });
+  const row = result.rows[0];
+  return row ? readNumber(row, "total", 0) : 0;
+}
+function buildTagContainsClause(alias) {
+  return `EXISTS (
+    SELECT 1
+    FROM json_each(
+      CASE
+        WHEN json_valid(COALESCE(${alias}.tags, '[]')) THEN COALESCE(${alias}.tags, '[]')
+        ELSE '[]'
+      END
+    )
+    WHERE json_each.value = ?
+  )`;
+}
+function normalizeOptionalString2(value) {
+  const trimmed = value?.trim();
+  return trimmed && trimmed.length > 0 ? trimmed : null;
+}
+function normalizeStringArray3(values) {
+  return [...new Set(values.map((value) => value.trim()).filter((value) => value.length > 0))].sort();
+}
+
+// src/adapters/db/dreaming-port.ts
+function createDreamPort(executor) {
+  return {
+    getDailyCost: async (now) => getDailyDreamCost(executor, now),
+    createRun: async (run) => createDreamRun(executor, run),
+    completeRun: async (runId, result) => completeDreamRun(executor, runId, result),
+    logRunAction: async (action) => logDreamAction(executor, action),
+    logRunProposal: async (proposal) => logDreamProposal(executor, proposal),
+    getLastRun: async () => getLastDreamRun(executor),
+    getRunHistory: async (limit) => getDreamRunHistory(executor, limit),
+    getRecentAppliedLightRuns: async (limit) => getRecentAppliedLightRuns(executor, limit),
+    getRunActions: async (runId) => getDreamRunActions(executor, runId),
+    getRunProposals: async (runId) => getDreamRunProposals(executor, runId),
+    getProposal: async (proposalId) => getDreamProposal(executor, proposalId),
+    reviewProposal: async (input) => reviewDreamProposal(executor, input),
+    listProposalBacklog: async (query) => listDreamProposalBacklog(executor, query),
+    getHealthStats: async (now) => getDreamHealthStats(executor, now),
+    getActiveProfileSnapshot: async () => getActiveProfileSnapshot(executor),
+    listReconcileDurables: async (query) => listReconcileDurables(executor, query),
+    listEpisodeEvidenceSince: async (since, options) => listEpisodeEvidenceSince(executor, since, options),
+    listSessionHostStoreDurables: async (sessionId, startedAt, endedAt) => listSessionHostStoreDurables(executor, sessionId, startedAt, endedAt),
+    findActiveDurablesByClaimKey: async (claimKey) => findActiveDurablesByClaimKey(executor, claimKey),
+    findExistingNormContentHashes: async (hashes) => findExistingNormHashes(executor, hashes),
+    insertDurable: async (durable, embedding, contentHash) => insertDurable(executor, durable, embedding, contentHash),
+    supersedeDurable: async (oldDurableId, newDurableId, kind, reason) => supersedeDurable(executor, oldDurableId, newDurableId, kind, reason),
+    getDurable: async (durableId) => getDurable(executor, durableId),
+    getDurables: async (durableIds) => getDurables(executor, durableIds),
+    closeDurableValidity: async (durableId, reason) => closeDurableValidity(executor, durableId, reason),
+    updateDurable: async (durableId, fields, options) => updateDurable(executor, durableId, fields, options),
+    countEpisodesSince: async (since, project) => countEpisodesSince(executor, since, project),
+    countIngestFilesSince: async (since) => countIngestFilesSince(executor, since),
+    countDurablesCreatedSince: async (since, project) => countDurablesCreatedSince(executor, since, project),
+    sumDurableImportanceCreatedSince: async (since, project) => sumDurableImportanceCreatedSince(executor, since, project),
+    updateDreamState: async (input) => updateDreamState(executor, input),
+    createProfileSnapshot: async (snapshot) => createProfileSnapshot(executor, snapshot),
+    tryAcquireRunLock: async (holderToken) => tryAcquireDreamStateRunLock(executor, holderToken, /* @__PURE__ */ new Date()),
+    heartbeatRunLock: async (holderToken) => heartbeatDreamStateRunLock(executor, holderToken, /* @__PURE__ */ new Date()),
+    releaseRunLock: async (holderToken) => releaseDreamStateRunLock(executor, holderToken, /* @__PURE__ */ new Date()),
+    withTransaction: async (fn) => runInDreamTransaction(executor, fn)
+  };
+}
+async function runInDreamTransaction(executor, fn) {
+  return runImmediateTransaction(executor, () => fn(createDreamPort(executor)));
+}
+
+// src/app/memory/trace-timeline.ts
+var UPDATED_EVENT_MIN_DELTA_MS = 1e3;
+function buildEntryTraceProvenance(entry) {
+  return {
+    ...entry.source_file ? { sourceFile: entry.source_file } : {},
+    ...entry.source_context ? { sourceContext: entry.source_context } : {},
+    ...entry.claim_key_source ? { claimKeySource: entry.claim_key_source } : {},
+    ...entry.claim_support_locator ? { claimSupportLocator: entry.claim_support_locator } : {},
+    ...entry.claim_support_observed_at ? { claimSupportObservedAt: entry.claim_support_observed_at } : {},
+    ...entry.project ? { project: entry.project } : {},
+    ...entry.user_id ? { userId: entry.user_id } : {}
+  };
+}
+function buildEntryTraceTimeline(input) {
+  const events = [
+    {
+      at: input.entry.created_at,
+      kind: "created",
+      label: "Durable created",
+      detail: formatProvenanceDetail(input.entry)
+    }
+  ];
+  const createdMs = Date.parse(input.entry.created_at);
+  const updatedMs = Date.parse(input.entry.updated_at);
+  if (Number.isFinite(createdMs) && Number.isFinite(updatedMs) && updatedMs - createdMs >= UPDATED_EVENT_MIN_DELTA_MS) {
+    events.push({
+      at: input.entry.updated_at,
+      kind: "updated",
+      label: "Durable updated",
+      detail: formatUpdateDetail(input.entry)
+    });
+  }
+  for (const action of input.dreamActions) {
+    events.push({
+      at: action.createdAt,
+      kind: "dream",
+      label: `Dream ${action.actionType}`,
+      detail: action.reasoning,
+      runId: action.runId,
+      actionType: action.actionType
+    });
+  }
+  for (const snapshot of input.profileSnapshots) {
+    events.push({
+      at: snapshot.createdAt,
+      kind: "profile",
+      label: snapshot.role === "directive" ? "Included in directive profile snapshot" : "Included in profile snapshot",
+      detail: `snapshot=${snapshot.id}`,
+      runId: snapshot.runId ?? void 0
+    });
+  }
+  for (const recall of input.recallEvents) {
+    events.push({
+      at: recall.recalledAt,
+      kind: "recall",
+      label: "Recalled",
+      detail: formatRecallDetail(recall)
+    });
+  }
+  return events.sort(compareTimelineEvents);
+}
+function formatProvenanceDetail(entry) {
+  const parts = [];
+  if (entry.source_file) {
+    parts.push(`source=${entry.source_file}`);
+  }
+  if (entry.claim_key_source) {
+    parts.push(`claim_key_source=${entry.claim_key_source}`);
+  }
+  if (entry.claim_key) {
+    parts.push(`claim_key=${entry.claim_key}`);
+  }
+  return parts.length > 0 ? parts.join(" | ") : void 0;
+}
+function formatUpdateDetail(entry) {
+  const parts = [];
+  if (entry.supersession_kind) {
+    parts.push(`supersession_kind=${entry.supersession_kind}`);
+  }
+  if (entry.supersession_reason) {
+    parts.push(`reason=${entry.supersession_reason}`);
+  }
+  if (entry.valid_to) {
+    parts.push(`valid_to=${entry.valid_to}`);
+  }
+  if (entry.claim_key) {
+    parts.push(`claim_key=${entry.claim_key}`);
+  }
+  return parts.length > 0 ? parts.join(" | ") : void 0;
+}
+function formatRecallDetail(recall) {
+  const parts = [];
+  if (recall.query) {
+    parts.push(`query=${recall.query}`);
+  }
+  if (recall.sessionKey) {
+    parts.push(`session=${recall.sessionKey}`);
+  }
+  return parts.length > 0 ? parts.join(" | ") : void 0;
+}
+function compareTimelineEvents(left, right) {
+  const leftMs = Date.parse(left.at);
+  const rightMs = Date.parse(right.at);
+  if (Number.isFinite(leftMs) && Number.isFinite(rightMs) && leftMs !== rightMs) {
+    return leftMs - rightMs;
+  }
+  const kindDelta = timelineKindRank(left.kind) - timelineKindRank(right.kind);
+  if (kindDelta !== 0) {
+    return kindDelta;
+  }
+  return left.label.localeCompare(right.label);
+}
+function timelineKindRank(kind) {
+  switch (kind) {
+    case "created":
+      return 0;
+    case "updated":
+      return 1;
+    case "dream":
+      return 2;
+    case "profile":
+      return 3;
+    case "recall":
+      return 4;
+  }
+}
+
+// src/adapters/db/trace-queries.ts
+var TRACE_RECALL_EVENT_LIMIT = 25;
+var TRACE_DREAM_ACTION_LIMIT = 50;
+var TRACE_PROFILE_SNAPSHOT_LIMIT = 10;
+async function countRecallEventsForDurable(executor, entryId) {
+  const normalizedId = entryId.trim();
+  if (normalizedId.length === 0) {
+    return 0;
+  }
+  const result = await executor.execute({
+    sql: `
+      SELECT COUNT(*) AS total
+      FROM recall_events
+      WHERE durable_id = ?
+    `,
+    args: [normalizedId]
+  });
+  return readNumber(result.rows[0] ?? {}, "total", 0);
+}
+async function listRecallEventsForDurable(executor, entryId, limit = TRACE_RECALL_EVENT_LIMIT) {
+  const normalizedId = entryId.trim();
+  if (normalizedId.length === 0) {
+    return [];
+  }
+  const safeLimit = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : TRACE_RECALL_EVENT_LIMIT;
+  const result = await executor.execute({
+    sql: `
+      SELECT
+        query,
+        session_key,
+        recalled_at
+      FROM recall_events
+      WHERE durable_id = ?
+      ORDER BY recalled_at DESC
+      LIMIT ?
+    `,
+    args: [normalizedId, safeLimit]
+  });
+  return result.rows.map((row) => ({
+    query: readOptionalString(row, "query"),
+    sessionKey: readOptionalString(row, "session_key"),
+    recalledAt: readRequiredString(row, "recalled_at")
+  }));
+}
+async function listDreamActionsForDurable(executor, entryId, limit = TRACE_DREAM_ACTION_LIMIT) {
+  const normalizedId = entryId.trim();
+  if (normalizedId.length === 0) {
+    return [];
+  }
+  const safeLimit = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : TRACE_DREAM_ACTION_LIMIT;
+  const result = await executor.execute({
+    sql: `
+      SELECT
+        id,
+        run_id,
+        action_type,
+        durable_ids,
+        reasoning,
+        details_json,
+        created_at
+      FROM dream_run_actions
+      WHERE durable_id = ?
+         OR EXISTS (
+           SELECT 1
+           FROM json_each(dream_run_actions.durable_ids) AS ids
+           WHERE ids.value = ?
+         )
+      ORDER BY created_at ASC, id ASC
+      LIMIT ?
+    `,
+    args: [normalizedId, normalizedId, safeLimit]
+  });
+  return result.rows.map((row) => {
+    const action = mapActionRow(row);
+    return {
+      id: action.id,
+      runId: action.runId,
+      actionType: action.actionType,
+      reasoning: action.reasoning,
+      details: action.details ?? null,
+      createdAt: action.createdAt
+    };
+  });
+}
+async function listProfileSnapshotsForDurable(executor, entryId, limit = TRACE_PROFILE_SNAPSHOT_LIMIT) {
+  const normalizedId = entryId.trim();
+  if (normalizedId.length === 0) {
+    return [];
+  }
+  const safeLimit = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : TRACE_PROFILE_SNAPSHOT_LIMIT;
+  const result = await executor.execute({
+    sql: `
+      SELECT
+        id,
+        durable_ids,
+        directive_ids,
+        as_of,
+        run_id,
+        created_at
+      FROM profile_snapshots
+      WHERE EXISTS (
+        SELECT 1
+        FROM json_each(profile_snapshots.durable_ids) AS profile_ids
+        WHERE profile_ids.value = ?
+      )
+      OR EXISTS (
+        SELECT 1
+        FROM json_each(COALESCE(profile_snapshots.directive_ids, '[]')) AS directive_ids
+        WHERE directive_ids.value = ?
+      )
+      ORDER BY created_at DESC, id DESC
+      LIMIT ?
+    `,
+    args: [normalizedId, normalizedId, safeLimit]
+  });
+  return result.rows.map((row) => {
+    const durableIds = parseJsonStringArray2(readOptionalString(row, "durable_ids"));
+    const role = durableIds.includes(normalizedId) ? "profile" : "directive";
+    return {
+      id: readRequiredString(row, "id"),
+      asOf: readRequiredString(row, "as_of"),
+      runId: readOptionalString(row, "run_id") ?? null,
+      createdAt: readRequiredString(row, "created_at"),
+      role
+    };
+  });
+}
+function parseJsonStringArray2(raw) {
+  if (!raw || raw.trim().length === 0) {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) {
+      return [];
+    }
+    return parsed.filter((value) => typeof value === "string");
+  } catch {
+    return [];
+  }
+}
+
+// src/adapters/db/memory-repository.ts
+var ZERO_VECTOR = JSON.stringify(Array.from({ length: EMBEDDING_DIMENSIONS }, () => 0));
+function createMemoryRepository(executor, options = {}) {
+  return {
+    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 findEntryBySubject(executor, subject) {
+  const normalizedSubject = subject.trim();
+  if (normalizedSubject.length === 0) {
+    return null;
+  }
+  const result = await executor.execute({
+    sql: `
+      SELECT
+        ${DURABLE_SELECT_COLUMNS},
+        CASE
+          WHEN lower(subject) = lower(?) THEN 0
+          WHEN lower(subject) LIKE lower(?) THEN 1
+          ELSE 2
+        END AS match_rank
+      FROM durables
+      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 ? mapDurableRow(row) : null;
+}
+async function findMostRecentEntry(executor) {
+  const result = await executor.execute({
+    sql: `
+      SELECT
+        ${DURABLE_SELECT_COLUMNS}
+      FROM durables
+      ORDER BY created_at DESC
+      LIMIT 1
+    `
+  });
+  const row = result.rows[0];
+  return row ? mapDurableRow(row) : null;
+}
+async function getEntryTrace(executor, entryId, claimSlotPolicyConfig) {
+  const entry = await getDurableByIdIncludingInactive(executor, entryId);
+  if (!entry) {
+    return null;
+  }
+  const [supersededBy, supersedes, claimFamily, recallTotalCount, recallEvents, dreamActions, profileSnapshots] = await Promise.all([
+    entry.superseded_by ? getDurableByIdIncludingInactive(executor, entry.superseded_by) : Promise.resolve(null),
+    listSupersededEntries(executor, entry.id),
+    entry.claim_key ? getClaimFamily(executor, entry.claim_key, claimSlotPolicyConfig) : Promise.resolve(void 0),
+    countRecallEventsForDurable(executor, entry.id),
+    listRecallEventsForDurable(executor, entry.id),
+    listDreamActionsForDurable(executor, entry.id),
+    listProfileSnapshotsForDurable(executor, entry.id)
+  ]);
+  const recall = {
+    totalCount: recallTotalCount,
+    recentEvents: recallEvents
+  };
+  return {
+    entry,
+    ...supersededBy ? { supersededBy } : {},
+    supersedes,
+    ...claimFamily ? { claimFamily } : {},
+    recall,
+    provenance: buildEntryTraceProvenance(entry),
+    dreamActions,
+    profileSnapshots,
+    timeline: buildEntryTraceTimeline({
+      entry,
+      dreamActions,
+      recallEvents,
+      profileSnapshots
+    })
+  };
+}
+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 durables
+      WHERE ${buildActiveDurableClause()}
+    `
+  });
+  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('${DURABLE_VECTOR_INDEX_NAME}', vector32(?), ?) AS matches
+      `,
+      args: [ZERO_VECTOR, 1]
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getDurableByIdIncludingInactive(executor, entryId) {
+  const normalizedId = entryId.trim();
+  if (normalizedId.length === 0) {
+    return null;
+  }
+  const result = await executor.execute({
+    sql: `
+      SELECT
+        ${DURABLE_SELECT_COLUMNS}
+      FROM durables
+      WHERE id = ?
+      LIMIT 1
+    `,
+    args: [normalizedId]
+  });
+  const row = result.rows[0];
+  return row ? mapDurableRow(row) : null;
+}
+async function listSupersededEntries(executor, entryId) {
+  const result = await executor.execute({
+    sql: `
+      SELECT
+        ${DURABLE_SELECT_COLUMNS}
+      FROM durables
+      WHERE superseded_by = ?
+      ORDER BY created_at DESC
+    `,
+    args: [entryId]
+  });
+  return result.rows.map((row) => mapDurableRow(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
+        ${DURABLE_SELECT_COLUMNS}
+      FROM durables
+      WHERE claim_key = ?
+      ORDER BY created_at ASC, id ASC
+    `,
+    args: [normalizedClaimKey]
+  });
+  const entries = result.rows.map((row) => mapDurableRow(row));
+  const slotPolicy = resolveClaimSlotPolicy(normalizedClaimKey, claimSlotPolicyConfig);
+  return {
+    claimKey: normalizedClaimKey,
+    slotPolicy: slotPolicy.policy,
+    slotPolicyReason: slotPolicy.reason,
+    entries
+  };
+}
+
+// src/core/store/pipeline.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
+// 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 (!DURABLE_KINDS.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 if (input.type === "directive") {
+        normalizedClaimKey = normalizeMemoryDirectiveClaimKey(input.claim_key);
+        if (!normalizedClaimKey) {
+          warnings.push(`Entry ${index} provided invalid directive claim key ${JSON.stringify(input.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 directiveMetadata = validateDirectiveMetadata(input, normalizedClaimKey, index, errors, rejectedInputIndexes);
+    if (!directiveMetadata.ok) {
+      continue;
+    }
+    const claimKeyRaw = normalizedClaimKey ? normalizeOptionalString3(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 ? normalizeOptionalString3(input.claim_key_rationale) : void 0;
+    const claimSupportSourceKind = normalizedClaimKey ? normalizeOptionalString3(input.claim_support_source_kind) : void 0;
+    const claimSupportLocator = normalizedClaimKey ? normalizeOptionalString3(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 ?? (input.type === "directive" ? "core" : "temporary"),
+        tags: normalizeTags2(input.tags),
+        source_file: normalizeOptionalString3(input.source_file),
+        source_context: normalizeOptionalString3(input.source_context),
+        user_id: normalizeOptionalString3(input.user_id),
+        project: normalizeOptionalString3(input.project),
+        created_at: normalizeOptionalString3(input.created_at),
+        supersedes: normalizeOptionalString3(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,
+        ...directiveMetadata.metadata ? { directive_polarity: directiveMetadata.metadata.polarity, directive_trigger: directiveMetadata.metadata.trigger } : {}
+      }
+    });
+  }
+  return {
+    valid,
+    rejected: errors.length,
+    rejectedInputIndexes,
+    errors,
+    warnings
+  };
+}
+function validateDirectiveMetadata(input, normalizedClaimKey, index, errors, rejectedInputIndexes) {
+  const hasDirectiveMetadata = input.directive_polarity !== void 0 || input.directive_trigger !== void 0;
+  if (input.type !== "directive") {
+    if (hasDirectiveMetadata) {
+      errors.push(`Entry ${index} provided directive metadata on a non-directive durable.`);
+      rejectedInputIndexes.push(index);
+      return { ok: false };
+    }
+    return { ok: true };
+  }
+  if (!normalizedClaimKey?.startsWith(MEMORY_DIRECTIVE_CLAIM_KEY_PREFIX)) {
+    errors.push(`Entry ${index} directive claim_key must use the ${MEMORY_DIRECTIVE_CLAIM_KEY_PREFIX} prefix.`);
+    rejectedInputIndexes.push(index);
+    return { ok: false };
+  }
+  const polarity = parseDirectivePolarity(input.directive_polarity);
+  if (!polarity) {
+    errors.push(`Entry ${index} directive_polarity must be abstain or proactive.`);
+    rejectedInputIndexes.push(index);
+    return { ok: false };
+  }
+  const trigger = input.directive_trigger === void 0 ? defaultDirectiveTrigger(polarity) : parseDirectiveTrigger(input.directive_trigger);
+  if (!trigger) {
+    errors.push(`Entry ${index} directive_trigger must be session_start, always, or topic:<term>.`);
+    rejectedInputIndexes.push(index);
+    return { ok: false };
+  }
+  return { ok: true, metadata: { polarity, trigger } };
+}
+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 normalizeOptionalString3(value) {
+  const normalized = value?.trim();
+  return normalized && normalized.length > 0 ? normalized : void 0;
+}
+function normalizeClaimSupportObservedAt(value, index, warnings) {
+  const normalized = normalizeOptionalString3(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 normalizeTags2(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 storeDurablesDetailed(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.insertDurable(entry, embedding, preparedEntry.contentHash);
+      const supersededEntryId = preparedEntry.input.supersedes;
+      if (supersededEntryId) {
+        const superseded = await targetDb.supersedeDurable(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.supersedeDurable(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: randomUUID2(),
+    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,
+    // Reserved neutral quality placeholder. Keep this constant unless a scored
+    // quality signal is introduced behind recall evals/feature flags; production
+    // recall must not treat this as an active ranking input while it is defaulted.
+    quality_score: 0.5,
+    recall_count: 0,
+    valid_from: preparedEntry.input.valid_from,
+    valid_to: preparedEntry.input.valid_to,
+    directive_polarity: preparedEntry.input.directive_polarity,
+    directive_trigger: preparedEntry.input.directive_trigger,
+    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,
+    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,
+      claimExtraction.config.concurrency ?? 10,
+      options.onWarning,
+      (entry, diagnostic) => {
+        const preparedEntry = preparedEntries.find((candidate) => candidate.input === entry);
+        if (preparedEntry) {
+          options.onClaimExtractionDiagnostic?.(preparedEntry.inputIndex, diagnostic);
+        }
+      }
+    );
+    const extractedClaimKeys = /* @__PURE__ */ new Map();
+    for (const preparedEntry of preparedEntries) {
+      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.findActiveDurablesByClaimKey(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 ?? normalizeOptionalString4(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 normalizeOptionalString4(value) {
+  const normalized = value?.trim();
+  return normalized && normalized.length > 0 ? normalized : void 0;
+}
+
+export {
+  validateEntriesWithIndexes,
+  storeDurablesDetailed,
+  formatErrorMessage,
+  CLAIM_KEY_DESCRIPTION,
+  MEMORY_RECALL_SECTION_HEADER,
+  RECALL_MODE_SCHEMA_DESCRIPTION,
+  MEMORY_DOCTRINE,
+  buildStoreToolGuidelines,
+  buildUpdateToolGuidelines,
+  buildSkelnRecallToolGuidelines,
+  buildOpenClawStorePromptLines,
+  buildOpenClawStoreToolDescription,
+  buildSkelnStoreToolDescription,
+  buildOpenClawRecallToolDescription,
+  buildSkelnRecallToolDescription,
+  buildUpdateToolDescription,
+  ENTRY_TYPE_DESCRIPTION,
+  EXPIRY_DESCRIPTION,
+  UPDATE_EXPIRY_DESCRIPTION,
+  RECALL_MODES2 as RECALL_MODES,
+  asRecord,
+  parseExpiry,
+  parseDurableKinds,
+  parseDurableKind,
+  parseRecallMode,
+  normalizeStringArray2 as normalizeStringArray,
+  formatTargetSelector,
+  formatTargetSelectorFromParams,
+  sanitizeUpdateToolParams,
+  sanitizeFetchToolParams,
+  backfillEpisodeEmbeddings,
+  prepareEpisodeIngest,
+  ingestEpisodeTranscript,
+  executeEpisodeIngestPlan,
+  createEpisodeIngestPlan,
+  createSingleTranscriptDiscoveryPort,
+  buildDreamProposalReviewReason,
+  resolveDreamProposalApplyTarget,
+  getLastDreamRun,
+  createDreamPort,
+  createMemoryRepository
+};