@realqiyan/agent-task 0.0.1-rc.2 → 0.0.1-rc.3

package/dist/protocol/settings-contract.js

@@ -0,0 +1,40 @@
+import { SettingsError } from "../configuration/settings.js";
+import { z } from "zod";
+import { configSchema } from "../configuration/contract.js";
+import { executorSchema } from "../executors/validation.js";
+import { identifier } from "../shared/validation.js";
+export const settingsConfigSchema = z.object({
+    editToken: z.string().uuid(),
+    config: configSchema,
+    approveExecutors: z.array(identifier).max(100).default([]),
+}).strict();
+export const settingsChangeSchema = z.object({
+    editToken: z.string().uuid(),
+    change: z.discriminatedUnion("action", [
+        z.object({ action: z.literal("executor-add"), executor: executorSchema.omit({ unattendedApproved: true }) }).strict(),
+        z.object({ action: z.literal("executor-update"), id: identifier,
+            patch: executorSchema.omit({ unattendedApproved: true }).extend({ note: executorSchema.shape.note.removeDefault() }).partial() }).strict(),
+        z.object({ action: z.enum(["executor-remove", "executor-approve", "executor-revoke"]), id: identifier }).strict(),
+        z.object({ action: z.literal("coordinator-set"), coordinator: configSchema.shape.coordinator.unwrap() }).strict(),
+        z.object({ action: z.literal("coordinator-clear") }).strict(),
+    ]),
+}).strict();
+const credential = {
+    editToken: z.string().uuid(),
+    key: z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(200),
+};
+export const credentialUpdateSchema = z.discriminatedUnion("action", [
+    z.object({ ...credential, action: z.literal("replace"),
+        value: z.string().min(1).max(16_384).refine(value => Boolean(value.trim()) && !value.includes("\0")) }).strict(),
+    z.object({ ...credential, action: z.literal("delete") }).strict(),
+]);
+/** Reject with field paths only; rejected values and parser diagnostics can contain credentials. */
+export function parseSettings(schema, value) {
+    const result = schema.safeParse(value);
+    if (!result.success) {
+        const fields = result.error.issues.slice(0, 8).map(issue => issue.path.join(".") || "request");
+        throw new SettingsError("invalid", "Invalid fields: " + fields.join(", "));
+    }
+    return result.data;
+}
+//# sourceMappingURL=settings-contract.js.map

package/dist/protocol/task-contract.js

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import { requestTimestamp } from "../shared/validation.js";
+import { nodeData, replyData, taskData, taskUpdateData } from "../tasks/validation.js";
+export const nodeSchema = nodeData.extend({
+    prompt: z.string().trim().min(1).max(64_000),
+    dependsOn: nodeData.shape.dependsOn.default([]), maxRunSeconds: nodeData.shape.maxRunSeconds.default(600),
+});
+export const replySchema = replyData.extend({ answer: z.string().trim().min(1).max(16000) });
+export const taskIdSchema = z.object({ id: z.string().uuid() }).strict();
+export const taskListSchema = z.object({
+    after: z.number().int().nonnegative().default(0), limit: z.number().int().min(1).max(100).default(20),
+}).strict();
+export const taskRunListSchema = taskListSchema.extend({ taskId: z.string().uuid().optional() });
+export const taskUpdateSchema = taskUpdateData;
+export const taskSchema = taskData.extend({
+    name: z.string().trim().min(1).max(200),
+    prompt: z.string().trim().min(1).max(64_000).describe("Overall goal; the caller supplies the fixed DAG."),
+    nodes: z.array(nodeSchema).min(1).max(20).describe("Fixed DAG with an administrator-registered ACP executorId on every node."),
+    schedule: z.discriminatedUnion("type", [
+        z.object({ type: z.literal("now") }).strict(),
+        z.object({ type: z.literal("once"), at: requestTimestamp }).strict(),
+        z.object({ type: z.literal("interval"), startAt: requestTimestamp, seconds: z.number().int().min(60).max(31_536_000) }).strict(),
+    ]),
+    expiresAt: requestTimestamp.optional(),
+    maxRunSeconds: taskData.shape.maxRunSeconds.default(1800), maxSteps: taskData.shape.maxSteps.default(40),
+    maxNodeTurns: taskData.shape.maxNodeTurns.default(3), inputWaitSeconds: taskData.shape.inputWaitSeconds.default(86400),
+});
+//# sourceMappingURL=task-contract.js.map

package/dist/results/files.js

