@mono-agent/agent-app 0.11.3 → 0.11.4

package/dist/continuation-store.js

@@ -1,106 +1,21 @@
-import { randomBytes, randomUUID } from "node:crypto";
-import { constants as fsConstants } from "node:fs";
-import { chmod, lstat, mkdir, open, readdir, readFile, rename, rm, writeFile, } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { AGENT_CONTINUATION_ORIGIN_CONTEXT_MAX_BYTES, AGENT_CONTINUATION_ORIGIN_CONTEXT_MAX_MESSAGE_BYTES, AGENT_CONTINUATION_ORIGIN_CONTEXT_MAX_MESSAGES, assertAgentContinuationOriginContext, } from "@mono-agent/agent-contracts";
-import { canonicalContinuationJson, continuationDigest, isContinuationMode, isContinuationState, TERMINAL_CONTINUATION_STATES, } from "./continuations.js";
-export const CONTINUATION_STORE_SCHEMA_VERSION = 1;
-export const CONTINUATION_RECORD_STORE_SCHEMA_VERSION = 3;
-const RECORDS_DIRECTORY = "records-v3";
-const TRANSACTION_FILE = "continuation-transaction-v3.json";
-const MANIFEST_FILE = "continuation-store-v3.json";
-const LEGACY_RECORDS_DIRECTORY = "records-v2";
-const LEGACY_TRANSACTION_FILE = "continuation-transaction-v2.json";
-const V2_ROLLBACK_GUARD = "UPGRADED-TO-RECORDS-V3";
-const ORIGIN_CONTEXT_GROUPS_DIRECTORY = "origin-context-groups-v1";
-const OWNER_DATABASE_FILE = "continuations-owner.sqlite";
-const ORIGIN_CONTEXTS_DIRECTORY = "origin-context-v1";
-const MAX_RECORD_BYTES = 2 * 1024 * 1024;
-const MAX_TRANSACTION_BYTES = 16 * 1024 * 1024;
-const DEFAULT_TERMINAL_MAX_RECORDS = 50_000;
-const DEFAULT_TERMINAL_MAX_AGE_MS = 365 * 24 * 60 * 60 * 1_000;
-const DEFAULT_CAPTURED_TEXT_MAX_RECORDS = 1_000;
-const DEFAULT_CAPTURED_TEXT_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1_000;
-export const MAX_CONTINUATION_ORIGIN_CONTEXT_BYTES = AGENT_CONTINUATION_ORIGIN_CONTEXT_MAX_BYTES;
-export const MAX_CONTINUATION_ORIGIN_CONTEXT_MESSAGES = AGENT_CONTINUATION_ORIGIN_CONTEXT_MAX_MESSAGES;
-export const MAX_CONTINUATION_ORIGIN_CONTEXT_MESSAGE_BYTES = AGENT_CONTINUATION_ORIGIN_CONTEXT_MAX_MESSAGE_BYTES;
-export const MAX_CONTINUATION_ORIGIN_CONTEXT_STORE_BYTES = 256 * 1024 * 1024;
-/**
- * Claim exclusive ownership of a continuation state directory for this process.
- * SQLite holds an OS-backed exclusive transaction for the process lifetime.
- * There is no stale-path cleanup race: close or process death releases the OS
- * lock, and SQLite performs any required journal recovery for the next owner.
- */
-export async function acquireContinuationStoreLock(stateDir) {
-    await ensureOwnerOnlyDirectory(stateDir);
-    const path = join(stateDir, OWNER_DATABASE_FILE);
-    let database;
-    try {
-        if (await continuationPathExists(path)) {
-            await assertOwnerOnlyRegularFile(path, "Continuation owner database");
-        }
-        const { DatabaseSync } = await import("node:sqlite");
-        database = new DatabaseSync(path, { timeout: 0 });
-        if (process.platform !== "win32")
-            await chmod(path, 0o600);
-        await assertOwnerOnlyRegularFile(path, "Continuation owner database");
-        database.exec("PRAGMA journal_mode=DELETE; PRAGMA locking_mode=EXCLUSIVE; BEGIN EXCLUSIVE");
-        database.exec(`
-      CREATE TABLE IF NOT EXISTS ownership (
-        id INTEGER PRIMARY KEY CHECK (id = 1),
-        pid INTEGER NOT NULL,
-        acquired_at TEXT NOT NULL
-      );
-    `);
-        database.prepare(`
-      INSERT INTO ownership (id, pid, acquired_at)
-      VALUES (1, ?, ?)
-      ON CONFLICT(id) DO UPDATE SET pid = excluded.pid, acquired_at = excluded.acquired_at
-    `).run(process.pid, new Date().toISOString());
-        const journalPath = `${path}-journal`;
-        if (process.platform !== "win32" && await continuationPathExists(journalPath)) {
-            await chmod(journalPath, 0o600);
-        }
-    }
-    catch (error) {
-        try {
-            database?.close();
-        }
-        catch { /* best-effort close after failed acquisition */ }
-        if (isObject(error) && error.code === "ERR_SQLITE_ERROR" && String(error.message).includes("database is locked")) {
-            throw new Error(`Continuation state is already owned by another live process: ${stateDir}`, { cause: error });
-        }
-        throw error;
-    }
-    let released = false;
-    const owner = database;
-    return {
-        async release() {
-            if (released)
-                return;
-            released = true;
-            try {
-                if (owner.isTransaction)
-                    owner.exec("ROLLBACK");
-            }
-            finally {
-                owner.close();
-            }
-        },
-    };
-}
-/**
- * Open the bounded per-record store. Each continuation has its own atomic 0600
- * file, so a result mutates O(1) durable data instead of rewriting every prior
- * payload. A tiny write-ahead transaction makes multi-record maintenance
- * restart-safe. The legacy v1 monolith is migrated idempotently on first open.
- */
+import { randomUUID } from "node:crypto";
+import { readdir, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { assertAgentContinuationOriginContext, } from "@mono-agent/agent-contracts";
+import { canonicalContinuationJson } from "./continuations.js";
+import { OriginContextCorruptionError, applyOriginContextGroupCommit, applyOriginContextGroupCommits, cleanOriginContextGroupTemporaries, loadOriginContextGroupCommit, originContextDigest, originContextStoreBytes, prepareOriginContextGroupCommit, readOriginContextCanonical, referencedOriginContextDigests, releasePendingOriginPin, removeOriginContextGroupCommits, sweepOriginContextBlobs, } from "./continuation-origin-store.js";
+import { continuationPathExists, ensureOwnerOnlyDirectory, readBoundedOwnerOnlyFile, syncDirectory, writeJsonAtomic, writeTextAtomic, } from "./continuation-store-fs.js";
+import { applyRetention, cloneRecord, cloneRecords, continuationStoreStats, isMissing, isOriginContextReference, normalizeLegacyContinuationRecords, replaceRecords, requiredDate, requiredString, resolveRetention, } from "./continuation-store-policy.js";
+import { assertV3Manifest, loadLegacyStore, loadRecordDirectory, mergeMigrationRecords, persistManifest, persistRecordChanges, recoverRecordTransaction, } from "./continuation-store-records.js";
+import { CONTINUATION_RECORD_STORE_SCHEMA_VERSION, LEGACY_RECORDS_DIRECTORY, LEGACY_TRANSACTION_FILE, MANIFEST_FILE, MAX_CONTINUATION_ORIGIN_CONTEXT_BYTES, MAX_CONTINUATION_ORIGIN_CONTEXT_MESSAGES, MAX_CONTINUATION_ORIGIN_CONTEXT_MESSAGE_BYTES, MAX_CONTINUATION_ORIGIN_CONTEXT_STORE_BYTES, ORIGIN_CONTEXT_GROUPS_DIRECTORY, ORIGIN_CONTEXTS_DIRECTORY, RECORDS_DIRECTORY, TRANSACTION_FILE, V2_ROLLBACK_GUARD, } from "./continuation-store-types.js";
+const V2_ROLLBACK_GUARD_CONTENT = "This state directory uses continuation records v3. Older runtimes must not open records-v2.\n";
+export { acquireContinuationStoreLock, loadOrCreateContinuationSecret, } from "./continuation-store-fs.js";
+export { CONTINUATION_RECORD_STORE_SCHEMA_VERSION, CONTINUATION_STORE_SCHEMA_VERSION, MAX_CONTINUATION_ORIGIN_CONTEXT_BYTES, MAX_CONTINUATION_ORIGIN_CONTEXT_MESSAGES, MAX_CONTINUATION_ORIGIN_CONTEXT_MESSAGE_BYTES, MAX_CONTINUATION_ORIGIN_CONTEXT_STORE_BYTES, } from "./continuation-store-types.js";
 export async function openContinuationStore(stateDir, options = {}) {
     await ensureOwnerOnlyDirectory(stateDir);
     const recordsDir = join(stateDir, RECORDS_DIRECTORY);
     await ensureOwnerOnlyDirectory(recordsDir);
     const legacyRecordsDir = join(stateDir, LEGACY_RECORDS_DIRECTORY);
-    await ensureOwnerOnlyDirectory(legacyRecordsDir);
     const originContextsDir = join(stateDir, ORIGIN_CONTEXTS_DIRECTORY);
     await ensureOwnerOnlyDirectory(originContextsDir);
     const originContextGroupsDir = join(stateDir, ORIGIN_CONTEXT_GROUPS_DIRECTORY);
@@ -108,52 +23,140 @@ export async function openContinuationStore(stateDir, options = {}) {
     const transactionPath = join(stateDir, TRANSACTION_FILE);
     const manifestPath = join(stateDir, MANIFEST_FILE);
     const legacyPath = join(stateDir, "continuations-v1.json");
+    const legacyManifestPath = join(stateDir, "continuation-store-v2.json");
     const legacyTransactionPath = join(stateDir, LEGACY_TRANSACTION_FILE);
     const rollbackGuardPath = join(legacyRecordsDir, V2_ROLLBACK_GUARD);
     const policy = resolveRetention(options.retention);
     const now = options.now ?? (() => new Date());
     const manifestExists = await continuationPathExists(manifestPath);
-    if (manifestExists)
-        await assertV3Manifest(manifestPath);
-    // Finish any v2 transaction before installing the rollback guard. Once the
-    // guard exists, v0.10 fails closed while v3 deliberately leaves the v2/v1
-    // evidence untouched for audit and manual recovery.
-    if (!await continuationPathExists(rollbackGuardPath)) {
-        await recoverRecordTransaction(legacyRecordsDir, legacyTransactionPath, 2);
-    }
-    const recoveredGeneration = await recoverRecordTransaction(recordsDir, transactionPath, CONTINUATION_RECORD_STORE_SCHEMA_VERSION);
-    const records = await loadRecordDirectory(recordsDir);
-    const beforeOpen = cloneRecords(records);
-    normalizeLegacyContinuationRecords(records);
-    if (!manifestExists) {
-        const migrationSource = await loadRecordDirectory(legacyRecordsDir, new Set([V2_ROLLBACK_GUARD]));
+    const manifest = manifestExists ? await assertV3Manifest(manifestPath) : undefined;
+    // Fieldless manifests were written by the eager-guard implementation, so
+    // they remain permanently fenced. Only a new explicit false opens the one
+    // clean rollback window for an empty store.
+    const manifestRollbackGuardRequired = manifest === undefined
+        ? false
+        : manifest.rollbackGuardRequired ?? true;
+    let legacyRecordsDirectoryExists = await continuationPathExists(legacyRecordsDir);
+    if (legacyRecordsDirectoryExists)
+        await ensureOwnerOnlyDirectory(legacyRecordsDir);
+    const ensureLegacyRecordsDirectory = async () => {
+        if (legacyRecordsDirectoryExists)
+            return;
+        await ensureOwnerOnlyDirectory(legacyRecordsDir);
+        await syncDirectory(stateDir);
+        legacyRecordsDirectoryExists = true;
+    };
+    let rollbackGuardInstalled = legacyRecordsDirectoryExists
+        ? await continuationPathExists(rollbackGuardPath)
+        : false;
+    let rollbackGuardValidated = false;
+    const ensureV2RollbackGuard = async () => {
+        if (rollbackGuardValidated)
+            return;
+        await ensureLegacyRecordsDirectory();
+        if (!rollbackGuardInstalled) {
+            await writeTextAtomic(rollbackGuardPath, V2_ROLLBACK_GUARD_CONTENT, 4 * 1024);
+            rollbackGuardInstalled = true;
+        }
+        const contents = await readBoundedOwnerOnlyFile(rollbackGuardPath, 4 * 1024, "Continuation v2 rollback guard");
+        if (contents !== V2_ROLLBACK_GUARD_CONTENT) {
+            throw new Error(`Continuation v2 rollback guard contents are invalid: ${rollbackGuardPath}`);
+        }
+        rollbackGuardValidated = true;
+    };
+    const isCommittedEntry = (entry) => !(entry.startsWith(".") && entry.endsWith(".tmp"));
+    const v3StateExists = await continuationPathExists(transactionPath)
+        || (await readdir(recordsDir)).some(isCommittedEntry)
+        || (await readdir(originContextGroupsDir)).some(isCommittedEntry);
+    if (manifestRollbackGuardRequired) {
+        if (!rollbackGuardInstalled) {
+            throw new Error(`Continuation v2 rollback guard is missing from activated v3 state: ${rollbackGuardPath}`);
+        }
+        await ensureV2RollbackGuard();
+    }
+    else if (v3StateExists) {
+        // Preserve recovery of an interrupted first v3 transaction or activation:
+        // fence the legacy reader before inspecting or replaying that evidence.
+        await ensureV2RollbackGuard();
+    }
+    const legacyStateExists = legacyRecordsDirectoryExists
+        || await continuationPathExists(legacyPath)
+        || await continuationPathExists(legacyManifestPath)
+        || await continuationPathExists(legacyTransactionPath);
+    const migrationRequired = legacyStateExists && !manifestRollbackGuardRequired;
+    let migrationSource;
+    if (migrationRequired) {
+        // A guard can already exist after an interrupted migration. Validate it
+        // before touching state, but always finish any admitted v2 transaction:
+        // the guard does not itself prove that v2 replay completed.
+        if (rollbackGuardInstalled)
+            await ensureV2RollbackGuard();
+        if (await continuationPathExists(legacyTransactionPath)) {
+            await ensureLegacyRecordsDirectory();
+            await recoverRecordTransaction(legacyRecordsDir, legacyTransactionPath, 2);
+        }
+        migrationSource = legacyRecordsDirectoryExists
+            ? await loadRecordDirectory(legacyRecordsDir, new Set([V2_ROLLBACK_GUARD]))
+            : new Map();
         normalizeLegacyContinuationRecords(migrationSource);
         if (await continuationPathExists(legacyPath)) {
             const legacy = await loadLegacyStore(legacyPath);
             normalizeLegacyContinuationRecords(legacy);
             mergeMigrationRecords(migrationSource, legacy, "v1 and v2");
         }
-        // Install the old-reader poison before the first v3 record becomes active.
-        // A crash on either side is restart-safe: v3 repeats a semantic merge, and
-        // v0.10 cannot start against a stale v2 snapshot.
-        if (!await continuationPathExists(rollbackGuardPath)) {
-            await writeTextAtomic(rollbackGuardPath, "This state directory uses continuation records v3. Older runtimes must not open records-v2.\n", 4 * 1024);
-        }
+    }
+    const recoveredGeneration = await recoverRecordTransaction(recordsDir, transactionPath, CONTINUATION_RECORD_STORE_SCHEMA_VERSION);
+    const records = await loadRecordDirectory(recordsDir);
+    const beforeMigration = cloneRecords(records);
+    normalizeLegacyContinuationRecords(records);
+    if (migrationSource !== undefined) {
         mergeMigrationRecords(records, migrationSource, "v2 and v3");
     }
-    const committedOriginGroups = await applyOriginContextGroupCommits(originContextGroupsDir, records);
-    applyRetention(records, policy, now());
-    const migrationGeneration = await persistRecordChanges(recordsDir, transactionPath, beforeOpen, records);
+    // Migration has its own durable phase. While the manifest remains false,
+    // legacy records are still authoritative and every partially materialized
+    // v3 record must remain semantically identical to that normalized source.
+    // Retention and activation are v3-only projections: publishing either one
+    // before the manifest closes migration would make crash replay compare a
+    // projected v3 record with its unprojected legacy source and reject it as a
+    // lossy conflict.
+    const migrationCompletionRequired = !manifestRollbackGuardRequired
+        && (migrationSource !== undefined || v3StateExists || rollbackGuardInstalled);
+    const projectionTime = now();
+    if (migrationCompletionRequired) {
+        // Validate the retention projection before closing migration. This is a
+        // read-only draft: normalized legacy records remain the only durable v3
+        // state until the manifest commits, but a growing compaction tombstone
+        // cannot strand the store behind that completion fence. Activation markers
+        // remain the later v3-only durable projection; their publisher preflights
+        // exact membership and record bounds before creating the marker.
+        const projectionDraft = cloneRecords(records);
+        // Temporary marker debris is cleanup-only and therefore excluded from the
+        // v3-evidence fence decision. Validate and clean it before publishing the
+        // migration fence so an unsafe linked/oversized temporary cannot poison
+        // every subsequent restart.
+        await cleanOriginContextGroupTemporaries(originContextGroupsDir);
+        applyRetention(projectionDraft, policy, projectionTime);
+        // The preflight above is non-durable. Fence the v2 reader only after the
+        // retention projection is known to be materializable, then publish
+        // normalized records as their own migration phase.
+        await ensureV2RollbackGuard();
+    }
+    const migrationGeneration = await persistRecordChanges(recordsDir, transactionPath, beforeMigration, records, ensureV2RollbackGuard);
     let generation = migrationGeneration ?? recoveredGeneration ?? randomUUID();
-    await persistManifest(manifestPath, generation, continuationStoreStats(records, policy), now());
+    if (migrationCompletionRequired) {
+        await persistManifest(manifestPath, generation, continuationStoreStats(records, policy), now(), true);
+    }
+    const beforeProjections = cloneRecords(records);
+    const committedOriginGroups = await applyOriginContextGroupCommits(originContextGroupsDir, records);
+    applyRetention(records, policy, projectionTime);
+    const projectionGeneration = await persistRecordChanges(recordsDir, transactionPath, beforeProjections, records, ensureV2RollbackGuard);
+    if (projectionGeneration !== undefined)
+        generation = projectionGeneration;
+    await persistManifest(manifestPath, generation, continuationStoreStats(records, policy), now(), rollbackGuardInstalled);
     await removeOriginContextGroupCommits(originContextGroupsDir, committedOriginGroups);
     await sweepOriginContextBlobs(originContextsDir, referencedOriginContextDigests(records), new Set());
     let tail = Promise.resolve();
     let originTail = Promise.resolve();
-    // Multiple capabilities from one origin run intentionally stage the same
-    // content-addressed snapshot concurrently. Track leases, not just presence:
-    // one failed/finalized caller must not sweep the blob while another caller
-    // still owns an uncommitted pin for the same digest.
     const pendingOriginPins = new Map();
     let poisoned;
     async function withOriginLock(operation) {
@@ -189,11 +192,11 @@ export async function openContinuationStore(stateDir, options = {}) {
         }
         try {
             applyRetention(draft, policy, now());
-            const committedGeneration = await persistRecordChanges(recordsDir, transactionPath, before, draft);
+            const committedGeneration = await persistRecordChanges(recordsDir, transactionPath, before, draft, ensureV2RollbackGuard);
             if (committedGeneration !== undefined)
                 generation = committedGeneration;
             replaceRecords(records, draft);
-            await persistManifest(manifestPath, generation, continuationStoreStats(records, policy), now());
+            await persistManifest(manifestPath, generation, continuationStoreStats(records, policy), now(), rollbackGuardInstalled);
             await withOriginLock(async () => {
                 await sweepOriginContextBlobs(originContextsDir, referencedOriginContextDigests(records), new Set(pendingOriginPins.keys()));
             });
@@ -238,6 +241,10 @@ export async function openContinuationStore(stateDir, options = {}) {
             commit = prepareOriginContextGroupCommit(draft, input);
             if (commit === undefined)
                 return;
+            // Preflight the exact projection, including v3 record-size bounds,
+            // before the durable marker becomes the recovery commit point.
+            applyOriginContextGroupCommit(draft, commit);
+            await ensureV2RollbackGuard();
             markerPath = join(originContextGroupsDir, `${commit.groupKey}.json`);
             if (await continuationPathExists(markerPath)) {
                 const existing = await loadOriginContextGroupCommit(markerPath);
@@ -246,27 +253,19 @@ export async function openContinuationStore(stateDir, options = {}) {
                 }
             }
             else {
-                // The marker is the semantic commit point. It is deliberately compact:
-                // the member-set digest makes one fsync atomic for groups whose record
-                // materialization spans arbitrarily many bounded transaction batches.
                 await writeJsonAtomic(markerPath, commit, true, 64 * 1024);
             }
             published = true;
-            applyOriginContextGroupCommit(draft, commit);
             replaceRecords(records, draft);
             try {
-                const committedGeneration = await persistRecordChanges(recordsDir, transactionPath, before, draft);
+                const committedGeneration = await persistRecordChanges(recordsDir, transactionPath, before, draft, ensureV2RollbackGuard);
                 if (committedGeneration !== undefined)
                     generation = committedGeneration;
-                await persistManifest(manifestPath, generation, continuationStoreStats(records, policy), now());
+                await persistManifest(manifestPath, generation, continuationStoreStats(records, policy), now(), rollbackGuardInstalled);
                 await rm(markerPath, { force: true });
                 await syncDirectory(originContextGroupsDir);
             }
             catch (materializationError) {
-                // Publication already committed. Recover the bounded materialization if
-                // possible and keep the group marker as the restart-time source of
-                // truth. Never report an ambiguous activation failure to a caller that
-                // might then abandon an already-published group.
                 try {
                     const recovered = await recoverRecordTransaction(recordsDir, transactionPath, CONTINUATION_RECORD_STORE_SCHEMA_VERSION);
                     if (recovered !== undefined)
@@ -288,9 +287,6 @@ export async function openContinuationStore(stateDir, options = {}) {
         catch (error) {
             if (!published)
                 throw error;
-            // The fsynced marker means activation is no longer ambiguous. Preserve
-            // that success contract and force a restart for any unexpected local
-            // maintenance failure after the commit point.
             poisoned ??= error;
         }
         finally {
@@ -332,15 +328,21 @@ export async function openContinuationStore(stateDir, options = {}) {
                 throw new Error(`Continuation origin context exceeds its ${String(MAX_CONTINUATION_ORIGIN_CONTEXT_BYTES)} byte limit.`);
             }
             const digest = originContextDigest(canonical);
-            const reference = { schemaVersion: 1, digest, bytes, messageCount: snapshot.messages.length };
+            const reference = {
+                schemaVersion: 1,
+                digest,
+                bytes,
+                messageCount: snapshot.messages.length,
+            };
             pendingOriginPins.set(digest, (pendingOriginPins.get(digest) ?? 0) + 1);
             try {
                 await withOriginLock(async () => {
                     const path = join(originContextsDir, `${digest}.json`);
                     if (await continuationPathExists(path)) {
                         const existing = await readOriginContextCanonical(path, reference);
-                        if (existing !== canonical)
+                        if (existing !== canonical) {
                             throw new Error("Continuation origin context digest collision or content conflict.");
+                        }
                         return;
                     }
                     const aggregate = await originContextStoreBytes(originContextsDir);
@@ -389,910 +391,4 @@ export async function openContinuationStore(stateDir, options = {}) {
         mutate: locked,
     };
 }
-/** Persistent owner-only key used to derive restart-stable callback capabilities. */
-export async function loadOrCreateContinuationSecret(stateDir) {
-    await ensureOwnerOnlyDirectory(stateDir);
-    const path = join(stateDir, "continuation-secret");
-    try {
-        const info = await lstat(path);
-        if (!info.isFile() || info.isSymbolicLink())
-            throw new Error(`Continuation secret is not a regular file: ${path}`);
-        if (typeof process.getuid === "function" && info.uid !== process.getuid()) {
-            throw new Error(`Continuation secret is not owned by the current user: ${path}`);
-        }
-        if (process.platform !== "win32" && (info.mode & 0o077) !== 0) {
-            throw new Error(`Continuation secret permissions are not owner-only: ${path}`);
-        }
-        const encoded = (await readFile(path, "utf8")).trim();
-        const secret = Buffer.from(encoded, "base64url");
-        if (secret.length !== 32)
-            throw new Error(`Continuation secret has invalid contents: ${path}`);
-        return secret;
-    }
-    catch (error) {
-        if (!isMissing(error))
-            throw error;
-    }
-    const secret = randomBytes(32);
-    try {
-        await writeFile(path, `${secret.toString("base64url")}\n`, { flag: "wx", mode: 0o600 });
-        return secret;
-    }
-    catch (error) {
-        if (!isObject(error) || error.code !== "EEXIST")
-            throw error;
-        return await loadOrCreateContinuationSecret(stateDir);
-    }
-}
-async function ensureOwnerOnlyDirectory(path) {
-    await mkdir(path, { recursive: true, mode: 0o700 });
-    const info = await lstat(path);
-    if (!info.isDirectory() || info.isSymbolicLink()) {
-        throw new Error(`Continuation state path is not a real directory: ${path}`);
-    }
-    if (typeof process.getuid === "function" && info.uid !== process.getuid()) {
-        throw new Error(`Continuation state directory is not owned by the current user: ${path}`);
-    }
-    if (process.platform !== "win32" && (info.mode & 0o077) !== 0) {
-        await chmod(path, 0o700);
-        const repaired = await lstat(path);
-        if ((repaired.mode & 0o077) !== 0) {
-            throw new Error(`Continuation state directory permissions are not owner-only: ${path}`);
-        }
-    }
-}
-async function loadLegacyStore(path) {
-    let raw;
-    try {
-        const info = await lstat(path);
-        if (!info.isFile() || info.isSymbolicLink()) {
-            throw new Error(`Continuation store is not a regular file: ${path}`);
-        }
-        if (typeof process.getuid === "function" && info.uid !== process.getuid()) {
-            throw new Error(`Continuation store is not owned by the current user: ${path}`);
-        }
-        if (process.platform !== "win32" && (info.mode & 0o077) !== 0) {
-            throw new Error(`Continuation store permissions are not owner-only: ${path}`);
-        }
-        raw = await readFile(path, "utf8");
-    }
-    catch (error) {
-        if (isMissing(error))
-            return new Map();
-        throw error;
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch (error) {
-        throw new Error(`Continuation store contains invalid JSON: ${path}`, { cause: error });
-    }
-    if (!isStoreFile(parsed)) {
-        throw new Error(`Continuation store has an unsupported or malformed schema: ${path}`);
-    }
-    return new Map(Object.entries(parsed.records).map(([id, record]) => [id, record]));
-}
-async function loadRecordDirectory(path, ignoredEntries = new Set()) {
-    const records = new Map();
-    let removedTemporary = false;
-    for (const entry of await readdir(path, { withFileTypes: true })) {
-        const filePath = join(path, entry.name);
-        if (ignoredEntries.has(entry.name)) {
-            await assertOwnerOnlyRegularFile(filePath, "Continuation migration guard");
-            continue;
-        }
-        if (entry.name.startsWith(".") && entry.name.endsWith(".tmp")) {
-            if (!entry.isFile() || entry.isSymbolicLink()) {
-                throw new Error(`Continuation temporary record is not a regular file: ${filePath}`);
-            }
-            await rm(filePath, { force: true });
-            removedTemporary = true;
-            continue;
-        }
-        if (!entry.name.endsWith(".json")) {
-            throw new Error(`Unexpected entry in continuation record directory: ${filePath}`);
-        }
-        await assertOwnerOnlyRegularFile(filePath, "Continuation record");
-        const raw = await readBoundedOwnerOnlyFile(filePath, MAX_RECORD_BYTES, "Continuation record");
-        let value;
-        try {
-            value = JSON.parse(raw);
-        }
-        catch (error) {
-            throw new Error(`Continuation record contains invalid JSON: ${filePath}`, { cause: error });
-        }
-        if (!isObject(value) || !requiredString(value.continuationId) || !isRecord(value, value.continuationId)) {
-            throw new Error(`Continuation record has a malformed schema: ${filePath}`);
-        }
-        const expectedName = continuationRecordFileName(value.continuationId);
-        if (entry.name !== expectedName) {
-            throw new Error(`Continuation record filename does not match its id: ${filePath}`);
-        }
-        if (records.has(value.continuationId)) {
-            throw new Error(`Duplicate continuation record: ${value.continuationId}`);
-        }
-        records.set(value.continuationId, structuredClone(value));
-    }
-    if (removedTemporary)
-        await syncDirectory(path);
-    return records;
-}
-function mergeMigrationRecords(target, source, label) {
-    // Both sides must be normalized before the semantic comparison. Otherwise a
-    // crash after persisting defaults (for example synthesisDeferrals=0) makes a
-    // restart falsely report a migration conflict against the equivalent v1/v2
-    // representation that omitted those fields.
-    normalizeLegacyContinuationRecords(target);
-    normalizeLegacyContinuationRecords(source);
-    for (const [id, record] of source) {
-        const current = target.get(id);
-        if (current === undefined) {
-            target.set(id, structuredClone(record));
-        }
-        else if (canonicalContinuationJson(current) !== canonicalContinuationJson(record)) {
-            throw new Error(`${label} continuation records conflict for id ${id}; refusing lossy migration.`);
-        }
-    }
-}
-async function assertV3Manifest(path) {
-    const raw = await readBoundedOwnerOnlyFile(path, 1024 * 1024, "Continuation v3 manifest");
-    let value;
-    try {
-        value = JSON.parse(raw);
-    }
-    catch (error) {
-        throw new Error(`Continuation v3 manifest contains invalid JSON: ${path}`, { cause: error });
-    }
-    if (!isObject(value)
-        || value.schemaVersion !== CONTINUATION_RECORD_STORE_SCHEMA_VERSION
-        || !requiredString(value.generation)
-        || !requiredDate(value.updatedAt)
-        || !isObject(value.stats)) {
-        throw new Error(`Continuation v3 manifest has a malformed schema: ${path}`);
-    }
-}
-function prepareOriginContextGroupCommit(records, input) {
-    const seeds = [...records.values()].filter((record) => record.claimFingerprint === input.claimFingerprint);
-    if (seeds.length === 0)
-        return undefined;
-    const seed = seeds[0];
-    if (seed.originContextState === "detached_latest")
-        return undefined;
-    if (seed.historyBoundary === undefined) {
-        throw new Error("A pinned continuation origin group must have an immutable history boundary.");
-    }
-    const candidates = [...records.values()].filter((record) => record.originRunId === seed.originRunId
-        && record.originConversationId === seed.originConversationId
-        && record.historyBoundary === seed.historyBoundary
-        && !TERMINAL_CONTINUATION_STATES.has(record.state));
-    if (candidates.length === 0)
-        return undefined;
-    const digests = new Set();
-    for (const record of candidates) {
-        if ((record.originContextState !== "pending" && record.originContextState !== "pinned")
-            || record.originContextRef === undefined
-            || record.originContextDigest !== record.originContextRef.digest
-            || record.originContextBindingMac === undefined) {
-            throw new Error("Continuation origin context was not durably prepared for activation.");
-        }
-        digests.add(record.originContextRef.digest);
-    }
-    if (digests.size !== 1) {
-        throw new Error("Continuation origin claims were prepared with conflicting snapshots.");
-    }
-    if (candidates.every((record) => record.originContextState === "pinned"))
-        return undefined;
-    const snapshotDigest = [...digests][0];
-    if (snapshotDigest === undefined)
-        throw new Error("Continuation origin group has no snapshot digest.");
-    const memberIds = candidates.map((record) => record.continuationId).sort();
-    const groupIdentity = {
-        originRunId: seed.originRunId,
-        originConversationId: seed.originConversationId,
-        historyBoundary: seed.historyBoundary,
-    };
-    return {
-        schemaVersion: 1,
-        groupKey: continuationDigest(`mono-agent-origin-context-group-v1\0${canonicalContinuationJson(groupIdentity)}`),
-        ...groupIdentity,
-        snapshotDigest,
-        memberCount: memberIds.length,
-        memberSetDigest: continuationDigest(`mono-agent-origin-context-members-v1\0${canonicalContinuationJson(memberIds)}`),
-        activatedAt: input.activatedAt,
-    };
-}
-function applyOriginContextGroupCommit(records, commit) {
-    const candidates = [...records.values()].filter((record) => record.originRunId === commit.originRunId
-        && record.originConversationId === commit.originConversationId
-        && record.historyBoundary === commit.historyBoundary
-        && !TERMINAL_CONTINUATION_STATES.has(record.state));
-    const memberIds = candidates.map((record) => record.continuationId).sort();
-    const memberSetDigest = continuationDigest(`mono-agent-origin-context-members-v1\0${canonicalContinuationJson(memberIds)}`);
-    if (candidates.length !== commit.memberCount || memberSetDigest !== commit.memberSetDigest) {
-        throw new Error("Continuation origin-context group commit member set does not match durable records.");
-    }
-    for (const record of candidates) {
-        if ((record.originContextState !== "pending" && record.originContextState !== "pinned")
-            || record.originContextRef?.digest !== commit.snapshotDigest
-            || record.originContextDigest !== commit.snapshotDigest
-            || record.originContextBindingMac === undefined) {
-            throw new Error("Continuation origin-context group commit does not match its prepared records.");
-        }
-    }
-    for (const record of candidates) {
-        if (record.originContextState === "pinned")
-            continue;
-        record.originContextState = "pinned";
-        record.updatedAt = commit.activatedAt;
-        if (record.lastError?.code === "origin_context_pending")
-            delete record.lastError;
-        delete record.nextAttemptAt;
-    }
-}
-async function applyOriginContextGroupCommits(directory, records) {
-    const applied = [];
-    let removedTemporary = false;
-    for (const entry of await readdir(directory, { withFileTypes: true })) {
-        const path = join(directory, entry.name);
-        if (entry.name.startsWith(".") && entry.name.endsWith(".tmp")) {
-            if (!entry.isFile() || entry.isSymbolicLink()) {
-                throw new Error(`Continuation origin-context group temporary is not a regular file: ${path}`);
-            }
-            await rm(path, { force: true });
-            removedTemporary = true;
-            continue;
-        }
-        if (!/^[a-f0-9]{64}\.json$/u.test(entry.name) || !entry.isFile() || entry.isSymbolicLink()) {
-            throw new Error(`Unexpected entry in continuation origin-context group directory: ${path}`);
-        }
-        const commit = await loadOriginContextGroupCommit(path);
-        if (`${commit.groupKey}.json` !== entry.name) {
-            throw new Error(`Continuation origin-context group filename does not match its key: ${path}`);
-        }
-        applyOriginContextGroupCommit(records, commit);
-        applied.push(path);
-    }
-    if (removedTemporary)
-        await syncDirectory(directory);
-    return applied;
-}
-async function loadOriginContextGroupCommit(path) {
-    const raw = await readBoundedOwnerOnlyFile(path, 64 * 1024, "Continuation origin-context group commit");
-    let value;
-    try {
-        value = JSON.parse(raw);
-    }
-    catch (error) {
-        throw new Error(`Continuation origin-context group commit contains invalid JSON: ${path}`, { cause: error });
-    }
-    if (!isOriginContextGroupCommit(value)) {
-        throw new Error(`Continuation origin-context group commit has a malformed schema: ${path}`);
-    }
-    return value;
-}
-async function removeOriginContextGroupCommits(directory, paths) {
-    if (paths.length === 0)
-        return;
-    for (const path of paths)
-        await rm(path, { force: true });
-    await syncDirectory(directory);
-}
-async function persistRecordChanges(recordsDir, transactionPath, before, after) {
-    const writes = [...after.values()].filter((record) => {
-        const prior = before.get(record.continuationId);
-        return prior === undefined || JSON.stringify(prior) !== JSON.stringify(record);
-    }).map((record) => structuredClone(record));
-    const deletes = [...before.keys()].filter((id) => !after.has(id));
-    if (writes.length === 0 && deletes.length === 0)
-        return undefined;
-    let generation;
-    for (const transaction of createTransactionBatches(writes, deletes)) {
-        await writeJsonAtomic(transactionPath, transaction, true, MAX_TRANSACTION_BYTES);
-        await applyRecordTransaction(recordsDir, transaction);
-        await rm(transactionPath, { force: true });
-        await syncDirectory(dirname(transactionPath));
-        generation = transaction.generation;
-    }
-    return generation;
-}
-async function recoverRecordTransaction(recordsDir, transactionPath, expectedSchemaVersion) {
-    if (!await continuationPathExists(transactionPath))
-        return undefined;
-    const raw = await readBoundedOwnerOnlyFile(transactionPath, MAX_TRANSACTION_BYTES, "Continuation transaction");
-    let value;
-    try {
-        value = JSON.parse(raw);
-    }
-    catch (error) {
-        throw new Error(`Continuation transaction contains invalid JSON: ${transactionPath}`, { cause: error });
-    }
-    if (!isRecordTransaction(value, expectedSchemaVersion)) {
-        throw new Error(`Continuation transaction has a malformed schema: ${transactionPath}`);
-    }
-    await applyRecordTransaction(recordsDir, value);
-    await rm(transactionPath, { force: true });
-    await syncDirectory(dirname(transactionPath));
-    return value.generation;
-}
-async function applyRecordTransaction(recordsDir, transaction) {
-    for (const record of transaction.writes) {
-        await writeJsonAtomic(join(recordsDir, continuationRecordFileName(record.continuationId)), record, false, MAX_RECORD_BYTES);
-    }
-    for (const id of transaction.deletes) {
-        await rm(join(recordsDir, continuationRecordFileName(id)), { force: true });
-    }
-    await syncDirectory(recordsDir);
-}
-async function persistManifest(path, generation, stats, now) {
-    await writeJsonAtomic(path, {
-        schemaVersion: CONTINUATION_RECORD_STORE_SCHEMA_VERSION,
-        generation,
-        updatedAt: now.toISOString(),
-        stats,
-    });
-}
-async function writeJsonAtomic(path, value, syncParent = true, maxBytes = Number.MAX_SAFE_INTEGER) {
-    const body = `${JSON.stringify(value, null, 2)}\n`;
-    if (Buffer.byteLength(body, "utf8") > maxBytes) {
-        throw new Error(`Durable continuation file exceeds its ${String(maxBytes)} byte safety limit: ${path}`);
-    }
-    const temporary = join(dirname(path), `.${continuationDigest(path).slice(0, 12)}-${process.pid}-${randomUUID()}.tmp`);
-    let handle;
-    try {
-        handle = await open(temporary, "wx", 0o600);
-        await handle.writeFile(body, "utf8");
-        await handle.sync();
-        await handle.close();
-        handle = undefined;
-        await rename(temporary, path);
-        if (process.platform !== "win32")
-            await chmod(path, 0o600);
-        if (syncParent)
-            await syncDirectory(dirname(path));
-    }
-    finally {
-        await handle?.close().catch(() => undefined);
-        await rm(temporary, { force: true }).catch(() => undefined);
-    }
-}
-async function writeTextAtomic(path, body, maxBytes) {
-    if (Buffer.byteLength(body, "utf8") > maxBytes) {
-        throw new Error(`Durable continuation file exceeds its ${String(maxBytes)} byte safety limit: ${path}`);
-    }
-    const temporary = join(dirname(path), `.${continuationDigest(path).slice(0, 12)}-${process.pid}-${randomUUID()}.tmp`);
-    let handle;
-    try {
-        handle = await open(temporary, "wx", 0o600);
-        await handle.writeFile(body, "utf8");
-        await handle.sync();
-        await handle.close();
-        handle = undefined;
-        await rename(temporary, path);
-        if (process.platform !== "win32")
-            await chmod(path, 0o600);
-        await syncDirectory(dirname(path));
-    }
-    finally {
-        await handle?.close().catch(() => undefined);
-        await rm(temporary, { force: true }).catch(() => undefined);
-    }
-}
-class OriginContextCorruptionError extends Error {
-}
-function originContextDigest(canonical) {
-    return continuationDigest(`mono-agent-origin-context-v1\0${canonical}`);
-}
-async function readOriginContextCanonical(path, reference) {
-    let canonical;
-    try {
-        const loaded = await readBoundedOwnerOnlyFileWithStats(path, MAX_CONTINUATION_ORIGIN_CONTEXT_BYTES, "Continuation origin context");
-        if (loaded.bytes !== reference.bytes) {
-            throw new OriginContextCorruptionError("Continuation origin context size does not match its reference.");
-        }
-        canonical = loaded.text;
-    }
-    catch (error) {
-        if (error instanceof OriginContextCorruptionError || isMissing(error))
-            throw error;
-        throw new OriginContextCorruptionError("Continuation origin context is not a safe owner-only file.", { cause: error });
-    }
-    if (Buffer.byteLength(canonical, "utf8") !== reference.bytes
-        || originContextDigest(canonical) !== reference.digest) {
-        throw new OriginContextCorruptionError("Continuation origin context digest does not match its reference.");
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(canonical);
-    }
-    catch (error) {
-        throw new OriginContextCorruptionError("Continuation origin context is not valid JSON.", { cause: error });
-    }
-    if (canonicalContinuationJson(parsed) !== canonical) {
-        throw new OriginContextCorruptionError("Continuation origin context is not canonically encoded.");
-    }
-    try {
-        assertAgentContinuationOriginContext(parsed);
-    }
-    catch (error) {
-        throw new OriginContextCorruptionError("Continuation origin context has an invalid schema.", { cause: error });
-    }
-    if (parsed.messages.length !== reference.messageCount) {
-        throw new OriginContextCorruptionError("Continuation origin context message count does not match its reference.");
-    }
-    return canonical;
-}
-function referencedOriginContextDigests(records) {
-    return new Set([...records.values()].flatMap((record) => record.originContextRef === undefined ? [] : [record.originContextRef.digest]));
-}
-function releasePendingOriginPin(pins, digest) {
-    const count = pins.get(digest);
-    if (count === undefined)
-        return;
-    if (count <= 1)
-        pins.delete(digest);
-    else
-        pins.set(digest, count - 1);
-}
-async function sweepOriginContextBlobs(directory, referenced, pending) {
-    let changed = false;
-    for (const entry of await readdir(directory, { withFileTypes: true })) {
-        const path = join(directory, entry.name);
-        if (entry.name.startsWith(".") && entry.name.endsWith(".tmp")) {
-            if (!entry.isFile() && !entry.isSymbolicLink()) {
-                throw new Error(`Continuation origin-context temporary is not a regular file: ${path}`);
-            }
-            await rm(path, { force: true });
-            changed = true;
-            continue;
-        }
-        const match = /^([a-f0-9]{64})\.json$/u.exec(entry.name);
-        if (match?.[1] !== undefined && !referenced.has(match[1]) && !pending.has(match[1])) {
-            // Once no durable record references a blob, unlink it without opening or
-            // following it. This also lets the safe-fallback path clean up a blob
-            // whose mode/identity was corrupted instead of poisoning record storage.
-            await rm(path, { force: true, recursive: true });
-            changed = true;
-            continue;
-        }
-        if (match?.[1] === undefined) {
-            throw new Error(`Unexpected entry in continuation origin-context directory: ${path}`);
-        }
-        // A referenced blob is untrusted payload, not store metadata. Do not let a
-        // corrupt mode, hard link, symlink, or non-file poison startup; the
-        // descriptor-stable load path will classify it as unavailable and the
-        // service can emit its deterministic zero-model fallback.
-        if (!entry.isFile() || entry.isSymbolicLink())
-            continue;
-        try {
-            await assertOwnerOnlyRegularFile(path, "Continuation origin context");
-        }
-        catch {
-            continue;
-        }
-    }
-    if (changed)
-        await syncDirectory(directory);
-}
-async function originContextStoreBytes(directory) {
-    let total = 0;
-    for (const entry of await readdir(directory, { withFileTypes: true })) {
-        if (entry.name.startsWith(".") && entry.name.endsWith(".tmp"))
-            continue;
-        if (!/^[a-f0-9]{64}\.json$/u.test(entry.name)) {
-            throw new Error(`Unexpected entry in continuation origin-context directory: ${join(directory, entry.name)}`);
-        }
-        if (!entry.isFile() || entry.isSymbolicLink())
-            continue;
-        const info = await lstat(join(directory, entry.name));
-        total += info.size;
-        if (total > MAX_CONTINUATION_ORIGIN_CONTEXT_STORE_BYTES) {
-            throw new Error("Continuation origin context store exceeds its aggregate byte quota.");
-        }
-    }
-    return total;
-}
-async function syncDirectory(path) {
-    let directory;
-    try {
-        directory = await open(path, "r");
-        await directory.sync();
-    }
-    catch (error) {
-        if (process.platform === "win32"
-            && isObject(error)
-            && (error.code === "EISDIR"
-                || error.code === "EPERM"
-                || error.code === "EACCES"
-                || error.code === "EINVAL"
-                || error.code === "EBADF")) {
-            return;
-        }
-        throw error;
-    }
-    finally {
-        await directory?.close().catch(() => undefined);
-    }
-}
-function createTransactionBatches(writes, deletes) {
-    const batches = [];
-    const createdAt = new Date().toISOString();
-    for (const record of writes) {
-        const bytes = Buffer.byteLength(`${JSON.stringify(record, null, 2)}\n`, "utf8");
-        if (bytes > MAX_RECORD_BYTES) {
-            throw new Error(`Continuation record exceeds its ${String(MAX_RECORD_BYTES)} byte safety limit: ${record.continuationId}`);
-        }
-    }
-    const changes = [
-        ...writes.map((record) => ({ kind: "write", record: structuredClone(record) })),
-        ...deletes.map((id) => ({ kind: "delete", id })),
-    ];
-    const makeTransaction = (entries) => ({
-        schemaVersion: CONTINUATION_RECORD_STORE_SCHEMA_VERSION,
-        generation: randomUUID(),
-        createdAt,
-        writes: entries.flatMap((entry) => entry.kind === "write" ? [entry.record] : []),
-        deletes: entries.flatMap((entry) => entry.kind === "delete" ? [entry.id] : []),
-    });
-    const appendBounded = (entries) => {
-        if (entries.length === 0)
-            return;
-        const candidate = makeTransaction(entries);
-        const bytes = Buffer.byteLength(`${JSON.stringify(candidate, null, 2)}\n`, "utf8");
-        if (bytes <= MAX_TRANSACTION_BYTES) {
-            batches.push(candidate);
-            return;
-        }
-        if (entries.length === 1) {
-            const only = entries[0];
-            throw new Error(only?.kind === "write"
-                ? `Continuation record is too large for a bounded durable transaction: ${only.record.continuationId}`
-                : `Continuation id is too large for a bounded durable transaction: ${only?.id ?? "unknown"}`);
-        }
-        const middle = Math.floor(entries.length / 2);
-        appendBounded(entries.slice(0, middle));
-        appendBounded(entries.slice(middle));
-    };
-    // Coarse compact-JSON estimates avoid repeatedly serializing an ever-growing
-    // migration batch. Exact pretty-JSON size is checked at flush and recursively
-    // split, so every persisted transaction remains within the hard bound.
-    const targetBytes = Math.floor(MAX_TRANSACTION_BYTES / 2);
-    let batch = [];
-    let estimatedBytes = 512;
-    for (const change of changes) {
-        const value = change.kind === "write" ? change.record : change.id;
-        const estimate = Buffer.byteLength(JSON.stringify(value), "utf8") + 64;
-        if (batch.length > 0 && estimatedBytes + estimate > targetBytes) {
-            appendBounded(batch);
-            batch = [];
-            estimatedBytes = 512;
-        }
-        batch.push(change);
-        estimatedBytes += estimate;
-    }
-    appendBounded(batch);
-    return batches;
-}
-function resolveRetention(options) {
-    const policy = {
-        terminalMaxRecords: options?.terminalMaxRecords ?? DEFAULT_TERMINAL_MAX_RECORDS,
-        terminalMaxAgeMs: options?.terminalMaxAgeMs ?? DEFAULT_TERMINAL_MAX_AGE_MS,
-        capturedTextMaxRecords: options?.capturedTextMaxRecords ?? DEFAULT_CAPTURED_TEXT_MAX_RECORDS,
-        capturedTextMaxAgeMs: options?.capturedTextMaxAgeMs ?? DEFAULT_CAPTURED_TEXT_MAX_AGE_MS,
-    };
-    for (const [name, value] of Object.entries(policy)) {
-        if (!Number.isSafeInteger(value) || value < 0) {
-            throw new Error(`Continuation retention ${name} must be a non-negative safe integer.`);
-        }
-    }
-    return policy;
-}
-const SETTLED_TERMINAL_STATES = new Set([
-    "delivered",
-    "expired",
-    "cancelled",
-    "dead_lettered",
-]);
-const ORIGIN_CONTEXT_SCRUB_STATES = new Set([
-    "delivery_unknown",
-    "delivered",
-    "expired",
-    "cancelled",
-    "dead_lettered",
-]);
-function applyRetention(records, policy, now) {
-    const nowMs = now.getTime();
-    const captures = [...records.values()]
-        .filter((record) => SETTLED_TERMINAL_STATES.has(record.state)
-        && record.mode === "capture"
-        && record.synthesizedText !== undefined
-        && nowMs - Date.parse(record.updatedAt) <= policy.capturedTextMaxAgeMs)
-        .sort(newestFirst)
-        .slice(0, policy.capturedTextMaxRecords);
-    const retainedCaptureText = new Set(captures.map((record) => record.continuationId));
-    for (const record of records.values()) {
-        if (ORIGIN_CONTEXT_SCRUB_STATES.has(record.state) && record.originContextRef !== undefined) {
-            record.originContextDigest ??= record.originContextRef.digest;
-            record.originContextMessageCount ??= record.originContextRef.messageCount;
-            delete record.originContextRef;
-            record.originContextState = "scrubbed";
-        }
-        if (!SETTLED_TERMINAL_STATES.has(record.state))
-            continue;
-        if (record.resultPayload !== undefined) {
-            delete record.resultPayload;
-        }
-        if (record.synthesizedText !== undefined && !retainedCaptureText.has(record.continuationId)) {
-            delete record.synthesizedText;
-        }
-        if (record.compactedAt === undefined) {
-            record.compactedAt = now.toISOString();
-        }
-    }
-    const retainedTerminalIds = new Set([...records.values()]
-        .filter((record) => SETTLED_TERMINAL_STATES.has(record.state)
-        && nowMs - Date.parse(record.updatedAt) <= policy.terminalMaxAgeMs)
-        .sort(newestFirst)
-        .slice(0, policy.terminalMaxRecords)
-        .map((record) => record.continuationId));
-    for (const [id, record] of records) {
-        if (SETTLED_TERMINAL_STATES.has(record.state) && !retainedTerminalIds.has(id))
-            records.delete(id);
-    }
-}
-function newestFirst(left, right) {
-    const byUpdatedAt = right.updatedAt.localeCompare(left.updatedAt);
-    return byUpdatedAt === 0 ? right.continuationId.localeCompare(left.continuationId) : byUpdatedAt;
-}
-function continuationStoreStats(records, policy) {
-    const values = [...records.values()];
-    return {
-        format: "per-record-v3",
-        records: values.length,
-        active: values.filter((record) => !SETTLED_TERMINAL_STATES.has(record.state) && record.state !== "delivery_unknown").length,
-        unresolvedDelivery: values.filter((record) => record.state === "delivery_unknown").length,
-        deadLettered: values.filter((record) => record.state === "dead_lettered").length,
-        terminalTombstones: values.filter((record) => SETTLED_TERMINAL_STATES.has(record.state)).length,
-        compacted: values.filter((record) => record.compactedAt !== undefined).length,
-        capturedText: values.filter((record) => record.mode === "capture" && record.synthesizedText !== undefined).length,
-        historyDegraded: values.filter((record) => record.receipt?.historyRecorded === false).length,
-        limits: { ...policy },
-    };
-}
-function cloneRecords(records) {
-    return new Map([...records].map(([id, record]) => [id, structuredClone(record)]));
-}
-function replaceRecords(target, source) {
-    target.clear();
-    for (const [id, record] of source)
-        target.set(id, structuredClone(record));
-}
-function continuationRecordFileName(id) {
-    return `${continuationDigest(id)}.json`;
-}
-async function continuationPathExists(path) {
-    try {
-        await lstat(path);
-        return true;
-    }
-    catch (error) {
-        if (isMissing(error))
-            return false;
-        throw error;
-    }
-}
-async function assertOwnerOnlyRegularFile(path, label) {
-    const info = await lstat(path);
-    assertOwnerOnlySingleLinkStats(info, path, label);
-}
-function assertOwnerOnlySingleLinkStats(info, path, label) {
-    if (!info.isFile() || info.isSymbolicLink())
-        throw new Error(`${label} is not a regular file: ${path}`);
-    if (info.nlink !== 1)
-        throw new Error(`${label} must have exactly one filesystem link: ${path}`);
-    if (typeof process.getuid === "function" && info.uid !== process.getuid()) {
-        throw new Error(`${label} is not owned by the current user: ${path}`);
-    }
-    if (process.platform !== "win32" && (info.mode & 0o077) !== 0) {
-        throw new Error(`${label} permissions are not owner-only: ${path}`);
-    }
-}
-async function readBoundedOwnerOnlyFile(path, maxBytes, label) {
-    return (await readBoundedOwnerOnlyFileWithStats(path, maxBytes, label)).text;
-}
-async function readBoundedOwnerOnlyFileWithStats(path, maxBytes, label) {
-    const pathInfo = await lstat(path);
-    assertOwnerOnlySingleLinkStats(pathInfo, path, label);
-    const flags = fsConstants.O_RDONLY
-        | (process.platform === "win32" ? 0 : fsConstants.O_NOFOLLOW);
-    let handle;
-    try {
-        handle = await open(path, flags);
-        const before = await handle.stat();
-        assertOwnerOnlySingleLinkStats(before, path, label);
-        if (before.dev !== pathInfo.dev || before.ino !== pathInfo.ino) {
-            throw new Error(`${label} changed identity while it was opened: ${path}`);
-        }
-        if (before.size > maxBytes) {
-            throw new Error(`${label} exceeds its ${String(maxBytes)} byte safety limit: ${path}`);
-        }
-        const body = await handle.readFile();
-        const after = await handle.stat();
-        assertOwnerOnlySingleLinkStats(after, path, label);
-        if (after.dev !== before.dev || after.ino !== before.ino || after.size !== before.size
-            || body.byteLength !== before.size) {
-            throw new Error(`${label} changed while it was being read: ${path}`);
-        }
-        return { text: body.toString("utf8"), bytes: body.byteLength };
-    }
-    finally {
-        await handle?.close().catch(() => undefined);
-    }
-}
-function isRecordTransaction(value, expectedSchemaVersion) {
-    if (!isObject(value)
-        || value.schemaVersion !== expectedSchemaVersion
-        || !requiredString(value.generation)
-        || !requiredDate(value.createdAt)
-        || !Array.isArray(value.writes)
-        || !Array.isArray(value.deletes))
-        return false;
-    const writesValid = value.writes.every((record) => isObject(record)
-        && requiredString(record.continuationId)
-        && isRecord(record, record.continuationId));
-    if (!writesValid || !value.deletes.every(requiredString))
-        return false;
-    const writeIds = value.writes.map((record) => record.continuationId);
-    const deleteIds = value.deletes;
-    return new Set(writeIds).size === writeIds.length
-        && new Set(deleteIds).size === deleteIds.length
-        && !deleteIds.some((id) => writeIds.includes(id));
-}
-function isStoreFile(value) {
-    if (!isObject(value) || value.schemaVersion !== CONTINUATION_STORE_SCHEMA_VERSION || !isObject(value.records)) {
-        return false;
-    }
-    return Object.entries(value.records).every(([id, record]) => id.length > 0 && isRecord(record, id));
-}
-function normalizeLegacyContinuationRecords(records) {
-    for (const record of records.values()) {
-        if (record.originContextState === undefined) {
-            record.originContextState = record.historyBoundary === undefined
-                ? "detached_latest"
-                : "legacy_missing";
-        }
-        if (record.synthesisDeferrals === undefined)
-            record.synthesisDeferrals = 0;
-    }
-}
-function isRecord(value, id) {
-    if (!isObject(value))
-        return false;
-    return value.continuationId === id
-        && requiredString(value.serverName)
-        && requiredString(value.originRunId)
-        && requiredString(value.originConversationId)
-        && optionalString(value.replyToConversationId)
-        && optionalString(value.historyBoundary)
-        && (value.originContextState === undefined || isOriginContextState(value.originContextState))
-        && (value.originContextRef === undefined || isOriginContextReference(value.originContextRef))
-        && (value.originContextDigest === undefined || isSha256(value.originContextDigest))
-        && (value.originContextMessageCount === undefined
-            || (Number.isSafeInteger(value.originContextMessageCount)
-                && Number(value.originContextMessageCount) >= 0
-                && Number(value.originContextMessageCount) <= MAX_CONTINUATION_ORIGIN_CONTEXT_MESSAGES))
-        && (value.originContextFingerprint === undefined || isSha256(value.originContextFingerprint))
-        && (value.originContextBindingMac === undefined || isSha256(value.originContextBindingMac))
-        && (value.completionKind === undefined
-            || value.completionKind === "synthesized"
-            || value.completionKind === "origin_context_unavailable")
-        && isContinuationMode(value.mode)
-        && optionalString(value.routeName)
-        && requiredString(value.taskKey)
-        && requiredString(value.taskHash)
-        && requiredString(value.claimFingerprint)
-        && /^[a-f0-9]{64}$/u.test(String(value.resultTokenHash))
-        && requiredDate(value.createdAt)
-        && requiredDate(value.updatedAt)
-        && requiredDate(value.deadline)
-        && isContinuationState(value.state)
-        && Number.isInteger(value.synthesisAttempts)
-        && Number(value.synthesisAttempts) >= 0
-        && (value.synthesisDeferrals === undefined
-            || (Number.isSafeInteger(value.synthesisDeferrals) && Number(value.synthesisDeferrals) >= 0))
-        && Number.isInteger(value.deliveryAttempts)
-        && Number(value.deliveryAttempts) >= 0
-        && optionalString(value.resultIdempotencyKey)
-        && optionalString(value.resultPayloadHash)
-        && optionalDate(value.synthesisStartedAt)
-        && optionalString(value.synthesizedText)
-        && (value.actionable === undefined || typeof value.actionable === "boolean")
-        && optionalDate(value.deliveryStartedAt)
-        && optionalDate(value.nextAttemptAt)
-        && optionalString(value.leaseOwner)
-        && optionalDate(value.leaseUntil)
-        && optionalDate(value.compactedAt)
-        && (value.lastError === undefined || isLastError(value.lastError))
-        && (value.receipt === undefined || isReceipt(value.receipt));
-}
-function isOriginContextState(value) {
-    return value === "pending"
-        || value === "pinned"
-        || value === "abandoned"
-        || value === "detached_latest"
-        || value === "legacy_missing"
-        || value === "scrubbed";
-}
-function isOriginContextReference(value) {
-    return isObject(value)
-        && value.schemaVersion === 1
-        && isSha256(value.digest)
-        && Number.isSafeInteger(value.bytes)
-        && Number(value.bytes) > 0
-        && Number(value.bytes) <= MAX_CONTINUATION_ORIGIN_CONTEXT_BYTES
-        && Number.isSafeInteger(value.messageCount)
-        && Number(value.messageCount) >= 2
-        && Number(value.messageCount) <= MAX_CONTINUATION_ORIGIN_CONTEXT_MESSAGES;
-}
-function isOriginContextGroupCommit(value) {
-    if (!isObject(value)
-        || value.schemaVersion !== 1
-        || !isSha256(value.groupKey)
-        || !requiredString(value.originRunId)
-        || !requiredString(value.originConversationId)
-        || !requiredString(value.historyBoundary)
-        || !isSha256(value.snapshotDigest)
-        || !Number.isSafeInteger(value.memberCount)
-        || Number(value.memberCount) < 1
-        || !isSha256(value.memberSetDigest)
-        || !requiredDate(value.activatedAt))
-        return false;
-    const expectedKey = continuationDigest(`mono-agent-origin-context-group-v1\0${canonicalContinuationJson({
-        originRunId: value.originRunId,
-        originConversationId: value.originConversationId,
-        historyBoundary: value.historyBoundary,
-    })}`);
-    return value.groupKey === expectedKey;
-}
-function isSha256(value) {
-    return typeof value === "string" && /^[a-f0-9]{64}$/u.test(value);
-}
-function isLastError(value) {
-    return isObject(value) && requiredString(value.code) && requiredString(value.reason) && requiredDate(value.at);
-}
-function isReceipt(value) {
-    if (!isObject(value)
-        || (value.kind !== "delivered" && value.kind !== "suppressed" && value.kind !== "captured" && value.kind !== "silent")) {
-        return false;
-    }
-    return requiredDate(value.deliveredAt)
-        && optionalString(value.deliveryId)
-        && optionalString(value.channelId)
-        && (value.historyRecorded === undefined || typeof value.historyRecorded === "boolean")
-        && (value.historyErrorCode === undefined
-            || (typeof value.historyErrorCode === "string" && value.historyErrorCode.length > 0 && value.historyErrorCode.length <= 128))
-        && (value.historyErrorCode === undefined || value.historyRecorded === false)
-        && (value.kind === "delivered" || (value.historyRecorded === undefined && value.historyErrorCode === undefined));
-}
-function isObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function requiredString(value) {
-    return typeof value === "string" && value.length > 0;
-}
-function optionalString(value) {
-    return value === undefined || typeof value === "string";
-}
-function requiredDate(value) {
-    return requiredString(value) && Number.isFinite(Date.parse(value));
-}
-function optionalDate(value) {
-    return value === undefined || requiredDate(value);
-}
-function isMissing(error) {
-    return isObject(error) && error.code === "ENOENT";
-}
-function cloneRecord(record) {
-    return record === undefined ? undefined : structuredClone(record);
-}
 //# sourceMappingURL=continuation-store.js.map