@deepstrike/wasm 0.2.36 → 0.2.38

package/dist/index.d.ts

@@ -5,7 +5,7 @@ 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, WorkflowTaskSpec, WorkflowSpawnInfo, } from "./runtime/types/agent.js";
-export { workflowSpecToKernel, workflowNodeSpecToKernel, submitWorkflowNodesToKernel, submitWorkflowToKernel, submitWorkflowNodesTool, startWorkflowTool, fanoutSynthesize, generateAndFilter, verifyRules } from "./runtime/types/agent.js";
+export { workflowSpecToKernel, workflowNodeSpecToKernel, submitWorkflowNodesToKernel, submitWorkflowToKernel, 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";
@@ -25,4 +25,4 @@ export { ScheduledPrompt } from "./signals/index.js";
 export type { RuntimeSignal, SignalSource } from "./signals/index.js";
 export { PermissionManager, PermissionMode } from "./safety/index.js";
 export type { PermissionDecision } from "./safety/index.js";
-export type { Message, ToolCall, ToolResult, ToolSchema, RenderedContext, ProviderRunState, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolResultEvent, ToolAuditFailedEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, PermissionResolvedEvent, PermissionResponse, LLMProvider, CacheBreakpointStrategy, } from "./types.js";
+export type { Message, ToolCall, ToolResult, ToolSchema, RenderedContext, ProviderRunState, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolResultEvent, ToolAuditFailedEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, PermissionResolvedEvent, PermissionResponse, EntropySample, EntropySampleEvent, EntropyAlertEvent, EntropyWatchOptions, LLMProvider, CacheBreakpointStrategy, } from "./types.js";

package/dist/index.js

@@ -1,7 +1,7 @@
 export { RuntimeRunner, collectText, runAgent, runFanout, InMemorySessionLog, LocalExecutionPlane, DEFAULT_NATIVE_ATTENTION_POLICY, DEFAULT_NATIVE_GOVERNANCE_POLICY, DEFAULT_SANDBOX_POLICY, assertNativeProfile, osProfile, validateDeclarativePolicy, ReplayProvider, extractRecordedMessages, judge, buildEvalMessages, parseVerdict, verdictOutputSchema, } 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, verifyRules } from "./runtime/types/agent.js";
+export { workflowSpecToKernel, workflowNodeSpecToKernel, submitWorkflowNodesToKernel, submitWorkflowToKernel, 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/facade.js

@@ -3,6 +3,7 @@
 import { RuntimeRunner, collectText } from "./runner.js";
 import { LocalExecutionPlane } from "./execution-plane.js";
 import { InMemorySessionLog } from "./session-log.js";
+import { fanoutSynthesize } from "./types/agent.js";
 /** Run a single agent to completion and return its final text. */
 export async function runAgent(opts) {
     const plane = opts.executionPlane ??
@@ -26,13 +27,16 @@ export async function runFanout(opts) {
         maxTokens: opts.maxTokens ?? 32_000,
         ...(opts.maxTurns !== undefined ? { maxTurns: opts.maxTurns } : {}),
     });
-    const workerRole = opts.workerRole ?? "explore";
-    const spec = {
-        nodes: [
-            ...opts.tasks.map(task => ({ task, role: workerRole })),
-            { task: opts.synthesize, role: opts.synthesisRole ?? "plan", dependsOn: opts.tasks.map((_, i) => i) },
-        ],
-    };
+    // W-N8: build the spec via the ONE fanout template (it pins the pattern's isolation /
+    // context-inheritance choices — read-only system-only workers, full-context synthesizer — which
+    // this facade used to silently drop), then apply the caller's role overrides on top.
+    const spec = fanoutSynthesize(opts.tasks, opts.synthesize);
+    if (opts.workerRole) {
+        for (const node of spec.nodes.slice(0, opts.tasks.length))
+            node.role = opts.workerRole;
+    }
+    if (opts.synthesisRole)
+        spec.nodes[spec.nodes.length - 1].role = opts.synthesisRole;
     const outcome = await runner.runWorkflow(spec, opts.sessionId ? { sessionId: opts.sessionId } : undefined);
     const synthesisId = `wf-node${opts.tasks.length}`;
     const lastCompleted = outcome.completed[outcome.completed.length - 1];

package/dist/runtime/kernel-event-log.d.ts

@@ -3,12 +3,6 @@ import type { SessionEvent } from "./session-log.js";
 /** Agent OS kernel event category (Phase 5). */
 export type KernelEventCategory = "syscall" | "sched" | "mm" | "proc" | "ipc";
 export declare function categoryForKind(kind: string): KernelEventCategory;
-export declare function withCategory<T extends {
-    kind: string;
-}>(event: T): T & {
-    category: KernelEventCategory;
-    primitive: KernelPrimitive;
-};
 type CompressionAction = Extract<SessionEvent, {
     kind: "compressed";
 }>["action"];

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

@@ -22,33 +22,16 @@ export function categoryForKind(kind) {
             return "sched";
     }
 }
