@deepstrike/sdk 0.2.52 → 0.2.61

package/dist/collaboration/pool.js

@@ -1,109 +1,49 @@
-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());
+    /** Assert that this pool has one canonical kernel coordinator. */
+    ensureCoordinator() {
+        if (!this.coordinator) {
+            throw new Error("AgentPool.configureCoordinator() must be called before execution");
+        }
+        return this;
     }
     usesSpawnPath() {
         return this.coordinator !== undefined;
     }
-    has(role) {
-        return this.runners.has(role);
-    }
-    get(role) {
-        const runner = this.runners.get(role);
-        if (!runner)
-            throw new Error(`AgentPool: no runner registered for role "${role}"`);
-        return runner;
-    }
-    /**
-     * Spawn a kernel-isolated sub-agent. Requires `configureCoordinator()`.
-     * Maps legacy pool roles to kernel roles (executor → implement, etc.).
-     */
+    /** Spawn a kernel-isolated sub-agent. Requires `configureCoordinator()`. */
     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,
+            identity: agentIdentitySub(`${role}-${crypto.randomUUID()}`, crypto.randomUUID(), this.coordinator.sessionId),
+            role,
             goal,
             ...extra,
         };
         return spawnStandalone(this.coordinator.opts, this.coordinator.sessionId, spec);
     }
-    /** Execute a role in a caller-owned session so AttemptLoop can retain transcript across attempts. */
+    /** Execute a role in a caller-owned session while preserving kernel lineage. */
     async execute(role, input) {
-        if (this.coordinator) {
-            const kernelRole = KERNEL_ROLE_MAP[role];
-            const spec = {
-                identity: agentIdentitySub(`${kernelRole}-${input.sessionId}`, input.sessionId, this.coordinator.sessionId),
-                role: kernelRole,
-                goal: input.goal,
-                ...(input.verificationContractId
-                    ? { verificationContractId: input.verificationContractId }
-                    : {}),
-            };
-            return spawnStandalone(this.coordinator.opts, this.coordinator.sessionId, spec, undefined, input.contextInput);
-        }
-        const runner = this.get(role);
-        if (input.contextInput)
-            runner.injectNote(input.contextInput);
-        let finalText = "";
-        let turnsUsed = 0;
-        let totalTokensUsed = 0;
-        let termination = "error";
-        for await (const event of runner.run({ sessionId: input.sessionId, goal: input.goal })) {
-            if (event.type === "text_delta")
-                finalText += event.delta;
-            if (event.type === "done") {
-                const done = event;
-                turnsUsed = done.iterations;
-                totalTokensUsed = done.totalTokens;
-                termination = done.status;
-            }
-        }
-        return {
-            agentId: `${KERNEL_ROLE_MAP[role]}-${input.sessionId}`,
-            result: {
-                termination,
-                turnsUsed,
-                totalTokensUsed,
-                ...(finalText
-                    ? { finalMessage: { role: "assistant", content: finalText, toolCalls: [] } }
-                    : {}),
-            },
+        this.ensureCoordinator();
+        const coordinator = this.coordinator;
+        const spec = {
+            identity: agentIdentitySub(`${role}-${input.sessionId}`, input.sessionId, coordinator.sessionId),
+            role,
+            goal: input.goal,
+            ...(input.verificationContractId
+                ? { verificationContractId: input.verificationContractId }
+                : {}),
         };
+        return spawnStandalone(coordinator.opts, coordinator.sessionId, spec, undefined, input.contextInput);
     }
     async verify(ctx) {
         const contractBlock = formatContractForSystemPrompt(ctx.contract);
@@ -128,15 +68,11 @@ export class AgentPool {
             }, null, 2),
             "Every contract criterion id must appear exactly once in details. Do not emit prose or markdown.",
         ].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 }));
+        const result = await this.spawn("verify", auditGoal, {
+            verificationContractId: ctx.contract.id,
+            isolation: "read_only",
+        });
+        return result.result.finalMessage?.content ?? "";
     }
     async orchestrate(goal) {
         const orchestratorGoal = [
@@ -155,13 +91,7 @@ export class AgentPool {
             ``,
             `Output ONLY the JSON object, no prose.`,
         ].join("\n");
-        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,
-        }));
+        const result = await this.spawn("plan", orchestratorGoal);
+        return result.result.finalMessage?.content ?? "";
     }
 }

