@deepstrike/wasm 0.2.36 → 0.2.38

package/dist/runtime/runner.js

@@ -10,7 +10,7 @@ import { agentRunSpecToKernel, findSpawnProcessObservation, milestoneCheckPass,
 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, extractLoopContinue, extractClassifyBranch, extractJudgeWinner, } from "./workflow-control-flow.js";
+import { loopInstruction, classifyInstruction, judgeGoal, dependencyOutputsNote, extractLoopContinue, extractClassifyBranch, extractJudgeWinner, } from "./workflow-control-flow.js";
 import { kernelObservationToSessionEvent } from "./kernel-event-log.js";
 import { assertNativeProfile } from "./os-profile.js";
 import { LargeResultSpool } from "./large-result-spool.js";
@@ -28,6 +28,8 @@ export class RuntimeRunner {
      *  run — guards against re-pushing a duplicate entry if the model calls `skill(name)` again for
      *  an already-active skill (loading is idempotent; the knowledge push should be too). */
     knowledgePushedSkills = new Set();
+    /** Most recent kernel entropy sample of the active/last run (see `latestEntropy`). */
+    lastEntropySample = null;
     /** K4: the active run's goal, kept for the renewal-boundary memory re-query. */
     currentGoal = "";
     nextArchiveStart = 0;
@@ -48,6 +50,11 @@ export class RuntimeRunner {
     injectNote(text, urgency = "normal") {
         this.injectedSignals.push({ source: "custom", signalType: "event", urgency, payload: { goal: text } });
     }
+    /** The most recent kernel session-entropy sample (one per completed turn), or `null` before the
+     *  first boundary. A pull companion to the streamed `entropy_sample` events. */
+    latestEntropy() {
+        return this.lastEntropySample;
+    }
     /** Injected-note drain shared with the main loop's per-turn poll: injected notes first (FIFO), then
      *  the configured `signalSource` — one code path so the two inbound channels never drift. */
     async nextInboundSignal() {
@@ -859,10 +866,35 @@ export class RuntimeRunner {
                         }
                         catch { /* skip */ }
                     }
+                    const entropyObsStart = this.pendingObservations.length;
                     action = kernelAction(runtime, this.pendingObservations, {
                         kind: "tool_results",
                         results: toolResults.map(toolResultToKernel),
                     });
+                    // Surface the boundary's entropy measurement live (the heartbeat watch source).
+                    for (const obs of this.pendingObservations.slice(entropyObsStart)) {
+                        if (obs.kind === "entropy_sample") {
+                            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,
+                                rollbacksInWindow: obs.rollbacks_in_window ?? 0,
+                                windowTurns: obs.window_turns ?? 0,
+                            };
+                            yield { type: "entropy_sample", sample: this.lastEntropySample };
+                        }
+                        else if (obs.kind === "entropy_alert") {
+                            yield {
+                                type: "entropy_alert",
+                                turn: obs.turn ?? 0,
+                                score: obs.score ?? 0,
+                                threshold: obs.threshold ?? 0,
+                            };
+                        }
+                    }
                 }
                 else if (action.kind === "evaluate_milestone") {
                     const milestonePolicy = this.opts.milestonePolicy ?? "require_verifier";
@@ -959,7 +991,14 @@ export class RuntimeRunner {
                 catch { /* non-fatal */ }
             }
         }
-        yield { type: "done", iterations: turnsUsed, totalTokens, status };
+        yield {
+            type: "done",
+            iterations: turnsUsed,
+            totalTokens,
+            status,
+            // ③ loop-agent: surface the kernel-adjudicated after-round decision to the driver.
+            ...(result?.paceDecision ? { paceDecision: result.paceDecision } : {}),
+        };
         this.activeKernel = null;
         this.currentSessionId = null;
     }
