@hanphone/dsh-a2a 0.1.0 → 0.3.0

package/lib/index.js

@@ -5,107 +5,28 @@ import { mkdirSync } from "node:fs";
 import { z as z$1 } from "zod";
 import { defineDomain, domainTable } from "@deepseek-ai/dsh-storage-domain";
 import { Service } from "@deepseek-ai/cordis";
-//#region lib/types/server/card.js
-/**
-* AgentCard assembly for the inbound half: skills are DERIVED from the live
-* tool registry by an explicit id list (never invented), plus a built-in
-* `chat` skill so a fresh install is immediately exercisable end-to-end.
-* @module dsh-a2a/server/card
-*/
-/**
-* Derive the inbound skill list from the live tool registry.
-*
-* Every configured id must resolve to a registered tool — a missing referent
-* fails the derivation loudly (the plugin's misconfiguration contract) with
-* all missing ids listed. The built-in `chat` skill is always present so the
-* server answers before any tool is exposed.
-*
-* @param tools - the tool registry getter.
-* @param policy - explicit-id derivation policy.
-* @returns the derived skills, `chat` first, configured tools after, excludes applied.
-*/
-function deriveSkills(tools, policy) {
-	const excluded = new Set(policy.exclude);
-	const skills = [{
-		id: "chat",
-		name: "chat",
-		description: "Conversational assistance over a DSH agent session.",
-		tags: ["chat"]
-	}];
-	const missing = [];
-	for (const id of policy.ids) {
-		if (excluded.has(id)) continue;
-		const tool = tools.get(id);
-		if (tool === void 0) {
-			missing.push(id);
-			continue;
-		}
-		skills.push({
-			id,
-			name: id,
-			description: tool.description ?? `Expose the DSH tool \`${id}\` over A2A.`,
-			tags: ["tool"]
-		});
-	}
-	if (missing.length > 0) throw new Error(`dsh-a2a: server.skills.ids reference unregistered tools: ${missing.join(", ")}`);
-	return skills;
-}
-/** Assemble the AgentCard advertised by this DSH. */
-function buildCard(options) {
-	const iface = {
-		url: `${options.baseUrl.replace(/\/$/, "")}${options.endpointPath}`,
-		protocolBinding: "JSONRPC",
-		protocolVersion: "1.0"
-	};
-	return {
-		name: options.name,
-		description: options.description,
-		version: options.version,
-		provider: {
-			url: "https://deepseek.com",
-			organization: "DeepSeek"
-		},
-		capabilities: {
-			streaming: true,
-			pushNotifications: false,
-			extensions: []
-		},
-		defaultInputModes: ["text/plain"],
-		defaultOutputModes: ["text/plain"],
-		skills: options.skills,
-		supportedInterfaces: [iface],
-		...options.authToken !== void 0 ? {
-			securitySchemes: { bearerAuth: {
-				type: "http",
-				scheme: "bearer",
-				description: "Shared bearer token"
-			} },
-			securityRequirements: [{ bearerAuth: [] }]
-		} : {}
-	};
-}
-//#endregion
 //#region lib/types/protocol.js
 /**
-* Agent2Agent (A2A) Protocol v1.0 — types, task states, JSON-RPC methods and
-* error codes used by this plugin's JSON-RPC over HTTP binding.
-*
-* The surface mirrors the normative `a2a.proto` of the A2A project (Apache-2.0);
-* this file is the plugin's own transcription and the single source of protocol
-* truth. Bindings other than JSON-RPC over HTTP (gRPC, REST) are not provided.
+* Agent2Agent (A2A) Protocol v1.0.1 — types, JSON-RPC methods, task states,
+* error codes and JSON serialization, transcribed from the official
+* `a2aproject/A2A` specification (Apache-2.0), cross-checked against
+* `specification/a2a.proto` and `docs/specification.md` (JSON-RPC binding,
+* ADR-001 ProtoJSON). This file is the plugin's single source of protocol
+* truth for the JSON-RPC over HTTP binding. Other bindings (gRPC, REST) are
+* not provided.
 * @module dsh-a2a/protocol
 */
