@ouro.bot/cli 0.1.0-alpha.729 → 0.1.0-alpha.730

package/dist/heart/tool-approval.js

@@ -0,0 +1,339 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApprovalExecutionFailedError = exports.ApprovalExecutionIndeterminateError = void 0;
+exports.coordinateApprovalDecision = coordinateApprovalDecision;
+exports.digestApprovalSuspensionCheckpointPayload = digestApprovalSuspensionCheckpointPayload;
+exports.commitApprovalProposal = commitApprovalProposal;
+exports.recoverApprovalProposals = recoverApprovalProposals;
+exports.executeApprovalDecision = executeApprovalDecision;
+exports.recoverClaimedApproval = recoverClaimedApproval;
+exports.recoverAttemptedApproval = recoverAttemptedApproval;
+const node_crypto_1 = require("node:crypto");
+const approval_store_1 = require("./approval-store");
+const runtime_1 = require("../nerves/runtime");
+const tool_arguments_1 = require("../repertoire/tool-arguments");
+class ApprovalExecutionIndeterminateError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ApprovalExecutionIndeterminateError";
+    }
+}
+exports.ApprovalExecutionIndeterminateError = ApprovalExecutionIndeterminateError;
+class ApprovalExecutionFailedError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ApprovalExecutionFailedError";
+    }
+}
+exports.ApprovalExecutionFailedError = ApprovalExecutionFailedError;
+async function coordinateApprovalDecision(options) {
+    return options.withSessionLease(async (lease) => {
+        let currentSessionRevision = options.readCurrentRevision();
+        const record = await options.decideAndExecute({
+            currentSessionRevision,
+            lease,
+            hooks: {
+                afterClaim: async () => {
+                    currentSessionRevision = options.readCurrentRevision();
+                },
+            },
+        });
+        await options.persist?.(record);
+        await options.resume(record);
+        (0, runtime_1.emitNervesEvent)({
+            component: "engine",
+            event: "engine.approval_decision_coordinated",
+            message: "approval decision coordinated under session turn lease",
+            meta: { approvalId: record.approvalId, state: record.state },
+        });
+        return { record };
+    });
+}
+function checkpointMatches(record, checkpoint) {
+    return checkpoint.approvalId === record.approvalId
+        && checkpoint.checkpointDigest === record.checkpointDigest
+        && checkpoint.baseSessionRevision === record.baseSessionRevision
+        && (record.state === "preparing" || checkpoint.suspendedSessionRevision === record.suspendedSessionRevision)
+        && checkpoint.argumentDigest === record.argumentDigest
+        && checkpoint.schemaDigest === record.schemaDigest
+        && checkpoint.toolDigest === record.toolDigest
+        && checkpoint.policyDigest === record.policyDigest
+        && checkpoint.preCallDigest === digestTranscript(checkpoint.preCallMessages)
+        && record.checkpointDigest === digestApprovalSuspensionCheckpointPayload(checkpoint)
+        && JSON.stringify(checkpoint.frozenAssistantMessage) === JSON.stringify(record.frozenAssistantMessage);
+}
+function frozenCallMatches(record, checkpoint) {
+    const message = checkpoint.frozenAssistantMessage;
+    if (message.role !== "assistant")
+        return false;
+    if (!Array.isArray(message.tool_calls) || message.tool_calls.length !== 1)
+        return false;
+    const call = message.tool_calls[0];
+    if (!call || typeof call !== "object" || Array.isArray(call))
+        return false;
+    const callRecord = call;
+    if (callRecord.type !== "function")
+        return false;
+    const fn = callRecord.function;
+    if (!fn || typeof fn !== "object" || Array.isArray(fn))
+        return false;
+    const functionRecord = fn;
+    if (callRecord.id !== record.toolCallId || functionRecord.name !== record.toolName || typeof functionRecord.arguments !== "string")
+        return false;
+    try {
+        const parsed = JSON.parse(functionRecord.arguments);
+        return JSON.stringify(parsed) === JSON.stringify(record.arguments);
+    }
+    catch {
+        return false;
+    }
+}
+function digestTranscript(messages) {
+    return (0, node_crypto_1.createHash)("sha256").update(JSON.stringify(messages), "utf8").digest("hex");
+}
+function digestApprovalSuspensionCheckpointPayload(checkpoint) {
+    return (0, node_crypto_1.createHash)("sha256").update(JSON.stringify({
+        baseSessionRevision: checkpoint.baseSessionRevision,
+        argumentDigest: checkpoint.argumentDigest,
+        schemaDigest: checkpoint.schemaDigest,
+        toolDigest: checkpoint.toolDigest,
+        policyDigest: checkpoint.policyDigest,
+        preCallDigest: checkpoint.preCallDigest,
+        preCallMessages: checkpoint.preCallMessages,
+        frozenAssistantMessage: checkpoint.frozenAssistantMessage,
+    }), "utf8").digest("hex");
+}
+function digestDecisionToken(token) {
+    return (0, node_crypto_1.createHash)("sha256").update(token, "utf8").digest("hex");
+}
+function commitApprovalProposal(options) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.approval_proposal_commit_start",
+        message: "approval proposal commit started",
+        meta: { toolName: options.proposal.toolName, toolCallId: options.proposal.toolCallId },
+    });
+    const preCallDigest = digestTranscript(options.preCallMessages);
+    const checkpointDigest = digestApprovalSuspensionCheckpointPayload({
+        baseSessionRevision: options.proposal.baseSessionRevision,
+        argumentDigest: (0, approval_store_1.canonicalApprovalArguments)(options.proposal.arguments).digest,
+        schemaDigest: options.proposal.schemaDigest,
+        toolDigest: options.proposal.toolDigest,
+        policyDigest: options.proposal.policyDigest,
+        preCallDigest,
+        preCallMessages: options.preCallMessages,
+        frozenAssistantMessage: options.proposal.frozenAssistantMessage,
+    });
+    const prepared = options.approvalStore.prepare({ ...options.proposal, checkpointDigest });
+    options.hooks?.afterJournalPrepare?.();
+    options.tokenStore.put(prepared.record.approvalId, prepared.decisionToken);
+    options.hooks?.afterTokenPersist?.();
+    const attestation = options.checkpointStore.write({
+        approvalId: prepared.record.approvalId,
+        baseSessionRevision: prepared.record.baseSessionRevision,
+        argumentDigest: prepared.record.argumentDigest,
+        schemaDigest: prepared.record.schemaDigest,
+        toolDigest: prepared.record.toolDigest,
+        policyDigest: prepared.record.policyDigest,
+        preCallDigest,
+        preCallMessages: structuredClone(options.preCallMessages),
+        frozenAssistantMessage: structuredClone(prepared.record.frozenAssistantMessage),
+    });
+    options.hooks?.afterCheckpointWrite?.();
+    if (attestation.checkpointDigest !== prepared.record.checkpointDigest) {
+        options.tokenStore.remove(prepared.record.approvalId);
+        options.checkpointStore.remove(prepared.record.approvalId);
+        options.approvalStore.recoverPreparing({
+            approvalId: prepared.record.approvalId,
+            state: "drifted",
+            reason: "checkpoint attestation digest mismatch",
+        });
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "engine",
+            event: "engine.approval_checkpoint_attestation_mismatch",
+            message: "approval checkpoint durability attestation did not match proposal",
+            meta: { approvalId: prepared.record.approvalId },
+        });
+        throw new approval_store_1.ApprovalStoreError("checkpoint_attestation_mismatch");
+    }
+    const record = options.approvalStore.activate({
+        approvalId: prepared.record.approvalId,
+        checkpointDigest: attestation.checkpointDigest,
+        suspendedSessionRevision: attestation.suspendedSessionRevision,
+    });
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.approval_proposal_commit_end",
+        message: "approval proposal checkpoint activated",
+        meta: { approvalId: record.approvalId },
+    });
+    return { record, decisionToken: prepared.decisionToken };
+}
+function recoverApprovalProposals(options) {
+    const recovered = [];
+    const preparing = options.approvalStore.listPreparing();
+    const preparingIds = new Set(preparing.map((record) => record.approvalId));
+    for (const checkpoint of options.checkpointStore.list()) {
+        if (preparingIds.has(checkpoint.approvalId) || options.approvalStore.read(checkpoint.approvalId))
+            continue;
+        options.checkpointStore.remove(checkpoint.approvalId);
+        recovered.push({ approvalId: checkpoint.approvalId, state: "orphan_checkpoint_removed" });
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "engine",
+            event: "engine.approval_orphan_checkpoint_removed",
+            message: "removed approval checkpoint with no journal authority",
+            meta: { approvalId: checkpoint.approvalId },
+        });
+    }
+    for (const record of preparing) {
+        const checkpoint = options.checkpointStore.read(record.approvalId);
+        const token = options.tokenStore.get(record.approvalId);
+        const hasToken = token !== null;
+        const tokenMatches = token !== null && digestDecisionToken(token) === record.decisionTokenDigest;
+        if (checkpoint && tokenMatches && checkpointMatches(record, checkpoint)) {
+            const activated = options.approvalStore.activate({
+                approvalId: record.approvalId,
+                checkpointDigest: checkpoint.checkpointDigest,
+                suspendedSessionRevision: checkpoint.suspendedSessionRevision,
+            });
+            recovered.push({ approvalId: record.approvalId, state: activated.state });
+            continue;
+        }
+        options.tokenStore.remove(record.approvalId);
+        if (checkpoint)
+            options.checkpointStore.remove(record.approvalId);
+        const checkpointMismatch = checkpoint !== null && !checkpointMatches(record, checkpoint);
+        const tokenMismatch = hasToken && !tokenMatches;
+        const mismatch = checkpointMismatch || tokenMismatch;
+        const terminal = options.approvalStore.recoverPreparing({
+            approvalId: record.approvalId,
+            state: mismatch ? "drifted" : "abandoned_before_attempt",
+            reason: tokenMismatch ? "decision token evidence mismatch" : mismatch ? "checkpoint evidence mismatch" : "incomplete proposal commit",
+        });
+        recovered.push({ approvalId: record.approvalId, state: terminal.state });
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "engine",
+        event: "engine.approval_proposal_recovery",
+        message: "approval proposal recovery scan completed",
+        meta: { recoveredCount: recovered.length },
+    });
+    return recovered;
+}
+function terminalizeClaimed(store, claimed, state, reason) {
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "engine",
+        event: "engine.approval_pre_attempt_terminalized",
+        message: "approval stopped during live revalidation",
+        meta: { approvalId: claimed.approvalId, state, reason },
+    });
+    return store.terminalizeBeforeAttempt({
+        approvalId: claimed.approvalId,
+        ownerId: claimed.ownerId,
+        epoch: claimed.epoch,
+        state,
+        reason,
+    });
+}
+async function executeApprovalDecision(options) {
+    const decided = options.approvalStore.decide({ ...options.decision, ownerId: options.ownerId });
+    if (decided.state !== "claimed")
+        return decided;
+    await options.hooks?.afterClaim?.();
+    if (options.currentSessionRevision !== decided.suspendedSessionRevision) {
+        return terminalizeClaimed(options.approvalStore, decided, "session_head_changed", "suspended session revision changed");
+    }
+    const checkpoint = options.checkpointStore.read(decided.approvalId);
+    if (!checkpoint || !checkpointMatches(decided, checkpoint) || !frozenCallMatches(decided, checkpoint)) {
+        return terminalizeClaimed(options.approvalStore, decided, "drifted", "checkpoint evidence drift");
+    }
+    const definition = options.resolveTool(decided.toolName);
+    if (!definition || definition.tool.function.name !== decided.toolName) {
+        return terminalizeClaimed(options.approvalStore, decided, "drifted", "tool identity drift");
+    }
+    const schema = definition.tool.function.parameters;
+    if (!schema || typeof schema !== "object") {
+        return terminalizeClaimed(options.approvalStore, decided, "drifted", "advertised schema missing");
+    }
+    const validated = (0, tool_arguments_1.validateAdvertisedToolArguments)(JSON.stringify(decided.arguments), schema);
+    if (!validated.ok || validated.value.argumentDigest !== decided.argumentDigest
+        || validated.value.schemaDigest !== decided.schemaDigest) {
+        return terminalizeClaimed(options.approvalStore, decided, "drifted", "tool arguments or schema drift");
+    }
+    const policy = definition.approvalPolicy?.(validated.value.arguments) ?? { kind: "not_required" };
+    if (policy.kind !== "required") {
+        return terminalizeClaimed(options.approvalStore, decided, "drifted", "approval policy no longer requires approval");
+    }
+    const toolDigest = (0, tool_arguments_1.digestJson)({ name: decided.toolName, schemaDigest: validated.value.schemaDigest, policyId: policy.policyId });
+    const policyDigest = (0, tool_arguments_1.digestJson)({ policyId: policy.policyId, actionClass: policy.actionClass, classification: "required" });
+    if (policy.policyId !== decided.policyId || toolDigest !== decided.toolDigest || policyDigest !== decided.policyDigest) {
+        return terminalizeClaimed(options.approvalStore, decided, "drifted", "approval policy or tool digest drift");
+    }
+    const context = {
+        record: structuredClone(decided),
+        checkpoint: structuredClone(checkpoint),
+        definition,
+        arguments: structuredClone(validated.value.arguments),
+    };
+    const guard = await options.liveGuard(context);
+    if (!guard.ok)
+        return terminalizeClaimed(options.approvalStore, decided, "drifted", guard.reason);
+    const risk = await options.liveRisk(context);
+    if (!risk.ok)
+        return terminalizeClaimed(options.approvalStore, decided, "drifted", risk.reason);
+    const attempted = options.approvalStore.markAttempted({
+        approvalId: decided.approvalId,
+        ownerId: decided.ownerId,
+        epoch: decided.epoch,
+    });
+    await options.hooks?.afterAttempt?.();
+    let result;
+    try {
+        result = await options.execute(attempted.toolName, structuredClone(attempted.arguments));
+    }
+    catch (error) {
+        if (!(error instanceof ApprovalExecutionFailedError))
+            throw error;
+        return options.approvalStore.complete({
+            approvalId: attempted.approvalId,
+            ownerId: attempted.ownerId,
+            epoch: attempted.epoch,
+            state: "failed",
+            result: `error: ${error.message}`,
+        });
+    }
+    await options.hooks?.afterHandler?.();
+    return options.approvalStore.complete({
+        approvalId: attempted.approvalId,
+        ownerId: attempted.ownerId,
+        epoch: attempted.epoch,
+        state: "succeeded",
+        result,
+    });
+}
+function recoverClaimedApproval(options) {
+    const record = options.approvalStore.read(options.approvalId);
+    if (!record || record.state !== "claimed" || !record.ownerId)
+        throw new approval_store_1.ApprovalStoreError("claimed_recovery_not_eligible");
+    return options.approvalStore.abandonBeforeAttempt({
+        approvalId: record.approvalId,
+        ownerId: record.ownerId,
+        epoch: record.epoch,
+        reason: options.reason,
+    });
+}
+function recoverAttemptedApproval(options) {
+    const record = options.approvalStore.read(options.approvalId);
+    if (!record || record.state !== "attempted" || !record.ownerId)
+        throw new approval_store_1.ApprovalStoreError("attempted_recovery_not_eligible");
+    return options.approvalStore.complete({
+        approvalId: record.approvalId,
+        ownerId: record.ownerId,
+        epoch: record.epoch,
+        state: "attempted_indeterminate",
+        result: "execution outcome is indeterminate after restart; action was not retried",
+    });
+}