-export function withCategory(event) {
-    const category = categoryForKind(event.kind);
-    return {
-        ...event,
-        category,
-        primitive: primitiveForCategory(category),
-    };
-}
 export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
     const t = obs.turn ?? turn;
     const compressionAction = opts.compressionAction ?? (() => undefined);
     switch (obs.kind) {
-        case "page_out":
-            return withCategory({
-                kind: "page_out",
-                turn: t,
-                action: compressionAction(obs.action),
-                summary: obs.summary,
-                tier_hint: obs.tier_hint ?? "durable",
-                message_count: Array.isArray(obs.archived) ? obs.archived.length : 0,
-            });
         case "compressed": {
             const latest = opts.latestSeq ?? -1;
             const start = opts.nextArchiveStart ?? 0;
             if (latest < start)
                 return null;
-            return withCategory({
+            return {
                 kind: "compressed",
                 turn: t,
                 archived_seq_range: [start, latest],
@@ -57,24 +40,24 @@ export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
                 summary_tokens: obs.summary ? Math.max(1, Math.ceil(obs.summary.length / 4)) : undefined,
                 archive_ref: opts.archiveRef,
                 preserved_refs: opts.preservedRefs ?? [],
-            });
+            };
         }
         case "renewed":
-            return withCategory({
+            return {
                 kind: "context_renewed",
                 turn: t,
                 sprint: obs.sprint ?? 0,
                 handoff_ref: "",
-            });
+            };
         case "rollbacked":
-            return withCategory({
+            return {
                 kind: "rollbacked",
                 turn: t,
                 checkpoint_history_len: obs.checkpoint_history_len ?? 0,
                 reason: obs.reason,
-            });
+            };
         case "capability_changed":
-            return withCategory({
+            return {
                 kind: "capability_changed",
                 turn: t,
                 added: obs.added ?? [],
@@ -84,36 +67,48 @@ export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
                 ...(obs.version != null && { version: obs.version }),
                 ...(obs.mounted_by != null && { mounted_by: obs.mounted_by }),
                 ...(obs.mount_reason != null && { mount_reason: obs.mount_reason }),
-            });
+            };
         case "milestone_advanced":
-            return withCategory({
+            return {
                 kind: "milestone_advanced",
                 turn: t,
                 phase_id: obs.phase_id ?? "",
                 capabilities_unlocked: obs.capabilities_unlocked ?? [],
-            });
+            };
         case "milestone_blocked":
-            return withCategory({
+            return {
                 kind: "milestone_blocked",
                 turn: t,
                 phase_id: obs.phase_id ?? "",
                 reason: typeof obs.reason === "string" ? obs.reason : "",
-            });
-        case "milestone_evidence":
-            return withCategory({
-                kind: "milestone_evidence",
-                turn: t,
-                phase_id: obs.phase_id ?? "",
-                evidence: obs.evidence ?? [],
-            });
+            };
         case "checkpoint_taken":
-            return withCategory({
+            return {
                 kind: "checkpoint_taken",
                 turn: t,
                 history_len: obs.history_len ?? 0,
-            });
+            };
+        case "entropy_sample":
+            return {
+                kind: "entropy_sample",
+                turn: t,
+                score: obs.score ?? 0,
+                score_version: obs.score_version ?? 0,
+                rho: obs.rho ?? 0,
+                repeat_pressure: obs.repeat_pressure ?? 0,
+                failure_rate: obs.failure_rate ?? 0,
+                rollbacks_in_window: obs.rollbacks_in_window ?? 0,
+                window_turns: obs.window_turns ?? 0,
+            };
+        case "entropy_alert":
+            return {
+                kind: "entropy_alert",
+                turn: t,
+                score: obs.score ?? 0,
+                threshold: obs.threshold ?? 0,
+            };
         case "agent_process_changed":
-            return withCategory({
+            return {
                 kind: "agent_process_changed",
                 turn: t,
                 agent_id: obs.agent_id ?? "",
@@ -126,47 +121,47 @@ export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
                 ...(obs.result_termination
                     ? { result_termination: obs.result_termination }
                     : {}),
-            });
+            };
         case "tool_gated":
-            return withCategory({
+            return {
                 kind: "tool_gated",
                 turn: t,
                 call_id: obs.call_id ?? "",
                 tool: obs.tool ?? "",
                 reason: typeof obs.reason === "string" ? obs.reason : "",
-            });
+            };
         case "signal_disposed":
-            return withCategory({
+            return {
                 kind: "signal_disposed",
                 turn: t,
                 signal_id: obs.signal_id ?? "",
                 disposition: obs.disposition ?? "",
                 queue_depth: obs.queue_depth ?? 0,
-            });
+            };
         case "budget_exceeded":
-            return withCategory({
+            return {
                 kind: "budget_exceeded",
                 turn: t,
                 budget: obs.budget ?? "",
-            });
+            };
         case "suspended":
-            return withCategory({
+            return {
                 kind: "suspended",
                 turn: t,
                 reason: typeof obs.reason === "string" ? obs.reason : "",
                 pending_calls: obs.pending_calls ?? [],
-            });
+            };
         case "resumed":
-            return withCategory({
+            return {
                 kind: "resumed",
                 turn: t,
                 approved: obs.approved ?? [],
                 denied: obs.denied ?? [],
-            });
+            };
         case "page_in_requested":
             return null;
         case "large_result_spooled":
-            return withCategory({
+            return {
                 kind: "large_result_spooled",
                 turn: t,
                 call_id: obs.call_id ?? "",
@@ -174,49 +169,49 @@ export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
                 original_size: obs.original_size ?? 0,
                 preview_size: obs.preview_size ?? 0,
                 spool_ref: opts.spoolRef,
-            });
+            };
         case "memory_written":
-            return withCategory({
+            return {
                 kind: "memory_written",
                 turn: t,
                 memory_id: obs.memory_id ?? "",
                 memory_kind: obs.memory_kind ?? "",
                 size_bytes: obs.size_bytes ?? 0,
-            });
+            };
         case "memory_queried":
-            return withCategory({
+            return {
                 kind: "memory_queried",
                 turn: t,
                 query_context: obs.query_context ?? "",
                 requested_k: obs.requested_k ?? 0,
                 requires_async_response: obs.requires_async_response ?? false,
-            });
+            };
         case "memory_validation_failed":
-            return withCategory({
+            return {
                 kind: "memory_validation_failed",
                 turn: t,
                 memory_id: obs.memory_id ?? "",
                 error: obs.error ?? "",
-            });
+            };
         case "workflow_batch_spawned": {
             const nodes = obs.nodes ?? [];
-            return withCategory({
+            return {
                 kind: "workflow_batch_spawned",
                 turn: t,
                 node_count: nodes.length,
                 node_ids: nodes.map((n) => n.agent_id ?? ""),
-            });
+            };
         }
         case "workflow_completed": {
             const completed = obs.completed ?? [];
             const failed = obs.failed ?? [];
-            return withCategory({
+            return {
                 kind: "workflow_completed",
                 turn: t,
                 completed,
                 failed,
                 total_nodes: completed.length + failed.length,
-            });
+            };
         }
         default:
             return null;

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

@@ -28,10 +28,19 @@ export interface KernelRuntimeHandle {
     drainNewMessages(): Message[];
     preservedRefs(): string[];
 }
+export interface PaceDecision {
+    action: "continue" | "sleep" | "stop";
+    delayMs?: number;
+    reason: string;
+    /** Set when the kernel trap coerced the model's proposal (clamped delay / forced stop). */
+    coercedFrom?: string;
+}
 export interface KernelLoopResult {
     termination: string;
     turnsUsed: number;
     totalTokensUsed: number;
+    /** ③ loop-agent: the kernel-adjudicated after-round decision (absent on non-loop runs). */
+    paceDecision?: PaceDecision;
 }
 export type KernelRunnerAction = {
     kind: "call_provider";
@@ -106,6 +115,14 @@ export interface KernelObservation {
     }>;
     completed?: string[];
     failed?: string[];
+    score?: number;
+    score_version?: number;
+    rho?: number;
+    repeat_pressure?: number;
+    failure_rate?: number;
+    rollbacks_in_window?: number;
+    window_turns?: number;
+    threshold?: number;
 }
 export declare function toolSchemaToKernel(schema: ToolSchema): Record<string, unknown>;
 export declare function skillMetadataToKernel(skill: SkillMetadata): Record<string, unknown>;

package/dist/runtime/kernel-step.js

@@ -159,12 +159,24 @@ function mapKernelAction(raw) {
             };
         case "done": {
             const result = raw.result ?? {};
+            const pace = result.pace_decision;
             return {
                 kind: "done",
                 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,
+                            },
+                        }
+                        : {}),
                 },
             };
         }

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

