@psiclawops/hypermem 0.9.1 → 0.9.3

package/dist/compaction-fence.js

@@ -0,0 +1,174 @@
+/**
+ * hypermem Compaction Fence
+ *
+ * Protects the recent conversation tail from being compacted.
+ *
+ * The fence is a per-conversation high-water mark (message ID) that divides
+ * the message timeline into two zones:
+ *
+ *   - ABOVE the fence: messages the LLM can currently see (recent tail).
+ *     These are off-limits to compaction.
+ *   - BELOW the fence: older messages eligible for compaction/summarization.
+ *
+ * The compositor updates the fence every compose cycle by recording the
+ * oldest message ID that was included in the composed context. This means
+ * the fence automatically advances as conversations grow.
+ *
+ * Safety defaults:
+ *   - No fence row = no compaction allowed (explicit opt-in)
+ *   - Fence never moves backward (monotone progress)
+ *   - Fence update is idempotent (same value = no-op)
+ *
+ * Inspired by the continuity model in openclaw-memory-libravdb, which
+ * formally proves that compaction must never touch the recent tail.
+ */
+// ─── Schema ─────────────────────────────────────────────────────
+/**
+ * Add the compaction_fences table to an existing messages.db.
+ * Idempotent — safe to call on every startup.
+ */
+export function ensureCompactionFenceSchema(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS compaction_fences (
+      conversation_id INTEGER PRIMARY KEY REFERENCES conversations(id),
+      fence_message_id INTEGER NOT NULL,
+      updated_at TEXT NOT NULL
+    )
+  `);
+}
+// ─── Fence Operations ───────────────────────────────────────────
+/**
+ * Update the compaction fence for a conversation.
+ *
+ * Called by the compositor after assembling context, passing the ID of
+ * the oldest message that was included in the composed history.
+ *
+ * The fence only moves forward (monotone progress). If the new fence
+ * is lower than the existing one, the update is silently ignored.
+ * This prevents a short compose window from accidentally exposing
+ * already-compacted messages.
+ */
+export function updateCompactionFence(db, conversationId, oldestVisibleMessageId, opts = {}) {
+    const now = new Date().toISOString();
+    const minTailMessages = typeof opts.minTailMessages === 'number' && Number.isFinite(opts.minTailMessages)
+        ? Math.max(1, Math.floor(opts.minTailMessages))
+        : undefined;
+    const oldestRecentRow = minTailMessages != null
+        ? db.prepare(`
+          SELECT id FROM messages
+          WHERE conversation_id = ?
+            AND role != 'system'
+          ORDER BY message_index DESC
+          LIMIT 1 OFFSET ?
+        `).get(conversationId, minTailMessages - 1) ?? db.prepare(`
+          SELECT id FROM messages
+          WHERE conversation_id = ?
+            AND role != 'system'
+          ORDER BY message_index ASC
+          LIMIT 1
+        `).get(conversationId)
+        : undefined;
+    const clampedMessageId = oldestRecentRow
+        ? Math.min(oldestVisibleMessageId, oldestRecentRow.id)
+        : oldestVisibleMessageId;
+    const existing = db.prepare('SELECT fence_message_id FROM compaction_fences WHERE conversation_id = ?').get(conversationId);
+    if (!existing) {
+        // First fence for this conversation
+        db.prepare('INSERT INTO compaction_fences (conversation_id, fence_message_id, updated_at) VALUES (?, ?, ?)').run(conversationId, clampedMessageId, now);
+        return;
+    }
+    // Monotone progress: fence only moves forward
+    if (clampedMessageId > existing.fence_message_id) {
+        db.prepare('UPDATE compaction_fences SET fence_message_id = ?, updated_at = ? WHERE conversation_id = ?').run(clampedMessageId, now, conversationId);
+    }
+}
+/**
+ * Get the current compaction fence for a conversation.
+ * Returns null if no fence has been set (meaning: no compaction allowed).
+ */
+export function getCompactionFence(db, conversationId) {
+    const row = db.prepare('SELECT conversation_id, fence_message_id, updated_at FROM compaction_fences WHERE conversation_id = ?').get(conversationId);
+    if (!row)
+        return null;
+    return {
+        conversationId: row.conversation_id,
+        fenceMessageId: row.fence_message_id,
+        updatedAt: row.updated_at,
+    };
+}
+/**
+ * Query compaction eligibility for a conversation.
+ *
+ * Returns the count and range of messages that are below the fence
+ * and therefore eligible for compaction. If no fence exists, returns
+ * zero eligible (safe default: no fence = no compaction).
+ *
+ * Excludes messages that are already covered by a summary
+ * (via the summary_messages junction table).
+ */
+export function getCompactionEligibility(db, conversationId) {
+    const fence = getCompactionFence(db, conversationId);
+    if (!fence) {
+        return {
+            conversationId,
+            eligibleCount: 0,
+            oldestEligibleId: null,
+            newestEligibleId: null,
+            fence: null,
+        };
+    }
+    // Messages below the fence that haven't been summarized yet
+    const stats = db.prepare(`
+    SELECT
+      COUNT(*) AS cnt,
+      MIN(m.id) AS oldest_id,
+      MAX(m.id) AS newest_id
+    FROM messages m
+    WHERE m.conversation_id = ?
+      AND m.id < ?
+      AND m.id NOT IN (
+        SELECT sm.message_id FROM summary_messages sm
+        JOIN summaries s ON sm.summary_id = s.id
+        WHERE s.conversation_id = ?
+      )
+  `).get(conversationId, fence.fenceMessageId, conversationId);
+    return {
+        conversationId,
+        eligibleCount: stats.cnt,
+        oldestEligibleId: stats.oldest_id,
+        newestEligibleId: stats.newest_id,
+        fence,
+    };
+}
+/**
+ * Get messages eligible for compaction (below the fence, not yet summarized).
+ *
+ * Returns messages in chronological order, ready for clustering.
+ * Respects the fence boundary and excludes already-summarized messages.
+ */
+export function getCompactableMessages(db, conversationId, limit = 100) {
+    const fence = getCompactionFence(db, conversationId);
+    if (!fence)
+        return [];
+    const rows = db.prepare(`
+    SELECT m.id, m.role, m.text_content, m.created_at
+    FROM messages m
+    WHERE m.conversation_id = ?
+      AND m.id < ?
+      AND m.text_content IS NOT NULL
+      AND m.id NOT IN (
+        SELECT sm.message_id FROM summary_messages sm
+        JOIN summaries s ON sm.summary_id = s.id
+        WHERE s.conversation_id = ?
+      )
+    ORDER BY m.id ASC
+    LIMIT ?
+  `).all(conversationId, fence.fenceMessageId, conversationId, limit);
+    return rows.map(r => ({
+        id: r.id,
+        role: r.role,
+        textContent: r.text_content,
+        createdAt: r.created_at,
+    }));
+}
+//# sourceMappingURL=compaction-fence.js.map

package/dist/composition-snapshot-integrity.d.ts

@@ -0,0 +1,36 @@
+export type SnapshotJsonPrimitive = string | number | boolean | null;
+export type SnapshotJsonValue = SnapshotJsonPrimitive | SnapshotJsonValue[] | SnapshotJsonObject;
+export interface SnapshotJsonObject {
+    [key: string]: SnapshotJsonValue;
+}
+export type SnapshotSlotsRecord = Record<string, SnapshotJsonValue>;
+export type InlineSnapshotSlotPayload = SnapshotJsonObject & {
+    kind?: string | null;
+    source?: string | null;
+    inline?: boolean | null;
+    content?: SnapshotJsonValue;
+    integrity_hash?: string | null;
+};
+export type SnapshotIntegrityFailureReason = 'malformed_slots_json' | 'invalid_slots_root' | 'missing_inline_integrity_hash' | 'inline_hash_mismatch' | 'slots_hash_mismatch';
+export interface SnapshotIntegrityFailure {
+    slotKey: string;
+    reason: SnapshotIntegrityFailureReason;
+    expected?: string;
+    actual?: string;
+    error?: string;
+}
+export interface SnapshotIntegrityVerification {
+    ok: boolean;
+    slots: SnapshotSlotsRecord | null;
+    actualSlotsHash: string | null;
+    failures: SnapshotIntegrityFailure[];
+}
+export declare function canonicalizeSnapshotJson(value: unknown): string;
+export declare function hashSnapshotJson(value: unknown): string;
+export declare function parseSnapshotSlotsJson(raw: string): SnapshotSlotsRecord;
+export declare function isInlineSnapshotSlotPayload(value: SnapshotJsonValue): value is InlineSnapshotSlotPayload;
+export declare function computeInlineIntegrityHash(payload: InlineSnapshotSlotPayload): string;
+export declare function attachInlineIntegrityHash(payload: InlineSnapshotSlotPayload): InlineSnapshotSlotPayload;
+export declare function computeSlotsIntegrityHash(slots: SnapshotSlotsRecord): string;
+export declare function verifySnapshotSlotsIntegrity(slotsInput: SnapshotSlotsRecord | string, expectedSlotsHash?: string): SnapshotIntegrityVerification;
+//# sourceMappingURL=composition-snapshot-integrity.d.ts.map

package/dist/composition-snapshot-integrity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composition-snapshot-integrity.d.ts","sourceRoot":"","sources":["../src/composition-snapshot-integrity.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;AACrE,MAAM,MAAM,iBAAiB,GAAG,qBAAqB,GAAG,iBAAiB,EAAE,GAAG,kBAAkB,CAAC;AACjG,MAAM,WAAW,kBAAkB;IACjC,CAAC,GAAG,EAAE,MAAM,GAAG,iBAAiB,CAAC;CAClC;AACD,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;AAEpE,MAAM,MAAM,yBAAyB,GAAG,kBAAkB,GAAG;IAC3D,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IACxB,OAAO,CAAC,EAAE,iBAAiB,CAAC;IAC5B,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,8BAA8B,GACtC,sBAAsB,GACtB,oBAAoB,GACpB,+BAA+B,GAC/B,sBAAsB,GACtB,qBAAqB,CAAC;AAE1B,MAAM,WAAW,wBAAwB;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,8BAA8B,CAAC;IACvC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,6BAA6B;IAC5C,EAAE,EAAE,OAAO,CAAC;IACZ,KAAK,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAClC,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,QAAQ,EAAE,wBAAwB,EAAE,CAAC;CACtC;AAsCD,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAE/D;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEvD;AAED,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,mBAAmB,CAcvE;AAED,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,iBAAiB,GAAG,KAAK,IAAI,yBAAyB,CAGxG;AAOD,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,yBAAyB,GAAG,MAAM,CAErF;AAED,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,yBAAyB,GAAG,yBAAyB,CAKvG;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,mBAAmB,GAAG,MAAM,CAE5E;AAED,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,mBAAmB,GAAG,MAAM,EACxC,iBAAiB,CAAC,EAAE,MAAM,GACzB,6BAA6B,CA4D/B"}

package/dist/composition-snapshot-integrity.js

@@ -0,0 +1,131 @@
+import { createHash } from 'node:crypto';
+function isFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function isPlainObject(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+function normalizeSnapshotJson(value) {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean') {
+        return value;
+    }
+    if (isFiniteNumber(value)) {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map(entry => normalizeSnapshotJson(entry));
+    }
+    if (isPlainObject(value)) {
+        const out = {};
+        for (const key of Object.keys(value).sort()) {
+            const next = value[key];
+            if (next === undefined)
+                continue;
+            out[key] = normalizeSnapshotJson(next);
+        }
+        return out;
+    }
+    throw new TypeError(`Unsupported snapshot JSON value: ${String(value)}`);
+}
+export function canonicalizeSnapshotJson(value) {
+    return JSON.stringify(normalizeSnapshotJson(value));
+}
+export function hashSnapshotJson(value) {
+    return createHash('sha256').update(canonicalizeSnapshotJson(value)).digest('hex');
+}
+export function parseSnapshotSlotsJson(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Malformed slots_json: ${message}`);
+    }
+    if (!isPlainObject(parsed)) {
+        throw new Error('Invalid slots_json root: expected object');
+    }
+    return normalizeSnapshotJson(parsed);
+}
+export function isInlineSnapshotSlotPayload(value) {
+    if (!isPlainObject(value))
+        return false;
+    return value.kind === 'inline' || value.source === 'inline' || value.inline === true;
+}
+function stripInlineIntegrityHash(payload) {
+    const { integrity_hash: _integrityHash, ...rest } = payload;
+    return normalizeSnapshotJson(rest);
+}
+export function computeInlineIntegrityHash(payload) {
+    return hashSnapshotJson(stripInlineIntegrityHash(payload));
+}
+export function attachInlineIntegrityHash(payload) {
+    return {
+        ...payload,
+        integrity_hash: computeInlineIntegrityHash(payload),
+    };
+}
+export function computeSlotsIntegrityHash(slots) {
+    return hashSnapshotJson(slots);
+}
+export function verifySnapshotSlotsIntegrity(slotsInput, expectedSlotsHash) {
+    let slots;
+    try {
+        slots = typeof slotsInput === 'string'
+            ? parseSnapshotSlotsJson(slotsInput)
+            : normalizeSnapshotJson(slotsInput);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const reason = message.startsWith('Invalid slots_json root')
+            ? 'invalid_slots_root'
+            : 'malformed_slots_json';
+        return {
+            ok: false,
+            slots: null,
+            actualSlotsHash: null,
+            failures: [{ slotKey: '$slots', reason, error: message }],
+        };
+    }
+    const failures = [];
+    for (const [slotKey, slotValue] of Object.entries(slots)) {
+        if (!isInlineSnapshotSlotPayload(slotValue))
+            continue;
+        const actualField = slotValue.integrity_hash;
+        if (typeof actualField !== 'string' || actualField.length === 0) {
+            failures.push({
+                slotKey,
+                reason: 'missing_inline_integrity_hash',
+            });
+            continue;
+        }
+        const expectedField = computeInlineIntegrityHash(slotValue);
+        if (actualField !== expectedField) {
+            failures.push({
+                slotKey,
+                reason: 'inline_hash_mismatch',
+                expected: expectedField,
+                actual: actualField,
+            });
+        }
+    }
+    const actualSlotsHash = computeSlotsIntegrityHash(slots);
+    if (expectedSlotsHash && actualSlotsHash !== expectedSlotsHash) {
+        failures.push({
+            slotKey: '$slots',
+            reason: 'slots_hash_mismatch',
+            expected: expectedSlotsHash,
+            actual: actualSlotsHash,
+        });
+    }
+    return {
+        ok: failures.length === 0,
+        slots,
+        actualSlotsHash,
+        failures,
+    };
+}
+//# sourceMappingURL=composition-snapshot-integrity.js.map

