@deepstrike/wasm 0.2.2 → 0.2.5

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

@@ -0,0 +1,49 @@
+export interface ToolResult {
+    callId: string;
+    tool: string;
+    output: string;
+    isError?: boolean;
+}
+export interface SpooledToolResult {
+    originalOutput: string;
+    preview: string;
+    spoolRef: string;
+    wasSpooled: boolean;
+}
+export interface SpoolConfig {
+    spoolThresholdBytes: number;
+    previewTokens: number;
+    totalMessageLimitBytes: number;
+    maxAgeMs?: number;
+    driver?: SpoolStorageDriver;
+}
+export interface SpoolStorageDriver {
+    write(key: string, content: string): Promise<void> | void;
+    read(key: string): Promise<string> | string;
+    delete(key: string): Promise<void> | void;
+    list(): Promise<string[]> | string[];
+    mtime?(key: string): Promise<number> | number;
+}
+export declare class MemorySpoolDriver implements SpoolStorageDriver {
+    private cache;
+    write(key: string, content: string): Promise<void>;
+    read(key: string): Promise<string>;
+    delete(key: string): Promise<void>;
+    list(): Promise<string[]>;
+    mtime(key: string): Promise<number>;
+}
+export declare const DEFAULT_SPOOL_CONFIG: SpoolConfig;
+export declare class LargeResultSpool {
+    private config;
+    private driver;
+    private activeWrites;
+    constructor(config?: Partial<SpoolConfig>);
+    private needsSpool;
+    private getSpoolKey;
+    private writeToDriver;
+    private generatePreview;
+    processToolResult(result: ToolResult): Promise<SpooledToolResult>;
+    persistOutput(callId: string, content: string): Promise<string>;
+    readSpooledResult(spoolRef: string): Promise<string>;
+    cleanup(maxAgeMs?: number): Promise<number>;
+}

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

@@ -0,0 +1,137 @@
+export class MemorySpoolDriver {
+    cache = new Map();
+    async write(key, content) {
+        this.cache.set(key, { content, mtime: Date.now() });
+    }
+    async read(key) {
+        const val = this.cache.get(key);
+        if (!val)
+            throw new Error(`Spooled result not found: ${key}`);
+        return val.content;
+    }
+    async delete(key) {
+        this.cache.delete(key);
+    }
+    async list() {
+        return Array.from(this.cache.keys());
+    }
+    async mtime(key) {
+        return this.cache.get(key)?.mtime ?? 0;
+    }
+}
+export const DEFAULT_SPOOL_CONFIG = {
+    spoolThresholdBytes: 50 * 1024, // 50KB
+    previewTokens: 500, // ~2KB
+    totalMessageLimitBytes: 200 * 1024, // 200KB
+};
+function simpleHash(content) {
+    let hash = 5381;
+    for (let i = 0; i < content.length; i++) {
+        hash = (hash * 33) ^ content.charCodeAt(i);
+    }
+    return (hash >>> 0).toString(16);
+}
+export class LargeResultSpool {
+    config;
+    driver;
+    activeWrites = new Map();
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_SPOOL_CONFIG, ...config };
+        this.driver = this.config.driver ?? new MemorySpoolDriver();
+    }
+    needsSpool(result) {
+        return result.output.length > this.config.spoolThresholdBytes;
+    }
+    getSpoolKey(hash) {
+        return `.spool/${hash}.txt`;
+    }
+    async writeToDriver(content, hash) {
+        const key = this.getSpoolKey(hash);
+        let promise = this.activeWrites.get(key);
+        if (!promise) {
+            promise = (async () => {
+                try {
+                    await this.driver.write(key, content);
+                    return key;
+                }
+                finally {
+                    this.activeWrites.delete(key);
+                }
+            })();
+            this.activeWrites.set(key, promise);
+        }
+        return promise;
+    }
+    generatePreview(content) {
+        const previewTokens = Math.min(this.config.previewTokens, content.length / 4);
+        const preview = content.substring(0, previewTokens);
+        const omitted = content.length - previewTokens;
+        return `[tool_result_spooled]
+size: ${content.length} bytes
+preview: first ${previewTokens} chars
+omitted: ${omitted} chars
+[full content available via Read tool]
+`;
+    }
+    async processToolResult(result) {
+        if (!this.needsSpool(result)) {
+            return {
+                originalOutput: result.output,
+                preview: result.output,
+                spoolRef: "",
+                wasSpooled: false,
+            };
+        }
+        const hash = simpleHash(result.output);
+        const spoolRef = await this.writeToDriver(result.output, hash);
+        const preview = this.generatePreview(result.output);
+        return {
+            originalOutput: result.output,
+            preview,
+            spoolRef,
+            wasSpooled: true,
+        };
+    }
+    async persistOutput(callId, content) {
+        const hash = simpleHash(content);
+        const key = `.spool/${callId}-${hash.slice(0, 16)}.txt`;
+        let promise = this.activeWrites.get(key);
+        if (!promise) {
+            promise = (async () => {
+                try {
+                    await this.driver.write(key, content);
+                    return key;
+                }
+                finally {
+                    this.activeWrites.delete(key);
+                }
+            })();
+            this.activeWrites.set(key, promise);
+        }
+        return promise;
+    }
+    async readSpooledResult(spoolRef) {
+        return this.driver.read(spoolRef);
+    }
+    async cleanup(maxAgeMs) {
+        const limit = maxAgeMs ?? this.config.maxAgeMs ?? 7 * 24 * 60 * 60 * 1000;
+        try {
+            const keys = await this.driver.list();
+            let count = 0;
+            const now = Date.now();
+            for (const key of keys) {
+                if (this.driver.mtime) {
+                    const mtime = await this.driver.mtime(key);
+                    if (now - mtime > limit) {
+                        await this.driver.delete(key);
+                        count++;
+                    }
+                }
+            }
+            return count;
+        }
+        catch {
+            return 0;
+        }
+    }
+}

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