@@ -28,4 +28,3 @@ export interface OsSnapshot {
     toolGatedCount: number;
 }
 export declare function rebuildOsSnapshotFromSessionEvents(events: SessionEvent[]): OsSnapshot;
-export declare function sessionLogHasRequiredCategories(events: SessionEvent[]): boolean;

package/dist/runtime/os-snapshot.js

@@ -1,4 +1,3 @@
-import { categoryForKind, primitiveForKind } from "./kernel-event-log.js";
 const KERNEL_KINDS = new Set([
     "compressed",
     "page_out",
@@ -16,7 +15,6 @@ const KERNEL_KINDS = new Set([
     "agent_process_changed",
     "milestone_advanced",
     "milestone_blocked",
-    "milestone_evidence",
 ]);
 export function rebuildOsSnapshotFromSessionEvents(events) {
     const snap = {
@@ -89,20 +87,3 @@ export function rebuildOsSnapshotFromSessionEvents(events) {
     }
     return snap;
 }
-export function sessionLogHasRequiredCategories(events) {
-    for (const event of events) {
-        if (!KERNEL_KINDS.has(event.kind))
-            continue;
-        const cat = event.category;
-        if (!cat)
-            return false;
-        if (cat !== categoryForKind(event.kind))
-            return false;
-        const prim = event.primitive;
-        if (prim !== undefined) {
-            if (prim !== primitiveForKind(event.kind))
-                return false;
-        }
-    }
-    return true;
-}

package/dist/runtime/runner.d.ts

@@ -1,4 +1,4 @@
-import type { LLMProvider, Message, StreamEvent, PermissionRequestEvent, PermissionResponse, DreamSummarizer } from "../types.js";
+import type { LLMProvider, Message, StreamEvent, PermissionRequestEvent, PermissionResponse, EntropySample, EntropyWatchOptions, DreamSummarizer } from "../types.js";
 import type { ToolSuspendEvent } from "./execution-plane.js";
 import type { DreamStore, DreamResult } from "../memory/index.js";
 import type { KnowledgeSource } from "../knowledge/index.js";
@@ -6,6 +6,7 @@ import type { SignalSource, RuntimeSignal } from "../signals/index.js";
 import type { SessionLog, SessionEvent } from "./session-log.js";
 import type { ExecutionPlane } from "./execution-plane.js";
 import { type GovernancePolicy } from "../governance.js";
+import { type RecoveredNodeCompletion } from "./session-repair.js";
 import type { AgentRunSpec, SubAgentResult, MilestonePolicy, MilestoneContract, MilestoneCheckResult, WorkflowSpec } from "./types/agent.js";
 import { type SubAgentOrchestrator } from "./sub-agent-orchestrator.js";
 import { type ReducerRegistry } from "./reducers.js";
@@ -121,6 +122,10 @@ export interface RuntimeOptions {
      *  warn-once observation + oldest unpinned non-skill entries evicted at the next boundary.
      *  Pinned/skill entries are exempt. `0` disables. Default: kernel's 0.25. */
     knowledgeBudgetRatio?: number;
+    /** Opt-in kernel entropy watch: threshold alerting over the per-turn session-entropy score
+     *  (`entropy_sample` events stream unconditionally regardless). See the Node SDK's
+     *  `entropyWatch` for the canonical documentation. Absent ⇒ disabled (kernel default). */
+    entropyWatch?: EntropyWatchOptions;
     /** K3: default lease (in turns) for every skill activation — auto-deactivates after N turns
      *  (toolset re-widens, knowledge pin boundary-swept). Absent ⇒ permanent (default). */
     skillLeaseTurns?: number;
@@ -191,6 +196,8 @@ export declare class RuntimeRunner {
      *  run — guards against re-pushing a duplicate entry if the model calls `skill(name)` again for
      *  an already-active skill (loading is idempotent; the knowledge push should be too). */
     private knowledgePushedSkills;
+    /** Most recent kernel entropy sample of the active/last run (see `latestEntropy`). */
+    private lastEntropySample;
     /** K4: the active run's goal, kept for the renewal-boundary memory re-query. */
     private currentGoal;
     private nextArchiveStart;
@@ -207,6 +214,9 @@ export declare class RuntimeRunner {
      *  the kernel disposition ladder: `"normal"` queues (default), `"high"` soft-interrupts, `"critical"`
      *  preempts. */
     injectNote(text: string, urgency?: RuntimeSignal["urgency"]): void;
+    /** The most recent kernel session-entropy sample (one per completed turn), or `null` before the
+     *  first boundary. A pull companion to the streamed `entropy_sample` events. */
+    latestEntropy(): EntropySample | null;
     /** Injected-note drain shared with the main loop's per-turn poll: injected notes first (FIFO), then
      *  the configured `signalSource` — one code path so the two inbound channels never drift. */
     private nextInboundSignal;
@@ -281,7 +291,15 @@ export declare class RuntimeRunner {
     private bootstrapWorkflowKernel;
     runWorkflow(spec: WorkflowSpec, opts?: {
         resumedCompleted?: string[];
+        /** W-1: recovered completions WITH control signals (classify branch / loop stop) — lowered to
+         *  the kernel's `resumed_results` so control flow replays faithfully. Supersedes
+         *  `resumedCompleted` for ids present in both. */
+        resumedResults?: RecoveredNodeCompletion[];
         resumedSubmissions?: Record<string, unknown>[][];
+        /** R3-1: original base index per submission batch (parallel to resumedSubmissions). */
+        resumedSubmissionBases?: number[];
+        /** W-1: recovered node outputs (agent id → output text) to pre-seed the driver's outputs map. */
+        resumedOutputs?: Map<string, string>;
         /** Standalone session id when bootstrapping (no active parent run). Defaults to a fresh uuid. */
         sessionId?: string;
     }): Promise<{
@@ -325,8 +343,9 @@ export declare class RuntimeRunner {
     private driveWorkflow;
     /**
      * Resume a workflow from the parent session's completed nodes.
-     * Reads the session log, extracts completed workflow node agent_ids, and
-     * calls runWorkflow with resumedCompleted so the kernel skips those nodes.
+     * Reads the session log, extracts completed workflow node records (with their W-1 control
+     * signals + outputs), and calls runWorkflow so the kernel skips those nodes, replays control
+     * flow (classify prune / loop stop), and the driver re-seeds its outputs map.
      */
     resumeWorkflow(spec: WorkflowSpec, opts?: {
         sessionId?: string;