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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@realqiyan/agent-task",
-  "version": "0.0.1-rc.1",
+  "version": "0.0.1-rc.3",
   "license": "MIT",
   "author": "realqiyan",
   "repository": {
@@ -21,11 +21,9 @@
     "scripts/setup-wizard.mjs",
     "scripts/install-lib.mjs",
     "scripts/service-runner.mjs",
-    "scripts/uninstall.mjs",
     "scripts/probe-agent.mjs",
     "scripts/mcp-call.mjs",
     "docs/*.md",
-    "deploy/*.example",
     "config.example.json",
     "LICENSE"
   ],
@@ -34,24 +32,26 @@
     "registry": "https://registry.npmjs.org/",
     "tag": "latest"
   },
-  "os": ["linux", "darwin"],
+  "os": [
+    "linux",
+    "darwin"
+  ],
   "type": "module",
   "description": "Durable intelligent task coordination over MCP with ACP executors",
   "engines": {
     "node": ">=22.19.0"
   },
   "scripts": {
-    "check": "tsc --noEmit",
+    "check": "tsc --noEmit && node scripts/check-boundaries.mjs",
     "build": "rm -rf dist && tsc && node scripts/copy-web.mjs",
     "test": "npm run build && node --test --test-concurrency=1 tests/*.test.mjs",
     "test:e2e": "npm run build && node --test --test-concurrency=1 tests/e2e/deepseek-acp.test.mjs",
     "test:e2e:human": "npm run build && node scripts/run-pi-human-e2e.mjs",
-    "start": "node dist/main.js",
+    "start": "node bin/agent-task.mjs start",
     "setup": "node bin/agent-task.mjs setup",
     "prepack": "npm run build",
     "pack:release": "node scripts/pack-release.mjs",
-    "test:install": "node scripts/verify-install.mjs",
-    "uninstall:service": "node scripts/uninstall.mjs"
+    "test:install": "node scripts/verify-install.mjs"
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "2.0.0",

package/scripts/install-lib.mjs

@@ -1,22 +1,20 @@
 import { spawnSync } from "node:child_process";
-import { DatabaseSync } from "node:sqlite";
-import { existsSync, mkdirSync, readFileSync, writeFileSync, lstatSync, realpathSync, readdirSync, unlinkSync, rmdirSync, openSync, closeSync, fsyncSync, renameSync } from "node:fs";
+import { DatabaseSync } from "../dist/infrastructure/sqlite.js";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, lstatSync, realpathSync, readdirSync, unlinkSync, openSync, closeSync, fsyncSync, renameSync } from "node:fs";
 import { dirname, join, resolve, isAbsolute, basename } from "node:path";
 import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
-import { setTimeout as delay } from "node:timers/promises";
 
 export const packageRoot = realpathSync(fileURLToPath(new URL("..", import.meta.url)));
 
