@deepstrike/sdk 0.1.16 → 0.2.1

package/dist/collaboration/harness.d.ts

@@ -1,4 +1,4 @@
-import type { AgentPool } from "./pool.js";
+import type { AgentPool, CoordinatorConfig } from "./pool.js";
 import type { VerificationContract, ContractCheckResult } from "./contract.js";
 import type { HandoffArtifact } from "./handoff.js";
 export interface Violation {
@@ -17,6 +17,8 @@ export interface ContractOutcome {
 export interface ContractHarnessOptions {
     maxAttempts?: number;
     onViolation?: (violations: Violation[]) => void;
+    /** When set with pool.configureCoordinator(), enables kernel spawn path. */
+    coordinator?: CoordinatorConfig;
 }
 /**
  * ContractDrivenHarness — the core multi-agent execution primitive.
@@ -41,6 +43,7 @@ export declare class ContractDrivenHarness {
     private maxAttempts;
     private onViolation?;
     constructor(pool: AgentPool, contract: VerificationContract, options?: ContractHarnessOptions);
+    stream(): AsyncIterable<ContractOutcome>;
     run(): Promise<ContractOutcome>;
     private _findViolations;
     private _formatViolationsForFeedback;

package/dist/collaboration/harness.js

@@ -28,6 +28,12 @@ export class ContractDrivenHarness {
         this.contract = contract;
         this.maxAttempts = options.maxAttempts ?? 3;
         this.onViolation = options.onViolation;
+        if (options.coordinator) {
+            this.pool.configureCoordinator(options.coordinator.opts, options.coordinator.sessionId);
+        }
+    }
+    async *stream() {
+        yield await this.run();
     }
     async run() {
         let artifact = "";
@@ -43,14 +49,22 @@ export class ContractDrivenHarness {
                 ? `\n\n[Previous attempt failed. Violations to fix:\n${this._formatViolationsForFeedback(checkResults)}]`
                 : "";
             const executorGoal = `${contractBlock}\n\n---\n\n${currentGoal}${violationNote}`;
-            artifact = await collectText(this.pool.get("executor").run({
-                sessionId: crypto.randomUUID(),
-                goal: executorGoal,
-                criteria: contractToCriteriaStrings(this.contract),
-            }));
+            if (this.pool.usesSpawnPath()) {
+                const execResult = await this.pool.spawn("executor", executorGoal, {
+                    verificationContractId: this.contract.id,
+                });
+                artifact = execResult.result.finalMessage?.content ?? "";
+            }
+            else {
+                artifact = await collectText(this.pool.get("executor").run({
+                    sessionId: crypto.randomUUID(),
+                    goal: executorGoal,
+                    criteria: contractToCriteriaStrings(this.contract),
+                }));
+            }
             // ── Phase 2: Verifier ──────────────────────────────────────────────────
             // Verifier sees: artifact + contract only. No executor history.
-            const auditText = await this.pool.runVerifier({ contract: this.contract, artifact });
+            const auditText = await this.pool.verify({ contract: this.contract, artifact });
             // ── Phase 3: Parse audit → ContractCheckResult[] ──────────────────────
             checkResults = this._parseAuditText(auditText);
             const violations = this._findViolations(checkResults);

package/dist/collaboration/modes/creator-verifier.d.ts

@@ -9,8 +9,8 @@ export interface CreatorVerifierMetrics {
 /**
  * CreatorVerifierMode — the simplest multi-agent collaboration pattern.
  *
- * Wires an executor + verifier from an AgentPool into a ContractDrivenHarness.
- * The executor creates, the verifier audits. Contexts are fully isolated.
+ * By default uses the kernel spawn path via `pool.ensureCoordinator()`.
+ * Pass `useLegacyRunners: true` to fall back to independent runner sessions.
  *
  * Usage:
  * ```ts
@@ -33,6 +33,10 @@ export declare class CreatorVerifierMode {
     private _failed;
     constructor(pool: AgentPool, options?: {
         maxAttempts?: number;
+        /** Stable orchestration session for kernel lineage audit. */
+        coordinatorSessionId?: string;
+        /** Opt out of kernel spawn path and use legacy independent runner sessions. */
+        useLegacyRunners?: boolean;
     });
     run(contract: VerificationContract): Promise<ContractOutcome>;
     /** Aggregate drift metrics across all runs through this mode instance. */
