@loopingai/core 0.1.0

package/dist/contract/validation.js

@@ -0,0 +1,76 @@
+/**
+ * Merge a recipe's declared budget over the baseline, per field. A positive
+ * integer wins; anything else — missing, null, zero, fractional — falls back to
+ * the baseline rather than reaching the runner.
+ *
+ * The baseline is a default, not a ceiling: a recipe may declare a budget larger
+ * than the baseline and it is honored — sizing its own branch is what declaring
+ * `limits` is for, so nothing here clamps. What the merge buys, as
+ * defense-in-depth for a recipe that ever comes from data rather than code, is
+ * that a corrupt or absent value cannot reach the runner as a zero, fractional,
+ * or missing budget.
+ *
+ * Exported separately from {@link validateRecipe} because it must never throw.
+ */
+export function resolveLimits(limits, baseline) {
+    const positiveInt = (n, fallback) => typeof n === "number" && Number.isInteger(n) && n > 0 ? n : fallback;
+    return {
+        maxTurns: positiveInt(limits?.maxTurns, baseline.maxTurns),
+        maxWallMs: positiveInt(limits?.maxWallMs, baseline.maxWallMs)
+    };
+}
+/**
+ * Thrown by {@link validateRecipe} for a recipe that is unusable as given — it
+ * is disabled, carries no soul, or states no history window. All are
+ * deterministic caller bugs (the parent must only hand enabled, complete recipes
+ * to a subagent), so the child maps this to a terminal failed result rather than
+ * retrying.
+ */
+export class RecipeValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "RecipeValidationError";
+    }
+}
+/**
+ * Code-owned defensive validation of an already-resolved recipe. Returns a
+ * normalized copy (never mutates the input): a model id outside the policy's
+ * allowlist is substituted with the default for its slot — independently per
+ * slot — and unknown tool families are dropped (deduped, order-preserving).
+ * Applied by the parent when it resolves a recipe and re-applied by the subagent
+ * on its inbound request, so recipe data can never select arbitrary models or
+ * tools.
+ *
+ * The split between what is normalized and what is refused follows one rule:
+ * **the host declares a baseline ⇒ merge; it does not ⇒ require.** `limits`
+ * merge. A soul and a `historyWindow` do not: substituting a generic soul would
+ * run the work under an identity nobody declared — the model would answer,
+ * plausibly, as something other than what the recipe is for — and how much
+ * context a domain needs is likewise a property of the domain, not something a
+ * house default can guess. Both fail the recipe outright.
+ */
+export function validateRecipe(recipe, policy) {
+    if (!recipe.enabled) {
+        throw new RecipeValidationError(`recipe "${recipe.key}" (v${recipe.version}) is disabled`);
+    }
+    if (recipe.soul.trim() === "") {
+        throw new RecipeValidationError(`recipe "${recipe.key}" (v${recipe.version}) has no soul`);
+    }
+    if (!Number.isInteger(recipe.historyWindow) || recipe.historyWindow <= 0) {
+        throw new RecipeValidationError(`recipe "${recipe.key}" (v${recipe.version}) has no usable historyWindow ` +
+            `(got ${recipe.historyWindow}); every recipe states its own`);
+    }
+    const toolFamilies = [...new Set(recipe.toolFamilies)].filter((family) => policy.knownToolFamilies.has(family));
+    return {
+        ...recipe,
+        primaryModelId: policy.modelAllowlist.has(recipe.primaryModelId)
+            ? recipe.primaryModelId
+            : policy.defaultPrimaryModelId,
+        fallbackModelId: policy.modelAllowlist.has(recipe.fallbackModelId)
+            ? recipe.fallbackModelId
+            : policy.defaultFallbackModelId,
+        toolFamilies,
+        limits: resolveLimits(recipe.limits, policy.baselineLimits)
+    };
+}
+//# sourceMappingURL=validation.js.map

