@orion-agents/orion-code 0.1.8 → 0.1.9

package/dist/services/compact/compact.js

@@ -1,160 +1,545 @@
 "use strict";
-/**
- * orion code - Compact 服务
- *
- * 长对话压缩服务，减少上下文长度同时保留关键信息。
- * 参考 OpenClaude 的 compact/ 目录实现。
- */
+/** Semantic, group-safe conversation compaction. */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompactCandidateValidationError = void 0;
+exports.prepareCompactCandidate = prepareCompactCandidate;
+exports.validateCompactCandidate = validateCompactCandidate;
+exports.commitCompactCandidate = commitCompactCandidate;
 exports.compactMessages = compactMessages;
 exports.needsCompact = needsCompact;
-exports.quickCompact = quickCompact;
+const crypto_1 = require("crypto");
 const summary_generator_1 = require("./summary-generator");
 const harness_1 = require("../../harness");
+const token_estimate_1 = require("../../utils/token-estimate");
+const fingerprint_1 = require("./fingerprint");
+const planner_1 = require("./planner");
+const semantic_summary_1 = require("./semantic-summary");
 const tool_call_groups_1 = require("./tool-call-groups");
-// ============================================================================
-// 默认配置
-// ============================================================================
+const CONTEXT_SUMMARY_PREFIX = '[Context Summary]\n';
+const SUMMARY_ACK = 'I understand the context. I will continue the conversation with this background information.';
+class CompactCandidateValidationError extends Error {
+    constructor(validation) {
+        super(validation.errors.map(error => `${error.code}: ${error.message}`).join('; '));
+        this.validation = validation;
+        this.name = 'CompactCandidateValidationError';
+    }
+}
+exports.CompactCandidateValidationError = CompactCandidateValidationError;
 const DEFAULT_OPTIONS = {
     maxMessages: 20,
     keepToolCalls: true,
     keepSystemMessage: true,
-    threshold: 0, // 不再使用消息数阈值，由 auto-compact 基于 token 控制
+    threshold: 0,
 };
