@deepstrike/sdk 0.2.71 → 0.2.73

package/dist/providers/openai.d.ts

@@ -1,6 +1,6 @@
 import type { PreparedProviderRequest, ProviderRunState as PreparedRunState } from "../types.js";
 import OpenAI from "openai";
-import type { LLMProvider, ProviderMessage, ProviderDescriptor, ProviderReplay, ProviderTransportTelemetry, RenderedContext, ReplayabilityAssessment, RuntimePolicy, StreamEvent, ToolSchema } from "../types.js";
+import type { LLMProvider, ModelMessage, ProviderDescriptor, ProviderReplay, ProviderTransportTelemetry, RenderedContext, ReplayabilityAssessment, RuntimePolicy, StreamEvent, ToolSchema } from "../types.js";
 import { CircuitBreaker } from "./base.js";
 import { type CanonicalAdapterInput } from "./content-normalization.js";
 import { OpenAIChatAdapter } from "./openai-chat.js";
@@ -39,11 +39,11 @@ export declare class OpenAIChatProvider implements LLMProvider {
     /** P4-S1: transport facts of the most recent execution. Host evidence only (B7). */
     private lastTelemetry;
     peekTransportTelemetry(): ProviderTransportTelemetry | undefined;
-    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 rememberReplay;
     private adapterInput;
-    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<ProviderMessage>;
+    complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<ModelMessage>;
     prepareRequest(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: PreparedRunState): PreparedProviderRequest;
     stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: PreparedRunState, signal?: AbortSignal): AsyncIterable<StreamEvent>;
     private streamPlan;

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

@@ -1,4 +1,4 @@
-import type { ProviderMessage, ProviderReplay, ProviderRunState, ProviderUsage, StreamEvent } from "../types.js";
+import type { ModelMessage, ProviderReplay, ProviderRunState, ProviderUsage, StreamEvent } from "../types.js";
 import type { CanonicalAdapterInput } from "./content-normalization.js";
 import type { GenerationProtocol, ProtocolRuntimeCapabilities } from "./protocol-capabilities.js";
 export { GEMINI_PROTOCOL_CAPABILITIES, OLLAMA_PROTOCOL_CAPABILITIES, } from "./protocol-capabilities.js";
@@ -19,7 +19,7 @@ export interface ProtocolAdapter<TRequest, TCompleteResponse, TStreamChunk, TStr
     readonly protocolCapabilities: ProtocolRuntimeCapabilities;
     buildRequest(input: CanonicalAdapterInput): TRequest;
     decodeComplete(raw: TCompleteResponse, input: AdapterDecodeInput): {
-        message: ProviderMessage;
+        message: ModelMessage;
         replay?: ProviderReplay;
     };
     createStreamState(input: AdapterStreamInput): TStreamState;

package/dist/providers/protocol-capabilities.d.ts

@@ -1,6 +1,7 @@
 export type InputModality = "text" | "image" | "audio" | "video" | "file";
 export type OutputModality = "text" | "image" | "audio" | "embedding";
 export type GenerationProtocol = "anthropic-messages" | "openai-chat" | "openai-responses" | "gemini" | "ollama-chat";
