@agenr/skeln-plugin 3.3.0 → 2026.6.2

package/dist/{chunk-RYMSM3OS.js → chunk-ZX55JBV2.js}

@@ -1,44 +1,71 @@
 import {
+  BEFORE_TURN_DEBUG_ARTIFACT_DEFAULT_TOP_K,
+  BEFORE_TURN_DEBUG_ARTIFACT_MAX_TOP_K,
+  RECALL_DEBUG_ARTIFACT_DEFAULT_TOP_K,
+  RECALL_DEBUG_ARTIFACT_MAX_TOP_K
+} from "./chunk-5AXMFBHR.js";
+import {
+  applyDefaultClaimKeyLifecycle,
   composeProcedureRecallText,
   computeProcedureRevisionHash,
   computeProcedureSourceHash
-} from "./chunk-ZYADFKX3.js";
+} from "./chunk-MC3C2XM5.js";
 import {
+  createSessionStartRepository,
   formatAgenrBeforeTurnRecall,
-  runBeforeTurn
-} from "./chunk-KH52KJSJ.js";
+  listActiveAbstainDirectives,
+  listActiveSessionStartProactiveDirectives,
+  listActiveTopicProactiveDirectives,
+  runBeforeTurn,
+  runSessionStart
+} from "./chunk-XFJ4S4G2.js";
 import {
-  CLAIM_KEY_SOURCES,
-  CLAIM_KEY_STATUSES,
-  CLAIM_SUPPORT_MODES,
-  ENTRY_TYPES,
-  EXPIRY_LEVELS,
+  DREAM_STAGES,
+  DREAM_TIERS,
   attachCrossEncoderPort,
-  composeEmbeddingText,
+  completeDreamRun,
   createDatabase,
+  createDreamRun,
   createEmbeddingClient,
   createOpenAICrossEncoder,
+  createProfileSnapshot,
   createRecallAdapter,
-  isRecord,
+  mapRunRow,
   normalizeProcedureDefinition,
-  parseOptionalBoolean,
-  parseOptionalIntegerInRange,
-  parseOptionalTimestampString,
-  parseOptionalTrimmedString,
-  parseRequiredTrimmedString,
   projectClaimCentricRecallEntry,
-  pushIssue,
-  pushUnexpectedFields,
-  readConfig,
   resolveCrossEncoderApiKey,
   resolveEmbeddingApiKey,
   resolveEmbeddingModel,
   resolveModel,
-  runUnifiedRecall
-} from "./chunk-Z5X7T4QZ.js";
+  runUnifiedRecall,
+  updateDreamState
+} from "./chunk-5TIP2EPP.js";
 import {
   recall
-} from "./chunk-5LADPJ4C.js";
+} from "./chunk-GAERET5Q.js";
+import {
+  deriveDreamEfficiencySummary,
+  estimateProfileInjectionTokens
+} from "./chunk-GF3PX3VM.js";
+import {
+  CLAIM_KEY_SOURCES,
+  CLAIM_KEY_STATUSES,
+  CLAIM_SUPPORT_MODES,
+  DURABLE_KINDS,
+  EXPIRY_LEVELS,
+  composeEmbeddingText,
+  isRecord,
+  parseDirectivePolarity,
+  parseDirectiveTrigger,
+  parseOptionalBoolean,
+  parseOptionalIntegerInRange,
+  parseOptionalTimestampString,
+  parseOptionalTrimmedString,
+  parseRequiredTrimmedString,
+  pushIssue,
+  pushUnexpectedFields,
+  readConfig
+} from "./chunk-VTHBPXDQ.js";
 
 // src/internal-eval-server.ts
 import process from "process";
@@ -46,6 +73,103 @@ import process from "process";
 // src/adapters/api/internal-eval-server.ts
 import { createServer } from "http";
 
+// src/app/evals/ablation-arm.ts
+var ABLATION_ARMS = /* @__PURE__ */ new Set(["memory-off", "store-only", "dreaming-on"]);
+function resolveAblationConfig(sandbox) {
+  const arm = parseAblationArm(sandbox?.ablationArm);
+  const now = sandbox?.now?.trim();
+  const profileSnapshot = sandbox?.profileSnapshot;
+  return {
+    ...arm ? { arm } : {},
+    ...now ? { now } : {},
+    ...profileSnapshot ? { profileSnapshot } : {}
+  };
+}
+function isMemoryOffArm(config) {
+  return config.arm === "memory-off";
+}
+function shouldProvisionProfileSnapshot(config) {
+  return config.arm === "dreaming-on" && config.profileSnapshot !== void 0;
+}
+function parseAblationArm(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "string" || !ABLATION_ARMS.has(value)) {
+    throw new Error(`sandbox.ablationArm must be one of: ${[...ABLATION_ARMS].join(", ")}.`);
+  }
+  return value;
+}
+
+// src/app/evals/eval-embedding.ts
+function createEvalEmbeddingResolver() {
+  let sharedEmbeddingPort;
+  let sharedEmbeddingError;
+  const getSupport = () => {
+    if (sharedEmbeddingPort) {
+      return {
+        available: true,
+        port: sharedEmbeddingPort
+      };
+    }
+    if (sharedEmbeddingError) {
+      return {
+        available: false,
+        error: sharedEmbeddingError
+      };
+    }
+    const config = readConfig();
+    try {
+      sharedEmbeddingPort = createEmbeddingClient(resolveEmbeddingApiKey(config), resolveEmbeddingModel(config));
+      return {
+        available: true,
+        port: sharedEmbeddingPort
+      };
+    } catch (error) {
+      sharedEmbeddingError = error instanceof Error ? error.message : String(error);
+      return {
+        available: false,
+        error: sharedEmbeddingError
+      };
+    }
+  };
+  const requirePort = () => {
+    const support = getSupport();
+    if (!support.port) {
+      throw new Error(support.error ?? "Embeddings are unavailable.");
+    }
+    return support.port;
+  };
+  const portOrUnavailable = () => {
+    const support = getSupport();
+    return support.port ?? createUnavailableEmbeddingPort(support.error ?? "Embeddings are unavailable.");
+  };
+  return {
+    getSupport,
+    requirePort,
+    portOrUnavailable
+  };
+}
+function createUnavailableEmbeddingPort(message) {
+  return {
+    async embed() {
+      throw new Error(message);
+    }
+  };
+}
+
+// src/app/evals/eval-clock.ts
+function parseEvalNow(nowIso) {
+  if (!nowIso) {
+    return void 0;
+  }
+  const parsed = new Date(nowIso);
+  if (!Number.isFinite(parsed.getTime())) {
+    throw new Error(`sandbox.now must be a parseable ISO timestamp. Received: ${nowIso}`);
+  }
+  return parsed;
+}
+
 // src/app/evals/recall/provision-fixtures.ts
 import { createHash } from "crypto";
 var DEFAULT_IMPORTANCE = 6;
