@deepstrike/wasm 0.2.49 → 0.2.51

package/README.md

@@ -85,7 +85,8 @@ src/
 ```
 
 The kernel (`@deepstrike/wasm-kernel`, Rust/wasm-bindgen) owns:
-- `KernelRuntime.step()` — drives `call_provider → execute_tool → evaluate_milestone → done`
+- the Canonical Kernel ABI durable `prepare → append → commit` transition contract
+- typed effects, a single effect-resolution input, observations, and terminal disposition
 - `ContextEngine` — 4-slot context with tiered history compression
 - `Governance` — tool veto authority
 - `SignalRouter` — external interrupt queue

package/dist/index.d.ts

@@ -1,13 +1,14 @@
 export { RuntimeRunner, collectText, runAgent, runFanout, InMemorySessionLog, LocalExecutionPlane, DEFAULT_NATIVE_SIGNAL_POLICY, DEFAULT_NATIVE_GOVERNANCE_POLICY, DEFAULT_SANDBOX_POLICY, assertNativeProfile, osProfile, validateDeclarativePolicy, ReplayProvider, extractRecordedMessages, judge, buildEvalMessages, parseVerdict, verdictOutputSchema, } from "./runtime/index.js";
-export * from "./runtime/kernel-transaction-log.js";
+export { DriverKernelJournal, InMemoryJournalDriver, InMemoryKernelJournal, JournalCasConflictError, JournalIntegrityError, JournalIoError, } from "./runtime/kernel-journal.js";
+export type { CheckpointCandidate, InstalledCheckpoint, JournalAppendReceipt, JournalEntry, JournalHead, JournalPruneReceipt, JournalRecordInput, JournalStorageDriver, KernelJournal, } from "./runtime/kernel-journal.js";
 export type { ReplayProviderOpts, Criterion, Verdict, VerdictDetail, JudgeArgs, } from "./runtime/index.js";
-export type { NativeOsProfile, OsProfileId, MemoryPolicy, MemoryWriteRateLimit, ResourceQuota, RuntimeOptions, PromptBudget, SchedulerPolicy, SignalPolicy, SessionEvent, SessionLog, KernelTransactionEntry, RunContext, ExecutionPlane, KernelEventCategory, KernelPrimitive, } from "./runtime/index.js";
+export type { NativeOsProfile, OsProfileId, MemoryPolicy, MemoryWriteRateLimit, ResourceQuota, RuntimeOptions, PromptBudget, SchedulerPolicy, SignalPolicy, SessionEvent, SessionLog, RunContext, ExecutionPlane, KernelEventCategory, KernelPrimitive, } from "./runtime/index.js";
 export { primitiveForCategory, primitiveForKind } from "./runtime/index.js";
 export { FilteredExecutionPlane } from "./runtime/filtered-plane.js";
 export { SubAgentOrchestrator, defaultSubAgentOrchestrator, spawnStandalone } from "./runtime/sub-agent-orchestrator.js";
 export type { SubAgentRunContext } from "./runtime/sub-agent-orchestrator.js";
 export type { AgentCapabilityFilter, AgentIdentity, AgentIsolation, AgentRunSpec, AgentProcessChangedObservation, ContextInheritance, KernelAgentRole, LoopResult, MilestoneCheckResult, MilestoneContract, MilestonePhase, MilestonePolicy, SubAgentResult, TerminationReason, WorkflowSpec, WorkflowNodeSpec, WorkflowDependencyPolicy, WorkflowNodeStatus, WorkflowNodeOutcome, WorkflowOutcome, WorkflowTaskSpec, WorkflowSpawnInfo, } from "./runtime/types/agent.js";
-export { workflowSpecToKernel, workflowNodeSpecToKernel, submitWorkflowNodesToKernel, submitWorkflowToKernel, submitWorkflowNodesTool, startWorkflowTool, fanoutSynthesize, generateAndFilter, genEval, verifyRules } from "./runtime/types/agent.js";
+export { workflowSpecToKernel, workflowNodeSpecToKernel, submitWorkflowNodesTool, startWorkflowTool, fanoutSynthesize, generateAndFilter, genEval, verifyRules } from "./runtime/types/agent.js";
 export { loopInstruction, classifyInstruction, judgeGoal, extractLoopContinue, extractClassifyBranch, extractJudgeWinner, } from "./runtime/workflow-control-flow.js";
 export { Governance } from "./governance.js";
 export type { GovernanceVerdict } from "./governance.js";

package/dist/index.js

@@ -1,9 +1,10 @@
 export { RuntimeRunner, collectText, runAgent, runFanout, InMemorySessionLog, LocalExecutionPlane, DEFAULT_NATIVE_SIGNAL_POLICY, DEFAULT_NATIVE_GOVERNANCE_POLICY, DEFAULT_SANDBOX_POLICY, assertNativeProfile, osProfile, validateDeclarativePolicy, ReplayProvider, extractRecordedMessages, judge, buildEvalMessages, parseVerdict, verdictOutputSchema, } from "./runtime/index.js";
-export * from "./runtime/kernel-transaction-log.js";
+// ── Durable transaction capability (Canonical Kernel ABI §9.1) ──────────────
+export { DriverKernelJournal, InMemoryJournalDriver, InMemoryKernelJournal, JournalCasConflictError, JournalIntegrityError, JournalIoError, } from "./runtime/kernel-journal.js";
 export { primitiveForCategory, primitiveForKind } from "./runtime/index.js";
 export { FilteredExecutionPlane } from "./runtime/filtered-plane.js";
 export { SubAgentOrchestrator, defaultSubAgentOrchestrator, spawnStandalone } from "./runtime/sub-agent-orchestrator.js";
-export { workflowSpecToKernel, workflowNodeSpecToKernel, submitWorkflowNodesToKernel, submitWorkflowToKernel, submitWorkflowNodesTool, startWorkflowTool, fanoutSynthesize, generateAndFilter, genEval, verifyRules } from "./runtime/types/agent.js";
+export { workflowSpecToKernel, workflowNodeSpecToKernel, submitWorkflowNodesTool, startWorkflowTool, fanoutSynthesize, generateAndFilter, genEval, verifyRules } from "./runtime/types/agent.js";
 export { loopInstruction, classifyInstruction, judgeGoal, extractLoopContinue, extractClassifyBranch, extractJudgeWinner, } from "./runtime/workflow-control-flow.js";
 export { Governance } from "./governance.js";
 export { AnthropicProvider } from "./providers/anthropic.js";

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

@@ -0,0 +1,146 @@
+import type { CanonicalKernel as CanonicalKernelInstance, CanonicalRestoreCost } from "@deepstrike/wasm-kernel";
+import type { Message } from "../types.js";
+import { type InstalledCheckpoint, type KernelJournal } from "./kernel-journal.js";
+import { type KernelObservation, type KernelRunnerAction } from "./kernel-step.js";
+export declare const MAX_CHAIN_POSITION = 1000000000000;
+export type CanonicalKernelInput = Record<string, unknown> & {
+    kind: string;
+};
+export interface CanonicalPlannedStep {
+    root_kind?: "agent" | "workflow";
+    focus?: Record<string, unknown>;
+    observations?: Array<Record<string, unknown>>;
+    disposition: {
+        kind: "effects";
+        effects?: Array<Record<string, unknown>>;
+    } | {
+        kind: "terminal";
+        terminal: Record<string, unknown>;
+    };
+}
+export interface CanonicalTransitionOptions {
+    /** Caller-stable idempotency key. Generated once when omitted. */
+    inputId?: string;
+    /** Decimal-u64 host observation. Captured once when omitted and preserved across every retry. */
+    observedAtMs?: string;
+}
+export interface CanonicalTransition {
+    inputJson: string;
+    stepSeq: number;
+    recordDigest: string;
+    plannedStep: CanonicalPlannedStep;
+    checkpointAdvice?: Record<string, unknown>;
+    replayed: boolean;
+}
+export declare function canonicalUnsupportedEffectResolution(effectId: string, effectKind: string): CanonicalKernelInput;
+/** The only ABI-v3 planned-step → Node host-action projection. */
+export declare function canonicalActionFromPlannedStep(plannedStep: CanonicalPlannedStep): KernelRunnerAction | null;
+export declare class CanonicalKernelRejectedError extends Error {
+    readonly fault: Record<string, unknown>;
+    constructor(faultJson: string);
+}
+/**
+ * A record is already authoritative once the journal append returns. A later native commit failure
+ * is therefore a rebuild boundary, never an abort boundary.
+ */
+export declare class CanonicalKernelRebuildRequiredError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * WASM's canonical durable staged-transition host.
+ *
+ * It owns no scheduler truth. Core prepares opaque record bytes; `KernelJournal` makes those bytes
+ * authoritative; only then may core commit and expose the planned effects/terminal to the runner.
+ */
+export declare class CanonicalKernelHost {
+    readonly kernel: CanonicalKernelInstance;
+    readonly journal: KernelJournal;
+    readonly operationId: string;
+    constructor(kernel: CanonicalKernelInstance, journal: KernelJournal, operationId: string);
+    transition(input: CanonicalKernelInput, options?: CanonicalTransitionOptions): Promise<CanonicalTransition>;
+    /** Restore the latest installed checkpoint and its authoritative record tail in place. */
+    restore(): Promise<CanonicalRestoreCost>;
+    /**
+     * Replay a crash-window outbound envelope with identical bytes (adjudication 5e.3).
+     * No-op when nothing is staged. Clears the stage after commit/replay/reject.
+     */
+    drainOutboundEnvelope(): Promise<CanonicalTransition | undefined>;
+    /** Execute the full §12.3 install/ack/reclaim boundary. */
+    checkpoint(): Promise<InstalledCheckpoint>;
+    private transitionEnvelope;
+}
+export interface CanonicalRunnerRuntimeOptions {
+    maxContextTokens: number;
+    maxTurns?: number;
+    maxTotalTokens?: number;
+    maxWallMs?: number;
+    memoryBindingId?: string;
+    persistPayload?: (callId: string, content: string, previewBytes: number) => Promise<{
+        payloadRef: string;
+        digest: string;
+        originalSize: string;
+        preview: string;
+    }>;
+}
+export declare function sha256(value: string): string;
+/** Small synchronous SHA-256 for Worker/browser hosts (no node:crypto). */
+declare function syncSha256(value: string): string;
+export { syncSha256 as sha256Hex };
+/**
+ * Canonical operation runtime used by the WASM host.
+ * Every durable transition below is one of the canonical ABI's five input classes; no legacy
+ * envelope or synthesized host transaction reaches core or storage.
+ */
+export declare class CanonicalRunnerRuntime {
+    private readonly options;
+    private readonly host;
+    private readonly config;
+    private readonly initialContext;
+    private configured;
+    private started;
+    private turns;
+    private lastAction;
+    private readonly newMessages;
+    private readonly hostObservations;
+    private spawnedTasks;
+    private readonly memoryBindingId;
+    private payloadInlineThreshold;
+    private payloadPreviewBytes;
+    constructor(kernel: CanonicalKernelInstance, journal: KernelJournal, operationId: string, options: CanonicalRunnerRuntimeOptions);
+    get operationId(): string;
+    get journal(): KernelJournal;
+    turn(): number;
+    isTerminal(): boolean;
+    recoveryContentBytes(): number;
+    preservedRefs(): string[];
+    drainNewMessages(): Message[];
+    drainHostObservations(): KernelObservationLike[];
+    terminal(): Record<string, unknown> | undefined;
+    localSubagentsSpawned(): number;
+    restore(): Promise<void>;
+    resumeAction(): KernelRunnerAction | null;
+    startAgent(taskValue: Record<string, unknown>, runSpecValue?: Record<string, unknown>): Promise<KernelRunnerAction | null>;
+    startWorkflow(specValue: Record<string, unknown>): Promise<KernelRunnerAction | null>;
+    applyHostEvent(event: Record<string, unknown>): Promise<KernelRunnerAction | null>;
+    private ensureConfigured;
+    private commit;
+    private currentAction;
+    private pendingEffects;
+    private succeededEffect;
+    private failedEffect;
+    private pageOutResolution;
+    private canonicalSignal;
+    private canonicalCapabilityCommand;
+    private applyBootstrapEvent;
+    private featurePolicy;
+    private executionPolicy;
+    private mergeHostConfig;
+}
+export declare function canonicalKernelApply(runtime: CanonicalRunnerRuntime, pending: KernelObservationLike[], event: Record<string, unknown>): Promise<KernelObservationLike[]>;
+export declare function canonicalKernelMaybeAction(runtime: CanonicalRunnerRuntime, pending: KernelObservationLike[], event: Record<string, unknown>): Promise<KernelRunnerAction | null>;
+export declare function canonicalKernelAction(runtime: CanonicalRunnerRuntime, pending: KernelObservationLike[], event: Record<string, unknown>): Promise<KernelRunnerAction>;
+export declare function canonicalStartAgent(runtime: CanonicalRunnerRuntime, pending: KernelObservationLike[], task: Record<string, unknown>, runSpec?: Record<string, unknown>): Promise<KernelRunnerAction>;
+export declare function canonicalStartWorkflow(runtime: CanonicalRunnerRuntime, pending: KernelObservationLike[], spec: Record<string, unknown>): Promise<KernelRunnerAction | null>;
+type KernelObservationLike = KernelObservation;