@deepstrike/sdk 0.2.8 → 0.2.9

package/dist/index.d.ts

@@ -1,8 +1,6 @@
 export { RuntimeRunner, collectText } from "./runtime/runner.js";
 export type { RuntimeOptions, SchedulerBudget } from "./runtime/runner.js";
 export type { MemoryPolicy, MemoryWriteRateLimit, ResourceQuota } from "./kernel.js";
-export { createTournament, createLoopUntilDone } from "./kernel.js";
-export type { TournamentMatch, TournamentAction, StopConditionSpec, RoundReport, LoopAction, } from "./kernel.js";
 export { KernelPrimitivesDashboard } from "./runtime/kernel-primitives-dashboard.js";
 export { FilteredExecutionPlane } from "./runtime/filtered-plane.js";
 export { SubAgentOrchestrator, defaultSubAgentOrchestrator, spawnStandalone } from "./runtime/sub-agent-orchestrator.js";

package/dist/index.js

@@ -1,6 +1,5 @@
 // ── Runtime (Layer 1.5) ────────────────────────────────────────────────────
 export { RuntimeRunner, collectText } from "./runtime/runner.js";
-export { createTournament, createLoopUntilDone } from "./kernel.js";
 export { KernelPrimitivesDashboard } from "./runtime/kernel-primitives-dashboard.js";
 export { FilteredExecutionPlane } from "./runtime/filtered-plane.js";
 export { SubAgentOrchestrator, defaultSubAgentOrchestrator, spawnStandalone } from "./runtime/sub-agent-orchestrator.js";

package/dist/kernel.d.ts

@@ -147,54 +147,6 @@ export interface KernelRuntimeInstance {
     drainNewMessages(): Message[];
     preservedRefs(): string[];
 }