package/dist/contract/validation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.js","sourceRoot":"","sources":["../../src/contract/validation.ts"],"names":[],"mappings":"AA4CA;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,aAAa,CAC3B,MAA4B,EAC5B,QAAqB;IAErB,MAAM,WAAW,GAAG,CAAC,CAAqB,EAAE,QAAgB,EAAU,EAAE,CACtE,OAAO,CAAC,KAAK,QAAQ,IAAI,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;IACvE,OAAO;QACL,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC;QAC1D,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,EAAE,QAAQ,CAAC,SAAS,CAAC;KAC9D,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,OAAO,qBAAsB,SAAQ,KAAK;IAC9C,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,uBAAuB,CAAC;IACtC,CAAC;CACF;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,cAAc,CAC5B,MAAsB,EACtB,MAAoB;IAEpB,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;QACpB,MAAM,IAAI,qBAAqB,CAC7B,WAAW,MAAM,CAAC,GAAG,OAAO,MAAM,CAAC,OAAO,eAAe,CAC1D,CAAC;IACJ,CAAC;IACD,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;QAC9B,MAAM,IAAI,qBAAqB,CAC7B,WAAW,MAAM,CAAC,GAAG,OAAO,MAAM,CAAC,OAAO,eAAe,CAC1D,CAAC;IACJ,CAAC;IACD,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,MAAM,CAAC,aAAa,IAAI,CAAC,EAAE,CAAC;QACzE,MAAM,IAAI,qBAAqB,CAC7B,WAAW,MAAM,CAAC,GAAG,OAAO,MAAM,CAAC,OAAO,gCAAgC;YACxE,QAAQ,MAAM,CAAC,aAAa,gCAAgC,CAC/D,CAAC;IACJ,CAAC;IACD,MAAM,YAAY,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CACvE,MAAM,CAAC,iBAAiB,CAAC,GAAG,CAAC,MAAM,CAAC,CACrC,CAAC;IACF,OAAO;QACL,GAAG,MAAM;QACT,cAAc,EAAE,MAAM,CAAC,cAAc,CAAC,GAAG,CAAC,MAAM,CAAC,cAAc,CAAC;YAC9D,CAAC,CAAC,MAAM,CAAC,cAAc;YACvB,CAAC,CAAC,MAAM,CAAC,qBAAqB;QAChC,eAAe,EAAE,MAAM,CAAC,cAAc,CAAC,GAAG,CAAC,MAAM,CAAC,eAAe,CAAC;YAChE,CAAC,CAAC,MAAM,CAAC,eAAe;YACxB,CAAC,CAAC,MAAM,CAAC,sBAAsB;QACjC,YAAY;QACZ,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC;KAC5D,CAAC;AACJ,CAAC"}

package/dist/db/db.d.ts