package/dist/mind/context.js

@@ -47,7 +47,7 @@ const config_1 = require("../heart/config");
 const session_events_1 = require("../heart/session-events");
 const runtime_1 = require("../nerves/runtime");
 const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
+const session_transaction_1 = require("./session-transaction");
 const token_estimate_1 = require("./token-estimate");
 var session_events_2 = require("../heart/session-events");
 Object.defineProperty(exports, "detectDuplicateToolCallIds", { enumerable: true, get: function () { return session_events_2.detectDuplicateToolCallIds; } });
@@ -274,48 +274,65 @@ function denormalizeContinuityState(state) {
         ...(typeof state.lastFriendActivityAt === "string" ? { lastFriendActivityAt: state.lastFriendActivityAt } : {}),
     };
 }
-function writeSessionEnvelope(filePath, envelope) {
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, JSON.stringify(envelope, null, 2));
+function withMutationLease(filePath, lease, work) {
+    if (lease) {
+        (0, session_transaction_1.assertSessionTurnLease)(filePath, lease);
+        return work(lease);
+    }
+    const contextual = (0, session_transaction_1.currentSessionTurnLease)(filePath);
+    if (contextual)
+        return work(contextual);
+    return (0, session_transaction_1.withImmediateSessionTurnLease)(filePath, work);
 }
