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

package/dist/protocol/cli/commands.js

@@ -14,18 +14,19 @@ config edit [--editor EXECUTABLE] [--yes]
 config export --output FILE
 config validate --file FILE
 config apply --file FILE [--yes]
-Drafts contain {editToken, config, approveExecutors}; no credential values.
-Edit tokens expire after 15 minutes or a save/restart. Explicit approvals name executor IDs in the candidate configuration.
+Drafts contain {editToken, config}; no credential values.
+Edit tokens expire after 15 minutes or a save/restart.
 Saving applies on next start; it does not restart the service.`,
-    executor: `executor list [--saved | --running]
-executor show ID [--saved | --running]
-executor add --id ID --type pi|codex|claude|opencode --cwd ABSOLUTE_DIR [--note TEXT] [--yes]
-executor update ID [--id NEW_ID] [--type TYPE] [--cwd ABSOLUTE_DIR] [--note TEXT] [--yes]
-executor remove ID [--yes]
-executor approve ID [--yes]
-executor revoke ID [--yes]
-Changes apply on next start. New registrations are unapproved; changing ID, type or workspace clears approval.
-approve records the administrator's review of native authorization; --yes alone does not grant it.`,
+    executor: `executor list
+executor show pi|codex|claude|opencode
+executor refresh
+executor upgrade pi|codex|claude [--yes]
+executor enable pi|codex|claude|opencode [--yes]
+executor disable pi|codex|claude|opencode [--yes]
+list/show report current discovery and adapter preparation; native authentication is not verified.
+refresh discovers installed CLIs and prepares missing adapters in the background.
+upgrade explicitly updates a managed ACP adapter; existing tasks keep their native executor assignment.
+enable/disable apply on next start. Native CLI authentication and permissions remain native configuration.`,
     coordinator: `coordinator show [--saved | --running]
 coordinator set --provider openai|anthropic|deepseek|openai-compatible --model ID [--yes]
   Compatible provider also requires: --base-url URL --api-key-env NAME
@@ -176,15 +177,11 @@ export async function runCli(command, args, resolveHome) {
                 throw new Error("Unknown config action");
             break;
         case "executor":
-            if (action === "list" || action === "show") {
-                allowed = ["saved", "running"];
-                count = action === "show" ? 2 : 1;
-            }
-            else if (action === "add" || action === "update") {
-                allowed = ["id", "type", "cwd", "note", "yes"];
-                count = action === "update" ? 2 : 1;
-            }
-            else if (["remove", "approve", "revoke"].includes(action)) {
+            if (action === "list" || action === "refresh")
+                allowed = [];
+            else if (action === "show")
+                count = 2;
+            else if (["enable", "disable", "upgrade"].includes(action)) {
                 count = 2;
                 allowed = ["yes"];
             }
@@ -248,6 +245,27 @@ export async function runCli(command, args, resolveHome) {
         output({ event: "healthy", ...client.ready, ...await client.request("/status") });
         return;
     }
+    if (command === "executor" && ["list", "show", "refresh", "upgrade"].includes(action)) {
+        if (action === "refresh") {
+            output(await client.request("/executors/refresh", {}));
+            return;
+        }
+        if (action === "upgrade") {
+            await confirm(options, "Upgrade the managed ACP adapter for " + id + "?");
+            output(await client.request("/executors/upgrade", { id }));
+            return;
+        }
+        const result = await client.request("/executors");
+        if (action === "list")
+            output(result);
+        else {
+            const executor = result.executors.find(item => item.id === id);
+            if (!executor)
+                throw new Error("Executor not found");
+            output(executor);
+        }
+        return;
+    }
     if (command === "task" || command === "run") {
         if (action === "list") {
             const query = new URLSearchParams();
@@ -294,7 +312,7 @@ export async function runCli(command, args, resolveHome) {
             output(options.running ? view.running : view.saved);
             return;
         }
-        const draft = { editToken: view.editToken, config: view.saved, approveExecutors: [] };
+        const draft = { editToken: view.editToken, config: view.saved };
         if (action === "export") {
             const path = text(options, "output", true);
             writeDraft(path, draft);
@@ -333,36 +351,13 @@ export async function runCli(command, args, resolveHome) {
         return;
     }
     const selected = options.running ? view.running : view.saved;
-    if (action === "list") {
-        output(selected.executors);
-        return;
-    }
     if (action === "show") {
-        if (command === "coordinator")
-            output(selected.coordinator ?? null);
-        else {
-            const executor = selected.executors.find(item => item.id === id);
-            if (!executor)
-                throw new Error("Executor not found");
-            output(executor);
-        }
+        output(selected.coordinator ?? null);
         return;
     }
     let change;
     if (command === "executor") {
-        if (action === "add" || action === "update") {
-            const fields = {};
-            for (const key of ["id", "type", "cwd", "note"]) {
-                const value = text(options, key, action === "add" && key !== "note");
-                if (value !== undefined)
-                    fields[key] = value;
-            }
-            if (!Object.keys(fields).length)
-                throw new Error("Specify at least one executor field to update");
-            change = action === "add" ? { action: "executor-add", executor: fields } : { action: "executor-update", id, patch: fields };
-        }
-        else
-            change = { action: "executor-" + action, id };
+        change = { action: "executor-" + action, id };
     }
     else if (action === "clear")
         change = { action: "coordinator-clear" };

package/dist/protocol/http/server.js

@@ -39,6 +39,14 @@ export class HttpServer {
             next();
         }, express.json({ limit: "512kb" }));
         app.post("/mcp", async (req, res) => {
+            if (req.body?.method === "initialize") {
+                const discovered = options.tasks.executors.refresh();
+                if (!discovered.executors.some(executor => executor.nativePath !== null)) {
+                    res.json({ jsonrpc: "2.0", id: req.body.id ?? null, error: { code: -32000,
+                            message: "No local executor CLI found. Install and configure at least one of pi, codex, claude or opencode, then reconnect. Management remains available." } });
+                    return;
+                }
+            }
             const server = createMcpServer(options.tasks, options.fatal);
             const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined, enableJsonResponse: true });
             let closed;

package/dist/protocol/http/web.js

@@ -4,7 +4,7 @@ import { bearerVerifier } from "./auth.js";
 import { SettingsError } from "../../configuration/settings.js";
 import { previewSettings } from "../../configuration/management.js";
 import { StorageError } from "../../shared/errors.js";
-import { parseSettings, settingsConfigSchema, settingsChangeSchema, credentialUpdateSchema } from "../settings-contract.js";
+import { parseSettings, settingsConfigSchema, settingsChangeSchema, credentialUpdateSchema, executorRefreshSchema, executorUpgradeSchema } from "../settings-contract.js";
 import { taskIdSchema, taskListSchema, taskRunListSchema, taskUpdateSchema } from "../task-contract.js";
 function query(schema, request) {
     const value = { ...request.query };
@@ -91,6 +91,12 @@ export function createWebRouter(tasks, settings, token, fatal, restart, instance
     }));
     router.get("/api/runs/:id", respond(req => tasks.runs.get(taskIdSchema.parse(req.params).id)));
     router.post("/api/task-update", respond(req => tasks.definitions.update(taskUpdateSchema.parse(req.body))));
+    router.get("/api/executors", respond(() => tasks.executors.list()));
+    router.post("/api/executors/refresh", respond(req => {
+        parseSettings(executorRefreshSchema, req.body);
+        return tasks.executors.refresh();
+    }));
+    router.post("/api/executors/upgrade", respond(req => tasks.executors.upgrade(parseSettings(executorUpgradeSchema, req.body).id)));
     router.get("/api/settings", respond(() => settings.get()));
     router.get("/api/settings/diff", respond(() => settings.diff()));
     router.post("/api/settings/prepare", respond(req => settings.prepareChange(parseSettings(settingsChangeSchema, req.body))));

package/dist/protocol/mcp.js

@@ -26,10 +26,10 @@ export function createMcpServer(service, fatal) {
         });
     }
     register("service_status", "Service health and active node run IDs. MCP disconnection does not cancel tasks.", z.object({}).strict(), () => service.supervisor.status());
-    register("executor_list", "Registered local ACP execution profiles and authorization settings. Approval filtering is not a sandbox.", z.object({}).strict(), () => service.executors.list());
-    register("task_create", "Create a task with a caller-defined DAG in nodes. Each node selects an administrator-registered ACP executorId. The coordinator advances this fixed DAG, reviews deliveries and requests missing user facts; it does not plan new nodes. Optional workspace selects an existing absolute directory; otherwise each executor uses its registered cwd. Path checks do not grant permissions; no uncertain-effect retries.", taskSchema, input => service.definitions.create(input), false);
+    register("executor_list", "Discovered local ACP executors and adapter preparation status. Ready means launch dependencies are present, not verified authentication or tool permissions.", z.object({}).strict(), () => service.executors.list());
+    register("task_create", "Create a task with a caller-defined DAG. Each node selects a ready local ACP executorId. The coordinator advances the fixed DAG, reviews deliveries and requests missing user facts. Workspace is an existing absolute directory; local stdio supplies its launch directory when omitted, direct HTTP requires workspace. The resolved directory is fixed for all future runs. requestKey deduplicates within that directory. Path checks do not grant permissions; no uncertain-effect retries.", taskSchema, input => service.definitions.create(input), false);
     register("task_list", "List persisted task definitions.", taskListSchema, input => service.definitions.list(input.after, input.limit));
-    register("task_get", "Get task goal, caller-defined DAG and assigned executor profiles, canonical workspace (null means executor cwd defaults), budgets and schedule.", taskIdSchema, input => service.definitions.get(input.id));
+    register("task_get", "Get task goal, caller-defined DAG and assigned executors, fixed canonical workspace, budgets and schedule.", taskIdSchema, input => service.definitions.get(input.id));
     register("task_update", "Pause, resume or cancel future triggers only; resume never catches up. To change a task, cancel it and create a new task. Use task_run_cancel to stop an active run; cancellation does not roll back external effects.", taskUpdateSchema, input => service.definitions.update(input), false);
     register("task_run_list", "List independent task runs with node progress and blocking reasons.", taskRunListSchema, input => service.runs.list(input.taskId, input.after, input.limit));
     register("task_run_get", "Get the committed plan, selected node workspaces, ACP turns, accepted deliveries, blocking questions and errors for one task run.", taskIdSchema, input => service.runs.get(input.id));

package/dist/protocol/settings-contract.js

@@ -1,24 +1,21 @@
 import { SettingsError } from "../configuration/settings.js";
 import { z } from "zod";
 import { configSchema } from "../configuration/contract.js";
-import { executorSchema } from "../executors/validation.js";
-import { identifier } from "../shared/validation.js";
+import { executorTypeSchema } from "../executors/validation.js";
 export const settingsConfigSchema = z.object({
     editToken: z.string().uuid(),
     config: configSchema,
-    approveExecutors: z.array(identifier).max(100).default([]),
 }).strict();
 export const settingsChangeSchema = z.object({
     editToken: z.string().uuid(),
     change: z.discriminatedUnion("action", [
-        z.object({ action: z.literal("executor-add"), executor: executorSchema.omit({ unattendedApproved: true }) }).strict(),
-        z.object({ action: z.literal("executor-update"), id: identifier,
-            patch: executorSchema.omit({ unattendedApproved: true }).extend({ note: executorSchema.shape.note.removeDefault() }).partial() }).strict(),
-        z.object({ action: z.enum(["executor-remove", "executor-approve", "executor-revoke"]), id: identifier }).strict(),
+        z.object({ action: z.enum(["executor-enable", "executor-disable"]), id: executorTypeSchema }).strict(),
         z.object({ action: z.literal("coordinator-set"), coordinator: configSchema.shape.coordinator.unwrap() }).strict(),
         z.object({ action: z.literal("coordinator-clear") }).strict(),
     ]),
 }).strict();
+export const executorRefreshSchema = z.object({}).strict();
+export const executorUpgradeSchema = z.object({ id: executorTypeSchema }).strict();
 const credential = {
     editToken: z.string().uuid(),
     key: z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(200),

package/dist/protocol/stdio.js

@@ -0,0 +1,71 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
+import { version } from "../infrastructure/version.js";
+const toolNames = new Set(["service_status", "executor_list", "task_create", "task_list", "task_get", "task_update",
+    "task_run_list", "task_run_get", "task_run_reply", "task_run_cancel"]);
+/** A fixed Agent Task adapter; only task creation receives the connection's startup directory. */
+export async function serveStdio(options) {
+    const url = new URL(options.url);
+    if (url.protocol !== "http:" || url.hostname !== "127.0.0.1" || url.pathname !== "/mcp" || url.username || url.password || url.search || url.hash) {
+        throw new Error("Invalid local MCP address");
+    }
+    const client = new Client({ name: "agent-task-stdio", version });
+    const server = new Server({ name: "agent-task", version }, { capabilities: { tools: {} } });
+    let close, finish;
+    const finished = new Promise(resolve => { finish = resolve; });
+    const shutdown = () => close ??= Promise.resolve().then(async () => {
+        try {
+            await server.close();
+        }
+        finally {
+            try {
+                await client.close();
+            }
+            finally {
+                finish();
+            }
+        }
+    });
+    const stop = () => { void shutdown().catch(() => { }); };
+    server.onclose = stop;
+    client.onclose = stop;
+    server.onerror = stop;
+    process.stdin.once("end", stop);
+    process.stdin.once("close", stop);
+    process.stdout.once("error", stop);
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+    process.once("SIGHUP", stop);
+    server.setRequestHandler(ListToolsRequestSchema, async (request) => {
+        const result = await client.listTools(request.params);
+        return { ...result, tools: result.tools.filter(tool => toolNames.has(tool.name)) };
+    });
+    server.setRequestHandler(CallToolRequestSchema, request => {
+        if (!toolNames.has(request.params.name))
+            throw new McpError(ErrorCode.MethodNotFound, "Unknown Agent Task tool");
+        const input = request.params.arguments ?? {};
+        return client.callTool({ ...request.params, arguments: request.params.name === "task_create" && input.workspace === undefined
+                ? { ...input, workspace: options.workspace } : input });
+    });
+    try {
+        await client.connect(new StreamableHTTPClientTransport(url, {
+            requestInit: { headers: { Authorization: "Bearer " + options.token }, redirect: "error" },
+        }));
+        if (!close)
+            await server.connect(new StdioServerTransport());
+        await finished;
+    }
+    finally {
+        await shutdown();
+        process.stdin.off("end", stop);
+        process.stdin.off("close", stop);
+        process.stdout.off("error", stop);
+        process.off("SIGINT", stop);
+        process.off("SIGTERM", stop);
+        process.off("SIGHUP", stop);
+    }
+}
+//# sourceMappingURL=stdio.js.map

package/dist/protocol/task-contract.js

@@ -15,7 +15,7 @@ export const taskUpdateSchema = taskUpdateData;
 export const taskSchema = taskData.extend({
     name: z.string().trim().min(1).max(200),
     prompt: z.string().trim().min(1).max(64_000).describe("Overall goal; the caller supplies the fixed DAG."),
-    nodes: z.array(nodeSchema).min(1).max(20).describe("Fixed DAG with an administrator-registered ACP executorId on every node."),
+    nodes: z.array(nodeSchema).min(1).max(20).describe("Fixed DAG with a ready local ACP executorId on every node."),
     schedule: z.discriminatedUnion("type", [
         z.object({ type: z.literal("now") }).strict(),
         z.object({ type: z.literal("once"), at: requestTimestamp }).strict(),

package/dist/tasks/definitions.js

@@ -1,5 +1,4 @@
 import { randomUUID } from "node:crypto";
-import { authorizedProfile } from "../executors/registry.js";
 import { iso } from "../shared/time.js";
 import { validateGraph } from "./graph.js";
 import { hasUncertainOutcome, initialTime, resumeSchedule } from "./schedule.js";
@@ -24,7 +23,11 @@ export class TaskDefinitions {
         if (!this.coordinatorConfigured)
             throw new Error("Coordinator is not configured");
         const input = taskData.parse(value), all = this.store.definitions();
-        const existing = all.find(item => item.input.requestKey === input.requestKey);
+        if (input.workspace === undefined)
+            throw new Error("workspace is required without a local MCP launch directory");
+        const workspace = this.workspaces.resolve(input.workspace);
+        input.workspace = workspace;
+        const existing = all.find(item => item.workspace === workspace && item.input.requestKey === input.requestKey);
         if (existing) {
             if (JSON.stringify(existing.input) !== JSON.stringify(input))
                 throw new Error("requestKey already used with different parameters");
@@ -39,7 +42,7 @@ export class TaskDefinitions {
             throw new Error("Schedule must start in the future");
         if (input.expiresAt && Date.parse(input.expiresAt) <= Math.max(now, nextAt))
             throw new Error("Deadline must follow first trigger");
-        const task = { id: randomUUID(), input, workspace: input.workspace === undefined ? null : this.workspaces.resolve(input.workspace),
+        const task = { id: randomUUID(), input, workspace,
             executors, nextAt, status: "active", createdAt: iso(now) };
         this.store.saveDefinition(task);
         return task;
@@ -72,10 +75,10 @@ export class TaskDefinitions {
         this.store.saveDefinition(task);
         return task;
     }
-    executorImpact(profiles) {
+    executorImpact(disabled) {
         this.check();
         return this.store.definitions().filter(task => ((task.nextAt !== null && ["active", "paused"].includes(task.status)) || this.store.activeRounds(task.id).length > 0) &&
-            Object.entries(task.executors).some(([id, snapshot]) => !authorizedProfile(snapshot, profiles.find(profile => profile.id === id))))
+            Object.values(task.executors).some(snapshot => disabled.includes(snapshot.type)))
             .map(task => ({ id: task.id, name: task.input.name }));
     }
     close() { this.closed = true; }

package/dist/tasks/runs.js

@@ -123,7 +123,7 @@ export class TaskRuns {
                 throw new Error("Deadline reached before node start");
             if (sessions.size >= 8)
                 throw new Error("ACP session capacity reached; accept existing results first");
-            node.workspace = task.workspace ?? executor.cwd;
+            node.workspace = task.workspace;
             this.workspaces.check(node.workspace);
             node.inputFiles = parents.map(parent => parent.resultFile);
         }
@@ -141,7 +141,7 @@ export class TaskRuns {
         // The no-replay barrier precedes worker creation, not just the ACP prompt.
         this.store.commitRun(run);
         return opening ? { kind: "open", nodeRunId: node.id, text, seconds: node.definition.maxRunSeconds,
-            input: { executor: { ...executor, cwd: node.workspace }, inputFiles: node.inputFiles, resultsRoot: this.results.root } }
+            input: { executor, workspace: node.workspace, inputFiles: node.inputFiles, resultsRoot: this.results.root } }
             : { kind: "continue", nodeRunId: node.id, text };
     }
     beforeStart(id, nodeId) {

package/dist/tasks/storage/records.js

@@ -3,10 +3,10 @@ import { executorRecord } from "../../executors/validation.js";
 import { absolutePath, identifier, text, timestamp } from "../../shared/validation.js";
 import { nodeData, questionData, taskData } from "../validation.js";
 export const definitionSchema = z.object({
-    id: z.string().uuid(), input: taskData, workspace: absolutePath.nullable(), executors: z.record(identifier, executorRecord),
+    id: z.string().uuid(), input: taskData, workspace: absolutePath, executors: z.record(identifier, executorRecord),
     status: z.enum(["active", "paused", "cancelled", "completed", "expired"]),
     nextAt: z.number().finite().nullable(), createdAt: timestamp,
-}).strict();
+}).strict().refine(task => task.input.workspace === task.workspace, "Task workspace must match the canonical request");
 export const roundSchema = z.object({
     id: z.string().uuid(), taskId: z.string().uuid(), scheduledAt: z.number().finite(),
     status: z.enum(["running", "succeeded", "failed", "interrupted", "skipped", "cancelled", "timed_out", "waiting_input"]),

package/dist/tasks/storage/store.js

@@ -14,7 +14,7 @@ export class TaskStore {
         try {
             const tables = this.db.prepare("SELECT name FROM sqlite_master WHERE type='table'").all();
             if (tables.length) {
-                this.db.prepare("SELECT seq,id,request_key,data FROM definitions LIMIT 0").all();
+                this.db.prepare("SELECT seq,id,workspace,request_key,data FROM definitions LIMIT 0").all();
                 this.db.prepare("SELECT seq,id,task_id,scheduled_at,data FROM rounds LIMIT 0").all();
                 this.definitions();
                 this.rounds();
@@ -22,7 +22,8 @@ export class TaskStore {
             this.db.exec("PRAGMA journal_mode=WAL; PRAGMA synchronous=FULL; PRAGMA foreign_keys=ON");
             if (!tables.length)
                 this.db.exec(`BEGIN IMMEDIATE;
