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

package/dist/results.js

@@ -1,79 +0,0 @@
-import { mkdirSync, openSync, closeSync, writeFileSync, readFileSync, fstatSync, fsyncSync, realpathSync, statSync, accessSync, constants } from "node:fs";
-import { join, relative, isAbsolute } from "node:path";
-import { OUTPUT_LIMIT } from "./model.js";
-/** Exact upstream files within dataDir/results, never a general dataDir read capability. */
-export function readInputFile(root, allowed, path, line = 1, limit) {
-    if (!allowed.includes(path) || realpathSync(path) !== path)
-        throw new Error("Input file is not authorized for this run");
-    const rel = relative(root, path);
-    if (realpathSync(root) !== root || !rel || rel.startsWith("..") || isAbsolute(rel))
-        throw new Error("Input file outside result scope");
-    if (!Number.isInteger(line) || line < 1 || (limit !== undefined && (!Number.isInteger(limit) || limit < 1)))
-        throw new Error("Invalid line range");
-    const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW);
-    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");
-        if (line === 1 && limit === undefined)
-            return content;
-        return content.split("\n").slice(line - 1, limit === undefined ? undefined : line - 1 + limit).join("\n");
-    }
-    finally {
-        closeSync(fd);
-    }
-}
-export class Results {
-    root;
-    constructor(directory) {
-        mkdirSync(join(directory, "results"), { recursive: true, mode: 0o700 });
-        this.root = join(directory, "results");
-        if (realpathSync(this.root) !== this.root)
-            throw new Error("Result root must not be a symlink");
-    }
-    inside(root, path) {
-        const rel = relative(root, path);
-        return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
-    }
-    readable(path) {
-        if (realpathSync(path) !== path || !this.inside(this.root, path) || !statSync(path).isFile())
-            throw new Error("Invalid result file");
-        accessSync(path, constants.R_OK);
-        // Actually open it. Native agent sandbox access remains an administrator-reviewed prerequisite.
-        const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW);
-        closeSync(fd);
-    }
-    save(taskRunId, nodeId, runId, text) {
-        for (const id of [taskRunId, nodeId, runId]) {
-            if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,99}$/.test(id))
-                throw new Error("Invalid result identity");
-        }
-        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 + "." + runId + ".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=results.js.map

package/dist/settings-contract.js

@@ -1,16 +0,0 @@
-import { z } from "zod";
-import { configSchema } from "./config.js";
-export const settingsConfigSchema = z.object({
-    editToken: z.string().uuid(),
-    config: configSchema,
-}).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(),
-]);
-//# sourceMappingURL=settings-contract.js.map

package/dist/task-contract.js

@@ -1,37 +0,0 @@
-import { z } from "zod";
-import { isAbsolute } from "node:path";
-import { identifier, scheduleSchema, timestamp } from "./model.js";
-export const nodeSchema = z.object({
-    id: identifier, prompt: z.string().trim().min(1).max(64_000),
-    executorId: identifier.describe("Administrator-registered ACP executor assigned to this node; not a command or URL."),
-    dependsOn: z.array(identifier).max(20).default([]),
-    maxRunSeconds: z.number().int().min(1).max(3600).default(600),
-}).strict();
-export const questionSchema = z.object({
-    nodeId: identifier.optional(), question: z.string().trim().min(1).max(4000),
-    completedWork: z.string().trim().min(1).max(4000),
-}).strict();
-export const replySchema = z.object({
-    runId: z.string().uuid(), questionId: z.string().uuid(), requestKey: identifier,
-    answer: z.string().trim().min(1).max(16000),
-}).strict();
-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 = z.object({
-    id: z.string().uuid(), action: z.enum(["pause", "resume", "cancel"]),
-}).strict();
-export const taskSchema = z.object({
-    requestKey: identifier, name: z.string().trim().min(1).max(200),
-    prompt: z.string().trim().min(1).max(64_000).describe("Overall goal and coordination constraints; does not generate or replace the DAG."),
-    nodes: z.array(nodeSchema).min(1).max(20).describe("Caller-defined fixed DAG. Each node specifies its prompt, executorId and direct dependencies."),
-    workspace: z.string().min(1).max(4096).refine(path => isAbsolute(path) && !path.includes("\0"), "Workspace must be an absolute path without NUL").optional(),
-    schedule: scheduleSchema, expiresAt: timestamp.optional(),
-    maxRunSeconds: z.number().int().min(1).max(86_400).default(1800),
-    maxSteps: z.number().int().min(1).max(200).default(40),
-    maxNodeTurns: z.number().int().min(1).max(10).default(3),
-    inputWaitSeconds: z.number().int().min(1).max(604800).default(86400),
-}).strict();
-//# sourceMappingURL=task-contract.js.map

