@deepstrike/sdk 0.2.50 → 0.2.52

package/dist/runtime/execution-plane.d.ts

@@ -2,7 +2,6 @@ import type { ToolCall, ToolSchema, StreamEvent, ToolSuspendEvent, PermissionReq
 import type { RegisteredTool } from "../tools/index.js";
 import type { DreamStore, MemoryScope } from "../memory/protocols.js";
 import type { KnowledgeSource } from "../knowledge/source.js";
-import { LargeResultSpool } from "./large-result-spool.js";
 import type { OperationContext } from "./reliability.js";
 export interface RunContext {
     /** Immutable identity, deadline, and cancellation boundary for this operation. */
@@ -14,7 +13,6 @@ export interface RunContext {
     knowledgeSource?: KnowledgeSource;
     onToolSuspend?: (event: ToolSuspendEvent) => Promise<unknown> | unknown;
     onPermissionRequest?: (event: PermissionRequestEvent) => Promise<PermissionResponse | boolean> | PermissionResponse | boolean;
-    resultSpool?: LargeResultSpool;
     /** M3/G4 worktree isolation: the working directory a sub-agent's tools should run in (the git
      *  worktree created for an `isolation: "worktree"` node). Injected by `WorktreeExecutionPlane`; a
      *  cwd-aware execution plane / tool reads it to scope filesystem + subprocess work. Undefined ⇒
@@ -38,7 +36,6 @@ export declare class LocalExecutionPlane implements ExecutionPlane {
     unregister(name: string): this;
     schemas(): ToolSchema[];
     executeAll(calls: ToolCall[], ctx: RunContext): AsyncIterable<StreamEvent>;
-    private tryReadSpooledArgument;
     private executeSingle;
 }
 export declare function resolvePermissionRequest(request: PermissionRequestEvent, ctx: RunContext): Promise<PermissionResponse>;

package/dist/runtime/execution-plane.js

@@ -1,7 +1,6 @@
 import { isAsyncIterable, maybeWarnFailureShapedChunk, normalizeToolChunk, toolChunkText, validateToolArguments } from "../tools/index.js";
 import { formatToolError } from "../tools/errors.js";
 import { readSkillFile } from "../skills/loader.js";
-import { LargeResultSpool } from "./large-result-spool.js";
 export class LocalExecutionPlane {
     tools = new Map();
     register(...tools) {
@@ -81,30 +80,7 @@ export class LocalExecutionPlane {
             }
         }
     }
-    async tryReadSpooledArgument(call, ctx) {
-        const isReadTool = ["read", "read_file", "view_file", "read_spooled_result"].includes(call.name);
-        if (!isReadTool)
-            return null;
-        try {
-            const args = JSON.parse(call.arguments || "{}");
-            for (const val of Object.values(args)) {
-                if (typeof val === "string" && (val.startsWith(".spool/") || val.includes("/.spool/"))) {
-                    const spool = ctx.resultSpool ?? new LargeResultSpool();
-                    const content = await spool.readSpooledResult(val);
-                    return content;
-                }
-            }
-        }
-        catch {
-            // Ignore errors
-        }
-        return null;
-    }
     async *executeSingle(call, ctx) {
-        const spooledContent = await this.tryReadSpooledArgument(call, ctx);
-        if (spooledContent !== null) {
-            return { callId: call.id, output: spooledContent, isError: false };
-        }
         const registered = this.tools.get(call.name);
         if (!registered)
             return { callId: call.id, output: `unknown tool: ${call.name}`, isError: true };

package/dist/runtime/facade.js

@@ -58,6 +58,9 @@ export async function runFanout(opts) {
     if (opts.synthesisRole)
         spec.nodes[spec.nodes.length - 1].role = opts.synthesisRole;
     const outcome = await runner.runWorkflow(spec, opts.sessionId ? { sessionId: opts.sessionId } : undefined);
+    if (outcome.rejection) {
+        throw new Error(`workflow ${outcome.rejection.operation} rejected: ${outcome.rejection.reason}`);
+    }
     // The synthesis node is the last spec node; the kernel ids nodes `wf-node{index}`. Prefer that id,
     // but fall back to the last completed node's output so a kernel id-scheme change can't silently
     // return an empty synthesis.

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

@@ -9,7 +9,6 @@ export function categoryForKind(kind) {
         case "page_in_requested":
         case "renewed":
         case "context_renewed":
-        case "large_result_spooled":
         case "memory_written":
         case "memory_queried":
         case "memory_validation_failed":
@@ -111,7 +110,7 @@ export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
                 kind: "agent_process_changed",
                 turn: t,
                 agent_id: obs.agent_id ?? "",
-                parent_session_id: obs.parent_session_id ?? "",
+                parent_task_id: obs.parent_task_id ?? "",
                 role: obs.role ?? "",
                 isolation: obs.isolation ?? "",
                 context_inheritance: obs.context_inheritance ?? "",
@@ -182,16 +181,6 @@ export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
             };
         case "page_in_requested":
             return null;
-        case "large_result_spooled":
-            return {
-                kind: "large_result_spooled",
-                turn: t,
-                call_id: obs.call_id ?? "",
-                tool: obs.tool ?? "",
-                original_size: obs.original_size ?? 0,
-                preview_size: obs.preview_size ?? 0,
-                spool_ref: obs.spool_ref,
-            };
         case "page_out_archived":
             return {
                 kind: "page_out",
@@ -264,7 +253,12 @@ export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
             };
         }
         default:
-            return null;
+            return {
+                kind: "kernel_observation",
+                turn: t,
+                observation_kind: obs.kind,
+                raw: { ...obs },
+            };
     }
 }
 export function primitiveForCategory(category) {

package/dist/runtime/kernel-journal.d.ts

@@ -0,0 +1,264 @@
+/**
+ * `KernelJournal` — the durable transaction capability of the Canonical Kernel ABI (spec §9.1).
+ *
+ * This is the *authoritative* interface shape for all four SDKs (Node first, then Python/WASM/Rust).
+ *
+ * Three rules give this file its shape:
+ *
+ * 1. **Records are opaque.** core owns canonical serialization and hashing
+ *    (`KernelRecord::record_bytes()` / `record_digest()` / `expected_head()`). The host stores the
+ *    bytes verbatim and indexes them by the digest core handed it. A journal that re-serializes a
+ *    record to recompute its hash would make "the host recomputed and disagreed" a reachable state;
+ *    it is not one here.
+ * 2. **CAS is a storage-layer primitive, not a read-compare-write sequence.** §9.1 requires a real
+ *    atomic operation (file lock / `O_EXCL` chained naming / conditional database update).
+ *    `InMemoryKernelJournal` is atomic only within one process and says so in its own type;
+ *    `FileKernelJournal` is atomic across processes (see its class docs).
+ * 3. **The journal's sequence space is `step_seq`** — the operation's record-chain position — and is
+ *    completely independent of `SessionLog`'s business event `seq`. Pruning a journal prefix can
+ *    never punch a hole in business event numbering (spec Task 8b, criterion 4).
+ *
+ * Failures are typed so a caller can tell "retry after rebuild" from "this storage is broken" from
+ * "someone handed me a corrupt chain" — a durable-step wrapper must never publish effects on any of
+ * them, and must never collapse them into one opaque `Error`.
+ */
+export declare const MAX_CHAIN_POSITION = 1000000000000;
+/**
+ * The CAS precondition did not hold: the journal head (or checkpoint pointer) moved.
+ *
+ * Retryable — the protocol response is `abort(token)` → re-read head → rebuild → replay the input
+ * (spec §8.3, row "CAS conflict").
+ */
+export declare class JournalCasConflictError extends Error {
+    constructor(message: string);
+}
+/**
+ * The journal contents contradict themselves or the caller's claim: a broken digest chain, a
+ * `step_seq` that does not follow its predecessor, a checkpoint whose `covered_head` does not match
+ * the record at its `through_step_seq`. Never retryable — retrying replays the same contradiction.
+ */
+export declare class JournalIntegrityError extends Error {
+    constructor(message: string);
+}
+/**
+ * The storage layer failed (disk full, permission denied, hard links unsupported). Distinct from
+ * both of the above: the journal state is *unknown*, not known-conflicting and not known-corrupt.
+ */
+export declare class JournalIoError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+/** What a host hands the journal: core's opaque bytes plus the identity core assigned them. */
+export interface JournalRecordInput {
+    /** Chain position. Genesis (`ConfigureOperation`) is 0; every later record is `head + 1`. */
+    step_seq: number;
+    /** core's `record_digest`. The journal indexes by it and never recomputes it. */
+    record_digest: string;
+    /** core's `record_bytes`, stored verbatim. */
+    record_bytes: Uint8Array;
+}
+/** A stored record. `previous_record_digest` is the CAS precondition it was appended under. */
+export interface JournalEntry extends JournalRecordInput {
+    /** Absent on the genesis record only (spec §8.1: the first append's expected head is empty). */
+    previous_record_digest?: string;
+}
+/** The journal head: the last record of an operation's chain. */
+export interface JournalHead {
+    step_seq: number;
+    record_digest: string;
+}
+export interface JournalAppendReceipt {
+    step_seq: number;
+    record_digest: string;
+}
+/** The host-persistable part of `kernel.checkpoint_candidate()` (spec §12.3). */
+export interface CheckpointCandidate {
+    /** Stable identity of this checkpoint; the CAS token a later install names as its predecessor. */
+    checkpoint_id: string;
+    /** The chain position this checkpoint's logical state covers. */
+    through_step_seq: number;
+    /** core's digest of the logical state. Opaque to the journal. */
+    state_digest: string;
+    /** The serialized checkpoint blob, stored verbatim. */
+    checkpoint_bytes: Uint8Array;
+}
+export interface InstalledCheckpoint extends CheckpointCandidate {
+    /** Monotonic install ordinal. `previous_checkpoint_id === undefined` installs ordinal 0. */
+    ordinal: number;
+    /** The record digest at `through_step_seq` — verified at install, not required to still be head. */
+    covered_head: string;
+    previous_checkpoint_id?: string;
+    /**
+     * Whether `ackCheckpoint` has run. Prefix reclamation is gated on this: a checkpoint that is
+     * installed but not acknowledged is recoverable-from but not prune-authorising (spec §12.3 rule 5/6).
+     */
+    acknowledged: boolean;
+}
+export interface JournalPruneReceipt {
+    /** Highest `step_seq` no longer retained. `-1` when nothing has ever been pruned. */
+    pruned_through_step_seq: number;
+    pruned_count: number;
+}
+/**
+ * The durable transaction capability (spec §9.1). Deliberately *not* part of `SessionLog`: a custom
+ * business-projection log must never be forced to masquerade as a transactional journal (§9.4).
+ * One class may implement both — `InMemorySessionLog` does — but the interfaces stay separate.
+ *
+ * Guarantees an implementation owes (spec §9.1):
+ * - strict ordering within an operation;
+ * - a failed CAS never overwrites;
+ * - record bytes preserved verbatim;
+ * - checkpoint pointer advances monotonically;
+ * - the checkpoint store verifies `covered_head` against `through_step_seq` but does **not** require
+ *   it to still be the current transaction head (§22.14);
+ * - checkpoint pointer and prefix pruning have an explicit acknowledgement boundary.
+ */
+export interface KernelJournal {
+    /**
+     * Atomically append `record` iff the operation's head is exactly `expectedHead`.
+     *
+     * @param expectedHead `undefined` starts the chain (genesis; `record.step_seq` must be 0).
+     * @throws {JournalCasConflictError} head moved, or a genesis already exists.
+     * @throws {JournalIntegrityError} `step_seq` does not follow the head.
+     * @throws {JournalIoError} storage failure.
+     */
+    compareAndAppend(operationId: string, expectedHead: string | undefined, record: JournalRecordInput): Promise<JournalAppendReceipt>;
+    /** The current head, or `undefined` when the operation has no records and no pruned anchor. */
+    head(operationId: string): Promise<JournalHead | undefined>;
+    /** Records with `step_seq >= fromStepSeq` (default: the whole retained chain), in chain order. */
+    readFrom(operationId: string, fromStepSeq?: number): Promise<JournalEntry[]>;
+    /**
+     * Records strictly after the record whose digest is `afterHead` — the digest-anchored cursor
+     * §9.1 names `records_after(operation_id, checkpoint_head)`. `undefined` returns everything retained.
+     *
+     * @throws {JournalIntegrityError} `afterHead` names no retained record and no pruned anchor.
+     */
+    recordsAfter(operationId: string, afterHead?: string): Promise<JournalEntry[]>;
+    /**
+     * Atomically install `checkpoint` iff the operation's checkpoint pointer is exactly
+     * `previousCheckpointId`, and `coveredHead` is the record digest at `checkpoint.through_step_seq`.
+     *
+     * Per §22.14 this deliberately does **not** require `coveredHead` to still be the current
+     * transaction head: transactions appended after the candidate was taken stay as tail.
+     *
+     * @param previousCheckpointId `undefined` installs the operation's first checkpoint.
+     * @throws {JournalCasConflictError} the checkpoint pointer moved.
+     * @throws {JournalIntegrityError} `coveredHead`/`through_step_seq` disagree with the chain, or
+     *   `through_step_seq` would move the pointer backwards.
+     */
+    compareAndInstallCheckpoint(operationId: string, previousCheckpointId: string | undefined, coveredHead: string, checkpoint: CheckpointCandidate): Promise<InstalledCheckpoint>;
+    /** The highest-ordinal installed checkpoint, acknowledged or not. */
+    latestCheckpoint(operationId: string): Promise<InstalledCheckpoint | undefined>;
+    /**
+     * Record the durable acknowledgement that opens the prefix-reclamation boundary. Idempotent.
+     *
+     * @throws {JournalIntegrityError} no checkpoint with that id is installed.
+     */
+    ackCheckpoint(operationId: string, checkpointId: string): Promise<InstalledCheckpoint>;
+    /**
+     * Reclaim the record prefix covered by the latest **acknowledged** checkpoint. A no-op while no
+     * checkpoint is acknowledged. The pruned boundary is retained as an anchor so `head()` and the
+     * next CAS still resolve on a fully-pruned chain.
+     */
+    pruneAckedPrefix(operationId: string): Promise<JournalPruneReceipt>;
+    /**
+     * Durably stage one outbound WireEnvelope JSON for `operationId` until the matching record is
+     * append-acked (or the attempt is abandoned). Overwrites any previous pending envelope.
+     *
+     * Required by Phase 6 host cutover (adjudication 5e.3): retries must replay byte-identical
+     * envelopes — reminting `observed_at_ms` after a crash produces `DuplicateInputConflict`.
+     */
+    stageOutboundEnvelope(operationId: string, envelopeJson: string): Promise<void>;
+    /** Read the staged outbound envelope, if any. */
+    readOutboundEnvelope(operationId: string): Promise<string | undefined>;
+    /** Clear the staged outbound envelope. Idempotent. */
+    clearOutboundEnvelope(operationId: string): Promise<void>;
+}
+/**
+ * **Single-process dev/test implementation.**
+ *
+ * CAS is genuinely atomic here — every check-then-mutate below runs to completion without an
+ * intervening `await`, so no other task can interleave on a single-threaded runtime — but that
+ * atomicity ends at the process boundary. Two processes sharing "the same" journal do not exist:
+ * each has its own `Map`. Production hosts must supply a `KernelJournal` whose CAS is a real
+ * storage-layer primitive (spec §9.1); `FileKernelJournal` is the reference for that.
+ */
+export declare class InMemoryKernelJournal implements KernelJournal {
+    private readonly operations;
+    private state;
+    private headOf;
+    compareAndAppend(operationId: string, expectedHead: string | undefined, record: JournalRecordInput): Promise<JournalAppendReceipt>;
+    head(operationId: string): Promise<JournalHead | undefined>;
+    readFrom(operationId: string, fromStepSeq?: number): Promise<JournalEntry[]>;
+    recordsAfter(operationId: string, afterHead?: string): Promise<JournalEntry[]>;
+    compareAndInstallCheckpoint(operationId: string, previousCheckpointId: string | undefined, coveredHead: string, checkpoint: CheckpointCandidate): Promise<InstalledCheckpoint>;
+    latestCheckpoint(operationId: string): Promise<InstalledCheckpoint | undefined>;
+    ackCheckpoint(operationId: string, checkpointId: string): Promise<InstalledCheckpoint>;
+    pruneAckedPrefix(operationId: string): Promise<JournalPruneReceipt>;
+    stageOutboundEnvelope(operationId: string, envelopeJson: string): Promise<void>;
+    readOutboundEnvelope(operationId: string): Promise<string | undefined>;
+    clearOutboundEnvelope(operationId: string): Promise<void>;
+}
+/**
+ * **Cross-process atomic reference implementation** of `KernelJournal` (spec Task 8b).
+ *
+ * The atomicity primitive is POSIX `link(2)`: content is written to a private temp file and fsynced,
+ * then hard-linked into its final name. `link` fails with `EEXIST` if the name is taken, and it
+ * publishes already-complete content — so a crash can never leave a half-written `.rec`, only an
+ * orphan temp file that the naming rule ignores. The journal root must therefore live on a
+ * filesystem that supports hard links; that requirement is the price of real CAS.
+ *
+ * **Why the record filename is `<step_seq>.rec` and contains no digest.** The filename *is* the
+ * collision domain. Two writers racing on the same head both compute the same next `step_seq`, so
+ * they contend for one name and exactly one wins. Folding a per-writer value (the new record's
+ * digest) into the name would give the racers *different* names — both `link`s would succeed and the
+ * chain would fork. Only the predecessor-determined part of the identity may appear in the name.
+ *
+ * The pre-`link` head check is not a TOCTOU hole: it can only *reject* an append that `link` would
+ * have accepted (a stale `expectedHead` whose `step_seq` slot happens to be free), never accept one
+ * `link` would have rejected. Every acceptance is still decided by the atomic `link`.
+ *
+ * Checkpoint installs use the same primitive on a separate ordinal space
+ * (`<ordinal>.ckpt`), so two processes installing on the same predecessor also contend for one name.
+ */
+export declare class FileKernelJournal implements KernelJournal {
+    private readonly root;
+    constructor(root: string);
+    private operationDir;
+    private recordsDir;
+    private checkpointsDir;
+    private tmpDir;
+    private prunedPath;
+    /**
+     * Write `payload` to a temp file, fsync it, then atomically claim `target` by hard link.
+     *
+     * @returns `false` when the name was already taken — i.e. a lost CAS race.
+     */
+    private publish;
+    private syncDir;
+    /** Sorted `step_seq` values of the retained records. Anything not matching the rule is residue. */
+    private recordSeqs;
+    private readRecord;
+    private prunedAnchor;
+    head(operationId: string): Promise<JournalHead | undefined>;
+    compareAndAppend(operationId: string, expectedHead: string | undefined, record: JournalRecordInput): Promise<JournalAppendReceipt>;
+    readFrom(operationId: string, fromStepSeq?: number): Promise<JournalEntry[]>;
+    recordsAfter(operationId: string, afterHead?: string): Promise<JournalEntry[]>;
+    /** Sorted ordinals of installed checkpoints. */
+    private checkpointOrdinals;
+    private ackedOrdinals;
+    private readCheckpoint;
+    latestCheckpoint(operationId: string): Promise<InstalledCheckpoint | undefined>;
+    compareAndInstallCheckpoint(operationId: string, previousCheckpointId: string | undefined, coveredHead: string, checkpoint: CheckpointCandidate): Promise<InstalledCheckpoint>;
+    ackCheckpoint(operationId: string, checkpointId: string): Promise<InstalledCheckpoint>;
+    pruneAckedPrefix(operationId: string): Promise<JournalPruneReceipt>;
+    /** The anchor only ever moves forward, so an atomic overwriting `rename` is the right primitive. */
+    private writeAnchor;
+    private outboundPath;
+    /** Overwriteable durable blob — same write-tmp→fsync→rename pattern as the pruned anchor. */
+    private writeReplaceable;
+    stageOutboundEnvelope(operationId: string, envelopeJson: string): Promise<void>;
+    readOutboundEnvelope(operationId: string): Promise<string | undefined>;
+    clearOutboundEnvelope(operationId: string): Promise<void>;
+}