-        CREATE TABLE definitions(seq INTEGER PRIMARY KEY, id TEXT UNIQUE NOT NULL, request_key TEXT UNIQUE NOT NULL, data TEXT NOT NULL);
+        CREATE TABLE definitions(seq INTEGER PRIMARY KEY, id TEXT UNIQUE NOT NULL, workspace TEXT NOT NULL,
+          request_key TEXT NOT NULL, data TEXT NOT NULL, UNIQUE(workspace,request_key));
         CREATE TABLE rounds(seq INTEGER PRIMARY KEY, id TEXT UNIQUE NOT NULL, task_id TEXT NOT NULL REFERENCES definitions(id),
           scheduled_at REAL NOT NULL, data TEXT NOT NULL, UNIQUE(task_id,scheduled_at));
         COMMIT;`);
@@ -86,8 +87,8 @@ export class TaskStore {
         try {
             this.db.exec("BEGIN IMMEDIATE");
             if (definition)
-                this.db.prepare(`INSERT INTO definitions(id,request_key,data) VALUES(?,?,?)
-        ON CONFLICT(id) DO UPDATE SET data=excluded.data`).run(definition.id, definition.input.requestKey, JSON.stringify(definition));
+                this.db.prepare(`INSERT INTO definitions(id,workspace,request_key,data) VALUES(?,?,?,?)
+        ON CONFLICT(id) DO UPDATE SET data=excluded.data`).run(definition.id, definition.workspace, definition.input.requestKey, JSON.stringify(definition));
             if (round)
                 this.db.prepare(`INSERT INTO rounds(id,task_id,scheduled_at,data) VALUES(?,?,?,?)
         ON CONFLICT(id) DO UPDATE SET data=excluded.data`).run(round.id, round.taskId, round.scheduledAt, JSON.stringify(round));

package/dist/tasks/supervisor.js

@@ -132,7 +132,7 @@ export class RunSupervisor {
         if (this.timer)
             throw new Error("Run supervisor already started");
         this.recover();
-        this.timer = setInterval(() => this.tick(), 500);
+        this.timer = setInterval(() => this.tick(), 10_000);
         this.tick();
     }
     tick() {

package/dist/web/settings-view.js

@@ -1,31 +1,28 @@
 import { request } from "./api.js";
-import { element, field, select, button, submit, block, table, notice } from "./dom.js";
+import { element, field, select, button, submit, block, table, notice, report } from "./dom.js";
 
-function executorEditor(host, executor) {
-  const card = element("fieldset"), fields = {};
-  card.append(element("legend", "ACP 执行端"));
-  const type = select("类型", ["pi", "codex", "claude", "opencode"].map(value => [value, value]), executor.type ?? "pi");
-  fields.type = type.input; card.append(type.row);
-  for (const [key, label, kind, value] of [
-    ["id", "注册 ID", "text", executor.id],
-    ["note", "备注", "textarea", executor.note],
-    ["cwd", "默认工作空间（绝对路径）", "text", executor.cwd],
-  ]) {
-    const item = field(label, value, kind); fields[key] = item.input; card.append(item.row);
-  }
-  const approved = field("已由管理员审核原生授权，允许无人值守执行", executor.unattendedApproved, "checkbox");
-  let explicitlyApproved = false;
-  approved.input.addEventListener("change", () => { explicitlyApproved = approved.input.checked; });
-  for (const [key, input] of Object.entries(fields)) if (key !== "note") input.addEventListener("input", () => {
-    approved.input.checked = false; explicitlyApproved = false;
-  });
-  card.append(approved.row, element("p", "按类型从用户原生 PATH 查找 ACP 适配器。继承用户原生环境，但过滤服务私密变量；额外 ACP 审批一律拒绝。结果固定保存在 dataDir/results，只向节点提供指定上游文件，不提供整个数据目录读取。"),
-    button("从待保存配置中移除", () => { card.remove(); host.dispatchEvent(new Event("input", { bubbles: true })); }));
-  host.append(card);
-  return () => card.parentNode === host ? [{ explicitlyApproved, executor: {
-    id: fields.id.value, type: fields.type.value, note: fields.note.value,
-    cwd: fields.cwd.value, unattendedApproved: approved.input.checked,
-  } }] : [];
+function executorStatus(host, initial) {
+  let state = initial, timer;
+  const labels = { missing: "未安装", disabled: "已禁用", installing: "准备中", ready: "可派发", error: "准备失败" };
+  const draw = () => {
+    clearTimeout(timer);
+    host.replaceChildren(table(["执行端", "状态", "本机路径", "ACP 适配器版本", "错误", "操作"], state.executors.map(executor => [
+      executor.id, executor.state === "missing" && executor.nativePath ? "已发现，待准备" : labels[executor.state],
+      executor.nativePath, executor.adapterVersion ?? (executor.type === "opencode" ? "原生 ACP" : "—"), executor.error,
+      executor.type === "opencode" ? "通过原生 CLI 更新" : button("升级 ACP 适配器", async () => {
+        if (!confirm("升级 " + executor.id + " 的托管 ACP 适配器？准备期间暂停向此执行端派发新工作。")) return;
+        state = await request("/executors/upgrade", { id: executor.id }); draw();
+        notice("适配器升级已开始，完成后更新状态。");
+      }, !executor.nativePath || ["disabled", "installing"].includes(executor.state)),
+    ])));
+    if (state.executors.some(executor => executor.state === "installing")) timer = setTimeout(async () => {
+      if (!host.isConnected) return;
+      try { state = await request("/executors"); if (host.isConnected) draw(); }
+      catch (error) { if (host.isConnected) report(error); }
+    }, 2000);
+  };
+  draw();
+  return async () => { state = await request("/executors/refresh", {}); draw(); };
 }
 function coordinatorEditor(host, config) {
   const provider = select("协调模型提供方", [["", "未配置"], ["openai", "OpenAI"], ["anthropic", "Anthropic"],
@@ -56,12 +53,18 @@ function coordinatorEditor(host, config) {
   };
 }
 export async function renderSettings(root, navigate) {
-  let state = await request("/settings");
+  const initial = await Promise.all([request("/settings"), request("/executors")]);
+  let state = initial[0];
   root.append(element("h2", "配置与凭据"), element("p", "配置和密钥分别保存。保存不修改当前进程；每次重新启动（包括故障后拉起）读取已保存值。"),
     element("p", "先保存新密钥，再保存引用它的配置。执行端原生登录和原生权限仍通过官方工具管理；这里不编辑其认证文件。"),
     block("当前运行配置（只读，无密钥值）", state.running));
   if (state.writeBlocked) root.append(element("p", "上次文件提交结果不确定。请停服核查；当前禁止继续保存。"));
-  const form = element("form"), modelHost = element("fieldset"), executors = element("div"), readers = [];
+  const executorHost = element("div");
+  const refreshExecutors = executorStatus(executorHost, initial[1]);
+  root.append(element("h3", "本机执行端"),
+    element("p", "自动检测 pi、codex、claude 和 opencode。可派发表示启动依赖已准备，不代表原生认证或工具权限已验收。"),
+    button("重新检测并准备执行端", refreshExecutors), executorHost);
+  const form = element("form"), modelHost = element("fieldset"), executorOptions = element("fieldset");
   modelHost.append(element("legend", "协调模型"));
   const readModel = coordinatorEditor(modelHost, state.saved.coordinator);
   const startup = {
@@ -69,18 +72,21 @@ export async function renderSettings(root, navigate) {
     port: field("下次启动的监听端口（0 为自动分配）", state.saved.port, "number"),
     tokenEnv: field("MCP 令牌环境变量名（改名保留令牌值）", state.saved.tokenEnv),
   };
-  form.append(element("h3", "启动配置"), ...Object.values(startup).map(item => item.row),
-    modelHost, element("h3", "执行端注册与权限"), executors);
-  for (const executor of state.saved.executors) readers.push(executorEditor(executors, executor));
-  form.append(button("添加执行端", () => {
-    readers.push(executorEditor(executors, { id: "", type: "pi", note: "", cwd: "", unattendedApproved: false }));
-  }, state.writeBlocked));
+  executorOptions.append(element("legend", "下次启动启用的执行端"),
+    element("p", "默认使用所有检测到的执行端。取消勾选后保存并重启；已有任务不会自动改派。"));
+  const enabled = ["pi", "codex", "claude", "opencode"].map(type => {
+    const item = field(type, !state.saved.disabledExecutors.includes(type), "checkbox");
+    executorOptions.append(item.row); return { type, input: item.input };
+  });
+  const advanced = element("details"); advanced.dataset.key = "advanced-settings";
+  advanced.append(element("summary", "高级设置"), element("h3", "启动配置"),
+    ...Object.values(startup).map(item => item.row), executorOptions);
+  form.append(modelHost, advanced);
   const preview = element("div");
   const save = submit(form, "校验并预览配置变更", async () => {
-    const entries = readers.flatMap(read => read());
-    const input = { editToken: state.editToken, approveExecutors: entries.filter(item => item.explicitlyApproved).map(item => item.executor.id),
+    const input = { editToken: state.editToken,
       config: { dataDir: startup.dataDir.input.value, port: startup.port.input.valueAsNumber, tokenEnv: startup.tokenEnv.input.value,
-      coordinator: readModel(), executors: entries.map(item => item.executor) } };
+      coordinator: readModel(), disabledExecutors: enabled.filter(item => !item.input.checked).map(item => item.type) } };
     const checked = await request("/settings/validate", input);
     preview.replaceChildren(block("校验后的待保存配置", checked.config),
       block("配置变更", checked.changes),

package/docs/adr/0001-task-request-scope.md

@@ -0,0 +1,3 @@
+# 按任务工作目录区分创建请求
+
+多个项目共用本机后台时，调用方可能使用相同请求键。任务创建请求按最终规范工作目录和请求键确定身份，使不同目录的请求相互独立，同一目录中的重复提交仍能去重。

package/docs/adr/0002-mcp-workspace-source.md

@@ -0,0 +1,3 @@
+# 使用明确的任务工作目录来源
+
+MCP 宿主不保证从当前项目目录启动接入进程，服务无法据此通用地识别宿主当前项目。任务显式提供的工作目录优先，否则使用本机 MCP 入口的启动目录；直接 HTTP 调用须显式提供目录。默认目录属于该 MCP 连接，避免多个项目误用共用后台的启动目录。

package/docs/adr/0003-adapter-installation.md

@@ -0,0 +1,3 @@
+# 按需安装最新版适配器并复用已有安装
+
+MCP 连接触发 ACP 适配器检测，缺失时安装当时最新版，已有安装继续复用。升级由显式操作触发，避免普通重连改变任务使用的执行环境。

package/docs/architecture-guidelines.md

@@ -34,8 +34,8 @@ CLI 覆盖 Web 的全部配置和管理操作，两端必须复用同一套底
 ## 权限与敏感数据
 
 - 执行端声明能力、管理员授权、真实验证证据分别表达，不能相互推导。
-- 只有管理员注册的执行端可启动。命令、凭据和能力端点属于管理员；任务可选择现有绝对工作空间，但路径校验不是授权或沙箱。
-- 授权须在可控制的实际操作入口检查。沿用执行端原生授权，额外 ACP 审批请求一律拒绝；`unattendedApproved` 不能证明所有原生工具已受控。
+- 只有已发现、未禁用且 ACP 依赖就绪的本机执行端可启动。启动命令由系统控制，MCP 调用方不能提供命令、凭据或能力端点；任务目录在创建时确定，路径校验不是授权或沙箱。
+- 授权须在可控制的实际操作入口检查。沿用执行端原生授权，额外 ACP 审批请求一律拒绝；发现与依赖就绪不能证明所有原生工具已受控。
 - Prompt、角色、技能、工具标题、协议成功和人工事实回复都不授予权限。取消、恢复和跨 Agent 传递不能扩大授权。
 - 无人值守执行不等待交互审批；授权不充分或元数据不足时拒绝，不退回更宽权限或自动永久允许。
 - MCP token、管理员 token、协调模型与执行端凭据分开；执行端继承用户原生环境前过滤服务私密变量，不有意记录秘密。Agent 输出和协调日志仍可能敏感。

package/docs/cli.md

@@ -1,6 +1,6 @@
 # 本机管理 CLI
 
-CLI 覆盖 Web 的配置、凭据、任务查询、未来触发控制及重启操作。两端通过同一管理 API 使用配置和任务服务；重启由同一启动器处理。命令入口见 [命令实现](../src/protocol/cli/commands.ts)，管理传输见 [admin-client.ts](../src/protocol/cli/admin-client.ts)。
+CLI 覆盖 Web 的配置、凭据、执行端管理、任务查询、未来触发控制及重启操作。两端通过同一管理 API 使用配置、执行端和任务服务；重启由同一启动器处理。命令入口见 [命令实现](../src/protocol/cli/commands.ts)，管理传输见 [admin-client.ts](../src/protocol/cli/admin-client.ts)。
 
 ## 连接与命令
 
@@ -16,9 +16,9 @@ agent-task task --help
 agent-task run --help
 ```
 
