@deepstrike/wasm 0.2.77 → 0.2.79

package/dist/runtime/runner.js

@@ -1,13 +1,14 @@
 import { prepareProviderRequest } from "../providers/prepared-request.js";
-import { createNativeContextPreparationAdapter } from "./context.js";
-import { sha256Hex } from "./sha256.js";
-import { extractSessionMemories } from "../memory/extraction.js";
+import { resolveMemoryRuntimePolicy } from "../memory/runtime-policy.js";
+import { memoryCandidateId } from "../memory/candidate-sink.js";
 import { resolvePermissionRequest } from "./execution-plane.js";
 import { governancePolicyToKernelEvent } from "../governance.js";
 import { parseToolCallArguments } from "./tool-arguments.js";
 import { stripSkillFrontmatter } from "./execution-plane.js";
 import { getKernel } from "./kernel.js";
 import { checkMemoryWrite, deriveMemoryRecall } from "../memory/authority.js";
+import { memoryFetchRecall } from "../memory/recall-projection.js";
+import { MemoryWriter } from "../memory/writer.js";
 import { CanonicalRunnerRuntime, canonicalKernelAction, canonicalKernelApply, isInvalidInputError, canonicalKernelMaybeAction, canonicalStartAgent, canonicalStartWorkflow, sha256 as canonicalSha256, } from "./canonical-kernel-step.js";
 import { peekProviderReplay, seedProviderReplayFromEvents } from "./provider-replay.js";
 import { sanitizeReplayText } from "./replay-sanitize.js";
@@ -18,8 +19,6 @@ import { messageToKernelMessage, archivePresentationFromObservations, skillMetad
 import { agentRunSpecToKernel, MILESTONE_UNVERIFIED_REASON, milestoneCheckFail, milestoneCheckPass, milestoneCheckResultToKernel, subAgentResultToKernel, workflowBudgetNote, workflowNodeSpecToKernel, workflowNodeOutcomeFromKernel, workflowNodeStatusFromTermination, workflowNodeToManifest, workflowNodeToSpec, workflowSpecToKernel, } from "./types/agent.js";
 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, 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";
@@ -107,8 +106,19 @@ function controlRequestRejection(observations, operation) {
         reason: typeof rejected.reason === "string" ? rejected.reason : "request denied",
     };
 }
