@loopingai/core 0.5.1 → 0.6.0

package/dist/subtasks/types.d.ts

@@ -1,5 +1,6 @@
 import type { ResolvedRecipe, SubtaskParams } from "../contract/recipe.js";
-export type SubtaskStatus = "pending" | "running" | "completed" | "failed" | "skipped" | "canceled";
+import type { RoundFailureKind } from "../agent/inference.js";
+export type SubtaskStatus = "pending" | "running" | "completed" | "failed" | "canceled";
 /** A per-caller, SQLite-assigned, monotonically increasing Subtask identifier. */
 export type SubtaskId = number;
 /**
@@ -22,18 +23,15 @@ export interface SubtaskResultPart {
     text: string;
 }
 /**
- * Creation input for one Subtask, before it is persisted. `dependsOn` uses
- * draft-local keys (not yet-unknown {@link SubtaskId}s); the data layer resolves
- * them to SQLite-assigned ids when the decomposition is created. `ordinal` is
- * derived from the draft's position in the decomposition array.
+ * Creation input for one Subtask, before it is persisted. `ordinal` is derived
+ * from the draft's position in the decomposition array, which is the only thing
+ * that distinguishes one draft of a decomposition from another — they carry no
+ * identity of their own until the data layer assigns a {@link SubtaskId}.
  */
 export interface SubtaskDraft {
-    localKey: string;
     type: string;
     prompt: string;
     references: SubtaskReference[];
-    /** Draft-local keys of prerequisite drafts. */
-    dependsOn: string[];
     /** The type's required inputs, already validated for shape. */
     params: SubtaskParams;
 }
@@ -93,24 +91,11 @@ export interface SubtaskChunkOutcome {
     status: SubtaskStatus;
     progress: ProgressEvent[];
 }
