@agenr/skeln-plugin 3.3.0 → 2026.6.2

package/dist/{chunk-M5M65AYP.js → chunk-SOQW7356.js}

@@ -1,30 +1,10 @@
 import {
-  EMBEDDING_DIMENSIONS,
-  ENTRY_SELECT_COLUMNS,
-  ENTRY_TYPES,
-  EPISODE_ACTIVITY_LEVELS,
-  EXPIRY_LEVELS,
-  VECTOR_INDEX_NAME,
   applyClaimKeyLifecycle,
-  buildActiveEntryClause,
   buildExtractedClaimKeyLifecycle,
-  buildInferredIngestClaimKeySupportContext,
-  buildManualClaimKeyLifecycle,
-  buildPrecomputedClaimKeyLifecycle,
-  composeEmbeddingText,
-  hasPrecomputedClaimKeyLifecycleFields,
-  mapEntryRow,
-  parseClaimKeyConfidence,
-  parseClaimKeySource,
-  parseClaimKeyStatus,
-  parseClaimSupportMode,
-  readNumber,
-  readOptionalString,
-  readRequiredString,
-  truncate,
-  validateTemporalValidityRange
-} from "./chunk-Z5X7T4QZ.js";
+  buildInferredIngestClaimKeySupportContext
+} from "./chunk-VTHBPXDQ.js";
 import {
+  assertKeyedDurableHasLifecycle,
   compactClaimKey,
   describeClaimKeyNormalizationFailure,
   describeExtractedClaimKeyRejection,
@@ -32,1211 +12,167 @@ import {
   isTrustedClaimKeyForCleanup,
   normalizeClaimKey,
   normalizeClaimKeySegment,
-  parseRelativeDate,
-  resolveClaimSlotPolicy,
   validateExtractedClaimKey
-} from "./chunk-5LADPJ4C.js";
+} from "./chunk-VBPYU7GO.js";
 
-// src/adapters/shared/errors.ts
-function formatErrorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-
-// src/adapters/shared/resolve-target.ts
-function buildEntryMemoryResolverPorts(services) {
-  return {
-    getEntryById: async (entryId) => await services.entries.getEntry(entryId) ?? (await services.memory.getEntryTrace(entryId))?.entry ?? null,
-    findEntryBySubject: async (subject) => services.memory.findEntryBySubject(subject),
-    findMostRecentEntry: async () => services.memory.findMostRecentEntry()
-  };
-}
-async function resolveTargetEntry(ports, params, options = {}) {
-  const id = readOptionalStringParam(params, "id");
-  const subject = readOptionalStringParam(params, "subject");
-  const last = options.allowLast ? readBooleanParam(params, "last") : void 0;
-  const selectorCount = (id ? 1 : 0) + (subject ? 1 : 0) + (last === true ? 1 : 0);
-  const selectorDescription = options.allowLast ? "id, subject, or last" : "id or subject";
-  if (selectorCount !== 1) {
-    throw new Error(`Provide exactly one target selector: ${selectorDescription}.`);
-  }
-  if (last) {
-    const entry2 = await ports.findMostRecentEntry();
-    if (!entry2) {
-      throw new Error("No agenr entries exist yet.");
-    }
-    return entry2;
-  }
-  if (id) {
-    const entry2 = await ports.getEntryById(id);
-    if (!entry2) {
-      throw new Error(`No agenr entry found for id ${id}.`);
-    }
-    return entry2;
-  }
-  const entry = await ports.findEntryBySubject(subject ?? "");
-  if (!entry) {
-    throw new Error(`No agenr entry found for subject "${subject}".`);
-  }
-  return entry;
-}
-function readBooleanParam(params, key) {
-  const value = params[key];
-  if (value === void 0) {
-    return void 0;
-  }
-  if (typeof value === "boolean") {
-    return value;
-  }
-  throw new Error(`${key} must be a boolean.`);
-}
-function readOptionalStringParam(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;
-}
-
-// 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.";
-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_MODES = ["auto", "entries", "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 parseEntryTypes(values) {
-  return normalizeStringArray(values).map((value) => parseEntryType(value));
-}
-function parseEntryType(value) {
-  if (ENTRY_TYPES.includes(value)) {
-    return value;
-  }
-  throw new Error(`Unsupported entry type "${value}".`);
-}
-function parseRecallMode(value) {
-  if (value === void 0) {
-    return void 0;
-  }
-  if (RECALL_MODES.includes(value)) {
-    return value;
-  }
-  throw new Error(`Unsupported recall mode "${value}".`);
-}
-function normalizeStringArray(values) {
-  if (!values) {
-    return [];
-  }
-  return Array.from(new Set(values.map((value) => value.trim()).filter((value) => value.length > 0)));
-}
-function formatTargetSelector(id, subject, last) {
-  if (last === true) {
-    return "last";
-  }
-  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 last = options.allowLast ? readBooleanParam(params, "last") : void 0;
-  const maxValueChars = options.maxValueChars;
-  return formatTargetSelector(
-    id && maxValueChars !== void 0 ? truncate(id, maxValueChars) : id,
-    subject && maxValueChars !== void 0 ? truncate(subject, maxValueChars) : subject,
-    last
-  );
-}
-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 } : {}
-  };
-}
-function sanitizeFetchToolParams(params) {
-  return {
-    ...params.id ? { id: params.id } : {},
-    ...params.subject ? { subject: params.subject } : {}
-  };
-}
-
-// 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/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") {
+// src/app/dreaming/concurrency.ts
+import { randomUUID } from "crypto";
+var DREAMING_RUN_LEASE_BRAND = /* @__PURE__ */ Symbol("DreamingRunLease");
+var inProcessRunLocks = /* @__PURE__ */ new Map();
+var episodeWriteRefcounts = /* @__PURE__ */ new Map();
+var DEFAULT_LOCK_HEARTBEAT_INTERVAL_MS = 5 * 60 * 1e3;
+var DEFAULT_LOCK_WAIT_TIMEOUT_MS = 60 * 1e3;
+var DEFAULT_LOCK_WAIT_POLL_MS = 500;
+function resolveDreamingLockKey(dbPath) {
+  const trimmed = dbPath?.trim();
+  return trimmed && trimmed.length > 0 ? trimmed : ":memory:";
+}
+async function tryAcquireDreamingRunLock(port, dbPath) {
+  const lockKey = resolveDreamingLockKey(dbPath);
+  if (inProcessRunLocks.has(lockKey)) {
     return null;
   }
-  const normalized = value.replace(/\s+/gu, " ").trim();
-  return normalized ? normalized : null;
-}
-function normalizeActivityLevel(value) {
-  if (typeof value !== "string") {
+  const token = randomUUID();
+  const acquired = await port.tryAcquireRunLock(token);
+  if (!acquired) {
     return null;
   }
-  const normalized = value.trim().toLowerCase();
-  return EPISODE_ACTIVITY_LEVELS.includes(normalized) ? normalized : null;
+  inProcessRunLocks.set(lockKey, token);
+  return createDreamingRunLease(port, lockKey, token);
 }
-function normalizeTags(value) {
-  if (!Array.isArray(value)) {
-    return [];
+async function withDreamingRunLock(port, dbPath, fn) {
+  const lease = await tryAcquireDreamingRunLock(port, dbPath);
+  if (!lease) {
+    throw new Error("Dreaming run already in progress.");
   }
-  return Array.from(
-    new Set(
-      value.filter((tag) => typeof tag === "string").map((tag) => tag.trim().toLowerCase()).filter((tag) => tag.length > 0)
-    )
-  ).slice(0, 8);
+  return withHeldDreamingRunLock(lease, fn);
 }
-function normalizeProject(value) {
-  if (typeof value !== "string") {
-    return void 0;
+async function withHeldDreamingRunLock(lease, fn) {
+  let callbackError;
+  let result;
+  const stopHeartbeat = startDreamingRunLockHeartbeat(lease);
+  try {
+    await lease.heartbeat();
+    result = await fn(lease);
+  } catch (error) {
+    callbackError = error;
   }
-  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;
-    }
+  let cleanupError;
+  try {
+    await stopHeartbeat();
+  } catch (error) {
+    cleanupError = error;
   }
-  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);
+  try {
+    await lease.release();
+  } catch (error) {
+    if (cleanupError === void 0) {
+      cleanupError = error;
     }
   }
-  const objectStart = trimmed.indexOf("{");
-  const objectEnd = trimmed.lastIndexOf("}");
-  if (objectStart >= 0 && objectEnd > objectStart) {
-    candidates.add(trimmed.slice(objectStart, objectEnd + 1));
+  if (callbackError !== void 0) {
+    throw callbackError;
   }
-  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;
-    }
+  if (cleanupError !== void 0) {
+    throw cleanupError;
   }
-  return embedEpisodeSummaryWithPort(summary, ports.embedding);
+  return result;
 }
-async function embedEpisodeSummaryWithPort(summary, embeddingPort) {
-  if (!embeddingPort) {
-    return void 0;
-  }
+async function withEpisodeWriteGuard(input, fn) {
+  beginEpisodeWrite(input.dbPath);
   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;
+    const lease = await waitForDreamingRunLock(input.port, input.dbPath, {
+      timeoutMs: input.waitTimeoutMs,
+      pollMs: input.waitPollMs
+    });
+    return await withHeldDreamingRunLock(lease, async () => fn());
+  } finally {
+    endEpisodeWrite(input.dbPath);
   }
-  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;
+function beginEpisodeWrite(dbPath) {
+  const lockKey = resolveDreamingLockKey(dbPath);
+  episodeWriteRefcounts.set(lockKey, (episodeWriteRefcounts.get(lockKey) ?? 0) + 1);
 }
-
-// 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
-    };
+function endEpisodeWrite(dbPath) {
+  const lockKey = resolveDreamingLockKey(dbPath);
+  const next = (episodeWriteRefcounts.get(lockKey) ?? 0) - 1;
+  if (next <= 0) {
+    episodeWriteRefcounts.delete(lockKey);
+    return;
   }
-  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
-  };
+  episodeWriteRefcounts.set(lockKey, next);
 }
-
-// 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);
+function isEpisodeWriteInProgress(dbPath) {
+  return (episodeWriteRefcounts.get(resolveDreamingLockKey(dbPath)) ?? 0) > 0;
 }
-
-// src/app/episode-ingest/service/preflight.ts
-import path from "path";
-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);
+function createDreamingRunLease(port, lockKey, token) {
+  let released = false;
   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
+    token,
+    [DREAMING_RUN_LEASE_BRAND]: true,
+    async heartbeat() {
+      if (released) {
+        return;
       }
-    };
-  }
-  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 (inProcessRunLocks.get(lockKey) !== token) {
+        throw new Error("Dreaming run lock was lost in this process.");
       }
-    };
-  }
-  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 retained = await port.heartbeatRunLock(token);
+      if (!retained) {
+        throw new Error("Dreaming run lock was lost.");
       }