@@ -0,0 +1,7 @@
+import type { GovernancePolicy } from "../governance.js";
+/** Default attention policy for native profile smoke tests. */
+export declare const DEFAULT_NATIVE_ATTENTION_POLICY: {
+    maxQueueSize: number;
+};
+/** Permissive governance policy for native runs that do not need AskUser. */
+export declare const DEFAULT_NATIVE_GOVERNANCE_POLICY: GovernancePolicy;

package/dist/runtime/os-profile.js

@@ -0,0 +1,6 @@
+/** Default attention policy for native profile smoke tests. */
+export const DEFAULT_NATIVE_ATTENTION_POLICY = { maxQueueSize: 64 };
+/** Permissive governance policy for native runs that do not need AskUser. */
+export const DEFAULT_NATIVE_GOVERNANCE_POLICY = {
+    rules: [{ pattern: "*", action: "allow" }],
+};

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

@@ -0,0 +1,31 @@
+import type { SessionEvent } from "./session-log.js";
+export interface OsSnapshot {
+    lastSuspend?: {
+        turn: number;
+        reason: string;
+        pending_calls: string[];
+    };
+    lastResumedTurn?: number;
+    processByAgent: Array<{
+        turn: number;
+        agent_id: string;
+        parent_session_id: string;
+        state: string;
+    }>;
+    budgetExceeded: Array<{
+        turn: number;
+        budget: string;
+    }>;
+    signals: Array<{
+        turn: number;
+        signal_id: string;
+        disposition: string;
+        queue_depth: number;
+    }>;
+    pageOutCount: number;
+    pageInCount: number;
+    spoolCount: number;
+    toolGatedCount: number;
+}
+export declare function rebuildOsSnapshotFromSessionEvents(events: SessionEvent[]): OsSnapshot;
+export declare function sessionLogHasRequiredCategories(events: SessionEvent[]): boolean;

package/dist/runtime/os-snapshot.js

