@lucern/sdk 0.2.0-alpha.4 → 0.2.0-alpha.5

package/dist/lib/platform/sdk/contextClient.d.ts

@@ -0,0 +1,21 @@
+import { type GatewayClientConfig } from "./coreClient";
+import type { CompileContextInput, PublicCompiledContext } from "./contextTypes";
+/** Configuration for the context client. */
+export type ContextClientConfig = GatewayClientConfig;
+/** Alias for the compiled context payload returned by the gateway. */
+export type CompileContextResponse = PublicCompiledContext;
+/**
+ * Create the context client for compiling reasoning context packs.
+ * @param config - Gateway transport configuration.
+ * @returns An object with a `compile` method for building context packs.
+ */
+export declare function createContextClient(config?: ContextClientConfig): {
+    /**
+     * Compile a focused reasoning context pack for a topic scope.
+     * @param topicId - The topic to compile context for.
+     * @param input - Optional compile parameters (query, budget, ranking, etc.).
+     * @returns The compiled context payload with beliefs, questions, and evidence.
+     */
+    compile(topicId: string, input?: CompileContextInput): Promise<import("./coreClient").PlatformGatewaySuccess<PublicCompiledContext>>;
+};
+export type { CompileContextInput, PublicCompiledContext } from "./contextTypes";

package/dist/lib/platform/sdk/contextClient.js

@@ -0,0 +1,86 @@
+import { createGatewayRequestClient, } from "./coreClient.js";
+function cleanString(value) {
+    return typeof value === "string" && value.trim().length > 0
+        ? value.trim()
+        : undefined;
+}
+function cleanNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function cleanBoolean(value) {
+    return typeof value === "boolean" ? value : undefined;
+}
+function buildCompileContextRequest(topicId, input = {}) {
+    const payload = { topicId };
+    const query = cleanString(input.query);
+    if (query) {
+        payload.query = query;
+    }
+    const budget = cleanNumber(input.budget) ?? cleanNumber(input.tokenBudget);
+    if (budget !== undefined) {
+        payload.budget = budget;
+    }
+    const ranking = cleanString(input.ranking) ?? cleanString(input.rankingProfile);
+    if (ranking) {
+        payload.ranking = ranking;
+    }
+    const limit = cleanNumber(input.limit);
+    if (limit !== undefined) {
+        payload.limit = limit;
+    }
+    const maxDepth = cleanNumber(input.maxDepth);
+    if (maxDepth !== undefined) {
+        payload.maxDepth = maxDepth;
+    }
+    const includeEntities = cleanBoolean(input.includeEntities);
+    if (includeEntities !== undefined) {
+        payload.includeEntities = includeEntities;
+    }
+    const mode = cleanString(input.mode);
+    if (mode) {
+        payload.mode = mode;
+    }
+    const includeFailures = cleanBoolean(input.includeFailures);
+    if (includeFailures !== undefined) {
+        payload.includeFailures = includeFailures;
+    }
+    const worktreeId = cleanString(input.worktreeId);
+    if (worktreeId) {
+        payload.worktreeId = worktreeId;
+    }
+    const sessionId = cleanString(input.sessionId);
+    if (sessionId) {
+        payload.sessionId = sessionId;
+    }
+    if (Array.isArray(input.packWeightOverrides) && input.packWeightOverrides.length > 0) {
+        payload.packWeightOverrides = input.packWeightOverrides;
+    }
+    return {
+        path: "/api/platform/v1/context/compile",
+        method: "POST",
+        body: payload,
+    };
+}
+/**
+ * Create the context client for compiling reasoning context packs.
+ * @param config - Gateway transport configuration.
+ * @returns An object with a `compile` method for building context packs.
+ */
+export function createContextClient(config = {}) {
+    const gateway = createGatewayRequestClient(config);
+    return {
+        /**
+         * Compile a focused reasoning context pack for a topic scope.
+         * @param topicId - The topic to compile context for.
+         * @param input - Optional compile parameters (query, budget, ranking, etc.).
+         * @returns The compiled context payload with beliefs, questions, and evidence.
+         */
+        async compile(topicId, input = {}) {
+            const request = buildCompileContextRequest(topicId, input);
+            return gateway.request({
+                ...request,
+                body: request.body,
+            });
+        },
+    };
+}

package/dist/{lucern/packages/domain-context/src/context-pack-compiler.d.ts → lib/platform/sdk/contextPackCompiler.d.ts}