-    };
-  }
-  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
+    async release() {
+      if (released) {
+        return;
       }
-    };
-  }
-  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);
+      released = true;
+      if (inProcessRunLocks.get(lockKey) === token) {
+        inProcessRunLocks.delete(lockKey);
       }
-    })
-  );
-  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
+      await port.releaseRunLock(token);
     }
   };
 }
-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)
-      };
+function startDreamingRunLockHeartbeat(lease) {
+  let heartbeatError;
+  let pendingHeartbeat = null;
+  const timer = setInterval(() => {
+    pendingHeartbeat = lease.heartbeat().catch((error) => {
+      heartbeatError = error;
+    });
+  }, DEFAULT_LOCK_HEARTBEAT_INTERVAL_MS);
+  timer.unref?.();
+  return async () => {
+    clearInterval(timer);
+    if (pendingHeartbeat) {
+      await pendingHeartbeat;
+    }
+    if (heartbeatError !== void 0) {
+      throw heartbeatError;
     }
-    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 [];
+async function waitForDreamingRunLock(port, dbPath, options) {
+  const timeoutMs = options.timeoutMs ?? DEFAULT_LOCK_WAIT_TIMEOUT_MS;
+  const pollMs = options.pollMs ?? DEFAULT_LOCK_WAIT_POLL_MS;
+  const deadline = Date.now() + timeoutMs;
+  while (true) {
+    const lease = await tryAcquireDreamingRunLock(port, dbPath);
+    if (lease) {
+      return lease;
     }
-    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
+    if (Date.now() >= deadline) {
+      throw new Error("Timed out waiting for dreaming run lock before episode write.");
     }
-  };
-}
-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/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
-        ${ENTRY_SELECT_COLUMNS},
-        CASE
-          WHEN lower(subject) = lower(?) THEN 0
-          WHEN lower(subject) LIKE lower(?) THEN 1
-          ELSE 2
-        END AS match_rank
-      FROM entries
-      WHERE lower(subject) = lower(?)
-         OR lower(subject) LIKE lower(?)
-      ORDER BY match_rank ASC, created_at DESC
-      LIMIT 1
-    `,
-    args: [normalizedSubject, `%${normalizedSubject}%`, normalizedSubject, `%${normalizedSubject}%`]
-  });
-  const row = result.rows[0];
-  return row ? mapEntryRow(row) : null;
-}
-async function findMostRecentEntry(executor) {
-  const result = await executor.execute({
-    sql: `
-      SELECT
-        ${ENTRY_SELECT_COLUMNS}
-      FROM entries
-      ORDER BY created_at DESC
-      LIMIT 1
-    `
-  });
-  const row = result.rows[0];
-  return row ? mapEntryRow(row) : null;
-}
-async function getEntryTrace(executor, entryId, claimSlotPolicyConfig) {
-  const entry = await getEntryByIdIncludingInactive(executor, entryId);
-  if (!entry) {
-    return null;
+    await sleep(Math.min(pollMs, Math.max(1, deadline - Date.now())));
   }
-  const [supersededBy, supersedes, claimFamily, recallEvents] = await Promise.all([
-    entry.superseded_by ? getEntryByIdIncludingInactive(executor, entry.superseded_by) : Promise.resolve(null),
-    listSupersededEntries(executor, entry.id),
-    entry.claim_key ? getClaimFamily(executor, entry.claim_key, claimSlotPolicyConfig) : Promise.resolve(void 0),
-    listRecallEvents(executor, entry.id)
-  ]);
-  return {
-    entry,
-    ...supersededBy ? { supersededBy } : {},
-    supersedes,
-    ...claimFamily ? { claimFamily } : {},
-    recallEvents
-  };
 }
-async function getMemoryStatusSnapshot(executor) {
-  const result = await executor.execute({
-    sql: `
-      SELECT
-        COUNT(*) AS active_entries,
-        SUM(CASE WHEN expiry = 'core' THEN 1 ELSE 0 END) AS core_entries,
-        COUNT(DISTINCT source_file) AS source_files
-      FROM entries
-      WHERE ${buildActiveEntryClause()}
-    `
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
   });
-  const row = result.rows[0];
-  if (!row) {
-    return {
-      activeEntries: 0,
-      coreEntries: 0,
-      sourceFiles: 0
-    };
-  }
-  return {
-    activeEntries: readNumber(row, "active_entries", 0),
-    coreEntries: readNumber(row, "core_entries", 0),
-    sourceFiles: readNumber(row, "source_files", 0)
-  };
-}
-async function probeVectorAvailability(executor) {
-  try {
-    await executor.execute({
-      sql: `
-        SELECT COUNT(*) AS matches
-        FROM vector_top_k('${VECTOR_INDEX_NAME}', vector32(?), ?) AS matches
-      `,
-      args: [ZERO_VECTOR, 1]
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function getEntryByIdIncludingInactive(executor, entryId) {
-  const normalizedId = entryId.trim();
-  if (normalizedId.length === 0) {
-    return null;
-  }
-  const result = await executor.execute({
-    sql: `
-      SELECT
-        ${ENTRY_SELECT_COLUMNS}
-      FROM entries
-      WHERE id = ?
-      LIMIT 1
-    `,
-    args: [normalizedId]
-  });
-  const row = result.rows[0];
-  return row ? mapEntryRow(row) : null;
-}
-async function listSupersededEntries(executor, entryId) {
-  const result = await executor.execute({
-    sql: `
-      SELECT
-        ${ENTRY_SELECT_COLUMNS}
-      FROM entries
-      WHERE superseded_by = ?
-      ORDER BY created_at DESC
-    `,
-    args: [entryId]
-  });
-  return result.rows.map((row) => mapEntryRow(row));
-}
-async function getClaimFamily(executor, claimKey, claimSlotPolicyConfig) {
-  const normalizedClaimKey = claimKey.trim();
-  if (normalizedClaimKey.length === 0) {
-    return void 0;
-  }
-  const result = await executor.execute({
-    sql: `
-      SELECT
-        ${ENTRY_SELECT_COLUMNS}
-      FROM entries
-      WHERE claim_key = ?
-      ORDER BY created_at ASC, id ASC
-    `,
-    args: [normalizedClaimKey]
-  });
-  const entries = result.rows.map((row) => mapEntryRow(row));
-  const slotPolicy = resolveClaimSlotPolicy(normalizedClaimKey, claimSlotPolicyConfig);
-  return {
-    claimKey: normalizedClaimKey,
-    slotPolicy: slotPolicy.policy,
-    slotPolicyReason: slotPolicy.reason,
-    entries
-  };
-}
-async function listRecallEvents(executor, entryId) {
-  const result = await executor.execute({
-    sql: `
-      SELECT
-        query,
-        session_key,
-        recalled_at
-      FROM recall_events
-      WHERE entry_id = ?
-      ORDER BY recalled_at DESC
-      LIMIT 10
-    `,
-    args: [entryId]
-  });
-  return result.rows.map((row) => ({
-    query: readOptionalString(row, "query"),
-    sessionKey: readOptionalString(row, "session_key"),
-    recalledAt: readRequiredString(row, "recalled_at")
-  }));
 }
 
 // src/core/claim-key-entity-family.ts
@@ -1333,12 +269,12 @@ function detectClaimKeyEntityFamilyCandidates(entries) {
       return support?.autoSafe === true;
     });
     const componentProfiles = component.map((entity) => profiles.get(entity)).filter((profile) => Boolean(profile));
-    const entryIds = normalizeStringArray2(componentProfiles.flatMap((profile) => [...profile.entryIds]));
-    const claimKeys = normalizeStringArray2(componentProfiles.flatMap((profile) => [...profile.claimKeys]));
+    const durableIds = normalizeStringArray(componentProfiles.flatMap((profile) => [...profile.durableIds]));
+    const claimKeys = normalizeStringArray(componentProfiles.flatMap((profile) => [...profile.claimKeys]));
     const confidence = componentSupport.length > 0 ? Math.max(...componentSupport.map((support) => support.confidence)) : 0.75;
     families.push({
       entityPrefixes: [...component].sort((left, right) => left.localeCompare(right)),
-      entryIds,
+      durableIds,
       claimKeys,
       canonicalEntityPrefix,
       canonicalSelectionReasons: canonicalSelection.reasons,
@@ -1372,6 +308,7 @@ function summarizeClaimKeyEntityPrefixStats(observations) {
     if (!inspection.normalized) {
       continue;
     }
+    assertKeyedDurableHasLifecycle(observation);
     const entityPrefix = inspection.normalized.entity;
     const existing = counts.get(entityPrefix) ?? {
       entityPrefix,
@@ -1379,12 +316,11 @@ function summarizeClaimKeyEntityPrefixStats(observations) {
       trustedEntryCount: 0,
       tentativeEntryCount: 0,
       unresolvedEntryCount: 0,
-      legacyEntryCount: 0,
       deterministicRepairEntryCount: 0,
       manualEntryCount: 0,
       modelEntryCount: 0,
       jsonRetryEntryCount: 0,
-      surgeonFamilyReuseEntryCount: 0
+      dreamingFamilyReuseDurableCount: 0
     };
     existing.activeEntryCount += 1;
     switch (observation.claim_key_status) {
@@ -1397,9 +333,6 @@ function summarizeClaimKeyEntityPrefixStats(observations) {
       case "unresolved":
         existing.unresolvedEntryCount += 1;
         break;
-      default:
-        existing.legacyEntryCount += 1;
-        break;
     }
     switch (observation.claim_key_source) {
       case "deterministic_repair":
@@ -1414,8 +347,8 @@ function summarizeClaimKeyEntityPrefixStats(observations) {
       case "json_retry":
         existing.jsonRetryEntryCount += 1;
         break;
-      case "surgeon_family_reuse":
-        existing.surgeonFamilyReuseEntryCount += 1;
+      case "dreaming_reconcile":
+        existing.dreamingFamilyReuseDurableCount += 1;
         break;
       default:
         break;
@@ -1471,7 +404,7 @@ function buildTrustedClaimKeyEntityProfiles(entries) {
     const entityPrefix = inspection.normalized.entity;
     const attribute = inspection.normalized.attribute;
     const profile = getOrCreateProfile(profiles, entityPrefix);
-    profile.entryIds.add(entry.id);
+    profile.durableIds.add(entry.id);
     profile.claimKeys.add(inspection.normalized.claimKey);
     profile.attributeSet.add(attribute);
     const [attributeHead = attribute] = attribute.split("_");
@@ -1503,7 +436,7 @@ function getOrCreateProfile(profiles, entityPrefix) {
   const tokenList = entityPrefix.split("_").filter((token) => token.length > 0);
   const created = {
     entityPrefix,
-    entryIds: /* @__PURE__ */ new Set(),
+    durableIds: /* @__PURE__ */ new Set(),
     claimKeys: /* @__PURE__ */ new Set(),
     attributeSet: /* @__PURE__ */ new Set(),
     attributeHeadSet: /* @__PURE__ */ new Set(),
@@ -1533,7 +466,7 @@ function buildPairSupport(profiles) {
     }
   }
   for (const entities of attributeBuckets.values()) {
-    const normalizedEntities = normalizeStringArray2(entities);
+    const normalizedEntities = normalizeStringArray(entities);
     if (normalizedEntities.length < 2 || normalizedEntities.length > MAX_ATTRIBUTE_BUCKET_SIZE) {
       continue;
     }
@@ -1624,7 +557,7 @@ function evaluateEntityFamilyPairSupport(leftProfile, rightProfile) {
   );
   return {
     entityPrefixes: [leftProfile.entityPrefix, rightProfile.entityPrefix],
-    supportingEntryIds: normalizeStringArray2([...leftProfile.entryIds, ...rightProfile.entryIds]),
+    supportingDurableIds: normalizeStringArray([...leftProfile.durableIds, ...rightProfile.durableIds]),
     sharedAttributes,
     confidence,
     autoSafe: lexicalRelation.autoSafe && (sharedAttributes.length >= 2 || sharedAttributes.length === 1 && groundingAnchorCount >= 1 && groundingScore >= 2),
@@ -1730,7 +663,7 @@ function selectCanonicalEntityPrefix(entityPrefixes, pairSupport, profiles) {
       reasons.push(`lexical alias evidence prefers "${entityPrefix}"`);
     }
     scoreByEntity.set(entityPrefix, score);
-    reasonsByEntity.set(entityPrefix, normalizeStringArray2(reasons));
+    reasonsByEntity.set(entityPrefix, normalizeStringArray(reasons));
   }
   const ranked = [...scoreByEntity.entries()].sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]));
   const [bestCandidate, secondCandidate] = ranked;
@@ -1974,23 +907,133 @@ function intersectSets(left, right) {
   }
   return intersection.sort((first, second) => first.localeCompare(second));
 }
-function normalizeStringArray2(values) {
+function normalizeStringArray(values) {
   return Array.from(new Set(values.map((value) => value.trim()).filter((value) => value.length > 0)));
 }
 function buildPairKey(leftEntityPrefix, rightEntityPrefix) {
   return [leftEntityPrefix, rightEntityPrefix].sort((left, right) => left.localeCompare(right)).join("::");
 }
-function getOrCreateSet(map, key) {
-  const existing = map.get(key);
-  if (existing) {
-    return existing;
+function getOrCreateSet(map, key) {
+  const existing = map.get(key);
+  if (existing) {
+    return existing;
+  }
+  const created = /* @__PURE__ */ new Set();
+  map.set(key, created);
+  return created;
+}
+function pluralize(count, noun) {
+  return count === 1 ? noun : `${noun}s`;
+}
+
+// src/core/supersession.ts
+function validateSupersessionRules(oldEntry, newEntry) {
+  if (oldEntry.type !== newEntry.type) {
+    return {
+      ok: false,
+      reason: "type_mismatch"
+    };
+  }
+  if (oldEntry.type === "milestone") {
+    return {
+      ok: false,
+      reason: "milestone"
+    };
+  }
+  if (oldEntry.expiry === "core") {
+    return {
+      ok: false,
+      reason: "core_expiry"
+    };
+  }
+  return {
+    ok: true
+  };
+}
+function describeSupersessionRuleFailure(reason) {
+  switch (reason) {
+    case "type_mismatch":
+      return "Supersession requires both entries to have the same type.";
+    case "milestone":
+      return "Milestone entries are never superseded automatically.";
+    case "core_expiry":
+      return "Core-expiry entries are never superseded automatically.";
+  }
+}
+
+// src/core/store/hashing.ts
+import { createHash } from "crypto";
+function computeContentHash(content, sourceFile) {
+  const input = sourceFile ? `${sourceFile}
+${content}` : content;
+  return createHash("sha256").update(input).digest("hex");
+}
+function computeNormContentHash(content) {
+  const normalized = content.toLowerCase().replace(/\s+/g, " ").trim().replace(/[^\w\s]/g, "");
+  return createHash("sha256").update(normalized).digest("hex");
+}
+
+// src/core/store/project-scope.ts
+import path from "path";
+var IGNORED_PROJECT_DIRECTORY_NAMES = /* @__PURE__ */ new Set(["", ".", "..", "users", "user", "home", "tmp", "var"]);
+function resolveDurableProjectScope(entry, context = {}) {
+  const entryProject = normalizeOptionalString(entry.project);
+  if (entryProject) {
+    return entryProject;
+  }
+  const sessionWorkspace = normalizeOptionalString(context.sessionWorkspace ?? void 0);
+  if (sessionWorkspace) {
+    if (claimKeySuggestsProjectScope(entry.claim_key, sessionWorkspace) || entryContainsProjectSignal(entry, sessionWorkspace)) {
+      return sessionWorkspace;
+    }
+  }
+  const workingDirectoryProject = deriveWorkingDirectoryProject(context.workingDirectory);
+  if (workingDirectoryProject && entryContainsProjectSignal(entry, workingDirectoryProject)) {
+    return workingDirectoryProject;
+  }
+  return void 0;
+}
+function claimKeySuggestsProjectScope(claimKey, project) {
+  const entity = normalizeMetadataIdentifier(claimKey?.split("/")[0]);
+  const normalizedProject = normalizeMetadataIdentifier(project);
+  if (!entity || !normalizedProject) {
+    return false;
+  }
+  return entity === normalizedProject;
+}
+function deriveWorkingDirectoryProject(workingDirectory) {
+  const normalizedWorkingDirectory = normalizeOptionalString(workingDirectory ?? void 0);
+  if (!normalizedWorkingDirectory) {
+    return void 0;
+  }
+  const candidate = normalizeMetadataIdentifier(path.basename(normalizedWorkingDirectory));
+  if (!candidate || IGNORED_PROJECT_DIRECTORY_NAMES.has(candidate)) {
+    return void 0;
+  }
+  return candidate;
+}
+function entryContainsProjectSignal(entry, project) {
+  const projectTokens = project.split("_").filter((token) => token.length > 0);
+  if (projectTokens.length === 0) {
+    return false;
   }
-  const created = /* @__PURE__ */ new Set();
-  map.set(key, created);
-  return created;
+  return [entry.subject, entry.source_context, ...entry.tags ?? []].some((value) => {
+    const tokens = tokenizeText(value);
+    return projectTokens.every((token) => tokens.has(token));
+  });
 }
-function pluralize(count, noun) {
-  return count === 1 ? noun : `${noun}s`;
+function normalizeMetadataIdentifier(value) {
+  const normalized = normalizeOptionalString(value)?.toLowerCase().replace(/[^a-z0-9]+/gu, "_").replace(/^_+|_+$/gu, "");
+  return normalized && normalized.length > 0 ? normalized : void 0;
+}
+function tokenizeText(value) {
+  return new Set(
+    (value ?? "").toLowerCase().split(/[^a-z0-9]+/u).map((token) => token.trim()).filter((token) => token.length > 0)
+  );
+}
+function normalizeOptionalString(value) {
+  const normalized = value?.trim();
+  return normalized && normalized.length > 0 ? normalized : void 0;
 }
 
 // src/core/claim-key-support.ts
@@ -2239,7 +1282,7 @@ function evaluateClaimKeySupport(entry, targetClaimKey, trustedHints) {
     familyReuseCount: familyReuseEntries.length,
     groundedFamilyReuseCount: groundedFamilyReuseEntries.length,
     relaxedStableSlotFamilyGate: promotionSupport.relaxedStableSlotFamilyGate,
-    supportingEntryIds: normalizeStringArray3([
+    supportingDurableIds: normalizeStringArray2([
       ...groundedExactReuseEntries.map((candidate) => candidate.id),
       ...groundedFamilyReuseEntries.map((candidate) => candidate.id),
       ...familyReuseEntries.filter((candidate) => candidate.id.startsWith("example:")).map((candidate) => candidate.id)
@@ -2266,7 +1309,7 @@ function createEmptyClaimKeySupportEvaluation() {
     familyReuseCount: 0,
     groundedFamilyReuseCount: 0,
     relaxedStableSlotFamilyGate: false,
-    supportingEntryIds: [],
+    supportingDurableIds: [],
     supportEvidence: [],
     rationaleFragments: []
   };
@@ -2295,18 +1338,18 @@ function evaluateClaimKeyCompactness(claimKey, prior) {
   };
 }
 function normalizeGroundingTags(tags) {
-  return normalizeStringArray3((tags ?? []).map((tag) => normalizeClaimKeySegment(tag)).filter((tag) => tag.length > 0));
+  return normalizeStringArray2((tags ?? []).map((tag) => normalizeClaimKeySegment(tag)).filter((tag) => tag.length > 0));
 }
 function tokenizeGroundingText(value) {
   if (!value) {
     return [];
   }
-  return normalizeStringArray3(
+  return normalizeStringArray2(
     value.split(/[^a-zA-Z0-9]+/u).map((token) => normalizeClaimKeySegment(token)).filter((token) => token.length > 2 && !GROUNDING_STOP_TOKENS.has(token))
   );
 }
-function buildEntryLocalLexicalTokens(entry) {
-  return normalizeStringArray3([
+function buildDurableLocalLexicalTokens(entry) {
+  return normalizeStringArray2([
     ...tokenizeGroundingText(entry.subject),
     ...tokenizeGroundingText(entry.content),
     ...tokenizeGroundingText(entry.source_context),
@@ -2351,7 +1394,7 @@ function inspectGroundingOverlap(entryTagSet, entrySourceTokens, trustedEntry) {
   };
 }
 function inspectCandidateLexicalAlignment(entry, entity, attribute) {
-  const lexicalTokens = new Set(buildEntryLocalLexicalTokens(entry));
+  const lexicalTokens = new Set(buildDurableLocalLexicalTokens(entry));
   const entityTokens = entity.split("_").filter((token) => token.length > 0);
   const attributeTokens = attribute.split("_").filter((token) => token.length > 0 && !GROUNDING_STOP_TOKENS.has(token));
   const entityOverlapCount = countSetOverlap(lexicalTokens, entityTokens);
@@ -2414,7 +1457,7 @@ function intersects(left, right) {
   }
   return false;
 }
-function normalizeStringArray3(values) {
+function normalizeStringArray2(values) {
   const seen = /* @__PURE__ */ new Set();
   const normalized = [];
   for (const value of values) {
@@ -3069,12 +2112,11 @@ function summarizeAugmentedEntityPrefixStats(entityPrefixStats, entityPrefix) {
       trustedEntryCount: 0,
       tentativeEntryCount: 1,
       unresolvedEntryCount: 0,
-      legacyEntryCount: 0,
       deterministicRepairEntryCount: 1,
       manualEntryCount: 0,
       modelEntryCount: 0,
       jsonRetryEntryCount: 0,
-      surgeonFamilyReuseEntryCount: 0
+      dreamingFamilyReuseDurableCount: 0
     }
   ];
 }
@@ -3349,691 +2391,6 @@ function limitUnique(values, limit) {
   return Array.from(new Set(values.filter((value) => value.length > 0))).slice(0, limit);
 }
 
-// src/core/store/pipeline.ts
-import { randomUUID } from "crypto";
-
-// src/core/supersession.ts
-function validateSupersessionRules(oldEntry, newEntry) {
-  if (oldEntry.type !== newEntry.type) {
-    return {
-      ok: false,
-      reason: "type_mismatch"
-    };
-  }
-  if (oldEntry.type === "milestone") {
-    return {
-      ok: false,
-      reason: "milestone"
-    };
-  }
-  if (oldEntry.expiry === "core") {
-    return {
-      ok: false,
-      reason: "core_expiry"
-    };
-  }
-  return {
-    ok: true
-  };
-}
-function describeSupersessionRuleFailure(reason) {
-  switch (reason) {
-    case "type_mismatch":
-      return "Supersession requires both entries to have the same type.";
-    case "milestone":
-      return "Milestone entries are never superseded automatically.";
-    case "core_expiry":
-      return "Core-expiry entries are never superseded automatically.";
-  }
-}
-
-// src/core/store/hashing.ts
-import { createHash } from "crypto";
-function computeContentHash(content, sourceFile) {
-  const input = sourceFile ? `${sourceFile}
-${content}` : content;
-  return createHash("sha256").update(input).digest("hex");
-}
-function computeNormContentHash(content) {
-  const normalized = content.toLowerCase().replace(/\s+/g, " ").trim().replace(/[^\w\s]/g, "");
-  return createHash("sha256").update(normalized).digest("hex");
-}
-
-// src/core/store/validation.ts
-var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
-function validateEntriesWithIndexes(inputs) {
-  const valid = [];
-  const errors = [];
-  const warnings = [];
-  const rejectedInputIndexes = [];
-  for (const [index, input] of inputs.entries()) {
-    const subject = normalizeString(input.subject);
-    const content = normalizeString(input.content);
-    if (!ENTRY_TYPES.includes(input.type)) {
-      errors.push(`Entry ${index} has an invalid type.`);
-      rejectedInputIndexes.push(index);
-      continue;
-    }
-    if (subject.length === 0) {
-      errors.push(`Entry ${index} is missing a subject.`);
-      rejectedInputIndexes.push(index);
-      continue;
-    }
-    if (content.length === 0) {
-      errors.push(`Entry ${index} is missing content.`);
-      rejectedInputIndexes.push(index);
-      continue;
-    }
-    if (input.expiry !== void 0 && !EXPIRY_LEVELS.includes(input.expiry)) {
-      errors.push(`Entry ${index} has an invalid expiry.`);
-      rejectedInputIndexes.push(index);
-      continue;
-    }
-    if (input.tags !== void 0 && !areValidTags(input.tags)) {
-      errors.push(`Entry ${index} has invalid tags.`);
-      rejectedInputIndexes.push(index);
-      continue;
-    }
-    if (input.importance !== void 0 && !Number.isFinite(input.importance)) {
-      errors.push(`Entry ${index} has an invalid importance.`);
-      rejectedInputIndexes.push(index);
-      continue;
-    }
-    if (input.supersedes !== void 0 && !isUuid(input.supersedes)) {
-      errors.push(`Entry ${index} has an invalid supersedes id.`);
-      rejectedInputIndexes.push(index);
-      continue;
-    }
-    const temporalValidity = validateTemporalValidityRange(input.valid_from, input.valid_to);
-    if (!temporalValidity.ok) {
-      errors.push(`Entry ${index} ${temporalValidity.message}`);
-      rejectedInputIndexes.push(index);
-      continue;
-    }
-    let normalizedClaimKey;
-    if (input.claim_key !== void 0) {
-      if (typeof input.claim_key !== "string") {
-        warnings.push(`Entry ${index} provided a non-string claim key and it was dropped.`);
-      } else {
-        const claimKey = normalizeClaimKey(input.claim_key);
-        if (claimKey.ok) {
-          normalizedClaimKey = claimKey.value.claimKey;
-        } else {
-          warnings.push(
-            `Entry ${index} provided invalid claim key ${JSON.stringify(input.claim_key)} and it was dropped: ${describeClaimKeyNormalizationFailure(claimKey.reason)}.`
-          );
-        }
-      }
-    }
-    const claimKeyRaw = normalizedClaimKey ? normalizeOptionalString(input.claim_key_raw) : void 0;
-    const claimKeyStatus = normalizedClaimKey ? normalizeClaimKeyStatus(input.claim_key_status, index, warnings) : void 0;
-    const claimKeySource = normalizedClaimKey ? normalizeClaimKeySource(input.claim_key_source, index, warnings) : void 0;
-    const claimKeyConfidence = normalizedClaimKey ? normalizeClaimKeyConfidence(input.claim_key_confidence, index, warnings) : void 0;
-    const claimKeyRationale = normalizedClaimKey ? normalizeOptionalString(input.claim_key_rationale) : void 0;
-    const claimSupportSourceKind = normalizedClaimKey ? normalizeOptionalString(input.claim_support_source_kind) : void 0;
-    const claimSupportLocator = normalizedClaimKey ? normalizeOptionalString(input.claim_support_locator) : void 0;
-    const claimSupportObservedAt = normalizedClaimKey && input.claim_support_observed_at !== void 0 ? normalizeClaimSupportObservedAt(input.claim_support_observed_at, index, warnings) : void 0;
-    const claimSupportMode = normalizedClaimKey && input.claim_support_mode !== void 0 ? normalizeClaimSupportMode(input.claim_support_mode, index, warnings) : void 0;
-    const hasPrecomputedLifecycleFields = hasPrecomputedClaimKeyLifecycleFields(input);
-    const resolvedPrecomputedLifecycle = normalizedClaimKey && hasPrecomputedLifecycleFields ? buildPrecomputedClaimKeyLifecycle({
-      claim_key: normalizedClaimKey,
-      claim_key_raw: claimKeyRaw,
-      claim_key_status: claimKeyStatus,
-      claim_key_source: claimKeySource,
-      claim_key_confidence: claimKeyConfidence,
-      claim_key_rationale: claimKeyRationale,
-      claim_support_source_kind: claimSupportSourceKind,
-      claim_support_locator: claimSupportLocator,
-      claim_support_observed_at: claimSupportObservedAt,
-      claim_support_mode: claimSupportMode
-    }) : void 0;
-    if (hasPrecomputedLifecycleFields) {
-      if (!normalizedClaimKey) {
-        errors.push(`Entry ${index} provided claim-key lifecycle metadata without a valid claim key.`);
-        rejectedInputIndexes.push(index);
-        continue;
-      }
-      if (!resolvedPrecomputedLifecycle) {
-        errors.push(
-          `Entry ${index} provided partial or invalid claim-key lifecycle metadata. Complete bundles require claim_key_status, claim_key_source, claim_key_confidence, and claim_key_rationale.`
-        );
-        rejectedInputIndexes.push(index);
-        continue;
-      }
-    }
-    valid.push({
-      inputIndex: index,
-      input: {
-        type: input.type,
-        subject,
-        content,
-        importance: clampImportance(input.importance),
-        expiry: input.expiry ?? "temporary",
-        tags: normalizeTags2(input.tags),
-        source_file: normalizeOptionalString(input.source_file),
-        source_context: normalizeOptionalString(input.source_context),
-        user_id: normalizeOptionalString(input.user_id),
-        project: normalizeOptionalString(input.project),
-        created_at: normalizeOptionalString(input.created_at),
-        supersedes: normalizeOptionalString(input.supersedes),
-        claim_key: normalizedClaimKey,
-        claim_key_raw: resolvedPrecomputedLifecycle?.claim_key_raw ?? claimKeyRaw,
-        claim_key_status: resolvedPrecomputedLifecycle?.claim_key_status,
-        claim_key_source: resolvedPrecomputedLifecycle?.claim_key_source,
-        claim_key_confidence: resolvedPrecomputedLifecycle?.claim_key_confidence,
-        claim_key_rationale: resolvedPrecomputedLifecycle?.claim_key_rationale,
-        claim_support_source_kind: resolvedPrecomputedLifecycle?.claim_support_source_kind ?? claimSupportSourceKind,
-        claim_support_locator: resolvedPrecomputedLifecycle?.claim_support_locator ?? claimSupportLocator,
-        claim_support_observed_at: resolvedPrecomputedLifecycle?.claim_support_observed_at ?? claimSupportObservedAt,
-        claim_support_mode: resolvedPrecomputedLifecycle?.claim_support_mode ?? claimSupportMode,
-        valid_from: temporalValidity.value.validFrom,
-        valid_to: temporalValidity.value.validTo
-      }
-    });
-  }
-  return {
-    valid,
-    rejected: errors.length,
-    rejectedInputIndexes,
-    errors,
-    warnings
-  };
-}
-function clampImportance(value) {
-  if (value === void 0) {
-    return 7;
-  }
-  return Math.min(10, Math.max(1, Math.round(value)));
-}
-function normalizeString(value) {
-  return value.trim();
-}
-function normalizeOptionalString(value) {
-  const normalized = value?.trim();
-  return normalized && normalized.length > 0 ? normalized : void 0;
-}
-function normalizeClaimSupportObservedAt(value, index, warnings) {
-  const normalized = normalizeOptionalString(value);
-  if (!normalized) {
-    return void 0;
-  }
-  if (!isIsoTimestamp(normalized)) {
-    warnings.push(`Entry ${index} provided invalid claim_support_observed_at ${JSON.stringify(value)} and it was dropped.`);
-    return void 0;
-  }
-  return normalized;
-}
-function normalizeClaimKeyStatus(value, index, warnings) {
-  const parsed = parseClaimKeyStatus(value);
-  if (parsed) {
-    return parsed;
-  }
-  if (value !== void 0) {
-    warnings.push(`Entry ${index} provided invalid claim_key_status ${JSON.stringify(value)} and it was dropped.`);
-  }
-  return void 0;
-}
-function normalizeClaimKeySource(value, index, warnings) {
-  const parsed = parseClaimKeySource(value);
-  if (parsed) {
-    return parsed;
-  }
-  if (value !== void 0) {
-    warnings.push(`Entry ${index} provided invalid claim_key_source ${JSON.stringify(value)} and it was dropped.`);
-  }
-  return void 0;
-}
-function normalizeClaimKeyConfidence(value, index, warnings) {
-  if (value === void 0) {
-    return void 0;
-  }
-  const parsed = parseClaimKeyConfidence(value);
-  if (parsed !== void 0) {
-    return parsed;
-  }
-  warnings.push(`Entry ${index} provided invalid claim_key_confidence ${JSON.stringify(value)} and it was dropped.`);
-  return void 0;
-}
-function normalizeClaimSupportMode(value, index, warnings) {
-  const parsed = parseClaimSupportMode(value);
-  if (parsed) {
-    return parsed;
-  }
-  warnings.push(`Entry ${index} provided invalid claim_support_mode ${JSON.stringify(value)} and it was dropped.`);
-  return void 0;
-}
-function areValidTags(value) {
-  return Array.isArray(value) && value.every((tag) => typeof tag === "string");
-}
-function 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 storeEntriesDetailed(inputs, db, embedding, options = {}) {
-  if (inputs.length === 0) {
-    return { stored: 0, skipped: 0, rejected: 0, details: [] };
-  }
-  const plan = await buildStorePlan(inputs, db);
-  for (const warning of plan.warnings) {
-    options.onWarning?.(warning);
-  }
-  if (plan.pendingEntries.length === 0) {
-    return {
-      stored: 0,
-      skipped: plan.skipped,
-      rejected: plan.rejected,
-      details: sortStoreDetails(plan.details)
-    };
-  }
-  if (options.dryRun === true) {
-    return {
-      stored: 0,
-      skipped: plan.skipped,
-      rejected: plan.rejected,
-      details: sortStoreDetails([
-        ...plan.details,
-        ...plan.pendingEntries.map((entry) => ({
-          inputIndex: entry.inputIndex,
-          outcome: "dry_run",
-          reason: "dry_run"
-        }))
-      ])
-    };
-  }
-  const pendingEntries = plan.pendingEntries;
-  const extractedClaimKeys = await maybeExtractClaimKeys(pendingEntries, options);
-  applyExtractedClaimKeyMetadata(pendingEntries, extractedClaimKeys);
-  const embeddings = await resolvePendingEmbeddings(inputs, pendingEntries, embedding, options.precomputedEmbeddings);
-  await persistEntries(db, pendingEntries, embeddings, extractedClaimKeys, options.claimExtraction?.config, options.onWarning);
-  return {
-    stored: pendingEntries.length,
-    skipped: plan.skipped,
-    rejected: plan.rejected,
-    details: sortStoreDetails([
-      ...plan.details,
-      ...pendingEntries.map((entry) => ({
-        inputIndex: entry.inputIndex,
-        outcome: "stored"
-      }))
-    ])
-  };
-}
-async function resolvePendingEmbeddings(inputs, entries, embedding, precomputedEmbeddings) {
-  if (!precomputedEmbeddings) {
-    return embedPendingEntries(entries, embedding);
-  }
-  if (precomputedEmbeddings.length !== inputs.length) {
-    throw new Error(`Precomputed embedding length mismatch: expected ${inputs.length}, received ${precomputedEmbeddings.length}.`);
-  }
-  return entries.map((entry) => {
-    const vector = precomputedEmbeddings[entry.inputIndex];
-    if (!vector) {
-      throw new Error(`Missing precomputed embedding for input index ${entry.inputIndex}.`);
-    }
-    return vector;
-  });
-}
-async function embedPendingEntries(entries, embedding) {
-  const texts = entries.map(({ input }) => composeEmbeddingText(input));
-  const vectors = await embedding.embed(texts);
-  if (vectors.length !== entries.length) {
-    throw new Error(`Embedding length mismatch: expected ${entries.length}, received ${vectors.length}.`);
-  }
-  return vectors;
-}
-async function persistEntries(db, preparedEntries, embeddings, extractedClaimKeys, claimExtractionConfig, onWarning) {
-  const writeBatch = async (targetDb) => {
-    let stored = 0;
-    const autoSupersessionPlans = await planAutoSupersession(targetDb, preparedEntries, extractedClaimKeys, claimExtractionConfig);
-    const emittedWarnings = /* @__PURE__ */ new Set();
-    for (const [index, preparedEntry] of preparedEntries.entries()) {
-      const embedding = embeddings[index] ?? [];
-      const entry = buildEntry(preparedEntry, embedding);
-      const entryId = await targetDb.insertEntry(entry, embedding, preparedEntry.contentHash);
-      const supersededEntryId = preparedEntry.input.supersedes;
-      if (supersededEntryId) {
-        const superseded = await targetDb.supersedeEntry(supersededEntryId, entryId, "update");
-        if (!superseded) {
-          onWarning?.(`Stored entry ${entryId} but could not supersede ${supersededEntryId} because the target was missing or inactive.`);
-        }
-      }
-      const autoSupersessionPlan = autoSupersessionPlans.get(preparedEntry.inputIndex);
-      if (autoSupersessionPlan?.kind === "link" && autoSupersessionPlan.oldEntryId) {
-        const superseded = await targetDb.supersedeEntry(autoSupersessionPlan.oldEntryId, entryId, "update");
-        if (!superseded) {
-          onWarning?.(
-            `Stored entry ${entryId} with claim_key "${preparedEntry.input.claim_key}" but could not auto-supersede ${autoSupersessionPlan.oldEntryId} because the target was missing or inactive.`
-          );
-        }
-      }
-      if (autoSupersessionPlan?.warning && !emittedWarnings.has(autoSupersessionPlan.warning)) {
-        emittedWarnings.add(autoSupersessionPlan.warning);
-        onWarning?.(autoSupersessionPlan.warning);
-      }
-      stored += 1;
-    }
-    return stored;
-  };
-  if (hasTransactionSupport(db) && preparedEntries.some((entry) => entry.input.supersedes !== void 0 || entry.input.claim_key !== void 0)) {
-    return db.withTransaction(writeBatch);
-  }
-  if (hasTransactionSupport(db) && preparedEntries.length > 1) {
-    return db.withTransaction(writeBatch);
-  }
-  return writeBatch(db);
-}
-function buildEntry(preparedEntry, embedding) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const acceptedClaimKey = preparedEntry.claimKey;
-  return {
-    id: randomUUID(),
-    type: preparedEntry.input.type,
-    subject: preparedEntry.input.subject,
-    content: preparedEntry.input.content,
-    importance: preparedEntry.input.importance ?? 7,
-    expiry: preparedEntry.input.expiry ?? "temporary",
-    tags: preparedEntry.input.tags ?? [],
-    source_file: preparedEntry.input.source_file,
-    source_context: preparedEntry.input.source_context,
-    user_id: preparedEntry.input.user_id,
-    project: preparedEntry.input.project,
-    embedding,
-    content_hash: preparedEntry.contentHash,
-    norm_content_hash: preparedEntry.normContentHash,
-    quality_score: 0.5,
-    recall_count: 0,
-    valid_from: preparedEntry.input.valid_from,
-    valid_to: preparedEntry.input.valid_to,
-    claim_key: acceptedClaimKey?.claim_key ?? preparedEntry.input.claim_key,
-    claim_key_raw: acceptedClaimKey?.claim_key_raw,
-    claim_key_status: acceptedClaimKey?.claim_key_status,
-    claim_key_source: acceptedClaimKey?.claim_key_source,
-    claim_key_confidence: acceptedClaimKey?.claim_key_confidence,
-    claim_key_rationale: acceptedClaimKey?.claim_key_rationale,
-    claim_support_source_kind: acceptedClaimKey?.claim_support_source_kind,
-    claim_support_locator: acceptedClaimKey?.claim_support_locator,
-    claim_support_observed_at: acceptedClaimKey?.claim_support_observed_at,
-    claim_support_mode: acceptedClaimKey?.claim_support_mode,
-    retired: false,
-    created_at: preparedEntry.input.created_at ?? now,
-    updated_at: now
-  };
-}
-async function maybeExtractClaimKeys(preparedEntries, options) {
-  const claimExtraction = options.claimExtraction;
-  if (!claimExtraction || preparedEntries.length === 0) {
-    return /* @__PURE__ */ new Map();
-  }
-  try {
-    const extractedEntries = await runBatchClaimExtraction(
-      [
-        {
-          entries: preparedEntries.map((preparedEntry) => preparedEntry.input)
-        }
-      ],
-      {
-        createLlm: () => claimExtraction.llm,
-        db: claimExtraction.db
-      },
-      claimExtraction.config,
-      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.findActiveEntriesByClaimKey(claimKey);
-  cache.set(claimKey, siblings);
-  return siblings;
-}
-function isAutoSupersessionEligible(claimKey, claimExtractionConfig) {
-  if (!claimKey || claimKey.claim_key_status !== "trusted") {
-    return false;
-  }
-  if (claimKey.claim_key_source === "manual") {
-    return true;
-  }
-  if (!AUTO_SUPERSESSION_ELIGIBLE_SOURCES.has(claimKey.claim_key_source) || !claimExtractionConfig) {
-    return false;
-  }
-  return claimKey.claim_key_confidence >= Math.max(claimExtractionConfig.confidenceThreshold, AUTO_SUPERSESSION_MIN_EXTRACTED_CONFIDENCE);
-}
-function buildAutoSupersessionEligibilityWarning(preparedEntry) {
-  const acceptedClaimKey = preparedEntry.claimKey;
-  const claimKey = acceptedClaimKey?.claim_key ?? preparedEntry.input.claim_key ?? "(missing)";
-  if (!acceptedClaimKey) {
-    return `Stored entry "${preparedEntry.input.subject}" with claim_key "${claimKey}" but skipped auto-supersession because the claim-key provenance was not explicit or a tracked high-confidence extraction.`;
-  }
-  if (acceptedClaimKey.claim_key_source === "manual") {
-    return `Stored entry "${preparedEntry.input.subject}" with claim_key "${claimKey}" but skipped auto-supersession because the claim-key provenance was not eligible for automatic linking.`;
-  }
-  if (acceptedClaimKey.claim_key_status !== "trusted") {
-    return `Stored entry "${preparedEntry.input.subject}" with claim_key "${claimKey}" but skipped auto-supersession because the accepted claim key is ${acceptedClaimKey.claim_key_status} from ${acceptedClaimKey.claim_key_source} at confidence ${acceptedClaimKey.claim_key_confidence.toFixed(2)}. Only explicit/manual claim keys or model-extracted keys at ${AUTO_SUPERSESSION_MIN_EXTRACTED_CONFIDENCE.toFixed(2)}+ auto-link.`;
-  }
-  return `Stored entry "${preparedEntry.input.subject}" with claim_key "${claimKey}" but skipped auto-supersession because the extracted claim key came from ${acceptedClaimKey.claim_key_source} at confidence ${acceptedClaimKey.claim_key_confidence.toFixed(2)}. Only explicit/manual claim keys or model-extracted keys at ${AUTO_SUPERSESSION_MIN_EXTRACTED_CONFIDENCE.toFixed(2)}+ auto-link.`;
-}
-function buildAutoSupersessionRuleWarning(preparedEntry, sibling, reason) {
-  if (reason === "type_mismatch") {
-    return `Stored entry "${preparedEntry.input.subject}" with claim_key "${preparedEntry.input.claim_key}" but skipped auto-supersession because the matching active entry is type "${sibling.type}" and the new entry is type "${preparedEntry.input.type}". ${describeSupersessionRuleFailure(reason)}`;
-  }
-  return `Stored entry "${preparedEntry.input.subject}" with claim_key "${preparedEntry.input.claim_key}" but skipped auto-supersession: ${describeSupersessionRuleFailure(reason)}`;
-}
-async function buildStorePlan(inputs, db) {
-  const validation = validateEntriesWithIndexes(inputs);
-  const details = validation.rejectedInputIndexes.map((inputIndex) => ({
-    inputIndex,
-    outcome: "rejected",
-    reason: "validation"
-  }));
-  const preparedEntries = validation.valid.map(({ input, inputIndex }) => ({
-    input,
-    inputIndex,
-    contentHash: computeContentHash(input.content, input.source_file),
-    normContentHash: computeNormContentHash(input.content),
-    claimKey: buildManualAcceptedClaimKey(inputs[inputIndex], input)
-  }));
-  const afterBatchContentHash = dedupePreparedEntries(preparedEntries, "contentHash", "content_hash", details);
-  const existingHashes = await db.findExistingHashes(afterBatchContentHash.map((entry) => entry.contentHash));
-  const afterExistingContentHash = filterExistingPreparedEntries(afterBatchContentHash, existingHashes, "contentHash", "content_hash", details);
-  const afterBatchNormHash = dedupePreparedEntries(afterExistingContentHash, "normContentHash", "norm_content_hash", details);
-  const existingNormHashes = await db.findExistingNormHashes(afterBatchNormHash.map((entry) => entry.normContentHash));
-  const pendingEntries = filterExistingPreparedEntries(afterBatchNormHash, existingNormHashes, "normContentHash", "norm_content_hash", details);
-  return {
-    pendingEntries,
-    skipped: details.filter((detail) => detail.outcome === "skipped").length,
-    rejected: validation.rejected,
-    details,
-    warnings: validation.warnings
-  };
-}
-function dedupePreparedEntries(entries, field, reason, details) {
-  const seen = /* @__PURE__ */ new Set();
-  const deduped = [];
-  for (const entry of entries) {
-    const key = entry[field];
-    if (seen.has(key)) {
-      details.push({
-        inputIndex: entry.inputIndex,
-        outcome: "skipped",
-        reason
-      });
-      continue;
-    }
-    seen.add(key);
-    deduped.push(entry);
-  }
-  return deduped;
-}
-function filterExistingPreparedEntries(entries, existing, field, reason, details) {
-  return entries.filter((entry) => {
-    if (!existing.has(entry[field])) {
-      return true;
-    }
-    details.push({
-      inputIndex: entry.inputIndex,
-      outcome: "skipped",
-      reason
-    });
-    return false;
-  });
-}
-function formatPipelineError(error) {
-  if (error instanceof Error) {
-    return error.message;
-  }
-  return String(error);
-}
-function sortStoreDetails(details) {
-  return [...details].sort((left, right) => left.inputIndex - right.inputIndex);
-}
-function buildManualAcceptedClaimKey(rawInput, normalizedInput) {
-  const canonicalClaimKey = normalizedInput.claim_key;
-  if (!canonicalClaimKey) {
-    return void 0;
-  }
-  const precomputedAcceptedClaimKey = buildPrecomputedClaimKeyLifecycle(normalizedInput);
-  if (precomputedAcceptedClaimKey) {
-    return precomputedAcceptedClaimKey;
-  }
-  if (rawInput && hasPrecomputedClaimKeyLifecycleFields(rawInput)) {
-    throw new Error("Store inputs with claim-key lifecycle metadata must provide a complete valid lifecycle bundle.");
-  }
-  return buildManualClaimKeyLifecycle({
-    claimKey: canonicalClaimKey,
-    rawClaimKey: normalizedInput.claim_key_raw ?? normalizeOptionalString2(rawInput?.claim_key),
-    supportSourceKind: normalizedInput.claim_support_source_kind,
-    supportLocator: normalizedInput.claim_support_locator,
-    supportObservedAt: normalizedInput.claim_support_observed_at,
-    supportMode: normalizedInput.claim_support_mode
-  });
-}
-function normalizeOptionalString2(value) {
-  const normalized = value?.trim();
-  return normalized && normalized.length > 0 ? normalized : void 0;
-}
-
 export {
   detectClaimKeyEntityFamilyCandidates,
   detectClaimKeySingletonAliasCandidates,
@@ -4042,7 +2399,7 @@ export {
   evaluateClaimKeyCompactness,
   normalizeGroundingTags,
   tokenizeGroundingText,
-  buildEntryLocalLexicalTokens,
+  buildDurableLocalLexicalTokens,
   applyClaimExtractionResultToEntry,
   previewClaimKeyExtraction,
   runBatchClaimExtraction,
@@ -4050,30 +2407,10 @@ export {
   describeSupersessionRuleFailure,
   computeContentHash,
   computeNormContentHash,
-  validateEntriesWithIndexes,
-  storeEntriesDetailed,
-  formatErrorMessage,
-  buildEntryMemoryResolverPorts,
-  resolveTargetEntry,
-  ENTRY_TYPE_DESCRIPTION,
-  EXPIRY_DESCRIPTION,
-  UPDATE_EXPIRY_DESCRIPTION,
-  RECALL_MODES,
-  asRecord,
-  parseExpiry,
-  parseEntryTypes,
-  parseEntryType,
-  parseRecallMode,
-  normalizeStringArray,
-  formatTargetSelector,
-  formatTargetSelectorFromParams,
-  sanitizeUpdateToolParams,
-  sanitizeFetchToolParams,
-  backfillEpisodeEmbeddings,
-  prepareEpisodeIngest,
-  ingestEpisodeTranscript,
-  executeEpisodeIngestPlan,
-  createEpisodeIngestPlan,
-  createSingleTranscriptDiscoveryPort,
-  createMemoryRepository
+  resolveDurableProjectScope,
+  tryAcquireDreamingRunLock,
+  withDreamingRunLock,
+  withHeldDreamingRunLock,
+  withEpisodeWriteGuard,
+  isEpisodeWriteInProgress
 };