@loopingai/core 0.5.1 → 0.6.0

package/dist/round/workflow.d.ts

@@ -1,6 +1,7 @@
 import type { WorkflowStep } from "cloudflare:workers";
 import type { CoreConfig } from "../config.js";
 import type { GatewayIdentity } from "../a2a/verify.js";
+import type { RoundFailureKind } from "../agent/inference.js";
 import type { RoundAgentBase } from "./agent.js";
 import type { RoundPolicy } from "./policy.js";
 /**
@@ -15,10 +16,10 @@ import type { RoundPolicy } from "./policy.js";
  * 1. **Round** — one main-agent inference that either answers the user (the Task
  *    is done) or delegates durable Subtasks plus the acknowledgment the user sees
  *    while they run.
- * 2. **Execute** — a delegating round's Subtask DAG runs in waves, every
- *    dependency-ready node concurrently, each in an isolated managed subagent.
- *    Then the loop returns to 1, where the model sees the results and decides
- *    again — answer, or delegate once more.
+ * 2. **Execute** — a delegating round's Subtasks all run at once, each in an
+ *    isolated managed subagent. Then the loop returns to 1, where the model sees
+ *    the results and decides again — answer, or delegate once more. Sequencing
+ *    lives here, in the loop, not inside a round.
  * 3. **Deliver** — persist the terminal Task, then POST a signed callback.
  *
  * The main agent is never forced either way. A round that has run out of budget —
@@ -78,6 +79,22 @@ export interface HandleTaskDeps {
     config: CoreConfig;
     /** The user-facing copy. Only `copy.taskFailed` is read out here. */
     policy: RoundPolicy;
+    /**
+     * Terminal copy for a round that produced no answer, by {@link
+     * RoundFailureKind} — an expired credential, models that could not do it, and
+     * whatever that union grows to cover.
+     *
+     * A hook rather than more `RoundPolicy` copy, because the useful words are
+     * deployment-specific ("run `claude setup-token`, then
+     * `wrangler secret put …`") and most agents cannot hit these conditions at
+     * all. Returning `undefined` — or omitting this — falls back to
+     * `policy.copy.taskFailed`, so an agent that does not care changes nothing,
+     * and one that only cares about *some* kinds answers for those alone.
+     *
+     * Core still owns the delivery: this supplies only the message, so the
+     * guarded write that doubles as the cancellation check stays in one place.
+     */
+    failureCopy?: (kind: RoundFailureKind, detail: string) => string | undefined;
     /**
      * The deployment's Ed25519 private JWK, for the terminal callback. Passed
      * rather than read off a module-scope `env` so this stays a pure function of
@@ -106,9 +123,8 @@ type AgentStub = DurableObjectStub<RoundAgentBase>;
  * references to them.
  *
  * **Step names are durable cache keys.** Everything inside the round loop carries
- * its round for that reason: `turn:<round>`, `deadline:<round>`,
- * `scan:<round>:<wave>`, `cancel:<round>:<wave>`. Renaming one silently re-runs
- * its effect on replay.
+ * its round for that reason: `turn:<round>`, `deadline:<round>`, `scan:<round>`,
+ * `cancel:<round>`. Renaming one silently re-runs its effect on replay.
  */
 export declare function runHandleTask(p: HandleTaskParams, step: WorkflowStep, deps: HandleTaskDeps): Promise<void>;
 export {};

package/dist/round/workflow.js

@@ -1,7 +1,65 @@
-import { MAX_CHUNKS_PER_BRANCH } from "../platform.js";
+import { MAX_CHUNKS_PER_BRANCH, STEP_TIMEOUT_MS } from "../platform.js";
 import { buildCompletedTask, buildFailedTask } from "../a2a/notify.js";
 import { createPushChannel } from "../a2a/push.js";