@@ -1009,7 +1048,10 @@ export class RuntimeRunner {
         const manifest = workflowNodeToManifest(node, parentSessionId);
         // G4: surface remaining workflow budget so a coordinator node can size its submission.
         const budgetNote = workflowBudgetNote(budget);
-        const withBudget = (goal) => (budgetNote ? `${goal}\n\n${budgetNote}` : goal);
+        // 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");
         const mkCtx = (goal) => ({
             parentOpts: this.opts,
             parentSessionId,
@@ -1018,6 +1060,10 @@ export class RuntimeRunner {
             sessionLog: this.opts.sessionLog,
             // M5 v2.1: this child IS a workflow node — its `start_workflow` flattens to this kernel.
             isWorkflowNode: true,
+            // W-N1: trusted workflow nodes run on the parent's execution plane (they carry no grant list
+            // by design — filtering on the missing list ran every DAG node TOOL-LESS); quarantined nodes
+            // stay deny-all filtered (they read untrusted content).
+            toolAccess: (node.trust === "quarantined" ? "filtered" : "inherit"),
             // #2-B-ii: the per-node abort signal the driver fires when the kernel preempts this node.
             ...(abortSignal ? { abortSignal } : {}),
         });
@@ -1037,9 +1083,18 @@ 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, then extract a stop signal. No signal ⇒ run to cap.
+        // A#2 v2 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).
         if (node.loop_max_iters != null) {
-            const result = await orchestrator.run(mkCtx(`${baseSpec.goal}\n\n${loopInstruction(node.loop_max_iters)}`));
+            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 });
         }
