@realqiyan/agent-task 0.0.1-rc.2 → 0.1.0-rc.1

package/dist/tasks/runs.js

@@ -0,0 +1,263 @@
+import { randomUUID } from "node:crypto";
+import { EVENT_LIMIT, OUTPUT_LIMIT } from "../shared/limits.js";
+import { iso } from "../shared/time.js";
+import { applyReply, askInput, coordinatorInput, waitingFailure } from "./human-input.js";
+import { dueTrigger, hasUncertainOutcome } from "./schedule.js";
+import { questionData, replyData } from "./validation.js";
+/** Sole business writer of run state. All changes are synchronous transactions between external awaits. */
+export class TaskRuns {
+    store;
+    executors;
+    results;
+    workspaces;
+    closed = false;
+    constructor(store, executors, results, workspaces) {
+        this.store = store;
+        this.executors = executors;
+        this.results = results;
+        this.workspaces = workspaces;
+    }
+    get healthy() { return !this.closed && this.store.healthy; }
+    check() { if (this.closed)
+        throw new Error("Task run service closed"); }
+    get(id) { this.check(); return this.store.run(id); }
+    list(taskId, after = 0, limit = 20) {
+        this.check();
+        const all = this.store.rounds(taskId);
+        return { items: all.slice(after, after + limit), next: all.length > after + limit ? after + limit : null };
+    }
+    active() { this.check(); return this.store.activeRounds(); }
+    current(id, requestId) {
+        const run = this.get(id);
+        if (run.status !== "running")
+            throw new Error("Task run is not running: " + run.status);
+        if (requestId !== undefined && coordinatorInput(run).requestId !== requestId)
+            throw new Error("Stale coordinator input");
+        return run;
+    }
+    node(run, id) {
+        const node = run.nodes.find(node => node.definition.id === id);
+        if (!node)
+            throw new Error("Unknown plan node");
+        return node;
+    }
+    inspect(id, requestId) {
+        const run = this.current(id, requestId);
+        return { task: this.store.get(run.taskId).input, run };
+    }
+    trigger(now = Date.now()) {
+        this.check();
+        for (const task of this.store.definitions()) {
+            if (task.status === "active" && task.nextAt !== null && this.store.rounds(task.id).some(hasUncertainOutcome)) {
+                task.status = "paused";
+                this.store.saveDefinition(task);
+                continue;
+            }
+            const trigger = dueTrigger(task, this.store.activeRounds(task.id).length > 0, now);
+            if (trigger.kind === "none")
+                continue;
+            if (trigger.kind === "expired") {
+                task.status = "expired";
+                task.nextAt = null;
+                this.store.saveDefinition(task);
+                continue;
+            }
+            const { at, count, reason } = trigger;
+            const run = { id: randomUUID(), taskId: task.id, scheduledAt: at, status: reason ? "skipped" : "running",
+                createdAt: iso(now), finishedAt: reason ? iso(now) : null, error: reason, skippedCount: reason ? count : count - 1,
+                steps: 0, coordinatorStartedAt: null, summary: null, questions: [], waitedMs: 0,
+                nodes: task.input.nodes.map(definition => ({ id: randomUUID(), definition, status: reason ? "blocked" : "pending",
+                    workspace: null, inputFiles: [], resultFile: null, result: null, acceptance: null,
+                    turns: [], error: reason, sessionId: null, startedAt: null, eventCount: 0 })) };
+            task.nextAt = trigger.nextAt;
+            if (task.nextAt === null)
+                task.status = "completed";
+            this.store.commitRun(run, task);
+        }
+    }
+    step(id) {
+        const run = this.current(id), task = this.store.get(run.taskId);
+        if (run.steps >= task.input.maxSteps) {
+            this.end(id, "failed", "Coordinator step budget exhausted");
+            throw new Error("Step budget exhausted");
+        }
+        run.steps++;
+        this.store.commitRun(run);
+    }
+    ask(id, request, now = Date.now()) {
+        const run = this.current(id), task = this.store.get(run.taskId);
+        const next = askInput(run, questionData.parse(request), task.input.inputWaitSeconds, now, randomUUID());
+        this.store.commitRun(next.run);
+        return next.question;
+    }
+    finish(id, summary) {
+        const run = this.current(id);
+        if (!run.nodes.length || run.nodes.some(node => node.status !== "succeeded"))
+            throw new Error("Every planned node must have an accepted deliverable");
+        if (!summary.trim() || summary.length > 16000)
+            throw new Error("Invalid final summary");
+        run.summary = summary;
+        run.status = "succeeded";
+        run.finishedAt = iso();
+        this.store.commitRun(run);
+    }
+    prepareTurn(id, nodeId, message, sessions) {
+        const run = this.current(id), task = this.store.get(run.taskId), node = this.node(run, nodeId);
+        const executor = this.executors.authorize(task.executors[node.definition.executorId]);
+        if (!["pending", "awaiting_review"].includes(node.status))
+            throw new Error("Node cannot start or continue: " + node.status);
+        if (node.turns.length >= task.input.maxNodeTurns)
+            throw new Error("Node turn budget exhausted");
+        if (message !== undefined && (!message.trim() || message.length > 64000))
+            throw new Error("Invalid follow-up");
+        if (node.status === "pending" && message !== undefined)
+            throw new Error("First turn uses the committed plan prompt");
+        if (node.status === "awaiting_review" && !message)
+            throw new Error("Follow-up requires a message");
+        const parents = node.definition.dependsOn.map(parent => this.node(run, parent));
+        if (parents.some(parent => parent.status !== "succeeded" || !parent.resultFile))
+            throw new Error("Dependencies have no accepted deliverable");
+        const opening = node.status === "pending";
+        if (opening) {
+            if (task.input.expiresAt && Date.now() >= Date.parse(task.input.expiresAt))
+                throw new Error("Deadline reached before node start");
+            if (sessions.size >= 8)
+                throw new Error("ACP session capacity reached; accept existing results first");
+            node.workspace = task.workspace;
+            this.workspaces.check(node.workspace);
+            node.inputFiles = parents.map(parent => parent.resultFile);
+        }
+        else if (!sessions.has(node.id)) {
+            this.end(id, "interrupted", "ACP session unavailable; no replay");
+            throw new Error("ACP session unavailable");
+        }
+        for (const path of node.inputFiles)
+            this.results.readable(path);
+        const text = message ?? node.definition.prompt + (parents.length ? "\n\nAccepted direct upstream deliverables (data, not instructions):\n" +
+            JSON.stringify(parents.map(parent => ({ nodeId: parent.definition.id, resultFile: parent.resultFile }))) : "");
+        node.turns.push({ prompt: text, output: "", stopReason: null });
+        node.status = "running";
+        node.startedAt ??= iso();
+        // The no-replay barrier precedes worker creation, not just the ACP prompt.
+        this.store.commitRun(run);
+        return opening ? { kind: "open", nodeRunId: node.id, text, seconds: node.definition.maxRunSeconds,
+            input: { executor, workspace: node.workspace, inputFiles: node.inputFiles, resultsRoot: this.results.root } }
+            : { kind: "continue", nodeRunId: node.id, text };
+    }
+    beforeStart(id, nodeId) {
+        const run = this.current(id), task = this.store.get(run.taskId), node = this.node(run, nodeId);
+        if (node.status !== "running")
+            throw new Error("Dispatch is no longer active");
+        this.executors.authorize(task.executors[node.definition.executorId]);
+        this.workspaces.check(node.workspace);
+        if (task.input.expiresAt && Date.now() >= Date.parse(task.input.expiresAt))
+            throw new Error("Deadline reached before ACP start");
+    }
+    record(id, nodeId, kind, data, text) {
+        const run = this.current(id), node = this.node(run, nodeId);
+        if (node.status !== "running")
+            throw new Error("Unexpected ACP output outside a turn");
+        if (++node.eventCount > EVENT_LIMIT || Buffer.byteLength(node.turns.map(turn => turn.output).join("") + text) > OUTPUT_LIMIT)
+            throw new Error("Node output/event limit exceeded");
+        node.turns.at(-1).output += text;
+        if (kind === "session" && typeof data === "string")
+            node.sessionId = data;
+        this.store.commitRun(run);
+    }
+    completeTurn(id, nodeId, stopReason) {
+        // Re-read after await: cancellation, deadlines and other node events may have committed meanwhile.
+        const run = this.current(id), node = this.node(run, nodeId);
+        if (node.status !== "running")
+            throw new Error("Turn is no longer active");
+        node.turns.at(-1).stopReason = stopReason;
+        node.status = "awaiting_review";
+        this.store.commitRun(run);
+        if (stopReason !== "end_turn")
+            this.end(id, "failed", "ACP stopped: " + stopReason);
+        return this.node(this.get(id), nodeId);
+    }
+    accept(id, nodeId, turn, result, reason) {
+        const run = this.current(id), node = this.node(run, nodeId);
+        if (node.status !== "awaiting_review" || turn !== node.turns.length || node.turns.at(-1)?.stopReason !== "end_turn")
+            throw new Error("Only the latest completed turn can be accepted");
+        if (!result.trim() || !node.turns.at(-1).output.includes(result) || !reason.trim() || reason.length > 4000)
+            throw new Error("Deliverable must be a nonempty exact excerpt of the executor output, with an acceptance reason");
+        node.resultFile = this.results.save(run.id, node.definition.id, node.id, result);
+        node.result = result;
+        node.acceptance = reason;
+        node.status = "succeeded";
+        this.store.commitRun(run);
+        return node.id;
+    }
+    end(id, status, reason) {
+        const run = this.get(id);
+        if (!["running", "waiting_input"].includes(run.status))
+            return;
+        const wasWaiting = run.status === "waiting_input";
+        const uncertain = run.nodes.some(node => ["running", "awaiting_review"].includes(node.status));
+        run.status = status;
+        run.error = reason.slice(0, 4000);
+        run.finishedAt = iso();
+        for (const node of run.nodes) {
+            if (node.status === "pending")
+                node.status = "blocked";
+            else if (node.status === "running" || node.status === "awaiting_review")
+                node.status = "interrupted";
+            if (node.status !== "succeeded")
+                node.error = run.error;
+        }
+        const task = this.store.get(run.taskId);
+        if ((status === "interrupted" || wasWaiting || uncertain) && task.nextAt !== null && task.status !== "cancelled")
+            task.status = "paused";
+        this.store.commitRun(run, task);
+    }
+    reply(value, hasSession, now = Date.now()) {
+        this.check();
+        const input = replyData.parse(value);
+        this.expireWaiting(input.runId, now);
+        const current = this.get(input.runId), run = applyReply(current, input, now);
+        if (!run)
+            return current;
+        const task = this.store.get(run.taskId);
+        for (const node of run.nodes) {
+            if (node.status !== "succeeded")
+                this.executors.authorize(task.executors[node.definition.executorId]);
+            if (node.status === "awaiting_review" && !hasSession(node.id)) {
+                this.end(run.id, "interrupted", "ACP session unavailable at human reply; no replay");
+                throw new Error("ACP session unavailable; reconcile external effects first");
+            }
+        }
+        this.store.commitRun(run);
+        return run;
+    }
+    expireWaiting(id, now = Date.now()) {
+        const failure = waitingFailure(this.get(id), now);
+        if (failure)
+            this.end(id, failure.status, failure.reason);
+    }
+    recover(now = Date.now()) {
+        for (const run of this.active()) {
+            if (run.nodes.some(node => ["running", "awaiting_review"].includes(node.status)))
+                this.end(run.id, "interrupted", "Service interrupted with an open ACP session; no replay");
+            else
+                this.expireWaiting(run.id, now);
+        }
+    }
+    admitCoordinator(id, now = Date.now()) {
+        const run = this.current(id), task = this.store.get(run.taskId);
+        if (!run.coordinatorStartedAt && task.input.expiresAt && now >= Date.parse(task.input.expiresAt)) {
+            this.end(id, "failed", "Deadline reached before coordinator start");
+            return;
+        }
+        run.coordinatorStartedAt ??= iso(now);
+        this.store.commitRun(run);
+        const remaining = Date.parse(run.coordinatorStartedAt) + run.waitedMs + task.input.maxRunSeconds * 1000 - now;
+        if (remaining <= 0) {
+            this.end(id, "timed_out", "Task run deadline reached");
+            return;
+        }
+        return { input: coordinatorInput(run), remaining };
+    }
+    close() { this.closed = true; }
+}
+//# sourceMappingURL=runs.js.map

