@deepstrike/wasm 0.2.35 → 0.2.37

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,51 @@ 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: "agent_process_changed";
     turn: number;
-    category?: KernelEventCategory;
-    primitive?: KernelPrimitive;
     agent_id: string;
     parent_session_id: string;
     role: string;
@@ -212,52 +173,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>;
+};

package/dist/runtime/session-repair.js

@@ -48,24 +48,38 @@ export function buildRunTerminalEvent(input) {
         total_tokens: Math.max(0, input.totalTokens),
     };
 }
+/** 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;
@@ -73,15 +87,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) 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 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

@@ -10,6 +10,13 @@ export interface SubAgentRunContext {
     /** M5 v2.1: set when this child is a workflow node — propagated so a nested `start_workflow`
      *  FLATTENS to the parent kernel rather than auto-pivoting into its own bootstrap. */
     isWorkflowNode?: boolean;
+    /** W-N1 tool exposure. The kernel omits an EMPTY `permitted_capability_ids` on the wire, so a
+     *  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 the kernel preempts this node (`AgentPreempted`), the
      *  orchestrator interrupts the child runner, cancelling its in-flight LLM call. */
     abortSignal?: AbortSignal;

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

@@ -19,7 +19,9 @@ function terminationFromStatus(status) {
         normalized === "timeout" ||
         normalized === "user_abort" ||
         normalized === "error" ||
-        normalized === "milestone_exceeded") {
+        normalized === "milestone_exceeded" ||
+        normalized === "context_overflow" ||
+        normalized === "no_progress") {
         return normalized;
     }
     return status;