package/dist/composition-snapshot-runtime.d.ts

@@ -0,0 +1,59 @@
+import type { NeutralMessage, StoredMessage } from './types.js';
+import { type SnapshotSlotsRecord } from './composition-snapshot-integrity.js';
+interface BuildCompositionSnapshotSlotsInput {
+    system: string | null | undefined;
+    identity: string | null | undefined;
+    repairNotice?: string | null | undefined;
+    messages: NeutralMessage[];
+    contextBlock?: string;
+}
+export interface RestoredWarmSnapshotState {
+    system?: string;
+    identity?: string;
+    history: StoredMessage[];
+    diagnostics: WarmSnapshotRestoreDiagnostics;
+}
+export interface WarmSnapshotRestoreDiagnostics {
+    sourceProvider: string | null;
+    targetProvider: string | null;
+    crossProviderBoundary: boolean;
+    requiredSlotDrops: string[];
+    requiredSlotDropRate: number;
+    stablePrefixBoundaryViolations: number;
+    toolPairParityViolations: number;
+    crossProviderAssistantTurns: number;
+    quotedAssistantTurns: number;
+    continuityCriticalBoundaryTransformCount: number;
+    continuityCriticalBoundaryTransformRate: number;
+    tokenParityDriftSampleCount: number;
+    tokenParityDriftP95: number;
+    tokenParityDriftP99: number;
+    rolloutGatePassed: boolean;
+    rolloutGateViolations: WarmRestoreRolloutGateViolation[];
+}
+export interface WarmRestoreRolloutGateViolation {
+    gate: keyof typeof WARM_RESTORE_MEASUREMENT_GATES;
+    actual: number;
+    max: number;
+}
+export interface RestoreWarmSnapshotOptions {
+    sourceProvider?: string | null;
+    targetProvider?: string | null;
+}
+export declare const WARM_RESTORE_MEASUREMENT_GATES: Readonly<{
+    tokenParityDriftP95Max: 0.03;
+    tokenParityDriftP99Max: 0.05;
+    requiredSlotDropRateMax: 0;
+    stablePrefixBoundaryViolationsMax: 0;
+    toolPairParityViolationsMax: 0;
+    crossProviderAssistantTurnsMax: 0;
+    continuityCriticalBoundaryTransformRateMax: 0.005;
+}>;
+export declare function evaluateWarmRestoreRolloutGate(diagnostics: Pick<WarmSnapshotRestoreDiagnostics, 'tokenParityDriftP95' | 'tokenParityDriftP99' | 'requiredSlotDropRate' | 'stablePrefixBoundaryViolations' | 'toolPairParityViolations' | 'crossProviderAssistantTurns' | 'continuityCriticalBoundaryTransformRate'>): {
+    passed: boolean;
+    violations: WarmRestoreRolloutGateViolation[];
+};
+export declare function buildCompositionSnapshotSlots(input: BuildCompositionSnapshotSlotsInput): SnapshotSlotsRecord;
+export declare function restoreWarmSnapshotState(slots: SnapshotSlotsRecord, options?: RestoreWarmSnapshotOptions): RestoredWarmSnapshotState | null;
+export {};
+//# sourceMappingURL=composition-snapshot-runtime.d.ts.map

