@loopingai/core 0.5.0 → 0.6.0

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.
@@ -99,4 +90,3 @@ export async function fingerprintRequest(request) {
         .map((b) => b.toString(16).padStart(2, "0"))
         .join("");
 }
-//# sourceMappingURL=fingerprint.js.map

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
@@ -144,4 +146,3 @@ export declare abstract class RecipeSubagentBase<TEnv extends Cloudflare.Env = C
     /** Persist the rolling run state (called after every model turn). */
     private saveRunState;
 }
-//# sourceMappingURL=index.d.ts.map

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),
@@ -296,4 +298,3 @@ function mismatch(phase) {
         "different request; the parent must delete a stale child before starting a " +
         "genuinely new execution");
 }
-//# sourceMappingURL=index.js.map

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;
 }
 /**
@@ -31,4 +30,3 @@ export interface RenderedInvocation {
  * content are omitted entirely.
  */
 export declare function renderSubagentPrompt(request: RenderableExecution): RenderedInvocation;
-//# sourceMappingURL=prompt.d.ts.map

package/dist/subagent/prompt.js

@@ -33,14 +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") };
 }
-//# sourceMappingURL=prompt.js.map

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}
@@ -148,4 +155,3 @@ export interface RecipeRunDeps {
  * Throws only on a transient platform fault (as {@link runResumableChunk} does).
  */
 export declare function runRecipeExecution(request: RecipeExecutionRequest, deps: RecipeRunDeps): Promise<RecipeExecutionResult>;
-//# sourceMappingURL=run.d.ts.map

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: () => { }
@@ -488,4 +538,3 @@ export async function runRecipeExecution(request, deps) {
         modelId: null
     };
 }
-//# sourceMappingURL=run.js.map

package/dist/subagent/workspace.d.ts

@@ -83,4 +83,3 @@ export declare class WorkspaceLimitError extends Error {
  * fill storage.
  */
 export declare function makeWorkspaceHandle(ws: WorkspaceBacking): WorkspaceHandle;
-//# sourceMappingURL=workspace.d.ts.map

package/dist/subagent/workspace.js

@@ -125,4 +125,3 @@ export function makeWorkspaceHandle(ws) {
         }
     };
 }
-//# sourceMappingURL=workspace.js.map

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.
  *
@@ -38,4 +38,3 @@ export interface ReferenceCatalogEntry extends SubtaskReference {
  * flight.
  */
 export declare function isCatalogEligible(message: SessionMessage): boolean;
-//# sourceMappingURL=catalog.d.ts.map

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.
  *
@@ -34,4 +34,3 @@ export function isCatalogEligible(message) {
         return false;
     return sessionText(message).trim().length > 0;
 }
-//# sourceMappingURL=catalog.js.map

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,12 +75,11 @@ 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;
     drafts: SubtaskDraft[];
 };
-//# sourceMappingURL=decomposition.d.ts.map

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,17 +143,14 @@ 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
         };
     });
     return { reply: proposal.reply.trim(), drafts };
 }
-//# sourceMappingURL=decomposition.js.map