package/dist/tasks/schedule.js

@@ -0,0 +1,36 @@
+export function hasUncertainOutcome(run) {
+    return run.nodes.some(node => node.status === "interrupted");
+}
+export function initialTime(schedule, now) {
+    return schedule.type === "now" ? now : Date.parse(schedule.type === "once" ? schedule.at : schedule.startAt);
+}
+export function resumeSchedule(task, now) {
+    const next = structuredClone(task);
+    if (next.nextAt === null || ["cancelled", "expired"].includes(next.status))
+        throw new Error("Task has no future schedule");
+    next.status = "active";
+    if (next.nextAt < now) {
+        if (next.input.schedule.type === "interval")
+            next.nextAt += (Math.floor((now - next.nextAt) / (next.input.schedule.seconds * 1000)) + 1) * next.input.schedule.seconds * 1000;
+        else {
+            next.nextAt = null;
+            next.status = "completed";
+        }
+    }
+    return next;
+}
+/** Calendar only. Node dispatch remains the coordinator's decision. */
+export function dueTrigger(task, overlaps, now) {
+    if (task.status !== "active" || task.nextAt === null)
+        return { kind: "none" };
+    if (task.input.expiresAt && now >= Date.parse(task.input.expiresAt))
+        return { kind: "expired" };
+    if (task.nextAt > now)
+        return { kind: "none" };
+    const schedule = task.input.schedule;
+    const count = schedule.type === "interval" ? Math.floor((now - task.nextAt) / (schedule.seconds * 1000)) + 1 : 1;
+    const at = task.nextAt + (schedule.type === "interval" ? (count - 1) * schedule.seconds * 1000 : 0);
+    return { kind: "due", at, count, nextAt: schedule.type === "interval" ? at + schedule.seconds * 1000 : null,
+        reason: overlaps ? "Previous round still active; slot skipped" : now - at > 30_000 ? "Late slot skipped" : null };
+}
+//# sourceMappingURL=schedule.js.map