@@ -0,0 +1,131 @@
+import { type DrizzleSqliteDODatabase } from "drizzle-orm/durable-sqlite";
+import * as schema from "./schema.js";
+export type DB = DrizzleSqliteDODatabase<typeof schema>;
+/**
+ * A table owner outside core's migration journal.
+ *
+ * Drizzle's durable-sqlite migrator keeps **one flat integer journal** and one
+ * global `__drizzle_migrations` table. Two independently-versioned npm packages
+ * cannot share that index space — and this is not hypothetical: the two
+ * predecessor agents, both consuming the same `notify_tasks` module, had already
+ * forked the journal at index 1 (`0001_unusual_nova` vs `0001_great_goliath`).
+ * Worse, `drizzle-kit generate` diffs against a snapshot in one output
+ * directory, so a plugin shipping from its own repo cannot produce a correct
+ * diff at all.
+ *
+ * So a plugin never touches core's journal. It implements this instead:
+ * idempotent `CREATE TABLE IF NOT EXISTS` DDL, plus its own version bookkeeping
+ * in the {@link PLUGIN_MIGRATIONS_TABLE} row this class manages for it. That
+ * pattern is not novel here — it is what the subagent facet already does for its
+ * own two tables.
+ *
+ * ```ts
+ * const scorecardStore: PluginStore = {
+ *   plugin: "arc-agi",
+ *   version: 2,
+ *   ensureTables(sql, from) {
+ *     sql.exec(`CREATE TABLE IF NOT EXISTS arc_scorecards (…)`);
+ *     if (from < 2) sql.exec(`ALTER TABLE arc_scorecards ADD COLUMN …`);
+ *   }
+ * };
+ * ```
+ */
+export interface PluginStore {
+    /** Stable identifier. Also the bookkeeping row's key — never rename it. */
+    plugin: string;
+    /**
+     * Monotonically increasing schema version, starting at 1. Bump it whenever
+     * {@link ensureTables} needs to do something it did not do before.
+     */
+    version: number;
+    /**
+     * Bring this plugin's tables up to {@link version}.
+     *
+     * Called once per DO instance, and re-called on every hibernation wake-up, so
+     * it **must be idempotent**. `from` is the version last recorded for this
+     * plugin (0 on first ever run), which is what lets an upgrade path branch
+     * without re-running earlier DDL.
+     */
+    ensureTables(sql: SqlStorage, from: number): void;
+}
+/** Bookkeeping for {@link PluginStore} versions. Core owns the table; plugins own their rows. */
+export declare const PLUGIN_MIGRATIONS_TABLE = "plugin_migrations";
+export interface AgentDBOptions {
+    /**
+     * Plugin-owned stores to bring up alongside core's own tables. Order is
+     * preserved but must not matter: a plugin that depends on another plugin's
+     * table is a plugin that should have been one plugin.
+     */
+    stores?: readonly PluginStore[];
+    /**
+     * `CoreConfig.maxSubtasks` — the durable guard `createDecomposition` enforces.
+     * Passed rather than imported so one resolved config governs both the schema
+     * offered to the model and the write that has to hold.
+     */
+    maxSubtasks: number;
+}
+/**
+ * The agent's database: one drizzle handle over the DO's SQLite, with a memoized
+ * namespace per table domain (`db.tasks`, `db.subtasks`).
+ *
+ * Constructed once per DO instance. Core's migrations run in the constructor —
+ * the durable-sqlite migrator is idempotent, so a fresh `AgentDB` on every
+ * hibernation wake-up re-validates the schema safely. Call `ensureReady()` (and
+ * await it) before issuing any queries.
+ *
+ * Plugin stores are brought up in the same place but through a different
+ * mechanism, deliberately — see {@link PluginStore}.
+ */
+export declare class AgentDB {
+    private readonly storage;
+    private readonly options;
+    private readonly db;
+    private readonly _ready;
+    private _tasks?;
+    private _subtasks?;
+    constructor(storage: DurableObjectStorage, options: AgentDBOptions);
+    ensureReady(): Promise<void>;
+    get tasks(): {
+        begin(input: {
+            messageId: string;
+            taskId: string;
+            contextId: string;
+        }): import("../a2a/task.js").PlainTask;
+        get(taskId: string): import("../a2a/task.js").PlainTask | null;
+        list(query: import("./index.js").TaskListQuery): {
+            tasks: import("../a2a/task.js").PlainTask[];
+            totalSize: number;
+        };
+        save(task: import("@a2a-js/sdk").Task): boolean;
+        markWorking(taskId: string): "ok" | "canceled";
+        cancel(taskId: string): import("../a2a/task.js").PlainTask | null;
+        cleanup(): void;
+    };
+    get subtasks(): {
+        createDecomposition(taskId: string, round: number, drafts: import("../subtasks/types.js").SubtaskDraft[]): import("../subtasks/types.js").Subtask[];
+        get(id: import("../subtasks/types.js").SubtaskId): import("../subtasks/types.js").Subtask | null;
+        list(taskId: string): import("../subtasks/types.js").Subtask[];
+        listRound(taskId: string, round: number): import("../subtasks/types.js").Subtask[];
+        start(id: import("../subtasks/types.js").SubtaskId, recipe: {
+            recipeId: string;
+            recipeVersion: number;
+        }): 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;
+    };
+    /**
+     * Run each plugin store's DDL and record its version, after core's own
+     * migrations so a plugin may safely reference core tables (nothing should, but
+     * the ordering is free and the alternative is a surprising failure).
+     *
+     * A store that throws fails DO start rather than being skipped: a plugin whose
+     * tables are missing would otherwise fail later, at its first tool call, in a
+     * request the user is waiting on.
+     */
+    private applyStores;
+}
+//# sourceMappingURL=db.d.ts.map

package/dist/db/db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../../src/db/db.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,uBAAuB,EAC7B,MAAM,4BAA4B,CAAC;AAEpC,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AAKtC,MAAM,MAAM,EAAE,GAAG,uBAAuB,CAAC,OAAO,MAAM,CAAC,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,WAAW,WAAW;IAC1B,2EAA2E;IAC3E,MAAM,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;;;OAOG;IACH,YAAY,CAAC,GAAG,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CACnD;AAED,iGAAiG;AACjG,eAAO,MAAM,uBAAuB,sBAAsB,CAAC;AAE3D,MAAM,WAAW,cAAc;IAC7B;;;;OAIG;IACH,MAAM,CAAC,EAAE,SAAS,WAAW,EAAE,CAAC;IAChC;;;;OAIG;IACH,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,OAAO;IAOhB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAP1B,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAK;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;IACvC,OAAO,CAAC,MAAM,CAAC,CAA+B;IAC9C,OAAO,CAAC,SAAS,CAAC,CAAkC;gBAGjC,OAAO,EAAE,oBAAoB,EAC7B,OAAO,EAAE,cAAc;IAQ1C,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B,IAAI,KAAK;;;;;;;;;;;;;;;MAER;IAED,IAAI,QAAQ;;;;;;;;;;;;;;;MAIX;IAED;;;;;;;;OAQG;IACH,OAAO,CAAC,WAAW;CAsDpB"}