package/dist/composition-snapshot-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composition-snapshot-runtime.d.ts","sourceRoot":"","sources":["../src/composition-snapshot-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAChE,OAAO,EAGL,KAAK,mBAAmB,EACzB,MAAM,qCAAqC,CAAC;AAE7C,UAAU,kCAAkC;IAC1C,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAClC,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACpC,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACzC,QAAQ,EAAE,cAAc,EAAE,CAAC;IAC3B,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,yBAAyB;IACxC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,WAAW,EAAE,8BAA8B,CAAC;CAC7C;AAED,MAAM,WAAW,8BAA8B;IAC7C,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,qBAAqB,EAAE,OAAO,CAAC;IAC/B,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,oBAAoB,EAAE,MAAM,CAAC;IAC7B,8BAA8B,EAAE,MAAM,CAAC;IACvC,wBAAwB,EAAE,MAAM,CAAC;IACjC,2BAA2B,EAAE,MAAM,CAAC;IACpC,oBAAoB,EAAE,MAAM,CAAC;IAC7B,wCAAwC,EAAE,MAAM,CAAC;IACjD,uCAAuC,EAAE,MAAM,CAAC;IAChD,2BAA2B,EAAE,MAAM,CAAC;IACpC,mBAAmB,EAAE,MAAM,CAAC;IAC5B,mBAAmB,EAAE,MAAM,CAAC;IAC5B,iBAAiB,EAAE,OAAO,CAAC;IAC3B,qBAAqB,EAAE,+BAA+B,EAAE,CAAC;CAC1D;AAED,MAAM,WAAW,+BAA+B;IAC9C,IAAI,EAAE,MAAM,OAAO,8BAA8B,CAAC;IAClD,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,0BAA0B;IACzC,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAChC;AAED,eAAO,MAAM,8BAA8B;;;;;;;;EAQzC,CAAC;AAEH,wBAAgB,8BAA8B,CAC5C,WAAW,EAAE,IAAI,CAAC,8BAA8B,EAC5C,qBAAqB,GACrB,qBAAqB,GACrB,sBAAsB,GACtB,gCAAgC,GAChC,0BAA0B,GAC1B,6BAA6B,GAC7B,yCAAyC,CAC5C,GACA;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,+BAA+B,EAAE,CAAA;CAAE,CAgBpE;AA2BD,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,kCAAkC,GAAG,mBAAmB,CAwB5G;AAwHD,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,mBAAmB,EAC1B,OAAO,CAAC,EAAE,0BAA0B,GACnC,yBAAyB,GAAG,IAAI,CA8ElC"}

