@deepstrike/sdk 0.2.52 → 0.2.61

package/dist/runtime/runner.js

@@ -13,29 +13,37 @@ 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 { governancePolicyToKernelEvent, governanceFilterSchema } from "../governance.js";
+import { createProviderRequestPlanForProvider, estimateProviderPromptTokens, measurementForPlan, recordPromptMeasurement, } from "../providers/request-plan.js";
 import { kernelObservationToSessionEvent } from "./kernel-event-log.js";
 import { assertNativeProfile } from "./os-profile.js";
 import { PayloadStore } from "./payload-store.js";
 import { formatToolError } from "../tools/errors.js";
 import { ManagedTaskScope } from "./reliability.js";
-import { contextPolicyV1, normalizeContextPolicyV1, } from "./context-policy.js";
+import { contextPolicy, normalizeContextPolicy, } from "./context-policy.js";
 import { composeSystemPrompt } from "../harness/manifest.js";
+import { attachToolOutputOverlay, normalizeToolResultContent } from "../providers/content-normalization.js";
+import { decodeDurableContent, decodeDurableToolResult, durableBlocksToToolOutput, toolOutputBlocksToDurable } from "./durable-content.js";
+import { classifyProviderError, providerErrorEventFields } from "../providers/provider-error.js";
 import { NudgeEngine } from "../harness/nudge.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) {