+/** The kernel's wire form of the tiers a provider performs natively, or nothing when it performs
+ *  none — an operation that delegates nothing configures exactly as before. */
+export function delegatedContextTiers(native) {
+    if (!native?.toolResultClearing && !native?.compaction)
+        return undefined;
+    return {
+        ...(native.toolResultClearing ? { tool_result_clearing: true } : {}),
+        ...(native.compaction ? { compaction: true } : {}),
+    };
+}
 export class RuntimeRunner {
     opts;
+    memoryRuntimeGates;
     interrupted = false;
     cancellationReason;
     /** #2-B-ii: aborts the in-flight provider stream on interrupt/preempt. Recreated per `execute`. */
@@ -147,6 +157,10 @@ export class RuntimeRunner {
     activeProviderInvocationId;
     constructor(opts) {
         this.opts = opts;
+        this.memoryRuntimeGates = resolveMemoryRuntimePolicy(opts.memoryRuntimePolicy);
+        if (this.memoryPathToCandidateSink("modelWrites") && !opts.memoryCandidateSink) {
+            throw new Error('memory runtime policy modelWrites = "candidate_sink" needs RuntimeOptions.memoryCandidateSink');
+        }
         const schemaAttempts = opts.workflowSchemaValidationAttempts ?? 2;
         if (!Number.isInteger(schemaAttempts) || schemaAttempts < 1 || schemaAttempts > 16) {
             throw new RangeError("workflowSchemaValidationAttempts must be an integer between 1 and 16");
@@ -181,7 +195,6 @@ export class RuntimeRunner {
             maxTurns: this.opts.maxTurns,
             maxTotalTokens: this.opts.maxTotalTokens,
             maxWallMs: this.opts.timeoutMs,
-            artifactSetDigest: this.opts.artifactSetDigest,
             memoryBindingId: `wasm-memory-${this.opts.agentId ?? "root"}`,
             persistPayload: async (_callId, content, previewBytes) => {
                 const digest = canonicalSha256(content);
@@ -346,9 +359,9 @@ export class RuntimeRunner {
      * §22.13 · a host-authored memory write. The kernel decides whether it may happen: a live
      * operation answers through `admit_memory_write` (the model's validation rule and rolling write
      * quota); with no live operation the same kernel rule answers statelessly. Resolves `true` when
-     * the record was persisted.
+     * the record was persisted or submitted as a pending candidate.
      */
-    async writeMemory(memory, sessionId) {
+    async writeMemory(memory, sessionId, candidate) {
         if (!this.opts.memoryStore || !this.opts.agentId)
             return false;
         const turn = this.activeKernel?.turn() ?? 0;
@@ -361,6 +374,12 @@ export class RuntimeRunner {
             }
             return false;
         }
+        if (candidate) {
+            const receipt = await this.memoryWriter().propose(this.opts.agentId, { candidate_id: candidate.candidateId, source: candidate.source, record: memory });
+            if (sessionId)
+                await this.opts.sessionLog.append(sessionId, this.memoryCandidateEvent(receipt, candidate.source, memory));
+            return receipt.status !== "rejected";
+        }
         try {
             await this.opts.memoryStore.put(this.opts.agentId, memory);
         }
@@ -376,6 +395,114 @@ export class RuntimeRunner {
         }
         return true;
     }
+    /**
+     * M4 · a host-initiated recall (an explicit `recall`). Same path as the prefetch: the retrieval
+     * gate, the policy's `retrievalTopK`, the kernel-derived recall lifecycle, and a
+     * `memory_retrieval_result` audit.
+     */
+    async queryMemory(query, sessionId) {
+        if (!this.opts.memoryStore || !this.opts.agentId)
+            return [];
+        if (!this.memoryPathEnabled("retrievalEnabled"))
+            return [];
+        const policyLimit = this.opts.memoryPolicy?.retrievalTopK;
+        const limit = policyLimit === undefined ? query.top_k : Math.min(query.top_k, policyLimit);
+        if (limit <= 0)
+            return [];
+        const hits = (await this.opts.memoryStore.search(this.opts.agentId, { ...query, top_k: limit })).slice(0, limit);
+        await this.recordHostMemoryRecall(hits);
+        if (sessionId)
+            await this.opts.sessionLog.append(sessionId, { kind: "memory_retrieval_result", hits });
+        return hits;
+    }
+    async persistMemoryEffectResult(operationId, effectId, canonicalMemory) {
+        const agentId = this.opts.agentId;
+        const record = {
+            record_id: `memory:${crypto.randomUUID()}`,
+            scope: this.opts.memoryScope ?? { tenant_id: "default", namespace: agentId ?? "default" },
+            name: String(canonicalMemory.name ?? ""),
+            kind: String(canonicalMemory.kind ?? "reference"),
+            content: String(canonicalMemory.content ?? ""),
+            description: String(canonicalMemory.description ?? ""),
+            provenance: {
+                author: "model",
+                trust: "untrusted",
+                evidence_refs: Array.isArray(canonicalMemory.evidence_refs)
+                    ? canonicalMemory.evidence_refs.map(String)
+                    : [],
+            },
+            created_at: Number(canonicalMemory.accepted_at_ms ?? Date.now()),
+            updated_at: Number(canonicalMemory.accepted_at_ms ?? Date.now()),
+            recall_count: 0,
+            confidence: 1,
+            links: [],
+            pinned: false,
+        };
+        if (this.memoryPathToCandidateSink("modelWrites")) {
+            try {
+                if (!agentId)
+                    throw new Error("memory persistence requires RuntimeOptions.agentId");
+                const modelProposal = Boolean(canonicalMemory.causation && typeof canonicalMemory.causation === "object" && canonicalMemory.causation.kind === "provider_tool");
+                const source = modelProposal ? "model_proposal" : "child_request";
+                // Child requests keep their v2 identity so in-flight redeliveries still match the sink.
+                const candidateId = modelProposal
+                    ? await memoryCandidateId(["v3", agentId, "model_proposal", operationId, effectId, "0"])
+                    : await memoryCandidateId(["v2", agentId, "child_request", operationId, effectId, "0"]);
+                const receipt = await this.memoryWriter().propose(agentId, { candidate_id: candidateId, source, record });
+                return { kind: "memory_candidate_result", effect_id: effectId, ...receipt };
+            }
+            catch (cause) {
+                return { kind: "memory_candidate_result", effect_id: effectId, error: formatToolError(cause) };
+            }
+        }
+        try {
+            if (!this.memoryPathEnabled("modelWritesEnabled")) {
+                throw new Error("model memory writes are disabled by memoryRuntimePolicy.modelWrites");
+            }
+            if (!agentId)
+                throw new Error("memory persistence requires RuntimeOptions.agentId");
+            // The receipt names what the store now holds: the record's id and its content digest.
+            const receipt = await this.memoryWriter().persist(agentId, record);
+            return { kind: "memory_persist_result", effect_id: effectId, ...receipt };
+        }
+        catch (cause) {
+            return { kind: "memory_persist_result", effect_id: effectId, error: formatToolError(cause) };
+        }
+    }
+    /** The host's side of every memory write: the store, or the candidate sink's receipt contract. */
+    memoryWriter() {
+        return new MemoryWriter({ store: this.opts.memoryStore, sink: this.opts.memoryCandidateSink });
+    }
+    /** The audit fact for a sink's answer. Only an accepted candidate is a written record. */
+    memoryCandidateEvent(receipt, source, memory) {
+        const turn = this.activeKernel?.turn() ?? 0;
+        switch (receipt.status) {
+            case "pending":
+                return {
+                    kind: "memory_candidate_pending", turn, candidate_id: receipt.candidate_id, source,
+                    name: memory.name, receipt_id: receipt.receipt_id,
+                };
+            case "rejected":
+                return {
+                    kind: "memory_candidate_rejected", turn, candidate_id: receipt.candidate_id, source,
+                    name: memory.name, receipt_id: receipt.receipt_id, reason_code: receipt.reason_code,
+                };
+            case "accepted":
+                return {
+                    kind: "memory_written", turn, record_id: receipt.record_ref, scope: memory.scope,
+                    memory_kind: memory.kind, name: memory.name, size_bytes: new TextEncoder().encode(memory.content).byteLength,
+                };
+        }
+    }
+    /** Host memory-policy gate: a path is on unless the host set its switch to `"disabled"`. */
+    memoryPathEnabled(path) {
+        return this.memoryRuntimeGates?.[path] ?? true;
+    }
+    /** M2 · whether a write path hands its writes to the candidate sink. Off unless the host set the
+     *  path to `"candidate_sink"` — unlike the on/off gates, the default here is the store. */
+    memoryPathToCandidateSink(path) {
+        return this.memoryRuntimeGates?.[`${path}ToCandidateSink`] ?? false;
+    }
     async admitMemoryWrite(memory) {
         const runtime = this.activeKernel;
         if (runtime && runtime.hasStarted() && !runtime.isTerminal()) {
@@ -624,6 +751,22 @@ export class RuntimeRunner {
                     tokens: Math.max(1, Math.ceil(this.opts.systemPrompt.length / 4)),
                 });
             }
+            for (const [agentId, content] of Object.entries(this.opts.dependencyOutputs ?? {})) {
+                await this.commitKernelApply(runtime, this.pendingObservations, {
+                    kind: "add_dependency_output",
+                    agent_id: agentId,
+                    content,
+                });
+            }
+            for (const entry of this.opts.inheritedKnowledge ?? []) {
+                await this.commitKernelApply(runtime, this.pendingObservations, {
+                    kind: "add_knowledge_message",
+                    content: entry.content,
+                    ...(entry.key ? { key: entry.key } : {}),
+                    tokens: entry.tokens ?? Math.max(1, Math.ceil(entry.content.length / 4)),
+                    ...(entry.pinned ? { pinned: true } : {}),
+                });
+            }
             if (this.opts.initialMemory) {
                 for (const mem of this.opts.initialMemory) {
                     await this.commitKernelApply(runtime, this.pendingObservations, {
@@ -652,7 +795,7 @@ export class RuntimeRunner {
                 });
             }
             if (this.opts.memoryStore && this.opts.agentId) {
-                await this.commitKernelApply(runtime, this.pendingObservations, { kind: "set_memory_enabled", enabled: true });
+                await this.commitKernelApply(runtime, this.pendingObservations, { kind: "set_memory_enabled", enabled: true, read: this.memoryPathEnabled("retrievalEnabled"), write: this.memoryPathEnabled("modelWritesEnabled"), propose_memory: Boolean(this.opts.memoryCandidateSink && this.memoryPathToCandidateSink("modelWrites")), recall: Boolean(this.opts.memoryScope) });
             }
             if (this.opts.knowledgeSource) {
                 await this.commitKernelApply(runtime, this.pendingObservations, { kind: "set_knowledge_enabled", enabled: true });
@@ -748,14 +891,9 @@ export class RuntimeRunner {
         }
         if (!resumeMidRun)
             await this.applyKernelPolicies(runtime);
-        // I4: pre-fetch memory before the first LLM turn (mirrors Node). Strict dynamic context
-        // control: single-use retrieval content, not a stable skill — lands in `history` like an
-        // ordinary `memory` tool result, so it decays with the compression pyramid instead of
-        // pinning itself in `knowledge` forever.
+        // I4: pre-fetch memory before the first LLM turn (mirrors Node). Each hit is an unpinned keyed
+        // `memory:<record_id>` knowledge entry, evicted at a boundary when usage needs the room.
         this.currentGoal = goal;
-        if (!resumeMidRun) {
-            await this.prefetchMemoryIntoHistory(runtime, "initial");
-        }
         let action = resumeMidRun
             ? runtime.resumeAction() ?? (() => { throw new Error("restored canonical operation has no pending effect or terminal"); })()
             : await canonicalStartAgent(runtime, this.pendingObservations, startTask, startRunSpec);
@@ -885,18 +1023,6 @@ export class RuntimeRunner {
                         this.providerRetryPending = action.kind === "call_provider";
                         continue;
                     }
-                    if (!promptMeasurement)
-                        throw new Error("context preparation requires prompt measurement");
-                    const contextAdapter = await createNativeContextPreparationAdapter();
-                    const preparation = contextAdapter.prepare({
-                        effect: action.contextEffect,
-                        request_fingerprint: providerPlan.fingerprint,
-                        provider_route: { ...this.providerRoute, request_fingerprint_scope: preparedRequest.scope },
-                        prompt_measurement: promptMeasurement,
-                    });
-                    await this.opts.sessionLog.append(sessionId, {
-                        kind: "context_prepared", turn: runtime.turn(), effect_id: providerEffectId, preparation,
-                    });
                     const abortSignal = this.abortController?.signal;
                     try {
                         for await (const evt of preparedRequest.stream(abortSignal)) {
@@ -1122,56 +1248,28 @@ export class RuntimeRunner {
                     });
                 }
                 else if (action.kind === "persist_memory") {
-                    // The kernel hands over the validated canonical write, which carries no store identity:
-                    // build the full record here, and let the receipt name exactly what the store now holds.
-                    const canonicalMemory = action.memory;
-                    const acceptedAt = Number(canonicalMemory.accepted_at_ms ?? Date.now());
-                    const record = {
-                        record_id: `memory:${crypto.randomUUID()}`,
-                        scope: this.opts.memoryScope ?? { tenant_id: "default", namespace: this.opts.agentId ?? "default" },
-                        name: String(canonicalMemory.name ?? ""),
-                        kind: String(canonicalMemory.kind ?? "reference"),
-                        content: String(canonicalMemory.content ?? ""),
-                        description: String(canonicalMemory.description ?? ""),
-                        provenance: {
-                            author: "model",
-                            trust: "untrusted",
-                            evidence_refs: Array.isArray(canonicalMemory.evidence_refs) ? canonicalMemory.evidence_refs.map(String) : [],
-                        },
-                        created_at: acceptedAt,
-                        updated_at: acceptedAt,
-                        recall_count: 0,
-                        confidence: 1,
-                        links: [],
-                        pinned: false,
-                    };
-                    let error;
-                    try {
-                        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, record);
-                    }
-                    catch (cause) {
-                        error = formatToolError(cause);
-                    }
-                    action = await this.commitKernelAction(runtime, this.pendingObservations, {
-                        kind: "memory_persist_result",
-                        effect_id: action.effectId,
-                        ...(error ? { error } : {
-                            record_ref: record.record_id,
-                            digest: `sha256:${sha256Hex(record.content)}`,
-                        }),
-                    });
+                    action = await this.commitKernelAction(runtime, this.pendingObservations, await this.persistMemoryEffectResult(runtime.operationId, action.effectId, action.memory));
                 }
                 else if (action.kind === "query_memory") {
                     let hits = [];
                     let error;
                     try {
+                        if (!this.memoryPathEnabled("retrievalEnabled"))
+                            throw new Error("memory retrieval is disabled by memoryRuntimePolicy.retrieval");
                         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,
-                        });
+                        const recordId = typeof action.query.record_id === "string" ? action.query.record_id : undefined;
+                        const causation = action.query.causation;
+                        hits = causation?.kind === "kernel_recall"
+                            ? await this.kernelRecallHits(String(action.query.text ?? ""), action.requestedK, causation.sprint ? "renewal" : "initial")
+                            : recordId === undefined
+                                ? await this.opts.memoryStore.search(this.opts.agentId, {
+                                    ...action.query, top_k: action.requestedK,
+                                })
+                                : memoryFetchRecall(await this.opts.memoryStore.get(this.opts.agentId, recordId), {
+                                    scope: this.opts.memoryScope ?? { tenant_id: "default", namespace: this.opts.agentId },
+                                    kinds: Array.isArray(action.query.kinds) ? action.query.kinds.map(String) : [],
+                                }, Date.now());
                     }
                     catch (cause) {
                         error = formatToolError(cause);
@@ -1183,6 +1281,9 @@ export class RuntimeRunner {
                         hits,
                         ...(error ? { error } : {}),
                     });
+                    if (!error && hits.length > 0 && this.currentSessionId) {
+                        await this.opts.sessionLog.append(this.currentSessionId, { kind: "memory_retrieval_result", hits });
+                    }
                     // 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) {
@@ -1196,7 +1297,7 @@ export class RuntimeRunner {
                 else if (action.kind === "archive_page_out") {
                     const archiveMeta = this.activePageOutArchive
                         ?? this.pendingPageOutArchives.shift()
-                        ?? { archiveStart: this.nextArchiveStart, compressedSeq: await this.opts.sessionLog.latestSeq(sessionId) };
+                        ?? { archiveStart: this.nextArchiveStart, compressedSeq: await this.opts.sessionLog.latestSeq(sessionId), action: action.action, tier: action.tier };
                     this.activePageOutArchive = archiveMeta;
                     let archiveRef;
                     let error;
@@ -1212,9 +1313,6 @@ export class RuntimeRunner {
                     catch (cause) {
                         error = formatToolError(cause);
                     }
-                    const archived = action.archived;
-                    const archiveAction = archiveMeta.action ?? "auto_compact";
-                    const archiveTier = archiveMeta.tier;
                     if (!error)
                         this.activePageOutArchive = undefined;
                     action = await this.commitKernelAction(runtime, this.pendingObservations, {
@@ -1223,9 +1321,6 @@ export class RuntimeRunner {
                         ...(archiveRef ? { archive_ref: archiveRef } : {}),
                         ...(error ? { error } : {}),
                     });
-                    if (!error && archiveTier === "semantic" && archived.length > 0) {
-                        void this.archiveSemanticPageOut(archived, archiveAction);
-                    }
                 }
                 else if (action.kind === "load_payload") {
                     const content = await this.payloadStore().loadPayload(sessionId, action.payloadRef);
@@ -1552,11 +1647,6 @@ export class RuntimeRunner {
                         updatedAtMs: Date.now(),
                     };
                     await this.opts.memoryStore.saveSession(completedSession);
-                    if (this.opts.memoryScope) {
-                        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);
-                    }
                 }
                 catch { /* non-fatal */ }
             }
@@ -1579,24 +1669,21 @@ export class RuntimeRunner {
      * fed back on mismatch. If it still does not conform, the node is failed with the validation
      * reason (an `Error`-terminated result fails the node in-kernel, starving its dependents).
      */
-    async runWorkflowNode(node, parentSessionId, orchestrator, budget, outputs, abortSignal) {
-        // G2: a reduce node runs no LLM — execute the registered pure function over its dependency
-        // outputs and feed the result back as an ordinary completion. Deterministic; no agent burned.
-        if (node.reducer) {
-            return this.runReduceNode(node, outputs ?? new Map());
-        }
+    async runWorkflowNode(node, parentSessionId, orchestrator, budget, abortSignal) {
         const baseSpec = workflowNodeToSpec(node, parentSessionId);
         const manifest = workflowNodeToManifest(node, parentSessionId);
         // G4: surface remaining workflow budget so a coordinator node can size its submission.
         const budgetNote = workflowBudgetNote(budget);
-        // W-N2: a DAG edge carries data — every dependent node sees its dependencies' outputs (the
-        // kernel sends `input_agent_ids` for all dependents; judges/reduce keep their special paths).
-        const depsNote = dependencyOutputsNote(node.input_agent_ids, outputs);
-        const withBudget = (goal) => [goal, depsNote, budgetNote].filter(Boolean).join("\n\n");
+        // A DAG edge carries data: the kernel composes the dependency section of the brief.
+        const withBudget = (goal) => [goal, node.dependency_brief, budgetNote].filter(Boolean).join("\n\n");
         const mkCtx = (goal) => ({
             parentOpts: this.opts,
             parentSessionId,
             spec: { ...baseSpec, goal: withBudget(goal) },
+            ...(node.dependency_outputs
+                ? { dependencyOutputs: node.dependency_outputs }
+                : {}),
+            ...(node.inherited_knowledge?.length ? { inheritedKnowledge: node.inherited_knowledge } : {}),
             manifest,
             sessionLog: this.opts.sessionLog,
             // This child is a workflow node, so capability resolution applies workflow-node quarantine
@@ -1609,39 +1696,6 @@ export class RuntimeRunner {
             // #2-B-ii: the per-node abort signal the driver fires when the kernel preempts this node.
             ...(abortSignal ? { abortSignal } : {}),
         });
-        const textOf = (r) => {
-            const c = r.result.finalMessage?.content;
-            return typeof c === "string" ? c : c != null ? JSON.stringify(c) : "";
-        };
-        const withSignal = (r, patch) => ({ ...r, result: { ...r.result, ...patch } });
-        // A#2 tournament judge: compare two entrants' produced outputs rather than running the node's own
-        // goal. Look up both candidates, judge over the controller's criterion, and report the winner's id.
-        if (node.judge_match) {
-            const out = outputs ?? new Map();
-            const left = out.get(node.judge_match.left) ?? "";
-            const right = out.get(node.judge_match.right) ?? "";
-            const result = await orchestrator.run(mkCtx(judgeGoal(baseSpec.goal, left, right)));
-            const winner = extractJudgeWinner(textOf(result));
-            const winnerId = winner === "right" ? node.judge_match.right : node.judge_match.left;
-            return withSignal(result, { tournamentWinner: winnerId });
-        }
-        // 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).
-        // 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;
-            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) {
-            const labels = node.classify_labels;
-            const result = await orchestrator.run(mkCtx(`${baseSpec.goal}\n\n${classifyInstruction(labels)}`));
-            const branch = extractClassifyBranch(textOf(result), labels);
-            return branch === undefined ? result : withSignal(result, { classifyBranch: branch });
-        }
         const schema = node.output_schema;
         if (!schema)
             return orchestrator.run(mkCtx(baseSpec.goal));
@@ -1672,27 +1726,6 @@ export class RuntimeRunner {
             },
         };
     }
-    /**
-     * G2: execute a deterministic reduce node — run the named reducer (built-ins overlaid with
-     * `opts.reducers`) over its dependency outputs and return a synthetic completion. No LLM, zero
-     * tokens. An unknown reducer or a thrown reducer fails the node (`Error` → starves dependents).
-     */
-    runReduceNode(node, outputs) {
-        const ok = (content, termination) => ({
-            agentId: node.agent_id,
-            result: { termination, finalMessage: { role: "assistant", content, toolCalls: [] }, turnsUsed: 0, totalTokensUsed: 0 },
-        });
-        const reducer = resolveReducer(node.reducer, this.opts.reducers);
-        if (!reducer)
-            return ok(`unknown reducer "${node.reducer}"`, "error");
-        const inputs = (node.input_agent_ids ?? []).map(agentId => ({ agentId, output: outputs.get(agentId) ?? "" }));
-        try {
-            return ok(reducer(inputs), "completed");
-        }
-        catch (err) {
-            return ok(`reducer "${node.reducer}" threw: ${formatToolError(err)}`, "error");
-        }
-    }
     /**
      * W0-ABI: run a declarative workflow DAG. The kernel owns the DAG and gates every node spawn
      * through the syscall trap; this driver runs each kernel-emitted batch of nodes in parallel,
@@ -1715,6 +1748,10 @@ export class RuntimeRunner {
         if (this.opts.contextPolicy) {
             config.context_policy = normalizeContextPolicy(contextPolicy(this.opts.contextPolicy));
         }
+        const delegated = delegatedContextTiers(this.opts.provider?.descriptor?.().nativeContext);
+        if (delegated) {
+            config.context_policy = { ...config.context_policy, delegated_tiers: delegated };
+        }
         config.signal_policy = {
             queue_max: signalPolicy.queueMax,
             ...(signalPolicy.ttlMs !== undefined ? { ttl_ms: signalPolicy.ttlMs } : {}),
@@ -1971,7 +2008,7 @@ export class RuntimeRunner {
             }
             const controller = new AbortController();
             controllers.set(node.agent_id, controller);
-            const running = this.runWorkflowNode(node, parentSessionId, orchestrator, budget, outputs, controller.signal)
+            const running = this.runWorkflowNode(node, parentSessionId, orchestrator, budget, controller.signal)
                 .then(result => ({ kind: "node", node, result }))
                 .finally(() => batchState.finished.add(node.agent_id));
             // A node can fail while the driver is busy feeding another completion; the race observes
@@ -2004,15 +2041,10 @@ export class RuntimeRunner {
                     if (batchState.stopping)
                         return { spawned: [], done: undefined };
                     const { node, result } = landed;
-                    // G2: record this node's output so a downstream reduce node can consume it.
+                    // Record this node's output so its dependents can consume it.
                     const outContent = result.result.finalMessage?.content;
                     const outText = typeof outContent === "string" ? outContent : outContent != null ? JSON.stringify(outContent) : "";
                     outputs.set(result.agentId, outText);
-                    // A loop iteration completes under `wf-node{N}-i{k}` but its dependents consume the STABLE
-                    // node id `wf-node{N}` — alias it so the LAST iteration's output is what dependents see.
-                    const stableId = result.agentId.replace(/-i\d+$/, "");
-                    if (stableId !== result.agentId)
-                        outputs.set(stableId, outText);
                     const observationStart = this.pendingObservations.length;
                     const completionAction = await this.commitKernelMaybeAction(runtime, this.pendingObservations, {
                         kind: "sub_agent_completed",
@@ -2049,17 +2081,13 @@ export class RuntimeRunner {
                             }));
                         }
                     }
-                    // Persist node completion for resume recovery. W-1: the result-borne control signals ride
-                    // along (a resumed classifier re-prunes; a recorded loop stop is honored) plus the output
-                    // text (post-resume dependents/reduce still see this node's output).
+                    // Persist node completion for resume recovery, with the output text so post-resume
+                    // dependents still see this node's output.
                     await this.opts.sessionLog.append(parentSessionId, buildWorkflowNodeCompletedEvent({
                         turn: runtime.turn(),
                         agentId: result.agentId,
                         status: workflowNodeStatusFromTermination(result.result.termination),
                         termination: result.result.termination,
-                        classifyBranch: result.result.classifyBranch,
-                        tournamentWinner: result.result.tournamentWinner,
-                        loopContinue: result.result.loopContinue,
                         ...(result.result.finalMessage ? { output: result.result.finalMessage } : {}),
                     }));
                     return { spawned, done: findDone(obs) };
@@ -2112,94 +2140,32 @@ export class RuntimeRunner {
                 }
                 nextArchiveStart = compressedSeq + 1;
             }
-            // K4: a sprint renewal dropped the old history — including any earlier memory hits — so
-            // re-run the preQueryMemory prefetch for the new sprint (live observations only).
-            if (obs.kind === "renewed") {
-                await this.prefetchMemoryIntoHistory(runtime, "renewal");
-            }
         }
         return nextArchiveStart;
     }
-    /** I4 + K4: fetch long-term memory hits for the current goal and land them in `history` as an
-     *  ordinary user turn — single-use retrieval content that decays with the compression pyramid,
-     *  never pinned into `knowledge`. `phase: "initial"` = once before turn 1; `phase: "renewal"` =
-     *  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.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.
-        const preQuery = this.opts.preQueryMemory
-            ?? ((ctx) => [{ scope: this.opts.memoryScope, query: ctx.goal, top_k: 5, kinds: [] }]);
-        try {
-            const queries = await preQuery({ goal: this.currentGoal, phase });
-            const lines = [];
-            const seen = new Set();
-            const recalled = [];
-            for (const q of queries ?? []) {
-                if (!q.query.trim())
+    /** The kernel's own recall for the run goal (plan task 2.1). `preQueryMemory` may rewrite it
+     *  into several scoped queries; their hits are merged, one per record. */
+    async kernelRecallHits(goal, requestedK, phase) {
+        const scope = this.opts.memoryScope;
+        const queries = this.opts.preQueryMemory
+            ? await this.opts.preQueryMemory({ goal, phase }) ?? []
+            : [{ scope, query: goal, top_k: requestedK, kinds: [] }];
+        const seen = new Set();
+        const hits = [];
+        for (const query of queries) {
+            if (!query.query.trim())
+                continue;
+            const limit = Math.min(query.top_k ?? requestedK, requestedK);
+            for (const hit of (await this.opts.memoryStore.search(this.opts.agentId, { ...query, top_k: limit })).slice(0, limit)) {
+                if (seen.has(hit.record.record_id))
                     continue;
-                const hits = await this.opts.memoryStore.search(this.opts.agentId, q);
-                for (const hit of hits) {
-                    if (seen.has(hit.record.record_id))
-                        continue;
-                    seen.add(hit.record.record_id);
-                    recalled.push(hit);
-                    lines.push(`[memory record_id=${hit.record.record_id} trust=${hit.record.provenance.trust} score=${hit.score.toFixed(3)}] ${hit.record.content}`);
-                }
-            }
-            if (lines.length > 0) {
-                await this.commitKernelApply(runtime, this.pendingObservations, {
-                    kind: "add_history_message",
-                    message: { role: "user", content: lines.join("\n") },
-                });
+                seen.add(hit.record.record_id);
+                hits.push(hit);
             }
-            await this.recordHostMemoryRecall(recalled);
-        }
-        catch { /* errs-open */ }
-    }
-    async archiveSemanticPageOut(archived, action) {
-        if (!this.opts.memoryStore || !this.opts.agentId || !this.opts.memoryScope)
-            return;
-        try {
-            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({
-                record_id: `${this.opts.memoryScope.tenant_id}:${this.opts.memoryScope.namespace}:project:${name}`,
-                scope: this.opts.memoryScope, name, kind: "project", content: summary,
-                description: `auto summary of ${action ?? "compaction"} archive`,
-                provenance: { author: "extraction", trust: "untrusted", evidence_refs: [] },
-                created_at: now, updated_at: now, recall_count: 0, confidence: 0.6, links: [], pinned: false,
-            }, this.currentSessionId ?? undefined);
-        }
-        catch {
-            // non-fatal
         }
+        return hits;
     }
 }
-async function summarizeForLongTermMemory(provider, archived, systemPrompt) {
-    const transcript = archived
-        .map(m => `${m.role}: ${m.content}`)
-        .join("\n");
-    const context = {
-        systemText: [
-            systemPrompt,
-            "Summarize the following conversation for long-term memory. Preserve key facts, decisions, and open questions.",
-        ].filter(Boolean).join("\n\n"),
-        turns: [{ role: "user", content: transcript, toolCalls: [] }],
-    };
-    let text = "";
-    const state = provider.createRunState?.();
-    for await (const evt of provider.stream(context, [], undefined, state)) {
-        if (evt.type === "text_delta")
-            text += evt.delta;
-    }
-    return text.trim() || transcript.slice(0, 2000);
-}
 function isMidRun(events) {
     return events.length > 0 && !events.some(e => e.event.kind === "run_terminal");
 }