@hanphone/dsh-a2a 0.2.0 → 0.3.0

package/README.md

@@ -1,42 +1,55 @@
 # dsh-a2a
 
-Agent2Agent (A2A) Protocol v1.0 dual-end plugin for [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) — **English** · [中文](README.zh.md)
+Agent2Agent (A2A) Protocol v1.0.1 dual-end plugin for [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) — **English** · [中文](README.zh.md)
 
 `@hanphone/dsh-a2a` is an independent, open-source A2A plugin that turns a
-DeepSeek Harness profile into a first-class agent-to-agent citizen: an inbound
-server with a durable governed task store and a live-derived AgentCard, an
-outbound client whose remote skills appear as model tools, and a GUI
-dashboard that manages both halves without touching any file.
+DeepSeek Harness profile into a multi-faced agent-to-agent citizen: it can
+simultaneously serve **multiple inbound A2A servers**, each bound to its own
+agent preset with its own endpoint, AgentCard, declared skills and auth, and
+connect to **multiple outbound A2A servers**, each with its own preset, whose
+remote skills appear as model tools. Every server instance is created,
+started, stopped, edited and removed entirely from the GUI — no config-file
+editing.
 
 Architecture and design decisions: [docs/architecture.md](docs/architecture.md).
 
 ## Features
 
-- **A2A v1.0 protocol surface** — `SendMessage`, `SendStreamingMessage`,
-  `GetTask`, `ListTasks`, `CancelTask`, `GetExtendedAgentCard`,
-  `SubscribeToTask` over JSON-RPC; SSE streaming with catch-up frames.
-- **Dynamic AgentCard** — skills derived from the live `ctx.tools` registry
-  (explicit id list, loud failure on missing referents) plus a built-in
-  `chat` skill; a fresh install answers end-to-end immediately.
+- **A2A v1.0.1 protocol surface, aligned with the official spec** —
+  `SendMessage`, `SendStreamingMessage`, `GetTask`, `ListTasks`, `CancelTask`,
+  `GetExtendedAgentCard`, `SubscribeToTask` over JSON-RPC; SSE streaming with
+  catch-up frames; official `TASK_STATE_*` / `ROLE_*` enums and AgentCard
+  structure (including `supportedInterfaces`, `capabilities`, full error-code
+  table).
+- **Multiple inbound servers** — one per persona. Each instance gets its own
+  endpoint (`/a2a/<id>`), AgentCard route, authentication env, and skill
+  declarations.
+- **Per-instance agent preset** — every inbound server binds an agent preset
+  (e.g. `ptc`, `standard`, `minimal`, …); inbound tasks execute in sessions
+  composed from that preset through the standard `agentPresets` resolve+mount
+  path.
+- **Creator-declared skill declarations** — the AgentCard's skills are the
+  text the creator entered (id/name/description per skill); when left empty at
+  creation, the default is the bound preset's display name (built-in `chat`
+  otherwise). The v0.2 tool white-list derivation is removed.
+- **Multiple outbound servers** — each connection has its own remote URL,
+  auth env, timeout and optional preset; enabled instances map remote skills
+  to `a2a__<name>__<skill>` model tools.
 - **Durable task store** — tasks live in the `a2a` storage domain (JSON
   backend by default, SQLite per deployment choice); server-generated ids
-  survive restarts.
+  survive restarts, and each task records the inbound server it arrived
+  through.
 - **Executors** — `session` (one DSH session per `contextId`) and `subagent`
   (delegates to `ctx.subagents`, streams tool-call artifacts back).
 - **Governed inbound** — every inbound task passes through the
   `a2a/inbound-task` waterfall so policy plugins can veto or audit.
 - **Inbound connection monitoring** — the dashboard shows which remote peers