@@ -214,19 +222,19 @@ export class RuntimeRunner {
         return this.fallbackPayloadStore;
     }
     async persistMemoryToStore(memory, agentId) {
-        if (!this.opts.dreamStore)
-            throw new Error("memory persistence requires dreamStore");
-        await this.opts.dreamStore.upsert(agentId, memory);
+        if (!this.opts.memoryStore)
+            throw new Error("memory persistence requires memoryStore");
+        await this.opts.memoryStore.put(agentId, memory);
     }
     async retrieveMemoryFromStore(query, requestedK, agentId) {
-        if (!this.opts.dreamStore)
-            throw new Error("memory queries require dreamStore");
-        return (await this.opts.dreamStore.search(agentId, { ...query, top_k: requestedK }))
+        if (!this.opts.memoryStore)
+            throw new Error("memory queries require memoryStore");
+        return (await this.opts.memoryStore.search(agentId, { ...query, top_k: requestedK }))
             .slice(0, requestedK);
     }
     /**
      * Route a host-originated renewal prefetch into canonical knowledge commands. This is not an
-     * agent syscall: the host selects records from its store, then the kernel owns the only mutation
+     * agent syscall: the host selects records from its store, then the kernel owns the write
      * of live semantic context. `seenRecordIds` is the prefetch's dedupe horizon.
      */
     async prefetchMemoryIntoKnowledge(runtime, query, agentId, sessionId, seenRecordIds, leftovers) {
@@ -261,7 +269,7 @@ export class RuntimeRunner {
     async writeMemory(memory, opts = {}) {
         const sessionId = opts.sessionId ?? this.currentSessionId;
         const agentId = opts.agentId ?? this.opts.agentId;
-        if (!this.opts.dreamStore || !agentId)
+        if (!this.opts.memoryStore || !agentId)
             return;
         const policy = this.opts.memoryPolicy;
         if (policy?.validationEnabled !== false) {
@@ -300,7 +308,7 @@ export class RuntimeRunner {
     async queryMemory(query, opts = {}) {
         const sessionId = opts.sessionId ?? this.currentSessionId;
         const agentId = opts.agentId ?? this.opts.agentId;
-        if (!this.opts.dreamStore || !agentId)
+        if (!this.opts.memoryStore || !agentId)
             return [];
         const hits = await this.retrieveMemoryFromStore(query, query.top_k, agentId);
         await this.applyHostMemoryRecallLifecycle(hits, agentId);
@@ -315,7 +323,7 @@ export class RuntimeRunner {
             recall_count: hit.record.recall_count + 1,
             last_recalled_at: Date.now(),
         }));
-        await this.opts.dreamStore?.recordRecall?.(agentId, recalls);
+        await this.opts.memoryStore?.recordRecall?.(agentId, recalls);
         const threshold = this.opts.memoryPolicy?.promotionRecallThreshold;
         if (threshold === undefined)
             return;
@@ -423,13 +431,12 @@ 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));
         }
         if (this.opts.kernelReliability) {
             config.reliability = kernelReliabilityToKernel(this.opts.kernelReliability);
         }
         config.signal_policy = {
-            version: 1,
             queue_max: signalPolicy.queueMax,
             ...(signalPolicy.ttlMs !== undefined ? { ttl_ms: signalPolicy.ttlMs } : {}),
             ...(signalPolicy.deadlineEscalation !== undefined
@@ -484,11 +491,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;
@@ -517,8 +519,8 @@ export class RuntimeRunner {
     async mirrorMemoryLifecycle(obs) {
         if (obs.kind === "memory_recalled" && obs.recalls?.length) {
             const agentId = this.opts.agentId;
-            if (agentId && this.opts.dreamStore?.recordRecall) {
-                await this.opts.dreamStore.recordRecall(agentId, obs.recalls);
+            if (agentId && this.opts.memoryStore?.recordRecall) {
+                await this.opts.memoryStore.recordRecall(agentId, obs.recalls);
             }
         }
         if (obs.kind === "promotion_suggested" && obs.record_id) {
@@ -642,20 +644,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; the kernel runs that
         // branch and prunes the rest. No recognizable choice ⇒ leave unset (kernel prunes all branches).
@@ -1298,6 +1295,7 @@ export class RuntimeRunner {
                             output: `permission denied: ${denyReason}`,
                             is_error: true,
                             error_kind: "governance_denied",
+                            content: { blocks: [{ type: "text", text: `permission denied: ${denyReason}` }] },
                         }],
                 });
             }
@@ -1317,7 +1315,16 @@ export class RuntimeRunner {
         }
         const ext = { ...this.opts.extensions, ...(extensions ?? {}) };
         const providerState = this.opts.provider.createRunState?.();
+        // Structured blocks are intentionally operation-local. The durable kernel wire carries the
+        // text projection; a wake (same or new Runner) therefore has identical semantics.
+        const toolOutputOverlay = new Map();
         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;
@@ -1393,7 +1400,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 });
                 }
                 // Install optional memory policy. Maps the ergonomic camelCase option onto the kernel's
@@ -1439,18 +1446,15 @@ 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. Each augments an explicit spec, else
-            // synthesizes a minimal top-level spec carrying just the exposure config (reuses the existing
-            // run_spec wire — no new ABI). Unset on all ⇒ no run_spec ⇒ no gating (铁律: no config = old
-            // behavior).
+            // pre-activation surface to the kernel run spec. Each 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;
+            const baselineToolIds = this.opts.baselineToolIds ?? this.opts.runSpec?.exposureBaseline ?? [];
             const hasMilestoneContract = this.opts.milestoneContract !== undefined;