-/** One pairwise match-up in a tournament round. */
-export interface TournamentMatch {
-    id: number;
-    left: string;
-    right: string;
-}
-/** Discriminated action returned by {@link TournamentInstance} methods. */
-export interface TournamentAction {
-    kind: "judgeRound" | "done";
-    /** `judgeRound`: 1-based round number. */
-    round?: number;
-    /** `judgeRound`: run one fresh-context judge per match (parallelisable). */
-    matches?: TournamentMatch[];
-    /** `done`: the winning entrant id. */
-    winner?: string;
-    /** `done`: number of rounds played. */
-    roundsUsed?: number;
-}
-interface TournamentInstance {
-    start(): TournamentAction;
-    feedRound(winners: string[]): TournamentAction;
-    isDone(): boolean;
-}
-/** A single loop stop predicate. `maxRounds` is required when `kind === "maxRounds"`. */
-export interface StopConditionSpec {
-    kind: "noNewFindings" | "noErrors" | "maxRounds";
-    maxRounds?: number;
-}
-/** What the SDK reports after running a loop round's worker. */
-export interface RoundReport {
-    newFindings: number;
-    errors: number;
-}
-/** Discriminated action returned by {@link LoopUntilDoneInstance} methods. */
-export interface LoopAction {
-    kind: "spawn" | "done";
-    /** `spawn`: 1-based round number to run. */
-    round?: number;
-    /** `done`: number of rounds run. */
-    roundsUsed?: number;
-    /** `done`: which condition fired. */
-    reason?: "noNewFindings" | "noErrors" | "maxRounds";
-}
-interface LoopUntilDoneInstance {
-    start(): LoopAction;
-    feed(report: RoundReport): LoopAction;
-    isDone(): boolean;
-}
 interface KernelModule {
     Governance: new (defaultAction?: "allow" | "deny" | "ask_user") => GovernanceInstance;
     KernelRuntime: new (policy: {
@@ -208,12 +160,6 @@ interface KernelModule {
         extractSkillOnPass?: boolean;
     }) => EvalPipelineInstance;
     IdlePipeline: new (agentId: string) => IdlePipelineInstance;
-    Tournament: new (entrants: string[]) => TournamentInstance;
-    LoopUntilDone: new (conditions: StopConditionSpec[]) => LoopUntilDoneInstance;
 }
-/** Create a single-elimination tournament (pairwise comparative judging). Throws if `entrants` is empty. */
-export declare function createTournament(entrants: string[]): TournamentInstance;
-/** Create a loop-until-done state machine. A `maxRounds` backstop is injected if none is given. */
-export declare function createLoopUntilDone(conditions: StopConditionSpec[]): LoopUntilDoneInstance;
 export declare function getKernel(): KernelModule;
 export {};

package/dist/kernel.js

@@ -2,14 +2,6 @@ import { createRequire } from "module";
 import { existsSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-/** Create a single-elimination tournament (pairwise comparative judging). Throws if `entrants` is empty. */
-export function createTournament(entrants) {
-    return new (getKernel().Tournament)(entrants);
-}
-/** Create a loop-until-done state machine. A `maxRounds` backstop is injected if none is given. */
-export function createLoopUntilDone(conditions) {
-    return new (getKernel().LoopUntilDone)(conditions);
-}
 const cjsRequire = createRequire(import.meta.url);
 let cachedKernel;
 function resolveCoreModule() {

package/dist/runtime/runner.js

@@ -276,15 +276,17 @@ export class RuntimeRunner {
             // W0-ABI resume: skip nodes already completed before an interruption.
             ...(opts?.resumedCompleted?.length ? { resumed_completed: opts.resumedCompleted } : {}),
         });
+        const collectNodes = (obs) => obs.find(o => o.kind === "workflow_batch_spawned")
+            ?.nodes ?? [];
+        const findDone = (obs) => obs.find(o => o.kind === "workflow_completed");
+        let done = findDone(observations);
+        if (done)
+            return { completed: done.completed ?? [], failed: done.failed ?? [] };
+        let nodes = collectNodes(observations);
         for (;;) {
-            const done = observations.find(o => o.kind === "workflow_completed");
-            if (done)
-                return { completed: done.completed ?? [], failed: done.failed ?? [] };
-            const batch = observations.find(o => o.kind === "workflow_batch_spawned");
-            const nodes = batch?.nodes ?? [];
             if (nodes.length === 0)
                 return { completed: [], failed: [] }; // nothing to run (e.g. all gated)
-            // Run the batch's nodes in parallel — each is independent within a round.
+            // Run the currently-runnable nodes in parallel — each is independent within a round.
             const results = await Promise.all(nodes.map(node => orchestrator.run({
                 parentOpts: this.opts,
                 parentSessionId,
@@ -293,13 +295,23 @@ export class RuntimeRunner {
                 sessionLog: this.opts.sessionLog,
                 ...(this.opts.subAgentHarness ? { harness: this.opts.subAgentHarness } : {}),
             })));
-            // Feed completions back; the draining feed yields the next batch or completion.
-            observations = [];
+            // Feed completions back one at a time. The kernel's run-queue executor may spawn a node's
+            // dependents the moment *that* node completes (per-node unblock), so each feed can emit its
+            // own `workflow_batch_spawned`; ACCUMULATE them across the round rather than keeping only the
+            // last feed's (the old code overwrote `observations` per feed and dropped nodes unblocked by
+            // earlier completions — stalling uneven DAGs). Completion and new spawns are mutually
+            // exclusive per feed, so a `workflow_completed` only arrives once nothing remains to run.
+            const nextNodes = [];
+            done = undefined;
             for (const result of results) {
-                observations = kernelApply(runtime, this.pendingObservations, {
+                const obs = kernelApply(runtime, this.pendingObservations, {
                     kind: "sub_agent_completed",
                     result: subAgentResultToKernel(result),
                 });
+                nextNodes.push(...collectNodes(obs));
+                const d = findDone(obs);
+                if (d)
+                    done = d;
                 // Persist node completion for resume recovery.
                 await this.opts.sessionLog.append(parentSessionId, buildWorkflowNodeCompletedEvent({
                     turn: runtime.turn(),
@@ -307,6 +319,10 @@ export class RuntimeRunner {
                     termination: result.result.termination,
                 }));
             }
+            if (done && nextNodes.length === 0) {
+                return { completed: done.completed ?? [], failed: done.failed ?? [] };
+            }
+            nodes = nextNodes;
         }
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepstrike/sdk",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "description": "DeepStrike Node.js SDK",
   "type": "module",
   "main": "dist/index.js",
@@ -20,7 +20,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.99.0",
-    "@deepstrike/core": "0.2.8",
+    "@deepstrike/core": "0.2.9",
     "@google/generative-ai": "^0.24.1",
     "openai": "^5.23.2"
   },