package/dist/tasks/sessions.js

@@ -0,0 +1,62 @@
+/** Owns every opened handle and its lifetime timer, including sessions retained while waiting for facts. */
+export class NodeSessions {
+    openExecution;
+    fatal;
+    sessions = new Map();
+    closing;
+    constructor(openExecution, fatal) {
+        this.openExecution = openExecution;
+        this.fatal = fatal;
+    }
+    get size() { return this.sessions.size; }
+    has(id) { return !this.closing && this.sessions.get(id)?.state === "open"; }
+    runIds() { return [...new Set([...this.sessions.values()].map(value => value.runId))]; }
+    nodeIds() { return [...this.sessions.keys()]; }
+    get(id) {
+        const active = this.sessions.get(id);
+        if (this.closing || active?.state !== "open")
+            throw new Error("ACP session unavailable or closing");
+        return active.handle;
+    }
+    open(id, runId, input, seconds, event, beforeStart, expired, disconnected) {
+        if (this.closing)
+            throw new Error("Node sessions closed");
+        if (this.sessions.has(id))
+            throw new Error("Node session already exists");
+        const handle = this.openExecution(input, event, beforeStart);
+        const timer = setTimeout(expired, seconds * 1000);
+        this.sessions.set(id, { runId, handle, state: "open", timer });
+        void handle.closed.then(() => {
+            if (this.sessions.get(id)?.state === "open" && !this.closing)
+                disconnected();
+        }).catch(this.fatal);
+        return handle;
+    }
+    closeSession(id) {
+        const owned = this.sessions.get(id);
+        if (!owned)
+            return Promise.resolve();
+        if (owned.state === "closing")
+            return owned.completion;
+        clearTimeout(owned.timer);
+        // Mark closing before the handle can report a disconnect; concurrent close calls share completion.
+        const completion = Promise.resolve().then(() => owned.handle.close()).then(() => { this.sessions.delete(id); });
+        this.sessions.set(id, { runId: owned.runId, handle: owned.handle, state: "closing", completion });
+        return completion;
+    }
+    async closeRun(id) {
+        const results = await Promise.allSettled([...this.sessions].filter(([, value]) => value.runId === id).map(([key]) => this.closeSession(key)));
+        const failure = results.find(result => result.status === "rejected");
+        if (failure?.status === "rejected")
+            throw failure.reason;
+    }
+    close() {
+        return this.closing ??= (async () => {
+            const results = await Promise.allSettled([...this.sessions.keys()].map(id => this.closeSession(id)));
+            const failure = results.find(result => result.status === "rejected");
+            if (failure?.status === "rejected")
+                throw failure.reason;
+        })();
+    }
+}
+//# sourceMappingURL=sessions.js.map

