@deepstrike/sdk 0.2.51 → 0.2.60

package/dist/providers/usage-normalizer.d.ts

@@ -0,0 +1,48 @@
+/**
+ * spc_011-C-07: normalizes each vendor's raw postflight usage object into the shared
+ * `ProviderUsage` shape (`../types.js`). One function per wire family, not one
+ * per provider — DeepSeek/Kimi/GLM/Qwen/MiniMax's OpenAI-wire variants all route through
+ * `normalizeOpenAIUsage` via `OpenAIChatProvider` inheritance, and their Anthropic-wire variants
+ * route through `normalizeAnthropicUsage` via `AnthropicCompatibleProvider` inheritance — the
+ * "8 providers" the spec counts are 8 *providers*, not 8 independent parsing implementations.
+ *
+ * Reuses `openAICachedPromptTokens` (`./base.js`) for the OpenAI-family cache figure rather than
+ * re-deriving it — that function already covers the OpenAI/Qwen/MiniMax/GLM/Kimi standard shape
+ * plus DeepSeek's `prompt_cache_hit_tokens` variant.
+ *
+ * `TokenUsage`/`UsageEvent` are otherwise untouched by this module. Missing or malformed usage
+ * returns `undefined`; absence is not a zero-token measurement.
+ */
+import type { ProviderUsage } from "../types.js";
+/**
+ * Covers both OpenAI wire shapes actually in use: Chat Completions (`prompt_tokens`/
+ * `completion_tokens`/`completion_tokens_details.reasoning_tokens`, used by `openai.ts` and every
+ * `OpenAIChatProvider` subclass) and the Responses API (`input_tokens`/`output_tokens`/
+ * `output_tokens_details.reasoning_tokens`, used by `openai-responses.ts`) — the two field-name
+ * conventions are read via fallback, and only one will ever be present on a given raw object.
+ */
+export declare function normalizeOpenAIUsage(usage: unknown): ProviderUsage | undefined;
+/**
+ * Anthropic's raw `input_tokens` is UNCACHED input only (unlike OpenAI's `prompt_tokens`, which
+ * is already cache-inclusive) — `anthropic.ts`'s own `stream()` sums `input_tokens +
+ * cache_read_input_tokens + cache_creation_input_tokens` into the full prompt size for the same
+ * reason context-pressure accounting needs it (see that file's comment on why excluding cached
+ * tokens would suppress compaction until a 413). This function replicates that same sum so
+ * `ProviderUsage.inputTokens` means the same "full prompt size" thing across vendors — reading
+ * raw `input_tokens` alone here would silently undercount every cache-heavy Anthropic turn.
+ * No `reasoning_tokens`-equivalent field exists in this SDK's `Usage` type, so that field stays
+ * unset rather than guessed.
+ */
+export declare function normalizeAnthropicUsage(usage: unknown): ProviderUsage | undefined;
+/**
+ * `@google/generative-ai`'s `UsageMetadata` has no reasoning/thoughts token field and no separate
+ * cache-write count (only `cachedContentTokenCount`, a read figure) — `reasoningTokens` and
+ * `cacheCreationInputTokens` stay unset rather than invented.
+ */
+export declare function normalizeGeminiUsage(usage: unknown): ProviderUsage | undefined;
+/**
+ * Ollama's final stream chunk (`done: true`) carries `prompt_eval_count`/`eval_count` — no cache
+ * or reasoning concept exists in its API at all, so both stay unset. Before this card `ollama.ts`
+ * read neither field; this is the first usage extraction it has ever had.
+ */
+export declare function normalizeOllamaUsage(chunk: unknown): ProviderUsage | undefined;

package/dist/providers/usage-normalizer.js

