@ouro.bot/cli 0.1.0-alpha.73 → 0.1.0-alpha.731

package/dist/heart/approval-store.js

@@ -0,0 +1,791 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApprovalStoreError = void 0;
+exports.canonicalApprovalArguments = canonicalApprovalArguments;
+exports.parseApprovalRecord = parseApprovalRecord;
+exports.openApprovalStore = openApprovalStore;
+const node_crypto_1 = require("node:crypto");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const runtime_1 = require("../nerves/runtime");
+class ApprovalStoreError extends Error {
+    code;
+    constructor(code, message = code) {
+        super(message);
+        this.name = "ApprovalStoreError";
+        this.code = code;
+    }
+}
+exports.ApprovalStoreError = ApprovalStoreError;
+const HASH = /^[a-f0-9]{64}$/;
+const UUID = /^[a-f0-9]{8}-[a-f0-9]{4}-[1-5][a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/i;
+const RECORD_KEYS = [
+    "approvalId", "state", "toolCallId", "toolName", "arguments", "argumentDigest", "schemaDigest",
+    "toolDigest", "policyDigest", "policyId", "sessionKey", "sessionPath", "baseSessionRevision",
+    "suspendedSessionRevision", "checkpointDigest", "requesterId", "transport", "transportUserId",
+    "transportChatId", "transportMessageId", "decisionTokenDigest", "expiresAt", "createdAt", "updatedAt",
+    "ownerId", "epoch", "attemptedAt", "result", "reason", "frozenAssistantMessage",
+];
+const STATES = new Set([
+    "preparing", "awaiting_prompt_binding", "proposed", "claimed", "attempted", "succeeded", "failed",
+    "attempted_indeterminate", "denied", "expired", "drifted", "session_head_changed", "abandoned_before_attempt",
+]);
+const ATTEMPT_TERMINALS = new Set(["succeeded", "failed", "attempted_indeterminate"]);
+function fail(code) {
+    throw new ApprovalStoreError(code);
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isTimestamp(value) {
+    return typeof value === "string" && Number.isFinite(Date.parse(value)) && new Date(value).toISOString() === value;
+}
+function isNonEmpty(value) {
+    return typeof value === "string" && value.length > 0;
+}
+function processIsAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function assertJsonValue(value) {
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return;
+    if (typeof value === "number" && Number.isFinite(value))
+        return;
+    if (Array.isArray(value)) {
+        for (const item of value)
+            assertJsonValue(item);
+        return;
+    }
+    if (isObject(value)) {
+        for (const item of Object.values(value))
+            assertJsonValue(item);
+        return;
+    }
+    fail("invalid_json_value");
+}
+function canonicalize(value) {
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(canonicalize).join(",")}]`;
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalize(value[key])}`).join(",")}}`;
+}
+function sha256(value) {
+    return (0, node_crypto_1.createHash)("sha256").update(value, "utf8").digest("hex");
+}
+function canonicalApprovalArguments(value) {
+    if (!isObject(value))
+        fail("arguments_not_object");
+    assertJsonValue(value);
+    const canonical = canonicalize(value);
+    return { canonical, digest: sha256(canonical) };
+}
+function hasExactKeys(value) {
+    const actual = Object.keys(value).sort();
+    const expected = [...RECORD_KEYS].sort();
+    return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
+}
+function validStateShape(record) {
+    const hasOwner = isNonEmpty(record.ownerId);
+    const hasAttempt = isTimestamp(record.attemptedAt);
+    const hasSuspension = typeof record.suspendedSessionRevision === "string"
+        && HASH.test(record.suspendedSessionRevision);
+    const hasPromptBinding = isNonEmpty(record.transportMessageId);
+    const hasValidOwnershipEpoch = hasOwner ? record.epoch > 0 : record.epoch === 0;
+    if (record.state === "preparing") {
+        return record.suspendedSessionRevision === null && record.transportMessageId === null
+            && !hasOwner && record.epoch === 0 && !hasAttempt && record.result === null && record.reason === null;
+    }
+    if (record.state === "awaiting_prompt_binding") {
+        return hasSuspension && record.transportMessageId === null
+            && !hasOwner && record.epoch === 0 && !hasAttempt && record.result === null && record.reason === null;
+    }
+    if (record.state === "proposed") {
+        return hasSuspension && hasPromptBinding
+            && !hasOwner && record.epoch === 0 && !hasAttempt && record.result === null && record.reason === null;
+    }
+    if (record.state === "claimed") {
+        return hasSuspension && hasPromptBinding && hasOwner && record.epoch > 0
+            && !hasAttempt && record.result === null && record.reason === null;
+    }
+    if (record.state === "attempted") {
+        return hasSuspension && hasPromptBinding && hasOwner && record.epoch > 0
+            && hasAttempt && record.result === null && record.reason === null;
+    }
+    if (ATTEMPT_TERMINALS.has(record.state)) {
+        return hasSuspension && hasPromptBinding && hasOwner && record.epoch > 0
+            && hasAttempt && isNonEmpty(record.result) && record.reason === null;
+    }
+    if (record.state === "abandoned_before_attempt") {
+        const validPreparingRecovery = !hasOwner && record.epoch === 0
+            && record.suspendedSessionRevision === null && record.transportMessageId === null;
+        const validClaimRecovery = hasOwner && record.epoch > 0 && hasSuspension && hasPromptBinding;
+        return (validPreparingRecovery || validClaimRecovery)
+            && !hasAttempt && record.result === null && isNonEmpty(record.reason);
+    }
+    if (record.state === "drifted") {
+        const validPreparingRecovery = !hasOwner && record.epoch === 0
+            && record.suspendedSessionRevision === null && record.transportMessageId === null;
+        const validPostCheckpoint = !hasOwner && record.epoch === 0 && hasSuspension
+            && (hasPromptBinding || record.transportMessageId === null);
+        const validPostClaim = hasOwner && record.epoch > 0 && hasSuspension && hasPromptBinding;
+        return (validPreparingRecovery || validPostCheckpoint || validPostClaim)
+            && !hasAttempt && record.result === null && isNonEmpty(record.reason);
+    }
+    if (record.state === "denied") {
+        return hasValidOwnershipEpoch && hasSuspension && hasPromptBinding
+            && !hasAttempt && record.result === null && record.reason === null;
+    }
+    if (record.state === "expired") {
+        return !hasOwner && record.epoch === 0 && hasSuspension
+            && (hasPromptBinding || record.transportMessageId === null)
+            && !hasAttempt && record.result === null && record.reason === null;
+    }
+    if (record.state === "session_head_changed") {
+        return hasValidOwnershipEpoch && hasSuspension && hasPromptBinding
+            && !hasAttempt && record.result === null && isNonEmpty(record.reason);
+    }
+    return false;
+}
+function parseApprovalRecord(value) {
+    if (!isObject(value) || !hasExactKeys(value))
+        fail("corrupt_record");
+    const record = value;
+    if (!UUID.test(record.approvalId))
+        fail("corrupt_record");
+    for (const field of [
+        "toolCallId", "toolName", "policyId", "sessionKey", "sessionPath", "requesterId", "transport",
+        "transportUserId", "transportChatId",
+    ])
+        if (!isNonEmpty(record[field]))
+            fail("corrupt_record");
+    for (const field of [
+        "argumentDigest", "schemaDigest", "toolDigest", "policyDigest", "baseSessionRevision", "checkpointDigest",
+        "decisionTokenDigest",
+    ])
+        if (typeof record[field] !== "string" || !HASH.test(record[field]))
+            fail("corrupt_record");
+    if (!isObject(record.arguments) || !isObject(record.frozenAssistantMessage))
+        fail("corrupt_record");
+    assertJsonValue(record.arguments);
+    assertJsonValue(record.frozenAssistantMessage);
+    if (canonicalApprovalArguments(record.arguments).digest !== record.argumentDigest)
+        fail("corrupt_record");
+    if (!isTimestamp(record.expiresAt) || !isTimestamp(record.createdAt) || !isTimestamp(record.updatedAt))
+        fail("corrupt_record");
+    if (record.ownerId !== null && !isNonEmpty(record.ownerId))
+        fail("corrupt_record");
+    if (record.attemptedAt !== null && !isTimestamp(record.attemptedAt))
+        fail("corrupt_record");
+    if (record.reason !== null && !isNonEmpty(record.reason))
+        fail("corrupt_record");
+    if (record.result !== null && !isNonEmpty(record.result))
+        fail("corrupt_record");
+    if (record.transportMessageId !== null && !isNonEmpty(record.transportMessageId))
+        fail("corrupt_record");
+    if (record.suspendedSessionRevision !== null
+        && (typeof record.suspendedSessionRevision !== "string" || !HASH.test(record.suspendedSessionRevision)))
+        fail("corrupt_record");
+    if (!Number.isInteger(record.epoch) || record.epoch < 0 || !validStateShape(record) || !STATES.has(record.state))
+        fail("corrupt_record");
+    return structuredClone(record);
+}
+function assertHash(value, code) {
+    if (!HASH.test(value))
+        fail(code);
+}
+function assertPrepareInput(input) {
+    for (const value of [input.toolCallId, input.toolName, input.policyId, input.sessionKey, input.sessionPath,
+        input.requesterId, input.transport, input.transportUserId, input.transportChatId]) {
+        if (!isNonEmpty(value))
+            fail("invalid_proposal");
+    }
+    for (const value of [input.schemaDigest, input.toolDigest, input.policyDigest, input.baseSessionRevision, input.checkpointDigest]) {
+        assertHash(value, "invalid_proposal");
+    }
+    if (!isTimestamp(input.expiresAt) || !isObject(input.arguments) || !isObject(input.frozenAssistantMessage))
+        fail("invalid_proposal");
+    assertJsonValue(input.arguments);
+    assertJsonValue(input.frozenAssistantMessage);
+}
+function tokenMatches(token, digest) {
+    const actual = Buffer.from(sha256(token), "hex");
+    const expected = Buffer.from(digest, "hex");
+    return actual.length === expected.length && (0, node_crypto_1.timingSafeEqual)(actual, expected);
+}
+function sameDecisionBinding(record, input) {
+    return tokenMatches(input.decisionToken, record.decisionTokenDigest)
+        && input.requesterId === record.requesterId
+        && input.transport === record.transport
+        && input.transportUserId === record.transportUserId
+        && input.transportChatId === record.transportChatId
+        && input.transportMessageId === record.transportMessageId
+        && input.sessionKey === record.sessionKey;
+}
+function operationErrorMeta(operation, error) {
+    return {
+        operation,
+        outcome: "error",
+        code: error instanceof ApprovalStoreError ? error.code : "unexpected_error",
+    };
+}
+function observePrepare(operation) {
+    try {
+        const result = operation();
+        (0, runtime_1.emitNervesEvent)({ component: "heart", event: "approval.store_prepare", message: "approval store prepare completed", meta: { operation: "prepare", outcome: "success" } });
+        return result;
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({ level: "error", component: "heart", event: "approval.store_prepare", message: "approval store prepare failed", meta: operationErrorMeta("prepare", error) });
+        throw error;
+    }
+}
+function observeActivate(operation) {
+    try {
+        const result = operation();
+        (0, runtime_1.emitNervesEvent)({ component: "heart", event: "approval.store_activate", message: "approval store activation completed", meta: { operation: "activate", outcome: "success" } });
+        return result;
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({ level: "error", component: "heart", event: "approval.store_activate", message: "approval store activation failed", meta: operationErrorMeta("activate", error) });
+        throw error;
+    }
+}
+function observeBindPrompt(operation) {
+    try {
+        const result = operation();
+        (0, runtime_1.emitNervesEvent)({ component: "heart", event: "approval.store_bind_prompt", message: "approval prompt binding completed", meta: { operation: "bind_prompt", outcome: "success" } });
+        return result;
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({ level: "error", component: "heart", event: "approval.store_bind_prompt", message: "approval prompt binding failed", meta: operationErrorMeta("bind_prompt", error) });
+        throw error;
+    }
+}
+function observeDecide(operation) {
+    try {
+        const result = operation();
+        (0, runtime_1.emitNervesEvent)({ component: "heart", event: "approval.store_decide", message: "approval decision completed", meta: { operation: "decide", outcome: "success" } });
+        return result;
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({ level: "error", component: "heart", event: "approval.store_decide", message: "approval decision failed", meta: operationErrorMeta("decide", error) });
+        throw error;
+    }
+}
+function observeExpire(operation) {
+    try {
+        const result = operation();
+        (0, runtime_1.emitNervesEvent)({ component: "heart", event: "approval.store_expire", message: "approval expiry completed", meta: { operation: "expire", outcome: "success" } });
+        return result;
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({ level: "error", component: "heart", event: "approval.store_expire", message: "approval expiry failed", meta: operationErrorMeta("expire", error) });
+        throw error;
+    }
+}
+function observeMarkAttempted(operation) {
+    try {
+        const result = operation();
+        (0, runtime_1.emitNervesEvent)({ component: "heart", event: "approval.store_mark_attempted", message: "approval attempt marker completed", meta: { operation: "mark_attempted", outcome: "success" } });
+        return result;
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({ level: "error", component: "heart", event: "approval.store_mark_attempted", message: "approval attempt marker failed", meta: operationErrorMeta("mark_attempted", error) });
+        throw error;
+    }
+}
+function observeTerminalizeBeforeAttempt(operation) {
+    try {
+        const result = operation();
+        (0, runtime_1.emitNervesEvent)({ component: "heart", event: "approval.store_terminalize_before_attempt", message: "approval pre-attempt terminalization completed", meta: { operation: "terminalize_before_attempt", outcome: "success" } });
+        return result;
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({ level: "error", component: "heart", event: "approval.store_terminalize_before_attempt", message: "approval pre-attempt terminalization failed", meta: operationErrorMeta("terminalize_before_attempt", error) });
+        throw error;
+    }
+}
+function observeAbandonBeforeAttempt(operation) {
+    try {
+        const result = operation();
+        (0, runtime_1.emitNervesEvent)({ component: "heart", event: "approval.store_abandon_before_attempt", message: "approval abandonment completed", meta: { operation: "abandon_before_attempt", outcome: "success" } });
+        return result;
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({ level: "error", component: "heart", event: "approval.store_abandon_before_attempt", message: "approval abandonment failed", meta: operationErrorMeta("abandon_before_attempt", error) });
+        throw error;
+    }
+}
+function observeComplete(operation) {
+    try {
+        const result = operation();
+        (0, runtime_1.emitNervesEvent)({ component: "heart", event: "approval.store_complete", message: "approval completion completed", meta: { operation: "complete", outcome: "success" } });
+        return result;
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({ level: "error", component: "heart", event: "approval.store_complete", message: "approval completion failed", meta: operationErrorMeta("complete", error) });
+        throw error;
+    }
+}
+function observeClaimContinuation(operation) {
+    try {
+        const result = operation();
+        (0, runtime_1.emitNervesEvent)({ component: "heart", event: "approval.store_claim_continuation", message: "approval continuation claim completed", meta: { operation: "claim_continuation", outcome: "success" } });
+        return result;
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({ level: "error", component: "heart", event: "approval.store_claim_continuation", message: "approval continuation claim failed", meta: operationErrorMeta("claim_continuation", error) });
+        throw error;
+    }
+}
+function observeCompleteContinuation(operation) {
+    try {
+        const result = operation();
+        (0, runtime_1.emitNervesEvent)({ component: "heart", event: "approval.store_complete_continuation", message: "approval continuation completion completed", meta: { operation: "complete_continuation", outcome: "success" } });
+        return result;
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({ level: "error", component: "heart", event: "approval.store_complete_continuation", message: "approval continuation completion failed", meta: operationErrorMeta("complete_continuation", error) });
+        throw error;
+    }
+}
+function observeMaterializeContinuation(operation) {
+    try {
+        const result = operation();
+        (0, runtime_1.emitNervesEvent)({ component: "heart", event: "approval.store_materialize_continuation", message: "approval continuation materialization completed", meta: { operation: "materialize_continuation", outcome: "success" } });
+        return result;
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({ level: "error", component: "heart", event: "approval.store_materialize_continuation", message: "approval continuation materialization failed", meta: operationErrorMeta("materialize_continuation", error) });
+        throw error;
+    }
+}
+function observeAttemptContinuation(operation) {
+    try {
+        const result = operation();
+        (0, runtime_1.emitNervesEvent)({ component: "heart", event: "approval.store_attempt_continuation", message: "approval continuation attempt completed", meta: { operation: "attempt_continuation", outcome: "success" } });
+        return result;
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({ level: "error", component: "heart", event: "approval.store_attempt_continuation", message: "approval continuation attempt failed", meta: operationErrorMeta("attempt_continuation", error) });
+        throw error;
+    }
+}
+function observeRead(operation) {
+    try {
+        const result = operation();
+        (0, runtime_1.emitNervesEvent)({ component: "heart", event: "approval.store_read", message: "approval store read completed", meta: { operation: "read", outcome: "success" } });
+        return result;
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({ level: "error", component: "heart", event: "approval.store_read", message: "approval store read failed", meta: operationErrorMeta("read", error) });
+        throw error;
+    }
+}
+function observeListPreparing(operation) {
+    try {
+        const result = operation();
+        (0, runtime_1.emitNervesEvent)({ component: "heart", event: "approval.store_list_preparing", message: "preparing approval listing completed", meta: { operation: "list_preparing", outcome: "success" } });
+        return result;
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({ level: "error", component: "heart", event: "approval.store_list_preparing", message: "preparing approval listing failed", meta: operationErrorMeta("list_preparing", error) });
+        throw error;
+    }
+}
+function observeRecoverPreparing(operation) {
+    try {
+        const result = operation();
+        (0, runtime_1.emitNervesEvent)({ component: "heart", event: "approval.store_recover_preparing", message: "preparing approval recovery completed", meta: { operation: "recover_preparing", outcome: "success" } });
+        return result;
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({ level: "error", component: "heart", event: "approval.store_recover_preparing", message: "preparing approval recovery failed", meta: operationErrorMeta("recover_preparing", error) });
+        throw error;
+    }
+}
+function observeClose(operation) {
+    try {
+        const result = operation();
+        (0, runtime_1.emitNervesEvent)({ component: "heart", event: "approval.store_close", message: "approval store close completed", meta: { operation: "close", outcome: "success" } });
+        return result;
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({ level: "error", component: "heart", event: "approval.store_close", message: "approval store close failed", meta: operationErrorMeta("close", error) });
+        throw error;
+    }
+}
+function openApprovalStore(options) {
+    fs.mkdirSync(path.dirname(options.databasePath), { recursive: true });
+    const database = new better_sqlite3_1.default(options.databasePath);
+    database.pragma("journal_mode = WAL");
+    database.pragma("busy_timeout = 5000");
+    database.exec(`
+    CREATE TABLE IF NOT EXISTS approval_actions (
+      approval_id TEXT PRIMARY KEY,
+      state TEXT NOT NULL,
+      epoch INTEGER NOT NULL,
+      record_json TEXT NOT NULL
+    )
+    ;
+    CREATE TABLE IF NOT EXISTS approval_continuations (
+      approval_id TEXT PRIMARY KEY,
+      owner_id TEXT NOT NULL,
+      owner_pid INTEGER NOT NULL,
+      epoch INTEGER NOT NULL,
+      state TEXT NOT NULL,
+      claimed_at TEXT NOT NULL,
+      materialized_at TEXT,
+      attempted_at TEXT,
+      continued_at TEXT
+    )
+  `);
+    const now = options.now ?? (() => new Date());
+    const randomUUID = options.randomUUID ?? node_crypto_1.randomUUID;
+    const randomBytes = options.randomBytes ?? node_crypto_1.randomBytes;
+    const rawRead = (approvalId) => {
+        const row = database.prepare("SELECT record_json FROM approval_actions WHERE approval_id = ?")
+            .get(approvalId);
+        if (!row)
+            return null;
+        try {
+            return parseApprovalRecord(JSON.parse(row.record_json));
+        }
+        catch (error) {
+            if (error instanceof ApprovalStoreError)
+                throw error;
+            fail("corrupt_record");
+        }
+    };
+    const insert = (record) => {
+        database.prepare("INSERT INTO approval_actions (approval_id, state, epoch, record_json) VALUES (?, ?, ?, ?)")
+            .run(record.approvalId, record.state, record.epoch, JSON.stringify(record));
+    };
+    const cas = (previous, next) => {
+        const changed = database.prepare(`
+      UPDATE approval_actions SET state = ?, epoch = ?, record_json = ?
+      WHERE approval_id = ? AND state = ? AND epoch = ? AND record_json = ?
+    `).run(next.state, next.epoch, JSON.stringify(next), previous.approvalId, previous.state, previous.epoch, JSON.stringify(previous));
+        if (changed.changes !== 1)
+            fail("transition_conflict");
+        return structuredClone(next);
+    };
+    const requireRecord = (approvalId) => rawRead(approvalId) ?? fail("approval_not_found");
+    const timestamp = () => now().toISOString();
+    const readContinuationRow = (approvalId) => database.prepare(`
+    SELECT owner_id, owner_pid, epoch, state, claimed_at, materialized_at, attempted_at, continued_at
+    FROM approval_continuations WHERE approval_id = ?
+  `).get(approvalId);
+    const combineContinuation = (approval, row) => ({
+        ...approval,
+        continuationOwnerId: row.owner_id,
+        continuationOwnerPid: row.owner_pid,
+        continuationEpoch: row.epoch,
+        continuationState: row.state,
+        continuationClaimedAt: row.claimed_at,
+        continuationMaterializedAt: row.materialized_at,
+        continuationAttemptedAt: row.attempted_at,
+        continuedAt: row.continued_at,
+    });
+    const transitionContinuation = (input, from, to, timestampColumn) => {
+        const approval = requireRecord(input.approvalId);
+        const changed = database.prepare(`
+      UPDATE approval_continuations SET state = ?, ${timestampColumn} = ?
+      WHERE approval_id = ? AND owner_id = ? AND epoch = ? AND state = ?
+    `).run(to, timestamp(), input.approvalId, input.ownerId, input.epoch, from);
+        if (changed.changes !== 1)
+            fail(`continuation_${to}_not_eligible`);
+        return combineContinuation(approval, readContinuationRow(input.approvalId));
+    };
+    return {
+        prepare(input) {
+            return observePrepare(() => {
+                assertPrepareInput(input);
+                const approvalId = randomUUID();
+                if (!UUID.test(approvalId))
+                    fail("invalid_approval_id");
+                const tokenBytes = randomBytes(32);
+                if (tokenBytes.length !== 32)
+                    fail("invalid_token_entropy");
+                const decisionToken = tokenBytes.toString("base64url");
+                const createdAt = timestamp();
+                const record = {
+                    approvalId,
+                    state: "preparing",
+                    toolCallId: input.toolCallId,
+                    toolName: input.toolName,
+                    arguments: structuredClone(input.arguments),
+                    argumentDigest: canonicalApprovalArguments(input.arguments).digest,
+                    schemaDigest: input.schemaDigest,
+                    toolDigest: input.toolDigest,
+                    policyDigest: input.policyDigest,
+                    policyId: input.policyId,
+                    sessionKey: input.sessionKey,
+                    sessionPath: input.sessionPath,
+                    baseSessionRevision: input.baseSessionRevision,
+                    suspendedSessionRevision: null,
+                    checkpointDigest: input.checkpointDigest,
+                    requesterId: input.requesterId,
+                    transport: input.transport,
+                    transportUserId: input.transportUserId,
+                    transportChatId: input.transportChatId,
+                    transportMessageId: null,
+                    decisionTokenDigest: sha256(decisionToken),
+                    expiresAt: input.expiresAt,
+                    createdAt,
+                    updatedAt: createdAt,
+                    ownerId: null,
+                    epoch: 0,
+                    attemptedAt: null,
+                    result: null,
+                    reason: null,
+                    frozenAssistantMessage: structuredClone(input.frozenAssistantMessage),
+                };
+                insert(parseApprovalRecord(record));
+                return { record: structuredClone(record), decisionToken };
+            });
+        },
+        activate(input) {
+            return observeActivate(() => {
+                const previous = requireRecord(input.approvalId);
+                if (previous.state !== "preparing" || input.checkpointDigest !== previous.checkpointDigest)
+                    fail("invalid_activation");
+                assertHash(input.suspendedSessionRevision, "invalid_activation");
+                return cas(previous, { ...previous, state: "awaiting_prompt_binding", suspendedSessionRevision: input.suspendedSessionRevision, updatedAt: timestamp() });
+            });
+        },
+        bindPrompt(input) {
+            return observeBindPrompt(() => {
+                const previous = requireRecord(input.approvalId);
+                if (previous.state !== "awaiting_prompt_binding" || input.transport !== previous.transport
+                    || input.transportChatId !== previous.transportChatId || !isNonEmpty(input.transportMessageId))
+                    fail("invalid_prompt_binding");
+                return cas(previous, { ...previous, state: "proposed", transportMessageId: input.transportMessageId, updatedAt: timestamp() });
+            });
+        },
+        decide(input) {
+            return observeDecide(() => {
+                const previous = requireRecord(input.approvalId);
+                if (!sameDecisionBinding(previous, input))
+                    fail("decision_binding_mismatch");
+                if (previous.state === "denied" && input.decision === "deny")
+                    return previous;
+                if (previous.state !== "proposed")
+                    fail("decision_not_eligible");
+                if (now().getTime() >= Date.parse(previous.expiresAt)) {
+                    return cas(previous, { ...previous, state: "expired", updatedAt: timestamp() });
+                }
+                if (input.decision === "deny") {
+                    return cas(previous, { ...previous, state: "denied", updatedAt: timestamp() });
+                }
+                if (!isNonEmpty(input.ownerId))
+                    fail("invalid_owner");
+                options.hooks?.beforeClaimCas?.();
+                if (now().getTime() >= Date.parse(previous.expiresAt)) {
+                    return cas(previous, { ...previous, state: "expired", updatedAt: timestamp() });
+                }
+                return cas(previous, { ...previous, state: "claimed", ownerId: input.ownerId, epoch: previous.epoch + 1, updatedAt: timestamp() });
+            });
+        },
+        expire(input) {
+            return observeExpire(() => {
+                const previous = requireRecord(input.approvalId);
+                if (previous.state === "expired")
+                    return previous;
+                if ((previous.state !== "proposed" && previous.state !== "awaiting_prompt_binding")
+                    || now().getTime() < Date.parse(previous.expiresAt))
+                    fail("expiry_not_eligible");
+                return cas(previous, { ...previous, state: "expired", updatedAt: timestamp() });
+            });
+        },
+        markAttempted(input) {
+            return observeMarkAttempted(() => {
+                const previous = requireRecord(input.approvalId);
+                if (previous.state !== "claimed" || previous.ownerId !== input.ownerId || previous.epoch !== input.epoch)
+                    fail("attempt_not_eligible");
+                options.hooks?.beforeAttemptCas?.();
+                return cas(previous, { ...previous, state: "attempted", attemptedAt: timestamp(), updatedAt: timestamp() });
+            });
+        },
+        terminalizeBeforeAttempt(input) {
+            return observeTerminalizeBeforeAttempt(() => {
+                const previous = requireRecord(input.approvalId);
+                if (previous.state !== "claimed" || previous.ownerId !== input.ownerId || previous.epoch !== input.epoch
+                    || (input.state !== "drifted" && input.state !== "session_head_changed") || !isNonEmpty(input.reason)) {
+                    fail("pre_attempt_terminalization_not_eligible");
+                }
+                return cas(previous, { ...previous, state: input.state, reason: input.reason, updatedAt: timestamp() });
+            });
+        },
+        abandonBeforeAttempt(input) {
+            return observeAbandonBeforeAttempt(() => {
+                const previous = requireRecord(input.approvalId);
+                if (previous.state === "abandoned_before_attempt" && previous.ownerId === input.ownerId
+                    && previous.epoch === input.epoch && previous.reason === input.reason)
+                    return previous;
+                if (previous.state !== "claimed" || previous.ownerId !== input.ownerId || previous.epoch !== input.epoch
+                    || !isNonEmpty(input.reason))
+                    fail("abandon_not_eligible");
+                return cas(previous, { ...previous, state: "abandoned_before_attempt", reason: input.reason, updatedAt: timestamp() });
+            });
+        },
+        complete(input) {
+            return observeComplete(() => {
+                const previous = requireRecord(input.approvalId);
+                if (ATTEMPT_TERMINALS.has(previous.state)) {
+                    if (previous.state === input.state && previous.ownerId === input.ownerId && previous.epoch === input.epoch
+                        && previous.result === input.result)
+                        return previous;
+                    fail("completion_conflict");
+                }
+                if (previous.state !== "attempted" || previous.ownerId !== input.ownerId || previous.epoch !== input.epoch
+                    || !ATTEMPT_TERMINALS.has(input.state) || !isNonEmpty(input.result))
+                    fail("completion_not_eligible");
+                return cas(previous, { ...previous, state: input.state, result: input.result, updatedAt: timestamp() });
+            });
+        },
+        listPreparing() {
+            return observeListPreparing(() => {
+                const rows = database.prepare("SELECT record_json FROM approval_actions WHERE state = ? ORDER BY approval_id")
+                    .all("preparing");
+                return rows.map((row) => {
+                    try {
+                        return parseApprovalRecord(JSON.parse(row.record_json));
+                    }
+                    catch (error) {
+                        if (error instanceof ApprovalStoreError)
+                            throw error;
+                        return fail("corrupt_record");
+                    }
+                });
+            });
+        },
+        recoverPreparing(input) {
+            return observeRecoverPreparing(() => {
+                const previous = requireRecord(input.approvalId);
+                if (!isNonEmpty(input.reason))
+                    fail("recovery_not_eligible");
+                if (previous.state === input.state && previous.ownerId === null && previous.epoch === 0
+                    && previous.attemptedAt === null && previous.reason === input.reason)
+                    return previous;
+                if (previous.state !== "preparing")
+                    fail("recovery_not_eligible");
+                return cas(previous, { ...previous, state: input.state, reason: input.reason, updatedAt: timestamp() });
+            });
+        },
+        claimContinuation(input) {
+            return observeClaimContinuation(() => {
+                if (!isNonEmpty(input.ownerId))
+                    fail("invalid_continuation_owner");
+                const approval = requireRecord(input.approvalId);
+                if (!["succeeded", "failed", "denied", "expired", "drifted", "session_head_changed", "abandoned_before_attempt", "attempted_indeterminate"].includes(approval.state)) {
+                    fail("continuation_not_eligible");
+                }
+                const ownerPid = input.ownerPid ?? process.pid;
+                const claimedAt = timestamp();
+                const inserted = database.prepare(`
+          INSERT OR IGNORE INTO approval_continuations
+            (approval_id, owner_id, owner_pid, epoch, state, claimed_at, materialized_at, attempted_at, continued_at)
+          VALUES (?, ?, ?, 1, 'claimed', ?, NULL, NULL, NULL)
+        `).run(input.approvalId, input.ownerId, ownerPid, claimedAt);
+                let row = readContinuationRow(input.approvalId);
+                let claimed = inserted.changes === 1;
+                let interruptedAfterAttempt = false;
+                if (!claimed && (row.state === "claimed" || row.state === "materialized") && !processIsAlive(row.owner_pid)) {
+                    const reclaimed = database.prepare(`
+            UPDATE approval_continuations
+            SET owner_id = ?, owner_pid = ?, epoch = epoch + 1, claimed_at = ?
+            WHERE approval_id = ? AND owner_id = ? AND owner_pid = ? AND epoch = ? AND state = ?
+          `).run(input.ownerId, ownerPid, claimedAt, input.approvalId, row.owner_id, row.owner_pid, row.epoch, row.state);
+                    claimed = reclaimed.changes === 1;
+                    row = readContinuationRow(input.approvalId);
+                }
+                if (!claimed && row.state === "attempted" && !processIsAlive(row.owner_pid)) {
+                    const terminalized = database.prepare(`
+            UPDATE approval_continuations
+            SET owner_id = ?, owner_pid = ?, epoch = epoch + 1, state = 'completed', claimed_at = ?, continued_at = ?
+            WHERE approval_id = ? AND owner_id = ? AND owner_pid = ? AND epoch = ? AND state = 'attempted'
+          `).run(input.ownerId, ownerPid, claimedAt, claimedAt, input.approvalId, row.owner_id, row.owner_pid, row.epoch);
+                    interruptedAfterAttempt = terminalized.changes === 1;
+                    row = readContinuationRow(input.approvalId);
+                }
+                return {
+                    claimed,
+                    interruptedAfterAttempt,
+                    record: combineContinuation(approval, row),
+                };
+            });
+        },
+        markContinuationMaterialized(input) {
+            return observeMaterializeContinuation(() => transitionContinuation(input, "claimed", "materialized", "materialized_at"));
+        },
+        markContinuationAttempted(input) {
+            return observeAttemptContinuation(() => transitionContinuation(input, "materialized", "attempted", "attempted_at"));
+        },
+        completeContinuation(input) {
+            return observeCompleteContinuation(() => {
+                const approval = requireRecord(input.approvalId);
+                const completedAt = timestamp();
+                const changed = database.prepare(`
+          UPDATE approval_continuations SET state = 'completed', continued_at = ?
+          WHERE approval_id = ? AND owner_id = ? AND epoch = ?
+            AND state IN ('materialized', 'attempted') AND continued_at IS NULL
+        `).run(completedAt, input.approvalId, input.ownerId, input.epoch);
+                if (changed.changes !== 1)
+                    fail("continuation_completion_not_eligible");
+                return combineContinuation(approval, readContinuationRow(input.approvalId));
+            });
+        },
+        read(approvalId) { return observeRead(() => rawRead(approvalId)); },
+        close() {
+            return observeClose(() => {
+                options.hooks?.beforeClose?.();
+                database.close();
+            });
+        },
+    };
+}