@realqiyan/agent-task 0.0.1-rc.2 → 0.1.0-rc.1

package/CONTEXT.md

@@ -0,0 +1,17 @@
+# Agent Task
+
+本词汇表定义任务协调与执行中的项目术语。
+
+## Language
+
+**协调模型服务（Coordinator Provider）**：
+为内置协调员提供模型推理的服务。它的模型选择和凭据独立于各执行端的原生模型配置。
+_Avoid_: 全局模型服务、执行端模型服务
+
+**任务工作目录（Task Workspace）**：
+任务各节点开展工作的项目目录。它在提交任务时确定，后续各次运行使用同一个目录。
+_Avoid_: 执行端默认目录、服务工作目录
+
+**任务请求键（Task Request Key）**：
+由调用方提供、用于识别同一任务工作目录中一次任务创建请求的标识。不同工作目录中的相同请求键表示不同请求。
+_Avoid_: 全局任务 ID

package/README.md

@@ -8,9 +8,11 @@
 
 | 目的 | 入口 |
 | --- | --- |
-| 安装、认证、后台运行、卸载 | [部署说明](docs/deployment.md) |
+| 安装、配置、运行 | [部署说明](docs/deployment.md) |
 | 本机控制台、配置保存与 Web/CLI 重启 | [控制台说明](docs/web-console.md) |
+| 命令行配置、凭据和任务管理 | [CLI 说明](docs/cli.md) |
 | 理解产品目标和架构选择 | [总体方案](docs/design-proposal.md) |
+| 查询项目术语 | [词汇表](CONTEXT.md) |
 | 查找实现与对应测试 | [代码导航](docs/technical-design.md) |
 | 查询测试命令、真实验收及缺口 | [验证说明](docs/validation.md) |
 | npm 候选验收、GitHub Actions 与受控发布 | [发布说明](docs/release.md) |
@@ -20,28 +22,49 @@
 
 ## 使用入口
 