package/dist/compat/anthropic/mcp.d.ts

@@ -0,0 +1,15 @@
+import type { MCPServer } from "../../mcp-server.js";
+/** spc_007 §3: minimal Anthropic/Claude-style MCP server config shape (the per-server object in
+ *  a Claude Desktop-style `mcpServers` map — `{ command, args, env }`), not a live SDK type
+ *  import — this adapter reads a serialized config (e.g.
+ *  `__fixtures__/anthropic-mcp-config.json`). */
+export interface AnthropicMcpConfigJson {
+    name?: string;
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+}
+/** Anthropic MCP config → DeepStrike `MCPServer` (spc_001-07). Anthropic's config format is
+ *  always a subprocess launch (stdio transport) — there is no http/sse/custom variant to map
+ *  from. Pure Surface→Surface mapping, produces only `MCPServer`. */
+export declare function fromAnthropicMcpConfig(json: AnthropicMcpConfigJson): MCPServer;

package/dist/compat/anthropic/mcp.js

@@ -0,0 +1,10 @@
+/** Anthropic MCP config → DeepStrike `MCPServer` (spc_001-07). Anthropic's config format is
+ *  always a subprocess launch (stdio transport) — there is no http/sse/custom variant to map
+ *  from. Pure Surface→Surface mapping, produces only `MCPServer`. */
+export function fromAnthropicMcpConfig(json) {
+    return {
+        name: json.name,
+        transport: { kind: "stdio", command: json.command, args: json.args },
+        ...(json.env ? { metadata: { env: json.env } } : {}),
+    };
+}

package/dist/compat/openai/agent.d.ts

@@ -0,0 +1,34 @@
+import { Agent } from "../../agent.js";
+/** spc_007 §2: minimal OpenAI Agents SDK agent-definition shape this adapter accepts. Field
+ *  names/shape mirror the doc's §2 table left column, not any live OpenAI SDK type import — this
+ *  adapter reads a serialized agent definition (e.g. `__fixtures__/openai-agent.json`), not a
+ *  running SDK object. */
+export interface OpenAiAgentJson {
+    name: string;
+    instructions?: string;
+    model?: string;
+    tools?: Array<{
+        type?: string;
+        name: string;
+        description?: string;
+        parameters?: Record<string, unknown>;
+    }>;
+    handoffs?: Array<{
+        agent: string;
+        description?: string;
+    }>;
+    /** OpenAI-specific: no common `Agent` field for this (spc_007 §2's "Guardrails" row lowers to
+     *  governance policy, not a Canonical IR field) — preserved under `providerOptions.openai`
+     *  rather than silently dropped (spc_001 §3: "Unknown fields → never silently discarded"). */
+    guardrails?: unknown[];
+}
+/** spc_007 §2: OpenAI Agent → DeepStrike `Agent` (spc_001's Canonical Agent IR entry object).
+ *  Pure Surface→Surface mapping — produces only `Agent`, never a Kernel-internal type
+ *  (`Tcb`/`Capability`/etc.), matching this doc's own boundary ("Adapter 代码不得进入 Kernel
+ *  crate").
+ *
+ *  A JSON tool definition carries no executable body, so each mapped tool's `execute` is a
+ *  placeholder that throws — this adapter only reconstructs declarative shape (name/description/
+ *  schema/count), never behavior; wiring a real implementation back onto an OpenAI-sourced tool
+ *  definition is a separate, later concern outside this card. */
+export declare function fromOpenAiAgent(json: OpenAiAgentJson): Agent;

package/dist/compat/openai/agent.js

@@ -0,0 +1,24 @@
+import { Agent } from "../../agent.js";
+import { tool } from "../../tools/index.js";
+/** spc_007 §2: OpenAI Agent → DeepStrike `Agent` (spc_001's Canonical Agent IR entry object).
+ *  Pure Surface→Surface mapping — produces only `Agent`, never a Kernel-internal type
+ *  (`Tcb`/`Capability`/etc.), matching this doc's own boundary ("Adapter 代码不得进入 Kernel
+ *  crate").
+ *
+ *  A JSON tool definition carries no executable body, so each mapped tool's `execute` is a
+ *  placeholder that throws — this adapter only reconstructs declarative shape (name/description/
+ *  schema/count), never behavior; wiring a real implementation back onto an OpenAI-sourced tool
+ *  definition is a separate, later concern outside this card. */
+export function fromOpenAiAgent(json) {
+    const tools = (json.tools ?? []).map(t => tool(t.name, t.description ?? "", t.parameters ?? { type: "object", properties: {} }, async () => {
+        throw new Error(`tool "${t.name}" has no execution binding — fromOpenAiAgent only carries declarative shape`);
+    }));
+    return new Agent({
+        name: json.name,
+        instructions: json.instructions,
+        model: json.model,
+        tools,
+        handoffs: json.handoffs,
+        ...(json.guardrails ? { providerOptions: { openai: { guardrails: json.guardrails } } } : {}),
+    });
+}

