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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 realqiyan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,46 @@
-# Temporary Holding Version
+# Agent Task
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+独立的智能任务服务：**MCP 管理任务，pi durable 推进调用方定义的 DAG，ACP 执行端完成领域工作**。协调员负责澄清和交付验收，不拆解任务或修改计划。
+
+当前处于调研阶段，不宣称生产可用，不用于无人值守交易。已有验证结果及适用范围见[验证说明](docs/validation.md)。
+
+## 从哪里开始
+
+| 目的 | 入口 |
+| --- | --- |
+| 安装、认证、后台运行、卸载 | [部署说明](docs/deployment.md) |
+| 本机控制台、配置保存与手动重启 | [控制台说明](docs/web-console.md) |
+| 理解产品目标和架构选择 | [总体方案](docs/design-proposal.md) |
+| 查找实现与对应测试 | [代码导航](docs/technical-design.md) |
+| 查询测试命令、真实验收及缺口 | [验证说明](docs/validation.md) |
+| npm 候选验收、GitHub Actions 与受控发布 | [发布说明](docs/release.md) |
+| 修改项目 | [开发指南](AGENTS.md)、[架构原则](docs/architecture-guidelines.md) |
+
+文档保留用途、约束和证据；字段、默认值、状态转换及内部流程以代码为准。
+
+## 使用入口
+
+Linux/macOS，Node.js **22.19+**。安装包自带运行产物，无需克隆或编译。发布目标为 `0.0.1-rc.1`，使用 `latest`；实际发布与平台验收状态见[发布证据](docs/validation.md#npm-发布候选验证)。
+
+```bash
+npm install -g @realqiyan/agent-task
+agent-task setup
+agent-task start
+# 另一个终端进行带认证的健康检查：
+agent-task status
+```
+
+npm 包名为 `@realqiyan/agent-task`，安装后的命令仍为 `agent-task`。setup 提供交互配置；启动后可使用本机 Web 控制台。先停止前台实例，再用 `agent-task service install` 安装并启动用户后台服务。安装器不会替用户登录或批准执行端；详细操作见[部署说明](docs/deployment.md)。
+
+MCP 客户端使用独立服务 token。源码开发辅助命令（凭据须安全注入环境，不写命令行）：
+
+```bash
+node scripts/mcp-call.mjs --list
+node scripts/mcp-call.mjs service_status
+```
+
+任务由 `task_create` 提交固定 DAG，每个节点选择已注册执行端。具体契约见 [task-contract.ts](src/task-contract.ts)，管理工具见 [mcp.ts](src/mcp.ts)。Prompt、人工回复和工作空间选择都不授予工具权限。
+
+## 许可证
+
+[MIT](LICENSE)，Copyright (c) 2026 realqiyan。依赖及执行端仍遵循各自许可证。

package/bin/agent-task.mjs

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+
+const help = `Usage: agent-task <command>
+  setup [options]           Interactive configuration (setup --help for flags)
+  start [--home PATH]        Foreground service using the private installation
+  start --config PATH --environment PATH
+                            Foreground service with explicit private files
+  status [--home PATH]       Authenticated MCP health check; no token printed
+  service install [--home PATH]
+                            Install/start systemd user service or LaunchAgent
+  service remove [--home PATH]
+                            Stop/remove only the owned service
+  uninstall [--home PATH]    Remove service and owned executor components;
+                            preserve configuration, credentials and task data
+  --version | --help
+Node.js 22.19+; Linux or macOS. Setup never grants executor permissions.`;
+try {
+  const [major, minor] = process.versions.node.split(".").map(Number);
+  if (major < 22 || (major === 22 && minor < 19)) throw new Error("Node.js 22.19+ is required");
+  const [command, ...args] = process.argv.slice(2);
+  if (!command || command === "--help" || command === "help") {
+    console.log(help);
+  } else if (command === "--version") {
+    console.log(JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version);
+  } else if (command === "setup" || command === "uninstall") {
+    process.argv = [process.execPath, command, ...args];
+    await import(`../scripts/${command}.mjs`);
+  } else if (command === "start" && args[0] === "--config") {
+    if (args.length !== 4 || args[2] !== "--environment") throw new Error("Use start --config PATH --environment PATH");
+    process.argv = [process.execPath, "agent-task", ...args];
+    await import("../dist/main.js");
+  } else {
+    const lib = await import("../scripts/install-lib.mjs");
+    const action = command === "service" ? args.shift() : undefined;
+    if (!["start", "status", "service"].includes(command) || (command === "service" && !["install", "remove"].includes(action))) throw new Error(help);
+    const options = lib.argumentsFor(args);
+    if (Object.keys(options).some(key => key !== "home")) throw new Error("Only --home is accepted here");
+    const root = lib.installRoot(options);
+    if (action === "install") {
+      process.argv = [process.execPath, "setup", "--home", root, "--service"];
+      await import("../scripts/setup.mjs");
+    } else if (action === "remove") {
+      lib.readManifest(root);
+      const unlock = lib.operationLock(root);
+      try {
+        const manifest = lib.readManifest(root);
+        lib.deactivate(manifest);
+        manifest.serviceInstalled = false;
+        lib.saveManifest(root, manifest);
+        console.log("Owned service removed; configuration, credentials, components and data preserved.");
+      } finally { unlock(); }
+    } else if (command === "start") {
+      process.argv = [process.execPath, "service-runner", root];
+      await import("../scripts/service-runner.mjs");
+    } else {
+      const manifest = lib.readManifest(root);
+      if (manifest.phase !== "ready") throw new Error("Installation is not ready");
+      await lib.checkHealth(lib.json(root + "/config.json"), lib.runtimeEnv(manifest));
+      console.log("Authenticated MCP health check passed.");
+    }
+  }
+} catch (error) {
+  console.error(error.message);
+  process.exitCode = 1;
+}

package/config.example.json

@@ -0,0 +1,7 @@
+{
+  "dataDir": "/absolute/private/path/agent-task",
+  "port": 8765,
+  "tokenEnv": "AGENT_TASK_TOKEN",
+  "coordinator": { "provider": "openai", "model": "YOUR_AVAILABLE_MODEL_ID" },
+  "executors": []
+}

package/deploy/agent-task.service.example

@@ -0,0 +1,17 @@
+[Unit]
+Description=Agent Task local service
+StartLimitIntervalSec=60
+StartLimitBurst=3
+
+[Service]
+Type=simple
+WorkingDirectory=/absolute/path/to/agent-task
+ExecStart=/absolute/path/to/node /absolute/path/to/agent-task/dist/main.js --config %h/.config/agent-task/config.json --environment %h/.config/agent-task/environment.json
+Restart=on-failure
+RestartSec=5
+TimeoutStopSec=15
+KillMode=control-group
+UMask=0077
+
+[Install]
+WantedBy=default.target

package/dist/acp.js

@@ -0,0 +1,168 @@
+import { spawn } from "node:child_process";
+import { Readable, Writable } from "node:stream";
+import { setTimeout as delay } from "node:timers/promises";
+import * as acp from "@agentclientprotocol/sdk";
+import { executorEnv } from "./config.js";
+import { readInputFile } from "./results.js";
+import { permissionDecision } from "./permissions.js";
+import { version } from "./version.js";
+/** Project only public progress. Queue every piece before yielding so concurrent notifications cannot reorder output. */
+export function progressEvents(update) {
+    if (update.sessionUpdate === "agent_message_chunk" && update.content.type === "text") {
+        const result = [];
+        for (let i = 0; i < update.content.text.length; i += 2000) {
+            const text = update.content.text.slice(i, i + 2000);
+            result.push({ kind: "output", data: { text }, text });
+        }
+        return result;
+    }
+    if (update.sessionUpdate === "tool_call" || update.sessionUpdate === "tool_call_update") {
+        return [{ kind: "tool", data: { id: update.toolCallId, name: update.name ?? null,
+                    status: update.status ?? null, kind: update.kind ?? null } }];
+    }
+    if (update.sessionUpdate === "plan") {
+        return [{ kind: "plan", data: update.entries.slice(0, 30).map(entry => ({
+                    content: entry.content.slice(0, 300), status: entry.status, priority: entry.priority,
+                })) }];
+    }
+    return [];
+}
+function signalGroup(child, signal) {
+    if (child.pid) {
+        try {
+            process.kill(-child.pid, signal);
+        }
+        catch (error) {
+            if (error.code !== "ESRCH")
+                throw error;
+        }
+    }
+}
+/** Kill the whole group even if its leader already exited; Linux systemd additionally owns a cgroup; macOS does not. */
+export async function terminateGroup(child) {
+    signalGroup(child, "SIGTERM");
+    await delay(300);
+    signalGroup(child, "SIGKILL");
+    child.stdin?.destroy();
+    child.stdout?.destroy();
+    child.stderr?.destroy();
+}
+export async function openAcp(executor, signal, emit, inputFiles = []) {
+    signal.throwIfAborted();
+    const child = spawn(executor.command, executor.args, {
+        cwd: executor.cwd, env: executorEnv(executor.envKeys), detached: true, stdio: ["pipe", "pipe", "pipe"],
+    });
+    const controller = new AbortController();
+    const cancel = AbortSignal.any([signal, controller.signal]);
+    let sessionId, connection;
+    let killTimer;
+    let wireBytes = 0;
+    const closed = new Promise(resolve => child.once("close", () => resolve()));
+    child.once("error", error => controller.abort(error));
+    child.once("exit", (code, sig) => controller.abort(new Error("Agent exited: " + (sig ?? code))));
+    child.stdout.on("data", (chunk) => {
+        wireBytes += chunk.length;
+        if (wireBytes > 8_388_608)
+            controller.abort(new Error("ACP wire output limit exceeded"));
+    });
+    // Drain diagnostics without storing raw stderr, which can contain credentials.
+    child.stderr.on("data", (chunk) => {
+        wireBytes += chunk.length;
+        if (wireBytes > 8_388_608)
+            controller.abort(new Error("Agent diagnostic output limit exceeded"));
+    });
+    const abort = () => {
+        if (sessionId && connection)
+            void connection.agent.notify(acp.methods.agent.session.cancel, { sessionId }).catch(() => { });
+        killTimer ??= setTimeout(() => {
+            connection?.close(cancel.reason);
+            void terminateGroup(child).catch(() => { });
+        }, 500);
+    };
+    cancel.addEventListener("abort", abort, { once: true });
+    let reporting = Promise.resolve();
+    const report = (...args) => {
+        const next = reporting.then(() => emit(...args));
+        reporting = next.catch(error => { controller.abort(error); });
+        return next;
+    };
+    let closing;
+    const close = () => closing ??= (async () => {
+        cancel.removeEventListener("abort", abort);
+        if (killTimer)
+            clearTimeout(killTimer);
+        connection?.close();
+        await terminateGroup(child);
+        await closed;
+    })();
+    let busy = false;
+    const app = acp.client({ name: "agent-task" })
+        .onRequest(acp.methods.client.fs.readTextFile, async (ctx) => {
+        try {
+            cancel.throwIfAborted();
+            if (ctx.params.sessionId !== sessionId)
+                throw new Error("Wrong input-file session");
+            return { content: readInputFile(executor, inputFiles, ctx.params.path, ctx.params.line ?? 1, ctx.params.limit ?? undefined) };
+        }
+        catch (error) {
+            controller.abort(error);
+            throw error;
+        }
+    })
+        .onRequest(acp.methods.client.session.requestPermission, async (ctx) => {
+        const request = ctx.params;
+        const response = permissionDecision(request, executor.permissionAllowlist, cancel.aborted || request.sessionId !== sessionId);
+        await report("permission", { tool: request.toolCall.name ?? null, outcome: response.outcome });
+        return response;
+    })
+        .onNotification(acp.methods.client.session.update, async (ctx) => {
+        if (ctx.params.sessionId !== sessionId || cancel.aborted)
+            return;
+        await Promise.all(progressEvents(ctx.params.update).map(event => report(event.kind, event.data, event.text)));
+        // Do not persist internal thought streams, raw tool inputs/outputs, or arbitrary extensions.
+    });
+    try {
+        connection = await app.connect(acp.ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout), { maxMessageBytes: 1_048_576 }));
+        if (cancel.aborted)
+            abort();
+        const init = await connection.agent.request(acp.methods.agent.initialize, {
+            protocolVersion: acp.PROTOCOL_VERSION, clientCapabilities: inputFiles.length ? { fs: { readTextFile: true, writeTextFile: false } } : {},
+            clientInfo: { name: "agent-task", version },
+        });
+        cancel.throwIfAborted();
+        if (init.protocolVersion !== acp.PROTOCOL_VERSION)
+            throw new Error("Incompatible ACP protocol version");
+        await report("agent", { name: init.agentInfo?.name ?? null, version: init.agentInfo?.version ?? null });
+        const session = await connection.agent.request(acp.methods.agent.session.new, { cwd: executor.cwd, mcpServers: [] });
+        sessionId = session.sessionId;
+        await report("session", sessionId);
+        cancel.throwIfAborted();
+        return {
+            close, closed,
+            async prompt(text) {
+                cancel.throwIfAborted();
+                if (closing || busy)
+                    throw new Error("ACP session closed or busy");
+                busy = true;
+                try {
+                    const result = await connection.agent.request(acp.methods.agent.session.prompt, {
+                        sessionId: sessionId, prompt: [{ type: "text", text }],
+                    });
+                    await reporting;
+                    cancel.throwIfAborted();
+                    return result.stopReason;
+                }
+                finally {
+                    busy = false;
+                }
+            },
+        };
+    }
+    catch (error) {
+        await close();
+        if (cancel.aborted)
+            throw cancel.reason;
+        throw error;
+    }
+}
+//# sourceMappingURL=acp.js.map

