@deepstrike/wasm 0.2.2 → 0.2.6

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

@@ -65,7 +65,7 @@ export interface KernelObservation {
     phase_id?: string;
     capabilities_unlocked?: string[];
     evidence?: string[];
-    reason?: RollbackReason;
+    reason?: RollbackReason | string;
     agent_id?: string;
     parent_session_id?: string;
     role?: string;
@@ -73,6 +73,26 @@ export interface KernelObservation {
     context_inheritance?: string;
     permitted_capability_ids?: string[];
     history_len?: number;
+    tier_hint?: string;
+    call_id?: string;
+    tool?: string;
+    signal_id?: string;
+    disposition?: string;
+    queue_depth?: number;
+    budget?: string;
+    pending_calls?: string[];
+    approved?: string[];
+    denied?: string[];
+    original_size?: number;
+    preview_size?: number;
+    memory_id?: string;
+    memory_kind?: string;
+    size_bytes?: number;
+    query_context?: string;
+    requested_k?: number;
+    requires_async_response?: boolean;
+    /** memory_validation_failed (Phase 7). */
+    error?: string;
 }
 export declare function toolSchemaToKernel(schema: ToolSchema): Record<string, unknown>;
 export declare function skillMetadataToKernel(skill: SkillMetadata): Record<string, unknown>;
@@ -84,5 +104,7 @@ export declare function capabilitySkill(skill: SkillMetadata): Record<string, un
 export declare function capabilityMarker(kind: string, id: string, description: string): Record<string, unknown>;
 export declare function kernelApply(runtime: KernelRuntimeHandle, pending: KernelObservation[], event: Record<string, unknown>): KernelObservation[];
 export declare function kernelAction(runtime: KernelRuntimeHandle, pending: KernelObservation[], event: Record<string, unknown>): KernelRunnerAction;
+/** Like kernelAction but tolerates zero-action steps (e.g. queued signals). */
+export declare function kernelMaybeAction(runtime: KernelRuntimeHandle, pending: KernelObservation[], event: Record<string, unknown>): KernelRunnerAction | null;
 export declare function forceCompact(runtime: KernelRuntimeHandle, pending: KernelObservation[]): boolean;
 export {};

package/dist/runtime/kernel-step.js

@@ -114,6 +114,8 @@ function kernelMessageToSdk(raw) {
 function renderedContextToSdk(raw) {
     return {
         systemText: String(raw.system_text ?? raw.systemText ?? ""),
+        systemStable: String(raw.system_stable ?? raw.systemStable ?? ""),
+        systemKnowledge: String(raw.system_knowledge ?? raw.systemKnowledge ?? ""),
         turns: (raw.turns ?? []).map(kernelMessageToSdk),
     };
 }
@@ -176,6 +178,13 @@ export function kernelAction(runtime, pending, event) {
         throw new Error("kernel transition must return one action");
     return mapKernelAction(raw);
 }
+/** Like kernelAction but tolerates zero-action steps (e.g. queued signals). */
+export function kernelMaybeAction(runtime, pending, event) {
+    const step = parseStep(runtime.step(stepInput(event)));
+    pending.push(...step.observations);
+    const raw = step.actions[0];
+    return raw ? mapKernelAction(raw) : null;
+}
 export function forceCompact(runtime, pending) {
     return kernelApply(runtime, pending, { kind: "force_compact" }).some(o => o.kind === "compressed");
 }

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,30 @@
+import type { GovernancePolicy } from "../governance.js";
+export type OsProfileId = "native";
+export interface NativeOsProfile {
+    id: OsProfileId;
+    attentionPolicy: {
+        maxQueueSize?: number;
+    };
+    governancePolicy: GovernancePolicy;
+}
+/** 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;
+/** Default restrictive sandbox policy template requiring confirmation for modification/execution. */
+export declare const DEFAULT_SANDBOX_POLICY: GovernancePolicy;
+/** Resolve a named OS profile into concrete kernel-owned policy defaults. */
+export declare function osProfile(profile?: OsProfileId | NativeOsProfile): NativeOsProfile;
+/** Assert that a runtime is using a valid native microkernel policy profile. */
+export declare function assertNativeProfile(profile?: OsProfileId | NativeOsProfile): NativeOsProfile;
+/**
+ * Validates the declarative policies statically to prevent runtime crashes when loaded into the microkernel.
+ */
+export declare function validateDeclarativePolicy(govPolicy?: GovernancePolicy, attentionPolicy?: {
+    maxQueueSize?: number;
+}): {
+    valid: boolean;
+    errors: string[];
+};

package/dist/runtime/os-profile.js

@@ -0,0 +1,71 @@
+/** 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" }],
+};
+/** Default restrictive sandbox policy template requiring confirmation for modification/execution. */
+export const DEFAULT_SANDBOX_POLICY = {
+    rules: [
+        { pattern: "read_file", action: "allow" },
+        { pattern: "write_file", action: "ask_user" },
+        { pattern: "run_command", action: "ask_user" },
+        { pattern: "*", action: "deny" },
+    ],
+};
+/** Resolve a named OS profile into concrete kernel-owned policy defaults. */
+export function osProfile(profile = "native") {
+    if (typeof profile !== "string")
+        return profile;
+    if (profile !== "native")
+        throw new Error(`Unsupported OS profile: ${profile}`);
+    return {
+        id: "native",
+        attentionPolicy: DEFAULT_NATIVE_ATTENTION_POLICY,
+        governancePolicy: DEFAULT_NATIVE_GOVERNANCE_POLICY,
+    };
+}
+/** Assert that a runtime is using a valid native microkernel policy profile. */
+export function assertNativeProfile(profile = "native") {
+    const resolved = osProfile(profile);
+    if (resolved.id !== "native") {
+        throw new Error(`Unsupported OS profile: ${resolved.id}`);
+    }
+    const validation = validateDeclarativePolicy(resolved.governancePolicy, resolved.attentionPolicy);
+    if (!validation.valid) {
+        throw new Error(`Invalid native OS profile: ${validation.errors.join("; ")}`);
+    }
+    return resolved;
+}
+/**
+ * Validates the declarative policies statically to prevent runtime crashes when loaded into the microkernel.
+ */
+export function validateDeclarativePolicy(govPolicy, attentionPolicy) {
+    const errors = [];
+    if (govPolicy) {
+        if (!Array.isArray(govPolicy.rules)) {
+            errors.push("GovernancePolicy rules must be an array");
+        }
+        else {
+            govPolicy.rules.forEach((rule, idx) => {
+                if (!rule.pattern || typeof rule.pattern !== "string") {
+                    errors.push(`Rule[${idx}] pattern is missing or not a string`);
+                }
+                if (!["allow", "deny", "ask_user"].includes(rule.action)) {
+                    errors.push(`Rule[${idx}] action '${rule.action}' is invalid. Allowed: allow, deny, ask_user`);
+                }
+            });
+        }
+    }
+    if (attentionPolicy) {
+        if (attentionPolicy.maxQueueSize !== undefined) {
+            if (typeof attentionPolicy.maxQueueSize !== "number" || attentionPolicy.maxQueueSize <= 0) {
+                errors.push("AttentionPolicy maxQueueSize must be a positive integer");
+            }
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}

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,44 @@
-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 { type NativeOsProfile, type OsProfileId } from "./os-profile.js";
+import { LargeResultSpool } from "./large-result-spool.js";
+export interface MemoryWriteRateLimit {
+    maxWrites: number;
+    windowMs: number;
+}
+export interface ResourceQuota {
+    /** Max sub-agents in the `running` state at once; further spawns are denied while at cap. */
+    maxConcurrentSubagents?: number;
+    /** Max sub-agent nesting depth (direct children of the root loop are depth 1). */
+    maxSpawnDepth?: number;
+    /** Rolling-window memory-write rate limit: at most `maxWrites` per any `windowMs` span. */
+    memoryWritesPerWindow?: MemoryWriteRateLimit;
+}
+export interface SchedulerBudget {
+    maxWallMs?: number;
+}
+/**
+ * Long-term memory policy (`set_memory_policy`) — opt-in, kernel-enforced. `validationEnabled:
+ * false` admits writes without validation, `maxContentBytes` / `maxNameLength` override the
+ * validation limits, and `retrievalTopK` caps `query_memory` breadth. `memoryPath` /
+ * `staleWarningDays` are carried for SDK recall I/O. Omitted fields keep the kernel defaults.
+ */
+export interface MemoryPolicy {
+    memoryPath?: string;
+    staleWarningDays?: number;
+    retrievalTopK?: number;
+    validationEnabled?: boolean;
+    maxContentBytes?: number;
+    maxNameLength?: number;
+}
 export interface RuntimeOptions {
     provider: LLMProvider;
     sessionLog: SessionLog;
@@ -24,8 +55,19 @@ export interface RuntimeOptions {
     knowledgeSource?: KnowledgeSource;
     signalSource?: SignalSource;
     extensions?: Record<string, unknown>;
-    governance?: Governance;
+    /** Named or concrete OS profile. Defaults to the native microkernel profile. */
+    osProfile?: OsProfileId | NativeOsProfile;
+    governancePolicy?: GovernancePolicy;
+    attentionPolicy?: {
+        maxQueueSize?: number;
+    };
+    schedulerBudget?: SchedulerBudget;
+    resourceQuota?: ResourceQuota;
+    memoryPolicy?: MemoryPolicy;
+    tokenizer?: string;
+    enablePlanTool?: boolean;
     onToolSuspend?: (event: ToolSuspendEvent) => Promise<unknown> | unknown;
+    onPermissionRequest?: (event: PermissionRequestEvent) => Promise<PermissionResponse | boolean> | PermissionResponse | boolean;
     subAgentOrchestrator?: SubAgentOrchestrator;
     milestonePolicy?: MilestonePolicy;
     milestoneContract?: MilestoneContract;
@@ -35,6 +77,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 +89,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 +105,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>;