@deepstrike/sdk 0.2.36 → 0.2.38

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

@@ -1,5 +1,5 @@
+import type { KernelPrimitive } from "./kernel-event-log.js";
 import type { ContentPart, ProviderReplay, ToolCall, ToolErrorKind } from "../types.js";
-import type { KernelEventCategory, KernelPrimitive } from "./kernel-event-log.js";
 export type RollbackReason = {
     kind: "fatal_tool_error";
     tool_name: string;
@@ -75,8 +75,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;
@@ -86,8 +84,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;
@@ -95,14 +91,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;
@@ -111,15 +103,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;
@@ -130,78 +118,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;
@@ -213,24 +189,18 @@ 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;
 } | {
@@ -240,29 +210,35 @@ export type SessionEvent = {
 } | {
     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;
@@ -279,10 +255,26 @@ export type SessionEvent = {
     kind: "group_member_joined";
     session_id: string;
     role?: string;
+    member_kind?: "peer" | "vehicle";
 } | {
     kind: "group_budget_charged";
     tokens: number;
     subagents: number;
+    rounds?: number;
+} | {
+    kind: "round_started";
+    /** 1-based round number within the loop. */
+    round: number;
+    goal: string;
+} | {
+    kind: "round_paced";
+    round: number;
+    action: "continue" | "sleep" | "stop";
+    delay_ms?: number;
+    /** Absolute wake time for sleep — lets a stateless host re-arm from the log alone. */
+    wake_at_ms?: number;
+    reason: string;
+    coerced_from?: string;
 };
 export interface SessionLog {
     append(sessionId: string, event: SessionEvent): Promise<number>;

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

@@ -41,34 +41,56 @@ export declare function buildRunTerminalEvent(input: {
 }): Extract<SessionEvent, {
     kind: "run_terminal";
 }>;
-/** Build workflow_node_completed for persistence after a node finishes. */
+/** 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) from a session event stream, to rebuild
- *  `resumed_submissions` for resumeWorkflow so dynamically-appended nodes are reconstructed. */
+ *  `resumed_submissions` for 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>;
+};

package/dist/runtime/session-repair.js

@@ -53,25 +53,38 @@ export function buildRunTerminalEvent(input) {
         total_tokens: Math.max(0, input.totalTokens),
     };
 }
-/** Build workflow_node_completed for persistence after a node finishes. */
+/** 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 function buildWorkflowNodeCompletedEvent(input) {
     return {
         kind: "workflow_node_completed",
         turn: input.turn,
         agent_id: input.agentId,
         termination: input.termination,
+        ...(input.classifyBranch !== undefined ? { classify_branch: input.classifyBranch } : {}),
+        ...(input.tournamentWinner !== undefined ? { tournament_winner: input.tournamentWinner } : {}),
+        ...(input.loopContinue !== undefined ? { loop_continue: input.loopContinue } : {}),
+        ...(input.output ? { output: input.output } : {}),
     };
 }
 /**
- * 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 function recoverCompletedWorkflowNodes(events) {
     const completed = [];
     for (const { event } of events) {
         if (event.kind === "workflow_node_completed" && event.termination === "completed") {
-            completed.push(event.agent_id);
+            completed.push({
+                agentId: event.agent_id,
+                ...(event.classify_branch !== undefined ? { classifyBranch: event.classify_branch } : {}),
+                ...(event.tournament_winner !== undefined ? { tournamentWinner: event.tournament_winner } : {}),
+                ...(event.loop_continue !== undefined ? { loopContinue: event.loop_continue } : {}),
+                ...(event.output !== undefined ? { output: event.output } : {}),
+            });
         }
     }
     return completed;
@@ -79,15 +92,30 @@ export function recoverCompletedWorkflowNodes(events) {
 /** 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 function buildWorkflowNodesSubmittedEvent(input) {
-    return { kind: "workflow_nodes_submitted", turn: input.turn, nodes: input.nodes };
+    return {
+        kind: "workflow_nodes_submitted",
+        turn: input.turn,
+        nodes: input.nodes,
+        ...(input.baseIndex !== undefined ? { base_index: input.baseIndex } : {}),
+        ...(input.submitterAgentId !== undefined ? { submitter_agent_id: input.submitterAgentId } : {}),
+    };
 }
 /** R3-1: recover the runtime submission batches (in order) from a session event stream, to rebuild
- *  `resumed_submissions` for resumeWorkflow so dynamically-appended nodes are reconstructed. */
+ *  `resumed_submissions` for resumeWorkflow so dynamically-appended nodes are reconstructed.
+ *  `submitters` is parallel to `submissions` (undefined = host/bootstrap submission). */
 export function recoverSubmittedWorkflowNodes(events) {
     const submissions = [];
+    const bases = [];
+    const submitters = [];
     for (const { event } of events) {
-        if (event.kind === "workflow_nodes_submitted")
+        if (event.kind === "workflow_nodes_submitted") {
             submissions.push(event.nodes);
+            submitters.push(event.submitter_agent_id);
+            // Absent on legacy logs → order-only replay (bases array stays parallel-short only
+            // if ALL records carry it; a mixed log degrades to order-only for safety).
+            if (event.base_index !== undefined)
+                bases.push(event.base_index);
+        }
     }
-    return submissions;
+    return { submissions, bases: bases.length === submissions.length ? bases : [], submitters };
 }

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

@@ -16,6 +16,13 @@ export interface SubAgentRunContext {
      *  the child runner so a nested `start_workflow` FLATTENS to the parent kernel rather than
      *  auto-pivoting into its own bootstrap (which would fragment the one-kernel/one-quota governance). */
     isWorkflowNode?: boolean;
+    /** W-N1 tool exposure. The kernel omits an EMPTY `permitted_capability_ids` on the wire, so a
+     *  grant-less workflow node is indistinguishable from a zero-cap spawn at the manifest — the
+     *  caller states intent instead: `"inherit"` = run on the parent's execution plane with its
+     *  meta-tool availability (trusted workflow nodes — they carried no grant list by design, and
+     *  filtering on the missing list ran every DAG node TOOL-LESS); `"filtered"` (default) = filter
+     *  to the manifest grants, empty ⇒ deny-all (spawn path, quarantined nodes). */
+    toolAccess?: "inherit" | "filtered";
     /** #2-B-ii: parent-controlled abort. When this fires (the kernel preempted this node via
      *  `InterruptNow` → `AgentPreempted`), the orchestrator interrupts the child runner, cancelling its
      *  in-flight LLM call. */
@@ -26,6 +33,11 @@ export interface SubAgentRunContext {
 export declare function resolveProvider(opts: RuntimeOptions, modelHint?: string): RuntimeOptions["provider"];
 /** Host-side driver for kernel-isolated sub-agent runs. */
 export declare class SubAgentOrchestrator {
+    /** W-N4: the ONE child-runner construction shared by the direct-stream and harness paths — tool
+     *  grant resolution (W-N1), worktree wrapping, inherited system prompt / events, per-node caps.
+     *  The two used to be near-identical copies that had already drifted (the harness path silently
+     *  dropped context inheritance). */
+    private buildChild;
     stream(ctx: SubAgentRunContext): AsyncIterable<StreamEvent>;
     run(ctx: SubAgentRunContext): Promise<SubAgentResult>;
 }

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

@@ -62,14 +62,38 @@ function deriveMetaTools(permitted, opts) {
         metaTools.add("update_plan");
     return metaTools;
 }
+/** W-N1: meta-tools by source availability alone — a `toolAccess: "inherit"` child gets the same
+ *  meta surface a top-level run of these options would. */
+function availableMetaTools(opts) {
+    const metaTools = new Set();
+    if (opts.skillDir)
+        metaTools.add("skill");
+    if (opts.dreamStore)
+        metaTools.add("memory");
+    if (opts.knowledgeSource)
+        metaTools.add("knowledge");
+    if (opts.enablePlanTool)
+        metaTools.add("update_plan");
+    return metaTools;
+}
 /** Host-side driver for kernel-isolated sub-agent runs. */
 export class SubAgentOrchestrator {
-    async *stream(ctx) {
+    /** W-N4: the ONE child-runner construction shared by the direct-stream and harness paths — tool
+     *  grant resolution (W-N1), worktree wrapping, inherited system prompt / events, per-node caps.
+     *  The two used to be near-identical copies that had already drifted (the harness path silently
+     *  dropped context inheritance). */
+    async buildChild(ctx) {
+        // W-N1: "inherit" runs the child on the parent's plane with availability-derived meta-tools
+        // (trusted workflow nodes); "filtered" (default) filters to the manifest grants, empty ⇒
+        // deny-all (spawn path, quarantined nodes).
+        const inherit = ctx.toolAccess === "inherit";
         const permitted = new Set(ctx.manifest.permitted_capability_ids ?? []);
-        const metaTools = deriveMetaTools(permitted, ctx.parentOpts);
-        const filteredPlane = new FilteredExecutionPlane(ctx.parentOpts.executionPlane, permitted, metaTools);
-        // M3/G4: a worktree node runs inside its own git worktree (created here, removed in `finally`).
-        const { plane: execPlane, cleanup: cleanupWorktree } = withWorktree(ctx, filteredPlane);
+        const metaTools = inherit ? availableMetaTools(ctx.parentOpts) : deriveMetaTools(permitted, ctx.parentOpts);
+        const basePlane = inherit
+            ? ctx.parentOpts.executionPlane
+            : new FilteredExecutionPlane(ctx.parentOpts.executionPlane, permitted, metaTools);
+        // M3/G4: a worktree node runs inside its own git worktree (created here, removed by the caller).
+        const { plane: execPlane, cleanup: cleanupWorktree } = withWorktree(ctx, basePlane);
         let systemPrompt = ctx.parentOpts.systemPrompt;
         let inheritEvents;
         if (ctx.manifest.context_inheritance === "full") {
@@ -102,10 +126,21 @@ export class SubAgentOrchestrator {
             enablePlanTool: metaTools.has("update_plan") ? ctx.parentOpts.enablePlanTool : undefined,
             // M5 v2.1: a workflow node's `start_workflow` flattens to the parent kernel (no nested pivot).
             isWorkflowNode: ctx.isWorkflowNode,
+            // The child runs under ITS OWN spec, never the parent's: the spread above would otherwise
+            // leak the parent's `runSpec` (identity, capability filter — and a LoopDriver's armed
+            // `loopRound`, giving every child a phantom pace tool). A loop-node iteration carries its
+            // own minimal spec to arm the pacing trap (DW-3); everything else runs spec-less as before.
+            runSpec: ctx.spec.loopRound
+                ? { identity: ctx.spec.identity, role: ctx.spec.role, goal: ctx.spec.goal, loopRound: ctx.spec.loopRound }
+                : undefined,
         });
         // #2-B-ii: when the parent preempts this node (kernel `AgentPreempted`), interrupt the child —
         // cancelling its in-flight LLM call. Handle an already-aborted signal too (creation race).
         linkAbort(ctx.abortSignal, childRunner);
+        return { childRunner, inheritEvents, cleanupWorktree };
+    }
+    async *stream(ctx) {
+        const { childRunner, inheritEvents, cleanupWorktree } = await this.buildChild(ctx);
         try {
             yield* childRunner.run({
                 sessionId: ctx.spec.identity.sessionId,
@@ -119,34 +154,12 @@ export class SubAgentOrchestrator {
     }
     async run(ctx) {
         if (ctx.harness) {
-            const { RuntimeRunner } = await import("./runner.js");
             const { HarnessLoop } = await import("../harness/harness.js");
-            const permitted = new Set(ctx.manifest.permitted_capability_ids ?? []);
-            const metaTools = deriveMetaTools(permitted, ctx.parentOpts);
-            const filteredPlane = new FilteredExecutionPlane(ctx.parentOpts.executionPlane, permitted, metaTools);
-            // M3/G4: worktree isolation for a worktree node (cleaned up in `finally` below).
-            const { plane: execPlane, cleanup: cleanupWorktree } = withWorktree(ctx, filteredPlane);
-            const childRunner = new RuntimeRunner({
-                ...ctx.parentOpts,
-                // M1/G3: route to the node's hinted model (falls back to the parent provider).
-                provider: resolveProvider(ctx.parentOpts, ctx.spec.modelHint),
-                // M4/G5: cap the child run at the node's token budget (falls back to the inherited cap).
-                maxTotalTokens: ctx.spec.tokenBudget ?? ctx.parentOpts.maxTotalTokens,
-                // O3: per-child turn / wall-clock caps (fall back to the inherited limits).
-                maxTurns: ctx.spec.maxTurns ?? ctx.parentOpts.maxTurns,
-                timeoutMs: ctx.spec.maxWallMs ?? ctx.parentOpts.timeoutMs,
-                executionPlane: execPlane,
-                agentId: ctx.spec.identity.agentId,
-                sessionLog: ctx.sessionLog,
-                skillDir: metaTools.has("skill") ? ctx.parentOpts.skillDir : undefined,
-                dreamStore: metaTools.has("memory") ? ctx.parentOpts.dreamStore : undefined,
-                knowledgeSource: metaTools.has("knowledge") ? ctx.parentOpts.knowledgeSource : undefined,
-                enablePlanTool: metaTools.has("update_plan") ? ctx.parentOpts.enablePlanTool : undefined,
-                // M5 v2.1: a workflow node's `start_workflow` flattens to the parent kernel (no nested pivot).
-                isWorkflowNode: ctx.isWorkflowNode,
-            });
-            // #2-B-ii: parent preempt → interrupt the child (cancels its in-flight LLM call).
-            linkAbort(ctx.abortSignal, childRunner);
+            // W-N4: same construction as the direct path — the harness child now honors the inherited
+            // system prompt (`system_only`). NOTE: `full` inheritance is NOT consumable under a harness
+            // (HarnessLoop mints its own per-attempt session ids, so parent events can't be replayed) —
+            // the inherited events are dropped here by construction, not by drift.
+            const { childRunner, cleanupWorktree } = await this.buildChild(ctx);
             const loop = new HarnessLoop(childRunner, ctx.harness.evalProvider, {
                 maxAttempts: ctx.harness.maxAttempts ?? 3,
             });
@@ -194,6 +207,9 @@ export class SubAgentOrchestrator {
             turnsUsed: done?.iterations ?? 0,
             totalTokensUsed: done?.totalTokens ?? 0,
             ...(finalText ? { finalMessage: { role: "assistant", content: finalText, toolCalls: [] } } : {}),
+            // DW-3: surface the kernel-adjudicated pace decision (loop-node iterations consume it as the
+            // continuation vocabulary). SDK-internal; stripped by subAgentResultToKernel.
+            ...(done?.paceDecision ? { paceDecision: done.paceDecision } : {}),
         };
         return {
             agentId: ctx.spec.identity.agentId,

package/dist/runtime/workflow-control-flow.d.ts

@@ -1,5 +1,13 @@
-/** Instruction appended to a loop node's goal: do the next increment, and signal when done. */
-export declare function loopInstruction(maxIters: number): string;
+/** Instruction appended to a loop iteration's goal. DW-3: the continuation verb is the
+ *  kernel-adjudicated `pace` meta-tool (armed on every iteration run), not a text blob — one
+ *  vocabulary shared with the round-level loop agent. Iterations share one session, so "the work
+ *  so far" is simply the visible transcript. */
+export declare function loopInstruction(maxIters: number, iteration?: number): string;
+/** W-N2: dependency outputs appended to a dependent node's goal — a DAG edge carries data, not
+ *  just ordering (fan-out→synthesize was an uninformed synthesis without this). Each dependency's
+ *  output is clipped so a chain of large nodes can't blow the child's context; empty/unknown
+ *  outputs are skipped. Returns "" when the node has no dependencies. */
+export declare function dependencyOutputsNote(inputAgentIds: string[] | undefined, outputs: Map<string, string> | undefined, maxPerDep?: number): string;
 /** Instruction appended to a classify node's goal: pick exactly one of the kernel's branch labels. */
 export declare function classifyInstruction(labels: string[]): string;
 /** Build a tournament judge's goal: the controller's criterion + the two candidates to compare. */

package/dist/runtime/workflow-control-flow.js

@@ -6,12 +6,33 @@
 //! decision from the node's agent and extracts the matching result signal (`loopContinue` /
 //! `classifyBranch` / `tournamentWinner`) the kernel reads back.
 import { extractJsonValue } from "./output-schema.js";
-/** Instruction appended to a loop node's goal: do the next increment, and signal when done. */
-export function loopInstruction(maxIters) {
-    return (`This task runs as a LOOP (up to ${maxIters} iterations total). Do the next increment of work now. ` +
-        `When you judge the overall task COMPLETE and no further iterations are needed, end your response ` +
-        `with a JSON object {"loop_continue": false}. To request another iteration, omit it or return ` +
-        `{"loop_continue": true}.`);
+/** Instruction appended to a loop iteration's goal. DW-3: the continuation verb is the
+ *  kernel-adjudicated `pace` meta-tool (armed on every iteration run), not a text blob — one
+ *  vocabulary shared with the round-level loop agent. Iterations share one session, so "the work
+ *  so far" is simply the visible transcript. */
+export function loopInstruction(maxIters, iteration = 0) {
+    return (`This task runs as a LOOP — this is iteration ${iteration + 1} of up to ${maxIters}. Your prior ` +
+        `iterations' work (if any) is visible above; do the NEXT increment now. Then call the \`pace\` tool: ` +
+        `\`{"next": "continue"}\` to request another iteration, or \`{"next": "stop"}\` when the overall ` +
+        `task is complete. Ending without calling \`pace\` also completes the loop.`);
+}
+/** W-N2: dependency outputs appended to a dependent node's goal — a DAG edge carries data, not
+ *  just ordering (fan-out→synthesize was an uninformed synthesis without this). Each dependency's
+ *  output is clipped so a chain of large nodes can't blow the child's context; empty/unknown
+ *  outputs are skipped. Returns "" when the node has no dependencies. */
+export function dependencyOutputsNote(inputAgentIds, outputs, maxPerDep = 8_000) {
+    if (!inputAgentIds?.length || !outputs)
+        return "";
+    const blocks = inputAgentIds
+        .map(id => {
+        const out = outputs.get(id) ?? "";
+        if (!out)
+            return "";
+        const clipped = out.length > maxPerDep ? `${out.slice(0, maxPerDep)}\n…[truncated]` : out;
+        return `[dependency ${id} output]\n${clipped}`;
+    })
+        .filter(Boolean);
+    return blocks.join("\n\n");
 }
 /** Instruction appended to a classify node's goal: pick exactly one of the kernel's branch labels. */
 export function classifyInstruction(labels) {

package/dist/signals/gateway.d.ts

@@ -23,8 +23,10 @@ export declare class SignalGateway implements SignalSource {
      * shared gateway can serve N peer loops. Omit ⇒ legacy FIFO drain (any signal).
      */
     nextSignal(recipient?: string): Promise<RuntimeSignal | null>;
-    /** Register a listener that is called synchronously whenever a signal is emitted. */
-    onSignal(listener: (sig: RuntimeSignal) => void): void;
+    /** Register a listener that is called synchronously whenever a signal is emitted.
+     *  Returns an unsubscribe function — long-lived consumers (e.g. a loop's
+     *  `signalAwareSleeper`, re-registered per sleep) must call it or the listener leaks. */
+    onSignal(listener: (sig: RuntimeSignal) => void): () => void;
     /** Schedule a ScheduledPrompt to fire at its `runAtMs`. Idempotent by goal+time. */
     schedule(prompt: ScheduledPrompt): void;
     /** Cancel a scheduled prompt before it fires. */

package/dist/signals/gateway.js

@@ -30,9 +30,16 @@ export class SignalGateway {
         return this.queue.splice(idx, 1)[0];
     }
     // ── Push API ────────────────────────────────────────────────────────────────
-    /** Register a listener that is called synchronously whenever a signal is emitted. */
+    /** Register a listener that is called synchronously whenever a signal is emitted.
+     *  Returns an unsubscribe function — long-lived consumers (e.g. a loop's
+     *  `signalAwareSleeper`, re-registered per sleep) must call it or the listener leaks. */
     onSignal(listener) {
         this.listeners.push(listener);
+        return () => {
+            const idx = this.listeners.indexOf(listener);
+            if (idx !== -1)
+                this.listeners.splice(idx, 1);
+        };
     }
     /** Schedule a ScheduledPrompt to fire at its `runAtMs`. Idempotent by goal+time. */
     schedule(prompt) {