package/dist/task-model.js

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

package/dist/tasks.js

@@ -1,508 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { errorText, EVENT_LIMIT, GRACE_MS, initialTime, iso, OUTPUT_LIMIT } from "./model.js";
-import { TaskStore, StorageError } from "./task-storage.js";
-import { Results } from "./results.js";
-import { questionSchema, replySchema, taskSchema, taskUpdateSchema } from "./task-contract.js";
-import { applyReply, askInput, coordinatorInput, waitingFailure } from "./human-input.js";
-import { resolveWorkspace, checkWorkspace } from "./workspace.js";
-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));
-}
-function authorizedProfile(snapshot, current) {
-    return Boolean(snapshot && current?.unattendedApproved && snapshot.unattendedApproved &&
-        snapshot.id === current.id && snapshot.type === current.type && snapshot.cwd === current.cwd);
-}
-export class Tasks {
-    store;
-    executors;
-    results;
-    openExecution;
-    coordinate;
-    fatal;
-    closed = false;
-    closing;
-    timer;
-    active = new Map();
-    sessions = new Map();
-    constructor(store, executors, results, openExecution, coordinate, fatal) {
-        this.store = store;
-        this.executors = executors;
-        this.results = results;
-        this.openExecution = openExecution;
-        this.coordinate = coordinate;
-        this.fatal = fatal;
-    }
-    check() { if (this.closed)
-        throw new Error("Task service closed"); }
-    running(id) {
-        this.check();
-        const run = this.store.run(id);
-        if (run.status !== "running")
-            throw new Error("Task run is not running: " + run.status);
-        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;
-    }
-    status() {
-        return { running: !this.closed && this.timer !== undefined && this.store.healthy,
-            activeTaskRunIds: [...this.active.keys()], activeNodeRunIds: [...this.sessions.keys()], storageHealthy: this.store.healthy };
-    }
-    listExecutors() {
-        this.check();
-        return { executors: this.executors.map(executor => ({ ...executor, transport: "stdio" })) };
-    }
-    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 }));
-    }
-    create(value, now = Date.now()) {
-        this.check();
-        if (!this.coordinate)
-            throw new Error("Coordinator is not configured");
-        const input = taskSchema.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 = Object.create(null);
-        for (const node of input.nodes) {
-            const executor = this.executors.find(item => item.id === node.executorId);
-            if (!executor?.unattendedApproved)
-                throw new Error("Executor not found or not approved: " + node.executorId);
-            executors[node.executorId] = structuredClone(executor);
-        }
-        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 : resolveWorkspace(input.workspace), executors, nextAt, status: "active", createdAt: iso(now) };
-        this.store.commit(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 };
-    }
-    run(id) { this.check(); return this.store.run(id); }
-    runs(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 };
-    }
-    update(value, now = Date.now()) {
-        this.check();
-        const { id, action } = taskUpdateSchema.parse(value);
-        const 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");
-            task.status = action === "pause" ? "paused" : "active";
-            if (action === "resume" && task.nextAt < now) {
-                if (task.input.schedule.type === "interval")
-                    task.nextAt += (Math.floor((now - task.nextAt) / (task.input.schedule.seconds * 1000)) + 1) * task.input.schedule.seconds * 1000;
-                else {
-                    task.nextAt = null;
-                    task.status = "completed";
-                }
-            }
-        }
-        this.store.commit(task);
-        return task;
-    }
-    /** Only the calendar is automatic. The coordinator alone chooses node dispatch. */
-    trigger(now = Date.now()) {
-        this.check();
-        for (const task of this.store.definitions()) {
-            if (task.status !== "active" || task.nextAt === null)
-                continue;
-            if (task.input.expiresAt && now >= Date.parse(task.input.expiresAt)) {
-                task.status = "expired";
-                task.nextAt = null;
-                this.store.commit(task);
-                continue;
-            }
-            if (task.nextAt > now)
-                continue;
-            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);
-            const reason = this.store.activeRounds(task.id).length ? "Previous round still active; slot skipped"
-                : now - at > GRACE_MS ? "Late slot skipped" : null;
-            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 = schedule.type === "interval" ? at + schedule.seconds * 1000 : null;
-            if (task.nextAt === null)
-                task.status = "completed";
-            this.store.commit(task, run);
-        }
-    }
-    actions(id, requestId = coordinatorInput(this.store.run(id)).requestId) {
-        const current = () => {
-            const run = this.running(id);
-            if (coordinatorInput(run).requestId !== requestId)
-                throw new Error("Stale coordinator input");
-            return run;
-        };
-        return {
-            inspect: () => { const run = current(); return { task: this.store.get(run.taskId).input, run }; },
-            step: () => {
-                const run = current(), 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.commit(undefined, run);
-            },
-            converse: (node, message) => { current(); return this.converse(id, node, message); },
-            accept: (node, turn, result, reason) => { current(); return this.accept(id, node, turn, result, reason); },
-            ask: request => {
-                const run = current(), task = this.store.get(run.taskId);
-                const question = askInput(run, questionSchema.parse(request), task.input.inputWaitSeconds, Date.now());
-                this.store.commit(undefined, run);
-                clearTimeout(this.active.get(id)?.timer);
-                return question;
-            },
-            finish: summary => {
-                const run = current();
-                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.commit(undefined, run);
-            },
-            stop: (status, reason) => {
-                current();
-                this.end(id, status, reason);
-                // Do not leave parallel ACP turns running while durable waits for the tool round to settle.
-                for (const [nodeId, session] of this.sessions)
-                    if (session.runId === id)
-                        void this.closeSession(nodeId).catch(this.fatal);
-            },
-        };
-    }
-    authorized(task, id) {
-        const executor = task.executors[id], current = this.executors.find(value => value.id === id);
-        if (!executor || !authorizedProfile(executor, current))
-            throw new Error("Executor authorization revoked or changed");
-        return executor;
-    }
-    async converse(id, nodeId, message) {
-        const run = this.running(id), task = this.store.get(run.taskId), node = this.node(run, nodeId);
-        const executor = this.authorized(task, 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");
-        if (node.status === "pending") {
-            if (task.input.expiresAt && Date.now() >= Date.parse(task.input.expiresAt))
-                throw new Error("Deadline reached before node start");
-            if (this.sessions.size >= 8)
-                throw new Error("ACP session capacity reached; accept existing results first");
-            node.workspace = task.workspace ?? executor.cwd;
-            checkWorkspace(node.workspace);
-            node.inputFiles = parents.map(parent => parent.resultFile);
-        }
-        else if (!this.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();
-        // This commit is the no-replay barrier, before even starting the worker.
-        this.store.commit(undefined, run);
-        try {
-            let active = this.sessions.get(node.id);
-            if (!active) {
-                const handle = this.openExecution({ executor: { ...executor, cwd: node.workspace }, inputFiles: node.inputFiles, resultsRoot: this.results.root }, (kind, data, output) => this.record(id, nodeId, kind, data, output), () => {
-                    this.running(id);
-                    this.authorized(task, node.definition.executorId);
-                    checkWorkspace(node.workspace);
-                    if (task.input.expiresAt && Date.now() >= Date.parse(task.input.expiresAt))
-                        throw new Error("Deadline reached before ACP start");
-                });
-                active = { runId: id, handle, closing: false,
-                    timer: setTimeout(() => {
-                        const waiting = this.store.run(id).status === "waiting_input";
-                        this.stopActive(id, waiting ? "interrupted" : "timed_out", waiting
-                            ? "ACP session lifetime expired while waiting; no replay" : "ACP node session timed out");
-                    }, node.definition.maxRunSeconds * 1000) };
-                this.sessions.set(node.id, active);
-                const owned = active;
-                void handle.closed.then(() => {
-                    if (!owned.closing && !this.closed && this.store.healthy)
-                        this.stopActive(id, "interrupted", "ACP session disconnected; external effects unknown");
-                }).catch(this.fatal);
-            }
-            const result = await active.handle.prompt(text);
-            const current = this.running(id), saved = this.node(current, nodeId);
-            saved.turns.at(-1).stopReason = result.stopReason;
-            // An ended turn is only material for the coordinator to review, never a deliverable.
-            saved.status = "awaiting_review";
-            this.store.commit(undefined, current);
-            if (result.stopReason !== "end_turn")
-                this.stopActive(id, "failed", "ACP stopped: " + result.stopReason);
-            return this.node(this.store.run(id), nodeId);
-        }
-        catch (error) {
-            if (error instanceof StorageError) {
-                this.fatal(error);
-                throw error;
-            }
-            if (this.store.healthy)
-                this.stopActive(id, "interrupted", errorText(error));
-            throw error;
-        }
-    }
-    record(id, nodeId, kind, data, text) {
-        const run = this.running(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.commit(undefined, run);
-    }
-    async accept(id, nodeId, turn, result, reason) {
-        const run = this.running(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");
-        // Save the selected delivery, not the conversation or the coordinator's rewritten answer.
-        node.resultFile = this.results.save(run.id, node.definition.id, node.id, result);
-        node.result = result;
-        node.acceptance = reason;
-        node.status = "succeeded";
-        this.store.commit(undefined, run);
-        await this.closeSession(node.id);
-    }
-    async closeSession(id) {
-        const active = this.sessions.get(id);
-        if (!active)
-            return;
-        active.closing = true;
-        clearTimeout(active.timer);
-        await active.handle.close();
-        this.sessions.delete(id);
-    }
-    end(id, status, reason) {
-        const run = this.store.run(id);
-        if (!["running", "waiting_input"].includes(run.status))
-            return;
-        const wasWaiting = run.status === "waiting_input";
-        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) && task.nextAt !== null && task.status !== "cancelled")
-            task.status = "paused";
-        this.store.commit(task, run);
-    }
-    stopActive(id, status, reason) {
-        try {
-            this.end(id, status, reason);
-            this.active.get(id)?.controller.abort(new Error(reason));
-            for (const [nodeId, session] of this.sessions)
-                if (session.runId === id)
-                    void this.closeSession(nodeId).catch(this.fatal);
-        }
-        catch (error) {
-            this.fatal(error);
-        }
-    }
-    reply(value, now = Date.now()) {
-        this.check();
-        const input = replySchema.parse(value);
-        this.expireWaiting(this.store.run(input.runId), now);
-        const run = this.store.run(input.runId);
-        if (!applyReply(run, input, now))
-            return run;
-        const task = this.store.get(run.taskId);
-        for (const node of run.nodes) {
-            if (node.status !== "succeeded")
-                this.authorized(task, node.definition.executorId);
-            if (node.status === "awaiting_review" && (!this.sessions.has(node.id) || this.sessions.get(node.id).closing)) {
-                this.stopActive(run.id, "interrupted", "ACP session unavailable at human reply; no replay");
-                throw new Error("ACP session unavailable; reconcile external effects first");
-            }
-        }
-        this.store.commit(undefined, run);
-        return run;
-    }
-    expireWaiting(run, now) {
-        const failure = waitingFailure(run, now);
-        if (failure)
-            this.stopActive(run.id, failure.status, failure.reason);
-    }
-    cancel(id) { this.check(); this.stopActive(id, "cancelled", "Run cancelled; external effects are not rolled back"); return this.store.run(id); }
-    recover() {
-        this.check();
-        for (const run of this.store.activeRounds()) {
-            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, Date.now());
-        }
-    }
-    start() {
-        this.check();
-        if (this.timer)
-            throw new Error("Task service already started");
-        this.recover();
-        this.timer = setInterval(() => this.tick(), 500);
-        this.tick();
-    }
-    tick() {
-        if (this.closed)
-            return;
-        try {
-            this.trigger();
-            for (const run of this.store.activeRounds()) {
-                if (run.status === "waiting_input") {
-                    this.expireWaiting(run, Date.now());
-                    continue;
-                }
-                if (this.active.has(run.id) || this.active.size >= 4)
-                    continue;
-                this.launch(run);
-            }
-        }
-        catch (error) {
-            if (this.timer)
-                clearInterval(this.timer);
-            this.fatal(error);
-        }
-    }
-    launch(run) {
-        const task = this.store.get(run.taskId);
-        if (!this.coordinate) {
-            this.end(run.id, "failed", "Coordinator not configured");
-            return;
-        }
-        if (!run.coordinatorStartedAt && task.input.expiresAt && Date.now() >= Date.parse(task.input.expiresAt)) {
-            this.end(run.id, "failed", "Deadline reached before coordinator start");
-            return;
-        }
-        run.coordinatorStartedAt ??= iso();
-        this.store.commit(undefined, run);
-        const remaining = Date.parse(run.coordinatorStartedAt) + run.waitedMs + task.input.maxRunSeconds * 1000 - Date.now();
-        if (remaining <= 0) {
-            this.end(run.id, "timed_out", "Task run deadline reached");
-            return;
-        }
-        const input = coordinatorInput(run);
-        const stillCurrent = () => {
-            const current = this.store.run(run.id);
-            return current.status === "running" && coordinatorInput(current).requestId === input.requestId;
-        };
-        const controller = new AbortController();
-        const timer = setTimeout(() => this.stopActive(run.id, "timed_out", "Task run timed out"), remaining);
-        // Defer entry so cancellation always finds the controller before external work starts.
-        const completion = Promise.resolve().then(() => this.coordinate(run.id, input, this.actions(run.id, input.requestId), controller.signal))
-            .then(() => { if (!this.closed && stillCurrent())
-            this.end(run.id, "failed", "Coordinator ended without an explicit completion or blocking decision"); }, error => {
-            if (error instanceof StorageError)
-                throw error;
-            if (!this.closed && this.store.healthy && stillCurrent())
-                this.end(run.id, "failed", errorText(error));
-        }).catch(this.fatal).finally(async () => {
-            clearTimeout(timer);
-            try {
-                if (!this.store.healthy || !["running", "waiting_input"].includes(this.store.run(run.id).status)) {
-                    await Promise.all([...this.sessions].filter(([, session]) => session.runId === run.id).map(([id]) => this.closeSession(id)));
-                }
-            }
-            finally {
-                this.active.delete(run.id);
-            }
-        }).catch(this.fatal);
-        this.active.set(run.id, { controller, completion, timer });
-    }
-    close() { return this.closing ??= this.stop(); }
-    async stop() {
-        if (this.closed)
-            return;
-        if (this.timer)
-            clearInterval(this.timer);
-        // Waiting runs may own sessions without an active coordinator.
-        for (const id of new Set([...this.sessions.values()].map(session => session.runId))) {
-            this.end(id, "interrupted", "Service stopped with an open ACP session");
-        }
-        for (const [, active] of this.active) {
-            active.controller.abort(new Error("Service stopping"));
-        }
-        this.closed = true;
-        await Promise.all([...this.sessions.keys()].map(id => this.closeSession(id)));
-        await Promise.all([...this.active.values()].map(active => active.completion));
-    }
-}
-//# sourceMappingURL=tasks.js.map

package/dist/version.js

@@ -1,3 +0,0 @@
-import { readFileSync } from "node:fs";
-export const version = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
-//# sourceMappingURL=version.js.map