@@ -1151,6 +1206,17 @@ export class RuntimeRunner {
         if (this.opts.knowledgeBudgetRatio !== undefined) {
             config.knowledge_budget_ratio = this.opts.knowledgeBudgetRatio;
         }
+        // Entropy watch (opt-in): threshold alerting over the per-turn session-entropy score.
+        if (this.opts.entropyWatch !== undefined) {
+            const ew = this.opts.entropyWatch;
+            config.entropy_watch = {
+                enabled: ew.enabled ?? true,
+                ...(ew.threshold !== undefined ? { threshold: ew.threshold } : {}),
+                ...(ew.hysteresis !== undefined ? { hysteresis: ew.hysteresis } : {}),
+                ...(ew.cooldownTurns !== undefined ? { cooldown_turns: ew.cooldownTurns } : {}),
+                ...(ew.notifyModel !== undefined ? { notify_model: ew.notifyModel } : {}),
+            };
+        }
         kernelApply(runtime, this.pendingObservations, { kind: "configure_run", config });
         if (this.opts.memoryPolicy) {
             const m = this.opts.memoryPolicy;
@@ -1215,10 +1281,22 @@ export class RuntimeRunner {
                 parent_session_id: parentSessionId,
                 // W0-ABI resume: skip nodes already completed before an interruption.
                 ...(opts?.resumedCompleted && opts.resumedCompleted.length ? { resumed_completed: opts.resumedCompleted } : {}),
+                // W-1: signal-carrying completion records (classify branch / loop stop replay).
+                ...(opts?.resumedResults?.length
+                    ? {
+                        resumed_results: opts.resumedResults.map(r => ({
+                            agent_id: r.agentId,
+                            ...(r.classifyBranch !== undefined ? { classify_branch: r.classifyBranch } : {}),
+                            ...(r.tournamentWinner !== undefined ? { tournament_winner: r.tournamentWinner } : {}),
+                            ...(r.loopContinue !== undefined ? { loop_continue: r.loopContinue } : {}),
+                        })),
+                    }
+                    : {}),
                 // R3-1: re-apply recorded runtime submissions so dynamically-appended nodes are reconstructed.
                 ...(opts?.resumedSubmissions && opts.resumedSubmissions.length ? { resumed_submissions: opts.resumedSubmissions } : {}),
+                ...(opts?.resumedSubmissionBases && opts.resumedSubmissionBases.length ? { resumed_submission_bases: opts.resumedSubmissionBases } : {}),
             });
-            return await this.driveWorkflow(observations, parentSessionId, runtime);
+            return await this.driveWorkflow(observations, parentSessionId, runtime, opts?.resumedOutputs);
         }
         finally {
             if (bootstrapped) {
@@ -1241,6 +1319,18 @@ export class RuntimeRunner {
         const parentSessionId = this.currentSessionId;
         const runtime = this.activeKernel;
         const observations = kernelApply(runtime, this.pendingObservations, submitWorkflowToKernel(spec, parentSessionId, opts?.submitterAgentId));
+        // W-3: persist the agent-authored batch (bootstrap base 0 / flatten base N — the kernel now
+        // announces BOTH) so an interrupted authored workflow reconstructs on resume; the host never
+        // had this spec, unlike the `runWorkflow` path.
+        const submitted = observations.find(o => o.kind === "workflow_nodes_submitted");
+        if (submitted) {
+            await this.opts.sessionLog.append(parentSessionId, buildWorkflowNodesSubmittedEvent({
+                turn: runtime.turn(),
+                nodes: workflowSpecToKernel(spec).nodes ?? [],
+                baseIndex: submitted.base,
+                submitterAgentId: opts?.submitterAgentId,
+            }));
+        }
         return this.driveWorkflow(observations, parentSessionId, runtime);
     }
     /**
@@ -1297,7 +1387,7 @@ export class RuntimeRunner {
      * `submit_workflow`): run each kernel-emitted batch in parallel, feed completions back (appending any
      * agent-submitted nodes first), and loop until the kernel reports the workflow complete.
      */
-    async driveWorkflow(initial, parentSessionId, runtime) {
+    async driveWorkflow(initial, parentSessionId, runtime, seedOutputs) {
         const observations = initial;
         const orchestrator = this.opts.subAgentOrchestrator ?? defaultSubAgentOrchestrator;
         const collectNodes = (obs) => obs.find(o => o.kind === "workflow_batch_spawned")?.nodes ?? [];
@@ -1310,7 +1400,9 @@ export class RuntimeRunner {
         let nodes = collectNodes(observations);
         let budget = collectBudget(observations);
         // G2: each completed node's output, keyed by agent id — a reduce node reads its deps' outputs.
-        const outputs = new Map();
+        // W-1: on resume it is pre-seeded from the persisted node outputs, so post-resume dependents
+        // still see their (pre-crash) dependencies' outputs.
+        const outputs = new Map(seedOutputs ?? []);
         for (;;) {
             if (nodes.length === 0)
                 return { completed: [], failed: [], outputs: Object.fromEntries(outputs) };
@@ -1330,7 +1422,13 @@ export class RuntimeRunner {
             for (const result of results) {
                 // G2: record this node's output so a downstream reduce node can consume it.
                 const outContent = result.result.finalMessage?.content;
-                outputs.set(result.agentId, typeof outContent === "string" ? outContent : outContent != null ? JSON.stringify(outContent) : "");
+                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);
                 // R3-1: if this node's agent submitted more nodes, append them to the parent DAG BEFORE
                 // reporting the node's completion — the workflow is still active, so even a last-node
                 // submission keeps the DAG alive.
@@ -1341,10 +1439,15 @@ export class RuntimeRunner {
                     const subObs = kernelApply(runtime, this.pendingObservations, submitEvent);
                     nextNodes.push(...collectNodes(subObs));
                     budget = collectBudget(subObs) ?? budget;
-                    // R3-1: persist the submission (kernel-shape nodes) so resume can re-apply it.
+                    // R3-1: persist the submission (kernel-shape nodes) + its kernel-reported base index
+                    // so resume can re-apply the batch at the exact original graph position. W-N3: also the
+                    // submitter, so resume drops batches whose submitter re-runs (it will re-submit).
+                    const submitted = subObs.find(o => o.kind === "workflow_nodes_submitted");
                     await this.opts.sessionLog.append(parentSessionId, buildWorkflowNodesSubmittedEvent({
                         turn: runtime.turn(),
                         nodes: submitEvent.nodes ?? [],
+                        baseIndex: submitted?.base,
+                        submitterAgentId: result.agentId,
                     }));
                 }
                 const obs = kernelApply(runtime, this.pendingObservations, {
@@ -1356,11 +1459,17 @@ export class RuntimeRunner {
                 const d = findDone(obs);
                 if (d)
                     done = d;
-                // Persist node completion for resume recovery.
+                // 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).
                 await this.opts.sessionLog.append(parentSessionId, buildWorkflowNodeCompletedEvent({
                     turn: runtime.turn(),
                     agentId: result.agentId,
                     termination: result.result.termination,
+                    classifyBranch: result.result.classifyBranch,
+                    tournamentWinner: result.result.tournamentWinner,
+                    loopContinue: result.result.loopContinue,
+                    ...(result.result.termination === "completed" && outText ? { output: outText } : {}),
                 }));
             }
             if (done && nextNodes.length === 0) {
@@ -1371,8 +1480,9 @@ export class RuntimeRunner {
     }
     /**
      * Resume a workflow from the parent session's completed nodes.
-     * Reads the session log, extracts completed workflow node agent_ids, and
-     * calls runWorkflow with resumedCompleted so the kernel skips those nodes.
+     * Reads the session log, extracts completed workflow node records (with their W-1 control
+     * signals + outputs), and calls runWorkflow so the kernel skips those nodes, replays control
+     * flow (classify prune / loop stop), and the driver re-seeds its outputs map.
      */
     async resumeWorkflow(spec, opts) {
         // Standalone resume: a stateless handler passes the prior `sessionId`; mid-run callers omit it.
@@ -1381,9 +1491,34 @@ export class RuntimeRunner {
             throw new Error("resumeWorkflow requires an active parent run or an explicit sessionId");
         }
         const events = await this.opts.sessionLog.read(sessionId);
-        const resumedCompleted = recoverCompletedWorkflowNodes(events);
-        const resumedSubmissions = recoverSubmittedWorkflowNodes(events);
-        return this.runWorkflow(spec, { resumedCompleted, resumedSubmissions, sessionId });
+        const resumedResults = recoverCompletedWorkflowNodes(events);
+        const completedIds = new Set(resumedResults.map(r => r.agentId));
+        const recovered = recoverSubmittedWorkflowNodes(events);
+        // W-N3: DROP batches whose submitter did NOT complete — that node re-runs on resume and will
+        // re-submit its batch; replaying the logged copy too would duplicate its nodes in the DAG.
+        // Only safe with exact bases (the dropped batch's slots become inert placeholders); a legacy
+        // order-only log keeps every batch, since dropping would shift all later indices.
+        let { submissions, bases } = recovered;
+        if (bases.length === submissions.length && submissions.length > 0) {
+            const keep = recovered.submitters.map(s => s === undefined || completedIds.has(s));
+            submissions = submissions.filter((_, i) => keep[i]);
+            bases = bases.filter((_, i) => keep[i]);
+        }
+        const resumedOutputs = new Map(resumedResults.filter(r => r.output).map(r => [r.agentId, r.output]));
+        // Alias loop iterations onto their stable node id (last iteration wins) — dependents consume
+        // `wf-node{N}`, not `wf-node{N}-i{k}`.
+        for (const r of resumedResults) {
+            const stableId = r.agentId.replace(/-i\d+$/, "");
+            if (stableId !== r.agentId && r.output)
+                resumedOutputs.set(stableId, r.output);
+        }
+        return this.runWorkflow(spec, {
+            resumedResults,
+            resumedSubmissions: submissions,
+            resumedSubmissionBases: bases,
+            resumedOutputs,
+            sessionId,
+        });
     }
     async appendObservations(sessionId, runtime, nextArchiveStart) {
         const turn = runtime.turn();
@@ -1422,12 +1557,23 @@ export class RuntimeRunner {
             const compressedSeq = await this.opts.sessionLog.append(sessionId, event);
             if (event.kind === "compressed") {
                 nextArchiveStart = compressedSeq + 1;
-            }
-            if (obs.kind === "page_out"
-                && obs.tier_hint === "semantic"
-                && Array.isArray(obs.archived)
-                && obs.archived.length > 0) {
-                void this.archiveSemanticPageOut(obs.archived, compressionAction(obs.action));
+                // One compaction = one kernel observation: the page_out session record (and the
+                // semantic-archive branch) is DERIVED from Compressed.tier_hint, preserving the
+                // session-log format and OsSnapshot page_out_count.
+                const archived = obs.archived;
+                if (obs.tier_hint && Array.isArray(archived) && archived.length > 0) {
+                    await this.opts.sessionLog.append(sessionId, {
+                        kind: "page_out",
+                        turn: obs.turn ?? turn,
+                        action: compressionAction(obs.action),
+                        summary: obs.summary,
+                        tier_hint: obs.tier_hint ?? "durable",
+                        message_count: archived.length,
+                    });
+                    if (obs.tier_hint === "semantic") {
+                        void this.archiveSemanticPageOut(archived, compressionAction(obs.action));
+                    }
+                }
             }
             // 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).
@@ -1443,10 +1589,14 @@ 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.preQueryMemory || !this.opts.dreamStore || !this.opts.agentId)
+        if (!this.opts.dreamStore || !this.opts.agentId)
             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) => [ctx.goal]);
         try {
-            const queries = await this.opts.preQueryMemory({ goal: this.currentGoal, phase });
+            const queries = await preQuery({ goal: this.currentGoal, phase });
             const lines = [];
             for (const q of queries ?? []) {
                 if (typeof q !== "string" || !q.trim())
@@ -1473,8 +1623,12 @@ export class RuntimeRunner {
                 ? await this.opts.dreamSummarizer.summarize(archived, { action })
                 : await summarizeForLongTermMemory(this.opts.dreamProvider ?? this.opts.provider, archived, this.opts.dreamSystemPrompt);
             const existing = await this.opts.dreamStore.loadMemories(this.opts.agentId);
+            // P2 write-funnel (wasm surface has no kernel write gate yet): jaccard dedup +
+            // advisory 0.6 score — an automatic summary must never outrank curated content.
+            if (existing.some(e => jaccardSimilarity(e.text, summary) >= 0.9))
+                return;
             await this.opts.dreamStore.commit(this.opts.agentId, {
-                toAdd: [{ text: summary, score: 1.0, metadata: { source: "semantic_page_out", action } }],
+                toAdd: [{ text: summary, score: 0.6, metadata: { source: "semantic_page_out", action } }],
                 toRemoveIndices: [],
                 stats: {
                     insightsProcessed: 1,
@@ -1489,6 +1643,19 @@ export class RuntimeRunner {
         }
     }
 }
+/** Word-set jaccard similarity — the curator's dedup rule at the write funnel. */
+function jaccardSimilarity(a, b) {
+    const sa = new Set(a.split(/\s+/).filter(Boolean));
+    const sb = new Set(b.split(/\s+/).filter(Boolean));
+    if (sa.size === 0 && sb.size === 0)
+        return 1;
+    let inter = 0;
+    for (const w of sa)
+        if (sb.has(w))
+            inter++;
+    const union = sa.size + sb.size - inter;
+    return union === 0 ? 0 : inter / union;
+}
 async function summarizeForLongTermMemory(provider, archived, systemPrompt) {
     const transcript = archived
         .map(m => `${m.role}: ${m.content}`)

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

@@ -1,5 +1,5 @@
 import type { ProviderReplay, ToolCall, ToolErrorKind } from "../types.js";
-import type { KernelEventCategory, KernelPrimitive } from "./kernel-event-log.js";
+import type { KernelPrimitive } from "./kernel-event-log.js";
 export type RollbackReason = {
     kind: "fatal_tool_error";
     tool_name: string;
@@ -74,8 +74,6 @@ export type SessionEvent = {
 } | {
     kind: "compressed";
     turn: number;
-    category?: KernelEventCategory;
-    primitive?: KernelPrimitive;
     archived_seq_range: [number, number];
     action?: "snip_compact" | "micro_compact" | "context_collapse" | "auto_compact";
     summary?: string;
@@ -85,8 +83,6 @@ export type SessionEvent = {
 } | {
     kind: "page_out";
     turn: number;
-    category?: KernelEventCategory;
-    primitive?: KernelPrimitive;
     action?: "snip_compact" | "micro_compact" | "context_collapse" | "auto_compact";
     summary?: string;
     tier_hint?: string;
@@ -94,14 +90,10 @@ export type SessionEvent = {
 } | {
     kind: "page_in";
     turn: number;
-    category?: KernelEventCategory;
-    primitive?: KernelPrimitive;
     entry_count: number;
 } | {
     kind: "large_result_spooled";
     turn: number;
-    category?: KernelEventCategory;
-    primitive?: KernelPrimitive;
     call_id: string;
     tool: string;
     original_size: number;
@@ -110,15 +102,11 @@ export type SessionEvent = {
 } | {
     kind: "rollbacked";
     turn: number;
-    category?: KernelEventCategory;
-    primitive?: KernelPrimitive;
     checkpoint_history_len: number;
     reason?: RollbackReason;
 } | {
     kind: "capability_changed";
     turn: number;
-    category?: KernelEventCategory;
-    primitive?: KernelPrimitive;
     added: string[];
     removed: string[];
     change_kind?: string;
@@ -129,78 +117,66 @@ export type SessionEvent = {
 } | {
     kind: "context_renewed";
     turn: number;
-    category?: KernelEventCategory;
-    primitive?: KernelPrimitive;
     sprint: number;
     handoff_ref: string;
 } | {
     kind: "suspended";
     turn: number;
-    category?: KernelEventCategory;
-    primitive?: KernelPrimitive;
     reason: string;
     pending_calls?: string[];
 } | {
     kind: "resumed";
     turn: number;
-    category?: KernelEventCategory;
-    primitive?: KernelPrimitive;
     approved?: string[];
     denied?: string[];
 } | {
     kind: "tool_gated";
     turn: number;
-    category?: KernelEventCategory;
-    primitive?: KernelPrimitive;
     call_id: string;
     tool: string;
     reason: string;
 } | {
     kind: "signal_disposed";
     turn: number;
-    category?: KernelEventCategory;
-    primitive?: KernelPrimitive;
     signal_id: string;
     disposition: string;
     queue_depth: number;
 } | {
     kind: "budget_exceeded";
     turn: number;
-    category?: KernelEventCategory;
-    primitive?: KernelPrimitive;
     budget: string;
 } | {
     kind: "milestone_advanced";
     turn: number;
-    category?: KernelEventCategory;
-    primitive?: KernelPrimitive;
     phase_id: string;
     capabilities_unlocked: string[];
 } | {
     kind: "milestone_blocked";
     turn: number;
-    category?: KernelEventCategory;
-    primitive?: KernelPrimitive;
     phase_id: string;
     reason: string;
-} | {
-    kind: "milestone_evidence";
-    turn: number;
-    category?: KernelEventCategory;
-    primitive?: KernelPrimitive;
-    phase_id: string;
-    evidence: string[];
 } | {
     kind: "checkpoint_taken";
     turn: number;
-    category?: KernelEventCategory;
-    primitive?: KernelPrimitive;
     history_len: number;
+} | {
+    kind: "entropy_sample";
+    turn: number;
+    score: number;
+    score_version: number;
+    rho: number;
+    repeat_pressure: number;
+    failure_rate: number;
+    rollbacks_in_window: number;
+    window_turns: number;
+} | {
+    kind: "entropy_alert";
+    turn: number;
+    score: number;
+    threshold: number;
 } | {
     kind: "agent_process_changed";
     turn: number;
-    category?: KernelEventCategory;
-    primitive?: KernelPrimitive;
     agent_id: string;
     parent_session_id: string;
     role: string;
@@ -212,52 +188,52 @@ export type SessionEvent = {
 } | {
     kind: "memory_written";
     turn: number;
-    category?: KernelEventCategory;
-    primitive?: KernelPrimitive;
     memory_id: string;
     memory_kind: string;
     size_bytes: number;
 } | {
     kind: "memory_queried";
     turn: number;
-    category?: KernelEventCategory;
-    primitive?: KernelPrimitive;
     query_context: string;
     requested_k: number;
     requires_async_response: boolean;
 } | {
     kind: "memory_validation_failed";
     turn: number;
-    category?: KernelEventCategory;
-    primitive?: KernelPrimitive;
     memory_id: string;
     error: string;
 } | {
     kind: "workflow_node_completed";
     turn: number;
-    category?: KernelEventCategory;
-    primitive?: KernelPrimitive;
     agent_id: string;
     termination: string;
+    /** W-1: result-borne control signals, persisted so resume replays control flow faithfully —
+     *  a classifier re-prunes its rejected branches, a recorded loop stop is honored. */
+    classify_branch?: string;
+    tournament_winner?: string;
+    loop_continue?: boolean;
+    /** W-1: the node's final output text — resume re-seeds the driver's outputs map from it so
+     *  post-resume reduce/judge/dependent nodes still see their dependencies' outputs. */
+    output?: string;
 } | {
     kind: "workflow_nodes_submitted";
     turn: number;
-    category?: KernelEventCategory;
-    primitive?: KernelPrimitive;
     /** Kernel-shape (snake_case) submitted node specs — persisted so resume can re-apply them. */
     nodes: Record<string, unknown>[];
+    /** R3-1: graph base index the batch was appended at (from the kernel's
+     *  WorkflowNodesSubmitted observation) — lets resume rebuild exact indices. */
+    base_index?: number;
+    /** W-N3: the submitting node's agent id (absent = host/bootstrap). Resume DROPS batches whose
+     *  submitter re-runs — it will re-submit — instead of duplicating their nodes. */
+    submitter_agent_id?: string;
 } | {
     kind: "workflow_batch_spawned";
     turn: number;
-    category?: KernelEventCategory;
-    primitive?: KernelPrimitive;
     node_count: number;
     node_ids: string[];
 } | {
     kind: "workflow_completed";
     turn: number;
-    category?: KernelEventCategory;
-    primitive?: KernelPrimitive;
     completed: string[];
     failed: string[];
     total_nodes: number;

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

@@ -36,33 +36,56 @@ export declare function buildRunTerminalEvent(input: {
 }): Extract<SessionEvent, {
     kind: "run_terminal";
 }>;
+/** Build workflow_node_completed for persistence after a node finishes. W-1: carries the
+ *  result-borne control signals + output so resume replays control flow and re-seeds outputs. */
 export declare function buildWorkflowNodeCompletedEvent(input: {
     turn: number;
     agentId: string;
     termination: string;
+    classifyBranch?: string;
+    tournamentWinner?: string;
+    loopContinue?: boolean;
+    output?: string;
 }): Extract<SessionEvent, {
     kind: "workflow_node_completed";
 }>;
+/** One recovered node completion: the agent id plus its persisted control signals and output. */
+export interface RecoveredNodeCompletion {
+    agentId: string;
+    classifyBranch?: string;
+    tournamentWinner?: string;
+    loopContinue?: boolean;
+    output?: string;
+}
 /**
- * Recover completed workflow node agent_ids from a session event stream.
- * Scans for workflow_node_completed events and returns the agent_ids whose
- * termination was "completed". Used to rebuild resumedCompleted for resumeWorkflow.
+ * Recover completed workflow node records from a session event stream. Scans for
+ * workflow_node_completed events with termination "completed" and returns them WITH their
+ * result-borne control signals (W-1) — resumeWorkflow lowers these to the kernel's
+ * `resumed_results` so a classifier re-prunes and a loop stop is honored, and re-seeds the
+ * driver's outputs map from the persisted output text.
  */
 export declare function recoverCompletedWorkflowNodes(events: Array<{
     seq: number;
     event: SessionEvent;
-}>): string[];
+}>): RecoveredNodeCompletion[];
 /** R3-1: build workflow_nodes_submitted for persistence after a runtime submission, so resume can
  *  re-apply it. `nodes` is the kernel-shape (snake_case) submitted node array. */
 export declare function buildWorkflowNodesSubmittedEvent(input: {
     turn: number;
     nodes: Record<string, unknown>[];
+    baseIndex?: number;
+    submitterAgentId?: string;
 }): Extract<SessionEvent, {
     kind: "workflow_nodes_submitted";
 }>;
 /** R3-1: recover the runtime submission batches (in order) to rebuild `resumed_submissions` for
- *  resumeWorkflow, so dynamically-appended nodes are reconstructed. */
+ *  resumeWorkflow, so dynamically-appended nodes are reconstructed.
+ *  `submitters` is parallel to `submissions` (undefined = host/bootstrap submission). */
 export declare function recoverSubmittedWorkflowNodes(events: Array<{
     seq: number;
     event: SessionEvent;
-}>): Record<string, unknown>[][];
+}>): {
+    submissions: Record<string, unknown>[][];
+    bases: number[];
+    submitters: Array<string | undefined>;
+};