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

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

@@ -1,534 +0,0 @@
-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 "@lucern/reasoning-kernel/compat/contextPackPolicy";
-import { validateContextPackSchema } from "@/packages/mcp/src/contextPackSchema";
-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;
-}

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

@@ -1,133 +0,0 @@
-export type ContextRankingProfile = "baseline_v1" | "hybrid_v1" | "weighted_v1";
-export type ContextCompilationMode = "standard" | "delta";
-export type ContextPackSectionKey = "invariants" | "activeBeliefs" | "openQuestions" | "recentEvidence" | "contradictions";
-export type RankingWeightVector = {
-    query: number;
-    recency: number;
-    confidence?: number;
-    beliefType?: number;
-    priority?: number;
-    severity?: number;
-};
-export type PackWeightOverride = {
-    section: ContextPackSectionKey;
-    weights: Partial<RankingWeightVector>;
-};
-export type CompileContextInput = {
-    query?: string;
-    budget?: number;
-    ranking?: ContextRankingProfile;
-    limit?: number;
-    maxDepth?: number;
-    includeEntities?: boolean;
-    mode?: ContextCompilationMode;
-    includeFailures?: boolean;
-    worktreeId?: string;
-    sessionId?: string;
-    packWeightOverrides?: PackWeightOverride[];
-    tokenBudget?: number;
-    rankingProfile?: ContextRankingProfile;
-};
-export type PublicContextBelief = {
-    beliefId: string;
-    text: string;
-    confidence: number | null;
-    beliefType?: string | null;
-    status?: string;
-    updatedAt?: number | null;
-    score: number;
-    justification?: string;
-};
-export type PublicContextQuestion = {
-    questionId: string;
-    text: string;
-    status: string;
-    priority: string;
-    updatedAt?: number | null;
-    score: number;
-    justification?: string;
-};
-export type PublicContextEvidence = {
-    evidenceId: string;
-    text: string;
-    sourceUrl?: string | null;
-    kind: string;
-    createdAt?: number | null;
-    score: number;
-    justification?: string;
-};
-export type PublicContextContradiction = {
-    contradictionId: string;
-    severity: string;
-    status: string;
-    description: string;
-    score: number;
-    justification?: string;
-};
-export type PublicContextEntity = {
-    entityId: string;
-    entityType: string;
-    title: string;
-    text?: string;
-    connectedBeliefCount: number;
-    connectedEvidenceCount: number;
-    score: number;
-    metadata?: Record<string, unknown>;
-};
-export type PublicContextInjectionPolicy = {
-    tokenBudget: number;
-    estimatedTokens: number;
-    sectionBudgets: Record<string, number>;
-    sectionUsage: Record<string, number>;
-    selected: Record<string, string[]>;
-    excludedItems?: Array<{
-        id: string;
-        section: string;
-        reason: "budget_exceeded" | "anti_repetition" | "below_threshold";
-        score: number;
-    }>;
-};
-export type PublicCompiledContext = {
-    schemaVersion: string;
-    topicId: string;
-    topicName: string;
-    scopedTopicIds: string[];
-    generatedAt: number;
-    ranking: ContextRankingProfile;
-    summary: Record<string, unknown>;
-    invariants: PublicContextBelief[];
-    activeBeliefs: PublicContextBelief[];
-    openQuestions: PublicContextQuestion[];
-    recentEvidence: PublicContextEvidence[];
-    contradictions: PublicContextContradiction[];
-    relatedEntities?: PublicContextEntity[];
-    contextNarrative: string[];
-    injectionPolicy: PublicContextInjectionPolicy;
-    diagnostics: Record<string, unknown>;
-    compilationMode?: string;
-    failureContext?: {
-        failures: Array<{
-            attemptId: string;
-            approach: string;
-            outcome: string;
-            recordedAt: number;
-            score: number;
-        }>;
-        suppressedIds: string[];
-    };
-    deltaReport?: {
-        changedItems: Array<{
-            id: string;
-            section: string;
-            changeType: string;
-            summary: string;
-        }>;
-        verificationObligations: Array<{
-            description: string;
-            source: string;
-            severity: "critical" | "high" | "medium" | "low";
-        }>;
-        referencePoint: string;
-    };
-    appliedWeightOverrides?: unknown[];
-};

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

@@ -1 +0,0 @@
-export {};