@loopingai/core 0.5.1 → 0.6.0

package/dist/subagent/run.js

@@ -1,7 +1,7 @@
 import { generateText, isStepCount } from "ai";
 import { CHUNK_SOFT_MS } from "../platform.js";
 import { stepAllowance } from "../agent/budget.js";
-import { isTransientAiError } from "../agent/inference.js";
+import { isTransientAiError, nonRecoverableKind } from "../agent/inference.js";
 import { validateRecipe } from "../contract/validation.js";
 import { renderSubagentPrompt } from "./prompt.js";
 /**
@@ -200,6 +200,35 @@ function completed(state, deps, text, modelId) {
         state
     };
 }
+/**
+ * Fail a chunk on an error no second attempt can clear.
+ *
+ * Terminal for this subtask, and deliberately *not* a throw: a throw is retried
+ * by the Workflow step, which is exactly the spend this classification exists to
+ * avoid. The parent round then hits the same condition on its own inference and
+ * fails carrying the kind, which is where an operator-facing message gets
+ * attached — a subagent has no channel of its own to say "a human must fix
+ * this", only this row's `error` string.
+ */
+function nonRecoverableOutcome(state, deps, modelId, kind, diagnostic) {
+    console.error("[recipe-runner] non-recoverable model failure", {
+        model: modelId,
+        kind,
+        diagnostic
+    });
+    return {
+        outcome: {
+            done: true,
+            result: {
+                status: "failed",
+                error: `${kind}: ${diagnostic}`,
+                modelId
+            },
+            progress: deps.progress
+        },
+        state
+    };
+}
 /**
  * Run one durable chunk. Returns a terminal result (natural completion, budget
  * exhaustion, or exhausted models) or a `done: false` yield with the progress
@@ -263,8 +292,11 @@ export async function runResumableChunk(prev, deps) {
         // The run-wide deadline. Without it the entry guard would only observe the
         // deadline at the next chunk boundary, up to `chunkSoftMs` past it.
         () => deps.now() - state.startedAtMs >= deps.limits.maxWallMs,
-        // Not a budget: the platform's step timeout, which needs this chunk to
-        // checkpoint and hand back a fresh step long before ~10 minutes.
+        // Not a budget: the configured step timeout, which needs this chunk to
+        // checkpoint and hand back a fresh step before it trips. Soft, and only
+        // checked here between turns — the turn already in flight when it trips still
+        // runs to completion, which is why `STEP_TIMEOUT_MS - CHUNK_SOFT_MS` is sized
+        // to cover a whole turn rather than a nominal moment. See `platform.ts`.
         () => deps.now() - chunkStartMs >= deps.chunkSoftMs,
         // Not a budget either: publish progress to the user promptly.
         () => deps.progress.length > 0
@@ -280,8 +312,9 @@ export async function runResumableChunk(prev, deps) {
                 tools: deps.tools,
                 stopWhen: boundaries(),
                 maxOutputTokens: deps.maxOutputTokens,
-                // Primary → fallback recovery is manual; SDK backoff would only add latency.
-                maxRetries: 0,
+                // Not a duplicate of the fallback: the fallback answers "this model
+                // cannot do it", and a 429 says "not yet". See `ModelConfig.maxRetries`.
+                maxRetries: deps.maxRetries,
                 abortSignal: deps.abortSignal,
                 onStepEnd
             });
@@ -298,9 +331,9 @@ export async function runResumableChunk(prev, deps) {
             return { kind: "aborted" };
         if (result.finishReason === "length") {
             // Its own warning, not just a diagnostic string: hitting the output ceiling
-            // is a tuning signal about MAX_OUTPUT_TOKENS, distinct from the model
-            // producing bad output, and the two are indistinguishable once folded into
-            // the "recipe exhausted" message.
+            // is a tuning signal about `config.model.maxOutputTokens`, distinct from the
+            // model producing bad output, and the two are indistinguishable once folded
+            // into the "recipe exhausted" message.
             console.warn("[recipe-runner] model output truncated", {
                 model: modelId,
                 maxOutputTokens: deps.maxOutputTokens
@@ -325,6 +358,14 @@ export async function runResumableChunk(prev, deps) {
     if (a.kind === "aborted")
         return yielded();
     if (a.kind === "failed") {
+        // Checked before the fallback, not after: the second slot would present the
+        // same rejected credential. Returned rather than thrown — a throw here is
+        // retried by the Workflow step, which is the other cost this avoids. The
+        // chunk fails, and the parent's next round classifies it properly.
+        const blocked = nonRecoverableKind(a.error);
+        if (blocked) {
+            return nonRecoverableOutcome(state, deps, a.modelId, blocked, a.diagnostic);
+        }
         console.warn("[recipe-runner] primary attempt failed, trying fallback", {
             model: a.modelId,
             diagnostic: a.diagnostic
@@ -395,7 +436,9 @@ async function summarizeBudget(state, deps) {
                 messages,
                 stopWhen: isStepCount(1),
                 maxOutputTokens: deps.maxOutputTokens,
-                maxRetries: 0,
+                // Retries on this model, honouring `retry-after`, before the fallback.
+                // See `ModelConfig.maxRetries`.
+                maxRetries: deps.maxRetries,
                 abortSignal: deps.abortSignal
             });
         }
@@ -421,6 +464,12 @@ async function summarizeBudget(state, deps) {
     if (a.kind === "aborted")
         return yielded();
     if (a.kind === "failed") {
+        // Same rule as the work loop: no fallback on a credential the API already
+        // rejected. A summary is the cheapest call in the run, but it is not free.
+        const blocked = nonRecoverableKind(a.error);
+        if (blocked) {
+            return nonRecoverableOutcome(state, deps, a.modelId, blocked, a.diagnostic);
+        }
         const primaryFailure = a;
         a = await summarize(deps.models.fallback, deps.models.fallbackId());
         if (a.kind === "aborted")
@@ -473,6 +522,7 @@ export async function runRecipeExecution(request, deps) {
             toolOutputWindow: deps.toolOutputWindow,
             reportMetrics: recipe.reportMetrics,
             maxOutputTokens: deps.maxOutputTokens,
+            maxRetries: deps.maxRetries,
             now,
             progress: [],
             checkpoint: () => { }

package/dist/subtasks/catalog.d.ts

@@ -20,7 +20,7 @@ export interface ReferenceCatalogEntry extends SubtaskReference {
  * reference.
  *
  * This is the single eligibility rule, and it has exactly one caller:
- * {@link file://../turn.ts renderTurnMessages} numbers the messages it accepts
+ * {@link file://../round/turn.ts renderTurnMessages} numbers the messages it accepts
  * *and* marks those same messages with their `[ref N]` index, in one pass. One
  * predicate, one walk — the marked messages and the catalog indices cannot drift.
  *

package/dist/subtasks/catalog.js

@@ -10,7 +10,7 @@ import { sessionText } from "../agent/history.js";
  * reference.
  *
  * This is the single eligibility rule, and it has exactly one caller:
- * {@link file://../turn.ts renderTurnMessages} numbers the messages it accepts
+ * {@link file://../round/turn.ts renderTurnMessages} numbers the messages it accepts
  * *and* marks those same messages with their `[ref N]` index, in one pass. One
  * predicate, one walk — the marked messages and the catalog indices cannot drift.
  *

package/dist/subtasks/decomposition.d.ts

@@ -8,16 +8,15 @@ import type { DecompositionProposal, SubtaskDraft } from "./types.js";
  * reference catalog it was generated against, this either produces the drafts to
  * persist or throws.
  *
- * Two invariants live here:
+ * One invariant lives here: **the model selects references by index only.** It
+ * emits catalog indices; this module copies the catalog entry's exact role+text
+ * onto the draft. Model output never becomes reference text, so a Subtask cannot
+ * carry a rewritten, summarized, or fabricated "quote" of the conversation.
  *
- * - **The model selects references by index only.** It emits catalog indices; this
- *   module copies the catalog entry's exact role+text onto the draft. Model output
- *   never becomes reference text, so a Subtask cannot carry a rewritten,
- *   summarized, or fabricated "quote" of the conversation.
- * - **The dependency graph is a validated DAG.** Unknown, duplicate,
- *   self-referential, and cyclic edges are all rejected here. The data layer's
- *   `createDecomposition` re-checks the cheap structural rules as a storage guard,
- *   but full cycle detection is this module's job.
+ * A proposal's subtasks are **independent of one another**: they all run at once
+ * and none can read another's output, so there is no graph to validate and
+ * nothing to order. Sequencing is expressed across rounds instead — the main
+ * agent delegates, reads the results, and delegates the next step.
  *
  * Invalid output is never repaired: a throw fails the attempt, which falls back to
  * the other model, and two failed attempts fail the parent Task. Silently
@@ -39,12 +38,11 @@ export declare class DecompositionValidationError extends Error {
  * constraint reaches the model as part of the tool schema, on every field, with
  * no per-field `.describe()` needed to restate it.
  *
- * Being shown a rule is not the same as being held to it, and the difference used
- * to be a hole. This schema reaches the model through a **control** tool, which has
- * no `execute` — so the SDK's input validation never ran on it, and a blank value
- * the model was shown the pattern for sailed through anyway. What enforces it is
- * {@link file://../control.ts control.ts}, which parses every control call with its
- * own schema before the round uses it.
+ * Being shown a rule is not the same as being held to it. This schema reaches
+ * the model through a **control** tool, which has no `execute`, so the SDK never
+ * validates its input — what enforces the constraint is
+ * {@link file://../agent/control.ts control.ts}, which parses every control call
+ * with the tool's own schema before the round uses it.
  */
 export declare const nonBlank: (label: string) => z.ZodString;
 /**
@@ -63,13 +61,11 @@ export declare const nonBlank: (label: string) => z.ZodString;
 export declare function makeDecompositionProposalSchema(types: SubtaskTypeRegistry, maxSubtasks: number): z.ZodObject<{
     reply: z.ZodString;
     subtasks: z.ZodArray<z.ZodObject<{
-        localKey: z.ZodString;
         type: z.ZodEnum<{
             [x: string]: string;
         }>;
         prompt: z.ZodString;
         referenceIndexes: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-        dependsOn: z.ZodArray<z.ZodString>;
         params: z.ZodOptional<z.ZodObject<{
             [x: string]: z.ZodType<string | undefined, unknown, z.core.$ZodTypeInternals<string | undefined, unknown>>;
         }, z.core.$strip>>;
@@ -79,9 +75,9 @@ export declare function makeDecompositionProposalSchema(types: SubtaskTypeRegist
  * Resolve a validated model proposal into the drafts to persist.
  *
  * Throws {@link DecompositionValidationError} on any structural problem: blank
- * fields, duplicate local keys, unknown/duplicate reference indices, and unknown,
- * duplicate, self-referential, or cyclic dependency edges. On success, array order
- * is preserved — the data layer derives each Subtask's `ordinal` from it.
+ * fields, unknown or duplicate reference indices, and params a type refuses. On
+ * success, array order is preserved — the data layer derives each Subtask's
+ * `ordinal` from it.
  */
 export declare function resolveDecomposition(proposal: DecompositionProposal, catalog: ReferenceCatalogEntry[], types: SubtaskTypeRegistry): {
     reply: string;

package/dist/subtasks/decomposition.js

@@ -6,16 +6,15 @@ import { SubtaskParamsError } from "./subtask-types.js";
  * reference catalog it was generated against, this either produces the drafts to
  * persist or throws.
  *
- * Two invariants live here:
+ * One invariant lives here: **the model selects references by index only.** It
+ * emits catalog indices; this module copies the catalog entry's exact role+text
+ * onto the draft. Model output never becomes reference text, so a Subtask cannot
+ * carry a rewritten, summarized, or fabricated "quote" of the conversation.
  *
- * - **The model selects references by index only.** It emits catalog indices; this
- *   module copies the catalog entry's exact role+text onto the draft. Model output
- *   never becomes reference text, so a Subtask cannot carry a rewritten,
- *   summarized, or fabricated "quote" of the conversation.
- * - **The dependency graph is a validated DAG.** Unknown, duplicate,
- *   self-referential, and cyclic edges are all rejected here. The data layer's
- *   `createDecomposition` re-checks the cheap structural rules as a storage guard,
- *   but full cycle detection is this module's job.
+ * A proposal's subtasks are **independent of one another**: they all run at once
+ * and none can read another's output, so there is no graph to validate and
+ * nothing to order. Sequencing is expressed across rounds instead — the main
+ * agent delegates, reads the results, and delegates the next step.
  *
  * Invalid output is never repaired: a throw fails the attempt, which falls back to
  * the other model, and two failed attempts fail the parent Task. Silently
@@ -40,12 +39,11 @@ export class DecompositionValidationError extends Error {
  * constraint reaches the model as part of the tool schema, on every field, with
  * no per-field `.describe()` needed to restate it.
  *
- * Being shown a rule is not the same as being held to it, and the difference used
- * to be a hole. This schema reaches the model through a **control** tool, which has
- * no `execute` — so the SDK's input validation never ran on it, and a blank value
- * the model was shown the pattern for sailed through anyway. What enforces it is
- * {@link file://../control.ts control.ts}, which parses every control call with its
- * own schema before the round uses it.
+ * Being shown a rule is not the same as being held to it. This schema reaches
+ * the model through a **control** tool, which has no `execute`, so the SDK never
+ * validates its input — what enforces the constraint is
+ * {@link file://../agent/control.ts control.ts}, which parses every control call
+ * with the tool's own schema before the round uses it.
  */
 export const nonBlank = (label) => z
     .string()
@@ -53,13 +51,11 @@ export const nonBlank = (label) => z
     .regex(/\S/, { message: `${label} must not be blank` });
 function makeSubtaskProposalSchema(types) {
     return z.object({
-        localKey: nonBlank("localKey"),
         // A closed enum, not prose: an invented type is rejected by the tool schema
         // itself rather than silently resolving to some default recipe.
         type: z.enum(types.enumKeys()),
         prompt: nonBlank("prompt"),
         referenceIndexes: z.array(z.number().int().min(1)).optional(),
-        dependsOn: z.array(nonBlank("dependsOn entry")),
         /**
          * The type's required inputs — ids the model quotes from a tool result.
          * Every key any type declares is named here, gathered from those types by
@@ -94,45 +90,27 @@ export function makeDecompositionProposalSchema(types, maxSubtasks) {
         subtasks: z.array(makeSubtaskProposalSchema(types)).min(1).max(maxSubtasks)
     });
 }
-/**
- * Reject an edge set that contains a cycle, by Kahn's algorithm over the
- * draft-local keys: repeatedly remove nodes with no unresolved prerequisites; if
- * any node survives, it is part of (or downstream of) a cycle.
- */
-function assertAcyclic(proposal) {
-    const remaining = new Map(proposal.subtasks.map((s) => [s.localKey, new Set(s.dependsOn)]));
-    let progressed = true;
-    while (progressed && remaining.size > 0) {
-        progressed = false;
-        for (const [key, deps] of remaining) {
-            // Ready when every prerequisite has already been removed.
-            if ([...deps].every((d) => !remaining.has(d))) {
-                remaining.delete(key);
-                progressed = true;
-            }
-        }
-    }
-    if (remaining.size > 0) {
-        throw new DecompositionValidationError(`dependency cycle among subtasks: ${[...remaining.keys()].join(", ")}`);
-    }
-}
 /**
  * Snapshot the selected catalog entries onto a draft: validate every index against
  * the catalog, reject duplicates, and copy each entry's exact role+text. Indexes
  * are stored ascending so a Subtask's references read in conversation order
  * regardless of the order the model listed them.
+ *
+ * `label` names the offending subtask by its 1-based position in the proposal —
+ * the only handle a subtask has, and the one the model can map back to what it
+ * just wrote.
  */
-function resolveReferences(localKey, referenceIndexes, catalog) {
+function resolveReferences(label, referenceIndexes, catalog) {
     if (!referenceIndexes)
         return [];
     const seen = new Set();
     for (const index of referenceIndexes) {
         if (seen.has(index)) {
-            throw new DecompositionValidationError(`subtask ${localKey} references index ${index} more than once`);
+            throw new DecompositionValidationError(`${label} references index ${index} more than once`);
         }
         seen.add(index);
         if (index > catalog.length) {
-            throw new DecompositionValidationError(`subtask ${localKey} references unknown catalog index ${index} ` +
+            throw new DecompositionValidationError(`${label} references unknown catalog index ${index} ` +
                 `(catalog has ${catalog.length} ${catalog.length === 1 ? "entry" : "entries"})`);
         }
     }
@@ -148,37 +126,13 @@ function resolveReferences(localKey, referenceIndexes, catalog) {
  * Resolve a validated model proposal into the drafts to persist.
  *
  * Throws {@link DecompositionValidationError} on any structural problem: blank
- * fields, duplicate local keys, unknown/duplicate reference indices, and unknown,
- * duplicate, self-referential, or cyclic dependency edges. On success, array order
- * is preserved — the data layer derives each Subtask's `ordinal` from it.
+ * fields, unknown or duplicate reference indices, and params a type refuses. On
+ * success, array order is preserved — the data layer derives each Subtask's
+ * `ordinal` from it.
  */
 export function resolveDecomposition(proposal, catalog, types) {
-    const keys = new Set();
-    for (const s of proposal.subtasks) {
-        if (keys.has(s.localKey)) {
-            throw new DecompositionValidationError(`duplicate subtask local key: ${s.localKey}`);
-        }
-        keys.add(s.localKey);
-    }
-    // Every key must be registered before any edge is checked: an edge may point
-    // forward to a subtask defined later in the array.
-    for (const s of proposal.subtasks) {
-        const seen = new Set();
-        for (const dep of s.dependsOn) {
-            if (dep === s.localKey) {
-                throw new DecompositionValidationError(`subtask ${s.localKey} depends on itself`);
-            }
-            if (!keys.has(dep)) {
-                throw new DecompositionValidationError(`subtask ${s.localKey} depends on unknown key: ${dep}`);
-            }
-            if (seen.has(dep)) {
-                throw new DecompositionValidationError(`subtask ${s.localKey} depends on ${dep} more than once`);
-            }
-            seen.add(dep);
-        }
-    }
-    assertAcyclic(proposal);
-    const drafts = proposal.subtasks.map((s) => {
+    const drafts = proposal.subtasks.map((s, index) => {
+        const label = `subtask ${index + 1}`;
         const type = s.type.trim();
         let params;
         try {
@@ -189,14 +143,12 @@ export function resolveDecomposition(proposal, catalog, types) {
         catch (err) {
             if (!(err instanceof SubtaskParamsError))
                 throw err;
-            throw new DecompositionValidationError(`subtask ${s.localKey}: ${err.message}`);
+            throw new DecompositionValidationError(`${label}: ${err.message}`);
         }
         return {
-            localKey: s.localKey,
             type,
             prompt: s.prompt.trim(),
-            references: resolveReferences(s.localKey, s.referenceIndexes, catalog),
-            dependsOn: [...s.dependsOn],
+            references: resolveReferences(label, s.referenceIndexes, catalog),
             params
         };
     });

package/dist/subtasks/delegate.d.ts

@@ -41,8 +41,22 @@ export declare function makeDelegateTool(types: SubtaskTypeRegistry, maxSubtasks
 /**
  * The call's id, derived from the parent Task and the round that emitted it —
  * deterministic and replay-safe, the same discipline as the Session message ids
- * it sits alongside (see {@link file://../history.ts}). Later rounds rebuild it
+ * it sits alongside (see {@link file://../agent/history.ts}). Later rounds rebuild it
  * rather than storing it.
+ *
+ * **Underscores, not colons, and this is load-bearing.** Unlike a Session message
+ * id, this one is sent to a provider as a `tool_use.id`, and Anthropic validates
+ * that field against `^[a-zA-Z0-9_-]+$`. The colon-separated form this used to
+ * return failed every round from the first delegation onwards — round 0 was fine
+ * because the model authors its own ids, and round 1 reconstructs this one, so
+ * the request 400d deterministically on both the primary and the fallback until
+ * the deterministic join fired. Workers AI never validated the field, which is
+ * why it took a Claude-backed agent to surface it.
+ *
+ * Nothing persists this: both halves of the pair are rebuilt together on every
+ * request, so changing the shape needs no migration. See
+ * {@link file://../agent/anthropic/prompt.ts providerSafeToolCallId} for the
+ * backstop that catches the next one of these.
  */
 export declare function delegateToolCallId(taskId: string, round: number): string;
 /**
@@ -71,6 +85,11 @@ export type DelegateSubtaskOutcome = {
  * `referenceIndexes` is omitted rather than faked: this round's references were
  * snapshotted verbatim onto the rows when it ran, and the catalog they were
  * chosen from is long gone.
+ *
+ * A subtask proposal carries no identifier of its own, so the model pairs each
+ * entry here with its outcome **by position**: both arrays are built from the
+ * same ordinal-ordered `branches`, and the outcome additionally repeats `type`
+ * and carries the durable `subtaskId`.
  */
 export declare function delegateCallInput(reply: string, branches: CompositionBranch[]): DecompositionProposal;
 /** Rebuild one round's call result from its durable rows, in stable ordinal order. */

package/dist/subtasks/delegate.js

@@ -47,23 +47,25 @@ export function makeDelegateTool(types, maxSubtasks) {
 /**
  * The call's id, derived from the parent Task and the round that emitted it —
  * deterministic and replay-safe, the same discipline as the Session message ids
- * it sits alongside (see {@link file://../history.ts}). Later rounds rebuild it
+ * it sits alongside (see {@link file://../agent/history.ts}). Later rounds rebuild it
  * rather than storing it.
- */
-export function delegateToolCallId(taskId, round) {
-    return `task:${taskId}:round:${round}:delegate`;
-}
-/**
- * The draft-local key a reconstructed call uses for a durable Subtask.
  *
- * A row does not keep the `localKey` its round's model chose — the data layer
- * resolved it to a SQLite id and dropped it. So reconstruction derives a stable
- * key from that id instead: the *same* id the matching outcome carries in
- * {@link DelegateSubtaskOutcome}, so the model can line each result up with the
- * work that produced it.
+ * **Underscores, not colons, and this is load-bearing.** Unlike a Session message
+ * id, this one is sent to a provider as a `tool_use.id`, and Anthropic validates
+ * that field against `^[a-zA-Z0-9_-]+$`. The colon-separated form this used to
+ * return failed every round from the first delegation onwards — round 0 was fine
+ * because the model authors its own ids, and round 1 reconstructs this one, so
+ * the request 400d deterministically on both the primary and the fallback until
+ * the deterministic join fired. Workers AI never validated the field, which is
+ * why it took a Claude-backed agent to surface it.
+ *
+ * Nothing persists this: both halves of the pair are rebuilt together on every
+ * request, so changing the shape needs no migration. See
+ * {@link file://../agent/anthropic/prompt.ts providerSafeToolCallId} for the
+ * backstop that catches the next one of these.
  */
-function localKeyForId(id) {
-    return `s${id}`;
+export function delegateToolCallId(taskId, round) {
+    return `task_${taskId}_round_${round}_delegate`;
 }
 /**
  * Rebuild one round's call input from its durable rows, in stable ordinal order.
@@ -74,15 +76,18 @@ function localKeyForId(id) {
  * `referenceIndexes` is omitted rather than faked: this round's references were
  * snapshotted verbatim onto the rows when it ran, and the catalog they were
  * chosen from is long gone.
+ *
+ * A subtask proposal carries no identifier of its own, so the model pairs each
+ * entry here with its outcome **by position**: both arrays are built from the
+ * same ordinal-ordered `branches`, and the outcome additionally repeats `type`
+ * and carries the durable `subtaskId`.
  */
 export function delegateCallInput(reply, branches) {
     return {
         reply,
         subtasks: branches.map((branch) => ({
-            localKey: localKeyForId(branch.subtaskId),
             type: branch.type,
             prompt: branch.prompt,
-            dependsOn: branch.dependsOn.map(localKeyForId),
             // Reconstructed verbatim from the row: a later round must see the same
             // params the call really carried, or it cannot reason about what ran.
             params: branch.params

package/dist/subtasks/index.d.ts

@@ -1,10 +1,9 @@
 /**
  * `@loopingai/core/subtasks` — the delegation layer: what a round may hand out,
- * how a proposal becomes durable drafts, and which of them may run next.
+ * and how a proposal becomes durable drafts.
  */
 export { makeSubtaskTypes, SubtaskParamsError, type SubtaskTypeRegistry } from "./subtask-types.js";
 export { DecompositionValidationError, makeDecompositionProposalSchema, nonBlank, resolveDecomposition } from "./decomposition.js";
 export { DELEGATE_TOOL_NAME, makeDelegateTool, delegateToolCallId, delegateCallInput, delegateCallOutput, type DelegateSubtaskOutcome } from "./delegate.js";
-export { selectWave, type WaveDecision } from "./scheduler.js";
 export { isCatalogEligible, type ReferenceCatalogEntry } from "./catalog.js";
 export * from "./types.js";

package/dist/subtasks/index.js

@@ -1,10 +1,9 @@
 /**
  * `@loopingai/core/subtasks` — the delegation layer: what a round may hand out,
- * how a proposal becomes durable drafts, and which of them may run next.
+ * and how a proposal becomes durable drafts.
  */
 export { makeSubtaskTypes, SubtaskParamsError } from "./subtask-types.js";
 export { DecompositionValidationError, makeDecompositionProposalSchema, nonBlank, resolveDecomposition } from "./decomposition.js";
 export { DELEGATE_TOOL_NAME, makeDelegateTool, delegateToolCallId, delegateCallInput, delegateCallOutput } from "./delegate.js";
-export { selectWave } from "./scheduler.js";
 export { isCatalogEligible } from "./catalog.js";
 export * from "./types.js";

package/dist/subtasks/subtask-types.d.ts

@@ -78,14 +78,6 @@ export interface SubtaskTypeRegistry {
     paramProperties(): Record<string, z.ZodType<string | undefined>>;
     /** The type catalogue as the delegating model is shown it. */
     renderTypes(): string;
-    /**
-     * Every type's {@link SubtaskTypeSpec.capability}, for the main agent's soul.
-     *
-     * Returns `""` when no type declares one, and that case is worth naming: it is
-     * what lets each call site append unconditionally instead of emitting a
-     * separator around nothing.
-     */
-    renderCapabilities(): string;
     /** Every type's {@link SubtaskTypeSpec.delegationGuidance}, for the round contract. */
     renderDelegationGuidance(names: DelegationNames): string;
 }

package/dist/subtasks/subtask-types.js

@@ -91,13 +91,6 @@ export function makeSubtaskTypes(specs) {
             })
                 .join("\n");
         },
-        renderCapabilities() {
-            const blocks = [];
-            for (const s of specs)
-                if (s.capability)
-                    blocks.push(s.capability);
-            return blocks.join("\n\n");
-        },
         renderDelegationGuidance(names) {
             const sections = [];
             for (const s of specs) {