@deepstrike/wasm 0.2.52 → 0.2.60

package/dist/runtime/runner.js

@@ -5,6 +5,7 @@ import { getKernel } from "./kernel.js";
 import { CanonicalRunnerRuntime, canonicalKernelAction, canonicalKernelApply, canonicalKernelMaybeAction, canonicalStartAgent, canonicalStartWorkflow, sha256 as canonicalSha256, } from "./canonical-kernel-step.js";
 import { peekProviderReplay, seedProviderReplayFromEvents } from "./provider-replay.js";
 import { sanitizeReplayText } from "./replay-sanitize.js";
+import { decodeDurableContent, decodeDurableToolResult, durableBlocksToToolOutput, toolOutputBlocksToDurable } from "./durable-content.js";
 import { formatToolError } from "../tools/errors.js";
 import { buildLlmCompletedEvent, buildRunTerminalEvent, buildWorkflowNodeCompletedEvent, buildWorkflowNodesSubmittedEvent, } from "./session-repair.js";
 import { messageToKernelMessage, skillMetadataToKernel, taskUpdateToKernel, toolResultToKernel, toolSchemaToKernel, } from "./kernel-step.js";
@@ -12,24 +13,30 @@ import { agentRunSpecToKernel, MILESTONE_UNVERIFIED_REASON, milestoneCheckFail,
 import { defaultSubAgentOrchestrator } from "./sub-agent-orchestrator.js";
 import { extractJsonValue, schemaInstruction, schemaRetryInstruction, validateAgainstSchema, } from "./output-schema.js";
 import { resolveReducer } from "./reducers.js";
-import { loopInstruction, classifyInstruction, judgeGoal, dependencyOutputsNote, extractLoopContinue, extractClassifyBranch, extractJudgeWinner, } from "./workflow-control-flow.js";
+import { loopInstruction, classifyInstruction, judgeGoal, dependencyOutputsNote, extractClassifyBranch, extractJudgeWinner, } from "./workflow-control-flow.js";
 import { kernelObservationToSessionEvent } from "./kernel-event-log.js";
 import { assertNativeProfile } from "./os-profile.js";
+import { classifyProviderError, providerErrorEventFields } from "../providers/provider-error.js";
 import { PayloadStore } from "./payload-store.js";
-import { contextPolicyV1, normalizeContextPolicyV1, } from "./context-policy.js";
+import { contextPolicy, normalizeContextPolicy, } from "./context-policy.js";
+import { createProviderRequestPlanForProvider, estimateProviderPromptTokens, measurementForPlan, recordPromptMeasurement, } from "../providers/request-plan.js";
 export function schedulerPolicyToKernel(policy) {
     const allowed = new Set([
-        "version", "criticalPathWeight", "fanoutWeight", "ageWeight", "tokenCostWeight",
+        "criticalPathWeight", "fanoutWeight", "ageWeight", "tokenCostWeight",
+        "deadlineWeight", "processPriorityWeight", "resourcePressureWeight", "budgetPressureWeight",
     ]);
     const unknown = Object.keys(policy).filter(key => !allowed.has(key));
     if (unknown.length > 0)
         throw new TypeError(`unknown scheduler policy field(s): ${unknown.join(", ")}`);
     return {
-        version: policy.version,
         critical_path_weight: policy.criticalPathWeight,
         fanout_weight: policy.fanoutWeight,
         age_weight: policy.ageWeight,
         token_cost_weight: policy.tokenCostWeight,
+        ...(policy.deadlineWeight !== undefined ? { deadline_weight: policy.deadlineWeight } : {}),
+        ...(policy.processPriorityWeight !== undefined ? { process_priority_weight: policy.processPriorityWeight } : {}),
+        ...(policy.resourcePressureWeight !== undefined ? { resource_pressure_weight: policy.resourcePressureWeight } : {}),
+        ...(policy.budgetPressureWeight !== undefined ? { budget_pressure_weight: policy.budgetPressureWeight } : {}),
     };
 }
 function kernelReliabilityToKernel(policy) {
@@ -292,10 +299,10 @@ export class RuntimeRunner {
         yield* this.execute(sessionId, start.run_id, start.goal, start.criteria, extensions, events, true, start.attachments);
     }
     async writeMemory(memory, sessionId) {
-        if (!this.opts.dreamStore || !this.opts.agentId)
+        if (!this.opts.memoryStore || !this.opts.agentId)
             return;
         try {
-            await this.opts.dreamStore.upsert(this.opts.agentId, memory);
+            await this.opts.memoryStore.put(this.opts.agentId, memory);
         }
         catch (cause) {
             throw new Error(formatToolError(cause));
@@ -419,6 +426,7 @@ export class RuntimeRunner {
                             output: `permission denied: ${denyReason}`,
                             is_error: true,
                             error_kind: "governance_denied",
+                            content: { blocks: [{ type: "text", text: `permission denied: ${denyReason}` }] },
                         }],
                 });
             }