package/dist/admin.js

@@ -0,0 +1,31 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { loadConfig, validateConfig } from "./config.js";
+import { replacePrivateText } from "./private-files.js";
+import { executorSchema } from "./model.js";
+import { acquireLock } from "./lock.js";
+process.umask(0o077);
+const [action, configPath, profilePath] = process.argv.slice(2);
+if (!configPath || !["register", "list"].includes(action ?? "") || (action === "register" && !profilePath)) {
+    throw new Error("Usage: node dist/admin.js list CONFIG | register CONFIG PROFILE.json (service stopped)");
+}
+const path = resolve(configPath), config = loadConfig(path);
+const release = await acquireLock(config.dataDir);
+try {
+    if (action === "list") {
+        console.log(JSON.stringify(config.executors.map(({ id, command, args, cwd, envKeys, permissionAllowlist, unattendedApproved, resultReadRoots }) => ({ id, transport: "stdio", command, args, cwd, envKeys, permissionAllowlist, unattendedApproved, resultReadRoots })), null, 2));
+    }
+    else {
+        const profile = executorSchema.parse(JSON.parse(readFileSync(resolve(profilePath), "utf8")));
+        if (config.executors.some(item => item.id === profile.id))
+            throw new Error("Executor ID already registered; edit reviewed config while stopped to replace");
+        config.executors.push(profile);
+        // Validate the complete candidate before publication, using the same rules as startup and the console.
+        replacePrivateText(path, JSON.stringify(validateConfig(config), null, 2) + "\n");
+        console.log(JSON.stringify({ registered: profile.id, transport: "stdio" }));
+    }
+}
+finally {
+    await release();
+}
+//# sourceMappingURL=admin.js.map

