@deepstrike/sdk 0.2.39 → 0.2.40

package/dist/runtime/kernel-transaction-log.js

@@ -0,0 +1,149 @@
+import { createHash } from "node:crypto";
+export const KERNEL_LOG_RECORD_VERSION = 1;
+export class KernelLogConflictError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "KernelLogConflictError";
+    }
+}
+export class KernelLogIntegrityError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "KernelLogIntegrityError";
+    }
+}
+export function canonicalKernelJson(value) {
+    if (value === null)
+        return "null";
+    if (typeof value === "string" || typeof value === "boolean")
+        return JSON.stringify(value);
+    if (typeof value === "number") {
+        if (!Number.isFinite(value))
+            throw new KernelLogIntegrityError("canonical records require finite numbers");
+        if (Number.isSafeInteger(value))
+            return JSON.stringify(Object.is(value, -0) ? 0 : value);
+        if (Number.isInteger(value)) {
+            throw new KernelLogIntegrityError("canonical record integer exceeds the cross-SDK safe range");
+        }
+        const bytes = new Uint8Array(8);
+        new DataView(bytes.buffer).setFloat64(0, value, false);
+        return `f64:${Array.from(bytes, byte => byte.toString(16).padStart(2, "0")).join("")}`;
+    }
+    if (Array.isArray(value))
+        return `[${value.map(canonicalKernelJson).join(",")}]`;
+    if (typeof value === "object") {
+        const object = value;
+        const keys = Object.keys(object).sort();
+        return `{${keys.map(key => `${JSON.stringify(key)}:${canonicalKernelJson(object[key])}`).join(",")}}`;
+    }
+    throw new KernelLogIntegrityError(`unsupported canonical record value: ${typeof value}`);
+}
+export function kernelRecordDigest(value) {
+    return createHash("sha256").update(canonicalKernelJson(value), "utf8").digest("hex");
+}
+export async function createKernelOperationGenesis(input) {
+    const body = {
+        record_version: KERNEL_LOG_RECORD_VERSION,
+        ...input,
+    };
+    validateGenesisBody(body);
+    return { ...body, genesis_digest: kernelRecordDigest(body) };
+}
+export async function createKernelTransaction(input) {
+    const body = {
+        record_version: KERNEL_LOG_RECORD_VERSION,
+        operation_id: input.operation_id,
+        step_seq: input.step_seq,
+        base_generation: input.base_generation,
+        input: input.input,
+        input_digest: kernelRecordDigest(input.input),
+        previous_transaction_digest: input.previous_transaction_digest,
+        step_digest: kernelRecordDigest(input.step),
+    };
+    validateTransactionBody(body);
+    return { ...body, transaction_digest: kernelRecordDigest(body) };
+}
+export function verifyKernelOperationGenesis(genesis) {
+    const { genesis_digest, ...body } = genesis;
+    validateGenesisBody(body);
+    if (kernelRecordDigest(body) !== genesis_digest) {
+        throw new KernelLogIntegrityError("kernel genesis digest does not match its canonical body");
+    }
+}
+export function verifyKernelTransaction(transaction) {
+    const { transaction_digest, ...body } = transaction;
+    validateTransactionBody(body);
+    if (kernelRecordDigest(body.input) !== body.input_digest) {
+        throw new KernelLogIntegrityError("kernel transaction input digest does not match its input");
+    }
+    if (kernelRecordDigest(body) !== transaction_digest) {
+        throw new KernelLogIntegrityError("kernel transaction digest does not match its canonical body");
+    }
+}
+export function verifyKernelTransactionSuccessor(previous, transaction) {
+    const expectedStepSeq = previous ? previous.step_seq + 1 : 1;
+    const expectedGeneration = previous ? previous.base_generation + 1 : 0;
+    if (transaction.step_seq !== expectedStepSeq) {
+        throw new KernelLogIntegrityError(`kernel transaction step_seq ${transaction.step_seq} does not follow ${expectedStepSeq - 1}`);
+    }
+    if (transaction.base_generation !== expectedGeneration) {
+        throw new KernelLogIntegrityError(`kernel transaction base_generation ${transaction.base_generation} does not match ${expectedGeneration}`);
+    }
+    if (transaction.input.operation_id !== transaction.operation_id) {
+        throw new KernelLogIntegrityError("kernel transaction input operation_id does not match its envelope");
+    }
+}
+/** Validate one complete authoritative operation stream and derive its next wire cursor. */
+export function verifyKernelTransactionStream(genesis, transactions) {
+    verifyKernelOperationGenesis(genesis);
+    let previous;
+    let head = genesis.genesis_digest;
+    for (const transaction of transactions) {
+        verifyKernelTransaction(transaction);
+        if (transaction.operation_id !== genesis.operation_id) {
+            throw new KernelLogIntegrityError("kernel transaction operation_id does not match genesis");
+        }
+        if (transaction.previous_transaction_digest !== head) {
+            throw new KernelLogIntegrityError("kernel transaction digest chain is not continuous");
+        }
+        verifyKernelTransactionSuccessor(previous, transaction);
+        previous = transaction;
+        head = transaction.transaction_digest;
+    }
+    const nextSequence = (previous?.step_seq ?? 0) + 1;
+    return {
+        operation_id: genesis.operation_id,
+        next_event_sequence: nextSequence,
+        next_step_seq: nextSequence,
+        transaction_head_digest: head,
+    };
+}
+function validateGenesisBody(genesis) {
+    if (genesis.record_version !== KERNEL_LOG_RECORD_VERSION) {
+        throw new KernelLogIntegrityError("unsupported kernel genesis record version");
+    }
+    if (!Number.isSafeInteger(genesis.abi_version) || genesis.abi_version <= 0) {
+        throw new KernelLogIntegrityError("kernel genesis abi_version must be a positive safe integer");
+    }
+    if (!genesis.operation_id)
+        throw new KernelLogIntegrityError("kernel genesis operation_id is required");
+    if (!Number.isSafeInteger(genesis.default_policy_version) || genesis.default_policy_version <= 0) {
+        throw new KernelLogIntegrityError("kernel genesis default_policy_version must be a positive safe integer");
+    }
+}
+function validateTransactionBody(transaction) {
+    if (transaction.record_version !== KERNEL_LOG_RECORD_VERSION) {
+        throw new KernelLogIntegrityError("unsupported kernel transaction record version");
+    }
+    if (!transaction.operation_id)
+        throw new KernelLogIntegrityError("kernel transaction operation_id is required");
+    if (!Number.isSafeInteger(transaction.step_seq) || transaction.step_seq <= 0) {
+        throw new KernelLogIntegrityError("kernel transaction step_seq must be a positive safe integer");
+    }
+    if (!Number.isSafeInteger(transaction.base_generation) || transaction.base_generation < 0) {
+        throw new KernelLogIntegrityError("kernel transaction base_generation must be a non-negative safe integer");
+    }
+    if (!transaction.previous_transaction_digest) {
+        throw new KernelLogIntegrityError("kernel transaction previous_transaction_digest is required");
+    }
+}