package/dist/db/db.js

@@ -0,0 +1,91 @@
+import { drizzle } from "drizzle-orm/durable-sqlite";
+import { migrate } from "drizzle-orm/durable-sqlite/migrator";
+import * as schema from "./schema.js";
+import dbMigrations from "./migrations/index.js";
+import { makeTasks } from "./models/tasks.js";
+import { makeSubtasks } from "./models/subtasks.js";
+/** Bookkeeping for {@link PluginStore} versions. Core owns the table; plugins own their rows. */
+export const PLUGIN_MIGRATIONS_TABLE = "plugin_migrations";
+/**
+ * The agent's database: one drizzle handle over the DO's SQLite, with a memoized
+ * namespace per table domain (`db.tasks`, `db.subtasks`).
+ *
+ * Constructed once per DO instance. Core's migrations run in the constructor —
+ * the durable-sqlite migrator is idempotent, so a fresh `AgentDB` on every
+ * hibernation wake-up re-validates the schema safely. Call `ensureReady()` (and
+ * await it) before issuing any queries.
+ *
+ * Plugin stores are brought up in the same place but through a different
+ * mechanism, deliberately — see {@link PluginStore}.
+ */
+export class AgentDB {
+    storage;
+    options;
+    db;
+    _ready;
+    _tasks;
+    _subtasks;
+    constructor(storage, options) {
+        this.storage = storage;
+        this.options = options;
+        this.db = drizzle(storage, { schema });
+        this._ready = migrate(this.db, dbMigrations).then(() => {
+            this.applyStores(options.stores ?? []);
+        });
+    }
+    ensureReady() {
+        return this._ready;
+    }
+    get tasks() {
+        return (this._tasks ??= makeTasks(this.db));
+    }
+    get subtasks() {
+        return (this._subtasks ??= makeSubtasks(this.db, {
+            maxSubtasks: this.options.maxSubtasks
+        }));
+    }
+    /**
+     * Run each plugin store's DDL and record its version, after core's own
+     * migrations so a plugin may safely reference core tables (nothing should, but
+     * the ordering is free and the alternative is a surprising failure).
+     *
+     * A store that throws fails DO start rather than being skipped: a plugin whose
+     * tables are missing would otherwise fail later, at its first tool call, in a
+     * request the user is waiting on.
+     */
+    applyStores(stores) {
+        if (stores.length === 0)
+            return;
+        const sql = this.storage.sql;
+        sql.exec(`CREATE TABLE IF NOT EXISTS ${PLUGIN_MIGRATIONS_TABLE} (
+         plugin TEXT PRIMARY KEY,
+         version INTEGER NOT NULL,
+         updated_at INTEGER NOT NULL
+       )`);
+        const seen = new Set();
+        for (const store of stores) {
+            if (seen.has(store.plugin)) {
+                throw new Error(`duplicate PluginStore '${store.plugin}' — two plugins claim the same storage namespace`);
+            }
+            seen.add(store.plugin);
+            if (!Number.isInteger(store.version) || store.version < 1) {
+                throw new Error(`PluginStore '${store.plugin}' version must be an integer >= 1, got ${store.version}`);
+            }
+            const row = sql
+                .exec(`SELECT version FROM ${PLUGIN_MIGRATIONS_TABLE} WHERE plugin = ?`, store.plugin)
+                .toArray()[0];
+            const from = row?.version ?? 0;
+            if (from > store.version) {
+                throw new Error(`PluginStore '${store.plugin}' is at version ${from} on disk but the ` +
+                    `installed plugin declares ${store.version} — downgrade is not supported`);
+            }
+            store.ensureTables(sql, from);
+            if (from !== store.version) {
+                sql.exec(`INSERT INTO ${PLUGIN_MIGRATIONS_TABLE} (plugin, version, updated_at)
+             VALUES (?, ?, ?)
+             ON CONFLICT(plugin) DO UPDATE SET version = excluded.version, updated_at = excluded.updated_at`, store.plugin, store.version, Date.now());
+            }
+        }
+    }
+}
+//# sourceMappingURL=db.js.map