package/dist/config.js

@@ -0,0 +1,113 @@
+import { readFileSync, realpathSync, statSync, accessSync, constants } from "node:fs";
+import { basename, delimiter, isAbsolute, join } from "node:path";
+import { z } from "zod";
+import { executorSchema } from "./model.js";
+export const ADMIN_TOKEN_ENV = "AGENT_TASK_ADMIN_TOKEN";
+const envKey = z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/);
+const baseEnvKeys = ["PATH", "LANG", "LC_ALL", "TZ"];
+const modelId = z.string().min(1).max(200);
+const coordinatorSchema = z.discriminatedUnion("provider", [
+    z.object({ provider: z.enum(["openai", "anthropic", "deepseek"]), model: modelId }).strict(),
+    z.object({
+        provider: z.literal("openai-compatible"), model: modelId,
+        api: z.enum(["openai-completions", "openai-responses"]).default("openai-completions"),
+        baseUrl: z.string().url().refine(value => {
+            const url = new URL(value);
+            return ["https:", "http:"].includes(url.protocol) && !url.username && !url.password && !url.search && !url.hash;
+        }, "baseUrl must be HTTP(S) without credentials, query or fragment"),
+        apiKeyEnv: envKey.refine(key => !baseEnvKeys.includes(key), "Credential must not use a base environment key"),
+        contextWindow: z.number().int().positive(),
+        maxTokens: z.number().int().positive(),
+        reasoning: z.boolean().default(false),
+    }).strict(),
+]).refine(value => value.provider !== "openai-compatible" || value.maxTokens <= value.contextWindow, "maxTokens must not exceed contextWindow");
+export const configSchema = z.object({
+    dataDir: z.string().min(1),
+    port: z.number().int().min(0).max(65535).default(8765),
+    tokenEnv: z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).default("AGENT_TASK_TOKEN"),
+    coordinator: coordinatorSchema.optional(),
+    executors: z.array(executorSchema).max(100).default([]),
+}).strict();
+export function coordinatorCredentialEnv(config) {
+    switch (config.provider) {
+        case "openai": return "OPENAI_API_KEY";
+        case "anthropic": return "ANTHROPIC_API_KEY";
+        case "deepseek": return "DEEPSEEK_API_KEY";
+        case "openai-compatible": return config.apiKeyEnv;
+    }
+}
+export function loadConfig(path, environment = process.env) {
+    let value;
+    try {
+        value = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        throw new Error("Cannot read configuration JSON");
+    }
+    return validateConfig(value, environment);
+}
+export function validateConfig(value, environment = process.env) {
+    const config = configSchema.parse(value);
+    if (!isAbsolute(config.dataDir))
+        throw new Error("dataDir must be absolute");
+    const coordinatorKey = config.coordinator ? coordinatorCredentialEnv(config.coordinator) : undefined;
+    if ([...baseEnvKeys, ADMIN_TOKEN_ENV, "OPENAI_API_KEY", "ANTHROPIC_API_KEY", "DEEPSEEK_API_KEY", coordinatorKey].includes(config.tokenEnv))
+        throw new Error("tokenEnv must be separate from base environment, administrator and model credentials");
+    if (coordinatorKey === ADMIN_TOKEN_ENV)
+        throw new Error("Administrator token must not be used as a model credential");
+    const ids = new Set();
+    for (const executor of config.executors) {
+        if (ids.has(executor.id))
+            throw new Error("Duplicate executor ID");
+        ids.add(executor.id);
+        if (!isAbsolute(executor.command) || !isAbsolute(executor.cwd))
+            throw new Error("Executor command and cwd must be absolute");
+        if (basename(executor.command) === "pi") {
+            throw new Error(`Executor ${executor.id}: pi CLI is not an ACP server (including --mode rpc). Install pi-acp with npm install -g pi-acp@0.0.34 and configure its absolute executable path.`);
+        }
+        const piCommandOverride = executor.envKeys.includes("PI_ACP_PI_COMMAND") && environment.PI_ACP_PI_COMMAND;
+        if (basename(executor.command) === "pi-acp" && !piCommandOverride && !(environment.PATH ?? "").split(delimiter).some(directory => {
+            if (!isAbsolute(directory))
+                return false;
+            try {
+                const file = join(directory, "pi");
+                accessSync(file, constants.X_OK);
+                return statSync(file).isFile();
+            }
+            catch {
+                return false;
+            }
+        })) {
+            throw new Error(`Executor ${executor.id}: pi-acp requires pi on the executor PATH. Install/configure pi before starting the service.`);
+        }
+        try {
+            executor.command = realpathSync(executor.command);
+            accessSync(executor.command, constants.X_OK);
+        }
+        catch {
+            throw new Error(`Executor ${executor.id}: ACP executable is missing or not executable. Check the administrator-configured absolute command path. For Pi, install npm install -g pi-acp@0.0.34 and use command -v pi-acp to locate it; pi must also be on the executor PATH.`);
+        }
+        executor.cwd = realpathSync(executor.cwd);
+        if (!statSync(executor.command).isFile() || !statSync(executor.cwd).isDirectory())
+            throw new Error("Invalid executor command or cwd");
+        for (const root of executor.resultReadRoots) {
+            if (!isAbsolute(root) || realpathSync(root) !== root || !statSync(root).isDirectory())
+                throw new Error("Result read roots must be canonical absolute directories");
+        }
+        if (executor.envKeys.includes(config.tokenEnv) || executor.envKeys.includes(ADMIN_TOKEN_ENV))
+            throw new Error("Service or administrator token must not be passed to executors");
+        if (coordinatorKey && executor.envKeys.includes(coordinatorKey))
+            throw new Error("Coordinator credential must not be passed to executors; use separate executor credentials");
+    }
+    return config;
+}
+/** No shell or wholesale inheritance; secrets are references to administrator-selected environment keys. */
+export function executorEnv(keys, source = process.env) {
+    const env = {};
+    for (const key of new Set(["PATH", "LANG", "LC_ALL", "TZ", ...keys])) {
+        if (key !== ADMIN_TOKEN_ENV && source[key] !== undefined)
+            env[key] = source[key];
+    }
+    return env;
+}
+//# sourceMappingURL=config.js.map