-// ============================================================================
-// Compact 实现
-// ============================================================================
-/**
- * 压缩消息历史
- *
- * 策略：
- * 1. 保留 system 消息
- * 2. 保留最近 N 条消息
- * 3. 对早期消息生成摘要替换
- */
-async function compactMessages(messages, options) {
-    const opts = { ...DEFAULT_OPTIONS, ...options };
-    const originalCount = messages.length;
-    // 检查是否需要压缩
-    if (originalCount <= opts.threshold) {
-        return {
-            messages,
-            originalCount,
-            compactedCount: originalCount,
-            ratio: 1,
-            summary: '',
-            summarySource: 'heuristic',
-            summaryGeneratedAt: Date.now(),
-        };
+function cloneMessages(messages) {
+    return messages.map(message => ({
+        ...message,
+        tool_calls: message.tool_calls?.map(call => ({
+            ...call,
+            function: { ...call.function },
+        })),
+    }));
+}
+function uniqueStrings(values) {
+    return [
+        ...new Set(values.map(value => value?.trim()).filter((value) => !!value)),
+    ];
+}
+function invariantItemId(kind, material) {
+    const digest = (0, crypto_1.createHash)('sha256').update(material, 'utf8').digest('hex').slice(0, 20);
+    return `ctx-${kind}-${digest}`;
+}
+function invariantItem(params) {
+    const id = invariantItemId(params.kind, `${params.sourceRefs.join('\0')}\0${params.text}`);
+    return {
+        id,
+        groupId: `harness:${id}`,
+        kind: params.kind,
+        priority: 'must_keep',
+        sourceRefs: [...params.sourceRefs],
+        tokenEstimate: (0, token_estimate_1.estimateMessagesTokens)([{ role: 'system', content: params.text }]),
+        taskEpoch: params.taskEpoch,
+        expires: 'task',
+        text: params.text,
+        sourceRole: 'system',
+        messageIndexes: { start: -1, end: -1 },
+        status: params.status,
+    };
+}
+function structuredProjectionLine(label, value, maxLength = 280) {
+    const normalized = value.replace(/\s+/g, ' ').trim();
+    const prefix = `${label}: `;
+    if (prefix.length + normalized.length <= maxLength)
+        return `${prefix}${normalized}`;
+    const ref = (0, crypto_1.createHash)('sha256').update(normalized, 'utf8').digest('hex').slice(0, 16);
+    const suffix = ` [full-ref:${ref}]`;
+    const available = Math.max(0, maxLength - prefix.length - suffix.length);
+    return `${prefix}${normalized.slice(0, available)}${suffix}`;
+}
+function renderDeterministicSemanticSummary(summary, maxLength) {
+    const lines = ['[Semantic Snapshot v1]'];
+    if (summary.requestedFocus) {
+        lines.push(structuredProjectionLine('Requested focus', summary.requestedFocus));
+    }
+    if (summary.projectInstructions) {
+        lines.push(structuredProjectionLine('Project compact instructions', summary.projectInstructions));
     }
-    // 1. 保留 system 消息
-    const systemMessages = opts.keepSystemMessage ? messages.filter(m => m.role === 'system') : [];
-    // 2. 分离需要压缩的消息
-    const toCompact = opts.keepSystemMessage ? messages.filter(m => m.role !== 'system') : messages;
-    const priorSummary = [...toCompact]
+    if (summary.objective)
+        lines.push(structuredProjectionLine('Objective', summary.objective));
+    if (summary.activeInstruction) {
+        lines.push(structuredProjectionLine('Active instruction', summary.activeInstruction));
+    }
+    for (const criterion of summary.criterionStates ?? []) {
+        lines.push(structuredProjectionLine(`Criterion ${criterion.id} [${criterion.status}]`, `${criterion.statement}${criterion.evidenceRefs.length ? ` | evidence=${criterion.evidenceRefs.join(',')}` : ''}`));
+    }
+    const appendValues = (label, values) => {
+        for (const value of values ?? [])
+            lines.push(structuredProjectionLine(label, value));
+    };
+    appendValues('Constraint', summary.constraints);
+    appendValues('Non-goal', summary.nonGoals);
+    appendValues('Decision', summary.decisions);
+    appendValues('Completed', summary.completed);
+    appendValues('Pending', summary.pending);
+    appendValues('Blocker', summary.blockers);
+    appendValues('Verification passed', summary.successfulVerifications);
+    appendValues('Verification failed', summary.failedVerifications);
+    appendValues('Changed file', summary.changedFiles);
+    appendValues('Open question', summary.openQuestions);
+    if (summary.nextAction)
+        lines.push(structuredProjectionLine('Next action', summary.nextAction));
+    lines.push(`Source boundary: ${summary.coverage.groupCount} groups / ${summary.coverage.messageCount} messages`);
+    const selected = [];
+    const omitted = [];
+    let used = 0;
+    for (const line of lines) {
+        const needed = line.length + (selected.length > 0 ? 1 : 0);
+        if (used + needed <= maxLength) {
+            selected.push(line);
+            used += needed;
+        }
+        else {
+            omitted.push(line);
+        }
+    }
+    if (omitted.length > 0) {
+        const ref = (0, crypto_1.createHash)('sha256').update(omitted.join('\n'), 'utf8').digest('hex').slice(0, 16);
+        const receipt = `Omitted structured lines: ${omitted.length} [full-ref:${ref}]`;
+        while (selected.length > 1 && selected.join('\n').length + receipt.length + 1 > maxLength) {
+            omitted.unshift(selected.pop());
+        }
+        if (receipt.length <= maxLength)
+            selected.push(receipt);
+    }
+    return selected.join('\n');
+}
+function enrichSemanticSummary(summary, options) {
+    const state = options.harnessState;
+    const capsule = state?.capsule ?? options.contextCapsule;
+    const contract = state?.contract ?? capsule?.contract;
+    const capability = state?.capabilityProfile;
+    const taskEpoch = Math.max(1, state?.taskEpoch ?? contract?.taskEpoch ?? summary.taskEpoch);
+    const criterionStates = contract?.criteria?.map(criterion => ({
+        id: criterion.id,
+        statement: criterion.statement,
+        status: criterion.status ?? 'pending',
+        evidenceRefs: [...criterion.evidenceRefs],
+    }));
+    const boundEvidenceRefs = uniqueStrings((criterionStates ?? []).flatMap(criterion => criterion.evidenceRefs));
+    const evidenceByRef = new Map();
+    for (const record of state?.evidenceIndex ?? []) {
+        const value = { content: record.content, status: record.verificationStatus };
+        evidenceByRef.set(record.id, value);
+        evidenceByRef.set(`evidence:${record.id}`, value);
+    }
+    for (const entry of state?.ledger ?? []) {
+        const rawSuccess = entry.metadata?.success;
+        const status = rawSuccess === true ? 'passed' : rawSuccess === false ? 'failed' : 'unknown';
+        const value = { content: entry.content, status };
+        evidenceByRef.set(entry.id, value);
+        evidenceByRef.set(`ledger:${entry.id}`, value);
+    }
+    const invariantItems = [];
+    if (contract) {
+        invariantItems.push(invariantItem({
+            kind: 'contract',
+            text: JSON.stringify({
+                objective: contract.objective,
+                activeInstruction: state?.activeInstruction ?? contract.userIntent,
+                constraints: contract.constraints,
+                prohibitions: contract.prohibitions,
+                nonGoals: state?.nonGoals ?? contract.nonGoals ?? [],
+                openQuestions: state?.openQuestions ?? contract.openQuestions ?? [],
+                criteria: criterionStates ?? [],
+            }),
+            sourceRefs: uniqueStrings([
+                `contract:${contract.id}`,
+                ...(criterionStates ?? []).map(criterion => criterion.id),
+            ]),
+            taskEpoch,
+        }));
+    }
+    for (const ref of boundEvidenceRefs) {
+        const evidence = evidenceByRef.get(ref);
+        invariantItems.push(invariantItem({
+            kind: 'evidence',
+            text: evidence?.content ?? `Evidence reference: ${ref}`,
+            sourceRefs: [ref],
+            taskEpoch,
+            status: evidence?.status ?? 'unknown',
+        }));
+    }
+    if (capsule?.nextAction) {
+        invariantItems.push(invariantItem({
+            kind: 'next_action',
+            text: capsule.nextAction,
+            sourceRefs: ['harness:next-action'],
+            taskEpoch,
+        }));
+    }
+    return {
+        ...summary,
+        taskEpoch,
+        objective: options.goalObjective ?? state?.rootObjective ?? contract?.objective ?? summary.objective,
+        activeInstruction: state?.activeInstruction ?? contract?.userIntent ?? summary.latestUserInstruction,
+        scope: contract
+            ? {
+                cwd: contract.allowedScope.cwd,
+                files: contract.allowedScope.files ? [...contract.allowedScope.files] : undefined,
+                commands: contract.allowedScope.commands
+                    ? [...contract.allowedScope.commands]
+                    : undefined,
+            }
+            : undefined,
+        nonGoals: uniqueStrings([
+            ...(summary.nonGoals ?? []),
+            ...(state?.nonGoals ?? contract?.nonGoals ?? []),
+        ]),
+        openQuestions: uniqueStrings([
+            ...(summary.openQuestions ?? []),
+            ...(state?.openQuestions ?? contract?.openQuestions ?? []),
+        ]),
+        criterionStates,
+        files: uniqueStrings([...summary.files, ...(capsule?.changedFiles ?? [])]),
+        changedFiles: uniqueStrings(capsule?.changedFiles ?? []),
+        successfulVerifications: uniqueStrings(capsule?.verification.passed ?? []),
+        failedVerifications: uniqueStrings(capsule?.verification.failed ?? []),
+        blockers: uniqueStrings([...summary.blockers, ...(capsule?.verification.warnings ?? [])]),
+        nextAction: capsule?.nextAction,
+        evidenceRefs: uniqueStrings([...summary.evidenceRefs, ...boundEvidenceRefs]),
+        items: [...invariantItems, ...summary.items.map(item => ({ ...item, taskEpoch }))],
+        verification: [
+            ...invariantItems.filter(item => item.kind === 'evidence'),
+            ...summary.verification.map(item => ({ ...item, taskEpoch })),
+        ],
+        capability: capability
+            ? {
+                revision: capability.revision,
+                fingerprint: capability.fingerprint,
+                modelId: capability.model.id,
+                permissionMode: capability.permission.mode,
+                tools: [...capability.tools],
+            }
+            : undefined,
+    };
+}
+function pinnedContextMessages(options) {
+    if (options.harnessState) {
+        return [
+            {
+                role: 'user',
+                content: (0, harness_1.renderHarnessStateForCompact)(options.harnessState, options.compactMode ?? 'manual'),
+            },
+            {
+                role: 'assistant',
+                content: 'I will continue from this Orion Code Context State and preserve its root objective, active instruction, constraints, and verification state.',
+            },
+        ];
+    }
+    if (options.contextCapsule) {
+        return [
+            { role: 'user', content: (0, harness_1.renderContextCapsule)(options.contextCapsule) },
+            {
+                role: 'assistant',
+                content: 'I will continue from this Context Capsule and preserve its open todos, constraints, and verification state.',
+            },
+        ];
+    }
+    return [];
+}
+function stripSyntheticCompactMessages(messages) {
+    const priorSummary = [...messages]
         .reverse()
-        .find(message => message.content?.startsWith('[Context Summary]\n'));
-    const conversationMessages = toCompact.filter(message => !message.content?.startsWith('[Context Summary]\n') &&
+        .find(message => message.content?.startsWith(CONTEXT_SUMMARY_PREFIX));
+    const conversation = messages.filter(message => !message.content?.startsWith(CONTEXT_SUMMARY_PREFIX) &&
+        !(message.role === 'assistant' && message.content === SUMMARY_ACK) &&
+        !message.content?.startsWith('[Orion Code Context State v2]') &&
+        !message.content?.startsWith('## Context Capsule') &&
         !(message.role === 'assistant' &&
-            message.content ===
-                'I understand the context. I will continue the conversation with this background information.'));
-    // 3. 保留最近 maxMessages 条
-    const maxMessages = Math.max(0, Math.floor(opts.maxMessages ?? DEFAULT_OPTIONS.maxMessages));
-    const requestedStart = Math.max(0, conversationMessages.length - maxMessages);
-    const recentStart = (0, tool_call_groups_1.snapToToolCallGroupStart)(conversationMessages, requestedStart);
-    const recentMessages = conversationMessages.slice(recentStart);
-    const oldMessages = conversationMessages.slice(0, recentStart);
-    if (priorSummary)
-        oldMessages.unshift(priorSummary);
-    // 4. 对早期消息生成摘要
-    // Use LLM-driven summary if LLM service is provided, else fall back to heuristic
-    const generated = opts.llm
-        ? await (0, summary_generator_1.generateSummaryWithSource)(oldMessages, opts.llm, opts.summaryOptions)
-        : {
-            text: await (0, summary_generator_1.summaryGenerator)(oldMessages, opts.summaryOptions),
-            source: 'heuristic',
-        };
-    const summary = generated.text;
-    // 5. 构建压缩后的消息列表
-    let compactedMessages = [];
-    compactedMessages.push(...systemMessages);
-    // Preserve structured task state before the lossy natural-language summary.
-    if (opts.harnessState) {
-        compactedMessages.push({
-            role: 'user',
-            content: (0, harness_1.renderHarnessStateForCompact)(opts.harnessState, opts.compactMode ?? 'manual'),
+            (message.content.startsWith('I will continue from this Orion Code Context State') ||
+                message.content.startsWith('I will continue from this Context Capsule'))));
+    return { priorSummary, conversation: cloneMessages(conversation) };
+}
+function withoutToolProtocol(messages) {
+    const callIds = new Set(messages.flatMap(message => message.tool_calls?.map(call => call.id) ?? []));
+    return messages
+        .filter(message => message.role !== 'tool' || !callIds.has(message.tool_call_id ?? ''))
+        .map(message => message.tool_calls?.length ? { ...message, tool_calls: undefined } : { ...message });
+}
+function emptyPlan(messages) {
+    return (0, planner_1.planCompactMessages)(messages, { maxMessages: messages.length });
+}
+function resultFromCandidate(candidate) {
+    return {
+        messages: cloneMessages(candidate.messages),
+        originalCount: candidate.originalCount,
+        compactedCount: candidate.messages.length,
+        ratio: candidate.originalCount === 0 ? 1 : candidate.messages.length / candidate.originalCount,
+        summary: candidate.summary,
+        summarySource: candidate.summarySource,
+        summaryGeneratedAt: candidate.summaryGeneratedAt,
+        semanticSummary: candidate.semanticSummary,
+        diagnostics: candidate.diagnostics.map(diagnostic => ({ ...diagnostic })),
+        fingerprint: candidate.fingerprint,
+        beforeTokens: candidate.beforeTokens,
+        afterTokens: candidate.afterTokens,
+        plan: candidate.plan,
+    };
+}
+/** Prepare a model-context projection without mutating or persisting its source. */
+async function prepareCompactCandidate(messages, options = {}) {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    const source = cloneMessages(messages);
+    const systemMessages = opts.keepSystemMessage
+        ? source.filter(message => message.role === 'system')
+        : [];
+    const nonSystem = opts.keepSystemMessage
+        ? source.filter(message => message.role !== 'system')
+        : source;
+    const { priorSummary, conversation } = stripSyntheticCompactMessages(nonSystem);
+    const pinned = pinnedContextMessages(opts);
+    const framingTokens = (0, token_estimate_1.estimateMessagesTokens)([
+        { role: 'user', content: CONTEXT_SUMMARY_PREFIX },
+        { role: 'assistant', content: SUMMARY_ACK },
+    ]);
+    const plan = (0, planner_1.planCompactMessages)(conversation, {
+        maxMessages: opts.maxMessages,
+        safeInputBudget: opts.safeInputBudget,
+        targetRatio: opts.targetRatio ?? planner_1.DEFAULT_COMPACT_TARGET_RATIO,
+        fixedTokens: (0, token_estimate_1.estimateMessagesTokens)([...systemMessages, ...pinned]) + framingTokens,
+        summaryReserveTokens: opts.summaryReserveTokens,
+    });
+    const evictedMessages = (0, planner_1.flattenCompactGroups)(plan.evictedGroups);
+    const oldMessages = priorSummary ? [{ ...priorSummary }, ...evictedMessages] : evictedMessages;
+    let semanticSummary = (0, semantic_summary_1.extractCompactSummary)(plan.evictedGroups, {
+        taskEpoch: opts.harnessState?.taskEpoch ?? opts.harnessState?.contract?.taskEpoch,
+    });
+    semanticSummary = {
+        ...semanticSummary,
+        requestedFocus: (0, summary_generator_1.normalizeCompactFocus)(opts.summaryOptions?.focus),
+        projectInstructions: (0, summary_generator_1.normalizeCompactInstructions)(opts.summaryOptions?.instructions),
+    };
+    semanticSummary = enrichSemanticSummary(semanticSummary, opts);
+    let summary = '';
+    let summarySource = 'heuristic';
+    let diagnostics = [];
+    if (plan.evictedGroups.length > 0) {
+        if (opts.llm) {
+            const generated = await (0, summary_generator_1.generateSummaryWithSource)(oldMessages, opts.llm, opts.summaryOptions);
+            summary = generated.text;
+            summarySource = generated.source;
+            diagnostics = generated.diagnostics;
+            if (generated.source === 'heuristic') {
+                const projectionBudget = Math.max(256, Math.min(opts.summaryOptions?.maxLength ?? 2000, plan.summaryReserveTokens * 3 || 2000));
+                summary = renderDeterministicSemanticSummary(semanticSummary, projectionBudget);
+            }
+        }
+        else {
+            const projectionBudget = Math.max(256, Math.min(opts.summaryOptions?.maxLength ?? 2000, plan.summaryReserveTokens * 3 || 2000));
+            summary = renderDeterministicSemanticSummary(semanticSummary, projectionBudget);
+            diagnostics = [
+                {
+                    code: 'deterministic_projection',
+                    message: 'Rendered the typed semantic snapshot without a summary provider.',
+                    fallbackUsed: true,
+                },
+            ];
+        }
+    }
+    else if (priorSummary) {
+        summary = priorSummary.content.slice(CONTEXT_SUMMARY_PREFIX.length);
+    }
+    const candidateMessages = [...systemMessages];
+    if (plan.evictedGroups.length > 0)
+        candidateMessages.push(...pinned);
+    if (summary) {
+        candidateMessages.push({ role: 'user', content: `${CONTEXT_SUMMARY_PREFIX}${summary}` }, { role: 'assistant', content: SUMMARY_ACK });
+    }
+    candidateMessages.push(...(0, planner_1.flattenCompactGroups)(plan.recentGroups));
+    const visibleMessages = opts.keepToolCalls
+        ? candidateMessages
+        : withoutToolProtocol(candidateMessages);
+    return {
+        status: 'prepared',
+        messages: visibleMessages,
+        originalCount: source.length,
+        summary,
+        summarySource,
+        summaryGeneratedAt: Date.now(),
+        semanticSummary,
+        diagnostics,
+        fingerprint: (0, fingerprint_1.canonicalCompactCandidateFingerprint)({
+            messages: visibleMessages,
+            sourceBoundary: {
+                firstGroupId: semanticSummary.sourceBoundary?.firstGroupId,
+                lastGroupId: semanticSummary.sourceBoundary?.lastGroupId,
+                groupCount: semanticSummary.sourceBoundary?.groupCount ?? semanticSummary.coverage.groupCount,
+                messageCount: semanticSummary.sourceBoundary?.messageCount ?? semanticSummary.coverage.messageCount,
+                groupIds: semanticSummary.coverage.groupIds,
+            },
+        }),
+        beforeTokens: (0, token_estimate_1.estimateMessagesTokens)(source),
+        afterTokens: (0, token_estimate_1.estimateMessagesTokens)(visibleMessages),
+        plan,
+    };
+}
+/** Validate semantic coverage, provider headroom, and tool protocol invariants. */
+function validateCompactCandidate(candidate) {
+    const errors = [];
+    try {
+        (0, tool_call_groups_1.assertToolCallGroups)(candidate.messages);
+    }
+    catch (error) {
+        errors.push({
+            code: 'tool_group_invalid',
+            message: error instanceof Error ? error.message : String(error),
         });
-        compactedMessages.push({
-            role: 'assistant',
-            content: 'I will continue from this Orion Code Context State and preserve its root objective, active instruction, constraints, and verification state.',
+    }
+    if (candidate.plan.targetTokens !== undefined &&
+        candidate.afterTokens > candidate.plan.targetTokens) {
+        errors.push({
+            code: 'target_headroom_exceeded',
+            message: `Candidate uses ${candidate.afterTokens} tokens; target is ${candidate.plan.targetTokens}.`,
         });
     }
-    else if (opts.contextCapsule) {
-        compactedMessages.push({
-            role: 'user',
-            content: (0, harness_1.renderContextCapsule)(opts.contextCapsule),
+    const expectedCoverage = candidate.plan.evictedGroups.map(group => group.id);
+    if (expectedCoverage.length !== candidate.semanticSummary.coverage.groupIds.length ||
+        expectedCoverage.some((groupId, index) => candidate.semanticSummary.coverage.groupIds[index] !== groupId)) {
+        errors.push({
+            code: 'evicted_coverage_mismatch',
+            message: 'Semantic summary does not cover every evicted atomic group in order.',
         });
-        compactedMessages.push({
-            role: 'assistant',
-            content: 'I will continue from this Context Capsule and preserve its open todos, constraints, and verification state.',
+    }
+    const summary = candidate.semanticSummary;
+    const expectedMessageCount = candidate.plan.evictedGroups.reduce((total, group) => total + group.messages.length, 0);
+    if (summary.sourceBoundary?.firstGroupId !== expectedCoverage[0] ||
+        summary.sourceBoundary?.lastGroupId !== expectedCoverage.at(-1) ||
+        summary.sourceBoundary?.groupCount !== expectedCoverage.length ||
+        summary.sourceBoundary?.messageCount !== expectedMessageCount) {
+        errors.push({
+            code: 'source_boundary_mismatch',
+            message: 'Semantic source boundary does not match the evicted atomic groups.',
         });
     }
-    // 添加摘要作为 user 消息（作为上下文背景）
-    if (summary) {
-        compactedMessages.push({
-            role: 'user',
-            content: `[Context Summary]\n${summary}`,
+    const validKinds = new Set([
+        'system',
+        'contract',
+        'decision',
+        'evidence',
+        'tool_group',
+        'turn',
+        'next_action',
+    ]);
+    const validPriorities = new Set(['must_keep', 'high', 'normal', 'evictable']);
+    const schemaInvalid = !Number.isSafeInteger(summary.taskEpoch) ||
+        summary.taskEpoch < 1 ||
+        summary.items.some(item => !item.id ||
+            !item.groupId ||
+            !validKinds.has(item.kind) ||
+            !validPriorities.has(item.priority) ||
+            !Array.isArray(item.sourceRefs) ||
+            item.sourceRefs.length === 0 ||
+            !Number.isSafeInteger(item.tokenEstimate) ||
+            item.tokenEstimate < 0);
+    if (schemaInvalid) {
+        errors.push({
+            code: 'semantic_schema_invalid',
+            message: 'Semantic ContextItems do not satisfy the typed schema.',
         });
-        compactedMessages.push({
-            role: 'assistant',
-            content: 'I understand the context. I will continue the conversation with this background information.',
+    }
+    if (summary.items.some(item => item.taskEpoch !== summary.taskEpoch)) {
+        errors.push({
+            code: 'task_epoch_mismatch',
+            message: 'Semantic ContextItems are not bound to the current task epoch.',
+        });
+    }
+    const conversationItems = summary.items.filter(item => item.messageIndexes.start >= 0);
+    if (conversationItems.length !== expectedCoverage.length ||
+        expectedCoverage.some((groupId, index) => conversationItems[index]?.groupId !== groupId ||
+            !conversationItems[index]?.sourceRefs.includes(`group:${groupId}`))) {
+        errors.push({
+            code: 'semantic_reference_invalid',
+            message: 'Conversation ContextItems do not bind every evicted group in order.',
         });
     }
-    // 添加最近消息
-    compactedMessages.push(...recentMessages);
-    // 过滤工具调用（如果需要）
-    if (!opts.keepToolCalls) {
-        compactedMessages = compactedMessages.map(m => {
-            if (m.role === 'assistant' && m.tool_calls) {
-                return { ...m, tool_calls: undefined };
+    const criterionIds = new Set();
+    let semanticReferenceInvalid = false;
+    for (const criterion of summary.criterionStates ?? []) {
+        if (!criterion.id || criterionIds.has(criterion.id))
+            semanticReferenceInvalid = true;
+        criterionIds.add(criterion.id);
+        if (!summary.items.some(item => item.kind === 'contract' && item.sourceRefs.includes(criterion.id))) {
+            semanticReferenceInvalid = true;
+        }
+        for (const evidenceRef of criterion.evidenceRefs) {
+            if (!summary.evidenceRefs.includes(evidenceRef) ||
+                !summary.items.some(item => item.kind === 'evidence' && item.sourceRefs.includes(evidenceRef))) {
+                semanticReferenceInvalid = true;
             }
-            return m;
+        }
+    }
+    if (semanticReferenceInvalid) {
+        errors.push({
+            code: 'semantic_reference_invalid',
+            message: 'Criterion or evidence references are missing, duplicated, or dangling.',
         });
     }
-    const compactedCount = compactedMessages.length;
-    const ratio = compactedCount / originalCount;
-    return {
-        messages: compactedMessages,
-        originalCount,
-        compactedCount,
-        ratio,
-        summary,
-        summarySource: generated.source,
-        summaryGeneratedAt: Date.now(),
-    };
+    return { valid: errors.length === 0, errors };
 }
 /**
- * 检查是否需要压缩
+ * Commit the prepared in-memory projection. This intentionally does not write a
+ * session checkpoint; the runtime/session owner must perform that transaction.
  */
-function needsCompact(messages, threshold) {
-    const limit = threshold || DEFAULT_OPTIONS.threshold;
-    return messages.length > limit;
+function commitCompactCandidate(candidate) {
+    const validation = validateCompactCandidate(candidate);
+    if (!validation.valid)
+        throw new CompactCandidateValidationError(validation);
+    return resultFromCandidate(candidate);
 }
-/**
- * 快速压缩（不生成摘要，直接保留最近 N 条）
- */
-function quickCompact(messages, keepLast = 10) {
-    const systemMessage = messages.find(m => m.role === 'system');
-    // 过滤掉 system
-    const nonSystem = messages.filter(m => m.role !== 'system');
-    // 保留最近 keepLast 条
-    const recent = nonSystem.slice(-keepLast);
-    // 构建结果
-    const result = [];
-    if (systemMessage) {
-        result.push(systemMessage);
-    }
-    result.push(...recent);
-    return result;
+async function compactMessages(messages, options = {}) {
+    const threshold = options.threshold ?? DEFAULT_OPTIONS.threshold;
+    if (messages.length <= threshold) {
+        const cloned = cloneMessages(messages);
+        const tokens = (0, token_estimate_1.estimateMessagesTokens)(cloned);
+        return {
+            messages,
+            originalCount: messages.length,
+            compactedCount: messages.length,
+            ratio: 1,
+            summary: '',
+            summarySource: 'heuristic',
+            summaryGeneratedAt: Date.now(),
+            semanticSummary: (0, semantic_summary_1.emptyCompactSummary)(),
+            diagnostics: [],
+            fingerprint: (0, fingerprint_1.canonicalMessagesFingerprint)(cloned),
+            beforeTokens: tokens,
+            afterTokens: tokens,
+            plan: emptyPlan(cloned),
+        };
+    }
+    return commitCompactCandidate(await prepareCompactCandidate(messages, options));
+}
+function needsCompact(messages, threshold) {
+    return messages.length > (threshold ?? DEFAULT_OPTIONS.threshold);
 }
 //# sourceMappingURL=compact.js.map