@@ -58,7 +182,7 @@ async function provisionRecallEvalFixtures(params) {
       provisionedCount: 0,
       providedIdCount: 0,
       generatedIdCount: 0,
-      retiredCount: 0,
+      staleCount: 0,
       supersededCount: 0,
       createdAtDefaultedCount: 0,
       updatedAtDefaultedCount: 0,
@@ -71,14 +195,14 @@ async function provisionRecallEvalFixtures(params) {
   }
   await params.store.withTransaction(async (store) => {
     for (const [index, fixture] of preparedBatch.insertionOrder.entries()) {
-      await store.insertEntry(fixture.entry, embeddings[index] ?? [], fixture.contentHash);
+      await store.insertDurable(fixture.entry, embeddings[index] ?? [], fixture.contentHash);
     }
   });
   return {
     provisionedCount: preparedBatch.insertionOrder.length,
     providedIdCount: preparedBatch.providedIdCount,
     generatedIdCount: preparedBatch.generatedIdCount,
-    retiredCount: preparedBatch.retiredCount,
+    staleCount: preparedBatch.staleCount,
     supersededCount: preparedBatch.supersededCount,
     createdAtDefaultedCount: preparedBatch.createdAtDefaultedCount,
     updatedAtDefaultedCount: preparedBatch.updatedAtDefaultedCount,
@@ -111,7 +235,7 @@ ${entry.content}`),
     insertionOrder: topologicallySortFixtures(prepared),
     providedIdCount: fixtures.filter((fixture) => fixture.id !== void 0).length,
     generatedIdCount: fixtures.filter((fixture) => fixture.id === void 0).length,
-    retiredCount: prepared.filter((fixture) => fixture.entry.retired).length,
+    staleCount: prepared.filter((fixture) => fixture.entry.valid_to !== void 0).length,
     supersededCount: prepared.filter((fixture) => fixture.entry.superseded_by !== void 0).length,
     createdAtDefaultedCount: fixtures.filter((fixture) => fixture.created_at === void 0).length,
     updatedAtDefaultedCount: fixtures.filter((fixture) => fixture.updated_at === void 0).length,
@@ -121,43 +245,44 @@ ${entry.content}`),
 function buildEntry(fixture, id, provisionedAt) {
   const createdAt = fixture.created_at ?? provisionedAt;
   const updatedAt = fixture.updated_at ?? createdAt;
-  return {
-    id,
-    type: fixture.type,
-    subject: fixture.subject,
-    content: fixture.content,
-    importance: fixture.importance ?? DEFAULT_IMPORTANCE,
-    expiry: fixture.expiry ?? DEFAULT_EXPIRY,
-    tags: fixture.tags ?? [],
-    source_file: fixture.source_file,
-    source_context: fixture.source_context,
-    quality_score: DEFAULT_QUALITY_SCORE,
-    recall_count: 0,
-    superseded_by: fixture.superseded_by,
-    claim_key: fixture.claim_key,
-    claim_key_status: fixture.claim_key_status,
-    claim_key_source: fixture.claim_key_source,
-    claim_support_source_kind: fixture.claim_support_source_kind,
-    claim_support_locator: fixture.claim_support_locator,
-    claim_support_observed_at: fixture.claim_support_observed_at,
-    claim_support_mode: fixture.claim_support_mode,
-    valid_from: fixture.valid_from,
-    valid_to: fixture.valid_to,
-    supersession_kind: fixture.supersession_kind,
-    supersession_reason: fixture.supersession_reason,
-    retired: fixture.retired ?? false,
-    retired_at: fixture.retired_at,
-    retired_reason: fixture.retired_reason,
-    created_at: createdAt,
-    updated_at: updatedAt
-  };
+  return applyDefaultClaimKeyLifecycle(
+    {
+      id,
+      type: fixture.type,
+      subject: fixture.subject,
+      content: fixture.content,
+      importance: fixture.importance ?? DEFAULT_IMPORTANCE,
+      expiry: fixture.expiry ?? DEFAULT_EXPIRY,
+      tags: fixture.tags ?? [],
+      source_file: fixture.source_file,
+      source_context: fixture.source_context,
+      quality_score: DEFAULT_QUALITY_SCORE,
+      recall_count: 0,
+      superseded_by: fixture.superseded_by,
+      claim_key: fixture.claim_key,
+      claim_key_status: fixture.claim_key_status,
+      claim_key_source: fixture.claim_key_source,
+      claim_support_source_kind: fixture.claim_support_source_kind,
+      claim_support_locator: fixture.claim_support_locator,
+      claim_support_observed_at: fixture.claim_support_observed_at,
+      claim_support_mode: fixture.claim_support_mode,
+      valid_from: fixture.valid_from,
+      valid_to: fixture.valid_to,
+      supersession_kind: fixture.supersession_kind,
+      supersession_reason: fixture.supersession_reason,
+      directive_polarity: fixture.directive_polarity,
+      directive_trigger: fixture.directive_trigger,
+      created_at: createdAt,
+      updated_at: updatedAt
+    },
+    "eval fixture"
+  );
 }
 function summarizePreparedFixture(entry) {
   return {
     id: entry.id,
     created_at: entry.created_at,
     updated_at: entry.updated_at,
-    retired: entry.retired,
     superseded_by: entry.superseded_by,
     claim_key: entry.claim_key,
     claim_key_status: entry.claim_key_status,
@@ -277,9 +402,10 @@ function prepareProcedures(caseId, fixtures, provisionedAt) {
       recall_text: composeProcedureRecallText(normalizedBody),
       revision_hash: computeProcedureRevisionHash(normalizedBody),
       source_hash: computeProcedureSourceHash(JSON.stringify(normalizedBody)),
-      retired: fixture.retired ?? false,
-      retired_at: fixture.retired_at,
-      retired_reason: fixture.retired_reason,
+      valid_from: fixture.valid_from,
+      valid_to: fixture.valid_to,
+      supersession_kind: fixture.supersession_kind,
+      supersession_reason: fixture.supersession_reason,
       superseded_by: fixture.superseded_by,
       created_at: createdAt,
       updated_at: updatedAt
@@ -305,20 +431,181 @@ function findDuplicateIds2(ids) {
   return duplicates;
 }
 
+// src/app/evals/provision-sandbox.ts
+async function provisionEvalSandbox(params) {
+  let entryProvisionResult;
+  if (params.memoryPool.length > 0) {
+    if (!params.embedding) {
+      throw new Error("Embeddings are unavailable.");
+    }
+    entryProvisionResult = await provisionRecallEvalFixtures({
+      caseId: params.caseId,
+      memoryPool: params.memoryPool,
+      store: params.sandbox.fixtureStore,
+      embedding: params.embedding,
+      provisionedAt: params.provisionedAt
+    });
+  }
+  if ((params.procedurePool?.length ?? 0) > 0) {
+    await provisionRecallEvalProcedureFixtures({
+      caseId: params.caseId,
+      procedurePool: params.procedurePool ?? [],
+      store: params.sandbox.fixtureStore,
+      provisionedAt: params.provisionedAt
+    });
+  }
+  const profileSnapshot = params.profileSnapshot ? await params.sandbox.provisionProfileSnapshot(params.profileSnapshot, params.provisionedAt) : void 0;
+  return {
+    ...entryProvisionResult ? { entryProvisionResult } : {},
+    ...profileSnapshot ? { profileSnapshotId: profileSnapshot.snapshotId } : {}
+  };
+}
+
 // src/app/evals/recall/sandbox.ts
 import { access, copyFile, mkdir, mkdtemp, rm } from "fs/promises";
 import { tmpdir } from "os";
 import path from "path";
 
+// src/adapters/db/eval-dream-run-store.ts
+function createEvalDreamRunStore(executor) {
+  return {
+    provisionDreamRun: (fixture) => provisionEvalDreamRun(executor, fixture),
+    getDreamRun: (runId) => getEvalDreamRun(executor, runId)
+  };
+}
+async function provisionEvalDreamRun(executor, fixture) {
+  const completedAt = fixture.completedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const runId = await createDreamRun(executor, {
+    tier: fixture.tier,
+    dryRun: false,
+    startedAt: completedAt
+  });
+  const efficiency = fixture.summaryJson.efficiency;
+  const estimatedCostUsd = fixture.estimatedCostUsd ?? (efficiency?.costPerSynthesizedDurableUsd !== void 0 && efficiency?.costPerSynthesizedDurableUsd !== null && efficiency.synthesizedDurableMutations > 0 ? efficiency.costPerSynthesizedDurableUsd * efficiency.synthesizedDurableMutations : 0);
+  await completeDreamRun(executor, runId, {
+    status: "completed",
+    inputTokens: 0,
+    outputTokens: 0,
+    estimatedCostUsd,
+    actionsTaken: fixture.summaryJson.actions_taken ?? 0,
+    actionsSkipped: 0,
+    durablesStaled: fixture.summaryJson.prune?.durablesStaled ?? 0,
+    summaryJson: fixture.summaryJson,
+    completedAt
+  });
+  return { runId };
+}
+async function getEvalDreamRun(executor, runId) {
+  const result = await executor.execute({
+    sql: `
+      SELECT
+        id,
+        tier,
+        project,
+        started_at,
+        completed_at,
+        status,
+        input_tokens,
+        output_tokens,
+        estimated_cost_usd,
+        model,
+        actions_taken,
+        actions_skipped,
+        durables_staled,
+        summary_json,
+        error,
+        dry_run,
+        config_json
+      FROM dream_runs
+      WHERE id = ?
+      LIMIT 1
+    `,
+    args: [runId.trim()]
+  });
+  const row = result.rows[0];
+  if (!row) {
+    return null;
+  }
+  const run = mapRunRow(row);
+  return {
+    runId: run.id,
+    status: run.status,
+    completedAt: run.completedAt,
+    estimatedCostUsd: run.estimatedCostUsd,
+    summaryJson: run.summaryJson
+  };
+}
+
 // src/adapters/db/eval-fixture-store.ts
 function createRecallEvalFixtureStore(database) {
   return {
-    insertEntry: async (entry, embedding, contentHash) => database.insertEntry(entry, embedding, contentHash),
+    insertDurable: async (entry, embedding, contentHash) => database.insertDurable(entry, embedding, contentHash),
     insertProcedure: async (procedure) => database.upsertProcedure(procedure),
     withTransaction: async (fn) => database.withTransaction(async (transaction) => fn(createRecallEvalFixtureStore(transaction)))
   };
 }
 
+// src/adapters/db/eval-profile-snapshot-store.ts
+import { createHash as createHash3, randomUUID } from "crypto";
+async function ensureEvalDreamRunExists(executor, runId, provisionedAt) {
+  const normalizedRunId = runId.trim();
+  if (normalizedRunId.length === 0) {
+    return;
+  }
+  const existing = await executor.execute({
+    sql: `
+      SELECT id
+      FROM dream_runs
+      WHERE id = ?
+      LIMIT 1
+    `,
+    args: [normalizedRunId]
+  });
+  if (existing.rows[0]) {
+    return;
+  }
+  await executor.execute({
+    sql: `
+      INSERT INTO dream_runs (
+        id,
+        tier,
+        started_at,
+        completed_at,
+        status,
+        dry_run
+      )
+      VALUES (?, 'light', ?, ?, 'completed', 0)
+    `,
+    args: [normalizedRunId, provisionedAt, provisionedAt]
+  });
+}
+async function provisionEvalProfileSnapshot(executor, fixture, provisionedAt) {
+  const snapshotId = fixture.id?.trim() || `eval-profile-${randomUUID()}`;
+  const durableIds = fixture.durableIds.map((id) => id.trim()).filter((id) => id.length > 0);
+  const directiveIds = (fixture.directiveIds ?? []).map((id) => id.trim()).filter((id) => id.length > 0);
+  const createdAt = fixture.createdAt ?? provisionedAt;
+  const asOf = fixture.asOf ?? createdAt;
+  const contentHash = createHash3("sha256").update(JSON.stringify({ durableIds, directiveIds, asOf })).digest("hex");
+  const runId = fixture.runId?.trim();
+  if (runId) {
+    await ensureEvalDreamRunExists(executor, runId, createdAt);
+  }
+  await createProfileSnapshot(executor, {
+    id: snapshotId,
+    durableIds,
+    directiveIds,
+    asOf,
+    contentHash,
+    runId: runId ?? null,
+    createdAt
+  });
+  await updateDreamState(executor, {
+    activeProfileSnapshotId: snapshotId,
+    updatedAt: createdAt
+  });
+  return { snapshotId };
+}
+
 // src/app/evals/recall/sandbox.ts
 var SANDBOX_DB_FILENAME = "knowledge.db";
 var SANDBOX_DIR_PREFIX = "agenr-recall-eval-";
@@ -347,6 +634,12 @@ async function setupRecallEvalSandbox(request) {
       fixtureStore: createRecallEvalFixtureStore(openDatabase),
       episodeDatabase: openDatabase,
       procedureDatabase: openDatabase,
+      sessionStartRepository: createSessionStartRepository(openDatabase),
+      listActiveAbstainDirectives: (now) => listActiveAbstainDirectives(openDatabase, now),
+      listActiveSessionStartProactiveDirectives: (now) => listActiveSessionStartProactiveDirectives(openDatabase, now),
+      listActiveTopicProactiveDirectives: (now) => listActiveTopicProactiveDirectives(openDatabase, now),
+      provisionProfileSnapshot: (fixture, provisionedAt) => provisionEvalProfileSnapshot(openDatabase, fixture, provisionedAt),
+      dreamRunStore: createEvalDreamRunStore(openDatabase),
       ...snapshot ? { snapshot } : {},
       createRecallPorts: (embedding) => createRecallAdapter(openDatabase, embedding),
       cleanup: async () => {
@@ -438,14 +731,6 @@ function applyTelemetryWriteGate(ports, sandbox) {
   };
 }
 
-// src/app/debug-artifacts/before-turn.ts
-var BEFORE_TURN_DEBUG_ARTIFACT_DEFAULT_TOP_K = 10;
-var BEFORE_TURN_DEBUG_ARTIFACT_MAX_TOP_K = 25;
-
-// src/app/debug-artifacts/recall.ts
-var RECALL_DEBUG_ARTIFACT_DEFAULT_TOP_K = 10;
-var RECALL_DEBUG_ARTIFACT_MAX_TOP_K = 25;
-
 // src/app/evals/before-turn/build-debug-artifact.ts
 function buildBeforeTurnDebugArtifact(params) {
   const { request, patch, sandbox } = params;
@@ -587,38 +872,11 @@ function normalizePatchForEvalOutput(patch) {
 async function runBeforeTurnEvalCase(request, dependencies = {}) {
   const startedAt = Date.now();
   const provisionedAt = new Date(startedAt).toISOString();
+  const ablation = resolveAblationConfig(request.sandbox);
+  const evalNow = parseEvalNow(ablation.now);
+  const embeddingResolver = createEvalEmbeddingResolver();
   let sandbox;
-  let sharedEmbeddingPort;
-  let sharedEmbeddingError;
   let timings;
-  const getEmbeddingSupport = () => {
-    if (sharedEmbeddingPort) {
-      return {
-        available: true,
-        port: sharedEmbeddingPort
-      };
-    }
-    if (sharedEmbeddingError) {
-      return {
-        available: false,
-        error: sharedEmbeddingError
-      };
-    }
-    const config = readConfig();
-    try {
-      sharedEmbeddingPort = createEmbeddingClient(resolveEmbeddingApiKey(config), resolveEmbeddingModel(config));
-      return {
-        available: true,
-        port: sharedEmbeddingPort
-      };
-    } catch (error) {
-      sharedEmbeddingError = error instanceof Error ? error.message : String(error);
-      return {
-        available: false,
-        error: sharedEmbeddingError
-      };
-    }
-  };
   try {
     const sandboxStartedAt = Date.now();
     try {
@@ -641,28 +899,18 @@ async function runBeforeTurnEvalCase(request, dependencies = {}) {
         timings: request.options?.includeTimings === true ? timings : void 0
       });
     }
-    if (request.memoryPool.length > 0 || (request.procedurePool?.length ?? 0) > 0) {
+    if (request.memoryPool.length > 0 || (request.procedurePool?.length ?? 0) > 0 || shouldProvisionProfileSnapshot(ablation)) {
       const provisionStartedAt = Date.now();
       try {
-        if (request.memoryPool.length > 0) {
-          const embeddingSupport = getEmbeddingSupport();
-          const embeddingPort = embeddingSupport.port ?? createUnavailableEmbeddingPort(embeddingSupport.error ?? "Embeddings are unavailable.");
-          await provisionRecallEvalFixtures({
-            caseId: request.caseId,
-            memoryPool: request.memoryPool,
-            store: sandbox.fixtureStore,
-            embedding: embeddingPort,
-            provisionedAt
-          });
-        }
-        if ((request.procedurePool?.length ?? 0) > 0) {
-          await provisionRecallEvalProcedureFixtures({
-            caseId: request.caseId,
-            procedurePool: request.procedurePool ?? [],
-            store: sandbox.fixtureStore,
-            provisionedAt
-          });
-        }
+        await provisionEvalSandbox({
+          caseId: request.caseId,
+          sandbox,
+          memoryPool: request.memoryPool,
+          procedurePool: request.procedurePool,
+          profileSnapshot: shouldProvisionProfileSnapshot(ablation) ? ablation.profileSnapshot : void 0,
+          embedding: request.memoryPool.length > 0 ? embeddingResolver.portOrUnavailable() : void 0,
+          provisionedAt
+        });
         timings = {
           ...timings,
           fixtureProvisionMs: elapsedMs(provisionStartedAt)
@@ -685,14 +933,48 @@ async function runBeforeTurnEvalCase(request, dependencies = {}) {
     }
     const beforeTurnStartedAt = Date.now();
     try {
-      const embeddingSupport = getEmbeddingSupport();
-      const sandboxRecallPorts = sandbox.createRecallPorts(
+      if (isMemoryOffArm(ablation)) {
+        timings = {
+          ...timings,
+          beforeTurnMs: elapsedMs(beforeTurnStartedAt),
+          totalMs: elapsedMs(startedAt)
+        };
+        return buildBeforeTurnEvalSuccessResponse({
+          request,
+          patch: {
+            durableMemory: [],
+            diagnostics: {
+              abstained: true,
+              abstentionReasons: ["memory_off_ablation"],
+              queryVariants: [],
+              recentTurnCount: 0,
+              turnSignalLabels: [],
+              durableRecallUsed: false,
+              durableRecallCandidateCount: 0,
+              procedureRecallUsed: false,
+              procedureCandidateCount: 0,
+              notices: ["memory-off ablation arm stubbed before-turn injection."]
+            }
+          },
+          timings: request.options?.includeTimings === true ? timings : void 0,
+          sandbox
+        });
+      }
+      const activeSandbox = sandbox;
+      if (!activeSandbox) {
+        throw new Error("Before-turn eval sandbox was not initialized.");
+      }
+      const embeddingSupport = embeddingResolver.getSupport();
+      const sandboxRecallPorts = activeSandbox.createRecallPorts(
         embeddingSupport.port ?? createUnavailableEmbeddingPort(embeddingSupport.error ?? "Embeddings are unavailable.")
       );
-      const recallPorts = applyTelemetryWriteGate(attachCrossEncoderPort(sandboxRecallPorts, dependencies.crossEncoder), sandbox);
+      const recallPorts = applyTelemetryWriteGate(attachCrossEncoderPort(sandboxRecallPorts, dependencies.crossEncoder), activeSandbox);
       const patch = await runBeforeTurn(request.beforeTurnInput, {
         recall: recallPorts,
-        procedures: sandbox.procedureDatabase,
+        procedures: activeSandbox.procedureDatabase,
+        ...evalNow ? { now: evalNow } : {},
+        listActiveAbstainDirectives: () => activeSandbox.listActiveAbstainDirectives(evalNow),
+        listActiveTopicProactiveDirectives: () => activeSandbox.listActiveTopicProactiveDirectives(evalNow),
         embedQuery: embeddingSupport.port ? async (text) => {
           const vectors = await embeddingSupport.port.embed([text]);
           return vectors[0] ?? [];
@@ -720,7 +1002,7 @@ async function runBeforeTurnEvalCase(request, dependencies = {}) {
         patch,
         renderedPatchText,
         timings: request.options?.includeTimings === true ? timings : void 0,
-        sandbox
+        sandbox: activeSandbox
       });
     } catch (error) {
       timings = {
@@ -760,19 +1042,14 @@ function toErrorDetails(error) {
     cause: String(error)
   };
 }
-function createUnavailableEmbeddingPort(message) {
-  return {
-    async embed() {
-      throw new Error(message);
-    }
-  };
-}
 function elapsedMs(startedAt) {
   return Date.now() - startedAt;
 }
 
 // src/adapters/api/validation/internal-eval-shared.ts
-var SANDBOX_REQUEST_KEYS = /* @__PURE__ */ new Set(["root", "preserve", "corpusSeed"]);
+var SANDBOX_REQUEST_KEYS = /* @__PURE__ */ new Set(["root", "preserve", "corpusSeed", "ablationArm", "now", "profileSnapshot"]);
+var PROFILE_SNAPSHOT_KEYS = /* @__PURE__ */ new Set(["id", "durableIds", "directiveIds", "asOf", "runId", "createdAt"]);
+var ABLATION_ARMS2 = ["memory-off", "store-only", "dreaming-on"];
 var CORPUS_SEED_MODES = ["fixture", "snapshot_copy"];
 var FIXTURE_CORPUS_SEED_KEYS = /* @__PURE__ */ new Set(["mode"]);
 var SNAPSHOT_COPY_CORPUS_SEED_KEYS = /* @__PURE__ */ new Set(["mode", "snapshotDbPath", "snapshotId", "snapshotLabel", "allowTelemetryWrites"]);
@@ -788,9 +1065,6 @@ var FIXTURE_ENTRY_KEYS = /* @__PURE__ */ new Set([
   "source_context",
   "created_at",
   "updated_at",
-  "retired",
-  "retired_at",
-  "retired_reason",
   "superseded_by",
   "claim_key",
   "claim_key_status",
@@ -802,7 +1076,9 @@ var FIXTURE_ENTRY_KEYS = /* @__PURE__ */ new Set([
   "valid_from",
   "valid_to",
   "supersession_kind",
-  "supersession_reason"
+  "supersession_reason",
+  "directive_polarity",
+  "directive_trigger"
 ]);
 var FIXTURE_PROCEDURE_KEYS = /* @__PURE__ */ new Set([
   "id",
@@ -817,9 +1093,10 @@ var FIXTURE_PROCEDURE_KEYS = /* @__PURE__ */ new Set([
   "failure_modes",
   "sources",
   "source_file",
-  "retired",
-  "retired_at",
-  "retired_reason",
+  "valid_from",
+  "valid_to",
+  "supersession_kind",
+  "supersession_reason",
   "superseded_by",
   "created_at",
   "updated_at"
@@ -850,7 +1127,10 @@ function parseSandbox(value, issues) {
   return {
     root: parseOptionalTrimmedString(sandbox.root, "sandbox.root", issues),
     preserve: parseOptionalBoolean(sandbox.preserve, "sandbox.preserve", issues),
-    corpusSeed: parseCorpusSeed(sandbox.corpusSeed, issues)
+    corpusSeed: parseCorpusSeed(sandbox.corpusSeed, issues),
+    ablationArm: parseOptionalAblationArm(sandbox.ablationArm, "sandbox.ablationArm", issues),
+    now: parseOptionalTimestampString(sandbox.now, "sandbox.now", issues),
+    profileSnapshot: parseProfileSnapshot(sandbox.profileSnapshot, issues)
   };
 }
 function parseCorpusSeed(value, issues) {
@@ -922,7 +1202,10 @@ function mapSandboxRequestDto(dto) {
   return {
     root: dto.root,
     preserve: dto.preserve,
-    corpusSeed: dto.corpusSeed
+    corpusSeed: dto.corpusSeed,
+    ablationArm: dto.ablationArm,
+    now: dto.now,
+    profileSnapshot: dto.profileSnapshot
   };
 }
 function mapFixtureEntryDto(dto) {
@@ -938,9 +1221,6 @@ function mapFixtureEntryDto(dto) {
     source_context: dto.source_context,
     created_at: dto.created_at,
     updated_at: dto.updated_at,
-    retired: dto.retired,
-    retired_at: dto.retired_at,
-    retired_reason: dto.retired_reason,
     superseded_by: dto.superseded_by,
     claim_key: dto.claim_key,
     claim_key_status: dto.claim_key_status,
@@ -952,7 +1232,9 @@ function mapFixtureEntryDto(dto) {
     valid_from: dto.valid_from,
     valid_to: dto.valid_to,
     supersession_kind: dto.supersession_kind,
-    supersession_reason: dto.supersession_reason
+    supersession_reason: dto.supersession_reason,
+    directive_polarity: dto.directive_polarity,
+    directive_trigger: dto.directive_trigger
   };
 }
 function mapFixtureProcedureDto(dto) {
@@ -969,9 +1251,10 @@ function mapFixtureProcedureDto(dto) {
     failure_modes: dto.failure_modes,
     sources: dto.sources,
     source_file: dto.source_file,
-    retired: dto.retired,
-    retired_at: dto.retired_at,
-    retired_reason: dto.retired_reason,
+    valid_from: dto.valid_from,
+    valid_to: dto.valid_to,
+    supersession_kind: dto.supersession_kind,
+    supersession_reason: dto.supersession_reason,
     superseded_by: dto.superseded_by,
     created_at: dto.created_at,
     updated_at: dto.updated_at
@@ -1023,7 +1306,7 @@ function parseFixtureEntry(value, index, issues) {
     return void 0;
   }
   pushUnexpectedFields(fixture, FIXTURE_ENTRY_KEYS, basePath, issues);
-  const type = parseEntryType(fixture.type, `${basePath}.type`, issues);
+  const type = parseDurableKind(fixture.type, `${basePath}.type`, issues);
   const subject = parseRequiredTrimmedString(fixture.subject, `${basePath}.subject`, issues);
   const content = parseRequiredTrimmedString(fixture.content, `${basePath}.content`, issues);
   if (type === void 0 || subject === void 0 || content === void 0) {
@@ -1044,9 +1327,6 @@ function parseFixtureEntry(value, index, issues) {
     source_context: parseOptionalTrimmedString(fixture.source_context, `${basePath}.source_context`, issues),
     created_at: parseOptionalTimestampString(fixture.created_at, `${basePath}.created_at`, issues),
     updated_at: parseOptionalTimestampString(fixture.updated_at, `${basePath}.updated_at`, issues),
-    retired: parseOptionalBoolean(fixture.retired, `${basePath}.retired`, issues),
-    retired_at: parseOptionalTimestampString(fixture.retired_at, `${basePath}.retired_at`, issues),
-    retired_reason: parseOptionalTrimmedString(fixture.retired_reason, `${basePath}.retired_reason`, issues),
     superseded_by: parseOptionalTrimmedString(fixture.superseded_by, `${basePath}.superseded_by`, issues),
     claim_key: parseOptionalTrimmedString(fixture.claim_key, `${basePath}.claim_key`, issues),
     claim_key_status: parseOptionalClaimKeyStatus(fixture.claim_key_status, `${basePath}.claim_key_status`, issues),
@@ -1058,9 +1338,80 @@ function parseFixtureEntry(value, index, issues) {
     valid_from: parseOptionalTimestampString(fixture.valid_from, `${basePath}.valid_from`, issues),
     valid_to: parseOptionalTimestampString(fixture.valid_to, `${basePath}.valid_to`, issues),
     supersession_kind: parseOptionalTrimmedString(fixture.supersession_kind, `${basePath}.supersession_kind`, issues),
-    supersession_reason: parseOptionalTrimmedString(fixture.supersession_reason, `${basePath}.supersession_reason`, issues)
+    supersession_reason: parseOptionalTrimmedString(fixture.supersession_reason, `${basePath}.supersession_reason`, issues),
+    directive_polarity: parseOptionalDirectivePolarity(fixture.directive_polarity, `${basePath}.directive_polarity`, issues),
+    directive_trigger: parseOptionalDirectiveTrigger(fixture.directive_trigger, `${basePath}.directive_trigger`, issues)
   };
 }
+function parseOptionalAblationArm(value, path2, issues) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "string" || !ABLATION_ARMS2.includes(value)) {
+    pushIssue(issues, path2, `Expected one of: ${ABLATION_ARMS2.join(", ")}.`);
+    return void 0;
+  }
+  return value;
+}
+function parseProfileSnapshot(value, issues) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const snapshot = parseObject(value, "sandbox.profileSnapshot", issues);
+  if (snapshot === void 0) {
+    return void 0;
+  }
+  pushUnexpectedFields(snapshot, PROFILE_SNAPSHOT_KEYS, "sandbox.profileSnapshot", issues);
+  const durableIds = parseRequiredStringArray(snapshot.durableIds, "sandbox.profileSnapshot.durableIds", issues);
+  if (durableIds === void 0) {
+    return void 0;
+  }
+  return {
+    id: parseOptionalTrimmedString(snapshot.id, "sandbox.profileSnapshot.id", issues),
+    durableIds,
+    directiveIds: parseOptionalStringArray(snapshot.directiveIds, "sandbox.profileSnapshot.directiveIds", issues),
+    asOf: parseOptionalTimestampString(snapshot.asOf, "sandbox.profileSnapshot.asOf", issues),
+    runId: parseOptionalTrimmedString(snapshot.runId, "sandbox.profileSnapshot.runId", issues),
+    createdAt: parseOptionalTimestampString(snapshot.createdAt, "sandbox.profileSnapshot.createdAt", issues)
+  };
+}
+function parseRequiredStringArray(value, path2, issues) {
+  if (!Array.isArray(value) || value.length === 0 || value.some((item) => typeof item !== "string" || item.trim().length === 0)) {
+    pushIssue(issues, path2, "Expected a non-empty array of strings.");
+    return void 0;
+  }
+  return value.map((item) => item.trim());
+}
+function parseOptionalDirectivePolarity(value, path2, issues) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    pushIssue(issues, path2, "Expected a string.");
+    return void 0;
+  }
+  const polarity = parseDirectivePolarity(value);
+  if (!polarity) {
+    pushIssue(issues, path2, "Expected abstain or proactive.");
+    return void 0;
+  }
+  return polarity;
+}
+function parseOptionalDirectiveTrigger(value, path2, issues) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    pushIssue(issues, path2, "Expected a string.");
+    return void 0;
+  }
+  const trigger = parseDirectiveTrigger(value);
+  if (!trigger) {
+    pushIssue(issues, path2, "Expected session_start, always, or topic:<term>.");
+    return void 0;
+  }
+  return trigger;
+}
 function parseFixtureProcedure(value, index, issues) {
   const basePath = `procedurePool[${index}]`;
   const fixture = parseObject(value, basePath, issues);
@@ -1108,9 +1459,10 @@ function parseFixtureProcedure(value, index, issues) {
       failure_modes: normalized.failure_modes,
       sources: normalized.sources,
       source_file: parseOptionalTrimmedString(fixture.source_file, `${basePath}.source_file`, issues),
-      retired: parseOptionalBoolean(fixture.retired, `${basePath}.retired`, issues),
-      retired_at: parseOptionalTimestampString(fixture.retired_at, `${basePath}.retired_at`, issues),
-      retired_reason: parseOptionalTrimmedString(fixture.retired_reason, `${basePath}.retired_reason`, issues),
+      valid_from: parseOptionalTimestampString(fixture.valid_from, `${basePath}.valid_from`, issues),
+      valid_to: parseOptionalTimestampString(fixture.valid_to, `${basePath}.valid_to`, issues),
+      supersession_kind: parseOptionalTrimmedString(fixture.supersession_kind, `${basePath}.supersession_kind`, issues),
+      supersession_reason: parseOptionalTrimmedString(fixture.supersession_reason, `${basePath}.supersession_reason`, issues),
       superseded_by: parseOptionalTrimmedString(fixture.superseded_by, `${basePath}.superseded_by`, issues),
       created_at: parseOptionalTimestampString(fixture.created_at, `${basePath}.created_at`, issues),
       updated_at: parseOptionalTimestampString(fixture.updated_at, `${basePath}.updated_at`, issues)
@@ -1120,9 +1472,9 @@ function parseFixtureProcedure(value, index, issues) {
     return void 0;
   }
 }
-function parseEntryType(value, path2, issues) {
-  if (typeof value !== "string" || !ENTRY_TYPES.includes(value)) {
-    pushIssue(issues, path2, `Expected one of: ${ENTRY_TYPES.join(", ")}.`);
+function parseDurableKind(value, path2, issues) {
+  if (typeof value !== "string" || !DURABLE_KINDS.includes(value)) {
+    pushIssue(issues, path2, `Expected one of: ${DURABLE_KINDS.join(", ")}.`);
     return void 0;
   }
   return value;
@@ -1467,28 +1819,715 @@ var jsonResponse = (body, status) => new Response(JSON.stringify(body), {
   }
 });
 
-// src/app/evals/recall/collect-diagnostics.ts
-function createRecallEvalDiagnosticsCollector(request) {
-  const diagnosticsRequested = wantsRecallEvalDiagnostics(request);
-  const timingsRequested = request.options?.includeTimings === true;
-  const debugArtifactRequested = request.options?.includeDebugArtifact === true;
-  const observationEnabled = diagnosticsRequested || timingsRequested || debugArtifactRequested;
-  const execution = {
-    mode: "isolated-case",
-    provisioning: "exact-fixture-seed",
-    recallPath: request.recallPath ?? "core",
-    memoryPoolCount: request.memoryPool.length,
-    provisionedCount: 0,
-    requestedDiagnostics: request.options?.includeDiagnostics === true,
-    requestedCandidates: request.options?.includeCandidates === true
+// src/app/evals/dreaming-efficiency/normalize-response.ts
+function buildDreamingEfficiencyEvalSuccessResponse(params) {
+  return {
+    status: "ok",
+    caseId: params.request.caseId,
+    efficiency: params.efficiency,
+    profileInjectionTokenEstimate: params.profileInjectionTokenEstimate,
+    ...params.storeOnlyEquivalentTokenEstimate !== void 0 ? { storeOnlyEquivalentTokenEstimate: params.storeOnlyEquivalentTokenEstimate } : {},
+    ...params.timings ? { timings: params.timings } : {},
+    sandbox: buildSandboxResult2(params.sandbox)
   };
-  const stageTimings = {
-    sandboxSetupMs: 0,
-    fixtureProvisionMs: 0,
-    recallMs: 0,
-    queryEmbeddingMs: 0,
-    vectorSearchMs: 0,
-    lexicalSearchMs: 0,
+}
+function buildDreamingEfficiencyEvalErrorResponse(params) {
+  return {
+    status: "error",
+    caseId: params.request.caseId,
+    error: {
+      code: params.code,
+      message: params.message,
+      ...params.details !== void 0 ? { details: params.details } : {}
+    },
+    ...params.timings ? { timings: params.timings } : {},
+    ...params.sandbox ? { sandbox: buildSandboxResult2(params.sandbox) } : {}
+  };
+}
+function buildSandboxResult2(sandbox) {
+  return {
+    root: sandbox.root,
+    dbPath: sandbox.dbPath,
+    preserved: sandbox.preserved,
+    ...sandbox.snapshot ? { snapshot: sandbox.snapshot } : {}
+  };
+}
+
+// src/app/evals/dreaming-efficiency/run-dreaming-efficiency-eval-case.ts
+async function runDreamingEfficiencyEvalCase(request) {
+  const startedAt = Date.now();
+  const provisionedAt = new Date(startedAt).toISOString();
+  const ablation = resolveAblationConfig(request.sandbox);
+  const shouldProvisionProfile = shouldProvisionProfileSnapshot(ablation);
+  const embeddingResolver = createEvalEmbeddingResolver();
+  let sandbox;
+  let timings;
+  let dreamRunId;
+  try {
+    const sandboxStartedAt = Date.now();
+    try {
+      sandbox = await setupRecallEvalSandbox(request.sandbox);
+      timings = { sandboxSetupMs: elapsedMs2(sandboxStartedAt) };
+    } catch (error) {
+      return buildDreamingEfficiencyEvalErrorResponse({
+        request,
+        code: "sandbox_setup_failed",
+        message: "Failed to create isolated dreaming-efficiency eval sandbox.",
+        details: toErrorDetails2(error),
+        timings: request.options?.includeTimings === true ? { totalMs: elapsedMs2(startedAt), sandboxSetupMs: elapsedMs2(sandboxStartedAt) } : void 0
+      });
+    }
+    const provisionStartedAt = Date.now();
+    try {
+      if (request.memoryPool.length > 0) {
+        await provisionEvalSandbox({
+          caseId: request.caseId,
+          sandbox,
+          memoryPool: request.memoryPool,
+          embedding: request.memoryPool.length > 0 ? embeddingResolver.portOrUnavailable() : void 0,
+          provisionedAt
+        });
+      }
+      const seededRun = await sandbox.dreamRunStore.provisionDreamRun(request.dreamRunFixture);
+      dreamRunId = seededRun.runId;
+      if (shouldProvisionProfile) {
+        await sandbox.provisionProfileSnapshot(
+          {
+            ...ablation.profileSnapshot,
+            runId: dreamRunId
+          },
+          provisionedAt
+        );
+      }
+      timings = { ...timings, fixtureProvisionMs: elapsedMs2(provisionStartedAt) };
+    } catch (error) {
+      return buildDreamingEfficiencyEvalErrorResponse({
+        request,
+        code: "fixture_provision_failed",
+        message: "Failed to provision dreaming-efficiency eval fixtures into isolated storage.",
+        details: toErrorDetails2(error),
+        timings: request.options?.includeTimings === true ? { ...timings, totalMs: elapsedMs2(startedAt), fixtureProvisionMs: elapsedMs2(provisionStartedAt) } : void 0,
+        sandbox
+      });
+    }
+    try {
+      const persistedRun = dreamRunId ? await sandbox.dreamRunStore.getDreamRun(dreamRunId) : null;
+      if (!persistedRun?.summaryJson) {
+        return buildDreamingEfficiencyEvalErrorResponse({
+          request,
+          code: "efficiency_resolution_failed",
+          message: "Persisted dreaming run summary is required for dreaming-efficiency eval cases.",
+          timings: request.options?.includeTimings === true ? { ...timings, totalMs: elapsedMs2(startedAt) } : void 0,
+          sandbox
+        });
+      }
+      const efficiency = deriveDreamEfficiencySummary(persistedRun.summaryJson, persistedRun.estimatedCostUsd);
+      if (!efficiency) {
+        return buildDreamingEfficiencyEvalErrorResponse({
+          request,
+          code: "efficiency_resolution_failed",
+          message: "Persisted dreaming run summary must include scan and project counters for efficiency derivation.",
+          timings: request.options?.includeTimings === true ? { ...timings, totalMs: elapsedMs2(startedAt) } : void 0,
+          sandbox
+        });
+      }
+      const directiveCount = request.memoryPool.filter((entry) => entry.type === "directive").length;
+      const storeOnlyEquivalentTokenEstimate = request.memoryPool.length > 0 ? estimateProfileInjectionTokens(request.memoryPool.length, directiveCount) : void 0;
+      timings = {
+        ...timings,
+        totalMs: elapsedMs2(startedAt)
+      };
+      return buildDreamingEfficiencyEvalSuccessResponse({
+        request,
+        efficiency,
+        profileInjectionTokenEstimate: efficiency.profileInjectionTokenEstimate,
+        ...storeOnlyEquivalentTokenEstimate !== void 0 ? { storeOnlyEquivalentTokenEstimate } : {},
+        timings: request.options?.includeTimings === true ? timings : void 0,
+        sandbox
+      });
+    } catch (error) {
+      return buildDreamingEfficiencyEvalErrorResponse({
+        request,
+        code: "efficiency_resolution_failed",
+        message: "Failed to resolve dreaming-efficiency telemetry from isolated eval state.",
+        details: toErrorDetails2(error),
+        timings: request.options?.includeTimings === true ? { ...timings, totalMs: elapsedMs2(startedAt) } : void 0,
+        sandbox
+      });
+    }
+  } catch (error) {
+    return buildDreamingEfficiencyEvalErrorResponse({
+      request,
+      code: "internal_error",
+      message: "Dreaming-efficiency eval execution failed unexpectedly.",
+      details: toErrorDetails2(error),
+      timings: request.options?.includeTimings === true ? { ...timings, totalMs: elapsedMs2(startedAt) } : void 0,
+      sandbox
+    });
+  } finally {
+    await sandbox?.cleanup().catch(() => void 0);
+  }
+}
+function toErrorDetails2(error) {
+  if (error instanceof Error) {
+    return { cause: error.message };
+  }
+  return { cause: String(error) };
+}
+function elapsedMs2(startedAt) {
+  return Date.now() - startedAt;
+}
+
+// src/adapters/api/validation/parse-dream-completion-summary.ts
+var DREAM_COMPLETION_SUMMARY_KEYS = /* @__PURE__ */ new Set([
+  "actions_taken",
+  "backupSkipped",
+  "stages_skipped",
+  "durables_skipped",
+  "observations",
+  "recommendations",
+  "scan",
+  "extract",
+  "reconcile",
+  "temporalize",
+  "project",
+  "prune",
+  "efficiency"
+]);
+var DREAM_SCAN_KEYS = /* @__PURE__ */ new Set([
+  "episodesSinceLastRun",
+  "ingestFilesSinceLastRun",
+  "durablesCreatedSinceLastRun",
+  "evidenceRefs",
+  "unsynthesizedImportanceSum"
+]);
+var DREAM_EVIDENCE_REF_KEYS = /* @__PURE__ */ new Set(["kind", "locator", "observedAt"]);
+var DREAM_EXTRACT_KEYS = /* @__PURE__ */ new Set([
+  "episodesScanned",
+  "candidatesEmitted",
+  "newCandidates",
+  "refineCandidates",
+  "knownCandidates",
+  "durablesInserted"
+]);
+var DREAM_TEMPORALIZE_KEYS = /* @__PURE__ */ new Set(["revisionsIdentified", "revisionsApplied", "revisionsSkipped"]);
+var DREAM_PROJECT_KEYS = /* @__PURE__ */ new Set(["profileDurableCount", "directiveCount", "snapshotId", "applied"]);
+var DREAM_PRUNE_KEYS = /* @__PURE__ */ new Set(["durablesScanned", "candidatesIdentified", "candidatesProtected", "candidatesRetirable", "durablesStaled", "dryRun"]);
+var DREAM_EFFICIENCY_KEYS = /* @__PURE__ */ new Set([
+  "evidenceItemsRead",
+  "synthesizedDurableMutations",
+  "costPerSynthesizedDurableUsd",
+  "profileInjectionTokenEstimate",
+  "recomputeRatio"
+]);
+var DURABLE_SKIP_KEYS = /* @__PURE__ */ new Set(["durable_id", "reason"]);
+var DREAM_STAGE_SKIP_KEYS = /* @__PURE__ */ new Set(["stage", "reason"]);
+var DREAM_EVIDENCE_KINDS = ["episode", "ingest_log", "durable", "transcript"];
+var DREAM_STAGE_SKIP_REASONS = ["light_tier"];
+function parseDreamCompletionSummary(value, path2, issues) {
+  const summary = parseObject(value, path2, issues);
+  if (summary === void 0) {
+    return void 0;
+  }
+  pushUnexpectedFields(summary, DREAM_COMPLETION_SUMMARY_KEYS, path2, issues);
+  const actionsTaken = parseRequiredNonNegativeInteger(summary.actions_taken, `${path2}.actions_taken`, issues);
+  const backupSkipped = parseOptionalBoolean2(summary.backupSkipped, `${path2}.backupSkipped`, issues);
+  const stagesSkipped = parseDreamStageSkips(summary.stages_skipped, `${path2}.stages_skipped`, issues);
+  const durablesSkipped = parseDurablesSkipped(summary.durables_skipped, `${path2}.durables_skipped`, issues);
+  const observations = parseRequiredStringArray2(summary.observations, `${path2}.observations`, issues);
+  const recommendations = parseRequiredStringArray2(summary.recommendations, `${path2}.recommendations`, issues);
+  const scan = parseDreamScanSummary(summary.scan, `${path2}.scan`, issues);
+  const project = parseDreamProjectSummary(summary.project, `${path2}.project`, issues);
+  parseOptionalObject(summary.reconcile, `${path2}.reconcile`, issues);
+  return {
+    actions_taken: actionsTaken ?? 0,
+    ...backupSkipped !== void 0 ? { backupSkipped } : {},
+    ...stagesSkipped !== void 0 ? { stages_skipped: stagesSkipped } : {},
+    durables_skipped: durablesSkipped ?? [],
+    observations: observations ?? [],
+    recommendations: recommendations ?? [],
+    ...scan ? { scan } : {},
+    ...parseDreamExtractSummary(summary.extract, `${path2}.extract`, issues) ?? {},
+    ...parseDreamTemporalizeSummary(summary.temporalize, `${path2}.temporalize`, issues) ?? {},
+    ...project ? { project } : {},
+    ...parseDreamPruneSummary(summary.prune, `${path2}.prune`, issues) ?? {},
+    ...parseDreamEfficiencySummary(summary.efficiency, `${path2}.efficiency`, issues) ?? {}
+  };
+}
+function parseDreamStageSkips(value, path2, issues) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!Array.isArray(value)) {
+    pushIssue(issues, path2, "Expected an array.");
+    return void 0;
+  }
+  return value.flatMap((item, index) => {
+    const itemPath = `${path2}[${index}]`;
+    const record = parseObject(item, itemPath, issues);
+    if (record === void 0) {
+      return [];
+    }
+    pushUnexpectedFields(record, DREAM_STAGE_SKIP_KEYS, itemPath, issues);
+    const stage = parseDreamStage(record.stage, `${itemPath}.stage`, issues);
+    const reason = parseDreamStageSkipReason(record.reason, `${itemPath}.reason`, issues);
+    return [
+      {
+        stage: stage ?? "scan",
+        reason: reason ?? "light_tier"
+      }
+    ];
+  });
+}
+function parseDreamScanSummary(value, path2, issues) {
+  const scan = parseRequiredObject(value, path2, issues);
+  if (scan === void 0) {
+    return void 0;
+  }
+  pushUnexpectedFields(scan, DREAM_SCAN_KEYS, path2, issues);
+  return {
+    episodesSinceLastRun: parseRequiredNonNegativeInteger(scan.episodesSinceLastRun, `${path2}.episodesSinceLastRun`, issues) ?? 0,
+    ingestFilesSinceLastRun: parseRequiredNonNegativeInteger(scan.ingestFilesSinceLastRun, `${path2}.ingestFilesSinceLastRun`, issues) ?? 0,
+    durablesCreatedSinceLastRun: parseRequiredNonNegativeInteger(scan.durablesCreatedSinceLastRun, `${path2}.durablesCreatedSinceLastRun`, issues) ?? 0,
+    evidenceRefs: parseEvidenceRefs(scan.evidenceRefs, `${path2}.evidenceRefs`, issues) ?? [],
+    unsynthesizedImportanceSum: parseRequiredNonNegativeNumber(scan.unsynthesizedImportanceSum, `${path2}.unsynthesizedImportanceSum`, issues) ?? 0
+  };
+}
+function parseDreamExtractSummary(value, path2, issues) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const extract = parseObject(value, path2, issues);
+  if (extract === void 0) {
+    return void 0;
+  }
+  pushUnexpectedFields(extract, DREAM_EXTRACT_KEYS, path2, issues);
+  return {
+    extract: {
+      episodesScanned: parseRequiredNonNegativeInteger(extract.episodesScanned, `${path2}.episodesScanned`, issues) ?? 0,
+      candidatesEmitted: parseRequiredNonNegativeInteger(extract.candidatesEmitted, `${path2}.candidatesEmitted`, issues) ?? 0,
+      newCandidates: parseRequiredNonNegativeInteger(extract.newCandidates, `${path2}.newCandidates`, issues) ?? 0,
+      refineCandidates: parseRequiredNonNegativeInteger(extract.refineCandidates, `${path2}.refineCandidates`, issues) ?? 0,
+      knownCandidates: parseRequiredNonNegativeInteger(extract.knownCandidates, `${path2}.knownCandidates`, issues) ?? 0,
+      durablesInserted: parseRequiredNonNegativeInteger(extract.durablesInserted, `${path2}.durablesInserted`, issues) ?? 0
+    }
+  };
+}
+function parseDreamTemporalizeSummary(value, path2, issues) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const temporalize = parseObject(value, path2, issues);
+  if (temporalize === void 0) {
+    return void 0;
+  }
+  pushUnexpectedFields(temporalize, DREAM_TEMPORALIZE_KEYS, path2, issues);
+  return {
+    temporalize: {
+      revisionsIdentified: parseRequiredNonNegativeInteger(temporalize.revisionsIdentified, `${path2}.revisionsIdentified`, issues) ?? 0,
+      revisionsApplied: parseRequiredNonNegativeInteger(temporalize.revisionsApplied, `${path2}.revisionsApplied`, issues) ?? 0,
+      revisionsSkipped: parseRequiredNonNegativeInteger(temporalize.revisionsSkipped, `${path2}.revisionsSkipped`, issues) ?? 0
+    }
+  };
+}
+function parseDreamProjectSummary(value, path2, issues) {
+  const project = parseRequiredObject(value, path2, issues);
+  if (project === void 0) {
+    return void 0;
+  }
+  pushUnexpectedFields(project, DREAM_PROJECT_KEYS, path2, issues);
+  return {
+    profileDurableCount: parseRequiredNonNegativeInteger(project.profileDurableCount, `${path2}.profileDurableCount`, issues) ?? 0,
+    directiveCount: parseRequiredNonNegativeInteger(project.directiveCount, `${path2}.directiveCount`, issues) ?? 0,
+    snapshotId: parseOptionalStringOrNull(project.snapshotId, `${path2}.snapshotId`, issues),
+    applied: parseRequiredBoolean(project.applied, `${path2}.applied`, issues) ?? false
+  };
+}
+function parseDreamPruneSummary(value, path2, issues) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const prune = parseObject(value, path2, issues);
+  if (prune === void 0) {
+    return void 0;
+  }
+  pushUnexpectedFields(prune, DREAM_PRUNE_KEYS, path2, issues);
+  return {
+    prune: {
+      durablesScanned: parseRequiredNonNegativeInteger(prune.durablesScanned, `${path2}.durablesScanned`, issues) ?? 0,
+      candidatesIdentified: parseRequiredNonNegativeInteger(prune.candidatesIdentified, `${path2}.candidatesIdentified`, issues) ?? 0,
+      candidatesProtected: parseRequiredNonNegativeInteger(prune.candidatesProtected, `${path2}.candidatesProtected`, issues) ?? 0,
+      candidatesRetirable: parseRequiredNonNegativeInteger(prune.candidatesRetirable, `${path2}.candidatesRetirable`, issues) ?? 0,
+      durablesStaled: parseRequiredNonNegativeInteger(prune.durablesStaled, `${path2}.durablesStaled`, issues) ?? 0,
+      dryRun: parseRequiredBoolean(prune.dryRun, `${path2}.dryRun`, issues) ?? false
+    }
+  };
+}
+function parseDreamEfficiencySummary(value, path2, issues) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const efficiency = parseObject(value, path2, issues);
+  if (efficiency === void 0) {
+    return void 0;
+  }
+  pushUnexpectedFields(efficiency, DREAM_EFFICIENCY_KEYS, path2, issues);
+  return {
+    efficiency: {
+      evidenceItemsRead: parseRequiredNonNegativeInteger(efficiency.evidenceItemsRead, `${path2}.evidenceItemsRead`, issues) ?? 0,
+      synthesizedDurableMutations: parseRequiredNonNegativeInteger(efficiency.synthesizedDurableMutations, `${path2}.synthesizedDurableMutations`, issues) ?? 0,
+      costPerSynthesizedDurableUsd: parseOptionalNumberOrNull(efficiency.costPerSynthesizedDurableUsd, `${path2}.costPerSynthesizedDurableUsd`, issues),
+      profileInjectionTokenEstimate: parseRequiredNonNegativeInteger(efficiency.profileInjectionTokenEstimate, `${path2}.profileInjectionTokenEstimate`, issues) ?? 0,
+      recomputeRatio: parseRequiredNonNegativeNumber(efficiency.recomputeRatio, `${path2}.recomputeRatio`, issues) ?? 0
+    }
+  };
+}
+function parseDurablesSkipped(value, path2, issues) {
+  if (!Array.isArray(value)) {
+    pushIssue(issues, path2, "Expected an array.");
+    return void 0;
+  }
+  return value.flatMap((item, index) => {
+    const itemPath = `${path2}[${index}]`;
+    const record = parseObject(item, itemPath, issues);
+    if (record === void 0) {
+      return [];
+    }
+    pushUnexpectedFields(record, DURABLE_SKIP_KEYS, itemPath, issues);
+    const reason = parseRequiredTrimmedString(record.reason, `${itemPath}.reason`, issues);
+    const durableId = parseOptionalTrimmedString(record.durable_id, `${itemPath}.durable_id`, issues);
+    return [
+      {
+        ...durableId ? { durable_id: durableId } : {},
+        reason: reason ?? ""
+      }
+    ];
+  });
+}
+function parseEvidenceRefs(value, path2, issues) {
+  if (!Array.isArray(value)) {
+    pushIssue(issues, path2, "Expected an array.");
+    return void 0;
+  }
+  return value.flatMap((item, index) => {
+    const itemPath = `${path2}[${index}]`;
+    const record = parseObject(item, itemPath, issues);
+    if (record === void 0) {
+      return [];
+    }
+    pushUnexpectedFields(record, DREAM_EVIDENCE_REF_KEYS, itemPath, issues);
+    const kind = parseEvidenceKind(record.kind, `${itemPath}.kind`, issues);
+    const locator = parseRequiredTrimmedString(record.locator, `${itemPath}.locator`, issues);
+    const observedAt = parseOptionalTrimmedString(record.observedAt, `${itemPath}.observedAt`, issues);
+    return [
+      {
+        kind: kind ?? "episode",
+        locator: locator ?? "",
+        ...observedAt ? { observedAt } : {}
+      }
+    ];
+  });
+}
+function parseEvidenceKind(value, path2, issues) {
+  if (typeof value !== "string" || !DREAM_EVIDENCE_KINDS.includes(value)) {
+    pushIssue(issues, path2, `kind must be one of: ${DREAM_EVIDENCE_KINDS.join(", ")}.`);
+    return void 0;
+  }
+  return value;
+}
+function parseDreamStage(value, path2, issues) {
+  if (typeof value !== "string" || !DREAM_STAGES.includes(value)) {
+    pushIssue(issues, path2, `stage must be one of: ${DREAM_STAGES.join(", ")}.`);
+    return void 0;
+  }
+  return value;
+}
+function parseDreamStageSkipReason(value, path2, issues) {
+  if (typeof value !== "string" || !DREAM_STAGE_SKIP_REASONS.includes(value)) {
+    pushIssue(issues, path2, `reason must be one of: ${DREAM_STAGE_SKIP_REASONS.join(", ")}.`);
+    return void 0;
+  }
+  return value;
+}
+function parseOptionalObject(value, path2, issues) {
+  if (value === void 0) {
+    return void 0;
+  }
+  return parseObject(value, path2, issues);
+}
+function parseRequiredObject(value, path2, issues) {
+  if (value === void 0) {
+    pushIssue(issues, path2, "Expected an object.");
+    return void 0;
+  }
+  return parseObject(value, path2, issues);
+}
+function parseRequiredNonNegativeInteger(value, path2, issues) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    pushIssue(issues, path2, "Expected a non-negative integer.");
+    return void 0;
+  }
+  return value;
+}
+function parseRequiredNonNegativeNumber(value, path2, issues) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    pushIssue(issues, path2, "Expected a non-negative number.");
+    return void 0;
+  }
+  return value;
+}
+function parseOptionalBoolean2(value, path2, issues) {
+  if (value === void 0) {
+    return void 0;
+  }
+  return parseRequiredBoolean(value, path2, issues);
+}
+function parseRequiredBoolean(value, path2, issues) {
+  if (typeof value !== "boolean") {
+    pushIssue(issues, path2, "Expected a boolean.");
+    return void 0;
+  }
+  return value;
+}
+function parseRequiredStringArray2(value, path2, issues) {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    pushIssue(issues, path2, "Expected an array of strings.");
+    return void 0;
+  }
+  return value;
+}
+function parseOptionalStringOrNull(value, path2, issues) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  return parseOptionalTrimmedString(value, path2, issues) ?? null;
+}
+function parseOptionalNumberOrNull(value, path2, issues) {
+  if (value === null) {
+    return null;
+  }
+  return parseRequiredNonNegativeNumber(value, path2, issues) ?? null;
+}
+
+// src/adapters/api/validation/dreaming-efficiency-eval-request.ts
+var ROOT_REQUEST_KEYS2 = /* @__PURE__ */ new Set(["caseId", "description", "sandbox", "memoryPool", "dreamRunFixture", "options"]);
+var DREAM_RUN_FIXTURE_KEYS = /* @__PURE__ */ new Set(["tier", "summaryJson", "estimatedCostUsd", "completedAt"]);
+var OPTIONS_KEYS2 = /* @__PURE__ */ new Set(["includeTimings"]);
+var DreamingEfficiencyEvalRequestValidationError = class extends Error {
+  caseId;
+  issues;
+  /**
+   * Creates one validation error with structured request issues.
+   *
+   * @param issues - Validation failures found at the HTTP boundary.
+   * @param caseId - Optional case identifier extracted before validation failed.
+   */
+  constructor(issues, caseId) {
+    super("Invalid dreaming-efficiency eval request.");
+    this.name = "DreamingEfficiencyEvalRequestValidationError";
+    this.issues = issues;
+    this.caseId = caseId;
+  }
+};
+function parseDreamingEfficiencyEvalCaseRequest(payload) {
+  const issues = [];
+  const input = parseObject(payload, "$", issues);
+  if (input === void 0) {
+    throw new DreamingEfficiencyEvalRequestValidationError(issues);
+  }
+  pushUnexpectedFields(input, ROOT_REQUEST_KEYS2, "$", issues);
+  const caseId = parseRequiredTrimmedString(input.caseId, "caseId", issues);
+  const memoryPool = parseMemoryPool(input.memoryPool, issues);
+  if (memoryPool === void 0) {
+    pushUnexpectedFields({}, /* @__PURE__ */ new Set(["memoryPool"]), "$", issues);
+  }
+  const description = parseOptionalTrimmedString(input.description, "description", issues);
+  const sandbox = parseSandbox(input.sandbox, issues);
+  const dreamRunFixture = parseRequiredDreamRunFixture(input.dreamRunFixture, issues);
+  const options = parseOptions2(input.options, issues);
+  if (issues.length > 0) {
+    throw new DreamingEfficiencyEvalRequestValidationError(issues, caseId);
+  }
+  return {
+    caseId: caseId ?? "",
+    memoryPool: memoryPool ?? [],
+    ...description ? { description } : {},
+    ...sandbox ? { sandbox } : {},
+    dreamRunFixture,
+    ...options ? { options } : {}
+  };
+}
+function mapDreamingEfficiencyEvalCaseRequestDto(dto) {
+  return {
+    caseId: dto.caseId,
+    ...dto.description ? { description: dto.description } : {},
+    ...dto.sandbox ? { sandbox: mapSandboxRequestDto(dto.sandbox) } : {},
+    memoryPool: dto.memoryPool.map((entry) => mapFixtureEntryDto(entry)),
+    dreamRunFixture: mapDreamRunFixtureDto(dto.dreamRunFixture),
+    ...dto.options ? { options: mapCaseOptionsDto2(dto.options) } : {}
+  };
+}
+function parseRequiredDreamRunFixture(value, issues) {
+  if (value === void 0) {
+    pushIssue(issues, "dreamRunFixture", "Expected an object.");
+    return void 0;
+  }
+  const fixture = parseObject(value, "dreamRunFixture", issues);
+  if (fixture === void 0) {
+    return void 0;
+  }
+  pushUnexpectedFields(fixture, DREAM_RUN_FIXTURE_KEYS, "dreamRunFixture", issues);
+  const tier = parseDreamTier(fixture.tier, "dreamRunFixture.tier", issues);
+  const summaryJson = parseDreamCompletionSummary(fixture.summaryJson, "dreamRunFixture.summaryJson", issues);
+  if (summaryJson === void 0) {
+    return void 0;
+  }
+  return {
+    tier: tier ?? "standard",
+    summaryJson,
+    estimatedCostUsd: parseOptionalNonNegativeNumber(fixture.estimatedCostUsd, "dreamRunFixture.estimatedCostUsd", issues),
+    completedAt: parseOptionalTrimmedString(fixture.completedAt, "dreamRunFixture.completedAt", issues)
+  };
+}
+function parseDreamTier(value, path2, issues) {
+  if (value === void 0) {
+    pushIssue(issues, path2, "Expected a dreaming tier.");
+    return void 0;
+  }
+  if (typeof value !== "string" || !DREAM_TIERS.includes(value)) {
+    issues.push({ path: path2, message: `tier must be one of: ${DREAM_TIERS.join(", ")}.` });
+    return void 0;
+  }
+  return value;
+}
+function parseOptionalNonNegativeNumber(value, path2, issues) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    pushIssue(issues, path2, "Expected a non-negative number.");
+    return void 0;
+  }
+  return value;
+}
+function parseOptions2(value, issues) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const options = parseObject(value, "options", issues);
+  if (options === void 0) {
+    return void 0;
+  }
+  pushUnexpectedFields(options, OPTIONS_KEYS2, "options", issues);
+  return {
+    includeTimings: parseOptionalBoolean(options.includeTimings, "options.includeTimings", issues)
+  };
+}
+function mapDreamRunFixtureDto(dto) {
+  return {
+    tier: dto.tier,
+    summaryJson: dto.summaryJson,
+    ...dto.estimatedCostUsd !== void 0 ? { estimatedCostUsd: dto.estimatedCostUsd } : {},
+    ...dto.completedAt ? { completedAt: dto.completedAt } : {}
+  };
+}
+function mapCaseOptionsDto2(dto) {
+  return {
+    includeTimings: dto.includeTimings
+  };
+}
+
+// src/adapters/api/routes/internal-dreaming-efficiency-eval.ts
+var INTERNAL_DREAMING_EFFICIENCY_EVAL_ROUTE_PATH = "/internal/evals/dreaming-efficiency/run";
+var INTERNAL_DREAMING_EFFICIENCY_EVAL_ROUTE = {
+  method: "POST",
+  path: INTERNAL_DREAMING_EFFICIENCY_EVAL_ROUTE_PATH
+};
+function createInternalDreamingEfficiencyEvalRoute(runner = runDreamingEfficiencyEvalCase) {
+  return {
+    ...INTERNAL_DREAMING_EFFICIENCY_EVAL_ROUTE,
+    handler: async (request) => {
+      let validatedRequest;
+      try {
+        validatedRequest = await parseValidatedRequest2(request);
+        const result = await runner(validatedRequest);
+        return jsonResponse2(result, 200);
+      } catch (error) {
+        if (error instanceof DreamingEfficiencyEvalRequestValidationError) {
+          return jsonResponse2(
+            {
+              status: "error",
+              caseId: error.caseId,
+              error: {
+                code: "invalid_request",
+                message: error.message,
+                details: error.issues
+              }
+            },
+            400
+          );
+        }
+        return jsonResponse2(
+          {
+            status: "error",
+            caseId: validatedRequest?.caseId,
+            error: {
+              code: "internal_error",
+              message: "Internal dreaming-efficiency eval adapter error."
+            }
+          },
+          500
+        );
+      }
+    }
+  };
+}
+var parseJsonBody2 = async (request) => {
+  try {
+    return await request.json();
+  } catch {
+    throw new DreamingEfficiencyEvalRequestValidationError([
+      {
+        path: "$",
+        message: "Request body must be valid JSON."
+      }
+    ]);
+  }
+};
+var parseValidatedRequest2 = async (request) => {
+  const payload = await parseJsonBody2(request);
+  const requestDto = parseDreamingEfficiencyEvalCaseRequest(payload);
+  return mapDreamingEfficiencyEvalCaseRequestDto(requestDto);
+};
+var jsonResponse2 = (body, status) => new Response(JSON.stringify(body), {
+  status,
+  headers: {
+    "content-type": "application/json; charset=utf-8"
+  }
+});
+
+// src/app/evals/recall/collect-diagnostics.ts
+function createRecallEvalDiagnosticsCollector(request) {
+  const diagnosticsRequested = wantsRecallEvalDiagnostics(request);
+  const timingsRequested = request.options?.includeTimings === true;
+  const debugArtifactRequested = request.options?.includeDebugArtifact === true;
+  const observationEnabled = diagnosticsRequested || timingsRequested || debugArtifactRequested;
+  const execution = {
+    mode: "isolated-case",
+    provisioning: "exact-fixture-seed",
+    recallPath: request.recallPath ?? "core",
+    memoryPoolCount: request.memoryPool.length,
+    provisionedCount: 0,
+    requestedDiagnostics: request.options?.includeDiagnostics === true,
+    requestedCandidates: request.options?.includeCandidates === true
+  };
+  const stageTimings = {
+    sandboxSetupMs: 0,
+    fixtureProvisionMs: 0,
+    recallMs: 0,
+    queryEmbeddingMs: 0,
+    vectorSearchMs: 0,
+    lexicalSearchMs: 0,
     mergeCandidatesMs: 0,
     scoreCandidatesMs: 0,
     thresholdMs: 0,
@@ -1567,7 +2606,7 @@ function createRecallEvalDiagnosticsCollector(request) {
         expansionRequested: summary.neighborhood.expansionRequested,
         expansionAvailable: summary.neighborhood.expansionAvailable,
         familiesRequested: [...summary.neighborhood.familiesRequested],
-        includeRetired: summary.neighborhood.includeRetired,
+        includeHistorical: summary.neighborhood.includeHistorical,
         seedIds: [...summary.neighborhood.seedIds],
         expansionCandidates: summary.neighborhood.expansionCandidates,
         strongSeedIds: [...summary.neighborhood.strongSeedIds],
@@ -1633,7 +2672,7 @@ function createRecallEvalDiagnosticsCollector(request) {
         provisionedCount: result.provisionedCount,
         providedIdCount: result.providedIdCount,
         generatedIdCount: result.generatedIdCount,
-        retiredCount: result.retiredCount,
+        staleCount: result.staleCount,
         supersededCount: result.supersededCount,
         createdAtDefaultedCount: result.createdAtDefaultedCount,
         updatedAtDefaultedCount: result.updatedAtDefaultedCount,
@@ -1641,7 +2680,6 @@ function createRecallEvalDiagnosticsCollector(request) {
           id: entry.id,
           created_at: entry.created_at,
           updated_at: entry.updated_at,
-          retired: entry.retired,
           superseded_by: entry.superseded_by,
           claim_key: entry.claim_key,
           claim_key_status: entry.claim_key_status,
@@ -1734,13 +2772,13 @@ function createInstrumentedRecallPorts(ports, observer) {
       try {
         const embedding = await ports.embed(text);
         observer.recordQueryEmbedding({
-          durationMs: elapsedMs2(startedAt),
+          durationMs: elapsedMs3(startedAt),
           dimensions: embedding.length
         });
         return embedding;
       } catch (error) {
         observer.recordQueryEmbedding({
-          durationMs: elapsedMs2(startedAt),
+          durationMs: elapsedMs3(startedAt),
           dimensions: 0
         });
         throw error;
@@ -1751,14 +2789,14 @@ function createInstrumentedRecallPorts(ports, observer) {
       try {
         const results = await ports.vectorSearch(params);
         observer.recordVectorSearch({
-          durationMs: elapsedMs2(startedAt),
+          durationMs: elapsedMs3(startedAt),
           count: results.length,
           limit: params.limit
         });
         return results;
       } catch (error) {
         observer.recordVectorSearch({
-          durationMs: elapsedMs2(startedAt),
+          durationMs: elapsedMs3(startedAt),
           count: 0,
           limit: params.limit
         });
@@ -1770,14 +2808,14 @@ function createInstrumentedRecallPorts(ports, observer) {
       try {
         const results = await ports.ftsSearch(params);
         observer.recordLexicalSearch({
-          durationMs: elapsedMs2(startedAt),
+          durationMs: elapsedMs3(startedAt),
           count: results.length,
           limit: params.limit
         });
         return results;
       } catch (error) {
         observer.recordLexicalSearch({
-          durationMs: elapsedMs2(startedAt),
+          durationMs: elapsedMs3(startedAt),
           count: 0,
           limit: params.limit
         });
@@ -1802,13 +2840,13 @@ function createInstrumentedRecallPorts(ports, observer) {
       try {
         const entries = await ports.hydrateEntries(ids);
         observer.recordHydrateEntries({
-          durationMs: elapsedMs2(startedAt),
+          durationMs: elapsedMs3(startedAt),
           count: entries.length
         });
         return entries;
       } catch (error) {
         observer.recordHydrateEntries({
-          durationMs: elapsedMs2(startedAt),
+          durationMs: elapsedMs3(startedAt),
           count: 0
         });
         throw error;
@@ -1820,14 +2858,14 @@ function createInstrumentedRecallPorts(ports, observer) {
         await ports.recordRecallEvents(params);
       } finally {
         observer.recordRecallTelemetry({
-          durationMs: elapsedMs2(startedAt),
+          durationMs: elapsedMs3(startedAt),
           entryCount: params.entryIds.length
         });
       }
     }
   };
 }
-function elapsedMs2(startedAt) {
+function elapsedMs3(startedAt) {
   return Math.max(0, Date.now() - startedAt);
 }
 
@@ -1950,7 +2988,7 @@ function buildRecallEvalSuccessResponse(params) {
     metadata,
     diagnostics: params.diagnostics,
     timings: params.timings,
-    sandbox: buildSandboxResult2(params.sandbox),
+    sandbox: buildSandboxResult3(params.sandbox),
     ...debugArtifact ? { debugArtifact } : {}
   };
 }
@@ -1965,10 +3003,10 @@ function buildRecallEvalErrorResponse(params) {
     },
     diagnostics: params.diagnostics,
     timings: params.timings,
-    sandbox: params.sandbox ? buildSandboxResult2(params.sandbox) : void 0
+    sandbox: params.sandbox ? buildSandboxResult3(params.sandbox) : void 0
   };
 }
-function buildSandboxResult2(sandbox) {
+function buildSandboxResult3(sandbox) {
   return {
     root: sandbox.root,
     dbPath: sandbox.dbPath,
@@ -2038,118 +3076,89 @@ function buildClaimFamilyMetadata(family) {
     primaryEntryId: family.primary.entryId,
     entries: family.entries.map((entry) => ({
       id: entry.entryId,
-      memoryState: entry.memoryState,
-      claimStatus: entry.claimStatus
-    }))
-  };
-}
-
-// src/app/evals/recall/run-recall-eval-case.ts
-async function runRecallEvalCase(request, dependencies = {}) {
-  const startedAt = Date.now();
-  const provisionedAt = new Date(startedAt).toISOString();
-  const diagnostics = createRecallEvalDiagnosticsCollector(request);
-  const recallPath = request.recallPath ?? "core";
-  let sandbox;
-  let sharedEmbeddingPort;
-  let sharedEmbeddingError;
-  const getEmbeddingSupport = () => {
-    if (sharedEmbeddingPort) {
-      return {
-        available: true,
-        port: sharedEmbeddingPort
-      };
-    }
-    if (sharedEmbeddingError) {
-      return {
-        available: false,
-        error: sharedEmbeddingError
-      };
-    }
-    const config = readConfig();
-    try {
-      sharedEmbeddingPort = createEmbeddingClient(resolveEmbeddingApiKey(config), resolveEmbeddingModel(config));
-      return {
-        available: true,
-        port: sharedEmbeddingPort
-      };
-    } catch (error) {
-      sharedEmbeddingError = error instanceof Error ? error.message : String(error);
-      return {
-        available: false,
-        error: sharedEmbeddingError
-      };
-    }
-  };
-  const getEmbeddingPort = () => {
-    const support = getEmbeddingSupport();
-    if (!support.port) {
-      throw new Error(support.error ?? "Embeddings are unavailable.");
-    }
-    return support.port;
+      memoryState: entry.memoryState,
+      claimStatus: entry.claimStatus
+    }))
   };
+}
+
+// src/app/evals/recall/run-recall-eval-case.ts
+async function runRecallEvalCase(request, dependencies = {}) {
+  const startedAt = Date.now();
+  const provisionedAt = new Date(startedAt).toISOString();
+  const diagnostics = createRecallEvalDiagnosticsCollector(request);
+  const recallPath = request.recallPath ?? "core";
+  const ablation = resolveAblationConfig(request.sandbox);
+  const evalNow = parseEvalNow(ablation.now);
+  const embeddingResolver = createEvalEmbeddingResolver();
+  let sandbox;
   try {
     const sandboxStartedAt = Date.now();
     try {
       sandbox = await setupRecallEvalSandbox(request.sandbox);
-      diagnostics.recordSandboxSetup(elapsedMs3(sandboxStartedAt));
+      diagnostics.recordSandboxSetup(elapsedMs4(sandboxStartedAt));
     } catch (error) {
-      diagnostics.recordSandboxSetup(elapsedMs3(sandboxStartedAt));
+      diagnostics.recordSandboxSetup(elapsedMs4(sandboxStartedAt));
       return buildRecallEvalErrorResponse({
         request,
         code: "sandbox_setup_failed",
         message: "Failed to create isolated recall eval sandbox.",
-        details: toErrorDetails2(error),
+        details: toErrorDetails3(error),
         diagnostics: diagnostics.buildDiagnostics(),
-        timings: diagnostics.buildTimings(elapsedMs3(startedAt))
+        timings: diagnostics.buildTimings(elapsedMs4(startedAt))
       });
     }
-    if (request.memoryPool.length > 0 || (request.procedurePool?.length ?? 0) > 0) {
+    if (request.memoryPool.length > 0 || (request.procedurePool?.length ?? 0) > 0 || shouldProvisionProfileSnapshot(ablation)) {
       const provisionStartedAt = Date.now();
       try {
-        let entryProvisionResult;
-        if (request.memoryPool.length > 0) {
-          entryProvisionResult = await provisionRecallEvalFixtures({
-            caseId: request.caseId,
-            memoryPool: request.memoryPool,
-            store: sandbox.fixtureStore,
-            embedding: getEmbeddingPort(),
-            provisionedAt
-          });
-        }
-        if ((request.procedurePool?.length ?? 0) > 0) {
-          await provisionRecallEvalProcedureFixtures({
-            caseId: request.caseId,
-            procedurePool: request.procedurePool ?? [],
-            store: sandbox.fixtureStore,
-            provisionedAt
-          });
-        }
-        if (entryProvisionResult) {
-          diagnostics.recordProvision(entryProvisionResult, elapsedMs3(provisionStartedAt));
+        const provisionResult = await provisionEvalSandbox({
+          caseId: request.caseId,
+          sandbox,
+          memoryPool: request.memoryPool,
+          procedurePool: request.procedurePool,
+          profileSnapshot: shouldProvisionProfileSnapshot(ablation) ? ablation.profileSnapshot : void 0,
+          embedding: request.memoryPool.length > 0 ? embeddingResolver.requirePort() : void 0,
+          provisionedAt
+        });
+        if (provisionResult.entryProvisionResult) {
+          diagnostics.recordProvision(provisionResult.entryProvisionResult, elapsedMs4(provisionStartedAt));
         } else {
-          diagnostics.recordFixtureProvisionTiming(elapsedMs3(provisionStartedAt));
+          diagnostics.recordFixtureProvisionTiming(elapsedMs4(provisionStartedAt));
         }
       } catch (error) {
-        diagnostics.recordFixtureProvisionTiming(elapsedMs3(provisionStartedAt));
+        diagnostics.recordFixtureProvisionTiming(elapsedMs4(provisionStartedAt));
         return buildRecallEvalErrorResponse({
           request,
           code: "fixture_provision_failed",
           message: "Failed to provision recall eval fixtures into isolated storage.",
-          details: toErrorDetails2(error),
+          details: toErrorDetails3(error),
           diagnostics: diagnostics.buildDiagnostics(),
-          timings: diagnostics.buildTimings(elapsedMs3(startedAt)),
+          timings: diagnostics.buildTimings(elapsedMs4(startedAt)),
           sandbox
         });
       }
     }
     const recallStartedAt = Date.now();
     try {
-      const embeddingSupport = getEmbeddingSupport();
-      const recallEmbeddingPort = request.options?.faultInjection?.queryEmbeddingFailure === true ? createUnavailableEmbeddingPort2("Injected recall eval query embedding failure.") : embeddingSupport.port ?? createUnavailableEmbeddingPort2(embeddingSupport.error ?? "Embeddings are unavailable.");
-      const sandboxPorts = sandbox.createRecallPorts(recallEmbeddingPort);
+      if (isMemoryOffArm(ablation)) {
+        diagnostics.recordRecall(elapsedMs4(recallStartedAt));
+        return buildRecallEvalSuccessResponse({
+          request,
+          results: [],
+          diagnostics: diagnostics.buildDiagnostics(),
+          timings: diagnostics.buildTimings(elapsedMs4(startedAt)),
+          sandbox
+        });
+      }
+      const activeSandbox = sandbox;
+      if (!activeSandbox) {
+        throw new Error("Recall eval sandbox was not initialized.");
+      }
+      const embeddingSupport = embeddingResolver.getSupport();
+      const recallEmbeddingPort = request.options?.faultInjection?.queryEmbeddingFailure === true ? createUnavailableEmbeddingPort("Injected recall eval query embedding failure.") : embeddingSupport.port ?? createUnavailableEmbeddingPort(embeddingSupport.error ?? "Embeddings are unavailable.");
+      const sandboxPorts = activeSandbox.createRecallPorts(recallEmbeddingPort);
       const portsWithCrossEncoder = attachCrossEncoderPort(sandboxPorts, dependencies.crossEncoder);
-      const telemetryGatedPorts = applyTelemetryWriteGate(portsWithCrossEncoder, sandbox);
+      const telemetryGatedPorts = applyTelemetryWriteGate(portsWithCrossEncoder, activeSandbox);
       const basePorts = applyRecallEvalFaultInjection(telemetryGatedPorts, request);
       const recallPorts = diagnostics.isObservationEnabled() ? createInstrumentedRecallPorts(basePorts, diagnostics) : basePorts;
       const slotPolicyConfig = request.unified?.memoryPolicy?.slotPolicies;
@@ -2175,12 +3184,13 @@ async function runRecallEvalCase(request, dependencies = {}) {
           ...request.unified?.sessionKey ? { sessionKey: request.unified.sessionKey } : {}
         },
         {
-          database: sandbox.episodeDatabase,
-          procedures: sandbox.procedureDatabase,
+          database: activeSandbox.episodeDatabase,
+          procedures: activeSandbox.procedureDatabase,
           recall: recallPorts,
           embeddingAvailable: embeddingSupport.available,
           ...embeddingSupport.error ? { embeddingError: embeddingSupport.error } : {},
           ...slotPolicyConfig ? { claimSlotPolicyConfig: slotPolicyConfig } : {},
+          ...evalNow ? { now: evalNow } : {},
           ...embeddingSupport.available ? {
             embedQuery: async (text) => {
               const vectors = await recallEmbeddingPort.embed([text]);
@@ -2189,25 +3199,28 @@ async function runRecallEvalCase(request, dependencies = {}) {
           } : {},
           ...Object.keys(unifiedRecallOptions).length > 0 ? { recallOptions: unifiedRecallOptions } : {}
         }
-      ) : await recall(request.recallRequest, recallPorts, Object.keys(coreRecallOptions).length > 0 ? coreRecallOptions : void 0);
-      diagnostics.recordRecall(elapsedMs3(recallStartedAt));
+      ) : await recall(request.recallRequest, recallPorts, {
+        ...Object.keys(coreRecallOptions).length > 0 ? coreRecallOptions : {},
+        ...evalNow ? { now: evalNow } : {}
+      });
+      diagnostics.recordRecall(elapsedMs4(recallStartedAt));
       return buildRecallEvalSuccessResponse({
         request,
         results,
         diagnostics: diagnostics.buildDiagnostics(),
-        timings: diagnostics.buildTimings(elapsedMs3(startedAt)),
-        sandbox,
+        timings: diagnostics.buildTimings(elapsedMs4(startedAt)),
+        sandbox: activeSandbox,
         observedArtifactFacts: request.options?.includeDebugArtifact === true ? diagnostics.buildObservedArtifactFacts() : void 0
       });
     } catch (error) {
-      diagnostics.recordRecall(elapsedMs3(recallStartedAt));
+      diagnostics.recordRecall(elapsedMs4(recallStartedAt));
       return buildRecallEvalErrorResponse({
         request,
         code: "recall_execution_failed",
         message: "Failed to execute real recall against isolated eval state.",
-        details: toErrorDetails2(error),
+        details: toErrorDetails3(error),
         diagnostics: diagnostics.buildDiagnostics(),
-        timings: diagnostics.buildTimings(elapsedMs3(startedAt)),
+        timings: diagnostics.buildTimings(elapsedMs4(startedAt)),
         sandbox
       });
     }
@@ -2216,16 +3229,16 @@ async function runRecallEvalCase(request, dependencies = {}) {
       request,
       code: "internal_error",
       message: "Recall eval execution failed unexpectedly.",
-      details: toErrorDetails2(error),
+      details: toErrorDetails3(error),
       diagnostics: diagnostics.buildDiagnostics(),
-      timings: diagnostics.buildTimings(elapsedMs3(startedAt)),
+      timings: diagnostics.buildTimings(elapsedMs4(startedAt)),
       sandbox
     });
   } finally {
     await sandbox?.cleanup().catch(() => void 0);
   }
 }
-function toErrorDetails2(error) {
+function toErrorDetails3(error) {
   if (error instanceof Error) {
     return {
       cause: error.message
@@ -2235,13 +3248,6 @@ function toErrorDetails2(error) {
     cause: String(error)
   };
 }
-function createUnavailableEmbeddingPort2(message) {
-  return {
-    async embed() {
-      throw new Error(message);
-    }
-  };
-}
 function applyRecallEvalFaultInjection(ports, request) {
   if (request.options?.faultInjection?.vectorSearchFailure !== true) {
     return ports;
@@ -2277,12 +3283,12 @@ function applyRecallEvalFaultInjection(ports, request) {
     }
   };
 }
-function elapsedMs3(startedAt) {
+function elapsedMs4(startedAt) {
   return Math.max(0, Date.now() - startedAt);
 }
 
 // src/adapters/api/validation/recall-eval-request.ts
-var ROOT_REQUEST_KEYS2 = /* @__PURE__ */ new Set(["caseId", "description", "recallPath", "sandbox", "memoryPool", "recallRequest", "unified", "options"]);
+var ROOT_REQUEST_KEYS3 = /* @__PURE__ */ new Set(["caseId", "description", "recallPath", "sandbox", "memoryPool", "recallRequest", "unified", "options"]);
 var RECALL_REQUEST_KEYS = /* @__PURE__ */ new Set([
   "text",
   "limit",
@@ -2313,12 +3319,12 @@ var RANKING_POLICY_KEYS = /* @__PURE__ */ new Set([
 var UNIFIED_REQUEST_KEYS = /* @__PURE__ */ new Set(["mode", "sessionKey", "memoryPolicy"]);
 var UNIFIED_MEMORY_POLICY_KEYS = /* @__PURE__ */ new Set(["slotPolicies"]);
 var SLOT_POLICY_KEYS = /* @__PURE__ */ new Set(["attributeHeads"]);
-var OPTIONS_KEYS2 = /* @__PURE__ */ new Set(["includeDiagnostics", "includeCandidates", "includeTimings", "includeDebugArtifact", "topKCandidates", "faultInjection"]);
+var OPTIONS_KEYS3 = /* @__PURE__ */ new Set(["includeDiagnostics", "includeCandidates", "includeTimings", "includeDebugArtifact", "topKCandidates", "faultInjection"]);
 var FAULT_INJECTION_KEYS = /* @__PURE__ */ new Set(["queryEmbeddingFailure", "vectorSearchFailure"]);
 var RECALL_PATHS = ["core", "unified"];
 var RECALL_RANKING_PROFILES = ["historical_state"];
 var RANKING_POLICY_TOGGLES = ["enabled", "disabled"];
-var UNIFIED_RECALL_MODES = ["auto", "entries", "episodes"];
+var UNIFIED_RECALL_MODES = ["auto", "durables", "episodes"];
 var CLAIM_SLOT_POLICIES = ["exclusive", "multivalued"];
 var RecallEvalRequestValidationError = class extends Error {
   /** Parseable case identifier echoed for invalid request correlation when available. */
@@ -2352,7 +3358,7 @@ function parseRecallEvalCaseRequest(input) {
     );
   }
   const issues = [];
-  pushUnexpectedFields(input, ROOT_REQUEST_KEYS2, "", issues);
+  pushUnexpectedFields(input, ROOT_REQUEST_KEYS3, "", issues);
   const parsedCaseId = parseRequiredTrimmedString(input.caseId, "caseId", issues);
   const description = parseOptionalTrimmedString(input.description, "description", issues);
   const recallPath = parseOptionalRecallPath(input.recallPath, "recallPath", issues);
@@ -2360,7 +3366,7 @@ function parseRecallEvalCaseRequest(input) {
   const memoryPool = parseMemoryPool(input.memoryPool, issues);
   const recallRequest = parseRecallRequest(input.recallRequest, issues);
   const unified = parseUnifiedRequest(input.unified, issues);
-  const options = parseOptions2(input.options, issues);
+  const options = parseOptions3(input.options, issues);
   validatePathSpecificRequest(recallPath, recallRequest, unified, issues);
   if (issues.length > 0 || parsedCaseId === void 0 || memoryPool === void 0 || recallRequest === void 0) {
     throw new RecallEvalRequestValidationError(issues, caseId);
@@ -2385,7 +3391,7 @@ function mapRecallEvalCaseRequestDto(dto) {
     memoryPool: dto.memoryPool.map(mapFixtureEntryDto2),
     recallRequest: mapRecallRequestDto(dto.recallRequest),
     unified: mapUnifiedRequestDto(dto.unified),
-    options: mapCaseOptionsDto2(dto.options)
+    options: mapCaseOptionsDto3(dto.options)
   };
 }
 function parseRecallRequest(value, issues) {
@@ -2407,7 +3413,7 @@ function parseRecallRequest(value, issues) {
     budget: parseOptionalIntegerInRange(recallRequest.budget, "recallRequest.budget", issues, {
       min: 0
     }),
-    types: parseOptionalEntryTypeArray(recallRequest.types, "recallRequest.types", issues),
+    types: parseOptionalDurableKindArray(recallRequest.types, "recallRequest.types", issues),
     tags: parseOptionalStringArray(recallRequest.tags, "recallRequest.tags", issues),
     since: parseOptionalTrimmedString(recallRequest.since, "recallRequest.since", issues),
     until: parseOptionalTrimmedString(recallRequest.until, "recallRequest.until", issues),
@@ -2513,7 +3519,7 @@ function parseUnifiedRequest(value, issues) {
     memoryPolicy: parseUnifiedMemoryPolicy(unified.memoryPolicy, issues)
   };
 }
-function parseOptions2(value, issues) {
+function parseOptions3(value, issues) {
   if (value === void 0) {
     return void 0;
   }
@@ -2521,7 +3527,7 @@ function parseOptions2(value, issues) {
   if (options === void 0) {
     return void 0;
   }
-  pushUnexpectedFields(options, OPTIONS_KEYS2, "options", issues);
+  pushUnexpectedFields(options, OPTIONS_KEYS3, "options", issues);
   return {
     includeDiagnostics: parseOptionalBoolean(options.includeDiagnostics, "options.includeDiagnostics", issues),
     includeCandidates: parseOptionalBoolean(options.includeCandidates, "options.includeCandidates", issues),
@@ -2561,9 +3567,9 @@ function parseUnifiedMemoryPolicy(value, issues) {
     slotPolicies: parseClaimSlotPolicyConfig(memoryPolicy.slotPolicies, "unified.memoryPolicy.slotPolicies", issues)
   };
 }
-function parseEntryType2(value, path2, issues) {
-  if (typeof value !== "string" || !ENTRY_TYPES.includes(value)) {
-    pushIssue(issues, path2, `Expected one of: ${ENTRY_TYPES.join(", ")}.`);
+function parseDurableKind2(value, path2, issues) {
+  if (typeof value !== "string" || !DURABLE_KINDS.includes(value)) {
+    pushIssue(issues, path2, `Expected one of: ${DURABLE_KINDS.join(", ")}.`);
     return void 0;
   }
   return value;
@@ -2598,7 +3604,7 @@ function parseOptionalRankingProfile(value, path2, issues) {
   }
   return value;
 }
-function parseOptionalEntryTypeArray(value, path2, issues) {
+function parseOptionalDurableKindArray(value, path2, issues) {
   if (value === void 0) {
     return void 0;
   }
@@ -2608,7 +3614,7 @@ function parseOptionalEntryTypeArray(value, path2, issues) {
   }
   const parsed = [];
   for (const [index, item] of value.entries()) {
-    const entryType = parseEntryType2(item, `${path2}[${index}]`, issues);
+    const entryType = parseDurableKind2(item, `${path2}[${index}]`, issues);
     if (entryType !== void 0) {
       parsed.push(entryType);
     }
@@ -2687,7 +3693,10 @@ function mapSandboxRequestDto2(dto) {
   return {
     root: dto.root,
     preserve: dto.preserve,
-    corpusSeed: dto.corpusSeed
+    corpusSeed: dto.corpusSeed,
+    ablationArm: dto.ablationArm,
+    now: dto.now,
+    profileSnapshot: dto.profileSnapshot
   };
 }
 function mapFixtureEntryDto2(dto) {
@@ -2722,7 +3731,7 @@ function mapUnifiedRequestDto(dto) {
     } : void 0
   };
 }
-function mapCaseOptionsDto2(dto) {
+function mapCaseOptionsDto3(dto) {
   if (dto === void 0) {
     return void 0;
   }
@@ -2751,12 +3760,12 @@ function createInternalRecallEvalRoute(optionsOrRunner = {}) {
     handler: async (request) => {
       let validatedRequest;
       try {
-        validatedRequest = await parseValidatedRequest2(request);
+        validatedRequest = await parseValidatedRequest3(request);
         const result = await runner(validatedRequest);
-        return jsonResponse2(result, 200);
+        return jsonResponse3(result, 200);
       } catch (error) {
         if (error instanceof RecallEvalRequestValidationError) {
-          return jsonResponse2(
+          return jsonResponse3(
             {
               status: "error",
               caseId: error.caseId,
@@ -2769,7 +3778,7 @@ function createInternalRecallEvalRoute(optionsOrRunner = {}) {
             400
           );
         }
-        return jsonResponse2(
+        return jsonResponse3(
           {
             status: "error",
             caseId: validatedRequest?.caseId,
@@ -2784,7 +3793,7 @@ function createInternalRecallEvalRoute(optionsOrRunner = {}) {
     }
   };
 }
-var parseJsonBody2 = async (request) => {
+var parseJsonBody3 = async (request) => {
   try {
     return await request.json();
   } catch {
@@ -2796,12 +3805,386 @@ var parseJsonBody2 = async (request) => {
     ]);
   }
 };
-var parseValidatedRequest2 = async (request) => {
-  const payload = await parseJsonBody2(request);
+var parseValidatedRequest3 = async (request) => {
+  const payload = await parseJsonBody3(request);
   const requestDto = parseRecallEvalCaseRequest(payload);
   return mapRecallEvalCaseRequestDto(requestDto);
 };
-var jsonResponse2 = (body, status) => new Response(JSON.stringify(body), {
+var jsonResponse3 = (body, status) => new Response(JSON.stringify(body), {
+  status,
+  headers: {
+    "content-type": "application/json; charset=utf-8"
+  }
+});
+
+// src/app/evals/session-start/normalize-response.ts
+function buildSessionStartEvalSuccessResponse(params) {
+  return {
+    status: "ok",
+    caseId: params.request.caseId,
+    output: buildOutput2(params.patch),
+    ...params.request.options?.includeDiagnostics === true ? { diagnostics: params.patch.diagnostics } : {},
+    ...params.timings ? { timings: params.timings } : {},
+    sandbox: buildSandboxResult4(params.sandbox)
+  };
+}
+function buildSessionStartEvalErrorResponse(params) {
+  return {
+    status: "error",
+    caseId: params.request.caseId,
+    error: {
+      code: params.code,
+      message: params.message,
+      ...params.details !== void 0 ? { details: params.details } : {}
+    },
+    ...params.timings ? { timings: params.timings } : {},
+    ...params.sandbox ? { sandbox: buildSandboxResult4(params.sandbox) } : {}
+  };
+}
+function buildOutput2(patch) {
+  const sourceKindsByEntryId = {};
+  for (const item of patch.durableMemory) {
+    sourceKindsByEntryId[item.entry.id] = item.sourceKind;
+  }
+  return {
+    selectedEntryIds: patch.durableMemory.map((item) => item.entry.id),
+    sourceKindsByEntryId
+  };
+}
+function buildSandboxResult4(sandbox) {
+  return {
+    root: sandbox.root,
+    dbPath: sandbox.dbPath,
+    preserved: sandbox.preserved,
+    ...sandbox.snapshot ? { snapshot: sandbox.snapshot } : {}
+  };
+}
+
+// src/app/evals/session-start/run-session-start-eval-case.ts
+async function runSessionStartEvalCase(request) {
+  const startedAt = Date.now();
+  const provisionedAt = new Date(startedAt).toISOString();
+  const ablation = resolveAblationConfig(request.sandbox);
+  const evalNow = parseEvalNow(ablation.now);
+  const embeddingResolver = createEvalEmbeddingResolver();
+  let sandbox;
+  let timings;
+  try {
+    const sandboxStartedAt = Date.now();
+    try {
+      sandbox = await setupRecallEvalSandbox(request.sandbox);
+      timings = { sandboxSetupMs: elapsedMs5(sandboxStartedAt) };
+    } catch (error) {
+      return buildSessionStartEvalErrorResponse({
+        request,
+        code: "sandbox_setup_failed",
+        message: "Failed to create isolated session-start eval sandbox.",
+        details: toErrorDetails4(error),
+        timings: request.options?.includeTimings === true ? { totalMs: elapsedMs5(startedAt), sandboxSetupMs: elapsedMs5(sandboxStartedAt) } : void 0
+      });
+    }
+    if (request.memoryPool.length > 0 || shouldProvisionProfileSnapshot(ablation)) {
+      const provisionStartedAt = Date.now();
+      try {
+        await provisionEvalSandbox({
+          caseId: request.caseId,
+          sandbox,
+          memoryPool: request.memoryPool,
+          profileSnapshot: shouldProvisionProfileSnapshot(ablation) ? ablation.profileSnapshot : void 0,
+          embedding: request.memoryPool.length > 0 ? embeddingResolver.portOrUnavailable() : void 0,
+          provisionedAt
+        });
+        timings = { ...timings, fixtureProvisionMs: elapsedMs5(provisionStartedAt) };
+      } catch (error) {
+        return buildSessionStartEvalErrorResponse({
+          request,
+          code: "fixture_provision_failed",
+          message: "Failed to provision session-start eval fixtures into isolated storage.",
+          details: toErrorDetails4(error),
+          timings: request.options?.includeTimings === true ? { ...timings, totalMs: elapsedMs5(startedAt), fixtureProvisionMs: elapsedMs5(provisionStartedAt) } : void 0,
+          sandbox
+        });
+      }
+    }
+    const sessionStartStartedAt = Date.now();
+    try {
+      if (isMemoryOffArm(ablation)) {
+        timings = {
+          ...timings,
+          sessionStartMs: elapsedMs5(sessionStartStartedAt),
+          totalMs: elapsedMs5(startedAt)
+        };
+        return buildSessionStartEvalSuccessResponse({
+          request,
+          patch: {
+            durableMemory: [],
+            diagnostics: {
+              coreCandidateCount: 0,
+              profileCandidateCount: 0,
+              proactiveDirectiveCandidateCount: 0,
+              artifactRecallCandidateCount: 0,
+              artifactRecallUsed: false,
+              notices: ["memory-off ablation arm stubbed session-start injection."]
+            }
+          },
+          timings: request.options?.includeTimings === true ? timings : void 0,
+          sandbox
+        });
+      }
+      const activeSandbox = sandbox;
+      if (!activeSandbox) {
+        throw new Error("Session-start eval sandbox was not initialized.");
+      }
+      const embeddingSupport = embeddingResolver.getSupport();
+      const recallPorts = activeSandbox.createRecallPorts(
+        embeddingSupport.port ?? createUnavailableEmbeddingPort(embeddingSupport.error ?? "Embeddings are unavailable.")
+      );
+      const patch = await runSessionStart(request.sessionStartInput, {
+        repository: activeSandbox.sessionStartRepository,
+        recall: recallPorts,
+        ...evalNow ? { now: evalNow } : {},
+        listActiveAbstainDirectives: () => activeSandbox.listActiveAbstainDirectives(evalNow),
+        listActiveProactiveDirectives: () => activeSandbox.listActiveSessionStartProactiveDirectives(evalNow)
+      });
+      timings = {
+        ...timings,
+        sessionStartMs: elapsedMs5(sessionStartStartedAt),
+        totalMs: elapsedMs5(startedAt)
+      };
+      return buildSessionStartEvalSuccessResponse({
+        request,
+        patch,
+        timings: request.options?.includeTimings === true ? timings : void 0,
+        sandbox: activeSandbox
+      });
+    } catch (error) {
+      return buildSessionStartEvalErrorResponse({
+        request,
+        code: "session_start_execution_failed",
+        message: "Failed to execute real session-start selection against isolated eval state.",
+        details: toErrorDetails4(error),
+        timings: request.options?.includeTimings === true ? { ...timings, totalMs: elapsedMs5(startedAt), sessionStartMs: elapsedMs5(sessionStartStartedAt) } : void 0,
+        sandbox
+      });
+    }
+  } catch (error) {
+    return buildSessionStartEvalErrorResponse({
+      request,
+      code: "internal_error",
+      message: "Session-start eval execution failed unexpectedly.",
+      details: toErrorDetails4(error),
+      timings: request.options?.includeTimings === true ? { ...timings, totalMs: elapsedMs5(startedAt) } : void 0,
+      sandbox
+    });
+  } finally {
+    await sandbox?.cleanup().catch(() => void 0);
+  }
+}
+function toErrorDetails4(error) {
+  if (error instanceof Error) {
+    return { cause: error.message };
+  }
+  return { cause: String(error) };
+}
+function elapsedMs5(startedAt) {
+  return Date.now() - startedAt;
+}
+
+// src/adapters/api/validation/session-start-eval-request.ts
+var ROOT_REQUEST_KEYS4 = /* @__PURE__ */ new Set(["caseId", "description", "sandbox", "memoryPool", "sessionStartInput", "options"]);
+var SESSION_START_INPUT_KEYS = /* @__PURE__ */ new Set(["sessionKey", "policy"]);
+var SESSION_START_POLICY_KEYS = /* @__PURE__ */ new Set([
+  "maxCoreEntries",
+  "enableArtifactRecall",
+  "maxArtifactRecallEntries",
+  "maxDurableEntries",
+  "maxArtifactChars",
+  "recallThreshold",
+  "maxProfileSnapshotAgeHours"
+]);
+var OPTIONS_KEYS4 = /* @__PURE__ */ new Set(["includeDiagnostics", "includeTimings"]);
+var SessionStartEvalRequestValidationError = class extends Error {
+  caseId;
+  issues;
+  /** Creates a validation error with optional safely parsed case id. */
+  constructor(issues, caseId) {
+    super("Invalid session-start eval request.");
+    this.name = "SessionStartEvalRequestValidationError";
+    this.issues = issues;
+    this.caseId = caseId;
+  }
+};
+function parseSessionStartEvalCaseRequest(payload) {
+  const issues = [];
+  const input = parseObject(payload, "$", issues);
+  if (input === void 0) {
+    throw new SessionStartEvalRequestValidationError(issues);
+  }
+  pushUnexpectedFields(input, ROOT_REQUEST_KEYS4, "$", issues);
+  const caseId = parseRequiredTrimmedString(input.caseId, "caseId", issues);
+  const memoryPool = parseMemoryPool(input.memoryPool, issues);
+  const sessionStartInput = parseSessionStartInput(input.sessionStartInput, issues);
+  if (caseId === void 0 || memoryPool === void 0 || sessionStartInput === void 0) {
+    throw new SessionStartEvalRequestValidationError(issues, extractParseableCaseId(input));
+  }
+  const dto = {
+    caseId,
+    memoryPool,
+    sessionStartInput,
+    description: parseOptionalTrimmedString(input.description, "description", issues),
+    sandbox: parseSandbox(input.sandbox, issues),
+    options: parseOptions4(input.options, issues)
+  };
+  if (issues.length > 0) {
+    throw new SessionStartEvalRequestValidationError(issues, caseId);
+  }
+  return dto;
+}
+function mapSessionStartEvalCaseRequestDto(dto) {
+  return {
+    caseId: dto.caseId,
+    ...dto.description ? { description: dto.description } : {},
+    sandbox: mapSandboxRequestDto(dto.sandbox),
+    memoryPool: dto.memoryPool.map((entry) => mapFixtureEntryDto(entry)),
+    sessionStartInput: mapSessionStartInputDto(dto.sessionStartInput),
+    ...dto.options ? { options: mapCaseOptionsDto4(dto.options) } : {}
+  };
+}
+function parseSessionStartInput(value, issues) {
+  const sessionStartInput = parseObject(value, "sessionStartInput", issues);
+  if (sessionStartInput === void 0) {
+    return void 0;
+  }
+  pushUnexpectedFields(sessionStartInput, SESSION_START_INPUT_KEYS, "sessionStartInput", issues);
+  return {
+    sessionKey: parseOptionalTrimmedString(sessionStartInput.sessionKey, "sessionStartInput.sessionKey", issues),
+    policy: parseSessionStartPolicy(sessionStartInput.policy, issues)
+  };
+}
+function parseSessionStartPolicy(value, issues) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const policy = parseObject(value, "sessionStartInput.policy", issues);
+  if (policy === void 0) {
+    return void 0;
+  }
+  pushUnexpectedFields(policy, SESSION_START_POLICY_KEYS, "sessionStartInput.policy", issues);
+  return {
+    maxCoreEntries: parseOptionalIntegerInRange(policy.maxCoreEntries, "sessionStartInput.policy.maxCoreEntries", issues, { min: 0 }),
+    enableArtifactRecall: parseOptionalBoolean(policy.enableArtifactRecall, "sessionStartInput.policy.enableArtifactRecall", issues),
+    maxArtifactRecallEntries: parseOptionalIntegerInRange(policy.maxArtifactRecallEntries, "sessionStartInput.policy.maxArtifactRecallEntries", issues, {
+      min: 0
+    }),
+    maxDurableEntries: parseOptionalIntegerInRange(policy.maxDurableEntries, "sessionStartInput.policy.maxDurableEntries", issues, { min: 0 }),
+    maxArtifactChars: parseOptionalIntegerInRange(policy.maxArtifactChars, "sessionStartInput.policy.maxArtifactChars", issues, { min: 0 }),
+    recallThreshold: parseOptionalThreshold(policy.recallThreshold, "sessionStartInput.policy.recallThreshold", issues),
+    maxProfileSnapshotAgeHours: parseOptionalIntegerInRange(policy.maxProfileSnapshotAgeHours, "sessionStartInput.policy.maxProfileSnapshotAgeHours", issues, {
+      min: 0
+    })
+  };
+}
+function parseOptions4(value, issues) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const options = parseObject(value, "options", issues);
+  if (options === void 0) {
+    return void 0;
+  }
+  pushUnexpectedFields(options, OPTIONS_KEYS4, "options", issues);
+  return {
+    includeDiagnostics: parseOptionalBoolean(options.includeDiagnostics, "options.includeDiagnostics", issues),
+    includeTimings: parseOptionalBoolean(options.includeTimings, "options.includeTimings", issues)
+  };
+}
+function mapSessionStartInputDto(dto) {
+  return {
+    ...dto.sessionKey ? { sessionKey: dto.sessionKey } : {},
+    ...dto.policy ? { policy: mapSessionStartPolicyDto(dto.policy) } : {}
+  };
+}
+function mapSessionStartPolicyDto(dto) {
+  return {
+    maxCoreEntries: dto.maxCoreEntries,
+    enableArtifactRecall: dto.enableArtifactRecall,
+    maxArtifactRecallEntries: dto.maxArtifactRecallEntries,
+    maxDurableEntries: dto.maxDurableEntries,
+    maxArtifactChars: dto.maxArtifactChars,
+    recallThreshold: dto.recallThreshold,
+    maxProfileSnapshotAgeHours: dto.maxProfileSnapshotAgeHours
+  };
+}
+function mapCaseOptionsDto4(dto) {
+  return {
+    includeDiagnostics: dto.includeDiagnostics,
+    includeTimings: dto.includeTimings
+  };
+}
+
+// src/adapters/api/routes/internal-session-start-eval.ts
+var INTERNAL_SESSION_START_EVAL_ROUTE_PATH = "/internal/evals/session-start/run";
+var INTERNAL_SESSION_START_EVAL_ROUTE = {
+  method: "POST",
+  path: INTERNAL_SESSION_START_EVAL_ROUTE_PATH
+};
+function createInternalSessionStartEvalRoute(runner = runSessionStartEvalCase) {
+  return {
+    ...INTERNAL_SESSION_START_EVAL_ROUTE,
+    handler: async (request) => {
+      let validatedRequest;
+      try {
+        validatedRequest = await parseValidatedRequest4(request);
+        const result = await runner(validatedRequest);
+        return jsonResponse4(result, 200);
+      } catch (error) {
+        if (error instanceof SessionStartEvalRequestValidationError) {
+          return jsonResponse4(
+            {
+              status: "error",
+              caseId: error.caseId,
+              error: {
+                code: "invalid_request",
+                message: error.message,
+                details: error.issues
+              }
+            },
+            400
+          );
+        }
+        return jsonResponse4(
+          {
+            status: "error",
+            caseId: validatedRequest?.caseId,
+            error: {
+              code: "internal_error",
+              message: "Internal session-start eval adapter error."
+            }
+          },
+          500
+        );
+      }
+    }
+  };
+}
+var parseJsonBody4 = async (request) => {
+  try {
+    return await request.json();
+  } catch {
+    throw new SessionStartEvalRequestValidationError([
+      {
+        path: "$",
+        message: "Request body must be valid JSON."
+      }
+    ]);
+  }
+};
+var parseValidatedRequest4 = async (request) => {
+  const payload = await parseJsonBody4(request);
+  const requestDto = parseSessionStartEvalCaseRequest(payload);
+  return mapSessionStartEvalCaseRequestDto(requestDto);
+};
+var jsonResponse4 = (body, status) => new Response(JSON.stringify(body), {
   status,
   headers: {
     "content-type": "application/json; charset=utf-8"
@@ -2810,7 +4193,12 @@ var jsonResponse2 = (body, status) => new Response(JSON.stringify(body), {
 
 // src/adapters/api/internal-eval-routes.ts
 function createInternalEvalRoutes(options = {}) {
-  return [createInternalRecallEvalRoute({ crossEncoder: options.crossEncoder }), createInternalBeforeTurnEvalRoute({ crossEncoder: options.crossEncoder })];
+  return [
+    createInternalRecallEvalRoute({ crossEncoder: options.crossEncoder }),
+    createInternalBeforeTurnEvalRoute({ crossEncoder: options.crossEncoder }),
+    createInternalSessionStartEvalRoute(),
+    createInternalDreamingEfficiencyEvalRoute()
+  ];
 }
 
 // src/adapters/api/internal-eval-server.ts