@@ -0,0 +1,108 @@
+import { categoryForKind, primitiveForKind } from "./kernel-event-log.js";
+const KERNEL_KINDS = new Set([
+    "compressed",
+    "page_out",
+    "page_in",
+    "large_result_spooled",
+    "capability_changed",
+    "context_renewed",
+    "suspended",
+    "resumed",
+    "tool_gated",
+    "signal_disposed",
+    "budget_exceeded",
+    "checkpoint_taken",
+    "rollbacked",
+    "agent_process_changed",
+    "milestone_advanced",
+    "milestone_blocked",
+    "milestone_evidence",
+]);
+export function rebuildOsSnapshotFromSessionEvents(events) {
+    const snap = {
+        processByAgent: [],
+        budgetExceeded: [],
+        signals: [],
+        pageOutCount: 0,
+        pageInCount: 0,
+        spoolCount: 0,
+        toolGatedCount: 0,
+    };
+    const index = new Map();
+    for (const event of events) {
+        if (!KERNEL_KINDS.has(event.kind) && event.kind !== "suspended" && event.kind !== "resumed") {
+            continue;
+        }
+        switch (event.kind) {
+            case "suspended":
+                snap.lastSuspend = {
+                    turn: event.turn,
+                    reason: event.reason,
+                    pending_calls: event.pending_calls ?? [],
+                };
+                break;
+            case "resumed":
+                snap.lastResumedTurn = event.turn;
+                break;
+            case "tool_gated":
+                snap.toolGatedCount += 1;
+                break;
+            case "agent_process_changed": {
+                const record = {
+                    turn: event.turn,
+                    agent_id: event.agent_id,
+                    parent_session_id: event.parent_session_id,
+                    state: event.state ?? "running",
+                };
+                const idx = index.get(event.agent_id);
+                if (idx !== undefined)
+                    snap.processByAgent[idx] = record;
+                else {
+                    index.set(event.agent_id, snap.processByAgent.length);
+                    snap.processByAgent.push(record);
+                }
+                break;
+            }
+            case "budget_exceeded":
+                snap.budgetExceeded.push({ turn: event.turn, budget: event.budget });
+                break;
+            case "signal_disposed":
+                snap.signals.push({
+                    turn: event.turn,
+                    signal_id: event.signal_id,
+                    disposition: event.disposition,
+                    queue_depth: event.queue_depth,
+                });
+                break;
+            case "page_out":
+                snap.pageOutCount += 1;
+                break;
+            case "page_in":
+                snap.pageInCount += 1;
+                break;
+            case "large_result_spooled":
+                snap.spoolCount += 1;
+                break;
+            default:
+                break;
+        }
+    }
+    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,13 +1,14 @@
-import type { LLMProvider, Message, StreamEvent } from "../types.js";
+import type { LLMProvider, Message, StreamEvent, PermissionRequestEvent, PermissionResponse, 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";
 import type { SignalSource } from "../signals/index.js";
 import type { SessionLog, SessionEvent } from "./session-log.js";
 import type { ExecutionPlane } from "./execution-plane.js";
-import type { Governance } from "../governance.js";
+import { type GovernancePolicy } from "../governance.js";
 import type { AgentRunSpec, SubAgentResult, MilestonePolicy, MilestoneContract, MilestoneCheckResult } from "./types/agent.js";
 import { type SubAgentOrchestrator } from "./sub-agent-orchestrator.js";
+import { LargeResultSpool } from "./large-result-spool.js";
 export interface RuntimeOptions {
     provider: LLMProvider;
     sessionLog: SessionLog;
@@ -24,8 +25,12 @@ export interface RuntimeOptions {
     knowledgeSource?: KnowledgeSource;
     signalSource?: SignalSource;
     extensions?: Record<string, unknown>;
-    governance?: Governance;
+    governancePolicy?: GovernancePolicy;
+    attentionPolicy?: {
+        maxQueueSize?: number;
+    };
     onToolSuspend?: (event: ToolSuspendEvent) => Promise<unknown> | unknown;
+    onPermissionRequest?: (event: PermissionRequestEvent) => Promise<PermissionResponse | boolean> | PermissionResponse | boolean;
     subAgentOrchestrator?: SubAgentOrchestrator;
     milestonePolicy?: MilestonePolicy;
     milestoneContract?: MilestoneContract;
@@ -35,6 +40,10 @@ export interface RuntimeOptions {
         requiredEvidence: string[];
     }) => Promise<MilestoneCheckResult> | MilestoneCheckResult;
     runSpec?: AgentRunSpec;
+    dreamProvider?: LLMProvider;
+    dreamSummarizer?: DreamSummarizer;
+    dreamSystemPrompt?: string;
+    resultSpool?: LargeResultSpool;
 }
 export declare class RuntimeRunner {
     private readonly opts;
@@ -43,6 +52,8 @@ export declare class RuntimeRunner {
     private activeKernel;
     private currentSessionId;
     private nextArchiveStart;
+    private localPageOutCache;
+    private pendingSpoolOutputs;
     constructor(opts: RuntimeOptions);
     get hostOptions(): RuntimeOptions;
     interrupt(): void;
@@ -57,11 +68,15 @@ export declare class RuntimeRunner {
         }>;
     }): AsyncIterable<StreamEvent>;
     wake(sessionId: string, extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
-    /** Push a large artifact into the kernel artifacts partition (not inlined in history). */
-    pushArtifact(message: Message, tokens?: number): void;
+    /** 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;
+    private resolveKernelSuspend;
     dream(agentId: string, nowMs?: number): Promise<DreamResult>;
     private execute;
     spawnSubAgent(spec: AgentRunSpec): Promise<SubAgentResult>;
     private appendObservations;
+    private archiveSemanticPageOut;
 }
 export declare function collectText(stream: AsyncIterable<StreamEvent>): Promise<string>;