@deepstrike/sdk 0.2.38 → 0.2.40

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

@@ -1,7 +1,7 @@
 import { agentRunSpecToKernel, findSpawnProcessObservation, spawnObservationToManifest } from "../types/agent.js";
 import { FilteredExecutionPlane } from "./filtered-plane.js";
 import { WorktreeExecutionPlane } from "./worktree-plane.js";
-import { kernelApply } from "./kernel-step.js";
+import { durableKernelApply } from "./kernel-step.js";
 function terminationFromStatus(status) {
     const normalized = status.toLowerCase();
     if (normalized === "completed" ||
@@ -142,6 +142,8 @@ export class SubAgentOrchestrator {
     async *stream(ctx) {
         const { childRunner, inheritEvents, cleanupWorktree } = await this.buildChild(ctx);
         try {
+            if (ctx.contextInput)
+                childRunner.injectNote(ctx.contextInput);
             yield* childRunner.run({
                 sessionId: ctx.spec.identity.sessionId,
                 goal: ctx.spec.goal,
@@ -154,22 +156,25 @@ export class SubAgentOrchestrator {
     }
     async run(ctx) {
         if (ctx.harness) {
-            const { HarnessLoop } = await import("../harness/harness.js");
-            // 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,
+            const { AttemptLoop, RuntimeAttemptBody } = await import("../harness/harness.js");
+            const { LlmEvalJudge } = await import("../harness/judge.js");
+            const { childRunner, inheritEvents, cleanupWorktree } = await this.buildChild(ctx);
+            if (ctx.contextInput)
+                childRunner.injectNote(ctx.contextInput);
+            const loop = new AttemptLoop({
+                body: new RuntimeAttemptBody(childRunner),
+                judge: new LlmEvalJudge(ctx.harness.evalProvider, false),
+                stop: { maxAttempts: ctx.harness.maxAttempts ?? 3 },
             });
             let outcome;
             try {
                 outcome = await loop.run({
+                    sessionId: ctx.spec.identity.sessionId,
                     goal: ctx.spec.goal,
                     criteria: (ctx.spec.milestones?.phases.flatMap(p => p.criteria) ?? [])
                         .filter((t) => typeof t === "string")
                         .map(text => ({ text, required: true })),
+                    inheritEvents,
                 });
             }
             finally {
@@ -177,12 +182,7 @@ export class SubAgentOrchestrator {
             }
             return {
                 agentId: ctx.spec.identity.agentId,
-                result: {
-                    termination: outcome.passed ? "completed" : "error",
-                    turnsUsed: outcome.iterations,
-                    totalTokensUsed: outcome.totalTokens,
-                    ...(outcome.result ? { finalMessage: { role: "assistant", content: outcome.result, toolCalls: [] } } : {}),
-                },
+                result: attemptOutcomeToLoopResult(outcome),
                 // R3-1: surface nodes the agent submitted under the harness so `runWorkflow` appends them.
                 ...(outcome.submittedNodes?.length ? { submittedNodes: outcome.submittedNodes } : {}),
             };
@@ -219,8 +219,34 @@ export class SubAgentOrchestrator {
     }
 }
 export const defaultSubAgentOrchestrator = new SubAgentOrchestrator();
+export function attemptOutcomeToLoopResult(outcome) {
+    // H4: the run-health axis survives independently from the judge axis. A one-shot judge reject
+    // is a healthy completion carrying verdict=false; only exhausting the retry policy promotes the
+    // harness-level failure to a workflow error. A body run_error keeps its concrete kernel
+    // termination when valid, and normalizes non-kernel statuses (for example invalid_arg) to error.
+    const runTermination = terminationFromStatus(outcome.runStatus);
+    const termination = outcome.outcome === "exhausted"
+        ? "error"
+        : outcome.outcome === "run_error" && runTermination !== "error" && runTermination !== "user_abort"
+            ? "error"
+            : runTermination;
+    return {
+        termination,
+        ...(outcome.result
+            ? { finalMessage: { role: "assistant", content: outcome.result, toolCalls: [] } }
+            : {}),
+        turnsUsed: outcome.turns,
+        totalTokensUsed: outcome.totalTokens,
+        attempt: {
+            outcome: outcome.outcome,
+            runStatus: outcome.runStatus,
+            attempts: outcome.attempts,
+            ...(outcome.verdict ? { verdict: outcome.verdict } : {}),
+        },
+    };
+}
 /** Kernel spawn without an active parent run loop (harness / coordinator use). */
-export async function spawnStandalone(parentOpts, parentSessionId, spec, orchestrator = defaultSubAgentOrchestrator) {
+export async function spawnStandalone(parentOpts, parentSessionId, spec, orchestrator = defaultSubAgentOrchestrator, contextInput) {
     const kernel = (await import("../kernel.js")).getKernel();
     const runtime = new kernel.KernelRuntime({
         maxTokens: parentOpts.maxTokens,
@@ -228,8 +254,8 @@ export async function spawnStandalone(parentOpts, parentSessionId, spec, orchest
         timeoutMs: parentOpts.timeoutMs !== undefined ? BigInt(parentOpts.timeoutMs) : undefined,
     });
     const pending = [];
-    kernelApply(runtime, pending, { kind: "start_run", task: { goal: "coordinator", criteria: [] } });
-    const observations = kernelApply(runtime, pending, {
+    await durableKernelApply(runtime, parentOpts.sessionLog, parentSessionId, pending, { kind: "start_run", task: { goal: "coordinator", criteria: [] } });
+    const observations = await durableKernelApply(runtime, parentOpts.sessionLog, parentSessionId, pending, {
         kind: "spawn_sub_agent",
         spec: agentRunSpecToKernel(spec),
         parent_session_id: parentSessionId,
@@ -256,5 +282,6 @@ export async function spawnStandalone(parentOpts, parentSessionId, spec, orchest
         spec,
         manifest,
         sessionLog: parentOpts.sessionLog,
+        ...(contextInput ? { contextInput } : {}),
     });
 }

package/dist/signals/gateway.d.ts

@@ -1,11 +1,18 @@
-import type { RuntimeSignal, SignalSource } from "./types.js";
+import type { RuntimeSignal, SignalClaim, SignalDeliveryReceipt, SignalSource } from "./types.js";
 import type { ScheduledPrompt } from "./scheduled.js";
+import type { ObserverErrorHandler } from "../runtime/reliability.js";
+export interface SignalGatewayOptions {
+    onObserverError?: ObserverErrorHandler;
+    /** Injectable wall clock for deterministic lease tests. */
+    now?: () => number;
+    /** Default claim lease. Must be positive. Default: 30 seconds. */
+    defaultLeaseMs?: number;
+}
 /**
  * SignalGateway — entry point for all external signals into the agent.
  *
  * Implements `SignalSource` so it can be passed directly to `AgentOptions.signalSource`.
- * The gateway maintains an internal FIFO queue; `nextSignal()` drains it one entry at a time
- * on each agent turn.
+ * The gateway maintains an internal FIFO queue and exposes claim/ack/nack delivery leases.
  *
  * Responsibilities:
  * - Cron scheduling: fires ScheduledPrompts at the right wall-clock time (idempotent by goal+time)
@@ -13,16 +20,19 @@ import type { ScheduledPrompt } from "./scheduled.js";
  * - Listener API: `onSignal()` for side-channel observers that don't need the pull interface
  */
 export declare class SignalGateway implements SignalSource {
+    private readonly opts;
     private timers;
     private queue;
     private listeners;
-    /**
-     * Called by the agent loop each turn. Returns the oldest queued signal or null.
-     * When `recipient` is given, returns only the oldest signal addressed to it (plus
-     * unaddressed broadcasts); signals addressed to other recipients stay queued, so one
-     * shared gateway can serve N peer loops. Omit ⇒ legacy FIFO drain (any signal).
-     */
-    nextSignal(recipient?: string): Promise<RuntimeSignal | null>;
+    private deliverySeq;
+    private leaseSeq;
+    constructor(opts?: SignalGatewayOptions);
+    /** Claim one visible signal without deleting it. Unacked claims are redelivered after expiry. */
+    claimSignal(recipient?: string, leaseMs?: number): Promise<SignalClaim | null>;
+    /** Permanently remove the delivery iff the receipt still owns its current lease. */
+    ackSignal(receipt: SignalDeliveryReceipt): Promise<boolean>;
+    /** Release the current lease for immediate retry. Stale receipts are ignored. */
+    nackSignal(receipt: SignalDeliveryReceipt): Promise<boolean>;
     /** 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. */
@@ -33,9 +43,12 @@ export declare class SignalGateway implements SignalSource {
     cancel(goal: string, runAtMs: number): void;
     /** Push a raw signal directly (e.g. from a webhook handler). */
     ingest(sig: RuntimeSignal): void;
+    /** Fan one logical signal out to a known recipient set. Each recipient gets one queue item. */
+    broadcast(recipients: Iterable<string>, sig: RuntimeSignal): void;
     /** Number of signals currently buffered in the queue. */
     get depth(): number;
     /** Clear all pending timers. Call when shutting down to avoid process leaks. */
     destroy(): void;
     private emit;
+    private currentLeaseIndex;
 }

package/dist/signals/gateway.js

@@ -1,9 +1,9 @@
+import { reportObserverFailure } from "../runtime/reliability.js";
 /**
  * SignalGateway — entry point for all external signals into the agent.
  *
  * Implements `SignalSource` so it can be passed directly to `AgentOptions.signalSource`.
- * The gateway maintains an internal FIFO queue; `nextSignal()` drains it one entry at a time
- * on each agent turn.
+ * The gateway maintains an internal FIFO queue and exposes claim/ack/nack delivery leases.
  *
  * Responsibilities:
  * - Cron scheduling: fires ScheduledPrompts at the right wall-clock time (idempotent by goal+time)
@@ -11,23 +11,59 @@
  * - Listener API: `onSignal()` for side-channel observers that don't need the pull interface
  */
 export class SignalGateway {
+    opts;
     timers = new Map();
     queue = [];
     listeners = [];
+    deliverySeq = 0;
+    leaseSeq = 0;
+    constructor(opts = {}) {
+        this.opts = opts;
+    }
     // ── SignalSource interface (pull model) ─────────────────────────────────────
-    /**
-     * Called by the agent loop each turn. Returns the oldest queued signal or null.
-     * When `recipient` is given, returns only the oldest signal addressed to it (plus
-     * unaddressed broadcasts); signals addressed to other recipients stay queued, so one
-     * shared gateway can serve N peer loops. Omit ⇒ legacy FIFO drain (any signal).
-     */
-    async nextSignal(recipient) {
-        if (recipient === undefined)
-            return this.queue.shift() ?? null;
-        const idx = this.queue.findIndex(s => s.recipient === undefined || s.recipient === recipient);
+    /** Claim one visible signal without deleting it. Unacked claims are redelivered after expiry. */
+    async claimSignal(recipient, leaseMs = this.opts.defaultLeaseMs ?? 30_000) {
+        if (!Number.isFinite(leaseMs) || leaseMs <= 0)
+            throw new RangeError("leaseMs must be positive");
+        const now = this.opts.now?.() ?? Date.now();
+        const idx = this.queue.findIndex(entry => {
+            const visible = recipient === undefined
+                || entry.signal.recipient === undefined
+                || entry.signal.recipient === recipient;
+            const available = entry.lease === undefined || entry.lease.expiresAtMs <= now;
+            return visible && available;
+        });
         if (idx === -1)
             return null;
-        return this.queue.splice(idx, 1)[0];
+        const entry = this.queue[idx];
+        entry.deliveryAttempts += 1;
+        const token = `${entry.deliveryId}:lease-${++this.leaseSeq}`;
+        const expiresAtMs = now + leaseMs;
+        entry.lease = { token, expiresAtMs };
+        return {
+            deliveryId: entry.deliveryId,
+            leaseToken: token,
+            signalId: entry.signalId,
+            deliveryAttempt: entry.deliveryAttempts,
+            leaseExpiresAtMs: expiresAtMs,
+            signal: entry.signal,
+        };
+    }
+    /** Permanently remove the delivery iff the receipt still owns its current lease. */
+    async ackSignal(receipt) {
+        const idx = this.currentLeaseIndex(receipt);
+        if (idx === -1)
+            return false;
+        this.queue.splice(idx, 1);
+        return true;
+    }
+    /** Release the current lease for immediate retry. Stale receipts are ignored. */
+    async nackSignal(receipt) {
+        const idx = this.currentLeaseIndex(receipt);
+        if (idx === -1)
+            return false;
+        delete this.queue[idx].lease;
+        return true;
     }
     // ── Push API ────────────────────────────────────────────────────────────────
     /** Register a listener that is called synchronously whenever a signal is emitted.
@@ -49,7 +85,6 @@ export class SignalGateway {
         const fire = () => {
             this.timers.delete(key);
             this.emit({
-                kind: "scheduled",
                 source: "cron",
                 signalType: "job",
                 urgency: "normal",
@@ -78,6 +113,16 @@ export class SignalGateway {
     ingest(sig) {
         this.emit(sig);
     }
+    /** Fan one logical signal out to a known recipient set. Each recipient gets one queue item. */
+    broadcast(recipients, sig) {
+        const seen = new Set();
+        for (const recipient of recipients) {
+            if (!recipient || seen.has(recipient))
+                continue;
+            seen.add(recipient);
+            this.emit({ ...sig, recipient });
+        }
+    }
     /** Number of signals currently buffered in the queue. */
     get depth() {
         return this.queue.length;
@@ -91,8 +136,27 @@ export class SignalGateway {
     }
     // ── Internal ────────────────────────────────────────────────────────────────
     emit(sig) {
-        this.queue.push(sig);
-        for (const l of this.listeners)
-            l(sig);
+        this.queue.push({
+            deliveryId: `signal-${++this.deliverySeq}`,
+            signalId: crypto.randomUUID(),
+            deliveryAttempts: 0,
+            signal: sig,
+        });
+        for (const listener of this.listeners) {
+            try {
+                listener(sig);
+            }
+            catch (cause) {
+                reportObserverFailure(this.opts.onObserverError, {
+                    component: "SignalGateway",
+                    operation: "signal_listener",
+                    cause,
+                });
+            }
+        }
+    }
+    currentLeaseIndex(receipt) {
+        return this.queue.findIndex(entry => entry.deliveryId === receipt.deliveryId
+            && entry.lease?.token === receipt.leaseToken);
     }
 }

package/dist/signals/scheduled.js

@@ -11,7 +11,6 @@ export class ScheduledPrompt {
     }
     toSignal() {
         return {
-            kind: "scheduled",
             source: "cron",
             signalType: "job",
             urgency: "normal",

package/dist/signals/types.d.ts

@@ -7,20 +7,28 @@ export interface RuntimeSignal {
     urgency: RuntimeSignalUrgency;
     payload: Record<string, unknown>;
     dedupeKey?: string;
-    /** Target a specific session loop (its `sessionId`). Omitted ⇒ broadcast (any puller). */
+    /** Target a specific session loop. Omitted means a shared item consumed by one eligible puller. */
     recipient?: string;
-    /** Optional pub/sub topic (carried through; multi-subscriber routing deferred). */
-    topic?: string;
-    /** @deprecated Use source/signalType/urgency directly. */
-    kind?: "interrupt" | "scheduled" | "external";
-    /** @deprecated Prefer explicit `urgency`. */
-    priority?: number;
+    /** Absolute journal-clock deadline for optional urgency escalation. */
+    deadlineMs?: number;
+    /** Merge with an unconsumed queued signal carrying the same key. */
+    coalesceKey?: string;
+    /** Number of host signals deterministically represented by this signal. */
+    coalescedCount?: number;
 }
 export interface SignalSource {
-    /**
-     * Pull the next pending signal. When `recipient` is given, return only signals
-     * addressed to it (plus unaddressed broadcasts); other recipients' signals stay
-     * queued. Omit ⇒ legacy FIFO drain (any signal).
-     */
-    nextSignal(recipient?: string): Promise<RuntimeSignal | null>;
+    claimSignal(recipient?: string, leaseMs?: number): Promise<SignalClaim | null>;
+    ackSignal(receipt: SignalDeliveryReceipt): Promise<boolean>;
+    nackSignal(receipt: SignalDeliveryReceipt): Promise<boolean>;
+}
+/** Opaque proof that one consumer currently owns a leased signal delivery. */
+export interface SignalDeliveryReceipt {
+    deliveryId: string;
+    leaseToken: string;
+}
+export interface SignalClaim extends SignalDeliveryReceipt {
+    signalId: string;
+    deliveryAttempt: number;
+    signal: RuntimeSignal;
+    leaseExpiresAtMs: number;
 }

package/dist/skills/loader.js

@@ -1,5 +1,12 @@
 import { readFile, readdir } from "fs/promises";
 import path from "path";
+const SAFE_SKILL_NAME = /^[A-Za-z0-9_-]+$/;
+function skillPath(skillDir, name) {
+    if (!SAFE_SKILL_NAME.test(name)) {
+        throw new Error(`invalid skill name "${name}": use only letters, digits, "-", "_"`);
+    }
+    return path.join(skillDir, `${name}.md`);
+}
 /** Parse a frontmatter tool list: `read, write` or `[read, write]` → ["read","write"]. */
 function parseToolList(v) {
     if (v == null || v === "")
@@ -22,11 +29,14 @@ function parseFrontmatter(content) {
 }
 /** Read one skill file and return its body (frontmatter stripped). */
 export async function readSkillFile(skillDir, name) {
+    const file = skillPath(skillDir, name);
     try {
-        const raw = await readFile(path.join(skillDir, `${name}.md`), "utf8");
+        const raw = await readFile(file, "utf8");
         return parseFrontmatter(raw).body;
     }
-    catch {
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
         return null;
     }
 }

package/dist/tools/index.d.ts

@@ -1,4 +1,5 @@
 import type { ToolChunk, ToolSchema, ToolResult } from "../types.js";
+import type { OperationContext } from "../runtime/reliability.js";
 /** M3/G4: the runtime context a tool may read when executing. Carries the working directory the tool
  *  should operate in — set to a sub-agent's git worktree for `isolation: "worktree"` nodes. A narrow,
  *  dependency-free shape; the execution plane's `RunContext` is structurally assignable to it.
@@ -9,6 +10,7 @@ import type { ToolChunk, ToolSchema, ToolResult } from "../types.js";
  *  the tool still completes successfully — avoiding the foot-gun where a transient audit-store
  *  outage flips an already-committed write into `isError: true` and triggers a duplicate retry. */
 export interface ToolExecContext {
+    operation?: OperationContext;
     cwd?: string;
     audit?: (label: string, fn: () => Promise<void> | void) => Promise<void>;
 }

package/dist/types/agent.d.ts

@@ -90,6 +90,14 @@ export interface LoopResult {
      *  vocabulary (stop → loopContinue=false); the legacy text-sniffed signal is the fallback.
      *  SDK-internal — stripped by `subAgentResultToKernel`. */
     paceDecision?: import("../runtime/kernel-step.js").PaceDecision;
+    /** Two-axis AttemptLoop result. Serialized alongside `termination` so hosts can observe judge
+     *  failure independently from run health. */
+    attempt?: {
+        outcome: import("../harness/harness.js").AttemptOutcomeKind;
+        runStatus: string;
+        attempts: number;
+        verdict?: import("../runtime/eval.js").Verdict;
+    };
 }
 export interface SubAgentResult {
     agentId: string;
@@ -130,6 +138,9 @@ export type WorkflowTaskSpec = {
 } | string;
 /** W3 trust level for a workflow node. */
 export type NodeTrust = "trusted" | "quarantined";
+export type WorkflowDependencyPolicy = "all_success" | "accept_partial" | "all_terminal" | "optional";
+export type WorkflowNodeStatus = "completed" | "completed_partial" | "failed" | "skipped_upstream_failed";
+export declare function workflowNodeStatusFromTermination(termination: TerminationReason | string): WorkflowNodeStatus;
 /** One node in a declarative workflow DAG (camelCase host shape). */
 export interface WorkflowNodeSpec {
     task: WorkflowTaskSpec;
@@ -171,11 +182,39 @@ export interface WorkflowNodeSpec {
     maxWallMs?: number;
     /** Indices of nodes this node depends on. */
     dependsOn?: number[];
+    /** How dependency terminal states gate this node. Defaults to `all_success`. */
+    depPolicy?: WorkflowDependencyPolicy;
 }
 /** A declarative workflow DAG the kernel runs node-by-node, gating each spawn. */
 export interface WorkflowSpec {
     nodes: WorkflowNodeSpec[];
 }
+export interface KernelWorkflowNodeOutcome {
+    node_id: string;
+    status: WorkflowNodeStatus;
+    termination?: TerminationReason;
+    output?: {
+        role: Message["role"];
+        content: string;
+        tool_calls?: Array<{
+            id: string;
+            name: string;
+            arguments?: Record<string, unknown>;
+        }>;
+        token_count?: number;
+    };
+}
+export interface WorkflowNodeOutcome {
+    nodeId: string;
+    status: WorkflowNodeStatus;
+    termination?: TerminationReason;
+    output?: Message;
+}
+export interface WorkflowOutcome {
+    nodeOutcomes: WorkflowNodeOutcome[];
+    outputs: Record<string, string>;
+}
+export declare function workflowNodeOutcomeFromKernel(raw: KernelWorkflowNodeOutcome): WorkflowNodeOutcome;
 /** Per-node spawn descriptor carried in the `workflow_batch_spawned` observation. */
 export interface WorkflowSpawnInfo {
     agent_id: string;
@@ -267,7 +306,7 @@ export declare function generateAndFilter(generators: WorkflowTaskSpec[], filter
  * Generate→evaluate quality gate (the EvalPipeline successor, #6): a `loop` worker node (re-run up
  * to `maxIters`, stopping early on a `loop_continue=false` self-signal) + a bias-resistant `verify`
  * eval node gated on it, carrying the kernel's verdict `outputSchema`. Mirrors the kernel `gen_eval`
- * template. For the iterative retry-with-feedback variant, drive it with `HarnessLoop`.
+ * template. For the iterative retry-with-feedback variant, drive it with `AttemptLoop`.
  */
 export declare function genEval(worker: WorkflowTaskSpec, evaluate: WorkflowTaskSpec, maxIters?: number, extractSkillOnPass?: boolean): WorkflowSpec;
 /**

package/dist/types/agent.js

@@ -89,6 +89,7 @@ function safeParseToolArgs(raw) {
 }
 export function subAgentResultToKernel(result) {
     const finalMessage = result.result.finalMessage;
+    const attempt = result.result.attempt;
     return {
         agent_id: result.agentId,
         result: {
@@ -112,6 +113,30 @@ export function subAgentResultToKernel(result) {
             ...(result.result.loopContinue !== undefined ? { loop_continue: result.result.loopContinue } : {}),
             ...(result.result.classifyBranch !== undefined ? { classify_branch: result.result.classifyBranch } : {}),
             ...(result.result.tournamentWinner !== undefined ? { tournament_winner: result.result.tournamentWinner } : {}),
+            ...(attempt
+                ? {
+                    attempt: {
+                        outcome: attempt.outcome,
+                        run_status: attempt.runStatus,
+                        attempts: attempt.attempts,
+                        ...(attempt.verdict
+                            ? {
+                                verdict: {
+                                    passed: attempt.verdict.passed,
+                                    overall_score: attempt.verdict.overallScore,
+                                    feedback: attempt.verdict.feedback,
+                                    details: attempt.verdict.details.map(detail => ({
+                                        criterion: detail.criterion,
+                                        passed: detail.passed,
+                                        score: detail.score,
+                                        feedback: detail.feedback,
+                                    })),
+                                },
+                            }
+                            : {}),
+                    },
+                }
+                : {}),
         },
     };
 }
@@ -121,6 +146,35 @@ export function milestoneCheckPass(phaseId) {
 export function milestoneCheckFail(phaseId, reason) {
     return { phaseId, passed: false, reason };
 }
+export function workflowNodeStatusFromTermination(termination) {
+    if (termination === "completed")
+        return "completed";
+    if (termination === "error" || termination === "user_abort")
+        return "failed";
+    return "completed_partial";
+}
+export function workflowNodeOutcomeFromKernel(raw) {
+    const output = raw.output;
+    return {
+        nodeId: raw.node_id,
+        status: raw.status,
+        ...(raw.termination ? { termination: raw.termination } : {}),
+        ...(output
+            ? {
+                output: {
+                    role: output.role,
+                    content: output.content,
+                    toolCalls: (output.tool_calls ?? []).map(call => ({
+                        id: call.id,
+                        name: call.name,
+                        arguments: JSON.stringify(call.arguments ?? {}),
+                    })),
+                    ...(output.token_count != null ? { tokenCount: output.token_count } : {}),
+                },
+            }
+            : {}),
+    };
+}
 /** G4: a concise, human-readable budget note appended to a coordinator node's goal, so its agent can
  *  size a `submit_workflow_nodes` batch to what is actually available. Returns "" when nothing is
  *  bounded (no quota ⇒ no signal). */
@@ -192,6 +246,7 @@ export function workflowNodeSpecToKernel(n) {
         ...(n.maxTurns != null ? { max_turns: n.maxTurns } : {}),
         ...(n.maxWallMs != null ? { max_wall_ms: n.maxWallMs } : {}),
         ...(n.dependsOn && n.dependsOn.length ? { depends_on: n.dependsOn } : {}),
+        dep_policy: n.depPolicy ?? "all_success",
     };
 }
 /** Map a host `WorkflowSpec` to the snake_case kernel JSON (`load_workflow.spec`). */
@@ -321,6 +376,11 @@ const workflowNodesArraySchema = {
                 items: { type: "integer" },
                 description: "Batch-relative, backward-only dependency indices within this submission.",
             },
+            depPolicy: {
+                type: "string",
+                enum: ["all_success", "accept_partial", "all_terminal", "optional"],
+                description: "How dependency terminal states gate this node; defaults to all_success.",
+            },
         },
         required: ["task", "role"],
     },
@@ -451,7 +511,7 @@ export function generateAndFilter(generators, filter) {
  * Generate→evaluate quality gate (the EvalPipeline successor, #6): a `loop` worker node (re-run up
  * to `maxIters`, stopping early on a `loop_continue=false` self-signal) + a bias-resistant `verify`
  * eval node gated on it, carrying the kernel's verdict `outputSchema`. Mirrors the kernel `gen_eval`
- * template. For the iterative retry-with-feedback variant, drive it with `HarnessLoop`.
+ * template. For the iterative retry-with-feedback variant, drive it with `AttemptLoop`.
  */
 export function genEval(worker, evaluate, maxIters = 3, extractSkillOnPass = true) {
     const schema = JSON.parse(getKernel().verdictOutputSchema(extractSkillOnPass));

package/dist/types.d.ts

@@ -154,7 +154,6 @@ export interface DoneEvent extends StreamEvent {
     iterations: number;
     totalTokens: number;
     status: string;
-    dreamResult?: import("./memory/protocols.js").DreamResult;
     /** ③ loop-agent: the kernel-adjudicated after-round decision (absent on non-loop runs). */
     paceDecision?: import("./runtime/kernel-step.js").PaceDecision;
 }
@@ -372,6 +371,12 @@ export interface RenderedContext {
      * yet) ⇒ the provider falls back to the rolling-pair placement.
      */
     frozenPrefixLen?: number;
+    budgetOverflow?: ContextBudgetOverflow;
+}
+export interface ContextBudgetOverflow {
+    kind: "fixed_context" | "protected_tail";
+    requiredTokens: number;
+    maxTokens: number;
 }
 /**
  * Runtime execution policy advertised by a provider.

package/dist/workflow/public.d.ts

@@ -4,12 +4,11 @@ export { builtinReducers, resolveReducer } from "../runtime/reducers.js";
 export type { Reducer, ReducerRegistry, ReducerInput } from "../runtime/reducers.js";
 export { FileWorkflowStore } from "../runtime/workflow-store.js";
 export { submitWorkflowNodesTool, startWorkflowTool, generateAndFilter, verifyRules, genEval, milestoneCheckPass, milestoneCheckFail, } from "../types/agent.js";
-export type { AgentCapabilityFilter, AgentIdentity, AgentIsolation, AgentRunSpec, AgentProcessChangedObservation, ContextInheritance, KernelAgentRole, LoopResult, MilestoneCheckResult, MilestoneContract, MilestonePhase, MilestonePolicy, SubAgentResult, TerminationReason, WorkflowSpawnInfo, WorkflowTaskSpec, } from "../types/agent.js";
+export type { AgentCapabilityFilter, AgentIdentity, AgentIsolation, AgentRunSpec, AgentProcessChangedObservation, ContextInheritance, KernelAgentRole, LoopResult, MilestoneCheckResult, MilestoneContract, MilestonePhase, MilestonePolicy, SubAgentResult, TerminationReason, WorkflowSpawnInfo, WorkflowTaskSpec, WorkflowDependencyPolicy, WorkflowNodeStatus, WorkflowNodeOutcome, WorkflowOutcome, } from "../types/agent.js";
 export type { AcceptanceCriterion, VerificationContract, ContractCheckResult } from "../collaboration/contract.js";
 export { ContractBuilder, formatContractForSystemPrompt, contractToCriteriaStrings } from "../collaboration/contract.js";
 export type { AgentRole, IsolatedVerifierContext, CoordinatorConfig } from "../collaboration/pool.js";
-export { ContractDrivenHarness } from "../collaboration/harness.js";
-export type { ContractOutcome, ContractHarnessOptions, Violation } from "../collaboration/harness.js";
+export type { ContractOutcome } from "../collaboration/harness.js";
 export { HandoffBus } from "../collaboration/handoff.js";
 export type { HandoffArtifact, ContractOutcomeInput } from "../collaboration/handoff.js";
 export { CreatorVerifierMode, OrchestrationMode } from "../collaboration/modes/creator-verifier.js";

package/dist/workflow/public.js

@@ -7,7 +7,6 @@ export { builtinReducers, resolveReducer } from "../runtime/reducers.js";
 export { FileWorkflowStore } from "../runtime/workflow-store.js";
 export { submitWorkflowNodesTool, startWorkflowTool, generateAndFilter, verifyRules, genEval, milestoneCheckPass, milestoneCheckFail, } from "../types/agent.js";
 export { ContractBuilder, formatContractForSystemPrompt, contractToCriteriaStrings } from "../collaboration/contract.js";
-export { ContractDrivenHarness } from "../collaboration/harness.js";
 export { HandoffBus } from "../collaboration/handoff.js";
 export { CreatorVerifierMode, OrchestrationMode } from "../collaboration/modes/creator-verifier.js";
 // Skills loader + lower-level tool execution helpers.