-/**
- * Generated output of one completed prerequisite Subtask, loaded by the parent
- * from its durable row for a dependent's invocation. `type` is the
- * prerequisite's semantic type — used only to label the rendered section;
- * dependency output is always presented as generated, never as conversation
- * evidence.
- */
-export interface DependencyResult {
-    subtaskId: SubtaskId;
-    type: string;
-    resultParts: SubtaskResultPart[];
-}
 /**
  * RPC-safe input for one isolated `RecipeSubagent` execution, assembled by the
  * parent at execution start: the already-resolved (and code-validated) Recipe,
- * the Subtask's non-session prompt, its verbatim reference snapshots, and the
- * generated results of its completed dependencies. The child re-validates the
- * Recipe defensively but never resolves one itself.
+ * the Subtask's non-session prompt, and its verbatim reference snapshots. The
+ * child re-validates the Recipe defensively but never resolves one itself.
  */
 export interface RecipeExecutionRequest {
     taskId: string;
@@ -124,7 +109,6 @@ export interface RecipeExecutionRequest {
     recipe: ResolvedRecipe;
     prompt: string;
     references: SubtaskReference[];
-    dependencyResults: DependencyResult[];
     /**
      * The Subtask's validated params. Part of the execution's identity — two plays
      * of different games are different work — so this IS fingerprinted, unlike
@@ -154,11 +138,9 @@ export type RecipeExecutionResult = {
  * One Subtask as the delegating model emits it. The model selects references
  * by **catalog index only** — it never emits reference text, and application code
  * snapshots the catalog entry's exact role+text onto the Subtask (see
- * `agent/subtasks/decomposition.ts`). `dependsOn` uses draft-local keys, resolved
- * to SQLite-assigned {@link SubtaskId}s by the data layer.
+ * `agent/subtasks/decomposition.ts`).
  */
 export interface SubtaskProposal {
-    localKey: string;
     type: string;
     prompt: string;
     /**
@@ -167,8 +149,6 @@ export interface SubtaskProposal {
      * *reconstructed* historical call, whose references were resolved rounds ago.
      */
     referenceIndexes?: number[];
-    /** Draft-local keys of prerequisite proposals. */
-    dependsOn: string[];
     /** The type's required inputs; omitted for a type that takes none. */
     params?: SubtaskParams;
 }
@@ -188,18 +168,19 @@ export interface DecompositionProposal {
  *
  * `replied` is the terminal answer — the round chose to answer the user rather
  * than delegate, and the Workflow delivers it. `delegated` means the round's
- * Subtask rows are durable and Phase 2 should run them, after which another round
- * begins. `failed` means both models produced unusable output; no Subtask is ever
- * synthesized to cover for it. `canceled` means the caller cancelled during the
- * round: nothing was persisted and nothing was published. Transient platform
- * faults are not results: they throw so the enclosing Workflow step can retry
- * (mirrors {@link RecipeExecutionResult}).
+ * Subtask rows are durable and the Workflow should execute them, after which
+ * another round begins. `failed` means the round produced no answer, with
+ * {@link RoundFailureKind} carrying why; no Subtask is ever synthesized to cover
+ * for it. `canceled` means the caller cancelled during the round: nothing was
+ * persisted and nothing was published. Transient platform faults are not
+ * results: they throw so the enclosing Workflow step can retry (mirrors
+ * {@link RecipeExecutionResult}).
  *
  * `turns` is what this round cost, which the Workflow meters against the Task's
  * budget. This is the **only** type that carries it, and it carries it because the
  * count has to cross an RPC boundary to reach a Workflow in another isolate;
- * everything inside the DO shares one mutable {@link file://../budget.ts TurnBudget}
- * instead. The field is attached in a single place — see `runTaskTurn` — so no
+ * everything inside the DO shares one mutable
+ * {@link file://../agent/budget.ts TurnBudget} instead. The field is attached in a single place — see `runTaskTurn` — so no
  * branch can drop it and no branch can invent it.
  *
  * The idempotent recovery paths — a round replayed from durable rows rather than
@@ -220,8 +201,17 @@ export type TurnTaskResult = {
     reply: string;
     subtasks: Subtask[];
     turns: number;
-} | {
+}
+/**
+ * `kind` distinguishes a round that spent both models and got nothing usable
+ * (`exhausted`) from one that stopped on a fault no attempt could clear —
+ * where the fallback was deliberately *not* tried, and the kind is what lets
+ * the host say why in words an operator can act on. Same terminal Task either
+ * way; only the words differ.
+ */
+ | {
     status: "failed";
+    kind: RoundFailureKind;
     error: string;
     turns: number;
 } | {
@@ -243,15 +233,13 @@ export type TurnVerdict = WithoutTurns<TurnTaskResult>;
 /**
  * One branch's outcome as a later round sees it — a plain, RPC-safe subset of the
  * durable {@link Subtask} row, loaded across **every** round in stable ordinal
- * order. Completed, failed, and skipped branches are all included so the reply
- * can use available successes and disclose relevant failures.
+ * order. Completed and failed branches are both included so the reply can use
+ * available successes and disclose relevant failures.
  *
- * Carries `round`, `prompt` and `dependsOn` — not for composing, but for
- * reconstructing the per-round `delegate` call that produced these branches (see
- * `agent/subtasks/delegate.ts`). Unlike {@link SubtaskNode}, this projection is
- * built inside the DO and returns only a reply, so the 1 MiB Workflow-step cap
- * that keeps the scheduler's view narrow does not apply. `references` still stays
- * out: it is unbounded history text, and the call's shape does not need it.
+ * Carries `round` and `prompt` — not for composing, but for reconstructing the
+ * per-round `delegate` call that produced these branches (see
+ * `agent/subtasks/delegate.ts`). `references` stays out: it is unbounded history
+ * text, and the call's shape does not need it.
  */
 export interface CompositionBranch {
     subtaskId: SubtaskId;
@@ -259,41 +247,29 @@ export interface CompositionBranch {
     ordinal: number;
     type: string;
     prompt: string;
-    dependsOn: SubtaskId[];
     params: SubtaskParams;
     status: SubtaskStatus;
     resultParts: SubtaskResultPart[] | null;
     error: string | null;
 }
 /**
- * The `scan:<n>` wave projection (RPC-safe): either the caller cancelled, or the
- * refreshed DAG after blocked branches were skipped. Returning the verdict with
- * the nodes is what lets the Workflow drop its separate cancellation probe — one
- * round trip, and no gap between asking and acting.
+ * The `scan:<round>` projection (RPC-safe): either the caller cancelled, or the
+ * ids of the round's Subtasks that still owe an outcome, in ordinal order.
+ * Returning the verdict with the ids is what lets the Workflow drop its separate
+ * cancellation probe — one round trip, and no gap between asking and acting.
+ *
+ * Ids and nothing else, deliberately: a Workflow step return is capped at 1 MiB
+ * and a Subtask carries verbatim history snapshots bounded only by
+ * `MAX_INBOUND_TEXT_BYTES`, so a scan returning rows would overflow on a large
+ * task. The durable rows are the source of truth; the Workflow carries
+ * references to them and re-reads through the parent when it needs more.
  */
 export type SubtaskScan = {
     canceled: true;
 } | {
     canceled: false;
-    nodes: SubtaskNode[];
+    ids: SubtaskId[];
 };
-/**
- * The scheduler's view of one Subtask (Phase 2) — everything needed to pick the
- * next dependency-ready wave, and nothing else.
- *
- * Deliberately excludes `prompt`, `references`, and `resultParts`: a Workflow
- * step return is capped at 1 MiB, and a reference is a verbatim history snapshot
- * bounded only by `MAX_INBOUND_TEXT_BYTES`, so a wave scan returning full rows
- * would overflow on a large task. The durable rows — not Workflow state — are the
- * source of truth, so the Workflow carries ids and statuses and re-reads the rest
- * through the parent when it actually needs it.
- */
-export interface SubtaskNode {
-    id: SubtaskId;
-    ordinal: number;
-    status: SubtaskStatus;
-    dependsOn: SubtaskId[];
-}
 /** Durable state owned by the main agent for one delegated unit of work. */
 export interface Subtask {
     id: SubtaskId;
@@ -307,7 +283,6 @@ export interface Subtask {
     recipeVersion: number | null;
     prompt: string;
     references: SubtaskReference[];
-    dependsOn: SubtaskId[];
     /** The type's required inputs, validated at delegation time. */
     params: SubtaskParams;
     status: SubtaskStatus;

package/dist/testing/mock-model.d.ts

@@ -40,3 +40,38 @@ export declare function finalReply(text: string, opts?: {
  * last step.
  */
 export declare function mockModel(...steps: MockStep[]): MockLanguageModelV3;
+/**
+ * A model whose every call throws, and a count of how many times it was asked.
+ *
+ * The count is the point. Several of the attempt ladder's rules are about a call
+ * that must *not* happen — a fallback slot left unspent, a repair not attempted
+ * — and those are invisible to an assertion on the returned outcome alone, which
+ * can be right for the wrong reason.
+ */
+export declare function throwingModel(error: unknown): {
+    model: MockLanguageModelV3;
+    calls: () => number;
+};
+/** {@link mockModel}, plus the same call count {@link throwingModel} reports. */
+export declare function countingModel(...steps: MockStep[]): {
+    model: MockLanguageModelV3;
+    calls: () => number;
+};
+/**
+ * A model that fails the first `failures` calls with a retryable `APICallError`,
+ * then behaves like {@link mockModel}.
+ *
+ * Exists for the one behaviour a scripted-outcome assertion cannot see: whether
+ * a rate limit was *waited out on the same model* or fell straight through to
+ * the fallback. Only the call count distinguishes them — both produce a
+ * successful round.
+ *
+ * `retry-after: 0` is deliberate. The AI SDK honours the header and its own
+ * backoff opens at two seconds, which would spend real seconds asserting
+ * something that has nothing to do with duration. Zero exercises the identical
+ * path — header parsed, preferred over the exponential delay, waited — for free.
+ */
+export declare function rateLimitedModel(failures: number, ...steps: MockStep[]): {
+    model: MockLanguageModelV3;
+    calls: () => number;
+};

package/dist/testing/mock-model.js

@@ -1,4 +1,9 @@
 import { MockLanguageModelV3 } from "ai/test";
+// From `ai`, not `@ai-sdk/provider`. `ai` re-exports the class and is a declared
+// peer; reaching for the provider package directly makes this module — which is
+// on the published `/testing` subpath every consumer loads — depend on a package
+// core does not declare and only resolves today by hoisting.
+import { APICallError } from "ai";
 /**
  * Test doubles for the LLM. Lets the tool-loop / executor specs run the real
  * `generateText` machinery (tool execution, multi-step, fallback) against a
@@ -59,3 +64,73 @@ export function mockModel(...steps) {
         doGenerate: async () => stepResult(steps[Math.min(i++, steps.length - 1)])
     });
 }
+/**
+ * A model whose every call throws, and a count of how many times it was asked.
+ *
+ * The count is the point. Several of the attempt ladder's rules are about a call
+ * that must *not* happen — a fallback slot left unspent, a repair not attempted
+ * — and those are invisible to an assertion on the returned outcome alone, which
+ * can be right for the wrong reason.
+ */
+export function throwingModel(error) {
+    let calls = 0;
+    return {
+        model: new MockLanguageModelV3({
+            doGenerate: async () => {
+                calls += 1;
+                throw error;
+            }
+        }),
+        calls: () => calls
+    };
+}
+/** {@link mockModel}, plus the same call count {@link throwingModel} reports. */
+export function countingModel(...steps) {
+    let calls = 0;
+    let i = 0;
+    return {
+        model: new MockLanguageModelV3({
+            doGenerate: async () => {
+                calls += 1;
+                return stepResult(steps[Math.min(i++, steps.length - 1)]);
+            }
+        }),
+        calls: () => calls
+    };
+}
+/**
+ * A model that fails the first `failures` calls with a retryable `APICallError`,
+ * then behaves like {@link mockModel}.
+ *
+ * Exists for the one behaviour a scripted-outcome assertion cannot see: whether
+ * a rate limit was *waited out on the same model* or fell straight through to
+ * the fallback. Only the call count distinguishes them — both produce a
+ * successful round.
+ *
+ * `retry-after: 0` is deliberate. The AI SDK honours the header and its own
+ * backoff opens at two seconds, which would spend real seconds asserting
+ * something that has nothing to do with duration. Zero exercises the identical
+ * path — header parsed, preferred over the exponential delay, waited — for free.
+ */
+export function rateLimitedModel(failures, ...steps) {
+    let calls = 0;
+    let i = 0;
+    return {
+        model: new MockLanguageModelV3({
+            doGenerate: async () => {
+                calls += 1;
+                if (calls <= failures) {
+                    throw new APICallError({
+                        message: "429 Wholesale Rate limited",
+                        url: "anthropic:messages:test",
+                        requestBodyValues: {},
+                        statusCode: 429,
+                        responseHeaders: { "retry-after": "0" }
+                    });
+                }
+                return stepResult(steps[Math.min(i++, steps.length - 1)]);
+            }
+        }),
+        calls: () => calls
+    };
+}

package/dist/testing/vcr-global-setup.d.ts

@@ -6,9 +6,7 @@
  * Belt and braces rather than load-bearing — each cassette is already flushed
  * when its test releases it, so a run that ends normally has nothing left to do
  * here, and a run that dies mid-test keeps everything recorded up to that point.
- * (Under the old undici recorder this step was mandatory: it held real sockets
- * and a self-refreshing auto-flush timer open, and a `RECORD=1` run hung on
- * "close timed out" without it. Neither exists now.)
+ * The recorder holds no sockets and no timers, so nothing here has to close.
  */
 export declare function setup(): void;
 export declare function teardown(): Promise<void>;

package/dist/testing/vcr-global-setup.js

@@ -7,9 +7,7 @@ import { closeVcr } from "./vcr.js";
  * Belt and braces rather than load-bearing — each cassette is already flushed
  * when its test releases it, so a run that ends normally has nothing left to do
  * here, and a run that dies mid-test keeps everything recorded up to that point.
- * (Under the old undici recorder this step was mandatory: it held real sockets
- * and a self-refreshing auto-flush timer open, and a `RECORD=1` run hung on
- * "close timed out" without it. Neither exists now.)
+ * The recorder holds no sockets and no timers, so nothing here has to close.
  */
 export function setup() { }
 export async function teardown() {

package/dist/worker/index.d.ts

@@ -7,18 +7,11 @@ import type { MountedAgent } from "./define-agent.js";
  * The A2A Worker: the zero-trust, no-shared-secrets edge every Looping agent
  * puts in front of its Durable Object.
  *
- * Three routes, in order:
- *
- *  1. The card-signing **public** JWKS at the card's `jku`.
- *  2. A **signed** AgentCard at `…/.well-known/agent-card.json`, so a gateway can
- *     verify and pin this agent's identity at registration ("G knows R").
- *  3. **Verify the gateway's identity JWT** on every JSON-RPC call against the
- *     gateway's public JWKS ("R knows G"), then run the A2A JSON-RPC server for
- *     that call. {@link A2AExecutor} dispatches into the caller's agent DO — one
- *     instance per calling gateway-agent, keyed by the verified `identity.key`.
- *
- * No secret is ever shared in either direction: trust flows entirely on domains
- * and asymmetric (Ed25519) signatures over public JWKS.
+ * Trust flows entirely on domains and asymmetric (Ed25519) signatures over
+ * public JWKS: a gateway verifies and pins this agent's identity from its signed
+ * card at registration ("G knows R"), and this Worker verifies the gateway's
+ * identity JWT on every JSON-RPC call ("R knows G"). No secret is ever shared in
+ * either direction.
  *
  * **Several agents share one Worker, addressed by `tenant`.** They share one
  * origin, one endpoint, one signing key and one card at the well-known path;

package/dist/worker/index.js

@@ -12,18 +12,11 @@ import { parseGatewayOrigins } from "../env.js";
  * The A2A Worker: the zero-trust, no-shared-secrets edge every Looping agent
  * puts in front of its Durable Object.
  *
- * Three routes, in order:
- *
- *  1. The card-signing **public** JWKS at the card's `jku`.
- *  2. A **signed** AgentCard at `…/.well-known/agent-card.json`, so a gateway can
- *     verify and pin this agent's identity at registration ("G knows R").
- *  3. **Verify the gateway's identity JWT** on every JSON-RPC call against the
- *     gateway's public JWKS ("R knows G"), then run the A2A JSON-RPC server for
- *     that call. {@link A2AExecutor} dispatches into the caller's agent DO — one
- *     instance per calling gateway-agent, keyed by the verified `identity.key`.
- *
- * No secret is ever shared in either direction: trust flows entirely on domains
- * and asymmetric (Ed25519) signatures over public JWKS.
+ * Trust flows entirely on domains and asymmetric (Ed25519) signatures over
+ * public JWKS: a gateway verifies and pins this agent's identity from its signed
+ * card at registration ("G knows R"), and this Worker verifies the gateway's
+ * identity JWT on every JSON-RPC call ("R knows G"). No secret is ever shared in
+ * either direction.
  *
  * **Several agents share one Worker, addressed by `tenant`.** They share one
  * origin, one endpoint, one signing key and one card at the well-known path;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loopingai/core",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "Shared, mandatory foundation for Looping agents on Cloudflare Workers: zero-trust A2A, durable task lifecycle, delegation and subagent runtime, test harness.",
   "keywords": [
     "a2a",
@@ -90,6 +90,10 @@
       "import": "./dist/testing/vcr-global-setup.js"
     },
     "./eslint": "./eslint-rules/index.js",
+    "./anthropic": {
+      "types": "./dist/agent/anthropic/index.d.ts",
+      "import": "./dist/agent/anthropic/index.js"
+    },
     "./package.json": "./package.json"
   },
   "scripts": {
@@ -115,21 +119,35 @@
     "zod": "^4.4.3"
   },
   "peerDependencies": {
+    "@ai-sdk/provider": "^4.0.0",
+    "@anthropic-ai/sdk": "^0.116.0",
     "@cloudflare/vitest-pool-workers": ">=0.18",
+    "@typescript-eslint/utils": ">=8",
     "agents": "^0.20.0",
     "ai": "^7.0.52",
     "vitest": ">=4",
     "workers-ai-provider": "^4.0.0"
   },
   "peerDependenciesMeta": {
+    "@ai-sdk/provider": {
+      "optional": true
+    },
+    "@anthropic-ai/sdk": {
+      "optional": true
+    },
     "@cloudflare/vitest-pool-workers": {
       "optional": true
     },
+    "@typescript-eslint/utils": {
+      "optional": true
+    },
     "vitest": {
       "optional": true
     }
   },
   "devDependencies": {
+    "@ai-sdk/provider": "^4.0.0",
+    "@anthropic-ai/sdk": "^0.116.0",
     "@cloudflare/vitest-pool-workers": "^0.20.1",
     "@types/node": "^26.1.1",
     "agents": "^0.20.0",

package/dist/subtasks/scheduler.d.ts

@@ -1,48 +0,0 @@
-import type { SubtaskId, SubtaskNode } from "./types.js";
-/**
- * The Phase 2 wave scheduler: given the DAG's current state, decide what runs
- * next.
- *
- * Pure and non-mutating. Skipping nodes blocked by a failed prerequisite is the
- * parent's job (`skipBlockedSubtasks`, which runs to a fixpoint and owns the
- * durable writes); this only reads statuses and picks a wave. The Workflow calls
- * it between durable steps, so it must be a plain function of its input — no I/O,
- * no clock, no randomness.
- */
-/** What the Workflow should do with the DAG as it currently stands. */
-export type WaveDecision = 
-/** These nodes' prerequisites all succeeded — run them concurrently, now. */
-{
-    kind: "ready";
-    ids: SubtaskId[];
-}
-/** Every node reached a terminal status. Phase 2 is over. */
- | {
-    kind: "done";
-}
-/** Non-terminal nodes remain but none can ever run. An invariant violation. */
- | {
-    kind: "stuck";
-    active: SubtaskId[];
-};
-/**
- * Select the next wave of dependency-ready Subtasks.
- *
- * A node is ready when it is still active and **every** dependency completed
- * successfully — `completed` specifically, not merely terminal: a dependent must
- * never run on a failed prerequisite's absent output.
- *
- * Ready ids come back in `ordinal` order. The Workflow builds durable step names
- * from them (`execute:<id>`), and step names are a cache key, so the traversal
- * that produces them has to be deterministic.
- *
- * **On `stuck`:** one "active nodes, none ready" check is the whole safety net. A
- * cycle, a self-dependency, and a dangling dependency id all manifest identically
- * here — every node in a cycle waits on a non-completed peer, a self-dependency
- * waits on its own non-completed self, and an unknown id resolves to `undefined`,
- * which is not `completed`. None of them are reachable: `createDecomposition`
- * validates the DAG before it persists a single row. So this is a loud assertion
- * for a corrupted DAG, not a control path — which is exactly why it is one check
- * and not three detectors that can never fire.
- */
-export declare function selectWave(nodes: SubtaskNode[]): WaveDecision;

package/dist/subtasks/scheduler.js

@@ -1,47 +0,0 @@
-/**
- * Non-terminal statuses — nodes Phase 2 still owes an outcome for.
- *
- * `running` counts as active on purpose. `executeSubtask` accepts a row that is
- * `pending` **or** `running`: the latter is its ambiguous-retry path, where a
- * previous attempt crashed mid-execution and the managed child's fingerprint
- * cache may still hold the terminal result that makes the retry free. So a row
- * stranded `running` is re-runnable, and treating it as inert would deadlock its
- * dependents instead of recovering them.
- */
-const ACTIVE = new Set([
-    "pending",
-    "running"
-]);
-/**
- * Select the next wave of dependency-ready Subtasks.
- *
- * A node is ready when it is still active and **every** dependency completed
- * successfully — `completed` specifically, not merely terminal: a dependent must
- * never run on a failed prerequisite's absent output.
- *
- * Ready ids come back in `ordinal` order. The Workflow builds durable step names
- * from them (`execute:<id>`), and step names are a cache key, so the traversal
- * that produces them has to be deterministic.
- *
- * **On `stuck`:** one "active nodes, none ready" check is the whole safety net. A
- * cycle, a self-dependency, and a dangling dependency id all manifest identically
- * here — every node in a cycle waits on a non-completed peer, a self-dependency
- * waits on its own non-completed self, and an unknown id resolves to `undefined`,
- * which is not `completed`. None of them are reachable: `createDecomposition`
- * validates the DAG before it persists a single row. So this is a loud assertion
- * for a corrupted DAG, not a control path — which is exactly why it is one check
- * and not three detectors that can never fire.
- */
-export function selectWave(nodes) {
-    const statusById = new Map(nodes.map((n) => [n.id, n.status]));
-    const active = nodes.filter((n) => ACTIVE.has(n.status));
-    if (active.length === 0)
-        return { kind: "done" };
-    const ready = active
-        .filter((n) => n.dependsOn.every((d) => statusById.get(d) === "completed"))
-        .sort((a, b) => a.ordinal - b.ordinal)
-        .map((n) => n.id);
-    if (ready.length === 0)
-        return { kind: "stuck", active: active.map((n) => n.id) };
-    return { kind: "ready", ids: ready };
-}