package/dist/governance.d.ts

@@ -1,20 +1,3 @@
-import type { GovernanceVerdict } from "./kernel.js";
-type GovernanceDefaultAction = "allow" | "deny" | "ask_user";
-type GovernanceRuleAction = "allow" | "deny" | "ask_user";
-export declare class Governance {
-    private readonly inner;
-    constructor(defaultAction?: GovernanceDefaultAction);
-    setIdentity(agentId: string, sessionId: string): void;
-    addPermissionRule(pattern: string, action: GovernanceRuleAction): void;
-    blockTool(name: string): void;
-    setRateLimit(toolName: string, maxCalls: number, windowMs: number): void;
-    requireParam(toolName: string, paramPath: string): void;
-    allowParamValues(toolName: string, paramPath: string, allowedValues: string[]): void;
-    limitParamRange(toolName: string, paramPath: string, min?: number, max?: number): void;
-    setTime(nowMs: number | bigint): void;
-    evaluate(toolName: string, argsJson: string): GovernanceVerdict;
-}
-export type { GovernanceVerdict };
 type GovernancePolicyAction = "allow" | "deny" | "ask_user";
 export interface GovernancePolicy {
     defaultAction?: GovernancePolicyAction;
@@ -71,3 +54,4 @@ export type GovernanceConstraint = {
  * kernel event payload (snake_case wire fields). Pure — no side effects.
  */
 export declare function governancePolicyToKernelEvent(policy: GovernancePolicy): Record<string, unknown>;
+export {};

package/dist/governance.js

@@ -1,37 +1,4 @@
-import { getKernel } from "./kernel.js";
-export class Governance {
-    inner;
-    constructor(defaultAction = "allow") {
-        this.inner = new (getKernel().Governance)(defaultAction);
-    }
-    setIdentity(agentId, sessionId) {
-        this.inner.setIdentity(agentId, sessionId);
-    }
-    addPermissionRule(pattern, action) {
-        this.inner.addPermissionRule(pattern, action);
-    }
-    blockTool(name) {
-        this.inner.blockTool(name);
-    }
-    setRateLimit(toolName, maxCalls, windowMs) {
-        this.inner.setRateLimit(toolName, maxCalls, BigInt(windowMs));
-    }
-    requireParam(toolName, paramPath) {
-        this.inner.requireParam(toolName, paramPath);
-    }
-    allowParamValues(toolName, paramPath, allowedValues) {
-        this.inner.allowParamValues(toolName, paramPath, allowedValues);
-    }
-    limitParamRange(toolName, paramPath, min, max) {
-        this.inner.limitParamRange(toolName, paramPath, min, max);
-    }
-    setTime(nowMs) {
-        this.inner.setTime(typeof nowMs === "bigint" ? nowMs : BigInt(nowMs));
-    }
-    evaluate(toolName, argsJson) {
-        return this.inner.evaluate(toolName, argsJson);
-    }
-}
+// ─── Declarative policy (in-kernel gate) ──────────────────────────────────────
 /** I5: walk the tool list and bucket each tool into `allowed` / `denied` based on a declarative
  *  policy. A tool is denied when:
  *    - the tool name appears in `vetoes`

package/dist/guardrail.d.ts

@@ -0,0 +1,6 @@
+/** Public guardrail declaration. Execution/lowering belongs to a later governance card. */
+export interface Guardrail {
+    name: string;
+    description?: string;
+    metadata?: Record<string, unknown>;
+}

package/dist/guardrail.js

@@ -0,0 +1 @@
+export {};

package/dist/handoff-target.d.ts

@@ -0,0 +1,12 @@
+import type { JsonSchema } from "./runtime/output-schema.js";
+/** A control-transfer target, deliberately distinct from `HandoffArtifact` sprint evidence. */
+export type AgentRef = string | {
+    name: string;
+};
+export interface Handoff {
+    agent: AgentRef;
+    description?: string;
+    inputSchema?: JsonSchema;
+    metadata?: Record<string, unknown>;
+    providerOptions?: Record<string, unknown>;
+}

package/dist/handoff-target.js

@@ -0,0 +1 @@
+export {};

package/dist/harness/manifest.js

@@ -17,10 +17,6 @@
  * therefore structurally inexpressible, and the whole security audit stays O(1): read the whitelist,
  * check the one invariant. (`enablePlanTool` is exempt — it toggles a kernel-owned meta-tool,
  * attention-shaping not capability-granting, so it folds by plain assignment.)
- *
- * `toolDispatchGate` is deliberately ABSENT from the whitelist and must stay so: it selects whether
- * the kernel enforces the exposure surface at dispatch. A proposer that could set it to `"registered"`
- * would disable the enforcement half of the ceiling it is otherwise structurally unable to widen.
  */
 import { createHash } from "node:crypto";
 import { validateNudgeRules } from "./nudge.js";

package/dist/index.d.ts

@@ -8,8 +8,8 @@ export { PayloadStore } from "./runtime/payload-store.js";
 export type { PayloadStoreConfig } from "./runtime/payload-store.js";
 export type { InstructionProfile, NudgeRule, NudgeTrigger } from "./harness/public.js";
 export type { SignalPolicy } from "./runtime/os-profile.js";
-export { CONTEXT_POLICY_VERSION, DEFAULT_CONTEXT_POLICY_V1, PPM_SCALE, contextPolicyV1, normalizeContextPolicyV1, ratioToPpm, } from "./runtime/context-policy.js";
-export type { ContextPolicyOverridesV1, ContextPolicyV1, ContextPolicyWireV1, ContextPressureThresholdsV1, } from "./runtime/context-policy.js";
+export { DEFAULT_CONTEXT_POLICY, PPM_SCALE, contextPolicy, normalizeContextPolicy, ratioToPpm, } from "./runtime/context-policy.js";
+export type { ContextPolicyOverrides, ContextPolicy, ContextPolicyWire, ContextPressureThresholds, } from "./runtime/context-policy.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";
@@ -38,12 +38,24 @@ export type { AnthropicProviderConfig } from "./providers/anthropic.js";
 export { OpenAIProvider } from "./providers/openai.js";
 export type { OpenAIProviderOptions } from "./providers/openai.js";
 export { OpenAIResponsesProvider } from "./providers/openai-responses.js";
-export { createProvider } from "./providers/catalog.js";
+export { createProvider, createProviderAsync, resolveProviderRuntime, resolveProviderRuntimeAsync } from "./providers/catalog.js";
 export { UnsupportedModalityError } from "./providers/base.js";
 export type { CreateProviderOptions, EndpointProfileId } from "./providers/catalog.js";
-export { Governance } from "./governance.js";
-export type { GovernanceVerdict, GovernancePolicy, GovernanceConstraint } from "./governance.js";
+export { createProviderRequestPlan, createProviderRequestPlanForProvider, estimateProviderPromptTokens, measurementForPlan, normalizeProviderUsage, priceProviderUsage, recordPromptMeasurement } from "./providers/request-plan.js";
+export type { CostObservation, NormalizedProviderUsage, PricingSnapshot, ProviderRequestEndpoint, ProviderRequestPlan, RecordedPromptMeasurement } from "./providers/request-plan.js";
+export type { GovernancePolicy, GovernanceConstraint } from "./governance.js";
 export { AgentPool } from "./collaboration/pool.js";
+export { Agent } from "./agent.js";
+export type { AgentOptions, AgentMemory, MemoryReference, ModelRef, ModelRequirement } from "./agent.js";
+export { lowerAgent, normalizeAgent } from "./agent-ir.js";
+export type { AgentCapabilityIR, AgentDefinition, AgentLoweringInputs, AgentMemoryIR, AgentSpec, AgentToolDefinition, AgentToolIR } from "./agent-ir.js";
+export type { Guardrail } from "./guardrail.js";
+export type { MCPServer, McpTransport } from "./mcp-server.js";
+export type { Knowledge, KnowledgeSourceRef } from "./knowledge/public.js";
+export type { AgentRef, Handoff } from "./handoff-target.js";
+export type { Session } from "./session.js";
 export type { RuntimeSignal, SignalClaim, SignalDeliveryReceipt, SignalSource, } from "./signals/types.js";
-export type { Message, ToolCall, ToolResult, ToolSchema, ContentPart, TextPart, ImagePart, AudioPart, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolChunk, ToolDeltaEvent, ToolSuspendEvent, ToolResultEvent, ToolAuditFailedEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, PermissionResolvedEvent, PermissionResponse, EntropySample, EntropySampleEvent, EntropyAlertEvent, EntropyWatchOptions, LLMProvider, RetryConfig, TokenUsage, } from "./types.js";
-export type { WorkflowSpec, WorkflowNodeSpec, WorkflowDependencyPolicy, WorkflowNodeStatus, WorkflowNodeOutcome, WorkflowOutcome, } from "./types/agent.js";
+export type { Message, ToolCall, ToolResult, ToolSchema, ContentPart, TextPart, ImagePart, AudioPart, MediaSource, ContentBlockText, ContentBlockImage, ContentBlockAudio, ContentBlockVideo, ContentBlockFile, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolChunk, ToolDeltaEvent, ToolSuspendEvent, ToolResultEvent, ToolAuditFailedEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, PermissionResolvedEvent, PermissionResponse, EntropySample, EntropySampleEvent, EntropyAlertEvent, EntropyWatchOptions, LLMProvider, RetryConfig, TokenUsage, } from "./types.js";
+export { DurableContentError, decodeDurableContent, decodeDurableToolResult, encodeDurableContent, encodeDurableToolResult, toolOutputBlocksToDurable, durableBlocksToToolOutput, } from "./runtime/durable-content.js";
+export type { DurableContent, DurableContentBlock, DurableSource, DurableToolResult } from "./runtime/durable-content.js";
+export type { WorkflowSpec, WorkflowNodeSpec, SchedulingFactors, WorkflowDependencyPolicy, WorkflowNodeStatus, WorkflowNodeOutcome, WorkflowOutcome, } from "./types/agent.js";

package/dist/index.js

@@ -6,7 +6,7 @@
 // ║   @deepstrike/sdk/providers  — backend provider classes + profiles         ║
 // ║   @deepstrike/sdk/workflow   — orchestration, reducers, contracts, specs   ║
 // ║   @deepstrike/sdk/planes     — worktree / sandbox / mcp / vpc planes        ║
-// ║   @deepstrike/sdk/memory     — dream + working memory, knowledge sources    ║
+// ║   @deepstrike/sdk/memory     — durable + working memory, knowledge sources  ║
 // ║   @deepstrike/sdk/harness    — eval harnesses + judge                       ║
 // ║   @deepstrike/sdk/os         — profiles, diagnostics, signals, replay tests ║
 // ╚══════════════════════════════════════════════════════════════════════════╝
@@ -16,7 +16,7 @@ export { runAgent, runFanout } from "./runtime/facade.js";
 export { runLoop, LoopDriver, foldLoopState } from "./runtime/loop-driver.js";
 export { RuntimeRunner, collectText } from "./runtime/runner.js";
 export { PayloadStore } from "./runtime/payload-store.js";
-export { CONTEXT_POLICY_VERSION, DEFAULT_CONTEXT_POLICY_V1, PPM_SCALE, contextPolicyV1, normalizeContextPolicyV1, ratioToPpm, } from "./runtime/context-policy.js";
+export { DEFAULT_CONTEXT_POLICY, PPM_SCALE, contextPolicy, normalizeContextPolicy, ratioToPpm, } from "./runtime/context-policy.js";
 // ── Execution plane + session log (the defaults) ────────────────────────────
 export { LocalExecutionPlane } from "./runtime/execution-plane.js";
 export { InMemorySessionLog, FileSessionLog } from "./runtime/session-log.js";
@@ -37,10 +37,13 @@ export { safeTool, ok, fail, ToolError, formatToolError } from "./tools/errors.j
 export { AnthropicProvider } from "./providers/anthropic.js";
 export { OpenAIProvider } from "./providers/openai.js";
 export { OpenAIResponsesProvider } from "./providers/openai-responses.js";
-export { createProvider } from "./providers/catalog.js";
+export { createProvider, createProviderAsync, resolveProviderRuntime, resolveProviderRuntimeAsync } from "./providers/catalog.js";
 export { UnsupportedModalityError } from "./providers/base.js";
-// ── Governance ──────────────────────────────────────────────────────────────
-export { Governance } from "./governance.js";
+export { createProviderRequestPlan, createProviderRequestPlanForProvider, estimateProviderPromptTokens, measurementForPlan, normalizeProviderUsage, priceProviderUsage, recordPromptMeasurement } from "./providers/request-plan.js";
 // ── Multi-agent primitive ───────────────────────────────────────────────────
 // Parallel fan-out / sub-agent delegation. The full orchestration layer is in `@deepstrike/sdk/workflow`.
 export { AgentPool } from "./collaboration/pool.js";
+// ── Ecosystem Surface Contract (spc_001) ────────────────────────────────────
+export { Agent } from "./agent.js";
+export { lowerAgent, normalizeAgent } from "./agent-ir.js";
+export { DurableContentError, decodeDurableContent, decodeDurableToolResult, encodeDurableContent, encodeDurableToolResult, toolOutputBlocksToDurable, durableBlocksToToolOutput, } from "./runtime/durable-content.js";

package/dist/kernel.d.ts

@@ -1,13 +1,8 @@
 import type { Message } from "./types.js";
-export interface GovernanceVerdict {
-    kind: "allow" | "deny" | "rate_limited" | "ask_user";
-    reason?: string;
-    retryAfterMs?: number;
-}
 /**
  * M2 资源配额 — declarative resource limits enforced at the kernel's single syscall trap.
  *
- * Installed through the versioned JSON event ABI (`set_resource_quota`), not a side-channel
+ * Installed through the canonical JSON event contract (`set_resource_quota`), not a side-channel
  * setter, so quota config is replayable and session-loggable like governance/scheduler config.
  * Every field is optional; an omitted field imposes no limit, and omitting the quota entirely
  * preserves the pre-M2 behavior of admitting all spawn / memory-write syscalls.
@@ -35,7 +30,7 @@ export interface ResourceQuota {
  *
  * Included in canonical operation configuration, so memory policy is replayable and
  * kernel-enforced. Omitted fields retain the canonical defaults. Host storage belongs to the
- * configured `DreamStore`, never to this contract.
+ * configured `MemoryStore`, never to this contract.
  */
 export interface MemoryPolicy {
     /** Age after which a recalled memory is flagged stale (days). */
@@ -52,17 +47,6 @@ export interface MemoryPolicy {
      *  `promotion_suggested` for a recalled record. Omitted = suggestions disabled. */
     promotionRecallThreshold?: number;
 }
-export interface GovernanceInstance {
-    setIdentity(agentId: string, sessionId: string): void;
-    addPermissionRule(pattern: string, action: "allow" | "deny" | "ask_user"): void;
-    blockTool(name: string): void;
-    setRateLimit(toolName: string, maxCalls: number, windowMs: bigint): void;
-    requireParam(toolName: string, paramPath: string): void;
-    allowParamValues(toolName: string, paramPath: string, allowedValues: string[]): void;
-    limitParamRange(toolName: string, paramPath: string, min?: number, max?: number): void;
-    setTime(nowMs: bigint): void;
-    evaluate(toolName: string, argsJson: string): GovernanceVerdict;
-}
 export interface RuntimeSignal {
     id: string;
     source: "cron" | "gateway" | "heartbeat" | "custom";
@@ -160,9 +144,7 @@ export interface CanonicalKernelInstance {
     terminalJson(): string | undefined;
 }
 interface KernelModule {
-    Governance: new (defaultAction?: "allow" | "deny" | "ask_user") => GovernanceInstance;
     CanonicalKernel: new () => CanonicalKernelInstance;
-    kernelAbiVersion(): number;
     SignalRouter: new (maxQueueSize: number) => SignalRouterInstance;
     buildEvalMessages(goal: string, criteria: NativeCriterion[], result: string, attempt: number, extractSkillOnPass: boolean): Message[];
     parseVerdict(content: string): Verdict;

package/dist/knowledge/public.d.ts

@@ -0,0 +1,29 @@
+import type { KnowledgeSource } from "./source.js";
+/** Public knowledge descriptor, distinct from the executable `KnowledgeSource` retriever. */
+export type KnowledgeSourceRef = {
+    kind: "file";
+    path: string;
+} | {
+    kind: "directory";
+    path: string;
+} | {
+    kind: "text";
+    content: string;
+} | {
+    kind: "url";
+    url: string;
+} | {
+    kind: "vector";
+    retriever: KnowledgeSource;
+} | {
+    kind: "custom";
+    [key: string]: unknown;
+};
+export interface Knowledge {
+    id?: string;
+    name?: string;
+    source: KnowledgeSourceRef;
+    description?: string;
+    metadata?: Record<string, unknown>;
+    providerOptions?: Record<string, unknown>;
+}

package/dist/knowledge/public.js

@@ -0,0 +1 @@
+export {};

package/dist/mcp-server.d.ts

@@ -0,0 +1,28 @@
+/** spc_001 §2.3: public MCP server contract. A parallel new type — not a replacement for
+ *  `McpServerConfig` (`runtime/mcp-proxy-plane.ts`), which is the stdio-only execution-layer
+ *  config `McpProxyPlane` actually spawns. `MCPServer` is the public IR shape; lowering it down
+ *  to `McpServerConfig` (or an equivalent per transport kind) is separate, later work. */
+export type McpTransport = {
+    kind: "stdio";
+    command: string;
+    args?: string[];
+} | {
+    kind: "http";
+    url: string;
+} | {
+    kind: "sse";
+    url: string;
+} | {
+    kind: "custom";
+    [key: string]: unknown;
+};
+export interface MCPServer {
+    name?: string;
+    transport: McpTransport;
+    tools?: string[];
+    resources?: boolean;
+    prompts?: boolean;
+    auth?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+    providerOptions?: Record<string, unknown>;
+}

package/dist/mcp-server.js

@@ -0,0 +1 @@
+export {};

package/dist/memory/agent.d.ts

@@ -6,7 +6,7 @@
  * Design principles:
  * - Kernel defines memory types and validation rules
  * - SDK performs I/O and selection
- * - Semantic reranking remains an optional DreamStore capability
+ * - Semantic reranking remains an optional MemoryStore capability
  */
 import type { MemoryQuery, MemoryRecall, MemoryRecord } from "./protocols.js";
 export type { MemoryKind, MemoryQuery, MemoryRecall, MemoryRecord, } from "./protocols.js";
@@ -14,7 +14,7 @@ export type { MemoryKind, MemoryQuery, MemoryRecall, MemoryRecord, } from "./pro
  * Select relevant memories for the current context.
  *
  * The reference selector is deterministic and provider-independent: lexical overlap first,
- * recency second. Semantic/embedding reranking belongs in a DreamStore plugin.
+ * recency second. Semantic/embedding reranking belongs in a MemoryStore plugin.
  *
  * @param query - Memory query from kernel
  * @param memoryIndex - Memory index entries

package/dist/memory/agent.js

@@ -6,14 +6,14 @@
  * Design principles:
  * - Kernel defines memory types and validation rules
  * - SDK performs I/O and selection
- * - Semantic reranking remains an optional DreamStore capability
+ * - Semantic reranking remains an optional MemoryStore capability
  */
 import { rankMemories } from "./ranking.js";
 /**
  * Select relevant memories for the current context.
  *
  * The reference selector is deterministic and provider-independent: lexical overlap first,
- * recency second. Semantic/embedding reranking belongs in a DreamStore plugin.
+ * recency second. Semantic/embedding reranking belongs in a MemoryStore plugin.
  *
  * @param query - Memory query from kernel
  * @param memoryIndex - Memory index entries

package/dist/memory/durable.d.ts

@@ -0,0 +1,16 @@
+import type { Memory, MemoryRecord, MemoryScope, MemorySearchOptions, MemoryStore } from "./protocols.js";
+/**
+ * Binds the host storage protocol to the public Memory contract for one agent and namespace.
+ * This is deliberately an SDK adapter: it does not lower memory mutations into the Kernel.
+ */
+export declare class DurableMemory implements Memory {
+    private readonly store;
+    private readonly agentId;
+    private readonly scope;
+    readonly namespace: string;
+    constructor(store: MemoryStore, agentId: string, scope: MemoryScope);
+    search(query: string, options?: MemorySearchOptions): Promise<MemoryRecord[]>;
+    get(id: string): Promise<MemoryRecord | null>;
+    put(record: MemoryRecord): Promise<void>;
+    delete(id: string): Promise<void>;
+}