package/dist/coordinator-provider.js

@@ -0,0 +1,28 @@
+import { createProvider, envApiKeyAuth } from "@earendil-works/pi-ai";
+import { openAICompletionsApi } from "@earendil-works/pi-ai/api/openai-completions.lazy";
+import { openAIResponsesApi } from "@earendil-works/pi-ai/api/openai-responses.lazy";
+import { openaiProvider } from "@earendil-works/pi-ai/providers/openai";
+import { anthropicProvider } from "@earendil-works/pi-ai/providers/anthropic";
+import { deepseekProvider } from "@earendil-works/pi-ai/providers/deepseek";
+/** Administrator-owned model metadata; wire conversion and authentication stay in pi-ai. */
+export function createCoordinatorProvider(config) {
+    switch (config.provider) {
+        case "openai": return openaiProvider();
+        case "anthropic": return anthropicProvider();
+        case "deepseek": return deepseekProvider();
+        case "openai-compatible": return createProvider({
+            id: config.provider,
+            baseUrl: config.baseUrl,
+            auth: { apiKey: envApiKeyAuth("Coordinator API key", [config.apiKeyEnv]) },
+            api: config.api === "openai-responses" ? openAIResponsesApi() : openAICompletionsApi(),
+            models: [{
+                    id: config.model, name: config.model, provider: config.provider,
+                    api: config.api, baseUrl: config.baseUrl, input: ["text"], reasoning: config.reasoning,
+                    contextWindow: config.contextWindow, maxTokens: config.maxTokens,
+                    // Unknown pricing, not a claim that the endpoint is free.
+                    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+                }],
+        });
+    }
+}
+//# sourceMappingURL=coordinator-provider.js.map