-import { selectWave } from "../subtasks/scheduler.js";
+/**
+ * What the long steps configure instead of inheriting.
+ *
+ * Both halves of this were previously left at Workflows' defaults, and both
+ * defaults were wrong for this workload.
+ *
+ * **`timeout`.** The default is ten minutes. Nothing here passed a config, so that
+ * default silently became the ceiling {@link CHUNK_SOFT_MS} was sized against —
+ * see the note on `STEP_TIMEOUT_MS` in `platform.ts` for what that cost. A step
+ * here holds a model call and its provider retries, or a container command running
+ * a project's test suite; neither fits in ten minutes reliably and neither uses
+ * meaningful CPU while it waits.
+ *
+ * **`retries`.** The default is five attempts with exponential backoff from ten
+ * seconds. The failure documented on {@link ResolveAgent} is what that produces
+ * when the fault is not transient: five retries against a severed stub, each
+ * failing in under 10ms, spread across 160 seconds of backoff that bought nothing.
+ * Three attempts still cover a genuinely transient fault — the model call has its
+ * own provider-level retry underneath this — and a flat five-second delay stops a
+ * fast, permanent failure from being paid for at exponential rates.
+ *
+ * Deliberately applied only to the chunk steps — see {@link turnStep} for why a
+ * round does not share it. The short bookkeeping steps (`working`, `deadline:`,
+ * `scan:`, `complete`, `notify`) are sub-second projections where the defaults
+ * are fine and a shared config would only hide that.
+ */
+const CHUNK_STEP = {
+    timeout: STEP_TIMEOUT_MS,
+    retries: { limit: 3, delay: 5_000, backoff: "constant" }
+};
+/**
+ * The same retries, and a timeout a **round** can actually be measured against.
+ *
+ * A chunk and a round are bounded by different things, and sharing one constant
+ * hid that. A chunk has {@link CHUNK_SOFT_MS}: it checkpoints and hands back a
+ * fresh step, so `STEP_TIMEOUT_MS` is a ceiling it is sized to stay under. A
+ * round has no soft deadline at all — `runTurn` runs up to
+ * `mainAgentLimits.maxTurns` sequential model-plus-tool steps in one
+ * `generateText`, and its only bound is that step count. Twenty turns whose
+ * tools each take the {@link file://../platform.ts MAX_TOOL_CALL_MS} they are
+ * permitted is hours, not half an hour, so a perfectly legal round could be
+ * killed and replayed whole.
+ *
+ * So the ceiling comes from the agent's own patience: a round cannot usefully
+ * outlive the wall clock its Task is allowed, because the `deadline:` step fails
+ * the Task at that point anyway. Floored at `STEP_TIMEOUT_MS` so a deliberately
+ * tight `maxWallMs` cannot produce a step timeout shorter than the single tool
+ * call core tells hosts they may install.
+ *
+ * This remains a backstop against a hang, not a budget. What actually bounds
+ * what a round *spends* is `TurnBudget`, and what bounds the Task is
+ * `mainAgentLimits` — both of which are checked whatever this says.
+ */
+function turnStep(config) {
+    return {
+        ...CHUNK_STEP,
+        timeout: Math.max(config.mainAgentLimits.maxWallMs, STEP_TIMEOUT_MS)
+    };
+}
 /**
  * The orchestration itself, split from the `WorkflowEntrypoint` wiring so it can
  * be driven with a fake `step` in tests (workerd forbids constructing a
@@ -14,9 +72,8 @@ import { selectWave } from "../subtasks/scheduler.js";
  * references to them.
  *
  * **Step names are durable cache keys.** Everything inside the round loop carries
- * its round for that reason: `turn:<round>`, `deadline:<round>`,
- * `scan:<round>:<wave>`, `cancel:<round>:<wave>`. Renaming one silently re-runs
- * its effect on replay.
+ * its round for that reason: `turn:<round>`, `deadline:<round>`, `scan:<round>`,
+ * `cancel:<round>`. Renaming one silently re-runs its effect on replay.
  */
 export async function runHandleTask(p, step, deps) {
     const limits = deps.config.mainAgentLimits;
@@ -80,7 +137,7 @@ export async function runHandleTask(p, step, deps) {
         // durable work to fall back on) and routes to failed delivery; a transient
         // fault throws and the step retries, recovering from the durable rows with no
         // second inference.
-        const turn = await step.do(`turn:${round}`, async () => {
+        const turn = await step.do(`turn:${round}`, turnStep(deps.config), async () => {
             // Projected to a plain object: an RPC return carries a `Disposable` brand a
             // step result cannot serialize. Every branch must carry `turns` — a field
             // this projection drops is a field the budget never sees.
@@ -102,6 +159,7 @@ export async function runHandleTask(p, step, deps) {
             if (result.status === "failed")
                 return {
                     status: result.status,
+                    kind: result.kind,
                     error: result.error,
                     turns: result.turns
                 };
@@ -110,27 +168,33 @@ export async function runHandleTask(p, step, deps) {
         turnsUsed += turn.turns;
         if (turn.status === "canceled")
             return;
+        // The round produced no answer. `kind` is the whole difference between the
+        // two ways that happens — models that could not do it, versus a fault that
+        // stopped the round on its first attempt and that only a human can clear —
+        // and it exists to be turned into words the reader can act on. Same
+        // delivery either way; the diagnostic is logged, never shown.
         if (turn.status === "failed") {
             console.error("[handle-task] round failed", {
                 taskId: p.taskId,
                 round,
+                kind: turn.kind,
                 error: turn.error
             });
-            await deliver(p, step, agent, null, deps);
+            await deliver(p, step, agent, null, deps, {
+                kind: turn.kind,
+                detail: turn.error
+            });
             return;
         }
         if (turn.status === "replied") {
             await deliver(p, step, agent, turn.reply, deps);
             return;
         }
-        // Delegated: run this round's DAG, then loop and let the model decide again.
-        const executed = await executeDag(p, step, agent, round, push, deps);
+        // Delegated: run this round's Subtasks, then loop and let the model decide
+        // again.
+        const executed = await executeSubtasks(p, step, agent, round, push);
         if (executed === "canceled")
             return;
-        if (executed === "stuck") {
-            await deliver(p, step, agent, null, deps);
-            return;
-        }
     }
     // Unreachable: a `final` round is handed only `final_reply`, so it either
     // answers or fails, and both return above. Reaching here means a round
@@ -141,58 +205,49 @@ export async function runHandleTask(p, step, deps) {
     await deliver(p, step, agent, null, deps);
 }
 /**
- * Drive one round's Subtask DAG to termination, one wave at a time.
+ * Run every Subtask one round delegated, concurrently, to termination.
  *
- * Bounded by `maxSubtasks + 1` iterations rather than looping until `done`: a
- * wave that reports `ready` always retires at least one active node, so N
- * Subtasks need at most N waves of work plus one final scan to observe `done`.
- * Exhausting the budget means the DAG stopped making progress, which is the same
- * corruption `stuck` names.
+ * **One pass is the whole thing.** A round's Subtasks are independent of one
+ * another, so they are all runnable the moment they exist, and `runBranch` is
+ * contractually obliged to leave its row terminal — it resolves a deterministic
+ * failure itself and has a `fail:<id>` backstop once the retries are gone. So
+ * there is nothing left to re-scan afterwards, and no way for this to make no
+ * progress. Sequencing between units of work is the round loop's job.
  *
- * Every step name carries the round, because step names are durable cache keys:
- * two rounds of the same Task reusing `scan:0` would replay the first round's
- * cached answer into the second.
+ * Both step names carry the round, because step names are durable cache keys: two
+ * rounds of the same Task reusing `scan` would replay the first round's cached
+ * answer into the second.
  */
-async function executeDag(p, step, agent, round, push, deps) {
-    for (let wave = 0; wave <= deps.config.maxSubtasks; wave++) {
-        // One durable step per wave: `skipBlockedSubtasks` reports cancellation,
-        // propagates skips past any branch that just failed, and returns the
-        // refreshed DAG projection — one round trip, one consistent answer.
-        const scan = await step.do(`scan:${round}:${wave}`, async () => {
-            const result = await agent().skipBlockedSubtasks(p.taskId, round);
-            return result.canceled
-                ? { canceled: true, nodes: [] }
-                : { canceled: false, nodes: result.nodes };
+async function executeSubtasks(p, step, agent, round, push) {
+    // One durable step: `scanSubtasks` reports cancellation and returns the ids
+    // still owing an outcome — one round trip, one consistent answer. It writes
+    // nothing, so a replay that re-runs it costs only the read.
+    const scan = await step.do(`scan:${round}`, async () => {
+        const result = await agent().scanSubtasks(p.taskId, round);
+        return result.canceled
+            ? { canceled: true, ids: [] }
+            : { canceled: false, ids: result.ids };
+    });
+    if (scan.canceled) {
+        await step.do(`cancel:${round}`, async () => {
+            await agent().cancelPendingSubtasks(p.taskId);
         });
-        if (scan.canceled) {
-            await step.do(`cancel:${round}:${wave}`, async () => {
-                await agent().cancelPendingSubtasks(p.taskId);
-            });
-            return "canceled";
-        }
-        const decision = selectWave(scan.nodes);
-        if (decision.kind === "done")
-            return "done";
-        if (decision.kind === "stuck") {
-            console.error("[handle-task] subtask DAG made no progress", {
-                taskId: p.taskId,
-                round,
-                wave,
-                active: decision.active
-            });
-            return "stuck";
-        }
-        // Every dependency-ready node runs concurrently — the per-round Subtask
-        // maximum is the only fan-out bound. `runBranch` never rejects, so a single
-        // branch cannot fast-fail `Promise.all` and strand its siblings' durable
-        // results.
-        await Promise.all(decision.ids.map((id) => runBranch(p, step, agent, id, push)));
+        return "canceled";
     }
-    console.error("[handle-task] subtask DAG exceeded its wave budget", {
-        taskId: p.taskId,
-        round
-    });
-    return "stuck";
+    // Every Subtask runs concurrently — the per-round Subtask maximum is the only
+    // fan-out bound. `runBranch` never rejects, so a single branch cannot fast-fail
+    // `Promise.all` and strand its siblings' durable results.
+    //
+    // A cancellation arriving mid-pass is still honored, just not from here:
+    // `onTaskCanceled` aborts the live children *and* transitions every row still
+    // `pending` in the same sweep, and `executeSubtaskChunk` re-checks before
+    // publishing. That transition is what lets this pass end without a second
+    // scan. Without it, a branch whose RPC had not yet claimed its row when the
+    // cancellation landed would return terminal while leaving the row `pending`,
+    // and — since the next round's turn reports `canceled` and the workflow exits
+    // — nothing would resolve it before the 30-day cleanup.
+    await Promise.all(scan.ids.map((id) => runBranch(p, step, agent, id, push)));
+    return "done";
 }
 /**
  * Run one Subtask to termination as a sequence of durable **chunk** steps, and
@@ -202,7 +257,9 @@ async function executeDag(p, step, agent, round, push, deps) {
  * `done` on chunk 0 (step `execute:<id>`); a long recipe yields `done: false` and
  * the loop runs the next chunk (`execute:<id>:chunk:<n>`) until it terminates.
  * Each chunk is its own retryable step, and the child resumes from its
- * checkpoint — so no step approaches the platform timeout.
+ * checkpoint — so no step approaches the {@link CHUNK_STEP} timeout. `CHUNK_SOFT_MS`
+ * is what holds that true, and is sized against it rather than the other way
+ * round; a boundary here is not free, so it wants to be rare, not frequent.
  *
  * It resolves a deterministic branch failure into a `failed` row itself and
  * throws only on a transient fault (retry me) or a lifecycle bug. So a throw that
@@ -226,7 +283,7 @@ async function runBranch(p, step, agent, id, push) {
             // Chunk 0 keeps the plain `execute:<id>` step name so single-chunk branches
             // replay identically; later chunks append `:chunk:<n>`.
             const stepName = chunk === 0 ? `execute:${id}` : `execute:${id}:chunk:${chunk}`;
-            const done = await step.do(stepName, async () => {
+            const done = await step.do(stepName, CHUNK_STEP, async () => {
                 // The DO posts any progress itself; the step returns only the verdict.
                 const outcome = await agent().executeSubtaskChunk(id, chunk, push);
                 return outcome.done;
@@ -258,7 +315,13 @@ async function runBranch(p, step, agent, id, push) {
 /**
  * Persist the terminal Task, then notify the gateway. A null `reply` delivers a
  * `failed` Task with the policy's user-safe text; the diagnostic is already
- * logged.
+ * logged. Given a `failure`, the host's {@link HandleTaskDeps.failureCopy} may
+ * replace that text — same delivery, different words.
+ *
+ * `failure` is optional because only a round's own inference carries a kind. The
+ * other path here — a budget that ran out mid-delegation — is not a model failure
+ * and is deliberately not given a kind of its own until something needs to tell
+ * it apart.
  *
  * The Task is built **inside** the step and returned, so `notify` posts exactly
  * what was persisted: building it in the body would re-stamp `new Date()` on
@@ -271,11 +334,15 @@ async function runBranch(p, step, agent, id, push) {
  * `notify` — in which a `tasks/cancel` lands and the gateway still receives a
  * `completed` callback. Keying the notify on "did the write apply" closes it.
  */
-async function deliver(p, step, agent, reply, deps) {
+async function deliver(p, step, agent, reply, deps, failure) {
+    // Resolved outside the step body so a replay cannot take a different branch
+    // than the write it is replaying.
+    const failedText = (failure && deps.failureCopy?.(failure.kind, failure.detail)) ||
+        deps.policy.copy.taskFailed;
     const task = await step.do("complete", async () => {
         const terminal = reply !== null
             ? buildCompletedTask(p.taskId, p.contextId, reply)
-            : buildFailedTask(p.taskId, p.contextId, deps.policy.copy.taskFailed);
+            : buildFailedTask(p.taskId, p.contextId, failedText);
         return (await agent().saveTask(terminal)) ? terminal : null;
     });
     if (!task)

package/dist/runtime/index.d.ts

@@ -59,8 +59,10 @@ export interface AgentRuntime {
     /** Tools the installed plugins offer the *main* agent, merged. */
     mainAgentTools(ctx: MainAgentToolContext): Promise<ToolSet>;
     /**
-     * Every plugin's `capability` block, for the main agent's soul. Returns `""`
-     * when none declares one, so a call site can append unconditionally.
+     * The capability blocks for the main agent's soul, in plugin declaration
+     * order: each plugin's own {@link AgentPlugin.capability} and the one on its
+     * {@link AgentPlugin.subtaskType}, if it declares either. Returns `""` when
+     * none does, so a call site can append unconditionally.
      */
     renderCapabilities(): string;
     /**

package/dist/runtime/index.js

@@ -109,8 +109,14 @@ export function createAgentRuntime(options) {
         renderCapabilities() {
             const blocks = [];
             for (const plugin of plugins) {
+                // Both blocks a plugin may declare, emitted adjacently: a plugin that
+                // declares a subtask type puts its capability on the *type*, and one
+                // that only offers main-agent tools puts it on the plugin. Declaring
+                // both is legal and means the model reads both.
                 if (plugin.capability)
                     blocks.push(plugin.capability);
+                if (plugin.subtaskType?.capability)
+                    blocks.push(plugin.subtaskType.capability);
             }
             return blocks.join("\n\n");
         },

package/dist/subagent/fingerprint.d.ts

@@ -11,8 +11,8 @@ export declare const FINGERPRINT_VERSION = 1;
  * Canonical JSON of the fields that define an execution's identity, rebuilt as
  * literals in fixed key order so `JSON.stringify` is deterministic (object
  * insertion order). Array order is semantic and preserved: the parent builds
- * references and dependency results from ordinal-ordered rows, so a retry of the
- * same execution is byte-identical.
+ * references from ordinal-ordered rows, so a retry of the same execution is
+ * byte-identical.
  *
  * **Limits are canonicalized as *declared*, not as merged.** The predecessor
  * merged them against the house baseline first, on the reasoning that `{}` and

package/dist/subagent/fingerprint.js

@@ -10,8 +10,8 @@ export const FINGERPRINT_VERSION = 1;
  * Canonical JSON of the fields that define an execution's identity, rebuilt as
  * literals in fixed key order so `JSON.stringify` is deterministic (object
  * insertion order). Array order is semantic and preserved: the parent builds
- * references and dependency results from ordinal-ordered rows, so a retry of the
- * same execution is byte-identical.
+ * references from ordinal-ordered rows, so a retry of the same execution is
+ * byte-identical.
  *
  * **Limits are canonicalized as *declared*, not as merged.** The predecessor
  * merged them against the house baseline first, on the reasoning that `{}` and
@@ -36,13 +36,12 @@ export function canonicalRequest(request) {
         recipe: {
             key: request.recipe.key,
             version: request.recipe.version,
-            // No model ids. They used to be hashed because a recipe declared them;
-            // it no longer can, and their absence here is the same trade this file
-            // already makes for `limits`: the host's own configuration stays out of
-            // the fingerprint, so changing it does not invalidate every checkpoint at
-            // once and restart every in-flight run from turn zero with its budget
-            // already spent. A run that resumes on a newly configured model resumes
-            // from conversation state, which is model-independent.
+            // No model ids. Their absence is the same trade this file already makes
+            // for `limits`: the host's own configuration stays out of the fingerprint,
+            // so changing it does not invalidate every checkpoint at once and restart
+            // every in-flight run from turn zero with its budget already spent. A run
+            // that resumes on a newly configured model resumes from conversation
+            // state, which is model-independent.
             soul: request.recipe.soul,
             toolFamilies: request.recipe.toolFamilies,
             enabled: request.recipe.enabled,
@@ -55,14 +54,6 @@ export function canonicalRequest(request) {
             role: ref.role,
             text: ref.text
         })),
-        dependencyResults: request.dependencyResults.map((dep) => ({
-            subtaskId: dep.subtaskId,
-            type: dep.type,
-            resultParts: dep.resultParts.map((part) => ({
-                kind: part.kind,
-                text: part.text
-            }))
-        })),
         // Params ARE identity: the same prompt against a different external resource
         // is different work, and must not replay a cached result. Key order is fixed
         // by sorting, so an equivalent params object always canonicalizes identically.

package/dist/subagent/index.d.ts

@@ -25,6 +25,8 @@ export interface SubagentRuntime {
     toolOutputWindow: number;
     /** `CoreConfig.model.maxOutputTokens`. */
     maxOutputTokens: number;
+    /** `CoreConfig.model.maxRetries`. */
+    maxRetries: number;
     /**
      * Build the durable file store over this facet's own SQLite.
      *
@@ -43,14 +45,14 @@ export interface SubagentRuntime {
  * execution — and a Workflow retry after the parent's cleanup will succeed.
  */
 export declare const FINGERPRINT_MISMATCH = "recipe-subagent: request fingerprint mismatch";
-/** Deterministic managed-child name for one Subtask execution (shared with C3). */
+/** Deterministic managed-child name for one Subtask execution. */
 export declare function subagentName(taskId: string, subtaskId: SubtaskId): string;
 /**
  * `RecipeSubagent` — the isolated, stateless managed child that executes one
  * Subtask under a resolved Recipe. Created as an Agents SDK sub-agent (facet)
- * beneath the caller's `ReactiveAgent`, so it needs no wrangler Durable Object
- * binding and no `new_sqlite_classes` entry; it must only be exported from the
- * worker entry (`src/index.ts`) so `ctx.exports` can resolve it by class name.
+ * beneath the calling agent, so it needs no wrangler Durable Object binding and
+ * no `new_sqlite_classes` entry; it must only be exported from the consuming
+ * Worker's entry so `ctx.exports` can resolve it by class name.
  *
  * It never constructs a Session, never reads parent history beyond the
  * references supplied on its request, never reaches durable memory, and never

package/dist/subagent/index.js

@@ -16,7 +16,7 @@ import { runResumableChunk } from "./run.js";
  * execution — and a Workflow retry after the parent's cleanup will succeed.
  */
 export const FINGERPRINT_MISMATCH = "recipe-subagent: request fingerprint mismatch";
-/** Deterministic managed-child name for one Subtask execution (shared with C3). */
+/** Deterministic managed-child name for one Subtask execution. */
 export function subagentName(taskId, subtaskId) {
     return `subtask:${taskId}:${subtaskId}`;
 }
@@ -38,9 +38,9 @@ const cachedResultSchema = z.discriminatedUnion("status", [
 /**
  * `RecipeSubagent` — the isolated, stateless managed child that executes one
  * Subtask under a resolved Recipe. Created as an Agents SDK sub-agent (facet)
- * beneath the caller's `ReactiveAgent`, so it needs no wrangler Durable Object
- * binding and no `new_sqlite_classes` entry; it must only be exported from the
- * worker entry (`src/index.ts`) so `ctx.exports` can resolve it by class name.
+ * beneath the calling agent, so it needs no wrangler Durable Object binding and
+ * no `new_sqlite_classes` entry; it must only be exported from the consuming
+ * Worker's entry so `ctx.exports` can resolve it by class name.
  *
  * It never constructs a Session, never reads parent history beyond the
  * references supplied on its request, never reaches durable memory, and never
@@ -158,8 +158,9 @@ export class RecipeSubagentBase extends Agent {
             });
         }
         // Re-check the type's param contract, the same defensive posture as
-        // `validateRecipe`: a play with no scorecard cannot succeed, and failing
-        // here costs no model call and gives the parent a real diagnostic.
+        // `validateRecipe`: a subtask missing a param its type requires cannot
+        // succeed, and failing here costs no model call and gives the parent a real
+        // diagnostic.
         try {
             rt.types.validateParams(request.type, request.params);
         }
@@ -213,6 +214,7 @@ export class RecipeSubagentBase extends Agent {
                 toolOutputWindow: rt.toolOutputWindow,
                 reportMetrics: recipe.reportMetrics,
                 maxOutputTokens: rt.maxOutputTokens,
+                maxRetries: rt.maxRetries,
                 now: () => Date.now(),
                 progress,
                 checkpoint: (s) => this.saveRunState(fingerprint, s),

package/dist/subagent/prompt.d.ts

@@ -2,11 +2,10 @@ import type { RecipeExecutionRequest } from "../subtasks/types.js";
 import type { ValidatedRecipe } from "../contract/recipe.js";
 /**
  * Deterministic rendering of one subagent invocation. Pure — no model, no
- * Session, no lookups: everything comes verbatim from the request. The four
+ * Session, no lookups: everything comes verbatim from the request. The three
  * sections stay clearly separated and labeled so tests (and the model) can tell
- * them apart: the execution's budget, the main-agent instruction, the verbatim
- * conversation reference snapshots, and generated dependency output — which is
- * explicitly marked as generated and never presented as conversation evidence.
+ * them apart: the execution's budget, the main-agent instruction, and the
+ * verbatim conversation reference snapshots.
  */
 /**
  * A request whose Recipe has been through `validateRecipe`, so its limits are
@@ -21,7 +20,7 @@ export type RenderableExecution = RecipeExecutionRequest & {
 export interface RenderedInvocation {
     /** The validated Recipe soul, verbatim — the invocation's system prompt. */
     system: string;
-    /** The sectioned user message (instruction, references, dependency results). */
+    /** The sectioned user message (budget, instruction, references). */
     prompt: string;
 }
 /**

package/dist/subagent/prompt.js

@@ -33,13 +33,5 @@ export function renderSubagentPrompt(request) {
         sections.push("# Conversation references (verbatim snapshots of the caller's conversation)\n" +
             refs.join("\n"));
     }
-    if (request.dependencyResults.length > 0) {
-        const deps = request.dependencyResults.map((dep) => {
-            const text = dep.resultParts.map((part) => part.text).join("\n");
-            return `[dependency ${dep.subtaskId}] (${dep.type}): ${text}`;
-        });
-        sections.push("# Dependency results (generated output from prerequisite subtasks — not conversation evidence)\n" +
-            deps.join("\n"));
-    }
     return { system: request.recipe.soul, prompt: sections.join("\n\n") };
 }

package/dist/subagent/run.d.ts

@@ -48,7 +48,7 @@ export interface ChunkRunDeps {
     /**
      * How many of the most recent assistant turns keep their tool results in full;
      * older ones are stubbed by {@link elideToolOutputs}. A mechanic of the window
-     * rather than a property of a domain — see `TOOL_OUTPUT_WINDOW` in `config.ts`.
+     * rather than a property of a domain — see `CoreConfig.toolOutputWindow`.
      */
     toolOutputWindow: number;
     reportMetrics: boolean;
@@ -58,6 +58,11 @@ export interface ChunkRunDeps {
      * hardcoded one.
      */
     maxOutputTokens: number;
+    /**
+     * `CoreConfig.model.maxRetries` — retries on *this* model, honouring the
+     * provider's `retry-after`, before the slot hands over to the fallback.
+     */
+    maxRetries: number;
     now: () => number;
     /** Shared sink the tool families push progress events into (fresh per chunk). */
     progress: ProgressEvent[];
@@ -137,6 +142,8 @@ export interface RecipeRunDeps {
     toolOutputWindow: number;
     /** `CoreConfig.model.maxOutputTokens`. */
     maxOutputTokens: number;
+    /** `CoreConfig.model.maxRetries`. */
+    maxRetries: number;
 }
 /**
  * Run one recipe execution to a terminal result, driving {@link runResumableChunk}