-/** Task lifecycle states (spec `TaskState`). */
+/** Task lifecycle states (spec `TaskState`; JSON = SCREAMING_SNAKE_CASE per ADR-001). */
 var TaskState;
 (function(TaskState) {
-	TaskState["SUBMITTED"] = "SUBMITTED";
-	TaskState["WORKING"] = "WORKING";
-	TaskState["INPUT_REQUIRED"] = "INPUT_REQUIRED";
-	TaskState["AUTH_REQUIRED"] = "AUTH_REQUIRED";
-	TaskState["COMPLETED"] = "COMPLETED";
-	TaskState["FAILED"] = "FAILED";
-	TaskState["CANCELED"] = "CANCELED";
-	TaskState["REJECTED"] = "REJECTED";
+	TaskState["SUBMITTED"] = "TASK_STATE_SUBMITTED";
+	TaskState["WORKING"] = "TASK_STATE_WORKING";
+	TaskState["INPUT_REQUIRED"] = "TASK_STATE_INPUT_REQUIRED";
+	TaskState["AUTH_REQUIRED"] = "TASK_STATE_AUTH_REQUIRED";
+	TaskState["COMPLETED"] = "TASK_STATE_COMPLETED";
+	TaskState["FAILED"] = "TASK_STATE_FAILED";
+	TaskState["CANCELED"] = "TASK_STATE_CANCELED";
+	TaskState["REJECTED"] = "TASK_STATE_REJECTED";
 })(TaskState || (TaskState = {}));
 /** States that settle a task; a settled task no longer transitions. */
 const TERMINAL_STATES = new Set([
@@ -114,17 +35,34 @@ const TERMINAL_STATES = new Set([
 	TaskState.CANCELED,
 	TaskState.REJECTED
 ]);
+new Set([TaskState.INPUT_REQUIRED, TaskState.AUTH_REQUIRED]);
 /** @returns whether the state settles the task. */
 function isTerminal(state) {
 	return TERMINAL_STATES.has(state);
 }
-/** Message sender role (spec `Role`). */
+/** Message sender role (spec `Role`; JSON = `ROLE_*` per ADR-001). */
 var Role;
 (function(Role) {
-	Role["USER"] = "user";
-	Role["AGENT"] = "agent";
+	Role["USER"] = "ROLE_USER";
+	Role["AGENT"] = "ROLE_AGENT";
 })(Role || (Role = {}));
-/** A2A v1.0 JSON-RPC method names (canonical PascalCase as in a2a.proto). */
+/** JSON-RPC + A2A error codes. */
+const A2A_ERROR_CODES = {
+	PARSE_ERROR: -32700,
+	INVALID_REQUEST: -32600,
+	METHOD_NOT_FOUND: -32601,
+	INVALID_PARAMS: -32602,
+	INTERNAL_ERROR: -32603,
+	TASK_NOT_FOUND: -32001,
+	TASK_CANCEL_NOT_ALLOWED: -32002,
+	PUSH_NOTIFICATION_NOT_SUPPORTED: -32003,
+	UNSUPPORTED_OPERATION: -32004,
+	CONTENT_TYPE_NOT_SUPPORTED: -32005,
+	STREAMING_NOT_SUPPORTED: -32006,
+	VERSION_NOT_SUPPORTED: -32007,
+	INVALID_AGENT_RESPONSE: -32008
+};
+/** A2A v1.0 JSON-RPC method names (spec §5.3 Method Mapping Reference). */
 const A2A_METHODS = {
 	sendMessage: "SendMessage",
 	sendStreamingMessage: "SendStreamingMessage",
@@ -132,27 +70,25 @@ const A2A_METHODS = {
 	listTasks: "ListTasks",
 	cancelTask: "CancelTask",
 	subscribeToTask: "SubscribeToTask",
+	createTaskPushNotificationConfig: "CreateTaskPushNotificationConfig",
+	getTaskPushNotificationConfig: "GetTaskPushNotificationConfig",
+	listTaskPushNotificationConfigs: "ListTaskPushNotificationConfigs",
+	deleteTaskPushNotificationConfig: "DeleteTaskPushNotificationConfig",
 	getExtendedAgentCard: "GetExtendedAgentCard"
 };
-/** JSON-RPC error codes for the A2A binding (spec §error codes). */
-const A2A_ERROR_CODES = {
-	INVALID_REQUEST: -32600,
-	METHOD_NOT_FOUND: -32601,
-	INVALID_PARAMS: -32602,
-	INTERNAL_ERROR: -32603,
-	UNAUTHORIZED: -32e3,
-	TASK_NOT_FOUND: -32001,
-	TASK_CANCEL_NOT_ALLOWED: -32002,
-	AGENT_CARD_NOT_FOUND: -32004,
-	AGENT_CARD_SIGNATURE_INVALID: -32005
-};
-/** Read a message's text parts as a single string (model-facing convenience). */
+/**
+* Read a message's text parts as a single string (model-facing convenience).
+* File parts render as their URL/name; data parts as JSON.
+*/
 function partsToText(parts) {
 	if (!parts) return "";
 	return parts.map((p) => {
 		if ("text" in p && p.text) return p.text;
 		if ("data" in p && p.data !== void 0) return JSON.stringify(p.data);
-		if ("file" in p) return p.file.uri ?? `[file ${p.file.name ?? p.file.mimeType ?? "binary"}]`;
+		if ("raw" in p || "url" in p || "filename" in p) {
+			const f = p;
+			return f.url ?? `[file ${f.filename ?? f.mediaType ?? "binary"}]`;
+		}
 		return "";
 	}).filter(Boolean).join("\n");
 }
@@ -175,7 +111,10 @@ const a2aDomainSpec = defineDomain({
 	tables: {
 		tasks: domainTable(json$1),
 		contexts: domainTable(json$1),
-		agents: domainTable(json$1)
+		agents: domainTable(json$1),
+		identity: domainTable(json$1),
+		inbound_servers: domainTable(json$1),
+		outbound_servers: domainTable(json$1)
 	}
 });
 /**
@@ -214,6 +153,15 @@ var A2aDomain = class {
 	get agents() {
 		return this.handle.table("agents");
 	}
+	get identity() {
+		return this.handle.table("identity");
+	}
+	get inbound_servers() {
+		return this.handle.table("inbound_servers");
+	}
+	get outbound_servers() {
+		return this.handle.table("outbound_servers");
+	}
 	async close() {
 		await this.handle.close();
 	}
@@ -269,7 +217,8 @@ var DomainTaskStore = class {
 			parts: input.parts,
 			artifacts: [],
 			executor: "session",
-			summary: null
+			summary: null,
+			...input.serverId !== void 0 ? { serverId: input.serverId } : {}
 		};
 		this.records.set(record.taskId, record);
 		this.domain.tasks.put(recordKey(record.taskId), encodeRecord(record)).catch((err) => {
@@ -329,41 +278,6 @@ function withState(current, state, message, timestamp) {
 	};
 }
 //#endregion
-//#region lib/types/server/executor.js
-/**
-* Executor abstraction for inbound tasks: an executor turns one task into
-* output parts while reporting status and artifact updates. The registry is
-* INTERNAL (built by the plugin from config) — public registration was cut:
-* there is no external caller yet, so the seam stays an interface with two
-* built-in implementations (session, subagent).
-* @module dsh-a2a/server/executor
-*/
-/**
-* Skill → executor resolution. The subagent executor is absent on
-* compositions without the subagent seam; resolving a skill bound to a
-* missing kind fails loudly with a readable message.
-*/
-var ExecutorSet = class {
-	bySkill;
-	session;
-	subagent;
-	constructor(bySkill, session, subagent) {
-		this.bySkill = bySkill;
-		this.session = session;
-		this.subagent = subagent;
-	}
-	resolve(skill) {
-		if ((this.bySkill[skill] ?? "session") === "session") return this.session;
-		const subagent = this.subagent;
-		if (subagent === void 0) throw new Error(`a2a: skill "${skill}" is bound to the subagent executor but no subagent seam is mounted`);
-		return subagent;
-	}
-	async disposeAll() {
-		await this.session.disposeAll?.();
-		await this.subagent?.disposeAll?.();
-	}
-};
-//#endregion
 //#region lib/types/server/exec/agent-runtime.js
 /**
 * Shared agent machinery for the inbound executors: one DSH agent session per
@@ -406,7 +320,8 @@ var ContextSessionPool = class ContextSessionPool {
 		let presetId;
 		let setup;
 		if (presets !== void 0) {
-			presetId = (await presets.resolve()).id;
+			const wanted = this.opts.presetId?.() ?? void 0;
+			presetId = (wanted !== void 0 ? await presets.resolve(wanted) : await presets.resolve()).id;
 			setup = async (agentCtx) => {
 				await presets.mount(agentCtx, presetId);
 			};
@@ -499,62 +414,328 @@ function probeService(ctx, name, method) {
 	} catch {}
 }
 //#endregion
-//#region lib/types/server/exec/session.js
+//#region lib/types/api.js
 /**
-* The `session` executor: one inbound task is one turn on the context's DSH
-* agent session; reply text becomes the task's output part. Works on any
-* composition with an agent loop (the `chat` skill and the default path).
-* @module dsh-a2a/server/exec/session
+* GUI control API for the A2A settings dashboard: one `GET /a2a/api`
+* snapshot plus `POST /a2a/api` control actions (inbound/outbound server
+* CRUD + enable/disable, task view/cancel) and `GET /a2a/api/presets` for the
+* preset roster the pickers need. The browser half talks only to this route;
+* it carries no protocol knowledge. Loopback-only by default so the dashboard
+* cannot be driven from the wire.
+*
+* The route body is bound to the same `A2AServiceImpl` facade the `/a2a`
+* command surface uses, so GUI actions and commands cannot disagree.
+* @module dsh-a2a/api
 */
-/** Build the session executor over a context session pool. */
-function createSessionExecutor(pool) {
+function readBody$1(req) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		req.on("data", (chunk) => chunks.push(chunk));
+		req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+		req.once("error", reject);
+	});
+}
+/** The caller is the local machine (never a remote peer). */
+function isLoopback(req) {
+	const address = req.socket?.remoteAddress;
+	return address === "127.0.0.1" || address === "::1" || address === "::ffff:127.0.0.1";
+}
+function json(res, status, value) {
+	res.writeHead(status, {
+		"content-type": "application/json",
+		"cache-control": "no-cache"
+	});
+	res.end(JSON.stringify(value));
+}
+/** Handle one dashboard API request against the service facade. */
+async function handleApiRequest(req, res, impl) {
+	if (!isLoopback(req)) {
+		res.writeHead(403, { "content-type": "text/plain" });
+		res.end("forbidden");
+		return;
+	}
+	const path = (req.url ?? "").split("?")[0] ?? "";
+	if (req.method === "GET" && path === "/a2a/api/presets") {
+		json(res, 200, await impl.presets());
+		return;
+	}
+	if (req.method === "GET") {
+		json(res, 200, snapshotOf(impl));
+		return;
+	}
+	if (req.method === "POST") {
+		let payload;
+		try {
+			payload = JSON.parse(await readBody$1(req));
+		} catch {
+			json(res, 400, {
+				ok: false,
+				message: "invalid JSON body"
+			});
+			return;
+		}
+		const result = await dispatch(payload, impl);
+		json(res, result.ok ? 200 : 409, result);
+		return;
+	}
+	res.writeHead(405, { "content-type": "text/plain" });
+	res.end("Method Not Allowed");
+}
+function snapshotOf(impl) {
+	const status = impl.status();
 	return {
-		name: "session",
-		async execute(input) {
-			if (!input.prompt) return { parts: [{ text: "No prompt provided." }] };
-			const reply = await pool.runTurn(input.contextId, input.prompt, input.signal);
-			return { parts: [{ text: (input.signal.aborted && !reply ? "(canceled)" : reply) || "(no reply)" }] };
-		},
-		disposeAll: () => pool.disposeAll()
+		inbounds: status.inbounds ?? [],
+		outbounds: status.outbounds ?? [],
+		tasks: impl.listTasks(),
+		peers: status.peers ?? impl.inbounds()
 	};
 }
+async function dispatch(payload, impl) {
+	switch (payload.action) {
+		case "inbound.create": return impl.createInboundServer({
+			name: payload.name,
+			description: payload.description,
+			version: payload.version,
+			...payload.endpointPath !== void 0 ? { endpointPath: payload.endpointPath } : {},
+			...payload.preset !== void 0 ? { preset: payload.preset } : {},
+			...payload.authTokenEnv !== void 0 ? { authTokenEnv: payload.authTokenEnv } : {},
+			...payload.skills !== void 0 ? { skills: payload.skills } : {},
+			...payload.enabled !== void 0 ? { enabled: payload.enabled } : {}
+		});
+		case "inbound.remove": return impl.removeInboundServer(payload.id);
+		case "inbound.enable": return impl.setInboundServerEnabled(payload.id, true);
+		case "inbound.disable": return impl.setInboundServerEnabled(payload.id, false);
+		case "inbound.update": return impl.updateInboundServer(payload.id, {
+			...payload.name !== void 0 ? { name: payload.name } : {},
+			...payload.description !== void 0 ? { description: payload.description } : {},
+			...payload.version !== void 0 ? { version: payload.version } : {},
+			...payload.endpointPath !== void 0 ? { endpointPath: payload.endpointPath } : {},
+			...payload.preset !== void 0 ? { preset: payload.preset } : {},
+			...payload.authTokenEnv !== void 0 ? { authTokenEnv: payload.authTokenEnv } : {},
+			...payload.skills !== void 0 ? { skills: payload.skills } : {}
+		});
+		case "outbound.create": return impl.createOutboundServer({
+			name: payload.name,
+			agentCardUrl: payload.agentCardUrl,
+			...payload.bearerTokenEnv !== void 0 ? { bearerTokenEnv: payload.bearerTokenEnv } : {},
+			...payload.preset !== void 0 ? { preset: payload.preset } : {},
+			...payload.enabled !== void 0 ? { enabled: payload.enabled } : {},
+			...payload.timeoutMs !== void 0 ? { timeoutMs: payload.timeoutMs } : {}
+		});
+		case "outbound.remove": return impl.removeOutboundServer(payload.id);
+		case "outbound.enable": return impl.setOutboundServerEnabled(payload.id, true);
+		case "outbound.disable": return impl.setOutboundServerEnabled(payload.id, false);
+		case "outbound.refresh": return impl.refreshOutboundServer(payload.id);
+		case "task.cancel": return impl.cancelTask(payload.id);
+		case "inbound.close": return impl.closeInbound(payload.id);
+		default: return {
+			ok: false,
+			message: `unknown action ${String(payload.action)}`
+		};
+	}
+}
 //#endregion
-//#region lib/types/server/exec/subagent.js
+//#region lib/types/service.js
 /**
-* The `subagent` executor: one inbound task is delegated to a named one-shot
-* subagent under the context's parent session. The child runs with the
-* composition's own tools and the delegation boundary; its output becomes the
-* task's artifact. The subagent seam must be mounted, else the skill binding
-* fails loudly at resolution time.
-* @module dsh-a2a/server/exec/subagent
+* The `ctx.a2a` service facade: the thin read/control surface commands, the
+* GUI API, and other plugins use. Registered as a Cordis Service so the key
+* disappears with the plugin fiber.
+* @module dsh-a2a/service
 */
-/** Build a subagent executor delegating inbound tasks to one-shot children. */
-function createSubagentExecutor(opts) {
-	const { pool, subagents, provider } = opts;
+/** The service other plugins read as `ctx.a2a`. */
+var A2AService = class extends Service {
+	impl;
+	constructor(ctx, impl) {
+		super(ctx, "a2a");
+		this.impl = impl;
+	}
+	status() {
+		return this.impl.status();
+	}
+	async presets() {
+		return this.impl.presets();
+	}
+	listInboundServers() {
+		return this.impl.listInboundServers();
+	}
+	async createInboundServer(input) {
+		return this.impl.createInboundServer(input);
+	}
+	async removeInboundServer(id) {
+		return this.impl.removeInboundServer(id);
+	}
+	async setInboundServerEnabled(id, enabled) {
+		return this.impl.setInboundServerEnabled(id, enabled);
+	}
+	async updateInboundServer(id, patch) {
+		return this.impl.updateInboundServer(id, patch);
+	}
+	listOutboundServers() {
+		return this.impl.listOutboundServers();
+	}
+	async createOutboundServer(input) {
+		return this.impl.createOutboundServer(input);
+	}
+	async removeOutboundServer(id) {
+		return this.impl.removeOutboundServer(id);
+	}
+	async setOutboundServerEnabled(id, enabled) {
+		return this.impl.setOutboundServerEnabled(id, enabled);
+	}
+	async refreshOutboundServer(id) {
+		return this.impl.refreshOutboundServer(id);
+	}
+	getTask(taskId) {
+		return this.impl.getTask(taskId);
+	}
+	listTasks() {
+		return this.impl.listTasks();
+	}
+	async cancelTask(taskId) {
+		return this.impl.cancelTask(taskId);
+	}
+	inbounds() {
+		return this.impl.inbounds();
+	}
+	async closeInbound(peerId) {
+		return this.impl.closeInbound(peerId);
+	}
+};
+//#endregion
+//#region lib/types/commands.js
+/**
+* The `/a2a` command surface: status, inbound/outbound server CRUD +
+* enable/disable, and task control — a text backup to the GUI (the settings
+* panel is the primary surface). All operations delegate to the same
+* `A2AServiceImpl` facade as the dashboard API.
+* @module dsh-a2a/commands
+*/
+/** Build the `/a2a` command definition over the service facade. */
+function buildA2aCommand(impl) {
 	return {
-		name: "subagent",
-		async execute(input, execCtx) {
-			if (!input.prompt) return { parts: [{ text: "No prompt provided." }] };
-			const { agent } = await pool.agentFor(input.contextId);
-			const text = (await (await subagents.start(provider, {
-				label: `a2a:${input.skill}`,
-				prompt: [{
-					type: "text",
-					text: input.prompt
-				}],
-				parent: agent,
-				signal: input.signal
-			})).result).output.filter((b) => typeof b.text === "string").map((b) => b.text).filter(Boolean).join("\n").trim();
-			execCtx.onEvent({
-				type: "artifact",
-				artifactId: "result",
-				parts: [{ text: text || "(subagent returned no output)" }],
-				name: input.skill,
-				lastChunk: true
-			});
-			return { parts: [{ text: text || "(subagent returned no output)" }] };
+		name: "a2a",
+		description: "Manage the A2A plugin: status, inbound/outbound servers, tasks.",
+		handler: async (invocation) => {
+			const [verb, ...rest] = invocation.rawInput.trim().split(/\s+/);
+			switch (verb ?? "") {
+				case "":
+				case "status": return success(JSON.stringify(impl.status(), null, 2));
+				case "presets": return success(JSON.stringify(await impl.presets(), null, 2));
+				case "inbound": {
+					const [action, id, ...args] = rest;
+					switch (action ?? "") {
+						case "list": return success(JSON.stringify(impl.listInboundServers(), null, 2));
+						case "create": {
+							const name = args[0];
+							if (!name) return error("usage: /a2a inbound create <name> [preset] [description]");
+							const preset = args[1];
+							return outcome(await impl.createInboundServer({
+								name,
+								description: args[2] ?? "An A2A inbound server",
+								version: "1.0.0",
+								...preset && preset !== "default" ? { preset } : {}
+							}));
+						}
+						case "remove": return id ? outcome(await impl.removeInboundServer(id)) : error("usage: /a2a inbound remove <id>");
+						case "enable": return id ? outcome(await impl.setInboundServerEnabled(id, true)) : error("usage: /a2a inbound enable <id>");
+						case "disable": return id ? outcome(await impl.setInboundServerEnabled(id, false)) : error("usage: /a2a inbound disable <id>");
+						default: return error("usage: /a2a inbound list|create|remove|enable|disable ...");
+					}
+				}
+				case "outbound": {
+					const [action, id, ...args] = rest;
+					switch (action ?? "") {
+						case "list": return success(JSON.stringify(impl.listOutboundServers(), null, 2));
+						case "create": {
+							const url = args[0];
+							if (!url) return error("usage: /a2a outbound create <agentCardUrl> [name] [preset]");
+							const name = args[1] ?? url;
+							const preset = args[2];
+							return outcome(await impl.createOutboundServer({
+								name,
+								agentCardUrl: url,
+								...preset && preset !== "default" ? { preset } : {}
+							}));
+						}
+						case "remove": return id ? outcome(await impl.removeOutboundServer(id)) : error("usage: /a2a outbound remove <id>");
+						case "enable": return id ? outcome(await impl.setOutboundServerEnabled(id, true)) : error("usage: /a2a outbound enable <id>");
+						case "disable": return id ? outcome(await impl.setOutboundServerEnabled(id, false)) : error("usage: /a2a outbound disable <id>");
+						case "refresh": return id ? outcome(await impl.refreshOutboundServer(id)) : error("usage: /a2a outbound refresh <id>");
+						default: return error("usage: /a2a outbound list|create|remove|enable|disable|refresh ...");
+					}
+				}
+				case "tasks": return success(JSON.stringify(impl.listTasks(), null, 2));
+				case "task": {
+					const [action, id] = rest;
+					if (action === "get" && id) return success(JSON.stringify(impl.getTask(id), null, 2));
+					if (action === "cancel" && id) return outcome(await impl.cancelTask(id));
+					return error("usage: /a2a task get|cancel <taskId>");
+				}
+				case "peers": return success(JSON.stringify(impl.inbounds(), null, 2));
+				case "help": return success("a2a: status | presets | inbound list/create/remove/enable/disable | outbound list/create/remove/enable/disable/refresh | tasks | task get/cancel <id> | peers | help");
+				default: return error(`unknown a2a verb "${verb}" (try /a2a help)`);
+			}
+		}
+	};
+}
+function success(text) {
+	return {
+		kind: "success",
+		text
+	};
+}
+function error(text) {
+	return {
+		kind: "error",
+		text
+	};
+}
+function outcome(result) {
+	return result.ok ? success(result.message) : error(result.message);
+}
+//#endregion
+//#region lib/types/server/card.js
+/**
+* AgentCard assembly for the inbound half: identity and skill DECLARATION at
+* the instance level. The skill list is exactly the creator-declared
+* `AgentSkill[]` stored on the inbound server instance — no derivation from
+* the live tool registry (the v0.2 white-list mechanism is removed). The
+* advertised card is a pure function of the instance record plus its base URL
+* and endpoint path.
+* @module dsh-a2a/server/card
+*/
+/** Assemble the AgentCard advertised by this DSH. */
+function buildCard(options) {
+	const iface = {
+		url: `${options.baseUrl.replace(/\/$/, "")}${options.endpointPath}`,
+		protocolBinding: "JSONRPC",
+		protocolVersion: "1.0"
+	};
+	return {
+		name: options.name,
+		description: options.description,
+		version: options.version,
+		provider: {
+			url: "https://deepseek.com",
+			organization: "DeepSeek"
 		},
-		disposeAll: () => pool.disposeAll()
+		capabilities: {
+			streaming: true,
+			pushNotifications: false,
+			extendedAgentCard: true,
+			stateTransitionHistory: false
+		},
+		defaultInputModes: ["text/plain"],
+		defaultOutputModes: ["text/plain"],
+		skills: options.skills,
+		supportedInterfaces: [iface],
+		...options.authToken !== void 0 ? {
+			securitySchemes: { bearer: { httpAuthSecurityScheme: {
+				scheme: "bearer",
+				description: "Shared bearer token"
+			} } },
+			securityRequirements: [{ schemes: { bearer: { list: ["bearer"] } } }]
+		} : {}
 	};
 }
 //#endregion
@@ -621,6 +802,14 @@ var A2AServer = class {
 		this.opts = opts;
 		this.card = opts.card;
 	}
+	/** Swap the served AgentCard (runtime identity edits). Routes re-read `server.card` on every request. */
+	setCard(next) {
+		this.card = next;
+	}
+	/** The AgentCard route path for this instance. */
+	cardPath() {
+		return this.opts.cardPath ?? "/.well-known/agent-card.json";
+	}
 	/**
 	* Abort a running task by control path (facade /a2a task cancel): abort the
 	* executor's signal, settle the task CANCELED, and wake stream waiters.
@@ -648,7 +837,7 @@ var A2AServer = class {
 	/** Route one inbound HTTP request (GET card, POST JSON-RPC). */
 	async handle(req, body) {
 		const path = (req.url ?? "").split("?")[0] ?? "";
-		if (req.method === "GET" && path === "/.well-known/agent-card.json") return {
+		if (req.method === "GET" && path === this.cardPath()) return {
 			status: 200,
 			contentType: "application/json",
 			body: JSON.stringify(this.card)
@@ -661,7 +850,7 @@ var A2AServer = class {
 		if (!this.authorized(req)) return {
 			status: 401,
 			contentType: "application/json",
-			body: JSON.stringify(rpcError(null, A2A_ERROR_CODES.UNAUTHORIZED, "Unauthorized")),
+			body: JSON.stringify(rpcError(null, -32040, "Unauthorized")),
 			headers: { "WWW-Authenticate": "Bearer" }
 		};
 		const rpc = parseRpc(body);
@@ -790,7 +979,6 @@ var A2AServer = class {
 				const gateOutcome = await this.opts.gate(gateInputFrom(message, null));
 				if (!gateOutcome.ok) throw rpcFault(A2A_ERROR_CODES.INVALID_PARAMS, gateOutcome.reason);
 				const record = this.ensureTask(message, null);
-				this.noteInbound({ method }, method, [record.taskId], false);
 				await this.runTask(record);
 				return toTask(this.opts.store.get(record.taskId) ?? record);
 			}
@@ -1013,16 +1201,18 @@ function extractTaskIds(result) {
 * `@deepseek-ai/dsh-host-webserver`), with runtime enable/disable.
 * @module dsh-a2a/server/routes
 */
-const CARD_PATH = "/.well-known/agent-card.json";
+const DEFAULT_CARD_PATH = "/.well-known/agent-card.json";
 /** Runtime-registered HTTP routes for one A2A server. */
 var A2aRoutes = class {
 	webServer;
 	server;
+	cardPath;
 	disposers = [];
 	registered = false;
-	constructor(webServer, server) {
+	constructor(webServer, server, cardPath = DEFAULT_CARD_PATH) {
 		this.webServer = webServer;
 		this.server = server;
+		this.cardPath = cardPath;
 	}
 	get active() {
 		return this.registered;
@@ -1032,7 +1222,7 @@ var A2aRoutes = class {
 		if (this.registered) return;
 		this.disposers.push(this.webServer.register({
 			kind: "exact",
-			path: CARD_PATH,
+			path: this.cardPath,
 			handler: (_req, res) => {
 				res.writeHead(200, { "content-type": "application/json" });
 				res.end(JSON.stringify(this.server.card));
@@ -1057,7 +1247,7 @@ var A2aRoutes = class {
 		const path = (req.url ?? "").split("?")[0] ?? "";
 		const streaming = req.method === "POST" && (req.headers.accept ?? "").includes("text/event-stream");
 		if (req.method === "POST" && path === endpointPathOf(this.server)) {
-			const body = await readBody$1(req);
+			const body = await readBody(req);
 			if (streaming) {
 				if (!this.server.authorized(toServerReq(req))) {
 					res.writeHead(401, {
@@ -1093,7 +1283,7 @@ var A2aRoutes = class {
 			res.end(out.body);
 			return;
 		}
-		const out = await this.server.handle(toServerReq(req), path === CARD_PATH ? "" : "");
+		const out = await this.server.handle(toServerReq(req), path === this.cardPath ? "" : "");
 		res.writeHead(out.status, {
 			"content-type": out.contentType,
 			...out.headers ?? {}
@@ -1110,7 +1300,7 @@ function endpointPathOf(server) {
 		return "/a2a";
 	}
 }
-function readBody$1(req) {
+function readBody(req) {
 	return new Promise((resolve, reject) => {
 		const chunks = [];
 		req.on("data", (chunk) => chunks.push(chunk));
@@ -1136,94 +1326,494 @@ function toServerReq(req) {
 	};
 }
 //#endregion
-//#region lib/types/api.js
+//#region lib/types/server/exec/session.js
 /**
-* GUI control API for the A2A settings dashboard: one `GET /a2a/api`
-* snapshot plus `POST /a2a/api` control actions (server toggle, outbound
-* agent management, task view). The browser half talks only to this route;
-* it carries no protocol knowledge. Loopback-only by default so the
-* dashboard cannot be driven from the wire.
+* The `session` executor: one inbound task is one turn on the context's DSH
+* agent session; reply text becomes the task's output part. Works on any
+* composition with an agent loop (the `chat` skill and the default path).
+* @module dsh-a2a/server/exec/session
+*/
+/** Build the session executor over a context session pool. */
+function createSessionExecutor(pool) {
+	return {
+		name: "session",
+		async execute(input) {
+			if (!input.prompt) return { parts: [{ text: "No prompt provided." }] };
+			const reply = await pool.runTurn(input.contextId, input.prompt, input.signal);
+			return { parts: [{ text: (input.signal.aborted && !reply ? "(canceled)" : reply) || "(no reply)" }] };
+		},
+		disposeAll: () => pool.disposeAll()
+	};
+}
+//#endregion
+//#region lib/types/server/exec/subagent.js
+/**
+* The `subagent` executor: one inbound task is delegated to a named one-shot
+* subagent under the context's parent session. The child runs with the
+* composition's own tools and the delegation boundary; its output becomes the
+* task's artifact. The subagent seam must be mounted, else the skill binding
+* fails loudly at resolution time.
+* @module dsh-a2a/server/exec/subagent
+*/
+/** Build a subagent executor delegating inbound tasks to one-shot children. */
+function createSubagentExecutor(opts) {
+	const { pool, subagents, provider } = opts;
+	return {
+		name: "subagent",
+		async execute(input, execCtx) {
+			if (!input.prompt) return { parts: [{ text: "No prompt provided." }] };
+			const { agent } = await pool.agentFor(input.contextId);
+			const text = (await (await subagents.start(provider, {
+				label: `a2a:${input.skill}`,
+				prompt: [{
+					type: "text",
+					text: input.prompt
+				}],
+				parent: agent,
+				signal: input.signal
+			})).result).output.filter((b) => typeof b.text === "string").map((b) => b.text).filter(Boolean).join("\n").trim();
+			execCtx.onEvent({
+				type: "artifact",
+				artifactId: "result",
+				parts: [{ text: text || "(subagent returned no output)" }],
+				name: input.skill,
+				lastChunk: true
+			});
+			return { parts: [{ text: text || "(subagent returned no output)" }] };
+		},
+		disposeAll: () => pool.disposeAll()
+	};
+}
+//#endregion
+//#region lib/types/server/executor.js
+/**
+* Executor abstraction for inbound tasks: an executor turns one task into
+* output parts while reporting status and artifact updates. The registry is
+* INTERNAL (built by the plugin from config) — public registration was cut:
+* there is no external caller yet, so the seam stays an interface with two
+* built-in implementations (session, subagent).
+* @module dsh-a2a/server/executor
+*/
+/**
+* Skill → executor resolution. The subagent executor is absent on
+* compositions without the subagent seam; resolving a skill bound to a
+* missing kind fails loudly with a readable message.
+*/
+var ExecutorSet = class {
+	bySkill;
+	session;
+	subagent;
+	constructor(bySkill, session, subagent) {
+		this.bySkill = bySkill;
+		this.session = session;
+		this.subagent = subagent;
+	}
+	resolve(skill) {
+		if ((this.bySkill[skill] ?? "session") === "session") return this.session;
+		const subagent = this.subagent;
+		if (subagent === void 0) throw new Error(`a2a: skill "${skill}" is bound to the subagent executor but no subagent seam is mounted`);
+		return subagent;
+	}
+	async disposeAll() {
+		await this.session.disposeAll?.();
+		await this.subagent?.disposeAll?.();
+	}
+};
+//#endregion
+//#region lib/types/server/inbound-registry.js
+/**
+* Inbound connection registry: which remote peers are talking to this DSH's
+* A2A server. Fed by the A2A server's `onInbound` hook (every JSON-RPC
+* request / SSE open), surfaced through the dashboard API, and disconnectable
+* (`closePeer` cancels the peer's active tasks and drops the record).
+* @module dsh-a2a/server/inbound-registry
+*/
+function newPeerId() {
+	return `peer-${crypto.randomUUID()}`;
+}
+/** In-memory inbound peer registry. */
+var LiveInboundRegistry = class {
+	peers = /* @__PURE__ */ new Map();
+	findBySource(source) {
+		if (source === null) return void 0;
+		for (const peer of this.peers.values()) if (peer.source === source) return peer;
+	}
+	/** Observe one inbound event: method, source, task ids, streaming flag. */
+	note(input) {
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const source = input.source ?? null;
+		let peer = this.findBySource(source);
+		if (peer === void 0) {
+			peer = {
+				id: newPeerId(),
+				label: source ?? "unknown",
+				source,
+				firstSeen: now,
+				lastSeen: now,
+				taskCount: 0,
+				active: /* @__PURE__ */ new Set(),
+				streamingCount: 0
+			};
+			this.peers.set(peer.id, peer);
+		}
+		peer.lastSeen = now;
+		peer.taskCount += input.taskIds.length;
+		for (const id of input.taskIds) peer.active.add(id);
+		if (input.streaming) peer.streamingCount += 1;
+	}
+	/** A task settled: drop it from every peer's active set. */
+	settle(taskId) {
+		for (const peer of this.peers.values()) if (peer.active.delete(taskId)) peer.lastSeen = (/* @__PURE__ */ new Date()).toISOString();
+	}
+	/** Decrement streaming count when an SSE connection closes. */
+	endStream(source) {
+		const peer = this.findBySource(source ?? null);
+		if (peer !== void 0 && peer.streamingCount > 0) {
+			peer.streamingCount -= 1;
+			peer.lastSeen = (/* @__PURE__ */ new Date()).toISOString();
+		}
+	}
+	list() {
+		return [...this.peers.values()].map((p) => ({
+			id: p.id,
+			label: p.label,
+			source: p.source,
+			firstSeen: p.firstSeen,
+			lastSeen: p.lastSeen,
+			taskCount: p.taskCount,
+			activeTaskIds: [...p.active],
+			streaming: p.streamingCount > 0
+		})).sort((a, b) => a.lastSeen < b.lastSeen ? 1 : -1);
+	}
+	closePeer(peerId) {
+		const peer = this.peers.get(peerId);
+		if (peer === void 0) return {
+			ok: false,
+			message: `inbound peer ${peerId} not found`
+		};
+		this.peers.delete(peerId);
+		return {
+			ok: true,
+			message: `inbound peer ${peer.label} closed`
+		};
+	}
+	activeTasksOf(peerId) {
+		return [...this.peers.get(peerId)?.active ?? []];
+	}
+};
+//#endregion
+//#region lib/types/servers/inbound-manager.js
+/**
+* Inbound server manager: owns every inbound A2A server instance. Each
+* instance binds one agent preset (its session pool is composed from that
+* preset), advertises creator-declared skills, and serves its own endpoint and
+* AgentCard route. Instances are persisted in the `inbound_servers` domain
+* table and assembled on boot; the manager owns route registration and the
+* full lifecycle (add/enable/disable/update/remove) driven from the GUI and
+* facade, and disposes every instance's environment on teardown.
 *
-* The route body is bound to the same `A2AServiceImpl` facade the `/a2a`
-* command surface uses, so GUI actions and commands cannot disagree.
-* @module dsh-a2a/api
+* Skill declaration: the stored `skills` list is exactly what the creator
+* declared. When a creator leaves it empty at creation time, the default skill
+* derives from the bound preset's display name (else the built-in `chat`
+* skill), per the v1.0 design — the v0.2 tool white-list derivation is gone.
+* @module dsh-a2a/servers/inbound-manager
 */
-function readBody(req) {
-	return new Promise((resolve, reject) => {
-		const chunks = [];
-		req.on("data", (chunk) => chunks.push(chunk));
-		req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
-		req.once("error", reject);
-	});
+function refuseExecutor(reason) {
+	return {
+		name: "refuse",
+		async execute() {
+			throw new Error(`a2a: ${reason}; refusing inbound task`);
+		}
+	};
 }
-/** The caller is the local machine (never a remote peer). */
-function isLoopback(req) {
-	const address = req.socket?.remoteAddress;
-	return address === "127.0.0.1" || address === "::1" || address === "::ffff:127.0.0.1";
+/** Default skkill when a creator declares none: the preset display name. */
+function defaultSkillFor(skills, presetName) {
+	if (skills !== void 0 && skills.length > 0) return skills;
+	if (presetName !== void 0 && presetName.length > 0) return [{
+		id: "chat",
+		name: presetName,
+		description: `Compose inbound sessions from the "${presetName}" agent preset.`,
+		tags: ["preset"]
+	}];
+	return [{
+		id: "chat",
+		name: "chat",
+		description: "Conversational assistance over a DSH agent session.",
+		tags: ["chat"]
+	}];
 }
-function json(res, status, value) {
-	res.writeHead(status, {
-		"content-type": "application/json",
-		"cache-control": "no-cache"
+/** Assemble one live instance from a persisted record. */
+function assemble(record, host) {
+	const skills = record.skills;
+	const endpointPath = record.endpointPath;
+	const cardPath = `${endpointPath.replace(/\/$/, "")}/agent-card.json`;
+	const card = buildCard({
+		baseUrl: host.defaultBaseUrl,
+		endpointPath,
+		name: record.name,
+		description: record.description,
+		version: record.version,
+		skills,
+		...record.authTokenEnv !== void 0 && process.env[record.authTokenEnv] !== void 0 ? { authToken: process.env[record.authTokenEnv] } : {}
 	});
-	res.end(JSON.stringify(value));
+	const sessionPool = host.agents ? new ContextSessionPool(host.agents, {
+		cwd: host.sessionCwd,
+		...host.agentPresets !== void 0 ? { agentPresets: host.agentPresets } : {},
+		...record.preset !== void 0 ? { presetId: () => record.preset } : {},
+		resolveAgentOptions: () => host.resolveDefaultModel?.()
+	}) : void 0;
+	const executors = new ExecutorSet({ chat: "session" }, sessionPool ? createSessionExecutor(sessionPool) : refuseExecutor("no agent loop mounted"), sessionPool !== void 0 && host.subagents !== void 0 ? createSubagentExecutor({
+		pool: sessionPool,
+		subagents: host.subagents,
+		provider: host.subagentProvider
+	}) : void 0);
+	const inbound = new LiveInboundRegistry();
+	const skillIds = new Set(skills.map((s) => s.id));
+	const gate = async (input) => {
+		if (!skillIds.has(input.skill)) return {
+			ok: false,
+			reason: `unknown skill "${input.skill}"`
+		};
+		const decision = {
+			contextId: input.contextId,
+			skill: input.skill,
+			parts: input.parts,
+			remotePeerId: input.remotePeerId
+		};
+		const decided = await host.ctx.waterfall("a2a/inbound-task", decision, async (d) => d);
+		host.logger.info(`[a2a:${record.id}] inbound skill=${decided.skill} rejected=${decided.rejected?.reason ?? "no"}`);
+		if (decided.rejected !== void 0) return {
+			ok: false,
+			reason: decided.rejected.reason
+		};
+		return { ok: true };
+	};
+	const server = new A2AServer({
+		card,
+		store: host.tasks,
+		executors,
+		...card.securitySchemes !== void 0 ? { authToken: "configured" } : {},
+		cardPath,
+		gate,
+		onInbound: (facts) => inbound.note({
+			method: facts.method,
+			...facts.source !== void 0 ? { source: facts.source } : {},
+			taskIds: facts.taskIds,
+			streaming: facts.streaming
+		}),
+		onTaskSettled: (taskId) => {
+			host.logger.info(`[a2a:${record.id}] task settled ${taskId}`);
+			inbound.settle(taskId);
+		}
+	});
+	const routes = new A2aRoutes(host.webServer, server, cardPath);
+	return {
+		id: record.id,
+		record,
+		card,
+		server,
+		routes,
+		inbound,
+		executors,
+		endpointPath,
+		cardPath,
+		dispose: () => {
+			routes.dispose();
+			executors.disposeAll().catch(() => {});
+		}
+	};
 }
-/** Handle one dashboard API request against the service facade. */
-async function handleApiRequest(req, res, impl) {
-	if (!isLoopback(req)) {
-		res.writeHead(403, { "content-type": "text/plain" });
-		res.end("forbidden");
-		return;
+/** Persisted-instance store over the inbound_servers table. */
+var DomainInboundStore = class DomainInboundStore {
+	table;
+	static KEY(id) {
+		return `in:${id}`;
 	}
-	if (req.method === "GET") {
-		json(res, 200, snapshotOf(impl));
+	constructor(table) {
+		this.table = table;
+	}
+	list() {
+		const out = [];
+		const entries = this.table.entries;
+		if (entries === void 0) return out;
+		for (const [key, raw] of entries.call(this.table)) {
+			if (!key.startsWith("in:")) continue;
+			const parsed = safeParse$1(raw);
+			if (parsed !== void 0) out.push(parsed);
+		}
+		return out;
+	}
+	get(id) {
+		const raw = this.table.get(DomainInboundStore.KEY(id));
+		return raw === void 0 ? void 0 : safeParse$1(raw);
+	}
+	async save(record) {
+		await this.table.put(DomainInboundStore.KEY(record.id), JSON.stringify(record));
+	}
+	async remove(id) {
+		await this.table.put(DomainInboundStore.KEY(id), "");
+	}
+};
+function safeParse$1(raw) {
+	try {
+		const parsed = JSON.parse(raw);
+		if (typeof parsed.id !== "string" || typeof parsed.name !== "string" || !Array.isArray(parsed.skills)) return void 0;
+		return parsed;
+	} catch {
 		return;
 	}
-	if (req.method === "POST") {
-		let payload;
+}
+/** Manages the live set of inbound server instances. */
+var InboundServerManager = class {
+	host;
+	store;
+	live = /* @__PURE__ */ new Map();
+	constructor(host, store) {
+		this.host = host;
+		this.store = store;
+	}
+	/** Assemble every persisted enabled instance (boot). */
+	boot() {
+		for (const record of this.store.list()) try {
+			const live = assemble(record, this.host);
+			this.live.set(record.id, live);
+			if (record.enabled) live.routes.enable();
+		} catch (err) {
+			this.host.logger.error(`[a2a:${record.id}] failed to assemble: ${String(err.message)}`);
+		}
+	}
+	list() {
+		return [...this.live.values()];
+	}
+	get(id) {
+		return this.live.get(id);
+	}
+	/** Resolve the display name of a preset id (undefined when unnamed/absent). */
+	async presetDisplayName(preset) {
+		if (preset === void 0 || this.host.agentPresets === void 0) return void 0;
 		try {
-			payload = JSON.parse(await readBody(req));
+			const resolved = await this.host.agentPresets.resolve(preset);
+			return resolved.name ?? resolved.id;
 		} catch {
-			json(res, 400, {
-				ok: false,
-				message: "invalid JSON body"
-			});
 			return;
 		}
-		const result = await dispatch(payload, impl);
-		json(res, result.ok ? 200 : 409, result);
-		return;
 	}
-	res.writeHead(405, { "content-type": "text/plain" });
-	res.end("Method Not Allowed");
-}
-function snapshotOf(impl) {
-	return {
-		server: impl.status().server,
-		tasks: impl.listTasks(),
-		agents: impl.agents()
-	};
-}
-async function dispatch(payload, impl) {
-	switch (payload.action) {
-		case "server.enable": return impl.enableServer(true);
-		case "server.disable": return impl.enableServer(false);
-		case "agent.add": return impl.addAgent({
-			name: payload.name,
-			agentCardUrl: payload.agentCardUrl,
-			...payload.bearerTokenEnv ? { bearerTokenEnv: payload.bearerTokenEnv } : {}
-		});
-		case "agent.remove": return impl.removeAgent(payload.id);
-		case "agent.enable": return impl.setAgentEnabled(payload.id, true);
-		case "agent.disable": return impl.setAgentEnabled(payload.id, false);
-		case "agent.refresh": return impl.refreshAgentCard(payload.id);
-		case "task.cancel": return impl.cancelTask(payload.id);
-		default: return {
+	/** Create, persist, and assemble a new inbound instance. */
+	async add(input) {
+		const id = this.newId(input.name);
+		if (this.live.has(id)) return {
+			ok: false,
+			message: `inbound server ${id} already exists`
+		};
+		const presetName = await this.presetDisplayName(input.preset);
+		const record = {
+			id,
+			name: input.name,
+			description: input.description,
+			version: input.version,
+			endpointPath: input.endpointPath ?? `/a2a/${id}`,
+			...input.preset !== void 0 ? { preset: input.preset } : {},
+			...input.authTokenEnv !== void 0 ? { authTokenEnv: input.authTokenEnv } : {},
+			skills: [...defaultSkillFor(input.skills, presetName)],
+			enabled: input.enabled ?? true
+		};
+		try {
+			const live = assemble(record, this.host);
+			await this.store.save(record);
+			this.live.set(id, live);
+			if (record.enabled) live.routes.enable();
+			return {
+				ok: true,
+				message: `inbound server "${record.name}" created`,
+				id
+			};
+		} catch (err) {
+			return {
+				ok: false,
+				message: `failed to create inbound server: ${String(err.message)}`
+			};
+		}
+	}
+	/** Persist, rebuild, and apply a patch onto a live instance. */
+	async update(id, patch) {
+		const live = this.live.get(id);
+		const stored = this.store.get(id);
+		if (live === void 0 || stored === void 0) return {
+			ok: false,
+			message: `inbound server ${id} not found`
+		};
+		const next = {
+			...stored,
+			name: patch.name ?? stored.name,
+			description: patch.description ?? stored.description,
+			version: patch.version ?? stored.version,
+			endpointPath: patch.endpointPath ?? stored.endpointPath,
+			...patch.preset !== void 0 ? { preset: patch.preset } : {},
+			...patch.authTokenEnv !== void 0 ? { authTokenEnv: patch.authTokenEnv } : {},
+			skills: patch.skills ?? stored.skills,
+			enabled: stored.enabled
+		};
+		try {
+			await this.store.save(next);
+			const replaced = assemble(next, this.host);
+			const wasEnabled = live.routes.active;
+			live.dispose();
+			this.live.set(id, replaced);
+			if (wasEnabled || next.enabled) replaced.routes.enable();
+			return {
+				ok: true,
+				message: `inbound server ${id} updated`
+			};
+		} catch (err) {
+			return {
+				ok: false,
+				message: `failed to update inbound server: ${String(err.message)}`
+			};
+		}
+	}
+	/** Enable/disable an instance's routes. */
+	setEnabled(id, enabled) {
+		const live = this.live.get(id);
+		if (live === void 0) return {
 			ok: false,
-			message: `unknown action ${String(payload.action)}`
+			message: `inbound server ${id} not found`
+		};
+		if (enabled) live.routes.enable();
+		else live.routes.disable();
+		const stored = this.store.get(id);
+		if (stored !== void 0) this.store.save({
+			...stored,
+			enabled
+		}).catch(() => {});
+		return {
+			ok: true,
+			message: `inbound server ${id} ${enabled ? "enabled" : "disabled"}`
 		};
 	}
-}
+	/** Remove, dispose, and unpersist an instance. */
+	async remove(id) {
+		const live = this.live.get(id);
+		if (live === void 0) return {
+			ok: false,
+			message: `inbound server ${id} not found`
+		};
+		live.dispose();
+		this.live.delete(id);
+		await this.store.remove(id);
+		return {
+			ok: true,
+			message: `inbound server ${id} removed`
+		};
+	}
+	/** Dispose every instance. */
+	disposeAll() {
+		for (const live of this.live.values()) live.dispose();
+		this.live.clear();
+	}
+	newId(seed) {
+		return `${seed.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "server"}-${this.host.newId()}`;
+	}
+};
 //#endregion
 //#region lib/types/outbound/calls.js
 /**
@@ -1262,11 +1852,11 @@ var A2AClient = class A2AClient {
 			},
 			signal: AbortSignal.timeout(timeoutMs)
 		});
-		if (!response.ok) throw new A2AError(A2A_ERROR_CODES.AGENT_CARD_NOT_FOUND, `agent card fetch failed: HTTP ${response.status}`);
+		if (!response.ok) throw new A2AError(A2A_ERROR_CODES.INVALID_AGENT_RESPONSE, `agent card fetch failed: HTTP ${response.status}`);
 		const card = await response.json();
-		if (typeof card.name !== "string" || typeof card.description !== "string") throw new A2AError(A2A_ERROR_CODES.AGENT_CARD_SIGNATURE_INVALID, `invalid agent card at ${agentCardUrl}`);
-		const endpoint = (card.supportedInterfaces?.find((i) => (i.protocolBinding ?? "JSONRPC") === "JSONRPC") ?? card.supportedInterfaces?.[0])?.url ?? card.url;
-		if (!endpoint) throw new A2AError(A2A_ERROR_CODES.AGENT_CARD_NOT_FOUND, `agent card at ${agentCardUrl} advertises no JSON-RPC interface`);
+		if (typeof card.name !== "string" || !Array.isArray(card.skills)) throw new A2AError(A2A_ERROR_CODES.INVALID_AGENT_RESPONSE, `invalid agent card at ${agentCardUrl}`);
+		const endpoint = (card.supportedInterfaces?.find((i) => (i.protocolBinding ?? "JSONRPC") === "JSONRPC") ?? card.supportedInterfaces?.[0])?.url;
+		if (!endpoint) throw new A2AError(A2A_ERROR_CODES.INVALID_AGENT_RESPONSE, `agent card at ${agentCardUrl} advertises no JSON-RPC interface`);
 		return new A2AClient(card, endpoint, opts);
 	}
 	/** Send a message and wait (or poll) until the task settles. */
@@ -1319,7 +1909,7 @@ var A2AClient = class A2AClient {
 			if (err instanceof Error && err.name === "TimeoutError") throw new A2AError(-32e3, `A2A call ${method} timed out after ${timeoutMs}ms`);
 			throw err;
 		}
-		if (response.status === 401) throw new A2AError(A2A_ERROR_CODES.UNAUTHORIZED, "remote agent rejected credentials (401)");
+		if (response.status === 401) throw new A2AError(-32040, "remote agent rejected credentials (401)");
 		if (!response.ok) throw new A2AError(A2A_ERROR_CODES.INTERNAL_ERROR, `A2A call ${method} failed: HTTP ${response.status}`);
 		const payload = await response.json();
 		if ("error" in payload) {
@@ -1413,27 +2003,6 @@ function textOf(artifacts, state, statusParts) {
 * connection. Loaded at boot, mutations persist through the agent store.
 * @module dsh-a2a/client/registry
 */
-/** Domain-backed agent store: one JSON array under the `agents` table key. */
-var DomainAgentStore = class DomainAgentStore {
-	table;
-	static KEY = "records";
-	constructor(table) {
-		this.table = table;
-	}
-	list() {
-		const raw = this.table.get(DomainAgentStore.KEY);
-		if (raw === void 0) return [];
-		try {
-			const parsed = JSON.parse(raw);
-			return Array.isArray(parsed) ? parsed : [];
-		} catch {
-			return [];
-		}
-	}
-	async save(records) {
-		await this.table.put(DomainAgentStore.KEY, JSON.stringify(records));
-	}
-};
 /** A list of remote agents, each with live tool registrations when enabled. */
 var OutboundAgentRegistry = class {
 	opts;
@@ -1664,150 +2233,265 @@ var OutboundAgentRegistry = class {
 	}
 };
 //#endregion
-//#region lib/types/service.js
+//#region lib/types/servers/outbound-manager.js
 /**
-* The `ctx.a2a` service facade: the thin read/control surface commands and
-* other plugins use. Registered as a Cordis Service so the key disappears
-* with the plugin fiber.
-* @module dsh-a2a/service
+* Outbound server manager: owns every outbound A2A connection instance. Each
+* instance is one connected remote — its own AgentCard URL, auth env, timeout,
+* creator-declared name, and an optional agent-preset binding. Each live
+* instance is one `OutboundAgentRegistry` with an isolated per-instance agent
+* store; enabled instances map their remote skills to `a2a__<name>__<skill>`
+* model tools. The manager owns the full lifecycle (add/enable/disable/remove/
+* refresh) driven from the GUI and facade, persists each instance in the
+* `outbound_servers` domain table, and disposes every connection on teardown.
+*
+* The `preset` field names the agent preset this DSH would compose its local
+* hand-off session with when driving that remote. P0 connects skills to tools
+* and manages the connection; the hand-off session composition behind `preset`
+* is a documented extension point (the outbound tools currently call the
+* remote directly) and the value is persisted metadata surfaced to the GUI.
+* @module dsh-a2a/servers/outbound-manager
 */
-/** The service other plugins read as `ctx.a2a`. */
-var A2AService = class extends Service {
-	impl;
-	constructor(ctx, impl) {
-		super(ctx, "a2a");
-		this.impl = impl;
+/** An `AgentStore` bound to one outbound server instance's agents-table key. */
+var ServerAgentStore = class {
+	table;
+	key;
+	constructor(table, key) {
+		this.table = table;
+		this.key = key;
 	}
-	status() {
-		return this.impl.status();
+	list() {
+		const raw = this.table.get(this.key);
+		if (raw === void 0 || raw === "") return [];
+		try {
+			const parsed = JSON.parse(raw);
+			return Array.isArray(parsed) ? parsed : [];
+		} catch {
+			return [];
+		}
 	}
-	async enableServer(enable) {
-		return this.impl.enableServer(enable);
+	async save(records) {
+		await this.table.put(this.key, JSON.stringify(records));
 	}
-	getTask(taskId) {
-		return this.impl.getTask(taskId);
+};
+/** Persisted-instance store over the outbound_servers table. */
+var DomainOutboundStore = class DomainOutboundStore {
+	table;
+	static KEY(id) {
+		return `out:${id}`;
 	}
-	listTasks() {
-		return this.impl.listTasks();
+	constructor(table) {
+		this.table = table;
 	}
-	async cancelTask(taskId) {
-		return this.impl.cancelTask(taskId);
+	list() {
+		const out = [];
+		const entries = this.table.entries;
+		if (entries === void 0) return out;
+		for (const [key, raw] of entries.call(this.table)) {
+			if (!key.startsWith("out:")) continue;
+			const parsed = safeParse(raw);
+			if (parsed !== void 0) out.push(parsed);
+		}
+		return out;
 	}
-	agents() {
-		return this.impl.agents();
+	get(id) {
+		const raw = this.table.get(DomainOutboundStore.KEY(id));
+		return raw === void 0 ? void 0 : safeParse(raw);
 	}
-	async addAgent(spec) {
-		return this.impl.addAgent(spec);
+	async save(record) {
+		await this.table.put(DomainOutboundStore.KEY(record.id), JSON.stringify(record));
 	}
-	async removeAgent(id) {
-		return this.impl.removeAgent(id);
+	async remove(id) {
+		await this.table.put(DomainOutboundStore.KEY(id), "");
 	}
-	async setAgentEnabled(id, enabled) {
-		return this.impl.setAgentEnabled(id, enabled);
+};
+function safeParse(raw) {
+	try {
+		const parsed = JSON.parse(raw);
+		if (typeof parsed.id !== "string" || typeof parsed.name !== "string" || typeof parsed.agentCardUrl !== "string") return void 0;
+		return parsed;
+	} catch {
+		return;
 	}
-	async refreshAgentCard(id) {
-		return this.impl.refreshAgentCard(id);
+}
+/** Manages the live set of outbound connection instances. */
+var OutboundServerManager = class {
+	host;
+	agentSink;
+	records;
+	newId;
+	registries = /* @__PURE__ */ new Map();
+	constructor(host, agentSink, records, newId) {
+		this.host = host;
+		this.agentSink = agentSink;
+		this.records = records;
+		this.newId = newId;
+	}
+	/** The host default connection timeout (what a minimal record falls back to). */
+	get defaultTimeoutMs() {
+		return this.host.defaultTimeoutMs;
+	}
+	agentKeyFor(id) {
+		return `out:${id}`;
+	}
+	makeRegistry(record) {
+		return new OutboundAgentRegistry({
+			registrar: { register: (def) => this.host.registrar.register(def) },
+			store: new ServerAgentStore(this.agentSink, this.agentKeyFor(record.id)),
+			toolPrefix: "a2a",
+			defaultTimeoutMs: this.host.defaultTimeoutMs,
+			tokenOf: (env) => this.host.tokenOf(env),
+			onError: this.host.onError
+		});
 	}
-};
-//#endregion
-//#region lib/types/commands.js
-/**
-* The `/a2a` command surface: status, server enable/disable, card, agents,
-* and task control — the P0 operations surface (the settings panel is P1).
-* @module dsh-a2a/commands
-*/
-/** Build the `/a2a` command definition over the service facade. */
-function buildA2aCommand(impl) {
-	return {
-		name: "a2a",
-		description: "Manage the A2A plugin: status, server, agents, tasks, card.",
-		handler: async (invocation) => {
-			const [verb, ...rest] = invocation.rawInput.trim().split(/\s+/);
-			switch (verb ?? "") {
-				case "": {
-					const status = impl.status();
-					return success(`A2A status\n${JSON.stringify(status, null, 2)}`);
-				}
-				case "status": return success(JSON.stringify(impl.status(), null, 2));
-				case "enable": return outcome(await impl.enableServer(true));
-				case "disable": return outcome(await impl.enableServer(false));
-				case "card": return success(JSON.stringify(impl.listTasks(), null, 2).slice(0, 4e3));
-				case "agents": return success(JSON.stringify(impl.agents(), null, 2));
-				case "agent": {
-					const [action, ...args] = rest;
-					switch (action ?? "") {
-						case "add": {
-							const url = args[0];
-							if (!url) return error("usage: /a2a agent add <agentCardUrl> [name]");
-							const name = args[1] ?? url;
-							return outcome(await impl.addAgent({
-								name,
-								agentCardUrl: url
-							}));
-						}
-						case "remove": {
-							const id = args[0];
-							if (!id) return error("usage: /a2a agent remove <id>");
-							return outcome(await impl.removeAgent(id));
-						}
-						case "enable": {
-							const id = args[0];
-							if (!id) return error("usage: /a2a agent enable <id>");
-							return outcome(await impl.setAgentEnabled(id, true));
-						}
-						case "disable": {
-							const id = args[0];
-							if (!id) return error("usage: /a2a agent disable <id>");
-							return outcome(await impl.setAgentEnabled(id, false));
-						}
-						case "refresh": {
-							const id = args[0];
-							if (!id) return error("usage: /a2a agent refresh <id>");
-							return outcome(await impl.refreshAgentCard(id));
-						}
-						default: return error("usage: /a2a agent add|remove|enable|disable|refresh ...");
-					}
-				}
-				case "tasks": return success(JSON.stringify(impl.listTasks(), null, 2));
-				case "task": {
-					const [action, id] = rest;
-					if (action === "get" && id) return success(JSON.stringify(impl.getTask(id), null, 2));
-					if (action === "cancel" && id) return outcome(await impl.cancelTask(id));
-					return error("usage: /a2a task get|cancel <taskId>");
-				}
-				case "help": return success("a2a commands: status | enable | disable | card | agents | agent add/remove/enable/disable/refresh | tasks | task get/cancel <id> | help");
-				default: return error(`unknown a2a verb "${verb}" (try /a2a help)`);
-			}
+	/** Record → registry spec for connecting one instance. */
+	toSpec(record) {
+		return {
+			name: record.name,
+			agentCardUrl: record.agentCardUrl,
+			...record.bearerTokenEnv !== void 0 ? { bearerTokenEnv: record.bearerTokenEnv } : {},
+			enabled: record.enabled,
+			timeoutMs: record.timeoutMs ?? this.host.defaultTimeoutMs
+		};
+	}
+	/** Boot every persisted enabled instance as a connected registry. */
+	boot() {
+		for (const record of this.records.list()) try {
+			const registry = this.makeRegistry(record);
+			this.registries.set(record.id, registry);
+			if (record.enabled) registry.loadAll();
+		} catch (err) {
+			this.host.onError(`[a2a:out:${record.id}] failed to boot: ${String(err.message)}`);
 		}
-	};
-}
-function success(text) {
-	return {
-		kind: "success",
-		text
-	};
-}
-function error(text) {
-	return {
-		kind: "error",
-		text
-	};
-}
-function outcome(result) {
-	return result.ok ? success(result.message) : error(result.message);
-}
+	}
+	/** One view per live instance (enriched from its registry / record). */
+	list() {
+		return [...this.registries.keys()].map((id) => this.viewFor(id)).filter((v) => v !== void 0);
+	}
+	get(id) {
+		const registry = this.registries.get(id);
+		return registry === void 0 ? void 0 : {
+			id,
+			registry
+		};
+	}
+	viewFor(id) {
+		const registry = this.registries.get(id);
+		const record = this.records.get(id);
+		if (registry === void 0 || record === void 0) return void 0;
+		const agent = registry.list()[0];
+		return {
+			id,
+			name: record.name,
+			agentCardUrl: record.agentCardUrl,
+			...record.preset !== void 0 ? { preset: record.preset } : {},
+			enabled: agent?.enabled ?? record.enabled,
+			timeoutMs: record.timeoutMs,
+			state: agent?.state ?? "disconnected",
+			skillCount: agent?.skillCount ?? 0,
+			toolCount: agent?.toolCount ?? 0,
+			...agent?.lastError !== void 0 ? { lastError: agent.lastError } : {}
+		};
+	}
+	/** Create, persist, and connect a new outbound instance. */
+	async add(input) {
+		const record = {
+			id: input.id ?? this.newId(),
+			name: input.name,
+			agentCardUrl: input.agentCardUrl,
+			...input.bearerTokenEnv !== void 0 ? { bearerTokenEnv: input.bearerTokenEnv } : {},
+			...input.preset !== void 0 ? { preset: input.preset } : {},
+			enabled: input.enabled ?? true,
+			timeoutMs: input.timeoutMs ?? this.host.defaultTimeoutMs
+		};
+		if (this.registries.has(record.id)) return {
+			ok: false,
+			message: `outbound server ${record.id} already exists`
+		};
+		const registry = this.makeRegistry(record);
+		await this.records.save(record);
+		this.registries.set(record.id, registry);
+		if (record.enabled) {
+			const result = await registry.add(this.toSpec(record));
+			return result.ok ? {
+				...result,
+				id: record.id
+			} : result;
+		}
+		return {
+			ok: true,
+			message: `outbound server "${record.name}" added (disabled)`,
+			id: record.id
+		};
+	}
+	async setEnabled(id, enabled) {
+		const registry = this.registries.get(id);
+		if (registry === void 0) return {
+			ok: false,
+			message: `outbound server ${id} not found`
+		};
+		const view = registry.list()[0];
+		const record = this.records.get(id);
+		if (record !== void 0) await this.records.save({
+			...record,
+			enabled
+		});
+		if (view === void 0) return {
+			ok: true,
+			message: `outbound server ${id} marked ${enabled ? "enabled" : "disabled"}`
+		};
+		return registry.setEnabled(view.id, enabled);
+	}
+	async remove(id) {
+		const registry = this.registries.get(id);
+		if (registry === void 0) return {
+			ok: false,
+			message: `outbound server ${id} not found`
+		};
+		const view = registry.list()[0];
+		if (view !== void 0) await registry.remove(view.id);
+		await registry.disposeAll();
+		this.registries.delete(id);
+		await this.records.remove(id);
+		return {
+			ok: true,
+			message: `outbound server ${id} removed`
+		};
+	}
+	async refresh(id) {
+		const registry = this.registries.get(id);
+		if (registry === void 0) return {
+			ok: false,
+			message: `outbound server ${id} not found`
+		};
+		const view = registry.list()[0];
+		if (view === void 0) return {
+			ok: false,
+			message: `outbound server ${id} has no connected agent`
+		};
+		return registry.refresh(view.id);
+	}
+	async disposeAll() {
+		for (const registry of this.registries.values()) await registry.disposeAll();
+		this.registries.clear();
+	}
+};
 //#endregion
 //#region lib/types/index.js
 /**
 * @hanphone/dsh-a2a — Cordis plugin entry.
 *
-* Mounts the A2A v1.0 dual-end plugin: the inbound server (AgentCard derived
-* from the live tool registry, JSON-RPC + SSE, durable SQLite task store,
-* session/subagent executors, the `a2a/inbound-task` policy gate + audit)
-* and the outbound client (persisted multi-agent registry, skills mapped to
-* model tools, sync calls with per-agent timeout). Optional services are
-* probed rather than injected so a composition lacking one half idles just
-* that half; only the storage domain is required.
+* Mounts the A2A v1.0.1 dual-end plugin as a MULTI-INSTANCE composition: an
+* arbitrary set of inbound A2A servers (each a preset-bound session pool, its
+* own endpoint + AgentCard + creator-declared skills + auth) and an arbitrary
+* set of outbound A2A connections (each a remote URL + preset + timeout).
+* Instances are persisted in the `a2a` domain (`inbound_servers` /
+* `outbound_servers` tables) and created/edited/started/stopped entirely from
+* the GUI — the plugin `Config` is minimal and instance setup is not
+* patch-config driven. The protocol surface is aligned with the official A2A
+* v1.0.1 spec (see docs/design.md).
+*
+* Optional services are probed rather than injected so a composition lacking
+* one half idles just that half; only the storage domain is required.
 *
 * Function-plugin export shape: named `name`/`inject`/`Config`/`apply`, no
 * default export (mixing forms makes the Loader drop the namespace).
@@ -1818,245 +2502,197 @@ const name = "a2a";
 const inject = ["storageDomain"];
 /** Loader-validated config schema (defaults applied by the Loader). */
 const Config = z.object({
-	server: z.object({
-		enabled: z.boolean().default(true),
-		name: z.string().default("My DSH Agent"),
-		description: z.string().default("A DeepSeek Harness agent exposed over A2A v1.0"),
-		version: z.string().default("0.1.0"),
-		baseUrl: z.string(),
-		endpointPath: z.string().default("/a2a"),
-		authTokenEnv: z.string(),
-		skills: z.object({
-			ids: z.array(z.string()).default([]),
-			exclude: z.array(z.string()).default([])
-		}),
-		executors: z.dict(z.union(["session", "subagent"])).default({ chat: "session" }),
-		subagentProvider: z.string().default("in-process")
-	}),
-	client: z.object({
-		agents: z.array(z.object({
-			name: z.string(),
-			agentCardUrl: z.string(),
-			bearerTokenEnv: z.string(),
-			enabled: z.boolean().default(true),
-			timeoutMs: z.number().default(6e4)
-		})).default([]),
-		toolPrefix: z.string().default("a2a")
-	})
+	baseUrl: z.string(),
+	subagentProvider: z.string().default("in-process"),
+	defaultTimeoutMs: z.number().default(6e4)
 });
 function apply(ctx, config) {
 	const logger = ctx.logger("a2a");
-	const serverConfig = { ...config.server };
-	const clientConfig = { ...config.client };
-	const authToken = serverConfig.authTokenEnv !== void 0 ? process.env[serverConfig.authTokenEnv] : void 0;
-	const toolPrefix = clientConfig.toolPrefix;
-	const subagentProvider = serverConfig.subagentProvider;
+	const subagentProvider = config.subagentProvider;
 	const inboundCwd = inboundSessionCwd();
 	ctx.inject(["storageDomain"], (ctx) => {
 		ctx.effect(async () => {
 			const domain = await openDomain(ctx.storageDomain);
 			const store = new DomainTaskStore(domain);
-			const holder = {
+			const webServer = probeService(ctx, "webServer", "register");
+			const tools = probeService(ctx, "tools", "register");
+			const agents = probeService(ctx, "agents", "create");
+			const agentPresets = probeService(ctx, "agentPresets", "list");
+			const subagents = probeService(ctx, "subagents", "start");
+			const commandsRef = probeService(ctx, "commands", "register");
+			const baseUrl = config.baseUrl ?? `http://127.0.0.1:${webServerPort(webServer) ?? process.env["DSH_A2A_PORT"] ?? "3000"}`;
+			const inboundManager = new InboundServerManager({
+				ctx,
+				webServer: webServer ?? { register: noopRegister },
+				tasks: store,
+				logger,
+				...agents !== void 0 ? { agents } : {},
+				...agentPresets !== void 0 ? { agentPresets } : {},
+				...subagents !== void 0 ? { subagents } : {},
+				resolveDefaultModel: () => resolveDefaultModel(ctx),
+				sessionCwd: inboundCwd,
+				defaultBaseUrl: baseUrl,
+				subagentProvider,
+				newId: () => crypto.randomUUID().slice(0, 8)
+			}, new DomainInboundStore(domain.inbound_servers));
+			inboundManager.boot();
+			const outboundManager = new OutboundServerManager({
+				registrar: { register: (def) => tools?.register(def) },
+				tokenOf: (env) => env ? process.env[env] : void 0,
+				onError: (message) => logger.warn(message),
+				defaultTimeoutMs: config.defaultTimeoutMs
+			}, domain.agents, new DomainOutboundStore(domain.outbound_servers), () => `out-${crypto.randomUUID().slice(0, 12)}`);
+			outboundManager.boot();
+			const impl = makeFacade({
 				domain,
 				store,
-				registry: void 0,
-				server: void 0,
-				routes: void 0,
-				card: void 0,
-				executors: void 0,
-				enabled: serverConfig.enabled
-			};
-			const webServer = probeService(ctx, "webServer", "register");
-			if (webServer === void 0) logger.warn("a2a: webServer not mounted; inbound server idle");
-			else try {
-				const skills = deriveSkills(probeService(ctx, "tools", "get") ?? { get: () => void 0 }, {
-					ids: serverConfig.skills.ids,
-					exclude: serverConfig.skills.exclude
-				});
-				const card = buildCard({
-					baseUrl: serverConfig.baseUrl ?? `http://127.0.0.1:${process.env["DSH_A2A_PORT"] ?? "3000"}`,
-					endpointPath: serverConfig.endpointPath ?? "/a2a",
-					name: serverConfig.name ?? "My DSH Agent",
-					description: serverConfig.description ?? "A DeepSeek Harness agent exposed over A2A v1.0",
-					version: serverConfig.version ?? "0.1.0",
-					skills,
-					...authToken ? { authToken } : {}
-				});
-				holder.card = card;
-				const agents = probeService(ctx, "agents", "create");
-				const presets = probeService(ctx, "agentPresets", "resolve");
-				const sessionPool = agents ? new ContextSessionPool(agents, {
-					cwd: inboundCwd,
-					...presets ? { agentPresets: presets } : {},
-					resolveAgentOptions: () => resolveDefaultModel(ctx)
-				}) : void 0;
-				const sessionExecutor = sessionPool ? createSessionExecutor(sessionPool) : refuseExecutor("no agent loop mounted");
-				const subagents = probeService(ctx, "subagents", "start");
-				const subagentExecutor = sessionPool !== void 0 && subagents !== void 0 ? createSubagentExecutor({
-					pool: sessionPool,
-					subagents,
-					provider: subagentProvider
-				}) : void 0;
-				const executors = new ExecutorSet(serverConfig.executors, sessionExecutor, subagentExecutor);
-				holder.executors = executors;
-				const skillIds = new Set(skills.map((s) => s.id));
-				const gate = async (input) => {
-					if (!skillIds.has(input.skill)) return {
-						ok: false,
-						reason: `unknown skill "${input.skill}"`
-					};
-					const decision = {
-						contextId: input.contextId,
-						skill: input.skill,
-						parts: input.parts,
-						remotePeerId: input.remotePeerId
-					};
-					const decided = await ctx.waterfall("a2a/inbound-task", decision, async (d) => d);
-					logger.info(`[a2a] inbound skill=${decided.skill} remote=${decided.remotePeerId} rejected=${decided.rejected?.reason ?? "no"}`);
-					if (decided.rejected !== void 0) return {
-						ok: false,
-						reason: decided.rejected.reason
-					};
-					return { ok: true };
-				};
-				const server = new A2AServer({
-					card,
-					store,
-					executors,
-					...authToken ? { authToken } : {},
-					gate,
-					onTaskSettled: (taskId) => logger.info(`[a2a] task settled ${taskId}`)
-				});
-				holder.server = server;
-				const routes = new A2aRoutes(webServer, server);
-				holder.routes = routes;
-				if (holder.enabled) routes.enable();
-			} catch (err) {
-				logger.error(`a2a: server half failed to build: ${err.message}`);
-			}
-			const toolsService = probeService(ctx, "tools", "get");
-			if (toolsService === void 0) logger.warn("a2a: tools service not mounted; outbound client idle");
-			else {
-				const registry = new OutboundAgentRegistry({
-					registrar: { register: (def) => toolsService.register(def) },
-					store: new DomainAgentStore(domain.agents),
-					toolPrefix,
-					tokenOf: (env) => env ? process.env[env] : void 0,
-					onError: (message) => logger.warn(message)
-				});
-				holder.registry = registry;
-				registry.loadAll();
-				if (clientConfig.agents.length > 0) await registry.seed(clientConfig.agents);
-			}
-			const impl = makeFacade(holder, logger.info.bind(logger));
+				inboundManager,
+				outboundManager,
+				agentPresets,
+				logger: logger.info.bind(logger)
+			});
 			new A2AService(ctx, impl);
-			const commands = probeService(ctx, "commands", "register");
-			if (commands !== void 0) ctx.effect(() => commands.register(buildA2aCommand(impl)), "a2a: command");
-			const dashboardWebServer = probeService(ctx, "webServer", "register");
-			if (dashboardWebServer !== void 0) ctx.effect(() => dashboardWebServer.register({
+			if (commandsRef !== void 0) ctx.effect(() => commandsRef.register(buildA2aCommand(impl)), "a2a: command");
+			if (webServer !== void 0) ctx.effect(() => webServer.register({
 				kind: "prefix",
 				path: "/a2a/api",
 				handler: (req, res) => handleApiRequest(req, res, impl)
 			}), "a2a: dashboard api");
 			else logger.warn("a2a: webServer not mounted; GUI dashboard API idle");
 			return async () => {
-				holder.routes?.dispose();
-				await holder.executors?.disposeAll();
-				await holder.registry?.disposeAll();
+				inboundManager.disposeAll();
+				await outboundManager.disposeAll();
 				await domain.close();
 			};
-		}, "a2a: domain + halves");
+		}, "a2a: multi-instance composition");
 	});
 }
-/** Facade closure over the shared holder (commands and `ctx.a2a` consumers). */
-function makeFacade(holder, log) {
-	const serverEnabled = () => holder.routes?.active ?? false;
+/** Facade closure over the two managers (commands and `ctx.a2a` consumers). */
+function makeFacade(host) {
+	const inboundView = (id) => {
+		const live = host.inboundManager.get(id);
+		if (live === void 0) return void 0;
+		const r = live.record;
+		return {
+			id: r.id,
+			name: r.name,
+			description: r.description,
+			version: r.version,
+			endpointPath: live.endpointPath,
+			...r.preset !== void 0 ? { preset: r.preset } : {},
+			...r.authTokenEnv !== void 0 ? { authTokenEnv: r.authTokenEnv } : {},
+			cardPath: live.cardPath,
+			...live.card.supportedInterfaces?.[0]?.url !== void 0 ? { cardUrl: live.card.supportedInterfaces[0].url } : {},
+			enabled: live.routes.active,
+			skills: r.skills.map((s) => ({
+				id: s.id,
+				name: s.name,
+				...s.description != null ? { description: s.description } : {}
+			}))
+		};
+	};
 	return {
 		status() {
 			return {
-				server: {
-					enabled: serverEnabled(),
-					cardUrl: holder.card?.supportedInterfaces?.[0]?.url,
-					skills: holder.card?.skills?.map((s) => s.id) ?? [],
-					executors: holder.executors ? ["session", ...holder.executors["subagent"] !== void 0 ? ["subagent"] : []] : []
-				},
-				tasks: holder.store.list().length,
-				agents: holder.registry?.list() ?? []
+				inbounds: host.inboundManager.list().map((live) => inboundView(live.id)).filter((v) => v !== void 0),
+				outbounds: host.outboundManager.list(),
+				tasks: host.store.list().length
 			};
 		},
-		async enableServer(enable) {
-			if (holder.routes === void 0) return {
-				ok: false,
-				message: "inbound server is not mounted (no webServer)"
-			};
-			if (enable) holder.routes.enable();
-			else holder.routes.disable();
-			log(`[a2a] server ${enable ? "enabled" : "disabled"}`);
-			return {
-				ok: true,
-				message: `server ${enable ? "enabled" : "disabled"}`
-			};
+		async presets() {
+			if (host.agentPresets === void 0) return [];
+			try {
+				return (await host.agentPresets.list()).map((p) => ({
+					id: p.id,
+					...p.name !== void 0 ? { name: p.name } : {},
+					...p.description !== void 0 ? { description: p.description } : {},
+					...p.isDefault === true ? { isDefault: true } : {}
+				}));
+			} catch {
+				return [];
+			}
 		},
-		getTask(taskId) {
-			return holder.store.get(taskId);
+		listInboundServers() {
+			return host.inboundManager.list().map((live) => inboundView(live.id)).filter((v) => v !== void 0);
 		},
-		listTasks() {
-			return holder.store.list();
+		async createInboundServer(input) {
+			const result = await host.inboundManager.add({
+				name: input.name,
+				description: input.description,
+				version: input.version,
+				...input.endpointPath !== void 0 ? { endpointPath: input.endpointPath } : {},
+				...input.preset !== void 0 ? { preset: input.preset } : {},
+				...input.authTokenEnv !== void 0 ? { authTokenEnv: input.authTokenEnv } : {},
+				...input.skills !== void 0 ? { skills: input.skills } : {},
+				...input.enabled !== void 0 ? { enabled: input.enabled } : {}
+			});
+			host.logger(`[a2a] inbound created: ${result.message}`);
+			return result;
 		},
-		async cancelTask(taskId) {
-			if (holder.store.get(taskId) === void 0) return {
-				ok: false,
-				message: `task ${taskId} not found`
-			};
-			return {
-				ok: true,
-				message: holder.server?.abort?.(taskId) ?? false ? `task ${taskId} canceled` : `task ${taskId} already terminal`
-			};
+		async removeInboundServer(id) {
+			return host.inboundManager.remove(id);
 		},
-		agents() {
-			return holder.registry?.list() ?? [];
+		async setInboundServerEnabled(id, enabled) {
+			return host.inboundManager.setEnabled(id, enabled);
 		},
-		async addAgent(spec) {
-			const registry = holder.registry;
-			if (registry === void 0) return {
-				ok: false,
-				message: "outbound client not mounted (no tools service)"
-			};
-			return await registry.add({
-				...spec,
-				enabled: true,
-				timeoutMs: 6e4
+		async updateInboundServer(id, patch) {
+			return host.inboundManager.update(id, patch);
+		},
+		listOutboundServers() {
+			return [...host.outboundManager.list()];
+		},
+		async createOutboundServer(input) {
+			return host.outboundManager.add({
+				...input.id !== void 0 ? { id: input.id } : {},
+				name: input.name,
+				agentCardUrl: input.agentCardUrl,
+				...input.bearerTokenEnv !== void 0 ? { bearerTokenEnv: input.bearerTokenEnv } : {},
+				...input.preset !== void 0 ? { preset: input.preset } : {},
+				enabled: input.enabled ?? true,
+				timeoutMs: input.timeoutMs ?? host.outboundManager.defaultTimeoutMs
 			});
 		},
-		async removeAgent(id) {
-			return holder.registry?.remove(id) ?? {
-				ok: false,
-				message: "outbound client not mounted"
-			};
+		async removeOutboundServer(id) {
+			return host.outboundManager.remove(id);
 		},
-		async setAgentEnabled(id, enabled) {
-			return holder.registry?.setEnabled(id, enabled) ?? {
-				ok: false,
-				message: "outbound client not mounted"
+		async setOutboundServerEnabled(id, enabled) {
+			return host.outboundManager.setEnabled(id, enabled);
+		},
+		async refreshOutboundServer(id) {
+			return host.outboundManager.refresh(id);
+		},
+		getTask(taskId) {
+			return host.store.get(taskId);
+		},
+		listTasks() {
+			return host.store.list();
+		},
+		async cancelTask(taskId) {
+			const live = host.inboundManager.list().find((l) => l.server.abort(taskId));
+			return {
+				ok: live !== void 0,
+				message: live !== void 0 ? `task ${taskId} canceled` : `task ${taskId} not found or already terminal`
 			};
 		},
-		async refreshAgentCard(id) {
-			return holder.registry?.refresh(id) ?? {
+		inbounds() {
+			return host.inboundManager.list().flatMap((live) => live.inbound.list());
+		},
+		async closeInbound(peerId) {
+			for (const live of host.inboundManager.list()) {
+				const peers = live.inbound.activeTasksOf(peerId);
+				for (const taskId of peers) live.server.abort(taskId);
+				if (live.inbound.closePeer(peerId)) return {
+					ok: true,
+					message: `inbound peer ${peerId} closed`
+				};
+			}
+			return {
 				ok: false,
-				message: "outbound client not mounted"
+				message: `inbound peer ${peerId} not found`
 			};
 		}
 	};
 }
-/** A task that refuses readably on compositions without an agent loop. */
-function refuseExecutor(reason) {
-	return {
-		name: "refuse",
-		async execute() {
-			throw new Error(`a2a: ${reason}; refusing inbound task`);
-		}
-	};
-}
 function resolveDefaultModel(ctx) {
 	return probeService(ctx, "agentDefaultModel", "currentSelection")?.currentSelection();
 }
@@ -2069,5 +2705,15 @@ function inboundSessionCwd() {
 	} catch {}
 	return dir;
 }
+function noopRegister() {
+	return () => {};
+}
+/** The listening port of a mounted webServer (undefined when unavailable). */
+function webServerPort(webServer) {
+	const candidate = webServer;
+	if (candidate === void 0) return void 0;
+	const value = typeof candidate.port === "function" ? candidate.port() : candidate.port;
+	return typeof value === "number" && Number.isFinite(value) ? String(value) : void 0;
+}
 //#endregion
 export { A2AClient, A2AError, A2AServer, A2AService, Config, apply, inject, name };