+export declare const GENERATION_PROTOCOLS: readonly GenerationProtocol[];
 export interface ProtocolRuntimeCapabilities {
     acceptedInputModalities: readonly InputModality[];
     emittedOutputModalities: readonly OutputModality[];

package/dist/providers/protocol-capabilities.js

@@ -1,3 +1,6 @@
+export const GENERATION_PROTOCOLS = [
+    "anthropic-messages", "openai-chat", "openai-responses", "gemini", "ollama-chat",
+];
 export const ANTHROPIC_PROTOCOL_CAPABILITIES = {
     acceptedInputModalities: ["text", "image"],
     emittedOutputModalities: ["text"],

package/dist/providers/public.d.ts

@@ -20,8 +20,10 @@ export { ContentPolicyError, contentDispositionFor } from "./content-policy.js";
 export type { ContentDisposition, ContentPlacement } from "./content-policy.js";
 export { CapabilityRouter } from "./capability-router.js";
 export type { CapabilityRequirement, CapabilityRouteResult } from "./capability-router.js";
-export { createProviderRequestPlan, createProviderRequestPlanForProvider, estimateProviderPromptTokens, measurementForPlan, normalizeProviderUsage, priceProviderUsage, recordPromptMeasurement } from "./request-plan.js";
-export type { CostObservation, NormalizedProviderUsage, PricingSnapshot, ProviderRequestEndpoint, ProviderRequestPlan, RecordedPromptMeasurement } from "./request-plan.js";
+export { createProviderRequestPlan, createProviderRequestPlanForProvider, estimateProviderPromptTokens, measurementForPlan, normalizeProviderUsage, priceProviderUsage, recordPromptMeasurement, resolveProviderRoute } from "./request-plan.js";
+export type { CostObservation, NormalizedProviderUsage, PricingSnapshot, ProviderRequestEndpoint, ProviderRequestPlan, RecordedPromptMeasurement, ResolvedProviderRoute } from "./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 { CredentialResolutionError, OAuthCredentialResolver, redactCredential, resolveCredential } from "./credentials.js";
 export type { CredentialOptions, CredentialRequest, CredentialResolver, OAuthAccessToken, OAuthCredentialResolverOptions, OAuthRefreshRequest, ProviderCredential, } from "./credentials.js";
 export { DynamicModelCatalog, StaticModelCatalog } from "./model-catalog.js";

package/dist/providers/public.js

@@ -16,7 +16,8 @@ export { ProviderError, classifyProviderError, } from "./provider-error.js";
 export { endpointProfiles } from "./endpoints.js";
 export { ContentPolicyError, contentDispositionFor } from "./content-policy.js";
 export { CapabilityRouter } from "./capability-router.js";
-export { createProviderRequestPlan, createProviderRequestPlanForProvider, estimateProviderPromptTokens, measurementForPlan, normalizeProviderUsage, priceProviderUsage, recordPromptMeasurement } from "./request-plan.js";
+export { createProviderRequestPlan, createProviderRequestPlanForProvider, estimateProviderPromptTokens, measurementForPlan, normalizeProviderUsage, priceProviderUsage, recordPromptMeasurement, resolveProviderRoute } from "./request-plan.js";
+export { FULL_FOOTPRINT_USAGE_ACCOUNTING_POLICY, providerAttemptToRecord } from "../runtime/execution-evidence.js";
 export { CredentialResolutionError, OAuthCredentialResolver, redactCredential, resolveCredential } from "./credentials.js";
 export { DynamicModelCatalog, StaticModelCatalog } from "./model-catalog.js";
 export { modelRegistry, resolveEffectiveCapability } from "./model-registry.js";

package/dist/providers/replay-validator.d.ts

@@ -1,4 +1,4 @@
-import type { ProviderMessage, ProviderDescriptor, ProviderReplay, RenderedContext, ReplayabilityAssessment } from "../types.js";
+import type { ModelMessage, ProviderDescriptor, ProviderReplay, RenderedContext, ReplayabilityAssessment } from "../types.js";
 export type { ReplayabilityAssessment };
 export declare class ProviderReplayValidationError extends Error {
     constructor(message: string);
@@ -20,7 +20,7 @@ export interface OpenAIChatReplayValidationOptions {
      * rather than fail outright.
      */
     degradeMissingReasoning?: boolean;
-    replayForAssistant?: (message: Pick<ProviderMessage, "content" | "toolCalls">) => ProviderReplay | Record<string, unknown> | undefined;
+    replayForAssistant?: (message: Pick<ModelMessage, "content" | "toolCalls">) => ProviderReplay | Record<string, unknown> | undefined;
 }
 export declare function validateOpenAIChatReplay(context: RenderedContext, options?: OpenAIChatReplayValidationOptions): void;
 /**
@@ -29,4 +29,4 @@ export declare function validateOpenAIChatReplay(context: RenderedContext, optio
  * embedder decide per-candidate whether to keep thinking on, disable it, or
  * skip the candidate — before sending.
  */
-export declare function assessReasoningReplay(turns: ProviderMessage[], options: Pick<OpenAIChatReplayValidationOptions, "replayForAssistant">): ReplayabilityAssessment;
+export declare function assessReasoningReplay(turns: ModelMessage[], options: Pick<OpenAIChatReplayValidationOptions, "replayForAssistant">): ReplayabilityAssessment;

package/dist/reactions.d.ts

@@ -0,0 +1,2 @@
+export { InMemoryReactionCheckpointStore, } from "./runtime/reaction-checkpoint.js";
+export type { ReactionCheckpointClaim, ReactionCheckpointClaimResult, ReactionCheckpointReceipt, ReactionCheckpointStore, InMemoryReactionCheckpointStoreOptions, } from "./runtime/reaction-checkpoint.js";

package/dist/reactions.js

@@ -0,0 +1,3 @@
+// Public reaction checkpoint contract. The implementation remains behind the
+// runtime boundary while this module gives SDK users a stable host-owned store.
+export { InMemoryReactionCheckpointStore, } from "./runtime/reaction-checkpoint.js";

package/dist/runtime/archive.d.ts

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

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

@@ -1,5 +1,5 @@
 import type { CanonicalKernelInstance, CanonicalRestoreCost } from "../kernel.js";
-import type { ProviderMessage } from "../types.js";
+import type { ModelMessage } from "../types.js";
 import { type InstalledCheckpoint, type KernelJournal } from "./kernel-journal.js";
 import { type KernelObservation, type KernelRunnerAction } from "./kernel-step.js";
 export declare const MAX_CHAIN_POSITION = 1000000000000;
@@ -120,7 +120,7 @@ export declare class CanonicalRunnerRuntime {
     isTerminal(): boolean;
     recoveryContentBytes(): number;
     preservedRefs(): string[];
-    drainNewMessages(): ProviderMessage[];
+    drainNewMessages(): ModelMessage[];
     drainHostObservations(): KernelObservationLike[];
     terminal(): Record<string, unknown> | undefined;
     localSubagentsSpawned(): number;

package/dist/runtime/context-manager.d.ts

@@ -0,0 +1,56 @@
+export type ContextItemKind = "core" | "task" | "skill" | "memory" | "knowledge" | "workflow";
+export type ContextItemScope = "run" | "session" | "step" | "turn";
+export interface ContextItem {
+    id: string;
+    kind: ContextItemKind;
+    content: string;
+    scope: ContextItemScope;
+    priority: number;
+    tokenCost?: number;
+    confidence?: number;
+    expiresAt?: number;
+    pinned?: boolean;
+    source: {
+        type: string;
+        id?: string;
+    };
+}
+export interface ContextManagerOptions {
+    maxTokens: number;
+    responseReserveTokens?: number;
+    now?: () => number;
+    onEvent?: (event: ContextLedgerEvent) => void;
+}
+export type ContextLedgerEventKind = "context_added" | "context_removed" | "context_expired" | "context_selected";
+export interface ContextLedgerEvent {
+    kind: ContextLedgerEventKind;
+    itemId?: string;
+    source?: ContextItem["source"];
+    fingerprint: string;
+    at: number;
+}
+export interface ContextSnapshot {
+    items: ContextItem[];
+    selected: ContextItem[];
+    usedTokens: number;
+    availableTokens: number;
+    fingerprint: string;
+}
+export declare function estimateContextTokens(content: string): number;
+/** Host-side context budget and lifecycle manager. Kernel context remains the execution authority. */
+export declare class ContextManager {
+    private readonly items;
+    private readonly now;
+    private readonly budget;
+    private readonly onEvent?;
+    constructor(options: ContextManagerOptions);
+    upsert(item: ContextItem): void;
+    remove(id: string): void;
+    expire(now?: number): string[];
+    select(now?: number): ContextItem[];
+    snapshot(now?: number): ContextSnapshot;
+    fingerprint(now?: number): string;
+    private selectWithoutEvents;
+    private emit;
+    private fingerprintOf;
+}

package/dist/runtime/context-manager.js

@@ -0,0 +1,112 @@
+import { createHash } from "node:crypto";
+export function estimateContextTokens(content) {
+    return Math.max(1, Math.ceil(content.length / 4));
+}
+/** Host-side context budget and lifecycle manager. Kernel context remains the execution authority. */
+export class ContextManager {
+    items = new Map();
+    now;
+    budget;
+    onEvent;
+    constructor(options) {
+        if (!Number.isSafeInteger(options.maxTokens) || options.maxTokens < 1)
+            throw new RangeError("maxTokens must be a safe integer >= 1");
+        const reserve = options.responseReserveTokens ?? 0;
+        if (!Number.isSafeInteger(reserve) || reserve < 0 || reserve >= options.maxTokens)
+            throw new RangeError("responseReserveTokens must be >= 0 and lower than maxTokens");
+        this.budget = options.maxTokens - reserve;
+        this.now = options.now ?? Date.now;
+        this.onEvent = options.onEvent;
+    }
+    upsert(item) {
+        const tokenCost = item.tokenCost ?? estimateContextTokens(item.content);
+        if (!Number.isSafeInteger(tokenCost) || tokenCost < 1)
+            throw new RangeError(`context item "${item.id}" has invalid tokenCost`);
+        this.items.set(item.id, { ...item, tokenCost });
+        this.emit({ kind: "context_added", itemId: item.id, source: item.source });
+    }
+    remove(id) {
+        const item = this.items.get(id);
+        if (!item)
+            return;
+        this.items.delete(id);
+        this.emit({ kind: "context_removed", itemId: id, source: item.source });
+    }
+    expire(now = this.now()) {
+        const removed = [];
+        for (const [id, item] of this.items) {
+            if (item.expiresAt !== undefined && item.expiresAt <= now && !item.pinned) {
+                this.items.delete(id);
+                removed.push(id);
+                this.emit({ kind: "context_expired", itemId: id, source: item.source });
+            }
+        }
+        return removed;
+    }
+    select(now = this.now()) {
+        this.expire(now);
+        const selected = this.selectWithoutEvents();
+        this.emit({ kind: "context_selected" });
+        return selected;
+    }
+    snapshot(now = this.now()) {
+        this.expire(now);
+        const items = [...this.items.values()];
+        const selected = this.select(now);
+        const usedTokens = selected.reduce((sum, item) => sum + (item.tokenCost ?? estimateContextTokens(item.content)), 0);
+        return {
+            items,
+            selected,
+            usedTokens,
+            availableTokens: Math.max(0, this.budget - usedTokens),
+            fingerprint: this.fingerprint(now),
+        };
+    }
+    fingerprint(now = this.now()) {
+        this.expire(now);
+        return this.fingerprintOf(this.selectWithoutEvents());
+    }
+    selectWithoutEvents() {
+        const candidates = [...this.items.values()].sort((left, right) => Number(Boolean(right.pinned)) - Number(Boolean(left.pinned))
+            || right.priority - left.priority
+            || (right.confidence ?? 0) - (left.confidence ?? 0)
+            || left.id.localeCompare(right.id));
+        const selected = [];
+        let usedTokens = 0;
+        for (const item of candidates) {
+            const cost = item.tokenCost ?? estimateContextTokens(item.content);
+            if (usedTokens + cost > this.budget && !item.pinned)
+                continue;
+            selected.push(item);
+            usedTokens += cost;
+        }
+        return selected;
+    }
+    emit(event) {
+        try {
+            this.onEvent?.({ ...event, fingerprint: this.fingerprintOf(this.selectWithoutEvents()), at: this.now() });
+        }
+        catch {
+            // Ledger observers are diagnostic only; a faulty sink must never reject context admission.
+        }
+    }
+    fingerprintOf(selected) {
+        const hash = createHash("sha256");
+        for (const item of selected) {
+            hash.update(JSON.stringify({
+                id: item.id,
+                kind: item.kind,
+                content: item.content,
+                scope: item.scope,
+                priority: item.priority,
+                tokenCost: item.tokenCost ?? estimateContextTokens(item.content),
+                confidence: item.confidence ?? null,
+                expiresAt: item.expiresAt ?? null,
+                pinned: Boolean(item.pinned),
+                source: { type: item.source.type, id: item.source.id ?? null },
+            }));
+            hash.update("\n");
+        }
+        return `ctx-${hash.digest("hex")}`;
+    }
+}

package/dist/runtime/eval.d.ts

@@ -9,7 +9,7 @@
  * The judge is a single LLM call: build the eval prompt → stream → parse verdict. No retry loop,
  * no skill extraction, no loop state. Use `AttemptLoop` if you want the retry/refine flow.
  */
-import type { LLMProvider, ProviderMessage } from "../types.js";
+import type { LLMProvider, ModelMessage } from "../types.js";
 export interface Criterion {
     /** The criterion text the judge evaluates against. */
     text: string;
@@ -52,7 +52,7 @@ export interface JudgeArgs {
  * Exposed in case a caller wants to render the prompt without calling the LLM (e.g., dry-run cost
  * estimation, fixture generation). For the common case, use `judge()`.
  */
-export declare function buildEvalMessages(goal: string, criteria: Criterion[], result: string): ProviderMessage[];
+export declare function buildEvalMessages(goal: string, criteria: Criterion[], result: string): ModelMessage[];
 /** Parse a Verdict from raw judge-LLM text. Throws on schema mismatch. */
 export declare function parseVerdict(text: string): Verdict;
 /** The JSON Schema the kernel expects judge output to conform to. */

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

@@ -1,4 +1,4 @@
-import type { EntropySample, ProviderMessage, RenderedContext, TaskUpdate, ToolCall, ToolExecutionResult, ToolSchema } from "../types.js";
+import type { EntropySample, ModelMessage, RenderedContext, TaskUpdate, ToolCall, ToolExecutionResult, ToolSchema } from "../types.js";
 import type { SkillMetadata } from "../skills/loader.js";
 import type { RollbackReason } from "./session-log.js";
 export declare const CANONICAL_CONTENT_PARTS_PREFIX = "[[deepstrike-content-parts]]";
@@ -15,7 +15,7 @@ export interface KernelLoopResult {
     termination: string;
     turnsUsed: number;
     totalTokensUsed: number;
-    finalMessage?: ProviderMessage;
+    finalMessage?: ModelMessage;
     /** ③ loop-agent: the kernel-adjudicated after-round decision (absent on non-loop runs). */
     paceDecision?: PaceDecision;
 }
@@ -76,7 +76,7 @@ export type KernelRunnerAction = {
 } | {
     kind: "archive_page_out";
     effectId: string;
-    archived?: ProviderMessage[];
+    archived?: ModelMessage[];
     handleId?: string;
     payload?: {
         content: string;
@@ -213,7 +213,7 @@ export declare function archivePresentationFromObservations(observations: readon
 };
 export declare function toolSchemaToKernel(schema: ToolSchema): Record<string, unknown>;
 export declare function skillMetadataToKernel(skill: SkillMetadata): Record<string, unknown>;
-export declare function messageToKernelMessage(message: ProviderMessage): Record<string, unknown>;
+export declare function messageToKernelMessage(message: ModelMessage): Record<string, unknown>;
 export declare function toolResultToKernel(result: ToolExecutionResult): Record<string, unknown>;
 export declare function taskUpdateToKernel(update: TaskUpdate): Record<string, unknown>;
 export declare function capabilityTool(schema: ToolSchema): Record<string, unknown>;
@@ -223,5 +223,5 @@ export declare function capabilityCommandMount(capability: Record<string, unknow
 export declare function capabilityCommandUnmount(capabilityKind: string, id: string): Record<string, unknown>;
 /** Camel-case an `entropy_sample` kernel observation into the SDK's `EntropySample`. */
 export declare function entropySampleFromObservation(obs: KernelObservation): EntropySample;
-export declare function kernelMessageToSdk(raw: Record<string, unknown>): ProviderMessage;
+export declare function kernelMessageToSdk(raw: Record<string, unknown>): ModelMessage;
 export declare function renderedContextToSdk(raw: Record<string, unknown>): RenderedContext;

package/dist/runtime/provider-replay.d.ts

@@ -1,10 +1,10 @@
-import type { LLMProvider, ProviderMessage, ProviderDescriptor, ProviderReplay, RenderedContext, ReplayabilityAssessment, ToolCall } from "../types.js";
+import type { LLMProvider, ModelMessage, ProviderDescriptor, ProviderReplay, RenderedContext, ReplayabilityAssessment, ToolCall } from "../types.js";
 import type { SessionEvent } from "./session-log.js";
 export declare class ProviderReplayProtocolMismatchError extends Error {
     readonly code: "provider_replay_protocol_mismatch";
     constructor(provider: string, storedProtocol: string, resolvedProtocol: string);
 }
-export declare function assistantReplayKey(message: Pick<ProviderMessage, "content" | "toolCalls">): string;
+export declare function assistantReplayKey(message: Pick<ModelMessage, "content" | "toolCalls">): string;
 /**
  * A stored replay may only be seeded into a provider speaking the same wire
  * protocol. On a cross-protocol fallback (provider A -> provider B) the

package/dist/runtime/public.d.ts

@@ -0,0 +1,22 @@
+/** Runtime subpath: host execution primitives intentionally outside the root quick-start API. */
+export { RuntimeRunner, collectText } from "./runner.js";
+export { ContextManager, estimateContextTokens } from "./context-manager.js";
+export type { ContextItem, ContextItemKind, ContextItemScope, ContextLedgerEvent, ContextLedgerEventKind, ContextManagerOptions, ContextSnapshot, } from "./context-manager.js";
+export type { RuntimeOptions } from "./runner.js";
+export { runAgent, runFanout } from "./facade.js";
+export type { RunAgentOptions, RunFanoutOptions } from "./facade.js";
+export { InMemorySessionLog, FileSessionLog } from "./session-log.js";
+export type { SessionLog, SessionEvent, SessionEventKind } from "./session-log.js";
+export { projectAgentRun, projectAgentContext, projectAgentCapabilities, projectAgentGovernance, projectAgentDelegation } from "../agent-ir.js";
+export type { AgentDescriptor } from "../agent-ir.js";
+export { FileKernelJournal, InMemoryKernelJournal, JournalCasConflictError, JournalIntegrityError, JournalIoError, } from "./kernel-journal.js";
+export type { CheckpointCandidate, InstalledCheckpoint, JournalAppendReceipt, JournalEntry, JournalHead, JournalPruneReceipt, JournalRecordInput, KernelJournal, } from "./kernel-journal.js";
+export { diagnoseKernelJournal } from "./kernel-doctor.js";
+export type { KernelJournalDiagnosis } from "./kernel-doctor.js";
+export type { ContextPrepared } from "./context.js";
+export { createContextPreparationAdapter, createNativeContextPreparationAdapter } from "./context.js";
+export type { ContextPrepareJson, ContextVerifyJson, ContextProviderPreparationRequest } from "./context.js";
+export { createEvolutionRuntimeAdapter, createNativeEvolutionRuntimeAdapter, EvolutionRuntime } from "./evolution.js";
+export type { EvolutionStore } from "./evolution.js";
+export { FULL_FOOTPRINT_USAGE_ACCOUNTING_POLICY, providerAttemptToRecord } from "./execution-evidence.js";
+export type { InvocationOutcome, ModelInvocation, ProviderAttempt, ProviderAttemptRecord, ProviderAttemptStatus, UsageAccountingPolicy, ModelUsageSettlement } from "./execution-evidence.js";

package/dist/runtime/public.js

@@ -0,0 +1,11 @@
+/** Runtime subpath: host execution primitives intentionally outside the root quick-start API. */
+export { RuntimeRunner, collectText } from "./runner.js";
+export { ContextManager, estimateContextTokens } from "./context-manager.js";
+export { runAgent, runFanout } from "./facade.js";
+export { InMemorySessionLog, FileSessionLog } from "./session-log.js";
+export { projectAgentRun, projectAgentContext, projectAgentCapabilities, projectAgentGovernance, projectAgentDelegation } from "../agent-ir.js";
+export { FileKernelJournal, InMemoryKernelJournal, JournalCasConflictError, JournalIntegrityError, JournalIoError, } from "./kernel-journal.js";
+export { diagnoseKernelJournal } from "./kernel-doctor.js";
+export { createContextPreparationAdapter, createNativeContextPreparationAdapter } from "./context.js";
+export { createEvolutionRuntimeAdapter, createNativeEvolutionRuntimeAdapter, EvolutionRuntime } from "./evolution.js";
+export { FULL_FOOTPRINT_USAGE_ACCOUNTING_POLICY, providerAttemptToRecord } from "./execution-evidence.js";

package/dist/runtime/replay-fixture.d.ts

@@ -6,13 +6,13 @@
  * pulls the assistant turns in order, so the fixture is just "a prior session log + the messages
  * the LLM produced". No new on-disk format.
  */
-import type { ProviderMessage } from "../types.js";
+import type { ModelMessage } from "../types.js";
 import type { SessionEvent } from "./session-log.js";
 /**
  * Extract the ordered list of assistant Messages from a recorded session log.
  *
  * Walks `llm_completed` events (which is what the runner appends for every LLM call) and produces
- * one ProviderMessage per event. Pass the result directly to `new ReplayProvider(messages)`.
+ * one ModelMessage per event. Pass the result directly to `new ReplayProvider(messages)`.
  *
  * Accepts both wire shapes the SDK uses interchangeably:
  *   - in-memory: `{ toolCalls }` (camelCase)
@@ -23,4 +23,4 @@ import type { SessionEvent } from "./session-log.js";
  */
 export declare function extractRecordedMessages(events: Array<{
     event: SessionEvent;
-} | SessionEvent>): ProviderMessage[];
+} | SessionEvent>): ModelMessage[];

package/dist/runtime/replay-fixture.js

@@ -10,7 +10,7 @@
  * Extract the ordered list of assistant Messages from a recorded session log.
  *
  * Walks `llm_completed` events (which is what the runner appends for every LLM call) and produces
- * one ProviderMessage per event. Pass the result directly to `new ReplayProvider(messages)`.
+ * one ModelMessage per event. Pass the result directly to `new ReplayProvider(messages)`.
  *
  * Accepts both wire shapes the SDK uses interchangeably:
  *   - in-memory: `{ toolCalls }` (camelCase)

package/dist/runtime/replay-provider.d.ts

@@ -17,14 +17,14 @@
  *     from the original run). That's the point of replay-for-benchmarking: prompt may differ across
  *     variants, response is pinned, so a cost Δ purely reflects the prompt change.
  *   - `outputTokens` is estimated from `message.content.length / 4`; provider usage belongs to
- *     the session measurement plane, never to the public ProviderMessage mirror.
+ *     the session measurement plane, never to the public ModelMessage mirror.
  *   - `cacheReadInputTokens` / `cacheCreationInputTokens` are emitted as 0 — replay has no real
  *     cache state. Mechanisms whose Δ depends on cache behavior must validate with a live A/B too.
  *
  * Tokenizer: by default a `chars/4` estimator (±20% for English; worse for code/JSON). For tighter
  * numbers plug `opts.tokenizer = tiktokenEncoder` or similar.
  */
-import type { LLMProvider, ProviderMessage, ProviderDescriptor, ProviderRunState, RenderedContext, StreamEvent, ToolSchema } from "../types.js";
+import type { LLMProvider, ModelMessage, ProviderDescriptor, ProviderRunState, RenderedContext, StreamEvent, ToolSchema } from "../types.js";
 export interface ReplayProviderOpts {
     /**
      * Maps a rendered-context text payload to a token count. Defaults to `chars / 4`.
@@ -54,7 +54,7 @@ export declare class ReplayProvider implements LLMProvider {
      * @param messages Ordered list of assistant messages to replay (one per LLM call).
      * @param opts Optional tokenizer / descriptor / wrap-around behavior.
      */
-    constructor(messages: ReadonlyArray<ProviderMessage>, opts?: ReplayProviderOpts);
+    constructor(messages: ReadonlyArray<ModelMessage>, opts?: ReplayProviderOpts);
     descriptor(): ProviderDescriptor;
     /** Number of messages consumed so far. */
     consumed(): number;
@@ -62,7 +62,7 @@ export declare class ReplayProvider implements LLMProvider {
     remaining(): number;
     /** Reset the cursor — useful for re-running the same fixture in a fresh session. */
     reset(): void;
-    complete(_context: RenderedContext, _tools: ToolSchema[]): Promise<ProviderMessage>;
+    complete(_context: RenderedContext, _tools: ToolSchema[]): Promise<ModelMessage>;
     stream(context: RenderedContext, tools: ToolSchema[], _extensions?: Record<string, unknown>, _state?: ProviderRunState, _signal?: AbortSignal): AsyncIterable<StreamEvent>;
     private pull;
     private estimateInputTokens;

package/dist/runtime/replay-provider.js

@@ -17,7 +17,7 @@
  *     from the original run). That's the point of replay-for-benchmarking: prompt may differ across
  *     variants, response is pinned, so a cost Δ purely reflects the prompt change.
  *   - `outputTokens` is estimated from `message.content.length / 4`; provider usage belongs to
- *     the session measurement plane, never to the public ProviderMessage mirror.
+ *     the session measurement plane, never to the public ModelMessage mirror.
  *   - `cacheReadInputTokens` / `cacheCreationInputTokens` are emitted as 0 — replay has no real
  *     cache state. Mechanisms whose Δ depends on cache behavior must validate with a live A/B too.
  *

package/dist/runtime/runner.d.ts

@@ -1,6 +1,8 @@
-import type { LLMProvider, ProviderMessage, ContentPart, ToolSchema, StreamEvent, ToolSuspendEvent, PermissionRequestEvent, PermissionResponse, AsyncSummarizer, MemorySummarizer, EntropySample, EntropyWatchOptions } from "../types.js";
+import type { LLMProvider, ModelMessage, ContentPart, ToolSchema, StreamEvent, ToolSuspendEvent, PermissionRequestEvent, PermissionResponse, AsyncSummarizer, MemorySummarizer, EntropySample, EntropyWatchOptions } from "../types.js";
 import type { MemoryStore, MemoryRecord, MemoryRecall, MemoryScope, MemoryQuery } from "../memory/protocols.js";
 import type { KnowledgeSource } from "../knowledge/source.js";
+import type { Skill } from "../skill.js";
+import type { ContextManager } from "./context-manager.js";
 import type { RuntimeSignalUrgency, SignalSource } from "../signals/types.js";
 import type { SessionLog, SessionEvent } from "./session-log.js";
 import type { KernelJournal } from "./kernel-journal.js";
@@ -9,6 +11,7 @@ import type { ExecutionPlane } from "./execution-plane.js";
 import type { RunGroup } from "./run-group.js";
 import { type MemoryPolicy, type ResourceQuota } from "../kernel.js";
 import type { AgentRunSpec, MilestoneCheckResult, MilestoneContract, MilestonePolicy, WorkflowSpec, WorkflowOutcome } from "../types/agent.js";
+import type { AgentCapabilityFilter } from "../types/agent.js";
 export declare function stableSemanticArchiveName(effectId: string): string;
 import { type SubAgentOrchestrator } from "./sub-agent-orchestrator.js";
 import { type ReducerRegistry } from "./reducers.js";
@@ -95,6 +98,8 @@ export interface KernelReliabilityOptions {
 export type OperationCancellationReason = "user" | "deadline" | "lease_lost" | "host_shutdown";
 export interface RuntimeOptions {
     provider: LLMProvider;
+    /** Host-owned capability ceiling applied to the root run before skills or run profiles narrow it further. */
+    capabilityFilter?: AgentCapabilityFilter;
     /** Host-owned artifact set identity captured in operation genesis. */
     artifactSetDigest?: string;
     /** M4/G5: cumulative token cap for this run (the kernel's `max_total_tokens`). A workflow node's
@@ -150,7 +155,11 @@ export interface RuntimeOptions {
      *  behavior difference. */
     nudges?: NudgeRule[];
     initialMemory?: string[];
+    /** Optional host ledger that admits dynamic context before kernel insertion. */
+    contextManager?: ContextManager;
     skillDir?: string;
+    /** Inline skill catalog. Metadata is exposed at run start; content is loaded only on activation. */
+    skillCatalog?: Skill[];
     /** Host-layer allowlist over the `skillDir` catalog by skill NAME. When set, only scanned skills
      *  whose name is listed are fed to the kernel via `set_available_skills` (the manifest layer
      *  intersects onto this host baseline in `applyManifest`). Absent ⇒ zero behavior difference (all
@@ -398,6 +407,8 @@ export declare class RuntimeRunner {
      *  run — guards against re-pushing a duplicate entry if the model calls `skill(name)` again for
      *  an already-active skill (loading is idempotent; the knowledge push should be too). */
     private knowledgePushedSkills;
+    /** Host mirror of kernel skill lease expiry, used only to clear ContextManager overlays. */
+    private skillLeaseExpirations;
     private nextArchiveStart;
     private pendingPageOutArchives;
     private activePageOutArchive;
@@ -488,7 +499,7 @@ export declare class RuntimeRunner {
      *  K1: `opts.key` gives the entry identity — a same-key push upserts (applied at the next
      *  compaction/renewal boundary, where the cached system[1] block is rewritten anyway) instead
      *  of appending a duplicate. `opts.pinned` exempts the entry from the knowledge-budget sweep. */
-    pushKnowledge(message: ProviderMessage, tokens?: number, opts?: {
+    pushKnowledge(message: ModelMessage, tokens?: number, opts?: {
         key?: string;
         pinned?: boolean;
     }): Promise<void>;
@@ -500,6 +511,7 @@ export declare class RuntimeRunner {
      *  drops at the next compaction/renewal boundary. A later `skill(name)` call re-activates and
      *  re-pins fresh content. Errs-open: not-active is a kernel-side no-op. */
     deactivateSkill(name: string): Promise<void>;
+    private expireSkillContext;
     /**
      * G3: run one workflow node, enforcing its `output_schema` (if any). Without a schema this is a
      * plain `orchestrator.run`. With one, the node's agent is instructed to emit conforming JSON, its
@@ -603,14 +615,14 @@ export declare class RuntimeRunner {
  *  message exists. A tail assistant tool_call with nothing after it is a genuinely PENDING tool the
  *  run stopped in front of (the wake/recovery case), which must stay unpaired so wake executes it.
  *  Pure. */
-export declare function pairOrphanToolCalls(messages: ProviderMessage[]): ProviderMessage[];
+export declare function pairOrphanToolCalls(messages: ModelMessage[]): ModelMessage[];
 export declare function replayMessages(events: Array<{
     seq: number;
     event: SessionEvent;
-}>, maxBytes?: number): ProviderMessage[];
+}>, maxBytes?: number): ModelMessage[];
 export declare function replayMessagesAsync(events: Array<{
     seq: number;
     event: SessionEvent;
-}>, maxBytes?: number, loadArchive?: (archiveRef: string) => Promise<ProviderMessage[]>): Promise<ProviderMessage[]>;
+}>, maxBytes?: number, loadArchive?: (archiveRef: string) => Promise<ModelMessage[]>): Promise<ModelMessage[]>;
 /** Collect all text_delta events from a run into a single string. */
 export declare function collectText(stream: AsyncIterable<StreamEvent>): Promise<string>;