agenr 2.0.1 → 3.0.0

package/dist/internal-recall-eval-server.js

@@ -1,1817 +1,7 @@
 #!/usr/bin/env node
-import {
-  composeProcedureRecallText,
-  computeProcedureRevisionHash,
-  computeProcedureSourceHash
-} from "./chunk-ZYADFKX3.js";
-import {
-  CLAIM_KEY_SOURCES,
-  CLAIM_KEY_STATUSES,
-  CLAIM_SUPPORT_MODES,
-  ENTRY_TYPES,
-  EXPIRY_LEVELS,
-  composeEmbeddingText,
-  createDatabase,
-  createEmbeddingClient,
-  createRecallAdapter,
-  isRecord,
-  normalizeProcedureDefinition,
-  parseOptionalBoolean,
-  parseOptionalIntegerInRange,
-  parseOptionalTimestampString,
-  parseOptionalTrimmedString,
-  parseRequiredTrimmedString,
-  projectClaimCentricRecallEntry,
-  pushIssue,
-  pushUnexpectedFields,
-  readConfig,
-  resolveEmbeddingApiKey,
-  resolveEmbeddingModel,
-  runUnifiedRecall
-} from "./chunk-Y2BC7RCE.js";
-import {
-  recall
-} from "./chunk-MEHOGUZE.js";
-
-// src/internal-recall-eval-server.ts
-import process from "process";
-
-// src/adapters/api/internal-recall-eval-server.ts
-import { createServer } from "http";
-
-// src/app/evals/recall/collect-diagnostics.ts
-function createRecallEvalDiagnosticsCollector(request) {
-  const diagnosticsRequested = wantsRecallEvalDiagnostics(request);
-  const timingsRequested = request.options?.includeTimings === true;
-  const observationEnabled = diagnosticsRequested || timingsRequested;
-  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,
-    budgetMs: 0,
-    hydrateEntriesMs: 0,
-    shapeResultsMs: 0,
-    recordRecallEventsMs: 0
-  };
-  const retrieval = {
-    queryEmbeddingDimensions: 0,
-    vectorSearchLimit: 0,
-    lexicalSearchLimit: 0
-  };
-  const candidateCounts = {
-    vectorRetrieved: 0,
-    lexicalRetrieved: 0,
-    merged: 0,
-    thresholdQualified: 0,
-    budgetAccepted: 0,
-    finalRanked: 0,
-    hydrated: 0,
-    returned: 0,
-    telemetryAttempted: 0
-  };
-  let provision;
-  let ranking;
-  let filtering;
-  let claimKey;
-  let degraded;
-  let provisionObserved = false;
-  let retrievalObserved = false;
-  let traceObserved = false;
-  const traceSink = {
-    reportSummary(summary) {
-      traceObserved = true;
-      ranking = {
-        limit: summary.ranking.limit,
-        threshold: summary.ranking.threshold,
-        budget: summary.ranking.budget,
-        noResultReason: summary.ranking.noResultReason
-      };
-      filtering = {
-        types: [...summary.filtering.types],
-        tags: [...summary.filtering.tags],
-        since: summary.filtering.since,
-        until: summary.filtering.until,
-        around: summary.filtering.around ? {
-          source: summary.filtering.around.source,
-          anchor: summary.filtering.around.anchor,
-          radiusDays: summary.filtering.around.radiusDays
-        } : void 0
-      };
-      candidateCounts.merged = summary.candidateCounts.merged;
-      candidateCounts.thresholdQualified = summary.candidateCounts.thresholdQualified;
-      candidateCounts.budgetAccepted = summary.candidateCounts.budgetAccepted;
-      candidateCounts.finalRanked = summary.candidateCounts.finalRanked;
-      candidateCounts.returned = summary.candidateCounts.returned;
-      claimKey = {
-        historicalBoosted: summary.claimKey.historicalBoosted,
-        tentativeLineageSuppressed: summary.claimKey.tentativeLineageSuppressed,
-        trustPenalized: summary.claimKey.trustPenalized,
-        redundancyPenalized: summary.claimKey.redundancyPenalized
-      };
-      degraded = {
-        active: summary.degraded.active,
-        reasons: [...summary.degraded.reasons],
-        lexicalOnly: summary.degraded.lexicalOnly,
-        notices: [...summary.degraded.notices]
-      };
-      stageTimings.mergeCandidatesMs = summary.timings.mergeCandidatesMs;
-      stageTimings.scoreCandidatesMs = summary.timings.scoreCandidatesMs;
-      stageTimings.thresholdMs = summary.timings.thresholdMs;
-      stageTimings.budgetMs = summary.timings.budgetMs;
-      stageTimings.shapeResultsMs = summary.timings.shapeResultsMs;
-    }
-  };
-  return {
-    traceSink,
-    isObservationEnabled() {
-      return observationEnabled;
-    },
-    recordSandboxSetup(durationMs) {
-      stageTimings.sandboxSetupMs = durationMs;
-    },
-    recordFixtureProvisionTiming(durationMs) {
-      stageTimings.fixtureProvisionMs = durationMs;
-    },
-    recordProvision(result, durationMs) {
-      provisionObserved = true;
-      execution.provisionedCount = result.provisionedCount;
-      stageTimings.fixtureProvisionMs = durationMs;
-      provision = {
-        requestedCount: request.memoryPool.length,
-        provisionedCount: result.provisionedCount,
-        providedIdCount: result.providedIdCount,
-        generatedIdCount: result.generatedIdCount,
-        retiredCount: result.retiredCount,
-        supersededCount: result.supersededCount,
-        createdAtDefaultedCount: result.createdAtDefaultedCount,
-        updatedAtDefaultedCount: result.updatedAtDefaultedCount,
-        seededEntries: result.seededEntries.map((entry) => ({
-          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,
-          valid_from: entry.valid_from,
-          valid_to: entry.valid_to
-        }))
-      };
-    },
-    recordRecall(durationMs) {
-      stageTimings.recallMs = durationMs;
-    },
-    recordQueryEmbedding(params) {
-      retrievalObserved = true;
-      stageTimings.queryEmbeddingMs = params.durationMs;
-      retrieval.queryEmbeddingDimensions = params.dimensions;
-    },
-    recordVectorSearch(params) {
-      retrievalObserved = true;
-      stageTimings.vectorSearchMs = params.durationMs;
-      retrieval.vectorSearchLimit = params.limit;
-      candidateCounts.vectorRetrieved = params.count;
-    },
-    recordLexicalSearch(params) {
-      retrievalObserved = true;
-      stageTimings.lexicalSearchMs = params.durationMs;
-      retrieval.lexicalSearchLimit = params.limit;
-      candidateCounts.lexicalRetrieved = params.count;
-    },
-    recordHydrateEntries(params) {
-      retrievalObserved = true;
-      stageTimings.hydrateEntriesMs = params.durationMs;
-      candidateCounts.hydrated = params.count;
-    },
-    recordRecallTelemetry(params) {
-      retrievalObserved = true;
-      stageTimings.recordRecallEventsMs = params.durationMs;
-      candidateCounts.telemetryAttempted = params.entryCount;
-    },
-    buildDiagnostics() {
-      if (!diagnosticsRequested) {
-        return void 0;
-      }
-      return {
-        execution,
-        provision: provisionObserved ? provision : void 0,
-        retrieval: retrievalObserved ? retrieval : void 0,
-        ranking: traceObserved ? ranking : void 0,
-        filtering: traceObserved ? filtering : void 0,
-        claimKey: traceObserved ? claimKey : void 0,
-        degraded: traceObserved ? degraded : void 0,
-        candidateCounts
-      };
-    },
-    buildTimings(totalMs) {
-      if (!timingsRequested) {
-        return void 0;
-      }
-      return {
-        totalMs,
-        sandboxSetupMs: stageTimings.sandboxSetupMs,
-        fixtureProvisionMs: stageTimings.fixtureProvisionMs,
-        recallMs: stageTimings.recallMs,
-        queryEmbeddingMs: stageTimings.queryEmbeddingMs,
-        vectorSearchMs: stageTimings.vectorSearchMs,
-        lexicalSearchMs: stageTimings.lexicalSearchMs,
-        mergeCandidatesMs: stageTimings.mergeCandidatesMs,
-        scoreCandidatesMs: stageTimings.scoreCandidatesMs,
-        thresholdMs: stageTimings.thresholdMs,
-        budgetMs: stageTimings.budgetMs,
-        hydrateEntriesMs: stageTimings.hydrateEntriesMs,
-        shapeResultsMs: stageTimings.shapeResultsMs,
-        recordRecallEventsMs: stageTimings.recordRecallEventsMs
-      };
-    }
-  };
-}
-function wantsRecallEvalDiagnostics(request) {
-  return request.options?.includeDiagnostics === true || request.options?.includeCandidates === true;
-}
-
-// src/app/evals/recall/instrumented-recall-ports.ts
-function createInstrumentedRecallPorts(ports, observer) {
-  return {
-    async embed(text) {
-      const startedAt = Date.now();
-      try {
-        const embedding = await ports.embed(text);
-        observer.recordQueryEmbedding({
-          durationMs: elapsedMs(startedAt),
-          dimensions: embedding.length
-        });
-        return embedding;
-      } catch (error) {
-        observer.recordQueryEmbedding({
-          durationMs: elapsedMs(startedAt),
-          dimensions: 0
-        });
-        throw error;
-      }
-    },
-    async vectorSearch(params) {
-      const startedAt = Date.now();
-      try {
-        const results = await ports.vectorSearch(params);
-        observer.recordVectorSearch({
-          durationMs: elapsedMs(startedAt),
-          count: results.length,
-          limit: params.limit
-        });
-        return results;
-      } catch (error) {
-        observer.recordVectorSearch({
-          durationMs: elapsedMs(startedAt),
-          count: 0,
-          limit: params.limit
-        });
-        throw error;
-      }
-    },
-    async ftsSearch(params) {
-      const startedAt = Date.now();
-      try {
-        const results = await ports.ftsSearch(params);
-        observer.recordLexicalSearch({
-          durationMs: elapsedMs(startedAt),
-          count: results.length,
-          limit: params.limit
-        });
-        return results;
-      } catch (error) {
-        observer.recordLexicalSearch({
-          durationMs: elapsedMs(startedAt),
-          count: 0,
-          limit: params.limit
-        });
-        throw error;
-      }
-    },
-    ...ports.fetchPredecessors ? {
-      async fetchPredecessors(params) {
-        return ports.fetchPredecessors(params);
-      }
-    } : {},
-    async hydrateEntries(ids) {
-      const startedAt = Date.now();
-      try {
-        const entries = await ports.hydrateEntries(ids);
-        observer.recordHydrateEntries({
-          durationMs: elapsedMs(startedAt),
-          count: entries.length
-        });
-        return entries;
-      } catch (error) {
-        observer.recordHydrateEntries({
-          durationMs: elapsedMs(startedAt),
-          count: 0
-        });
-        throw error;
-      }
-    },
-    async recordRecallEvents(params) {
-      const startedAt = Date.now();
-      try {
-        await ports.recordRecallEvents(params);
-      } finally {
-        observer.recordRecallTelemetry({
-          durationMs: elapsedMs(startedAt),
-          entryCount: params.entryIds.length
-        });
-      }
-    }
-  };
-}
-function elapsedMs(startedAt) {
-  return Math.max(0, Date.now() - startedAt);
-}
-
-// src/app/evals/recall/normalize-response.ts
-function buildRecallEvalSuccessResponse(params) {
-  const entryResults = Array.isArray(params.results) ? params.results : params.results.entries;
-  const projectedEntries = Array.isArray(params.results) ? entryResults.map((result) => projectClaimCentricRecallEntry(result, { asOf: params.request.recallRequest.asOf })) : params.results.projectedEntries;
-  const metadata = buildMetadata(params.request, params.results, projectedEntries);
-  return {
-    status: "ok",
-    caseId: params.request.caseId,
-    result: {
-      entries: entryResults.map((result, index) => ({
-        id: result.entry.id,
-        subject: result.entry.subject,
-        content: result.entry.content,
-        type: result.entry.type,
-        importance: result.entry.importance,
-        expiry: result.entry.expiry,
-        tags: result.entry.tags,
-        created_at: result.entry.created_at,
-        score: result.score,
-        scores: result.scores,
-        claim: {
-          familyKey: projectedEntries[index]?.familyKey ?? `entry:${result.entry.id}`,
-          claimKey: projectedEntries[index]?.claimKey,
-          slotPolicy: projectedEntries[index]?.slotPolicy ?? "exclusive",
-          memoryState: projectedEntries[index]?.memoryState ?? "current",
-          claimStatus: projectedEntries[index]?.claimStatus ?? "no_key",
-          freshness: projectedEntries[index]?.freshness ?? {
-            createdAt: result.entry.created_at,
-            isCurrent: true,
-            label: `created ${result.entry.created_at} | current state`
-          },
-          provenance: projectedEntries[index]?.provenance ?? {},
-          whySurfaced: projectedEntries[index]?.whySurfaced ?? {
-            summary: `ranked score ${result.score.toFixed(2)}`,
-            reasons: []
-          }
-        }
-      })),
-      entryIds: entryResults.map((result) => result.entry.id)
-    },
-    metadata,
-    diagnostics: params.diagnostics,
-    timings: params.timings,
-    sandbox: buildSandboxResult(params.sandbox)
-  };
-}
-function buildRecallEvalErrorResponse(params) {
-  return {
-    status: "error",
-    caseId: params.request.caseId,
-    error: {
-      code: params.code,
-      message: params.message,
-      details: params.details
-    },
-    diagnostics: params.diagnostics,
-    timings: params.timings,
-    sandbox: params.sandbox ? buildSandboxResult(params.sandbox) : void 0
-  };
-}
-function buildSandboxResult(sandbox) {
-  return {
-    root: sandbox.root,
-    dbPath: sandbox.dbPath,
-    preserved: sandbox.preserved
-  };
-}
-function buildMetadata(request, results, projectedEntries) {
-  if (Array.isArray(results)) {
-    return {
-      path: request.recallPath ?? "core",
-      claim: {
-        projectedEntries: projectedEntries.map(buildProjectedEntryMetadata)
-      }
-    };
-  }
-  return {
-    path: "unified",
-    claim: {
-      projectedEntries: projectedEntries.map(buildProjectedEntryMetadata),
-      entryFamilies: results.entryFamilies.map(buildClaimFamilyMetadata),
-      transitions: results.claimTransitions
-    },
-    unified: {
-      routing: results.routing,
-      timeWindow: results.timeWindow,
-      asOf: results.asOf,
-      procedure: results.procedure ? {
-        id: results.procedure.id,
-        procedureKey: results.procedure.procedure_key,
-        title: results.procedure.title,
-        goal: results.procedure.goal
-      } : void 0,
-      procedureCandidates: results.procedureCandidates.map((candidate) => ({
-        id: candidate.procedure.id,
-        procedureKey: candidate.procedure.procedure_key,
-        title: candidate.procedure.title,
-        score: candidate.score,
-        lexicalScore: candidate.scores.lexical,
-        vectorScore: candidate.scores.vector
-      })),
-      procedureNotices: results.procedureNotices,
-      notices: results.notices,
-      episodeCount: results.episodes.length
-    }
-  };
-}
-function buildProjectedEntryMetadata(entry) {
-  return {
-    entryId: entry.entryId,
-    familyKey: entry.familyKey,
-    claimKey: entry.claimKey,
-    slotPolicy: entry.slotPolicy,
-    memoryState: entry.memoryState,
-    claimStatus: entry.claimStatus,
-    freshness: entry.freshness,
-    provenance: entry.provenance,
-    whySurfaced: entry.whySurfaced
-  };
-}
-function buildClaimFamilyMetadata(family) {
-  return {
-    familyKey: family.familyKey,
-    claimKey: family.claimKey,
-    slotPolicy: family.slotPolicy,
-    subject: family.subject,
-    primaryEntryId: family.primary.entryId,
-    entries: family.entries.map((entry) => ({
-      id: entry.entryId,
-      memoryState: entry.memoryState,
-      claimStatus: entry.claimStatus
-    }))
-  };
-}
-
-// src/app/evals/recall/provision-fixtures.ts
-import { createHash } from "crypto";
-var DEFAULT_IMPORTANCE = 6;
-var DEFAULT_EXPIRY = "permanent";
-var DEFAULT_QUALITY_SCORE = 0.5;
-async function provisionRecallEvalFixtures(params) {
-  const preparedBatch = prepareFixtures(params.caseId, params.memoryPool, params.provisionedAt);
-  if (preparedBatch.insertionOrder.length === 0) {
-    return {
-      provisionedCount: 0,
-      providedIdCount: 0,
-      generatedIdCount: 0,
-      retiredCount: 0,
-      supersededCount: 0,
-      createdAtDefaultedCount: 0,
-      updatedAtDefaultedCount: 0,
-      seededEntries: []
-    };
-  }
-  const embeddings = await params.embedding.embed(preparedBatch.insertionOrder.map((fixture) => fixture.embeddingText));
-  if (embeddings.length !== preparedBatch.insertionOrder.length) {
-    throw new Error(`Fixture embedding count mismatch: expected ${preparedBatch.insertionOrder.length}, received ${embeddings.length}.`);
-  }
-  await params.store.withTransaction(async (store) => {
-    for (const [index, fixture] of preparedBatch.insertionOrder.entries()) {
-      await store.insertEntry(fixture.entry, embeddings[index] ?? [], fixture.contentHash);
-    }
-  });
-  return {
-    provisionedCount: preparedBatch.insertionOrder.length,
-    providedIdCount: preparedBatch.providedIdCount,
-    generatedIdCount: preparedBatch.generatedIdCount,
-    retiredCount: preparedBatch.retiredCount,
-    supersededCount: preparedBatch.supersededCount,
-    createdAtDefaultedCount: preparedBatch.createdAtDefaultedCount,
-    updatedAtDefaultedCount: preparedBatch.updatedAtDefaultedCount,
-    seededEntries: preparedBatch.seededEntries
-  };
-}
-function prepareFixtures(caseId, fixtures, provisionedAt) {
-  const resolvedIds = fixtures.map((fixture, index) => fixture.id ?? createFixtureId(caseId, index, fixture));
-  const duplicateIds = findDuplicateIds(resolvedIds);
-  if (duplicateIds.length > 0) {
-    throw new Error(`Fixture IDs must be unique. Duplicate IDs: ${duplicateIds.join(", ")}.`);
-  }
-  const knownIds = new Set(resolvedIds);
-  const prepared = fixtures.map((fixture, index) => {
-    const supersededBy = fixture.superseded_by;
-    if (supersededBy && !knownIds.has(supersededBy)) {
-      throw new Error(`memoryPool[${index}].superseded_by references unknown fixture id "${supersededBy}".`);
-    }
-    const entry = buildEntry(fixture, resolvedIds[index] ?? "", provisionedAt);
-    return {
-      fixtureIndex: index,
-      entry,
-      contentHash: hashText(`${entry.type}
-${entry.subject}
-${entry.content}`),
-      embeddingText: composeEmbeddingText(entry)
-    };
-  });
-  return {
-    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,
-    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,
-    seededEntries: prepared.map((fixture) => summarizePreparedFixture(fixture.entry))
-  };
-}
-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
-  };
-}
-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,
-    valid_from: entry.valid_from,
-    valid_to: entry.valid_to
-  };
-}
-function createFixtureId(caseId, index, fixture) {
-  const digest = createHash("sha256").update(caseId).update(":").update(String(index)).update(":").update(fixture.type).update(":").update(fixture.subject).update(":").update(fixture.content).digest("hex");
-  return `eval-${digest.slice(0, 24)}`;
-}
-function findDuplicateIds(ids) {
-  const seen = /* @__PURE__ */ new Set();
-  const duplicates = [];
-  for (const id of ids) {
-    if (seen.has(id)) {
-      if (!duplicates.includes(id)) {
-        duplicates.push(id);
-      }
-      continue;
-    }
-    seen.add(id);
-  }
-  return duplicates;
-}
-function topologicallySortFixtures(fixtures) {
-  const indegree = new Map(fixtures.map((fixture) => [fixture.entry.id, 0]));
-  const dependents = /* @__PURE__ */ new Map();
-  for (const fixture of fixtures) {
-    const successorId = fixture.entry.superseded_by;
-    if (!successorId) {
-      continue;
-    }
-    indegree.set(fixture.entry.id, (indegree.get(fixture.entry.id) ?? 0) + 1);
-    const successorDependents = dependents.get(successorId) ?? [];
-    successorDependents.push(fixture);
-    dependents.set(successorId, successorDependents);
-  }
-  const ready = fixtures.filter((fixture) => (indegree.get(fixture.entry.id) ?? 0) === 0).sort((left, right) => left.fixtureIndex - right.fixtureIndex);
-  const sorted = [];
-  while (ready.length > 0) {
-    const current = ready.shift();
-    if (!current) {
-      break;
-    }
-    sorted.push(current);
-    const currentDependents = (dependents.get(current.entry.id) ?? []).sort((left, right) => left.fixtureIndex - right.fixtureIndex);
-    for (const dependent of currentDependents) {
-      const remaining = (indegree.get(dependent.entry.id) ?? 0) - 1;
-      indegree.set(dependent.entry.id, remaining);
-      if (remaining === 0) {
-        ready.push(dependent);
-        ready.sort((left, right) => left.fixtureIndex - right.fixtureIndex);
-      }
-    }
-  }
-  if (sorted.length !== fixtures.length) {
-    const unresolved = fixtures.filter((fixture) => !sorted.includes(fixture)).map((fixture) => fixture.entry.id);
-    throw new Error(`Fixture supersession metadata contains a cycle: ${unresolved.join(", ")}.`);
-  }
-  return sorted;
-}
-function hashText(value) {
-  return createHash("sha256").update(value).digest("hex");
-}
-
-// src/app/evals/recall/provision-procedure-fixtures.ts
-import { createHash as createHash2 } from "crypto";
-async function provisionRecallEvalProcedureFixtures(params) {
-  const procedures = prepareProcedures(params.caseId, params.procedurePool, params.provisionedAt);
-  if (procedures.length === 0) {
-    return {
-      provisionedCount: 0
-    };
-  }
-  await params.store.withTransaction(async (store) => {
-    for (const procedure of procedures) {
-      await store.insertProcedure(procedure);
-    }
-  });
-  return {
-    provisionedCount: procedures.length
-  };
-}
-function prepareProcedures(caseId, fixtures, provisionedAt) {
-  const resolvedIds = fixtures.map((fixture, index) => fixture.id ?? createFixtureId2(caseId, index, fixture));
-  const duplicateIds = findDuplicateIds2(resolvedIds);
-  if (duplicateIds.length > 0) {
-    throw new Error(`Procedure fixture IDs must be unique. Duplicate IDs: ${duplicateIds.join(", ")}.`);
-  }
-  const knownIds = new Set(resolvedIds);
-  return fixtures.map((fixture, index) => {
-    if (fixture.superseded_by && !knownIds.has(fixture.superseded_by)) {
-      throw new Error(`procedurePool[${index}].superseded_by references unknown fixture id "${fixture.superseded_by}".`);
-    }
-    const normalizedBody = normalizeProcedureDefinition(
-      {
-        procedure_key: fixture.procedure_key,
-        title: fixture.title,
-        goal: fixture.goal,
-        when_to_use: fixture.when_to_use ?? [],
-        when_not_to_use: fixture.when_not_to_use ?? [],
-        prerequisites: fixture.prerequisites ?? [],
-        steps: fixture.steps,
-        verification: fixture.verification ?? [],
-        failure_modes: fixture.failure_modes ?? [],
-        sources: fixture.sources ?? [{ kind: "manual", label: "recall eval fixture" }]
-      },
-      `procedurePool[${index}]`
-    );
-    const createdAt = fixture.created_at ?? provisionedAt;
-    const updatedAt = fixture.updated_at ?? createdAt;
-    return {
-      id: resolvedIds[index] ?? "",
-      ...normalizedBody,
-      source_file: fixture.source_file,
-      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,
-      superseded_by: fixture.superseded_by,
-      created_at: createdAt,
-      updated_at: updatedAt
-    };
-  });
-}
-function createFixtureId2(caseId, index, fixture) {
-  const digest = createHash2("sha256").update(caseId).update(":").update(String(index)).update(":").update(fixture.procedure_key).update(":").update(fixture.title).update(":").update(fixture.goal).digest("hex");
-  return `eval-procedure-${digest.slice(0, 24)}`;
-}
-function findDuplicateIds2(ids) {
-  const seen = /* @__PURE__ */ new Set();
-  const duplicates = [];
-  for (const id of ids) {
-    if (seen.has(id)) {
-      if (!duplicates.includes(id)) {
-        duplicates.push(id);
-      }
-      continue;
-    }
-    seen.add(id);
-  }
-  return duplicates;
-}
-
-// src/app/evals/recall/sandbox.ts
-import { mkdir, mkdtemp, rm } from "fs/promises";
-import { tmpdir } from "os";
-import path from "path";
-
-// src/adapters/db/eval-fixture-store.ts
-function createRecallEvalFixtureStore(database) {
-  return {
-    insertEntry: async (entry, embedding, contentHash) => database.insertEntry(entry, embedding, contentHash),
-    insertProcedure: async (procedure) => database.upsertProcedure(procedure),
-    withTransaction: async (fn) => database.withTransaction(async (transaction) => fn(createRecallEvalFixtureStore(transaction)))
-  };
-}
-
-// src/app/evals/recall/sandbox.ts
-var SANDBOX_DB_FILENAME = "knowledge.db";
-var SANDBOX_DIR_PREFIX = "agenr-recall-eval-";
-async function setupRecallEvalSandbox(request) {
-  const suppliedRoot = request?.root !== void 0;
-  const preserved = request?.preserve === true;
-  const root = suppliedRoot ? path.resolve(request.root ?? "") : await mkdtemp(path.join(tmpdir(), SANDBOX_DIR_PREFIX));
-  let database;
-  const dbPath = path.join(root, SANDBOX_DB_FILENAME);
-  try {
-    if (suppliedRoot) {
-      await mkdir(root, { recursive: true });
-    }
-    await removeDatabaseFiles(dbPath);
-    database = await createDatabase(dbPath);
-    const openDatabase = database;
-    return {
-      root,
-      dbPath,
-      preserved,
-      fixtureStore: createRecallEvalFixtureStore(openDatabase),
-      episodeDatabase: openDatabase,
-      procedureDatabase: openDatabase,
-      createRecallPorts: (embedding) => createRecallAdapter(openDatabase, embedding),
-      cleanup: async () => {
-        await openDatabase.close().catch(() => void 0);
-        if (preserved) {
-          return;
-        }
-        if (suppliedRoot) {
-          await removeDatabaseFiles(dbPath);
-          return;
-        }
-        await rm(root, { recursive: true, force: true });
-      }
-    };
-  } catch (error) {
-    await database?.close().catch(() => void 0);
-    if (!preserved) {
-      if (suppliedRoot) {
-        await removeDatabaseFiles(dbPath).catch(() => void 0);
-      } else {
-        await rm(root, { recursive: true, force: true }).catch(() => void 0);
-      }
-    }
-    throw error;
-  }
-}
-async function removeDatabaseFiles(dbPath) {
-  await Promise.all([rm(dbPath, { force: true }), rm(`${dbPath}-wal`, { force: true }), rm(`${dbPath}-shm`, { force: true })]);
-}
-
-// src/app/evals/recall/run-recall-eval-case.ts
-async function runRecallEvalCase(request) {
-  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;
-  };
-  try {
-    const sandboxStartedAt = Date.now();
-    try {
-      sandbox = await setupRecallEvalSandbox(request.sandbox);
-      diagnostics.recordSandboxSetup(elapsedMs2(sandboxStartedAt));
-    } catch (error) {
-      diagnostics.recordSandboxSetup(elapsedMs2(sandboxStartedAt));
-      return buildRecallEvalErrorResponse({
-        request,
-        code: "sandbox_setup_failed",
-        message: "Failed to create isolated recall eval sandbox.",
-        details: toErrorDetails(error),
-        diagnostics: diagnostics.buildDiagnostics(),
-        timings: diagnostics.buildTimings(elapsedMs2(startedAt))
-      });
-    }
-    if (request.memoryPool.length > 0 || (request.procedurePool?.length ?? 0) > 0) {
-      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, elapsedMs2(provisionStartedAt));
-        } else {
-          diagnostics.recordFixtureProvisionTiming(elapsedMs2(provisionStartedAt));
-        }
-      } catch (error) {
-        diagnostics.recordFixtureProvisionTiming(elapsedMs2(provisionStartedAt));
-        return buildRecallEvalErrorResponse({
-          request,
-          code: "fixture_provision_failed",
-          message: "Failed to provision recall eval fixtures into isolated storage.",
-          details: toErrorDetails(error),
-          diagnostics: diagnostics.buildDiagnostics(),
-          timings: diagnostics.buildTimings(elapsedMs2(startedAt)),
-          sandbox
-        });
-      }
-    }
-    const recallStartedAt = Date.now();
-    try {
-      const embeddingSupport = getEmbeddingSupport();
-      const recallEmbeddingPort = request.options?.faultInjection?.queryEmbeddingFailure === true ? createUnavailableEmbeddingPort("Injected recall eval query embedding failure.") : embeddingSupport.port ?? createUnavailableEmbeddingPort(embeddingSupport.error ?? "Embeddings are unavailable.");
-      const basePorts = applyRecallEvalFaultInjection(sandbox.createRecallPorts(recallEmbeddingPort), request);
-      const recallPorts = diagnostics.isObservationEnabled() ? createInstrumentedRecallPorts(basePorts, diagnostics) : basePorts;
-      const slotPolicyConfig = request.unified?.memoryPolicy?.slotPolicies;
-      const unifiedRecallOptions = {
-        ...slotPolicyConfig ? { slotPolicyConfig } : {},
-        ...diagnostics.isObservationEnabled() ? { trace: diagnostics.traceSink } : {}
-      };
-      const results = recallPath === "unified" ? await runUnifiedRecall(
-        {
-          text: request.recallRequest.text,
-          ...request.unified?.mode ? { mode: request.unified.mode } : {},
-          ...request.recallRequest.limit !== void 0 ? { limit: request.recallRequest.limit } : {},
-          ...request.recallRequest.threshold !== void 0 ? { threshold: request.recallRequest.threshold } : {},
-          ...request.recallRequest.types && request.recallRequest.types.length > 0 ? { types: request.recallRequest.types } : {},
-          ...request.recallRequest.tags && request.recallRequest.tags.length > 0 ? { tags: request.recallRequest.tags } : {},
-          ...request.recallRequest.asOf ? { asOf: request.recallRequest.asOf } : {},
-          ...request.unified?.sessionKey ? { sessionKey: request.unified.sessionKey } : {}
-        },
-        {
-          database: sandbox.episodeDatabase,
-          procedures: sandbox.procedureDatabase,
-          recall: recallPorts,
-          embeddingAvailable: embeddingSupport.available,
-          ...embeddingSupport.error ? { embeddingError: embeddingSupport.error } : {},
-          ...slotPolicyConfig ? { claimSlotPolicyConfig: slotPolicyConfig } : {},
-          ...embeddingSupport.available ? {
-            embedQuery: async (text) => {
-              const vectors = await recallEmbeddingPort.embed([text]);
-              return vectors[0] ?? [];
-            }
-          } : {},
-          ...Object.keys(unifiedRecallOptions).length > 0 ? { recallOptions: unifiedRecallOptions } : {}
-        }
-      ) : await recall(request.recallRequest, recallPorts, diagnostics.isObservationEnabled() ? { trace: diagnostics.traceSink } : void 0);
-      diagnostics.recordRecall(elapsedMs2(recallStartedAt));
-      return buildRecallEvalSuccessResponse({
-        request,
-        results,
-        diagnostics: diagnostics.buildDiagnostics(),
-        timings: diagnostics.buildTimings(elapsedMs2(startedAt)),
-        sandbox
-      });
-    } catch (error) {
-      diagnostics.recordRecall(elapsedMs2(recallStartedAt));
-      return buildRecallEvalErrorResponse({
-        request,
-        code: "recall_execution_failed",
-        message: "Failed to execute real recall against isolated eval state.",
-        details: toErrorDetails(error),
-        diagnostics: diagnostics.buildDiagnostics(),
-        timings: diagnostics.buildTimings(elapsedMs2(startedAt)),
-        sandbox
-      });
-    }
-  } catch (error) {
-    return buildRecallEvalErrorResponse({
-      request,
-      code: "internal_error",
-      message: "Recall eval execution failed unexpectedly.",
-      details: toErrorDetails(error),
-      diagnostics: diagnostics.buildDiagnostics(),
-      timings: diagnostics.buildTimings(elapsedMs2(startedAt)),
-      sandbox
-    });
-  } finally {
-    await sandbox?.cleanup().catch(() => void 0);
-  }
-}
-function toErrorDetails(error) {
-  if (error instanceof Error) {
-    return {
-      cause: error.message
-    };
-  }
-  return {
-    cause: String(error)
-  };
-}
-function createUnavailableEmbeddingPort(message) {
-  return {
-    async embed() {
-      throw new Error(message);
-    }
-  };
-}
-function applyRecallEvalFaultInjection(ports, request) {
-  if (request.options?.faultInjection?.vectorSearchFailure !== true) {
-    return ports;
-  }
-  return {
-    async embed(text) {
-      return ports.embed(text);
-    },
-    async vectorSearch() {
-      throw new Error("Injected recall eval vector search failure.");
-    },
-    async ftsSearch(params) {
-      return ports.ftsSearch(params);
-    },
-    ...ports.fetchPredecessors ? {
-      async fetchPredecessors(params) {
-        return ports.fetchPredecessors(params);
-      }
-    } : {},
-    async hydrateEntries(ids) {
-      return ports.hydrateEntries(ids);
-    },
-    async recordRecallEvents(params) {
-      return ports.recordRecallEvents(params);
-    }
-  };
-}
-function elapsedMs2(startedAt) {
-  return Math.max(0, Date.now() - startedAt);
-}
-
-// src/adapters/api/validation/recall-eval-request.ts
-var ROOT_REQUEST_KEYS = /* @__PURE__ */ new Set(["caseId", "description", "recallPath", "sandbox", "memoryPool", "recallRequest", "unified", "options"]);
-var SANDBOX_REQUEST_KEYS = /* @__PURE__ */ new Set(["root", "preserve"]);
-var FIXTURE_ENTRY_KEYS = /* @__PURE__ */ new Set([
-  "id",
-  "type",
-  "subject",
-  "content",
-  "importance",
-  "expiry",
-  "tags",
-  "source_file",
-  "source_context",
-  "created_at",
-  "updated_at",
-  "retired",
-  "retired_at",
-  "retired_reason",
-  "superseded_by",
-  "claim_key",
-  "claim_key_status",
-  "claim_key_source",
-  "claim_support_source_kind",
-  "claim_support_locator",
-  "claim_support_observed_at",
-  "claim_support_mode",
-  "valid_from",
-  "valid_to",
-  "supersession_kind",
-  "supersession_reason"
-]);
-var RECALL_REQUEST_KEYS = /* @__PURE__ */ new Set([
-  "text",
-  "limit",
-  "threshold",
-  "budget",
-  "types",
-  "tags",
-  "since",
-  "until",
-  "around",
-  "aroundRadius",
-  "asOf",
-  "rankingProfile"
-]);
-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_KEYS = /* @__PURE__ */ new Set(["includeDiagnostics", "includeCandidates", "includeTimings", "faultInjection"]);
-var FAULT_INJECTION_KEYS = /* @__PURE__ */ new Set(["queryEmbeddingFailure", "vectorSearchFailure"]);
-var RECALL_PATHS = ["core", "unified"];
-var RECALL_RANKING_PROFILES = ["historical_state"];
-var UNIFIED_RECALL_MODES = ["auto", "entries", "episodes"];
-var CLAIM_SLOT_POLICIES = ["exclusive", "multivalued"];
-var RecallEvalRequestValidationError = class extends Error {
-  /** Parseable case identifier echoed for invalid request correlation when available. */
-  caseId;
-  /** Structured list of request validation issues. */
-  issues;
-  /**
-   * Creates a request validation error with stable issue details.
-   *
-   * @param issues - Structured validation issues collected during parsing.
-   * @param caseId - Parseable request case identifier when available.
-   */
-  constructor(issues, caseId) {
-    super("Invalid recall eval request.");
-    this.name = "RecallEvalRequestValidationError";
-    this.issues = issues;
-    this.caseId = caseId;
-  }
-};
-function parseRecallEvalCaseRequest(input) {
-  const caseId = extractParseableCaseId(input);
-  if (!isRecord(input)) {
-    throw new RecallEvalRequestValidationError(
-      [
-        {
-          path: "$",
-          message: "Request body must be a JSON object."
-        }
-      ],
-      caseId
-    );
-  }
-  const issues = [];
-  pushUnexpectedFields(input, ROOT_REQUEST_KEYS, "", issues);
-  const parsedCaseId = parseRequiredTrimmedString(input.caseId, "caseId", issues);
-  const description = parseOptionalTrimmedString(input.description, "description", issues);
-  const recallPath = parseOptionalRecallPath(input.recallPath, "recallPath", issues);
-  const sandbox = parseSandbox(input.sandbox, issues);
-  const memoryPool = parseMemoryPool(input.memoryPool, issues);
-  const recallRequest = parseRecallRequest(input.recallRequest, issues);
-  const unified = parseUnifiedRequest(input.unified, issues);
-  const options = parseOptions(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);
-  }
-  return {
-    caseId: parsedCaseId,
-    description,
-    recallPath,
-    sandbox,
-    memoryPool,
-    recallRequest,
-    unified,
-    options
-  };
-}
-function mapRecallEvalCaseRequestDto(dto) {
-  return {
-    caseId: dto.caseId,
-    description: dto.description,
-    recallPath: dto.recallPath,
-    sandbox: mapSandboxRequestDto(dto.sandbox),
-    memoryPool: dto.memoryPool.map(mapFixtureEntryDto),
-    recallRequest: mapRecallRequestDto(dto.recallRequest),
-    unified: mapUnifiedRequestDto(dto.unified),
-    options: mapCaseOptionsDto(dto.options)
-  };
-}
-function extractParseableCaseId(value) {
-  if (!isRecord(value) || typeof value.caseId !== "string") {
-    return void 0;
-  }
-  const normalized = value.caseId.trim();
-  return normalized.length > 0 ? normalized : void 0;
-}
-function parseSandbox(value, issues) {
-  if (value === void 0) {
-    return void 0;
-  }
-  const sandbox = parseObject(value, "sandbox", issues);
-  if (sandbox === void 0) {
-    return void 0;
-  }
-  pushUnexpectedFields(sandbox, SANDBOX_REQUEST_KEYS, "sandbox", issues);
-  return {
-    root: parseOptionalTrimmedString(sandbox.root, "sandbox.root", issues),
-    preserve: parseOptionalBoolean(sandbox.preserve, "sandbox.preserve", issues)
-  };
-}
-function parseMemoryPool(value, issues) {
-  if (!Array.isArray(value)) {
-    pushIssue(issues, "memoryPool", "Expected an array of fixture entries.");
-    return void 0;
-  }
-  return value.flatMap((entry, index) => {
-    const parsed = parseFixtureEntry(entry, index, issues);
-    return parsed ? [parsed] : [];
-  });
-}
-function parseFixtureEntry(value, index, issues) {
-  const basePath = `memoryPool[${index}]`;
-  const fixture = parseObject(value, basePath, issues);
-  if (fixture === void 0) {
-    return void 0;
-  }
-  pushUnexpectedFields(fixture, FIXTURE_ENTRY_KEYS, basePath, issues);
-  const type = parseEntryType(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) {
-    return void 0;
-  }
-  return {
-    id: parseOptionalTrimmedString(fixture.id, `${basePath}.id`, issues),
-    type,
-    subject,
-    content,
-    importance: parseOptionalIntegerInRange(fixture.importance, `${basePath}.importance`, issues, {
-      min: 1,
-      max: 10
-    }),
-    expiry: parseOptionalExpiry(fixture.expiry, `${basePath}.expiry`, issues),
-    tags: parseOptionalStringArray(fixture.tags, `${basePath}.tags`, issues),
-    source_file: parseOptionalTrimmedString(fixture.source_file, `${basePath}.source_file`, 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),
-    claim_key_source: parseOptionalClaimKeySource(fixture.claim_key_source, `${basePath}.claim_key_source`, issues),
-    claim_support_source_kind: parseOptionalTrimmedString(fixture.claim_support_source_kind, `${basePath}.claim_support_source_kind`, issues),
-    claim_support_locator: parseOptionalTrimmedString(fixture.claim_support_locator, `${basePath}.claim_support_locator`, issues),
-    claim_support_observed_at: parseOptionalTimestampString(fixture.claim_support_observed_at, `${basePath}.claim_support_observed_at`, issues),
-    claim_support_mode: parseOptionalClaimSupportMode(fixture.claim_support_mode, `${basePath}.claim_support_mode`, 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)
-  };
-}
-function parseRecallRequest(value, issues) {
-  const recallRequest = parseObject(value, "recallRequest", issues);
-  if (recallRequest === void 0) {
-    return void 0;
-  }
-  pushUnexpectedFields(recallRequest, RECALL_REQUEST_KEYS, "recallRequest", issues);
-  const text = parseRequiredTrimmedString(recallRequest.text, "recallRequest.text", issues);
-  if (text === void 0) {
-    return void 0;
-  }
-  return {
-    text,
-    limit: parseOptionalIntegerInRange(recallRequest.limit, "recallRequest.limit", issues, {
-      min: 0
-    }),
-    threshold: parseOptionalThreshold(recallRequest.threshold, "recallRequest.threshold", issues),
-    budget: parseOptionalIntegerInRange(recallRequest.budget, "recallRequest.budget", issues, {
-      min: 0
-    }),
-    types: parseOptionalEntryTypeArray(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),
-    around: parseOptionalTrimmedString(recallRequest.around, "recallRequest.around", issues),
-    aroundRadius: parseOptionalIntegerInRange(recallRequest.aroundRadius, "recallRequest.aroundRadius", issues, {
-      min: 1
-    }),
-    asOf: parseOptionalTrimmedString(recallRequest.asOf, "recallRequest.asOf", issues),
-    rankingProfile: parseOptionalRankingProfile(recallRequest.rankingProfile, "recallRequest.rankingProfile", issues)
-  };
-}
-function parseUnifiedRequest(value, issues) {
-  if (value === void 0) {
-    return void 0;
-  }
-  const unified = parseObject(value, "unified", issues);
-  if (unified === void 0) {
-    return void 0;
-  }
-  pushUnexpectedFields(unified, UNIFIED_REQUEST_KEYS, "unified", issues);
-  return {
-    mode: parseOptionalUnifiedRecallMode(unified.mode, "unified.mode", issues),
-    sessionKey: parseOptionalTrimmedString(unified.sessionKey, "unified.sessionKey", issues),
-    memoryPolicy: parseUnifiedMemoryPolicy(unified.memoryPolicy, issues)
-  };
-}
-function parseOptions(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_KEYS, "options", issues);
-  return {
-    includeDiagnostics: parseOptionalBoolean(options.includeDiagnostics, "options.includeDiagnostics", issues),
-    includeCandidates: parseOptionalBoolean(options.includeCandidates, "options.includeCandidates", issues),
-    includeTimings: parseOptionalBoolean(options.includeTimings, "options.includeTimings", issues),
-    faultInjection: parseFaultInjection(options.faultInjection, issues)
-  };
-}
-function parseFaultInjection(value, issues) {
-  if (value === void 0) {
-    return void 0;
-  }
-  const faultInjection = parseObject(value, "options.faultInjection", issues);
-  if (faultInjection === void 0) {
-    return void 0;
-  }
-  pushUnexpectedFields(faultInjection, FAULT_INJECTION_KEYS, "options.faultInjection", issues);
-  return {
-    queryEmbeddingFailure: parseOptionalBoolean(faultInjection.queryEmbeddingFailure, "options.faultInjection.queryEmbeddingFailure", issues),
-    vectorSearchFailure: parseOptionalBoolean(faultInjection.vectorSearchFailure, "options.faultInjection.vectorSearchFailure", issues)
-  };
-}
-function parseUnifiedMemoryPolicy(value, issues) {
-  if (value === void 0) {
-    return void 0;
-  }
-  const memoryPolicy = parseObject(value, "unified.memoryPolicy", issues);
-  if (memoryPolicy === void 0) {
-    return void 0;
-  }
-  pushUnexpectedFields(memoryPolicy, UNIFIED_MEMORY_POLICY_KEYS, "unified.memoryPolicy", issues);
-  return {
-    slotPolicies: parseClaimSlotPolicyConfig(memoryPolicy.slotPolicies, "unified.memoryPolicy.slotPolicies", issues)
-  };
-}
-function parseEntryType(value, path2, issues) {
-  if (typeof value !== "string" || !ENTRY_TYPES.includes(value)) {
-    pushIssue(issues, path2, `Expected one of: ${ENTRY_TYPES.join(", ")}.`);
-    return void 0;
-  }
-  return value;
-}
-function parseOptionalRecallPath(value, path2, issues) {
-  if (value === void 0) {
-    return void 0;
-  }
-  if (typeof value !== "string" || !RECALL_PATHS.includes(value)) {
-    pushIssue(issues, path2, `Expected one of: ${RECALL_PATHS.join(", ")}.`);
-    return void 0;
-  }
-  return value;
-}
-function parseOptionalUnifiedRecallMode(value, path2, issues) {
-  if (value === void 0) {
-    return void 0;
-  }
-  if (typeof value !== "string" || !UNIFIED_RECALL_MODES.includes(value)) {
-    pushIssue(issues, path2, `Expected one of: ${UNIFIED_RECALL_MODES.join(", ")}.`);
-    return void 0;
-  }
-  return value;
-}
-function parseOptionalRankingProfile(value, path2, issues) {
-  if (value === void 0) {
-    return void 0;
-  }
-  if (typeof value !== "string" || !RECALL_RANKING_PROFILES.includes(value)) {
-    pushIssue(issues, path2, `Expected one of: ${RECALL_RANKING_PROFILES.join(", ")}.`);
-    return void 0;
-  }
-  return value;
-}
-function parseOptionalExpiry(value, path2, issues) {
-  if (value === void 0) {
-    return void 0;
-  }
-  if (typeof value !== "string" || !EXPIRY_LEVELS.includes(value)) {
-    pushIssue(issues, path2, `Expected one of: ${EXPIRY_LEVELS.join(", ")}.`);
-    return void 0;
-  }
-  return value;
-}
-function parseOptionalClaimKeyStatus(value, path2, issues) {
-  if (value === void 0) {
-    return void 0;
-  }
-  if (typeof value !== "string" || !CLAIM_KEY_STATUSES.includes(value)) {
-    pushIssue(issues, path2, `Expected one of: ${CLAIM_KEY_STATUSES.join(", ")}.`);
-    return void 0;
-  }
-  return value;
-}
-function parseOptionalClaimKeySource(value, path2, issues) {
-  if (value === void 0) {
-    return void 0;
-  }
-  if (typeof value !== "string" || !CLAIM_KEY_SOURCES.includes(value)) {
-    pushIssue(issues, path2, `Expected one of: ${CLAIM_KEY_SOURCES.join(", ")}.`);
-    return void 0;
-  }
-  return value;
-}
-function parseOptionalClaimSupportMode(value, path2, issues) {
-  if (value === void 0) {
-    return void 0;
-  }
-  if (typeof value !== "string" || !CLAIM_SUPPORT_MODES.includes(value)) {
-    pushIssue(issues, path2, `Expected one of: ${CLAIM_SUPPORT_MODES.join(", ")}.`);
-    return void 0;
-  }
-  return value;
-}
-function parseOptionalStringArray(value, path2, issues) {
-  if (value === void 0) {
-    return void 0;
-  }
-  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
-    pushIssue(issues, path2, "Expected an array of strings.");
-    return void 0;
-  }
-  return value.map((item) => item.trim()).filter((item) => item.length > 0);
-}
-function parseOptionalEntryTypeArray(value, path2, issues) {
-  if (value === void 0) {
-    return void 0;
-  }
-  if (!Array.isArray(value)) {
-    pushIssue(issues, path2, "Expected an array.");
-    return void 0;
-  }
-  const parsed = [];
-  for (const [index, item] of value.entries()) {
-    const entryType = parseEntryType(item, `${path2}[${index}]`, issues);
-    if (entryType !== void 0) {
-      parsed.push(entryType);
-    }
-  }
-  return parsed;
-}
-function parseOptionalThreshold(value, path2, issues) {
-  if (value === void 0) {
-    return void 0;
-  }
-  if (typeof value !== "number" || Number.isNaN(value) || value < 0 || value > 1) {
-    pushIssue(issues, path2, "Expected a number from 0 to 1.");
-    return void 0;
-  }
-  return value;
-}
-function parseClaimSlotPolicyConfig(value, path2, issues) {
-  if (value === void 0) {
-    return void 0;
-  }
-  const config = parseObject(value, path2, issues);
-  if (config === void 0) {
-    return void 0;
-  }
-  pushUnexpectedFields(config, SLOT_POLICY_KEYS, path2, issues);
-  const attributeHeads = parseClaimSlotPolicyAttributeHeads(config.attributeHeads, `${path2}.attributeHeads`, issues);
-  return attributeHeads ? { attributeHeads } : void 0;
-}
-function parseClaimSlotPolicyAttributeHeads(value, path2, issues) {
-  if (value === void 0) {
-    return void 0;
-  }
-  if (!isRecord(value)) {
-    pushIssue(issues, path2, "Expected an object.");
-    return void 0;
-  }
-  const normalized = {};
-  for (const [rawKey, rawValue] of Object.entries(value)) {
-    const attributeHead = rawKey.trim().toLowerCase();
-    if (!/^[a-z0-9][a-z0-9_-]*$/.test(attributeHead)) {
-      pushIssue(issues, `${path2}.${rawKey}`, "Expected a canonical attribute-head label.");
-      continue;
-    }
-    if (typeof rawValue !== "string" || !CLAIM_SLOT_POLICIES.includes(rawValue)) {
-      pushIssue(issues, `${path2}.${attributeHead}`, `Expected one of: ${CLAIM_SLOT_POLICIES.join(", ")}.`);
-      continue;
-    }
-    normalized[attributeHead] = rawValue;
-  }
-  return Object.keys(normalized).length > 0 ? normalized : void 0;
-}
-function parseObject(value, path2, issues) {
-  if (!isRecord(value)) {
-    pushIssue(issues, path2, "Expected an object.");
-    return void 0;
-  }
-  return value;
-}
-function validatePathSpecificRequest(recallPath, recallRequest, unified, issues) {
-  const effectivePath = recallPath ?? "core";
-  if (effectivePath !== "unified") {
-    if (unified !== void 0) {
-      pushIssue(issues, "unified", 'The "unified" block is only allowed when recallPath is "unified".');
-    }
-    return;
-  }
-  if (recallRequest === void 0) {
-    return;
-  }
-  if (recallRequest.budget !== void 0) {
-    pushIssue(issues, "recallRequest.budget", 'This field is only supported when recallPath is "core".');
-  }
-  if (recallRequest.since !== void 0) {
-    pushIssue(issues, "recallRequest.since", 'This field is only supported when recallPath is "core".');
-  }
-  if (recallRequest.until !== void 0) {
-    pushIssue(issues, "recallRequest.until", 'This field is only supported when recallPath is "core".');
-  }
-  if (recallRequest.around !== void 0) {
-    pushIssue(issues, "recallRequest.around", 'This field is only supported when recallPath is "core".');
-  }
-  if (recallRequest.aroundRadius !== void 0) {
-    pushIssue(issues, "recallRequest.aroundRadius", 'This field is only supported when recallPath is "core".');
-  }
-  if (recallRequest.rankingProfile !== void 0) {
-    pushIssue(issues, "recallRequest.rankingProfile", 'This field is derived by unified recall and cannot be supplied when recallPath is "unified".');
-  }
-}
-function mapSandboxRequestDto(dto) {
-  if (dto === void 0) {
-    return void 0;
-  }
-  return {
-    root: dto.root,
-    preserve: dto.preserve
-  };
-}
-function mapFixtureEntryDto(dto) {
-  return {
-    id: dto.id,
-    type: dto.type,
-    subject: dto.subject,
-    content: dto.content,
-    importance: dto.importance,
-    expiry: dto.expiry,
-    tags: dto.tags,
-    source_file: dto.source_file,
-    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,
-    claim_key_source: dto.claim_key_source,
-    claim_support_source_kind: dto.claim_support_source_kind,
-    claim_support_locator: dto.claim_support_locator,
-    claim_support_observed_at: dto.claim_support_observed_at,
-    claim_support_mode: dto.claim_support_mode,
-    valid_from: dto.valid_from,
-    valid_to: dto.valid_to,
-    supersession_kind: dto.supersession_kind,
-    supersession_reason: dto.supersession_reason
-  };
-}
-function mapRecallRequestDto(dto) {
-  return {
-    text: dto.text,
-    limit: dto.limit,
-    threshold: dto.threshold,
-    budget: dto.budget,
-    types: dto.types,
-    tags: dto.tags,
-    since: dto.since,
-    until: dto.until,
-    around: dto.around,
-    aroundRadius: dto.aroundRadius,
-    asOf: dto.asOf,
-    rankingProfile: dto.rankingProfile
-  };
-}
-function mapUnifiedRequestDto(dto) {
-  if (dto === void 0) {
-    return void 0;
-  }
-  return {
-    mode: dto.mode,
-    sessionKey: dto.sessionKey,
-    memoryPolicy: dto.memoryPolicy !== void 0 ? {
-      slotPolicies: dto.memoryPolicy.slotPolicies
-    } : void 0
-  };
-}
-function mapCaseOptionsDto(dto) {
-  if (dto === void 0) {
-    return void 0;
-  }
-  return {
-    includeDiagnostics: dto.includeDiagnostics,
-    includeCandidates: dto.includeCandidates,
-    includeTimings: dto.includeTimings,
-    faultInjection: dto.faultInjection
-  };
-}
-
-// src/adapters/api/routes/internal-recall-eval.ts
-var INTERNAL_RECALL_EVAL_ROUTE = {
-  method: "POST",
-  path: "/internal/evals/recall/run"
-};
-function createInternalRecallEvalRoute(runner = runRecallEvalCase) {
-  return {
-    ...INTERNAL_RECALL_EVAL_ROUTE,
-    handler: async (request) => {
-      let validatedRequest;
-      try {
-        validatedRequest = await parseValidatedRequest(request);
-        const result = await runner(validatedRequest);
-        return jsonResponse(result, 200);
-      } catch (error) {
-        if (error instanceof RecallEvalRequestValidationError) {
-          return jsonResponse(
-            {
-              status: "error",
-              caseId: error.caseId,
-              error: {
-                code: "invalid_request",
-                message: error.message,
-                details: error.issues
-              }
-            },
-            400
-          );
-        }
-        return jsonResponse(
-          {
-            status: "error",
-            caseId: validatedRequest?.caseId,
-            error: {
-              code: "internal_error",
-              message: "Internal recall eval adapter error."
-            }
-          },
-          500
-        );
-      }
-    }
-  };
-}
-var parseJsonBody = async (request) => {
-  try {
-    return await request.json();
-  } catch {
-    throw new RecallEvalRequestValidationError([
-      {
-        path: "$",
-        message: "Request body must be valid JSON."
-      }
-    ]);
-  }
-};
-var parseValidatedRequest = async (request) => {
-  const payload = await parseJsonBody(request);
-  const requestDto = parseRecallEvalCaseRequest(payload);
-  return mapRecallEvalCaseRequestDto(requestDto);
-};
-var jsonResponse = (body, status) => new Response(JSON.stringify(body), {
-  status,
-  headers: {
-    "content-type": "application/json; charset=utf-8"
-  }
-});
-
-// src/adapters/api/internal-recall-eval-server.ts
-var DEFAULT_INTERNAL_RECALL_EVAL_HOST = "127.0.0.1";
-var DEFAULT_INTERNAL_RECALL_EVAL_PORT = 4010;
-async function startInternalRecallEvalServer(options = {}) {
-  const host2 = options.host ?? DEFAULT_INTERNAL_RECALL_EVAL_HOST;
-  const port2 = options.port ?? DEFAULT_INTERNAL_RECALL_EVAL_PORT;
-  const route = createInternalRecallEvalRoute(options.runner);
-  const server2 = createServer((request, response) => {
-    void handleRequest(request, response, route, host2, port2).catch(() => {
-      if (response.headersSent !== true) {
-        writeTextResponse(response, 500, "Internal server error.\n");
-        return;
-      }
-      response.destroy();
-    });
-  });
-  await listen(server2, port2, host2);
-  const address = server2.address();
-  if (address === null || typeof address === "string") {
-    await closeServer(server2);
-    throw new Error("Internal recall eval server did not expose a TCP address.");
-  }
-  return {
-    host: host2,
-    port: address.port,
-    routePath: route.path,
-    baseUrl: `http://${formatHostForUrl(host2)}:${address.port}`,
-    close: async () => {
-      await closeServer(server2);
-    }
-  };
-}
-var handleRequest = async (request, response, route, fallbackHost, fallbackPort) => {
-  const requestUrl = new URL(request.url ?? "/", `http://${formatHostForUrl(fallbackHost)}:${request.socket.localPort ?? fallbackPort}`);
-  if (requestUrl.pathname !== route.path) {
-    writeTextResponse(response, 404, "Not found.\n");
-    return;
-  }
-  if (request.method !== route.method) {
-    response.statusCode = 405;
-    response.setHeader("allow", route.method);
-    response.end();
-    return;
-  }
-  const body = await readBody(request);
-  const routeRequest = new Request(requestUrl, {
-    method: route.method,
-    headers: toHeaders(request),
-    body: body.length > 0 ? body : void 0
-  });
-  const routeResponse = await route.handler(routeRequest);
-  await writeRouteResponse(response, routeResponse);
-};
-var readBody = async (request) => {
-  const chunks = [];
-  for await (const chunk of request) {
-    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
-  }
-  return Buffer.concat(chunks);
-};
-var toHeaders = (request) => {
-  const headers = new Headers();
-  for (const [name, value] of Object.entries(request.headers)) {
-    if (value === void 0) {
-      continue;
-    }
-    if (Array.isArray(value)) {
-      for (const item of value) {
-        headers.append(name, item);
-      }
-      continue;
-    }
-    headers.set(name, value);
-  }
-  return headers;
-};
-var writeRouteResponse = async (response, routeResponse) => {
-  response.statusCode = routeResponse.status;
-  for (const [name, value] of routeResponse.headers) {
-    response.setHeader(name, value);
-  }
-  const body = Buffer.from(await routeResponse.arrayBuffer());
-  response.end(body);
-};
-var writeTextResponse = (response, status, body) => {
-  response.statusCode = status;
-  response.setHeader("content-type", "text/plain; charset=utf-8");
-  response.end(body);
-};
-var listen = async (server2, port2, host2) => {
-  await new Promise((resolve, reject) => {
-    const onError = (error) => {
-      server2.off("listening", onListening);
-      reject(error);
-    };
-    const onListening = () => {
-      server2.off("error", onError);
-      resolve();
-    };
-    server2.once("error", onError);
-    server2.once("listening", onListening);
-    server2.listen(port2, host2);
-  });
-};
-var closeServer = async (server2) => {
-  if (server2.listening !== true) {
-    return;
-  }
-  await new Promise((resolve, reject) => {
-    server2.close((error) => {
-      if (error) {
-        reject(error);
-        return;
-      }
-      resolve();
-    });
-  });
-};
-var formatHostForUrl = (host2) => {
-  if (host2.includes(":") && host2.startsWith("[") !== true) {
-    return `[${host2}]`;
-  }
-  return host2;
-};
-
-// src/internal-recall-eval-server.ts
-var HOST_ENV_NAME = "AGENR_INTERNAL_RECALL_EVAL_HOST";
-var PORT_ENV_NAME = "AGENR_INTERNAL_RECALL_EVAL_PORT";
-var host = resolveHost(process.env[HOST_ENV_NAME]);
-var port = resolvePort(process.env[PORT_ENV_NAME]);
-var server = await startInternalRecallEvalServer({ host, port });
-console.log(`Internal recall eval dev server listening at ${server.baseUrl}${server.routePath}`);
-console.log("Serving only the existing internal recall eval route for local agenr-evals runs.");
-installSignalHandler("SIGINT");
-installSignalHandler("SIGTERM");
-function installSignalHandler(signal) {
-  process.once(signal, () => {
-    void shutdown(signal);
-  });
-}
-var shuttingDown = false;
-async function shutdown(signal) {
-  if (shuttingDown === true) {
-    return;
-  }
-  shuttingDown = true;
-  console.log(`Received ${signal}. Shutting down internal recall eval dev server.`);
-  try {
-    await server.close();
-  } finally {
-    process.exit(0);
-  }
-}
-function resolveHost(value) {
-  const trimmed = value?.trim();
-  if (!trimmed) {
-    return DEFAULT_INTERNAL_RECALL_EVAL_HOST;
-  }
-  return trimmed;
-}
-function resolvePort(value) {
-  const trimmed = value?.trim();
-  if (!trimmed) {
-    return DEFAULT_INTERNAL_RECALL_EVAL_PORT;
-  }
-  if (/^\d+$/u.test(trimmed) !== true) {
-    throw new Error(`${PORT_ENV_NAME} must be an integer between 0 and 65535.`);
-  }
-  const parsed = Number.parseInt(trimmed, 10);
-  if (!Number.isInteger(parsed) || parsed < 0 || parsed > 65535) {
-    throw new Error(`${PORT_ENV_NAME} must be an integer between 0 and 65535.`);
-  }
-  return parsed;
-}
+import "./chunk-P5SB75FK.js";
+import "./chunk-ZYADFKX3.js";
+import "./chunk-GELCEVFA.js";
+import "./chunk-575MUIW5.js";
+import "./chunk-ELR2HSVC.js";
+import "./chunk-5LADPJ4C.js";