@@ -0,0 +1,96 @@
+import { openAICachedPromptTokens } from "./base.js";
+function readNumber(obj, key) {
+    const value = obj?.[key];
+    return typeof value === "number" ? value : undefined;
+}
+/**
+ * Covers both OpenAI wire shapes actually in use: Chat Completions (`prompt_tokens`/
+ * `completion_tokens`/`completion_tokens_details.reasoning_tokens`, used by `openai.ts` and every
+ * `OpenAIChatProvider` subclass) and the Responses API (`input_tokens`/`output_tokens`/
+ * `output_tokens_details.reasoning_tokens`, used by `openai-responses.ts`) — the two field-name
+ * conventions are read via fallback, and only one will ever be present on a given raw object.
+ */
+export function normalizeOpenAIUsage(usage) {
+    const u = usage && typeof usage === "object" ? usage : undefined;
+    const rawInput = readNumber(u, "prompt_tokens") ?? readNumber(u, "input_tokens");
+    const rawOutput = readNumber(u, "completion_tokens") ?? readNumber(u, "output_tokens");
+    if (rawInput === undefined && rawOutput === undefined)
+        return undefined;
+    const inputTokens = rawInput ?? 0;
+    const outputTokens = rawOutput ?? 0;
+    const cacheReadInputTokens = openAICachedPromptTokens(usage);
+    const details = (u?.completion_tokens_details ?? u?.output_tokens_details);
+    const reasoningTokens = readNumber(details, "reasoning_tokens");
+    const providerUsage = {
+        inputTokens,
+        outputTokens,
+        ...(cacheReadInputTokens > 0 ? { cacheReadInputTokens } : {}),
+        ...(reasoningTokens !== undefined ? { reasoningTokens } : {}),
+    };
+    return providerUsage;
+}
+/**
+ * Anthropic's raw `input_tokens` is UNCACHED input only (unlike OpenAI's `prompt_tokens`, which
+ * is already cache-inclusive) — `anthropic.ts`'s own `stream()` sums `input_tokens +
+ * cache_read_input_tokens + cache_creation_input_tokens` into the full prompt size for the same
+ * reason context-pressure accounting needs it (see that file's comment on why excluding cached
+ * tokens would suppress compaction until a 413). This function replicates that same sum so
+ * `ProviderUsage.inputTokens` means the same "full prompt size" thing across vendors — reading
+ * raw `input_tokens` alone here would silently undercount every cache-heavy Anthropic turn.
+ * No `reasoning_tokens`-equivalent field exists in this SDK's `Usage` type, so that field stays
+ * unset rather than guessed.
+ */
+export function normalizeAnthropicUsage(usage) {
+    const u = usage && typeof usage === "object" ? usage : undefined;
+    const rawUncachedInput = readNumber(u, "input_tokens");
+    const rawCacheRead = readNumber(u, "cache_read_input_tokens");
+    const rawCacheCreation = readNumber(u, "cache_creation_input_tokens");
+    const rawOutput = readNumber(u, "output_tokens");
+    if (rawUncachedInput === undefined && rawCacheRead === undefined && rawCacheCreation === undefined && rawOutput === undefined)
+        return undefined;
+    const uncachedInput = rawUncachedInput ?? 0;
+    const cacheReadInputTokens = rawCacheRead ?? 0;
+    const cacheCreationInputTokens = rawCacheCreation ?? 0;
+    const outputTokens = rawOutput ?? 0;
+    const providerUsage = {
+        inputTokens: uncachedInput + cacheReadInputTokens + cacheCreationInputTokens,
+        outputTokens,
+        ...(cacheReadInputTokens > 0 ? { cacheReadInputTokens } : {}),
+        ...(cacheCreationInputTokens > 0 ? { cacheCreationInputTokens } : {}),
+    };
+    return providerUsage;
+}
+/**
+ * `@google/generative-ai`'s `UsageMetadata` has no reasoning/thoughts token field and no separate
+ * cache-write count (only `cachedContentTokenCount`, a read figure) — `reasoningTokens` and
+ * `cacheCreationInputTokens` stay unset rather than invented.
+ */
+export function normalizeGeminiUsage(usage) {
+    const u = usage && typeof usage === "object" ? usage : undefined;
+    const rawInput = readNumber(u, "promptTokenCount");
+    const rawOutput = readNumber(u, "candidatesTokenCount");
+    if (rawInput === undefined && rawOutput === undefined)
+        return undefined;
+    const inputTokens = rawInput ?? 0;
+    const outputTokens = rawOutput ?? 0;
+    const cacheReadInputTokens = readNumber(u, "cachedContentTokenCount");
+    const providerUsage = {
+        inputTokens,
+        outputTokens,
+        ...(cacheReadInputTokens ? { cacheReadInputTokens } : {}),
+    };
+    return providerUsage;
+}
+/**
+ * Ollama's final stream chunk (`done: true`) carries `prompt_eval_count`/`eval_count` — no cache
+ * or reasoning concept exists in its API at all, so both stay unset. Before this card `ollama.ts`
+ * read neither field; this is the first usage extraction it has ever had.
+ */
+export function normalizeOllamaUsage(chunk) {
+    const u = chunk && typeof chunk === "object" ? chunk : undefined;
+    const rawInput = readNumber(u, "prompt_eval_count");
+    const rawOutput = readNumber(u, "eval_count");
+    if (rawInput === undefined && rawOutput === undefined)
+        return undefined;
+    return { inputTokens: rawInput ?? 0, outputTokens: rawOutput ?? 0 };
+}

