@deepstrike/wasm 0.2.73 → 0.2.75

package/dist/agent.d.ts

@@ -1,8 +1,12 @@
-import type { AgentCapabilityFilter } from "./runtime/types/agent.js";
-import type { Memory, WorkingMemory } from "./memory/index.js";
+import type { AgentCapabilityFilter, WorkflowOutcome, WorkflowSpec } from "./runtime/types/agent.js";
+import type { Memory, WorkingMemory, MemoryRecord, MemoryRecall, MemoryKind } from "./memory/index.js";
 import type { RegisteredTool } from "./tools/index.js";
-import type { LLMProvider, StreamEvent } from "./types.js";
-import { type RuntimeOptions } from "./runtime/runner.js";
+import type { LLMProvider, StreamEvent, ContentPart } from "./types.js";
+import { RuntimeRunner } from "./runtime/runner.js";
+import { type ExecutionPlane } from "./runtime/execution-plane.js";
+import { type SessionEvent, type SessionLog } from "./runtime/session-log.js";
+import type { SignalSource } from "./signals/index.js";
+import type { McpExecutionPlane } from "./runtime/mcp-transport.js";
 type JsonSchema = Record<string, unknown>;
 export interface MemoryReference {
     kind?: "durable";
@@ -31,10 +35,7 @@ export type McpTransport = {
     command: string;
     args?: string[];
 } | {
-    kind: "http";
-    url: string;
-} | {
-    kind: "sse";
+    kind: "http" | "sse";
     url: string;
 } | {
     kind: "custom";
@@ -63,22 +64,7 @@ export interface Skill {
     providerOptions?: Record<string, unknown>;
 }
 export type KnowledgeSourceRef = {
-    kind: "file";
-    path: string;
-} | {
-    kind: "directory";
-    path: string;
-} | {
-    kind: "text";
-    content: string;
-} | {
-    kind: "url";
-    url: string;
-} | {
-    kind: "vector";
-    retriever: unknown;
-} | {
-    kind: "custom";
+    kind: "file" | "directory" | "text" | "url" | "vector" | "custom";
     [key: string]: unknown;
 };
 export interface Knowledge {
@@ -104,6 +90,16 @@ export interface Guardrail {
     description?: string;
     metadata?: Record<string, unknown>;
 }
+export interface AgentRuntimeBinding {
+    provider?: LLMProvider;
+    providerFor?: (model: string) => LLMProvider | undefined;
+    runtimeOptions?: Partial<import("./runtime/runner.js").RuntimeOptions>;
+    sessionLog?: SessionLog;
+    executionPlane?: ExecutionPlane;
+    mcpPlane?: McpExecutionPlane;
+    resolveAgent?: (name: string) => Agent | undefined | Promise<Agent | undefined>;
+    signalSource?: SignalSource;
+}
 export interface AgentOptions {
     name: string;
     description?: string;
@@ -120,16 +116,86 @@ export interface AgentOptions {
     outputSchema?: JsonSchema;
     metadata?: Record<string, unknown>;
     guardrails?: Guardrail[];
-    runtimeBinding?: {
-        provider?: LLMProvider;
-        providerFor?: (model: string) => LLMProvider | undefined;
-        runtimeOptions?: Partial<RuntimeOptions>;
-    };
+    runtimeBinding?: AgentRuntimeBinding;
+}
+export interface AgentRunOptions {
+    sessionId?: string;
+    maxTurns?: number;
+    maxTotalTokens?: number;
+    timeoutMs?: number;
+    metadata?: Record<string, unknown>;
+    providerOptions?: Record<string, unknown>;
+    attachments?: ContentPart[];
+    cancelSignal?: AbortSignal;
 }
 export interface AgentRunResult {
     output: string;
+    runId?: string;
     sessionId: string;
     status: "completed" | "partial" | "failed" | "cancelled";
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    };
+    outputValidation?: {
+        ok: boolean;
+        errors: string[];
+    };
+    evidence?: {
+        route?: unknown;
+        measurement?: unknown;
+        contextBinding?: unknown;
+    };
+}
+export interface MemoryInput {
+    name: string;
+    content: string;
+    description?: string;
+    kind?: MemoryKind;
+    confidence?: number;
+    pinned?: boolean;
+    ttlDays?: number;
+}
+export interface RecallOptions {
+    topK?: number;
+    kinds?: MemoryKind[];
+    minScore?: number;
+}
+export interface DelegationResult {
+    output: string;
+    status: "completed" | "partial" | "failed";
+}
+export declare class AgentSession {
+    private readonly owner;
+    readonly id: string;
+    private activeRunner?;
+    constructor(owner: Agent, id: string);
+    history(fromSeq?: number): Promise<{
+        seq: number;
+        event: SessionEvent;
+    }[]>;
+    latestSeq(): Promise<number>;
+    workflowTrace(): Promise<{
+        seq: number;
+        event: SessionEvent;
+    }[]>;
+    workflowReplay(): Promise<{
+        events: {
+            seq: number;
+            event: SessionEvent;
+        }[];
+        nodeOutcomes: Record<string, unknown>[];
+        completed: boolean;
+    }>;
+    private runner;
+    stream(goal: string, options?: Omit<AgentRunOptions, "sessionId">): AsyncIterable<StreamEvent>;
+    run(goal: string, options?: Omit<AgentRunOptions, "sessionId">): Promise<AgentRunResult>;
+    resume(options?: Omit<AgentRunOptions, "sessionId">): AsyncIterable<StreamEvent>;
+    interrupt(reason?: "user" | "deadline" | "lease_lost" | "host_shutdown"): void;
+    remember(input: MemoryInput): Promise<MemoryRecord>;
+    recall(query: string, options?: RecallOptions): Promise<MemoryRecall[]>;
+    workflow(spec: WorkflowSpec): Promise<WorkflowOutcome>;
 }
 export declare class Agent {
     readonly name: string;
@@ -147,14 +213,29 @@ export declare class Agent {
     readonly outputSchema?: JsonSchema;
     readonly metadata?: Record<string, unknown>;
     readonly guardrails?: Guardrail[];
-    readonly runtimeBinding?: AgentOptions["runtimeBinding"];
+    readonly runtimeBinding?: AgentRuntimeBinding;
+    readonly sessionLog: SessionLog;
+    private readonly sessions;
     constructor(options: AgentOptions);
-    run(goal: string, options?: {
-        sessionId?: string;
-        maxTurns?: number;
-    }): Promise<AgentRunResult>;
-    stream(goal: string, options?: {
+    session(id?: string): AgentSession;
+    createRunner(_goal: string, _sessionId: string, options?: AgentRunOptions): Promise<RuntimeRunner>;
+    run(goal: string, options?: AgentRunOptions): Promise<AgentRunResult>;
+    stream(goal: string, options?: AgentRunOptions): AsyncIterable<StreamEvent>;
+    resume(sessionId: string, options?: Omit<AgentRunOptions, "sessionId">): AsyncIterable<StreamEvent>;
+    interrupt(reason?: "user" | "deadline" | "lease_lost" | "host_shutdown", sessionId?: string): void;
+    workflow(spec: WorkflowSpec, options?: {
         sessionId?: string;
-    }): AsyncIterable<StreamEvent>;
+    }): Promise<WorkflowOutcome>;
+    remember(input: MemoryInput, sessionId?: string): Promise<MemoryRecord>;
+    recall(query: string, options?: RecallOptions, _sessionId?: string): Promise<MemoryRecall[]>;
+    delegate(request: {
+        target: AgentRef;
+        goal: string;
+        metadata?: Record<string, unknown>;
+        providerOptions?: Record<string, unknown>;
+    }): Promise<DelegationResult>;
+    listen(): Promise<AgentRunResult | null>;
+    close(): Promise<void>;
+    result(sessionId: string, events: StreamEvent[]): Promise<AgentRunResult>;
 }
 export {};

package/dist/agent.js

@@ -1,6 +1,99 @@
 import { RuntimeRunner } from "./runtime/runner.js";
 import { LocalExecutionPlane } from "./runtime/execution-plane.js";
 import { InMemorySessionLog } from "./runtime/session-log.js";
+import { extractJsonValue, validateAgainstSchema } from "./runtime/output-schema.js";
+import { checkMemoryWrite } from "./memory/authority.js";
+function statusOf(reason) {
+    if (["completed", "success", "done"].includes(reason))
+        return "completed";
+    if (["cancelled", "user", "user_abort", "deadline", "timeout"].includes(reason))
+        return "cancelled";
+    if (["failed", "error", "invalid_arg"].includes(reason))
+        return "failed";
+    return "partial";
+}
+export class AgentSession {
+    owner;
+    id;
+    activeRunner;
+    constructor(owner, id) {
+        this.owner = owner;
+        this.id = id;
+    }
+    history(fromSeq = 0) { return this.owner.sessionLog.read(this.id, fromSeq); }
+    latestSeq() { return this.owner.sessionLog.latestSeq(this.id); }
+    async workflowTrace() {
+        const kinds = new Set(["workflow_batch_spawned", "workflow_node_completed", "workflow_nodes_submitted", "workflow_completed"]);
+        return (await this.history()).filter(entry => kinds.has(entry.event.kind));
+    }
+    async workflowReplay() {
+        const events = await this.workflowTrace();
+        const outcomes = new Map();
+        let completed = false;
+        for (const entry of events) {
+            if (entry.event.kind === "workflow_node_completed") {
+                const id = entry.event.agent_id;
+                if (id)
+                    outcomes.set(id, entry.event);
+            }
+            if (entry.event.kind === "workflow_completed") {
+                completed = true;
+                for (const outcome of entry.event.node_outcomes) {
+                    const id = outcome.node_id;
+                    if (id)
+                        outcomes.set(id, outcome);
+                }
+            }
+        }
+        return { events, nodeOutcomes: [...outcomes.values()], completed };
+    }
+    runner(goal, options = {}) { return this.owner.createRunner(goal, this.id, options); }
+    async *stream(goal, options = {}) {
+        const runner = await this.runner(goal, { ...options, sessionId: this.id });
+        this.activeRunner = runner;
+        const abort = () => runner.interrupt("user");
+        if (options.cancelSignal?.aborted)
+            abort();
+        else
+            options.cancelSignal?.addEventListener("abort", abort, { once: true });
+        try {
+            yield* runner.run({ sessionId: this.id, goal, attachments: options.attachments, extensions: options.providerOptions });
+        }
+        finally {
+            options.cancelSignal?.removeEventListener("abort", abort);
+            this.activeRunner = undefined;
+        }
+    }
+    async run(goal, options = {}) {
+        const events = [];
+        for await (const event of this.stream(goal, options))
+            events.push(event);
+        return this.owner.result(this.id, events);
+    }
+    async *resume(options = {}) {
+        const runner = await this.runner("resume", { ...options, sessionId: this.id });
+        this.activeRunner = runner;
+        try {
+            yield* runner.wake(this.id, options.providerOptions);
+        }
+        finally {
+            this.activeRunner = undefined;
+        }
+    }
+    interrupt(reason = "user") { this.activeRunner?.interrupt(reason); }
+    remember(input) { return this.owner.remember(input, this.id); }
+    recall(query, options = {}) { return this.owner.recall(query, options, this.id); }
+    async workflow(spec) {
+        const runner = await this.runner("workflow", { sessionId: this.id });
+        this.activeRunner = runner;
+        try {
+            return await runner.runWorkflow(spec, { sessionId: this.id });
+        }
+        finally {
+            this.activeRunner = undefined;
+        }
+    }
+}
 export class Agent {
     name;
     description;
@@ -18,6 +111,8 @@ export class Agent {
     metadata;
     guardrails;
     runtimeBinding;
+    sessionLog;
+    sessions = new Map();
     constructor(options) {
         this.name = options.name;
         this.description = options.description;
@@ -35,44 +130,120 @@ export class Agent {
         this.metadata = options.metadata;
         this.guardrails = options.guardrails;
         this.runtimeBinding = options.runtimeBinding;
+        this.sessionLog = options.runtimeBinding?.sessionLog ?? options.runtimeBinding?.runtimeOptions?.sessionLog ?? new InMemorySessionLog();
     }
-    async run(goal, options = {}) {
+    session(id = `session-${crypto.randomUUID()}`) { if (!this.sessions.has(id))
+        this.sessions.set(id, new AgentSession(this, id)); return this.sessions.get(id); }
+    async createRunner(_goal, _sessionId, options = {}) {
         const binding = this.runtimeBinding;
         const provider = binding?.provider ?? (typeof this.model === "string" ? binding?.providerFor?.(this.model) : undefined);
         if (!provider)
             throw new Error(`agent "${this.name}" has no runtime provider binding`);
-        const runtime = new RuntimeRunner({
-            provider,
-            executionPlane: new LocalExecutionPlane(),
-            sessionLog: new InMemorySessionLog(),
-            maxTokens: 32_000,
-            agentId: this.name,
-            ...(this.instructions ? { systemPrompt: this.instructions } : {}),
-            ...(options.maxTurns !== undefined ? { maxTurns: options.maxTurns } : {}),
-            ...(binding?.runtimeOptions ?? {}),
-        });
-        const sessionId = options.sessionId ?? `session-${crypto.randomUUID()}`;
-        const events = [];
-        for await (const event of runtime.run({ sessionId, goal }))
-            events.push(event);
-        const output = events.filter(event => event.type === "text_delta").map(event => ("delta" in event ? String(event.delta) : "")).join("");
-        const failed = events.some(event => event.type === "error");
-        return { output, sessionId, status: failed ? "failed" : "completed" };
+        const base = { ...(binding?.runtimeOptions ?? {}) };
+        if (options.maxTurns !== undefined)
+            base.maxTurns = options.maxTurns;
+        if (options.maxTotalTokens !== undefined)
+            base.maxTotalTokens = options.maxTotalTokens;
+        if (options.timeoutMs !== undefined)
+            base.timeoutMs = options.timeoutMs;
+        if (options.providerOptions)
+            base.extensions = { ...(base.extensions ?? {}), ...options.providerOptions };
+        const mcpPlane = binding?.mcpPlane;
+        if (mcpPlane)
+            await mcpPlane.connect();
+        return new RuntimeRunner({ provider, executionPlane: binding?.executionPlane ?? mcpPlane ?? new LocalExecutionPlane(), sessionLog: this.sessionLog, maxTokens: 32_000, agentId: this.name, ...(this.instructions ? { systemPrompt: this.instructions } : {}), ...base });
     }
-    stream(goal, options = {}) {
-        const binding = this.runtimeBinding;
-        const provider = binding?.provider ?? (typeof this.model === "string" ? binding?.providerFor?.(this.model) : undefined);
-        if (!provider)
-            throw new Error(`agent "${this.name}" has no runtime provider binding`);
-        const runtime = new RuntimeRunner({
-            provider,
-            executionPlane: new LocalExecutionPlane(),
-            sessionLog: new InMemorySessionLog(),
-            maxTokens: 32_000,
-            agentId: this.name,
-            ...(this.instructions ? { systemPrompt: this.instructions } : {}),
-            ...(binding?.runtimeOptions ?? {}),
-        });
-        return runtime.run({ sessionId: options.sessionId ?? `session-${crypto.randomUUID()}`, goal });
+    async run(goal, options = {}) { return this.session(options.sessionId).run(goal, options); }
+    stream(goal, options = {}) { return this.session(options.sessionId).stream(goal, options); }
+    resume(sessionId, options = {}) { return this.session(sessionId).resume(options); }
+    interrupt(reason = "user", sessionId) { sessionId ? this.session(sessionId).interrupt(reason) : [...this.sessions.values()].forEach(s => s.interrupt(reason)); }
+    workflow(spec, options = {}) { return this.session(options.sessionId).workflow(spec); }
+    async remember(input, sessionId) {
+        if (!this.memory || typeof this.memory.put !== "function")
+            throw new Error(`agent "${this.name}" memory is not runtime-bound`);
+        const now = Date.now();
+        const record = {
+            record_id: crypto.randomUUID(), scope: this.memory.scope
+                ?? { tenant_id: "default", namespace: this.memory.namespace ?? this.name },
+            name: input.name, kind: input.kind ?? "reference", content: input.content,
+            description: input.description ?? input.name,
+            provenance: { author: "host", trust: "user_asserted", evidence_refs: [], session_id: sessionId ?? `memory-${crypto.randomUUID()}` },
+            created_at: now, updated_at: now, recall_count: 0, confidence: input.confidence ?? 1,
+            links: [], pinned: input.pinned ?? false, ...(input.ttlDays === undefined ? {} : { ttl_days: input.ttlDays }),
+        };
+        // §22.13 · the kernel's write rule, not a copy of it, decides whether this record may be stored.
+        const refusal = await checkMemoryWrite(undefined, record.name, record.content);
+        if (refusal)
+            throw new Error(`agent "${this.name}" memory write denied: ${refusal}`);
+        await this.memory.put(record);
+        return record;
+    }
+    async recall(query, options = {}, _sessionId) {
+        if (!this.memory || typeof this.memory.search !== "function")
+            throw new Error(`agent "${this.name}" memory is not runtime-bound`);
+        const records = await this.memory.search(query, { topK: options.topK ?? 8, kinds: options.kinds, minScore: options.minScore });
+        return records.map(record => ({ record, score: 1, why: "memory facade search" }));
+    }
+    async delegate(request) {
+        const targetName = typeof request.target === "string" ? request.target : request.target.name;
+        const declared = (this.handoffs ?? []).some(h => (typeof h.agent === "string" ? h.agent : h.agent.name) === targetName);
+        if (!declared)
+            throw new Error(`agent "${this.name}" cannot hand off to "${targetName}"`);
+        const resolver = this.runtimeBinding?.resolveAgent;
+        if (!resolver)
+            throw new Error(`agent "${this.name}" requires a host target resolver`);
+        const target = await resolver(targetName);
+        if (!target)
+            throw new Error(`target agent "${targetName}" is not registered`);
+        const result = await target.run(request.goal, { metadata: request.metadata, providerOptions: request.providerOptions });
+        return { output: result.output, status: result.status === "cancelled" ? "partial" : result.status };
+    }
+    async listen() {
+        const source = this.runtimeBinding?.signalSource;
+        if (!source)
+            throw new Error("agent signals require runtimeBinding.signalSource");
+        const claim = await source.claimSignal();
+        if (!claim)
+            return null;
+        const goal = String(claim.signal.payload.goal ?? claim.signal.payload.summary ?? JSON.stringify(claim.signal.payload));
+        try {
+            const result = await this.run(goal);
+            await source.ackSignal(claim);
+            return result;
+        }
+        catch (error) {
+            await source.nackSignal(claim);
+            throw error;
+        }
+    }
+    async close() { await this.runtimeBinding?.mcpPlane?.disconnect(); }
+    async result(sessionId, events) {
+        const entries = await this.sessionLog.read(sessionId);
+        const started = [...entries].reverse().find(e => e.event.kind === "run_started")?.event;
+        const terminal = [...entries].reverse().find(e => e.event.kind === "run_terminal")?.event;
+        const output = events.filter((e) => e.type === "text_delta" && "delta" in e).map(e => String(e.delta)).join("");
+        const usage = [...events].reverse().find((e) => e.type === "usage");
+        const result = { output, runId: started?.kind === "run_started" ? started.run_id : undefined, sessionId, status: statusOf(terminal?.kind === "run_terminal" ? terminal.reason : events.some(e => e.type === "error") ? "error" : "completed") };
+        const attempt = [...entries].reverse().find(e => e.event.kind === "provider_attempt")?.event;
+        if (usage)
+            result.usage = { inputTokens: usage.inputTokens ?? 0, outputTokens: usage.outputTokens ?? 0, totalTokens: usage.totalTokens };
+        else if (attempt?.kind === "provider_attempt" && attempt.usage) {
+            result.usage = { inputTokens: attempt.usage.inputTokens, outputTokens: attempt.usage.outputTokens, totalTokens: attempt.usage.inputTokens + attempt.usage.outputTokens };
+        }
+        const measured = [...entries].reverse().find(e => e.event.kind === "prompt_measured")?.event;
+        const prepared = [...entries].reverse().find(e => e.event.kind === "context_prepared")?.event;
+        if ((started?.kind === "run_started" && started.route) || (attempt?.kind === "provider_attempt" && attempt.route) || measured || prepared) {
+            result.evidence = {
+                ...((attempt?.kind === "provider_attempt" ? attempt.route : started?.kind === "run_started" ? started.route : undefined) ? { route: attempt?.kind === "provider_attempt" ? attempt.route : started.route } : {}),
+                ...(measured?.kind === "prompt_measured" ? { measurement: measured.measurement } : {}),
+                ...(prepared?.kind === "context_prepared" ? { contextBinding: prepared.preparation.binding } : {}),
+            };
+        }
+        if (this.outputSchema) {
+            result.outputValidation = validateAgainstSchema(extractJsonValue(output), this.outputSchema);
+            if (!result.outputValidation.ok && result.status === "completed")
+                result.status = "failed";
+        }
+        return result;
     }
 }

package/dist/governance.d.ts

@@ -12,16 +12,11 @@ export interface GovernancePolicy {
         windowMs: number;
     }[];
     constraints?: GovernanceConstraint[];
-    /** I5: when true (default), the runner pre-filters denied tools out of the schema. */
+    /** I5: when true (default), the kernel withholds statically denied tools (vetoes and `deny`
+     *  rules, evaluated exactly as the call gate evaluates them) from the provider surface and names
+     *  them once in the knowledge slot. Mirrors Node. */
     surfaceDeniedInSystem?: boolean;
 }
-/** I5: bucket tools into allowed/denied per the policy. Pure. Mirrors Node. */
-export declare function governanceFilterSchema<T extends {
-    name: string;
-}>(tools: T[], policy: GovernancePolicy | undefined): {
-    allowed: T[];
-    denied: string[];
-};
 export type GovernanceConstraint = {
     kind: "required";
     tool: string;
@@ -38,5 +33,34 @@ export type GovernanceConstraint = {
     min?: number;
     max?: number;
 };
-export declare function governancePolicyToKernelEvent(policy: GovernancePolicy): Record<string, unknown>;
+export declare function governancePolicyToKernelEvent(policy: GovernancePolicy): Record<string, unknown> & {
+    rate_limits: Array<{
+        tool: string;
+        max_calls: number;
+        window_ms: number;
+    }>;
+};
+/** A §13.2 live-policy patch replacing the governance posture, for `RuntimeRunner.applyPolicyPatch`. */
+export declare function governancePolicyPatch(policy: GovernancePolicy): {
+    kind: "replace_governance_policy";
+    policy: Record<string, unknown>;
+};
+/** A §13.2 live policy patch in kernel vocabulary — the closed set of policies that may change
+ *  while an operation runs. Use `governancePolicyPatch` to build the governance variant. */
+export type LivePolicyPatch = {
+    kind: "replace_signal_policy";
+    policy: Record<string, unknown>;
+} | {
+    kind: "replace_governance_policy";
+    policy: Record<string, unknown>;
+} | {
+    kind: "replace_recovery_policy";
+    policy: Record<string, unknown>;
+} | {
+    kind: "tighten_resource_quota";
+    max_concurrent_subagents?: number;
+    max_total_subagents?: number;
+    max_spawn_depth?: number;
+    max_workflow_nodes?: number;
+};
 export {};

package/dist/governance.js

@@ -1,29 +1,4 @@
 // ─── Declarative policy (in-kernel gate) ──────────────────────────────────────
-/** I5: bucket tools into allowed/denied per the policy. Pure. Mirrors Node. */
-export function governanceFilterSchema(tools, policy) {
-    if (!policy)
-        return { allowed: tools, denied: [] };
-    const vetoes = new Set(policy.vetoes ?? []);
-    const allowed = [];
-    const denied = [];
-    const matches = (pat, name) => pat === name || (pat.endsWith("*") && name.startsWith(pat.slice(0, -1)));
-    for (const tool of tools) {
-        if (vetoes.has(tool.name)) {
-            denied.push(tool.name);
-            continue;
-        }
-        let action = policy.defaultAction ?? "allow";
-        for (const r of policy.rules ?? []) {
-            if (matches(r.pattern, tool.name))
-                action = r.action;
-        }
-        if (action === "deny")
-            denied.push(tool.name);
-        else
-            allowed.push(tool);
-    }
-    return { allowed, denied };
-}
 export function governancePolicyToKernelEvent(policy) {
     return {
         kind: "load_governance_policy",
@@ -36,9 +11,31 @@ export function governancePolicyToKernelEvent(policy) {
             window_ms: rl.windowMs,
         })),
         constraints: (policy.constraints ?? []).map(c => c.kind === "enum"
-            ? { kind: "enum", tool: c.tool, path: c.path, values: c.values }
+            ? { kind: "enum", tool: c.tool, param_path: c.path, values: c.values }
             : c.kind === "range"
-                ? { kind: "range", tool: c.tool, path: c.path, ...(c.min !== undefined ? { min: c.min } : {}), ...(c.max !== undefined ? { max: c.max } : {}) }
-                : { kind: "required", tool: c.tool, path: c.path }),
+                ? {
+                    kind: "range", tool: c.tool, param_path: c.path,
+                    // The wire carries fixed-point micro-units so a bound replays byte-identically.
+                    ...(c.min !== undefined ? { min_micros: toMicros(c.min) } : {}),
+                    ...(c.max !== undefined ? { max_micros: toMicros(c.max) } : {}),
+                }
+                : { kind: "required", tool: c.tool, param_path: c.path }),
+        hide_denied_tools: policy.surfaceDeniedInSystem !== false,
     };
 }
+/** A §13.2 live-policy patch replacing the governance posture, for `RuntimeRunner.applyPolicyPatch`. */
+export function governancePolicyPatch(policy) {
+    const { kind: _kind, ...wire } = governancePolicyToKernelEvent(policy);
+    return {
+        kind: "replace_governance_policy",
+        policy: {
+            ...wire,
+            rate_limits: wire.rate_limits.map(limit => ({ ...limit, window_ms: String(limit.window_ms) })),
+        },
+    };
+}
+function toMicros(value) {
+    if (!Number.isFinite(value))
+        throw new RangeError(`governance range bound must be finite, got ${value}`);
+    return Math.round(value * 1_000_000);
+}

package/dist/index.d.ts

@@ -14,15 +14,16 @@ export type { AgentCapabilityFilter, AgentIdentity, AgentIsolation, AgentRunSpec
 export { workflowSpecToKernel, workflowNodeSpecToKernel, submitWorkflowNodesTool, startWorkflowTool, fanoutSynthesize, generateAndFilter, genEval, verifyRules } from "./runtime/types/agent.js";
 export { loopInstruction, classifyInstruction, judgeGoal, extractClassifyBranch, extractJudgeWinner, } from "./runtime/workflow-control-flow.js";
 export { Agent } from "./agent.js";
-export type { AgentMemory, AgentOptions, AgentRunResult, AgentToolDefinition, AgentRef, Guardrail, Handoff, Knowledge, KnowledgeSourceRef, MCPServer, McpTransport, MemoryReference, ModelRef, ModelRequirement, Skill, } from "./agent.js";
-export { lowerAgent, normalizeAgent } from "./agent-ir.js";
-export type { AgentCapabilityIR, AgentDefinition, AgentLoweringInputs, AgentMemoryIR, AgentSpec, AgentToolIR, } from "./agent-ir.js";
+export { McpExecutionPlane } from "./runtime/mcp-transport.js";
+export type { McpConnection, McpConnectionFactory, McpCredentialVault, McpServerConfig } from "./runtime/mcp-transport.js";
+export type { AgentMemory, AgentOptions, AgentRunResult, AgentRunOptions, AgentToolDefinition, AgentRef, Guardrail, Handoff, Knowledge, KnowledgeSourceRef, MCPServer, McpTransport, MemoryReference, ModelRef, ModelRequirement, Skill, MemoryInput, RecallOptions, DelegationResult, AgentRuntimeBinding, AgentSession, } from "./agent.js";
 export { AnthropicProvider } from "./providers/anthropic.js";
 export { OpenAIProvider, qwen, deepseek, minimax, kimi } from "./providers/openai.js";
 export type { OpenAIProviderOptions, BackendProviderOptions } from "./providers/openai.js";
 export { ProviderError, classifyProviderError } from "./providers/provider-error.js";
 export type { ProviderErrorKind, ProviderErrorOptions } from "./providers/provider-error.js";
-export type { GovernancePolicy, GovernanceConstraint } from "./governance.js";
+export type { GovernancePolicy, GovernanceConstraint, LivePolicyPatch } from "./governance.js";
+export { governancePolicyPatch } from "./governance.js";
 export { tool, executeTools } from "./tools/index.js";
 export type { RegisteredTool, ToolExecContext } from "./tools/index.js";
 export { safeTool, ok, fail, ToolError, formatToolError } from "./tools/errors.js";

package/dist/index.js

@@ -10,10 +10,11 @@ export { SubAgentOrchestrator, defaultSubAgentOrchestrator, spawnStandalone } fr
 export { workflowSpecToKernel, workflowNodeSpecToKernel, submitWorkflowNodesTool, startWorkflowTool, fanoutSynthesize, generateAndFilter, genEval, verifyRules } from "./runtime/types/agent.js";
 export { loopInstruction, classifyInstruction, judgeGoal, extractClassifyBranch, extractJudgeWinner, } from "./runtime/workflow-control-flow.js";
 export { Agent } from "./agent.js";
-export { lowerAgent, normalizeAgent } from "./agent-ir.js";
+export { McpExecutionPlane } from "./runtime/mcp-transport.js";
 export { AnthropicProvider } from "./providers/anthropic.js";
 export { OpenAIProvider, qwen, deepseek, minimax, kimi } from "./providers/openai.js";
 export { ProviderError, classifyProviderError } from "./providers/provider-error.js";
+export { governancePolicyPatch } from "./governance.js";
 export { tool, executeTools } from "./tools/index.js";
 export { safeTool, ok, fail, ToolError, formatToolError } from "./tools/errors.js";
 export { WorkingMemory } from "./memory/index.js";

package/dist/memory/authority.d.ts

@@ -0,0 +1,30 @@
+import type { MemoryRecall, MemoryRecallLifecycle } from "./index.js";
+/**
+ * §22.13 · the kernel's memory authority for a host with no live operation.
+ *
+ * Inside a run, every memory decision is a kernel transition (`admit_memory_write`, and the
+ * `memory_recalled` / `promotion_suggested` facts a query resolution journals). With no run — an
+ * explicit `remember`, a session extract after the run ended — the host asks the same kernel
+ * functions statelessly. The SDK keeps no copy of the validation rule and never computes a recall
+ * count itself.
+ */
+/** The canonical wire `MemoryPolicy` (the `u64` threshold travels as a decimal string). */
+export interface KernelMemoryPolicyWire {
+    stale_warning_days?: number;
+    retrieval_top_k?: number;
+    validation_enabled?: boolean;
+    max_content_bytes?: number;
+    max_name_length?: number;
+    promotion_recall_threshold?: string;
+}
+export interface MemoryPromotion {
+    record_id: string;
+    recall_count: number;
+}
+/** Would the kernel admit this write? Resolves to the refusal reason, or `undefined` when admitted. */
+export declare function checkMemoryWrite(policy: KernelMemoryPolicyWire | undefined, name: string, content: string): Promise<string | undefined>;
+/** Derive one recall's lifecycle from the counts the store reported it held. */
+export declare function deriveMemoryRecall(policy: KernelMemoryPolicyWire | undefined, recalledAt: number, hits: MemoryRecall[]): Promise<{
+    recalls: MemoryRecallLifecycle[];
+    promotions: MemoryPromotion[];
+}>;