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

package/src/contextPackCompiler.ts

@@ -1,828 +0,0 @@
-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;
-}