@@ -1,6 +1,5 @@
-import { type ContextCompilationMode, type ContextPackV1, type PackWeightOverride } from "../../../contracts/src/context-pack.contract";
-import { resolveEffectiveWeights } from "../../../mcp-server/src/context-pack-policy";
-import { type ContextRankingProfile } from "../../../mcp-server/src/context-pack-schema";
+import { type ContextCompilationMode, type ContextPackV1, type PackWeightOverride, type ContextRankingProfile } from "./contracts/context-pack.contract";
+import { resolveEffectiveWeights } from "../../convex-kernel/src/compat/contextPackPolicy";
 export type ContextPackTopicRow = {
     _id: string;
     name?: string;

package/dist/lib/platform/sdk/contextPackCompiler.js

@@ -0,0 +1,534 @@
+import { CONTEXT_PACK_SCHEMA_VERSION, DEFAULT_COMPILATION_MODE, DEFAULT_ENTITY_LIMIT, MAX_ENTITY_LIMIT, } from "./contracts/context-pack.contract.js";
+import { buildInjectionPlan, parseTokenBudget, rankContextSection, rankEntities, resolveEffectiveWeights, } from "../../convex-kernel/src/compat/contextPackPolicy.js";
+import { validateContextPackSchema } from "../../mcp/src/contextPackSchema.js";
+function assertContextPackSchema(payload) {
+    const result = validateContextPackSchema(payload);
+    if (!result.valid) {
+        throw new Error(`Invalid context pack payload: ${result.errors.join("; ")}`);
+    }
+}
+function asStringArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .map((entry) => (typeof entry === "string" ? entry.trim() : ""))
+        .filter((entry) => entry.length > 0);
+}
+function toPositiveInt(value, fallback, max) {
+    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) {
+    if (!query) {
+        return [];
+    }
+    return query
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .map((token) => token.trim())
+        .filter((token) => token.length >= 2);
+}
+function parseRankingProfile(value) {
+    return value === "baseline_v1" ? "baseline_v1" : "weighted_v1";
+}
+function beliefTypeOf(node) {
+    if (typeof node.beliefType === "string") {
+        return node.beliefType;
+    }
+    const metadata = (node.metadata || {});
+    if (typeof metadata.beliefType === "string") {
+        return metadata.beliefType;
+    }
+    return "";
+}
+function questionStatusOf(node) {
+    const metadata = (node.metadata || {});
+    const direct = typeof node.status === "string" ? node.status : "";
+    const questionStatus = typeof metadata.questionStatus === "string" ? metadata.questionStatus : "";
+    return (questionStatus || direct || "open").toLowerCase();
+}
+function isOpenQuestion(status) {
+    return ![
+        "answered",
+        "archived",
+        "closed",
+        "resolved",
+        "resolved_support",
+        "resolved_contra",
+        "belief_forked",
+    ].includes(status);
+}
+function metadataText(payload) {
+    return JSON.stringify(payload).toLowerCase();
+}
+function collectTopicNeighborhood(topics, rootTopicId, maxDescendantDepth = 2) {
+    const byId = new Map();
+    const children = new Map();
+    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([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 = [
+        { 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(rows) {
+    const seen = new Set();
+    const output = [];
+    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) {
+    if (!candidate || typeof candidate !== "object") {
+        return 0;
+    }
+    const record = candidate;
+    const timestamps = [record.updatedAt, record.createdAt, record.generatedAt].filter((value) => typeof value === "number" && Number.isFinite(value));
+    return timestamps.length > 0 ? Math.max(...timestamps) : 0;
+}
+function resolveReferenceTimeMs(...collections) {
+    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) {
+    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 = 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
+        : 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) {
+    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 = 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;
+    if (snapshot.plan.includeFailures && snapshot.failures) {
+        const allFailures = snapshot.failures.filter((node) => {
+            const metadata = (node.metadata || {});
+            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 || {});
+            return {
+                attemptId: row.id,
+                approach: String(row.text || ""),
+                outcome: String(metadata.errorMessage || "Failed"),
+                recordedAt: row.createdAt || referenceTimeMs || 0,
+                score: row.score,
+            };
+        });
+        const failureTexts = new Set(failures.map((failure) => failure.approach.toLowerCase().slice(0, 100)));
+        const suppressionIds = new Set();
+        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 = snapshot.plan.compilationMode === "delta" && snapshot.plan.worktreeId
+        ? {
+            changedItems: [],
+            verificationObligations: [],
+            referencePoint: snapshot.plan.worktreeId,
+        }
+        : undefined;
+    const excludedItems = [
+        ...(injectionPolicy.excludedItems || []),
+        ...suppressedEvidenceIds.map((id) => ({
+            id,
+            section: "recentEvidence",
+            reason: "anti_repetition",
+            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;
+}