-  are talking to this DSH (source, first/last seen, task counts, active
-  streams) and can close a peer.
-- **Runtime service identity** — edit the AgentCard's name/description/version
-  from the dashboard; the card rebuilds immediately and the identity persists
-  across restarts.
-- **First-run onboarding** — a fresh install shows a pre-filled identity form
-  ("service identity") so publishing the service is one click.
-- **Auth by environment variable** — inbound bearer token is referenced by
-  env-var name (`authTokenEnv`), never stored in config as plaintext.
-- **Install-and-use** — both halves are enabled by default after
-  `dsh plugin add`; no manual patch required to start.
+  are talking to each instance and can close a peer.
+- **Auth by environment variable** — each instance's bearer token is
+  referenced by env-var name (`authTokenEnv`), never stored as plaintext.
+- **Minimal plugin config** — instances are created through the GUI and live
+  in the domain; the plugin `Config` only carries host-level defaults
+  (`baseUrl`, `subagentProvider`, `defaultTimeoutMs`).
 
 ## Installation
 
@@ -58,7 +71,7 @@ dsh plugin --profile <name> add @hanphone/dsh-a2a
 cd dsh-a2a
 pnpm build
 npm pack
-dsh plugin --profile <name> add <path-to>/hanphone-dsh-a2a-0.2.0.tgz
+dsh plugin --profile <name> add <path-to>/hanphone-dsh-a2a-<version>.tgz
 ```
 
 ## Quick start
@@ -66,21 +79,21 @@ dsh plugin --profile <name> add <path-to>/hanphone-dsh-a2a-0.2.0.tgz
 1. **Install** — `dsh plugin --profile web add @hanphone/dsh-a2a`.
 2. **Restart the GUI** — the browser half is scanned at host startup, so
    restart once after installing (`pnpm dsh web` or your profile launcher).
-3. **Open Settings → A2A 连接** — the dashboard shows the inbound server
-   status, the service identity (with first-run onboarding pre-filled), the
-   outbound agent list, inbound peer connections, and the task list.
+3. **Open Settings → A2A 连接** — create your first inbound server (pick a
+   preset, declare skills, optionally set an auth env). It is enabled
+   immediately and publishes its own endpoint and AgentCard.
 
-The inbound server listens on the profile's webServer (default
-`http://127.0.0.1:3080`):
+Each inbound server listens on the profile's webServer:
 
 ```sh
-curl http://127.0.0.1:3080/.well-known/agent-card.json
+# the created instance's AgentCard (see the GUI for the exact id)
+curl http://127.0.0.1:3080/a2a/<id>/agent-card.json
 ```
 
-Send a task (the built-in `chat` skill):
+Send a task to an instance (its declared `chat` skill):
 
 ```sh
-curl -X POST http://127.0.0.1:3080/a2a \
+curl -X POST http://127.0.0.1:3080/a2a/<id> \
   -H "content-type: application/json" \
   -d '{"jsonrpc":"2.0","id":"1","method":"SendMessage","params":{"message":{"role":"user","parts":[{"text":"hello"}],"metadata":{"skill":"chat"}}}}'
 ```
@@ -90,59 +103,53 @@ curl -X POST http://127.0.0.1:3080/a2a \
 The browser half registers an **A2A 连接** page under Settings. From it you
 can, without touching any file:
 
-- toggle the inbound server;
-- view and edit the service identity (name/description/version) — the
-  AgentCard rebuilds immediately and the change persists;
-- list, add, enable/disable, refresh, and remove outbound agents;
-- see which inbound peers are connected (source, activity, tasks) and close
-  one;
-- view and cancel inbound tasks.
+- **入站 Servers** — create inbound servers (name/description/version, agent
+  preset picker, auth env, skill-declaration textarea), start/stop, edit, and
+  remove them; each row shows its endpoint, preset, declared skills and live
+  AgentCard URL.
+- **出站 Servers** — add outbound connections (name, remote AgentCard URL,
+  preset picker, bearer env, timeout), start/stop, refresh, and remove them;
+  each row shows connection state and tool registration counts.
+- **任务** — view and cancel inbound tasks (each task carries its source
+  server).
+- **入站连接** — see which remote peers are talking to the instances and
+  close one.
 
 All dashboard traffic goes through the **loopback-only** `/a2a/api` route —
 remote peers can never drive it.
 
 ## Configuration
 
