@deepstrike/sdk 0.2.70 → 0.2.72

package/dist/agent-ir.d.ts

@@ -1,3 +1,4 @@
+import type { AgentDefinition } from "./agent-facade.js";
 import { Agent, type AgentOptions, type ModelRef } from "./agent.js";
 import type { Guardrail } from "./guardrail.js";
 import type { Handoff } from "./handoff-target.js";
@@ -15,7 +16,7 @@ export interface AgentToolDefinition {
 }
 /** A JSON-friendly Agent definition accepted by `normalizeAgent`.  It is deliberately declarative:
  * executable tools still enter the SDK through `AgentOptions.tools`. */
-export interface AgentDefinition extends Omit<AgentOptions, "tools"> {
+export interface AgentDescriptor extends Omit<AgentOptions, "tools"> {
     tools?: Array<RegisteredTool | AgentToolDefinition>;
 }
 export interface AgentToolIR {
@@ -85,19 +86,24 @@ export interface AgentSpec {
     guardrails?: Guardrail[];
     metadata?: Record<string, unknown>;
     /** Declared capabilities. This descriptive view grants nothing by itself. */
-    capabilities: AgentCapabilityIR[];
+    readonly capabilities: AgentCapabilityIR[];
     /** Host ceiling copied from the public Agent, when supplied. Empty axes remain non-narrowing. */
     capabilityFilter?: AgentCapabilityFilter;
     /** The declarations that survive the supplied local ceiling. Host mounts may narrow further. */
-    effectiveCapabilities: AgentCapabilityIR[];
+    readonly effectiveCapabilities: AgentCapabilityIR[];
     /** Namespace-isolated provider extensions. Unknown namespaces are preserved verbatim. */
     extensions: Record<string, unknown>;
-    inputs: AgentLoweringInputs;
 }
 /** Normalizes native Agents and JSON-safe descriptor objects into the one public surface used by
  * lowering. It does not interpret provider namespaces or create executable capabilities. */
-export declare function normalizeAgent(agent: Agent | AgentDefinition): Agent;
+export declare function normalizeAgent(agent: Agent | AgentDefinition | AgentDescriptor): Agent;
 /** Pure: no provider branching, no scheduling, authorization, persistence, or Kernel wire calls.
  * Providers consume only their own namespace from `extensions`; the host decides whether declared
  * capabilities survive its existing attenuation filter. */
 export declare function lowerAgent(agent: Agent): AgentSpec;
+/** Detached projections; callers can adapt them without changing AgentSpec authority. */
+export declare function projectAgentRun(spec: AgentSpec): AgentLoweringInputs["run"];
+export declare function projectAgentContext(spec: AgentSpec): AgentLoweringInputs["context"];
+export declare function projectAgentCapabilities(spec: AgentSpec): AgentLoweringInputs["capabilities"];
+export declare function projectAgentGovernance(spec: AgentSpec): AgentLoweringInputs["governance"];
+export declare function projectAgentDelegation(spec: AgentSpec): AgentLoweringInputs["delegation"];

package/dist/agent-ir.js

@@ -37,7 +37,7 @@ export function normalizeAgent(agent) {
         return agent;
     const tools = agent.tools?.map(tool => isRegisteredTool(tool) ? tool : toolDefinitionToRegisteredTool(tool));
     const { tools: _rawTools, ...options } = agent;
-    return new Agent({ ...options, ...(tools ? { tools } : {}) });
+    return new Agent({ ...options, name: options.name ?? "agent", ...(tools ? { tools } : {}) });
 }
 function lowerTool(tool) {
     let parameters;
@@ -88,17 +88,7 @@ export function lowerAgent(agent) {
     const guardrails = clone(agent.guardrails ?? []);
     const memory = lowerMemory(agent.memory);
     const extensions = clone(agent.providerOptions ?? {});
-    const capabilities = [
-        ...tools.map(tool => ({ kind: "tool", id: tool.name, description: tool.description })),
-        ...mcpServers.map(server => ({
-            kind: "mcp_server",
-            id: server.name ?? server.transport.kind,
-            description: server.name ?? `${server.transport.kind} MCP server`,
-        })),
-        ...skills.map(skill => ({ kind: "skill", id: skill.name, description: skill.description ?? "" })),
-    ];
     const capabilityFilter = agent.capabilityFilter ? clone(agent.capabilityFilter) : undefined;
-    const effectiveCapabilities = capabilities.filter(capability => capabilityAllowed(capability, capabilityFilter));
     return {
         name: agent.name,
         ...(agent.description ? { description: agent.description } : {}),
@@ -113,22 +103,48 @@ export function lowerAgent(agent) {
         ...(handoffs.length ? { handoffs } : {}),
         ...(guardrails.length ? { guardrails } : {}),
         ...(agent.metadata ? { metadata: clone(agent.metadata) } : {}),
-        capabilities,
+        get capabilities() { return declaredCapabilities(this); },
         ...(capabilityFilter ? { capabilityFilter } : {}),
-        effectiveCapabilities,
-        extensions,
-        inputs: {
-            run: { name: agent.name, ...(agent.model ? { model: clone(agent.model) } : {}) },
-            context: {
-                ...(agent.description ? { description: agent.description } : {}),
-                ...(agent.instructions ? { instructions: agent.instructions } : {}),
-                ...(agent.outputSchema ? { outputSchema: clone(agent.outputSchema) } : {}),
-                knowledge,
-            },
-            capabilities: { tools, mcpServers, skills, effective: effectiveCapabilities },
-            ...(memory ? { memory } : {}),
-            delegation: { handoffs },
-            governance: { guardrails },
+        get effectiveCapabilities() {
+            return declaredCapabilities(this).filter(capability => capabilityAllowed(capability, this.capabilityFilter));
         },
+        extensions,
+    };
+}
+/** Detached projections; callers can adapt them without changing AgentSpec authority. */
+export function projectAgentRun(spec) {
+    return { name: spec.name, ...(spec.model !== undefined ? { model: clone(spec.model) } : {}) };
+}
+export function projectAgentContext(spec) {
+    return {
+        ...(spec.description !== undefined ? { description: spec.description } : {}),
+        ...(spec.instructions !== undefined ? { instructions: spec.instructions } : {}),
+        ...(spec.outputSchema !== undefined ? { outputSchema: clone(spec.outputSchema) } : {}),
+        knowledge: clone(spec.knowledge ?? []),
     };
 }
+export function projectAgentCapabilities(spec) {
+    return {
+        tools: clone(spec.tools),
+        mcpServers: clone(spec.mcpServers ?? []),
+        skills: clone(spec.skills ?? []),
+        effective: clone(spec.effectiveCapabilities),
+    };
+}
+export function projectAgentGovernance(spec) {
+    return { guardrails: clone(spec.guardrails ?? []) };
+}
+export function projectAgentDelegation(spec) {
+    return { handoffs: clone(spec.handoffs ?? []) };
+}
+function declaredCapabilities(spec) {
+    return [
+        ...spec.tools.map(tool => ({ kind: "tool", id: tool.name, description: tool.description })),
+        ...(spec.mcpServers ?? []).map(server => ({
+            kind: "mcp_server",
+            id: server.name ?? server.transport.kind,
+            description: server.name ?? `${server.transport.kind} MCP server`,
+        })),
+        ...(spec.skills ?? []).map(skill => ({ kind: "skill", id: skill.name, description: skill.description ?? "" })),
+    ];
+}

package/dist/canonical-prefix-allowlist.d.ts

@@ -0,0 +1,6 @@
+/**
+ * SPC-028-03: names that retain the Canonical prefix for ABI/runtime reasons.
+ * New provider-neutral types should use a domain and representation name instead.
+ */
+export declare const CANONICAL_PREFIX_ALLOWLIST: readonly ["CanonicalAdapterInput", "CanonicalCheckpoint", "CanonicalCommit", "CanonicalKernel", "CanonicalKernelHost", "CanonicalKernelInput", "CanonicalKernelInstance", "CanonicalKernelRebuildRequiredError", "CanonicalKernelRejectedError", "CanonicalMessage", "CanonicalMessageBlock", "CanonicalPlannedStep", "CanonicalPreparation", "CanonicalPrepared", "CanonicalRejected", "CanonicalRenderedContext", "CanonicalReplayed", "CanonicalRestoreCost", "CanonicalRunnerRuntime", "CanonicalRunnerRuntimeOptions", "CanonicalStopReason", "CanonicalToolResult", "CanonicalTransition", "CanonicalTransitionOptions"];
+export type AllowedCanonicalPrefixName = typeof CANONICAL_PREFIX_ALLOWLIST[number];

package/dist/canonical-prefix-allowlist.js

@@ -0,0 +1,30 @@
+/**
+ * SPC-028-03: names that retain the Canonical prefix for ABI/runtime reasons.
+ * New provider-neutral types should use a domain and representation name instead.
+ */
+export const CANONICAL_PREFIX_ALLOWLIST = [
+    "CanonicalAdapterInput",
+    "CanonicalCheckpoint",
+    "CanonicalCommit",
+    "CanonicalKernel",
+    "CanonicalKernelHost",
+    "CanonicalKernelInput",
+    "CanonicalKernelInstance",
+    "CanonicalKernelRebuildRequiredError",
+    "CanonicalKernelRejectedError",
+    "CanonicalMessage",
+    "CanonicalMessageBlock",
+    "CanonicalPlannedStep",
+    "CanonicalPreparation",
+    "CanonicalPrepared",
+    "CanonicalRejected",
+    "CanonicalRenderedContext",
+    "CanonicalReplayed",
+    "CanonicalRestoreCost",
+    "CanonicalRunnerRuntime",
+    "CanonicalRunnerRuntimeOptions",
+    "CanonicalStopReason",
+    "CanonicalToolResult",
+    "CanonicalTransition",
+    "CanonicalTransitionOptions",
+];

package/dist/evals/public.d.ts

@@ -0,0 +1,50 @@
+/** Public evaluation language. Runtime evidence remains available through the runtime subpath. */
+export { judge, buildEvalMessages, parseVerdict, verdictOutputSchema } from "../runtime/eval.js";
+export type { Criterion, Verdict, VerdictDetail, JudgeArgs } from "../runtime/eval.js";
+export interface DatasetCase {
+    id: string;
+    input: string;
+    expected?: unknown;
+    metadata?: Record<string, unknown>;
+}
+export interface Dataset {
+    name?: string;
+    cases: DatasetCase[];
+}
+export interface Evaluator {
+    name: string;
+    evaluate(input: {
+        testCase: DatasetCase;
+        output: string;
+    }): Promise<number> | number;
+}
+export interface EvalResult {
+    caseId: string;
+    output: string;
+    scores: Record<string, number>;
+}
+/** Optional execution evidence kept separate from the stable score/result contract. */
+export interface EvalTrace {
+    caseId: string;
+    executedInput: string;
+    contextBinding?: Record<string, unknown>;
+    route?: unknown;
+    measurement?: unknown;
+    artifactSet?: unknown;
+}
+export interface EvalRun {
+    runId: string;
+    results: EvalResult[];
+    completed: boolean;
+    traces?: EvalTrace[];
+}
+export declare function evaluate(agent: {
+    run(input: string): Promise<{
+        output: string;
+    }>;
+}, options: {
+    dataset: Dataset;
+    evaluators: Evaluator[];
+    runId?: string;
+    includeTrace?: boolean;
+}): Promise<EvalRun>;

package/dist/evals/public.js

@@ -0,0 +1,25 @@
+/** Public evaluation language. Runtime evidence remains available through the runtime subpath. */
+export { judge, buildEvalMessages, parseVerdict, verdictOutputSchema } from "../runtime/eval.js";
+export async function evaluate(agent, options) {
+    const results = [];
+    const traces = [];
+    for (const testCase of options.dataset.cases) {
+        const output = await agent.run(testCase.input);
+        const scores = {};
+        for (const evaluator of options.evaluators)
+            scores[evaluator.name] = await evaluator.evaluate({ testCase, output: output.output });
+        results.push({ caseId: testCase.id, output: output.output, scores });
+        if (options.includeTrace) {
+            const evidence = output;
+            traces.push({
+                caseId: testCase.id,
+                executedInput: testCase.input,
+                ...(testCase.metadata ? { contextBinding: testCase.metadata } : {}),
+                ...(evidence.route !== undefined ? { route: evidence.route } : {}),
+                ...(evidence.usage !== undefined ? { measurement: evidence.usage } : {}),
+                ...(evidence.artifacts !== undefined ? { artifactSet: evidence.artifacts } : {}),
+            });
+        }
+    }
+    return { runId: options.runId ?? crypto.randomUUID(), results, completed: true, ...(options.includeTrace ? { traces } : {}) };
+}

package/dist/guardrail.d.ts

@@ -1,6 +1,9 @@
-/** Public guardrail declaration. Execution/lowering belongs to a later governance card. */
+import type { GovernancePolicy } from "./governance.js";
+/** Public guardrail declaration. A policy-bearing guardrail lowers into host governance. */
 export interface Guardrail {
     name: string;
     description?: string;
     metadata?: Record<string, unknown>;
+    /** Optional executable governance policy. A descriptive guardrail without this field is inert. */
+    policy?: GovernancePolicy;
 }

package/dist/handoff-target.d.ts

@@ -3,6 +3,8 @@ import type { JsonSchema } from "./runtime/output-schema.js";
 export type AgentRef = string | {
     name: string;
 };
+/** Canonical lowering primitive shared by handoff authorization and workflow nodes. */
+export declare function agentRefName(ref: AgentRef): string;
 export interface Handoff {
     agent: AgentRef;
     description?: string;

package/dist/handoff-target.js

@@ -1 +1,7 @@
-export {};
+/** Canonical lowering primitive shared by handoff authorization and workflow nodes. */
+export function agentRefName(ref) {
+    const name = typeof ref === "string" ? ref : ref.name;
+    if (!name)
+        throw new Error("agent reference requires a non-empty name");
+    return name;
+}

package/dist/index.d.ts

@@ -1,31 +1,18 @@
-export { runAgent, runFanout } from "./runtime/facade.js";
-export { runLoop, LoopDriver, foldLoopState } from "./runtime/loop-driver.js";
-export type { LoopSpec, LoopOutcome } from "./runtime/loop-driver.js";
-export type { RunAgentOptions, RunFanoutOptions } from "./runtime/facade.js";
-export { RuntimeRunner, collectText } from "./runtime/runner.js";
-export type { RuntimeOptions, KernelReliabilityOptions, OperationCancellationReason, PromptBudget, SchedulerPolicy } from "./runtime/runner.js";
-export { PayloadStore } from "./runtime/payload-store.js";
-export type { PayloadStoreConfig } from "./runtime/payload-store.js";
+export { createAgent } from "./agent-facade.js";
+export type { AgentDefinition, AgentRunOptions, AgentSession, AgentRuntime, DelegationRequest, DelegationResult, MemoryInput, RecallOptions, RunResult, SessionRef, } from "./agent-facade.js";
+export { collectText } from "./runtime/runner.js";
 export type { InstructionProfile, NudgeRule, NudgeTrigger } from "./harness/public.js";
 export type { SignalPolicy } from "./runtime/os-profile.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";
-export type { SessionLog, SessionEvent, SessionEventKind } from "./runtime/session-log.js";
+export type { SessionEvent, SessionEventKind } from "./runtime/session-log.js";
 export { SESSION_EVENT_KINDS } from "./runtime/session-log.js";
 export { CANONICAL_CONTENT_PARTS_PREFIX, encodeCanonicalContentParts, decodeCanonicalContentParts, } from "./runtime/kernel-step.js";
-export { FileKernelJournal, InMemoryKernelJournal, JournalCasConflictError, JournalIntegrityError, JournalIoError, } from "./runtime/kernel-journal.js";
-export type { CheckpointCandidate, InstalledCheckpoint, JournalAppendReceipt, JournalEntry, JournalHead, JournalPruneReceipt, JournalRecordInput, KernelJournal, } from "./runtime/kernel-journal.js";
-export { diagnoseKernelJournal } from "./runtime/kernel-doctor.js";
-export type { KernelJournalDiagnosis } from "./runtime/kernel-doctor.js";
 export { InMemoryGroupBudgetStore, GroupBudgetScope } from "./runtime/run-group.js";
 export type { RunGroup, GroupBudgetStore, GroupLedger, GroupCharge, GroupMember, GroupBudgetRequest, GroupBudgetReservation, } from "./runtime/run-group.js";
 export { InMemoryEventStream, isVisibleTo } from "./runtime/event-stream.js";
 export type { EventStream, EventStreamOptions, BlackboardEvent, EventViewer } from "./runtime/event-stream.js";
 export type { ObserverFailure, ObserverErrorHandler } from "./runtime/reliability.js";
-export { ManagedTaskScope, operationAbortSignal } from "./runtime/reliability.js";
 export type { OperationContext, BackgroundTaskFailure, BackgroundTaskErrorHandler } from "./runtime/reliability.js";
 export { reactByMention, directorDriven, roundRobin, firstNonEmpty, union } from "./runtime/turn-policy.js";
 export type { TurnPolicy, PeerView } from "./runtime/turn-policy.js";
@@ -45,30 +32,27 @@ export { OpenAIResponsesProvider } from "./providers/openai-responses.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 { createProviderRequestPlan, createProviderRequestPlanForProvider, estimateProviderPromptTokens, measurementForPlan, normalizeProviderUsage, priceProviderUsage, recordPromptMeasurement, resolveProviderRoute } from "./providers/request-plan.js";
-export type { CostObservation, NormalizedProviderUsage, PricingSnapshot, ProviderRequestEndpoint, ProviderRequestPlan, RecordedPromptMeasurement, ResolvedProviderRoute } from "./providers/request-plan.js";
-export { FULL_FOOTPRINT_USAGE_ACCOUNTING_POLICY, providerAttemptToRecord } from "./runtime/execution-evidence.js";
-export type { InvocationOutcome, ModelInvocation, ProviderAttempt, ProviderAttemptRecord, ProviderAttemptStatus, UsageAccountingPolicy, ModelUsageSettlement } from "./runtime/execution-evidence.js";
 export { VERIFIABLE_REPORT_SCHEMA, VERIFIABLE_FORK_SCHEMA, assertVerifiableReportSchema, createVerifiableRuntimeAdapter, createNativeVerifiableRuntimeAdapter, VerifiableOperation, } from "./runtime/verifiable-report.js";
 export type { VerifiableCommand, CheckVerdict, VerifiableForkManifest, ForkPlan, VerifiableEvidence, VerifyOptions, ReplayOptions, VerifiableRuntimeAdapter, VerifiableReport, VerifiableOperationJson, } from "./runtime/verifiable-report.js";
-export { createEvolutionRuntimeAdapter, createNativeEvolutionRuntimeAdapter, EvolutionRuntime } from "./runtime/evolution.js";
-export type { ActivationBinding, ArtifactKind, ArtifactManifest, ArtifactRef, ArtifactSet, ArtifactVersion, ContextEntryRef, ContextEntrySource, ContextExecutionInput, ContextPreparationRequest, ContextPlan, ContextPlanAction, ContextSelection, ContextState, EvaluationContextBinding, EvaluationFact, EvaluationGate, EvaluationMetric, EvaluationRun, EvolutionBundle, EvolutionProposal, EvolutionReport, EvolutionVerdict, EvolutionViolation, PromotionDecision, PromotionOutcome, EvolutionStore, } from "./runtime/evolution.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 { AgentCapabilityIR, 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 { createTextKnowledgeSource } from "./knowledge/public.js";
+export type { TextKnowledgeDocument } from "./knowledge/public.js";
+export { agentRefName } from "./handoff-target.js";
 export type { AgentRef, Handoff } from "./handoff-target.js";
 export type { Session } from "./session.js";
+export { createWorkflow } from "./workflow/definition.js";
+export type { WorkflowDefinition, WorkflowStep, WorkflowResult } from "./workflow/definition.js";
+export { evaluate } from "./evals/public.js";
+export type { Dataset, DatasetCase, Evaluator, EvalResult, EvalRun, EvalTrace } from "./evals/public.js";
 export type { RuntimeSignal, SignalClaim, SignalDeliveryReceipt, SignalSource, } from "./signals/types.js";
-export type { ProviderMessage, ToolCall, ToolExecutionResult, 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, ProviderWireEvidence, ProviderTransportTelemetry, } from "./types.js";
+export type { ModelMessage, RuntimeMessage, StoredMessage, WireMessage, ToolCall, ToolExecutionResult, 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, ProviderWireEvidence, ProviderTransportTelemetry, } 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";
-export { createContextPreparationAdapter, createNativeContextPreparationAdapter } from "./runtime/context.js";
-export type { ContextPrepareJson, ContextVerifyJson, ContextPrepared, ContextProviderPreparationRequest } from "./runtime/context.js";
-export type { PreparedProviderRequest } from "./types.js";
+export type { WorkflowSpec, WorkflowNodeSpec, SchedulingFactors, WorkflowDependencyPolicy, WorkflowContextInclude, WorkflowDependencyMode, WorkflowContextPolicy, WorkflowNodeStatus, WorkflowNodeOutcome, WorkflowOutcome, } from "./types/agent.js";

package/dist/index.js

@@ -1,5 +1,5 @@
 // ╔══════════════════════════════════════════════════════════════════════════╗
-// ║ @deepstrike/sdk — root surface (v0.2.30).                                      ║
+// ║ @deepstrike/sdk — root surface (v0.2.72).                                      ║
 // ║                                                                            ║
 // ║ This is the intent layer: run an agent, run a workflow, author a tool,     ║
 // ║ pick a provider. Advanced machinery lives behind subpaths:                 ║
@@ -11,25 +11,17 @@
 // ║   @deepstrike/sdk/os         — profiles, diagnostics, signals, replay tests ║
 // ╚══════════════════════════════════════════════════════════════════════════╝
 // ── Start here: the canonical entry points ─────────────────────────────────
-export { runAgent, runFanout } from "./runtime/facade.js";
 // ③ dynamic loop agents: self-pacing rounds over the kernel pacing trap.
-export { runLoop, LoopDriver, foldLoopState } from "./runtime/loop-driver.js";
-export { RuntimeRunner, collectText } from "./runtime/runner.js";
-export { PayloadStore } from "./runtime/payload-store.js";
+export { createAgent } from "./agent-facade.js";
+export { collectText } from "./runtime/runner.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";
 // Registered session-event vocabulary (F9/S3; manifest-pinned by sdk-conformance, P7-S4)
 export { SESSION_EVENT_KINDS } from "./runtime/session-log.js";
 // ── content-parts-v1 registered encoding (F14/B5; byte-pinned by sdk-conformance) ──
 export { CANONICAL_CONTENT_PARTS_PREFIX, encodeCanonicalContentParts, decodeCanonicalContentParts, } from "./runtime/kernel-step.js";
 // ── Durable transaction capability (Canonical Kernel ABI §9.1) ──────────────
-export { FileKernelJournal, InMemoryKernelJournal, JournalCasConflictError, JournalIntegrityError, JournalIoError, } from "./runtime/kernel-journal.js";
-export { diagnoseKernelJournal } from "./runtime/kernel-doctor.js";
 export { InMemoryGroupBudgetStore, GroupBudgetScope } from "./runtime/run-group.js";
 export { InMemoryEventStream, isVisibleTo } from "./runtime/event-stream.js";
-export { ManagedTaskScope, operationAbortSignal } from "./runtime/reliability.js";
 export { reactByMention, directorDriven, roundRobin, firstNonEmpty, union } from "./runtime/turn-policy.js";
 export { ReactiveSession, readRecentTool } from "./runtime/reactive-session.js";
 export { InMemoryReactionCheckpointStore, ReactionInProgressError } from "./runtime/reaction-checkpoint.js";
@@ -44,15 +36,14 @@ export { OpenAIProvider } from "./providers/openai.js";
 export { OpenAIResponsesProvider } from "./providers/openai-responses.js";
 export { createProvider, createProviderAsync, resolveProviderRuntime, resolveProviderRuntimeAsync } from "./providers/catalog.js";
 export { UnsupportedModalityError } from "./providers/base.js";
-export { createProviderRequestPlan, createProviderRequestPlanForProvider, estimateProviderPromptTokens, measurementForPlan, normalizeProviderUsage, priceProviderUsage, recordPromptMeasurement, resolveProviderRoute } from "./providers/request-plan.js";
-export { FULL_FOOTPRINT_USAGE_ACCOUNTING_POLICY, providerAttemptToRecord } from "./runtime/execution-evidence.js";
 export { VERIFIABLE_REPORT_SCHEMA, VERIFIABLE_FORK_SCHEMA, assertVerifiableReportSchema, createVerifiableRuntimeAdapter, createNativeVerifiableRuntimeAdapter, VerifiableOperation, } from "./runtime/verifiable-report.js";
-export { createEvolutionRuntimeAdapter, createNativeEvolutionRuntimeAdapter, EvolutionRuntime } from "./runtime/evolution.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 { createTextKnowledgeSource } from "./knowledge/public.js";
+export { agentRefName } from "./handoff-target.js";
+export { createWorkflow } from "./workflow/definition.js";
+export { evaluate } from "./evals/public.js";
 export { DurableContentError, decodeDurableContent, decodeDurableToolResult, encodeDurableContent, encodeDurableToolResult, toolOutputBlocksToDurable, durableBlocksToToolOutput, } from "./runtime/durable-content.js";
-export { createContextPreparationAdapter, createNativeContextPreparationAdapter } from "./runtime/context.js";

package/dist/kernel.d.ts

@@ -1,4 +1,4 @@
-import type { ProviderMessage } from "./types.js";
+import type { ModelMessage } from "./types.js";
 /**
  * M2 资源配额 — declarative resource limits enforced at the kernel's single syscall trap.
  *
@@ -150,7 +150,7 @@ export interface CanonicalKernelInstance {
 interface KernelModule {
     CanonicalKernel: new () => CanonicalKernelInstance;
     SignalRouter: new (maxQueueSize: number) => SignalRouterInstance;
-    buildEvalMessages(goal: string, criteria: NativeCriterion[], result: string, attempt: number, extractSkillOnPass: boolean): ProviderMessage[];
+    buildEvalMessages(goal: string, criteria: NativeCriterion[], result: string, attempt: number, extractSkillOnPass: boolean): ModelMessage[];
     parseVerdict(content: string): Verdict;
     verdictOutputSchema(extractSkillOnPass: boolean): string;
     verifiableOperationJson(request: string): string;

package/dist/knowledge/public.d.ts

@@ -27,3 +27,5 @@ export interface Knowledge {
     metadata?: Record<string, unknown>;
     providerOptions?: Record<string, unknown>;
 }
+export { createTextKnowledgeSource } from "./source.js";
+export type { TextKnowledgeDocument } from "./source.js";

package/dist/knowledge/public.js

@@ -1 +1 @@
-export {};
+export { createTextKnowledgeSource } from "./source.js";

package/dist/knowledge/source.d.ts

@@ -3,3 +3,10 @@ export interface KnowledgeSource {
     /** One-time warmup called before the first run (load index, open connection, etc.). */
     init(): Promise<void>;
 }
+export interface TextKnowledgeDocument {
+    id?: string;
+    name?: string;
+    content: string;
+}
+/** Deterministic local retrieval for inline text knowledge; external sources keep explicit bindings. */
+export declare function createTextKnowledgeSource(documents: TextKnowledgeDocument[]): KnowledgeSource;

package/dist/knowledge/source.js

@@ -1 +1,20 @@
-export {};
+/** Deterministic local retrieval for inline text knowledge; external sources keep explicit bindings. */
+export function createTextKnowledgeSource(documents) {
+    const prepared = documents.filter(document => document.content.trim()).map((document, index) => ({
+        ...document,
+        key: document.id ?? document.name ?? `text-${index}`,
+        terms: new Set(document.content.toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? []),
+    }));
+    return {
+        async init() { },
+        async retrieve(goal, topK = 5) {
+            const queryTerms = new Set(goal.toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? []);
+            return prepared
+                .map(document => ({ document, score: [...queryTerms].reduce((score, term) => score + (document.terms.has(term) ? 1 : 0), 0) }))
+                .sort((left, right) => right.score - left.score || left.document.key.localeCompare(right.document.key))
+                .filter(item => item.score > 0 || queryTerms.size === 0)
+                .slice(0, Math.max(0, topK))
+                .map(({ document }) => document.name ? `[Knowledge: ${document.name}]\n${document.content}` : document.content);
+        },
+    };
+}

package/dist/memory/protocols.d.ts

@@ -1,6 +1,6 @@
-import type { ProviderMessage, ContentPart } from "../types.js";
+import type { ModelMessage, ContentPart } from "../types.js";
 export interface SessionMessage {
-    role: ProviderMessage["role"];
+    role: ModelMessage["role"];
     content: string;
     /** Structured multimodal parts. Preserved for round-trip fidelity (e.g. tool result messages). */
     contentParts?: ContentPart[];

package/dist/projection-pairs.d.ts

@@ -0,0 +1,43 @@
+/** SPC-028-09: registered authority/projection relationships. */
+export interface ProjectionPair {
+    readonly authority: string;
+    readonly projection: string;
+    readonly crossingFunction: string;
+}
+export declare const PROJECTION_PAIRS: {
+    readonly Message: {
+        readonly authority: "ModelMessage";
+        readonly projection: "WireMessage";
+        readonly crossingFunction: "adapter.encode/decode";
+    };
+    readonly Content: {
+        readonly authority: "ContentPart[]";
+        readonly projection: "string";
+        readonly crossingFunction: "projectContentToText";
+    };
+    readonly ToolResult: {
+        readonly authority: "contentParts";
+        readonly projection: "output";
+        readonly crossingFunction: "projectToolOutputToText";
+    };
+    readonly StopReason: {
+        readonly authority: "GenerationProtocol stop reason";
+        readonly projection: "CanonicalStopReason";
+        readonly crossingFunction: "normalizeStopReason";
+    };
+    readonly ToolCall: {
+        readonly authority: "ToolCall";
+        readonly projection: "ToolCallEvent";
+        readonly crossingFunction: "decodeToolCall";
+    };
+    readonly ResourceQuota: {
+        readonly authority: "ResourceQuota";
+        readonly projection: "QuotaSnapshot";
+        readonly crossingFunction: "projectQuota";
+    };
+    readonly TerminationReason: {
+        readonly authority: "Kernel terminal fact";
+        readonly projection: "RunResult.status";
+        readonly crossingFunction: "statusFromDone";
+    };
+};

package/dist/projection-pairs.js

@@ -0,0 +1,9 @@
+export const PROJECTION_PAIRS = {
+    Message: { authority: "ModelMessage", projection: "WireMessage", crossingFunction: "adapter.encode/decode" },
+    Content: { authority: "ContentPart[]", projection: "string", crossingFunction: "projectContentToText" },
+    ToolResult: { authority: "contentParts", projection: "output", crossingFunction: "projectToolOutputToText" },
+    StopReason: { authority: "GenerationProtocol stop reason", projection: "CanonicalStopReason", crossingFunction: "normalizeStopReason" },
+    ToolCall: { authority: "ToolCall", projection: "ToolCallEvent", crossingFunction: "decodeToolCall" },
+    ResourceQuota: { authority: "ResourceQuota", projection: "QuotaSnapshot", crossingFunction: "projectQuota" },
+    TerminationReason: { authority: "Kernel terminal fact", projection: "RunResult.status", crossingFunction: "statusFromDone" },
+};

package/dist/providers/anthropic-adapter.d.ts

@@ -1,4 +1,4 @@
-import type { ProviderMessage, ProviderReplay, ProviderUsage, ToolCall } from "../types.js";
+import type { ModelMessage, ProviderReplay, ProviderUsage, ToolCall } from "../types.js";
 import type { CanonicalAdapterInput } from "./content-normalization.js";
 import { type AdapterDecodeInput, type AdapterOutput, type AdapterStreamInput, type CanonicalStopReason, type ProtocolAdapter } from "./protocol-adapter.js";
 export declare const ANTHROPIC_TEXTUAL_TOOL_CALL_START_MARKER = "<\uFF5C\uFF5CDSML\uFF5C\uFF5Ctool_calls>";
@@ -47,7 +47,7 @@ export declare class AnthropicMessagesAdapter implements ProtocolAdapter<Anthrop
     readonly protocolCapabilities: import("./protocol-capabilities.js").ProtocolRuntimeCapabilities;
     buildRequest(input: CanonicalAdapterInput): AnthropicRequestPlan;
     decodeComplete(raw: Record<string, any>, decodeInput: AdapterDecodeInput): {
-        message: ProviderMessage;
+        message: ModelMessage;
         replay?: ProviderReplay;
     };
     createStreamState(input: AdapterStreamInput): AnthropicStreamState;

package/dist/providers/anthropic.d.ts

@@ -1,5 +1,5 @@
 import type { PreparedProviderRequest, ProviderRunState as PreparedRunState } from "../types.js";
-import type { LLMProvider, ProviderMessage, PromptMeasurement, ProviderDescriptor, ProviderReplay, ProviderTransportTelemetry, RenderedContext, RuntimePolicy, StreamEvent, ToolSchema } from "../types.js";
+import type { LLMProvider, ModelMessage, PromptMeasurement, ProviderDescriptor, ProviderReplay, ProviderTransportTelemetry, RenderedContext, RuntimePolicy, StreamEvent, ToolSchema } from "../types.js";
 import { type CanonicalAdapterInput } from "./content-normalization.js";
 export interface AnthropicProviderConfig {
     apiKey: string;
@@ -35,11 +35,11 @@ export declare class AnthropicProvider implements LLMProvider {
     private lastTelemetry;
     peekTransportTelemetry(): ProviderTransportTelemetry | undefined;
     bindResolvedRuntime(resolved: ResolvedAnthropicRuntime): void;
-    peekProviderReplay(message: Pick<ProviderMessage, "content" | "toolCalls">): ProviderReplay | undefined;
-    seedProviderReplay(message: Pick<ProviderMessage, "content" | "toolCalls">, replay: ProviderReplay): void;
+    peekProviderReplay(message: Pick<ModelMessage, "content" | "toolCalls">): ProviderReplay | undefined;
+    seedProviderReplay(message: Pick<ModelMessage, "content" | "toolCalls">, replay: ProviderReplay): void;
     private adapterInput;
     private buildPlan;
-    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<ProviderMessage>;
+    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<ModelMessage>;
     /** Native measurement belongs to the verified official endpoint, not the wire protocol. */
     countTokens(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<PromptMeasurement>;
     private countPlan;

package/dist/providers/base.d.ts

@@ -1,4 +1,4 @@
-import type { ProviderMessage, RenderedContext } from "../types.js";
+import type { ModelMessage, RenderedContext } from "../types.js";
 export declare class CircuitBreaker {
     private readonly openAfter;
     private readonly resetAfter;
@@ -53,7 +53,7 @@ export declare class UnsupportedModalityError extends Error {
     readonly provider: string;
     constructor(modality: string, provider: string);
 }
-export declare function toAnthropicContent(msg: ProviderMessage): string | Array<Record<string, unknown>>;
+export declare function toAnthropicContent(msg: ModelMessage): string | Array<Record<string, unknown>>;
 /**
  * History turns with the volatile State turn appended as the latest turn, for
  * providers that render it inline (OpenAI-family, Gemini, Ollama). Appending
@@ -64,14 +64,14 @@ export declare function toAnthropicContent(msg: ProviderMessage): string | Array
  * AnthropicProvider.buildMessages). When `stateTurn` is absent (un-rebuilt
  * binding) the State turn is still inside `turns`, so this returns `turns` as-is.
  */
-export declare function turnsWithStateAppended(context: RenderedContext): ProviderMessage[];
+export declare function turnsWithStateAppended(context: RenderedContext): ModelMessage[];
 /** Convert RenderedContext.turns to Anthropic messages array.
  *  `turns` contains only user / assistant / tool roles — no system filtering needed. */
-export declare function toAnthropicMessages(turns: ProviderMessage[], nativeReplay?: (message: ProviderMessage) => Array<Record<string, unknown>> | undefined): Array<Record<string, unknown>>;
+export declare function toAnthropicMessages(turns: ModelMessage[], nativeReplay?: (message: ModelMessage) => Array<Record<string, unknown>> | undefined): Array<Record<string, unknown>>;
 /** Map an audio MIME type to OpenAI's `input_audio.format` (accepts "mp3" | "wav").
  *  `audio/mpeg` must become "mp3", not the raw "mpeg" subtype. */
 export declare function openaiAudioFormat(mediaType: string | undefined): string;
-export declare function toOpenAIContent(msg: ProviderMessage): string | Array<Record<string, unknown>>;
+export declare function toOpenAIContent(msg: ModelMessage): string | Array<Record<string, unknown>>;
 /** Build the full OpenAI messages array from a RenderedContext.
  *  Prepends systemText as the first system message, then converts turns. */
 export declare function toOpenAIMessageParams(context: RenderedContext): Array<Record<string, unknown>>;