@agenr/skeln-plugin 3.3.0 → 2026.6.2

package/dist/chunk-5AYIXQRF.js

@@ -0,0 +1,4452 @@
+import {
+  buildDreamEfficiencySummary
+} from "./chunk-GF3PX3VM.js";
+import {
+  buildDurableLocalLexicalTokens,
+  buildTrustedClaimKeySupportSeed,
+  computeContentHash,
+  computeNormContentHash,
+  detectClaimKeyEntityFamilyCandidates,
+  detectClaimKeySingletonAliasCandidates,
+  evaluateClaimKeyCompactness,
+  evaluateClaimKeySupport,
+  normalizeGroundingTags,
+  previewClaimKeyExtraction,
+  resolveDurableProjectScope,
+  tokenizeGroundingText,
+  validateSupersessionRules,
+  withDreamingRunLock
+} from "./chunk-SOQW7356.js";
+import {
+  DEFAULT_CLAIM_EXTRACTION_CONCURRENCY,
+  DEFAULT_DREAMING_DAILY_COST_CAP,
+  DEFAULT_DREAMING_EXTRACT_MAX_SESSIONS,
+  DEFAULT_DREAMING_LIGHT_MAX_SESSIONS,
+  DEFAULT_DREAMING_PRUNE_PROTECT_MIN_IMPORTANCE,
+  DEFAULT_DREAMING_PRUNE_PROTECT_RECALLED_DAYS,
+  MEMORY_DIRECTIVE_CLAIM_KEY_PREFIX,
+  applyClaimKeyLifecycle,
+  buildClaimKeyLifecycleAuditDetails,
+  buildClaimKeyLifecycleUpdateFields,
+  buildReconcileAppliedClaimKeyLifecycleBundle,
+  buildReconcileProposalClaimKeyAuditDetails,
+  buildReconcileProposalClaimKeyLifecycle,
+  buildReconcileProposalLifecycleRationale,
+  composeEmbeddingText,
+  defaultDirectiveTrigger,
+  normalizeMemoryDirectiveClaimKey,
+  parseDirectiveMetadata,
+  resolveClaimExtractionConfig,
+  resolveLocalFilesystemPath
+} from "./chunk-VTHBPXDQ.js";
+import {
+  compactClaimKey,
+  describeClaimKeyNormalizationFailure,
+  describeClaimKeySuspicion,
+  inspectClaimKey,
+  isCurrentlyValidMemory,
+  isStaleMemory,
+  isTrustedClaimKeyForCleanup,
+  normalizeClaimKey,
+  normalizeClaimKeySegment
+} from "./chunk-VBPYU7GO.js";
+import {
+  runDreamScan
+} from "./chunk-GKZQ5AG5.js";
+
+// src/app/dreaming/service.ts
+import { copyFile, mkdir } from "fs/promises";
+import path from "path";
+
+// src/core/dreaming/domain/tier-plan.ts
+function resolveTierStages(tier) {
+  switch (tier) {
+    case "light":
+      return {
+        runReconcile: false,
+        runPrune: false
+      };
+    case "standard":
+    case "deep":
+      return {
+        runReconcile: true,
+        runPrune: true
+      };
+  }
+}
+
+// src/app/dreaming/abort.ts
+var USER_ABORT_ERROR = "Run aborted by user (SIGINT).";
+function throwIfAborted(signal) {
+  if (signal?.aborted) {
+    throw new Error(USER_ABORT_ERROR);
+  }
+}
+
+// src/app/dreaming/extract.ts
+import { randomUUID } from "crypto";
+
+// src/core/ingestion/parser.ts
+var IMPORTANCE_TIER_MAP = {
+  high: 8,
+  standard: 6,
+  low: 4
+};
+var TYPE_ALIAS_MAP = {
+  fact: "fact",
+  facts: "fact",
+  decision: "decision",
+  decisions: "decision",
+  preference: "preference",
+  preferences: "preference",
+  lesson: "lesson",
+  lessons: "lesson",
+  event: "milestone",
+  events: "milestone",
+  milestone: "milestone",
+  milestones: "milestone",
+  relationship: "relationship",
+  relationships: "relationship",
+  directive: "directive",
+  directives: "directive"
+};
+var EXPIRY_ALIAS_MAP = {
+  permanent: "permanent",
+  perm: "permanent",
+  temporary: "temporary",
+  temp: "temporary",
+  core: "core"
+};
+var BLOCKED_SUBJECTS = /* @__PURE__ */ new Set([
+  "user",
+  "assistant",
+  "human",
+  "ai",
+  "bot",
+  "developer",
+  "engineer",
+  "maintainer",
+  "team",
+  "we",
+  "the conversation",
+  "this session",
+  "the transcript"
+]);
+function parseExtractionResponse(raw) {
+  const warnings = [];
+  const payload = coerceResponseObject(raw);
+  if (!payload) {
+    return {
+      entries: [],
+      warnings: ["Extraction response was not a valid JSON object."]
+    };
+  }
+  if (!Array.isArray(payload.durables)) {
+    return {
+      entries: [],
+      warnings: ['Extraction response must have a "durables" array.']
+    };
+  }
+  const entries = [];
+  for (const [index, value] of payload.durables.entries()) {
+    const entry = parseEntry(value, index, warnings);
+    if (entry) {
+      entries.push(entry);
+    }
+  }
+  return { entries, warnings };
+}
+function coerceResponseObject(raw) {
+  if (typeof raw === "string") {
+    try {
+      const parsed = JSON.parse(stripCodeFence(raw));
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return parsed;
+      }
+    } catch {
+      return null;
+    }
+  }
+  if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+    return raw;
+  }
+  return null;
+}
+function parseEntry(value, index, warnings) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    warnings.push(`Dropped entry ${index + 1}: entry must be an object.`);
+    return null;
+  }
+  const record = value;
+  const type = coerceType(record.type);
+  if (!type) {
+    warnings.push(`Dropped entry ${index + 1}: invalid type.`);
+    return null;
+  }
+  const subject = normalizeString(record.subject);
+  if (!subject) {
+    warnings.push(`Dropped entry ${index + 1}: subject is required.`);
+    return null;
+  }
+  if (BLOCKED_SUBJECTS.has(subject.toLowerCase())) {
+    warnings.push(`Dropped entry ${index + 1}: subject "${subject}" is blocked.`);
+    return null;
+  }
+  const content = normalizeString(record.content);
+  if (!content) {
+    warnings.push(`Dropped entry ${index + 1}: content is required.`);
+    return null;
+  }
+  if (content.length < 20) {
+    warnings.push(`Dropped entry ${index + 1}: content must be at least 20 characters.`);
+    return null;
+  }
+  const expiry = coerceExpiry(record.expiry, type, index, warnings);
+  const sourceContext = coerceOptionalString(record.source_context);
+  const claimKey = coerceClaimKey(record.claim_key ?? record.claimKey, type, index, warnings);
+  const directivePolarity = coerceDirectivePolarity(record.directive_polarity ?? record.polarity, type, index, warnings);
+  const directiveTrigger = coerceDirectiveTrigger(record.directive_trigger ?? record.trigger, type, directivePolarity, index, warnings);
+  const sourceFile = coerceOptionalString(record.source_file ?? record.sourceFile);
+  const userId = coerceOptionalString(record.user_id ?? record.userId);
+  const project = coerceOptionalString(record.project);
+  if (type === "directive") {
+    if (!directivePolarity) {
+      warnings.push(`Dropped entry ${index + 1}: directive entries require directive_polarity.`);
+      return null;
+    }
+    if (!claimKey?.claimKey.startsWith(MEMORY_DIRECTIVE_CLAIM_KEY_PREFIX)) {
+      warnings.push(`Dropped entry ${index + 1}: directive entries require claim_key prefix ${MEMORY_DIRECTIVE_CLAIM_KEY_PREFIX}.`);
+      return null;
+    }
+  }
+  return {
+    type,
+    subject,
+    content,
+    importance: coerceImportance(record.importance),
+    expiry,
+    tags: coerceTags(record.tags),
+    source_file: sourceFile,
+    claim_key: claimKey?.claimKey,
+    claim_key_raw: claimKey?.rawClaimKey,
+    directive_polarity: directivePolarity,
+    directive_trigger: directiveTrigger,
+    source_context: sourceContext,
+    user_id: userId,
+    project
+  };
+}
+function coerceType(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  return TYPE_ALIAS_MAP[normalizeToken(value)] ?? null;
+}
+function coerceImportance(value) {
+  if (typeof value === "number" && Number.isInteger(value) && value >= 1 && value <= 10) {
+    return value;
+  }
+  if (typeof value === "string") {
+    const normalized = normalizeToken(value);
+    const mappedTier = IMPORTANCE_TIER_MAP[normalized];
+    if (mappedTier !== void 0) {
+      return mappedTier;
+    }
+    const parsed = Number(normalized);
+    if (Number.isInteger(parsed) && parsed >= 1 && parsed <= 10) {
+      return parsed;
+    }
+  }
+  return 6;
+}
+function coerceExpiry(value, type, index, warnings) {
+  if (typeof value !== "string") {
+    return type === "directive" ? "core" : "temporary";
+  }
+  const normalized = EXPIRY_ALIAS_MAP[normalizeToken(value)];
+  if (!normalized) {
+    return "temporary";
+  }
+  if (normalized === "core" && type !== "directive") {
+    warnings.push(`Entry ${index + 1}: expiry "core" is reserved and was changed to "temporary".`);
+    return "temporary";
+  }
+  return normalized;
+}
+function coerceDirectivePolarity(value, type, index, warnings) {
+  if (type !== "directive") {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    warnings.push(`Entry ${index + 1}: directive_polarity is required for directive entries.`);
+    return void 0;
+  }
+  const normalized = normalizeToken(value);
+  if (normalized === "abstain" || normalized === "proactive") {
+    return normalized;
+  }
+  warnings.push(`Entry ${index + 1}: dropped invalid directive_polarity ${JSON.stringify(value)}.`);
+  return void 0;
+}
+function coerceDirectiveTrigger(value, type, polarity, index, warnings) {
+  if (type !== "directive") {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    return polarity ? defaultDirectiveTrigger(polarity) : void 0;
+  }
+  const normalized = normalizeToken(value);
+  if (normalized === "session_start" || normalized === "always") {
+    return normalized;
+  }
+  if (normalized.startsWith("topic:") && normalized.slice("topic:".length).trim().length > 0) {
+    return `topic:${normalizeWhitespace(normalized.slice("topic:".length))}`;
+  }
+  warnings.push(`Entry ${index + 1}: dropped invalid directive_trigger ${JSON.stringify(value)}.`);
+  return void 0;
+}
+function coerceTags(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const unique = /* @__PURE__ */ new Set();
+  for (const tag of value) {
+    if (typeof tag !== "string") {
+      continue;
+    }
+    const normalized = normalizeToken(tag);
+    if (!normalized) {
+      continue;
+    }
+    unique.add(normalized);
+    if (unique.size === 4) {
+      break;
+    }
+  }
+  return Array.from(unique);
+}
+function coerceOptionalString(value) {
+  if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
+    return void 0;
+  }
+  const normalized = normalizeWhitespace(String(value));
+  return normalized.length > 0 ? normalized : void 0;
+}
+function coerceClaimKey(value, type, index, warnings) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const rawClaimKey = coerceOptionalString(value);
+  if (!rawClaimKey) {
+    return void 0;
+  }
+  if (type === "directive") {
+    const directiveClaimKey = normalizeMemoryDirectiveClaimKey(rawClaimKey);
+    if (directiveClaimKey) {
+      return {
+        claimKey: directiveClaimKey,
+        rawClaimKey: rawClaimKey !== directiveClaimKey ? rawClaimKey : void 0
+      };
+    }
+    warnings.push(`Entry ${index + 1}: dropped directive claim_key ${JSON.stringify(value)} because it must use ${MEMORY_DIRECTIVE_CLAIM_KEY_PREFIX}<name>.`);
+    return void 0;
+  }
+  const normalized = normalizeClaimKey(rawClaimKey);
+  if (normalized.ok) {
+    return {
+      claimKey: normalized.value.claimKey,
+      rawClaimKey: rawClaimKey !== normalized.value.claimKey ? rawClaimKey : void 0
+    };
+  }
+  warnings.push(`Entry ${index + 1}: dropped claim_key ${JSON.stringify(value)} because ${describeClaimKeyNormalizationFailure(normalized.reason)}.`);
+  return void 0;
+}
+function normalizeString(value) {
+  return typeof value === "string" ? normalizeWhitespace(value) : "";
+}
+function normalizeWhitespace(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function normalizeToken(value) {
+  return normalizeWhitespace(value).toLowerCase();
+}
+function stripCodeFence(text) {
+  const trimmed = text.trim();
+  const match = /^```(?:json)?\s*([\s\S]+?)\s*```$/i.exec(trimmed);
+  return match?.[1]?.trim() ?? trimmed;
+}
+
+// src/core/dreaming/prompts.ts
+var GOOD_EPISODE_EXAMPLE = `{
+  "type": "preference",
+  "subject": "communication style preference",
+  "content": "Jim prefers terse responses with an explain-first approach when debugging unfamiliar systems.",
+  "importance": "standard",
+  "expiry": "permanent",
+  "tags": ["communication", "style"],
+  "source_context": "User stated response preferences during a personal onboarding session.",
+  "claim_key": "jim/communication_style"
+}`;
+var BAD_EPISODE_PROJECT_SCOPE = `BAD:
+{
+  "type": "fact",
+  "subject": "jim birthday",
+  "content": "Jim Martin is 49 years old and his birthday is March 15.",
+  "importance": "high",
+  "expiry": "permanent",
+  "tags": ["family", "personal"],
+  "source_context": "User shared family details during casual conversation.",
+  "claim_key": "jim/birthday",
+  "project": "skeln"
+}
+WHY: Personal family facts are cross-workspace knowledge. Do not tag them with the session workspace just because the chat happened inside one repo.`;
+var BAD_EPISODE_META = `BAD:
+{
+  "type": "fact",
+  "subject": "this session",
+  "content": "The session focused on establishing personal facts and preferences for future recall.",
+  "importance": "standard",
+  "expiry": "temporary",
+  "tags": ["session"]
+}
+WHY: Episode summaries are already meta-narration. Extract only durable facts, preferences, and rules the summary affirms as knowledge.`;
+var EMPTY_EXAMPLE = `If nothing qualifies, return exactly:
+{"durables":[]}`;
+function buildDreamExtractSystemPrompt(options = {}) {
+  const dateString = options.currentDate ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  return [
+    "You are a selective memory synthesis engine for dreaming maintenance.",
+    "",
+    `Current date: ${dateString}.`,
+    "",
+    "Input is a condensed episode summary, not a raw transcript. The summary already collapsed tool chatter,",
+    "debugging steps, and session narration. Extract only durable knowledge the summary still affirms as",
+    "long-term memory.",
+    "",
+    "Default action: SKIP. Most episode summaries should produce zero entries.",
+    "",
+    "## Types",
+    "",
+    "- fact: Verified descriptive information about a person, project, system, or concept.",
+    "- decision: A standing rule, requirement, convention, or durable constraint on future behavior.",
+    "- preference: A stated preference, opinion, or value that should influence future behavior.",
+    "- lesson: A non-obvious insight from a specific experience, not generic advice.",
+    "- milestone: A significant one-time transition, launch, or life/project moment.",
+    "- relationship: A connection between named entities or people.",
+    "- directive: A memory-behavior instruction about what to suppress or proactively surface.",
+    "",
+    "## Claim Keys",
+    "",
+    "- Include `claim_key` on every non-directive entry unless the summary gives no stable entity anchor.",
+    "- Use canonical `entity/attribute` form: lowercase snake_case segments separated by `/`.",
+    "- Prefer person- or project-scoped entities when the summary names them (`jim/timezone`, `agenr/package_manager`).",
+    "- For directive entries, use `user/memory_directive/<name>`.",
+    "- If the summary quotes an explicit tool-call claim key, preserve that raw value in `claim_key`.",
+    "- Do not emit malformed keys with spaces, mixed casing, or more than four segments.",
+    "",
+    "## Provenance",
+    "",
+    "- Every entry must include `source_context`: one sentence, max 20 words, describing what evidence in the summary supports the durable.",
+    "",
+    "## Project Scope",
+    "",
+    "- `project` tags knowledge *about* a workspace or product, not the workspace where the chat happened.",
+    "- Omit `project` for personal, family, health, preference, and other facts that should follow the user across workspaces.",
+    "- Include `project` only when the durable is specifically about one repo, codebase, deployment, or product surface.",
+    "- A session may include a workspace hint for context. Treat it as a hint, not a default stamp for every entry.",
+    '- Claim keys like `agenr/release_policy` may justify `project: "agenr"`; claim keys like `jim/birthday` should stay unscoped.',
+    "",
+    "## Importance And Expiry",
+    "",
+    '- Rate importance as "high", "standard", or "low". Standard is the default.',
+    '- Use expiry "permanent" for biographical facts, preferences, and standing rules.',
+    '- Use expiry "temporary" for active project state and time-bounded context.',
+    '- Extraction assigns "core" only for directive entries.',
+    "",
+    "## Directive Fields",
+    "",
+    "- Directive entries require `claim_key`, `directive_polarity`, and usually `directive_trigger`.",
+    "",
+    "## Already Stored In Session",
+    "",
+    "- The user prompt may list durables already written live through `agenr_store` during this session.",
+    "- Do not emit another entry for the same underlying knowledge, even when the episode summary paraphrases it.",
+    "- Omit covered facts entirely instead of restating them with a new subject, claim key, or wording.",
+    "- When a genuinely new fact remains, emit only that new fact.",
+    "- If you must reference an already-stored claim key family, reuse the exact existing `claim_key` rather than inventing a synonym.",
+    "",
+    "## Anti-Patterns",
+    "",
+    "- Session summaries, progress narration, or duplicate paraphrases of the same fact.",
+    "- Generic advice that could appear in any tutorial.",
+    "- Facts the summary only mentions as recalled context without independent affirmation.",
+    "",
+    "## Calibration",
+    "",
+    "- Typical good output per episode summary: 0-4 entries.",
+    "- Hard maximum: 6 entries. Reaching the cap usually means over-extraction.",
+    "- One grounded entry beats three near-duplicates.",
+    "",
+    "## Output",
+    "",
+    'Return JSON only: {"durables":[...]}',
+    'Use {"durables":[]} when nothing qualifies.',
+    "",
+    "Each entry must have:",
+    '{ "type": "fact|decision|preference|lesson|relationship|milestone|directive", "subject": "2-6 word topic noun phrase", "content": "specific declarative statement, min 20 chars", "importance": "high|standard|low", "expiry": "permanent|temporary|core", "tags": ["1-4", "lowercase", "tags"], "source_context": "one sentence, max 20 words", "claim_key": "entity/attribute" }',
+    'Optional: { "project": "workspace-name" } only when the durable is workspace-specific knowledge.',
+    "Directive entries also require `directive_polarity` and `directive_trigger` when applicable.",
+    "",
+    "GOOD:",
+    GOOD_EPISODE_EXAMPLE,
+    "",
+    BAD_EPISODE_PROJECT_SCOPE,
+    "",
+    BAD_EPISODE_META,
+    "",
+    EMPTY_EXAMPLE
+  ].join("\n");
+}
+function buildDreamExtractChunkPrompt(chunk, options = {}) {
+  const sections = ["Episode summary to mine for durable knowledge:"];
+  const sessionWorkspace = options.sessionWorkspace?.trim();
+  if (sessionWorkspace) {
+    sections.push(
+      "",
+      `Session workspace context: ${sessionWorkspace}`,
+      "This names where the conversation happened. Do not default every durable to this project.",
+      "Tag `project` only when the knowledge itself is about that workspace."
+    );
+  }
+  if (options.existingSessionDurables && options.existingSessionDurables.length > 0) {
+    sections.push(
+      "",
+      "Already stored live during this session (do not duplicate or paraphrase):",
+      ...options.existingSessionDurables.map(
+        (durable) => `- [${durable.type}] ${durable.subject}: ${durable.content}${durable.claimKey ? ` (claim_key: ${durable.claimKey})` : ""}`
+      ),
+      "",
+      "Emit only durable knowledge from the summary that is not already covered above."
+    );
+  }
+  sections.push("---", chunk.text, "---", "", "Return JSON only. No markdown fences, no commentary, and no extra keys.");
+  return sections.join("\n");
+}
+
+// src/core/dreaming/extract.ts
+var MAX_ATTEMPTS = 3;
+async function extractFromEpisodeSummary(transcript, llm, options = {}) {
+  if (transcript.messages.length === 0) {
+    return {
+      entries: [],
+      chunks: 0,
+      successfulChunks: 0,
+      failedChunks: 0,
+      chunkDetails: [],
+      warnings: []
+    };
+  }
+  const chunk = buildSummaryChunk(transcript);
+  const systemPrompt = buildDreamExtractSystemPrompt();
+  const observedAt = transcript.metadata.endedAt ?? transcript.metadata.startedAt;
+  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt += 1) {
+    try {
+      const raw = await llm.completeJson(
+        systemPrompt,
+        buildDreamExtractChunkPrompt(chunk, {
+          sessionWorkspace: options.sessionWorkspace ?? transcript.metadata.project,
+          existingSessionDurables: options.existingSessionDurables
+        })
+      );
+      const parsed = parseExtractionResponse(raw);
+      if (observedAt) {
+        for (const entry of parsed.entries) {
+          entry.created_at = observedAt;
+        }
+      }
+      return {
+        entries: parsed.entries,
+        chunks: 1,
+        successfulChunks: 1,
+        failedChunks: 0,
+        chunkDetails: [{ chunkIndex: 0, messageRange: chunk.message_range, success: true }],
+        warnings: parsed.warnings
+      };
+    } catch {
+      if (attempt === MAX_ATTEMPTS) {
+        return {
+          entries: [],
+          chunks: 1,
+          successfulChunks: 0,
+          failedChunks: 1,
+          chunkDetails: [{ chunkIndex: 0, messageRange: chunk.message_range, success: false }],
+          warnings: [`Episode summary extraction failed after ${MAX_ATTEMPTS} attempts.`]
+        };
+      }
+      await sleep(backoffMs(attempt));
+    }
+  }
+  return {
+    entries: [],
+    chunks: 1,
+    successfulChunks: 0,
+    failedChunks: 1,
+    chunkDetails: [{ chunkIndex: 0, messageRange: chunk.message_range, success: false }],
+    warnings: ["Episode summary extraction failed."]
+  };
+}
+function buildSummaryChunk(transcript) {
+  const message = transcript.messages[0];
+  return {
+    chunk_index: 0,
+    message_range: [message?.index ?? 0, message?.index ?? 0],
+    text: message?.text ?? ""
+  };
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function backoffMs(attempt) {
+  return Math.min(1e3, 100 * 2 ** (attempt - 1));
+}
+
+// src/core/dreaming/session-store-context.ts
+function toDreamSessionStoreDurables(durables) {
+  return durables.map((durable) => ({
+    type: durable.type,
+    subject: durable.subject,
+    content: durable.content,
+    claimKey: durable.claim_key?.trim() ? durable.claim_key : null,
+    normContentHash: durable.norm_content_hash?.trim() || computeNormContentHash(durable.content)
+  }));
+}
+function buildDreamSessionStoreContext(durables) {
+  const claimKeys = /* @__PURE__ */ new Set();
+  const normContentHashes = /* @__PURE__ */ new Set();
+  for (const durable of durables) {
+    normContentHashes.add(durable.normContentHash);
+    if (durable.claimKey) {
+      claimKeys.add(durable.claimKey);
+    }
+  }
+  return { claimKeys, normContentHashes };
+}
+
+// src/app/dreaming/extract.ts
+var DEFAULT_CANDIDATE_IMPORTANCE = 5;
+async function runExtractStage(options, deps) {
+  const emptyUsage = { inputTokens: 0, outputTokens: 0, estimatedCostUsd: 0 };
+  const emptySummary = {
+    episodesScanned: 0,
+    candidatesEmitted: 0,
+    newCandidates: 0,
+    refineCandidates: 0,
+    knownCandidates: 0,
+    durablesInserted: 0
+  };
+  if (!deps.createExtractLlm) {
+    return { status: "completed", candidates: [], summary: emptySummary, usage: emptyUsage, warnings: [] };
+  }
+  const since = await resolveExtractSince(deps.port, options.fullBacklog === true);
+  const episodes = await deps.port.listEpisodeEvidenceSince(since, {
+    ...options.project ? { project: options.project } : {},
+    limit: options.maxEpisodes
+  });
+  if (episodes.length === 0) {
+    return { status: "completed", candidates: [], summary: emptySummary, usage: emptyUsage, warnings: [] };
+  }
+  const llm = deps.createExtractLlm();
+  const mined = [];
+  const warnings = [];
+  let episodesScanned = 0;
+  let status = "completed";
+  for (const episode of episodes) {
+    throwIfAborted(options.signal);
+    if (readUsage(llm).estimatedCostUsd >= options.costCapUsd) {
+      status = "cost_capped";
+      break;
+    }
+    const episodeWindowEnd = episode.endedAt ?? options.now().toISOString();
+    const existingSessionDurables = episode.sessionId !== null ? toDreamSessionStoreDurables(await deps.port.listSessionHostStoreDurables(episode.sessionId, episode.startedAt, episodeWindowEnd)) : [];
+    const transcript = buildEpisodeTranscript(episode);
+    const extraction = await extractFromEpisodeSummary(transcript, llm, {
+      sessionWorkspace: episode.project,
+      existingSessionDurables
+    });
+    episodesScanned += 1;
+    warnings.push(...extraction.warnings.map((warning) => `Episode ${episode.id}: ${warning}`));
+    if (readUsage(llm).estimatedCostUsd >= options.costCapUsd) {
+      status = "cost_capped";
+    }
+    for (const entry of extraction.entries) {
+      mined.push(toMinedCandidate(entry, episode));
+    }
+    if (status === "cost_capped") {
+      break;
+    }
+  }
+  const candidates = await classifyCandidates(mined, {
+    port: deps.port,
+    contextLookupEnabled: options.contextLookupEnabled
+  });
+  const summary = {
+    episodesScanned,
+    candidatesEmitted: candidates.length,
+    newCandidates: candidates.filter((candidate) => candidate.disposition === "new").length,
+    refineCandidates: candidates.filter((candidate) => candidate.disposition === "refines").length,
+    knownCandidates: candidates.filter((candidate) => candidate.disposition === "known").length,
+    durablesInserted: 0
+  };
+  return { status, candidates, summary, usage: readUsage(llm), warnings };
+}
+async function applyExtractedDurables(input, deps) {
+  const createdAt = input.now().toISOString();
+  const prepared = input.candidates.filter((candidate) => candidate.disposition === "new").map((candidate) => ({
+    candidate,
+    durable: buildDurableFromCandidate(candidate, {
+      claimKeySource: "dreaming_extract",
+      claimKeyStatus: "tentative",
+      claimKeyConfidence: 0.5,
+      claimKeyRationale: "Mined from episode evidence during dreaming extract.",
+      createdAt
+    })
+  }));
+  if (prepared.length === 0) {
+    return { inserted: 0 };
+  }
+  const embeddings = await deps.embedding.embed(prepared.map(({ durable }) => composeEmbeddingText(durable)));
+  await deps.port.withTransaction(async (tx) => {
+    for (const [index, { candidate, durable }] of prepared.entries()) {
+      const contentHash = durable.content_hash ?? computeContentHash(durable.content, durable.source_file);
+      await tx.insertDurable(durable, embeddings[index] ?? [], contentHash);
+      await tx.logRunAction({
+        id: randomUUID(),
+        runId: input.runId,
+        actionType: "insert_durable",
+        durableIds: [durable.id],
+        reasoning: "Inserted durable mined from episode evidence.",
+        details: {
+          claim_key: candidate.claimKey,
+          evidence_refs: candidate.evidenceRefs.map((ref) => `${ref.kind}:${ref.locator}`)
+        },
+        createdAt
+      });
+    }
+  });
+  return { inserted: prepared.length };
+}
+async function classifyCandidates(mined, deps) {
+  if (mined.length === 0) {
+    return [];
+  }
+  const normHashByIndex = mined.map((candidate) => computeNormContentHash(candidate.content));
+  const existingNormHashes = await deps.port.findExistingNormContentHashes(normHashByIndex);
+  const seenNormHashes = new Set(existingNormHashes);
+  const sessionContextByWindow = /* @__PURE__ */ new Map();
+  const candidates = [];
+  for (const [index, candidate] of mined.entries()) {
+    const normHash = normHashByIndex[index] ?? computeNormContentHash(candidate.content);
+    let disposition = "new";
+    let refinesDurableId = null;
+    if (seenNormHashes.has(normHash)) {
+      disposition = "known";
+    } else if (candidate.sessionId) {
+      const sessionContext = await loadSessionStoreContext(candidate, deps.port, sessionContextByWindow);
+      if (sessionContext.normContentHashes.has(normHash)) {
+        disposition = "known";
+      } else if (candidate.claimKey && sessionContext.claimKeys.has(candidate.claimKey)) {
+        disposition = "known";
+      }
+    }
+    if (disposition === "new" && deps.contextLookupEnabled && candidate.claimKey) {
+      const family = await deps.port.findActiveDurablesByClaimKey(candidate.claimKey);
+      const active = family[0];
+      if (active) {
+        disposition = "refines";
+        refinesDurableId = active.id;
+      }
+    }
+    if (disposition !== "known") {
+      seenNormHashes.add(normHash);
+    }
+    candidates.push({
+      id: randomUUID(),
+      type: candidate.type,
+      subject: candidate.subject,
+      content: candidate.content,
+      importance: candidate.importance,
+      expiry: candidate.expiry,
+      tags: candidate.tags,
+      ...candidate.directivePolarity ? { directivePolarity: candidate.directivePolarity } : {},
+      ...candidate.directiveTrigger ? { directiveTrigger: candidate.directiveTrigger } : {},
+      claimKey: candidate.claimKey,
+      trust: "tentative",
+      disposition,
+      refinesDurableId,
+      evidenceRefs: candidate.evidenceRefs,
+      sourceFile: candidate.sourceFile,
+      ...candidate.sourceContext ? { sourceContext: candidate.sourceContext } : {},
+      ...candidate.project ? { project: candidate.project } : {},
+      validFrom: candidate.validFrom
+    });
+  }
+  return candidates;
+}
+function buildDurableFromCandidate(candidate, lifecycle) {
+  const sourceFile = candidate.sourceFile;
+  const contentHash = computeContentHash(candidate.content, sourceFile);
+  const normContentHash = computeNormContentHash(candidate.content);
+  const claimKey = lifecycle.claimKeyOverride !== void 0 ? lifecycle.claimKeyOverride : candidate.claimKey;
+  const primaryEvidence = candidate.evidenceRefs[0];
+  const validFrom = lifecycle.validFrom ?? candidate.validFrom;
+  const durable = {
+    id: lifecycle.id ?? candidate.id,
+    type: candidate.type,
+    subject: candidate.subject,
+    content: candidate.content,
+    importance: candidate.importance,
+    expiry: candidate.expiry,
+    tags: candidate.tags,
+    directive_polarity: candidate.directivePolarity,
+    directive_trigger: candidate.directiveTrigger,
+    quality_score: 0.5,
+    recall_count: 0,
+    content_hash: contentHash,
+    norm_content_hash: normContentHash,
+    created_at: lifecycle.createdAt,
+    updated_at: lifecycle.createdAt,
+    source_file: sourceFile
+  };
+  if (candidate.sourceContext) {
+    durable.source_context = candidate.sourceContext;
+  }
+  if (candidate.project) {
+    durable.project = candidate.project;
+  }
+  if (validFrom) {
+    durable.valid_from = validFrom;
+  }
+  durable.claim_support_source_kind = primaryEvidence?.kind ?? "episode";
+  if (primaryEvidence?.locator) {
+    durable.claim_support_locator = primaryEvidence.locator;
+  }
+  if (primaryEvidence?.observedAt) {
+    durable.claim_support_observed_at = primaryEvidence.observedAt;
+  }
+  durable.claim_support_mode = "inferred";
+  if (claimKey) {
+    durable.claim_key = claimKey;
+    durable.claim_key_raw = claimKey;
+    durable.claim_key_status = lifecycle.claimKeyStatus;
+    durable.claim_key_source = lifecycle.claimKeySource;
+    durable.claim_key_confidence = lifecycle.claimKeyConfidence;
+    durable.claim_key_rationale = lifecycle.claimKeyRationale;
+  }
+  return durable;
+}
+async function resolveExtractSince(port, fullBacklog) {
+  if (fullBacklog) {
+    return "1970-01-01T00:00:00.000Z";
+  }
+  const lastRun = await port.getLastRun();
+  const lastSuccessfulAt = lastRun?.status === "completed" ? lastRun.completedAt : null;
+  return lastSuccessfulAt ?? "1970-01-01T00:00:00.000Z";
+}
+function buildEpisodeTranscript(episode) {
+  return {
+    messages: [
+      {
+        index: 0,
+        role: "assistant",
+        text: episode.summary,
+        timestamp: episode.endedAt ?? episode.startedAt
+      }
+    ],
+    metadata: {
+      messageCount: 1,
+      transcriptHash: episode.id,
+      startedAt: episode.startedAt,
+      ...episode.endedAt ? { endedAt: episode.endedAt } : {},
+      ...episode.sessionId ? { sessionId: episode.sessionId } : {},
+      ...episode.project ? { project: episode.project } : {}
+    },
+    warnings: []
+  };
+}
+function toMinedCandidate(entry, episode) {
+  const observedAt = episode.endedAt ?? episode.startedAt;
+  const project = resolveDurableProjectScope(
+    {
+      project: entry.project,
+      subject: entry.subject,
+      content: entry.content,
+      tags: entry.tags ?? [],
+      source_context: entry.source_context,
+      claim_key: entry.claim_key
+    },
+    { sessionWorkspace: episode.project }
+  );
+  return {
+    type: entry.type,
+    subject: entry.subject,
+    content: entry.content,
+    importance: typeof entry.importance === "number" ? entry.importance : DEFAULT_CANDIDATE_IMPORTANCE,
+    expiry: entry.expiry ?? "permanent",
+    tags: entry.tags ?? [],
+    directivePolarity: entry.directive_polarity,
+    directiveTrigger: entry.directive_trigger,
+    claimKey: normalizeCandidateClaimKey(entry.claim_key),
+    evidenceRefs: [
+      {
+        kind: "episode",
+        locator: episode.id,
+        observedAt
+      }
+    ],
+    sessionId: episode.sessionId,
+    episodeStartedAt: episode.startedAt,
+    episodeEndedAt: observedAt,
+    sourceFile: buildEpisodeSourceFile(episode),
+    ...entry.source_context ? { sourceContext: entry.source_context } : {},
+    ...project ? { project } : {},
+    validFrom: observedAt
+  };
+}
+function buildEpisodeSourceFile(episode) {
+  if (episode.sessionId) {
+    return `episode-session:${episode.sessionId}:${episode.id}`;
+  }
+  return `episode:${episode.id}`;
+}
+async function loadSessionStoreContext(candidate, port, cache) {
+  const sessionId = candidate.sessionId?.trim();
+  if (!sessionId) {
+    return { claimKeys: /* @__PURE__ */ new Set(), normContentHashes: /* @__PURE__ */ new Set() };
+  }
+  const cacheKey = `${sessionId}:${candidate.episodeStartedAt}:${candidate.episodeEndedAt}`;
+  const cached = cache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+  const durables = await port.listSessionHostStoreDurables(sessionId, candidate.episodeStartedAt, candidate.episodeEndedAt);
+  const resolved = buildDreamSessionStoreContext(toDreamSessionStoreDurables(durables));
+  cache.set(cacheKey, resolved);
+  return resolved;
+}
+function normalizeCandidateClaimKey(rawClaimKey) {
+  if (!rawClaimKey) {
+    return null;
+  }
+  const normalized = normalizeClaimKey(rawClaimKey);
+  return normalized.ok ? normalized.value.claimKey : null;
+}
+function readUsage(llm) {
+  const usage = llm.metadata?.usage;
+  return {
+    inputTokens: usage?.inputTokens ?? 0,
+    outputTokens: usage?.outputTokens ?? 0,
+    estimatedCostUsd: usage?.totalCost ?? 0
+  };
+}
+
+// src/app/dreaming/progress.ts
+function emitDreamProgress(reporter, event) {
+  if (!reporter) {
+    return;
+  }
+  try {
+    reporter(event);
+  } catch {
+  }
+}
+
+// src/app/dreaming/prune.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/core/dreaming/domain/stale-candidate-policy.ts
+var STATUS_ARTIFACT_SUBJECT_HINTS = ["session handoff", "status update", "progress snapshot", "session summary", "next steps", "in progress"];
+function isActionableStaleCandidate(candidate) {
+  return candidate.expiry === "temporary" || candidate.type === "milestone" && (candidate.importance <= 6 || candidate.expiry === "permanent") || candidate.type === "fact" && candidate.importance <= 5 && candidate.recallCount === 0;
+}
+function compareStaleCandidates(left, right) {
+  const tierDelta = getStaleCandidatePriorityTier(left) - getStaleCandidatePriorityTier(right);
+  if (tierDelta !== 0) {
+    return tierDelta;
+  }
+  const leftNeverRecalled = left.recallCount === 0;
+  const rightNeverRecalled = right.recallCount === 0;
+  if (leftNeverRecalled !== rightNeverRecalled) {
+    return leftNeverRecalled ? -1 : 1;
+  }
+  const createdDelta = parseTimestamp(left.createdAt) - parseTimestamp(right.createdAt);
+  if (createdDelta !== 0) {
+    return createdDelta;
+  }
+  if (left.importance !== right.importance) {
+    return left.importance - right.importance;
+  }
+  const updatedDelta = left.updatedAt.localeCompare(right.updatedAt);
+  if (updatedDelta !== 0) {
+    return updatedDelta;
+  }
+  return left.id.localeCompare(right.id);
+}
+function looksLikeStaleStatusArtifact(subject) {
+  const normalized = subject.trim().toLowerCase();
+  return normalized.startsWith("handoff") || STATUS_ARTIFACT_SUBJECT_HINTS.some((hint) => normalized.includes(hint));
+}
+function getStaleCandidatePriorityTier(candidate) {
+  if (candidate.expiry === "temporary") {
+    return 0;
+  }
+  if (candidate.type === "milestone" && candidate.importance <= 4) {
+    return 1;
+  }
+  if (looksLikeStaleStatusArtifact(candidate.subject)) {
+    return 2;
+  }
+  return 3;
+}
+function parseTimestamp(value) {
+  const timestamp = Date.parse(value);
+  return Number.isFinite(timestamp) ? timestamp : Number.MAX_SAFE_INTEGER;
+}
+
+// src/app/dreaming/prune.ts
+var DAY_MS = 24 * 60 * 60 * 1e3;
+async function runPruneStage(options, deps) {
+  const durables = await deps.port.listReconcileDurables({
+    ...options.project ? { project: options.project } : {},
+    includeInactive: false
+  });
+  const activeProfileIds = await loadProtectedProfileIds(deps.port, options.protectedDurableIds ?? []);
+  const evaluated = durables.map(
+    (durable) => evaluatePruneCandidate(durable, {
+      activeProfileIds,
+      now: options.now(),
+      protectMinImportance: options.protectMinImportance,
+      protectRecalledDays: options.protectRecalledDays
+    })
+  ).filter((candidate) => candidate !== null).sort((left, right) => compareStaleCandidates(toStaleCandidatePolicyCandidate(left.durable), toStaleCandidatePolicyCandidate(right.durable)));
+  const protectedCount = evaluated.filter((candidate) => candidate.protectionReason !== null).length;
+  const stalable = evaluated.filter((candidate) => candidate.protectionReason === null);
+  let durablesStaled = 0;
+  if (options.apply && stalable.length > 0) {
+    await deps.port.withTransaction(async (tx) => {
+      for (const candidate of stalable) {
+        const staled = await tx.closeDurableValidity(candidate.durable.id, candidate.staleReason);
+        if (!staled) {
+          continue;
+        }
+        durablesStaled += 1;
+        await tx.logRunAction({
+          id: randomUUID2(),
+          runId: options.runId,
+          actionType: "stale",
+          durableIds: [candidate.durable.id],
+          reasoning: candidate.staleReason,
+          details: {
+            stage: "prune",
+            expiry: candidate.durable.expiry,
+            importance: candidate.durable.importance,
+            recall_count: candidate.durable.recall_count
+          },
+          createdAt: options.now().toISOString()
+        });
+      }
+    });
+  }
+  return {
+    durablesScanned: durables.length,
+    candidatesIdentified: evaluated.length,
+    candidatesProtected: protectedCount,
+    candidatesRetirable: stalable.length,
+    durablesStaled,
+    dryRun: !options.apply
+  };
+}
+function evaluatePruneCandidate(durable, options) {
+  if (!isActionableStaleCandidate(toStaleCandidatePolicyCandidate(durable)) && !isStaleMemory(durable, options.now.getTime())) {
+    return null;
+  }
+  return {
+    durable,
+    protectionReason: resolveProtectionReason(durable, options),
+    staleReason: buildStaleReason(durable, options.now)
+  };
+}
+async function loadProtectedProfileIds(port, protectedDurableIds) {
+  const snapshot = await port.getActiveProfileSnapshot();
+  const profileIds = new Set(protectedDurableIds);
+  if (!snapshot) {
+    return profileIds;
+  }
+  for (const durableId of [...snapshot.durableIds, ...snapshot.directiveIds]) {
+    profileIds.add(durableId);
+  }
+  return profileIds;
+}
+function resolveProtectionReason(durable, options) {
+  if (options.activeProfileIds.has(durable.id)) {
+    return "active_profile";
+  }
+  if (durable.type === "directive") {
+    return "directive";
+  }
+  if (durable.expiry === "core") {
+    return "core_expiry";
+  }
+  if (durable.importance >= options.protectMinImportance) {
+    return "high_importance";
+  }
+  if (wasRecentlyRecalled(durable, options.now, options.protectRecalledDays)) {
+    return "recent_recall";
+  }
+  return null;
+}
+function wasRecentlyRecalled(durable, now, protectRecalledDays) {
+  if (!durable.last_recalled_at) {
+    return false;
+  }
+  const recalledAt = Date.parse(durable.last_recalled_at);
+  if (!Number.isFinite(recalledAt)) {
+    return false;
+  }
+  const cutoff = now.getTime() - protectRecalledDays * DAY_MS;
+  return recalledAt >= cutoff;
+}
+function buildStaleReason(durable, now) {
+  if (isStaleMemory(durable, now.getTime())) {
+    return "Dream prune staled an expired valid-time durable.";
+  }
+  if (durable.expiry === "temporary") {
+    return "Dream prune staled a temporary durable after synthesis.";
+  }
+  return "Dream prune staled a low-signal durable after synthesis.";
+}
+function toStaleCandidatePolicyCandidate(durable) {
+  return {
+    id: durable.id,
+    subject: durable.subject,
+    type: durable.type,
+    importance: durable.importance,
+    expiry: durable.expiry,
+    recallCount: durable.recall_count,
+    createdAt: durable.created_at,
+    updatedAt: durable.updated_at
+  };
+}
+
+// src/app/dreaming/project.ts
+import { createHash, randomUUID as randomUUID3 } from "crypto";
+var DEFAULT_MAX_PROFILE_DURABLES = 8;
+var MIN_PROFILE_DURABLES = 1;
+var MAX_PROFILE_DURABLES = 8;
+async function runProjectStage(options, deps) {
+  const asOfDate = options.now();
+  const asOf = asOfDate.toISOString();
+  const maxProfileDurables = normalizeMaxProfileDurables(options.maxProfileDurables);
+  const activeCurrent = (await deps.port.listReconcileDurables({ ...options.project ? { project: options.project } : {} })).filter(
+    (durable) => isCurrentDurable(durable, asOfDate.getTime())
+  );
+  const directiveDurables = activeCurrent.filter((durable) => parseDirectiveMetadata(durable) !== null).sort(compareDirectiveDurables);
+  const profileDurables = activeCurrent.filter((durable) => parseDirectiveMetadata(durable) === null).sort(compareProfileDurables).slice(0, maxProfileDurables);
+  const snapshot = profileDurables.length > 0 || directiveDurables.length > 0 ? {
+    id: randomUUID3(),
+    durableIds: profileDurables.map((durable) => durable.id),
+    directiveIds: directiveDurables.map((durable) => durable.id),
+    asOf,
+    contentHash: buildProfileContentHash(profileDurables, directiveDurables),
+    runId: options.runId,
+    createdAt: asOf
+  } : null;
+  return {
+    summary: {
+      profileDurableCount: profileDurables.length,
+      directiveCount: directiveDurables.length,
+      snapshotId: null,
+      applied: false
+    },
+    snapshot
+  };
+}
+function normalizeMaxProfileDurables(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return DEFAULT_MAX_PROFILE_DURABLES;
+  }
+  return Math.min(MAX_PROFILE_DURABLES, Math.max(MIN_PROFILE_DURABLES, Math.trunc(value)));
+}
+function isCurrentDurable(durable, asOfMs) {
+  return isCurrentlyValidMemory(durable, asOfMs);
+}
+function compareProfileDurables(left, right) {
+  const expiryDelta = profileExpiryRank(right) - profileExpiryRank(left);
+  if (expiryDelta !== 0) {
+    return expiryDelta;
+  }
+  const importanceDelta = right.importance - left.importance;
+  if (importanceDelta !== 0) {
+    return importanceDelta;
+  }
+  const qualityDelta = right.quality_score - left.quality_score;
+  if (qualityDelta !== 0) {
+    return qualityDelta;
+  }
+  return right.created_at.localeCompare(left.created_at) || left.id.localeCompare(right.id);
+}
+function compareDirectiveDurables(left, right) {
+  const leftMetadata = parseDirectiveMetadata(left);
+  const rightMetadata = parseDirectiveMetadata(right);
+  const polarityDelta = directivePolarityRank(rightMetadata?.polarity) - directivePolarityRank(leftMetadata?.polarity);
+  if (polarityDelta !== 0) {
+    return polarityDelta;
+  }
+  const importanceDelta = right.importance - left.importance;
+  if (importanceDelta !== 0) {
+    return importanceDelta;
+  }
+  return right.created_at.localeCompare(left.created_at) || left.id.localeCompare(right.id);
+}
+function profileExpiryRank(durable) {
+  if (durable.expiry === "core") {
+    return 3;
+  }
+  if (durable.expiry === "permanent") {
+    return 2;
+  }
+  return 1;
+}
+function directivePolarityRank(polarity) {
+  return polarity === "proactive" ? 2 : 1;
+}
+function buildProfileContentHash(profileDurables, directiveDurables) {
+  const payload = {
+    profile: profileDurables.map(toHashableDurable),
+    directives: directiveDurables.map(toHashableDurable)
+  };
+  return createHash("sha256").update(JSON.stringify(payload)).digest("hex");
+}
+function toHashableDurable(durable) {
+  return {
+    id: durable.id,
+    updated_at: durable.updated_at,
+    content_hash: durable.content_hash,
+    norm_content_hash: durable.norm_content_hash,
+    importance: durable.importance,
+    expiry: durable.expiry,
+    directive_polarity: durable.directive_polarity,
+    directive_trigger: durable.directive_trigger
+  };
+}
+
+// src/app/dreaming/reconcile/constants.ts
+var HIGH_CONFIDENCE_BACKFILL_THRESHOLD = 0.92;
+var STRUCTURED_AUTO_APPLY_BACKFILL_THRESHOLD = 0.86;
+var COMPACTED_SUPPORTED_AUTO_APPLY_BACKFILL_THRESHOLD = 0.78;
+var PROPOSAL_CONFIDENCE_THRESHOLD = 0.75;
+var SUPPORTED_PROPOSAL_CONFIDENCE_THRESHOLD = 0.65;
+var MAX_CLEANUP_ENTITY_HINTS = 12;
+var MAX_CLEANUP_CLAIM_KEY_HINTS = 8;
+var CLAIM_KEY_CONCENTRATION_THRESHOLD = 25;
+var CLAIM_KEY_CONCENTRATION_RATIO = 0.8;
+var ENTITY_CONCENTRATION_THRESHOLD = 40;
+var ENTITY_CONCENTRATION_RATIO = 0.85;
+var COLLISION_SPIKE_THRESHOLD = 30;
+var COLLISION_SPIKE_RATIO = 0.85;
+var CLAIM_KEY_PROGRESS_INTERVAL_MS = 5e3;
+var CLAIM_KEY_PROGRESS_VERBOSE_INTERVAL_MS = 2e3;
+var CLAIM_KEY_PROGRESS_EVERY_DURABLES = 250;
+var CLAIM_KEY_PROGRESS_EVERY_VERBOSE_DURABLES = 50;
+var SHADOW_RESONANCE_MIN_FAMILY_REUSE_COUNT = 20;
+var SHADOW_RESONANCE_MIN_GROUNDED_RATIO = 0.7;
+var SHADOW_RESONANCE_MIN_CONFIDENCE = 0.74;
+var USER_METADATA_ENTITY_ALIASES = /* @__PURE__ */ new Set(["i", "me", "myself", "person", "the_user", "user"]);
+var PROJECT_METADATA_ENTITY_ALIASES = /* @__PURE__ */ new Set(["app", "application", "project", "the_project", "this_project", "workspace"]);
+var SHADOW_BUCKET_ORDER = [
+  "high_density_grounded_family",
+  "large_grounding_diluted_grounded_family",
+  "thin_grounded_family_tail",
+  "relaxed_one_sibling_stable_slot",
+  "other_grounded_family_alignment"
+];
+
+// src/app/dreaming/reconcile/helpers/utils.ts
+function normalizeOptionalString(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : null;
+}
+function normalizeStringArray(values) {
+  return Array.from(new Set(values.map((value) => value.trim()).filter((value) => value.length > 0)));
+}
+function normalizeOptionalNonNegativeCount(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return 0;
+  }
+  return Math.max(0, Math.floor(value));
+}
+function elapsedMs(startedAtMs, nowMs = Date.now()) {
+  return Math.max(0, nowMs - startedAtMs);
+}
+function countSetOverlap(left, right) {
+  let count = 0;
+  for (const value of right) {
+    if (left.has(value)) {
+      count += 1;
+    }
+  }
+  return count;
+}
+function normalizeMetadataEntity(value) {
+  const normalized = value ? normalizeClaimKeySegment(value) : "";
+  if (normalized.length === 0 || !/[a-z]/u.test(normalized)) {
+    return null;
+  }
+  return normalized;
+}
+function describeShadowBucket(bucket) {
+  switch (bucket) {
+    case "high_density_grounded_family":
+      return "high-density grounded-family";
+    case "large_grounding_diluted_grounded_family":
+      return "large grounding-diluted grounded-family";
+    case "thin_grounded_family_tail":
+      return "thin grounded-family tail";
+    case "relaxed_one_sibling_stable_slot":
+      return "relaxed one-sibling stable-slot";
+    case "other_grounded_family_alignment":
+      return "other grounded-family alignment";
+  }
+}
+
+// src/app/dreaming/reconcile/helpers/claim-key-inspection.ts
+function inspectExistingClaimKey(durable) {
+  const rawClaimKey = durable.claim_key?.trim();
+  if (!rawClaimKey) {
+    return { kind: "missing" };
+  }
+  const inspection = inspectClaimKey(rawClaimKey);
+  if (inspection.normalizationFailure) {
+    return { kind: "malformed", inspection };
+  }
+  if (inspection.normalized && !inspection.canonical) {
+    return {
+      kind: "noncanonical",
+      inspection,
+      normalized: inspection.normalized
+    };
+  }
+  if (inspection.suspectReasons.length > 0) {
+    return { kind: "suspect", inspection };
+  }
+  return { kind: "ok", inspection };
+}
+function resolveExplicitMetadataRepair(durable, inspection) {
+  const normalized = inspection.normalized;
+  if (!normalized) {
+    return null;
+  }
+  const userEntity = normalizeMetadataEntity(durable.user_id);
+  const projectEntity = normalizeMetadataEntity(durable.project);
+  if (USER_METADATA_ENTITY_ALIASES.has(normalized.entity) && userEntity) {
+    const candidate = `${userEntity}/${normalized.attribute}`;
+    return isTrustedClaimKeyForCleanup(candidate) ? candidate : null;
+  }
+  if (PROJECT_METADATA_ENTITY_ALIASES.has(normalized.entity) && projectEntity) {
+    const candidate = `${projectEntity}/${normalized.attribute}`;
+    return isTrustedClaimKeyForCleanup(candidate) ? candidate : null;
+  }
+  return null;
+}
+function resolveMetadataBackfillClaimKey(durable, claimKey) {
+  return resolveExplicitMetadataRepair(durable, inspectClaimKey(claimKey));
+}
+function describeSuspicionList(inspection) {
+  if (!inspection.normalized || inspection.suspectReasons.length === 0) {
+    return "it is low-trust";
+  }
+  return inspection.suspectReasons.map((reason) => describeClaimKeySuspicion(reason, inspection.normalized)).join(", ");
+}
+function buildSuspectProposalRationale(durable, inspection, metadataRepair, suggestion) {
+  const suspectReason = describeSuspicionList(inspection);
+  const replacementHint = metadataRepair !== null ? ` Explicit metadata suggests "${metadataRepair}".` : suggestion?.claimKey ? ` Claim extraction preview suggested "${suggestion.claimKey}" at confidence ${suggestion.confidence.toFixed(2)}.` : "";
+  return `Claim key "${durable.claim_key}" is structurally canonical but suspect because ${suspectReason}.${replacementHint}`;
+}
+
+// src/app/dreaming/reconcile/helpers/claim-key-health-tally.ts
+function createEmptyClaimKeyInspectionTally() {
+  return {
+    malformedOrNoncanonicalCount: 0,
+    suspectCanonicalCount: 0,
+    missingCount: 0,
+    eligibleMissingCount: 0
+  };
+}
+function cloneClaimKeyInspectionTally(tally) {
+  return {
+    malformedOrNoncanonicalCount: tally.malformedOrNoncanonicalCount,
+    suspectCanonicalCount: tally.suspectCanonicalCount,
+    missingCount: tally.missingCount,
+    eligibleMissingCount: tally.eligibleMissingCount
+  };
+}
+function untallyExistingClaimKeyInspection(inspection, durableType, eligibleTypes, tally) {
+  switch (inspection.kind) {
+    case "malformed":
+    case "noncanonical":
+      tally.malformedOrNoncanonicalCount -= 1;
+      break;
+    case "suspect":
+      tally.suspectCanonicalCount -= 1;
+      break;
+    case "missing":
+      tally.missingCount -= 1;
+      if (eligibleTypes.includes(durableType)) {
+        tally.eligibleMissingCount -= 1;
+      }
+      break;
+    default:
+      break;
+  }
+}
+function refreshDurableInspectionTally(durable, previous, eligibleTypes, tally) {
+  const next = inspectExistingClaimKey(durable);
+  untallyExistingClaimKeyInspection(previous, durable.type, eligibleTypes, tally);
+  tallyExistingClaimKeyInspection(next, durable.type, eligibleTypes, tally);
+  return next;
+}
+function tallyExistingClaimKeyInspection(inspection, durableType, eligibleTypes, tally) {
+  switch (inspection.kind) {
+    case "malformed":
+    case "noncanonical":
+      tally.malformedOrNoncanonicalCount += 1;
+      break;
+    case "suspect":
+      tally.suspectCanonicalCount += 1;
+      break;
+    case "missing":
+      tally.missingCount += 1;
+      if (eligibleTypes.includes(durableType)) {
+        tally.eligibleMissingCount += 1;
+      }
+      break;
+    default:
+      break;
+  }
+}
+
+// src/app/dreaming/reconcile/helpers/durable.ts
+function cloneDurable(durable) {
+  return {
+    ...durable,
+    tags: [...durable.tags],
+    embedding: durable.embedding ? [...durable.embedding] : void 0
+  };
+}
+function isDurableActive(durable) {
+  return isCurrentlyValidMemory(durable, Date.now());
+}
+function findClaimKeyOccupants(durables, claimKey, excludeDurableId) {
+  return durables.filter((durable) => durable.id !== excludeDurableId && durable.claim_key === claimKey);
+}
+function findActiveClaimKeyOccupants(durables, claimKey, excludeDurableId) {
+  return durables.filter((durable) => durable.id !== excludeDurableId && durable.claim_key === claimKey && isDurableActive(durable));
+}
+function countExactKeyMultiActiveClusters(durables) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const durable of durables) {
+    const claimKey = durable.claim_key?.trim();
+    if (!claimKey) {
+      continue;
+    }
+    counts.set(claimKey, (counts.get(claimKey) ?? 0) + 1);
+  }
+  return [...counts.values()].filter((count) => count >= 2).length;
+}
+function findTrustedGroupReuseCandidate(durables, trustedDurableIds, durable) {
+  const normalizedSubject = durable.subject.trim().toLowerCase();
+  if (normalizedSubject.length === 0) {
+    return null;
+  }
+  const trustedPeers = durables.filter((candidate) => {
+    if (candidate.id === durable.id || candidate.type !== durable.type) {
+      return false;
+    }
+    if (!trustedDurableIds.has(candidate.id)) {
+      return false;
+    }
+    if (candidate.subject.trim().toLowerCase() !== normalizedSubject) {
+      return false;
+    }
+    const claimKey2 = candidate.claim_key?.trim();
+    return Boolean(claimKey2 && isTrustedClaimKeyForCleanup(claimKey2));
+  });
+  const trustedClaimKeys = normalizeStringArray(
+    trustedPeers.flatMap((candidate) => {
+      const claimKey2 = candidate.claim_key?.trim();
+      return claimKey2 ? [claimKey2] : [];
+    })
+  );
+  if (trustedClaimKeys.length !== 1) {
+    return null;
+  }
+  const claimKey = trustedClaimKeys[0];
+  if (!claimKey) {
+    return null;
+  }
+  return {
+    claimKey,
+    supportingDurableIds: trustedPeers.map((candidate) => candidate.id)
+  };
+}
+function snapshotClaimKeyLifecycle(durable) {
+  return {
+    claimKey: durable.claim_key,
+    claimKeyRaw: durable.claim_key_raw,
+    claimKeyStatus: durable.claim_key_status,
+    claimKeySource: durable.claim_key_source,
+    claimKeyConfidence: durable.claim_key_confidence,
+    claimKeyRationale: durable.claim_key_rationale
+  };
+}
+function restoreClaimKeyLifecycle(durable, snapshot) {
+  durable.claim_key = snapshot.claimKey;
+  durable.claim_key_raw = snapshot.claimKeyRaw;
+  durable.claim_key_status = snapshot.claimKeyStatus;
+  durable.claim_key_source = snapshot.claimKeySource;
+  durable.claim_key_confidence = snapshot.claimKeyConfidence;
+  durable.claim_key_rationale = snapshot.claimKeyRationale;
+}
+
+// src/app/dreaming/reconcile/helpers/mixed-groups.ts
+function findMixedKeyGroups(durables, coveredClaimKeys = /* @__PURE__ */ new Set()) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const durable of durables) {
+    const normalizedSubject = durable.subject.trim().toLowerCase();
+    if (normalizedSubject.length === 0) {
+      continue;
+    }
+    const groupKey = `${normalizedSubject}::${durable.type}`;
+    const existing = groups.get(groupKey);
+    if (existing) {
+      existing.push(durable);
+      continue;
+    }
+    groups.set(groupKey, [durable]);
+  }
+  return [...groups.entries()].flatMap(([groupKey, groupDurables]) => {
+    if (groupDurables.length < 2) {
+      return [];
+    }
+    const claimKeys = normalizeStringArray(groupDurables.flatMap((durable) => durable.claim_key ? [durable.claim_key] : []));
+    const hasMissing = groupDurables.some((durable) => !durable.claim_key);
+    const distinctClaimKeyCount = claimKeys.length;
+    if (!hasMissing && distinctClaimKeyCount <= 1) {
+      return [];
+    }
+    if (!hasMissing && distinctClaimKeyCount > 1 && claimKeys.every((claimKey) => coveredClaimKeys.has(claimKey))) {
+      return [];
+    }
+    const trustedClaimKeys = claimKeys.filter((claimKey) => isTrustedClaimKeyForCleanup(claimKey));
+    const proposedClaimKey = trustedClaimKeys.length === 1 ? trustedClaimKeys[0] ?? null : null;
+    return [
+      {
+        groupKey,
+        durables: groupDurables,
+        proposedClaimKey
+      }
+    ];
+  }).sort((left, right) => left.groupKey.localeCompare(right.groupKey));
+}
+function buildMixedGroupRationale(group) {
+  const currentClaimKeys = normalizeStringArray(group.durables.flatMap((durable) => durable.claim_key ? [durable.claim_key] : []));
+  if (group.proposedClaimKey) {
+    return `Durables sharing subject/type group "${group.groupKey}" use mixed or missing claim keys. The only trusted canonical family already present is "${group.proposedClaimKey}", so it is the conservative proposed target for later adjudication. Current non-null keys: ${currentClaimKeys.join(", ") || "(none)"}.`;
+  }
+  return `Durables sharing subject/type group "${group.groupKey}" use mixed or missing claim keys, but the group does not expose one uniquely trusted canonical target. Current non-null keys: ${currentClaimKeys.join(", ") || "(none)"}.`;
+}
+
+// src/app/dreaming/reconcile/health.ts
+function buildClaimKeyHealthSnapshot(durables, eligibleTypes, tally) {
+  const activeDurables = durables.filter((durable) => isDurableActive(durable));
+  const withClaimKeys = durables.filter((durable) => typeof durable.claim_key === "string" && durable.claim_key.trim().length > 0);
+  const entityFamilyCandidates = detectClaimKeyEntityFamilyCandidates(durables);
+  const singletonAliasCandidates = detectClaimKeySingletonAliasCandidates(durables);
+  return {
+    totalDurables: durables.length,
+    activeDurables: activeDurables.length,
+    coverageCount: withClaimKeys.length,
+    coveragePct: durables.length > 0 ? withClaimKeys.length / durables.length : 0,
+    missingCount: tally.missingCount,
+    eligibleMissingCount: tally.eligibleMissingCount,
+    malformedOrNoncanonicalCount: tally.malformedOrNoncanonicalCount,
+    suspectCanonicalCount: tally.suspectCanonicalCount,
+    entityFamilyGroupCount: entityFamilyCandidates.length,
+    suspiciousSingletonAliasCount: singletonAliasCandidates.length,
+    mixedGroupCount: findMixedKeyGroups(durables).length,
+    exactKeyMultiActiveClusterCount: countExactKeyMultiActiveClusters(activeDurables)
+  };
+}
+
+// src/app/dreaming/reconcile/helpers/reconcile-proposal.ts
+import { randomUUID as randomUUID5 } from "crypto";
+
+// src/app/dreaming/reconcile/helpers/ambiguous-proposal.ts
+function defaultFlagAmbiguousProposal(issueKind) {
+  switch (issueKind) {
+    case "mixed_claim_key_group":
+    case "noncanonical_claim_key":
+      return false;
+    default:
+      return true;
+  }
+}
+function resolveFlagAmbiguousProposal(issueKind, override) {
+  return override ?? defaultFlagAmbiguousProposal(issueKind);
+}
+
+// src/app/dreaming/reconcile/helpers/audit.ts
+function buildMissingBackfillSupportAuditDetails(support) {
+  if (!support?.supportedProposal) {
+    return support?.autoApplyClass ? {
+      support_class: support.autoApplyClass
+    } : {};
+  }
+  return {
+    support_evidence: [...support.supportEvidence],
+    supporting_durable_ids: [...support.supportingDurableIds],
+    support_family_reuse_count: support.familyReuseCount,
+    support_grounded_family_reuse_count: support.groundedFamilyReuseCount,
+    support_sibling_slot_resonance_applicable: support.siblingSlotResonance.applicable,
+    support_sibling_slot_resonance_fired: support.siblingSlotResonance.fired,
+    support_sibling_slot_resonance_resonant_sibling_count: support.siblingSlotResonance.resonantSiblingCount,
+    support_sibling_slot_resonance_dominant_shape: support.siblingSlotResonance.dominantShape,
+    support_sibling_slot_resonance_dominant_shape_count: support.siblingSlotResonance.dominantShapeCount,
+    support_sibling_slot_resonance_grounded_share: support.siblingSlotResonance.dominantShapeGroundedShare,
+    support_sibling_slot_resonance_local_shape_coverage: support.siblingSlotResonance.localShapeTokenCoverage,
+    support_sibling_slot_resonance_family_generic_tokens: [...support.siblingSlotResonance.familyGenericTokens],
+    support_sibling_slot_resonance_discriminative_candidate_tokens: [...support.siblingSlotResonance.discriminativeCandidateTokens],
+    support_sibling_slot_resonance_sibling_durable_ids: [...support.siblingSlotResonance.dominantSiblingEntryIds],
+    support_sibling_slot_resonance_sibling_claim_keys: [...support.siblingSlotResonance.dominantSiblingClaimKeys],
+    ...support.strongEntityAttributeLexicalAlignment ? {
+      support_strong_entity_attribute_lexical_alignment: true
+    } : {},
+    ...support.autoApplyClass ? {
+      support_class: support.autoApplyClass
+    } : {},
+    ...support.relaxedStableSlotFamilyGate ? {
+      support_relaxed_stable_slot_family_gate: true
+    } : {}
+  };
+}
+function buildAppliedClaimKeyActionDetails(input) {
+  return {
+    issue_kind: input.issueKind,
+    old_claim_key: input.oldClaimKey,
+    new_claim_key: input.newClaimKey,
+    ...buildClaimKeyLifecycleAuditDetails(input.lifecycle),
+    proposal_source: input.proposalSource,
+    confidence: input.confidence,
+    auto_apply_threshold: input.promotion?.autoApplyThreshold,
+    auto_applied: true,
+    promotion_lane: input.promotion?.lane,
+    supported_auto_apply: input.support?.autoApplyClass !== null,
+    ...buildMissingBackfillSupportAuditDetails(input.support),
+    ...buildMissingBackfillShadowAuditDetails(input.shadow),
+    ...buildClaimKeyCompactionAuditDetails(input.compactness),
+    ...buildEntityFamilyAuditDetails(input.entityFamilyAudit)
+  };
+}
+function buildProposalClaimKeyActionDetails(proposal, audit) {
+  return {
+    proposal_id: proposal.id,
+    group_id: proposal.groupId,
+    issue_kind: proposal.issueKind,
+    current_claim_keys: proposal.currentClaimKeys,
+    proposed_claim_keys: proposal.proposedClaimKeys,
+    confidence: proposal.confidence,
+    proposal_source: proposal.source,
+    auto_apply_threshold: audit?.promotion?.autoApplyThreshold,
+    auto_applied: false,
+    promotion_lane: audit?.promotion?.lane,
+    eligible_for_apply: proposal.eligibleForApply,
+    supported_candidate: audit?.supportedCandidate === true,
+    ...buildReconcileProposalClaimKeyAuditDetails(audit?.proposalLifecycle),
+    ...buildMissingBackfillSupportAuditDetails(audit?.support),
+    ...buildMissingBackfillShadowAuditDetails(audit?.shadow),
+    ...buildClaimKeyCompactionAuditDetails(audit?.compactness),
+    ...audit?.autoApplyBlocker ? {
+      auto_apply_blocker: audit.autoApplyBlocker
+    } : {},
+    ...buildEntityFamilyAuditDetails(audit?.entityFamilyAudit)
+  };
+}
+function buildMissingBackfillShadowAuditDetails(shadow) {
+  if (!shadow) {
+    return {};
+  }
+  return {
+    shadow_threshold_only_bucket: shadow.thresholdOnlyBucket,
+    shadow_would_qualify: shadow.shadowWouldQualify
+  };
+}
+function buildClaimKeyCompactionAuditDetails(compactness) {
+  return compactness?.compactedFrom ? {
+    claim_key_compacted_from: compactness.compactedFrom,
+    claim_key_compaction_reason: compactness.compactionReason
+  } : {};
+}
+function buildEntityFamilyAuditDetails(entityFamilyAudit) {
+  return entityFamilyAudit ? {
+    competing_entity_prefixes: [...entityFamilyAudit.competingEntityPrefixes],
+    canonical_entity_prefix: entityFamilyAudit.canonicalEntityPrefix,
+    canonical_selection_reasons: [...entityFamilyAudit.canonicalSelectionReasons],
+    entity_family_unresolved_reason: entityFamilyAudit.unresolvedReason,
+    entity_family_evidence: entityFamilyAudit.evidence.map((evidence) => ({ ...evidence })),
+    entity_family_pair_support: entityFamilyAudit.pairSupport.map((support) => ({
+      ...support,
+      entityPrefixes: [...support.entityPrefixes],
+      supportingDurableIds: [...support.supportingDurableIds],
+      sharedAttributes: [...support.sharedAttributes],
+      evidence: support.evidence.map((evidence) => ({ ...evidence }))
+    }))
+  } : {};
+}
+
+// src/app/dreaming/reconcile/helpers/proposal.ts
+import { randomUUID as randomUUID4 } from "crypto";
+function createProposal(input) {
+  return {
+    id: randomUUID4(),
+    ...input,
+    durableIds: normalizeStringArray(input.durableIds),
+    currentClaimKeys: normalizeStringArray(input.currentClaimKeys),
+    proposedClaimKeys: normalizeStringArray(input.proposedClaimKeys),
+    reviewStatus: "open",
+    reviewedAt: null,
+    reviewReason: null,
+    appliedActionCount: 0
+  };
+}
+function buildMalformedClaimKeyPersistInput(durable, inspection, suggestionRecord) {
+  const proposedClaimKeys = suggestionRecord.suggestion?.claimKey ? [suggestionRecord.suggestion.claimKey] : [];
+  const source = suggestionRecord.suggestion?.path ?? "normalize";
+  return {
+    groupId: `claim-key-malformed:${durable.id}`,
+    issueKind: "malformed_claim_key",
+    scope: "single_durable",
+    durableIds: [durable.id],
+    currentClaimKeys: durable.claim_key ? [durable.claim_key] : [],
+    proposedClaimKeys,
+    rationale: `Stored claim key "${durable.claim_key}" is malformed because ${describeClaimKeyNormalizationFailure(inspection.inspection.normalizationFailure ?? "missing_separator")}.` + (suggestionRecord.suggestion?.claimKey ? ` Claim extraction preview suggested "${suggestionRecord.suggestion.claimKey}" at confidence ${suggestionRecord.suggestion.confidence.toFixed(2)}.` : ""),
+    confidence: suggestionRecord.suggestion?.confidence ?? 0.5,
+    source,
+    eligibleForApply: proposedClaimKeys.length > 0,
+    lifecycle: {
+      proposedClaimKeys,
+      source,
+      rawClaimKey: durable.claim_key ?? null
+    }
+  };
+}
+function buildTrustedGroupReusePersistInput(durable, trustedGroupReuse) {
+  return {
+    groupId: `claim-key-backfill:${durable.id}`,
+    issueKind: "missing_claim_key",
+    scope: "single_durable",
+    durableIds: [durable.id],
+    currentClaimKeys: [],
+    proposedClaimKeys: [trustedGroupReuse.claimKey],
+    rationale: `A matched subject/type group already uses trusted canonical key "${trustedGroupReuse.claimKey}" across ${trustedGroupReuse.supportingDurableIds.length} supporting durable${trustedGroupReuse.supportingDurableIds.length === 1 ? "" : "s"}, but that same key is already occupied by a different active durable type in the matched working set.`,
+    confidence: 0.99,
+    source: "trusted_group_reuse",
+    eligibleForApply: true,
+    lifecycle: {
+      proposedClaimKeys: [trustedGroupReuse.claimKey],
+      source: "trusted_group_reuse"
+    }
+  };
+}
+function buildMissingBackfillPersistInput(durable, resolved, input) {
+  return {
+    groupId: `claim-key-backfill:${durable.id}`,
+    issueKind: "missing_claim_key",
+    scope: "single_durable",
+    durableIds: input.durableIds,
+    currentClaimKeys: [],
+    proposedClaimKeys: [resolved.targetClaimKey],
+    rationale: input.rationale,
+    confidence: resolved.suggestion.confidence,
+    source: resolved.targetSource,
+    eligibleForApply: true,
+    lifecycle: {
+      proposedClaimKeys: [resolved.targetClaimKey],
+      source: resolved.targetSource,
+      rawClaimKey: resolved.originalClaimKey,
+      compactness: resolved.compactness,
+      support: resolved.support
+    },
+    audit: {
+      compactness: resolved.compactness,
+      promotion: resolved.promotionPolicy,
+      support: resolved.support,
+      supportedCandidate: resolved.support.supportedProposal,
+      ...input.audit
+    }
+  };
+}
+function buildEntityFamilyPersistInput(candidate, input) {
+  return {
+    groupId: `claim-key-entity-family:${candidate.entityPrefixes.join(",")}`,
+    issueKind: "entity_family_convergence",
+    scope: "cluster",
+    durableIds: input.durableIds,
+    currentClaimKeys: candidate.claimKeys,
+    proposedClaimKeys: input.proposedClaimKeys,
+    rationale: input.rationale,
+    confidence: candidate.confidence,
+    source: input.source,
+    eligibleForApply: input.eligibleForApply,
+    lifecycle: {
+      proposedClaimKeys: input.proposedClaimKeys,
+      source: input.source
+    },
+    audit: {
+      entityFamilyAudit: input.audit,
+      ...input.auditExtras
+    }
+  };
+}
+
+// src/app/dreaming/reconcile/helpers/reconcile-proposal.ts
+async function persistReconcileProposal(ctx, input) {
+  const proposalLifecycle = buildReconcileProposalClaimKeyLifecycle(input.lifecycle);
+  const proposal = createProposal({
+    runId: ctx.options.runId,
+    groupId: input.groupId,
+    issueKind: input.issueKind,
+    scope: input.scope,
+    durableIds: input.durableIds,
+    currentClaimKeys: input.currentClaimKeys,
+    proposedClaimKeys: input.proposedClaimKeys,
+    rationale: buildReconcileProposalLifecycleRationale(input.rationale, proposalLifecycle),
+    confidence: input.confidence,
+    source: input.source,
+    eligibleForApply: input.eligibleForApply,
+    createdAt: ctx.options.now().toISOString()
+  });
+  await ctx.deps.port.logRunProposal(proposal);
+  await ctx.deps.port.logRunAction({
+    id: randomUUID5(),
+    runId: ctx.options.runId,
+    actionType: "flag_review",
+    durableIds: proposal.durableIds,
+    reasoning: proposal.rationale,
+    details: buildProposalClaimKeyActionDetails(proposal, {
+      proposalLifecycle,
+      ...input.audit
+    }),
+    createdAt: proposal.createdAt
+  });
+  ctx.telemetry.actionsTaken += 1;
+  ctx.telemetry.counts.proposalsEmitted += 1;
+  if (resolveFlagAmbiguousProposal(input.issueKind, input.flagAmbiguousProposal)) {
+    ctx.telemetry.counts.flaggedAmbiguousProposals += 1;
+  }
+  input.onPersisted?.(ctx);
+}
+async function persistCrossTypeCollisionProposal(ctx, input) {
+  await persistReconcileProposal(ctx, {
+    ...input,
+    durableIds: normalizeStringArray(input.durableIds),
+    audit: {
+      autoApplyBlocker: "cross_type_collision",
+      ...input.audit
+    }
+  });
+}
+function expandCrossTypeCollisionDurableIds(durableIds, activeSiblingIds) {
+  return normalizeStringArray([...durableIds, ...activeSiblingIds]);
+}
+function appendCrossTypeCollisionRationaleSuffix(rationale, targetClaimKey) {
+  return `${rationale} The same slot key is already used by a different durable type in the matched working set at "${targetClaimKey}".`;
+}
+
+// src/app/dreaming/reconcile/helpers/cross-type-collision-outcome.ts
+function findCrossTypeActiveSiblings(projectedDurables, targetClaimKey, durable) {
+  return findActiveClaimKeyOccupants(projectedDurables, targetClaimKey, durable.id).filter((sibling) => sibling.type !== durable.type);
+}
+function resolveCrossTypeCollisionSiblingIds(projectedDurables, targetClaimKey, durable) {
+  return findCrossTypeActiveSiblings(projectedDurables, targetClaimKey, durable).map((sibling) => sibling.id);
+}
+async function persistProposalWhenCrossTypeCollision(ctx, targetClaimKey, durable, buildInput) {
+  const activeSiblingIds = resolveCrossTypeCollisionSiblingIds(ctx.workingSet.projectedDurables, targetClaimKey, durable);
+  if (activeSiblingIds.length === 0) {
+    return false;
+  }
+  const input = buildInput(activeSiblingIds);
+  await persistCrossTypeCollisionProposal(ctx, {
+    ...input,
+    durableIds: expandCrossTypeCollisionDurableIds(input.durableIds, activeSiblingIds)
+  });
+  return true;
+}
+
+// src/app/dreaming/reconcile/helpers/entity-family.ts
+function buildEntityFamilyConvergenceAudit(candidate) {
+  return {
+    competingEntityPrefixes: [...candidate.entityPrefixes],
+    canonicalEntityPrefix: candidate.canonicalEntityPrefix,
+    canonicalSelectionReasons: [...candidate.canonicalSelectionReasons],
+    unresolvedReason: candidate.unresolvedReason,
+    evidence: flattenEntityFamilyEvidence(candidate.pairSupport),
+    pairSupport: candidate.pairSupport.map((support) => ({
+      entityPrefixes: [...support.entityPrefixes],
+      supportingDurableIds: [...support.supportingDurableIds],
+      sharedAttributes: [...support.sharedAttributes],
+      confidence: support.confidence,
+      autoSafe: support.autoSafe,
+      preferredCanonicalEntityPrefix: support.preferredCanonicalEntityPrefix,
+      evidence: support.evidence.map((evidence) => ({ ...evidence }))
+    }))
+  };
+}
+function flattenEntityFamilyEvidence(pairSupport) {
+  const evidenceByKey = /* @__PURE__ */ new Map();
+  for (const support of pairSupport) {
+    for (const evidence of support.evidence) {
+      const evidenceKey = `${evidence.kind}:${evidence.detail}`;
+      if (!evidenceByKey.has(evidenceKey)) {
+        evidenceByKey.set(evidenceKey, { ...evidence });
+      }
+    }
+  }
+  return [...evidenceByKey.values()];
+}
+function collectEntityFamilyDurablesToRewrite(projectedDurables, candidate) {
+  const canonicalEntityPrefix = candidate.canonicalEntityPrefix;
+  if (!canonicalEntityPrefix) {
+    return [];
+  }
+  return projectedDurables.filter((durable) => {
+    const claimKey = durable.claim_key?.trim();
+    if (!claimKey) {
+      return false;
+    }
+    const claimKeyInspection = inspectClaimKey(claimKey);
+    if (!claimKeyInspection.normalized || claimKeyInspection.suspectReasons.length > 0 || !candidate.entityPrefixes.includes(claimKeyInspection.normalized.entity)) {
+      return false;
+    }
+    return claimKeyInspection.normalized.entity !== canonicalEntityPrefix;
+  });
+}
+function resolveEntityFamilyTargetClaimKey(durable, canonicalEntityPrefix) {
+  const claimKey = durable.claim_key?.trim();
+  if (!claimKey) {
+    return null;
+  }
+  const claimKeyInspection = inspectClaimKey(claimKey);
+  if (!claimKeyInspection.normalized) {
+    return null;
+  }
+  return `${canonicalEntityPrefix}/${claimKeyInspection.normalized.attribute}`;
+}
+function mapEntityFamilyClaimKeys(claimKeys, entityPrefixes, canonicalEntityPrefix) {
+  const entityPrefixSet = new Set(entityPrefixes);
+  return normalizeStringArray(
+    claimKeys.flatMap((claimKey) => {
+      const inspection = inspectClaimKey(claimKey);
+      if (!inspection.normalized || !entityPrefixSet.has(inspection.normalized.entity) || inspection.normalized.entity === canonicalEntityPrefix) {
+        return [];
+      }
+      return [`${canonicalEntityPrefix}/${inspection.normalized.attribute}`];
+    })
+  );
+}
+function buildEntityFamilyConvergenceRationale(candidate) {
+  const evidenceText = flattenEntityFamilyEvidence(candidate.pairSupport).map((evidence) => evidence.detail).join(" ");
+  const canonicalText = candidate.canonicalEntityPrefix ? ` Canonical entity prefix candidate: "${candidate.canonicalEntityPrefix}".` : " No single canonical entity prefix is safe to choose automatically.";
+  const reasonText = candidate.unresolvedReason ? ` ${candidate.unresolvedReason}` : "";
+  const selectionText = candidate.canonicalSelectionReasons.length > 0 ? ` Canonical selection signals: ${candidate.canonicalSelectionReasons.join(", ")}.` : "";
+  return (`Claim-key entity families ${candidate.entityPrefixes.join(", ")} show repeated same-slot overlap and grounding support. ` + evidenceText + canonicalText + selectionText + reasonText).trim();
+}
+
+// src/app/dreaming/reconcile/pass-apply-handlers.ts
+import { randomUUID as randomUUID6 } from "crypto";
+
+// src/app/dreaming/reconcile/helpers/circuit-breaker.ts
+function createCircuitBreakerState() {
+  return {
+    totalAutoMutations: 0,
+    blockedCollisions: 0,
+    appliedByClaimKey: /* @__PURE__ */ new Map(),
+    appliedByEntity: /* @__PURE__ */ new Map()
+  };
+}
+function recordCollision(state) {
+  state.blockedCollisions += 1;
+}
+function recordAppliedRepair(state, claimKey) {
+  state.totalAutoMutations += 1;
+  state.appliedByClaimKey.set(claimKey, (state.appliedByClaimKey.get(claimKey) ?? 0) + 1);
+  const entity = claimKey.split("/", 1)[0] ?? claimKey;
+  state.appliedByEntity.set(entity, (state.appliedByEntity.get(entity) ?? 0) + 1);
+  return evaluateCircuitBreaker(state);
+}
+function evaluateCircuitBreaker(state) {
+  const largestClaimKeyCluster = maxCounterValue(state.appliedByClaimKey);
+  if (state.totalAutoMutations >= CLAIM_KEY_CONCENTRATION_THRESHOLD && largestClaimKeyCluster >= CLAIM_KEY_CONCENTRATION_THRESHOLD && largestClaimKeyCluster / state.totalAutoMutations >= CLAIM_KEY_CONCENTRATION_RATIO) {
+    const target = maxCounterKey(state.appliedByClaimKey) ?? "unknown";
+    return {
+      kind: "claim_key_concentration",
+      message: `Reconcile circuit breaker tripped: ${largestClaimKeyCluster}/${state.totalAutoMutations} auto-repairs converged onto "${target}".`
+    };
+  }
+  const largestEntityCluster = maxCounterValue(state.appliedByEntity);
+  if (state.totalAutoMutations >= ENTITY_CONCENTRATION_THRESHOLD && largestEntityCluster >= ENTITY_CONCENTRATION_THRESHOLD && largestEntityCluster / state.totalAutoMutations >= ENTITY_CONCENTRATION_RATIO) {
+    const target = maxCounterKey(state.appliedByEntity) ?? "unknown";
+    return {
+      kind: "entity_prefix_concentration",
+      message: `Reconcile circuit breaker tripped: ${largestEntityCluster}/${state.totalAutoMutations} auto-repairs converged onto entity prefix "${target}".`
+    };
+  }
+  if (state.blockedCollisions >= COLLISION_SPIKE_THRESHOLD && state.totalAutoMutations + state.blockedCollisions > 0 && state.blockedCollisions / (state.totalAutoMutations + state.blockedCollisions) >= COLLISION_SPIKE_RATIO) {
+    return {
+      kind: "collision_spike",
+      message: `Reconcile circuit breaker tripped: ${state.blockedCollisions} proposed repairs were blocked by collisions, suggesting non-convergent claim-key cleanup.`
+    };
+  }
+  return null;
+}
+function maxCounterValue(counter) {
+  let max = 0;
+  for (const value of counter.values()) {
+    max = Math.max(max, value);
+  }
+  return max;
+}
+function maxCounterKey(counter) {
+  let bestKey = null;
+  let bestValue = -1;
+  for (const [key, value] of counter.entries()) {
+    if (value > bestValue) {
+      bestKey = key;
+      bestValue = value;
+    }
+  }
+  return bestKey;
+}
+
+// src/app/dreaming/reconcile/helpers/effects.ts
+function markAbortedIfSignalled(ctx) {
+  if (ctx.options.signal?.aborted === true) {
+    ctx.telemetry.terminalStatus = "aborted";
+    ctx.telemetry.terminalError = USER_ABORT_ERROR;
+    return true;
+  }
+  return false;
+}
+function tripCircuitBreaker(ctx, breaker) {
+  if (!breaker) {
+    return;
+  }
+  ctx.telemetry.circuitBreaker = breaker;
+  ctx.telemetry.terminalStatus = "failed";
+  ctx.telemetry.terminalError = breaker.message;
+}
+function recordRepairOutcome(ctx, claimKey, projected) {
+  if (!projected) {
+    return;
+  }
+  tripCircuitBreaker(ctx, recordAppliedRepair(ctx.telemetry.circuitBreakerState, claimKey));
+}
+function recordCollisionOutcome(ctx) {
+  recordCollision(ctx.telemetry.circuitBreakerState);
+  if (ctx.telemetry.circuitBreaker) {
+    return;
+  }
+  tripCircuitBreaker(ctx, evaluateCircuitBreaker(ctx.telemetry.circuitBreakerState));
+}
+
+// src/app/dreaming/reconcile/pass-apply-handlers.ts
+async function maybeApplyClaimKeyUpdate(ctx, durableId, claimKey, input) {
+  const projected = ctx.workingSet.durablesById.get(durableId);
+  const actual = ctx.workingSet.actualDurablesById.get(durableId);
+  if (!projected || !actual) {
+    return { projected: false, applied: false };
+  }
+  const previousProjected = snapshotClaimKeyLifecycle(projected);
+  const lifecycle = buildReconcileAppliedClaimKeyLifecycleBundle({
+    targetClaimKey: claimKey,
+    priorClaimKey: input.oldClaimKey,
+    priorClaimKeyRaw: projected.claim_key_raw ?? actual.claim_key_raw,
+    rawClaimKey: input.rawClaimKey,
+    source: input.source,
+    confidence: input.confidence,
+    rationale: input.rationale,
+    support: input.support,
+    compactness: input.compactness
+  });
+  applyClaimKeyLifecycle(projected, lifecycle);
+  if (!ctx.options.apply) {
+    refreshClaimKeyInspectionState(ctx, durableId, "projected");
+    return { projected: true, applied: false };
+  }
+  const updated = await ctx.deps.port.updateDurable(durableId, buildClaimKeyLifecycleUpdateFields(lifecycle), {
+    includeInactive: ctx.workingSet.selection.includeInactive
+  });
+  if (!updated) {
+    restoreClaimKeyLifecycle(projected, previousProjected);
+    return { projected: false, applied: false };
+  }
+  refreshClaimKeyInspectionState(ctx, durableId, "projected");
+  applyClaimKeyLifecycle(actual, lifecycle);
+  refreshClaimKeyInspectionState(ctx, durableId, "actual");
+  await ctx.deps.port.logRunAction({
+    id: randomUUID6(),
+    runId: ctx.options.runId,
+    actionType: "update_durable",
+    durableIds: [durableId],
+    reasoning: input.rationale,
+    details: buildAppliedClaimKeyActionDetails({
+      issueKind: input.issueKind,
+      oldClaimKey: input.oldClaimKey,
+      newClaimKey: claimKey,
+      proposalSource: input.source,
+      confidence: input.confidence,
+      lifecycle,
+      promotion: input.promotion,
+      support: input.support,
+      shadow: input.shadow,
+      compactness: input.compactness,
+      entityFamilyAudit: input.entityFamilyAudit
+    }),
+    createdAt: ctx.options.now().toISOString()
+  });
+  ctx.telemetry.actionsTaken += 1;
+  return { projected: true, applied: true };
+}
+async function applyClaimKeyRepair(ctx, durableId, claimKey, input, options = {}) {
+  options.onIdentified?.();
+  const updateResult = await maybeApplyClaimKeyUpdate(ctx, durableId, claimKey, input);
+  if (updateResult.applied) {
+    options.onApplied?.();
+  }
+  if (updateResult.projected) {
+    options.onProjected?.();
+    if (options.registerTrustedReuse && isTrustedClaimKeyForCleanup(claimKey)) {
+      ctx.workingSet.trustedReusableDurableIds.add(durableId);
+    }
+    recordRepairOutcome(ctx, claimKey, updateResult.projected);
+  }
+  return updateResult;
+}
+function refreshClaimKeyInspectionState(ctx, durableId, scope) {
+  const durable = scope === "projected" ? ctx.workingSet.durablesById.get(durableId) : ctx.workingSet.actualDurablesById.get(durableId);
+  const inspectionById = scope === "projected" ? ctx.workingSet.projectedInspectionById : ctx.workingSet.actualInspectionById;
+  const tally = scope === "projected" ? ctx.workingSet.projectedInspectionTally : ctx.workingSet.actualInspectionTally;
+  const previous = inspectionById.get(durableId);
+  if (!durable || !previous) {
+    return;
+  }
+  inspectionById.set(durableId, refreshDurableInspectionTally(durable, previous, ctx.extraction.claimExtractionConfig.eligibleTypes, tally));
+}
+
+// src/app/dreaming/reconcile/handlers/entity-family.ts
+async function processEntityFamilyConvergenceCandidate(ctx, candidate) {
+  const decision = evaluateEntityFamilyDecision(ctx, candidate);
+  await executeEntityFamilyDecision(ctx, candidate, decision);
+}
+function evaluateEntityFamilyDecision(ctx, candidate) {
+  const audit = buildEntityFamilyConvergenceAudit(candidate);
+  const canonicalEntityPrefix = candidate.canonicalEntityPrefix;
+  const durablesToRewrite = collectEntityFamilyDurablesToRewrite(ctx.workingSet.projectedDurables, candidate);
+  if (!canonicalEntityPrefix || !candidate.autoConverge || durablesToRewrite.length === 0) {
+    const proposedClaimKeys = canonicalEntityPrefix ? mapEntityFamilyClaimKeys(candidate.claimKeys, candidate.entityPrefixes, canonicalEntityPrefix) : [];
+    return {
+      kind: "propose_unresolved",
+      audit,
+      proposedClaimKeys,
+      source: canonicalEntityPrefix ? "entity_family_canonical_candidate" : "entity_family_ambiguous",
+      eligibleForApply: proposedClaimKeys.length === 1
+    };
+  }
+  const rewrites = [];
+  for (const durable of durablesToRewrite) {
+    const targetClaimKey = resolveEntityFamilyTargetClaimKey(durable, canonicalEntityPrefix);
+    if (!targetClaimKey) {
+      continue;
+    }
+    const activeSiblingIds = resolveCrossTypeCollisionSiblingIds(ctx.workingSet.projectedDurables, targetClaimKey, durable);
+    if (activeSiblingIds.length > 0) {
+      return {
+        kind: "propose_cross_type_collision",
+        audit,
+        targetClaimKey,
+        activeSiblingIds,
+        proposedClaimKeys: mapEntityFamilyClaimKeys(candidate.claimKeys, candidate.entityPrefixes, canonicalEntityPrefix)
+      };
+    }
+    const oldClaimKey = durable.claim_key?.trim();
+    if (!oldClaimKey) {
+      continue;
+    }
+    rewrites.push({
+      durable,
+      targetClaimKey,
+      oldClaimKey,
+      attribute: targetClaimKey.slice(canonicalEntityPrefix.length + 1)
+    });
+  }
+  return {
+    kind: "auto_apply",
+    audit,
+    rewrites
+  };
+}
+async function executeEntityFamilyDecision(ctx, candidate, decision) {
+  switch (decision.kind) {
+    case "propose_unresolved": {
+      await persistReconcileProposal(ctx, {
+        ...buildEntityFamilyPersistInput(candidate, {
+          audit: decision.audit,
+          proposedClaimKeys: decision.proposedClaimKeys,
+          durableIds: candidate.durableIds,
+          rationale: buildEntityFamilyConvergenceRationale(candidate),
+          source: decision.source,
+          eligibleForApply: decision.eligibleForApply
+        }),
+        onPersisted: (passCtx) => {
+          passCtx.telemetry.entityFamilyDecisionStats.proposedClusters += 1;
+        }
+      });
+      return;
+    }
+    case "propose_cross_type_collision": {
+      await persistCrossTypeCollisionProposal(ctx, {
+        ...buildEntityFamilyPersistInput(candidate, {
+          audit: decision.audit,
+          proposedClaimKeys: decision.proposedClaimKeys,
+          durableIds: expandCrossTypeCollisionDurableIds(candidate.durableIds, decision.activeSiblingIds),
+          rationale: `${buildEntityFamilyConvergenceRationale(candidate)} Auto-convergence would collide with an active durable of a different type at "${decision.targetClaimKey}".`,
+          source: "entity_family_collision",
+          eligibleForApply: false
+        }),
+        onPersisted: (passCtx) => {
+          passCtx.telemetry.entityFamilyDecisionStats.proposedClusters += 1;
+        }
+      });
+      return;
+    }
+    case "auto_apply": {
+      let appliedDurables = 0;
+      for (const rewrite of decision.rewrites) {
+        await applyClaimKeyRepair(
+          ctx,
+          rewrite.durable.id,
+          rewrite.targetClaimKey,
+          {
+            issueKind: "entity_family_convergence",
+            oldClaimKey: rewrite.oldClaimKey,
+            source: "entity_family_auto_convergence",
+            confidence: candidate.confidence,
+            rationale: `${buildEntityFamilyConvergenceRationale(candidate)} This durable keeps attribute "${rewrite.attribute}" while converging its entity prefix onto "${candidate.canonicalEntityPrefix}".`,
+            entityFamilyAudit: decision.audit
+          },
+          {
+            onIdentified: () => {
+              ctx.telemetry.counts.identifiedEntityFamilyConvergences += 1;
+            },
+            onApplied: () => {
+              ctx.telemetry.counts.appliedEntityFamilyConvergences += 1;
+              appliedDurables += 1;
+            }
+          }
+        );
+        if (ctx.telemetry.circuitBreaker) {
+          return;
+        }
+      }
+      if (appliedDurables > 0) {
+        ctx.telemetry.entityFamilyDecisionStats.appliedClusters += 1;
+        ctx.telemetry.entityFamilyDecisionStats.appliedDurables += appliedDurables;
+      }
+    }
+  }
+}
+
+// src/app/dreaming/reconcile/helpers/claim-extraction.ts
+function claimExtractionUsage(llms) {
+  return llms.reduce(
+    (total, llm) => {
+      const usage = llm.metadata?.usage;
+      total.inputTokens += usage?.inputTokens ?? 0;
+      total.outputTokens += usage?.outputTokens ?? 0;
+      total.estimatedCostUsd += usage?.totalCost ?? 0;
+      return total;
+    },
+    {
+      inputTokens: 0,
+      outputTokens: 0,
+      estimatedCostUsd: 0
+    }
+  );
+}
+function resolveClaimExtractionConcurrency(config) {
+  const concurrency = config.concurrency;
+  const normalized = typeof concurrency === "number" ? Math.trunc(concurrency) : Number.NaN;
+  if (!Number.isFinite(normalized) || normalized <= 0) {
+    return DEFAULT_CLAIM_EXTRACTION_CONCURRENCY;
+  }
+  return normalized;
+}
+
+// src/app/dreaming/reconcile/helpers/stats.ts
+function createEmptyMissingBackfillDecisionStats() {
+  return {
+    autoAppliedTrustedGroupReuse: 0,
+    autoAppliedDeterministicRepair: 0,
+    autoAppliedMetadataRepair: 0,
+    autoAppliedSupportedPreview: 0,
+    autoAppliedGroundedFamilyPromotion: 0,
+    autoAppliedRelaxedStableSlotPromotion: 0,
+    autoAppliedPreviewModel: 0,
+    autoAppliedCompactedCandidate: 0,
+    proposedTrustedGroupReuse: 0,
+    proposedSupportedCandidate: 0,
+    proposedGroundedFamilyPromotion: 0,
+    proposedRelaxedStableSlotPromotion: 0,
+    proposedPreviewCandidate: 0,
+    proposedCompactedCandidate: 0,
+    noClaimWithWarnings: 0
+  };
+}
+function createEmptySiblingSlotResonanceShadowStats() {
+  return {
+    thresholdOnlyCandidateCount: 0,
+    resonanceApplicableCount: 0,
+    resonanceFiredCount: 0,
+    shadowQualifiedCount: 0,
+    resonanceFiredClaimKeys: [],
+    shadowQualifiedClaimKeys: [],
+    buckets: new Map(
+      SHADOW_BUCKET_ORDER.map((bucket) => [
+        bucket,
+        {
+          candidateCount: 0,
+          resonanceApplicableCount: 0,
+          resonanceFiredCount: 0,
+          shadowQualifiedCount: 0
+        }
+      ])
+    )
+  };
+}
+function createEmptyEntityFamilyConvergenceDecisionStats() {
+  return {
+    appliedClusters: 0,
+    appliedDurables: 0,
+    proposedClusters: 0
+  };
+}
+function createEmptyRepairCounts() {
+  return {
+    identifiedNormalizations: 0,
+    appliedNormalizations: 0,
+    identifiedBackfills: 0,
+    appliedBackfills: 0,
+    identifiedMetadataRewrites: 0,
+    appliedMetadataRewrites: 0,
+    identifiedEntityFamilyConvergences: 0,
+    appliedEntityFamilyConvergences: 0,
+    proposalsEmitted: 0,
+    skippedNoClaim: 0,
+    skippedLowConfidence: 0,
+    skippedCollision: 0,
+    flaggedAmbiguousProposals: 0
+  };
+}
+function createEmptySuggestionRecord() {
+  return {
+    suggestion: null,
+    warnings: [],
+    previewOutcome: null
+  };
+}
+function cloneRepairCounts(counts) {
+  return {
+    identifiedNormalizations: counts.identifiedNormalizations,
+    appliedNormalizations: counts.appliedNormalizations,
+    identifiedBackfills: counts.identifiedBackfills,
+    appliedBackfills: counts.appliedBackfills,
+    identifiedMetadataRewrites: counts.identifiedMetadataRewrites,
+    appliedMetadataRewrites: counts.appliedMetadataRewrites,
+    identifiedEntityFamilyConvergences: counts.identifiedEntityFamilyConvergences,
+    appliedEntityFamilyConvergences: counts.appliedEntityFamilyConvergences,
+    proposalsEmitted: counts.proposalsEmitted,
+    skippedNoClaim: counts.skippedNoClaim,
+    skippedLowConfidence: counts.skippedLowConfidence,
+    skippedCollision: counts.skippedCollision,
+    flaggedAmbiguousProposals: counts.flaggedAmbiguousProposals
+  };
+}
+
+// src/app/dreaming/reconcile/helpers/trusted-hints.ts
+function buildTrustedCleanupHintSeed(durables) {
+  const sharedSeed = buildTrustedClaimKeySupportSeed(durables);
+  const claimKeyExamples = normalizeStringArray(sharedSeed.entries.map((durable) => durable.claimKey)).slice(0, MAX_CLEANUP_CLAIM_KEY_HINTS);
+  const entityHints = normalizeStringArray(claimKeyExamples.map((claimKey) => claimKey.split("/", 1)[0] ?? "").filter((entity) => entity.length > 0)).slice(
+    0,
+    MAX_CLEANUP_ENTITY_HINTS
+  );
+  return {
+    globalEntityHints: entityHints,
+    globalClaimKeyExamples: claimKeyExamples,
+    durables: sharedSeed.entries
+  };
+}
+function buildCleanupHintsForDurable(baseHints, durable) {
+  const rankedDurables = baseHints.durables.map((trustedDurable) => ({
+    trustedDurable,
+    score: scoreTrustedHintRelevance(durable, trustedDurable)
+  })).filter((candidate) => candidate.score > 0).sort((left, right) => {
+    const scoreDelta = right.score - left.score;
+    if (scoreDelta !== 0) {
+      return scoreDelta;
+    }
+    const createdAtDelta = right.trustedDurable.createdAt.localeCompare(left.trustedDurable.createdAt);
+    if (createdAtDelta !== 0) {
+      return createdAtDelta;
+    }
+    return left.trustedDurable.claimKey.localeCompare(right.trustedDurable.claimKey);
+  });
+  const relevantClaimKeyExamples = rankedDurables.map((candidate) => candidate.trustedDurable.claimKey);
+  const claimKeyExamples = normalizeStringArray([...relevantClaimKeyExamples, ...baseHints.globalClaimKeyExamples]).slice(0, MAX_CLEANUP_CLAIM_KEY_HINTS);
+  const entityHints = normalizeStringArray([
+    ...rankedDurables.map((candidate) => candidate.trustedDurable.entity),
+    ...claimKeyExamples.map((claimKey) => claimKey.split("/", 1)[0] ?? ""),
+    ...baseHints.globalEntityHints
+  ]).slice(0, MAX_CLEANUP_ENTITY_HINTS);
+  return {
+    entityHints,
+    claimKeyExamples,
+    project: durable.project,
+    userId: durable.user_id,
+    tags: normalizeGroundingTags(durable.tags),
+    sourceContext: durable.source_context
+  };
+}
+function scoreTrustedHintRelevance(durable, trustedDurable) {
+  const durableTagSet = new Set(normalizeGroundingTags(durable.tags));
+  const durableSourceTokens = new Set(tokenizeGroundingText(durable.source_context));
+  const durableSubjectTokens = new Set(tokenizeGroundingText(durable.subject));
+  const tagOverlap = countSetOverlap(durableTagSet, trustedDurable.tags);
+  const sourceOverlap = countSetOverlap(durableSourceTokens, trustedDurable.sourceContextTokens);
+  const subjectOverlap = countSetOverlap(durableSubjectTokens, trustedDurable.subjectTokens);
+  return tagOverlap * 6 + sourceOverlap * 5 + subjectOverlap * 2 + (durable.type === trustedDurable.type ? 1 : 0);
+}
+
+// src/app/dreaming/reconcile/pass-suggestion-handlers.ts
+function shouldPreloadSuggestions(ctx) {
+  return ctx.extraction.claimExtractionConfig.enabled && typeof ctx.deps.createClaimExtractionLlm === "function";
+}
+function shouldPreviewMissingDurable(ctx, item) {
+  return findTrustedGroupReuseCandidate(ctx.workingSet.projectedDurables, ctx.workingSet.trustedReusableDurableIds, item.durable) === null;
+}
+function shouldPreloadSuspectSuggestion(ctx, item) {
+  if (!ctx.extraction.claimExtractionConfig.eligibleTypes.includes(item.durable.type)) {
+    return false;
+  }
+  if (item.inspection.kind !== "suspect") {
+    return false;
+  }
+  const metadataRepair = resolveExplicitMetadataRepair(item.durable, item.inspection.inspection);
+  return metadataRepair === null || findClaimKeyOccupants(ctx.workingSet.projectedDurables, metadataRepair, item.durable.id).length > 0;
+}
+async function preloadSuggestionsForStage(ctx, durables) {
+  if (durables.length === 0 || !shouldPreloadSuggestions(ctx)) {
+    return;
+  }
+  if (ctx.options.costCapUsd <= 0) {
+    ctx.telemetry.terminalStatus = "cost_capped";
+    ctx.telemetry.terminalError = "Cost cap exhausted before previewing claim-key repairs.";
+    return;
+  }
+  const workerCount = Math.min(ctx.extraction.previewConcurrency, durables.length);
+  let nextIndex = 0;
+  await Promise.all(
+    Array.from({ length: workerCount }, async () => {
+      const llm = createTrackedClaimExtractionLlm(ctx);
+      while (true) {
+        if (ctx.telemetry.terminalStatus !== "completed") {
+          return;
+        }
+        if (markAbortedIfSignalled(ctx)) {
+          return;
+        }
+        const currentIndex = nextIndex;
+        nextIndex += 1;
+        if (currentIndex >= durables.length) {
+          return;
+        }
+        const durable = durables[currentIndex];
+        if (!durable) {
+          return;
+        }
+        await loadSuggestion(ctx, durable, llm);
+        ctx.progressTracker.advancePreview();
+      }
+    })
+  );
+}
+async function loadSuggestion(ctx, durable, llmOverride) {
+  const cached = ctx.extraction.suggestionCache.get(durable.id);
+  if (cached) {
+    return cached;
+  }
+  if (!ctx.extraction.claimExtractionConfig.enabled || !ctx.extraction.claimExtractionConfig.eligibleTypes.includes(durable.type)) {
+    const empty = createEmptySuggestionRecord();
+    ctx.extraction.suggestionCache.set(durable.id, empty);
+    return empty;
+  }
+  if (ctx.options.costCapUsd <= 0) {
+    ctx.telemetry.terminalStatus = "cost_capped";
+    ctx.telemetry.terminalError = "Cost cap exhausted before previewing claim-key repairs.";
+    const empty = createEmptySuggestionRecord();
+    ctx.extraction.suggestionCache.set(durable.id, empty);
+    return empty;
+  }
+  const llm = llmOverride ?? getFallbackClaimExtractionLlm(ctx);
+  if (!llm) {
+    const empty = createEmptySuggestionRecord();
+    ctx.extraction.suggestionCache.set(durable.id, empty);
+    return empty;
+  }
+  const warnings = [];
+  let previewOutcome = null;
+  let suggestion;
+  try {
+    suggestion = await previewClaimKeyExtraction(
+      {
+        type: durable.type,
+        subject: durable.subject,
+        content: durable.content
+      },
+      llm,
+      ctx.extraction.claimExtractionConfig,
+      {
+        hints: buildCleanupHintsForDurable(ctx.workingSet.trustedHints, durable),
+        onWarning: (warning) => warnings.push(warning),
+        onPreviewOutcome: (outcome) => {
+          previewOutcome = outcome;
+        }
+      }
+    );
+  } catch (error) {
+    warnings.push(error instanceof Error ? error.message : String(error));
+    suggestion = null;
+  }
+  const record = { suggestion, warnings, previewOutcome };
+  ctx.extraction.suggestionCache.set(durable.id, record);
+  const usage = claimExtractionUsage(ctx.extraction.claimExtractionLlms);
+  if (ctx.telemetry.terminalStatus === "completed" && usage.estimatedCostUsd >= ctx.options.costCapUsd) {
+    ctx.telemetry.terminalStatus = "cost_capped";
+    ctx.telemetry.terminalError = `Cost cap exceeded while previewing claim-key repairs at ${usage.estimatedCostUsd.toFixed(4)} USD.`;
+  }
+  return record;
+}
+async function loadSuggestionIfContinuing(ctx, durable, llmOverride) {
+  const record = await loadSuggestion(ctx, durable, llmOverride);
+  if (ctx.telemetry.terminalStatus !== "completed") {
+    return null;
+  }
+  return record;
+}
+function getFallbackClaimExtractionLlm(ctx) {
+  if (ctx.extraction.fallbackClaimExtractionLlm !== void 0) {
+    return ctx.extraction.fallbackClaimExtractionLlm;
+  }
+  ctx.extraction.fallbackClaimExtractionLlm = createTrackedClaimExtractionLlm(ctx);
+  return ctx.extraction.fallbackClaimExtractionLlm;
+}
+function createTrackedClaimExtractionLlm(ctx) {
+  const llm = ctx.deps.createClaimExtractionLlm ? ctx.deps.createClaimExtractionLlm() : null;
+  if (llm && !ctx.extraction.claimExtractionLlms.includes(llm)) {
+    ctx.extraction.claimExtractionLlms.push(llm);
+  }
+  return llm;
+}
+
+// src/app/dreaming/reconcile/handlers/invalid-durable.ts
+async function processInvalidOrNoncanonicalDurable(ctx, item) {
+  const { durable, inspection } = item;
+  if (inspection.kind !== "malformed" && inspection.kind !== "noncanonical") {
+    return;
+  }
+  if (inspection.kind === "malformed") {
+    const suggestionRecord = await loadSuggestion(ctx, durable);
+    await persistReconcileProposal(ctx, buildMalformedClaimKeyPersistInput(durable, inspection, suggestionRecord));
+    return;
+  }
+  const targetClaimKey = inspection.normalized.claimKey;
+  const collision = findClaimKeyOccupants(ctx.workingSet.projectedDurables, targetClaimKey, durable.id);
+  if (collision.length > 0) {
+    ctx.telemetry.counts.skippedCollision += 1;
+    recordCollisionOutcome(ctx);
+    await persistReconcileProposal(ctx, {
+      groupId: `claim-key-normalize:${durable.id}`,
+      issueKind: "noncanonical_claim_key",
+      scope: "single_durable",
+      durableIds: [durable.id],
+      currentClaimKeys: [durable.claim_key ?? ""],
+      proposedClaimKeys: [targetClaimKey],
+      rationale: `Canonical normalization would change "${durable.claim_key}" to "${targetClaimKey}", but that canonical key is already occupied by ${collision.length} other matched durable${collision.length === 1 ? "" : "s"}.`,
+      confidence: 0.99,
+      source: "normalize",
+      eligibleForApply: true,
+      lifecycle: {
+        proposedClaimKeys: [targetClaimKey],
+        source: "normalize",
+        rawClaimKey: durable.claim_key ?? null
+      }
+    });
+    return;
+  }
+  await applyClaimKeyRepair(
+    ctx,
+    durable.id,
+    targetClaimKey,
+    {
+      issueKind: "noncanonical_claim_key",
+      oldClaimKey: durable.claim_key ?? null,
+      source: "normalize",
+      confidence: 0.99,
+      rationale: `Canonical normalization preserves the slot while rewriting "${durable.claim_key}" to "${targetClaimKey}".`
+    },
+    {
+      onIdentified: () => {
+        ctx.telemetry.counts.identifiedNormalizations += 1;
+      },
+      onApplied: () => {
+        ctx.telemetry.counts.appliedNormalizations += 1;
+      },
+      registerTrustedReuse: true
+    }
+  );
+}
+
+// src/core/claim-key-slot-resonance.ts
+var FAMILY_GENERIC_TOKEN_MIN_COUNT = 3;
+var FAMILY_GENERIC_TOKEN_RATIO = 0.5;
+var MIN_RESONANT_SHARED_TOKENS = 2;
+var MIN_RESONANT_SHAPE_COUNT = 2;
+function evaluateSiblingSlotResonance(input) {
+  const candidateTokens = extractAttributeTokens(input.candidateClaimKey);
+  const groundedSiblingAttributes = input.groundedSiblings.map((sibling) => ({
+    entryId: sibling.entryId,
+    claimKey: sibling.claimKey,
+    tokens: extractAttributeTokens(sibling.claimKey)
+  })).filter((sibling) => sibling.tokens.length > 0);
+  if (candidateTokens.length < MIN_RESONANT_SHARED_TOKENS || groundedSiblingAttributes.length === 0) {
+    return createEmptySiblingSlotResonanceEvaluation(groundedSiblingAttributes.length);
+  }
+  const familyTokenFrequency = countFamilyTokenFrequency(groundedSiblingAttributes.map((sibling) => sibling.tokens));
+  const familyGenericCutoff = Math.max(FAMILY_GENERIC_TOKEN_MIN_COUNT, Math.ceil(groundedSiblingAttributes.length * FAMILY_GENERIC_TOKEN_RATIO));
+  const familyGenericTokens = candidateTokens.filter((token) => (familyTokenFrequency.get(token) ?? 0) >= familyGenericCutoff);
+  const discriminativeCandidateTokens = candidateTokens.filter((token) => !familyGenericTokens.includes(token));
+  const localLexicalTokenSet = new Set(input.localLexicalTokens);
+  const resonantShapes = /* @__PURE__ */ new Map();
+  let resonantSiblingCount = 0;
+  for (const sibling of groundedSiblingAttributes) {
+    const resonanceShapeTokens = resolveResonanceShapeTokens(candidateTokens, discriminativeCandidateTokens, sibling.tokens);
+    if (resonanceShapeTokens.length < MIN_RESONANT_SHARED_TOKENS) {
+      continue;
+    }
+    resonantSiblingCount += 1;
+    const resonanceShape = resonanceShapeTokens.join("_");
+    const existing = resonantShapes.get(resonanceShape);
+    if (existing) {
+      existing.siblingEntryIds.push(sibling.entryId);
+      existing.siblingClaimKeys.push(sibling.claimKey);
+      continue;
+    }
+    resonantShapes.set(resonanceShape, {
+      siblingEntryIds: [sibling.entryId],
+      siblingClaimKeys: [sibling.claimKey]
+    });
+  }
+  const dominantShapeEntry = [...resonantShapes.entries()].sort((left, right) => {
+    const countDelta = right[1].siblingEntryIds.length - left[1].siblingEntryIds.length;
+    if (countDelta !== 0) {
+      return countDelta;
+    }
+    const tokenCountDelta = right[0].split("_").length - left[0].split("_").length;
+    if (tokenCountDelta !== 0) {
+      return tokenCountDelta;
+    }
+    return left[0].localeCompare(right[0]);
+  })[0];
+  const dominantShape = dominantShapeEntry?.[0] ?? null;
+  const dominantShapeCount = dominantShapeEntry?.[1].siblingEntryIds.length ?? 0;
+  const dominantShapeTokens = dominantShape ? dominantShape.split("_").filter((token) => token.length > 0) : [];
+  const localShapeTokenCoverage = dominantShapeTokens.length > 0 ? dominantShapeTokens.filter((token) => localLexicalTokenSet.has(token)).length / dominantShapeTokens.length : 0;
+  const fired = dominantShapeTokens.length >= MIN_RESONANT_SHARED_TOKENS && dominantShapeCount >= MIN_RESONANT_SHAPE_COUNT && localShapeTokenCoverage === 1;
+  return {
+    applicable: true,
+    fired,
+    groundedSiblingCount: groundedSiblingAttributes.length,
+    resonantSiblingCount,
+    dominantShape,
+    dominantShapeCount,
+    dominantShapeGroundedShare: groundedSiblingAttributes.length > 0 ? dominantShapeCount / groundedSiblingAttributes.length : 0,
+    localShapeTokenCoverage,
+    discriminativeCandidateTokens,
+    familyGenericTokens,
+    dominantSiblingEntryIds: dominantShapeEntry ? [...dominantShapeEntry[1].siblingEntryIds] : [],
+    dominantSiblingClaimKeys: dominantShapeEntry ? [...dominantShapeEntry[1].siblingClaimKeys] : []
+  };
+}
+function createEmptySiblingSlotResonanceEvaluation(groundedSiblingCount) {
+  return {
+    applicable: false,
+    fired: false,
+    groundedSiblingCount,
+    resonantSiblingCount: 0,
+    dominantShape: null,
+    dominantShapeCount: 0,
+    dominantShapeGroundedShare: 0,
+    localShapeTokenCoverage: 0,
+    discriminativeCandidateTokens: [],
+    familyGenericTokens: [],
+    dominantSiblingEntryIds: [],
+    dominantSiblingClaimKeys: []
+  };
+}
+function extractAttributeTokens(claimKey) {
+  const compacted = compactClaimKey(claimKey);
+  if (compacted) {
+    return compacted.attribute.split("_").filter((token) => token.length > 0);
+  }
+  const normalized = normalizeClaimKey(claimKey);
+  if (!normalized.ok) {
+    return [];
+  }
+  return normalized.value.attribute.split("_").filter((token) => token.length > 0);
+}
+function countFamilyTokenFrequency(attributes) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const tokens of attributes) {
+    for (const token of new Set(tokens)) {
+      counts.set(token, (counts.get(token) ?? 0) + 1);
+    }
+  }
+  return counts;
+}
+function resolveResonanceShapeTokens(candidateTokens, discriminativeCandidateTokens, siblingTokens) {
+  const siblingTokenSet = new Set(siblingTokens);
+  const sharedTokens = candidateTokens.filter((token) => siblingTokenSet.has(token));
+  if (sharedTokens.length < MIN_RESONANT_SHARED_TOKENS) {
+    return [];
+  }
+  const sharedDiscriminativeTokens = discriminativeCandidateTokens.filter((token) => siblingTokenSet.has(token));
+  const sharedSpan = findLongestSharedContiguousSpan(candidateTokens, siblingTokens);
+  if (sharedSpan.length >= MIN_RESONANT_SHARED_TOKENS) {
+    return sharedSpan;
+  }
+  const candidateHead = candidateTokens[candidateTokens.length - 1];
+  const siblingHead = siblingTokens[siblingTokens.length - 1];
+  if (candidateHead && siblingHead && candidateHead === siblingHead && sharedDiscriminativeTokens.length >= 1) {
+    return dedupeOrderedTokens([...sharedDiscriminativeTokens, candidateHead]);
+  }
+  if (sharedDiscriminativeTokens.length >= MIN_RESONANT_SHARED_TOKENS) {
+    return sharedDiscriminativeTokens;
+  }
+  return [];
+}
+function findLongestSharedContiguousSpan(candidateTokens, siblingTokens) {
+  let best = [];
+  for (let start = 0; start < candidateTokens.length; start += 1) {
+    for (let end = start + MIN_RESONANT_SHARED_TOKENS; end <= candidateTokens.length; end += 1) {
+      const span = candidateTokens.slice(start, end);
+      if (span.length < best.length) {
+        continue;
+      }
+      if (includesContiguousSpan(siblingTokens, span)) {
+        if (span.length > best.length || span.join("_").localeCompare(best.join("_")) < 0) {
+          best = span;
+        }
+      }
+    }
+  }
+  return best;
+}
+function includesContiguousSpan(tokens, span) {
+  if (span.length === 0 || span.length > tokens.length) {
+    return false;
+  }
+  for (let start = 0; start <= tokens.length - span.length; start += 1) {
+    let matched = true;
+    for (let index = 0; index < span.length; index += 1) {
+      if (tokens[start + index] !== span[index]) {
+        matched = false;
+        break;
+      }
+    }
+    if (matched) {
+      return true;
+    }
+  }
+  return false;
+}
+function dedupeOrderedTokens(tokens) {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const token of tokens) {
+    if (seen.has(token)) {
+      continue;
+    }
+    seen.add(token);
+    deduped.push(token);
+  }
+  return deduped;
+}
+
+// src/app/dreaming/reconcile/helpers/suggestions.ts
+function evaluateMissingBackfillSupport(durable, targetClaimKey, trustedHints) {
+  const support = evaluateClaimKeySupport(durable, targetClaimKey, { entries: trustedHints.durables });
+  const inspection = inspectClaimKey(targetClaimKey);
+  const normalized = inspection.normalized;
+  if (!normalized) {
+    return {
+      ...support,
+      siblingSlotResonance: createEmptySiblingSlotResonanceEvaluation(0)
+    };
+  }
+  return {
+    ...support,
+    siblingSlotResonance: evaluateSiblingSlotResonance({
+      candidateClaimKey: normalized.claimKey,
+      localLexicalTokens: buildDurableLocalLexicalTokens(durable),
+      groundedSiblings: support.supportingDurableIds.map((durableId) => trustedHints.durables.find((trustedDurable) => trustedDurable.id === durableId)).filter((trustedDurable) => Boolean(trustedDurable)).map((trustedDurable) => ({
+        entryId: trustedDurable.id,
+        claimKey: trustedDurable.claimKey
+      }))
+    })
+  };
+}
+function resolveMissingBackfillNullOutcome(suggestionRecord) {
+  if (suggestionRecord.previewOutcome?.outcome === "no_claim") {
+    return "no_claim";
+  }
+  if (suggestionRecord.previewOutcome?.outcome === "rejected_candidate") {
+    return "rejected_candidate";
+  }
+  if (suggestionRecord.warnings.some((warning) => /json|unexpected token|unterminated|position \d+/iu.test(warning))) {
+    return "malformed_output";
+  }
+  return "rejected_candidate";
+}
+
+// src/app/dreaming/reconcile/helpers/missing-backfill-stats.ts
+function recordMissingBackfillNoClaimOutcome(ctx, durable, suggestionRecord) {
+  if (suggestionRecord.warnings.length > 0) {
+    ctx.telemetry.missingDecisionStats.noClaimWithWarnings += 1;
+  }
+  ctx.telemetry.counts.skippedNoClaim += 1;
+  ctx.telemetry.skippedDiagnostics.push(
+    buildMissingBackfillSkipDiagnostic(durable, suggestionRecord, {
+      outcomeOverride: resolveMissingBackfillNullOutcome(suggestionRecord)
+    })
+  );
+}
+function recordMissingBackfillLowConfidenceSkip(ctx, durable, suggestionRecord, targetClaimKey) {
+  ctx.telemetry.counts.skippedLowConfidence += 1;
+  ctx.telemetry.skippedDiagnostics.push(
+    buildMissingBackfillSkipDiagnostic(durable, suggestionRecord, {
+      outcomeOverride: "low_confidence_candidate",
+      suggestedClaimKey: targetClaimKey
+    })
+  );
+}
+function recordMissingBackfillProposalLaneOutcome(ctx, resolved) {
+  if (resolved.metadataBackfillClaimKey !== null || resolved.suggestion.path === "deterministic_repair" || resolved.support.supportedProposal) {
+    ctx.telemetry.missingDecisionStats.proposedSupportedCandidate += 1;
+  } else {
+    ctx.telemetry.missingDecisionStats.proposedPreviewCandidate += 1;
+  }
+}
+function recordMissingBackfillProposalPersisted(ctx, resolved) {
+  recordGroundedFamilyPromotionDecision(ctx.telemetry.missingDecisionStats, resolved.support, "proposal");
+  if (resolved.compactness.compactedFrom) {
+    ctx.telemetry.missingDecisionStats.proposedCompactedCandidate += 1;
+  }
+}
+function recordMissingBackfillAutoApplyIdentified(ctx) {
+  ctx.telemetry.counts.identifiedBackfills += 1;
+}
+function recordMissingBackfillAutoApplyApplied(ctx) {
+  ctx.telemetry.counts.appliedBackfills += 1;
+}
+function recordMissingBackfillAutoApplyProjected(ctx, resolved) {
+  if (resolved.metadataBackfillClaimKey !== null) {
+    ctx.telemetry.missingDecisionStats.autoAppliedMetadataRepair += 1;
+  } else if (resolved.suggestion.path === "deterministic_repair") {
+    ctx.telemetry.missingDecisionStats.autoAppliedDeterministicRepair += 1;
+  } else if (resolved.support.autoApplyClass !== null && resolved.suggestion.confidence < HIGH_CONFIDENCE_BACKFILL_THRESHOLD) {
+    ctx.telemetry.missingDecisionStats.autoAppliedSupportedPreview += 1;
+  } else {
+    ctx.telemetry.missingDecisionStats.autoAppliedPreviewModel += 1;
+  }
+  recordGroundedFamilyPromotionDecision(ctx.telemetry.missingDecisionStats, resolved.support, "auto_apply");
+  if (resolved.compactness.compactedFrom) {
+    ctx.telemetry.missingDecisionStats.autoAppliedCompactedCandidate += 1;
+  }
+}
+function recordMissingBackfillTrustedGroupReuseProposed(ctx) {
+  ctx.telemetry.missingDecisionStats.proposedTrustedGroupReuse += 1;
+}
+function recordMissingBackfillTrustedGroupReuseAutoApplied(ctx) {
+  ctx.telemetry.missingDecisionStats.autoAppliedTrustedGroupReuse += 1;
+}
+
+// src/app/dreaming/reconcile/helpers/shadow-resonance.ts
+function buildSiblingSlotResonanceShadowSummary(stats) {
+  if (stats.thresholdOnlyCandidateCount === 0) {
+    return null;
+  }
+  const buckets = SHADOW_BUCKET_ORDER.map((bucket) => {
+    const bucketStats = stats.buckets.get(bucket);
+    return {
+      bucket,
+      candidateCount: bucketStats?.candidateCount ?? 0,
+      resonanceApplicableCount: bucketStats?.resonanceApplicableCount ?? 0,
+      resonanceFiredCount: bucketStats?.resonanceFiredCount ?? 0,
+      shadowQualifiedCount: bucketStats?.shadowQualifiedCount ?? 0
+    };
+  });
+  return {
+    rule: {
+      supportClass: "trusted_family_grounded_alignment",
+      minFamilyReuseCount: SHADOW_RESONANCE_MIN_FAMILY_REUSE_COUNT,
+      minGroundedRatio: SHADOW_RESONANCE_MIN_GROUNDED_RATIO,
+      minConfidence: SHADOW_RESONANCE_MIN_CONFIDENCE,
+      requiresSiblingSlotResonance: true
+    },
+    thresholdOnlyCandidateCount: stats.thresholdOnlyCandidateCount,
+    resonanceApplicableCount: stats.resonanceApplicableCount,
+    resonanceFiredCount: stats.resonanceFiredCount,
+    shadowQualifiedCount: stats.shadowQualifiedCount,
+    resonanceFiredClaimKeys: [...stats.resonanceFiredClaimKeys],
+    shadowQualifiedClaimKeys: [...stats.shadowQualifiedClaimKeys],
+    buckets
+  };
+}
+function resolveThresholdOnlyShadowBucket(support) {
+  if (support.relaxedStableSlotFamilyGate) {
+    return "relaxed_one_sibling_stable_slot";
+  }
+  if (support.autoApplyClass !== "trusted_family_grounded_alignment") {
+    return null;
+  }
+  const groundedRatio = support.familyReuseCount > 0 ? support.groundedFamilyReuseCount / support.familyReuseCount : 0;
+  if (support.familyReuseCount >= SHADOW_RESONANCE_MIN_FAMILY_REUSE_COUNT) {
+    return groundedRatio >= SHADOW_RESONANCE_MIN_GROUNDED_RATIO ? "high_density_grounded_family" : "large_grounding_diluted_grounded_family";
+  }
+  if (support.familyReuseCount <= 5) {
+    return "thin_grounded_family_tail";
+  }
+  return "other_grounded_family_alignment";
+}
+function buildMissingBackfillShadowAudit(input) {
+  if (input.autoApplyBlocker !== "below_auto_apply_threshold") {
+    return null;
+  }
+  const bucket = resolveThresholdOnlyShadowBucket(input.support);
+  if (!bucket) {
+    return null;
+  }
+  const groundedRatio = input.support.familyReuseCount > 0 ? input.support.groundedFamilyReuseCount / input.support.familyReuseCount : 0;
+  return {
+    thresholdOnlyBucket: bucket,
+    shadowWouldQualify: input.support.autoApplyClass === "trusted_family_grounded_alignment" && input.support.familyReuseCount >= SHADOW_RESONANCE_MIN_FAMILY_REUSE_COUNT && groundedRatio >= SHADOW_RESONANCE_MIN_GROUNDED_RATIO && input.confidence >= SHADOW_RESONANCE_MIN_CONFIDENCE && input.support.siblingSlotResonance.fired
+  };
+}
+function recordSiblingSlotResonanceShadowCandidate(stats, claimKey, support, shadow) {
+  stats.thresholdOnlyCandidateCount += 1;
+  if (support.siblingSlotResonance.applicable) {
+    stats.resonanceApplicableCount += 1;
+  }
+  if (support.siblingSlotResonance.fired) {
+    stats.resonanceFiredCount += 1;
+    stats.resonanceFiredClaimKeys = normalizeStringArray([...stats.resonanceFiredClaimKeys, claimKey]);
+  }
+  if (shadow.shadowWouldQualify) {
+    stats.shadowQualifiedCount += 1;
+    stats.shadowQualifiedClaimKeys = normalizeStringArray([...stats.shadowQualifiedClaimKeys, claimKey]);
+  }
+  const bucketStats = stats.buckets.get(shadow.thresholdOnlyBucket);
+  if (!bucketStats) {
+    return;
+  }
+  bucketStats.candidateCount += 1;
+  if (support.siblingSlotResonance.applicable) {
+    bucketStats.resonanceApplicableCount += 1;
+  }
+  if (support.siblingSlotResonance.fired) {
+    bucketStats.resonanceFiredCount += 1;
+  }
+  if (shadow.shadowWouldQualify) {
+    bucketStats.shadowQualifiedCount += 1;
+  }
+}
+
+// src/app/dreaming/reconcile/helpers/missing-backfill-rationale.ts
+function formatConfidence(confidence) {
+  return confidence.toFixed(2);
+}
+function hasMetadataGrounding(input) {
+  return input.metadataBackfillClaimKey !== null && input.originalClaimKey !== input.targetClaimKey;
+}
+function hasCompactionRewrite(input) {
+  return Boolean(input.compactness.compactedFrom && input.compactness.compactedFrom !== input.targetClaimKey);
+}
+function formatCompactionSuffix(input) {
+  if (!hasCompactionRewrite(input)) {
+    return "";
+  }
+  return ` The candidate was compacted from "${input.compactness.compactedFrom}" to "${input.targetClaimKey}" because ${input.compactness.compactionReason}.`;
+}
+function formatInlineCompactionClause(input) {
+  if (!hasCompactionRewrite(input)) {
+    return "";
+  }
+  return ` after safely compacting "${input.compactness.compactedFrom}" to "${input.targetClaimKey}" because ${input.compactness.compactionReason}`;
+}
+function formatApplyCompactionSuffix(input) {
+  if (!hasCompactionRewrite(input)) {
+    return "";
+  }
+  return ` The candidate was compacted from "${input.compactness.compactedFrom}" because ${input.compactness.compactionReason}.`;
+}
+function formatPreviewLead(input) {
+  if (hasMetadataGrounding(input)) {
+    return `Backfill preview suggested "${input.originalClaimKey}" at confidence ${formatConfidence(input.confidence)}, and explicit metadata safely grounds that candidate to "${input.targetClaimKey}".`;
+  }
+  if (hasCompactionRewrite(input)) {
+    return `Backfill preview suggested "${input.compactness.compactedFrom}" at confidence ${formatConfidence(input.confidence)}, and compact canonicalization safely shortened it to "${input.targetClaimKey}" because ${input.compactness.compactionReason}.`;
+  }
+  return `Backfill preview suggested "${input.targetClaimKey}" at confidence ${formatConfidence(input.confidence)}.`;
+}
+function buildMissingBackfillConflictRationale(input) {
+  return `${formatPreviewLead(input)}${formatCompactionSuffix(input)}`;
+}
+function buildMissingBackfillProposalRationale(input) {
+  if (!input.trusted) {
+    return `Backfill preview suggested "${input.targetClaimKey}" at confidence ${formatConfidence(input.confidence)}, but the proposed key is still structurally suspect.`;
+  }
+  if (!input.compactness.compactEnoughForAutoApply) {
+    return `Backfill preview suggested "${input.targetClaimKey}" at confidence ${formatConfidence(input.confidence)}${formatInlineCompactionClause(input)}, but the resulting slot name is still too verbose or awkward to auto-apply safely.`;
+  }
+  if (hasMetadataGrounding(input)) {
+    return `Backfill preview suggested "${input.originalClaimKey}" at confidence ${formatConfidence(input.confidence)}, and explicit metadata resolves that candidate to likely canonical key "${input.targetClaimKey}", but that supported repair stays below the auto-apply threshold of ${formatConfidence(input.autoApplyThreshold)}.`;
+  }
+  if (input.support.autoApplyClass !== null) {
+    const promotionLead = input.promotionLane === "compacted_supported" ? "Supported evidence remained strong after compact canonicalization" : `Supported evidence from ${describeMissingBackfillPromotionClass(input.support.autoApplyClass)} exists`;
+    return `Backfill preview suggested "${input.targetClaimKey}" at confidence ${formatConfidence(input.confidence)}. ${promotionLead} via ${input.support.rationaleFragments.join(", ")}, but the candidate stays below the auto-apply threshold of ${formatConfidence(input.autoApplyThreshold)}.`;
+  }
+  if (input.support.rationaleFragments.length > 0) {
+    return `Backfill preview suggested "${input.targetClaimKey}" at confidence ${formatConfidence(input.confidence)}. Structural support exists from ${input.support.rationaleFragments.join(", ")}, but the candidate stays below the auto-apply threshold of ${formatConfidence(input.autoApplyThreshold)}.`;
+  }
+  return `Backfill preview suggested "${input.targetClaimKey}" at confidence ${formatConfidence(input.confidence)}, below the auto-apply threshold of ${formatConfidence(input.autoApplyThreshold)}.`;
+}
+function buildMissingBackfillApplyRationale(input) {
+  if (hasMetadataGrounding(input)) {
+    return `Metadata-grounded claim-key backfill rewrote preview candidate "${input.originalClaimKey}" to "${input.targetClaimKey}" at confidence ${formatConfidence(input.confidence)} from ${input.source}.` + (hasCompactionRewrite(input) ? ` Compact canonicalization also shortened "${input.compactness.compactedFrom}" because ${input.compactness.compactionReason}.` : "");
+  }
+  if (input.support.autoApplyClass !== null && input.confidence < HIGH_CONFIDENCE_BACKFILL_THRESHOLD) {
+    const promotionPrefix = input.promotionLane === "compacted_supported" ? "Post-compaction supported claim-key backfill" : "Supported claim-key backfill";
+    return `${promotionPrefix} assigned "${input.targetClaimKey}" from ${input.source} at confidence ${formatConfidence(input.confidence)} through ${describeMissingBackfillPromotionClass(input.support.autoApplyClass)} using ${input.support.rationaleFragments.join(", ")}.` + formatApplyCompactionSuffix(input);
+  }
+  return `High-confidence claim-key backfill assigned "${input.targetClaimKey}" from ${input.source} at confidence ${formatConfidence(input.confidence)}.` + formatApplyCompactionSuffix(input);
+}
+function describeMissingBackfillPromotionClass(promotionClass) {
+  switch (promotionClass) {
+    case "trusted_exact_reuse_grounded":
+      return "trusted exact-key reuse with local grounding";
+    case "trusted_family_template_grounded":
+      return "trusted family reuse plus grounded template support";
+    case "trusted_family_stable_slot":
+      return "trusted family reuse plus a stable compact slot";
+    case "trusted_family_grounded_alignment":
+      return "trusted family reuse plus grounded dual lexical alignment";
+  }
+}
+
+// src/app/dreaming/reconcile/helpers/missing-backfill.ts
+function buildMissingBackfillSkipDiagnostic(durable, suggestionRecord, options) {
+  const previewPath = suggestionRecord.suggestion?.path ?? suggestionRecord.previewOutcome?.path ?? null;
+  const previewConfidence = suggestionRecord.suggestion?.confidence ?? (typeof suggestionRecord.previewOutcome?.confidence === "number" ? suggestionRecord.previewOutcome.confidence : null);
+  return {
+    durableId: durable.id,
+    outcome: options.outcomeOverride,
+    confidence: previewConfidence,
+    path: previewPath,
+    warning: suggestionRecord.warnings[0] ?? null,
+    suggestedClaimKey: options.suggestedClaimKey ?? suggestionRecord.suggestion?.claimKey ?? null
+  };
+}
+function formatMissingBackfillSkipDiagnostic(diagnostic) {
+  const parts = [
+    `missing_claim_key:${diagnostic.outcome}`,
+    diagnostic.path ? `path=${diagnostic.path}` : null,
+    typeof diagnostic.confidence === "number" ? `confidence=${diagnostic.confidence.toFixed(2)}` : null,
+    diagnostic.suggestedClaimKey ? `suggested=${diagnostic.suggestedClaimKey}` : null,
+    diagnostic.warning ? `warning=${diagnostic.warning}` : null
+  ].filter((value) => value !== null);
+  return parts.join(" ");
+}
+function resolveMissingBackfillPromotionPolicy(input) {
+  if (input.metadataRepaired) {
+    return {
+      lane: "metadata_rewrite",
+      autoApplyThreshold: STRUCTURED_AUTO_APPLY_BACKFILL_THRESHOLD
+    };
+  }
+  if (input.previewPath === "deterministic_repair") {
+    return {
+      lane: "deterministic_repair",
+      autoApplyThreshold: STRUCTURED_AUTO_APPLY_BACKFILL_THRESHOLD
+    };
+  }
+  if (input.support.autoApplyClass !== null && input.compactness.compactedFrom) {
+    return {
+      lane: "compacted_supported",
+      autoApplyThreshold: COMPACTED_SUPPORTED_AUTO_APPLY_BACKFILL_THRESHOLD
+    };
+  }
+  if (input.support.autoApplyClass !== null) {
+    return {
+      lane: "structured_supported",
+      autoApplyThreshold: STRUCTURED_AUTO_APPLY_BACKFILL_THRESHOLD
+    };
+  }
+  return {
+    lane: "high_confidence_preview",
+    autoApplyThreshold: HIGH_CONFIDENCE_BACKFILL_THRESHOLD
+  };
+}
+function resolveMissingBackfillProposalThreshold(input) {
+  if (input.metadataRepaired || input.previewPath === "deterministic_repair" || input.support.supportedProposal) {
+    return SUPPORTED_PROPOSAL_CONFIDENCE_THRESHOLD;
+  }
+  return PROPOSAL_CONFIDENCE_THRESHOLD;
+}
+function resolveMissingBackfillAutoApplyBlocker(input) {
+  if (!input.trusted) {
+    return "structurally_suspect_claim_key";
+  }
+  if (!input.compactness.compactEnoughForAutoApply) {
+    return input.compactness.blockerReason;
+  }
+  if (input.confidence < input.autoApplyThreshold) {
+    return "below_auto_apply_threshold";
+  }
+  return null;
+}
+function recordGroundedFamilyPromotionDecision(stats, support, decision) {
+  if (support.autoApplyClass === "trusted_family_grounded_alignment") {
+    if (decision === "auto_apply") {
+      stats.autoAppliedGroundedFamilyPromotion += 1;
+    } else {
+      stats.proposedGroundedFamilyPromotion += 1;
+    }
+  }
+  if (support.relaxedStableSlotFamilyGate) {
+    if (decision === "auto_apply") {
+      stats.autoAppliedRelaxedStableSlotPromotion += 1;
+    } else {
+      stats.proposedRelaxedStableSlotPromotion += 1;
+    }
+  }
+}
+function buildMissingBackfillResolvedPreview(durable, suggestion, ctx) {
+  const metadataBackfillClaimKey = resolveMetadataBackfillClaimKey(durable, suggestion.claimKey);
+  const originalClaimKey = suggestion.compactedFrom ?? suggestion.claimKey;
+  const compactness = evaluateClaimKeyCompactness(metadataBackfillClaimKey ?? suggestion.claimKey, {
+    priorCompactedFrom: suggestion.compactedFrom ?? null,
+    priorCompactionReason: suggestion.compactionReason ?? null
+  });
+  const targetClaimKey = compactness.claimKey;
+  const targetSource = metadataBackfillClaimKey ? "metadata_backfill_rewrite" : suggestion.path;
+  const support = evaluateMissingBackfillSupport(durable, targetClaimKey, ctx.workingSet.trustedHints);
+  const promotionPolicy = resolveMissingBackfillPromotionPolicy({
+    metadataRepaired: metadataBackfillClaimKey !== null,
+    previewPath: suggestion.path,
+    support,
+    compactness
+  });
+  return {
+    targetClaimKey,
+    targetSource,
+    originalClaimKey,
+    compactness,
+    promotionPolicy,
+    support,
+    suggestion,
+    metadataBackfillClaimKey
+  };
+}
+function evaluateMissingDurablePreview(durable, suggestionRecord, ctx) {
+  const suggestion = suggestionRecord.suggestion;
+  if (!suggestion?.claimKey) {
+    return { kind: "skip_no_claim", suggestionRecord };
+  }
+  const resolved = buildMissingBackfillResolvedPreview(durable, suggestion, ctx);
+  const targetInspection = inspectClaimKey(resolved.targetClaimKey);
+  const targetIsTrusted = targetInspection.suspectReasons.length === 0;
+  const autoApplyThreshold = resolved.promotionPolicy.autoApplyThreshold;
+  const proposalThreshold = resolveMissingBackfillProposalThreshold({
+    metadataRepaired: resolved.metadataBackfillClaimKey !== null,
+    previewPath: suggestion.path,
+    support: resolved.support
+  });
+  const activeSiblingIds = resolveCrossTypeCollisionSiblingIds(ctx.workingSet.projectedDurables, resolved.targetClaimKey, durable);
+  if (activeSiblingIds.length > 0) {
+    return {
+      kind: "propose_cross_type_collision",
+      activeSiblingIds,
+      ...resolved
+    };
+  }
+  if (!targetIsTrusted || !resolved.compactness.compactEnoughForAutoApply || suggestion.confidence < autoApplyThreshold) {
+    if (suggestion.confidence >= proposalThreshold) {
+      return {
+        kind: "propose_below_auto_apply",
+        autoApplyThreshold,
+        proposalThreshold,
+        targetIsTrusted,
+        ...resolved
+      };
+    }
+    return { kind: "skip_low_confidence", suggestionRecord, targetClaimKey: resolved.targetClaimKey };
+  }
+  return {
+    kind: "auto_apply",
+    ...resolved
+  };
+}
+async function executeMissingDurablePreviewDecision(ctx, durable, decision) {
+  switch (decision.kind) {
+    case "skip_no_claim": {
+      recordMissingBackfillNoClaimOutcome(ctx, durable, decision.suggestionRecord);
+      return;
+    }
+    case "propose_cross_type_collision": {
+      await persistMissingBackfillProposal(ctx, durable, decision, {
+        durableIds: [.../* @__PURE__ */ new Set([durable.id, ...decision.activeSiblingIds])],
+        rationale: appendCrossTypeCollisionRationaleSuffix(
+          buildMissingBackfillConflictRationale({
+            originalClaimKey: decision.originalClaimKey,
+            targetClaimKey: decision.targetClaimKey,
+            confidence: decision.suggestion.confidence,
+            metadataBackfillClaimKey: decision.metadataBackfillClaimKey,
+            compactness: decision.compactness
+          }),
+          decision.targetClaimKey
+        ),
+        audit: {}
+      });
+      return;
+    }
+    case "propose_below_auto_apply": {
+      const autoApplyBlocker = resolveMissingBackfillAutoApplyBlocker({
+        trusted: decision.targetIsTrusted,
+        compactness: decision.compactness,
+        confidence: decision.suggestion.confidence,
+        autoApplyThreshold: decision.autoApplyThreshold
+      });
+      const shadowAudit = buildMissingBackfillShadowAudit({
+        support: decision.support,
+        confidence: decision.suggestion.confidence,
+        autoApplyBlocker
+      });
+      await persistMissingBackfillProposal(ctx, durable, decision, {
+        durableIds: [durable.id],
+        rationale: buildMissingBackfillProposalRationale({
+          originalClaimKey: decision.originalClaimKey,
+          targetClaimKey: decision.targetClaimKey,
+          confidence: decision.suggestion.confidence,
+          autoApplyThreshold: decision.autoApplyThreshold,
+          promotionLane: decision.promotionPolicy.lane,
+          trusted: decision.targetIsTrusted,
+          metadataBackfillClaimKey: decision.metadataBackfillClaimKey,
+          compactness: decision.compactness,
+          support: decision.support
+        }),
+        audit: {
+          autoApplyBlocker,
+          shadow: shadowAudit ?? void 0
+        }
+      });
+      if (shadowAudit && ctx.options.includeShadowTelemetry === true) {
+        recordSiblingSlotResonanceShadowCandidate(ctx.telemetry.siblingSlotResonanceShadowStats, decision.targetClaimKey, decision.support, shadowAudit);
+      }
+      recordMissingBackfillProposalLaneOutcome(ctx, decision);
+      return;
+    }
+    case "skip_low_confidence": {
+      recordMissingBackfillLowConfidenceSkip(ctx, durable, decision.suggestionRecord, decision.targetClaimKey);
+      return;
+    }
+    case "auto_apply": {
+      await applyClaimKeyRepair(
+        ctx,
+        durable.id,
+        decision.targetClaimKey,
+        {
+          issueKind: "missing_claim_key",
+          oldClaimKey: null,
+          source: decision.targetSource,
+          confidence: decision.suggestion.confidence,
+          compactness: decision.compactness,
+          promotion: decision.promotionPolicy,
+          support: decision.support,
+          rawClaimKey: decision.originalClaimKey,
+          rationale: buildMissingBackfillApplyRationale({
+            originalClaimKey: decision.originalClaimKey,
+            targetClaimKey: decision.targetClaimKey,
+            confidence: decision.suggestion.confidence,
+            promotionLane: decision.promotionPolicy.lane,
+            source: decision.targetSource,
+            metadataBackfillClaimKey: decision.metadataBackfillClaimKey,
+            compactness: decision.compactness,
+            support: decision.support
+          })
+        },
+        {
+          onIdentified: () => {
+            recordMissingBackfillAutoApplyIdentified(ctx);
+          },
+          onApplied: () => {
+            recordMissingBackfillAutoApplyApplied(ctx);
+          },
+          onProjected: () => {
+            recordMissingBackfillAutoApplyProjected(ctx, decision);
+          }
+        }
+      );
+    }
+  }
+}
+async function persistMissingBackfillProposal(ctx, durable, resolved, input) {
+  await persistReconcileProposal(ctx, {
+    ...buildMissingBackfillPersistInput(durable, resolved, input),
+    onPersisted: (passCtx) => {
+      recordMissingBackfillProposalPersisted(passCtx, resolved);
+    }
+  });
+}
+
+// src/app/dreaming/reconcile/handlers/missing-durable.ts
+async function processMissingDurable(ctx, item) {
+  const { durable, inspection } = item;
+  if (inspection.kind !== "missing") {
+    return;
+  }
+  const trustedGroupReuse = findTrustedGroupReuseCandidate(ctx.workingSet.projectedDurables, ctx.workingSet.trustedReusableDurableIds, durable);
+  if (trustedGroupReuse) {
+    await executeTrustedGroupReuse(ctx, durable, trustedGroupReuse);
+    return;
+  }
+  const suggestionRecord = await loadSuggestionIfContinuing(ctx, durable);
+  if (!suggestionRecord) {
+    return;
+  }
+  const decision = evaluateMissingDurablePreview(durable, suggestionRecord, ctx);
+  await executeMissingDurablePreviewDecision(ctx, durable, decision);
+}
+async function executeTrustedGroupReuse(ctx, durable, trustedGroupReuse) {
+  const persistedCollision = await persistProposalWhenCrossTypeCollision(ctx, trustedGroupReuse.claimKey, durable, () => ({
+    ...buildTrustedGroupReusePersistInput(durable, trustedGroupReuse),
+    onPersisted: (passCtx) => {
+      recordMissingBackfillTrustedGroupReuseProposed(passCtx);
+    }
+  }));
+  if (persistedCollision) {
+    return;
+  }
+  await applyClaimKeyRepair(
+    ctx,
+    durable.id,
+    trustedGroupReuse.claimKey,
+    {
+      issueKind: "missing_claim_key",
+      oldClaimKey: null,
+      source: "trusted_group_reuse",
+      confidence: 0.99,
+      rationale: `Matched subject/type durables already use trusted canonical key "${trustedGroupReuse.claimKey}", so the missing key can safely reuse that established family from ${trustedGroupReuse.supportingDurableIds.length} supporting durable${trustedGroupReuse.supportingDurableIds.length === 1 ? "" : "s"}.`
+    },
+    {
+      onIdentified: () => {
+        recordMissingBackfillAutoApplyIdentified(ctx);
+      },
+      onApplied: () => {
+        recordMissingBackfillAutoApplyApplied(ctx);
+      },
+      onProjected: () => {
+        recordMissingBackfillTrustedGroupReuseAutoApplied(ctx);
+      }
+    }
+  );
+}
+
+// src/app/dreaming/reconcile/handlers/mixed-group.ts
+async function processMixedKeyGroup(ctx, group) {
+  const source = group.proposedClaimKey ? "mixed_group_consensus" : "mixed_group";
+  await persistReconcileProposal(ctx, {
+    groupId: `claim-key-mixed:${group.groupKey}`,
+    issueKind: "mixed_claim_key_group",
+    scope: "cluster",
+    durableIds: group.durables.map((durable) => durable.id),
+    currentClaimKeys: group.durables.flatMap((durable) => durable.claim_key ? [durable.claim_key] : []),
+    proposedClaimKeys: group.proposedClaimKey ? [group.proposedClaimKey] : [],
+    rationale: buildMixedGroupRationale(group),
+    confidence: group.proposedClaimKey ? 0.8 : 0.55,
+    source,
+    eligibleForApply: group.proposedClaimKey !== null,
+    lifecycle: {
+      proposedClaimKeys: group.proposedClaimKey ? [group.proposedClaimKey] : [],
+      source
+    }
+  });
+}
+
+// src/app/dreaming/reconcile/handlers/suspect-durable.ts
+async function processSuspectDurable(ctx, item) {
+  const { durable, inspection } = item;
+  if (inspection.kind !== "suspect") {
+    return;
+  }
+  const metadataRepair = resolveExplicitMetadataRepair(durable, inspection.inspection);
+  if (metadataRepair && findClaimKeyOccupants(ctx.workingSet.projectedDurables, metadataRepair, durable.id).length === 0) {
+    await applyClaimKeyRepair(
+      ctx,
+      durable.id,
+      metadataRepair,
+      {
+        issueKind: "suspect_canonical_claim_key",
+        oldClaimKey: durable.claim_key ?? null,
+        source: "metadata_rewrite",
+        confidence: 0.98,
+        rationale: `Explicit durable metadata resolves ${describeSuspicionList(inspection.inspection)} to "${metadataRepair}".`
+      },
+      {
+        onIdentified: () => {
+          ctx.telemetry.counts.identifiedMetadataRewrites += 1;
+        },
+        onApplied: () => {
+          ctx.telemetry.counts.appliedMetadataRewrites += 1;
+        }
+      }
+    );
+    return;
+  }
+  const suggestionRecord = ctx.extraction.claimExtractionConfig.eligibleTypes.includes(durable.type) ? await loadSuggestionIfContinuing(ctx, durable) : { suggestion: null, warnings: [], previewOutcome: null };
+  if (!suggestionRecord) {
+    return;
+  }
+  const proposedClaimKeys = [
+    metadataRepair,
+    suggestionRecord.suggestion?.claimKey && suggestionRecord.suggestion.claimKey !== durable.claim_key ? suggestionRecord.suggestion.claimKey : null
+  ].filter((value) => value !== null);
+  const source = metadataRepair ? "metadata_rewrite" : suggestionRecord.suggestion?.path ?? "heuristic";
+  await persistReconcileProposal(ctx, {
+    groupId: `claim-key-suspect:${durable.id}`,
+    issueKind: "suspect_canonical_claim_key",
+    scope: "single_durable",
+    durableIds: [durable.id],
+    currentClaimKeys: durable.claim_key ? [durable.claim_key] : [],
+    proposedClaimKeys,
+    rationale: buildSuspectProposalRationale(durable, inspection.inspection, metadataRepair, suggestionRecord.suggestion),
+    confidence: metadataRepair ? 0.98 : suggestionRecord.suggestion?.confidence ?? 0.5,
+    source,
+    eligibleForApply: proposedClaimKeys.length > 0,
+    lifecycle: {
+      proposedClaimKeys,
+      source,
+      rawClaimKey: durable.claim_key_raw ?? durable.claim_key ?? null
+    }
+  });
+}
+
+// src/app/dreaming/reconcile/helpers/observations.ts
+function buildEntityFamilyConvergenceObservation(stats) {
+  if (stats.appliedClusters === 0 && stats.proposedClusters === 0) {
+    return null;
+  }
+  return `Entity-family convergence auto-applied ${stats.appliedDurables} durable rewrite${stats.appliedDurables === 1 ? "" : "s"} across ${stats.appliedClusters} family cluster${stats.appliedClusters === 1 ? "" : "s"} and staged ${stats.proposedClusters} unresolved family proposal${stats.proposedClusters === 1 ? "" : "s"}.`;
+}
+function buildMissingDecisionObservation(stats) {
+  const autoAppliedParts = [
+    stats.autoAppliedTrustedGroupReuse > 0 ? `${stats.autoAppliedTrustedGroupReuse} trusted-group reuses` : null,
+    stats.autoAppliedMetadataRepair > 0 ? `${stats.autoAppliedMetadataRepair} metadata-grounded backfills` : null,
+    stats.autoAppliedDeterministicRepair > 0 ? `${stats.autoAppliedDeterministicRepair} deterministic repairs` : null,
+    stats.autoAppliedSupportedPreview > 0 ? `${stats.autoAppliedSupportedPreview} supported preview auto-applies` : null,
+    stats.autoAppliedPreviewModel > 0 ? `${stats.autoAppliedPreviewModel} high-confidence preview suggestions` : null
+  ].filter((value) => value !== null);
+  const proposalParts = [
+    stats.proposedTrustedGroupReuse > 0 ? `${stats.proposedTrustedGroupReuse} trusted-group reuse proposals` : null,
+    stats.proposedSupportedCandidate > 0 ? `${stats.proposedSupportedCandidate} supported preview proposals` : null,
+    stats.proposedPreviewCandidate > 0 ? `${stats.proposedPreviewCandidate} plain preview proposals` : null
+  ].filter((value) => value !== null);
+  if (autoAppliedParts.length === 0 && proposalParts.length === 0) {
+    return null;
+  }
+  return `Missing-key decisions used ${autoAppliedParts.join(", ") || "no auto-applies"} and ${proposalParts.join(", ") || "no proposals"} after structural reuse checks.`;
+}
+function buildGroundedFamilyPromotionObservation(stats) {
+  const observations = [
+    stats.autoAppliedGroundedFamilyPromotion > 0 || stats.proposedGroundedFamilyPromotion > 0 ? `Grounded-family promotion auto-applied ${stats.autoAppliedGroundedFamilyPromotion} candidate${stats.autoAppliedGroundedFamilyPromotion === 1 ? "" : "s"} and staged ${stats.proposedGroundedFamilyPromotion} proposal${stats.proposedGroundedFamilyPromotion === 1 ? "" : "s"}.` : null,
+    stats.autoAppliedRelaxedStableSlotPromotion > 0 || stats.proposedRelaxedStableSlotPromotion > 0 ? `Relaxed stable-slot promotion auto-applied ${stats.autoAppliedRelaxedStableSlotPromotion} candidate${stats.autoAppliedRelaxedStableSlotPromotion === 1 ? "" : "s"} and staged ${stats.proposedRelaxedStableSlotPromotion} proposal${stats.proposedRelaxedStableSlotPromotion === 1 ? "" : "s"} after accepting one grounded family sibling.` : null
+  ].filter((value) => value !== null);
+  if (observations.length === 0) {
+    return null;
+  }
+  return observations.join(" ");
+}
+function buildSiblingSlotResonanceObservation(stats) {
+  if (stats.thresholdOnlyCandidateCount === 0) {
+    return null;
+  }
+  const bucketSummary = SHADOW_BUCKET_ORDER.map((bucket) => {
+    const bucketStats = stats.buckets.get(bucket);
+    const label = describeShadowBucket(bucket);
+    return `${label} ${bucketStats?.resonanceFiredCount ?? 0}/${bucketStats?.candidateCount ?? 0}`;
+  }).join(", ");
+  return `Shadow sibling-slot resonance fired for ${stats.resonanceFiredCount}/${stats.thresholdOnlyCandidateCount} threshold-only candidates (${bucketSummary}).`;
+}
+function buildSiblingSlotResonanceShadowRuleObservation(stats) {
+  if (stats.thresholdOnlyCandidateCount === 0) {
+    return null;
+  }
+  if (stats.shadowQualifiedCount === 0) {
+    return `Shadow sibling-slot-resonance rule would have qualified 0 candidates under grounded-family counts >= ${SHADOW_RESONANCE_MIN_FAMILY_REUSE_COUNT}, grounded ratio >= ${SHADOW_RESONANCE_MIN_GROUNDED_RATIO.toFixed(2)}, confidence >= ${SHADOW_RESONANCE_MIN_CONFIDENCE.toFixed(2)}, and sibling-slot resonance.`;
+  }
+  return `Shadow sibling-slot-resonance rule would have qualified ${stats.shadowQualifiedCount} candidate${stats.shadowQualifiedCount === 1 ? "" : "s"}: ${stats.shadowQualifiedClaimKeys.join(", ")}.`;
+}
+function buildMissingCompactionObservation(stats) {
+  if (stats.autoAppliedCompactedCandidate === 0 && stats.proposedCompactedCandidate === 0) {
+    return null;
+  }
+  return `Compact canonicalization rewrote ${stats.autoAppliedCompactedCandidate} missing-key candidate${stats.autoAppliedCompactedCandidate === 1 ? "" : "s"} before auto-apply and ${stats.proposedCompactedCandidate} before unresolved proposal logging.`;
+}
+function buildReconcilePassObservations(ctx, input) {
+  const { counts, missingDecisionStats, siblingSlotResonanceShadowStats, entityFamilyDecisionStats } = ctx.telemetry;
+  const observations = [
+    `Reconcile reviewed ${input.before.totalDurables} durable${input.before.totalDurables === 1 ? "" : "s"} in ${input.executionStyle} mode.`,
+    `Identified ${counts.identifiedNormalizations} normalizations, ${counts.identifiedBackfills} backfills, ${counts.identifiedMetadataRewrites} metadata-backed suspect-key rewrites, and ${counts.identifiedEntityFamilyConvergences} entity-family convergence rewrites.`,
+    `Emitted ${counts.proposalsEmitted} unresolved proposal${counts.proposalsEmitted === 1 ? "" : "s"}.`
+  ];
+  if (counts.skippedNoClaim > 0 || counts.skippedLowConfidence > 0 || counts.skippedCollision > 0) {
+    observations.push(
+      `Skipped ${counts.skippedNoClaim} no-claim cases, ${counts.skippedLowConfidence} low-confidence cases, and ${counts.skippedCollision} collision cases.`
+    );
+  }
+  if (counts.flaggedAmbiguousProposals > 0) {
+    observations.push(`Flagged ${counts.flaggedAmbiguousProposals} ambiguous proposal${counts.flaggedAmbiguousProposals === 1 ? "" : "s"} for later review.`);
+  }
+  const missingDecisionObservation = buildMissingDecisionObservation(missingDecisionStats);
+  if (missingDecisionObservation) {
+    observations.push(missingDecisionObservation);
+  }
+  const groundedFamilyObservation = buildGroundedFamilyPromotionObservation(missingDecisionStats);
+  if (groundedFamilyObservation) {
+    observations.push(groundedFamilyObservation);
+  }
+  if (ctx.options.includeShadowTelemetry === true) {
+    const siblingSlotResonanceObservation = buildSiblingSlotResonanceObservation(siblingSlotResonanceShadowStats);
+    if (siblingSlotResonanceObservation) {
+      observations.push(siblingSlotResonanceObservation);
+    }
+    const siblingSlotResonanceShadowRuleObservation = buildSiblingSlotResonanceShadowRuleObservation(siblingSlotResonanceShadowStats);
+    if (siblingSlotResonanceShadowRuleObservation) {
+      observations.push(siblingSlotResonanceShadowRuleObservation);
+    }
+  }
+  const missingCompactionObservation = buildMissingCompactionObservation(missingDecisionStats);
+  if (missingCompactionObservation) {
+    observations.push(missingCompactionObservation);
+  }
+  if (missingDecisionStats.noClaimWithWarnings > 0) {
+    observations.push(
+      `${missingDecisionStats.noClaimWithWarnings} missing-key previews ended without a safe claim after deterministic validation warnings or malformed output.`
+    );
+  }
+  const entityFamilyObservation = buildEntityFamilyConvergenceObservation(entityFamilyDecisionStats);
+  if (entityFamilyObservation) {
+    observations.push(entityFamilyObservation);
+  }
+  return observations;
+}
+function buildReconcilePassRecommendations(ctx, actualAfter) {
+  const recommendations = [];
+  const circuitBreakerMessage = ctx.telemetry.circuitBreaker?.message;
+  if (circuitBreakerMessage) {
+    recommendations.push(circuitBreakerMessage);
+  }
+  if (actualAfter.exactKeyMultiActiveClusterCount > 0) {
+    recommendations.push(
+      `Exact-key multi-active clusters remain at ${actualAfter.exactKeyMultiActiveClusterCount}. Run supersession after reconcile to adjudicate lineage separately.`
+    );
+  }
+  return recommendations;
+}
+
+// src/app/dreaming/reconcile/helpers/partition.ts
+function partitionReconcileDurables(durables, eligibleTypes) {
+  const invalidOrNoncanonical = [];
+  const missing = [];
+  const suspect = [];
+  const inspectionTally = createEmptyClaimKeyInspectionTally();
+  const inspectionById = /* @__PURE__ */ new Map();
+  for (const durable of durables) {
+    const inspection = inspectExistingClaimKey(durable);
+    inspectionById.set(durable.id, inspection);
+    tallyExistingClaimKeyInspection(inspection, durable.type, eligibleTypes, inspectionTally);
+    const item = { durable, inspection };
+    switch (inspection.kind) {
+      case "malformed":
+      case "noncanonical":
+        invalidOrNoncanonical.push(item);
+        break;
+      case "missing":
+        if (eligibleTypes.includes(durable.type)) {
+          missing.push(item);
+        }
+        break;
+      case "suspect":
+        suspect.push(item);
+        break;
+      default:
+        break;
+    }
+  }
+  return {
+    partitions: { invalidOrNoncanonical, missing, suspect },
+    inspectionTally,
+    inspectionById
+  };
+}
+
+// src/app/dreaming/reconcile/progress-tracker.ts
+function createReconcileProgressTracker(input) {
+  const startedAtMs = Date.now();
+  const progressIntervalMs = input.verbose ? CLAIM_KEY_PROGRESS_VERBOSE_INTERVAL_MS : CLAIM_KEY_PROGRESS_INTERVAL_MS;
+  const progressEvery = input.verbose ? CLAIM_KEY_PROGRESS_EVERY_VERBOSE_DURABLES : CLAIM_KEY_PROGRESS_EVERY_DURABLES;
+  let processedDurables = 0;
+  let activeStage = null;
+  return {
+    emitHealthSnapshot(snapshot) {
+      emitDreamProgress(input.reportProgress, {
+        kind: "reconcile_progress",
+        tier: input.tier,
+        apply: input.apply,
+        stage: "health",
+        status: "snapshot",
+        completed: 0,
+        total: snapshot.totalDurables,
+        unitLabel: "durables",
+        processedDurables,
+        totalDurables: input.totalDurables,
+        counts: cloneRepairCounts(input.counts),
+        elapsedMs: elapsedMs(startedAtMs),
+        health: snapshot
+      });
+    },
+    startStage(stage, total, unitLabel, options) {
+      const previewTotal = normalizeOptionalNonNegativeCount(options?.previewTotal);
+      activeStage = total > 0 ? {
+        stage,
+        total,
+        completed: 0,
+        unitLabel,
+        previewQueued: previewTotal,
+        previewCompleted: 0,
+        previewTotal,
+        previewConcurrency: previewTotal > 0 ? options?.previewConcurrency ?? null : null,
+        lastReportedCompleted: 0,
+        lastReportedPreviewCompleted: 0,
+        lastReportedAtMs: Date.now()
+      } : null;
+      if (!activeStage) {
+        return;
+      }
+      emitStageEvent("started");
+    },
+    advancePreview(count = 1) {
+      if (!activeStage || activeStage.previewTotal === 0) {
+        return;
+      }
+      activeStage.previewCompleted += count;
+      if (activeStage.previewCompleted > activeStage.previewTotal) {
+        activeStage.previewCompleted = activeStage.previewTotal;
+      }
+      const nowMs = Date.now();
+      if (activeStage.previewCompleted >= activeStage.previewTotal || activeStage.previewCompleted - activeStage.lastReportedPreviewCompleted >= progressEvery || nowMs - activeStage.lastReportedAtMs >= progressIntervalMs) {
+        emitStageEvent("preview_progress", nowMs);
+      }
+    },
+    advanceStage(count = 1) {
+      if (!activeStage) {
+        return;
+      }
+      activeStage.completed += count;
+      if (activeStage.unitLabel === "durables") {
+        processedDurables += count;
+      }
+      if (activeStage.completed >= activeStage.total) {
+        emitStageEvent("completed");
+        activeStage = null;
+        return;
+      }
+      const nowMs = Date.now();
+      if (activeStage.completed - activeStage.lastReportedCompleted >= progressEvery || nowMs - activeStage.lastReportedAtMs >= progressIntervalMs) {
+        emitStageEvent("progress", nowMs);
+      }
+    }
+  };
+  function emitStageEvent(status, nowMs = Date.now()) {
+    if (!activeStage) {
+      return;
+    }
+    activeStage.lastReportedCompleted = activeStage.completed;
+    activeStage.lastReportedPreviewCompleted = activeStage.previewCompleted;
+    activeStage.lastReportedAtMs = nowMs;
+    emitDreamProgress(input.reportProgress, {
+      kind: "reconcile_progress",
+      tier: input.tier,
+      apply: input.apply,
+      stage: activeStage.stage,
+      status,
+      completed: activeStage.completed,
+      total: activeStage.total,
+      unitLabel: activeStage.unitLabel,
+      ...activeStage.previewTotal > 0 ? {
+        previewQueued: activeStage.previewQueued,
+        previewCompleted: activeStage.previewCompleted,
+        previewTotal: activeStage.previewTotal,
+        ...activeStage.previewConcurrency !== null ? { previewConcurrency: activeStage.previewConcurrency } : {}
+      } : {},
+      processedDurables,
+      totalDurables: input.totalDurables,
+      counts: cloneRepairCounts(input.counts),
+      elapsedMs: elapsedMs(startedAtMs, nowMs)
+    });
+  }
+}
+
+// src/app/dreaming/reconcile/pass-context.ts
+async function createReconcilePassContext(options, deps) {
+  const selection = {
+    includeInactive: options.includeInactive === true,
+    project: normalizeOptionalString(options.project) ?? null,
+    type: normalizeOptionalString(options.type) ?? null,
+    claimKeyPrefix: normalizeOptionalString(options.claimKeyPrefix) ?? null,
+    durableIds: normalizeStringArray(options.durableIds ?? [])
+  };
+  const sourceDurables = await deps.port.listReconcileDurables({
+    project: selection.project ?? void 0,
+    type: selection.type ?? void 0,
+    claimKeyPrefix: selection.claimKeyPrefix ?? void 0,
+    durableIds: selection.durableIds,
+    includeInactive: selection.includeInactive
+  });
+  const actualDurables = sourceDurables.map((durable) => cloneDurable(durable));
+  const projectedDurables = sourceDurables.map((durable) => cloneDurable(durable));
+  const durablesById = new Map(projectedDurables.map((durable) => [durable.id, durable]));
+  const actualDurablesById = new Map(actualDurables.map((durable) => [durable.id, durable]));
+  const counts = createEmptyRepairCounts();
+  const claimExtractionConfig = resolveClaimExtractionConfig(deps.config ?? void 0);
+  const previewConcurrency = resolveClaimExtractionConcurrency(claimExtractionConfig);
+  const trustedHints = buildTrustedCleanupHintSeed(actualDurables);
+  const trustedReusableDurableIds = new Set(
+    sourceDurables.flatMap((durable) => {
+      const claimKey = durable.claim_key?.trim();
+      return claimKey && isTrustedClaimKeyForCleanup(claimKey) ? [durable.id] : [];
+    })
+  );
+  const progressTracker = createReconcileProgressTracker({
+    tier: options.tier,
+    apply: options.apply,
+    verbose: options.verbose,
+    totalDurables: actualDurables.length,
+    counts,
+    reportProgress: options.reportProgress
+  });
+  return {
+    options,
+    deps,
+    workingSet: {
+      selection,
+      projectedDurables,
+      actualDurables,
+      durablesById,
+      actualDurablesById,
+      trustedHints,
+      trustedReusableDurableIds,
+      handledEntityFamilyClaimKeys: /* @__PURE__ */ new Set(),
+      projectedInspectionById: /* @__PURE__ */ new Map(),
+      actualInspectionById: /* @__PURE__ */ new Map(),
+      projectedInspectionTally: createEmptyClaimKeyInspectionTally(),
+      actualInspectionTally: createEmptyClaimKeyInspectionTally()
+    },
+    extraction: {
+      claimExtractionConfig,
+      previewConcurrency,
+      suggestionCache: /* @__PURE__ */ new Map(),
+      claimExtractionLlms: [],
+      fallbackClaimExtractionLlm: void 0
+    },
+    telemetry: {
+      counts,
+      observations: [],
+      recommendations: [],
+      missingDecisionStats: createEmptyMissingBackfillDecisionStats(),
+      siblingSlotResonanceShadowStats: createEmptySiblingSlotResonanceShadowStats(),
+      entityFamilyDecisionStats: createEmptyEntityFamilyConvergenceDecisionStats(),
+      skippedDiagnostics: [],
+      circuitBreakerState: createCircuitBreakerState(),
+      circuitBreaker: null,
+      terminalStatus: "completed",
+      terminalError: null,
+      actionsTaken: 0
+    },
+    progressTracker
+  };
+}
+function getClaimExtractionUsage(ctx) {
+  return claimExtractionUsage(ctx.extraction.claimExtractionLlms);
+}
+
+// src/app/dreaming/reconcile/pass-stage-runner.ts
+async function runReconcileStage(ctx, options) {
+  ctx.progressTracker.startStage(options.stage, options.items.length, options.unitLabel, {
+    previewTotal: options.preview?.items.length ?? 0,
+    previewConcurrency: options.preview?.concurrency
+  });
+  if (options.preload && options.preview) {
+    await options.preload(ctx, options.preview.items);
+  }
+  for (const item of options.items) {
+    if (markAbortedIfSignalled(ctx)) {
+      break;
+    }
+    await options.process(ctx, item);
+    options.afterItem?.(ctx, item);
+    ctx.progressTracker.advanceStage();
+    if (ctx.telemetry.terminalStatus !== "completed" || ctx.telemetry.circuitBreaker) {
+      break;
+    }
+  }
+}
+function canContinueReconcilePass(ctx) {
+  return !ctx.telemetry.circuitBreaker && ctx.telemetry.terminalStatus === "completed";
+}
+
+// src/app/dreaming/reconcile/pass.ts
+async function runReconcilePass(options, deps) {
+  const ctx = await createReconcilePassContext(options, deps);
+  const { selection, projectedDurables, actualDurables } = ctx.workingSet;
+  const executionStyle = selection.includeInactive || selection.type !== null || selection.claimKeyPrefix !== null || selection.durableIds.length > 0 ? "targeted" : "autonomous";
+  const eligibleTypes = ctx.extraction.claimExtractionConfig.eligibleTypes;
+  const { partitions, inspectionTally, inspectionById } = partitionReconcileDurables(projectedDurables, eligibleTypes);
+  const before = buildClaimKeyHealthSnapshot(actualDurables, eligibleTypes, inspectionTally);
+  ctx.workingSet.projectedInspectionById = new Map(inspectionById);
+  ctx.workingSet.actualInspectionById = new Map(inspectionById);
+  ctx.workingSet.projectedInspectionTally = cloneClaimKeyInspectionTally(inspectionTally);
+  ctx.workingSet.actualInspectionTally = cloneClaimKeyInspectionTally(inspectionTally);
+  emitDreamProgress(options.reportProgress, {
+    kind: "phase",
+    phase: "load_working_set_complete",
+    tier: options.tier,
+    apply: options.apply,
+    workingSetSize: before.totalDurables
+  });
+  emitDreamProgress(options.reportProgress, {
+    kind: "phase",
+    phase: "pass_start",
+    tier: options.tier,
+    apply: options.apply
+  });
+  ctx.progressTracker.emitHealthSnapshot(before);
+  const stageRunners = buildReconcileStageRunners(partitions);
+  try {
+    for (const runStage of stageRunners) {
+      if (!canContinueReconcilePass(ctx)) {
+        break;
+      }
+      await runStage(ctx);
+    }
+  } catch (error) {
+    ctx.telemetry.terminalStatus = "failed";
+    ctx.telemetry.terminalError = error instanceof Error ? error.message : String(error);
+  }
+  const actualAfter = buildClaimKeyHealthSnapshot(actualDurables, ctx.extraction.claimExtractionConfig.eligibleTypes, ctx.workingSet.actualInspectionTally);
+  const projectedAfter = buildClaimKeyHealthSnapshot(
+    projectedDurables,
+    ctx.extraction.claimExtractionConfig.eligibleTypes,
+    ctx.workingSet.projectedInspectionTally
+  );
+  ctx.telemetry.observations.push(...buildReconcilePassObservations(ctx, { before, executionStyle }));
+  ctx.telemetry.recommendations.push(...buildReconcilePassRecommendations(ctx, actualAfter));
+  const passSummary = {
+    executionStyle,
+    workingSet: selection,
+    before,
+    after: options.apply ? actualAfter : before,
+    projectedAfter: options.apply ? void 0 : projectedAfter,
+    counts: ctx.telemetry.counts,
+    shadowSiblingSlotResonance: ctx.options.includeShadowTelemetry ? buildSiblingSlotResonanceShadowSummary(ctx.telemetry.siblingSlotResonanceShadowStats) : void 0,
+    circuitBreaker: ctx.telemetry.circuitBreaker
+  };
+  const completion = {
+    actions_taken: ctx.telemetry.actionsTaken,
+    durables_skipped: ctx.telemetry.skippedDiagnostics.map((diagnostic) => ({
+      durable_id: diagnostic.durableId,
+      reason: formatMissingBackfillSkipDiagnostic(diagnostic)
+    })),
+    observations: ctx.telemetry.observations,
+    recommendations: ctx.telemetry.recommendations,
+    reconcile: passSummary
+  };
+  return {
+    status: ctx.telemetry.terminalStatus,
+    error: ctx.telemetry.terminalError,
+    completion,
+    durablesStaled: 0,
+    usage: getClaimExtractionUsage(ctx)
+  };
+}
+function buildReconcileStageRunners(partitions) {
+  const durableStageDefs = [
+    {
+      stage: "invalid_noncanonical",
+      items: partitions.invalidOrNoncanonical,
+      process: processInvalidOrNoncanonicalDurable
+    },
+    {
+      stage: "missing",
+      items: partitions.missing,
+      process: processMissingDurable,
+      previewFilter: shouldPreviewMissingDurable
+    },
+    {
+      stage: "suspect_canonical",
+      items: partitions.suspect,
+      process: processSuspectDurable,
+      previewFilter: shouldPreloadSuspectSuggestion
+    }
+  ];
+  return [
+    ...durableStageDefs.map(buildInspectedDurableStageRunner),
+    (ctx) => runReconcileStage(ctx, {
+      stage: "entity_family_convergence",
+      items: detectClaimKeyEntityFamilyCandidates(ctx.workingSet.projectedDurables),
+      unitLabel: "groups",
+      process: processEntityFamilyConvergenceCandidate,
+      afterItem: (passCtx, candidate) => {
+        for (const claimKey of candidate.claimKeys) {
+          passCtx.workingSet.handledEntityFamilyClaimKeys.add(claimKey);
+        }
+      }
+    }),
+    (ctx) => runReconcileStage(ctx, {
+      stage: "mixed_key_groups",
+      items: findMixedKeyGroups(ctx.workingSet.projectedDurables, ctx.workingSet.handledEntityFamilyClaimKeys),
+      unitLabel: "groups",
+      process: processMixedKeyGroup
+    })
+  ];
+}
+function buildInspectedDurableStageRunner(def) {
+  return (ctx) => {
+    const preloadEnabled = shouldPreloadSuggestions(ctx);
+    const previewItems = def.previewFilter && preloadEnabled ? def.items.filter((item) => def.previewFilter(ctx, item)) : [];
+    return runReconcileStage(ctx, {
+      stage: def.stage,
+      items: def.items,
+      unitLabel: "durables",
+      preview: def.previewFilter && preloadEnabled ? {
+        items: previewItems,
+        concurrency: previewItems.length > 0 ? ctx.extraction.previewConcurrency : void 0
+      } : void 0,
+      preload: def.previewFilter ? (ctx2, items) => preloadSuggestionsForStage(
+        ctx2,
+        items.map((item) => item.durable)
+      ) : void 0,
+      process: def.process
+    });
+  };
+}
+
+// src/app/dreaming/temporalize.ts
+import { randomUUID as randomUUID7 } from "crypto";
+async function runTemporalizeStage(options, deps) {
+  const refineCandidates = options.candidates.filter(
+    (candidate) => candidate.disposition === "refines" && candidate.refinesDurableId !== null
+  );
+  let revisionsIdentified = 0;
+  let revisionsApplied = 0;
+  let revisionsSkipped = 0;
+  for (const candidate of refineCandidates) {
+    throwIfAborted(options.signal);
+    const predecessor = await deps.port.getDurable(candidate.refinesDurableId);
+    if (!predecessor) {
+      revisionsSkipped += 1;
+      continue;
+    }
+    const rules = validateSupersessionRules({ type: predecessor.type, expiry: predecessor.expiry }, { type: candidate.type, expiry: candidate.expiry });
+    if (!rules.ok) {
+      revisionsSkipped += 1;
+      continue;
+    }
+    revisionsIdentified += 1;
+    if (!options.apply) {
+      continue;
+    }
+    await applyRevision(candidate, predecessor, options, deps);
+    revisionsApplied += 1;
+  }
+  return {
+    summary: {
+      revisionsIdentified,
+      revisionsApplied,
+      revisionsSkipped
+    }
+  };
+}
+async function applyRevision(candidate, predecessor, options, deps) {
+  const nowIso = options.now().toISOString();
+  const successorId = randomUUID7();
+  const successor = buildDurableFromCandidate(candidate, {
+    id: successorId,
+    claimKeySource: "dreaming_temporalize",
+    claimKeyStatus: predecessor.claim_key_status ?? "tentative",
+    claimKeyConfidence: predecessor.claim_key_confidence ?? 0.6,
+    claimKeyRationale: `Temporal revision superseding durable ${predecessor.id} from episode evidence.`,
+    claimKeyOverride: predecessor.claim_key ?? candidate.claimKey,
+    createdAt: nowIso,
+    validFrom: nowIso
+  });
+  successor.expiry = predecessor.expiry;
+  const contentHash = successor.content_hash ?? computeContentHash(successor.content, successor.source_file);
+  const [successorEmbedding = []] = await deps.embedding.embed([composeEmbeddingText(successor)]);
+  await deps.port.withTransaction(async (tx) => {
+    await tx.insertDurable(successor, successorEmbedding, contentHash);
+    await tx.supersedeDurable(predecessor.id, successorId, "update", "Temporal revision from dreaming evidence.");
+    if (canCloseValidityWindow(predecessor.valid_from, nowIso)) {
+      await tx.updateDurable(predecessor.id, { valid_to: nowIso }, { includeInactive: true });
+    }
+    await tx.logRunAction({
+      id: randomUUID7(),
+      runId: options.runId,
+      actionType: "supersede_durable",
+      durableIds: [predecessor.id, successorId],
+      reasoning: `Superseded durable ${predecessor.id} with temporal revision ${successorId}.`,
+      details: {
+        claim_key: successor.claim_key ?? null,
+        predecessor_id: predecessor.id,
+        successor_id: successorId,
+        valid_to: nowIso
+      },
+      createdAt: nowIso
+    });
+  });
+}
+function canCloseValidityWindow(validFrom, nowIso) {
+  if (!validFrom) {
+    return true;
+  }
+  const fromMs = Date.parse(validFrom);
+  const nowMs = Date.parse(nowIso);
+  if (Number.isNaN(fromMs) || Number.isNaN(nowMs)) {
+    return true;
+  }
+  return fromMs < nowMs;
+}
+
+// src/app/dreaming/service.ts
+async function runDream(options, deps) {
+  throwIfAborted(options.signal);
+  return withDreamingRunLock(deps.port, deps.dbPath, (lease) => runDreamWithHeldLock(options, deps, lease));
+}
+async function runDreamWithHeldLock(options, deps, lease) {
+  throwIfAborted(options.signal);
+  await lease.heartbeat();
+  return executeDreamRun(options, deps);
+}
+async function executeDreamRun(options, deps) {
+  const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  assertDreamTierEnabled(options.tier, deps.config);
+  const dailyCost = await deps.port.getDailyCost(now());
+  const dailyCap = deps.config?.dreaming?.dailyCostCap ?? DEFAULT_DREAMING_DAILY_COST_CAP;
+  if (dailyCost >= dailyCap) {
+    throw new Error(`Daily dreaming cost cap reached (${dailyCost.toFixed(2)} / ${dailyCap.toFixed(2)} USD).`);
+  }
+  const remainingDailyBudgetUsd = Math.max(0, dailyCap - dailyCost);
+  const runId = await deps.port.createRun({
+    tier: options.tier,
+    project: options.project,
+    dryRun: !options.apply,
+    config: {
+      tier: options.tier,
+      project: options.project ?? null,
+      type: options.type ?? null,
+      claimKeyPrefix: options.claimKeyPrefix ?? null,
+      durableIds: options.durableIds ?? [],
+      includeInactive: options.includeInactive ?? false
+    }
+  });
+  emitDreamProgress(deps.reportProgress, {
+    kind: "phase",
+    phase: "start",
+    tier: options.tier,
+    apply: options.apply
+  });
+  if (options.apply && !options.skipBackup && deps.dbPath && deps.dbPath !== ":memory:" && deps.backupDb) {
+    emitDreamProgress(deps.reportProgress, { kind: "phase", phase: "backup_start", tier: options.tier, apply: options.apply });
+    const backupPath = await deps.backupDb(deps.dbPath);
+    emitDreamProgress(deps.reportProgress, {
+      kind: "phase",
+      phase: "backup_complete",
+      tier: options.tier,
+      apply: options.apply,
+      backupPath
+    });
+  }
+  const extractStages = resolveExtractStageConfig(deps.config, options.tier);
+  const stagePlan = resolveTierStages(options.tier);
+  const createExtractLlm = deps.createExtractLlm ?? deps.createClaimExtractionLlm;
+  const embedding = resolveDreamEmbedding(deps.embedding);
+  let scanSummary;
+  let extractSummary;
+  let reconcileSummary;
+  let temporalizeSummary;
+  let projectSummary;
+  let pruneSummary;
+  let efficiencySummary;
+  const stagesSkipped = [];
+  let durablesSkipped = [];
+  let observations = [];
+  let recommendations = [];
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let estimatedCostUsd = 0;
+  let actionsTaken = 0;
+  let actionsSkipped = 0;
+  let durablesStaled = 0;
+  let reconcileStatus;
+  let reconcileError;
+  try {
+    const fullBacklog = options.tier === "deep";
+    const scan = await runDreamScan({ project: options.project, fullBacklog, now }, { port: deps.port });
+    scanSummary = scan;
+    const extract = await runExtractStage(
+      {
+        now,
+        ...options.project ? { project: options.project } : {},
+        fullBacklog,
+        maxEpisodes: extractStages.maxEpisodes,
+        contextLookupEnabled: extractStages.contextLookupEnabled,
+        costCapUsd: remainingDailyBudgetUsd,
+        ...options.signal ? { signal: options.signal } : {}
+      },
+      {
+        port: deps.port,
+        ...createExtractLlm ? { createExtractLlm } : {}
+      }
+    );
+    let durablesInserted = 0;
+    if (options.apply) {
+      const applied = await applyExtractedDurables({ runId, candidates: extract.candidates, now }, { port: deps.port, embedding });
+      durablesInserted = applied.inserted;
+    }
+    extractSummary = { ...extract.summary, durablesInserted };
+    actionsTaken = durablesInserted;
+    inputTokens = extract.usage.inputTokens;
+    outputTokens = extract.usage.outputTokens;
+    estimatedCostUsd = extract.usage.estimatedCostUsd;
+    if (stagePlan.runReconcile) {
+      const reconcile = await runReconcilePass(
+        {
+          runId,
+          tier: options.tier,
+          apply: options.apply,
+          project: options.project,
+          type: options.type,
+          claimKeyPrefix: options.claimKeyPrefix,
+          durableIds: options.durableIds,
+          includeInactive: options.includeInactive,
+          signal: options.signal,
+          now,
+          costCapUsd: Math.max(0, remainingDailyBudgetUsd - extract.usage.estimatedCostUsd),
+          verbose: options.verbose,
+          includeShadowTelemetry: options.includeShadowTelemetry === true,
+          reportProgress: deps.reportProgress
+        },
+        {
+          port: deps.port,
+          config: deps.config,
+          ...deps.createClaimExtractionLlm ? { createClaimExtractionLlm: deps.createClaimExtractionLlm } : {}
+        }
+      );
+      observations = [...reconcile.completion.observations];
+      actionsTaken = reconcile.completion.actions_taken + durablesInserted;
+      actionsSkipped = reconcile.completion.durables_skipped.length;
+      durablesSkipped = reconcile.completion.durables_skipped;
+      recommendations = reconcile.completion.recommendations;
+      reconcileSummary = reconcile.completion.reconcile;
+      durablesStaled = reconcile.durablesStaled;
+      inputTokens = reconcile.usage.inputTokens + extract.usage.inputTokens;
+      outputTokens = reconcile.usage.outputTokens + extract.usage.outputTokens;
+      estimatedCostUsd = reconcile.usage.estimatedCostUsd + extract.usage.estimatedCostUsd;
+      reconcileStatus = reconcile.status;
+      reconcileError = reconcile.error ?? void 0;
+    } else {
+      stagesSkipped.push({ stage: "reconcile", reason: "light_tier" });
+      observations.push("Reconcile stage skipped for light tier.");
+      actionsTaken = durablesInserted;
+      reconcileStatus = "completed";
+    }
+    if (extract.status === "cost_capped") {
+      observations.push("Extract stage stopped early after reaching the daily dreaming cost cap.");
+    }
+    const temporalize = await runTemporalizeStage(
+      {
+        runId,
+        candidates: extract.candidates,
+        apply: options.apply,
+        now,
+        ...options.signal ? { signal: options.signal } : {}
+      },
+      { port: deps.port, embedding }
+    );
+    temporalizeSummary = temporalize.summary;
+    actionsTaken += temporalize.summary.revisionsApplied;
+    const projectStage = await runProjectStage(
+      {
+        runId,
+        now,
+        ...options.project ? { project: options.project } : {},
+        maxProfileDurables: resolveProjectStageConfig(deps.config).maxProfileDurables
+      },
+      { port: deps.port }
+    );
+    const status = extract.status === "cost_capped" && reconcileStatus === "completed" ? "cost_capped" : reconcileStatus;
+    const activeProfileSnapshot = status === "completed" && options.apply && !options.project ? projectStage.snapshot : null;
+    projectSummary = {
+      ...projectStage.summary,
+      snapshotId: activeProfileSnapshot?.id ?? null,
+      applied: activeProfileSnapshot !== null
+    };
+    if (stagePlan.runPrune) {
+      const pruneConfig = resolvePruneStageConfig(deps.config);
+      pruneSummary = await runPruneStage(
+        {
+          runId,
+          apply: options.apply,
+          now,
+          ...options.project ? { project: options.project } : {},
+          protectedDurableIds: projectStage.snapshot ? [...projectStage.snapshot.durableIds, ...projectStage.snapshot.directiveIds] : [],
+          protectRecalledDays: pruneConfig.protectRecalledDays,
+          protectMinImportance: pruneConfig.protectMinImportance
+        },
+        { port: deps.port }
+      );
+      actionsTaken += pruneSummary.durablesStaled;
+      actionsSkipped += pruneSummary.candidatesProtected + (options.apply ? 0 : pruneSummary.candidatesRetirable);
+      durablesStaled += pruneSummary.durablesStaled;
+    } else {
+      stagesSkipped.push({ stage: "prune", reason: "light_tier" });
+    }
+    efficiencySummary = buildDreamEfficiencySummary({
+      scan,
+      estimatedCostUsd,
+      synthesizedDurableMutations: extractSummary.durablesInserted + temporalizeSummary.revisionsApplied + (pruneSummary?.durablesStaled ?? 0),
+      profileDurableCount: projectSummary.profileDurableCount,
+      directiveCount: projectSummary.directiveCount
+    });
+    const completionSummary = {
+      actions_taken: actionsTaken,
+      ...resolveBackupSkipped(options) ? { backupSkipped: true } : {},
+      ...stagesSkipped.length > 0 ? { stages_skipped: stagesSkipped } : {},
+      durables_skipped: durablesSkipped,
+      observations,
+      recommendations,
+      scan,
+      extract: extractSummary,
+      ...reconcileSummary ? { reconcile: reconcileSummary } : {},
+      temporalize: temporalizeSummary,
+      project: projectSummary,
+      ...pruneSummary ? { prune: pruneSummary } : {},
+      efficiency: efficiencySummary
+    };
+    const runCompletion = {
+      status,
+      inputTokens,
+      outputTokens,
+      estimatedCostUsd,
+      actionsTaken,
+      actionsSkipped,
+      durablesStaled,
+      summaryJson: completionSummary,
+      error: reconcileError
+    };
+    const dreamStateUpdate = {
+      unsynthesizedImportanceSum: status === "completed" ? 0 : scan.unsynthesizedImportanceSum,
+      ...status === "completed" ? { lastSuccessfulRunAt: now().toISOString() } : {},
+      ...activeProfileSnapshot ? { activeProfileSnapshotId: activeProfileSnapshot.id } : {},
+      updatedAt: now().toISOString()
+    };
+    if (activeProfileSnapshot) {
+      await deps.port.withTransaction(async (tx) => {
+        await tx.createProfileSnapshot(activeProfileSnapshot);
+        await tx.completeRun(runId, runCompletion);
+        await tx.updateDreamState(dreamStateUpdate);
+      });
+    } else {
+      await deps.port.completeRun(runId, runCompletion);
+      await deps.port.updateDreamState(dreamStateUpdate);
+    }
+    return {
+      runId,
+      status,
+      tier: options.tier,
+      actionsTaken,
+      actionsSkipped,
+      durablesStaled,
+      inputTokens,
+      outputTokens,
+      estimatedCostUsd,
+      summary: reconcileError ?? (status === "completed" ? "Dreaming run completed." : null),
+      completionSummary
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const status = message === USER_ABORT_ERROR ? "aborted" : "failed";
+    const partialActions = await loadPartialRunActions(deps.port, runId);
+    actionsTaken = Math.max(actionsTaken, partialActions);
+    const failureObservations = [...observations, `Dreaming run stopped before completion: ${message}`];
+    const failureSummary = {
+      actions_taken: actionsTaken,
+      ...resolveBackupSkipped(options) ? { backupSkipped: true } : {},
+      ...stagesSkipped.length > 0 ? { stages_skipped: stagesSkipped } : {},
+      durables_skipped: durablesSkipped,
+      observations: failureObservations,
+      recommendations,
+      ...scanSummary ? { scan: scanSummary } : {},
+      ...extractSummary ? { extract: extractSummary } : {},
+      ...reconcileSummary ? { reconcile: reconcileSummary } : {},
+      ...temporalizeSummary ? { temporalize: temporalizeSummary } : {},
+      ...projectSummary ? { project: projectSummary } : {},
+      ...pruneSummary ? { prune: pruneSummary } : {},
+      ...efficiencySummary ? { efficiency: efficiencySummary } : {}
+    };
+    await deps.port.completeRun(runId, {
+      status,
+      inputTokens,
+      outputTokens,
+      estimatedCostUsd,
+      actionsTaken,
+      actionsSkipped,
+      durablesStaled,
+      summaryJson: failureSummary,
+      error: message
+    });
+    throw error;
+  }
+}
+function assertDreamTierEnabled(tier, config) {
+  if (config?.dreaming?.tiers?.[tier]?.enabled === false) {
+    throw new Error(`Dreaming tier "${tier}" is disabled in config.`);
+  }
+}
+function resolveBackupSkipped(options) {
+  return options.apply === true && options.skipBackup === true;
+}
+function resolveProjectStageConfig(config) {
+  return {
+    maxProfileDurables: config?.dreaming?.stages?.project?.maxProfileDurables
+  };
+}
+function resolvePruneStageConfig(config) {
+  const prune = config?.dreaming?.stages?.prune;
+  return {
+    protectRecalledDays: typeof prune?.protectRecalledDays === "number" && prune.protectRecalledDays >= 0 ? prune.protectRecalledDays : DEFAULT_DREAMING_PRUNE_PROTECT_RECALLED_DAYS,
+    protectMinImportance: typeof prune?.protectMinImportance === "number" && prune.protectMinImportance >= 0 ? prune.protectMinImportance : DEFAULT_DREAMING_PRUNE_PROTECT_MIN_IMPORTANCE
+  };
+}
+async function backupDatabaseFile(dbPath) {
+  const sourcePath = resolveLocalFilesystemPath(dbPath);
+  if (!sourcePath) {
+    throw new Error(`Cannot back up non-file database path: ${dbPath}.`);
+  }
+  const backupDir = path.join(path.dirname(sourcePath), "backups");
+  await mkdir(backupDir, { recursive: true });
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const backupPath = path.join(backupDir, `knowledge-${stamp}.db`);
+  await copyFile(sourcePath, backupPath);
+  for (const suffix of ["-wal", "-shm"]) {
+    await copySidecarIfPresent(`${sourcePath}${suffix}`, `${backupPath}${suffix}`);
+  }
+  return backupPath;
+}
+function resolveExtractStageConfig(config, tier) {
+  const extract = config?.dreaming?.stages?.extract;
+  const defaultMaxSessions = tier === "light" ? DEFAULT_DREAMING_LIGHT_MAX_SESSIONS : DEFAULT_DREAMING_EXTRACT_MAX_SESSIONS;
+  const configuredMaxSessions = tier === "light" ? extract?.lightMaxSessionsPerRun : extract?.maxSessionsPerRun;
+  const maxEpisodes = typeof configuredMaxSessions === "number" && configuredMaxSessions > 0 ? configuredMaxSessions : defaultMaxSessions;
+  const contextLookupEnabled = extract?.contextLookup?.enabled ?? true;
+  return { maxEpisodes, contextLookupEnabled };
+}
+function resolveDreamEmbedding(embedding) {
+  if (embedding) {
+    return embedding;
+  }
+  return {
+    embed: async (texts) => {
+      if (texts.length === 0) {
+        return [];
+      }
+      throw new Error("Dreaming apply requires an embedding provider, but none was configured.");
+    }
+  };
+}
+async function copySidecarIfPresent(sourcePath, targetPath) {
+  try {
+    await copyFile(sourcePath, targetPath);
+  } catch (error) {
+    if (isMissingFileError(error)) {
+      return;
+    }
+    throw error;
+  }
+}
+async function loadPartialRunActions(port, runId) {
+  try {
+    return (await port.getRunActions(runId)).length;
+  } catch {
+    return 0;
+  }
+}
+function isMissingFileError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+
+export {
+  parseExtractionResponse,
+  runDream,
+  runDreamWithHeldLock,
+  backupDatabaseFile
+};