@loopingai/core 0.5.1 → 0.6.0

package/dist/contract/plugin.js

@@ -36,3 +36,79 @@ export function definePlugin(plugin) {
         contractVersion: plugin.contractVersion ?? PLUGIN_CONTRACT_VERSION
     };
 }
+/**
+ * A plugin whose tool families stay registered but whose main-agent surface is
+ * narrowed, or removed.
+ *
+ * ## Why this has to exist
+ *
+ * `validateRecipe` runs on the **parent** and drops any tool family no installed
+ * plugin registered. So an agent that wants "my subagents can run a shell, I
+ * cannot" has a problem: uninstalling the sandbox plugin from the parent also
+ * deletes `sandbox` from every recipe the parent validates, and the subagents
+ * silently lose it. The parent has to install the plugin and decline its tools,
+ * which is exactly what this expresses.
+ *
+ * ```ts
+ * // The parent registers the family, and gets three read-only tools from it.
+ * restrictMainAgentTools(sandbox(cfg), {
+ *   allow: ["sb_read", "sb_ls", "sb_exists"],
+ *   capability: "You can read the checkout, not change it."
+ * })
+ * ```
+ *
+ * ## What passes through untouched
+ *
+ * Everything else: `toolFamilies`, `subtaskType`, `resolveRuntime`, `store`,
+ * `requires`, and the lifecycle hooks. In particular `requires` must survive, or
+ * a parent that stops offering `sb_exec` also stops asserting that the `Sandbox`
+ * binding exists — and the failure moves from DO start to a subagent's first
+ * tool call.
+ *
+ * ## Why a missing name logs instead of throwing
+ *
+ * `mainAgentTools` is async and called per turn, so a throw here lands inside a
+ * request someone is waiting on — a bad trade for what is always a typo. The
+ * error names the plugin and the tool so it is greppable, and the honest place
+ * to catch it is a test over the assembled surface, which is cheap to write and
+ * fails the build instead.
+ */
+export function restrictMainAgentTools(plugin, options) {
+    const allow = new Set(options.allow);
+    // Spread first so anything added to `AgentPlugin` later keeps flowing through
+    // without an edit here — the failure mode of an explicit field list is a
+    // capability that silently stops reaching the parent.
+    const restricted = { ...plugin };
+    if (allow.size === 0) {
+        delete restricted.mainAgentTools;
+    }
+    else {
+        // Installed even when the plugin offers no `mainAgentTools` at all, rather
+        // than left `undefined`. A plugin with no main-agent surface is not the
+        // "nothing to narrow" case it looks like — it is an allowlist naming tools
+        // that do not exist, which is precisely the typo this helper promises to
+        // report, and the one shape of it that is hardest to spot: a whole surface
+        // removed or renamed disappears without a word. The assembled tool set is
+        // identical either way, because `runtime.mainAgentTools` merges each
+        // plugin's result and an empty one contributes nothing.
+        const inner = plugin.mainAgentTools;
+        restricted.mainAgentTools = async (ctx) => {
+            const all = inner ? await inner(ctx) : {};
+            const kept = {};
+            for (const name of allow) {
+                if (name in all)
+                    kept[name] = all[name];
+                else
+                    console.error(`[plugin] "${plugin.key}" offers no main-agent tool "${name}" — ` +
+                        "the allowlist names a tool that does not exist, so the main " +
+                        "agent is quietly missing it. Check for a rename.");
+            }
+            return kept;
+        };
+    }
+    if (options.capability === undefined)
+        delete restricted.capability;
+    else
+        restricted.capability = options.capability;
+    return restricted;
+}

package/dist/contract/recipe.d.ts