@@ -0,0 +1,70 @@
+import { mkdirSync, openSync, closeSync, writeFileSync, readFileSync, fstatSync, fsyncSync, realpathSync, statSync, constants } from "node:fs";
+import { join, relative, isAbsolute } from "node:path";
+import { OUTPUT_LIMIT } from "../shared/limits.js";
+/** Handles are local to each operation and always closed, including failure paths. */
+export class LocalResultFiles {
+    root;
+    constructor(root, create = false) {
+        this.root = root;
+        if (create)
+            mkdirSync(root, { recursive: true, mode: 0o700 });
+        if (realpathSync(root) !== root)
+            throw new Error("Result root must not be a symlink");
+    }
+    describe(path) {
+        const rel = relative(this.root, path);
+        return { canonical: realpathSync(this.root) === this.root && realpathSync(path) === path,
+            inside: Boolean(rel) && !rel.startsWith("..") && !isAbsolute(rel), regular: statSync(path).isFile() };
+    }
+    readable(path) {
+        const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+        try {
+            if (!fstatSync(fd).isFile())
+                throw new Error("Invalid result file");
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+    read(path) {
+        const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+        try {
+            const stat = fstatSync(fd);
+            if (!stat.isFile() || stat.size > OUTPUT_LIMIT)
+                throw new Error("Invalid or oversized input file");
+            const content = readFileSync(fd, "utf8");
+            if (Buffer.byteLength(content) > OUTPUT_LIMIT)
+                throw new Error("Input file grew beyond limit");
+            return content;
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+    save(taskRunId, nodeId, nodeRunId, text) {
+        const directory = join(this.root, taskRunId);
+        mkdirSync(directory, { recursive: true, mode: 0o700 });
+        if (realpathSync(directory) !== directory)
+            throw new Error("Result directory must not be a symlink");
+        const path = join(directory, nodeId + "." + nodeRunId + ".txt");
+        const fd = openSync(path, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+        try {
+            writeFileSync(fd, text, "utf8");
+            fsyncSync(fd);
+        }
+        finally {
+            closeSync(fd);
+        }
+        for (const dir of [directory, this.root]) {
+            const handle = openSync(dir, constants.O_RDONLY);
+            try {
+                fsyncSync(handle);
+            }
+            finally {
+                closeSync(handle);
+            }
+        }
+        return path;
+    }
+}
+//# sourceMappingURL=files.js.map

package/dist/results/ports.js

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

package/dist/results/service.js

@@ -0,0 +1,42 @@
+import { OUTPUT_LIMIT } from "../shared/limits.js";
+/** Authorization and content policy; the file adapter owns OS operations and durability. */
+export class Results {
+    files;
+    constructor(files) {
+        this.files = files;
+    }
+    get root() { return this.files.root; }
+    readable(path) {
+        const facts = this.files.describe(path);
+        if (!facts.canonical || !facts.inside || !facts.regular)
+            throw new Error("Invalid result file");
+        this.files.readable(path);
+    }
+    readInputFile(allowed, path, line = 1, limit) {
+        if (!allowed.includes(path))
+            throw new Error("Input file is not authorized for this run");
+        const facts = this.files.describe(path);
+        if (!facts.canonical)
+            throw new Error("Input file is not authorized for this run");
+        if (!facts.inside)
+            throw new Error("Input file outside result scope");
+        if (!facts.regular)
+            throw new Error("Invalid input file");
+        if (!Number.isInteger(line) || line < 1 || (limit !== undefined && (!Number.isInteger(limit) || limit < 1)))
+            throw new Error("Invalid line range");
+        const content = this.files.read(path);
+        if (line === 1 && limit === undefined)
+            return content;
+        return content.split("\n").slice(line - 1, limit === undefined ? undefined : line - 1 + limit).join("\n");
+    }
+    save(taskRunId, nodeId, nodeRunId, text) {
+        for (const id of [taskRunId, nodeId, nodeRunId]) {
+            if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,99}$/.test(id))
+                throw new Error("Invalid result identity");
+        }
+        if (Buffer.byteLength(text) > OUTPUT_LIMIT)
+            throw new Error("Result exceeds output limit");
+        return this.files.save(taskRunId, nodeId, nodeRunId, text);
+    }
+}
+//# sourceMappingURL=service.js.map

package/dist/shared/errors.js

@@ -0,0 +1,13 @@
+export function errorText(error) {
+    return (error instanceof Error ? error.message : String(error)).slice(0, 2000);
+}
+export class StorageError extends Error {
+}
+export class FileCommitError extends Error {
+    uncertain;
+    constructor(uncertain) {
+        super(uncertain ? "Configuration publication could not be confirmed; stop and inspect the files" : "Configuration was not published");
+        this.uncertain = uncertain;
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/shared/limits.js

@@ -0,0 +1,3 @@
+export const OUTPUT_LIMIT = 262_144;
+export const EVENT_LIMIT = 2000;
+//# sourceMappingURL=limits.js.map

package/dist/shared/time.js

@@ -0,0 +1,2 @@
+export function iso(now = Date.now()) { return new Date(now).toISOString(); }
+//# sourceMappingURL=time.js.map

package/dist/shared/validation.js

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export const identifier = z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,99}$/);
+/** Records must already be canonical; readers never normalize or fill missing data. */
+export const timestamp = z.string().datetime().refine(value => new Date(value).toISOString() === value, "Expected a canonical UTC timestamp");
+export const requestTimestamp = z.string().datetime({ offset: true }).transform(value => new Date(value).toISOString());
+export const absolutePath = z.string().min(1).max(4096).refine(value => value.startsWith("/") && !value.includes("\0"), "Expected an absolute path without NUL");
+export const text = (max) => z.string().min(1).max(max).refine(value => value.trim().length > 0 && value.trim() === value, "Expected normalized nonempty text");
+//# sourceMappingURL=validation.js.map

package/dist/tasks/definitions.js

@@ -0,0 +1,83 @@
+import { randomUUID } from "node:crypto";
+import { authorizedProfile } from "../executors/registry.js";
+import { iso } from "../shared/time.js";
+import { validateGraph } from "./graph.js";
+import { hasUncertainOutcome, initialTime, resumeSchedule } from "./schedule.js";
+import { taskData, taskUpdateData } from "./validation.js";
+/** Owns task definitions and future-trigger controls. Never writes a run. */
+export class TaskDefinitions {
+    store;
+    executors;
+    workspaces;
+    coordinatorConfigured;
+    closed = false;
+    constructor(store, executors, workspaces, coordinatorConfigured) {
+        this.store = store;
+        this.executors = executors;
+        this.workspaces = workspaces;
+        this.coordinatorConfigured = coordinatorConfigured;
+    }
+    check() { if (this.closed)
+        throw new Error("Task definition service closed"); }
+    create(value, now = Date.now()) {
+        this.check();
+        if (!this.coordinatorConfigured)
+            throw new Error("Coordinator is not configured");
+        const input = taskData.parse(value), all = this.store.definitions();
+        const existing = all.find(item => item.input.requestKey === input.requestKey);
+        if (existing) {
+            if (JSON.stringify(existing.input) !== JSON.stringify(input))
+                throw new Error("requestKey already used with different parameters");
+            return existing;
+        }
+        if (all.length >= 1000)
+            throw new Error("Task definition limit reached");
+        validateGraph(input.nodes);
+        const executors = this.executors.snapshot(input.nodes.map(node => node.executorId));
+        const nextAt = initialTime(input.schedule, now);
+        if (input.schedule.type !== "now" && nextAt < now)
+            throw new Error("Schedule must start in the future");
+        if (input.expiresAt && Date.parse(input.expiresAt) <= Math.max(now, nextAt))
+            throw new Error("Deadline must follow first trigger");
+        const task = { id: randomUUID(), input, workspace: input.workspace === undefined ? null : this.workspaces.resolve(input.workspace),
+            executors, nextAt, status: "active", createdAt: iso(now) };
+        this.store.saveDefinition(task);
+        return task;
+    }
+    get(id) { this.check(); return this.store.get(id); }
+    list(after = 0, limit = 20) {
+        this.check();
+        const all = this.store.definitions();
+        return { items: all.slice(after, after + limit), next: all.length > after + limit ? after + limit : null };
+    }
+    update(value, now = Date.now()) {
+        this.check();
+        const { id, action } = taskUpdateData.parse(value);
+        let task = this.store.get(id);
+        if (action === "cancel") {
+            task.status = "cancelled";
+            task.nextAt = null;
+        }
+        else {
+            if (task.nextAt === null || ["cancelled", "expired"].includes(task.status))
+                throw new Error("Task has no future schedule");
+            if (action === "pause")
+                task.status = "paused";
+            else {
+                if (this.store.rounds(id).some(hasUncertainOutcome))
+                    throw new Error("Task has uncertain external outcomes; future triggers require reconciliation");
+                task = resumeSchedule(task, now);
+            }
+        }
+        this.store.saveDefinition(task);
+        return task;
+    }
+    executorImpact(profiles) {
+        this.check();
+        return this.store.definitions().filter(task => ((task.nextAt !== null && ["active", "paused"].includes(task.status)) || this.store.activeRounds(task.id).length > 0) &&
+            Object.entries(task.executors).some(([id, snapshot]) => !authorizedProfile(snapshot, profiles.find(profile => profile.id === id))))
+            .map(task => ({ id: task.id, name: task.input.name }));
+    }
+    close() { this.closed = true; }
+}
+//# sourceMappingURL=definitions.js.map

package/dist/tasks/graph.js

@@ -0,0 +1,23 @@
+export function validateGraph(nodes) {
+    const graph = new Map(nodes.map(node => [node.id, node]));
+    if (!nodes.length || nodes.length > 20 || graph.size !== nodes.length)
+        throw new Error("Invalid or duplicate plan nodes");
+    const visited = new Set(), visiting = new Set();
+    const visit = (id) => {
+        if (visiting.has(id))
+            throw new Error("Cyclic dependency: " + id);
+        if (visited.has(id))
+            return;
+        const node = graph.get(id);
+        if (!node)
+            throw new Error("Unknown dependency: " + id);
+        if (new Set(node.dependsOn).size !== node.dependsOn.length)
+            throw new Error("Duplicate dependency");
+        visiting.add(id);
+        node.dependsOn.forEach(visit);
+        visiting.delete(id);
+        visited.add(id);
+    };
+    nodes.forEach(node => visit(node.id));
+}
+//# sourceMappingURL=graph.js.map

package/dist/{human-input.js → tasks/human-input.js}

@@ -1,7 +1,6 @@
-import { randomUUID } from "node:crypto";
-import { iso } from "./model.js";
+import { iso } from "../shared/time.js";
 /** Human facts are persisted business state, not executor permission or retry authorization. */
-export function askInput(run, request, seconds, now) {
+export function askInput(run, request, seconds, now, questionId) {
     if (run.status !== "running")
         throw new Error("Task run is not running");
     if (run.nodes.some(node => node.status === "running"))
@@ -10,12 +9,13 @@ export function askInput(run, request, seconds, now) {
         throw new Error("Unknown question node");
     if (run.questions.length >= 20)
         throw new Error("Question limit reached");
+    run = structuredClone(run);
     const sessions = run.nodes.filter(node => node.status === "awaiting_review");
-    const question = { ...request, id: randomUUID(), createdAt: iso(now), expiresAt: iso(now + seconds * 1000),
+    const question = { ...request, id: questionId, createdAt: iso(now), expiresAt: iso(now + seconds * 1000),
         sessionExpiresAt: sessions.length ? iso(Math.min(now + 300_000, ...sessions.map(node => Date.parse(node.startedAt) + node.definition.maxRunSeconds * 1000))) : null, reply: null };
     run.questions.push(question);
     run.status = "waiting_input";
-    return question;
+    return { run, question };
 }
 export function waitingFailure(run, now) {
     if (run.status !== "waiting_input")
@@ -29,6 +29,7 @@ export function waitingFailure(run, now) {
 }
 /** Exact retries return their receipt, even after completion/cancellation; they never reactivate a run. */
 export function applyReply(run, input, now) {
+    run = structuredClone(run);
     const question = run.questions.find(value => value.id === input.questionId);
     if (!question)
         throw new Error("Unknown question");
@@ -36,7 +37,7 @@ export function applyReply(run, input, now) {
     if (used) {
         if (used.id !== question.id || used.reply.answer !== input.answer)
             throw new Error("Reply requestKey already used with different parameters");
-        return false;
+        return undefined;
     }
     if (question.reply || run.questions.at(-1)?.id !== question.id)
         throw new Error("Question already answered or stale");
@@ -48,7 +49,7 @@ export function applyReply(run, input, now) {
     question.reply = { requestKey: input.requestKey, answer: input.answer, receivedAt: iso(now) };
     run.waitedMs += Math.max(0, now - Date.parse(question.createdAt));
     run.status = "running";
-    return true;
+    return run;
 }
 export function coordinatorInput(run) {
     const question = run.questions.findLast(value => value.reply !== null);

package/dist/tasks/model.js

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

package/dist/tasks/ports.js

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

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 ?? executor.cwd;
+            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: { ...executor, cwd: 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