-            if (this.opts.runSpec || hasProfile || hasBaseline || hasMilestoneContract) {
+            {
                 const baseSpec = this.opts.runSpec ?? {
                     identity: { agentId: this.opts.agentId ?? "root", sessionId, isSubAgent: false },
                     role: "custom",
@@ -1459,8 +1463,7 @@ export class RuntimeRunner {
                 let spec = hasProfile
                     ? { ...baseSpec, capabilityFilter: { ...baseSpec.capabilityFilter, allowedIds: allowedToolIds } }
                     : baseSpec;
-                if (hasBaseline)
-                    spec = { ...spec, exposureBaseline: baselineToolIds };
+                spec = { ...spec, exposureBaseline: baselineToolIds };
                 if (hasMilestoneContract && !spec.verificationContractId) {
                     spec = { ...spec, verificationContractId: "node-default" };
                 }
@@ -1507,7 +1510,7 @@ export class RuntimeRunner {
             // I4/T5: pre-fetch memory before root start so the model sees it on turn 1 instead of
             // discovering it via the `memory` tool later. Accepted hits enter `initial_context.messages`
             // and are therefore frozen into the canonical start record. Skipped on restore (the checkpoint
-            // or journal already owns them) and when dreamStore/agentId is absent.
+            // or journal already owns them) and when memoryStore/agentId is absent.
             // P0-C: the skill loaded and in effect going into the current turn (updated when the model's
             // `skill` tool call resolves). Drives the per-turn `activeSkill` metric → dwell measurement.
             let activeSkill;
@@ -1552,7 +1555,7 @@ export class RuntimeRunner {
                         // model sees them — the model can't plan a call it doesn't know about, so the rollback
                         // overhead disappears. The list of denied names is appended to systemKnowledge so the
                         // model knows not to plan around them.
-                        let context = action.context;
+                        let context = attachToolOutputOverlay(action.context, toolOutputOverlay);
                         let tools = action.tools;
                         if (this.opts.governancePolicy && this.opts.governancePolicy.surfaceDeniedInSystem !== false) {
                             const { allowed, denied } = governanceFilterSchema(tools, this.opts.governancePolicy);
@@ -1572,8 +1575,57 @@ export class RuntimeRunner {
                         let turnOutputTokens = 0;
                         let turnCacheReadTokens = 0;
                         let turnCacheCreationTokens = 0;
+                        let turnCacheTelemetryStatus = "unavailable";
+                        let turnCacheTelemetrySource;
                         let turnCacheReadBySlot;
                         let turnStopReason;
+                        const providerPlan = createProviderRequestPlanForProvider(this.opts.provider, context, tools, ext);
+                        const recorded = measurementForPlan(providerPlan, recordedMeasurements.get(providerPlan.fingerprint));
+                        let promptMeasurement = recorded;
+                        if (!promptMeasurement && !context.budgetOverflow) {
+                            try {
+                                const count = this.opts.provider.countTokens
+                                    ? await withTimeout(this.opts.provider.countTokens(context, tools, Object.keys(ext).length ? ext : undefined), 5_000)
+                                    : undefined;
+                                promptMeasurement = recordPromptMeasurement(providerPlan, count ?? {
+                                    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);
+                        // Heuristic and non-native counts are advisory: their purpose is to choose a better
+                        // compaction path, not to turn a coarse byte estimate into a false context-overflow
+                        // terminal. A trustworthy native/local-exact measurement can block the provider call.
+                        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)) {
@@ -1590,9 +1642,36 @@ export class RuntimeRunner {
                                     // P0-C: capture the prompt-cache split for the tool-gating hit-rate baseline.
                                     turnCacheReadTokens = usageEvt.cacheReadInputTokens ?? 0;
                                     turnCacheCreationTokens = usageEvt.cacheCreationInputTokens ?? 0;
+                                    turnCacheTelemetryStatus = usageEvt.cacheTelemetryStatus
+                                        ?? usageEvt.providerUsage?.cacheTelemetryStatus
+                                        ?? ((usageEvt.cacheReadInputTokens ?? 0) > 0 || (usageEvt.cacheCreationInputTokens ?? 0) > 0
+                                            ? "measured"
+                                            : "unavailable");
+                                    turnCacheTelemetrySource = usageEvt.cacheTelemetrySource ?? usageEvt.providerUsage?.cacheTelemetrySource;
                                     // I1: per-slot attribution forwarded into TurnMetrics. Undefined when the provider
                                     // doesn't honor cache_control (OpenAI-family auto-cache).
                                     turnCacheReadBySlot = usageEvt.cacheReadInputTokensBySlot;
+                                    // spc_024-06: postflight observed input is the authority (INV-024-08). Feed it back
+                                    // as a durable measurement fact for this exact request fingerprint so replay reuses
+                                    // the observed truth instead of re-counting (or trusting the preflight estimate).
+                                    if (turnInputTokens > 0) {
+                                        const postflight = recordPromptMeasurement(providerPlan, {
+                                            inputTokens: turnInputTokens,
+                                            source: { kind: "postflight" },
+                                            confidence: "exact",
+                                        });
+                                        recordedMeasurements.set(providerPlan.fingerprint, postflight);
+                                        await this.opts.sessionLog.append(sessionId, {
+                                            kind: "prompt_measured",
+                                            turn: runtime.turn(),
+                                            measurement: {
+                                                requestFingerprint: postflight.requestFingerprint,
+                                                inputTokens: postflight.inputTokens,
+                                                source: postflight.source,
+                                                confidence: postflight.confidence,
+                                            },
+                                        });
+                                    }
                                     // Phase 4: stop_reason drives the kernel's max-output-tokens recovery. The closing
                                     // usage frame carries it; keep the last non-empty value seen this turn.
                                     if (usageEvt.stopReason)
@@ -1615,6 +1694,9 @@ export class RuntimeRunner {
                                 this.cancellationReason ??= "user";
                             }
                             else {
+                                const provider = this.opts.provider.descriptor?.().provider ?? "unknown";
+                                const providerError = classifyProviderError(provider, err);
+                                const message = providerError.message;
                                 // 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
@@ -1625,14 +1707,15 @@ export class RuntimeRunner {
                                 action = await this.commitKernelAction(runtime, this.pendingObservations, {
                                     kind: "provider_error",
                                     effect_id: providerEffectId,
-                                    message: formatToolError(err),
+                                    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`)
                                 // the error stays hidden, so embedders that terminate on `error` events don't see a
                                 // phantom failure mid-recovery.
                                 if (action.kind === "done") {
-                                    yield { type: "error", message: formatToolError(err) };
+                                    yield { type: "error", message };
                                 }
                                 continue;
                             }
@@ -1728,6 +1811,10 @@ export class RuntimeRunner {
                                     inputTokens: turnInputTokens,
                                     cacheReadTokens: turnCacheReadTokens,
                                     cacheCreationTokens: turnCacheCreationTokens,
+                                    cacheTelemetryStatus: turnCacheTelemetryStatus,
+                                    ...(turnCacheTelemetrySource ? { cacheTelemetrySource: turnCacheTelemetrySource } : {}),
+                                    requestFingerprint: providerPlan.fingerprint,
+                                    stablePrefixFingerprint: providerPlan.stablePrefixFingerprint,
                                     ...(turnCacheReadBySlot ? { cacheReadTokensBySlot: turnCacheReadBySlot } : {}),
                                 });
                             }
@@ -1918,7 +2005,7 @@ export class RuntimeRunner {
                             agentId: this.opts.agentId,
                             memoryScope: this.opts.memoryScope,
                             skillDir: this.opts.skillDir,
-                            dreamStore: this.opts.dreamStore,
+                            memoryStore: this.opts.memoryStore,
                             knowledgeSource: this.opts.knowledgeSource,
                             onToolSuspend: this.opts.onToolSuspend,
                             onPermissionRequest: this.opts.onPermissionRequest,
@@ -1944,8 +2031,7 @@ export class RuntimeRunner {
                         }
                         // O5 (PreToolUse-hook analog): give the host a STATEFUL veto over each kernel-approved
                         // call. A blocked call never executes; its reason reaches the model as a committed
-                        // governance-denied tool result. Decision failures are closed
-                        // unless the host explicitly marks this hook advisory with `onToolCallFailure: "open"`.
+                        // governance-denied tool result. Decision failures are closed.
                         let executableCalls = normalCalls;
                         if (this.opts.onToolCall) {
                             const allowed = [];
@@ -1955,9 +2041,7 @@ export class RuntimeRunner {
                                     decision = await this.opts.onToolCall({ callId: call.id, name: call.name, arguments: call.arguments });
                                 }
                                 catch (cause) {
-                                    decision = this.opts.onToolCallFailure === "open"
-                                        ? undefined
-                                        : { block: true, reason: `onToolCall hook failed: ${formatToolError(cause)}` };
+                                    decision = { block: true, reason: `onToolCall hook failed: ${formatToolError(cause)}` };
                                 }
                                 if (decision?.block) {
                                     const reason = decision.reason ?? "blocked by host onToolCall hook";
@@ -1979,12 +2063,17 @@ export class RuntimeRunner {
                                 yield evt;
                                 if (evt.type === "tool_result") {
                                     const tre = evt;
+                                    if (tre.contentParts !== undefined) {
+                                        const canonical = normalizeToolResultContent(tre.callId, tre.content, tre.isError, tre.contentParts);
+                                        toolOutputOverlay.set(tre.callId, canonical.blocks);
+                                    }
                                     toolResults.push({
                                         callId: tre.callId,
                                         output: tre.content,
                                         isError: tre.isError,
                                         isFatal: tre.isFatal,
                                         errorKind: tre.errorKind,
+                                        ...(tre.contentParts?.length ? { contentParts: tre.contentParts } : {}),
                                     });
                                 }
                                 else if (evt.type === "tool_argument_repaired") {
@@ -2069,6 +2158,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 }]) },
                             })),
                         });
                         // The canonical provider resolution already activates a successfully resolved `skill` call.
@@ -2256,7 +2346,7 @@ export class RuntimeRunner {
                 });
                 this.activeGroupBudgetScope = undefined;
             }
-            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,
@@ -2274,9 +2364,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, agentId: this.opts.agentId });
                             }
@@ -2313,7 +2403,7 @@ export class RuntimeRunner {
      *  after each sprint renewal (`phase: "renewal"`): renewal drops the old history INCLUDING the
      *  earlier memory hits, so the new sprint gets a fresh recall pass. 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 undefined;
         // 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.
@@ -2351,7 +2441,7 @@ export class RuntimeRunner {
         return undefined;
     }
     async prefetchMemoryIntoInitialContext(runtime) {
-        if (!this.opts.dreamStore || !this.opts.agentId || !this.opts.memoryScope)
+        if (!this.opts.memoryStore || !this.opts.agentId || !this.opts.memoryScope)
             return;
         const preQuery = this.opts.preQueryMemory
             ?? ((ctx) => [{
@@ -2440,11 +2530,11 @@ export class RuntimeRunner {
         return nextArchiveStart;
     }
     async archiveSemanticPageOut(archived, action, sessionId) {
-        if (!this.opts.dreamStore || !this.opts.agentId || !this.opts.memoryScope)
+        if (!this.opts.memoryStore || !this.opts.agentId || !this.opts.memoryScope)
             return;
-        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);
         // P2 write-funnel: route through the ONE gated WriteMemory syscall so validation,
         // the rolling write quota, dedup, and the memory_written audit all apply. Score is
         // advisory (0.6) — an automatic summary must never outrank curated content.
@@ -2666,11 +2756,16 @@ export function replayMessages(events, maxBytes) {
         }
         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: "",
                     toolCalls: [],
-                    contentParts: [{ type: "tool_result", callId: r.call_id, output: sanitizeReplayText(r.output, maxBytes), isError: r.is_error ?? false }],
+                    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,
                 });
             }
@@ -2764,11 +2859,16 @@ export async function replayMessagesAsync(events, maxBytes, loadArchive) {
         }
         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: "",
                     toolCalls: [],
-                    contentParts: [{ type: "tool_result", callId: r.call_id, output: sanitizeReplayText(r.output, maxBytes), isError: r.is_error ?? false }],
+                    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,
                 });
             }
@@ -2790,6 +2890,21 @@ function nextArchivedSeqStart(events) {
     }
     return next;
 }
+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);
+    }
+}
 /** Collect all text_delta events from a run into a single string. */
 export async function collectText(stream) {
     let text = "";

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

@@ -1,5 +1,6 @@
 import type { KernelPrimitive } from "./kernel-event-log.js";
 import type { ContentPart, ProviderReplay, ToolCall, ToolErrorKind } from "../types.js";
+import type { RecordedPromptMeasurement } from "../providers/request-plan.js";
 import type { MemoryRecall, MemoryScope } from "../memory/protocols.js";
 import type { KernelJournal } from "./kernel-journal.js";
 export type RollbackReason = {
@@ -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-log.js

@@ -5,6 +5,7 @@ import { createInterface } from "node:readline";
 import { primitiveForKind } from "./kernel-event-log.js";
 import { KeyedSerialExecutor } from "./reliability.js";
 import { FileKernelJournal, InMemoryKernelJournal } from "./kernel-journal.js";
+import { decodeDurableContent } from "./durable-content.js";
 /**
  * **Single-process dev/test implementation** of both capabilities (spec §9.4: one class may
  * implement several capabilities; the *interfaces* stay separate). Its `KernelJournal` half is
@@ -84,7 +85,7 @@ export class FileSessionLog {
     async read(sessionId, fromSeq = 0, primitiveFilter) {
         const results = [];
         for (const record of await this.readRecords(sessionId)) {
-            if (!("event" in record) || record.seq < fromSeq)
+            if (record.seq < fromSeq)
                 continue;
             if (primitiveFilter && primitiveForKind(record.event.kind) !== primitiveFilter)
                 continue;
@@ -133,7 +134,7 @@ export class FileSessionLog {
             });
             for await (const line of rl) {
                 if (line.trim())
-                    records.push(JSON.parse(line));
+                    records.push(decodePersistedSessionRecord(JSON.parse(line)));
             }
         }
         catch (err) {
@@ -143,3 +144,42 @@ export class FileSessionLog {
         return records;
     }
 }
+function decodePersistedSessionRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("session record must be an object");
+    const record = value;
+    if (Object.keys(record).some(key => key !== "seq" && key !== "event"))
+        throw new Error("session record has unknown fields");
+    if (!Number.isInteger(record.seq) || record.seq < 0)
+        throw new Error("session record seq must be a non-negative integer");
+    if (!record.event || typeof record.event !== "object" || Array.isArray(record.event))
+        throw new Error("session record event must be an object");
+    const event = record.event;
+    if (event.kind === "llm_completed" && event.provider_replay !== undefined) {
+        assertCanonicalProviderReplay(event.provider_replay);
+    }
+    if (event.kind === "tool_completed") {
+        if (!Array.isArray(event.results))
+            throw new Error("tool_completed results must be an array");
+        for (const result of event.results) {
+            if (!result || typeof result !== "object" || Array.isArray(result))
+                throw new Error("tool_completed result must be an object");
+            const wire = result;
+            if ("blocks" in wire)
+                throw new Error("tool_completed result has removed blocks field");
+            decodeDurableContent(wire.content);
+        }
+    }
+    return { seq: record.seq, event: event };
+}
+const REPLAY_KEYS = new Set(["protocol", "provider", "model", "native_blocks", "reasoning_content", "reasoning_details", "native_message", "tool_calls"]);
+function assertCanonicalProviderReplay(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("provider replay must be an object");
+    const replay = value;
+    for (const key of Object.keys(replay))
+        if (!REPLAY_KEYS.has(key))
+            throw new Error(`provider replay has unknown field ${key}`);
+    if (typeof replay.protocol !== "string" || replay.protocol.length === 0)
+        throw new Error("provider replay protocol is required");
+}