-The dashboard covers day-to-day operations. Values the dashboard does not
-edit (baseUrl, `authTokenEnv`, skills, executors, toolPrefix) are configured
-through the profile's user patch layer (`$DSH_HOME/profiles/<name>/cordis.patch.yml`)
-— the reserve path:
+The GUI covers instance management day-to-day. The plugin `Config` only has
+host-level defaults, set through the profile's user patch layer
+(`$DSH_HOME/profiles/<name>/cordis.patch.yml`) if you want to override them:
 
 ```yaml
 - id: a2a
   config:
-    server:
-      enabled: true
-      name: My DSH Agent
-      description: A DeepSeek Harness agent exposed over A2A v1.0
-      version: 0.1.0
-      baseUrl: http://127.0.0.1:<port>   # omit to derive from the webServer address
-      endpointPath: /a2a
-      authTokenEnv: A2A_INBOUND_TOKEN    # optional; an env var NAME, never the token
-      skills:
-        ids: []                          # explicit tool ids to expose; chat is built-in
-        exclude: []
-      executors:
-        chat: session                    # or subagent (needs the subagent seam)
-      subagentProvider: in-process
-    client:
-      toolPrefix: a2a
-      agents: []                         # or declare agents declaratively
+    baseUrl: http://127.0.0.1:<port>   # omit to derive from the webServer address
+    subagentProvider: in-process
+    defaultTimeoutMs: 60000            # default outbound connection timeout
 ```
 
+Instances are **not** configured via patches — they are created in the GUI and
+persisted in the `a2a` domain (`inbound_servers` / `outbound_servers` tables).
+
 ### Required host services
 
 Base-backed profiles mount them all: `webServer` (`@deepseek-ai/dsh-host-webserver`),
 the storage stack (`@deepseek-ai/dsh-storage` + `@deepseek-ai/dsh-storage-domain`),
-the tools registry (`@deepseek-ai/dsh-tools`), and an agent loop
-(`@deepseek-ai/dsh-agent` + `@deepseek-ai/dsh-agent-loop`; the subagent
-executor additionally needs `@deepseek-ai/dsh-subagent`).
+the tools registry (`@deepseek-ai/dsh-tools`), an agent loop
+(`@deepseek-ai/dsh-agent` + `@deepseek-ai/dsh-agent-loop`), and agent presets
+(`@deepseek-ai/dsh-agent-presets`; the preset pickers and preset-bound session
+composition need it). The subagent executor additionally needs
+`@deepseek-ai/dsh-subagent`.
 
 ### Storage backend
 
-The task store lives in the `a2a` storage domain. The base composition routes
-storage through the `json` backend; to use SQLite, route the domain and add
-the backend in the same patch layer:
+The task and instance stores live in the `a2a` storage domain. The base
+composition routes storage through the `json` backend; to use SQLite, route
+the domain and add the backend in the same patch layer:
 
 ```yaml
 - id: storage-domain
@@ -157,46 +164,31 @@ the backend in the same patch layer:
         path: /absolute/path/to/a2a.sqlite
 ```
 
-### Outbound agents (file-declared, optional — the GUI manages the same list)
-
-```yaml
-- id: a2a
-  config:
-    client:
-      toolPrefix: a2a
-      agents:
-        - name: my-remote-agent
-          agentCardUrl: https://remote.example/.well-known/agent-card.json
-          bearerTokenEnv: A2A_REMOTE_TOKEN   # optional; env var NAME
-          enabled: true
-          timeoutMs: 60000
-```
-
-Each enabled remote agent's skills become model tools named
-`a2a__<name>__<skill>` (normalized, collision-hashed). The registry persists
-across restarts.
-
 ## CLI
 
-A `/a2a` chat command mirrors the dashboard:
+A `/a2a` chat command mirrors the dashboard (a text backup to the GUI):
 
 ```
-a2a status | enable | disable | card | agents |
-    agent add|remove|enable|disable|refresh |
+a2a status | presets | peers |
+    inbound list|create|remove|enable|disable |
+    outbound list|create|remove|enable|disable|refresh |
     tasks | task get|cancel <id> | help
 ```
 
 ## How it works
 