-逐级帮助是命令与参数的完整入口。管理命令支持 `--json`，结果写入 stdout，预览和诊断写入 stderr；失败退出码非零。非交互保存与任务变更须使用 `--yes`，它只确认本次操作，不替代校验或执行端授权。
+逐级帮助是命令与参数的完整入口。管理命令支持 `--json`，结果写入 stdout，预览和诊断写入 stderr；失败退出码非零。非交互保存、适配器升级与任务变更须使用 `--yes`，它只确认本次操作，不授予执行端原生工具权限。
 
-服务不可用时，管理命令失败，不自动离线写文件。首次安装仍使用 `setup`；启动故障按[部署说明](deployment.md#前台重启与健康检查)停服核查。CLI 不迁移数据或修复历史。
+服务不可用时，管理命令失败，不自动离线写文件。首次安装仍使用 `setup`；启动故障按[部署说明](deployment.md#后台前台与健康检查)停服核查。CLI 不迁移数据或修复历史。
 
 ## 配置流程
 
@@ -38,10 +38,18 @@ agent-task config show --running
 
 导出文件不包含密钥值，以私有权限创建，拒绝覆盖已有文件。编辑令牌过期、服务重启或任一客户端保存配置/凭据后，旧草稿不能提交；重新读取并人工核对，不自动合并。草稿契约见 [settings-contract.ts](../src/protocol/settings-contract.ts)。
 
-`executor` 和 `coordinator` 提供便捷操作，配置服务负责生成候选配置，再走同一预览、校验和保存流程。新执行端默认未批准；修改 ID、类型或工作空间后清除批准。原生授权审核完成后，显式运行 `executor approve ID`。完整草稿新增或变更已批准的执行端时，也须明确声明对候选配置的授权。
+`executor enable/disable` 和 `coordinator` 提供便捷配置操作。配置服务生成候选配置，再走同一预览、校验和保存流程。执行端自动发现，无须手工注册、设置默认工作目录或另行批准。启用与禁用在下次启动生效，不改写已有任务的执行端指派。
 
 配置与凭据均在下次启动生效。影响预览不修改旧任务快照，也不证明模型认证或 ACP 执行成功。保存顺序、端点与凭据隔离、重启影响见[控制台说明](web-console.md#保存与重启)。
 
+## 执行端发现与更新
+
+`agent-task executor list` 查看当前发现和准备结果；`executor show codex` 查看单个执行端。安装新的原生 CLI 后，运行 `executor refresh` 重新检测并在后台准备缺少的 ACP 适配器。该操作无需重启。准备失败时先检查报告的原因，修正后显式刷新或升级。
+
+已准备的适配器不会随普通启动或刷新自动升级。需要更新时运行 `agent-task executor upgrade codex --yes`，再用 `executor list` 检查结果。升级期间暂停向该执行端派发新工作；它不修改已有任务指派。OpenCode 使用原生 ACP 命令，通过原生 CLI 的安装渠道更新。
+
+就绪状态只表示启动依赖已准备。原生登录和权限仍由执行端管理；首次准备、版本来源及运行边界见[部署说明](deployment.md)。
+
 ## 凭据与任务
 
 `credential set NAME` 使用隐藏终端输入；自动化通过 `--stdin --yes` 从可信凭据工具或受保护文件传值，不把值写进命令参数。`credential list` 只显示设置状态。执行端原生登录和权限继续由其官方工具管理。