@@ -48,12 +48,10 @@ export interface DelegationNames {
  *
  * Deliberately *not* here: how a run is sliced into durable chunks. That is a
  * Workers step-timeout constraint, it is identical for every Recipe, and it lives
- * in {@link file://../platform.ts}. It used to include a `turnsPerChunk`, on the
- * theory that a turn count could keep a step under the timeout — it cannot,
- * because nothing predicts how long a turn takes, and the resulting arithmetic was
- * wrong by 2-3× in practice.
- */
-/**
+ * in {@link file://../platform.ts}. A turn count cannot do that job — nothing
+ * predicts how long a turn takes — so no per-chunk turn budget belongs on a
+ * Recipe.
+ *
  * Structurally identical to {@link AgentLimits} — a budget is a budget at both
  * levels, and keeping one shape means `resolveLimits` merges a recipe's
  * declaration straight over the host's baseline with no translation. Aliased
@@ -81,8 +79,10 @@ export interface ResolvedRecipe {
     toolFamilies: string[];
     enabled: boolean;
     /**
-     * Only the budget fields this Recipe overrides; the rest come from
-     * `SUBAGENT_LIMITS`. `{}` means "the baseline", which is what most Recipes want.
+     * Only the budget fields this Recipe overrides; the rest come from the host's
+     * `CoreConfig.subagentLimits`, which reaches validation as
+     * `RecipePolicy.baselineLimits`. `{}` means "the baseline", which is what most
+     * Recipes want.
      */
     limits: Partial<RecipeLimits>;
     /**
@@ -107,8 +107,8 @@ export interface ValidatedRecipe extends ResolvedRecipe {
      *
      * These exist only here, never on {@link ResolvedRecipe}, and that asymmetry
      * is the design: a recipe cannot state a model, so the only way to hold one is
-     * to have been through {@link validateRecipe}, which copies the host's. Recipe
-     * data has no path to influence them.
+     * to have been through `validateRecipe`, which copies the host's. Recipe data
+     * has no path to influence them.
      *
      * Guaranteed non-empty and guaranteed distinct, because `resolveConfig`
      * refuses a config that is either — so the fallback is always a genuinely
@@ -145,9 +145,9 @@ export interface SubtaskTypeSpec {
      *
      * A `z.object`, not an opaque `z.ZodType`, and that is load-bearing: the agent
      * reads `.shape` back to build the `params` field of the delegate tool's schema
-     * (see `subtaskParamProperties`). Declaring a param the model is never shown is
-     * the failure this shape exists to prevent — describe each key with
-     * `.describe()`, because that text is what the model reads.
+     * (see `SubtaskTypeRegistry.paramProperties`). Declaring a param the model is
+     * never shown is the failure this shape exists to prevent — describe each key
+     * with `.describe()`, because that text is what the model reads.
      */
     params: SubtaskParamsSchema | null;
     /** How the model is told to obtain each param, appended to the description. */
@@ -159,10 +159,9 @@ export interface SubtaskTypeSpec {
      *
      * These two prompt fields exist to hold one rule: **everything the main agent
      * is told about a domain is declared here, never written inside the runtime.**
-     * Both of them started as hand-written blocks in `agent/prompt.ts` and
-     * `agent/turn.ts`; the main agent read the same advice twice per round from two
-     * files that had already drifted into contradicting each other on how many
-     * subtasks a multi-game request gets.
+     * Advice written in the runtime instead has to be repeated per call site, and
+     * the copies drift — into telling the main agent two contradictory things
+     * about the same domain, twice per round.
      */
     capability?: string;
     /**

package/dist/db/db.d.ts

@@ -130,7 +130,6 @@ export declare class AgentDB {
         }): boolean;
         complete(id: import("../subtasks/types.js").SubtaskId, resultParts: import("../subtasks/types.js").SubtaskResultPart[]): boolean;
         fail(id: import("../subtasks/types.js").SubtaskId, error: string): boolean;
-        skip(id: import("../subtasks/types.js").SubtaskId): boolean;
         cancelRunning(id: import("../subtasks/types.js").SubtaskId): boolean;
         cancelPending(taskId: string): number;
         cleanup(): void;

package/dist/db/migrations/index.js

@@ -6,6 +6,12 @@ const dbMigrations = {
                 when: 1785537420937,
                 tag: "0000_init",
                 breakpoints: true
+            },
+            {
+                idx: 1,
+                when: 1786871925215,
+                tag: "0001_drop_depends_on",
+                breakpoints: true
             }
         ]
     },
@@ -47,7 +53,8 @@ CREATE TABLE \`subtasks\` (
 CREATE UNIQUE INDEX \`idx_subtasks_task_ordinal\` ON \`subtasks\` (\`task_id\`,\`ordinal\`);--> statement-breakpoint
 CREATE INDEX \`idx_subtasks_task_round\` ON \`subtasks\` (\`task_id\`,\`round\`);--> statement-breakpoint
 CREATE INDEX \`idx_subtasks_status\` ON \`subtasks\` (\`status\`);--> statement-breakpoint
-CREATE INDEX \`idx_subtasks_created_at\` ON \`subtasks\` (\`created_at\`);`
+CREATE INDEX \`idx_subtasks_created_at\` ON \`subtasks\` (\`created_at\`);`,
+        m0001: `ALTER TABLE \`subtasks\` DROP COLUMN \`depends_on_json\`;`
     }
 };
 export default dbMigrations;

package/dist/db/models/subtasks.d.ts

@@ -15,28 +15,22 @@ export interface SubtaskModelOptions {
  * durable-sqlite is synchronous; the multi-statement `createDecomposition` runs
  * inside an explicit `db.transaction` (drizzle maps it to
  * `storage.transactionSync`), so a mid-create failure rolls back every statement
- * instead of leaving a partial DAG. Guarded transitions filter on the expected
+ * instead of leaving a partial decomposition. Guarded transitions filter on the expected
  * current `status`, so a disallowed transition matches no row and is a no-op.
  */
 export declare function makeSubtasks(db: DB, opts: SubtaskModelOptions): {
     /**
-     * Create one **round's** decomposition atomically: the entire
-     * check-validate-insert sequence runs in one synchronous `db.transaction`, so
-     * a failure anywhere rolls back every statement — no truncated subtask set, no
-     * nodes left with unwritten dependency edges. Idempotent on
-     * `(taskId, round)`: if this round already has Subtasks, returns them
-     * unchanged (a Workflow-step retry must not duplicate work); the unique
-     * `(task_id, ordinal)` index is the schema-level backstop. Enforces the 1..8
-     * per-round bound, unique local keys, and resolvable non-self dependency
-     * edges, then resolves draft-local dependency keys to the SQLite-assigned
-     * {@link SubtaskId}s. Full cycle/edge DAG validation lives in the turn
-     * operation; this is the storage guard.
+     * Create one **round's** decomposition atomically: the whole check-and-insert
+     * sequence runs in one synchronous `db.transaction`, so a failure anywhere
+     * rolls back every statement rather than leaving a truncated subtask set.
+     * Idempotent on `(taskId, round)`: if this round already has Subtasks,
+     * returns them unchanged (a Workflow-step retry must not duplicate work); the
+     * unique `(task_id, ordinal)` index is the schema-level backstop. Enforces the
+     * 1..8 per-round bound as the durable guard.
      *
      * `ordinal` continues across rounds (it is the Task-wide position, and what
      * the unique index is built on), so a later round's rows sort after the
-     * earlier ones in {@link list}. Dependency edges never cross a round: each
-     * round's DAG is self-contained, and the drafts handed here only carry keys
-     * from their own round.
+     * earlier ones in {@link list}.
      */
     createDecomposition(taskId: string, round: number, drafts: SubtaskDraft[]): Subtask[];
     /** Load one Subtask by id. */
@@ -44,9 +38,10 @@ export declare function makeSubtasks(db: DB, opts: SubtaskModelOptions): {
     /** List every round's Subtasks for a Task, in ordinal order. */
     list(taskId: string): Subtask[];
     /**
-     * List one round's Subtasks, in ordinal order — the scheduler's view. Phase 2
-     * drives a single round's DAG at a time, so it must not see a sibling round's
-     * rows; composition, by contrast, reads {@link list} across all rounds.
+     * List one round's Subtasks, in ordinal order — what the Workflow's `scan`
+     * projects. It executes a single round at a time, so it must not see a
+     * sibling round's rows; a later round, by contrast, reads {@link list}
+     * across all rounds to reunite each `delegate` call with its results.
      */
     listRound(taskId: string, round: number): Subtask[];
     /**
@@ -70,17 +65,14 @@ export declare function makeSubtasks(db: DB, opts: SubtaskModelOptions): {
      * Both sides are reachable and both must land. A child's failed result arrives
      * on a `running` row. The Workflow's last resort — `failSubtask`, once
      * `execute:<id>` has exhausted every retry — can arrive on either:
-     * `executeSubtask` may throw before its `pending -> running` claim (a
-     * dependency-invariant fault) or after it (a transient child fault). Leaving
-     * either behind strands the row: a `pending` node re-enters the next wave
-     * forever, and a `running` node blocks its dependents, which {@link skip} only
-     * propagates past *failed* prerequisites.
+     * `executeSubtask` may throw before its `pending -> running` claim (an
+     * unresolvable recipe) or after it (a transient child fault). Leaving either
+     * behind strands the row in a non-terminal state that nobody is coming back
+     * to resolve.
      *
      * Returns false once the row is terminal — a late loser to the real result.
      */
     fail(id: SubtaskId, error: string): boolean;
-    /** Skip a Subtask blocked by a failed/skipped dependency: guarded `pending -> skipped`. */
-    skip(id: SubtaskId): boolean;
     /**
      * Discard a late result after parent cancellation: guarded
      * `running -> canceled`. The parent calls this when a child returned a
@@ -94,6 +86,13 @@ export declare function makeSubtasks(db: DB, opts: SubtaskModelOptions): {
      * Running Subtasks are left alone here — the parent transitions those with
      * {@link cancelRunning} once their in-flight result comes back and is
      * discarded. Returns the number canceled.
+     *
+     * Keyed on the Task rather than one id, so this is the one guarded
+     * transition that cannot go through {@link transition} and sets its own
+     * timestamps. `completedAt` is part of that and not optional: every other
+     * terminal write records it, and a terminal row without one reads as still
+     * in flight to anything measuring how long a Subtask took or when a Task
+     * actually stopped.
      */
     cancelPending(taskId: string): number;
     /** Delete Subtasks older than 30 days (called by the weekly maintenance cron). */

package/dist/db/models/subtasks.js

@@ -11,7 +11,6 @@ const resultPartSchema = z.object({
 });
 const referencesSchema = z.array(referenceSchema);
 const resultPartsSchema = z.array(resultPartSchema);
-const dependsOnSchema = z.array(z.number().int());
 const paramsSchema = z.record(z.string(), z.string());
 /**
  * Query methods for the `subtasks` table (durable decomposed units of work).
@@ -20,7 +19,7 @@ const paramsSchema = z.record(z.string(), z.string());
  * durable-sqlite is synchronous; the multi-statement `createDecomposition` runs
  * inside an explicit `db.transaction` (drizzle maps it to
  * `storage.transactionSync`), so a mid-create failure rolls back every statement
- * instead of leaving a partial DAG. Guarded transitions filter on the expected
+ * instead of leaving a partial decomposition. Guarded transitions filter on the expected
  * current `status`, so a disallowed transition matches no row and is a no-op.
  */
 export function makeSubtasks(db, opts) {
@@ -34,7 +33,6 @@ export function makeSubtasks(db, opts) {
         recipeVersion: row.recipeVersion,
         prompt: row.prompt,
         references: referencesSchema.parse(JSON.parse(row.referencesJson)),
-        dependsOn: dependsOnSchema.parse(JSON.parse(row.dependsOnJson)),
         params: paramsSchema.parse(JSON.parse(row.paramsJson)),
         status: row.status,
         resultParts: row.resultPartsJson === null
@@ -74,23 +72,17 @@ export function makeSubtasks(db, opts) {
     };
     return {
         /**
-         * Create one **round's** decomposition atomically: the entire
-         * check-validate-insert sequence runs in one synchronous `db.transaction`, so
-         * a failure anywhere rolls back every statement — no truncated subtask set, no
-         * nodes left with unwritten dependency edges. Idempotent on
-         * `(taskId, round)`: if this round already has Subtasks, returns them
-         * unchanged (a Workflow-step retry must not duplicate work); the unique
-         * `(task_id, ordinal)` index is the schema-level backstop. Enforces the 1..8
-         * per-round bound, unique local keys, and resolvable non-self dependency
-         * edges, then resolves draft-local dependency keys to the SQLite-assigned
-         * {@link SubtaskId}s. Full cycle/edge DAG validation lives in the turn
-         * operation; this is the storage guard.
+         * Create one **round's** decomposition atomically: the whole check-and-insert
+         * sequence runs in one synchronous `db.transaction`, so a failure anywhere
+         * rolls back every statement rather than leaving a truncated subtask set.
+         * Idempotent on `(taskId, round)`: if this round already has Subtasks,
+         * returns them unchanged (a Workflow-step retry must not duplicate work); the
+         * unique `(task_id, ordinal)` index is the schema-level backstop. Enforces the
+         * 1..8 per-round bound as the durable guard.
          *
          * `ordinal` continues across rounds (it is the Task-wide position, and what
          * the unique index is built on), so a later round's rows sort after the
-         * earlier ones in {@link list}. Dependency edges never cross a round: each
-         * round's DAG is self-contained, and the drafts handed here only carry keys
-         * from their own round.
+         * earlier ones in {@link list}.
          */
         createDecomposition(taskId, round, drafts) {
             return db.transaction(() => {
@@ -100,38 +92,14 @@ export function makeSubtasks(db, opts) {
                 if (drafts.length < 1 || drafts.length > opts.maxSubtasks) {
                     throw new Error(`decomposition must have 1..${opts.maxSubtasks} subtasks, got ${drafts.length}`);
                 }
-                // Register every local key first, rejecting duplicates. This is its own
-                // pass because the dependency check below reads the complete key set: an
-                // edge may point forward to a draft defined later, so every key must be
-                // known before any edge is validated.
-                const keys = new Set();
-                for (const d of drafts) {
-                    if (keys.has(d.localKey)) {
-                        throw new Error(`duplicate draft local key: ${d.localKey}`);
-                    }
-                    keys.add(d.localKey);
-                }
-                for (const d of drafts) {
-                    for (const dep of d.dependsOn) {
-                        // A subtask cannot depend on itself.
-                        if (dep === d.localKey) {
-                            throw new Error(`subtask ${d.localKey} depends on itself`);
-                        }
-                        // Every edge must resolve to a key in this decomposition.
-                        if (!keys.has(dep)) {
-                            throw new Error(`subtask ${d.localKey} depends on unknown key: ${dep}`);
-                        }
-                    }
-                    // References must match the persisted shape before we serialize them.
+                // References must match the persisted shape before we serialize them.
+                for (const d of drafts)
                     referencesSchema.parse(d.references);
-                }
                 const now = Date.now();
-                const keyToId = new Map();
-                // Pass 1: insert nodes (deps empty for now) to assign ids. Ordinals
-                // continue above every earlier round's rows — from the current maximum,
-                // not a row count, so a gap left by {@link cleanup} deleting part of a
-                // Task cannot hand a later round an ordinal that is already taken. Both
-                // read the `(task_id, ordinal)` index; only this one stays monotonic.
+                // Ordinals continue above every earlier round's rows — from the current
+                // maximum, not a row count, so a gap left by {@link cleanup} deleting part
+                // of a Task cannot hand a later round an ordinal that is already taken.
+                // Both read the `(task_id, ordinal)` index; only this one stays monotonic.
                 const highest = db
                     .select({ max: max(subtasks.ordinal) })
                     .from(subtasks)
@@ -139,8 +107,7 @@ export function makeSubtasks(db, opts) {
                     .get()?.max ?? null;
                 const firstOrdinal = highest === null ? 0 : highest + 1;
                 drafts.forEach((d, offset) => {
-                    const { id } = db
-                        .insert(subtasks)
+                    db.insert(subtasks)
                         .values({
                         taskId,
                         round,
@@ -150,7 +117,6 @@ export function makeSubtasks(db, opts) {
                         recipeVersion: null,
                         prompt: d.prompt,
                         referencesJson: JSON.stringify(d.references),
-                        dependsOnJson: "[]",
                         paramsJson: JSON.stringify(d.params ?? {}),
                         status: "pending",
                         resultPartsJson: null,
@@ -159,20 +125,8 @@ export function makeSubtasks(db, opts) {
                         updatedAt: now,
                         completedAt: null
                     })
-                        .returning({ id: subtasks.id })
-                        .get();
-                    keyToId.set(d.localKey, id);
-                });
-                // Pass 2: rewrite dependency edges to real ids.
-                for (const d of drafts) {
-                    if (d.dependsOn.length === 0)
-                        continue;
-                    const ids = d.dependsOn.map((k) => keyToId.get(k));
-                    db.update(subtasks)
-                        .set({ dependsOnJson: JSON.stringify(ids) })
-                        .where(eq(subtasks.id, keyToId.get(d.localKey)))
                         .run();
-                }
+                });
                 return listRound(taskId, round);
             });
         },
@@ -186,9 +140,10 @@ export function makeSubtasks(db, opts) {
             return list(taskId);
         },
         /**
-         * List one round's Subtasks, in ordinal order — the scheduler's view. Phase 2
-         * drives a single round's DAG at a time, so it must not see a sibling round's
-         * rows; composition, by contrast, reads {@link list} across all rounds.
+         * List one round's Subtasks, in ordinal order — what the Workflow's `scan`
+         * projects. It executes a single round at a time, so it must not see a
+         * sibling round's rows; a later round, by contrast, reads {@link list}
+         * across all rounds to reunite each `delegate` call with its results.
          */
         listRound(taskId, round) {
             return listRound(taskId, round);
@@ -227,11 +182,10 @@ export function makeSubtasks(db, opts) {
          * Both sides are reachable and both must land. A child's failed result arrives
          * on a `running` row. The Workflow's last resort — `failSubtask`, once
          * `execute:<id>` has exhausted every retry — can arrive on either:
-         * `executeSubtask` may throw before its `pending -> running` claim (a
-         * dependency-invariant fault) or after it (a transient child fault). Leaving
-         * either behind strands the row: a `pending` node re-enters the next wave
-         * forever, and a `running` node blocks its dependents, which {@link skip} only
-         * propagates past *failed* prerequisites.
+         * `executeSubtask` may throw before its `pending -> running` claim (an
+         * unresolvable recipe) or after it (a transient child fault). Leaving either
+         * behind strands the row in a non-terminal state that nobody is coming back
+         * to resolve.
          *
          * Returns false once the row is terminal — a late loser to the real result.
          */
@@ -242,10 +196,6 @@ export function makeSubtasks(db, opts) {
                 completedAt: Date.now()
             });
         },
-        /** Skip a Subtask blocked by a failed/skipped dependency: guarded `pending -> skipped`. */
-        skip(id) {
-            return transition(id, "pending", { status: "skipped" });
-        },
         /**
          * Discard a late result after parent cancellation: guarded
          * `running -> canceled`. The parent calls this when a child returned a
@@ -264,12 +214,19 @@ export function makeSubtasks(db, opts) {
          * Running Subtasks are left alone here — the parent transitions those with
          * {@link cancelRunning} once their in-flight result comes back and is
          * discarded. Returns the number canceled.
+         *
+         * Keyed on the Task rather than one id, so this is the one guarded
+         * transition that cannot go through {@link transition} and sets its own
+         * timestamps. `completedAt` is part of that and not optional: every other
+         * terminal write records it, and a terminal row without one reads as still
+         * in flight to anything measuring how long a Subtask took or when a Task
+         * actually stopped.
          */
         cancelPending(taskId) {
             const now = Date.now();
             const canceled = db
                 .update(subtasks)
-                .set({ status: "canceled", updatedAt: now })
+                .set({ status: "canceled", updatedAt: now, completedAt: now })
                 .where(and(eq(subtasks.taskId, taskId), eq(subtasks.status, "pending")))
                 .returning({ id: subtasks.id })
                 .all();

package/dist/db/schema.d.ts

@@ -164,8 +164,8 @@ export declare const notifyTasks: import("drizzle-orm/sqlite-core").SQLiteTableW
  *
  * The integer primary key assigns a caller-local, monotonically increasing
  * `SubtaskId` (autoincrement, so ids are never reused after cleanup deletes
- * rows). References, dependency edges, and result parts are stored as JSON text
- * and parsed back into the `Subtask` contract by `models/subtasks.ts`.
+ * rows). References and result parts are stored as JSON text and parsed back
+ * into the `Subtask` contract by `models/subtasks.ts`.
  * `recipe_id`/`recipe_version` are null until execution starts, then record the
  * resolved recipe after the fact.
  */
@@ -336,25 +336,6 @@ export declare const subtasks: import("drizzle-orm/sqlite-core").SQLiteTableWith
         }, {}, {
             length: number | undefined;
         }>;
-        dependsOnJson: import("drizzle-orm/sqlite-core").SQLiteColumn<{
-            name: "depends_on_json";
-            tableName: "subtasks";
-            dataType: "string";
-            columnType: "SQLiteText";
-            data: string;
-            driverParam: string;
-            notNull: true;
-            hasDefault: false;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {
-            length: number | undefined;
-        }>;
         paramsJson: import("drizzle-orm/sqlite-core").SQLiteColumn<{
             name: "params_json";
             tableName: "subtasks";

package/dist/db/schema.js

@@ -51,8 +51,8 @@ export const notifyTasks = sqliteTable("notify_tasks", {
  *
  * The integer primary key assigns a caller-local, monotonically increasing
  * `SubtaskId` (autoincrement, so ids are never reused after cleanup deletes
- * rows). References, dependency edges, and result parts are stored as JSON text
- * and parsed back into the `Subtask` contract by `models/subtasks.ts`.
+ * rows). References and result parts are stored as JSON text and parsed back
+ * into the `Subtask` contract by `models/subtasks.ts`.
  * `recipe_id`/`recipe_version` are null until execution starts, then record the
  * resolved recipe after the fact.
  */
@@ -71,8 +71,6 @@ export const subtasks = sqliteTable("subtasks", {
     prompt: text("prompt").notNull(),
     /** JSON `SubtaskReference[]` — verbatim role+text snapshots from decomposition. */
     referencesJson: text("references_json").notNull(),
-    /** JSON `SubtaskId[]` — resolved dependency edges. */
-    dependsOnJson: text("depends_on_json").notNull(),
     /** JSON `SubtaskParams` — the type's required inputs, validated at delegation. */
     paramsJson: text("params_json").notNull().default("{}"),
     status: text("status").notNull(),

package/dist/host/agent.d.ts

@@ -2,7 +2,7 @@ import { Agent, type Schedule } from "agents";
 import { type Task } from "@a2a-js/sdk";
 import { type AgentRuntime } from "../runtime/index.js";
 import type { AgentPlugin } from "../contract/plugin.js";
-import { type CoreConfig, type CoreConfigOverrides } from "../config.js";
+import { type CoreConfig, type CoreConfigOverrides, type ModelConfig } from "../config.js";
 import type { A2ASecretsEnv, AiEnv } from "../env.js";
 import { AgentDB } from "../db/index.js";
 import type { GatewayIdentity } from "../a2a/verify.js";
@@ -10,7 +10,7 @@ import type { PlainTask } from "../a2a/task.js";
 import type { TaskListQuery } from "../a2a/agent-stub.js";
 import { type PushChannel, type TurnPushContext } from "../a2a/push.js";
 import { type SessionLike } from "../agent/session.js";
-import { type GatewayMetadata, type ModelPair, type ModelRuntime } from "../agent/model.js";
+import type { GatewayMetadata, ModelPair, ModelRuntime } from "../agent/model.js";
 import type { PluginHost } from "./plugin-host.js";
 /**
  * The Durable Object body every Looping agent has, whatever loop it runs.
@@ -64,6 +64,9 @@ export declare abstract class LoopingAgent<TEnv extends Cloudflare.Env & AiEnv &
      * `onStart` runs before any request, so it is not known when `agentPlugins()`
      * is built — which is why anything per-caller takes a thunk. The DO is keyed
      * 1:1 by this value, so it is constant once set.
+     *
+     * In-memory, and deliberately so — see {@link requireIdentityKey}, which does
+     * not depend on it surviving.
      */
     private identityKey?;
     /**
@@ -95,7 +98,30 @@ export declare abstract class LoopingAgent<TEnv extends Cloudflare.Env & AiEnv &
     protected get config(): CoreConfig;
     /** The agent's database (drizzle + migrations), built once per DO instance. */
     protected get db(): AgentDB;
-    /** The model runtime for this instance, built lazily over the `AI` binding. */
+    /**
+     * Which provider this agent's loops run on. Defaults to Workers AI; override
+     * to run on something else.
+     *
+     * The seam is here rather than in `models` because `models` memoizes, and a
+     * subclass overriding a memoized getter has to remember to keep the caching —
+     * a trap that only shows up as a performance bug. This is called once.
+     *
+     * `ModelRuntime` is the whole contract: return anything satisfying it and
+     * every loop in core keeps working unchanged. Core ships two implementations,
+     * one directory each — {@link file://../agent/workers-ai/index.ts
+     * `agent/workers-ai`} (the default below) and `@loopingai/core/anthropic` —
+     * and a third provider is a third directory exporting one
+     * {@link file://../agent/model.ts ModelRuntimeFactory}, not a change to
+     * anything on this path.
+     *
+     * Takes the resolved {@link ModelConfig} rather than reading `this.config`, so
+     * that this signature matches
+     * {@link file://../round/subagent.ts RecipeSubagentHost.modelRuntime} — an
+     * agent and its facet **must** run the same provider, and identical seams are
+     * what let one factory serve both instead of two hand-copied bodies.
+     */
+    protected modelRuntime(model: ModelConfig): ModelRuntime;
+    /** The model runtime for this instance, built lazily and memoized. */
     protected get models(): ModelRuntime;
     /**
      * What this agent's plugins are handed. Built from
@@ -141,7 +167,35 @@ export declare abstract class LoopingAgent<TEnv extends Cloudflare.Env & AiEnv &
      * announces the loss, and the runtime fans it out to every plugin that asked.
      */
     getSession(identity: GatewayIdentity): SessionLike;
-    /** The caller key, which is present on every path that can reach a plugin. */
+    /**
+     * The caller key, which is present on every path that can reach a plugin.
+     *
+     * ## Why this does not just read the field
+     *
+     * `identityKey` is set on the first turn and lives in the isolate. An isolate
+     * does not live as long as the work does: it can be evicted between two rounds
+     * of the same task, and it can be reset outright — "Durable Object connection
+     * closed because the object was reset" — while a Workflow step is mid-flight.
+     * The next call arrives on a fresh instance where the field is empty, and
+     * every per-caller thunk built off it throws.
+     *
+     * That failure is disproportionate to its cause. A plugin asking which caller
+     * it is serving gets an exception, mid-task, on an object whose entire purpose
+     * is to be that caller's — and because the throw happens inside a tool or a
+     * runtime resolution rather than at the edge, it surfaces as a failed branch
+     * rather than as anything an operator can read.
+     *
+     * So the object answers from itself. `define-agent` routes with
+     * `ns.get(ns.idFromName(identity.key))`, which means the caller key *is* this
+     * object's name and the platform hands it back on `ctx.id.name` — durable, free
+     * and correct by construction: an object cannot disagree with the name it was
+     * addressed by.
+     *
+     * The field still wins when it is set. `id.name` is undefined for an object
+     * addressed by `newUniqueId()` or a raw id string, so it is a fallback rather
+     * than the source of truth, and the throw is kept for the case where neither
+     * exists.
+     */
     protected requireIdentityKey(): string;
     /** The gateway callback channel for one turn. See {@link PushChannel}. */
     protected push(context: TurnPushContext): PushChannel;