-function saveSession(filePath, messages, lastUsage, state) {
-    const existing = (0, session_events_1.loadSessionEnvelopeFile)(filePath);
-    const previousMessages = existing ? (0, session_events_1.projectProviderMessages)(existing) : [];
-    const currentIngressTimes = messages.map(session_events_1.getIngressTime);
-    const sanitized = (0, session_events_1.sanitizeProviderMessages)(messages);
-    const { envelope } = (0, session_events_1.buildCanonicalSessionEnvelope)({
-        existing,
-        previousMessages,
-        currentMessages: sanitized,
-        trimmedMessages: sanitized,
-        currentIngressTimes,
-        recordedAt: new Date().toISOString(),
-        lastUsage: lastUsage ?? null,
-        state,
-        projectionBasis: {
-            maxTokens: null,
-            contextMargin: null,
-            inputTokens: lastUsage?.input_tokens ?? null,
-        },
+function writeSessionEnvelopeUnderLease(filePath, envelope, lease, expectedRevision) {
+    const current = (0, session_transaction_1.readSessionTransaction)(filePath, lease);
+    (0, session_transaction_1.writeSessionTransaction)(filePath, envelope, {
+        lease,
+        expectedRevision: expectedRevision ?? current.revision,
+    });
+}
+function saveSession(filePath, messages, lastUsage, state, lease) {
+    withMutationLease(filePath, lease, (owned) => {
+        const existing = (0, session_events_1.loadSessionEnvelopeFile)(filePath);
+        const previousMessages = existing ? (0, session_events_1.projectProviderMessages)(existing) : [];
+        const currentIngressTimes = messages.map(session_events_1.getIngressTime);
+        const sanitized = (0, session_events_1.sanitizeProviderMessages)(messages);
+        const { envelope } = (0, session_events_1.buildCanonicalSessionEnvelope)({
+            existing,
+            previousMessages,
+            currentMessages: sanitized,
+            trimmedMessages: sanitized,
+            currentIngressTimes,
+            recordedAt: new Date().toISOString(),
+            lastUsage: lastUsage ?? null,
+            state,
+            projectionBasis: {
+                maxTokens: null,
+                contextMargin: null,
+                inputTokens: lastUsage?.input_tokens ?? null,
+            },
+        });
+        writeSessionEnvelopeUnderLease(filePath, envelope, owned);
     });
-    writeSessionEnvelope(filePath, envelope);
 }
-function appendSyntheticAssistantMessage(filePath, content) {
+function appendSyntheticAssistantMessage(filePath, content, lease) {
     try {
-        if (!fs.existsSync(filePath))
-            return false;
-        const envelope = (0, session_events_1.loadSessionEnvelopeFile)(filePath);
-        if (!envelope)
-            return false;
-        const updated = (0, session_events_1.appendSyntheticAssistantEvent)(envelope, content, new Date().toISOString());
-        writeSessionEnvelope(filePath, updated);
-        (0, runtime_1.emitNervesEvent)({
-            component: "mind",
-            event: "mind.session_synthetic_message_appended",
-            message: "appended synthetic assistant message to session",
-            meta: { path: filePath, contentLength: content.length },
+        return withMutationLease(filePath, lease, (owned) => {
+            if (!fs.existsSync(filePath))
+                return false;
+            const envelope = (0, session_events_1.loadSessionEnvelopeFile)(filePath);
+            if (!envelope)
+                return false;
+            const updated = (0, session_events_1.appendSyntheticAssistantEvent)(envelope, content, new Date().toISOString());
+            writeSessionEnvelopeUnderLease(filePath, updated, owned);
+            (0, runtime_1.emitNervesEvent)({
+                component: "mind",
+                event: "mind.session_synthetic_message_appended",
+                message: "appended synthetic assistant message to session",
+                meta: { path: filePath, contentLength: content.length },
+            });
+            return true;
         });
-        return true;
     }
     catch {
         return false;
@@ -379,26 +396,28 @@ function postTurnTrim(messages, usage, hooks) {
 /**
  * Synchronous persist: load existing envelope, build canonical envelope, write to disk.
  */
-function postTurnPersist(sessPath, prepared, usage, state) {
-    const existing = (0, session_events_1.loadSessionEnvelopeFile)(sessPath);
-    const previousMessages = existing ? (0, session_events_1.projectProviderMessages)(existing) : [];
-    const { envelope } = (0, session_events_1.buildCanonicalSessionEnvelope)({
-        existing,
-        previousMessages,
-        currentMessages: prepared.currentMessages,
-        trimmedMessages: prepared.trimmedMessages,
-        currentIngressTimes: prepared.currentIngressTimes,
-        recordedAt: new Date().toISOString(),
-        lastUsage: usage ?? null,
-        state,
-        projectionBasis: {
-            maxTokens: prepared.maxTokens,
-            contextMargin: prepared.contextMargin,
-            inputTokens: usage?.input_tokens ?? null,
-        },
+function postTurnPersist(sessPath, prepared, usage, state, lease, expectedRevision) {
+    return withMutationLease(sessPath, lease, (owned) => {
+        const existing = (0, session_events_1.loadSessionEnvelopeFile)(sessPath);
+        const previousMessages = existing ? (0, session_events_1.projectProviderMessages)(existing) : [];
+        const { envelope } = (0, session_events_1.buildCanonicalSessionEnvelope)({
+            existing,
+            previousMessages,
+            currentMessages: prepared.currentMessages,
+            trimmedMessages: prepared.trimmedMessages,
+            currentIngressTimes: prepared.currentIngressTimes,
+            recordedAt: new Date().toISOString(),
+            lastUsage: usage ?? null,
+            state,
+            projectionBasis: {
+                maxTokens: prepared.maxTokens,
+                contextMargin: prepared.contextMargin,
+                inputTokens: usage?.input_tokens ?? null,
+            },
+        });
+        writeSessionEnvelopeUnderLease(sessPath, envelope, owned, expectedRevision);
+        return envelope.events;
     });
-    writeSessionEnvelope(sessPath, envelope);
-    return envelope.events;
 }
 /**
  * Per-sessPath serialization queue. Without this, two concurrent
@@ -436,11 +455,11 @@ function enqueueSessionPersist(sessPath, fn) {
  * sessPath, so concurrent turns cannot race and produce duplicate event ids
  * in the saved session.
  */
-function deferPostTurnPersist(sessPath, prepared, usage, state) {
+function deferPostTurnPersist(sessPath, prepared, usage, state, lease, expectedRevision) {
     return enqueueSessionPersist(sessPath, () => new Promise((resolve) => {
         setImmediate(() => {
             try {
-                const events = postTurnPersist(sessPath, prepared, usage, state);
+                const events = postTurnPersist(sessPath, prepared, usage, state, lease, expectedRevision);
                 resolve(events);
             }
             catch (err) {
@@ -456,12 +475,6 @@ function deferPostTurnPersist(sessPath, prepared, usage, state) {
         });
     }));
 }
-function deleteSession(filePath) {
-    try {
-        fs.unlinkSync(filePath);
-    }
-    catch (e) {
-        if (e instanceof Error && e.code !== "ENOENT")
-            throw e;
-    }
+function deleteSession(filePath, lease) {
+    withMutationLease(filePath, lease, (owned) => (0, session_transaction_1.deleteSessionTransaction)(filePath, owned));
 }