package/dist/coordinator-storage.js

@@ -0,0 +1,43 @@
+import { existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { SqliteStorage } from "@earendil-works/pi-durable/storage/sqlite";
+import { openNodeSqliteDatabase } from "@earendil-works/pi-durable/storage/sqlite/node";
+/** The caller holds the application directory lock. New files initialize; existing files must already match the pinned SDK. */
+export async function openCoordinatorStorage(directory, runId) {
+    if (!/^[a-f0-9-]{36}$/.test(runId))
+        throw new Error("Invalid run identity");
+    const root = join(directory, "coordinators");
+    mkdirSync(root, { recursive: true, mode: 0o700 });
+    const path = join(root, runId + ".sqlite");
+    if (existsSync(path)) {
+        const db = new DatabaseSync(path, { readOnly: true });
+        try {
+            const version = db.prepare("SELECT version FROM durable_schema WHERE singleton=1").get()?.["version"];
+            if (version !== 1)
+                throw new Error("Unsupported durable schema; explicit offline upgrade required");
+            // SDK index columns such as kind are JSON-encoded; read the decoded record fields together.
+            const tasks = db.prepare("SELECT json_extract(record,'$.kind') AS kind, json_extract(record,'$.version') AS version FROM tasks WHERE status != 'terminal'").all();
+            for (const task of tasks) {
+                const expected = task["kind"] === "pi.tool" ? 2 : ["pi.generation", "pi.compaction"].includes(String(task["kind"])) ? 1 : undefined;
+                if (task["version"] !== expected || expected === undefined)
+                    throw new Error("Unsupported durable task version");
+            }
+            if (db.prepare("SELECT 1 FROM document_revisions WHERE version != 1 LIMIT 1").get())
+                throw new Error("Unsupported durable document version");
+        }
+        finally {
+            db.close();
+        }
+    }
+    const database = await openNodeSqliteDatabase(path);
+    try {
+        await database.exec("PRAGMA synchronous=FULL");
+        return await SqliteStorage.open(database);
+    }
+    catch (error) {
+        await database.close().catch(() => { });
+        throw error;
+    }
+}
+//# sourceMappingURL=coordinator-storage.js.map