package/dist/providers/vendor-profiles.d.ts

@@ -1,6 +1,5 @@
-import type { RuntimePolicy } from "../types.js";
-import { endpointProfiles } from "./profiles.js";
-import type { ProviderId } from "./profiles.js";
+import { endpointProfiles } from "./endpoints.js";
+import type { ProviderId } from "./endpoints.js";
 export type EndpointProfileKey = keyof typeof endpointProfiles;
 export interface AnthropicVendorProfile {
     /** Identity advertised in `descriptor().provider`. */
@@ -9,44 +8,32 @@ export interface AnthropicVendorProfile {
     defaultModel: string;
     /** Endpoint profile whose `baseURL` is the Anthropic-compatible wire for this vendor. */
     baseURLProfileKey: EndpointProfileKey;
-    /** Recommended `maxTurns` per model id; missing model → empty policy. */
-    policies: Record<string, RuntimePolicy>;
 }
-export declare const DEEPSEEK_POLICIES: Record<string, RuntimePolicy>;
-export declare const KIMI_POLICIES: Record<string, RuntimePolicy>;
-export declare const QWEN_POLICIES: Record<string, RuntimePolicy>;
-export declare const GLM_POLICIES: Record<string, RuntimePolicy>;
-export declare const MINIMAX_POLICIES: Record<string, RuntimePolicy>;
 export declare const anthropicVendorProfiles: {
     deepseek: {
         providerId: "deepseek";
         defaultModel: string;
         baseURLProfileKey: "deepseek.anthropic";
-        policies: Record<string, RuntimePolicy>;
     };
     kimi: {
         providerId: "kimi";
         defaultModel: string;
         baseURLProfileKey: "kimi.anthropic";
-        policies: Record<string, RuntimePolicy>;
     };
     qwen: {
         providerId: "qwen";
         defaultModel: string;
         baseURLProfileKey: "qwen.anthropic";
-        policies: Record<string, RuntimePolicy>;
     };
     glm: {
         providerId: "glm";
         defaultModel: string;
         baseURLProfileKey: "glm.anthropic";
-        policies: Record<string, RuntimePolicy>;
     };
     minimax: {
         providerId: "minimax";
         defaultModel: string;
         baseURLProfileKey: "minimax.anthropic";
-        policies: Record<string, RuntimePolicy>;
     };
 };
 export type AnthropicVendorId = keyof typeof anthropicVendorProfiles;

package/dist/providers/vendor-profiles.js

@@ -1,64 +1,18 @@
-import { endpointProfiles } from "./profiles.js";
-export const DEEPSEEK_POLICIES = {
-    "deepseek-chat": { maxTurns: 25 },
-    "deepseek-reasoner": { maxTurns: 50 },
-    "deepseek-v4-flash": { maxTurns: 20 },
-    "deepseek-v4-pro": { maxTurns: 35 },
-};
-export const KIMI_POLICIES = {
-    "moonshot-v1-8k": { maxTurns: 15 },
-    "moonshot-v1-32k": { maxTurns: 20 },
-    "moonshot-v1-128k": { maxTurns: 30 },
-    "kimi-k2.5": { maxTurns: 30 },
-    "kimi-k2.6": { maxTurns: 35 },
-    "kimi-k2-thinking": { maxTurns: 50 },
-    "kimi-k2-thinking-turbo": { maxTurns: 40 },
-};
-export const QWEN_POLICIES = {
-    "qwen3.7-max-preview": { maxTurns: 45 },
-    "qwen3.7-plus-preview": { maxTurns: 40 },
-    "qwen3.6-max-preview": { maxTurns: 40 },
-    "qwen3.6-plus": { maxTurns: 35 },
-    "qwen3.6-flash": { maxTurns: 20 },
-    "qwen3.6-35b-a3b": { maxTurns: 25 },
-    "qwen3.6-27b": { maxTurns: 25 },
-    "qwen3.5-plus": { maxTurns: 35 },
-    "qwen3.5-flash": { maxTurns: 20 },
-    "qwen3.5-397b-a17b": { maxTurns: 35 },
-    "qwen3.5-122b-a10b": { maxTurns: 25 },
-    "qwen3.5-35b-a3b": { maxTurns: 20 },
-    "qwen3.5-27b": { maxTurns: 20 },
-};
-export const GLM_POLICIES = {
-    "glm-5.2": { maxTurns: 50 },
-    "glm/glm-5.2": { maxTurns: 50 },
-    "glm-5.1": { maxTurns: 50 },
-    "glm/glm-5.1": { maxTurns: 50 },
-    "glm-4-plus": { maxTurns: 35 },
-    "glm/glm-4-plus": { maxTurns: 35 },
-    "glm-4-flash": { maxTurns: 15 },
-    "glm/glm-4-flash": { maxTurns: 15 },
-    "glm-4-air": { maxTurns: 20 },
-    "glm/glm-4-air": { maxTurns: 20 },
-};
-export const MINIMAX_POLICIES = {
-    "MiniMax-M3": { maxTurns: 35 },
-    "MiniMax-M3-highspeed": { maxTurns: 35 },
-    "MiniMax-M2.7": { maxTurns: 35 },
-    "MiniMax-M2.7-highspeed": { maxTurns: 35 },
-    "MiniMax-M2.5": { maxTurns: 25 },
-    "MiniMax-M2.5-highspeed": { maxTurns: 25 },
-    "MiniMax-M2.1": { maxTurns: 25 },
-    "MiniMax-M2.1-highspeed": { maxTurns: 25 },
-    "MiniMax-M2": { maxTurns: 20 },
-    "MiniMax-Text-01": { maxTurns: 20 },
-};
+// Single source of truth for the Anthropic-compatible vendor backends (DeepSeek,
+// Kimi, Qwen, GLM, MiniMax). Each backend differs only by data — provider id,
+// default model, endpoint, and per-model runtime policy — so the generic
+// `AnthropicCompatibleProvider` reads a profile from here instead of every
+// backend subclassing `AnthropicProvider` purely to carry configuration.
+//
+// Runtime policy and default model resolution live in ModelRegistry; this module
+// only carries Anthropic-compatible transport configuration.
+import { endpointProfiles } from "./endpoints.js";
 export const anthropicVendorProfiles = {
-    deepseek: { providerId: "deepseek", defaultModel: "deepseek-v4-flash", baseURLProfileKey: "deepseek.anthropic", policies: DEEPSEEK_POLICIES },
-    kimi: { providerId: "kimi", defaultModel: "kimi-k2.6", baseURLProfileKey: "kimi.anthropic", policies: KIMI_POLICIES },
-    qwen: { providerId: "qwen", defaultModel: "qwen3.6-plus", baseURLProfileKey: "qwen.anthropic", policies: QWEN_POLICIES },
-    glm: { providerId: "glm", defaultModel: "glm-5.2", baseURLProfileKey: "glm.anthropic", policies: GLM_POLICIES },
-    minimax: { providerId: "minimax", defaultModel: "MiniMax-M3", baseURLProfileKey: "minimax.anthropic", policies: MINIMAX_POLICIES },
+    deepseek: { providerId: "deepseek", defaultModel: "deepseek-v4-flash", baseURLProfileKey: "deepseek.anthropic" },
+    kimi: { providerId: "kimi", defaultModel: "kimi-k2.6", baseURLProfileKey: "kimi.anthropic" },
+    qwen: { providerId: "qwen", defaultModel: "qwen3.6-plus", baseURLProfileKey: "qwen.anthropic" },
+    glm: { providerId: "glm", defaultModel: "glm-5.2", baseURLProfileKey: "glm.anthropic" },
+    minimax: { providerId: "minimax", defaultModel: "MiniMax-M3", baseURLProfileKey: "minimax.anthropic" },
 };
 /** Resolve the Anthropic-compatible base URL for a vendor profile. */
 export function anthropicVendorBaseURL(profile) {

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

@@ -30,6 +30,10 @@ export interface CanonicalTransition {
     recordDigest: string;
     plannedStep: CanonicalPlannedStep;
     checkpointAdvice?: Record<string, unknown>;
+    /** Set when the advised §12.3 checkpoint failed AFTER this step was durably committed.
+     *  The step itself is published and authoritative; the checkpoint is deferred
+     *  housekeeping retried at the next advice or forced by the checkpoint_required gate. */
+    checkpointFailure?: string;
     replayed: boolean;
 }
 export declare function canonicalUnsupportedEffectResolution(effectId: string, effectKind: string): CanonicalKernelInput;
@@ -44,8 +48,13 @@ export declare class CanonicalKernelRejectedError extends Error {
  * is therefore a rebuild boundary, never an abort boundary.
  */
 export declare class CanonicalKernelRebuildRequiredError extends Error {
+    /** True when the runtime was already rebuilt from the journal with the durable record
+     *  applied — the caller can resync and continue. False when the rebuild itself failed
+     *  and the operation cannot proceed without journal repair. */
+    readonly rebuilt: boolean;
     constructor(message: string, options?: {
         cause?: unknown;
+        rebuilt?: boolean;
     });
 }
 /**
@@ -86,8 +95,7 @@ export interface CanonicalRunnerRuntimeOptions {
 }
 /**
  * Canonical operation runtime used by the Node host.
- * Every durable transition below is one of the canonical ABI's five input classes; no legacy
- * envelope or synthesized host transaction reaches core or storage.
+ * Every durable transition below is one of the canonical contract's five input classes.
  */
 export declare class CanonicalRunnerRuntime {
     private readonly options;

package/dist/runtime/canonical-kernel-step.js

@@ -1,5 +1,4 @@
 import { createHash, randomUUID } from "node:crypto";
-import { getKernel } from "../kernel.js";
 import { JournalCasConflictError, MAX_CHAIN_POSITION as JOURNAL_MAX_CHAIN_POSITION, } from "./kernel-journal.js";
 import { encodeCanonicalContentParts, kernelMessageToSdk, renderedContextToSdk, } from "./kernel-step.js";
 export const MAX_CHAIN_POSITION = JOURNAL_MAX_CHAIN_POSITION;
@@ -12,6 +11,21 @@ function totalUsageTokens(terminal) {
     const output = Number(usage.output_tokens ?? 0);
     return Number.isSafeInteger(input + output) ? input + output : 0;
 }
+function canonicalProviderFailureKind(kind) {
+    switch (kind) {
+        case "transport":
+        case "rate_limit":
+        case "model_unavailable":
+            return "transport_exhausted";
+        case "auth":
+        case "invalid_request":
+        case "modality":
+        case "protocol":
+            return "protocol_error";
+        default:
+            return "unknown";
+    }
+}
 export function canonicalUnsupportedEffectResolution(effectId, effectKind) {
     return {
         kind: "resolve_effect",
@@ -281,9 +295,14 @@ export class CanonicalKernelRejectedError extends Error {
  * is therefore a rebuild boundary, never an abort boundary.
  */
 export class CanonicalKernelRebuildRequiredError extends Error {
+    /** True when the runtime was already rebuilt from the journal with the durable record
+     *  applied — the caller can resync and continue. False when the rebuild itself failed
+     *  and the operation cannot proceed without journal repair. */
+    rebuilt;
     constructor(message, options) {
-        super(message, options);
+        super(message, options?.cause !== undefined ? { cause: options.cause } : undefined);
         this.name = "CanonicalKernelRebuildRequiredError";
+        this.rebuilt = options?.rebuilt ?? false;
     }
 }
 function chainPosition(value, label) {
@@ -338,7 +357,6 @@ export class CanonicalKernelHost {
     }
     async transition(input, options = {}) {
         const inputJson = JSON.stringify({
-            abi_version: getKernel().kernelAbiVersion(),
             operation_id: this.operationId,
             input_id: options.inputId ?? `node-input-${randomUUID()}`,
             observed_at_ms: options.observedAtMs ?? String(Date.now()),
@@ -434,6 +452,7 @@ export class CanonicalKernelHost {
         }
         const stepSeq = chainPosition(preparation.stepSeq, "prepared stepSeq");
         let appended = false;
+        let transition;
         try {
             const receipt = await this.journal.compareAndAppend(this.operationId, preparation.expectedHead, {
                 step_seq: stepSeq,
@@ -447,7 +466,7 @@ export class CanonicalKernelHost {
                 throw new Error("canonical commit receipt disagrees with the durably appended record");
             }
             const checkpointAdvice = parseAdvice(committed.checkpointAdviceJson);
-            const transition = {
+            transition = {
                 inputJson,
                 stepSeq,
                 recordDigest: committed.recordDigest,
@@ -455,9 +474,6 @@ export class CanonicalKernelHost {
                 ...(checkpointAdvice ? { checkpointAdvice } : {}),
                 replayed: false,
             };
-            if (checkpointAdvice)
-                await this.checkpoint();
-            return transition;
         }
         catch (error) {
             if (appended) {
@@ -467,7 +483,7 @@ export class CanonicalKernelHost {
                 catch (restoreError) {
                     throw new CanonicalKernelRebuildRequiredError("canonical record is durable, commit failed, and journal rebuild also failed", { cause: new AggregateError([error, restoreError]) });
                 }
-                throw new CanonicalKernelRebuildRequiredError("canonical record is durable but commit could not be published; runtime rebuilt from journal", { cause: error });
+                throw new CanonicalKernelRebuildRequiredError("canonical record is durable but commit could not be published; runtime rebuilt from journal", { cause: error, rebuilt: true });
             }
             try {
                 this.kernel.abort(preparation.prepareToken);
@@ -481,6 +497,19 @@ export class CanonicalKernelHost {
             }
             throw error;
         }
+        // Past this point the step is durable AND committed. A failing advised checkpoint
+        // must not be misdiagnosed as a lost commit: it is deferred housekeeping — the next
+        // advice retries it, and the checkpoint_required prepare gate is the hard backstop.
+        if (transition.checkpointAdvice) {
+            try {
+                await this.checkpoint();
+            }
+            catch (checkpointError) {
+                transition.checkpointFailure =
+                    checkpointError instanceof Error ? checkpointError.message : String(checkpointError);
+            }
+        }
+        return transition;
     }
 }
 function canonicalProviderMessage(raw) {
@@ -575,7 +604,7 @@ function logicalRunSpec(raw, goal) {
         ...(raw.metadata && typeof raw.metadata === "object" ? { metadata: raw.metadata } : {}),
     };
 }
-function canonicalWorkflowSpec(raw) {
+function canonicalWorkflowSpec(raw, allowHostSchedulingFactors = false) {
     const nodes = Array.isArray(raw.nodes) ? raw.nodes.map(asObject) : [];
     const nodeIds = nodes.map((_node, index) => `wf-node${index}`);
     return {
@@ -598,6 +627,9 @@ function canonicalWorkflowSpec(raw) {
                 unsupported.push("max_turns");
             if (node.max_wall_ms !== undefined || node.maxWallMs !== undefined)
                 unsupported.push("max_wall_ms");
+            const schedulingFactors = node.scheduling_factors ?? node.schedulingFactors;
+            if (schedulingFactors !== undefined && !allowHostSchedulingFactors)
+                unsupported.push("scheduling_factors");
             const inheritance = node.context_inheritance ?? node.contextInheritance;
             if (unsupported.length > 0) {
                 throw new CanonicalKernelRejectedError(JSON.stringify({
@@ -618,16 +650,20 @@ function canonicalWorkflowSpec(raw) {
                 : [];
             const modelHint = node.model_hint ?? node.modelHint;
             const outputSchema = node.output_schema ?? node.outputSchema;
+            const canonicalSchedulingFactors = schedulingFactors === undefined
+                ? undefined
+                : canonicalSchedulingFactorsForHost(schedulingFactors);
             const runSpec = logicalRunSpec({
                 goal,
                 ...(node.role ? { role: node.role } : {}),
                 ...(node.isolation ? { isolation: node.isolation } : {}),
                 ...(inheritance ? { context_inheritance: inheritance } : {}),
-                ...((modelHint !== undefined || outputSchema !== undefined)
+                ...((modelHint !== undefined || outputSchema !== undefined || canonicalSchedulingFactors !== undefined)
                     ? {
                         metadata: {
                             ...(modelHint !== undefined ? { model_hint: modelHint } : {}),
                             ...(outputSchema !== undefined ? { output_schema: outputSchema } : {}),
+                            ...(canonicalSchedulingFactors !== undefined ? { scheduling_factors: canonicalSchedulingFactors } : {}),
                         },
                     }
                     : {}),
@@ -645,6 +681,24 @@ function canonicalWorkflowSpec(raw) {
         }),
     };
 }
+function canonicalSchedulingFactorsForHost(value) {
+    const raw = asObject(value);
+    const allowed = new Set(["deadline_urgency", "process_priority", "resource_pressure", "budget_pressure"]);
+    const unknown = Object.keys(raw).filter(key => !allowed.has(key));
+    if (unknown.length > 0)
+        throw new TypeError(`unknown scheduling factor(s): ${unknown.join(", ")}`);
+    const factors = {};
+    for (const key of allowed) {
+        const factor = raw[key];
+        if (factor === undefined)
+            continue;
+        if (!Number.isSafeInteger(factor) || factor < 0) {
+            throw new RangeError(`scheduling_factors.${key} must be a non-negative safe integer`);
+        }
+        factors[key] = factor;
+    }
+    return factors;
+}
 function sha256(value) {
     return `sha256:${createHash("sha256").update(value).digest("hex")}`;
 }
@@ -659,8 +713,7 @@ function providerStopReason(value) {
 }
 /**
  * Canonical operation runtime used by the Node host.
- * Every durable transition below is one of the canonical ABI's five input classes; no legacy
- * envelope or synthesized host transaction reaches core or storage.
+ * Every durable transition below is one of the canonical contract's five input classes.
  */
 export class CanonicalRunnerRuntime {
     options;
@@ -786,7 +839,7 @@ export class CanonicalRunnerRuntime {
             kind: "start_operation",
             entry: {
                 kind: "workflow",
-                spec: canonicalWorkflowSpec(specValue),
+                spec: canonicalWorkflowSpec(specValue, true),
             },
             initial_context: this.initialContext,
         });
@@ -840,7 +893,8 @@ export class CanonicalRunnerRuntime {
             }
             case "provider_error": {
                 const message = String(event.message ?? "");
-                const contextOverflow = /context|token.*limit|too long/i.test(message);
+                const hasStructuredKind = typeof event.error_kind === "string";
+                const contextOverflow = event.error_kind === "context_overflow";
                 input = contextOverflow
                     ? {
                         kind: "resolve_effect",
@@ -850,7 +904,7 @@ export class CanonicalRunnerRuntime {
                             result: { kind: "provider", outcome: { kind: "context_overflow" } },
                         },
                     }
-                    : this.failedEffect(event, "transport_exhausted", message, true);
+                    : this.failedEffect(event, hasStructuredKind ? canonicalProviderFailureKind(event.error_kind) : "transport_exhausted", message, typeof event.retryable === "boolean" ? event.retryable : true);
                 break;
             }
             case "tool_results": {
@@ -1100,22 +1154,45 @@ export class CanonicalRunnerRuntime {
     async commit(input) {
         let nextInput = input;
         for (;;) {
-            const transition = await this.host.transition(nextInput);
-            if (!transition.replayed) {
-                for (const raw of transition.plannedStep.observations ?? []) {
-                    const kind = String(raw.kind ?? "");
-                    if (!kind)
-                        throw new Error("canonical observation is missing kind");
-                    this.hostObservations.push({ ...raw, kind });
-                }
-                if (transition.checkpointAdvice) {
-                    this.hostObservations.push({
-                        kind: "checkpoint_advised",
-                        ...transition.checkpointAdvice,
-                    });
+            let transition;
+            try {
+                transition = await this.host.transition(nextInput);
+            }
+            catch (error) {
+                if (!(error instanceof CanonicalKernelRebuildRequiredError) || !error.rebuilt)
+                    throw error;
+                // The input's record is durable and the kernel was rebuilt from the journal with it
+                // applied; only that step's observations are lost (the crash-window cost). Resync and
+                // publish the rebuilt kernel's pending work instead of failing a healthy run.
+                const lifecycle = this.host.kernel.lifecycle();
+                this.configured = lifecycle !== "created";
+                this.started = !["created", "configured"].includes(lifecycle);
+                this.hostObservations.push({ kind: "kernel_rebuilt", reason: error.message });
+                this.lastAction = this.currentAction();
+            }
+            if (transition) {
+                if (!transition.replayed) {
+                    for (const raw of transition.plannedStep.observations ?? []) {
+                        const kind = String(raw.kind ?? "");
+                        if (!kind)
+                            throw new Error("canonical observation is missing kind");
+                        this.hostObservations.push({ ...raw, kind });
+                    }
+                    if (transition.checkpointAdvice) {
+                        this.hostObservations.push({
+                            kind: "checkpoint_advised",
+                            ...transition.checkpointAdvice,
+                        });
+                    }
+                    if (transition.checkpointFailure) {
+                        this.hostObservations.push({
+                            kind: "checkpoint_deferred",
+                            reason: transition.checkpointFailure,
+                        });
+                    }
                 }
+                this.lastAction = canonicalActionFromPlannedStep(transition.plannedStep);
             }
-            this.lastAction = canonicalActionFromPlannedStep(transition.plannedStep);
             if (this.lastAction?.kind !== "unsupported_effect")
                 return this.lastAction;
             nextInput = canonicalUnsupportedEffectResolution(this.lastAction.effectId, this.lastAction.effectKind);
@@ -1386,9 +1463,6 @@ export class CanonicalRunnerRuntime {
             delete asObject(execution.entropy_watch).threshold;
             delete asObject(execution.entropy_watch).hysteresis;
         }
-        if (config.tool_dispatch_gate !== undefined) {
-            this.featurePolicy().tool_dispatch_gate = config.tool_dispatch_gate;
-        }
         if (config.knowledge_budget_ratio !== undefined) {
             const context = asObject(this.config.context_policy);
             context.knowledge_budget_ppm = Math.round(Number(config.knowledge_budget_ratio) * 1_000_000);

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

@@ -1,35 +1,33 @@
-export declare const CONTEXT_POLICY_VERSION: 1;
 export declare const PPM_SCALE: 1000000;
-export interface ContextPressureThresholdsV1 {
+export interface ContextPressureThresholds {
     snip: number;
     micro: number;
     collapse: number;
     auto: number;
     renewal: number;
 }
-export interface ContextPolicyV1 {
-    pressureThresholds: ContextPressureThresholdsV1;
+export interface ContextPolicy {
+    pressureThresholds: ContextPressureThresholds;
     targetAfterCompress: number;
     preserveRecentTurns: number;
     renewalCarryover: number;
     collapseOldAssistantNarration: boolean;
     idleMicroCompactMinutes: number;
 }
-export interface ContextPolicyWireV1 {
-    version: typeof CONTEXT_POLICY_VERSION;
-    pressure_thresholds_ppm: ContextPressureThresholdsV1;
+export interface ContextPolicyWire {
+    pressure_thresholds_ppm: ContextPressureThresholds;
     target_after_compress_ppm: number;
     preserve_recent_turns: number;
     renewal_carryover_ppm: number;
     collapse_old_assistant_narration: boolean;
     idle_micro_compact_minutes: number;
 }
-export interface ContextPolicyOverridesV1 extends Partial<Omit<ContextPolicyV1, "pressureThresholds">> {
-    pressureThresholds?: Partial<ContextPressureThresholdsV1>;
+export interface ContextPolicyOverrides extends Partial<Omit<ContextPolicy, "pressureThresholds">> {
+    pressureThresholds?: Partial<ContextPressureThresholds>;
 }
-export declare const DEFAULT_CONTEXT_POLICY_V1: Readonly<ContextPolicyV1>;
+export declare const DEFAULT_CONTEXT_POLICY: Readonly<ContextPolicy>;
 /** Resolve ergonomic partial SDK options into one complete, atomically validated policy. */
-export declare function contextPolicyV1(overrides?: ContextPolicyOverridesV1): ContextPolicyV1;
+export declare function contextPolicy(overrides?: ContextPolicyOverrides): ContextPolicy;
 /** Convert the public ratio-based policy to the canonical integer-only ABI wire shape. */
-export declare function normalizeContextPolicyV1(policy: ContextPolicyV1): ContextPolicyWireV1;
+export declare function normalizeContextPolicy(policy: ContextPolicy): ContextPolicyWire;
 export declare function ratioToPpm(value: number, field?: string): number;