@loopingai/core 0.5.0 → 0.6.0

package/dist/contract/plugin.d.ts

@@ -160,9 +160,9 @@ export interface AgentPlugin<TRuntime = SubtaskRuntime> {
      *
      * A plugin that declares a {@link subtaskType} should put its capability block
      * on the *type* instead ({@link SubtaskTypeSpec.capability}) and leave this
-     * unset — the two are rendered by different call sites, so declaring both
-     * makes the main agent read the same advice twice per round. Which is the
-     * exact failure the type's own prompt fields were introduced to end.
+     * unset. Both are rendered, so declaring both makes the main agent read the
+     * same advice twice per round — the exact failure the type's own prompt
+     * fields were introduced to end.
      */
     capability?: string;
     /**
@@ -262,4 +262,63 @@ export interface AgentPlugin<TRuntime = SubtaskRuntime> {
 export declare function definePlugin<TRuntime = SubtaskRuntime>(plugin: Omit<AgentPlugin<TRuntime>, "contractVersion"> & {
     contractVersion?: number;
 }): AgentPlugin<TRuntime>;
-//# sourceMappingURL=plugin.d.ts.map
+/** See {@link restrictMainAgentTools}. */
+export interface RestrictMainAgentToolsOptions {
+    /**
+     * The tool names the main agent keeps. `[]` removes the hook entirely, which
+     * is the "orchestrator with no hands" case.
+     *
+     * Names rather than a predicate, because the point is to state the surface
+     * explicitly at the install site: a reader of `plugins.ts` should be able to
+     * see what the main agent can do without opening the plugin.
+     */
+    allow: readonly string[];
+    /**
+     * What the main agent is told instead of the plugin's own
+     * {@link AgentPlugin.capability}.
+     *
+     * Required in spirit whenever `allow` is non-empty: the plugin's block
+     * describes its *whole* surface, so leaving it in place tells the model about
+     * tools it no longer has — which it then tries to call. Omit it to say
+     * nothing, which is right for `allow: []`.
+     */
+    capability?: string;
+}
+/**
+ * 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 declare function restrictMainAgentTools<TRuntime = SubtaskRuntime>(plugin: AgentPlugin<TRuntime>, options: RestrictMainAgentToolsOptions): AgentPlugin<TRuntime>;

package/dist/contract/plugin.js

@@ -36,4 +36,79 @@ export function definePlugin(plugin) {
         contractVersion: plugin.contractVersion ?? PLUGIN_CONTRACT_VERSION
     };
 }
-//# sourceMappingURL=plugin.js.map
+/**
+ * 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;
     /**
@@ -179,4 +178,3 @@ export interface SubtaskTypeSpec {
     /** The execution configuration this type runs under. */
     recipe: ResolvedRecipe;
 }
-//# sourceMappingURL=recipe.d.ts.map

package/dist/contract/recipe.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=recipe.js.map

package/dist/contract/validation.d.ts

@@ -89,4 +89,3 @@ export declare class RecipeValidationError extends Error {
  * house default can guess. Both fail the recipe outright.
  */
 export declare function validateRecipe(recipe: ResolvedRecipe, policy: RecipePolicy): ValidatedRecipe;
-//# sourceMappingURL=validation.d.ts.map

package/dist/contract/validation.js

@@ -82,4 +82,3 @@ export function validateRecipe(recipe, policy) {
         limits: resolveLimits(recipe.limits, policy.baselineLimits)
     };
 }
-//# sourceMappingURL=validation.js.map

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;
@@ -146,4 +145,3 @@ export declare class AgentDB {
      */
     private applyStores;
 }
-//# sourceMappingURL=db.d.ts.map

package/dist/db/db.js

@@ -88,4 +88,3 @@ export class AgentDB {
         }
     }
 }
-//# sourceMappingURL=db.js.map

package/dist/db/index.d.ts

@@ -6,4 +6,3 @@ export { AgentDB, PLUGIN_MIGRATIONS_TABLE, type AgentDBOptions, type DB, type Pl
 export { notifyTasks, subtasks } from "./schema.js";
 export { makeTasks, stateOf, type TaskListQuery } from "./models/tasks.js";
 export { makeSubtasks, type SubtaskModelOptions } from "./models/subtasks.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/db/index.js

@@ -6,4 +6,3 @@ export { AgentDB, PLUGIN_MIGRATIONS_TABLE } from "./db.js";
 export { notifyTasks, subtasks } from "./schema.js";
 export { makeTasks, stateOf } from "./models/tasks.js";
 export { makeSubtasks } from "./models/subtasks.js";
-//# sourceMappingURL=index.js.map

package/dist/db/migrations/index.d.ts

@@ -18,4 +18,3 @@ import type { migrate } from "drizzle-orm/durable-sqlite/migrator";
 type MigrationConfig = Parameters<typeof migrate>[1];
 declare const dbMigrations: MigrationConfig;
 export default dbMigrations;
-//# sourceMappingURL=index.d.ts.map

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,8 +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;
-//# sourceMappingURL=index.js.map

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,9 +86,15 @@ 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). */
     cleanup(): void;
 };
-//# sourceMappingURL=subtasks.d.ts.map

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();
@@ -282,4 +239,3 @@ export function makeSubtasks(db, opts) {
         }
     };
 }
-//# sourceMappingURL=subtasks.js.map

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

@@ -103,4 +103,3 @@ export declare function makeTasks(db: DB): {
     /** Delete all tasks older than 30 days (called by the maintenance cron). */
     cleanup(): void;
 };
-//# sourceMappingURL=tasks.d.ts.map

package/dist/db/models/tasks.js

@@ -239,4 +239,3 @@ function project(task, query) {
             : history.slice(Math.max(0, history.length - query.historyLength))
     };
 }
-//# sourceMappingURL=tasks.js.map