-export const label = "com.agent-task.service";
-export const unit = "agent-task.service";
 export const packages = {
   pi: ["@earendil-works/pi-coding-agent@1.3.0", "pi-acp@0.0.34"],
   codex: ["@agentclientprotocol/codex-acp@2.2.2"],
+  claude: ["@zed-industries/claude-agent-acp@0.23.1"],
   opencode: ["opencode-ai@1.19.3"],
 };
 export function argumentsFor(argv) {
-  const flags = new Set(["prepare-only", "service", "check", "probe", "resume", "help"]), options = {};
+  const flags = new Set(["check", "probe", "resume", "help"]), options = {};
   for (let i = 0; i < argv.length; i++) {
     const key = argv[i].replace(/^--/, "");
     if (!argv[i].startsWith("--") || key in options) throw new Error("Invalid or repeated option");
@@ -59,7 +57,7 @@ export function run(command, args, options = {}) {
 export function operationLock(root) {
   const db = new DatabaseSync(join(root, "setup-lock.sqlite"));
   try { db.exec("PRAGMA busy_timeout=0; BEGIN EXCLUSIVE"); }
-  catch { db.close(); throw new Error("Another setup/uninstall operation owns this installation"); }
+  catch { db.close(); throw new Error("Another setup operation owns this installation"); }
   return () => db.close();
 }
 export function readManifest(root) {
@@ -85,107 +83,11 @@ export function saveManifest(root, manifest) {
   }
 }
 export function runtimeBaseEnv(manifest) {
-  // Do not inherit shell/service-manager credentials, loader hooks or executor overrides.
-  return { HOME: manifest.home, PATH: [join(manifest.root, "components/node_modules/.bin"), dirname(manifest.node), "/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin"].join(":"), LANG: "en_US.UTF-8" };
-}
-export function runtimeEnv(manifest) {
-  const values = json(join(manifest.root, "environment.json"));
-  if (!values || typeof values !== "object" || Array.isArray(values) || Object.entries(values).some(([key, value]) => !/^[A-Za-z_][A-Za-z0-9_]*$/.test(key) || ["__proto__", "constructor", "prototype"].includes(key) || typeof value !== "string" || value.includes("\0"))) throw new Error("Invalid environment.json");
-  return { ...runtimeBaseEnv(manifest), ...values };
-}
-const xml = value => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
-const systemdQuote = value => '"' + value.replaceAll("\\", "\\\\").replaceAll('"', '\\"').replaceAll("%", "%%").replaceAll("$", "$$") + '"';
-export function serviceDefinition(manifest) {
-  const runner = join(manifest.app, "scripts/service-runner.mjs");
-  if (manifest.platform === "linux") return {
-    path: join(manifest.home, ".config/systemd/user", unit),
-    text: `[Unit]\nDescription=Agent Task (managed by setup)\nAfter=network.target\n\n[Service]\nType=simple\nExecStart=${[manifest.node, runner, manifest.root].map(systemdQuote).join(" ")}\nRestart=on-failure\nRestartSec=5\nTimeoutStopSec=20\nKillMode=control-group\nUMask=0077\n\n[Install]\nWantedBy=default.target\n`,
-  };
-  return { path: join(manifest.home, "Library/LaunchAgents", label + ".plist"), text:
-    `<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n<plist version="1.0"><dict>\n<key>Label</key><string>${label}</string>\n<key>ProgramArguments</key><array>${[manifest.node, runner, manifest.root].map(value => `<string>${xml(value)}</string>`).join("")}</array>\n<key>RunAtLoad</key><true/>\n<key>KeepAlive</key><dict><key>SuccessfulExit</key><false/></dict>\n<key>ThrottleInterval</key><integer>5</integer>\n<key>ExitTimeOut</key><integer>20</integer>\n<key>AbandonProcessGroup</key><false/>\n<key>Umask</key><integer>63</integer>\n<key>StandardOutPath</key><string>${xml(join(manifest.root, "service.log"))}</string>\n<key>StandardErrorPath</key><string>${xml(join(manifest.root, "service-error.log"))}</string>\n</dict></plist>\n` };
-}
-export function serviceEnv() {
-  const keys = ["HOME", "PATH", "LANG", "LC_ALL", "DBUS_SESSION_BUS_ADDRESS"];
-  return { ...Object.fromEntries(keys.filter(key => process.env[key] !== undefined).map(key => [key, process.env[key]])),
-    XDG_RUNTIME_DIR: process.env.XDG_RUNTIME_DIR ?? `/run/user/${process.getuid()}` };
-}
-export async function checkHealth(config, env, waitMs = 5000) {
-  const token = env[config.tokenEnv ?? "AGENT_TASK_TOKEN"];
-  if (!token || token.length < 32) throw new Error("A valid service token is required for the health check");
-  const deadline = Date.now() + waitMs;
-  do {
-    try {
-      const response = await fetch(`http://127.0.0.1:${config.port}/mcp`, {
-        method: "POST", headers: { Authorization: "Bearer " + token, "Content-Type": "application/json", Accept: "application/json, text/event-stream" },
-        body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/call", params: { name: "service_status", arguments: {} } }),
-        signal: AbortSignal.timeout(1000),
-      });
-      const body = await response.json();
-      if (response.ok && body.result?.structuredContent?.ok && body.result.structuredContent.data?.running) return;
-    } catch { /* Startup can take several seconds; never log the authenticated request. */ }
-    await delay(200);
-  } while (Date.now() < deadline);
-  throw new Error("Authenticated MCP health check failed; inspect the service manager and private configuration");
-}
-export function verifyServiceFile(manifest) {
-  const definition = serviceDefinition(manifest);
-  if (existsSync(definition.path)) {
-    privateFile(definition.path);
-    if (readFileSync(definition.path, "utf8") !== definition.text) throw new Error("Service file differs; refusing to overwrite or remove it: " + definition.path);
-  }
-  return definition;
-}
-export function activate(manifest) {
-  const definition = verifyServiceFile(manifest);
-  if (!existsSync(definition.path)) createFile(definition.path, definition.text);
-  if (manifest.platform === "linux") {
-    run("systemctl", ["--user", "daemon-reload"], { env: serviceEnv() });
-    run("systemctl", ["--user", "enable", "--now", unit], { env: serviceEnv() });
-    run("systemctl", ["--user", "is-active", unit], { env: serviceEnv() });
-  } else {
-    const domain = `gui/${process.getuid()}`;
-    const active = spawnSync("launchctl", ["print", domain + "/" + label], { stdio: "ignore" });
-    if (active.status !== 0) run("launchctl", ["bootstrap", domain, definition.path]);
-    run("launchctl", ["kickstart", domain + "/" + label]);
-    run("launchctl", ["print", domain + "/" + label]);
-  }
-}
-export function deactivate(manifest) {
-  const definition = verifyServiceFile(manifest);
-  if (!existsSync(definition.path)) {
-    if (manifest.serviceInstalled) throw new Error("Managed service file is missing; verify it is unloaded before cleanup");
-    return;
-  }
-  if (manifest.platform === "linux") {
-    run("systemctl", ["--user", "disable", "--now", unit], { env: serviceEnv() });
-    // Do not remove code while the service is still active or deactivating.
-    const state = run("systemctl", ["--user", "show", "--property=ActiveState", "--value", unit], { env: serviceEnv() });
-    if (!["inactive", "failed"].includes(state)) throw new Error("Service has not stopped");
-  } else {
-    const target = `gui/${process.getuid()}/${label}`;
-    const active = spawnSync("launchctl", ["print", target], { stdio: "ignore" });
-    if (active.status === 0) run("launchctl", ["bootout", target]);
-    if (spawnSync("launchctl", ["print", target], { stdio: "ignore" }).status === 0) throw new Error("LaunchAgent is still loaded");
-  }
-  unlinkSync(definition.path);
-  if (manifest.platform === "linux") run("systemctl", ["--user", "daemon-reload"], { env: serviceEnv() });
+  // Capture the OS user environment; the runtime isolates private service values before worker creation.
+  return { ...process.env, HOME: manifest.home, PATH: [join(manifest.root, "components/node_modules/.bin"), dirname(manifest.node), process.env.PATH ?? "", "/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin"].join(":"), LANG: process.env.LANG ?? "en_US.UTF-8" };
 }
 export function inventory(root, relative) {
   const path = join(root, relative), stat = lstatSync(path);
   if (!stat.isDirectory() || stat.isSymbolicLink()) return [relative];
   return readdirSync(path).flatMap(name => inventory(root, join(relative, name))).concat(relative);
 }
-export function removeInventory(root, files) {
-  for (const relative of files) {
-    if (!/^components(\/|$)/.test(relative) || relative.split("/").includes("..")) throw new Error("Invalid component inventory");
-    const path = join(root, relative);
-    // Never follow a directory replaced by a symlink outside the installation.
-    try {
-      if (realpathSync(dirname(path)) !== dirname(path)) throw new Error("Component parent path changed; cleanup stopped");
-      const stat = lstatSync(path);
-      if (stat.isDirectory() && !stat.isSymbolicLink()) {
-        try { rmdirSync(path); } catch (error) { if (error.code !== "ENOTEMPTY") throw error; }
-      } else unlinkSync(path);
-    } catch (error) { if (error.code !== "ENOENT") throw error; }
-  }
-}

package/scripts/mcp-call.mjs

@@ -1,6 +1,6 @@
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { version } from "../dist/version.js";
+import { version } from "../dist/infrastructure/version.js";
 const [tool, input = "{}"] = process.argv.slice(2);
 if (!tool || !process.env.AGENT_TASK_TOKEN) {
   console.error("Usage: AGENT_TASK_TOKEN=... node scripts/mcp-call.mjs <tool|--list> '[JSON arguments]'\nAGENT_TASK_URL defaults to http://127.0.0.1:8765/mcp");

package/scripts/probe-agent.mjs

@@ -2,16 +2,22 @@
 import { spawn } from "node:child_process";
 import { Readable, Writable } from "node:stream";
 import * as acp from "@agentclientprotocol/sdk";
-import { loadConfig, executorEnv } from "../dist/config.js";
-import { terminateGroup } from "../dist/acp.js";
-import { version } from "../dist/version.js";
+import { loadConfig } from "../dist/configuration/files.js";
+import { executorEnvironment } from "../dist/executors/environment.js";
+import { executorCommand } from "../dist/integrations/acp/runtime.js";
+import { readEnvironment } from "../dist/configuration/files.js";
+import { join } from "node:path";
+import { terminateGroup } from "../dist/integrations/acp/connection.js";
+import { version } from "../dist/infrastructure/version.js";
 const [file, id] = process.argv.slice(2);
 if (!file || !id) { console.error("Usage: node scripts/probe-agent.mjs <config.json> <executorId>"); process.exit(2); }
 const config = loadConfig(file);
 const executor = config.executors.find(value => value.id === id);
 if (!executor) throw new Error("Executor not found");
-const child = spawn(executor.command, executor.args, {
-  cwd: executor.cwd, env: executorEnv(executor.envKeys), detached: true, stdio: ["pipe", "pipe", "pipe"],
+const env = executorEnvironment(process.env, readEnvironment(join(config.dataDir, "environment.json")), config);
+const launch = executorCommand(executor.type, env);
+const child = spawn(launch.command, launch.args, {
+  cwd: executor.cwd, env, detached: true, stdio: ["pipe", "pipe", "pipe"],
 });
 child.stderr.resume();
 let connection;

package/scripts/service-runner.mjs

@@ -1,14 +1,9 @@
-// Same process as the service: the service manager supervises the actual HTTP owner.
-import { join } from "node:path";
 import { readManifest, runtimeBaseEnv } from "./install-lib.mjs";
+import { launch } from "../dist/application/launcher.js";
 
 process.umask(0o077);
 const root = process.argv[2];
 if (!root || process.argv.length !== 3) throw new Error("Expected installation home");
 const manifest = readManifest(root);
 if (manifest.phase !== "ready") throw new Error("Installation is not ready");
-const env = runtimeBaseEnv(manifest);
-for (const key of Object.keys(process.env)) delete process.env[key];
-Object.assign(process.env, env);
-process.argv = [process.execPath, join(manifest.app, "dist/main.js"), "--config", join(root, "config.json"), "--environment", join(root, "environment.json")];
-await import("../dist/main.js");
+await launch(root, runtimeBaseEnv(manifest));

package/scripts/setup-wizard.mjs

@@ -1,14 +1,14 @@
 import { createInterface } from "node:readline/promises";
 
 export async function setupWizard(options, root) {
-  if (!process.stdin.isTTY || !process.stdout.isTTY) throw new Error("Interactive setup requires a terminal; use --executors none|pi,codex,opencode and --cwd ABSOLUTE_DIR for noninteractive setup");
+  if (!process.stdin.isTTY || !process.stdout.isTTY) throw new Error("Interactive setup requires a terminal; use --executors none|pi,codex,claude,opencode and --cwd ABSOLUTE_DIR for noninteractive setup");
   const input = createInterface({ input: process.stdin, output: process.stdout });
   const abort = new AbortController();
   input.on("SIGINT", () => abort.abort());
   const ask = async (question, fallback) => (await input.question(`${question}${fallback ? " [" + fallback + "]" : ""}: `, { signal: abort.signal })).trim() || fallback;
   try {
-    console.log(`Private installation: ${root}\nNo credentials are requested here. Use the local Web console or a private editor after setup.\nExecutors are optional; installing one does not authorize it.`);
-    options.executors ??= await ask("Executors to install (none or comma-separated pi,codex,opencode)", "none");
+    console.log(`Private installation: ${root}`);
+    options.executors ??= await ask("Executors to install (none or comma-separated pi,codex,claude,opencode)", "none");
     options.cwd ??= await ask("Existing absolute workspace (outside installation and npm package)", process.cwd());
     if (!options.provider) {
       const provider = await ask("Coordinator provider (none/openai/anthropic/deepseek; configurable later in Web)", "none");
@@ -16,11 +16,6 @@ export async function setupWizard(options, root) {
     }
     if (options.provider) options.model ??= await ask("Coordinator model ID", "");
     options.port ??= await ask("Loopback HTTP port", "8765");
-    if (!options["prepare-only"] && !options.service) {
-      const answer = await ask("Install and start the background service now? (yes/no)", "no");
-      if (!["yes", "no"].includes(answer)) throw new Error("Expected yes or no; setup cancelled");
-      if (answer === "yes") options.service = true;
-    }
     if (await ask("Write private configuration and install selected components? (yes/no)", "no") !== "yes") throw new Error("Setup cancelled; no configuration written");
   } catch (error) {
     if (abort.signal.aborted) throw new Error("Setup cancelled; no configuration written");

package/scripts/setup.mjs

@@ -5,18 +5,21 @@ import { pathToFileURL } from "node:url";
 import { homedir } from "node:os";
 import { randomBytes } from "node:crypto";
 import { argumentsFor, installRoot, packages, createFile, json, run, operationLock, readManifest, saveManifest,
-  runtimeEnv, activate, inventory, verifyServiceFile, packageRoot, checkHealth } from "./install-lib.mjs";
+  runtimeBaseEnv, inventory, packageRoot } from "./install-lib.mjs";
 import { setupWizard } from "./setup-wizard.mjs";
+import { startupPaths } from "../dist/configuration/files.js";
+import { readEnvironment } from "../dist/configuration/files.js";
+import { executorEnvironment } from "../dist/executors/environment.js";
+import { executorCommand } from "../dist/integrations/acp/runtime.js";
 
 process.umask(0o077);
 let unlock;
 try {
   const options = argumentsFor(process.argv.slice(2));
   if (options.help) {
-    console.log("Usage: agent-task setup [--home ABSOLUTE_PRIVATE_DIR]\nInteractive on a terminal for a new installation. Noninteractive: --executors pi,codex,opencode|none --cwd ABSOLUTE_DIR [--provider openai|anthropic|deepseek --model ID] [--port 8765]\nDefault: --prepare-only (no background service). --service explicitly installs/starts the background service.\nExisting installation: --check [--probe] | --resume. No credentials accepted on the command line. Existing configuration is never replaced.");
+    console.log("Usage: agent-task setup [--home ABSOLUTE_PRIVATE_DIR]\nInteractive on a terminal for a new installation. Noninteractive: --executors pi,codex,claude,opencode|none --cwd ABSOLUTE_DIR [--provider openai|anthropic|deepseek --model ID] [--port 8765]\nExisting installation: --check [--probe] | --resume. No credentials accepted on the command line. Existing configuration is never replaced.");
     process.exit(0);
   }
-  if (options.service && (options["prepare-only"] || options.check)) throw new Error("--service cannot be combined with --prepare-only or --check");
   if (options.probe && !options.check) throw new Error("--probe requires --check");
   const root = installRoot(options), manifestPath = join(root, "installation.json");
   if (!existsSync(manifestPath) && !options.check && !options.resume && (!options.executors || !options.cwd)) await setupWizard(options, root);
@@ -27,10 +30,10 @@ try {
   if (existsSync(manifestPath)) {
     manifest = readManifest(root);
     if (["executors", "cwd", "provider", "model", "port"].some(key => options[key] !== undefined)) throw new Error("Installation already exists; initialization options cannot replace existing configuration");
-    if (manifest.phase !== "ready" && !options.resume) throw new Error("Incomplete or uninstalled components; use --resume explicitly (configuration will be preserved)");
+    if (manifest.phase !== "ready" && !options.resume) throw new Error("Incomplete components; use --resume explicitly (configuration will be preserved)");
   } else {
     if (options.check || options.probe || options.resume) throw new Error("No installation to check/resume");
-    if (!options.executors || !options.cwd) throw new Error("Select --executors pi,codex,opencode|none and --cwd ABSOLUTE_DIR");
+    if (!options.executors || !options.cwd) throw new Error("Select --executors pi,codex,claude,opencode|none and --cwd ABSOLUTE_DIR");
     const selected = options.executors === "none" ? [] : options.executors.split(",");
     if (selected.some(id => !Object.hasOwn(packages, id)) || new Set(selected).size !== selected.length) throw new Error("Invalid executor selection");
     if (!options.cwd.startsWith("/") || !lstatSync(realpathSync(options.cwd)).isDirectory()) throw new Error("cwd must be an existing absolute directory");
@@ -40,31 +43,28 @@ try {
     const port = Number(options.port ?? 8765);
     if (!Number.isInteger(port) || port < 1 || port > 65535) throw new Error("Invalid port");
     // Reject unowned artifacts. This script never adopts or clears an existing installation.
-    for (const name of ["components", "config.json", "environment.json", "data"]) {
+    for (const name of ["components", "launch.json", "data"]) {
       if (existsSync(join(root, name))) throw new Error("Existing unowned installation artifact: " + name);
     }
     manifest = { project: "agent-task", root, home: homedir(), platform: process.platform, node: process.execPath, app: packageRoot,
       selected, cwd, port, coordinator: options.provider ? { provider: options.provider, model: options.model } : undefined,
-      phase: "installing", serviceInstalled: false, files: [] };
+      phase: "installing", files: [] };
     createFile(manifestPath, JSON.stringify(manifest, null, 2) + "\n");
   }
-  verifyServiceFile(manifest);
   const app = manifest.app, components = join(root, "components");
-  if (!existsSync(join(app, "dist/main.js"))) throw new Error("Prebuilt runtime is missing; reinstall the npm package (source contributors: npm run build)");
+  if (!existsSync(join(app, "dist/application/main.js"))) throw new Error("Prebuilt runtime is missing; reinstall the npm package (source contributors: npm run build)");
   if (manifest.phase !== "ready") {
-    if (manifest.serviceInstalled) throw new Error("Stop/uninstall the existing service before rebuilding components");
     for (const name of ["components"]) {
       if (!existsSync(join(root, name))) continue;
       const known = new Set(manifest.files);
       if (inventory(root, name).some(file => !known.has(file))) throw new Error("Uninventoried component files exist; refusing to overwrite them during resume");
     }
     try {
-      console.log("Using the prebuilt npm runtime. No source checkout or compilation required.");
       mkdirSync(components, { recursive: true, mode: 0o700 });
       if (!existsSync(join(components, "package.json"))) createFile(join(components, "package.json"), JSON.stringify({ private: true }));
       const dependencies = manifest.selected.flatMap(id => packages[id]);
       if (dependencies.length) {
-        console.log("Installing selected ACP executors into private components (not global executables).");
+        console.log("Installing selected ACP executors...");
         const installArgs = existsSync(join(components, "package-lock.json"))
           ? ["ci", "--ignore-scripts", "--no-audit", "--no-fund"]
           : ["install", "--save-exact", "--ignore-scripts", "--no-audit", "--no-fund", ...dependencies];
@@ -75,52 +75,43 @@ try {
         }
       }
       mkdirSync(join(root, "data/results"), { recursive: true, mode: 0o700 });
-      if (!existsSync(join(root, "environment.json"))) createFile(join(root, "environment.json"), JSON.stringify({ AGENT_TASK_TOKEN: randomBytes(32).toString("hex"), AGENT_TASK_ADMIN_TOKEN: randomBytes(32).toString("hex") }, null, 2) + "\n");
-      if (!existsSync(join(root, "config.json"))) createFile(join(root, "config.json"), JSON.stringify({ dataDir: join(root, "data"), port: manifest.port,
+      const dataDir = join(root, "data");
+      if (!existsSync(join(root, "launch.json"))) createFile(join(root, "launch.json"), JSON.stringify({ dataDir }) + "\n");
+      if (!existsSync(join(dataDir, "environment.json"))) createFile(join(dataDir, "environment.json"), JSON.stringify({ AGENT_TASK_TOKEN: randomBytes(32).toString("hex"), AGENT_TASK_ADMIN_TOKEN: randomBytes(32).toString("hex") }, null, 2) + "\n");
+      if (!existsSync(join(dataDir, "config.json"))) createFile(join(dataDir, "config.json"), JSON.stringify({ dataDir, port: manifest.port,
         tokenEnv: "AGENT_TASK_TOKEN", coordinator: manifest.coordinator,
-        executors: manifest.selected.map(id => ({ id, command: join(components, "node_modules/.bin", id === "pi" ? "pi-acp" : id === "codex" ? "codex-acp" : "opencode"),
-          args: id === "opencode" ? ["acp"] : [], cwd: manifest.cwd, envKeys: ["HOME"],
-          permissionAllowlist: [], unattendedApproved: false, resultReadRoots: [] })) }, null, 2) + "\n");
+        executors: manifest.selected.map(id => ({ id, type: id, note: "", cwd: manifest.cwd, unattendedApproved: false })) }, null, 2) + "\n");
       manifest.phase = "ready";
+      delete manifest.port; delete manifest.cwd; delete manifest.coordinator;
     } finally {
       manifest.files = ["components"].filter(name => existsSync(join(root, name))).flatMap(name => inventory(root, name));
       saveManifest(root, manifest);
     }
   }
-  const env = runtimeEnv(manifest);
-  // Config validation and probes run in the SAME explicit environment as the background service.
-  run(manifest.node, ["--input-type=module", "-e", `import {loadConfig} from ${JSON.stringify(pathToFileURL(join(app, "dist/config.js")).href)}; loadConfig(process.argv[1]);`, join(root, "config.json")], { env });
-  const config = json(join(root, "config.json"));
-  const { executorEnv } = await import(pathToFileURL(join(app, "dist/config.js")).href);
+  const paths = startupPaths(root), env = runtimeBaseEnv(manifest);
+  // Use the same native launch environment; private values are read separately, never passed to probes.
+  run(manifest.node, ["--input-type=module", "-e", `import {loadConfig} from ${JSON.stringify(pathToFileURL(join(app, "dist/configuration/files.js")).href)}; loadConfig(process.argv[1]);`, paths.configPath], { env });
+  const config = json(paths.configPath);
   for (const id of manifest.selected) {
-    const binary = id === "pi" ? "pi" : id;
-    const cliEnv = executorEnv(config.executors.find(executor => executor.id === id)?.envKeys ?? [], env);
-    run(join(components, "node_modules/.bin", binary), ["--version"], { env: cliEnv, timeout: 20000 });
+    const cliEnv = executorEnvironment(env, readEnvironment(paths.environmentPath), config);
+    executorCommand(id, cliEnv); // No native process is launched without an explicit --probe.
   }
-  const report = { platform: process.platform, dependencies: "ready", configuration: "valid", background: "not-checked",
+  const report = { platform: process.platform, dependencies: "ready", configuration: "valid",
     coordinator: config.coordinator ? "configured; authentication not verified" : "not configured; task admission disabled",
     executors: config.executors.map(executor => ({ id: executor.id, authorized: executor.unattendedApproved,
       handshake: "not checked", execution: "not verified by setup" })) };
   if (options.probe) {
     for (const entry of report.executors) {
-      try { run(manifest.node, [join(app, "scripts/probe-agent.mjs"), join(root, "config.json"), entry.id], { env, timeout: 20000 }); entry.handshake = "passed (initialize only)"; }
+      try { run(manifest.node, [join(app, "scripts/probe-agent.mjs"), paths.configPath, entry.id], { env, timeout: 20000 }); entry.handshake = "passed (initialize only)"; }
       catch { entry.handshake = "failed; inspect native dependencies/configuration separately"; process.exitCode = 1; }
     }
   }
-  if (options.service) {
-    // Record intent before activating so a failed service start is still owned by uninstall.
-    manifest.serviceInstalled = true; saveManifest(root, manifest);
-    activate(manifest);
-    report.background = "service manager registered";
-  }
-  if (manifest.serviceInstalled) {
-    try {
-      await checkHealth(config, env, 15000);
-      report.background = "authenticated MCP health check passed";
-    } catch { report.background = "not ready; run --check after startup and inspect the service manager"; process.exitCode = 1; }
-  }
   console.log(JSON.stringify(report, null, 2));
-  console.log(`Config: ${join(root, "config.json")}\nSecrets (never printed): ${join(root, "environment.json")}\nNative login: use ${join(components, "node_modules/.bin")} executables: pi then /login; codex login; opencode auth login. No login is performed by setup.\nConsole: http://127.0.0.1:${config.port}/admin/ (use the separate AGENT_TASK_ADMIN_TOKEN from the private environment file; never place it in a URL). Configure coordinator credentials there or in environment.json, and audit native executor permissions before setting unattendedApproved=true. No permissions are granted by setup. Restart the service manually after changes.\nLinux: user service requires lingering for logout survival (administrator decision). macOS: LaunchAgent survives terminal close, not user logout; log in again to restart. Neither platform executes during sleep/shutdown.`);
+  if (!options.check) {
+    console.log(`Config: ${paths.configPath}\nCredentials: ${paths.environmentPath}\nConsole: http://127.0.0.1:${config.port}/admin/\nSign in with AGENT_TASK_ADMIN_TOKEN from the credentials file.`);
+    if (config.executors.length) console.log("Prepare native executor authentication and review permissions before approving unattended execution.");
+    console.log(`Start: agent-task start --home '${root.replaceAll("'", "'\"'\"'")}'`);
+  }
 } catch (error) {
   console.error(error.message); process.exitCode = 1;
 } finally { unlock?.(); }

package/deploy/agent-task.service.example

@@ -1,17 +0,0 @@
-[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/admin.js

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

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

@@ -1,23 +0,0 @@
-import { readPrivateText } from "./private-files.js";
-export function parseEnvironment(text) {
-    let value;
-    try {
-        value = JSON.parse(text);
-    }
-    catch {
-        throw new Error("Invalid environment file JSON");
-    }
-    if (!value || typeof value !== "object" || Array.isArray(value) || Object.entries(value).some(([key, item]) => !/^[A-Za-z_][A-Za-z0-9_]*$/.test(key) || ["__proto__", "constructor", "prototype"].includes(key) ||
-        typeof item !== "string" || item.includes("\0")))
-        throw new Error("Invalid environment file");
-    return value;
-}
-export function readEnvironment(path) {
-    return parseEnvironment(readPrivateText(path));
-}
-/** Explicit file mode never falls back to inherited shell credentials. */
-export function baseEnvironment(source) {
-    return Object.fromEntries(["HOME", "PATH", "LANG", "LC_ALL", "TZ", "TMPDIR"]
-        .filter(key => source[key] !== undefined).map(key => [key, source[key]]));
-}
-//# sourceMappingURL=environment.js.map