-Linux/macOS，Node.js **22.19+**。安装包自带运行产物，无需克隆或编译。`latest` 指向的已发布版本及平台验收范围见[发布证据](docs/validation.md#npm-发布候选验证)。
+Linux/macOS，Node.js **22.19+**。以下描述 `0.1.0-rc.1` 的使用入口；安装包自带运行产物。实际发布状态及平台验收范围见[发布证据](docs/validation.md#npm-发布候选验证)。
 
 ```bash
 npm install -g @realqiyan/agent-task
 agent-task setup
-agent-task start
-# 另一个终端进行带认证的健康检查：
+# 在 MCP 宿主中配置 command: agent-task，args: [mcp]
+# 连接后可查询后台状态：
 agent-task status
 # 应用已保存配置并确认新实例可用：
 agent-task restart
 ```
 
-npm 包名为 `@realqiyan/agent-task`，安装后的命令仍为 `agent-task`。setup 提供交互配置；启动后可使用本机 Web 控制台。先停止前台实例，再用 `agent-task service install` 安装并启动用户后台服务。安装器不会替用户登录或批准执行端；详细操作见[部署说明](docs/deployment.md)。
+npm 包名为 `@realqiyan/agent-task`，安装后的命令仍为 `agent-task`。setup 要求确认目录、端口、令牌与协调模型。MCP 连接自动启动或复用独立后台，检测本机执行 CLI，并在缺少 ACP 适配器时安装当时最新版；已有适配器复用，原生登录仍由其官方工具管理。宿主退出后后台继续运行。接入配置与前台管理方式见[部署说明](docs/deployment.md)。
 
-MCP 客户端使用独立服务 token。源码开发辅助命令（凭据须安全注入环境，不写命令行）：
+stdio 入口从私有文件读取内部服务 token；直接 HTTP 接入需配置独立服务 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、人工回复和工作空间选择都不授予工具权限。
+任务由 `task_create` 提交固定 DAG，每个节点选择已就绪执行端。显式工作目录优先，否则 stdio 入口补入自己的启动目录；直接 HTTP 调用必须提供目录。具体契约见 [task-contract.ts](src/protocol/task-contract.ts)，管理工具见 [mcp.ts](src/protocol/mcp.ts)。Prompt、人工回复和工作空间选择都不授予工具权限。
+
+## CLI 命令索引
+
+下表列出全部命令及子命令。参数见 `agent-task <命令> --help`，操作流程见 [CLI 说明](docs/cli.md)和[部署说明](docs/deployment.md)。
+
+| 命令 | 子命令 | 用途 |
+| --- | --- | --- |
+| `agent-task setup` | — | 初始化、检查或接续安装配置 |
+| `agent-task mcp` | — | stdio 接入，自动启动或连接共用后台 |
+| `agent-task start` | — | 前台启动服务并调度任务 |
+| `agent-task stop` | — | 停止共用服务 |
+| `agent-task restart` | — | 应用已保存配置并重启、检查可用性 |
+| `agent-task status` | — | 查看服务健康、活动任务及待生效配置 |
+| `agent-task config` | `show`、`diff`、`edit`、`export`、`validate`、`apply` | 查看、编辑、导出、校验及保存配置 |
+| `agent-task executor` | `list`、`show`、`refresh`、`upgrade`、`enable`、`disable` | 查看与刷新执行端、升级适配器、设置启停 |
+| `agent-task coordinator` | `show`、`set`、`clear` | 查看、设置或清除协调模型配置 |
+| `agent-task credential` | `list`、`set`、`delete` | 查看凭据状态、设置或删除凭据 |
+| `agent-task task` | `list`、`show`、`pause`、`resume`、`cancel` | 查看任务，控制未来触发 |
+| `agent-task run` | `list`、`show` | 查看运行历史与交付详情 |
+| `agent-task help` / `agent-task --help` | — | 查看总帮助 |
+| `agent-task --version` | — | 查看版本 |
 
 ## 许可证
 

package/bin/agent-task.mjs

@@ -3,17 +3,20 @@ import { readFileSync } from "node:fs";
 
 const help = `Usage: agent-task <command>
   setup [options]           Interactive configuration (setup --help for flags)
+  mcp [--home PATH]          MCP stdio connection; start or reuse the shared background service
   start [--home PATH]        Foreground service using the private installation
-  restart [--home PATH]      Restart foreground or managed runtime; verify readiness
-  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
+  stop [--home PATH]         Stop the shared service
+  restart [--home PATH]      Restart runtime; verify readiness
+  status [--home PATH]       Health, active work and pending configuration
+  config                    Show, edit, validate and apply configuration
+  executor                  Discover executors, upgrade adapters and configure enable/disable
+  coordinator               Configure the coordination model
+  credential                List, replace or delete private credentials
+  task                      Inspect tasks and control future triggers
+  run                       Inspect run history and deliveries
+  <command> --help           Command usage; management supports --json
   --version | --help
-Node.js 22.19+; Linux or macOS. Setup never grants executor permissions.`;
+Node.js 22.19+; Linux or macOS.`;
 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");
@@ -22,40 +25,36 @@ try {
     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") {
+  } else if (command === "setup") {
     process.argv = [process.execPath, command, ...args];
     await import(`../scripts/${command}.mjs`);
   } else {
     const lib = await import("../scripts/install-lib.mjs");
-    const action = command === "service" ? args.shift() : undefined;
-    if (!["start", "status", "restart", "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);
-        await 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") {
-      if (lib.readManifest(root).serviceInstalled) throw new Error("Remove the managed service before starting a foreground instance");
-      process.argv = [process.execPath, "service-runner", root];
-      await import("../scripts/service-runner.mjs");
+    if (["start", "mcp", "stop"].includes(command)) {
+      if (args.includes("--help")) { console.log("Usage: agent-task " + command + " [--home ABSOLUTE_DIR]" + (command === "stop" ? " [--json]" : "")); }
+      else {
+        const json = command === "stop" && args.includes("--json");
+        if (args.filter(arg => arg === "--json").length > 1) throw new Error("Repeated option: --json");
+        const options = lib.argumentsFor(json ? args.filter(arg => arg !== "--json") : args);
+        if (Object.keys(options).some(key => key !== "home")) throw new Error("Only --home is accepted here");
+        const root = lib.installRoot(options);
+        if (command === "mcp") {
+          const { runMcp } = await import("../dist/application/mcp-entry.js");
+          await runMcp(root);
+        } else if (command === "stop") {
+          const { controlService } = await import("../dist/integrations/local-service/control.js");
+          console.log(JSON.stringify({ event: "stopped", ...await controlService(root, "stop") }, null, json ? undefined : 2));
+        } else {
+          process.argv = [process.execPath, "service-runner", root];
+          await import("../scripts/service-runner.mjs");
+        }
+      }
     } else {
-      const { controlService } = await import("../dist/launcher.js");
-      const ready = await controlService(root, command);
-      console.log(JSON.stringify({ event: command === "restart" ? "restarted" : "healthy", ...ready }));
+      const { runCli } = await import("../dist/protocol/cli/commands.js");
+      await runCli(command, args, home => lib.installRoot({ home }));
     }
   }
 } catch (error) {
-  console.error(error.message);
+  console.error(process.argv.includes("--json") ? JSON.stringify({ error: error.message }) : error.message);
   process.exitCode = 1;
 }

package/config.example.json

@@ -3,5 +3,5 @@
   "port": 8765,
   "tokenEnv": "AGENT_TASK_TOKEN",
   "coordinator": { "provider": "openai", "model": "YOUR_AVAILABLE_MODEL_ID" },
-  "executors": []
+  "disabledExecutors": []
 }

package/dist/{launcher.js → application/launcher.js}

@@ -1,13 +1,12 @@
 import { fork } from "node:child_process";
-import { createServer, request } from "node:http";
+import { createServer } from "node:http";
 import { appendFileSync, chmodSync, closeSync, constants, existsSync, fstatSync, lstatSync, openSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { randomUUID } from "node:crypto";
-import { acquireLauncherLock } from "./lock.js";
-import { prepareStartup, startupPaths } from "./startup.js";
-import { readEnvironment } from "./environment.js";
-import { loadConfig } from "./config.js";
+import { acquireLauncherLock } from "../infrastructure/lock.js";
+import { prepareStartup } from "./startup.js";
+import { startupPaths } from "../configuration/files.js";
 function message(child, type, timeout = 30_000) {
     return new Promise((resolve, reject) => {
         const cleanup = () => { clearTimeout(timer); child.off("message", receive); child.off("exit", exit); child.off("error", fail); };
@@ -67,17 +66,25 @@ function logFile(path) {
 export async function launch(home, nativeEnvironment) {
     process.umask(0o077);
     startupPaths(home); // Also checks private ownership of the locator.
-    const unlock = acquireLauncherLock(home);
+    const unlock = await acquireLauncherLock(home);
     const socket = join(home, "control.sock"), children = new Set();
     let current, ready, restarting = true, closing = false;
+    let shutting;
     let release;
     const finished = new Promise(resolve => { release = resolve; });
     const control = createServer(async (req, res) => {
         try {
-            if (req.method !== "POST" || !["/status", "/restart"].includes(req.url ?? "")) {
+            if (req.method !== "POST" || !["/status", "/restart", "/stop"].includes(req.url ?? "")) {
                 res.writeHead(404).end();
                 return;
             }
+            if (req.url === "/stop") {
+                await shutdown(true);
+                res.setHeader("Content-Type", "application/json");
+                res.setHeader("Connection", "close");
+                res.end(JSON.stringify({ stopped: true }));
+                return;
+            }
             const result = req.url === "/restart" ? await restart() : await status();
             res.setHeader("Content-Type", "application/json");
             res.end(JSON.stringify(result));
@@ -86,31 +93,36 @@ export async function launch(home, nativeEnvironment) {
             res.writeHead(503).end(JSON.stringify({ error: "Service unavailable; inspect private logs and startup files" }));
         }
     });
-    const shutdown = async () => {
-        if (closing)
-            return;
+    const shutdown = (drain = false) => {
+        if (shutting)
+            return shutting;
         closing = true;
-        control.close();
-        control.closeAllConnections();
-        await Promise.all([...children].map(stop));
-        try {
-            removeSocket(socket);
-        }
-        finally {
-            unlock();
-            release();
-        }
+        return shutting = (async () => {
+            control.close();
+            if (!drain)
+                control.closeAllConnections();
+            await Promise.all([...children].map(stop));
+            try {
+                removeSocket(socket);
+            }
+            finally {
+                unlock();
+                release();
+            }
+        })();
     };
     const signal = () => { void shutdown(); };
+    const hangup = () => { }; // A detached launcher survives the originating terminal closing.
     process.on("SIGINT", signal);
     process.on("SIGTERM", signal);
+    process.on("SIGHUP", hangup);
     const start = async () => {
         const inputs = await prepareStartup(home);
         if (closing)
             throw new Error("Launcher is closing");
         const log = logFile(join(inputs.dataDir, "service.log"));
         const child = fork(fileURLToPath(new URL("./main.js", import.meta.url)), ["--config", inputs.configPath, "--environment", inputs.environmentPath], {
-            env: { ...nativeEnvironment, AGENT_TASK_INSTANCE_ID: randomUUID() }, execArgv: [], stdio: ["ignore", "pipe", "pipe", "ipc"],
+            env: { ...nativeEnvironment, AGENT_TASK_INSTANCE_ID: randomUUID(), AGENT_TASK_INSTALL_HOME: home }, execArgv: [], stdio: ["ignore", "pipe", "pipe", "ipc"],
         });
         children.add(child);
         const output = (chunk) => { appendFileSync(log, chunk); process.stdout.write(chunk); };
@@ -144,7 +156,7 @@ export async function launch(home, nativeEnvironment) {
             const value = (await message(child, "ready")).ready;
             await health(value, inputs.environment[inputs.config.tokenEnv]);
             current = child;
-            ready = value;
+            ready = { info: value, token: inputs.environment[inputs.config.tokenEnv] };
             return value;
         }
         catch (error) {
@@ -155,28 +167,35 @@ export async function launch(home, nativeEnvironment) {
     const status = async () => {
         if (!ready || restarting || closing)
             throw new Error("Service unavailable");
-        const paths = startupPaths(home), config = loadConfig(paths.configPath), env = readEnvironment(paths.environmentPath);
-        await health(ready, env[config.tokenEnv]);
-        return ready;
+        // Saved inputs may need repair. Health belongs to the running instance,
+        // including the credential with which that instance actually started.
+        const running = ready;
+        await health(running.info, running.token);
+        return running.info;
     };
     const restart = async (requester) => {
         if (restarting || closing)
             throw new Error("Restart already in progress or closed");
         restarting = true;
         const old = current;
-        current = undefined;
-        ready = undefined;
         try {
             if (old) {
                 const drained = message(old, "drained");
                 old.send({ type: "drain" });
+                let result;
                 try {
-                    await drained;
+                    result = await drained;
                 }
                 catch (error) {
+                    current = undefined;
+                    ready = undefined;
                     await stop(old);
                     throw error;
                 }
+                if (result.error)
+                    throw new Error(result.error);
+                current = undefined;
+                ready = undefined;
                 // Keep only the authenticated Web response alive until the new process is verified.
                 if (old !== requester)
                     await stop(old);
@@ -186,7 +205,7 @@ export async function launch(home, nativeEnvironment) {
         }
         finally {
             restarting = false;
-            if (requester) {
+            if (requester && requester !== current) {
                 const timer = setTimeout(() => { void stop(requester); }, 5000);
                 requester.once("close", () => clearTimeout(timer));
             }
@@ -204,35 +223,7 @@ export async function launch(home, nativeEnvironment) {
         await shutdown();
         process.off("SIGINT", signal);
         process.off("SIGTERM", signal);
+        process.off("SIGHUP", hangup);
     }
 }
-/** Local administrator capability: the socket lives in the private launcher directory. */
-export function controlService(home, action) {
-    startupPaths(home);
-    return new Promise((resolve, reject) => {
-        let timedOut = false;
-        const req = request({ socketPath: join(home, "control.sock"), path: "/" + action, method: "POST" }, res => {
-            let body = "";
-            res.setEncoding("utf8");
-            res.on("data", chunk => { body += chunk; });
-            res.on("end", () => {
-                if (res.statusCode !== 200) {
-                    reject(new Error("Service unavailable; inspect private logs and startup files"));
-                    return;
-                }
-                try {
-                    resolve(JSON.parse(body));
-                }
-                catch {
-                    reject(new Error("Invalid launcher response"));
-                }
-            });
-        });
-        req.setTimeout(60_000, () => { timedOut = true; req.destroy(); });
-        req.once("error", () => reject(new Error(timedOut
-            ? "Service control timed out; outcome is unknown, check status before another restart"
-            : "Cannot contact launcher; start the foreground or managed service first")));
-        req.end();
-    });
-}
 //# sourceMappingURL=launcher.js.map

package/dist/application/main.js

@@ -0,0 +1,125 @@
+import { HttpServer } from "../protocol/http/server.js";
+import { createTaskRuntime } from "./task-runtime.js";
+import { LocalSettingsFiles, configurationPaths } from "../configuration/files.js";
+import { dirname, join, resolve } from "node:path";
+import { randomUUID } from "node:crypto";
+import { loadConfig } from "../configuration/files.js";
+import { baseEnvironment, validateServiceEnvironment } from "../configuration/environment.js";
+import { readEnvironment } from "../configuration/files.js";
+import { Settings } from "../configuration/settings.js";
+import { acquireLock } from "../infrastructure/lock.js";
+import { errorText } from "../shared/errors.js";
+import { createExecution } from "../integrations/acp/execution.js";
+import { executorEnvironment } from "../executors/environment.js";
+import { createCoordinator } from "../integrations/coordinator/coordinator.js";
+import { LocalExecutors } from "../integrations/acp/discovery.js";
+process.umask(0o077);
+const args = process.argv.slice(2);
+if (args[0] !== "--config" || args.length !== 4 || args[2] !== "--environment") {
+    console.error("Internal runtime requires --config PATH --environment PATH; use agent-task start");
+    process.exit(2);
+}
+const configPath = resolve(args[1]), environmentPath = resolve(args[3]);
+const native = { ...process.env }, base = baseEnvironment(native);
+const environment = readEnvironment(environmentPath);
+const instanceId = process.env.AGENT_TASK_INSTANCE_ID ?? randomUUID();
+for (const key of Object.keys(process.env))
+    delete process.env[key];
+Object.assign(process.env, base, environment);
+const config = loadConfig(configPath);
+const { token, adminToken } = validateServiceEnvironment(config, environment);
+let http;
+let tasks, settings;
+let release;
+let shutting;
+function shutdown(code, drain = false) {
+    process.exitCode = Math.max(process.exitCode ? Number(process.exitCode) : 0, code);
+    return shutting ??= (async () => {
+        http?.stopAccepting();
+        settings?.close();
+        try {
+            await tasks?.close();
+        }
+        catch (error) {
+            console.error(errorText(error));
+            process.exitCode = 1;
+        }
+        await http?.close(drain);
+        await release?.();
+    })().catch(error => { console.error(errorText(error)); process.exitCode = 1; });
+}
+const fatal = (error) => { console.error(errorText(error)); void shutdown(1).finally(() => { if (process.connected)
+    process.disconnect(); }); };
+let restartPending = false;
+const restart = async () => {
+    if (!process.connected || restartPending || shutting)
+        throw new Error("Restart unavailable");
+    restartPending = true;
+    return new Promise((resolve, reject) => {
+        process.once("message", function receive(value) {
+            if (value.type !== "restarted") {
+                process.once("message", receive);
+                return;
+            }
+            if (value.error && !shutting) {
+                restartPending = false;
+                reject(new Error(value.error));
+                return;
+            }
+            // The HTTP adapter finishes the authenticated response before this child exits.
+            setTimeout(() => { if (process.connected)
+                process.disconnect(); http?.closeConnections(); }, 200);
+            if (value.error)
+                reject(new Error(value.error));
+            else
+                resolve(value.ready);
+        });
+        process.send({ type: "restart" });
+    });
+};
+process.on("message", (value) => {
+    if (value.type !== "drain")
+        return;
+    // Both Web and CLI restarts pass this boundary before changing runtime ownership.
+    try {
+        if (settings?.status().writeBlocked)
+            throw new Error("Configuration publication is uncertain");
+    }
+    catch {
+        process.send?.({ type: "drained", error: "Restart blocked; stop and inspect private configuration files" });
+        return;
+    }
+    void shutdown(0, true).then(() => {
+        if (process.exitCode) {
+            if (process.connected)
+                process.disconnect();
+        }
+        else
+            process.send?.({ type: "drained" });
+    });
+});
+const stop = () => { void shutdown(0).finally(() => { http?.closeConnections(); if (process.connected)
+    process.disconnect(); }); };
+process.once("SIGINT", stop);
+process.once("SIGTERM", stop);
+process.once("disconnect", stop);
+try {
+    release = await acquireLock(config.dataDir);
+    const executorEnv = executorEnvironment(native, environment, config);
+    const discovery = new LocalExecutors(join(native.AGENT_TASK_INSTALL_HOME ?? dirname(configPath), "adapters"), executorEnv);
+    tasks = createTaskRuntime(config.dataDir, [], createExecution(executorEnv), config.coordinator ? createCoordinator(config.dataDir, config.coordinator) : undefined, fatal, discovery, config.disabledExecutors);
+    if (adminToken)
+        settings = new Settings(new LocalSettingsFiles(configPath, environmentPath), configurationPaths, config, base, process.env);
+    http = new HttpServer({ tasks, settings, token, adminToken, fatal, restart, instanceId });
+    const origin = await http.listen(config.port);
+    if (shutting)
+        throw new Error("Startup stopped");
+    tasks.supervisor.start();
+    const ready = { instanceId, pid: process.pid, url: origin + "/mcp", consoleUrl: settings ? origin + "/admin/" : null };
+    console.log(JSON.stringify({ event: "ready", ...ready }));
+    process.send?.({ type: "ready", ready });
+}
+catch (error) {
+    fatal(error);
+}
+//# sourceMappingURL=main.js.map

package/dist/application/mcp-entry.js

@@ -0,0 +1,71 @@
+import { spawn } from "node:child_process";
+import { closeSync, constants, existsSync, fstatSync, openSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { setTimeout } from "node:timers/promises";
+import { configSchema } from "../configuration/contract.js";
+import { readEnvironment, startupPaths } from "../configuration/files.js";
+import { readPrivateText } from "../infrastructure/private-files.js";
+import { controlService, ControlError } from "../integrations/local-service/control.js";
+import { serveStdio } from "../protocol/stdio.js";
+async function startBackground(home) {
+    const fd = openSync(join(home, "launcher.log"), constants.O_WRONLY | constants.O_APPEND | constants.O_CREAT | constants.O_NOFOLLOW, 0o600);
+    try {
+        const stat = fstatSync(fd);
+        if (!stat.isFile() || stat.uid !== process.getuid() || (stat.mode & 0o077))
+            throw new Error("Expected a private launcher log");
+        const child = spawn(process.execPath, [fileURLToPath(new URL("../../scripts/service-runner.mjs", import.meta.url)), home], {
+            cwd: home, env: { ...process.env }, detached: true, stdio: ["ignore", fd, fd],
+        });
+        await new Promise((resolve, reject) => {
+            child.once("error", () => reject(new Error("Cannot start background service; inspect the private launcher log")));
+            child.once("spawn", () => { child.unref(); resolve(); });
+        });
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+async function connectBackground(home) {
+    const deadline = Date.now() + 40_000;
+    let mayStart = true;
+    while (Date.now() < deadline) {
+        try {
+            return await controlService(home, "status", 2000);
+        }
+        catch (error) {
+            if (!(error instanceof ControlError) || error.kind === "invalid")
+                throw error;
+            if (error.kind === "unreachable" && mayStart) {
+                mayStart = false;
+                await startBackground(home);
+            }
+            else
+                mayStart = false;
+        }
+        // Concurrent clients may launch together. The existing launcher lock selects one owner.
+        await setTimeout(200);
+    }
+    throw new Error("Background service did not become ready; inspect the private launcher log and use agent-task status. No restart was attempted");
+}
+/** The stdio connection owns neither the shared launcher nor persisted work. */
+export async function runMcp(home) {
+    const workspace = process.cwd();
+    if (!existsSync(join(home, "launch.json")))
+        throw new Error("Agent Task is not initialized; run agent-task setup first");
+    startupPaths(home);
+    const ready = await connectBackground(home);
+    const paths = startupPaths(home);
+    let config;
+    try {
+        config = configSchema.parse(JSON.parse(readPrivateText(paths.configPath)));
+    }
+    catch {
+        throw new Error("Cannot read service configuration; inspect the private startup files");
+    }
+    const token = readEnvironment(paths.environmentPath)[config.tokenEnv];
+    if (!token)
+        throw new Error("Service credential is unavailable; inspect the private startup files");
+    await serveStdio({ url: ready.url, token, workspace });
+}
+//# sourceMappingURL=mcp-entry.js.map

package/dist/{startup.js → application/startup.js}

@@ -1,16 +1,11 @@
+import { startupPaths } from "../configuration/files.js";
 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") };
-}
+import { loadConfig } from "../configuration/files.js";
+import { readEnvironment } from "../configuration/files.js";
+import { validateServiceEnvironment } from "../configuration/environment.js";
+import { checkDataDirectory, readPrivateText, replacePrivateText } from "../infrastructure/private-files.js";
+import { acquireLock } from "../infrastructure/lock.js";
 function prepareFile(path, text) {
     if (existsSync(path)) {
         if (readPrivateText(path) !== text)

package/dist/application/task-runtime.js

@@ -0,0 +1,42 @@
+import { join } from "node:path";
+import { ExecutorRegistry } from "../executors/registry.js";
+import { checkWorkspace, resolveWorkspace } from "../infrastructure/workspace.js";
+import { LocalResultFiles } from "../results/files.js";
+import { Results } from "../results/service.js";
+import { TaskDefinitions } from "../tasks/definitions.js";
+import { TaskRuns } from "../tasks/runs.js";
+import { RunSupervisor } from "../tasks/supervisor.js";
+import { TaskStore } from "../tasks/storage/store.js";
+/** Creates and owns the business store and services; callers must stop ingress before closing. */
+export function createTaskRuntime(directory, profiles, openExecution, coordinate, fatal, discovery, disabled = []) {
+    const store = new TaskStore(directory);
+    try {
+        const executors = new ExecutorRegistry(profiles, discovery, disabled);
+        const workspaces = { resolve: resolveWorkspace, check: checkWorkspace };
+        const results = new Results(new LocalResultFiles(join(directory, "results"), true));
+        const definitions = new TaskDefinitions(store, executors, workspaces, Boolean(coordinate));
+        const runs = new TaskRuns(store, executors, results, workspaces);
+        const supervisor = new RunSupervisor(runs, openExecution, coordinate, fatal);
+        let closing;
+        return { definitions, runs, supervisor, executors,
+            close() {
+                return closing ??= (async () => {
+                    definitions.close();
+                    const stopped = supervisor.close();
+                    runs.close();
+                    try {
+                        await Promise.all([stopped, executors.close()]);
+                    }
+                    finally {
+                        store.close();
+                    }
+                })();
+            },
+        };
+    }
+    catch (error) {
+        store.close();
+        throw error;
+    }
+}
+//# sourceMappingURL=task-runtime.js.map