@@ -436,6 +444,12 @@ export class RuntimeRunner {
         const ext = { ...this.opts.extensions, ...(extensions ?? {}) };
         const providerState = this.opts.provider.createRunState?.();
         let nextCompressedArchiveStart = nextArchivedSeqStart(priorEvents);
+        const recordedMeasurements = new Map();
+        for (const entry of priorEvents ?? []) {
+            if (entry.event.kind === "prompt_measured") {
+                recordedMeasurements.set(entry.event.measurement.requestFingerprint, entry.event.measurement);
+            }
+        }
         const providerPolicy = this.opts.provider.runtimePolicy?.() ?? {};
         const effectiveMaxTurns = this.opts.maxTurns ?? providerPolicy.maxTurns ?? 25;
         const effectiveTimeoutMs = this.opts.timeoutMs ?? providerPolicy.timeoutMs;
@@ -494,7 +508,7 @@ export class RuntimeRunner {
                     tool_ids: this.opts.stableCoreToolIds,
                 });
             }
-            if (this.opts.dreamStore && this.opts.agentId) {
+            if (this.opts.memoryStore && this.opts.agentId) {
                 await this.commitKernelApply(runtime, this.pendingObservations, { kind: "set_memory_enabled", enabled: true });
             }
             if (this.opts.knowledgeSource) {
@@ -542,7 +556,7 @@ export class RuntimeRunner {
                             const output = toolResultByCallId.get(tc.id);
                             if (output && !this.knowledgePushedSkills.has(name)) {
                                 this.knowledgePushedSkills.add(name);
-                                // K1: keyed — the kernel-side upsert is the authoritative dedup across wake replays.
+                                // K1: keyed — the kernel-side put is the authoritative dedup across wake replays.
                                 this.pushKnowledge({ role: "system", content: output }, undefined, { key: `skill:${name}` });
                             }
                         }
@@ -565,15 +579,14 @@ export class RuntimeRunner {
         const startTask = { goal, criteria };
         let startRunSpec;
         // P0-A: lower an explicit `runSpec`, the `allowedToolIds` ceiling, and/or the `baselineToolIds`
-        // pre-activation surface to the kernel run spec (reuses the existing run_spec wire — no new
-        // ABI). Unset on all ⇒ no gating (铁律: no config = old behavior).
+        // pre-activation surface to the kernel run spec. Every run has a run spec; an omitted baseline
+        // is the canonical minimal surface.
         const allowedToolIds = this.opts.allowedToolIds;
         const hasProfile = allowedToolIds !== undefined && allowedToolIds.length > 0;
         // NOT the `length > 0` idiom above: `baselineToolIds: []` is the legitimate minimal surface
         // (meta + stable-core only), so mere presence triggers the lowering.
-        const baselineToolIds = this.opts.baselineToolIds;
-        const hasBaseline = baselineToolIds !== undefined;
-        if (this.opts.runSpec || hasProfile || hasBaseline) {
+        const baselineToolIds = this.opts.baselineToolIds ?? this.opts.runSpec?.exposureBaseline ?? [];
+        {
             const baseSpec = this.opts.runSpec ?? {
                 identity: { agentId: this.opts.agentId ?? "root", sessionId, isSubAgent: false },
                 role: "custom",
@@ -582,8 +595,7 @@ export class RuntimeRunner {
             let spec = hasProfile
                 ? { ...baseSpec, capabilityFilter: { ...baseSpec.capabilityFilter, allowedIds: allowedToolIds } }
                 : baseSpec;
-            if (hasBaseline)
-                spec = { ...spec, exposureBaseline: baselineToolIds };
+            spec = { ...spec, exposureBaseline: baselineToolIds };
             startRunSpec = agentRunSpecToKernel(spec);
         }
         if (!resumeMidRun)
@@ -651,6 +663,43 @@ export class RuntimeRunner {
                     let turnCacheCreationTokens = 0;
                     let turnCacheReadBySlot;
                     let turnStopReason;
+                    const providerPlan = createProviderRequestPlanForProvider(this.opts.provider, context, tools, ext);
+                    let promptMeasurement = measurementForPlan(providerPlan, recordedMeasurements.get(providerPlan.fingerprint));
+                    if (!promptMeasurement && !context.budgetOverflow) {
+                        try {
+                            const counted = this.opts.provider.countTokens
+                                ? await withTimeout(this.opts.provider.countTokens(context, tools, Object.keys(ext).length ? ext : undefined), 5_000)
+                                : undefined;
+                            promptMeasurement = recordPromptMeasurement(providerPlan, counted ?? {
+                                inputTokens: estimateProviderPromptTokens(context, tools),
+                                source: { kind: "heuristic" },
+                                confidence: "low_confidence",
+                            });
+                        }
+                        catch {
+                            promptMeasurement = recordPromptMeasurement(providerPlan, {
+                                inputTokens: estimateProviderPromptTokens(context, tools),
+                                source: { kind: "heuristic" },
+                                confidence: "low_confidence",
+                            });
+                        }
+                        recordedMeasurements.set(providerPlan.fingerprint, promptMeasurement);
+                        await this.opts.sessionLog.append(sessionId, { kind: "prompt_measured", turn: runtime.turn(), measurement: promptMeasurement });
+                    }
+                    const reservedPromptTokens = (this.opts.promptBudget?.promptOverheadTokens ?? 0)
+                        + (this.opts.promptBudget?.outputReserveTokens ?? 0)
+                        + (this.opts.promptBudget?.safetyMarginTokens ?? 0);
+                    const measuredOverflow = promptMeasurement
+                        && promptMeasurement.source.kind !== "heuristic"
+                        && promptMeasurement.inputTokens + reservedPromptTokens > this.opts.maxTokens;
+                    if (context.budgetOverflow || measuredOverflow) {
+                        action = await this.commitKernelAction(runtime, this.pendingObservations, {
+                            kind: "provider_error", effect_id: providerEffectId,
+                            message: "provider-visible prompt exceeds the configured context budget",
+                            error_kind: "context_overflow", retryable: false,
+                        });
+                        continue;
+                    }
                     const abortSignal = this.abortController?.signal;
                     try {
                         for await (const evt of this.opts.provider.stream(context, tools, Object.keys(ext).length ? ext : undefined, providerState, abortSignal)) {
@@ -690,6 +739,8 @@ export class RuntimeRunner {
                             this.cancellationReason ??= "user";
                         }
                         else {
+                            const descriptor = this.opts.provider.descriptor?.();
+                            const providerError = classifyProviderError(descriptor?.provider ?? "unknown", err);
                             // Reactive recovery is now a kernel decision. Forward the raw provider error and
                             // dispatch whatever the kernel returns: `call_provider` to retry with a freshly
                             // compacted context, or `done` to terminate with an honest `ContextOverflow`. The
@@ -698,7 +749,8 @@ export class RuntimeRunner {
                             action = await this.commitKernelAction(runtime, this.pendingObservations, {
                                 kind: "provider_error",
                                 effect_id: providerEffectId,
-                                message: formatToolError(err),
+                                message: providerError.message,
+                                ...providerErrorEventFields(providerError),
                             });
                             // Withholding (query.ts parity): surface the raw provider error only when the kernel
                             // could NOT recover (it returned a terminal). On a recovered retry (`call_provider`)
@@ -706,7 +758,7 @@ export class RuntimeRunner {
                             // compaction archive via the loop-top appendObservations, and a terminal `done` exits
                             // through `isTerminal()`.
                             if (action.kind === "done") {
-                                yield { type: "error", message: formatToolError(err) };
+                                yield { type: "error", message: providerError.message };
                             }
                             continue;
                         }
@@ -784,9 +836,9 @@ export class RuntimeRunner {
                 else if (action.kind === "persist_memory") {
                     let error;
                     try {
-                        if (!this.opts.dreamStore || !this.opts.agentId)
-                            throw new Error("WASM memory persistence requires dreamStore and agentId");
-                        await this.opts.dreamStore.upsert(this.opts.agentId, action.memory);
+                        if (!this.opts.memoryStore || !this.opts.agentId)
+                            throw new Error("WASM memory persistence requires memoryStore and agentId");
+                        await this.opts.memoryStore.put(this.opts.agentId, action.memory);
                     }
                     catch (cause) {
                         error = formatToolError(cause);
@@ -801,9 +853,9 @@ export class RuntimeRunner {
                     let hits = [];
                     let error;
                     try {
-                        if (!this.opts.dreamStore || !this.opts.agentId)
-                            throw new Error("WASM memory queries require dreamStore and agentId");
-                        hits = await this.opts.dreamStore.search(this.opts.agentId, {
+                        if (!this.opts.memoryStore || !this.opts.agentId)
+                            throw new Error("WASM memory queries require memoryStore and agentId");
+                        hits = await this.opts.memoryStore.search(this.opts.agentId, {
                             ...action.query, top_k: action.requestedK,
                         });
                     }
@@ -820,7 +872,7 @@ export class RuntimeRunner {
                     // M3/M4: mirror the kernel's journaled recall lifecycle + surface promotion suggestions.
                     for (const obs of this.pendingObservations.slice(obsStart)) {
                         if (obs.kind === "memory_recalled" && obs.recalls?.length && this.opts.agentId) {
-                            await this.opts.dreamStore?.recordRecall?.(this.opts.agentId, obs.recalls);
+                            await this.opts.memoryStore?.recordRecall?.(this.opts.agentId, obs.recalls);
                         }
                         if (obs.kind === "promotion_suggested" && obs.record_id) {
                             this.opts.onPromotionSuggested?.({ recordId: obs.record_id, recallCount: obs.recall_count ?? 0 });
@@ -888,7 +940,7 @@ export class RuntimeRunner {
                         agentId: this.opts.agentId,
                         memoryScope: this.opts.memoryScope,
                         skillContentMap: this.opts.skillContentMap,
-                        dreamStore: this.opts.dreamStore,
+                        memoryStore: this.opts.memoryStore,
                         knowledgeSource: this.opts.knowledgeSource,
                         onToolSuspend: this.opts.onToolSuspend,
                         onPermissionRequest: this.opts.onPermissionRequest,
@@ -1029,6 +1081,7 @@ export class RuntimeRunner {
                             output: r.output,
                             is_error: r.isError,
                             token_count: r.tokenCount,
+                            content: { blocks: toolOutputBlocksToDurable(r.contentParts?.length ? r.contentParts : [{ type: "text", text: r.output }]) },
                         })),
                     });
                     // Canonical provider-result reduction activates a successfully resolved `skill` call. The
@@ -1050,10 +1103,10 @@ export class RuntimeRunner {
                             if (!name)
                                 continue;
                             // With a lease configured, skip the Set optimization: an expired-then-reloaded skill
-                            // must re-pin — only the kernel knows the lease state; its upsert dedupes anyway.
+                            // must re-pin — only the kernel knows the lease state; its put dedupes anyway.
                             if (this.opts.skillLeaseTurns !== undefined || !this.knowledgePushedSkills.has(name)) {
                                 this.knowledgePushedSkills.add(name);
-                                // K1: keyed `skill:<name>` — the kernel-side upsert dedupes across runner instances.
+                                // K1: keyed `skill:<name>` — the kernel-side put dedupes across runner instances.
                                 this.pushKnowledge({ role: "system", content: res.output }, undefined, { key: `skill:${name}` });
                             }
                         }
@@ -1071,7 +1124,6 @@ export class RuntimeRunner {
                             this.lastEntropySample = {
                                 turn: obs.turn ?? 0,
                                 score: obs.score ?? 0,
-                                scoreVersion: obs.score_version ?? 0,
                                 rho: obs.rho ?? 0,
                                 repeatPressure: obs.repeat_pressure ?? 0,
                                 failureRate: obs.failure_rate ?? 0,
@@ -1201,7 +1253,7 @@ export class RuntimeRunner {
             turnsUsed,
             totalTokens,
         }));
-        if (this.opts.dreamStore && this.opts.agentId) {
+        if (this.opts.memoryStore && this.opts.agentId) {
             const newMsgs = runtime.drainNewMessages().map(m => ({
                 role: m.role,
                 content: m.content,
@@ -1218,9 +1270,9 @@ export class RuntimeRunner {
                         createdAtMs: sessionStart,
                         updatedAtMs: Date.now(),
                     };
-                    await this.opts.dreamStore.saveSession(completedSession);
+                    await this.opts.memoryStore.saveSession(completedSession);
                     if (this.opts.memoryScope) {
-                        const extracted = await extractSessionMemories(this.opts.dreamProvider ?? this.opts.provider, completedSession, this.opts.memoryScope, this.opts.dreamSystemPrompt);
+                        const extracted = await extractSessionMemories(this.opts.memoryProvider ?? this.opts.provider, completedSession, this.opts.memoryScope, this.opts.memorySystemPrompt);
                         for (const memory of extracted)
                             await this.writeMemory(memory, sessionId);
                     }
@@ -1291,20 +1343,15 @@ export class RuntimeRunner {
             const winnerId = winner === "right" ? node.judge_match.right : node.judge_match.left;
             return withSignal(result, { tournamentWinner: winnerId });
         }
-        // A#2 v2 loop iteration: run the increment under the armed pacing trap (workflowNodeToSpec set
+        // loop-control loop iteration: run the increment under the armed pacing trap (workflowNodeToSpec set
         // `loopRound`, and the iteration resumes the loop's stable session — transcript-as-carry).
-        // DW-3 one vocabulary: the kernel-adjudicated `pace` verb IS the continuation signal
-        // (stop → loopContinue=false); the legacy text-sniffed JSON blob survives only as the fallback
-        // when no pace decision arrives (stub orchestrators, harness children), where no signal still
-        // means "run to max_iters" (v1).
+        // The kernel-adjudicated `pace` verb is the only continuation signal. Ending without a pace
+        // decision completes the loop.
         if (node.loop_max_iters != null) {
             const iteration = Number(/-i(\d+)$/.exec(node.agent_id)?.[1] ?? "0");
             const result = await orchestrator.run(mkCtx(`${baseSpec.goal}\n\n${loopInstruction(node.loop_max_iters, iteration)}`));
             const pace = result.result.paceDecision;
-            if (pace)
-                return withSignal(result, { loopContinue: pace.action !== "stop" });
-            const cont = extractLoopContinue(textOf(result));
-            return cont === undefined ? result : withSignal(result, { loopContinue: cont });
+            return withSignal(result, { loopContinue: pace?.action === "continue" });
         }
         // A#2 classify: run the classifier, then extract the chosen branch label (kernel prunes the rest).
         if (node.classify_labels && node.classify_labels.length) {
@@ -1384,10 +1431,9 @@ export class RuntimeRunner {
         const { kind: _govKind, ...governance } = governancePolicyToKernelEvent(governancePolicy);
         const config = { governance };
         if (this.opts.contextPolicy) {
-            config.context_policy = normalizeContextPolicyV1(contextPolicyV1(this.opts.contextPolicy));
+            config.context_policy = normalizeContextPolicy(contextPolicy(this.opts.contextPolicy));
         }
         config.signal_policy = {
-            version: 1,
             queue_max: signalPolicy.queueMax,
             ...(signalPolicy.ttlMs !== undefined ? { ttl_ms: signalPolicy.ttlMs } : {}),
             ...(signalPolicy.deadlineEscalation !== undefined
@@ -1429,11 +1475,6 @@ export class RuntimeRunner {
         if (this.opts.criteriaGate !== undefined) {
             config.criteria_gate = this.opts.criteriaGate;
         }
-        // P1: fail-closed dispatch selector (absent ⇒ kernel default "exposed"). "registered" is the
-        // escape hatch back to permissive dispatch; the kernel rejects any other value.
-        if (this.opts.toolDispatchGate !== undefined) {
-            config.tool_dispatch_gate = this.opts.toolDispatchGate;
-        }
         // K2: knowledge budget ratio (absent ⇒ kernel default 0.25; 0 disables).
         if (this.opts.knowledgeBudgetRatio !== undefined) {
             config.knowledge_budget_ratio = this.opts.knowledgeBudgetRatio;
@@ -1744,7 +1785,7 @@ export class RuntimeRunner {
      *  re-fired after each sprint renewal (renewal drops the old history INCLUDING earlier memory
      *  hits). Errs-open throughout. */
     async prefetchMemoryIntoHistory(runtime, phase) {
-        if (!this.opts.dreamStore || !this.opts.agentId || !this.opts.memoryScope)
+        if (!this.opts.memoryStore || !this.opts.agentId || !this.opts.memoryScope)
             return;
         // P10: recall is default-on (CC session-start recall) — with no hook configured,
         // the goal itself is the query. preQueryMemory stays as the targeting override.
@@ -1756,7 +1797,7 @@ export class RuntimeRunner {
             for (const q of queries ?? []) {
                 if (!q.query.trim())
                     continue;
-                const hits = await this.opts.dreamStore.search(this.opts.agentId, q);
+                const hits = await this.opts.memoryStore.search(this.opts.agentId, q);
                 for (const hit of hits) {
                     lines.push(`[memory record_id=${hit.record.record_id} trust=${hit.record.provenance.trust} score=${hit.score.toFixed(3)}] ${hit.record.content}`);
                 }
@@ -1771,12 +1812,12 @@ export class RuntimeRunner {
         catch { /* errs-open */ }
     }
     async archiveSemanticPageOut(archived, action) {
-        if (!this.opts.dreamStore || !this.opts.agentId || !this.opts.memoryScope)
+        if (!this.opts.memoryStore || !this.opts.agentId || !this.opts.memoryScope)
             return;
         try {
-            const summary = this.opts.dreamSummarizer
-                ? await this.opts.dreamSummarizer.summarize(archived, { action })
-                : await summarizeForLongTermMemory(this.opts.dreamProvider ?? this.opts.provider, archived, this.opts.dreamSystemPrompt);
+            const summary = this.opts.memorySummarizer
+                ? await this.opts.memorySummarizer.summarize(archived, { action })
+                : await summarizeForLongTermMemory(this.opts.memoryProvider ?? this.opts.provider, archived, this.opts.memorySystemPrompt);
             const now = Date.now();
             const name = `page-out-${now}`;
             await this.writeMemory({
@@ -1823,7 +1864,7 @@ function compressionAction(action) {
     }
     return undefined;
 }
-async function replayMessages(events, maxBytes, archiveStore) {
+export async function replayMessages(events, maxBytes, archiveStore) {
     // Build upgraded-summary index: compressed_seq -> upgraded summary
     const upgradedSummaries = new Map();
     for (const { event: e } of events) {
@@ -1893,10 +1934,16 @@ async function replayMessages(events, maxBytes, archiveStore) {
         }
         else if (e.kind === "tool_completed") {
             for (const r of e.results) {
+                const durable = decodeDurableToolResult({
+                    call_id: r.call_id,
+                    is_error: r.is_error ?? false,
+                    blocks: decodeDurableContent(r.content).blocks,
+                });
                 messages.push({
                     role: "tool",
-                    content: sanitizeReplayText(r.output, maxBytes),
+                    content: "",
                     toolCalls: [],
+                    contentParts: [{ type: "tool_result", callId: durable.call_id, output: sanitizeReplayText(r.output, maxBytes), isError: durable.is_error, ...(durable.blocks.length ? { contentParts: durableBlocksToToolOutput(durable.blocks) } : {}) }],
                     tokenCount: r.token_count,
                 });
             }
@@ -1926,6 +1973,19 @@ export async function collectText(stream) {
     }
     return text;
 }
+async function withTimeout(promise, timeoutMs) {
+    let timer;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_, reject) => { timer = setTimeout(() => reject(new Error("provider token measurement timed out")), timeoutMs); }),
+        ]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}
 /** Parse `update_plan` meta-tool args into a task update (snake_case aliases accepted, mirroring
  *  the node/python runners). Malformed payload → an empty update (a no-op `update_task`). */
 function parseUpdatePlanArgs(argsStr) {

package/dist/runtime/session-log.d.ts

@@ -2,6 +2,7 @@ import type { ProviderReplay, ToolCall, ToolErrorKind } from "../types.js";
 import type { MemoryRecall, MemoryScope } from "../memory/index.js";
 import type { KernelPrimitive } from "./kernel-event-log.js";
 import type { KernelJournal } from "./kernel-journal.js";
+import type { RecordedPromptMeasurement } from "../providers/request-plan.js";
 export type RollbackReason = {
     kind: "fatal_tool_error";
     tool_name: string;
@@ -36,6 +37,10 @@ export type SessionEvent = {
     token_count?: number;
     tool_calls: ToolCall[];
     provider_replay?: ProviderReplay;
+} | {
+    kind: "prompt_measured";
+    turn: number;
+    measurement: RecordedPromptMeasurement;
 } | {
     kind: "tool_requested";
     turn: number;
@@ -50,6 +55,9 @@ export type SessionEvent = {
         is_fatal?: boolean;
         error_kind?: ToolErrorKind;
         token_count?: number;
+        content: {
+            blocks: Record<string, unknown>[];
+        };
     }>;
 } | {
     kind: "tool_argument_repaired";
@@ -177,7 +185,6 @@ export type SessionEvent = {
     kind: "entropy_sample";
     turn: number;
     score: number;
-    score_version: number;
     rho: number;
     repeat_pressure: number;
     failure_rate: number;

package/dist/runtime/session-repair.d.ts

@@ -6,7 +6,7 @@ export { REPLAY_CONTENT_MAX_BYTES as RECOVERY_CONTENT_MAX_BYTES } from "./replay
  * Normalize a persisted llm_completed event for recovery. Content is sanitized
  * and token_count backfilled, but the stored `provider_replay` envelope is
  * passed through verbatim — this layer is provider-neutral and never
- * synthesizes protocol-specific replay shapes. Legacy reconstruction is the
+ * synthesizes protocol-specific replay shapes. Canonical replay seeding is the
  * responsibility of the target provider's `seedProviderReplay`.
  */
 export declare function normalizeLlmCompleted(event: Extract<SessionEvent, {

package/dist/runtime/session-repair.js

@@ -7,7 +7,7 @@ function estimateTokenCount(text) {
  * Normalize a persisted llm_completed event for recovery. Content is sanitized
  * and token_count backfilled, but the stored `provider_replay` envelope is
  * passed through verbatim — this layer is provider-neutral and never
- * synthesizes protocol-specific replay shapes. Legacy reconstruction is the
+ * synthesizes protocol-specific replay shapes. Canonical replay seeding is the
  * responsibility of the target provider's `seedProviderReplay`.
  */
 export function normalizeLlmCompleted(event, maxBytes) {

package/dist/runtime/sha256.d.ts

@@ -0,0 +1,2 @@
+/** Small synchronous SHA-256 for Worker/browser hosts (no node:crypto). */
+export declare function sha256Hex(value: string): string;

package/dist/runtime/sha256.js

@@ -0,0 +1,38 @@
+/** Small synchronous SHA-256 for Worker/browser hosts (no node:crypto). */
+export function sha256Hex(value) {
+    const input = new TextEncoder().encode(value);
+    const bitLength = input.length * 8;
+    const length = ((input.length + 9 + 63) >> 6) << 6;
+    const data = new Uint8Array(length);
+    data.set(input);
+    data[input.length] = 0x80;
+    new DataView(data.buffer).setUint32(length - 4, bitLength >>> 0, false);
+    const h = new Uint32Array([0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19]);
+    const k = [0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2];
+    const ror = (x, n) => (x >>> n) | (x << (32 - n));
+    for (let offset = 0; offset < data.length; offset += 64) {
+        const w = new Uint32Array(64);
+        const view = new DataView(data.buffer, offset, 64);
+        for (let i = 0; i < 16; i++)
+            w[i] = view.getUint32(i * 4, false);
+        for (let i = 16; i < 64; i++) {
+            w[i] = (w[i - 16] + (ror(w[i - 15], 7) ^ ror(w[i - 15], 18) ^ (w[i - 15] >>> 3)) + w[i - 7] + (ror(w[i - 2], 17) ^ ror(w[i - 2], 19) ^ (w[i - 2] >>> 10))) >>> 0;
+        }
+        let [a, b, c, d, e, f, g, hh] = h;
+        for (let i = 0; i < 64; i++) {
+            const t1 = (hh + (ror(e, 6) ^ ror(e, 11) ^ ror(e, 25)) + ((e & f) ^ ((~e) & g)) + k[i] + w[i]) >>> 0;
+            const t2 = ((ror(a, 2) ^ ror(a, 13) ^ ror(a, 22)) + ((a & b) ^ (a & c) ^ (b & c))) >>> 0;
+            hh = g;
+            g = f;
+            f = e;
+            e = (d + t1) >>> 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (t1 + t2) >>> 0;
+        }
+        for (let i = 0; i < 8; i++)
+            h[i] = (h[i] + [a, b, c, d, e, f, g, hh][i]) >>> 0;
+    }
+    return `sha256:${Array.from(h, word => word.toString(16).padStart(8, "0")).join("")}`;
+}

package/dist/runtime/sub-agent-orchestrator.d.ts

@@ -7,7 +7,7 @@ export interface SubAgentRunContext {
     spec: AgentRunSpec;
     manifest: AgentProcessChangedObservation;
     sessionLog: SessionLog;
-    /** M5 v2.1: set when this child is a workflow node — propagated so a nested `start_workflow`
+    /** workflow-node: set when this child is a workflow node — propagated so a nested `start_workflow`
      *  FLATTENS to the parent kernel rather than auto-pivoting into its own bootstrap. */
     isWorkflowNode?: boolean;
     /** W-N1 tool exposure. The kernel omits an EMPTY `permitted_capability_ids` on the wire, so a

package/dist/runtime/sub-agent-orchestrator.js

@@ -39,7 +39,7 @@ function deriveMetaTools(permitted, opts) {
     const metaTools = new Set();
     if (permitted.has("skill") && opts.skillContentMap?.size)
         metaTools.add("skill");
-    if (permitted.has("memory") && opts.dreamStore)
+    if (permitted.has("memory") && opts.memoryStore)
         metaTools.add("memory");
     if (permitted.has("knowledge") && opts.knowledgeSource)
         metaTools.add("knowledge");
@@ -53,7 +53,7 @@ function availableMetaTools(opts) {
     const metaTools = new Set();
     if (opts.skillContentMap?.size)
         metaTools.add("skill");
-    if (opts.dreamStore)
+    if (opts.memoryStore)
         metaTools.add("memory");
     if (opts.knowledgeSource)
         metaTools.add("knowledge");
@@ -116,7 +116,7 @@ export class SubAgentOrchestrator {
             systemPrompt,
             sessionLog: ctx.sessionLog,
             skillContentMap: metaTools.has("skill") ? ctx.parentOpts.skillContentMap : undefined,
-            dreamStore: metaTools.has("memory") ? ctx.parentOpts.dreamStore : undefined,
+            memoryStore: metaTools.has("memory") ? ctx.parentOpts.memoryStore : undefined,
             knowledgeSource: metaTools.has("knowledge") ? ctx.parentOpts.knowledgeSource : undefined,
             enablePlanTool: metaTools.has("update_plan") ? ctx.parentOpts.enablePlanTool : undefined,
             // The child runs under ITS OWN spec, never the parent's: the spread above would otherwise

package/dist/runtime/types/agent.d.ts

@@ -45,7 +45,7 @@ export interface AgentRunSpec {
      *  The ceiling bounds what this run may EVER expose; the baseline selects which of those are
      *  advertised before any skill activates, so `exposed = meta ∪ ((baseline ∪ stableCore ∪
      *  ⋃ activeSkills.allowed_tools) ∩ ceiling)`. That makes narrow→wide progressive disclosure
-     *  expressible. Absent ⇒ legacy behavior. `[]` is meaningful and distinct from absent: the minimal
+     *  expressible. Absent and `[]` both mean the minimal
      *  surface (meta-tools + stable-core only). Entries outside the ceiling silently intersect away.
      *  Lowered from `RuntimeOptions.baselineToolIds`. */
     exposureBaseline?: string[];
@@ -84,7 +84,7 @@ export interface LoopResult {
     finalMessage?: Message;
     turnsUsed: number;
     totalTokensUsed: number;
-    /** A#2 v2 loop stop signal: a loop iteration sets `false` to end the loop before `max_iters`.
+    /** loop-control loop stop signal: a loop iteration sets `false` to end the loop before `max_iters`.
      *  `undefined` (every non-loop result) ⇒ no opinion → run to the cap. Sent only when set. */
     loopContinue?: boolean;
     /** A#2 classify routing: a classifier node reports the chosen branch label here; the kernel runs
@@ -94,7 +94,7 @@ export interface LoopResult {
     tournamentWinner?: string;
     /** ③ loop-agent pacing: the kernel-adjudicated after-round decision, surfaced by the orchestrator
      *  from the child's done event. For a loop-node iteration this is the PRIMARY continuation
-     *  vocabulary (stop → loopContinue=false); the legacy text-sniffed signal is the fallback.
+     *  vocabulary (stop → loopContinue=false).
      *  SDK-internal — stripped by `subAgentResultToKernel`. */
     paceDecision?: import("../kernel-step.js").PaceDecision;
 }
@@ -149,6 +149,14 @@ export type WorkflowTaskSpec = {
 export type NodeTrust = "trusted" | "quarantined";
 export type WorkflowDependencyPolicy = "all_success" | "accept_partial" | "all_terminal" | "optional";
 export type WorkflowNodeStatus = "completed" | "completed_partial" | "failed" | "skipped_upstream_failed";
+/** Host-observed, deterministic scheduling inputs for one workflow node. They never originate
+ * from model-authored workflow tools. */
+export interface SchedulingFactors {
+    deadlineUrgency?: number;
+    processPriority?: number;
+    resourcePressure?: number;
+    budgetPressure?: number;
+}
 export declare function workflowNodeStatusFromTermination(termination: TerminationReason | string): WorkflowNodeStatus;
 export interface WorkflowNodeSpec {
     task: WorkflowTaskSpec;
@@ -163,7 +171,7 @@ export interface WorkflowNodeSpec {
     /** G2: make this a deterministic reduce node — runs no LLM; the runner routes it to the registered
      *  reducer of this name over its `dependsOn` nodes' outputs. */
     reducer?: string;
-    /** A#2 v2: make this a *loop* node — re-run its agent up to `maxIters` times. An iteration may end
+    /** loop-control: make this a *loop* node — re-run its agent up to `maxIters` times. An iteration may end
      *  the loop early by reporting `loopContinue: false` (the runner solicits this from the agent). */
     loop?: {
         maxIters: number;
@@ -187,6 +195,8 @@ export interface WorkflowNodeSpec {
     maxTurns?: number;
     /** O3: cap this node's child run at `maxWallMs` wall-clock milliseconds. */
     maxWallMs?: number;
+    /** Host-only scheduling facts used with the configured deterministic scheduler policy. */
+    schedulingFactors?: SchedulingFactors;
     /** Indices of nodes this node depends on. */
     dependsOn?: number[];
     /** How dependency terminal states gate this node. Defaults to `all_success`. */
@@ -251,7 +261,7 @@ export interface WorkflowSpawnInfo {
         left: string;
         right: string;
     };
-    /** A#2 v2: present only for a *loop* iteration spawn — the loop's `max_iters`. Marks the spawn as a
+    /** loop-control: present only for a *loop* iteration spawn — the loop's `max_iters`. Marks the spawn as a
      *  loop iteration so the runner solicits + reports a `loopContinue` stop signal. */
     loop_max_iters?: number;
     /** A#2: present only for a *classify* spawn — the branch labels the classifier must choose among.
@@ -286,9 +296,9 @@ export declare function workflowBudgetNote(budget: WorkflowBudget | undefined):
 export declare function workflowNodeSpecToKernel(n: WorkflowNodeSpec): Record<string, unknown>;
 export declare function workflowSpecToKernel(spec: WorkflowSpec): Record<string, unknown>;
 export declare const submitWorkflowNodesTool: ToolSchema;
-/** M5 v1 (flatten): the tool an agent calls to author a sub-workflow — a cohesive DAG of nodes
+/** workflow authoring: the tool an agent calls to author a sub-workflow — a cohesive DAG of nodes
  *  composed onto the running workflow. Lowers to the same append path as `submit_workflow_nodes`
- *  (a `WorkflowSpec` is a node batch). v2 adds top-level bootstrap (the `LoadWorkflow` syscall). */
+ *  (a `WorkflowSpec` is a node batch). Top-level bootstrap uses (the `LoadWorkflow` syscall). */
 export declare const startWorkflowTool: ToolSchema;
 /** Build a sub-agent run spec for a kernel-generated workflow node. */
 export declare function workflowNodeToSpec(node: WorkflowSpawnInfo, parentSessionId: string): AgentRunSpec;