package/dist/runtime/large-result-spool.d.ts

@@ -57,6 +57,8 @@ export declare class LargeResultSpool {
      * Get spool file path for a hash.
      */
     private getSpoolPath;
+    private callKey;
+    private atomicWrite;
     /**
      * Write large result to disk.
      */
@@ -80,7 +82,7 @@ export declare class LargeResultSpool {
     /**
      * O7: locate a spooled output by the tool call's id (the `read_result` meta-tool only knows
      * `call_id`, not the content-hashed file name `persistOutput` chose). Scans the spool directory
-     * for the `${callId}-*.txt` naming convention; returns `undefined` if nothing was ever spooled
+     * for the hashed call-key prefix; returns `undefined` if nothing was ever spooled
      * for that call (e.g. it never actually exceeded the threshold, or the spool dir was cleaned up).
      */
     findByCallId(callId: string): Promise<string | undefined>;

package/dist/runtime/large-result-spool.js

@@ -46,6 +46,25 @@ export class LargeResultSpool {
     getSpoolPath(hash) {
         return path.join(this.spoolDir, `${hash}.txt`);
     }
+    callKey(callId) {
+        return this.hashContent(callId).slice(0, 32);
+    }
+    async atomicWrite(spoolPath, content) {
+        const tempPath = `${spoolPath}.${process.pid}.${crypto.randomUUID()}.tmp`;
+        let handle;
+        try {
+            handle = await fs.open(tempPath, 'wx');
+            await handle.writeFile(content, 'utf-8');
+            await handle.sync();
+            await handle.close();
+            handle = undefined;
+            await fs.rename(tempPath, spoolPath);
+        }
+        finally {
+            await handle?.close().catch(() => undefined);
+            await fs.unlink(tempPath).catch(() => undefined);
+        }
+    }
     /**
      * Write large result to disk.
      */
@@ -56,7 +75,7 @@ export class LargeResultSpool {
             promise = (async () => {
                 try {
                     await fs.mkdir(this.spoolDir, { recursive: true });
-                    await fs.writeFile(spoolPath, content, 'utf-8');
+                    await this.atomicWrite(spoolPath, content);
                     return spoolPath;
                 }
                 finally {
@@ -111,13 +130,13 @@ omitted: ${omitted} chars
      */
     async persistOutput(callId, content) {
         const hash = this.hashContent(content);
-        const spoolPath = this.getSpoolPath(`${callId}-${hash.slice(0, 16)}`);
+        const spoolPath = this.getSpoolPath(`${this.callKey(callId)}-${hash.slice(0, 16)}`);
         let promise = this.activeWrites.get(spoolPath);
         if (!promise) {
             promise = (async () => {
                 try {
                     await fs.mkdir(this.spoolDir, { recursive: true });
-                    await fs.writeFile(spoolPath, content, 'utf-8');
+                    await this.atomicWrite(spoolPath, content);
                     return spoolPath;
                 }
                 finally {
@@ -143,7 +162,7 @@ omitted: ${omitted} chars
     /**
      * O7: locate a spooled output by the tool call's id (the `read_result` meta-tool only knows
      * `call_id`, not the content-hashed file name `persistOutput` chose). Scans the spool directory
-     * for the `${callId}-*.txt` naming convention; returns `undefined` if nothing was ever spooled
+     * for the hashed call-key prefix; returns `undefined` if nothing was ever spooled
      * for that call (e.g. it never actually exceeded the threshold, or the spool dir was cleaned up).
      */
     async findByCallId(callId) {
@@ -154,7 +173,7 @@ omitted: ${omitted} chars
         catch {
             return undefined;
         }
-        const prefix = `${callId}-`;
+        const prefix = `${this.callKey(callId)}-`;
         const match = files.find(f => f.startsWith(prefix) && f.endsWith('.txt'));
         if (!match)
             return undefined;

package/dist/runtime/loop-driver.d.ts

@@ -12,7 +12,7 @@
  *
  * Durable pacing: every round appends `round_started` / `round_paced` to the loop's
  * session log, so `LoopDriver.resume()`-style recovery is a fold over the log
- * (the SessionLogGroupBudgetStore pattern) — zero new storage. A stateless host
+ * — zero new storage. A stateless host
  * reads `wake_at_ms` from the fold and re-arms via its own cron/queue; an
  * in-process host lets `run()` sleep inline.
  */

package/dist/runtime/loop-driver.js

@@ -108,9 +108,8 @@ export class LoopDriver {
                     defaultAction: this.spec.defaultAction,
                 },
             };
-            // With a RunGroup configured, run() seeds the kernel trap's round base from the
-            // group ledger (the driver charges rounds:1 per round below) — max_rounds coercion
-            // then happens IN-KERNEL; the check above is the ungrouped backstop.
+            // With a RunGroup configured, run() reserves one round and the kernel reports its
+            // correlated local usage; the check above remains the ungrouped backstop.
             try {
                 for await (const evt of this.runner.run({
                     sessionId: loopId,
@@ -164,10 +163,6 @@ export class LoopDriver {
                 reason: finalDecision.reason,
                 ...(finalDecision.coercedFrom ? { coerced_from: finalDecision.coercedFrom } : {}),
             });
-            // Lifetime governance: one round = one group charge on the rounds axis.
-            const group = this.runner.hostOptions.runGroup;
-            if (group)
-                await group.budgetStore.charge(group.id, { rounds: 1 });
             if (finalDecision.action === "stop") {
                 return {
                     loopId, roundsCompleted: round, stopped: true, state: "stopped",

package/dist/runtime/mcp-proxy-plane.d.ts

@@ -39,6 +39,7 @@ export declare class McpProxyPlane implements ExecutionPlane {
     constructor(opts: {
         servers: Record<string, McpServerConfig>;
         vault: CredentialVault;
+        timeoutMs?: number;
     });
     /** Start all configured MCP server processes and discover their tool schemas. */
     connect(): Promise<void>;

package/dist/runtime/mcp-proxy-plane.js

@@ -2,6 +2,7 @@ import { spawn } from "node:child_process";
 import { createInterface } from "node:readline";
 import { LocalExecutionPlane } from "./execution-plane.js";
 import { formatToolError } from "../tools/errors.js";
+import { operationAbortSignal } from "./reliability.js";
 class McpConnection {
     serverName;
     config;
@@ -63,14 +64,28 @@ class McpConnection {
             this.schemaNames.add(t.name);
         }
     }
-    request(method, params) {
+    request(method, params, signal) {
         return new Promise((resolve, reject) => {
             if (!this.child?.stdin) {
                 reject(new Error(`MCP server "${this.serverName}" not running`));
                 return;
             }
             const id = this.nextId++;
-            this.pending.set(id, { resolve, reject });
+            const cleanup = () => signal?.removeEventListener("abort", abort);
+            const abort = () => {
+                this.pending.delete(id);
+                cleanup();
+                reject(signal?.reason instanceof Error ? signal.reason : new Error("operation cancelled"));
+            };
+            this.pending.set(id, {
+                resolve: result => { cleanup(); resolve(result); },
+                reject: error => { cleanup(); reject(error); },
+            });
+            signal?.addEventListener("abort", abort, { once: true });
+            if (signal?.aborted) {
+                abort();
+                return;
+            }
             const msg = { jsonrpc: "2.0", method, id };
             if (params !== undefined)
                 msg.params = params;
@@ -87,10 +102,10 @@ class McpConnection {
     }
     schemas() { return this._schemas; }
     hasSchema(name) { return this.schemaNames.has(name); }
-    async execute(call) {
+    async execute(call, signal) {
         try {
             const args = JSON.parse(call.arguments || "{}");
-            const result = await this.request("tools/call", { name: call.name, arguments: args });
+            const result = await this.request("tools/call", { name: call.name, arguments: args }, signal);
             const text = (result.content ?? [])
                 .filter(c => c.type === "text")
                 .map(c => c.text ?? "")
@@ -192,8 +207,10 @@ export class McpProxyPlane {
         }
         const tasks = Array.from(groups.entries()).map(async ([conn, serverCalls]) => {
             const results = [];
-            for (const call of serverCalls)
-                results.push({ call, result: await conn.execute(call) });
+            for (const call of serverCalls) {
+                const signal = operationAbortSignal(ctx.operation, this.opts.timeoutMs ?? 30_000);
+                results.push({ call, result: await conn.execute(call, signal) });
+            }
             return results;
         });
         for (const settled of await Promise.all(tasks)) {

package/dist/runtime/os-profile.d.ts

@@ -1,16 +1,17 @@
 import type { GovernancePolicy } from "../governance.js";
 export type OsProfileId = "native";
+export interface SignalPolicy {
+    queueMax: number;
+    ttlMs?: number;
+    deadlineEscalation?: boolean;
+}
 export interface NativeOsProfile {
     id: OsProfileId;
-    attentionPolicy: {
-        maxQueueSize?: number;
-    };
+    signalPolicy: SignalPolicy;
     governancePolicy: GovernancePolicy;
 }
-/** Default attention policy for native profile smoke tests. */
-export declare const DEFAULT_NATIVE_ATTENTION_POLICY: {
-    maxQueueSize: number;
-};
+/** Default signal policy for native profile smoke tests. */
+export declare const DEFAULT_NATIVE_SIGNAL_POLICY: SignalPolicy;
 /** Permissive governance policy for native runs that do not need AskUser. */
 export declare const DEFAULT_NATIVE_GOVERNANCE_POLICY: GovernancePolicy;
 /** Default restrictive sandbox policy template requiring confirmation for modification/execution. */
@@ -22,9 +23,7 @@ export declare function assertNativeProfile(profile?: OsProfileId | NativeOsProf
 /**
  * Validates the declarative policies statically to prevent runtime crashes when loaded into the microkernel.
  */
-export declare function validateDeclarativePolicy(govPolicy?: GovernancePolicy, attentionPolicy?: {
-    maxQueueSize?: number;
-}): {
+export declare function validateDeclarativePolicy(govPolicy?: GovernancePolicy, signalPolicy?: SignalPolicy): {
     valid: boolean;
     errors: string[];
 };

package/dist/runtime/os-profile.js

@@ -1,5 +1,5 @@
-/** Default attention policy for native profile smoke tests. */
-export const DEFAULT_NATIVE_ATTENTION_POLICY = { maxQueueSize: 64 };
+/** Default signal policy for native profile smoke tests. */
+export const DEFAULT_NATIVE_SIGNAL_POLICY = { queueMax: 64 };
 /** Permissive governance policy for native runs that do not need AskUser. */
 export const DEFAULT_NATIVE_GOVERNANCE_POLICY = {
     rules: [{ pattern: "*", action: "allow" }],
@@ -21,7 +21,7 @@ export function osProfile(profile = "native") {
         throw new Error(`Unsupported OS profile: ${profile}`);
     return {
         id: "native",
-        attentionPolicy: DEFAULT_NATIVE_ATTENTION_POLICY,
+        signalPolicy: DEFAULT_NATIVE_SIGNAL_POLICY,
         governancePolicy: DEFAULT_NATIVE_GOVERNANCE_POLICY,
     };
 }
@@ -31,7 +31,7 @@ export function assertNativeProfile(profile = "native") {
     if (resolved.id !== "native") {
         throw new Error(`Unsupported OS profile: ${resolved.id}`);
     }
-    const validation = validateDeclarativePolicy(resolved.governancePolicy, resolved.attentionPolicy);
+    const validation = validateDeclarativePolicy(resolved.governancePolicy, resolved.signalPolicy);
     if (!validation.valid) {
         throw new Error(`Invalid native OS profile: ${validation.errors.join("; ")}`);
     }
@@ -40,7 +40,7 @@ export function assertNativeProfile(profile = "native") {
 /**
  * Validates the declarative policies statically to prevent runtime crashes when loaded into the microkernel.
  */
-export function validateDeclarativePolicy(govPolicy, attentionPolicy) {
+export function validateDeclarativePolicy(govPolicy, signalPolicy) {
     const errors = [];
     if (govPolicy) {
         if (!Array.isArray(govPolicy.rules)) {
@@ -57,11 +57,15 @@ export function validateDeclarativePolicy(govPolicy, attentionPolicy) {
             });
         }
     }
-    if (attentionPolicy) {
-        if (attentionPolicy.maxQueueSize !== undefined) {
-            if (typeof attentionPolicy.maxQueueSize !== "number" || attentionPolicy.maxQueueSize <= 0) {
-                errors.push("AttentionPolicy maxQueueSize must be a positive integer");
-            }
+    if (signalPolicy) {
+        if (!Number.isInteger(signalPolicy.queueMax) || signalPolicy.queueMax <= 0) {
+            errors.push("SignalPolicy queueMax must be a positive integer");
+        }
+        if (signalPolicy.ttlMs !== undefined && (!Number.isInteger(signalPolicy.ttlMs) || signalPolicy.ttlMs <= 0)) {
+            errors.push("SignalPolicy ttlMs must be a positive integer");
+        }
+        if (signalPolicy.deadlineEscalation !== undefined && typeof signalPolicy.deadlineEscalation !== "boolean") {
+            errors.push("SignalPolicy deadlineEscalation must be a boolean");
         }
     }
     return {

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

@@ -14,10 +14,29 @@ export interface OsSnapshot {
     }>;
     budgetExceeded: Array<{
         turn: number;
+        operation_id: string;
+        reservation_id?: string;
         budget: string;
     }>;
+    budgetUsageReported: Array<{
+        turn: number;
+        operation_id: string;
+        reservation_id: string;
+        tokens: number;
+        subagents: number;
+        rounds: number;
+    }>;
+    cancellations: Array<{
+        turn: number;
+        operation_id: string;
+        reason: "user" | "deadline" | "lease_lost" | "host_shutdown";
+        pending_call_ids: string[];
+    }>;
     signals: Array<{
         turn: number;
+        operation_id: string;
+        delivery_id: string;
+        attempt: number;
         signal_id: string;
         disposition: string;
         queue_depth: number;

package/dist/runtime/os-snapshot.js

@@ -8,8 +8,10 @@ const KERNEL_KINDS = new Set([
     "suspended",
     "resumed",
     "tool_gated",
-    "signal_disposed",
+    "signal_delivery_disposed",
     "budget_exceeded",
+    "budget_usage_reported",
+    "operation_cancelled",
     "checkpoint_taken",
     "rollbacked",
     "agent_process_changed",
@@ -23,6 +25,8 @@ export function rebuildOsSnapshotFromSessionEvents(events) {
     const snap = {
         processByAgent: [],
         budgetExceeded: [],
+        budgetUsageReported: [],
+        cancellations: [],
         signals: [],
         pageOutCount: 0,
         pageInCount: 0,
@@ -73,11 +77,37 @@ export function rebuildOsSnapshotFromSessionEvents(events) {
                 break;
             }
             case "budget_exceeded":
-                snap.budgetExceeded.push({ turn: event.turn, budget: event.budget });
+                snap.budgetExceeded.push({
+                    turn: event.turn,
+                    operation_id: event.operation_id,
+                    ...(event.reservation_id ? { reservation_id: event.reservation_id } : {}),
+                    budget: event.budget,
+                });
+                break;
+            case "budget_usage_reported":
+                snap.budgetUsageReported.push({
+                    turn: event.turn,
+                    operation_id: event.operation_id,
+                    reservation_id: event.reservation_id,
+                    tokens: event.tokens,
+                    subagents: event.subagents,
+                    rounds: event.rounds,
+                });
+                break;
+            case "operation_cancelled":
+                snap.cancellations.push({
+                    turn: event.turn,
+                    operation_id: event.operation_id,
+                    reason: event.reason,
+                    pending_call_ids: event.pending_call_ids,
+                });
                 break;
-            case "signal_disposed":
+            case "signal_delivery_disposed":
                 snap.signals.push({
                     turn: event.turn,
+                    operation_id: event.operation_id,
+                    delivery_id: event.delivery_id,
+                    attempt: event.attempt,
                     signal_id: event.signal_id,
                     disposition: event.disposition,
                     queue_depth: event.queue_depth,

package/dist/runtime/process-sandbox-plane.js

@@ -3,6 +3,7 @@ import { mkdir } from "node:fs/promises";
 import { tool } from "../tools/index.js";
 import { LocalExecutionPlane } from "./execution-plane.js";
 import { formatToolError } from "../tools/errors.js";
+import { operationAbortSignal } from "./reliability.js";
 /**
  * ExecutionPlane that runs subprocesses with a sandbox directory as cwd.
  * Extends LocalExecutionPlane with two built-in tools:
@@ -39,7 +40,7 @@ export class ProcessSandboxPlane extends LocalExecutionPlane {
         }
         return env;
     }
-    runSubprocess(cmd, argv, cwd) {
+    runSubprocess(cmd, argv, cwd, operation) {
         return new Promise(resolve => {
             const chunks = [];
             let totalBytes = 0;
@@ -48,7 +49,7 @@ export class ProcessSandboxPlane extends LocalExecutionPlane {
                 if (settled)
                     return;
                 settled = true;
-                clearTimeout(timer);
+                signal.removeEventListener("abort", abort);
                 resolve({ output, isError });
             };
             const child = spawn(cmd, argv, {
@@ -56,10 +57,14 @@ export class ProcessSandboxPlane extends LocalExecutionPlane {
                 env: this.buildEnv(),
                 stdio: ["ignore", "pipe", "pipe"],
             });
-            const timer = setTimeout(() => {
+            const signal = operationAbortSignal(operation, this.timeoutMs);
+            const abort = () => {
                 child.kill("SIGKILL");
-                settle(`timed out after ${this.timeoutMs}ms`, true);
-            }, this.timeoutMs);
+                settle(signal.reason instanceof Error ? signal.reason.message : "operation cancelled", true);
+            };
+            signal.addEventListener("abort", abort, { once: true });
+            if (signal.aborted)
+                abort();
             const capture = (chunk) => {
                 if (settled)
                     return;
@@ -89,9 +94,9 @@ export class ProcessSandboxPlane extends LocalExecutionPlane {
             const cwd = ctx?.cwd ?? this.sandboxDir;
             if (!ctx?.cwd)
                 await mkdir(this.sandboxDir, { recursive: true });
-            const { output, isError } = await this.runSubprocess("bash", ["-c", String(args.command)], cwd);
-            if (isError && !output.trim())
-                return "Process exited with non-zero status and produced no output.";
+            const { output, isError } = await this.runSubprocess("bash", ["-c", String(args.command)], cwd, ctx?.operation);
+            if (isError)
+                throw new Error(output.trim() || "Process exited with non-zero status and produced no output.");
             return output || "(no output)";
         });
     }
@@ -107,9 +112,9 @@ export class ProcessSandboxPlane extends LocalExecutionPlane {
             const cwd = ctx?.cwd ?? this.sandboxDir;
             if (!ctx?.cwd)
                 await mkdir(this.sandboxDir, { recursive: true });
-            const { output, isError } = await this.runSubprocess("node", ["-e", String(args.code)], cwd);
-            if (isError && !output.trim())
-                return "Script exited with non-zero status and produced no output.";
+            const { output, isError } = await this.runSubprocess("node", ["-e", String(args.code)], cwd, ctx?.operation);
+            if (isError)
+                throw new Error(output.trim() || "Script exited with non-zero status and produced no output.");
             return output || "(no output)";
         });
     }

package/dist/runtime/reaction-checkpoint.d.ts

@@ -0,0 +1,51 @@
+export interface ReactionRecord {
+    personaId: string;
+    output: string;
+}
+export interface ReactionCheckpointReceipt {
+    checkpointKey: string;
+    leaseToken: string;
+}
+export interface ReactionCheckpointClaim extends ReactionCheckpointReceipt {
+    leaseExpiresAtMs: number;
+    plan?: string[];
+    outputs: Record<string, string>;
+}
+export type ReactionCheckpointClaimResult = {
+    status: "claimed";
+    claim: ReactionCheckpointClaim;
+} | {
+    status: "completed";
+    reactions: ReactionRecord[];
+} | {
+    status: "busy";
+};
+export interface ReactionCheckpointStore {
+    claim(checkpointKey: string, leaseMs?: number): Promise<ReactionCheckpointClaimResult>;
+    savePlan(receipt: ReactionCheckpointReceipt, personaIds: string[]): Promise<string[] | null>;
+    record(receipt: ReactionCheckpointReceipt, reaction: ReactionRecord): Promise<boolean>;
+    complete(receipt: ReactionCheckpointReceipt): Promise<boolean>;
+    release(receipt: ReactionCheckpointReceipt): Promise<boolean>;
+}
+export interface InMemoryReactionCheckpointStoreOptions {
+    now?: () => number;
+    defaultLeaseMs?: number;
+}
+/** Process-local reference implementation; durable stores implement the same atomic contract. */
+export declare class InMemoryReactionCheckpointStore implements ReactionCheckpointStore {
+    private readonly opts;
+    private readonly states;
+    private leaseSeq;
+    constructor(opts?: InMemoryReactionCheckpointStoreOptions);
+    claim(checkpointKey: string, leaseMs?: number): Promise<ReactionCheckpointClaimResult>;
+    savePlan(receipt: ReactionCheckpointReceipt, personaIds: string[]): Promise<string[] | null>;
+    record(receipt: ReactionCheckpointReceipt, reaction: ReactionRecord): Promise<boolean>;
+    complete(receipt: ReactionCheckpointReceipt): Promise<boolean>;
+    release(receipt: ReactionCheckpointReceipt): Promise<boolean>;
+    private current;
+    private reactions;
+}
+export declare class ReactionInProgressError extends Error {
+    readonly checkpointKey: string;
+    constructor(checkpointKey: string);
+}