@lucern/sdk 0.2.0-alpha.6 → 0.2.0-alpha.7

package/src/contextPackCompiler.ts

@@ -0,0 +1,828 @@
+import {
+  type ContextCompilationMode,
+  type ContextPackDeltaReport,
+  type ContextPackV1,
+  CONTEXT_PACK_SCHEMA_VERSION,
+  DEFAULT_COMPILATION_MODE,
+  DEFAULT_ENTITY_LIMIT,
+  MAX_ENTITY_LIMIT,
+  type PackWeightOverride,
+  type ContextRankingProfile,
+} from "./contracts/context-pack.contract";
+import {
+  buildInjectionPlan,
+  type EntityCandidate,
+  parseTokenBudget,
+  rankContextSection,
+  rankEntities,
+  resolveEffectiveWeights,
+} from "@lucern/reasoning-kernel/compat/contextPackPolicy";
+import { validateContextPackSchema } from "./contextPackSchema";
+
+export type ContextPackTopicRow = {
+  _id: string;
+  name?: string;
+  parentTopicId?: string;
+  depth?: number;
+  status?: string;
+  updatedAt?: number;
+  createdAt?: number;
+  generatedAt?: number;
+};
+
+type ContextPackBeliefRow = {
+  _id: string;
+  canonicalText?: string;
+  confidence?: number;
+  beliefType?: string;
+  status?: string;
+  metadata?: Record<string, unknown>;
+  updatedAt?: number;
+  createdAt?: number;
+};
+
+type ContextPackQuestionRow = {
+  _id: string;
+  canonicalText?: string;
+  status?: string;
+  metadata?: Record<string, unknown>;
+  updatedAt?: number;
+  createdAt?: number;
+};
+
+type ContextPackEvidenceRow = {
+  _id: string;
+  canonicalText?: string;
+  sourceUrl?: string;
+  metadata?: Record<string, unknown>;
+  updatedAt?: number;
+  createdAt?: number;
+};
+
+type ContextPackContradictionRow = {
+  _id?: string;
+  globalId?: string;
+  weight?: number;
+  context?: string;
+  description?: string;
+  summary?: string;
+  updatedAt?: number;
+  createdAt?: number;
+};
+
+type ContextPackEntityRow = {
+  _id: string;
+  nodeType?: string;
+  title?: string;
+  canonicalText?: string;
+  connectedBeliefCount?: number;
+  connectedEvidenceCount?: number;
+  metadata?: Record<string, unknown>;
+  updatedAt?: number;
+};
+
+type ContextPackFailureRow = {
+  _id: string;
+  canonicalText?: string;
+  metadata?: Record<string, unknown>;
+  updatedAt?: number;
+  createdAt?: number;
+};
+
+export type CompileContextPackPlan = {
+  topicId: string;
+  queryText?: string;
+  tokens: string[];
+  limit: number;
+  rankingProfile: ContextRankingProfile;
+  tokenBudget: number;
+  descendantDepth: number;
+  includeEntities: boolean;
+  compilationMode: ContextCompilationMode;
+  includeFailures: boolean;
+  worktreeId?: string;
+  sessionId?: string;
+  packWeightOverrides?: PackWeightOverride[];
+  effectiveWeights: ReturnType<typeof resolveEffectiveWeights>;
+  scopedTopicIds: string[];
+};
+
+export type CompileContextPackPlanInput = {
+  args: Record<string, unknown> | undefined;
+  topic: ContextPackTopicRow;
+  allTopics: ContextPackTopicRow[];
+};
+
+export type CompileContextPackSnapshot = {
+  topic: ContextPackTopicRow;
+  plan: CompileContextPackPlan;
+  beliefs: ContextPackBeliefRow[];
+  questions: ContextPackQuestionRow[];
+  evidence: ContextPackEvidenceRow[];
+  contradictions: ContextPackContradictionRow[];
+  entities: ContextPackEntityRow[];
+  failures?: ContextPackFailureRow[];
+};
+
+function assertContextPackSchema(payload: unknown): void {
+  const result = validateContextPackSchema(payload);
+  if (!result.valid) {
+    throw new Error(
+      `Invalid context pack payload: ${result.errors.join("; ")}`
+    );
+  }
+}
+
+function asStringArray(value: unknown): string[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value
+    .map((entry) => (typeof entry === "string" ? entry.trim() : ""))
+    .filter((entry) => entry.length > 0);
+}
+
+function toPositiveInt(value: unknown, fallback: number, max: number): number {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return fallback;
+  }
+  const floored = Math.floor(value);
+  return Math.max(1, Math.min(floored, max));
+}
+
+function normalizeQueryTokens(query: string | undefined): string[] {
+  if (!query) {
+    return [];
+  }
+  return query
+    .toLowerCase()
+    .split(/[^a-z0-9]+/)
+    .map((token) => token.trim())
+    .filter((token) => token.length >= 2);
+}
+
+function parseRankingProfile(value: unknown): ContextRankingProfile {
+  return value === "baseline_v1" ? "baseline_v1" : "weighted_v1";
+}
+
+function beliefTypeOf(node: ContextPackBeliefRow): string {
+  if (typeof node.beliefType === "string") {
+    return node.beliefType;
+  }
+  const metadata = (node.metadata || {}) as Record<string, unknown>;
+  if (typeof metadata.beliefType === "string") {
+    return metadata.beliefType;
+  }
+  return "";
+}
+
+function questionStatusOf(node: ContextPackQuestionRow): string {
+  const metadata = (node.metadata || {}) as Record<string, unknown>;
+  const direct = typeof node.status === "string" ? node.status : "";
+  const questionStatus =
+    typeof metadata.questionStatus === "string" ? metadata.questionStatus : "";
+  return (questionStatus || direct || "open").toLowerCase();
+}
+
+function isOpenQuestion(status: string): boolean {
+  return ![
+    "answered",
+    "archived",
+    "closed",
+    "resolved",
+    "resolved_support",
+    "resolved_contra",
+    "belief_forked",
+  ].includes(status);
+}
+
+function metadataText(payload: Record<string, unknown>): string {
+  return JSON.stringify(payload).toLowerCase();
+}
+
+function collectTopicNeighborhood(
+  topics: ContextPackTopicRow[],
+  rootTopicId: string,
+  maxDescendantDepth = 2
+): string[] {
+  const byId = new Map<string, ContextPackTopicRow>();
+  const children = new Map<string, string[]>();
+  for (const topic of topics) {
+    const id = String(topic._id);
+    byId.set(id, topic);
+    if (!children.has(id)) {
+      children.set(id, []);
+    }
+  }
+  for (const topic of topics) {
+    if (!topic.parentTopicId) {
+      continue;
+    }
+    const parent = String(topic.parentTopicId);
+    const id = String(topic._id);
+    const list = children.get(parent) || [];
+    list.push(id);
+    children.set(parent, list);
+  }
+
+  const selected = new Set<string>([rootTopicId]);
+
+  let cursor = byId.get(rootTopicId);
+  while (cursor?.parentTopicId) {
+    const parentId = String(cursor.parentTopicId);
+    if (selected.has(parentId)) {
+      break;
+    }
+    selected.add(parentId);
+    cursor = byId.get(parentId);
+  }
+
+  const queue: Array<{ id: string; depth: number }> = [
+    { id: rootTopicId, depth: 0 },
+  ];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current || current.depth >= maxDescendantDepth) {
+      continue;
+    }
+    for (const childId of children.get(current.id) || []) {
+      if (!selected.has(childId)) {
+        selected.add(childId);
+      }
+      queue.push({ id: childId, depth: current.depth + 1 });
+    }
+  }
+
+  return Array.from(selected);
+}
+
+function dedupeById<T extends { _id?: string }>(rows: T[]): T[] {
+  const seen = new Set<string>();
+  const output: T[] = [];
+  for (const row of rows) {
+    const id = row?._id ? String(row._id) : "";
+    if (!id || seen.has(id)) {
+      continue;
+    }
+    seen.add(id);
+    output.push(row);
+  }
+  return output;
+}
+
+function candidateTimestamp(candidate: unknown): number {
+  if (!candidate || typeof candidate !== "object") {
+    return 0;
+  }
+  const record = candidate as Record<string, unknown>;
+  const timestamps = [record.updatedAt, record.createdAt, record.generatedAt].filter(
+    (value): value is number => typeof value === "number" && Number.isFinite(value)
+  );
+  return timestamps.length > 0 ? Math.max(...timestamps) : 0;
+}
+
+function resolveReferenceTimeMs(...collections: unknown[][]): number {
+  let maxTimestamp = 0;
+  for (const collection of collections) {
+    for (const item of collection) {
+      const timestamp = candidateTimestamp(item);
+      if (timestamp > maxTimestamp) {
+        maxTimestamp = timestamp;
+      }
+    }
+  }
+  return maxTimestamp;
+}
+
+export function planContextPackCompilation(
+  input: CompileContextPackPlanInput
+): CompileContextPackPlan {
+  const args = input.args ?? {};
+  const topicId = String(input.topic._id);
+  const queryText =
+    typeof args.query === "string" && args.query.trim().length > 0
+      ? args.query.trim()
+      : undefined;
+  const tokens = normalizeQueryTokens(queryText);
+  const limit = toPositiveInt(args.limit, 8, 25);
+  const rankingProfile = parseRankingProfile(
+    typeof args.ranking === "string" ? args.ranking : args.rankingProfile
+  );
+  const tokenBudget = parseTokenBudget(
+    typeof args.budget === "number" ? args.budget : args.tokenBudget,
+    1800
+  );
+  const topicDepth =
+    typeof input.topic.depth === "number" && Number.isFinite(input.topic.depth)
+      ? input.topic.depth
+      : 0;
+  const requestedMaxDepth =
+    typeof args.maxDepth === "number" && Number.isFinite(args.maxDepth)
+      ? Math.max(1, Math.min(Math.floor(args.maxDepth), 6))
+      : undefined;
+  const descendantDepth = requestedMaxDepth ?? (topicDepth <= 1 ? 4 : 2);
+  const includeEntities = args.includeEntities !== false;
+  const compilationMode: ContextCompilationMode =
+    args.mode === "delta" ? "delta" : DEFAULT_COMPILATION_MODE;
+  const includeFailures =
+    compilationMode === "delta" || args.includeFailures === true;
+  const worktreeId =
+    typeof args.worktreeId === "string" && args.worktreeId.trim().length > 0
+      ? args.worktreeId.trim()
+      : undefined;
+  const sessionId =
+    typeof args.sessionId === "string" && args.sessionId.trim().length > 0
+      ? args.sessionId.trim()
+      : undefined;
+  const packWeightOverrides = Array.isArray(args.packWeightOverrides)
+    ? (args.packWeightOverrides as PackWeightOverride[])
+    : undefined;
+  const effectiveWeights = resolveEffectiveWeights(packWeightOverrides);
+
+  let scopedTopicIds = collectTopicNeighborhood(
+    input.allTopics,
+    topicId,
+    descendantDepth
+  );
+
+  const allowedTopicIds = asStringArray(args.allowedTopicIds);
+  if (allowedTopicIds.length > 0) {
+    const allowedSet = new Set(allowedTopicIds);
+    if (!allowedSet.has(topicId)) {
+      throw new Error(`Access denied to compile context for topic ${topicId}.`);
+    }
+    scopedTopicIds = scopedTopicIds.filter((id) => allowedSet.has(id));
+  }
+
+  return {
+    topicId,
+    ...(queryText ? { queryText } : {}),
+    tokens,
+    limit,
+    rankingProfile,
+    tokenBudget,
+    descendantDepth,
+    includeEntities,
+    compilationMode,
+    includeFailures,
+    ...(worktreeId ? { worktreeId } : {}),
+    ...(sessionId ? { sessionId } : {}),
+    ...(packWeightOverrides ? { packWeightOverrides } : {}),
+    effectiveWeights,
+    scopedTopicIds,
+  };
+}
+
+export function compileContextPackFromSnapshot(
+  snapshot: CompileContextPackSnapshot
+): ContextPackV1 {
+  const uniqueBeliefs = dedupeById(snapshot.beliefs);
+  const uniqueQuestions = dedupeById(snapshot.questions);
+  const uniqueEvidence = dedupeById(snapshot.evidence);
+  const uniqueContradictions = dedupeById(snapshot.contradictions);
+  const referenceTimeMs =
+    resolveReferenceTimeMs(
+      [snapshot.topic],
+      uniqueBeliefs,
+      uniqueQuestions,
+      uniqueEvidence,
+      uniqueContradictions,
+      snapshot.entities
+    ) || 0;
+
+  const rankOptions = {
+    effectiveWeights: snapshot.plan.effectiveWeights,
+    includeJustifications: snapshot.plan.compilationMode === "delta",
+    referenceTimeMs,
+  };
+
+  const invariantCandidates = uniqueBeliefs
+    .filter((belief) => beliefTypeOf(belief).toLowerCase() === "invariant")
+    .map((belief) => ({
+      nodeId: String(belief._id),
+      canonicalText: String(belief.canonicalText || ""),
+      confidence:
+        typeof belief.confidence === "number" ? belief.confidence : null,
+      beliefType: beliefTypeOf(belief) || "invariant",
+      updatedAt: belief.updatedAt || belief.createdAt || null,
+    }));
+
+  const invariants = rankContextSection(
+    "invariants",
+    invariantCandidates.map((candidate) => ({
+      ...candidate,
+      id: candidate.nodeId,
+      text: `${candidate.canonicalText} ${candidate.beliefType}`,
+    })),
+    snapshot.plan.tokens,
+    snapshot.plan.limit,
+    snapshot.plan.rankingProfile,
+    rankOptions
+  ).map((row) => ({
+    nodeId: row.nodeId,
+    canonicalText: row.canonicalText,
+    confidence: row.confidence,
+    beliefType: row.beliefType,
+    score: row.score,
+    ...(row.justification ? { justification: row.justification } : {}),
+  }));
+
+  const activeBeliefCandidates = uniqueBeliefs
+    .filter((belief) => (belief.status || "active") !== "archived")
+    .map((belief) => ({
+      nodeId: String(belief._id),
+      canonicalText: String(belief.canonicalText || ""),
+      confidence:
+        typeof belief.confidence === "number" ? belief.confidence : null,
+      beliefType: beliefTypeOf(belief) || null,
+      status: belief.status || "active",
+      updatedAt: belief.updatedAt || belief.createdAt || null,
+      metadataText:
+        belief.metadata && typeof belief.metadata === "object"
+          ? metadataText(belief.metadata)
+          : "",
+    }));
+
+  const activeBeliefs = rankContextSection(
+    "activeBeliefs",
+    activeBeliefCandidates.map((candidate) => ({
+      ...candidate,
+      id: candidate.nodeId,
+      text: `${candidate.canonicalText} ${candidate.metadataText}`,
+    })),
+    snapshot.plan.tokens,
+    snapshot.plan.limit,
+    snapshot.plan.rankingProfile,
+    rankOptions
+  ).map((row) => ({
+    nodeId: row.nodeId,
+    canonicalText: row.canonicalText,
+    confidence: row.confidence,
+    beliefType: row.beliefType,
+    status: row.status,
+    updatedAt: row.updatedAt,
+    score: row.score,
+    ...(row.justification ? { justification: row.justification } : {}),
+  }));
+
+  const openQuestionCandidates = uniqueQuestions
+    .map((question) => {
+      const status = questionStatusOf(question);
+      const metadata =
+        question.metadata && typeof question.metadata === "object"
+          ? question.metadata
+          : {};
+      return {
+        questionId: String(question._id),
+        text: String(question.canonicalText || ""),
+        status,
+        priority:
+          typeof metadata.priority === "string" ? metadata.priority : "medium",
+        updatedAt: question.updatedAt || question.createdAt || null,
+        metadataText: metadataText(metadata),
+      };
+    })
+    .filter((row) => isOpenQuestion(row.status));
+
+  const openQuestions = rankContextSection(
+    "openQuestions",
+    openQuestionCandidates.map((candidate) => ({
+      ...candidate,
+      id: candidate.questionId,
+      text: `${candidate.text} ${candidate.metadataText}`,
+    })),
+    snapshot.plan.tokens,
+    snapshot.plan.limit,
+    snapshot.plan.rankingProfile,
+    rankOptions
+  ).map((row) => ({
+    questionId: row.questionId,
+    text: row.text,
+    status: row.status,
+    priority: row.priority,
+    updatedAt: row.updatedAt,
+    score: row.score,
+    ...(row.justification ? { justification: row.justification } : {}),
+  }));
+
+  const evidenceCandidates = uniqueEvidence.map((item) => {
+    const metadata =
+      item.metadata && typeof item.metadata === "object" ? item.metadata : {};
+    return {
+      nodeId: String(item._id),
+      canonicalText: String(item.canonicalText || ""),
+      sourceUrl:
+        (typeof metadata.sourceUrl === "string" && metadata.sourceUrl) ||
+        (typeof item.sourceUrl === "string" && item.sourceUrl) ||
+        null,
+      kind:
+        (typeof metadata.kind === "string" && metadata.kind) || "observation",
+      createdAt: item.createdAt || null,
+      updatedAt: item.updatedAt || item.createdAt || null,
+      metadataText: metadataText(metadata),
+    };
+  });
+
+  const recentEvidence = rankContextSection(
+    "recentEvidence",
+    evidenceCandidates.map((candidate) => ({
+      ...candidate,
+      id: candidate.nodeId,
+      text: `${candidate.canonicalText} ${candidate.metadataText}`,
+    })),
+    snapshot.plan.tokens,
+    snapshot.plan.limit,
+    snapshot.plan.rankingProfile,
+    rankOptions
+  ).map((row) => ({
+    nodeId: row.nodeId,
+    canonicalText: row.canonicalText,
+    sourceUrl: row.sourceUrl,
+    kind: row.kind,
+    createdAt: row.createdAt,
+    score: row.score,
+    ...(row.justification ? { justification: row.justification } : {}),
+  }));
+
+  const contradictionCandidates = uniqueContradictions.map((row) => {
+    const weight = typeof row.weight === "number" ? row.weight : 0;
+    const severity =
+      weight <= -0.9
+        ? "critical"
+        : weight <= -0.7
+          ? "high"
+          : weight <= -0.5
+            ? "medium"
+            : "low";
+    return {
+      contradictionId: String(row._id || row.globalId || ""),
+      severity,
+      status: "active",
+      description: row.context || row.description || row.summary || "",
+      updatedAt: row.updatedAt || row.createdAt || null,
+    };
+  });
+
+  const contradictions = rankContextSection(
+    "contradictions",
+    contradictionCandidates.map((candidate) => ({
+      ...candidate,
+      id: candidate.contradictionId,
+      text: `${candidate.description} ${candidate.severity}`,
+    })),
+    snapshot.plan.tokens,
+    snapshot.plan.limit,
+    snapshot.plan.rankingProfile,
+    rankOptions
+  ).map((row) => ({
+    contradictionId: row.contradictionId,
+    severity: row.severity,
+    status: row.status,
+    description: row.description,
+    score: row.score,
+    ...(row.justification ? { justification: row.justification } : {}),
+  }));
+
+  const entityCandidates: EntityCandidate[] = snapshot.entities.map((row) => ({
+    nodeId: String(row._id),
+    entityType: String(row.nodeType || ""),
+    title: String(row.title || ""),
+    canonicalText: String(row.canonicalText || ""),
+    connectedBeliefCount:
+      typeof row.connectedBeliefCount === "number" ? row.connectedBeliefCount : 0,
+    connectedEvidenceCount:
+      typeof row.connectedEvidenceCount === "number"
+        ? row.connectedEvidenceCount
+        : 0,
+    metadata:
+      row.metadata && typeof row.metadata === "object" ? row.metadata : {},
+    updatedAt: row.updatedAt || null,
+  }));
+
+  const entityLimit = toPositiveInt(
+    snapshot.plan.limit,
+    DEFAULT_ENTITY_LIMIT,
+    MAX_ENTITY_LIMIT
+  );
+  const rankedEntities = snapshot.plan.includeEntities
+    ? rankEntities(entityCandidates, snapshot.plan.tokens, entityLimit).map(
+        (row) => ({
+          nodeId: row.nodeId,
+          entityType: row.entityType,
+          title: row.title,
+          connectedBeliefCount: row.connectedBeliefCount,
+          connectedEvidenceCount: row.connectedEvidenceCount,
+          score: row.score,
+          ...(Object.keys(row.metadata).length > 0
+            ? { metadata: row.metadata }
+            : {}),
+        })
+      )
+    : undefined;
+
+  let failureContext:
+    | {
+        failures: Array<{
+          attemptId: string;
+          approach: string;
+          outcome: string;
+          recordedAt: number;
+          score: number;
+        }>;
+        suppressedIds: string[];
+      }
+    | undefined;
+
+  if (snapshot.plan.includeFailures && snapshot.failures) {
+    const allFailures = snapshot.failures.filter((node) => {
+      const metadata = (node.metadata || {}) as Record<string, unknown>;
+      return metadata.failedApproach === true || metadata.isFailedAttempt === true;
+    });
+
+    const rankedFailures = rankContextSection(
+      "recentEvidence",
+      allFailures.map((node) => ({
+        id: String(node._id),
+        text: String(node.canonicalText || ""),
+        createdAt: node.createdAt || null,
+        updatedAt: node.updatedAt || node.createdAt || null,
+      })),
+      snapshot.plan.tokens,
+      10,
+      snapshot.plan.rankingProfile,
+      rankOptions
+    );
+
+    const failures = rankedFailures.map((row) => {
+      const original = allFailures.find((node) => String(node._id) === row.id);
+      const metadata = (original?.metadata || {}) as Record<string, unknown>;
+      return {
+        attemptId: row.id,
+        approach: String(row.text || ""),
+        outcome: String(metadata.errorMessage || "Failed"),
+        recordedAt: (row.createdAt as number) || referenceTimeMs || 0,
+        score: row.score,
+      };
+    });
+
+    const failureTexts = new Set(
+      failures.map((failure) => failure.approach.toLowerCase().slice(0, 100))
+    );
+    const suppressionIds = new Set<string>();
+
+    if (snapshot.plan.sessionId && failureTexts.size > 0) {
+      for (const evidenceRow of recentEvidence) {
+        const evidenceText = evidenceRow.canonicalText.toLowerCase().slice(0, 100);
+        for (const failureText of failureTexts) {
+          if (
+            evidenceText.includes(failureText) ||
+            failureText.includes(evidenceText)
+          ) {
+            suppressionIds.add(evidenceRow.nodeId);
+            break;
+          }
+        }
+      }
+    }
+
+    if (failures.length > 0) {
+      failureContext = {
+        failures,
+        suppressedIds: Array.from(suppressionIds),
+      };
+    }
+  }
+
+  const suppressionSet = new Set(failureContext?.suppressedIds || []);
+  const effectiveEvidence =
+    suppressionSet.size > 0
+      ? recentEvidence.filter((row) => !suppressionSet.has(row.nodeId))
+      : recentEvidence;
+  const suppressedEvidenceIds =
+    suppressionSet.size > 0
+      ? recentEvidence
+          .filter((row) => suppressionSet.has(row.nodeId))
+          .map((row) => row.nodeId)
+      : [];
+
+  const summary = {
+    totalBeliefs: uniqueBeliefs.length,
+    invariants: invariants.length,
+    openQuestions: openQuestions.length,
+    evidenceItems: uniqueEvidence.length,
+    contradictions: contradictions.length,
+    ...(rankedEntities ? { relatedEntities: rankedEntities.length } : {}),
+    scopedTopics: snapshot.plan.scopedTopicIds.length,
+    descendantDepth: snapshot.plan.descendantDepth,
+    query: snapshot.plan.queryText || null,
+  };
+
+  const injectionPolicy = buildInjectionPlan({
+    tokenBudget: snapshot.plan.tokenBudget,
+    invariants: invariants.map((row) => ({
+      nodeId: row.nodeId,
+      canonicalText: row.canonicalText,
+      score: row.score,
+    })),
+    activeBeliefs: activeBeliefs.map((row) => ({
+      nodeId: row.nodeId,
+      canonicalText: row.canonicalText,
+      score: row.score,
+    })),
+    openQuestions: openQuestions.map((row) => ({
+      questionId: row.questionId,
+      text: row.text,
+      score: row.score,
+    })),
+    recentEvidence: effectiveEvidence.map((row) => ({
+      nodeId: row.nodeId,
+      canonicalText: row.canonicalText,
+      score: row.score,
+    })),
+    contradictions: contradictions.map((row) => ({
+      contradictionId: row.contradictionId,
+      description: row.description,
+      score: row.score,
+    })),
+    trackExclusions: snapshot.plan.compilationMode === "delta",
+  });
+
+  const contextNarrative = [
+    "Prefer invariant beliefs as hard constraints while reasoning over this scope.",
+    "Treat open questions as unresolved work items and avoid claiming closure without evidence.",
+    "Use recent evidence for implementation context before creating new beliefs.",
+    "When contradictions exist, resolve explicitly (fork, lower confidence, or gather counter-evidence).",
+    `Apply injection token budget of ${injectionPolicy.tokenBudget} with section quotas before prompt assembly.`,
+  ];
+
+  const deltaReport: ContextPackDeltaReport | undefined =
+    snapshot.plan.compilationMode === "delta" && snapshot.plan.worktreeId
+      ? {
+          changedItems: [] as ContextPackDeltaReport["changedItems"],
+          verificationObligations:
+            [] as ContextPackDeltaReport["verificationObligations"],
+          referencePoint: snapshot.plan.worktreeId,
+        }
+      : undefined;
+
+  const excludedItems = [
+    ...(injectionPolicy.excludedItems || []),
+    ...suppressedEvidenceIds.map((id) => ({
+      id,
+      section: "recentEvidence" as const,
+      reason: "anti_repetition" as const,
+      score: recentEvidence.find((row) => row.nodeId === id)?.score ?? 0,
+    })),
+  ];
+
+  const result = {
+    schemaVersion: CONTEXT_PACK_SCHEMA_VERSION,
+    topicId: snapshot.plan.topicId,
+    topicName: snapshot.topic.name || "Untitled Topic",
+    scopedTopicIds: snapshot.plan.scopedTopicIds,
+    generatedAt: referenceTimeMs,
+    rankingProfile: snapshot.plan.rankingProfile,
+    summary,
+    invariants,
+    activeBeliefs,
+    openQuestions,
+    recentEvidence: effectiveEvidence,
+    contradictions,
+    ...(rankedEntities ? { relatedEntities: rankedEntities } : {}),
+    contextNarrative,
+    injectionPolicy: {
+      ...injectionPolicy,
+      ...(excludedItems.length > 0 ? { excludedItems } : {}),
+    },
+    diagnostics: {
+      itemsScored:
+        invariantCandidates.length +
+        activeBeliefCandidates.length +
+        openQuestionCandidates.length +
+        evidenceCandidates.length +
+        contradictionCandidates.length +
+        entityCandidates.length,
+      tokenBudgetUtilization:
+        injectionPolicy.tokenBudget === 0
+          ? 0
+          : Number(
+              (
+                injectionPolicy.estimatedTokens / injectionPolicy.tokenBudget
+              ).toFixed(4)
+            ),
+      referenceTimeMs,
+    },
+    ...(snapshot.plan.compilationMode !== "standard"
+      ? { compilationMode: snapshot.plan.compilationMode }
+      : {}),
+    ...(failureContext ? { failureContext } : {}),
+    ...(deltaReport ? { deltaReport } : {}),
+    ...(snapshot.plan.packWeightOverrides &&
+    snapshot.plan.packWeightOverrides.length > 0
+      ? { appliedWeightOverrides: snapshot.plan.packWeightOverrides }
+      : {}),
+  };
+
+  assertContextPackSchema(result);
+  return result as ContextPackV1;
+}