-- **Inbound** — `POST /a2a` (JSON-RPC) and `GET /.well-known/agent-card.json`;
-  the AgentCard derives from the live tool registry and carries the persisted
-  service identity. Tasks flow through `a2a/inbound-task` → executor → task
-  store, with SSE frames streamed to subscribers.
-- **Outbound** — a persisted `agents` table in the `a2a` domain; `A2AClient`
-  discovers an AgentCard, and each skill registers as a tool.
+- **Inbound** — an `InboundServerManager` owns every instance: one preset-bound
+  session pool + `A2AServer` + routes per instance. Each instance persists in
+  the `inbound_servers` table and serves its own endpoint + AgentCard. Tasks
+  flow through `a2a/inbound-task` → executor → task store, with SSE frames
+  streamed to subscribers.
+- **Outbound** — an `OutboundServerManager` owns every connection: one
+  `OutboundAgentRegistry` with an isolated agent store per instance,
+  persisted in the `outbound_servers` table. `A2AClient` discovers an
+  AgentCard, and each skill registers as a tool.
 - **Dashboard** — the browser half (React, `settings.section`) reads/writes
-  the loopback-only `/a2a/api` route; the host half feeds it snapshots of the
-  server, tasks, agents, inbound peers, and the service identity.
+  the loopback-only `/a2a/api` route; the host half feeds it snapshots of
+  inbound/outbound server views and the preset roster (`/a2a/api/presets`).
 
 See [docs/architecture.md](docs/architecture.md) for the full design.
 
@@ -204,13 +196,16 @@ See [docs/architecture.md](docs/architecture.md) for the full design.
 
 ```
 src/
-  api.ts                  # loopback dashboard API (/a2a/api)
+  api.ts                  # loopback dashboard API (/a2a/api, /a2a/api/presets)
   index.ts                # Cordis plugin entry (apply)
-  protocol.ts             # A2A v1.0 protocol constants + types
+  protocol.ts             # A2A v1.0.1 protocol constants + types
   jsonrpc.ts              # JSON-RPC framing
-  server/                 # inbound half: store, card, a2a-server, routes,
-                          #   executors, inbound-registry, identity
-  outbound/               # outbound half: A2AClient, registry, tools
+  servers/                # multi-instance managers
+    inbound-manager.ts    #   inbound server instances (CRUD, routes, lifecycle)
+    outbound-manager.ts   #   outbound connection instances (CRUD, tools)
+  server/                 # single-instance internals: store, card, a2a-server,
+                          #   routes, executors, inbound-registry
+  outbound/               # outbound internals: A2AClient, registry, tools
   client/                 # browser half: settings dashboard (React)
   service.ts              # ctx.a2a service facade
   commands.ts             # /a2a chat command
@@ -218,7 +213,7 @@ tests/
   unit/                   # protocol, framing, card, store, registry, server,
                           #   client, api, inbound-registry, identity
   composition/            # apply() on a real Cordis Context with stub host services
-cordis.patch.yml          # bundle patch (mounts the plugin, enabled by default)
+cordis.patch.yml          # bundle patch (mounts the plugin; instances are GUI-managed)
 ```
 
 ## Development
