@deepstrike/sdk 0.2.49 → 0.2.51

package/dist/runtime/kernel-primitives-dashboard.d.ts

@@ -20,8 +20,6 @@ export interface PrimitivesStats {
         compressedCount: number;
         pageOutCount: number;
         pageInCount: number;
-        largeResultSpooledCount: number;
-        totalSpooledBytes: number;
         contextRenewedCount: number;
     };
 }

package/dist/runtime/kernel-primitives-dashboard.js

@@ -22,8 +22,6 @@ export class KernelPrimitivesDashboard {
             compressedCount: 0,
             pageOutCount: 0,
             pageInCount: 0,
-            largeResultSpooledCount: 0,
-            totalSpooledBytes: 0,
             contextRenewedCount: 0,
         },
     };
@@ -80,10 +78,6 @@ export class KernelPrimitivesDashboard {
                 this.stats.mm.pageInCount++;
             else if (event.kind === "context_renewed")
                 this.stats.mm.contextRenewedCount++;
-            else if (event.kind === "large_result_spooled") {
-                this.stats.mm.largeResultSpooledCount++;
-                this.stats.mm.totalSpooledBytes += event.original_size;
-            }
         }
         // Special handling for tool completion which logs at outer runner
         if (event.kind === "tool_completed") {
@@ -120,8 +114,7 @@ export class KernelPrimitivesDashboard {
             `║                                                                      ║`,
             `║ ${bold}${magenta}💾 MM (Memory Management & Context Paging)${reset}                          ║`,
             `║   - Compressions: ${s.mm.compressedCount.toString().padEnd(9)} - Page-Outs (Semantic): ${s.mm.pageOutCount.toString().padEnd(10)}       ║`,
-            `║   - Page-Ins (Cache): ${s.mm.pageInCount.toString().padEnd(7)} - Large Spooled: ${s.mm.largeResultSpooledCount.toString().padEnd(14)} ║`,
-            `║   - Total Spooled Bytes: ${(s.mm.totalSpooledBytes / 1024).toFixed(1).toString() + " KB"}`.padEnd(70) + "║",
+            `║   - Page-Ins (Cache): ${s.mm.pageInCount.toString().padEnd(43)} ║`,
             footer
         ];
         return lines.join("\n");

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

@@ -1,69 +1,7 @@
 import type { EntropySample, Message, RenderedContext, TaskUpdate, ToolCall, ToolResult, ToolSchema } from "../types.js";
 import type { SkillMetadata } from "../skills/loader.js";
 import type { RollbackReason } from "./session-log.js";
-import type { SessionLog } from "./session-log.js";
-export declare const KERNEL_ABI_VERSION = 2;
-export interface KernelRuntimeHandle {
-    step(inputJson: string): string;
-    prepareStep(inputJson: string): string;
-    commitPrepared(prepareToken: string): string;
-    abortPrepared(prepareToken: string): void;
-    snapshot(): string;
-    restore(snapshotJson: string): void;
-    diagnostics(): string;
-    isTerminal(): boolean;
-    turn(): number;
-    recoveryContentBytes(): number;
-    render(): RenderedContext;
-    drainNewMessages(): Message[];
-    preservedRefs(): string[];
-}
-export type KernelPreparationStatus = "prepared" | "replayed" | "rejected";
-export interface KernelPreparedStep {
-    status: KernelPreparationStatus;
-    base_generation: number;
-    prepare_token?: string;
-    input: Record<string, unknown>;
-    step: KernelStepJson;
-}
-export interface KernelDiagnostics {
-    lifecycle: string;
-    next_step_seq: number;
-    accepted_input_count: number;
-    accepted_input_bytes: number;
-    snapshot_input_limit: number;
-    snapshot_journal_bytes_limit: number;
-    max_input_bytes: number;
-    snapshot_overflowed: boolean;
-    recorded_event_count: number;
-    completed_effect_count: number;
-    pending_effect_count: number;
-}
-export declare function readKernelDiagnostics(runtime: KernelRuntimeHandle): KernelDiagnostics;
-export interface KernelSnapshot {
-    snapshot_version: 2;
-    abi_version: 2;
-    initial_policy: {
-        max_tokens: number;
-        max_turns: number;
-        max_total_tokens: string;
-        max_wall_ms?: string;
-    };
-    lifecycle: string;
-    operation_id?: string;
-    next_step_seq: number;
-    snapshot_input_limit: number;
-    max_input_bytes: number;
-    snapshot_journal_bytes_limit: number;
-    accepted_input_bytes: number;
-    accepted_inputs: Array<{
-        event_id: string;
-        [key: string]: unknown;
-    }>;
-    last_step?: Record<string, unknown>;
-}
-export declare function snapshotKernelRuntime(runtime: KernelRuntimeHandle): KernelSnapshot;
-export declare function restoreKernelRuntime(runtime: KernelRuntimeHandle, snapshot: KernelSnapshot): void;
+export declare function encodeCanonicalContentParts(parts: unknown[]): string;
 export interface PaceDecision {
     action: "continue" | "sleep" | "stop";
     delayMs?: number;
@@ -75,6 +13,7 @@ export interface KernelLoopResult {
     termination: string;
     turnsUsed: number;
     totalTokensUsed: number;
+    finalMessage?: Message;
     /** ③ loop-agent: the kernel-adjudicated after-round decision (absent on non-loop runs). */
     paceDecision?: PaceDecision;
 }
@@ -117,6 +56,10 @@ export type KernelRunnerAction = {
     kind: "preempt_sub_agents";
     effectId: string;
     agentIds: string[];
+    attempts?: Array<{
+        task_id: string;
+        attempt_id: string;
+    }>;
     reason: string;
 } | {
     kind: "persist_memory";
@@ -127,22 +70,26 @@ export type KernelRunnerAction = {
     effectId: string;
     query: Record<string, unknown>;
     requestedK: number;
-} | {
-    kind: "spool_large_result";
-    effectId: string;
-    callId: string;
-    tool: string;
-    output: string;
-    originalSize: number;
-    previewSize: number;
 } | {
     kind: "archive_page_out";
     effectId: string;
-    turn: number;
-    action: string;
+    turn?: number;
+    action?: string;
     summary?: string;
-    archived: Message[];
-    tier: string;
+    archived?: Message[];
+    tier?: string;
+    handleId?: string;
+    payload?: {
+        content: string;
+        digest: string;
+        original_size: string;
+        preview?: string;
+    };
+} | {
+    kind: "load_payload";
+    effectId: string;
+    handleId: string;
+    payloadRef: string;
 } | {
     kind: "evaluate_milestone";
     effectId: string;
@@ -150,6 +97,10 @@ export type KernelRunnerAction = {
     criteria: string[];
     verifier?: MilestoneVerifierKind;
     requiredEvidence: string[];
+} | {
+    kind: "unsupported_effect";
+    effectId: string;
+    effectKind: string;
 } | {
     kind: "done";
     effectId: string;
@@ -182,7 +133,7 @@ export interface KernelObservation {
     tokens_freed?: number;
     reason?: RollbackReason | string;
     agent_id?: string;
-    parent_session_id?: string;
+    parent_task_id?: string;
     role?: string;
     isolation?: string;
     context_inheritance?: string;
@@ -207,7 +158,6 @@ export interface KernelObservation {
     tier?: string;
     message_count?: number;
     archive_ref?: string;
-    spool_ref?: string;
     original_size?: number;
     preview_size?: number;
     record_id?: string;
@@ -252,19 +202,6 @@ export interface KernelObservation {
     window_turns?: number;
     threshold?: number;
 }
-export interface KernelStepJson {
-    version: number;
-    operation_id: string;
-    input_event_id: string;
-    step_seq: number;
-    actions: Array<Record<string, unknown>>;
-    observations: KernelObservation[];
-    faults?: Array<{
-        code?: string;
-        message?: string;
-        effect_id?: string;
-    }>;
-}
 export declare function toolSchemaToKernel(schema: ToolSchema): Record<string, unknown>;
 export declare function skillMetadataToKernel(skill: SkillMetadata): Record<string, unknown>;
 export declare function messageToKernelMessage(message: Message): Record<string, unknown>;
@@ -277,22 +214,5 @@ export declare function capabilityCommandMount(capability: Record<string, unknow
 export declare function capabilityCommandUnmount(capabilityKind: string, id: string): Record<string, unknown>;
 /** Camel-case an `entropy_sample` kernel observation into the SDK's `EntropySample`. */
 export declare function entropySampleFromObservation(obs: KernelObservation): EntropySample;
-/**
- * Execute one production transition behind the durable action-publish gate. Genesis is persisted
- * before prepare; a newly prepared transaction is CAS-appended before commit; only the committed
- * step is returned to callers, so actions and observations cannot escape early.
- */
-export declare function durableKernelStep(runtime: KernelRuntimeHandle, sessionLog: SessionLog, sessionId: string, event: Record<string, unknown>): Promise<KernelStepJson>;
-export declare function durableKernelApply(runtime: KernelRuntimeHandle, sessionLog: SessionLog, sessionId: string, pending: KernelObservation[], event: Record<string, unknown>): Promise<KernelObservation[]>;
-export declare function durableKernelMaybeAction(runtime: KernelRuntimeHandle, sessionLog: SessionLog, sessionId: string, pending: KernelObservation[], event: Record<string, unknown>): Promise<KernelRunnerAction | null>;
-export declare function durableKernelAction(runtime: KernelRuntimeHandle, sessionLog: SessionLog, sessionId: string, pending: KernelObservation[], event: Record<string, unknown>): Promise<KernelRunnerAction>;
-export declare function kernelApply(runtime: KernelRuntimeHandle, pending: KernelObservation[], event: Record<string, unknown>): KernelObservation[];
-export declare function kernelAction(runtime: KernelRuntimeHandle, pending: KernelObservation[], event: Record<string, unknown>): KernelRunnerAction;
-/**
- * Like {@link kernelAction} but tolerates a zero-action step. Used for events
- * whose outcome may not drive a provider call — e.g. a signal the kernel queues
- * or ignores returns no action. Returns `null` in that case.
- */
-export declare function kernelMaybeAction(runtime: KernelRuntimeHandle, pending: KernelObservation[], event: Record<string, unknown>): KernelRunnerAction | null;
-/** Internal ABI-v2 step primitive shared by SDK adapters and conformance tests. */
-export declare function kernelStep(runtime: KernelRuntimeHandle, event: Record<string, unknown>): KernelStepJson;
+export declare function kernelMessageToSdk(raw: Record<string, unknown>): Message;
+export declare function renderedContextToSdk(raw: Record<string, unknown>): RenderedContext;

package/dist/runtime/kernel-step.js

@@ -1,25 +1,20 @@
-import { createKernelOperationGenesis, createKernelTransaction, kernelRecordDigest, } from "./kernel-transaction-log.js";
-export const KERNEL_ABI_VERSION = 2;
-export function readKernelDiagnostics(runtime) {
-    return JSON.parse(runtime.diagnostics());
+const CANONICAL_CONTENT_PARTS_PREFIX = "[[deepstrike-content-parts:v1]]";
+export function encodeCanonicalContentParts(parts) {
+    return `${CANONICAL_CONTENT_PARTS_PREFIX}${Buffer.from(JSON.stringify(parts)).toString("base64url")}`;
 }
-export function snapshotKernelRuntime(runtime) {
-    return JSON.parse(runtime.snapshot());
-}
-export function restoreKernelRuntime(runtime, snapshot) {
-    runtime.restore(JSON.stringify(snapshot));
-    const operationId = snapshot.operation_id;
-    if (!operationId) {
-        kernelWireStates.delete(runtime);
-        return;
+function decodeCanonicalContentParts(content) {
+    if (!content.startsWith(CANONICAL_CONTENT_PARTS_PREFIX))
+        return undefined;
+    try {
+        const decoded = JSON.parse(Buffer.from(content.slice(CANONICAL_CONTENT_PARTS_PREFIX.length), "base64url").toString("utf8"));
+        return Array.isArray(decoded)
+            ? decoded.filter((part) => Boolean(part) && typeof part === "object")
+            : undefined;
+    }
+    catch {
+        return undefined;
     }
-    const nextEventSequence = snapshot.accepted_inputs.reduce((next, input) => {
-        const match = input.event_id.match(/-event-(\d+)$/);
-        return match ? Math.max(next, Number(match[1]) + 1) : next;
-    }, 1);
-    kernelWireStates.set(runtime, { operationId, nextEventSequence });
 }
-const kernelWireStates = new WeakMap();
 function tryParseJson(s) {
     try {
         return JSON.parse(s);
@@ -153,9 +148,6 @@ export function capabilityCommandUnmount(capabilityKind, id) {
         command: { action: "unmount", kind: capabilityKind, id },
     };
 }
-function parseStep(raw) {
-    return JSON.parse(raw);
-}
 /** Camel-case an `entropy_sample` kernel observation into the SDK's `EntropySample`. */
 export function entropySampleFromObservation(obs) {
     return {
@@ -169,31 +161,40 @@ export function entropySampleFromObservation(obs) {
         windowTurns: obs.window_turns ?? 0,
     };
 }
-function kernelMessageToSdk(raw) {
+export function kernelMessageToSdk(raw) {
     const content = raw.content;
+    const canonicalParts = typeof content === "string"
+        ? decodeCanonicalContentParts(content)
+        : undefined;
+    const structuredContent = canonicalParts ?? (Array.isArray(content) ? content : undefined);
     const message = {
         role: raw.role,
-        content: typeof content === "string"
-            ? content
-            : Array.isArray(content)
+        content: canonicalParts
+            ? canonicalParts
+                .filter(part => part.type === "text")
+                .map(part => String(part.text ?? ""))
+                .join("")
+            : typeof content === "string"
                 ? content
-                    .filter((part) => {
-                    return typeof part === "object" && part !== null && part.type === "text";
-                })
-                    .map(part => String(part.text ?? ""))
-                    .join("")
-                : "",
+                : Array.isArray(content)
+                    ? content
+                        .filter((part) => {
+                        return typeof part === "object" && part !== null && part.type === "text";
+                    })
+                        .map(part => String(part.text ?? ""))
+                        .join("")
+                    : "",
         toolCalls: (raw.tool_calls ?? []).map(tc => ({
-            id: String(tc.id ?? ""),
+            id: String(tc.call_id ?? tc.id ?? ""),
             name: String(tc.name ?? ""),
             arguments: JSON.stringify(tc.arguments ?? {}),
         })),
     };
-    if (typeof raw.token_count === "number") {
-        message.tokenCount = raw.token_count;
+    if (typeof (raw.tokens ?? raw.token_count) === "number") {
+        message.tokenCount = Number(raw.tokens ?? raw.token_count);
     }
-    if (Array.isArray(content)) {
-        message.contentParts = content
+    if (structuredContent) {
+        message.contentParts = structuredContent
             .filter((part) => typeof part === "object" && part !== null)
             .map(part => {
             if (part.type === "text") {
@@ -226,9 +227,17 @@ function kernelMessageToSdk(raw) {
             return { type: "text", text: "" };
         });
     }
+    else if (typeof raw.tool_call_id === "string") {
+        message.contentParts = [{
+                type: "tool_result",
+                callId: raw.tool_call_id,
+                output: message.content,
+                isError: false,
+            }];
+    }
     return message;
 }
-function renderedContextToSdk(raw) {
+export function renderedContextToSdk(raw) {
     const rawStateTurn = (raw.state_turn ?? raw.stateTurn);
     const frozenLen = (raw.frozen_prefix_len ?? raw.frozenPrefixLen);
     const ctx = {
@@ -243,282 +252,3 @@ function renderedContextToSdk(raw) {
         ctx.frozenPrefixLen = frozenLen;
     return ctx;
 }
-function mapKernelAction(raw) {
-    const effectId = String(raw.effect_id ?? "");
-    if (!effectId)
-        throw new Error(`kernel action ${String(raw.kind)} is missing effect_id`);
-    switch (raw.kind) {
-        case "call_provider":
-            return {
-                kind: "call_provider",
-                effectId,
-                context: renderedContextToSdk(raw.context ?? {}),
-                tools: (raw.tools ?? []).map(t => ({
-                    name: String(t.name ?? ""),
-                    description: String(t.description ?? ""),
-                    parameters: JSON.stringify(t.parameters ?? {}),
-                })),
-            };
-        case "execute_tool":
-            return {
-                kind: "execute_tool",
-                effectId,
-                calls: (raw.calls ?? []).map(c => ({
-                    id: String(c.id ?? ""),
-                    name: String(c.name ?? ""),
-                    arguments: JSON.stringify(c.arguments ?? {}),
-                })),
-            };
-        case "request_approval":
-            return {
-                kind: "request_approval",
-                effectId,
-                requests: (raw.requests ?? []).map(request => ({
-                    callId: String(request.call_id ?? ""),
-                    tool: String(request.tool ?? ""),
-                    arguments: JSON.stringify(request.arguments ?? {}),
-                    reason: String(request.reason ?? ""),
-                })),
-            };
-        case "spawn_workflow":
-            return {
-                kind: "spawn_workflow",
-                effectId,
-                nodes: raw.nodes ?? [],
-                ...(raw.budget && typeof raw.budget === "object"
-                    ? { budget: raw.budget }
-                    : {}),
-            };
-        case "preempt_sub_agents":
-            return {
-                kind: "preempt_sub_agents",
-                effectId,
-                agentIds: raw.agent_ids ?? [],
-                reason: String(raw.reason ?? ""),
-            };
-        case "persist_memory":
-            return {
-                kind: "persist_memory",
-                effectId,
-                memory: raw.memory ?? {},
-            };
-        case "query_memory":
-            return {
-                kind: "query_memory",
-                effectId,
-                query: raw.query ?? {},
-                requestedK: Number(raw.requested_k ?? 0),
-            };
-        case "spool_large_result":
-            return {
-                kind: "spool_large_result",
-                effectId,
-                callId: String(raw.call_id ?? ""),
-                tool: String(raw.tool ?? ""),
-                output: String(raw.output ?? ""),
-                originalSize: Number(raw.original_size ?? 0),
-                previewSize: Number(raw.preview_size ?? 0),
-            };
-        case "archive_page_out":
-            return {
-                kind: "archive_page_out",
-                effectId,
-                turn: Number(raw.turn ?? 0),
-                action: String(raw.action ?? "auto_compact"),
-                ...(typeof raw.summary === "string" ? { summary: raw.summary } : {}),
-                archived: (raw.archived ?? []).map(kernelMessageToSdk),
-                tier: String(raw.tier ?? "durable"),
-            };
-        case "evaluate_milestone":
-            return {
-                kind: "evaluate_milestone",
-                effectId,
-                phaseId: String(raw.phase_id ?? ""),
-                criteria: raw.criteria ?? [],
-                verifier: raw.verifier,
-                requiredEvidence: raw.required_evidence ?? [],
-            };
-        case "done": {
-            const result = raw.result ?? {};
-            const pace = result.pace_decision;
-            return {
-                kind: "done",
-                effectId,
-                result: {
-                    termination: String(result.termination ?? "error"),
-                    turnsUsed: Number(result.turns_used ?? 0),
-                    totalTokensUsed: Number(result.total_tokens_used ?? 0),
-                    // ③ loop-agent: the kernel-adjudicated after-round decision (absent on non-loop runs).
-                    ...(pace
-                        ? {
-                            paceDecision: {
-                                action: (pace.action ?? "stop"),
-                                delayMs: pace.delay_ms,
-                                reason: pace.reason ?? "",
-                                coercedFrom: pace.coerced_from,
-                            },
-                        }
-                        : {}),
-                },
-            };
-        }
-        default:
-            throw new Error(`unknown KernelAction kind: ${String(raw.kind)}`);
-    }
-}
-function stepInput(runtime, event) {
-    let state = kernelWireStates.get(runtime);
-    if (!state) {
-        // Globally unique, never a process-local counter: durable session logs key the kernel
-        // genesis/transaction chains by (sessionId, operationId) and outlive this process, so a
-        // counter that restarts at 1 collides with yesterday's chain on the same session (genesis
-        // digest conflict, or step_seq successor violation when the policy digest happens to match).
-        state = {
-            operationId: `node-operation-${crypto.randomUUID()}`,
-            nextEventSequence: 1,
-        };
-        kernelWireStates.set(runtime, state);
-    }
-    const correlatedEvent = event.kind === "cancel_operation"
-        ? { ...event, operation_id: state.operationId }
-        : event;
-    return JSON.stringify({
-        version: KERNEL_ABI_VERSION,
-        operation_id: state.operationId,
-        event_id: `${state.operationId}-event-${state.nextEventSequence++}`,
-        observed_at_ms: Date.now(),
-        event: correlatedEvent,
-    });
-}
-const durableKernelStates = new WeakMap();
-/**
- * Execute one production transition behind the durable action-publish gate. Genesis is persisted
- * before prepare; a newly prepared transaction is CAS-appended before commit; only the committed
- * step is returned to callers, so actions and observations cannot escape early.
- */
-export async function durableKernelStep(runtime, sessionLog, sessionId, event) {
-    const inputJson = stepInput(runtime, event);
-    const input = JSON.parse(inputJson);
-    const operationId = String(input.operation_id ?? "");
-    if (!operationId)
-        throw new Error("kernel input is missing operation_id");
-    let durableState = durableKernelStates.get(runtime);
-    if (!durableState) {
-        const snapshot = snapshotKernelRuntime(runtime);
-        const genesis = await createKernelOperationGenesis({
-            abi_version: KERNEL_ABI_VERSION,
-            operation_id: operationId,
-            initial_scheduler_policy: snapshot.initial_policy,
-            resolved_runtime_defaults: {
-                snapshot_version: snapshot.snapshot_version,
-                snapshot_input_limit: snapshot.snapshot_input_limit,
-                max_input_bytes: snapshot.max_input_bytes,
-                snapshot_journal_bytes_limit: snapshot.snapshot_journal_bytes_limit,
-            },
-            default_policy_version: 1,
-        });
-        const receipt = await sessionLog.appendKernelGenesis(sessionId, genesis);
-        durableState = {
-            sessionId,
-            operationId,
-            genesisDigest: receipt.genesis_digest,
-        };
-        durableKernelStates.set(runtime, durableState);
-    }
-    else if (durableState.sessionId !== sessionId || durableState.operationId !== operationId) {
-        throw new Error("kernel runtime cannot change its durable session or operation identity");
-    }
-    const prepared = JSON.parse(runtime.prepareStep(inputJson));
-    if (prepared.status !== "prepared")
-        return prepared.step;
-    const token = prepared.prepare_token;
-    if (!token)
-        throw new Error("prepared kernel transition is missing its commit token");
-    let committed = false;
-    try {
-        const head = await sessionLog.kernelTransactionHead(sessionId, operationId);
-        if (!head)
-            throw new Error("durable kernel genesis is missing before transaction append");
-        const transaction = await createKernelTransaction({
-            operation_id: operationId,
-            step_seq: prepared.step.step_seq,
-            base_generation: prepared.base_generation,
-            input: prepared.input,
-            step: prepared.step,
-            previous_transaction_digest: head,
-        });
-        await sessionLog.compareAndAppendKernelTransaction(sessionId, head, transaction);
-        const committedStep = parseStep(runtime.commitPrepared(token));
-        committed = true;
-        if (kernelRecordDigest(committedStep) !== transaction.step_digest) {
-            throw new Error("committed kernel step does not match the durable prepared step");
-        }
-        return committedStep;
-    }
-    catch (transitionError) {
-        if (!committed) {
-            try {
-                runtime.abortPrepared(token);
-            }
-            catch (abortError) {
-                throw new AggregateError([transitionError, abortError], "durable transition failed and the prepared kernel state could not be aborted");
-            }
-        }
-        throw transitionError;
-    }
-}
-export async function durableKernelApply(runtime, sessionLog, sessionId, pending, event) {
-    const step = await durableKernelStep(runtime, sessionLog, sessionId, event);
-    const fault = step.faults?.[0];
-    if (fault)
-        throw new Error(`${fault.code ?? "kernel_fault"}: ${fault.message ?? "kernel transition failed"}`);
-    pending.push(...step.observations);
-    return step.observations;
-}
-export async function durableKernelMaybeAction(runtime, sessionLog, sessionId, pending, event) {
-    const step = await durableKernelStep(runtime, sessionLog, sessionId, event);
-    const fault = step.faults?.[0];
-    if (fault)
-        throw new Error(`${fault.code ?? "kernel_fault"}: ${fault.message ?? "kernel transition failed"}`);
-    pending.push(...step.observations);
-    const raw = step.actions[0];
-    return raw ? mapKernelAction(raw) : null;
-}
-export async function durableKernelAction(runtime, sessionLog, sessionId, pending, event) {
-    const action = await durableKernelMaybeAction(runtime, sessionLog, sessionId, pending, event);
-    if (!action)
-        throw new Error("kernel transition must return one action");
-    return action;
-}
-export function kernelApply(runtime, pending, event) {
-    const step = kernelStep(runtime, event);
-    const fault = step.faults?.[0];
-    if (fault)
-        throw new Error(`${fault.code ?? "kernel_fault"}: ${fault.message ?? "kernel transition failed"}`);
-    pending.push(...step.observations);
-    return step.observations;
-}
-export function kernelAction(runtime, pending, event) {
-    const action = kernelMaybeAction(runtime, pending, event);
-    if (!action)
-        throw new Error("kernel transition must return one action");
-    return action;
-}
-/**
- * Like {@link kernelAction} but tolerates a zero-action step. Used for events
- * whose outcome may not drive a provider call — e.g. a signal the kernel queues
- * or ignores returns no action. Returns `null` in that case.
- */
-export function kernelMaybeAction(runtime, pending, event) {
-    const step = kernelStep(runtime, event);
-    const fault = step.faults?.[0];
-    if (fault)
-        throw new Error(`${fault.code ?? "kernel_fault"}: ${fault.message ?? "kernel transition failed"}`);
-    pending.push(...step.observations);
-    const raw = step.actions[0];
-    return raw ? mapKernelAction(raw) : null;
-}
-/** Internal ABI-v2 step primitive shared by SDK adapters and conformance tests. */
-export function kernelStep(runtime, event) {
-    return parseStep(runtime.step(stepInput(runtime, event)));
-}

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

@@ -9,7 +9,8 @@ export interface OsSnapshot {
     processByAgent: Array<{
         turn: number;
         agent_id: string;
-        parent_session_id: string;
+        parent_task_id?: string;
+        parent_session_id?: string;
         state: string;
     }>;
     budgetExceeded: Array<{
@@ -43,7 +44,6 @@ export interface OsSnapshot {
     }>;
     pageOutCount: number;
     pageInCount: number;
-    spoolCount: number;
     toolGatedCount: number;
     memoryWrittenCount: number;
     memoryQueriedCount: number;