@deepstrike/wasm 0.2.37 → 0.2.38

package/dist/index.d.ts

@@ -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/runtime/kernel-event-log.js

@@ -88,6 +88,25 @@ export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
                 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 {
                 kind: "agent_process_changed",

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

@@ -115,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/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";
@@ -122,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;
@@ -192,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;
@@ -208,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;

package/dist/runtime/runner.js

@@ -28,6 +28,8 @@ export 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). */
     knowledgePushedSkills = new Set();
+    /** Most recent kernel entropy sample of the active/last run (see `latestEntropy`). */
+    lastEntropySample = null;
     /** K4: the active run's goal, kept for the renewal-boundary memory re-query. */
     currentGoal = "";
     nextArchiveStart = 0;
@@ -48,6 +50,11 @@ export class RuntimeRunner {
     injectNote(text, urgency = "normal") {
         this.injectedSignals.push({ source: "custom", signalType: "event", urgency, payload: { goal: text } });
     }
+    /** 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() {
+        return this.lastEntropySample;
+    }
     /** 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. */
     async nextInboundSignal() {
@@ -859,10 +866,35 @@ export class RuntimeRunner {
                         }
                         catch { /* skip */ }
                     }
+                    const entropyObsStart = this.pendingObservations.length;
                     action = kernelAction(runtime, this.pendingObservations, {
                         kind: "tool_results",
                         results: toolResults.map(toolResultToKernel),
                     });
+                    // Surface the boundary's entropy measurement live (the heartbeat watch source).
+                    for (const obs of this.pendingObservations.slice(entropyObsStart)) {
+                        if (obs.kind === "entropy_sample") {
+                            this.lastEntropySample = {
+                                turn: obs.turn ?? 0,
+                                score: obs.score ?? 0,
+                                scoreVersion: obs.score_version ?? 0,
+                                rho: obs.rho ?? 0,
+                                repeatPressure: obs.repeat_pressure ?? 0,
+                                failureRate: obs.failure_rate ?? 0,
+                                rollbacksInWindow: obs.rollbacks_in_window ?? 0,
+                                windowTurns: obs.window_turns ?? 0,
+                            };
+                            yield { type: "entropy_sample", sample: this.lastEntropySample };
+                        }
+                        else if (obs.kind === "entropy_alert") {
+                            yield {
+                                type: "entropy_alert",
+                                turn: obs.turn ?? 0,
+                                score: obs.score ?? 0,
+                                threshold: obs.threshold ?? 0,
+                            };
+                        }
+                    }
                 }
                 else if (action.kind === "evaluate_milestone") {
                     const milestonePolicy = this.opts.milestonePolicy ?? "require_verifier";
@@ -1174,6 +1206,17 @@ export class RuntimeRunner {
         if (this.opts.knowledgeBudgetRatio !== undefined) {
             config.knowledge_budget_ratio = this.opts.knowledgeBudgetRatio;
         }
+        // Entropy watch (opt-in): threshold alerting over the per-turn session-entropy score.
+        if (this.opts.entropyWatch !== undefined) {
+            const ew = this.opts.entropyWatch;
+            config.entropy_watch = {
+                enabled: ew.enabled ?? true,
+                ...(ew.threshold !== undefined ? { threshold: ew.threshold } : {}),
+                ...(ew.hysteresis !== undefined ? { hysteresis: ew.hysteresis } : {}),
+                ...(ew.cooldownTurns !== undefined ? { cooldown_turns: ew.cooldownTurns } : {}),
+                ...(ew.notifyModel !== undefined ? { notify_model: ew.notifyModel } : {}),
+            };
+        }
         kernelApply(runtime, this.pendingObservations, { kind: "configure_run", config });
         if (this.opts.memoryPolicy) {
             const m = this.opts.memoryPolicy;

package/dist/runtime/session-log.d.ts

@@ -159,6 +159,21 @@ export type SessionEvent = {
     kind: "checkpoint_taken";
     turn: number;
     history_len: number;
+} | {
+    kind: "entropy_sample";
+    turn: number;
+    score: number;
+    score_version: number;
+    rho: number;
+    repeat_pressure: number;
+    failure_rate: number;
+    rollbacks_in_window: number;
+    window_turns: number;
+} | {
+    kind: "entropy_alert";
+    turn: number;
+    score: number;
+    threshold: number;
 } | {
     kind: "agent_process_changed";
     turn: number;

package/dist/types.d.ts

@@ -155,6 +155,38 @@ export interface ToolArgumentRepairedEvent extends StreamEvent {
     originalArguments: string;
     repairedArguments: string;
 }
+/** Kernel session-entropy measurement at a completed turn boundary (see the Node SDK's
+ *  `EntropySample` for the canonical documentation; this is the WASM mirror). */
+export interface EntropySample {
+    turn: number;
+    score: number;
+    scoreVersion: number;
+    rho: number;
+    repeatPressure: number;
+    failureRate: number;
+    rollbacksInWindow: number;
+    windowTurns: number;
+}
+/** One kernel entropy sample, emitted once per completed turn (a heartbeat watch source). */
+export interface EntropySampleEvent extends StreamEvent {
+    type: "entropy_sample";
+    sample: EntropySample;
+}
+/** The opt-in kernel entropy watch tripped (see `RunnerOptions.entropyWatch`). */
+export interface EntropyAlertEvent extends StreamEvent {
+    type: "entropy_alert";
+    turn: number;
+    score: number;
+    threshold: number;
+}
+/** Opt-in kernel-side threshold watch over the per-turn entropy score (Node SDK mirror). */
+export interface EntropyWatchOptions {
+    enabled?: boolean;
+    threshold?: number;
+    hysteresis?: number;
+    cooldownTurns?: number;
+    notifyModel?: boolean;
+}
 /**
  * Opaque per-run state owned by the provider (e.g. OpenAI Responses continuation).
  * The framework creates and threads this object; providers may read/write it.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepstrike/wasm",
-  "version": "0.2.37",
+  "version": "0.2.38",
   "description": "DeepStrike WASM SDK — browser, Cloudflare Workers, Deno Deploy",
   "type": "module",
   "main": "dist/index.js",
@@ -15,7 +15,7 @@
     "test": "node --experimental-vm-modules node_modules/.bin/jest"
   },
   "dependencies": {
-    "@deepstrike/wasm-kernel": "0.2.37"
+    "@deepstrike/wasm-kernel": "0.2.38"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",