@@ -59,6 +63,8 @@ export declare class OrchestrationMode {
     private inner;
     constructor(pool: AgentPool, options?: {
         maxAttempts?: number;
+        coordinatorSessionId?: string;
+        useLegacyRunners?: boolean;
     });
     run(goal: string): Promise<ContractOutcome & {
         contract: VerificationContract;

package/dist/collaboration/modes/creator-verifier.js

@@ -2,8 +2,8 @@ import { ContractDrivenHarness } from "../harness.js";
 /**
  * CreatorVerifierMode — the simplest multi-agent collaboration pattern.
  *
- * Wires an executor + verifier from an AgentPool into a ContractDrivenHarness.
- * The executor creates, the verifier audits. Contexts are fully isolated.
+ * By default uses the kernel spawn path via `pool.ensureCoordinator()`.
+ * Pass `useLegacyRunners: true` to fall back to independent runner sessions.
  *
  * Usage:
  * ```ts
@@ -30,6 +30,9 @@ export class CreatorVerifierMode {
     }
     async run(contract) {
         this._total++;
+        if (!this.options.useLegacyRunners) {
+            this.pool.ensureCoordinator(this.options.coordinatorSessionId);
+        }
         const harness = new ContractDrivenHarness(this.pool, contract, {
             maxAttempts: this.options.maxAttempts ?? 3,
         });
@@ -78,8 +81,11 @@ export class OrchestrationMode {
         this.inner = new CreatorVerifierMode(pool, options);
     }
     async run(goal) {
+        if (!this.options.useLegacyRunners) {
+            this.pool.ensureCoordinator(this.options.coordinatorSessionId);
+        }
         // Step 1: orchestrator produces a VerificationContract
-        const contractJson = await this.pool.runOrchestrator(goal);
+        const contractJson = await this.pool.orchestrate(goal);
         const contract = this._parseContract(contractJson, goal);
         // Step 2: CreatorVerifierMode executes against the contract
         const outcome = await this.inner.run(contract);

package/dist/collaboration/pool.d.ts

@@ -1,15 +1,36 @@
-import type { RuntimeRunner } from "../runtime/runner.js";
+import type { RuntimeOptions, RuntimeRunner } from "../runtime/runner.js";
 import type { VerificationContract } from "./contract.js";
+import type { AgentRunSpec, KernelAgentRole, SubAgentResult } from "../types/agent.js";
+/** Legacy pool roles — mapped to kernel AgentRole when using spawn path. */
 export type AgentRole = "orchestrator" | "executor" | "verifier";
+export declare const KERNEL_ROLE_MAP: Record<AgentRole, KernelAgentRole>;
 export interface IsolatedVerifierContext {
     contract: VerificationContract;
     artifact: string;
 }
+export interface CoordinatorConfig {
+    opts: RuntimeOptions;
+    sessionId: string;
+}
 export declare class AgentPool {
     private runners;
+    private coordinator?;
     add(role: AgentRole, runner: RuntimeRunner): this;
+    /** Enable kernel spawn path with lineage recorded under `sessionId`. */
+    configureCoordinator(opts: RuntimeOptions, sessionId: string): this;
+    /**
+     * Infer coordinator from a registered runner (executor → orchestrator → verifier).
+     * Idempotent when coordinator is already configured.
+     */
+    ensureCoordinator(sessionId?: string): this;
+    usesSpawnPath(): boolean;
     has(role: AgentRole): boolean;
     get(role: AgentRole): RuntimeRunner;
-    runVerifier(ctx: IsolatedVerifierContext): Promise<string>;
-    runOrchestrator(goal: string): Promise<string>;
+    /**
+     * Spawn a kernel-isolated sub-agent. Requires `configureCoordinator()`.
+     * Maps legacy pool roles to kernel roles (executor → implement, etc.).
+     */
+    spawn(role: AgentRole | KernelAgentRole, goal: string, extra?: Partial<Omit<AgentRunSpec, "identity" | "role" | "goal">>): Promise<SubAgentResult>;
+    verify(ctx: IsolatedVerifierContext): Promise<string>;
+    orchestrate(goal: string): Promise<string>;
 }

package/dist/collaboration/pool.js

@@ -1,11 +1,41 @@
 import { collectText } from "../runtime/runner.js";
+import { spawnStandalone } from "../runtime/sub-agent-orchestrator.js";
 import { formatContractForSystemPrompt } from "./contract.js";
+import { agentIdentitySub } from "../types/agent.js";
+export const KERNEL_ROLE_MAP = {
+    orchestrator: "plan",
+    executor: "implement",
+    verifier: "verify",
+};
 export class AgentPool {
     runners = new Map();
+    coordinator;
     add(role, runner) {
         this.runners.set(role, runner);
         return this;
     }
+    /** Enable kernel spawn path with lineage recorded under `sessionId`. */
+    configureCoordinator(opts, sessionId) {
+        this.coordinator = { opts, sessionId };
+        return this;
+    }
+    /**
+     * Infer coordinator from a registered runner (executor → orchestrator → verifier).
+     * Idempotent when coordinator is already configured.
+     */
+    ensureCoordinator(sessionId) {
+        if (this.coordinator)
+            return this;
+        const source = this.has("executor")
+            ? "executor"
+            : this.has("orchestrator")
+                ? "orchestrator"
+                : "verifier";
+        return this.configureCoordinator(this.get(source).hostOptions, sessionId ?? crypto.randomUUID());
+    }
+    usesSpawnPath() {
+        return this.coordinator !== undefined;
+    }
     has(role) {
         return this.runners.has(role);
     }
@@ -15,8 +45,24 @@ export class AgentPool {
             throw new Error(`AgentPool: no runner registered for role "${role}"`);
         return runner;
     }
-    async runVerifier(ctx) {
-        const runner = this.get("verifier");
+    /**
+     * Spawn a kernel-isolated sub-agent. Requires `configureCoordinator()`.
+     * Maps legacy pool roles to kernel roles (executor → implement, etc.).
+     */
+    async spawn(role, goal, extra) {
+        if (!this.coordinator) {
+            throw new Error("AgentPool.configureCoordinator() required for kernel spawn path");
+        }
+        const kernelRole = role in KERNEL_ROLE_MAP ? KERNEL_ROLE_MAP[role] : role;
+        const spec = {
+            identity: agentIdentitySub(`${kernelRole}-${crypto.randomUUID()}`, crypto.randomUUID(), this.coordinator.sessionId),
+            role: kernelRole,
+            goal,
+            ...extra,
+        };
+        return spawnStandalone(this.coordinator.opts, this.coordinator.sessionId, spec);
+    }
+    async verify(ctx) {
         const contractBlock = formatContractForSystemPrompt(ctx.contract);
         const auditGoal = [
             contractBlock, "",
@@ -29,10 +75,17 @@ export class AgentPool {
             "List any anti-patterns you detected.",
             "Conclude with an overall PASS or FAIL verdict.",
         ].join("\n");
+        if (this.coordinator) {
+            const result = await this.spawn("verify", auditGoal, {
+                verificationContractId: ctx.contract.id,
+                isolation: "read_only",
+            });
+            return result.result.finalMessage?.content ?? "";
+        }
+        const runner = this.get("verifier");
         return collectText(runner.run({ sessionId: crypto.randomUUID(), goal: auditGoal }));
     }
-    async runOrchestrator(goal) {
-        const runner = this.get("orchestrator");
+    async orchestrate(goal) {
         const orchestratorGoal = [
             `You are a planning orchestrator. Decompose the following goal into a VerificationContract.`,
             ``,
@@ -49,6 +102,13 @@ export class AgentPool {
             ``,
             `Output ONLY the JSON object, no prose.`,
         ].join("\n");
-        return collectText(runner.run({ sessionId: crypto.randomUUID(), goal: orchestratorGoal }));
+        if (this.coordinator) {
+            const result = await this.spawn("plan", orchestratorGoal);
+            return result.result.finalMessage?.content ?? "";
+        }
+        return collectText(this.get("orchestrator").run({
+            sessionId: crypto.randomUUID(),
+            goal: orchestratorGoal,
+        }));
     }
 }

package/dist/harness/harness.d.ts

@@ -1,5 +1,6 @@
 import type { RuntimeRunner } from "../runtime/runner.js";
 import { collectText } from "../runtime/runner.js";
+import type { StreamEvent } from "../types.js";
 export interface Criterion {
     text: string;
     required: boolean;
@@ -75,6 +76,7 @@ export declare class SinglePassHarness {
     private runner;
     constructor(runner: RuntimeRunner);
     run(request: HarnessRequest): Promise<HarnessOutcome>;
+    stream(request: HarnessRequest): AsyncIterable<StreamEvent>;
 }
 export declare class EvalLoopHarness {
     private runner;
@@ -82,6 +84,7 @@ export declare class EvalLoopHarness {
     private maxAttempts;
     constructor(runner: RuntimeRunner, gate: QualityGate, maxAttempts?: number);
     run(request: HarnessRequest): Promise<HarnessOutcome>;
+    stream(request: HarnessRequest): AsyncIterable<StreamEvent>;
 }
 export interface HarnessLoopOptions {
     maxAttempts?: number;
@@ -93,6 +96,7 @@ export declare class HarnessLoop {
     private maxAttempts;
     private skillDir?;
     constructor(runner: RuntimeRunner, evalProvider: import("../types.js").LLMProvider, options?: HarnessLoopOptions);
-    runStreaming(request: HarnessRequest): AsyncIterable<HarnessEvent>;
+    run(request: HarnessRequest): Promise<HarnessOutcome>;
+    stream(request: HarnessRequest): AsyncIterable<HarnessEvent>;
 }
 export { collectText };

package/dist/harness/harness.js

@@ -22,6 +22,9 @@ export class SinglePassHarness {
     async run(request) {
         return { ...await runOnce(this.runner, request), passed: true };
     }
+    async *stream(request) {
+        yield* this.runner.run({ sessionId: crypto.randomUUID(), goal: request.goal, criteria: request.criteria?.map(c => c.text), extensions: request.extensions });
+    }
 }
 export class EvalLoopHarness {
     runner;
@@ -41,6 +44,9 @@ export class EvalLoopHarness {
         }
         return outcome;
     }
+    async *stream(request) {
+        yield* this.runner.run({ sessionId: crypto.randomUUID(), goal: request.goal, criteria: request.criteria?.map(c => c.text), extensions: request.extensions });
+    }
 }
 export class HarnessLoop {
     runner;
@@ -53,7 +59,23 @@ export class HarnessLoop {
         this.maxAttempts = options.maxAttempts ?? 3;
         this.skillDir = options.skillDir;
     }
-    async *runStreaming(request) {
+    async run(request) {
+        let last;
+        for await (const evt of this.stream(request))
+            last = evt;
+        const done = last?.type === "done" ? last : undefined;
+        return {
+            result: "",
+            passed: done?.verdict.passed ?? false,
+            iterations: done?.iterations ?? 0,
+            totalTokens: done?.totalTokens ?? 0,
+            status: done?.status ?? "error",
+            overallScore: done?.verdict.overallScore,
+            feedback: done?.verdict.feedback,
+            details: done?.verdict.details,
+        };
+    }
+    async *stream(request) {
         const kernel = getKernel();
         const pipeline = new kernel.EvalPipeline({ extractSkillOnPass: true });
         const criteria = request.criteria ?? [];

package/dist/index.d.ts

@@ -1,9 +1,14 @@
 export { RuntimeRunner, collectText } from "./runtime/runner.js";
 export type { RuntimeOptions } from "./runtime/runner.js";
+export { FilteredExecutionPlane } from "./runtime/filtered-plane.js";
+export { SubAgentOrchestrator, defaultSubAgentOrchestrator, spawnStandalone } from "./runtime/sub-agent-orchestrator.js";
+export type { SubAgentRunContext } from "./runtime/sub-agent-orchestrator.js";
 export { LocalExecutionPlane } from "./runtime/execution-plane.js";
 export type { ExecutionPlane, RunContext } from "./runtime/execution-plane.js";
 export { InMemorySessionLog, FileSessionLog } from "./runtime/session-log.js";
 export type { SessionLog, SessionEvent } from "./runtime/session-log.js";
+export { NullArchiveStore, FileArchiveStore } from "./runtime/archive.js";
+export type { ArchiveStore } from "./runtime/archive.js";
 export { EnvCredentialVault, InMemoryCredentialVault, ChainedCredentialVault } from "./runtime/credential-vault.js";
 export type { CredentialVault } from "./runtime/credential-vault.js";
 export { ProcessSandboxPlane } from "./runtime/process-sandbox-plane.js";
@@ -45,10 +50,13 @@ export type { GovernanceVerdict } from "./governance.js";
 export { SinglePassHarness, EvalLoopHarness, HarnessLoop } from "./harness/harness.js";
 export type { HarnessRequest, HarnessOutcome, HarnessLoopOptions, QualityGate } from "./harness/harness.js";
 export type { Message, ToolCall, ToolResult, ToolSchema, ContentPart, TextPart, ImagePart, AudioPart, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolChunk, ToolDeltaEvent, ToolSuspendEvent, ToolResultEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, LLMProvider, RetryConfig, TokenUsage, ProviderToolSpec, ProviderRunState, ProviderReplay, RenderedContext, } from "./types.js";
+export type { AgentCapabilityFilter, AgentIdentity, AgentIsolation, AgentRunSpec, AgentSpawnedObservation, ContextInheritance, KernelAgentRole, LoopResult, MilestoneCheckResult, MilestoneContract, MilestonePhase, MilestonePolicy, SubAgentResult, TerminationReason, } from "./types/agent.js";
+export { agentIdentitySub, agentRunSpecToKernel, milestoneCheckFail, milestoneCheckPass, milestoneCheckResultToKernel, subAgentResultToKernel, } from "./types/agent.js";
 export type { AcceptanceCriterion, VerificationContract, ContractCheckResult, } from "./collaboration/contract.js";
 export { ContractBuilder, formatContractForSystemPrompt, contractToCriteriaStrings, } from "./collaboration/contract.js";
 export { AgentPool } from "./collaboration/pool.js";
-export type { AgentRole, IsolatedVerifierContext } from "./collaboration/pool.js";
+export type { AgentRole, IsolatedVerifierContext, CoordinatorConfig } from "./collaboration/pool.js";
+export { KERNEL_ROLE_MAP } from "./collaboration/pool.js";
 export { ContractDrivenHarness } from "./collaboration/harness.js";
 export type { ContractOutcome, ContractHarnessOptions, Violation } from "./collaboration/harness.js";
 export { HandoffBus } from "./collaboration/handoff.js";

package/dist/index.js

@@ -1,7 +1,10 @@
 // ── Runtime (Layer 1.5) ────────────────────────────────────────────────────
 export { RuntimeRunner, collectText } from "./runtime/runner.js";
+export { FilteredExecutionPlane } from "./runtime/filtered-plane.js";
+export { SubAgentOrchestrator, defaultSubAgentOrchestrator, spawnStandalone } from "./runtime/sub-agent-orchestrator.js";
 export { LocalExecutionPlane } from "./runtime/execution-plane.js";
 export { InMemorySessionLog, FileSessionLog } from "./runtime/session-log.js";
+export { NullArchiveStore, FileArchiveStore } from "./runtime/archive.js";
 export { EnvCredentialVault, InMemoryCredentialVault, ChainedCredentialVault } from "./runtime/credential-vault.js";
 export { ProcessSandboxPlane } from "./runtime/process-sandbox-plane.js";
 export { McpProxyPlane } from "./runtime/mcp-proxy-plane.js";
@@ -32,8 +35,10 @@ export { PermissionManager, PermissionMode } from "./safety/permissions.js";
 export { Governance } from "./governance.js";
 // ── Harness ────────────────────────────────────────────────────────────────
 export { SinglePassHarness, EvalLoopHarness, HarnessLoop } from "./harness/harness.js";
+export { agentIdentitySub, agentRunSpecToKernel, milestoneCheckFail, milestoneCheckPass, milestoneCheckResultToKernel, subAgentResultToKernel, } from "./types/agent.js";
 export { ContractBuilder, formatContractForSystemPrompt, contractToCriteriaStrings, } from "./collaboration/contract.js";
 export { AgentPool } from "./collaboration/pool.js";
+export { KERNEL_ROLE_MAP } from "./collaboration/pool.js";
 export { ContractDrivenHarness } from "./collaboration/harness.js";
 export { HandoffBus } from "./collaboration/handoff.js";
 export { CreatorVerifierMode, OrchestrationMode } from "./collaboration/modes/creator-verifier.js";

package/dist/kernel.d.ts

@@ -1,5 +1,4 @@
-import type { Message, RenderedContext, ToolCall, ToolResult, ToolSchema } from "./types.js";
-import type { SkillMetadata } from "./skills/loader.js";
+import type { Message, RenderedContext } from "./types.js";
 export interface GovernanceVerdict {
     kind: "allow" | "deny" | "rate_limited" | "ask_user";
     reason?: string;
@@ -26,45 +25,6 @@ export interface RuntimeSignal {
     dedupeKey?: string;
     timestampMs: number;
 }
-export interface LoopAction {
-    kind: "call_llm" | "execute_tools" | "done";
-    context?: RenderedContext;
-    tools?: ToolSchema[];
-    calls?: ToolCall[];
-    result?: {
-        termination: string;
-        turnsUsed: number;
-        totalTokensUsed: bigint;
-    };
-}
-interface LoopObservation {
-    kind: "compressed";
-    action?: string;
-    rhoAfter?: number;
-}
-interface LoopStateMachineInstance {
-    setAvailableSkills(skills: SkillMetadata[]): void;
-    setMemoryEnabled(enabled: boolean): void;
-    setKnowledgeEnabled(enabled: boolean): void;
-    addSystemMessage(content: string, tokens: number): void;
-    addMemoryMessage(content: string, tokens: number): void;
-    addHistoryMessage(message: Message, tokens: number): void;
-    setTools(tools: ToolSchema[]): void;
-    start(task: {
-        goal: string;
-        criteria: string[];
-    }): LoopAction;
-    resumeAfterPreload(): LoopAction;
-    feedLlmResponse(message: Message): LoopAction;
-    feedToolResults(results: ToolResult[]): LoopAction;
-    feedTimeout(): LoopAction;
-    isTerminal(): boolean;
-    preloadHistory(messages: Message[]): void;
-    drainNewMessages(): Message[];
-    readonly turn: number;
-    pressure(): number;
-    takeObservations(): LoopObservation[];
-}
 interface SignalRouterInstance {
     ingest(signal: RuntimeSignal, isRunning: boolean): string;
     next(): RuntimeSignal | null;
@@ -135,14 +95,23 @@ interface IdlePipelineInstance {
     }>, nowMs: number): IdlePipelineAction;
     feedSynthesisResult(content: string): IdlePipelineAction;
 }
+export interface KernelRuntimeInstance {
+    step(inputJson: string): string;
+    isTerminal(): boolean;
+    turn(): number;
+    recoveryContentBytes(): number;
+    render(): RenderedContext;
+    drainNewMessages(): Message[];
+    preservedRefs(): string[];
+}
 interface KernelModule {
     Governance: new (defaultAction?: "allow" | "deny" | "ask_user") => GovernanceInstance;
-    LoopStateMachine: new (policy: {
+    KernelRuntime: new (policy: {
         maxTokens: number;
         maxTurns?: number;
         maxTotalTokens?: bigint;
         timeoutMs?: bigint;
-    }) => LoopStateMachineInstance;
+    }) => KernelRuntimeInstance;
     SignalRouter: new (maxQueueSize: number) => SignalRouterInstance;
     EvalPipeline: new (options?: {
         extractSkillOnPass?: boolean;

package/dist/kernel.js

@@ -5,7 +5,7 @@ import { fileURLToPath } from "node:url";
 const cjsRequire = createRequire(import.meta.url);
 let cachedKernel;
 function resolveCoreModule() {
-    const localCore = join(dirname(fileURLToPath(import.meta.url)), "../../../crates/deepstrike-node");
+    const localCore = join(dirname(fileURLToPath(import.meta.url)), "../../crates/deepstrike-node");
     if (existsSync(join(localCore, "index.js")))
         return localCore;
     return "@deepstrike/core";

package/dist/providers/anthropic.js

@@ -22,7 +22,9 @@ export class AnthropicProvider {
     constructor(apiKey, model = "claude-sonnet-4-6", retry = { maxRetries: 3, baseDelay: 1000 }, options = {}) {
         this.model = model;
         this.client = withServerRuntimeGuard(() => new Anthropic({
-            ...(options.authMode === "bearer" ? { authToken: apiKey } : { apiKey }),
+            ...(options.authMode === "bearer"
+                ? { authToken: apiKey, apiKey: null }
+                : { apiKey, authToken: null }),
             ...(options.baseURL ? { baseURL: options.baseURL } : {}),
         }));
         this.circuit = new CircuitBreaker();

package/dist/runtime/archive.d.ts

@@ -0,0 +1,15 @@
+import type { Message } from "../types.js";
+export interface ArchiveStore {
+    write(sessionId: string, seq: number, messages: Message[]): Promise<string>;
+    read(archiveRef: string): Promise<Message[]>;
+}
+export declare class NullArchiveStore implements ArchiveStore {
+    write(_sessionId: string, _seq: number, _messages: Message[]): Promise<string>;
+    read(_archiveRef: string): Promise<Message[]>;
+}
+export declare class FileArchiveStore implements ArchiveStore {
+    private readonly root;
+    constructor(root: string);
+    write(sessionId: string, seq: number, messages: Message[]): Promise<string>;
+    read(archiveRef: string): Promise<Message[]>;
+}

package/dist/runtime/archive.js

@@ -0,0 +1,35 @@
+import { mkdir, writeFile, readFile } from "node:fs/promises";
+import { join } from "node:path";
+export class NullArchiveStore {
+    async write(_sessionId, _seq, _messages) {
+        return "";
+    }
+    async read(_archiveRef) {
+        throw new Error("NullArchiveStore does not store archives");
+    }
+}
+export class FileArchiveStore {
+    root;
+    constructor(root) {
+        this.root = root;
+    }
+    async write(sessionId, seq, messages) {
+        const dir = join(this.root, sessionId);
+        await mkdir(dir, { recursive: true });
+        const filePath = join(dir, `${seq}.jsonl`);
+        const lines = messages.map(msg => JSON.stringify(msg)).join("\n") + "\n";
+        await writeFile(filePath, lines, "utf8");
+        return filePath;
+    }
+    async read(archiveRef) {
+        const content = await readFile(archiveRef, "utf8");
+        const lines = content.split("\n");
+        const messages = [];
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            messages.push(JSON.parse(line));
+        }
+        return messages;
+    }
+}

package/dist/runtime/execution-plane.js

@@ -23,7 +23,7 @@ export class LocalExecutionPlane {
                 ctx.governance.setTime?.(BigInt(Date.now()));
                 const v = ctx.governance.evaluate(c.name, c.arguments);
                 if (v.kind === "deny") {
-                    yield { type: "error", message: `permission denied: ${c.name} — ${v.reason ?? ""}` };
+                    yield { type: "tool_denied", callId: c.id, toolName: c.name, reason: v.reason ?? "" };
                     yield { type: "tool_result", callId: c.id, name: c.name, content: `permission denied: ${v.reason ?? ""}`, isError: true };
                     continue;
                 }
@@ -81,7 +81,15 @@ export class LocalExecutionPlane {
                 const task = active[index];
                 if (result.done) {
                     const r = result.value;
-                    yield { type: "tool_result", callId: r.callId, name: task.call.name, content: r.output, isError: r.isError };
+                    yield {
+                        type: "tool_result",
+                        callId: r.callId,
+                        name: task.call.name,
+                        content: r.output,
+                        isError: r.isError,
+                        isFatal: r.isFatal,
+                        errorKind: r.errorKind,
+                    };
                     active.splice(index, 1);
                     continue;
                 }
@@ -96,9 +104,19 @@ export class LocalExecutionPlane {
             return { callId: call.id, output: `unknown tool: ${call.name}`, isError: true };
         try {
             const args = JSON.parse(call.arguments || "{}");
-            const err = validateToolArguments(registered.schema.parameters, args);
-            if (err)
-                return { callId: call.id, output: `invalid arguments: ${err}`, isError: true };
+            const originalArgsStr = JSON.stringify(args);
+            const validation = validateToolArguments(registered.schema.parameters, args);
+            if (validation.error)
+                return { callId: call.id, output: `invalid arguments: ${validation.error}`, isError: true };
+            if (validation.repaired) {
+                yield {
+                    type: "tool_argument_repaired",
+                    callId: call.id,
+                    name: call.name,
+                    originalArguments: originalArgsStr,
+                    repairedArguments: JSON.stringify(args),
+                };
+            }
             const output = await registered.execute(args);
             if (isAsyncIterable(output)) {
                 let combined = "";
@@ -132,7 +150,13 @@ export class LocalExecutionPlane {
             return { callId: call.id, output, isError: false };
         }
         catch (err) {
-            return { callId: call.id, output: String(err), isError: true };
+            return {
+                callId: call.id,
+                output: String(err),
+                isError: true,
+                isFatal: Boolean(err?.isFatal),
+                errorKind: err?.errorKind,
+            };
         }
     }
 }

package/dist/runtime/filtered-plane.d.ts

@@ -0,0 +1,14 @@
+import type { ToolCall, ToolSchema, StreamEvent } from "../types.js";
+import type { RegisteredTool } from "../tools/index.js";
+import type { ExecutionPlane, RunContext } from "./execution-plane.js";
+/** Wraps an execution plane, allowing only manifest-permitted tool IDs (+ meta-tools). */
+export declare class FilteredExecutionPlane implements ExecutionPlane {
+    private readonly inner;
+    private readonly permittedIds;
+    private readonly metaTools;
+    constructor(inner: ExecutionPlane, permittedIds: Set<string>, metaTools?: Set<string>);
+    register(...tools: RegisteredTool[]): this;
+    unregister(name: string): this;
+    schemas(): ToolSchema[];
+    executeAll(calls: ToolCall[], ctx: RunContext): AsyncIterable<StreamEvent>;
+}