package/dist/composition-snapshot-runtime.js

@@ -0,0 +1,250 @@
+import { isInlineSnapshotSlotPayload, } from './composition-snapshot-integrity.js';
+export const WARM_RESTORE_MEASUREMENT_GATES = Object.freeze({
+    tokenParityDriftP95Max: 0.03,
+    tokenParityDriftP99Max: 0.05,
+    requiredSlotDropRateMax: 0,
+    stablePrefixBoundaryViolationsMax: 0,
+    toolPairParityViolationsMax: 0,
+    crossProviderAssistantTurnsMax: 0,
+    continuityCriticalBoundaryTransformRateMax: 0.005,
+});
+export function evaluateWarmRestoreRolloutGate(diagnostics) {
+    const violations = [];
+    const check = (gate, actual) => {
+        const max = WARM_RESTORE_MEASUREMENT_GATES[gate];
+        if (actual > max)
+            violations.push({ gate, actual, max });
+    };
+    check('tokenParityDriftP95Max', diagnostics.tokenParityDriftP95);
+    check('tokenParityDriftP99Max', diagnostics.tokenParityDriftP99);
+    check('requiredSlotDropRateMax', diagnostics.requiredSlotDropRate);
+    check('stablePrefixBoundaryViolationsMax', diagnostics.stablePrefixBoundaryViolations);
+    check('toolPairParityViolationsMax', diagnostics.toolPairParityViolations);
+    check('crossProviderAssistantTurnsMax', diagnostics.crossProviderAssistantTurns);
+    check('continuityCriticalBoundaryTransformRateMax', diagnostics.continuityCriticalBoundaryTransformRate);
+    return { passed: violations.length === 0, violations };
+}
+function toSnapshotInlineContent(content) {
+    return { kind: 'inline', content };
+}
+function normalizeSnapshotMessage(message) {
+    const base = {
+        role: message.role,
+        textContent: message.textContent,
+        toolCalls: message.toolCalls,
+        toolResults: message.toolResults,
+    };
+    const stored = message;
+    if (typeof stored.id === 'number')
+        base.id = stored.id;
+    if (typeof stored.conversationId === 'number')
+        base.conversationId = stored.conversationId;
+    if (typeof stored.agentId === 'string')
+        base.agentId = stored.agentId;
+    if (typeof stored.messageIndex === 'number')
+        base.messageIndex = stored.messageIndex;
+    if (typeof stored.tokenCount === 'number' || stored.tokenCount === null)
+        base.tokenCount = stored.tokenCount ?? null;
+    if (typeof stored.isHeartbeat === 'boolean')
+        base.isHeartbeat = stored.isHeartbeat;
+    if (typeof stored.createdAt === 'string')
+        base.createdAt = stored.createdAt;
+    if (message.metadata && typeof message.metadata === 'object')
+        base.metadata = message.metadata;
+    return base;
+}
+export function buildCompositionSnapshotSlots(input) {
+    const stablePrefix = input.messages
+        .filter(message => message.role === 'system')
+        .map(message => normalizeSnapshotMessage(message));
+    const history = input.messages
+        .filter(message => message.role !== 'system')
+        .map(message => normalizeSnapshotMessage(message));
+    const slots = {
+        system: toSnapshotInlineContent(input.system ?? ''),
+        identity: toSnapshotInlineContent(input.identity ?? ''),
+        stable_prefix: toSnapshotInlineContent(stablePrefix),
+        history: toSnapshotInlineContent(history),
+    };
+    if (input.repairNotice) {
+        slots.repair_notice = toSnapshotInlineContent(input.repairNotice);
+    }
+    if (input.contextBlock) {
+        slots.context_block = toSnapshotInlineContent(input.contextBlock);
+    }
+    return slots;
+}
+function extractInlineContent(slotValue) {
+    if (!slotValue || !isInlineSnapshotSlotPayload(slotValue))
+        return undefined;
+    return slotValue.content;
+}
+function isMessageRole(value) {
+    return value === 'user' || value === 'assistant' || value === 'system';
+}
+function restoreStoredMessages(value) {
+    if (!Array.isArray(value))
+        return null;
+    const restored = [];
+    for (const entry of value) {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry))
+            return null;
+        const row = entry;
+        if (!isMessageRole(row.role) || row.role === 'system')
+            return null;
+        if (row.textContent !== null && typeof row.textContent !== 'string')
+            return null;
+        restored.push({
+            id: typeof row.id === 'number' ? row.id : 0,
+            conversationId: typeof row.conversationId === 'number' ? row.conversationId : 0,
+            agentId: typeof row.agentId === 'string' ? row.agentId : '',
+            role: row.role,
+            textContent: row.textContent ?? null,
+            toolCalls: Array.isArray(row.toolCalls) ? row.toolCalls : null,
+            toolResults: Array.isArray(row.toolResults) ? row.toolResults : null,
+            metadata: typeof row.metadata === 'object' && row.metadata !== null && !Array.isArray(row.metadata)
+                ? row.metadata
+                : undefined,
+            messageIndex: typeof row.messageIndex === 'number' ? row.messageIndex : 0,
+            tokenCount: typeof row.tokenCount === 'number' ? row.tokenCount : null,
+            isHeartbeat: typeof row.isHeartbeat === 'boolean' ? row.isHeartbeat : false,
+            createdAt: typeof row.createdAt === 'string' ? row.createdAt : new Date(0).toISOString(),
+        });
+    }
+    return restored;
+}
+function estimateTextTokens(text) {
+    if (!text)
+        return 0;
+    return Math.ceil(text.length / 4);
+}
+function estimateToolTokens(value) {
+    if (!value)
+        return 0;
+    return Math.ceil(JSON.stringify(value).length / 2);
+}
+function estimateStoredMessageTokens(message) {
+    return estimateTextTokens(message.textContent)
+        + estimateToolTokens(message.toolCalls)
+        + estimateToolTokens(message.toolResults)
+        + 4;
+}
+function computeRelativeTokenDrift(baselineTokens, restoredTokens) {
+    if (baselineTokens <= 0)
+        return restoredTokens > 0 ? 1 : 0;
+    return Math.abs(restoredTokens - baselineTokens) / baselineTokens;
+}
+function computePercentile(values, percentile) {
+    if (values.length === 0)
+        return 0;
+    const sorted = [...values].sort((a, b) => a - b);
+    const rank = Math.min(sorted.length - 1, Math.max(0, Math.ceil(sorted.length * percentile) - 1));
+    return sorted[rank] ?? 0;
+}
+function quoteForeignProviderAssistantTurns(history, sourceProvider, targetProvider) {
+    if (!sourceProvider || !targetProvider || sourceProvider === targetProvider) {
+        return { history, quotedAssistantTurns: 0, toolPairParityViolations: 0 };
+    }
+    let quotedAssistantTurns = 0;
+    let toolPairParityViolations = 0;
+    const quotedHistory = history.map(message => {
+        if (message.role !== 'assistant')
+            return message;
+        quotedAssistantTurns++;
+        const hadToolPayload = Boolean((message.toolCalls && message.toolCalls.length > 0)
+            || (message.toolResults && message.toolResults.length > 0));
+        if (hadToolPayload)
+            toolPairParityViolations++;
+        const quotedText = (message.textContent && message.textContent.trim().length > 0)
+            ? `"""${message.textContent.trim()}"""`
+            : '[no text content retained]';
+        const prefix = `Historical assistant turn from ${sourceProvider} provider, quoted for ${targetProvider} replay.`;
+        const toolGap = hadToolPayload
+            ? '[tool call/result payload omitted at cross-provider boundary]'
+            : null;
+        return {
+            ...message,
+            role: 'user',
+            textContent: [prefix, quotedText, toolGap].filter(Boolean).join('\n'),
+            toolCalls: null,
+            toolResults: null,
+            metadata: {
+                ...(message.metadata || {}),
+                _historicalQuote: true,
+                _quotedFromRole: 'assistant',
+                _quotedSourceProvider: sourceProvider,
+                _quotedTargetProvider: targetProvider,
+            },
+        };
+    });
+    return { history: quotedHistory, quotedAssistantTurns, toolPairParityViolations };
+}
+export function restoreWarmSnapshotState(slots, options) {
+    const requiredSlotDrops = [];
+    if (extractInlineContent(slots.system) === undefined)
+        requiredSlotDrops.push('system');
+    if (extractInlineContent(slots.identity) === undefined)
+        requiredSlotDrops.push('identity');
+    if (extractInlineContent(slots.history) === undefined)
+        requiredSlotDrops.push('history');
+    const stablePrefixBoundaryViolations = Array.isArray(extractInlineContent(slots.stable_prefix)) ? 0 : 1;
+    const history = restoreStoredMessages(extractInlineContent(slots.history));
+    if (!history || history.length === 0)
+        return null;
+    const sourceProvider = options?.sourceProvider ?? null;
+    const targetProvider = options?.targetProvider ?? null;
+    const quoted = quoteForeignProviderAssistantTurns(history, sourceProvider, targetProvider);
+    const continuityCriticalBoundaryTransformCount = quoted.quotedAssistantTurns;
+    const continuityCriticalBoundaryTransformRate = quoted.history.length > 0
+        ? continuityCriticalBoundaryTransformCount / quoted.history.length
+        : 0;
+    const restoreStringSlot = (key) => {
+        const value = extractInlineContent(slots[key]);
+        return typeof value === 'string' && value.length > 0 ? value : undefined;
+    };
+    const restoredSystem = restoreStringSlot('system');
+    const restoredIdentity = restoreStringSlot('identity');
+    const tokenParityDriftSamples = [];
+    const originalSystem = extractInlineContent(slots.system);
+    if (typeof originalSystem === 'string' && restoredSystem !== undefined) {
+        tokenParityDriftSamples.push(computeRelativeTokenDrift(estimateTextTokens(originalSystem), estimateTextTokens(restoredSystem)));
+    }
+    const originalIdentity = extractInlineContent(slots.identity);
+    if (typeof originalIdentity === 'string' && restoredIdentity !== undefined) {
+        tokenParityDriftSamples.push(computeRelativeTokenDrift(estimateTextTokens(originalIdentity), estimateTextTokens(restoredIdentity)));
+    }
+    for (let i = 0; i < history.length && i < quoted.history.length; i++) {
+        tokenParityDriftSamples.push(computeRelativeTokenDrift(estimateStoredMessageTokens(history[i]), estimateStoredMessageTokens(quoted.history[i])));
+    }
+    const baseDiagnostics = {
+        sourceProvider,
+        targetProvider,
+        crossProviderBoundary: Boolean(sourceProvider && targetProvider && sourceProvider !== targetProvider),
+        requiredSlotDrops,
+        requiredSlotDropRate: requiredSlotDrops.length / 3,
+        stablePrefixBoundaryViolations,
+        toolPairParityViolations: quoted.toolPairParityViolations,
+        crossProviderAssistantTurns: quoted.quotedAssistantTurns,
+        quotedAssistantTurns: quoted.quotedAssistantTurns,
+        continuityCriticalBoundaryTransformCount,
+        continuityCriticalBoundaryTransformRate,
+        tokenParityDriftSampleCount: tokenParityDriftSamples.length,
+        tokenParityDriftP95: computePercentile(tokenParityDriftSamples, 0.95),
+        tokenParityDriftP99: computePercentile(tokenParityDriftSamples, 0.99),
+    };
+    const rolloutGate = evaluateWarmRestoreRolloutGate(baseDiagnostics);
+    return {
+        system: restoredSystem,
+        identity: restoredIdentity,
+        history: quoted.history.map(message => ({
+            ...message,
+            metadata: { ...(message.metadata || {}), _warmed: true },
+        })),
+        diagnostics: {
+            ...baseDiagnostics,
+            rolloutGatePassed: rolloutGate.passed,
+            rolloutGateViolations: rolloutGate.violations,
+        },
+    };
+}
+//# sourceMappingURL=composition-snapshot-runtime.js.map