@realqiyan/agent-task 0.0.0-stage → 0.0.1-rc.2

package/dist/model.js

@@ -0,0 +1,25 @@
+import { z } from "zod";
+export const timestamp = z.string().datetime({ offset: true }).transform(value => new Date(value).toISOString());
+export const identifier = z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,99}$/);
+export const scheduleSchema = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("now") }).strict(),
+    z.object({ type: z.literal("once"), at: timestamp }).strict(),
+    z.object({ type: z.literal("interval"), startAt: timestamp,
+        seconds: z.number().int().min(60).max(31_536_000) }).strict(),
+]);
+export const executorSchema = z.object({
+    id: identifier,
+    type: z.enum(["pi", "codex", "claude", "opencode"]),
+    note: z.string().max(2000).default(""),
+    cwd: z.string().min(1),
+    unattendedApproved: z.boolean().default(false),
+}).strict();
+export const OUTPUT_LIMIT = 262_144;
+export const EVENT_LIMIT = 2000;
+export const GRACE_MS = 30_000;
+export function iso(now = Date.now()) { return new Date(now).toISOString(); }
+export function errorText(error) { return (error instanceof Error ? error.message : String(error)).slice(0, 2000); }
+export function initialTime(schedule, now) {
+    return schedule.type === "now" ? now : Date.parse(schedule.type === "once" ? schedule.at : schedule.startAt);
+}
+//# sourceMappingURL=model.js.map

package/dist/node-execution.js

@@ -0,0 +1,102 @@
+import { fork } from "node:child_process";
+import { fileURLToPath } from "node:url";
+/** One supervised worker and ACP session per node, retained across turns. */
+export const createExecution = (environment) => (input, event, beforeStart) => {
+    const worker = fork(fileURLToPath(new URL("./worker.js", import.meta.url)), [], {
+        env: { ...environment }, stdio: ["ignore", "ignore", "pipe", "ipc"], execArgv: [],
+    });
+    worker.stderr?.resume();
+    let stopped = false, exited = false, busy = false;
+    let failure;
+    let kill, hardKill;
+    let turn;
+    let readyResolve, readyReject;
+    const ready = new Promise((resolve, reject) => { readyResolve = resolve; readyReject = reject; });
+    void ready.catch(() => { });
+    let done;
+    const closed = new Promise(resolve => { done = resolve; });
+    const close = () => {
+        if (!stopped && !exited) {
+            stopped = true;
+            readyReject(new Error("Execution stopped"));
+            turn?.reject(new Error("Execution stopped"));
+            turn = undefined;
+            if (worker.connected)
+                worker.send({ type: "close" }, () => { });
+            kill = setTimeout(() => worker.kill("SIGTERM"), 3000);
+            hardKill = setTimeout(() => worker.kill("SIGKILL"), 6000);
+        }
+        return closed;
+    };
+    const fail = (error) => { failure = error; readyReject(error); turn?.reject(error); turn = undefined; void close(); };
+    worker.on("error", fail);
+    worker.on("message", (message) => {
+        try {
+            if (message.type === "ready") {
+                if (stopped) {
+                    if (worker.connected)
+                        worker.disconnect();
+                    return;
+                }
+                beforeStart();
+                worker.send({ type: "open", input }, error => { if (error)
+                    fail(error); });
+            }
+            else if (message.type === "opened")
+                readyResolve();
+            else if (message.type === "event" && message.kind && message.seq !== undefined) {
+                event(message.kind, message.data ?? null, message.text ?? "");
+                if (worker.connected)
+                    worker.send({ type: "ack", seq: message.seq }, () => { });
+            }
+            else if (message.type === "turn") {
+                turn?.resolve({ stopReason: message.stopReason ?? "unknown" });
+                turn = undefined;
+            }
+            else if (message.type === "failed")
+                fail(new Error(message.error ?? "Worker failed"));
+        }
+        catch (error) {
+            fail(error);
+        }
+    });
+    const settle = () => {
+        if (exited)
+            return;
+        exited = true;
+        worker.stderr?.destroy();
+        if (kill)
+            clearTimeout(kill);
+        if (hardKill)
+            clearTimeout(hardKill);
+        const error = failure ?? new Error("Execution stopped or disconnected; external effects may be unknown");
+        readyReject(error);
+        turn?.reject(error);
+        turn = undefined;
+        done();
+    };
+    worker.once("exit", settle);
+    worker.once("close", settle);
+    return {
+        closed, close,
+        async prompt(text) {
+            if (stopped || exited || busy)
+                throw new Error("Execution closed or busy");
+            busy = true;
+            try {
+                await ready;
+                if (stopped || exited)
+                    throw new Error("Execution stopped");
+                return await new Promise((resolve, reject) => {
+                    turn = { resolve, reject };
+                    worker.send({ type: "prompt", text }, error => { if (error)
+                        fail(error); });
+                });
+            }
+            finally {
+                busy = false;
+            }
+        },
+    };
+};
+//# sourceMappingURL=node-execution.js.map