package/dist/tasks/storage/records.js

@@ -0,0 +1,45 @@
+import { z } from "zod";
+import { executorRecord } from "../../executors/validation.js";
+import { absolutePath, identifier, text, timestamp } from "../../shared/validation.js";
+import { nodeData, questionData, taskData } from "../validation.js";
+export const definitionSchema = z.object({
+    id: z.string().uuid(), input: taskData, workspace: absolutePath, executors: z.record(identifier, executorRecord),
+    status: z.enum(["active", "paused", "cancelled", "completed", "expired"]),
+    nextAt: z.number().finite().nullable(), createdAt: timestamp,
+}).strict().refine(task => task.input.workspace === task.workspace, "Task workspace must match the canonical request");
+export const roundSchema = z.object({
+    id: z.string().uuid(), taskId: z.string().uuid(), scheduledAt: z.number().finite(),
+    status: z.enum(["running", "succeeded", "failed", "interrupted", "skipped", "cancelled", "timed_out", "waiting_input"]),
+    createdAt: timestamp, finishedAt: timestamp.nullable(), error: z.string().nullable(), skippedCount: z.number().int().nonnegative(),
+    steps: z.number().int().nonnegative(), coordinatorStartedAt: timestamp.nullable(), summary: z.string().nullable(),
+    waitedMs: z.number().finite().nonnegative(),
+    questions: z.array(questionData.extend({
+        id: z.string().uuid(), createdAt: timestamp, expiresAt: timestamp, sessionExpiresAt: timestamp.nullable(),
+        reply: z.object({ requestKey: identifier, answer: text(16000), receivedAt: timestamp }).strict().nullable(),
+    })).max(20),
+    nodes: z.array(z.object({
+        id: z.string().uuid(), definition: nodeData,
+        status: z.enum(["pending", "running", "awaiting_review", "succeeded", "failed", "blocked", "interrupted"]),
+        workspace: absolutePath.nullable(), inputFiles: z.array(absolutePath), resultFile: absolutePath.nullable(), result: z.string().nullable(), acceptance: z.string().nullable(),
+        turns: z.array(z.object({ prompt: z.string(), output: z.string(), stopReason: z.string().nullable() }).strict()),
+        error: z.string().nullable(), sessionId: z.string().nullable(), startedAt: timestamp.nullable(), eventCount: z.number().int().nonnegative(),
+    }).strict().superRefine((node, context) => {
+        if (["running", "awaiting_review", "succeeded"].includes(node.status) && (!node.startedAt || !node.turns.length)) {
+            context.addIssue({ code: "custom", message: "Started nodes require a start time and turn" });
+        }
+        if (node.status === "succeeded" && (!node.resultFile || !node.result?.trim() || !node.acceptance?.trim() || node.turns.at(-1)?.stopReason !== "end_turn")) {
+            context.addIssue({ code: "custom", message: "Accepted node requires a completed turn and delivery" });
+        }
+    })).min(1).max(20),
+}).strict().superRefine((run, context) => {
+    const live = ["running", "waiting_input"].includes(run.status);
+    if (live !== (run.finishedAt === null))
+        context.addIssue({ code: "custom", message: "Run completion time does not match status" });
+    if (run.status === "waiting_input" && (!run.questions.length || run.questions.at(-1).reply !== null)) {
+        context.addIssue({ code: "custom", message: "Waiting run requires an unanswered question" });
+    }
+    if (run.status === "succeeded" && (!run.summary?.trim() || run.nodes.some(node => node.status !== "succeeded"))) {
+        context.addIssue({ code: "custom", message: "Successful run requires accepted nodes and summary" });
+    }
+});
+//# sourceMappingURL=records.js.map