package/dist/db/db.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"db.js","sourceRoot":"","sources":["../../src/db/db.ts"],"names":[],"mappings":"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"}

package/dist/db/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * `@loopingai/core/db` — the two tables core owns, and the seam a plugin uses to
+ * own its own without touching core's migration journal.
+ */
+export { AgentDB, PLUGIN_MIGRATIONS_TABLE, type AgentDBOptions, type DB, type PluginStore } from "./db.js";
+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.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/db/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,OAAO,EACP,uBAAuB,EACvB,KAAK,cAAc,EACnB,KAAK,EAAE,EACP,KAAK,WAAW,EACjB,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEpD,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAE3E,OAAO,EAAE,YAAY,EAAE,KAAK,mBAAmB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/db/index.js

@@ -0,0 +1,9 @@
+/**
+ * `@loopingai/core/db` — the two tables core owns, and the seam a plugin uses to
+ * own its own without touching core's migration journal.
+ */
+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/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/db/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,OAAO,EACP,uBAAuB,EAIxB,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEpD,OAAO,EAAE,SAAS,EAAE,OAAO,EAAsB,MAAM,mBAAmB,CAAC;AAE3E,OAAO,EAAE,YAAY,EAA4B,MAAM,sBAAsB,CAAC"}

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

@@ -0,0 +1,21 @@
+/**
+ * Drizzle migrations, inlined for Cloudflare Workers.
+ *
+ * GENERATED FILE — do not edit. Run `npm run db:generate` after changing
+ * `src/db/schema.ts`; that runs `drizzle-kit generate` and then
+ * `scripts/build-migrations.mjs`, which rebuilds this from
+ * `meta/_journal.json` and the `.sql` files beside it.
+ *
+ * Key format: "m{zero-padded idx}" — what drizzle's durable-sqlite migrator
+ * reads from `config.migrations[key]`.
+ *
+ * This journal is CORE's alone. A plugin must never add an entry: the journal is
+ * a flat integer sequence over one shared `__drizzle_migrations` table, and two
+ * independently-versioned packages writing to it will collide. Plugins own their
+ * tables through `PluginStore` instead — see `src/db/db.ts`.
+ */
+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.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/db/migrations/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qCAAqC,CAAC;AAEnE,KAAK,eAAe,GAAG,UAAU,CAAC,OAAO,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;AAErD,QAAA,MAAM,YAAY,EAAE,eAmDnB,CAAC;AAEF,eAAe,YAAY,CAAC"}

package/dist/db/migrations/index.js

@@ -0,0 +1,54 @@
+const dbMigrations = {
+    journal: {
+        entries: [
+            {
+                idx: 0,
+                when: 1785537420937,
+                tag: "0000_init",
+                breakpoints: true
+            }
+        ]
+    },
+    migrations: {
+        m0000: `CREATE TABLE \`notify_tasks\` (
+	\`task_id\` text PRIMARY KEY NOT NULL,
+	\`message_id\` text,
+	\`context_id\` text DEFAULT '' NOT NULL,
+	\`state\` text NOT NULL,
+	\`task_json\` text NOT NULL,
+	\`created_at\` integer NOT NULL,
+	\`updated_at\` integer NOT NULL
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX \`notify_tasks_message_id_unique\` ON \`notify_tasks\` (\`message_id\`);--> statement-breakpoint
+CREATE INDEX \`idx_notify_tasks_created_at\` ON \`notify_tasks\` (\`created_at\`);--> statement-breakpoint
+CREATE INDEX \`idx_notify_tasks_context\` ON \`notify_tasks\` (\`context_id\`);--> statement-breakpoint
+CREATE INDEX \`idx_notify_tasks_state\` ON \`notify_tasks\` (\`state\`);--> statement-breakpoint
+CREATE TABLE \`subtasks\` (
+	\`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	\`task_id\` text NOT NULL,
+	\`round\` integer NOT NULL,
+	\`ordinal\` integer NOT NULL,
+	\`type\` text NOT NULL,
+	\`recipe_id\` text,
+	\`recipe_version\` integer,
+	\`prompt\` text NOT NULL,
+	\`references_json\` text NOT NULL,
+	\`depends_on_json\` text NOT NULL,
+	\`params_json\` text DEFAULT '{}' NOT NULL,
+	\`status\` text NOT NULL,
+	\`result_parts_json\` text,
+	\`error\` text,
+	\`created_at\` integer NOT NULL,
+	\`updated_at\` integer NOT NULL,
+	\`completed_at\` integer
+);
+--> statement-breakpoint
+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\`);`
+    }
+};
+export default dbMigrations;
+//# sourceMappingURL=index.js.map