@@ -47,12 +49,32 @@ 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.skillContentMap?.size)
+        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 run(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);
+        const metaTools = inherit ? availableMetaTools(ctx.parentOpts) : deriveMetaTools(permitted, ctx.parentOpts);
+        const execPlane = inherit
+            ? ctx.parentOpts.executionPlane
+            : new FilteredExecutionPlane(ctx.parentOpts.executionPlane, permitted, metaTools);
         let systemPrompt = ctx.parentOpts.systemPrompt;
         let inheritEvents;
         if (ctx.manifest.context_inheritance === "full") {
@@ -72,7 +94,10 @@ export class SubAgentOrchestrator {
             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,
-            executionPlane: filteredPlane,
+            // 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,
             systemPrompt,
             sessionLog: ctx.sessionLog,
@@ -82,6 +107,13 @@ 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 an 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: parent preempt → interrupt the child (cancels its in-flight LLM call).
         linkAbort(ctx.abortSignal, childRunner);
@@ -107,6 +139,9 @@ export class SubAgentOrchestrator {
             ...(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/types/agent.d.ts

@@ -2,7 +2,12 @@ import type { Message, ToolSchema } from "../../types.js";
 export type KernelAgentRole = "explore" | "plan" | "implement" | "verify" | "custom";
 export type AgentIsolation = "shared" | "read_only" | "worktree" | "remote";
 export type ContextInheritance = "none" | "system_only" | "full";
-export type TerminationReason = "completed" | "max_turns" | "token_budget" | "timeout" | "user_abort" | "error" | "milestone_exceeded";
+export type TerminationReason = "completed" | "max_turns" | "token_budget" | "timeout" | "user_abort" | "error" | "milestone_exceeded"
+/** v0.2.35 recovery ladder: compaction exhausted and the prompt still exceeds the provider window. */
+ | "context_overflow"
+/** Repeat-fuse escalation: the same tool call (name AND args) re-issued past `terminateAfter` —
+ *  a stall, distinct from `max_turns` which productive runs can also hit. */
+ | "no_progress";
 export type MilestonePolicy = "require_verifier" | "terminate" | "auto_pass";
 export interface AgentIdentity {
     agentId: string;
@@ -14,6 +19,16 @@ export interface AgentCapabilityFilter {
     allowedKinds?: string[];
     allowedIds?: string[];
 }
+export interface LoopRoundSpec {
+    /** Hard round cap across the loop's lifetime; continue/sleep at the cap is coerced to stop. */
+    maxRounds?: number;
+    /** Sleep clamp floor (ms). */
+    minSleepMs?: number;
+    /** Sleep clamp ceiling (ms). */
+    maxSleepMs?: number;
+    /** Fallback when a round ends without a pace call: "stop" (goal loops, default) | "sleep" (cron loops). */
+    defaultAction?: "stop" | "sleep";
+}
 export interface AgentRunSpec {
     identity: AgentIdentity;
     role: KernelAgentRole;
@@ -23,11 +38,18 @@ export interface AgentRunSpec {
     capabilityFilter?: AgentCapabilityFilter;
     milestones?: MilestoneContract;
     metadata?: Record<string, unknown>;
+    /** ③ loop-agent rounds: presence makes this run ONE round of a paced loop (gates the
+     *  kernel `pace` meta-tool and arms the pacing trap). */
+    loopRound?: LoopRoundSpec;
     /** M1/G3: per-agent model preference; the host resolves it via `RuntimeOptions.providerFor`.
      *  Host-side routing only — not sent to the kernel. */
     modelHint?: string;
     /** M4/G5: cumulative token cap for this sub-agent's run (sets the child kernel's `maxTotalTokens`). */
     tokenBudget?: number;
+    /** O3: per-child turn cap (sets the child runner's `maxTurns`; falls back to the parent's). */
+    maxTurns?: number;
+    /** O3: per-child wall-clock cap in ms (sets the child runner's `timeoutMs`; falls back to the parent's). */
+    maxWallMs?: number;
 }
 /** Kernel process-table observation (Phase 3 canonical spawn signal). */
 export interface AgentProcessChangedObservation {
@@ -61,6 +83,11 @@ export interface LoopResult {
     classifyBranch?: string;
     /** A#2 tournament verdict: a judge reports the winning entrant's agent id here. Sent only when set. */
     tournamentWinner?: string;
+    /** ③ loop-agent pacing: the kernel-adjudicated after-round decision, surfaced by the orchestrator
+     *  from the child's done event. For a loop-node iteration this is the PRIMARY continuation
+     *  vocabulary (stop → loopContinue=false); the legacy text-sniffed signal is the fallback.
+     *  SDK-internal — stripped by `subAgentResultToKernel`. */
+    paceDecision?: import("../kernel-step.js").PaceDecision;
 }
 export interface SubAgentResult {
     agentId: string;
@@ -132,6 +159,10 @@ export interface WorkflowNodeSpec {
     };
     /** M4/G5: cap this node's child run at `tokenBudget` cumulative tokens (the per-node "use N tokens"). */
     tokenBudget?: number;
+    /** O3: cap this node's child run at `maxTurns` provider turns (falls back to the parent's). */
+    maxTurns?: number;
+    /** O3: cap this node's child run at `maxWallMs` wall-clock milliseconds. */
+    maxWallMs?: number;
     /** Indices of nodes this node depends on. */
     dependsOn?: number[];
 }
@@ -147,11 +178,14 @@ export interface WorkflowSpawnInfo {
     isolation: string;
     context_inheritance: string;
     model_hint?: string;
+    /** W3 trust level: `"trusted"` | `"quarantined"`. */
+    trust?: string;
     /** G3: JSON Schema the node's output must conform to (carried verbatim from the spec). */
     output_schema?: Record<string, unknown>;
     /** G2: for a reduce node, the registered reducer name to run (no LLM). */
     reducer?: string;
-    /** G2: the dependency agent ids whose outputs a reduce node consumes. */
+    /** The dependency agent ids for EVERY dependent node (W-N2: a DAG edge carries data). A reduce
+     *  node's registered function consumes them; every other node gets its deps' outputs in context. */
     input_agent_ids?: string[];
     /** A#2: present only for a tournament *judge* spawn — the two entrant agent ids whose produced
      *  outputs this judge compares. The runner looks them up and reports the winner as `tournamentWinner`. */
@@ -167,6 +201,10 @@ export interface WorkflowSpawnInfo {
     classify_labels?: string[];
     /** M4/G5: the node's per-node cumulative token cap, if set — the runner caps the child run here. */
     token_budget?: number;
+    /** O3: per-node turn cap → the child run's `maxTurns`. */
+    max_turns?: number;
+    /** O3: per-node wall-clock cap (ms) → the child run's timeout. */
+    max_wall_ms?: number;
 }
 /** G4 budget-as-signal: the workflow's remaining headroom under the active quota, carried on the
  *  `workflow_batch_spawned` observation so a coordinator node can scale its next submission. */
@@ -216,3 +254,9 @@ export declare function generateAndFilter(generators: WorkflowTaskSpec[], filter
  * re-checks flags. Verifiers run read-only with no inherited author context (bias-resistant).
  */
 export declare function verifyRules(rules: WorkflowTaskSpec[], skeptic?: WorkflowTaskSpec): WorkflowSpec;
+/**
+ * Generate → evaluate loop template (parity with node/python `genEval`): a worker Loop node
+ * (worktree isolation, full context) feeding a fresh-context verifier whose output is pinned
+ * to the kernel's verdict schema. Async because the wasm kernel module loads lazily.
+ */
+export declare function genEval(worker: WorkflowTaskSpec, evaluate: WorkflowTaskSpec, maxIters?: number, extractSkillOnPass?: boolean): Promise<WorkflowSpec>;

package/dist/runtime/types/agent.js

@@ -1,3 +1,4 @@
+import { getKernel } from "../kernel.js";
 /** Map kernel spawn observation → host manifest. */
 export function spawnObservationToManifest(obs, spec, parentSessionId) {
     const o = obs;
@@ -45,6 +46,14 @@ export function agentRunSpecToKernel(spec) {
         out.verification_contract_id = spec.verificationContractId;
     if (spec.milestones)
         out.milestones = milestoneContractToKernel(spec.milestones);
+    if (spec.loopRound) {
+        out.loop_round = {
+            ...(spec.loopRound.maxRounds !== undefined ? { max_rounds: spec.loopRound.maxRounds } : {}),
+            ...(spec.loopRound.minSleepMs !== undefined ? { min_sleep_ms: spec.loopRound.minSleepMs } : {}),
+            ...(spec.loopRound.maxSleepMs !== undefined ? { max_sleep_ms: spec.loopRound.maxSleepMs } : {}),
+            ...(spec.loopRound.defaultAction !== undefined ? { default_action: spec.loopRound.defaultAction } : {}),
+        };
+    }
     return out;
 }
 export function milestoneContractToKernel(contract) {
@@ -175,6 +184,9 @@ export function workflowNodeSpecToKernel(n) {
         ...(kind ? { kind } : {}),
         // M4/G5: per-node token cap (additive; omitted when unset).
         ...(n.tokenBudget != null ? { token_budget: n.tokenBudget } : {}),
+        // O3: per-node turn / wall-clock caps (additive; omitted when unset).
+        ...(n.maxTurns != null ? { max_turns: n.maxTurns } : {}),
+        ...(n.maxWallMs != null ? { max_wall_ms: n.maxWallMs } : {}),
         ...(n.dependsOn && n.dependsOn.length ? { depends_on: n.dependsOn } : {}),
     };
 }
@@ -302,10 +314,15 @@ export const startWorkflowTool = {
 };
 /** Build a sub-agent run spec for a kernel-generated workflow node. */
 export function workflowNodeToSpec(node, parentSessionId) {
+    // W-N6 transcript-as-carry: a loop node's iterations share ONE stable session id (the `-i{k}`
+    // suffix names the spawn, not the session), so iteration k replays the transcript of 0..k-1 —
+    // "do the next increment" actually sees the previous increments. The agent_id keeps the
+    // per-iteration suffix (kernel completion routing).
+    const sessionNodeId = node.loop_max_iters != null ? node.agent_id.replace(/-i\d+$/, "") : node.agent_id;
     return {
         identity: {
             agentId: node.agent_id,
-            sessionId: `${parentSessionId}-${node.agent_id}`,
+            sessionId: `${parentSessionId}-${sessionNodeId}`,
             isSubAgent: true,
             parentSessionId,
         },
@@ -316,6 +333,14 @@ export function workflowNodeToSpec(node, parentSessionId) {
         ...(node.model_hint ? { modelHint: node.model_hint } : {}),
         // M4/G5: carry the node's token cap so the orchestrator can bound the child run.
         ...(node.token_budget != null ? { tokenBudget: node.token_budget } : {}),
+        // O3: carry the node's turn / wall-clock caps (the orchestrator already honors these).
+        ...(node.max_turns != null ? { maxTurns: node.max_turns } : {}),
+        ...(node.max_wall_ms != null ? { maxWallMs: node.max_wall_ms } : {}),
+        // DW-3 one continuation vocabulary: a loop ITERATION runs with the pacing trap armed, so the
+        // agent signals continue/stop through the kernel-adjudicated `pace` meta-tool instead of a
+        // text-sniffed JSON blob. One iteration = one round; the DAG (not max_rounds) caps iterations,
+        // and default stop means "ended without pacing" = done — the CC silence-is-completion contract.
+        ...(node.loop_max_iters != null ? { loopRound: { defaultAction: "stop" } } : {}),
     };
 }
 /** Build the host manifest for a kernel-generated workflow node. */
@@ -391,3 +416,31 @@ export function verifyRules(rules, skeptic) {
     }
     return { nodes };
 }
+/**
+ * Generate → evaluate loop template (parity with node/python `genEval`): a worker Loop node
+ * (worktree isolation, full context) feeding a fresh-context verifier whose output is pinned
+ * to the kernel's verdict schema. Async because the wasm kernel module loads lazily.
+ */
+export async function genEval(worker, evaluate, maxIters = 3, extractSkillOnPass = true) {
+    const kernel = await getKernel();
+    const schema = JSON.parse(kernel.verdictOutputSchema(extractSkillOnPass));
+    return {
+        nodes: [
+            {
+                task: asTask(worker),
+                role: "implement",
+                isolation: "worktree",
+                contextInheritance: "full",
+                loop: { maxIters: Math.max(1, maxIters) },
+            },
+            {
+                task: asTask(evaluate),
+                role: "verify",
+                isolation: "read_only",
+                contextInheritance: "none",
+                dependsOn: [0],
+                outputSchema: schema,
+            },
+        ],
+    };
+}

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. */