@deepstrike/wasm 0.2.34 → 0.2.36

package/README.md

@@ -1,3 +1,9 @@
+<p align="center">
+  <a href="https://github.com/kongusen/deepstrike">
+    <img src="https://raw.githubusercontent.com/kongusen/deepstrike/main/docs/public/banner.png" alt="DeepStrike" width="420" />
+  </a>
+</p>
+
 # DeepStrike WASM SDK
 
 Runtime framework built on a Rust kernel compiled to WebAssembly. Runs in browsers, Cloudflare Workers, Deno Deploy, and Vercel Edge — anywhere that supports `fetch` and WASM.

package/dist/providers/anthropic.js

@@ -250,6 +250,8 @@ export class AnthropicProvider {
                             const inputTokens = uncachedInput + cacheReadTokens + cacheCreationTokens;
                             if (inputTokens > 0 || outputTokens > 0) {
                                 const bySlot = estimateCacheReadBySlot(cacheReadTokens, slotBp);
+                                // stop_reason rides on message_delta; "max_tokens" drives output-cap recovery.
+                                const stopReason = evt.delta?.stop_reason;
                                 yield {
                                     type: "usage",
                                     totalTokens: inputTokens + outputTokens,
@@ -258,6 +260,7 @@ export class AnthropicProvider {
                                     cacheReadInputTokens: cacheReadTokens,
                                     cacheCreationInputTokens: cacheCreationTokens,
                                     ...(bySlot ? { cacheReadInputTokensBySlot: bySlot } : {}),
+                                    ...(stopReason ? { stopReason } : {}),
                                 };
                             }
                         }

package/dist/providers/openai.js

@@ -37,6 +37,9 @@ export class OpenAIProvider {
         const reader = resp.body.getReader();
         const decoder = new TextDecoder();
         let buf = "";
+        // Phase 4: OpenAI signals an output-cap truncation via finish_reason="length"; the kernel
+        // treats it as a truncation (== Anthropic "max_tokens") and drives output-cap recovery.
+        let finishReason;
         while (true) {
             const { done, value } = await reader.read();
             if (done)
@@ -48,10 +51,17 @@ export class OpenAIProvider {
                 if (!line.startsWith("data: "))
                     continue;
                 const data = line.slice(6).trim();
-                if (data === "[DONE]")
+                if (data === "[DONE]") {
+                    // Surface an output-cap truncation (finish_reason="length") to the runner/kernel. Emitted
+                    // as a usage frame (the channel the runner reads stopReason from) before the early return.
+                    if (finishReason)
+                        yield { type: "usage", totalTokens: 0, stopReason: finishReason };
                     return;
+                }
                 try {
                     const chunk = JSON.parse(data);
+                    if (chunk.choices?.[0]?.finish_reason)
+                        finishReason = chunk.choices[0].finish_reason ?? undefined;
                     const delta = chunk.choices?.[0]?.delta;
                     if (!delta)
                         continue;

package/dist/runtime/large-result-spool.d.ts

@@ -45,5 +45,12 @@ export declare class LargeResultSpool {
     processToolResult(result: ToolResult): Promise<SpooledToolResult>;
     persistOutput(callId: string, content: string): Promise<string>;
     readSpooledResult(spoolRef: string): Promise<string>;
+    /**
+     * O7: locate a spooled output by the tool call's id (the `read_result` meta-tool only knows
+     * `call_id`, not the content-hashed key `persistOutput` chose). Scans the driver's key list for
+     * the `.spool/${callId}-*.txt` naming convention; returns `undefined` if nothing was ever
+     * spooled for that call.
+     */
+    findByCallId(callId: string): Promise<string | undefined>;
     cleanup(maxAgeMs?: number): Promise<number>;
 }

package/dist/runtime/large-result-spool.js

@@ -113,6 +113,31 @@ omitted: ${omitted} chars
     async readSpooledResult(spoolRef) {
         return this.driver.read(spoolRef);
     }
+    /**
+     * O7: locate a spooled output by the tool call's id (the `read_result` meta-tool only knows
+     * `call_id`, not the content-hashed key `persistOutput` chose). Scans the driver's key list for
+     * the `.spool/${callId}-*.txt` naming convention; returns `undefined` if nothing was ever
+     * spooled for that call.
+     */
+    async findByCallId(callId) {
+        let keys;
+        try {
+            keys = await this.driver.list();
+        }
+        catch {
+            return undefined;
+        }
+        const prefix = `.spool/${callId}-`;
+        const match = keys.find(k => k.startsWith(prefix) && k.endsWith('.txt'));
+        if (!match)
+            return undefined;
+        try {
+            return await this.driver.read(match);
+        }
+        catch {
+            return undefined;
+        }
+    }
     async cleanup(maxAgeMs) {
         const limit = maxAgeMs ?? this.config.maxAgeMs ?? 7 * 24 * 60 * 60 * 1000;
         try {

package/dist/runtime/runner.d.ts

@@ -2,7 +2,7 @@ import type { LLMProvider, Message, StreamEvent, PermissionRequestEvent, Permiss
 import type { ToolSuspendEvent } from "./execution-plane.js";
 import type { DreamStore, DreamResult } from "../memory/index.js";
 import type { KnowledgeSource } from "../knowledge/index.js";
-import type { SignalSource } from "../signals/index.js";
+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";
@@ -59,6 +59,16 @@ export interface TurnMetrics {
     };
     cacheCreationTokens: number;
 }
+/** O5: decision returned by `onToolCall` — `block: true` denies this call before it executes. */
+export interface ToolCallHookDecision {
+    block?: boolean;
+    reason?: string;
+}
+/** O5: decision returned by `onToolResult` — replace the output and/or inject a signal note. */
+export interface ToolResultHookDecision {
+    replaceOutput?: string;
+    note?: string;
+}
 export interface RuntimeOptions {
     provider: LLMProvider;
     /** M1/G3 intelligence routing: resolve a per-node provider from a workflow node's `modelHint`.
@@ -78,6 +88,8 @@ export interface RuntimeOptions {
      *  the knowledge partition before turn 1. Requires dreamStore + agentId. */
     preQueryMemory?: (ctx: {
         goal: string;
+        /** K4: `"initial"` = pre-turn-1 fetch; `"renewal"` = re-fired after a sprint renewal. */
+        phase?: "initial" | "renewal";
     }) => Promise<string[] | undefined> | string[] | undefined;
     systemPrompt?: string;
     initialMemory?: string[];
@@ -95,6 +107,39 @@ export interface RuntimeOptions {
     };
     schedulerBudget?: SchedulerBudget;
     resourceQuota?: ResourceQuota;
+    /** O6: the in-kernel repeat fuse — identical tool call (same name AND args) `denyAfter` turns in a
+     *  row ⇒ deny + directive note; `terminateAfter` ⇒ run ends `no_progress`. Defaults 5/8; `false`
+     *  disables. Same-tool/different-args loops never trip it. */
+    repeatFuse?: {
+        denyAfter?: number;
+        terminateAfter?: number;
+    } | false;
+    /** O4: turn-end criteria gate — one kernel-injected self-check turn before accepting completion
+     *  while `criteria` stand. Default enabled; `false` accepts the first finish unconditionally. */
+    criteriaGate?: boolean;
+    /** K2: max share of `maxTokens` the durable knowledge partition may occupy. Over budget ⇒
+     *  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;
+    /** 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;
+    /** O5 (PreToolUse-hook analog): stateful host veto over each kernel-approved call; return
+     *  `{ block: true, reason }` to deny — the reason reaches the model as a denied result. Errs-open. */
+    onToolCall?: (call: {
+        callId: string;
+        name: string;
+        arguments: string;
+    }) => Promise<ToolCallHookDecision | undefined | void> | ToolCallHookDecision | undefined | void;
+    /** O5 (PostToolUse-hook analog): inspect each executed result; `{ replaceOutput }` swaps what the
+     *  model sees, `{ note }` injects a signal note (the `injectNote` channel). Errs-open. */
+    onToolResult?: (result: {
+        callId: string;
+        name: string;
+        arguments: string;
+        output: string;
+        isError: boolean;
+    }) => Promise<ToolResultHookDecision | undefined | void> | ToolResultHookDecision | undefined | void;
     memoryPolicy?: MemoryPolicy;
     tokenizer?: string;
     enablePlanTool?: boolean;
@@ -140,8 +185,15 @@ export declare class RuntimeRunner {
     private pendingObservations;
     private activeKernel;
     private currentSessionId;
+    /** O2 (system-reminder channel): host-pushed notes awaiting the next turn-boundary drain. */
+    private injectedSignals;
+    /** Skill names whose content has already been pushed into the durable `knowledge` slot this
+     *  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;
+    /** K4: the active run's goal, kept for the renewal-boundary memory re-query. */
+    private currentGoal;
     private nextArchiveStart;
-    private localPageOutCache;
     /** M5 v2.1: sub-workflow specs a top-level agent authored via `start_workflow`, awaiting auto-drive
      *  at the next safe point (after the tool turn resolves, kernel back in Reason). */
     private pendingAuthoredWorkflows;
@@ -149,6 +201,15 @@ export declare class RuntimeRunner {
     constructor(opts: RuntimeOptions);
     get hostOptions(): RuntimeOptions;
     interrupt(): void;
+    /** Push a contextual note into the run's signal stream (the system-reminder channel): it drains at
+     *  the next turn boundary, routes through the kernel attention policy, and — once acted on — renders
+     *  as a `[SIGNAL] <text>` line in the volatile state turn plus a durable directive. `urgency` maps to
+     *  the kernel disposition ladder: `"normal"` queues (default), `"high"` soft-interrupts, `"critical"`
+     *  preempts. */
+    injectNote(text: string, urgency?: RuntimeSignal["urgency"]): void;
+    /** 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;
     run(req: {
         sessionId: string;
         goal: string;
@@ -160,11 +221,29 @@ export declare class RuntimeRunner {
         }>;
     }): AsyncIterable<StreamEvent>;
     wake(sessionId: string, extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
-    /** Push content into Slot 2 (system_knowledge) via add_knowledge_message. */
-    pushKnowledge(message: Message, tokens?: number): void;
-    /** Phase 4: satisfy kernel page-in requests before meta-tool execution. */
-    private applyKernelPageIn;
+    /** Push content into Slot 2 (system_knowledge) via add_knowledge_message.
+     *  K1: `opts.key` gives the entry identity — a same-key push upserts (applied at the next
+     *  compaction/renewal boundary) instead of appending a duplicate. `opts.pinned` exempts the
+     *  entry from the knowledge-budget sweep. */
+    pushKnowledge(message: Message, tokens?: number, opts?: {
+        key?: string;
+        pinned?: boolean;
+    }): void;
+    /** K1: mark a keyed knowledge entry for removal at the next compaction/renewal boundary.
+     *  Errs-open: an unknown key is a kernel-side no-op. */
+    removeKnowledge(key: string): void;
+    /** K3: host-driven skill deactivation — toolset re-widens at the next provider call, the
+     *  skill's knowledge pin drops at the next boundary. Errs-open: not-active is a no-op. */
+    deactivateSkill(name: string): void;
     private resolveKernelSuspend;
+    /**
+     * O7: resolve a `read_result` meta-tool call to the full text of a previously-evicted tool
+     * output. Resolution order: (a) this turn's in-memory `pendingSpoolOutputs` map, (b) the result
+     * spool (persisted once the kernel observation `large_result_spooled` was processed), (c) a
+     * session-log scan for the original `tool_completed` event carrying that `call_id`. Slices the
+     * resolved text by `[offset, offset + maxBytes)` (plain string slice — "bytes-ish").
+     */
+    private resolveReadResult;
     dream(agentId: string, nowMs?: number): Promise<DreamResult>;
     private execute;
     spawnSubAgent(spec: AgentRunSpec): Promise<SubAgentResult>;
@@ -256,6 +335,12 @@ export declare class RuntimeRunner {
         failed: string[];
     }>;
     private appendObservations;
+    /** I4 + K4: fetch long-term memory hits for the current goal and land them in `history` as an
+     *  ordinary user turn — single-use retrieval content that decays with the compression pyramid,
+     *  never pinned into `knowledge`. `phase: "initial"` = once before turn 1; `phase: "renewal"` =
+     *  re-fired after each sprint renewal (renewal drops the old history INCLUDING earlier memory
+     *  hits). Errs-open throughout. */
+    private prefetchMemoryIntoHistory;
     private archiveSemanticPageOut;
 }
 export declare function collectText(stream: AsyncIterable<StreamEvent>): Promise<string>;

package/dist/runtime/runner.js

@@ -5,13 +5,13 @@ import { peekProviderReplay, seedProviderReplayFromEvents } from "./provider-rep
 import { sanitizeReplayText } from "./replay-sanitize.js";
 import { formatToolError } from "../tools/errors.js";
 import { buildLlmCompletedEvent, buildRunTerminalEvent, buildWorkflowNodeCompletedEvent, buildWorkflowNodesSubmittedEvent, recoverCompletedWorkflowNodes, recoverSubmittedWorkflowNodes, repairEventsForRecovery, } from "./session-repair.js";
-import { forceCompact, kernelAction, kernelApply, kernelMaybeAction, messageToKernelMessage, skillMetadataToKernel, toolResultToKernel, toolSchemaToKernel, } from "./kernel-step.js";
+import { kernelAction, kernelApply, kernelMaybeAction, messageToKernelMessage, skillMetadataToKernel, toolResultToKernel, toolSchemaToKernel, } from "./kernel-step.js";
 import { agentRunSpecToKernel, findSpawnProcessObservation, milestoneCheckPass, milestoneCheckResultToKernel, spawnObservationToManifest, subAgentResultToKernel, submitWorkflowNodesToKernel, submitWorkflowToKernel, workflowBudgetNote, workflowNodeToManifest, workflowNodeToSpec, workflowSpecToKernel, } from "./types/agent.js";
 import { defaultSubAgentOrchestrator } from "./sub-agent-orchestrator.js";
 import { extractJsonValue, schemaInstruction, schemaRetryInstruction, validateAgainstSchema, } from "./output-schema.js";
 import { resolveReducer } from "./reducers.js";
 import { loopInstruction, classifyInstruction, judgeGoal, extractLoopContinue, extractClassifyBranch, extractJudgeWinner, } from "./workflow-control-flow.js";
-import { kernelObservationToSessionEvent, withCategory } from "./kernel-event-log.js";
+import { kernelObservationToSessionEvent } from "./kernel-event-log.js";
 import { assertNativeProfile } from "./os-profile.js";
 import { LargeResultSpool } from "./large-result-spool.js";
 export class RuntimeRunner {
@@ -22,8 +22,15 @@ export class RuntimeRunner {
     pendingObservations = [];
     activeKernel = null;
     currentSessionId = null;
+    /** O2 (system-reminder channel): host-pushed notes awaiting the next turn-boundary drain. */
+    injectedSignals = [];
+    /** Skill names whose content has already been pushed into the durable `knowledge` slot this
+     *  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();
+    /** K4: the active run's goal, kept for the renewal-boundary memory re-query. */
+    currentGoal = "";
     nextArchiveStart = 0;
-    localPageOutCache = [];
     /** M5 v2.1: sub-workflow specs a top-level agent authored via `start_workflow`, awaiting auto-drive
      *  at the next safe point (after the tool turn resolves, kernel back in Reason). */
     pendingAuthoredWorkflows = [];
@@ -33,6 +40,24 @@ export class RuntimeRunner {
     }
     get hostOptions() { return this.opts; }
     interrupt() { this.interrupted = true; this.abortController?.abort(); }
+    /** Push a contextual note into the run's signal stream (the system-reminder channel): it drains at
+     *  the next turn boundary, routes through the kernel attention policy, and — once acted on — renders
+     *  as a `[SIGNAL] <text>` line in the volatile state turn plus a durable directive. `urgency` maps to
+     *  the kernel disposition ladder: `"normal"` queues (default), `"high"` soft-interrupts, `"critical"`
+     *  preempts. */
+    injectNote(text, urgency = "normal") {
+        this.injectedSignals.push({ source: "custom", signalType: "event", urgency, payload: { goal: text } });
+    }
+    /** 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() {
+        const injected = this.injectedSignals.shift();
+        if (injected)
+            return injected;
+        if (!this.opts.signalSource)
+            return null;
+        return this.opts.signalSource.nextSignal();
+    }
     async *run(req) {
         const prior = req.inheritEvents ?? await this.opts.sessionLog.read(req.sessionId);
         const midRun = isMidRun(prior);
@@ -58,59 +83,35 @@ export class RuntimeRunner {
         const start = startEntry.event;
         yield* this.execute(sessionId, start.goal, start.criteria, extensions, events, true);
     }
-    /** Push content into Slot 2 (system_knowledge) via add_knowledge_message. */
-    pushKnowledge(message, tokens) {
+    /** Push content into Slot 2 (system_knowledge) via add_knowledge_message.
+     *  K1: `opts.key` gives the entry identity — a same-key push upserts (applied at the next
+     *  compaction/renewal boundary) instead of appending a duplicate. `opts.pinned` exempts the
+     *  entry from the knowledge-budget sweep. */
+    pushKnowledge(message, tokens, opts) {
         if (!this.activeKernel)
             return;
         kernelApply(this.activeKernel, this.pendingObservations, {
             kind: "add_knowledge_message",
             content: message.content ?? "",
             tokens: tokens ?? Math.max(1, Math.ceil((message.content?.length ?? 0) / 4)),
+            ...(opts?.key !== undefined ? { key: opts.key } : {}),
+            ...(opts?.pinned ? { pinned: true } : {}),
         });
     }
-    /** Phase 4: satisfy kernel page-in requests before meta-tool execution. */
-    async applyKernelPageIn(runtime, sessionId) {
-        const requests = this.pendingObservations.filter((o) => o.kind === "page_in_requested" && typeof o.tool === "string");
-        if (requests.length === 0)
+    /** K1: mark a keyed knowledge entry for removal at the next compaction/renewal boundary.
+     *  Errs-open: an unknown key is a kernel-side no-op. */
+    removeKnowledge(key) {
+        if (!this.activeKernel)
             return;
-        const entries = [];
-        for (const req of requests) {
-            const query = typeof req.query === "string" ? req.query : "";
-            const topK = typeof req.top_k === "number" ? req.top_k : 5;
-            if (req.tool === "memory") {
-                const localHits = this.localPageOutCache.filter(m => typeof m.content === "string" && m.content.toLowerCase().includes(query.toLowerCase())).slice(0, topK);
-                for (const hit of localHits) {
-                    entries.push({
-                        content: `[local semantic cache] ${hit.role}: ${hit.content}`,
-                        source: "semantic_cache",
-                    });
-                }
-                const remainingK = topK - entries.length;
-                if (remainingK > 0 && this.opts.dreamStore && this.opts.agentId) {
-                    const hits = await this.opts.dreamStore.search(this.opts.agentId, query, remainingK);
-                    for (const hit of hits) {
-                        entries.push({
-                            content: `[memory score=${hit.score.toFixed(3)}] ${hit.text}`,
-                            source: "memory",
-                        });
-                    }
-                }
-            }
-            else if (req.tool === "knowledge" && this.opts.knowledgeSource) {
-                const snippets = await this.opts.knowledgeSource.retrieve(query, topK);
-                for (const snippet of snippets) {
-                    entries.push({ content: snippet, source: "knowledge" });
-                }
-            }
-        }
-        if (entries.length === 0)
+        kernelApply(this.activeKernel, this.pendingObservations, { kind: "remove_knowledge", key });
+    }
+    /** K3: host-driven skill deactivation — toolset re-widens at the next provider call, the
+     *  skill's knowledge pin drops at the next boundary. Errs-open: not-active is a no-op. */
+    deactivateSkill(name) {
+        if (!this.activeKernel)
             return;
-        kernelApply(runtime, this.pendingObservations, { kind: "page_in", entries });
-        await this.opts.sessionLog.append(sessionId, withCategory({
-            kind: "page_in",
-            turn: runtime.turn(),
-            entry_count: entries.length,
-        }));
+        kernelApply(this.activeKernel, this.pendingObservations, { kind: "skill_deactivated", name });
+        this.knowledgePushedSkills.delete(name);
     }
     async resolveKernelSuspend(runtime, sessionId) {
         const gated = this.pendingObservations.filter((o) => o.kind === "tool_gated" && typeof o.call_id === "string" && typeof o.tool === "string");
@@ -190,6 +191,63 @@ export class RuntimeRunner {
         }
         return { approved, denied, events };
     }
+    /**
+     * O7: resolve a `read_result` meta-tool call to the full text of a previously-evicted tool
+     * output. Resolution order: (a) this turn's in-memory `pendingSpoolOutputs` map, (b) the result
+     * spool (persisted once the kernel observation `large_result_spooled` was processed), (c) a
+     * session-log scan for the original `tool_completed` event carrying that `call_id`. Slices the
+     * resolved text by `[offset, offset + maxBytes)` (plain string slice — "bytes-ish").
+     */
+    async resolveReadResult(sessionId, argsJson) {
+        let callId = "";
+        let offset = 0;
+        let maxBytes = 4000;
+        try {
+            const args = JSON.parse(argsJson || "{}");
+            callId = typeof args.call_id === "string" ? args.call_id : "";
+            if (typeof args.offset === "number" && Number.isFinite(args.offset))
+                offset = args.offset;
+            if (typeof args.max_bytes === "number" && Number.isFinite(args.max_bytes))
+                maxBytes = args.max_bytes;
+        }
+        catch {
+            // malformed arguments — callId stays empty, falls through to "not found" below
+        }
+        let full = this.pendingSpoolOutputs.get(callId)?.output;
+        if (full === undefined && this.opts.resultSpool) {
+            try {
+                full = await this.opts.resultSpool.findByCallId(callId);
+            }
+            catch {
+                full = undefined;
+            }
+        }
+        if (full === undefined) {
+            try {
+                const events = await this.opts.sessionLog.read(sessionId);
+                for (const { event } of events) {
+                    if (event.kind !== "tool_completed")
+                        continue;
+                    const match = event.results.find(r => r.call_id === callId);
+                    if (match)
+                        full = match.output;
+                }
+            }
+            catch {
+                full = undefined;
+            }
+        }
+        if (full === undefined) {
+            return { text: `no stored output for call_id "${callId}"`, isError: true };
+        }
+        const start = Math.max(0, offset);
+        const end = Math.min(full.length, start + Math.max(0, maxBytes));
+        const slice = full.slice(start, end);
+        return {
+            text: `[read_result ${callId}: chars ${start}–${end} of ${full.length}]\n${slice}`,
+            isError: false,
+        };
+    }
     async dream(agentId, nowMs = Date.now()) {
         if (!this.opts.dreamStore)
             throw new Error("dreamStore not configured");
@@ -351,14 +409,35 @@ export class RuntimeRunner {
                 messages: replayed.map(messageToKernelMessage),
             });
             // P1-B B3: rebuild active-skill gating after a wake (active_skills is not snapshotted).
+            // `knowledge` isn't snapshotted either (same graceful-reset philosophy) — best-effort re-push
+            // the skill's content from its replayed tool_result so the durable copy survives a wake too.
+            const toolResultByCallId = new Map();
+            for (const m of replayed) {
+                for (const part of m.contentParts ?? []) {
+                    if (part.type === "tool_result" && part.callId && part.output !== undefined) {
+                        toolResultByCallId.set(part.callId, part.output);
+                    }
+                }
+            }
             for (const m of replayed) {
                 for (const tc of m.toolCalls ?? []) {
                     if (tc.name !== "skill")
                         continue;
                     try {
                         const name = JSON.parse(tc.arguments || "{}").name;
-                        if (name)
-                            kernelApply(runtime, this.pendingObservations, { kind: "skill_activated", name });
+                        if (!name)
+                            continue;
+                        kernelApply(runtime, this.pendingObservations, {
+                            kind: "skill_activated",
+                            name,
+                            ...(this.opts.skillLeaseTurns !== undefined ? { lease_turns: this.opts.skillLeaseTurns } : {}),
+                        });
+                        const output = toolResultByCallId.get(tc.id);
+                        if (output && !this.knowledgePushedSkills.has(name)) {
+                            this.knowledgePushedSkills.add(name);
+                            // K1: keyed — the kernel-side upsert is the authoritative dedup across wake replays.
+                            this.pushKnowledge({ role: "system", content: output }, undefined, { key: `skill:${name}` });
+                        }
                     }
                     catch { /* skip */ }
                 }
@@ -386,44 +465,29 @@ export class RuntimeRunner {
             startPayload.run_spec = agentRunSpecToKernel(spec);
         }
         this.applyKernelPolicies(runtime);
-        // I4: pre-fetch memory into the knowledge partition before the first LLM turn (mirrors Node).
-        if (!resumeMidRun && this.opts.preQueryMemory && this.opts.dreamStore && this.opts.agentId) {
-            try {
-                const queries = await this.opts.preQueryMemory({ goal });
-                const entries = [];
-                for (const q of queries ?? []) {
-                    if (typeof q !== "string" || !q.trim())
-                        continue;
-                    const hits = await this.opts.dreamStore.search(this.opts.agentId, q, 5);
-                    for (const hit of hits) {
-                        entries.push({ content: `[memory score=${hit.score.toFixed(3)}] ${hit.text}`, source: "memory" });
-                    }
-                }
-                if (entries.length > 0) {
-                    kernelApply(runtime, this.pendingObservations, { kind: "page_in", entries });
-                }
-            }
-            catch { /* errs-open */ }
+        // I4: pre-fetch memory before the first LLM turn (mirrors Node). Strict dynamic context
+        // control: single-use retrieval content, not a stable skill — lands in `history` like an
+        // ordinary `memory` tool result, so it decays with the compression pyramid instead of
+        // pinning itself in `knowledge` forever.
+        this.currentGoal = goal;
+        if (!resumeMidRun) {
+            await this.prefetchMemoryIntoHistory(runtime, "initial");
         }
         let action = resumeMidRun
             ? kernelAction(runtime, this.pendingObservations, { kind: "resume" })
             : kernelAction(runtime, this.pendingObservations, startPayload);
-        let hasAttemptedReactiveCompact = false;
         // P0-C: the skill loaded and in effect going into the current turn → per-turn `activeSkill` metric.
         let activeSkill;
         // I0b: kernel-throw safety net — see Node runner for full rationale.
         try {
             while (!runtime.isTerminal()) {
-                if (action.kind === "execute_tool") {
-                    await this.applyKernelPageIn(runtime, sessionId);
-                }
                 nextCompressedArchiveStart = await this.appendObservations(sessionId, runtime, nextCompressedArchiveStart);
                 if (this.interrupted) {
                     action = kernelAction(runtime, this.pendingObservations, { kind: "timeout" });
                     break;
                 }
-                if (this.opts.signalSource) {
-                    const sig = await this.opts.signalSource.nextSignal();
+                if (this.opts.signalSource || this.injectedSignals.length > 0) {
+                    const sig = await this.nextInboundSignal();
                     if (sig) {
                         const sigAction = kernelMaybeAction(runtime, this.pendingObservations, signalToKernelEvent(sig));
                         if (sigAction)
@@ -466,7 +530,7 @@ export class RuntimeRunner {
                     let turnCacheReadTokens = 0;
                     let turnCacheCreationTokens = 0;
                     let turnCacheReadBySlot;
-                    let shouldRetry = false;
+                    let turnStopReason;
                     const abortSignal = this.abortController?.signal;
                     try {
                         for await (const evt of this.opts.provider.stream(context, tools, Object.keys(ext).length ? ext : undefined, providerState, abortSignal)) {
@@ -483,6 +547,9 @@ export class RuntimeRunner {
                                 turnCacheCreationTokens = usageEvt.cacheCreationInputTokens ?? 0;
                                 // I1: per-slot attribution forwarded to TurnMetrics; undefined on non-Anthropic providers.
                                 turnCacheReadBySlot = usageEvt.cacheReadInputTokensBySlot;
+                                // Phase 4: stop_reason drives the kernel's max-output-tokens recovery.
+                                if (usageEvt.stopReason)
+                                    turnStopReason = usageEvt.stopReason;
                                 continue;
                             }
                             yield evt;
@@ -495,23 +562,31 @@ export class RuntimeRunner {
                         }
                     }
                     catch (err) {
-                        // #2-B-ii: an aborted in-flight request surfaces as an AbortError — treat as an interrupt.
                         if (abortSignal?.aborted) {
+                            // #2-B-ii: an aborted in-flight request surfaces as an AbortError — treat it as an
+                            // interrupt (the post-stream `aborted` check below converts it to a clean
+                            // timeout/UserAbort), not a crash or a provider error.
                             this.interrupted = true;
                         }
-                        const errMsg = formatToolError(err).toLowerCase();
-                        if ((errMsg.includes("413") || errMsg.includes("too long") || errMsg.includes("context length exceeded") || errMsg.includes("context_length_exceeded")) &&
-                            !hasAttemptedReactiveCompact) {
-                            hasAttemptedReactiveCompact = true;
-                            if (forceCompact(runtime, this.pendingObservations)) {
-                                nextCompressedArchiveStart = await this.appendObservations(sessionId, runtime, nextCompressedArchiveStart);
-                                shouldRetry = true;
+                        else {
+                            // Reactive recovery is now a kernel decision. Forward the raw provider error and
+                            // dispatch whatever the kernel returns: `call_provider` to retry with a freshly
+                            // compacted context, or `done` to terminate with an honest `ContextOverflow`. The
+                            // classify + compact + retry + give-up policy lives in the kernel (one place), not
+                            // duplicated across the four SDK runners.
+                            action = kernelAction(runtime, this.pendingObservations, {
+                                kind: "provider_error",
+                                message: formatToolError(err),
+                            });
+                            // Withholding (query.ts parity): surface the raw provider error only when the kernel
+                            // could NOT recover (it returned a terminal). On a recovered retry (`call_provider`)
+                            // the error stays hidden. `continue` re-enters the loop: a recovered turn persists its
+                            // compaction archive via the loop-top appendObservations, and a terminal `done` exits
+                            // through `isTerminal()`.
+                            if (action.kind === "done") {
+                                yield { type: "error", message: formatToolError(err) };
                             }
-                        }
-                        if (!shouldRetry) {
-                            yield { type: "error", message: formatToolError(err) };
-                            action = kernelAction(runtime, this.pendingObservations, { kind: "timeout" });
-                            break;
+                            continue;
                         }
                     }
                     // #2-B-ii: stream aborted (preempt/interrupt) via the break path — end the turn now.
@@ -519,14 +594,6 @@ export class RuntimeRunner {
                         action = kernelAction(runtime, this.pendingObservations, { kind: "timeout" });
                         break;
                     }
-                    if (shouldRetry) {
-                        action = {
-                            kind: "call_provider",
-                            context: runtime.render(),
-                            tools,
-                        };
-                        continue;
-                    }
                     const assistantMessage = {
                         role: "assistant",
                         content: finalText,
@@ -539,6 +606,7 @@ export class RuntimeRunner {
                         ...(turnInputTokens > 0 ? { observed_input_tokens: turnInputTokens } : {}),
                         ...(turnOutputTokens > 0 ? { observed_output_tokens: turnOutputTokens } : {}),
                         now_ms: Date.now(),
+                        ...(turnStopReason ? { stop_reason: turnStopReason } : {}),
                     };
                     let nextAction = kernelMaybeAction(runtime, this.pendingObservations, providerEvent);
                     const hasSuspended = this.pendingObservations.some(o => o.kind === "suspended");
@@ -605,7 +673,16 @@ export class RuntimeRunner {
                     // the orchestrator collects them and `runWorkflow` sends them to the parent kernel.
                     // M5 v1: `start_workflow` (author a sub-workflow) flattens to the same append path.
                     const submitCalls = allCalls.filter(c => c.name === "submit_workflow_nodes" || c.name === "start_workflow");
-                    const normalCalls = allCalls.filter(c => c.name !== "submit_workflow_nodes" && c.name !== "start_workflow");
+                    // O7: `read_result` re-fetches a tool output the kernel evicted from context. Content is
+                    // host-resolved: (a) this turn's in-memory pending spool map, (b) the on-disk result spool,
+                    // (c) a session-log scan for the original `tool_completed` event.
+                    const readResultCalls = allCalls.filter(c => c.name === "read_result");
+                    const normalCalls = allCalls.filter(c => c.name !== "submit_workflow_nodes" && c.name !== "start_workflow" && c.name !== "read_result");
+                    for (const call of readResultCalls) {
+                        const out = await this.resolveReadResult(sessionId, call.arguments);
+                        toolResults.push({ callId: call.id, output: out.text, isError: out.isError });
+                        yield { type: "tool_result", callId: call.id, content: out.text, isError: out.isError };
+                    }
                     for (const call of submitCalls) {
                         // M5 v2.1: a TOP-LEVEL agent authoring a whole sub-workflow via `start_workflow` — record the
                         // spec and AUTO-PIVOT once this tool turn resolves. A workflow-NODE's `start_workflow` (and
@@ -627,7 +704,35 @@ export class RuntimeRunner {
                         toolResults.push({ callId: call.id, output: "submitted", isError: false });
                         yield { type: "tool_result", callId: call.id, content: "submitted", isError: false };
                     }
-                    for await (const evt of this.opts.executionPlane.executeAll(normalCalls, runCtx)) {
+                    // O5 (PreToolUse-hook analog): stateful host veto over each kernel-approved call.
+                    // A blocked call never executes; its reason reaches the model as a denied result.
+                    let executableCalls = normalCalls;
+                    if (this.opts.onToolCall) {
+                        const allowed = [];
+                        for (const call of normalCalls) {
+                            let decision;
+                            try {
+                                decision = await this.opts.onToolCall({ callId: call.id, name: call.name, arguments: call.arguments });
+                            }
+                            catch {
+                                decision = undefined;
+                            }
+                            if (decision?.block) {
+                                const reason = decision.reason ?? "blocked by host onToolCall hook";
+                                yield { type: "tool_denied", callId: call.id, toolName: call.name, reason };
+                                await this.opts.sessionLog.append(sessionId, {
+                                    kind: "tool_denied", turn: runtime.turn(), call_id: call.id, tool_name: call.name, reason,
+                                });
+                                const out = `blocked by host hook: ${reason}`;
+                                toolResults.push({ callId: call.id, output: out, isError: true, errorKind: "governance_denied" });
+                                yield { type: "tool_result", callId: call.id, name: call.name, content: out, isError: true };
+                                continue;
+                            }
+                            allowed.push(call);
+                        }
+                        executableCalls = allowed;
+                    }
+                    for await (const evt of this.opts.executionPlane.executeAll(executableCalls, runCtx)) {
                         yield evt;
                         if (evt.type === "tool_result") {
                             const tre = evt;
@@ -681,6 +786,31 @@ export class RuntimeRunner {
                             });
                         }
                     }
+                    // O5 (PostToolUse-hook analog): host inspection of each executed result before it reaches
+                    // the kernel/session-log — replace the output and/or inject a signal note. Errs-open.
+                    if (this.opts.onToolResult) {
+                        for (const r of toolResults) {
+                            const call = executableCalls.find(c => c.id === r.callId);
+                            if (!call)
+                                continue;
+                            let decision;
+                            try {
+                                decision = await this.opts.onToolResult({
+                                    callId: r.callId, name: call.name, arguments: call.arguments,
+                                    output: r.output, isError: r.isError,
+                                });
+                            }
+                            catch {
+                                decision = undefined;
+                            }
+                            if (!decision)
+                                continue;
+                            if (typeof decision.replaceOutput === "string")
+                                r.output = decision.replaceOutput;
+                            if (decision.note)
+                                this.injectNote(decision.note);
+                        }
+                    }
                     await this.opts.sessionLog.append(sessionId, {
                         kind: "tool_completed",
                         turn: runtime.turn(),
@@ -698,6 +828,12 @@ export class RuntimeRunner {
                         }
                     }
                     // P1-B B3: a successfully-resolved `skill` call activates that skill for the next turn.
+                    //
+                    // Strict dynamic context control: a skill is METHOD content — how to do something — reused
+                    // for the rest of the run, unlike a one-off memory/knowledge lookup (fact content, relevant
+                    // for the moment it's used). So its text ALSO goes into the durable `knowledge` slot here
+                    // (in addition to the ordinary tool_result already headed for `history`, where it will decay
+                    // with the compression pyramid like any other tool output). First activation only.
                     for (const call of allCalls) {
                         if (call.name !== "skill")
                             continue;
@@ -706,8 +842,20 @@ export class RuntimeRunner {
                             continue;
                         try {
                             const name = JSON.parse(call.arguments || "{}").name;
-                            if (name)
-                                kernelApply(runtime, this.pendingObservations, { kind: "skill_activated", name });
+                            if (!name)
+                                continue;
+                            kernelApply(runtime, this.pendingObservations, {
+                                kind: "skill_activated",
+                                name,
+                                ...(this.opts.skillLeaseTurns !== undefined ? { lease_turns: this.opts.skillLeaseTurns } : {}),
+                            });
+                            // With a lease configured, skip the Set optimization: an expired-then-reloaded skill
+                            // must re-pin — only the kernel knows the lease state; its upsert dedupes anyway.
+                            if (this.opts.skillLeaseTurns !== undefined || !this.knowledgePushedSkills.has(name)) {
+                                this.knowledgePushedSkills.add(name);
+                                // K1: keyed `skill:<name>` — the kernel-side upsert dedupes across runner instances.
+                                this.pushKnowledge({ role: "system", content: res.output }, undefined, { key: `skill:${name}` });
+                            }
                         }
                         catch { /* skip */ }
                     }
@@ -988,6 +1136,21 @@ export class RuntimeRunner {
                     : {}),
             };
         }
+        // O6: tune/disable the in-kernel repeat fuse (absent ⇒ kernel defaults: enabled, 5/8).
+        if (this.opts.repeatFuse !== undefined) {
+            const rf = this.opts.repeatFuse;
+            config.repeat_fuse = rf === false
+                ? { enabled: false, deny_after: 0, terminate_after: 0 }
+                : { enabled: true, deny_after: rf.denyAfter ?? 5, terminate_after: rf.terminateAfter ?? 8 };
+        }
+        // O4: turn-end criteria gate toggle (absent ⇒ kernel default: enabled).
+        if (this.opts.criteriaGate !== undefined) {
+            config.criteria_gate = this.opts.criteriaGate;
+        }
+        // K2: knowledge budget ratio (absent ⇒ kernel default 0.25; 0 disables).
+        if (this.opts.knowledgeBudgetRatio !== undefined) {
+            config.knowledge_budget_ratio = this.opts.knowledgeBudgetRatio;
+        }
         kernelApply(runtime, this.pendingObservations, { kind: "configure_run", config });
         if (this.opts.memoryPolicy) {
             const m = this.opts.memoryPolicy;
@@ -1110,7 +1273,8 @@ export class RuntimeRunner {
         if (!source)
             return null;
         while (!batchState.settled) {
-            const sig = await source.nextSignal();
+            // O2: injected notes participate in the monitor too (drain order matches nextInboundSignal).
+            const sig = this.injectedSignals.shift() ?? await source.nextSignal();
             if (batchState.settled)
                 break;
             if (!sig) {
@@ -1255,9 +1419,6 @@ export class RuntimeRunner {
             });
             if (!event)
                 continue;
-            if (obs.kind === "page_out" && obs.archived) {
-                this.localPageOutCache.push(...obs.archived);
-            }
             const compressedSeq = await this.opts.sessionLog.append(sessionId, event);
             if (event.kind === "compressed") {
                 nextArchiveStart = compressedSeq + 1;
@@ -1268,9 +1429,42 @@ export class RuntimeRunner {
                 && obs.archived.length > 0) {
                 void this.archiveSemanticPageOut(obs.archived, compressionAction(obs.action));
             }
+            // K4: a sprint renewal dropped the old history — including any earlier memory hits — so
+            // re-run the preQueryMemory prefetch for the new sprint (live observations only).
+            if (obs.kind === "renewed") {
+                await this.prefetchMemoryIntoHistory(runtime, "renewal");
+            }
         }
         return nextArchiveStart;
     }
+    /** I4 + K4: fetch long-term memory hits for the current goal and land them in `history` as an
+     *  ordinary user turn — single-use retrieval content that decays with the compression pyramid,
+     *  never pinned into `knowledge`. `phase: "initial"` = once before turn 1; `phase: "renewal"` =
+     *  re-fired after each sprint renewal (renewal drops the old history INCLUDING earlier memory
+     *  hits). Errs-open throughout. */
+    async prefetchMemoryIntoHistory(runtime, phase) {
+        if (!this.opts.preQueryMemory || !this.opts.dreamStore || !this.opts.agentId)
+            return;
+        try {
+            const queries = await this.opts.preQueryMemory({ goal: this.currentGoal, phase });
+            const lines = [];
+            for (const q of queries ?? []) {
+                if (typeof q !== "string" || !q.trim())
+                    continue;
+                const hits = await this.opts.dreamStore.search(this.opts.agentId, q, 5);
+                for (const hit of hits) {
+                    lines.push(`[memory score=${hit.score.toFixed(3)}] ${hit.text}`);
+                }
+            }
+            if (lines.length > 0) {
+                kernelApply(runtime, this.pendingObservations, {
+                    kind: "add_history_message",
+                    message: { role: "user", content: lines.join("\n") },
+                });
+            }
+        }
+        catch { /* errs-open */ }
+    }
     async archiveSemanticPageOut(archived, action) {
         if (!this.opts.dreamStore || !this.opts.agentId)
             return;

package/dist/runtime/sub-agent-orchestrator.js

@@ -19,7 +19,9 @@ function terminationFromStatus(status) {
         normalized === "timeout" ||
         normalized === "user_abort" ||
         normalized === "error" ||
-        normalized === "milestone_exceeded") {
+        normalized === "milestone_exceeded" ||
+        normalized === "context_overflow" ||
+        normalized === "no_progress") {
         return normalized;
     }
     return status;
@@ -72,6 +74,9 @@ export class SubAgentOrchestrator {
             provider: resolveProvider(ctx.parentOpts, ctx.spec.modelHint),
             // M4/G5: cap the child run at the node's token budget (falls back to the inherited cap).
             maxTotalTokens: ctx.spec.tokenBudget ?? ctx.parentOpts.maxTotalTokens,
+            // O3: per-child turn / wall-clock caps (fall back to the inherited limits).
+            maxTurns: ctx.spec.maxTurns ?? ctx.parentOpts.maxTurns,
+            timeoutMs: ctx.spec.maxWallMs ?? ctx.parentOpts.timeoutMs,
             executionPlane: filteredPlane,
             agentId: ctx.spec.identity.agentId,
             systemPrompt,

package/dist/runtime/types/agent.d.ts

@@ -2,7 +2,12 @@ import type { Message, ToolSchema } from "../../types.js";
 export type KernelAgentRole = "explore" | "plan" | "implement" | "verify" | "custom";
 export type AgentIsolation = "shared" | "read_only" | "worktree" | "remote";
 export type ContextInheritance = "none" | "system_only" | "full";
-export type TerminationReason = "completed" | "max_turns" | "token_budget" | "timeout" | "user_abort" | "error" | "milestone_exceeded";
+export type TerminationReason = "completed" | "max_turns" | "token_budget" | "timeout" | "user_abort" | "error" | "milestone_exceeded"
+/** v0.2.35 recovery ladder: compaction exhausted and the prompt still exceeds the provider window. */
+ | "context_overflow"
+/** Repeat-fuse escalation: the same tool call (name AND args) re-issued past `terminateAfter` —
+ *  a stall, distinct from `max_turns` which productive runs can also hit. */
+ | "no_progress";
 export type MilestonePolicy = "require_verifier" | "terminate" | "auto_pass";
 export interface AgentIdentity {
     agentId: string;
@@ -28,6 +33,10 @@ export interface AgentRunSpec {
     modelHint?: string;
     /** M4/G5: cumulative token cap for this sub-agent's run (sets the child kernel's `maxTotalTokens`). */
     tokenBudget?: number;
+    /** O3: per-child turn cap (sets the child runner's `maxTurns`; falls back to the parent's). */
+    maxTurns?: number;
+    /** O3: per-child wall-clock cap in ms (sets the child runner's `timeoutMs`; falls back to the parent's). */
+    maxWallMs?: number;
 }
 /** Kernel process-table observation (Phase 3 canonical spawn signal). */
 export interface AgentProcessChangedObservation {

package/dist/types.d.ts

@@ -73,7 +73,8 @@ export interface UsageEvent extends StreamEvent {
         system?: number;
         tools?: number;
         messages?: number;
-    };
+    }; /** Provider stop reason — `max_tokens` (Anthropic) / `length` (OpenAI) flag an output-cap truncation driving the kernel's max-output-tokens recovery. */
+    stopReason?: string;
 }
 export interface ThinkingDelta extends StreamEvent {
     type: "thinking_delta";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepstrike/wasm",
-  "version": "0.2.34",
+  "version": "0.2.36",
   "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.34"
+    "@deepstrike/wasm-kernel": "0.2.36"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",