package/dist/db/migrations/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/db/migrations/index.ts"],"names":[],"mappings":"AAoBA,MAAM,YAAY,GAAoB;IACpC,OAAO,EAAE;QACP,OAAO,EAAE;YACP;gBACE,GAAG,EAAE,CAAC;gBACN,IAAI,EAAE,aAAa;gBACnB,GAAG,EAAE,WAAW;gBAChB,WAAW,EAAE,IAAI;aAClB;SACF;KACF;IACD,UAAU,EAAE;QACV,KAAK,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2EAqCgE;KACxE;CACF,CAAC;AAEF,eAAe,YAAY,CAAC"}

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

@@ -0,0 +1,102 @@
+import type { DB } from "../db.js";
+import type { Subtask, SubtaskDraft, SubtaskId, SubtaskResultPart } from "../../subtasks/types.js";
+export interface SubtaskModelOptions {
+    /**
+     * Upper bound on subtasks per round, re-checked here as the **durable** guard.
+     * The delegation schema offers the model the same bound, but a schema is a
+     * suggestion to a model and this is the write that has to hold.
+     */
+    maxSubtasks: number;
+}
+/**
+ * Query methods for the `subtasks` table (durable decomposed units of work).
+ *
+ * Bound to a drizzle handle by {@link AgentDB} and reached as `db.subtasks.*`.
+ * 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
+ * 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.
+     *
+     * `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.
+     */
+    createDecomposition(taskId: string, round: number, drafts: SubtaskDraft[]): Subtask[];
+    /** Load one Subtask by id. */
+    get(id: SubtaskId): Subtask | null;
+    /** 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.
+     */
+    listRound(taskId: string, round: number): Subtask[];
+    /**
+     * Begin execution: guarded `pending -> running`, recording the resolved
+     * Recipe id/version after-the-fact. Returns false if the Subtask was not
+     * pending (already started, terminal, or unknown).
+     */
+    start(id: SubtaskId, recipe: {
+        recipeId: string;
+        recipeVersion: number;
+    }): boolean;
+    /**
+     * Persist a successful terminal result: guarded `running -> completed`.
+     * Requires at least one non-empty text result part (a successful Recipe
+     * output invariant).
+     */
+    complete(id: SubtaskId, resultParts: SubtaskResultPart[]): boolean;
+    /**
+     * Persist a failure from either non-terminal status, with a diagnostic message.
+     *
+     * 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.
+     *
+     * 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
+     * terminal result but the Task was canceled while it ran — the result is
+     * dropped, and this leaves the row in a truthful terminal state instead of a
+     * `running` that never resolves. Returns false if the Subtask was not running.
+     */
+    cancelRunning(id: SubtaskId): boolean;
+    /**
+     * Cancel every still-pending Subtask of a Task (parent cancellation).
+     * 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.
+     */
+    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.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subtasks.d.ts","sourceRoot":"","sources":["../../../src/db/models/subtasks.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AACnC,OAAO,KAAK,EACV,OAAO,EACP,YAAY,EACZ,SAAS,EAET,iBAAiB,EAElB,MAAM,yBAAyB,CAAC;AAmBjC,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,mBAAmB;IAiE1D;;;;;;;;;;;;;;;;;;OAkBG;gCAEO,MAAM,SACP,MAAM,UACL,YAAY,EAAE,GACrB,OAAO,EAAE;IA+FZ,8BAA8B;YACtB,SAAS,GAAG,OAAO,GAAG,IAAI;IAKlC,gEAAgE;iBACnD,MAAM,GAAG,OAAO,EAAE;IAI/B;;;;OAIG;sBACe,MAAM,SAAS,MAAM,GAAG,OAAO,EAAE;IAInD;;;;OAIG;cAEG,SAAS,UACL;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAA;KAAE,GAClD,OAAO;IAQV;;;;OAIG;iBACU,SAAS,eAAe,iBAAiB,EAAE,GAAG,OAAO;IAYlE;;;;;;;;;;;;;OAaG;aACM,SAAS,SAAS,MAAM,GAAG,OAAO;IAQ3C,2FAA2F;aAClF,SAAS,GAAG,OAAO;IAI5B;;;;;;OAMG;sBACe,SAAS,GAAG,OAAO;IAOrC;;;;;OAKG;0BACmB,MAAM,GAAG,MAAM;IAWrC,kFAAkF;eACvE,IAAI;EAKlB"}