package/dist/permissions.js

@@ -0,0 +1,9 @@
+/** Applies only to ACP requests that actually ask for approval; this is not a sandbox. */
+export function permissionDecision(request, cancelled = false) {
+    if (cancelled)
+        return { outcome: { outcome: "cancelled" } };
+    // Native authorization must suffice. A new ACP approval would widen it.
+    const option = request.options.find(value => value.kind === "reject_once");
+    return option ? { outcome: { outcome: "selected", optionId: option.optionId } } : { outcome: { outcome: "cancelled" } };
+}
+//# sourceMappingURL=permissions.js.map

package/dist/private-files.js

@@ -0,0 +1,95 @@
+import { existsSync, constants, openSync, closeSync, fstatSync, lstatSync, realpathSync, readFileSync, writeFileSync, fsyncSync, renameSync, unlinkSync } from "node:fs";
+import { dirname, basename, join, isAbsolute, resolve } from "node:path";
+import { randomUUID } from "node:crypto";
+export function checkDataDirectory(path) {
+    if (!isAbsolute(path) || resolve(path) !== path || /[\x00-\x1f\x7f]/.test(path))
+        throw new Error("Expected a canonical absolute dataDir");
+    let parent = path;
+    while (!existsSync(parent))
+        parent = dirname(parent);
+    if (realpathSync(parent) !== parent || !lstatSync(parent).isDirectory())
+        throw new Error("dataDir must not traverse symlinks");
+    if (parent === path) {
+        const stat = lstatSync(path);
+        if (stat.uid !== process.getuid() || (stat.mode & 0o077))
+            throw new Error("dataDir must be owned and private");
+    }
+}
+function privateDirectory(path) {
+    const directory = dirname(path), stat = lstatSync(directory);
+    if (realpathSync(directory) !== directory || !stat.isDirectory() || stat.uid !== process.getuid() || (stat.mode & 0o077)) {
+        throw new Error("Expected a canonical, private, owned configuration directory");
+    }
+}
+function ownedFile(path) {
+    const stat = lstatSync(path);
+    if (!stat.isFile() || stat.uid !== process.getuid())
+        throw new Error("Expected an owned regular configuration file");
+}
+export function readPrivateText(path) {
+    privateDirectory(path);
+    ownedFile(path);
+    const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    try {
+        const stat = fstatSync(fd);
+        if (!stat.isFile() || stat.uid !== process.getuid() || (stat.mode & 0o077) || stat.size > 1_048_576) {
+            throw new Error("Expected a private, owned configuration file of at most 1 MiB");
+        }
+        const text = readFileSync(fd, "utf8");
+        if (Buffer.byteLength(text) > 1_048_576)
+            throw new Error("Configuration file grew beyond limit");
+        return text;
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+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;
+    }
+}
+/** Caller owns the configuration. No await between comparison, validation and publication. */
+export function replacePrivateText(path, text) {
+    const temporary = join(dirname(path), "." + basename(path) + "." + randomUUID() + ".tmp");
+    let fd, created = false, published = false;
+    try {
+        privateDirectory(path);
+        ownedFile(path);
+        if (Buffer.byteLength(text) > 1_048_576)
+            throw new Error("Configuration exceeds file limit");
+        fd = openSync(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+        created = true;
+        writeFileSync(fd, text, "utf8");
+        fsyncSync(fd);
+        closeSync(fd);
+        fd = undefined;
+        privateDirectory(path);
+        ownedFile(path);
+        renameSync(temporary, path);
+        published = true;
+        const directory = openSync(dirname(path), constants.O_RDONLY);
+        try {
+            fsyncSync(directory);
+        }
+        finally {
+            closeSync(directory);
+        }
+    }
+    catch {
+        throw new FileCommitError(published);
+    }
+    finally {
+        if (fd !== undefined)
+            closeSync(fd);
+        if (created && !published) {
+            try {
+                unlinkSync(temporary);
+            }
+            catch { /* Never remove the committed file. */ }
+        }
+    }
+}
+//# sourceMappingURL=private-files.js.map

package/dist/results.js

@@ -0,0 +1,79 @@
+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

@@ -0,0 +1,16 @@
+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/settings.js

@@ -0,0 +1,180 @@
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+import { ADMIN_TOKEN_ENV, configSchema, coordinatorCredentialEnv, validateConfig } from "./config.js";
+import { parseEnvironment, validateServiceEnvironment } from "./environment.js";
+import { checkDataDirectory, FileCommitError, readPrivateText, replacePrivateText } from "./private-files.js";
+import { credentialUpdateSchema, settingsConfigSchema } from "./settings-contract.js";
+export class SettingsError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+const protectedKeys = new Set(["HOME", "PATH", "LANG", "LC_ALL", "TZ", "TMPDIR", "NODE_OPTIONS", "NODE_PATH",
+    "PI_ACP_PI_COMMAND", "AGENT_TASK_TOKEN", ADMIN_TOKEN_ENV, "__proto__", "constructor", "prototype"]);
+const modelKeys = ["OPENAI_API_KEY", "ANTHROPIC_API_KEY", "DEEPSEEK_API_KEY"];
+function parse(schema, value) {
+    const result = schema.safeParse(value);
+    if (!result.success) {
+        // Field paths only: parser diagnostics and rejected values may contain credentials.
+        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;
+}
+function referenced(config) {
+    return new Set(config.coordinator ? [coordinatorCredentialEnv(config.coordinator)] : []);
+}
+function editableKey(key, config) {
+    return !protectedKeys.has(key) && key !== config.tokenEnv && !/^(NODE_|LD_|DYLD_)/.test(key) &&
+        (/(?:_KEY|_TOKEN|_SECRET|_PASSWORD)$/.test(key) || referenced(config).has(key));
+}
+/** Disk settings are next-start inputs only. This service never mutates live objects or process.env. */
+export class Settings {
+    configPath;
+    environmentPath;
+    edits = new Map();
+    initial;
+    running;
+    runningEnvironment;
+    base;
+    closed = false;
+    uncertain = false;
+    startedAt = new Date().toISOString();
+    constructor(configPath, environmentPath, running, base, environment) {
+        this.configPath = configPath;
+        this.environmentPath = environmentPath;
+        if (configPath === environmentPath)
+            throw new SettingsError("invalid", "Configuration and environment must be separate files");
+        this.running = structuredClone(running);
+        this.base = { ...base };
+        this.runningEnvironment = { ...environment };
+        this.initial = this.snapshot();
+    }
+    snapshot() {
+        if (this.closed)
+            throw new SettingsError("unavailable", "Configuration management is closed");
+        try {
+            const configText = readPrivateText(this.configPath), environmentText = readPrivateText(this.environmentPath);
+            return { configText, environmentText, config: configSchema.parse(JSON.parse(configText)), environment: parseEnvironment(environmentText) };
+        }
+        catch {
+            throw new SettingsError("unavailable", "Cannot read private configuration files; inspect their format, ownership and permissions offline");
+        }
+    }
+    pending(snapshot) {
+        return snapshot.configText !== this.initial.configText || snapshot.environmentText !== this.initial.environmentText;
+    }
+    status() {
+        return { pendingRestart: this.pending(this.snapshot()), writeBlocked: this.uncertain, startedAt: this.startedAt };
+    }
+    get() {
+        const snapshot = this.snapshot(), now = Date.now();
+        for (const [key, edit] of this.edits)
+            if (edit.expires <= now)
+                this.edits.delete(key);
+        while (this.edits.size >= 32)
+            this.edits.delete(this.edits.keys().next().value);
+        const editToken = randomUUID();
+        this.edits.set(editToken, { configText: snapshot.configText, environmentText: snapshot.environmentText, expires: now + 15 * 60_000 });
+        const keys = new Set([...modelKeys, ...Object.keys(snapshot.environment), ...referenced(snapshot.config), ...referenced(this.running)]);
+        const credentials = [...keys].filter(key => editableKey(key, snapshot.config) && editableKey(key, this.running) && ![snapshot.environment[snapshot.config.tokenEnv], snapshot.environment[ADMIN_TOKEN_ENV]].includes(snapshot.environment[key])).sort().map(key => ({
+            key, saved: Boolean(snapshot.environment[key]), running: Boolean(this.runningEnvironment[key]),
+            pendingRestart: snapshot.environment[key] !== this.runningEnvironment[key],
+            referenced: referenced(snapshot.config).has(key),
+        }));
+        return { editToken, running: structuredClone(this.running), saved: snapshot.config, credentials,
+            pendingRestart: this.pending(snapshot), writeBlocked: this.uncertain };
+    }
+    editing(token) {
+        if (this.uncertain)
+            throw new SettingsError("unavailable", "Publication was uncertain; stop the service and inspect configuration files before further saves");
+        const snapshot = this.snapshot(), edit = this.edits.get(token);
+        if (!edit || edit.expires <= Date.now() || edit.configText !== snapshot.configText || edit.environmentText !== snapshot.environmentText) {
+            throw new SettingsError("conflict", "Configuration changed or the edit expired; reload before saving");
+        }
+        return snapshot;
+    }
+    candidate(value) {
+        const input = parse(settingsConfigSchema, value), snapshot = this.editing(input.editToken);
+        const environment = { ...this.base, ...snapshot.environment };
+        let config;
+        try {
+            config = validateConfig(input.config);
+            checkDataDirectory(config.dataDir);
+        }
+        catch (error) {
+            if (error instanceof z.ZodError)
+                throw new SettingsError("invalid", "Invalid configuration fields");
+            throw new SettingsError("invalid", "Local validation failed: check data directory, workspaces and credential isolation");
+        }
+        const previous = snapshot.config.coordinator, next = config.coordinator;
+        const endpoint = (model) => model.provider === "openai-compatible" ? model.baseUrl : model.provider;
+        if (previous && next && endpoint(previous) !== endpoint(next) && coordinatorCredentialEnv(previous) === coordinatorCredentialEnv(next)) {
+            throw new SettingsError("invalid", "Changing the model endpoint requires a new credential reference; save the new key first");
+        }
+        for (const key of referenced(config)) {
+            if (!environment[key])
+                throw new SettingsError("invalid", "A referenced environment value is missing; prepare credentials or native configuration first");
+        }
+        const token = environment[config.tokenEnv] ?? environment[snapshot.config.tokenEnv];
+        try {
+            validateServiceEnvironment(config, { ...environment, [config.tokenEnv]: token });
+        }
+        catch {
+            throw new SettingsError("invalid", "Service, administrator and model credentials must be valid and distinct");
+        }
+        if (config.tokenEnv !== snapshot.config.tokenEnv && environment[config.tokenEnv] && environment[config.tokenEnv] !== environment[snapshot.config.tokenEnv]) {
+            throw new SettingsError("invalid", "tokenEnv already contains another value; use a new environment name");
+        }
+        return config;
+    }
+    validate(value) { return this.candidate(value); }
+    saveConfig(value) {
+        const config = this.candidate(value);
+        const snapshot = this.editing(parse(settingsConfigSchema, value).editToken);
+        if (config.tokenEnv !== snapshot.config.tokenEnv) {
+            snapshot.environment[config.tokenEnv] = snapshot.environment[snapshot.config.tokenEnv];
+            // Publish an alias first. Either configuration still uses the same service token.
+            this.publish(this.environmentPath, snapshot.environment);
+        }
+        this.publish(this.configPath, config);
+        return this.get();
+    }
+    saveCredential(value) {
+        const input = parse(credentialUpdateSchema, value), snapshot = this.editing(input.editToken);
+        if (!editableKey(input.key, snapshot.config) || !editableKey(input.key, this.running) ||
+            [snapshot.environment[snapshot.config.tokenEnv], snapshot.environment[ADMIN_TOKEN_ENV]].includes(snapshot.environment[input.key]))
+            throw new SettingsError("invalid", "This environment key is not console-managed; new credential names must end in _KEY, _TOKEN, _SECRET or _PASSWORD");
+        if (input.action === "delete") {
+            if (referenced(snapshot.config).has(input.key))
+                throw new SettingsError("invalid", "The saved configuration still references this credential");
+            delete snapshot.environment[input.key];
+        }
+        else {
+            if ([snapshot.environment[snapshot.config.tokenEnv], snapshot.environment[ADMIN_TOKEN_ENV],
+                this.runningEnvironment[this.running.tokenEnv], this.runningEnvironment[ADMIN_TOKEN_ENV]].includes(input.value)) {
+                throw new SettingsError("invalid", "Service and administrator tokens cannot be reused as credentials");
+            }
+            snapshot.environment[input.key] = input.value;
+        }
+        // Recheck the complete environment format, not only the edited value.
+        parseEnvironment(JSON.stringify(snapshot.environment));
+        this.publish(this.environmentPath, snapshot.environment);
+        return this.get();
+    }
+    publish(path, value) {
+        try {
+            replacePrivateText(path, JSON.stringify(value, null, 2) + "\n");
+        }
+        catch (error) {
+            if (error instanceof FileCommitError && error.uncertain)
+                this.uncertain = true;
+            throw new SettingsError("unavailable", this.uncertain ? "Publication could not be confirmed; stop and inspect the files" : "Save failed; no replacement was published");
+        }
+        this.edits.clear();
+    }
+    close() { this.closed = true; this.edits.clear(); }
+}
+//# sourceMappingURL=settings.js.map

package/dist/startup.js

@@ -0,0 +1,56 @@
+import { existsSync, mkdirSync, writeFileSync, openSync, fsyncSync, closeSync } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+import { loadConfig } from "./config.js";
+import { readEnvironment, validateServiceEnvironment } from "./environment.js";
+import { checkDataDirectory, readPrivateText, replacePrivateText } from "./private-files.js";
+import { acquireLock } from "./lock.js";
+/** A stable launch locator is the only runtime input outside the selected dataDir. */
+export function startupPaths(home) {
+    const { dataDir } = z.object({ dataDir: z.string() }).strict().parse(JSON.parse(readPrivateText(join(home, "launch.json"))));
+    checkDataDirectory(dataDir);
+    return { dataDir, configPath: join(dataDir, "config.json"), environmentPath: join(dataDir, "environment.json") };
+}
+function prepareFile(path, text) {
+    if (existsSync(path)) {
+        if (readPrivateText(path) !== text)
+            throw new Error("Target contains different startup files; refusing to overwrite them");
+        return; // Explicitly resume an interrupted preparation, not a data repair.
+    }
+    const fd = openSync(path, "wx", 0o600);
+    try {
+        writeFileSync(fd, text);
+        fsyncSync(fd);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+export async function prepareStartup(home) {
+    const current = startupPaths(home), config = loadConfig(current.configPath), environment = readEnvironment(current.environmentPath);
+    validateServiceEnvironment(config, environment);
+    checkDataDirectory(config.dataDir);
+    if (config.dataDir !== current.dataDir) {
+        mkdirSync(config.dataDir, { recursive: true, mode: 0o700 });
+        checkDataDirectory(config.dataDir);
+        const release = await acquireLock(config.dataDir);
+        try {
+            // Only next-start inputs. Never copy tasks, sessions, results, native configuration or workspaces.
+            prepareFile(join(config.dataDir, "config.json"), JSON.stringify(config, null, 2) + "\n");
+            prepareFile(join(config.dataDir, "environment.json"), JSON.stringify(environment, null, 2) + "\n");
+            const fd = openSync(config.dataDir, "r");
+            try {
+                fsyncSync(fd);
+            }
+            finally {
+                closeSync(fd);
+            }
+            replacePrivateText(join(home, "launch.json"), JSON.stringify({ dataDir: config.dataDir }) + "\n");
+        }
+        finally {
+            await release();
+        }
+    }
+    return { ...startupPaths(home), config, environment };
+}
+//# sourceMappingURL=startup.js.map

package/dist/task-contract.js

@@ -0,0 +1,37 @@
+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

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