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

package/dist/{web.js → protocol/http/web.js}

@@ -1,9 +1,11 @@
 import express from "express";
 import { fileURLToPath } from "node:url";
-import { bearerVerifier } from "./http-auth.js";
-import { SettingsError } from "./settings.js";
-import { StorageError } from "./task-storage.js";
-import { taskIdSchema, taskListSchema, taskRunListSchema, taskUpdateSchema } from "./task-contract.js";
+import { bearerVerifier } from "./auth.js";
+import { SettingsError } from "../../configuration/settings.js";
+import { previewSettings } from "../../configuration/management.js";
+import { StorageError } from "../../shared/errors.js";
+import { parseSettings, settingsConfigSchema, settingsChangeSchema, credentialUpdateSchema } from "../settings-contract.js";
+import { taskIdSchema, taskListSchema, taskRunListSchema, taskUpdateSchema } from "../task-contract.js";
 function query(schema, request) {
     const value = { ...request.query };
     for (const key of ["after", "limit"]) {
@@ -16,7 +18,7 @@ function query(schema, request) {
     }
     return schema.parse(value);
 }
-export function createWebRouter(tasks, settings, token, fatal) {
+export function createWebRouter(tasks, settings, token, fatal, restart, instanceId) {
     const router = express.Router(), authorized = bearerVerifier(token);
     router.use((req, res, next) => {
         res.set({
@@ -53,7 +55,7 @@ export function createWebRouter(tasks, settings, token, fatal) {
         next();
     });
     const assets = new Map(["index.html", "app.js", "api.js", "dom.js", "tasks-view.js", "settings-view.js", "style.css"]
-        .map(name => [name === "index.html" ? "/" : "/" + name, fileURLToPath(new URL("./web/" + name, import.meta.url))]));
+        .map(name => [name === "index.html" ? "/" : "/" + name, fileURLToPath(new URL("../../web/" + name, import.meta.url))]));
     router.get(["/", ...[...assets.keys()].filter(path => path !== "/")], (req, res) => {
         res.sendFile(assets.get(req.path), { lastModified: false, cacheControl: false, acceptRanges: false }, error => { if (error && !res.headersSent)
             res.status(404).end(); });
@@ -75,27 +77,38 @@ export function createWebRouter(tasks, settings, token, fatal) {
                 res.status(400).json({ error: "Request rejected; check inputs and refresh the current state" });
         }
     };
-    router.get("/api/status", respond(() => ({ ...tasks.status(), settings: settings.status() })));
+    router.get("/api/status", respond(() => ({ ...tasks.supervisor.status(), settings: settings.status(), instanceId })));
     router.get("/api/tasks", respond(req => {
-        const input = query(taskListSchema, req), page = tasks.list(input.after, input.limit);
+        const input = query(taskListSchema, req), page = tasks.definitions.list(input.after, input.limit);
         return { ...page, items: page.items.map(task => ({ id: task.id, name: task.input.name, status: task.status, nextAt: task.nextAt, schedule: task.input.schedule })) };
     }));
-    router.get("/api/tasks/:id", respond(req => tasks.get(taskIdSchema.parse(req.params).id)));
+    router.get("/api/tasks/:id", respond(req => tasks.definitions.get(taskIdSchema.parse(req.params).id)));
     router.get("/api/runs", respond(req => {
-        const input = query(taskRunListSchema, req), page = tasks.runs(input.taskId, input.after, input.limit);
+        const input = query(taskRunListSchema, req), page = tasks.runs.list(input.taskId, input.after, input.limit);
         return { ...page, items: page.items.map(run => ({ id: run.id, taskId: run.taskId, status: run.status,
                 createdAt: run.createdAt, finishedAt: run.finishedAt, error: run.error,
                 accepted: run.nodes.filter(node => node.status === "succeeded").length, total: run.nodes.length })) };
     }));
-    router.get("/api/runs/:id", respond(req => tasks.run(taskIdSchema.parse(req.params).id)));
-    router.post("/api/task-update", respond(req => tasks.update(taskUpdateSchema.parse(req.body))));
+    router.get("/api/runs/:id", respond(req => tasks.runs.get(taskIdSchema.parse(req.params).id)));
+    router.post("/api/task-update", respond(req => tasks.definitions.update(taskUpdateSchema.parse(req.body))));
     router.get("/api/settings", respond(() => settings.get()));
-    router.post("/api/settings/validate", respond(req => {
-        const config = settings.validate(req.body);
-        return { config, affectedTasks: tasks.executorImpact(config.executors) };
-    }));
-    router.post("/api/settings/config", respond(req => settings.saveConfig(req.body)));
-    router.post("/api/settings/credential", respond(req => settings.saveCredential(req.body)));
+    router.get("/api/settings/diff", respond(() => settings.diff()));
+    router.post("/api/settings/prepare", respond(req => settings.prepareChange(parseSettings(settingsChangeSchema, req.body))));
+    router.post("/api/settings/validate", respond(req => previewSettings(settings, tasks.definitions, parseSettings(settingsConfigSchema, req.body))));
+    router.post("/api/settings/config", respond(req => settings.saveConfig(parseSettings(settingsConfigSchema, req.body))));
+    router.post("/api/settings/credential", respond(req => settings.saveCredential(parseSettings(credentialUpdateSchema, req.body))));
+    router.post("/api/restart", async (req, res) => {
+        if (!req.body || Array.isArray(req.body) || typeof req.body !== "object" || Object.keys(req.body).length) {
+            res.status(400).json({ error: "Expected an empty request" });
+            return;
+        }
+        try {
+            res.json({ data: await restart() });
+        }
+        catch {
+            res.status(503).json({ error: "Restart could not be confirmed; inspect private logs and use CLI status before retrying" });
+        }
+    });
     router.use((_req, res) => { res.status(404).end(); });
     router.use(((error, _req, res, _next) => {
         res.status(error.status === 413 ? 413 : error.status === 415 ? 415 : 400).json({ error: "Invalid request body" });

package/dist/{mcp.js → protocol/mcp.js}

@@ -1,9 +1,9 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
-import { errorText } from "./model.js";
-import { StorageError } from "./task-storage.js";
+import { errorText } from "../shared/errors.js";
+import { StorageError } from "../shared/errors.js";
 import { replySchema, taskSchema, taskUpdateSchema, taskIdSchema, taskListSchema, taskRunListSchema } from "./task-contract.js";
-import { version } from "./version.js";
+import { version } from "../infrastructure/version.js";
 export function createMcpServer(service, fatal) {
     const server = new McpServer({ name: "agent-task", version });
     function register(name, description, inputSchema, execute, readOnly = true) {
@@ -25,16 +25,16 @@ export function createMcpServer(service, fatal) {
                 isError: !value.ok };
         });
     }
-    register("service_status", "Service health and active node run IDs. MCP disconnection does not cancel tasks.", z.object({}).strict(), () => service.status());
-    register("executor_list", "Registered local ACP execution profiles and authorization settings. Approval filtering is not a sandbox.", z.object({}).strict(), () => service.listExecutors());
-    register("task_create", "Create a task with a caller-defined DAG in nodes. Each node selects an administrator-registered ACP executorId. The coordinator advances this fixed DAG, reviews deliveries and requests missing user facts; it does not plan new nodes. Optional workspace selects an existing absolute directory; otherwise each executor uses its registered cwd. Path checks do not grant permissions; no uncertain-effect retries.", taskSchema, input => service.create(input), false);
-    register("task_list", "List persisted task definitions.", taskListSchema, input => service.list(input.after, input.limit));
-    register("task_get", "Get task goal, caller-defined DAG and assigned executor profiles, canonical workspace (null means executor cwd defaults), budgets and schedule.", taskIdSchema, input => service.get(input.id));
-    register("task_update", "Pause, resume or cancel future triggers only; resume never catches up. To change a task, cancel it and create a new task. Use task_run_cancel to stop an active run; cancellation does not roll back external effects.", taskUpdateSchema, input => service.update(input), false);
-    register("task_run_list", "List independent task runs with node progress and blocking reasons.", taskRunListSchema, input => service.runs(input.taskId, input.after, input.limit));
-    register("task_run_get", "Get the committed plan, selected node workspaces, ACP turns, accepted deliveries, blocking questions and errors for one task run.", taskIdSchema, input => service.run(input.id));
-    register("task_run_reply", "Answer a persisted question on the same task run. Deduplicated by requestKey; no permission escalation or uncertain-effect replay.", replySchema, input => service.reply(input), false);
-    register("task_run_cancel", "Stop this task run; external effects are not rolled back.", taskIdSchema, input => service.cancel(input.id), false);
+    register("service_status", "Service health and active node run IDs. MCP disconnection does not cancel tasks.", z.object({}).strict(), () => service.supervisor.status());
+    register("executor_list", "Registered local ACP execution profiles and authorization settings. Approval filtering is not a sandbox.", z.object({}).strict(), () => service.executors.list());
+    register("task_create", "Create a task with a caller-defined DAG in nodes. Each node selects an administrator-registered ACP executorId. The coordinator advances this fixed DAG, reviews deliveries and requests missing user facts; it does not plan new nodes. Optional workspace selects an existing absolute directory; otherwise each executor uses its registered cwd. Path checks do not grant permissions; no uncertain-effect retries.", taskSchema, input => service.definitions.create(input), false);
+    register("task_list", "List persisted task definitions.", taskListSchema, input => service.definitions.list(input.after, input.limit));
+    register("task_get", "Get task goal, caller-defined DAG and assigned executor profiles, canonical workspace (null means executor cwd defaults), budgets and schedule.", taskIdSchema, input => service.definitions.get(input.id));
+    register("task_update", "Pause, resume or cancel future triggers only; resume never catches up. To change a task, cancel it and create a new task. Use task_run_cancel to stop an active run; cancellation does not roll back external effects.", taskUpdateSchema, input => service.definitions.update(input), false);
+    register("task_run_list", "List independent task runs with node progress and blocking reasons.", taskRunListSchema, input => service.runs.list(input.taskId, input.after, input.limit));
+    register("task_run_get", "Get the committed plan, selected node workspaces, ACP turns, accepted deliveries, blocking questions and errors for one task run.", taskIdSchema, input => service.runs.get(input.id));
+    register("task_run_reply", "Answer a persisted question on the same task run. Deduplicated by requestKey; no permission escalation or uncertain-effect replay.", replySchema, input => service.supervisor.reply(input), false);
+    register("task_run_cancel", "Stop this task run; external effects are not rolled back.", taskIdSchema, input => service.supervisor.cancel(input.id), false);
     return server;
 }
 //# sourceMappingURL=mcp.js.map

package/dist/protocol/services.js

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

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