@@ -237,10 +232,10 @@ pnpm build       # tsc + tsdown → lib/index.js (host) + lib/client.js (browser
 This plugin was inspired by and developed alongside
 [ryubyte/dsh-a2a](https://github.com/ryubyte/dsh-a2a), an earlier A2A plugin
 for DeepSeek Harness. That project's design — dual-end scope, AgentCard
-derivation from the tool registry, and the settings-dashboard pattern — set
-the direction this implementation follows. Our protocol layer, task store,
-and executor seam are independent implementations; the GUI management model
-owes a direct debt to ryubyte's connection dashboard.
+advertisement, and the settings-dashboard pattern — set the direction this
+implementation follows. Our protocol layer, task store, and executor seam are
+independent implementations; the GUI management model owes a direct debt to
+ryubyte's connection dashboard.
 
 ## License
 

package/README.zh.md

@@ -1,23 +1,24 @@
 # dsh-a2a
 
-Agent2Agent（A2A）v1.0 双端插件，用于 [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) — [English](README.md) · **中文**
+Agent2Agent（A2A）v1.0.1 双端插件，用于 [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) — [English](README.md) · **中文**
 
-`@hanphone/dsh-a2a` 是一个独立开源的 A2A 插件，把 DeepSeek Harness profile 变成 A2A 一等公民：带持久化、受治理任务存储与实时派生 AgentCard 的入站服务端；远程技能映射为模型工具的出站客户端；以及无需改任何文件即可管理两端的 GUI 面板。
+`@hanphone/dsh-a2a` 是一个独立开源的 A2A 插件，把 DeepSeek Harness profile 变成多面手 A2A 一等公民：能**同时对外发布多个入站 A2A server**，每个绑定一个自己的 agent preset、拥有独立端点 / AgentCard / 技能宣告 / 鉴权；也能**同时接入多个出站 A2A server**，每个独立 preset，远端技能映射为模型工具。所有 server 实例的创建、启停、编辑、删除全部在 GUI 完成——无需改任何配置文件。
 
 架构与设计决策：[docs/architecture.md](docs/architecture.md)。
 
 ## 功能
 
-- **A2A v1.0 协议面** — JSON-RPC 上的 `SendMessage`、`SendStreamingMessage`、`GetTask`、`ListTasks`、`CancelTask`、`GetExtendedAgentCard`、`SubscribeToTask`；SSE 流式带补发帧。
-- **动态 AgentCard** — 技能从实时 `ctx.tools` 注册表派生（显式 id 清单，缺失引用大声失败），外加内置 `chat` 技能；全新安装即可端到端验证。
-- **持久化任务存储** — 任务存于 `a2a` 存储域（默认 json 后端，可按部署切 SQLite）；服务端生成 id，跨重启存活。
-- **执行器** — `session`（每个 `contextId` 一个 DSH 会话）与 `subagent`（委托 `ctx.subagents`，把工具调用过程流式回传）。
-- **受治理入站** — 每个入站任务都经过 `a2a/inbound-task` waterfall，策略插件可否决或审计。
-- **入站连接监控** — 面板展示谁在调用本 DSH（来源、首/末次、任务数、活跃流），可关闭某个对端。
-- **运行时服务身份** — 在面板中编辑 AgentCard 的 name/description/version；卡片立即重建，身份跨重启持久化。
-- **引导式首次配置** — 全新安装显示预填身份表单（"服务身份"），一步发布服务。
-- **环境变量鉴权** — 入站 Bearer token 只以环境变量名（`authTokenEnv`）引用，不以明文落配置。
-- **装完即用** — `dsh plugin add` 后两端默认启用，无需手动 patch。
+- **A2A v1.0.1 协议面，对齐官方规范** — JSON-RPC 上的 `SendMessage`、`SendStreamingMessage`、`GetTask`、`ListTasks`、`CancelTask`、`GetExtendedAgentCard`、`SubscribeToTask`；SSE 流式带补发帧；官方 `TASK_STATE_*` / `ROLE_*` 枚举与 AgentCard 结构（含 `supportedInterfaces`、`capabilities`、完整错误码表）。
+- **多入站 server** — 每实例一个"人格"：独立端点（`/a2a/<id>`）、AgentCard 路由、鉴权 env、技能宣告。
+- **每实例 agent preset** — 每个入站 server 绑定一个 agent preset（如 `ptc`、`standard`、`minimal`、…）；入站任务在按该 preset 组装的会话中执行（标准 `agentPresets` resolve+mount 路径）。
+- **创建者输入技能宣告** — AgentCard 技能即创建者输入的文字（每个技能 id/name/description）；创建留空时默认取所绑 preset 展示名（否则内置 `chat`）。v0.2 工具白名单派生机制已删除。
+- **多出站 server** — 每个连接独立远端 URL、鉴权 env、超时与可选 preset；启用实例把远端技能映射为 `a2a__<name>__<skill>` 模型工具。
+- **持久化任务存储** — 任务存于 `a2a` 存储域（默认 json 后端，可按部署切 SQLite）；服务端生成 id 跨重启存活，每个任务记录来源入站实例。
+- **执行器** — `session`（每个 `contextId` 一个 DSH 会话）与 `subagent`（委托 `ctx.subagents`，工具调用过程流式回传）。
+- **受治理入站** — 每个入站任务经过 `a2a/inbound-task` waterfall，策略插件可否决或审计。
+- **入站连接监控** — 面板展示每个实例的对端连接，可关闭某个对端。
+- **环境变量鉴权** — 每个实例的 Bearer token 只以环境变量名（`authTokenEnv`）引用，不落明文。
+- **最小插件配置** — 实例经 GUI 创建并存于域中；插件 `Config` 只承载宿主级默认值（`baseUrl`、`subagentProvider`、`defaultTimeoutMs`）。
 
 ## 安装
 
@@ -39,25 +40,26 @@ dsh plugin --profile <name> add @hanphone/dsh-a2a
 cd dsh-a2a
 pnpm build
 npm pack
-dsh plugin --profile <name> add <path-to>/hanphone-dsh-a2a-0.2.0.tgz
+dsh plugin --profile <name> add <path-to>/hanphone-dsh-a2a-<version>.tgz
 ```
 
 ## 快速开始
 
 1. **安装** — `dsh plugin --profile web add @hanphone/dsh-a2a`。
 2. **重启 GUI** — 浏览器端插件表在 host 启动时扫描，装完请重启一次（`pnpm dsh web` 或对应 profile 启动命令）。
-3. **打开 设置 → A2A 连接** — 面板展示入站服务端状态、服务身份（全新安装预填引导表单）、出站 agent 列表、入站对端连接、任务列表。
+3. **打开 设置 → A2A 连接** — 创建第一个入站 server（选 preset、填技能宣告、可选鉴权 env）。创建即时启用并发布自己的端点与 AgentCard。
 
-入站服务端监听在 profile 的 webServer 上（默认 `http://127.0.0.1:3080`）：
+每个入站 server 监听在 profile 的 webServer 上：
 
 ```sh
-curl http://127.0.0.1:3080/.well-known/agent-card.json
+# 所建实例的 AgentCard（确切 id 见 GUI）
+curl http://127.0.0.1:3080/a2a/<id>/agent-card.json
 ```
 
-发一个任务（内置 `chat` 技能）：
+向实例发任务（其宣告的 `chat` 技能）：
 
 ```sh
-curl -X POST http://127.0.0.1:3080/a2a \
+curl -X POST http://127.0.0.1:3080/a2a/<id> \
   -H "content-type: application/json" \
   -d '{"jsonrpc":"2.0","id":"1","method":"SendMessage","params":{"message":{"role":"user","parts":[{"text":"hello"}],"metadata":{"skill":"chat"}}}}'
 ```
@@ -66,47 +68,34 @@ curl -X POST http://127.0.0.1:3080/a2a \
 
 浏览器端在设置中注册 **A2A 连接** 页。无需改文件即可：
 
-- 开关入站服务端；
-- 查看与编辑服务身份（name/description/version）——AgentCard 立即重建，变更持久化；
-- 列出、添加、启用/停用、刷新、删除出站 agent；
-- 查看入站对端连接（来源、活动、任务）并关闭某个对端；
-- 查看与取消入站任务。
+- **入站 Servers** — 创建入站 server（名称/描述/版本、agent preset 选择器、鉴权 env、技能宣告表单），启停、编辑、删除；每行显示端点、preset、宣告技能与实时 AgentCard URL。
+- **出站 Servers** — 添加出站连接（名称、远端 AgentCard URL、preset 选择器、Bearer env、超时），启停、刷新、删除；每行显示连接状态与工具注册数。
+- **任务** — 查看与取消入站任务（每个任务携带来源 server）。
+- **入站连接** — 查看哪些远程对端在调用各实例，可关闭某个对端。
 
-所有面板流量都走 profile webServer 上的**仅回环** `/a2a/api` 路由——远程对端永远无法驱动它。
+所有面板流量走 profile webServer 上的**仅回环** `/a2a/api` 路由——远程对端永远无法驱动它。
 
 ## 配置
 
-面板覆盖日常操作。面板不编辑的项（baseUrl、`authTokenEnv`、skills、executors、toolPrefix）通过 profile 用户 patch 层（`$DSH_HOME/profiles/<name>/cordis.patch.yml`）配置——保留方式：
+GUI 覆盖日常实例管理。插件 `Config` 只有宿主级默认值，如需覆盖可经 profile 用户 patch 层（`$DSH_HOME/profiles/<name>/cordis.patch.yml`）设置：
 
 ```yaml
 - id: a2a
   config:
-    server:
-      enabled: true
-      name: My DSH Agent
-      description: A DeepSeek Harness agent exposed over A2A v1.0
-      version: 0.1.0
-      baseUrl: http://127.0.0.1:<port>   # 省略则从 webServer 地址派生
-      endpointPath: /a2a
-      authTokenEnv: A2A_INBOUND_TOKEN    # 可选；环境变量名，绝不写 token 明文
-      skills:
-        ids: []                          # 暴露的显式工具 id；chat 为内置
-        exclude: []
-      executors:
-        chat: session                    # 或 subagent（需要 subagent 接缝）
-      subagentProvider: in-process
-    client:
-      toolPrefix: a2a
-      agents: []                         # 或声明式列出 agent
+    baseUrl: http://127.0.0.1:<port>   # 省略则从 webServer 地址派生
+    subagentProvider: in-process
+    defaultTimeoutMs: 60000            # 出站连接默认超时
 ```
 
+实例**不**经 patch 配置——它们在 GUI 中创建并持久化于 `a2a` 域（`inbound_servers` / `outbound_servers` 表）。
+
 ### 所需宿主服务
 
-base 类 profile 全部挂载：`webServer`（`@deepseek-ai/dsh-host-webserver`）、存储栈（`@deepseek-ai/dsh-storage` + `@deepseek-ai/dsh-storage-domain`）、工具注册表（`@deepseek-ai/dsh-tools`）、agent 循环（`@deepseek-ai/dsh-agent` + `@deepseek-ai/dsh-agent-loop`；subagent 执行器还需要 `@deepseek-ai/dsh-subagent`）。
+base 类 profile 全部挂载：`webServer`（`@deepseek-ai/dsh-host-webserver`）、存储栈（`@deepseek-ai/dsh-storage` + `@deepseek-ai/dsh-storage-domain`）、工具注册表（`@deepseek-ai/dsh-tools`）、agent 循环（`@deepseek-ai/dsh-agent` + `@deepseek-ai/dsh-agent-loop`）、agent presets（`@deepseek-ai/dsh-agent-presets`；preset 选择器与 preset 化会话组装需要它）。subagent 执行器还需要 `@deepseek-ai/dsh-subagent`。
 
 ### 存储后端
 
-任务存储位于 `a2a` 存储域。base 组合默认走 `json` 后端；要切 SQLite，在同一 patch 层路由域并加后端：
+任务与实例存储位于 `a2a` 存储域。base 组合默认走 `json` 后端；要切 SQLite，在同一 patch 层路由域并加后端：
 
 ```yaml
 - id: storage-domain
@@ -121,38 +110,22 @@ base 类 profile 全部挂载：`webServer`（`@deepseek-ai/dsh-host-webserver`
         path: /absolute/path/to/a2a.sqlite
 ```
 
-### 出站 agent（文件声明，可选——GUI 管理同一列表）
-
-```yaml
-- id: a2a
-  config:
-    client:
-      toolPrefix: a2a
-      agents:
-        - name: my-remote-agent
-          agentCardUrl: https://remote.example/.well-known/agent-card.json
-          bearerTokenEnv: A2A_REMOTE_TOKEN   # 可选；环境变量名
-          enabled: true
-          timeoutMs: 60000
-```
-
-每个启用远程 agent 的技能会注册为 `a2a__<name>__<skill>` 模型工具（规范化、冲突哈希）。注册表跨重启持久化。
-
 ## CLI
 
-`/a2a` 聊天命令与面板对应：
+`/a2a` 聊天命令与面板对应（GUI 的文字备用路线）：
 
 ```
-a2a status | enable | disable | card | agents |
-    agent add|remove|enable|disable|refresh |
+a2a status | presets | peers |
+    inbound list|create|remove|enable|disable |
+    outbound list|create|remove|enable|disable|refresh |
     tasks | task get|cancel <id> | help
 ```
 
 ## 工作原理
 
-- **入站** — `POST /a2a`（JSON-RPC）与 `GET /.well-known/agent-card.json`；AgentCard 从实时工具注册表派生并携带持久化服务身份。任务流经 `a2a/inbound-task` → 执行器 → 任务存储，SSE 帧推送给订阅者。
-- **出站** — `a2a` 域中的持久化 `agents` 表；`A2AClient` 发现 AgentCard，每个技能注册为一个工具。
-- **面板** — 浏览器端（React，`settings.section`）经仅回环 `/a2a/api` 路由读写；host 端喂给它 server/tasks/agents/入站对端/服务身份的快照。
+- **入站** — `InboundServerManager` 拥有每个实例：每实例 = preset 化会话池 + `A2AServer` + 路由。实例持久化于 `inbound_servers` 表，各自服务独立端点与 AgentCard。任务流经 `a2a/inbound-task` → 执行器 → 任务存储，SSE 帧推送给订阅者。
+- **出站** — `OutboundServerManager` 拥有每个连接：每实例一个带独立 agent 存储的 `OutboundAgentRegistry`，实例持久化于 `outbound_servers` 表。`A2AClient` 发现 AgentCard，每个技能注册为一个工具。
+- **面板** — 浏览器端（React，`settings.section`）经仅回环 `/a2a/api` 路由读写；host 端喂给它入站/出站 server 视图与 preset 名单（`/a2a/api/presets`）。
 
 完整设计见 [docs/architecture.md](docs/architecture.md)。
 
@@ -160,13 +133,16 @@ a2a status | enable | disable | card | agents |
 
 ```
 src/
-  api.ts                  # 回环面板 API (/a2a/api)
+  api.ts                  # 回环面板 API (/a2a/api、/a2a/api/presets)
   index.ts                # Cordis 插件入口 (apply)
-  protocol.ts             # A2A v1.0 协议常量与类型
+  protocol.ts             # A2A v1.0.1 协议常量与类型
   jsonrpc.ts              # JSON-RPC 帧
-  server/                 # 入站半区：store、card、a2a-server、routes、
-                          #   executors、inbound-registry、identity
-  outbound/               # 出站半区：A2AClient、registry、tools
+  servers/                # 多实例管理器
+    inbound-manager.ts    #   入站 server 实例（CRUD、路由、生命周期）
+    outbound-manager.ts   #   出站连接实例（CRUD、工具）
+  server/                 # 单实例内部件：store、card、a2a-server、
+                          #   routes、executors、inbound-registry
+  outbound/               # 出站内部件：A2AClient、registry、tools
   client/                 # 浏览器半区：设置面板 (React)
   service.ts              # ctx.a2a 服务 facade
   commands.ts             # /a2a 聊天命令
@@ -174,7 +150,7 @@ tests/
   unit/                   # protocol、framing、card、store、registry、server、
                           #   client、api、inbound-registry、identity
   composition/            # 在真实 Cordis Context 上以 stub 宿主服务跑 apply()
-cordis.patch.yml          # bundle patch（挂载插件，默认启用）
+cordis.patch.yml          # bundle patch（挂载插件；实例由 GUI 管理）
 ```
 
 ## 开发
@@ -189,7 +165,7 @@ pnpm build       # tsc + tsdown → lib/index.js（host）+ lib/client.js（浏
 
 ## 致谢
 
-本项目受 [ryubyte/dsh-a2a](https://github.com/ryubyte/dsh-a2a) 启发并与其并行开发——那是 DeepSeek Harness 上更早的 A2A 插件。其设计——双端范围、从工具注册表派生 AgentCard、设置面板模式——为本文实现指明了方向。我们的协议层、任务存储与执行器接缝均为独立实现；GUI 管理模型则直接承袭了 ryubyte 的连接面板。
+本项目受 [ryubyte/dsh-a2a](https://github.com/ryubyte/dsh-a2a) 启发并与其并行开发——那是 DeepSeek Harness 上更早的 A2A 插件。其设计——双端范围、AgentCard 宣告、设置面板模式——为本文实现指明了方向。我们的协议层、任务存储与执行器接缝均为独立实现；GUI 管理模型则直接承袭了 ryubyte 的连接面板。
 
 ## 许可证
 

package/cordis.patch.yml

@@ -1,11 +1,8 @@
 # @hanphone/dsh-a2a bundle patch: mount the plugin as one row, enabled by
-# default (install-and-use; turn either half off through the GUI dashboard or
-# an overlay patch on this row).
+# default. v1.0 instances are NOT patch-configured — inbound/outbound server
+# instances are created, preset-bound, and enabled/disabled entirely from the
+# GUI (persisted in the a2a domain); this row only mounts the plugin core.
 - insert:
     - id: a2a
       name: '@hanphone/dsh-a2a'
-      config:
-        server:
-          enabled: true
-        client:
-          agents: []
+      config: {}