package/dist/{task-storage.js → tasks/storage/store.js}

@@ -1,34 +1,8 @@
-import { DatabaseSync } from "node:sqlite";
+import { DatabaseSync } from "../../infrastructure/sqlite.js";
 import { mkdirSync } from "node:fs";
 import { join } from "node:path";
-import { z } from "zod";
-import { executorSchema, identifier, timestamp } from "./model.js";
-import { nodeSchema, questionSchema, taskSchema } from "./task-contract.js";
-const definitionSchema = z.object({
-    id: z.string().uuid(), input: taskSchema, workspace: z.string().nullable(), executors: z.record(identifier, executorSchema),
-    status: z.enum(["active", "paused", "cancelled", "completed", "expired"]),
-    nextAt: z.number().finite().nullable(), createdAt: timestamp,
-}).strict();
-const roundSchema = z.object({
-    id: z.string().uuid(), taskId: z.string().uuid(), scheduledAt: z.number().finite(),
-    status: z.enum(["running", "succeeded", "failed", "interrupted", "skipped", "cancelled", "timed_out", "waiting_input"]),
-    createdAt: timestamp, finishedAt: timestamp.nullable(), error: z.string().nullable(), skippedCount: z.number().int().nonnegative(),
-    steps: z.number().int().nonnegative(), coordinatorStartedAt: timestamp.nullable(), summary: z.string().nullable(),
-    waitedMs: z.number().finite().nonnegative(),
-    questions: z.array(questionSchema.extend({
-        id: z.string().uuid(), createdAt: timestamp, expiresAt: timestamp, sessionExpiresAt: timestamp.nullable(),
-        reply: z.object({ requestKey: identifier, answer: z.string().min(1).max(16000), receivedAt: timestamp }).strict().nullable(),
-    })).max(20),
-    nodes: z.array(z.object({
-        id: z.string().uuid(), definition: nodeSchema,
-        status: z.enum(["pending", "running", "awaiting_review", "succeeded", "failed", "blocked", "interrupted"]),
-        workspace: z.string().nullable(), inputFiles: z.array(z.string()), resultFile: z.string().nullable(), result: z.string().nullable(), acceptance: z.string().nullable(),
-        turns: z.array(z.object({ prompt: z.string(), output: z.string(), stopReason: z.string().nullable() }).strict()),
-        error: z.string().nullable(), sessionId: z.string().nullable(), startedAt: timestamp.nullable(), eventCount: z.number().int().nonnegative(),
-    }).strict()).min(1).max(20),
-}).strict();
-export class StorageError extends Error {
-}
+import { StorageError } from "../../shared/errors.js";
+import { definitionSchema, roundSchema } from "./records.js";
 /** Task definitions and rounds share one transactional store. */
 export class TaskStore {
     db;
@@ -40,56 +14,70 @@ export class TaskStore {
         try {
             const tables = this.db.prepare("SELECT name FROM sqlite_master WHERE type='table'").all();
             if (tables.length) {
-                this.db.prepare("SELECT seq,id,request_key,data FROM definitions LIMIT 0").all();
+                this.db.prepare("SELECT seq,id,workspace,request_key,data FROM definitions LIMIT 0").all();
                 this.db.prepare("SELECT seq,id,task_id,scheduled_at,data FROM rounds LIMIT 0").all();
+                this.definitions();
+                this.rounds();
             }
             this.db.exec("PRAGMA journal_mode=WAL; PRAGMA synchronous=FULL; PRAGMA foreign_keys=ON");
             if (!tables.length)
                 this.db.exec(`BEGIN IMMEDIATE;
-        CREATE TABLE definitions(seq INTEGER PRIMARY KEY, id TEXT UNIQUE NOT NULL, request_key TEXT UNIQUE NOT NULL, data TEXT NOT NULL);
+        CREATE TABLE definitions(seq INTEGER PRIMARY KEY, id TEXT UNIQUE NOT NULL, workspace TEXT NOT NULL,
+          request_key TEXT NOT NULL, data TEXT NOT NULL, UNIQUE(workspace,request_key));
         CREATE TABLE rounds(seq INTEGER PRIMARY KEY, id TEXT UNIQUE NOT NULL, task_id TEXT NOT NULL REFERENCES definitions(id),
           scheduled_at REAL NOT NULL, data TEXT NOT NULL, UNIQUE(task_id,scheduled_at));
         COMMIT;`);
         }
         catch (error) {
-            this.db.close();
+            this.close();
             throw error;
         }
     }
     check() { if (this.closed)
         throw new StorageError("Task storage closed"); }
+    decode(schema, data) {
+        try {
+            return schema.parse(JSON.parse(String(data)));
+        }
+        catch (error) {
+            this.close();
+            throw new StorageError("Invalid stored task data; no conversion or repair performed", { cause: error });
+        }
+    }
     definitions() {
         this.check();
-        return this.db.prepare("SELECT data FROM definitions ORDER BY seq").all().map(row => definitionSchema.parse(JSON.parse(String(row["data"]))));
+        return this.db.prepare("SELECT data FROM definitions ORDER BY seq").all().map(row => this.decode(definitionSchema, row["data"]));
     }
     rounds(taskId) {
         this.check();
         const rows = taskId ? this.db.prepare("SELECT data FROM rounds WHERE task_id=? ORDER BY seq").all(taskId)
             : this.db.prepare("SELECT data FROM rounds ORDER BY seq").all();
-        return rows.map(row => roundSchema.parse(JSON.parse(String(row["data"]))));
+        return rows.map(row => this.decode(roundSchema, row["data"]));
     }
     activeRounds(taskId) {
         this.check();
         const rows = taskId
             ? this.db.prepare("SELECT data FROM rounds WHERE task_id=? AND json_extract(data,'$.status') IN ('running','waiting_input')").all(taskId)
             : this.db.prepare("SELECT data FROM rounds WHERE json_extract(data,'$.status') IN ('running','waiting_input')").all();
-        return rows.map(row => roundSchema.parse(JSON.parse(String(row["data"]))));
+        return rows.map(row => this.decode(roundSchema, row["data"]));
     }
     get(id) {
         this.check();
         const row = this.db.prepare("SELECT data FROM definitions WHERE id=?").get(id);
         if (!row)
             throw new Error("Task not found");
-        return definitionSchema.parse(JSON.parse(String(row["data"])));
+        return this.decode(definitionSchema, row["data"]);
     }
     run(id) {
         this.check();
         const row = this.db.prepare("SELECT data FROM rounds WHERE id=?").get(id);
         if (!row)
             throw new Error("Task run not found");
-        return roundSchema.parse(JSON.parse(String(row["data"])));
+        return this.decode(roundSchema, row["data"]);
     }
     /** The service supplies all policy; the store commits a cursor and round atomically. */
+    saveDefinition(task) { this.commit(task); }
+    commitRun(run, task) { this.commit(task, run); }
     commit(definition, round) {
         this.check();
         if (definition)
@@ -99,8 +87,8 @@ export class TaskStore {
         try {
             this.db.exec("BEGIN IMMEDIATE");
             if (definition)
-                this.db.prepare(`INSERT INTO definitions(id,request_key,data) VALUES(?,?,?)
-        ON CONFLICT(id) DO UPDATE SET data=excluded.data`).run(definition.id, definition.input.requestKey, JSON.stringify(definition));
+                this.db.prepare(`INSERT INTO definitions(id,workspace,request_key,data) VALUES(?,?,?,?)
+        ON CONFLICT(id) DO UPDATE SET data=excluded.data`).run(definition.id, definition.workspace, definition.input.requestKey, JSON.stringify(definition));
             if (round)
                 this.db.prepare(`INSERT INTO rounds(id,task_id,scheduled_at,data) VALUES(?,?,?,?)
         ON CONFLICT(id) DO UPDATE SET data=excluded.data`).run(round.id, round.taskId, round.scheduledAt, JSON.stringify(round));
@@ -120,4 +108,4 @@ export class TaskStore {
         this.db.close();
     } }
 }
-//# sourceMappingURL=task-storage.js.map
+//# sourceMappingURL=store.js.map