@chorus-aidlc/chorus 0.16.2 → 0.16.4

package/.next/standalone/public/skill/orchestrate-chorus/SKILL.md

@@ -0,0 +1,128 @@
+---
+name: orchestrate-chorus
+description: Multi-agent orchestration playbook — coordinate OTHER agents and humans across the AI-DLC lifecycle by delegating ideas and tasks, running independent reviewers, and gatekeeping at the Reversed-Conversation gates.
+license: AGPL-3.0
+metadata:
+  author: chorus
+  version: "0.16.4"
+  category: project-management
+  mcp_server: chorus
+---
+
+# Orchestrate Skill
+
+This skill is for an **orchestrator** (typically an Admin-preset agent) that coordinates *other* agents and humans across the AI-DLC lifecycle instead of doing all the work itself. The orchestrator decomposes work, hands each piece to a chosen owner, runs independent reviewers as quality gates, and gatekeeps the human-owned approval/verify gates — but never ships on its own.
+
+It complements the other skills rather than replacing them:
+
+- `yolo-chorus` (`<BASE_URL>/skill/yolo-chorus/SKILL.md`) — **one** agent drives the whole pipeline solo. Orchestration is the opposite: **many** agents, each owning a piece, coordinated by you.
+- `idea-chorus`, `proposal-chorus`, `develop-chorus`, `review-chorus`, `quick-dev-chorus` — a single stage you execute yourself. Orchestration is the layer *above* those: you decide who runs each stage.
+
+---
+
+## When to use this skill
+
+Use it when **more than one agent (or agent + human) will touch the work** and someone has to keep them coherent:
+
+- You own a **theme / epic / container idea** that decomposes into several independent child ideas, and you want to hand each child to a specific worker (the motivating case: a theme owner gives one child to Codex, another to a Claude dev agent, another to a human).
+- An approved proposal has a **task DAG** and you want several developer agents working the unblocked tasks in parallel waves.
+- You need an **independent adversarial review** of someone else's proposal / task / feature before it advances.
+- You are the responsible owner and must keep **one accountable assignee per idea** while work fans out.
+
+Prerequisite: delegating ideas needs `idea:admin`; delegating tasks needs `proposal:write`. Run `chorus_checkin()` first to confirm your permission set.
+
+---
+
+## Delegation primitives
+
+### Assign an idea — `chorus_pm_assign_idea` (`idea:admin`)
+
+Hand a whole idea to a chosen agent or user. Parameters:
+
+| Param | Meaning |
+|-------|---------|
+| `ideaUuid` | The idea to delegate |
+| `assigneeType` | `"agent"` or `"user"` |
+| `assigneeUuid` | The chosen agent/user UUID (resolve names with `chorus_search_mentionables`) |
+| `instanceUuid` | *(optional, agent targets only)* pin the work to one durable AgentInstance — the `(agent, host, cwd)` place — so wakes land where the code lives |
+
+Behavior you must understand:
+
+- **The assignee is woken and advances from the idea's *current* stage** — it does **NOT** re-claim. If the idea is `open` it moves to `elaborating`; any other status is preserved. The assignee picks up wherever the idea already is (elaboration, ready-for-proposal, etc.).
+- **Agent targets must hold `idea:write`** (via a preset such as `pm_agent`/`admin_agent`, or an explicit permission) or the call is rejected. **User targets must be in your company.** `instanceUuid` is rejected for user targets.
+- **Silent takeover.** Reassigning an already-owned idea simply moves ownership to the new assignee — there is one owner at a time, no confirmation prompt. Use this deliberately, not by accident.
+
+### Assign a task — `chorus_pm_assign_task` (`proposal:write`)
+
+Hand a single task to a developer agent. Parameters: `taskUuid`, `agentUuid` (must hold `task:write`), optional `instanceUuid`. The task must be `open` or `assigned`. The assignee is woken to execute it. Use this to distribute the tasks of an approved proposal.
+
+### Derive child ideas and fan them out
+
+The theme-decomposition case, end to end:
+
+1. Read the container/theme idea and its context (`chorus_get_idea`, `chorus_get_documents`, `chorus_get_comments`).
+2. For each independent slice, create a child idea with `chorus_pm_create_idea` (link it back to the parent in the body / via `references[]`).
+3. Assign each child to a distinct owner with `chorus_pm_assign_idea` — e.g. one child to Codex, one to a Claude dev agent, one to a human. Each child now has its **own single owner** and advances independently.
+4. @mention each assignee and the theme owner so the delegation is visible.
+
+---
+
+## Independent review as an adversarial gate
+
+Chorus uses three read-only adversarial reviewers as quality gates. As orchestrator you run them at the three gates and act on the verdict — this is your primary quality lever when you are not writing the code yourself.
+
+| Reviewer skill | Run after | Reviews |
+|----------------|-----------|---------|
+| `proposal-reviewer-chorus` | a proposal is submitted | proposal draft quality (VERDICT on the proposal) |
+| `task-reviewer-chorus` | a task is submitted for verify | one task vs its acceptance criteria (VERDICT on the task) |
+| `code-reviewer-chorus` | the idea's last task is verified | the idea's **aggregate** code change — the final ship gateway (VERDICT on the idea) |
+
+Spawn a read-only sub-agent that loads the matching reviewer skill and the target UUID (pass the `ideaUuid` for code review); if your harness has no sub-agent primitive, run the reviewer's procedure inline yourself. Each posts exactly one `VERDICT: PASS` / `PASS WITH NOTES` / `FAIL` comment. Verdicts are **advisory** — they do not auto-approve, auto-verify, or hard-block; you read the BLOCKERs and decide. A `FAIL` means route the BLOCKERs back for a fix before advancing (for a code-review FAIL, add fix tasks to the *approved* proposal via `quick-dev-chorus` and re-run once they are `done`). The **Independent Review** section of the core `chorus` skill (`<BASE_URL>/skill/chorus/SKILL.md`) is the canonical description of this pattern.
+
+---
+
+## Choosing a collaboration mode
+
+Pick the lightest mode that fits the shape of the work:
+
+| Mode | Use when | How you run it |
+|------|----------|----------------|
+| **Single-owner drives one idea** | The work is one coherent feature | Assign the idea once (`chorus_pm_assign_idea`); that owner runs idea → proposal → tasks; you gatekeep the gates |
+| **Fan-out children to N agents** | A theme decomposes into independent slices | Derive child ideas, assign each to a distinct owner; children run in parallel, each single-owner |
+| **Parallel task waves** | One approved proposal with a task DAG | Assign the currently-unblocked tasks (`chorus_pm_assign_task`) to several dev agents; as tasks reach `done`, assign the next wave |
+| **Review-only** | Work is already produced elsewhere | Spawn the relevant reviewer, read the VERDICT, and gatekeep — no new delegation |
+
+Guidance: start narrow. If a single owner can hold the whole feature in their head, prefer **single-owner** — coordination overhead is not free. Reach for **fan-out** only when slices are genuinely independent (separate scope, separable elaboration). Use **parallel task waves** only after a proposal is approved and its DAG is real; respect dependencies — `to_verify` does **not** unblock downstream, only `done` does.
+
+---
+
+## Single-owner & concurrency discipline
+
+- **One responsible assignee per idea at a time.** This mirrors the daemon's single-owner semantics: the idea is the authoritative pin root, and its owner's proposals/tasks/wakes inherit that identity. Don't leave an idea ambiguously "owned by the team."
+- **Don't race duplicate sessions on the same work.** Two daemon sessions (or two agents) driving the same idea/task will collide on status transitions and produce conflicting wakes. Assign, then let one owner run.
+- **Pin with `instanceUuid` when the work is tied to a place.** If a child idea's code lives on a specific host/cwd, pin the assignment to that AgentInstance so every downstream wake lands there instead of a random daemon.
+
+---
+
+## Reversed-Conversation gates (you never auto-ship)
+
+Chorus is **AI proposes, humans verify**. As orchestrator you enforce that, you do not bypass it:
+
+- **Elaboration gate (gateway resolve/skip).** When a child idea you assigned to another agent has its elaboration answered, you can close the elaboration gate yourself via `chorus_pm_validate_elaboration` (or `chorus_pm_skip_elaboration` for a trivially clear idea) even though you are not the assignee — holding `idea:admin` is enough. This is the MCP parity of the UI Verify-Elaborate: it wakes the **assignee** agent to write the proposal. You gatekeep the gate; the assignee still authors the proposal (Reversed-Conversation preserved).
+- **Proposal gate.** When a delegated owner submits a proposal, STOP. Run the proposal reviewer, then hand the approve/reject decision to the human owner. Do not self-approve just because you *can* (`proposal:admin`).
+- **Verify gate.** When a task reaches `to_verify`, STOP. Run the task reviewer, then let the human verify. Permission to verify is not authorization to rubber-stamp your own coordinated work.
+- **Never merge or push.** The orchestrator drives work up to "PR ready" and hands it back to the human — it does not merge, push, or otherwise ship autonomously.
+
+@mention the owner at each gate so the handoff is explicit and auditable.
+
+---
+
+## Derive a child idea vs add a task vs assign directly
+
+| Do this | When |
+|---------|------|
+| **Derive a new child idea** (`chorus_pm_create_idea` + assign) | The slice is genuinely separate scope that deserves its own elaboration, proposal, and owner — a theme decomposition, or a parallelizable sub-feature. |
+| **Add a task to an approved proposal** (`chorus_create_tasks` with `proposalUuid`) | The work is a discrete unit of the **same** feature that already has a proposal — e.g. code-review fix tasks, or a follow-up step in an existing DAG. |
+| **Assign the existing idea/task directly** (`chorus_pm_assign_idea` / `chorus_pm_assign_task`) | The work is already scoped and just needs a (different) owner or executor — reassignment, taking over a stalled idea, or distributing existing tasks. |
+
+Rule of thumb: **new scope → child idea; same-proposal unit → task; only the owner changes → assign.**

package/.next/standalone/public/skill/proposal-chorus/SKILL.md

@@ -4,7 +4,7 @@ description: Chorus Proposal workflow — create proposals with document and tas
 license: AGPL-3.0
 metadata:
   author: chorus
-  version: "0.16.0"
+  version: "0.16.4"
   category: project-management
   mcp_server: chorus
 ---

package/.next/standalone/public/skill/proposal-reviewer-chorus/SKILL.md

@@ -4,7 +4,7 @@ description: Read-only adversarial Chorus proposal reviewer — audits PRD/task
 license: AGPL-3.0
 metadata:
   author: chorus
-  version: "0.16.2"
+  version: "0.16.4"
   category: project-management
   mcp_server: chorus
 ---

package/.next/standalone/public/skill/quick-dev-chorus/SKILL.md

@@ -4,7 +4,7 @@ description: Quick Task workflow — skip Idea→Proposal, create tasks directly
 license: AGPL-3.0
 metadata:
   author: chorus
-  version: "0.16.0"
+  version: "0.16.4"
   category: project-management
   mcp_server: chorus
 ---

package/.next/standalone/public/skill/review-chorus/SKILL.md

@@ -4,7 +4,7 @@ description: Chorus Review workflow — approve/reject proposals, verify tasks,
 license: AGPL-3.0
 metadata:
   author: chorus
-  version: "0.16.0"
+  version: "0.16.4"
   category: project-management
   mcp_server: chorus
 ---

package/.next/standalone/public/skill/task-reviewer-chorus/SKILL.md

@@ -4,7 +4,7 @@ description: Read-only adversarial Chorus task reviewer — independently verifi
 license: AGPL-3.0
 metadata:
   author: chorus
-  version: "0.16.2"
+  version: "0.16.4"
   category: project-management
   mcp_server: chorus
 ---

package/.next/standalone/public/skill/yolo-chorus/SKILL.md

@@ -4,7 +4,7 @@ description: Full-auto AI-DLC pipeline — drive a single prompt from Idea throu
 license: AGPL-3.0
 metadata:
   author: chorus
-  version: "0.16.0"
+  version: "0.16.4"
   category: project-management
   mcp_server: chorus
 ---

package/.next/standalone/public/test-dsh-credentials.sh

@@ -0,0 +1,55 @@
+#!/usr/bin/env bash
+# Tests for public/dsh-credentials.sh — write/merge/mode/idempotency/validation.
+# Runs the real script against disposable $DSH_HOME dirs. Bash 3.2 compatible.
+set -uo pipefail
+
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SCRIPT="$HERE/dsh-credentials.sh"
+fail=0
+
+ok() { printf 'ok   %s\n' "$1"; }
+no() { printf 'FAIL %s\n' "$1"; fail=1; }
+
+# run the script with a clean env (no ambient CHORUS_*), stdin from /dev/null.
+run() {
+  local home="$1"; shift
+  env -u CHORUS_URL -u CHORUS_API_KEY DSH_HOME="$home" "$@" bash "$SCRIPT" </dev/null >/dev/null 2>&1
+}
+
+# 1. writes both keys, preserves unrelated lines, mode 0600, normalizes URL
+T="$(mktemp -d)"; printf 'DEEPSEEK_API_KEY=sk-keep\nOTHER=1\n' > "$T/.env"
+run "$T" CHORUS_URL="https://c.example/api/mcp/" CHORUS_API_KEY="cho_test123"
+grep -qx 'CHORUS_URL=https://c.example' "$T/.env" && ok "writes+normalizes CHORUS_URL" || no "writes+normalizes CHORUS_URL"
+grep -qx 'CHORUS_API_KEY=cho_test123' "$T/.env" && ok "writes CHORUS_API_KEY" || no "writes CHORUS_API_KEY"
+grep -qx 'DEEPSEEK_API_KEY=sk-keep' "$T/.env" && ok "preserves DEEPSEEK line" || no "preserves DEEPSEEK line"
+grep -qx 'OTHER=1' "$T/.env" && ok "preserves OTHER line" || no "preserves OTHER line"
+[ "$(stat -c '%a' "$T/.env" 2>/dev/null || stat -f '%A' "$T/.env")" = "600" ] && ok "mode 0600" || no "mode 0600"
+
+# 2. idempotent: re-run replaces, no duplicate lines
+run "$T" CHORUS_URL="https://c.example" CHORUS_API_KEY="cho_new"
+[ "$(grep -c '^CHORUS_URL=' "$T/.env")" = "1" ] && ok "no duplicate CHORUS_URL" || no "no duplicate CHORUS_URL"
+[ "$(grep -c '^CHORUS_API_KEY=' "$T/.env")" = "1" ] && ok "no duplicate CHORUS_API_KEY" || no "no duplicate CHORUS_API_KEY"
+grep -qx 'CHORUS_API_KEY=cho_new' "$T/.env" && ok "replaced key value" || no "replaced key value"
+rm -rf "$T"
+
+# 3. drops a prior `export CHORUS_*` form too, keeps others
+T="$(mktemp -d)"; printf 'export CHORUS_URL=https://old\nexport CHORUS_API_KEY=cho_old\nKEEP=2\n' > "$T/.env"
+run "$T" CHORUS_URL="https://c.example" CHORUS_API_KEY="cho_fresh"
+grep -q 'export CHORUS_URL' "$T/.env" && no "drops export CHORUS_URL" || ok "drops export CHORUS_URL"
+grep -q 'export CHORUS_API_KEY' "$T/.env" && no "drops export CHORUS_API_KEY" || ok "drops export CHORUS_API_KEY"
+grep -qx 'KEEP=2' "$T/.env" && ok "KEEP preserved" || no "KEEP preserved"
+rm -rf "$T"
+
+# 4. validation: missing creds (no TTY) / bad URL / bad key all exit non-zero, write nothing
+T="$(mktemp -d)"
+run "$T" && no "missing creds exits non-zero" || ok "missing creds exits non-zero"
+[ ! -f "$T/.env" ] && ok "no .env written on failure" || no "no .env written on failure"
+run "$T" CHORUS_URL="ftp://x" CHORUS_API_KEY="cho_x" && no "bad URL exits non-zero" || ok "bad URL exits non-zero"
+run "$T" CHORUS_URL="https://x" CHORUS_API_KEY="nope" && no "bad key exits non-zero" || ok "bad key exits non-zero"
+rm -rf "$T"
+
+# 5. --help exits 0
+bash "$SCRIPT" --help >/dev/null 2>&1 && ok "--help exits 0" || no "--help exits 0"
+
+if [ "$fail" -eq 0 ]; then printf '\nALL PASS\n'; else printf '\nFAILURES\n'; fi
+exit "$fail"

package/README.ja.md

@@ -38,6 +38,8 @@ Idea ──> Proposal ──> [Document + Task DAG] ──> Execute ──> Veri
 
 ## 最近の更新
 
+**[v0.16.4](https://chorus-ai.dev/blog/chorus-v0.16.4-release/)** — DeepSeek Harness（dsh）が 6 つ目の接続方法に。`@chorus-aidlc/chorus-dsh` バンドルが Chorus のスキル・ペルソナ・MCP 設定を任意の dsh プロファイルに追加します。現時点は対話的な利用のみ、デーモンウェイクは後日対応。
+
 **[v0.16.1](https://chorus-ai.dev/blog/chorus-v0.16.1-release/)** — 1 つの `chorus daemon` が、互いに独立した複数のエージェントを同時に扱えるようになりました。各エージェントは `agents[]` 配列で自分のキー・作業ディレクトリ・バックエンド・権限を持ちます。エージェント同士は @メンションで作業を渡し合え、各ウェイクはそのエージェント自身のプロジェクトディレクトリに届きます。
 
 **[v0.16.0](https://chorus-ai.dev/blog/chorus-v0.16.0-release/)** — エージェントをドキュメントサイト（[doc.chorus-ai.dev](https://doc.chorus-ai.dev)）へ案内する `docs` スキルを追加し、記憶に頼らず現在のドキュメントを読んで回答するようにしました。
@@ -99,7 +101,7 @@ PM エージェントが要件を分析し、PRD と課題 DAG を含む提案
 
 ## AI エージェントを接続する
 
-最も手早い方法は、アプリ内のセットアップウィザードです：**Settings → Setup Guide** を開いてください。ウィザードが API キーを作成し、お使いのクライアント（Claude Code、Codex、Kiro、OpenCode、OpenClaw、Pi、その他 MCP 互換のエージェント）向けの正確なコマンドを表示します。
+最も手早い方法は、アプリ内のセットアップウィザードです：**Settings → Setup Guide** を開いてください。ウィザードが API キーを作成し、お使いのクライアント（Claude Code、Codex、Kiro、dsh、OpenCode、OpenClaw、Pi、その他 MCP 互換のエージェント）向けの正確なコマンドを表示します。
 
 クライアントごとの詳細なガイド → **[エージェントプラットフォーム](https://doc.chorus-ai.dev/ja/reference/agents/)**。
 

package/README.ko.md

@@ -38,6 +38,8 @@ Idea ──> Proposal ──> [Document + Task DAG] ──> Execute ──> Veri
 
 ## 최근 업데이트
 
+**[v0.16.4](https://chorus-ai.dev/blog/chorus-v0.16.4-release/)** — DeepSeek Harness(dsh)가 여섯 번째 연결 방식으로 추가됩니다: `@chorus-aidlc/chorus-dsh` 번들이 Chorus의 스킬·페르소나·MCP 설정을 임의의 dsh 프로파일에 추가합니다. 현재는 대화식 사용만, 데몬 웨이크는 추후 지원.
+
 **[v0.16.1](https://chorus-ai.dev/blog/chorus-v0.16.1-release/)** — 이제 하나의 `chorus daemon`이 서로 독립적인 여러 에이전트를 동시에 서비스합니다. 각 에이전트는 `agents[]` 배열로 자신의 키·작업 디렉터리·백엔드·권한을 가집니다. 에이전트끼리 @멘션으로 작업을 넘길 수 있고, 각 웨이크는 해당 에이전트 자신의 프로젝트 디렉터리에 도착합니다.
 
 **[v0.16.0](https://chorus-ai.dev/blog/chorus-v0.16.0-release/)** — 에이전트를 문서 사이트([doc.chorus-ai.dev](https://doc.chorus-ai.dev))로 안내하는 `docs` 스킬을 추가해, 기억에 의존하지 않고 현재 문서를 읽고 답하도록 했습니다.
@@ -99,7 +101,7 @@ PM 에이전트가 요구사항을 분석해 PRD와 작업 DAG를 생성하며,
 
 ## 에이전트 연결하기
 
-가장 빠른 방법은 앱 내 마법사입니다: **Settings → Setup Guide**를 여세요. 마법사가 API 키를 만들고, 사용하는 클라이언트(Claude Code, Codex, Kiro, OpenCode, OpenClaw, Pi, 또는 그 밖의 MCP 호환 에이전트)에 맞는 정확한 명령을 보여줍니다.
+가장 빠른 방법은 앱 내 마법사입니다: **Settings → Setup Guide**를 여세요. 마법사가 API 키를 만들고, 사용하는 클라이언트(Claude Code, Codex, Kiro, dsh, OpenCode, OpenClaw, Pi, 또는 그 밖의 MCP 호환 에이전트)에 맞는 정확한 명령을 보여줍니다.
 
 클라이언트별 전체 가이드 → **[에이전트 플랫폼](https://doc.chorus-ai.dev/ko/reference/agents/)**.
 

package/README.md

@@ -38,6 +38,8 @@ The labels under each stage are the **permissions** an actor needs there — gra
 
 ## What's New
 
+**[v0.16.4](https://chorus-ai.dev/blog/chorus-v0.16.4-release/)** — DeepSeek Harness (dsh) is the sixth way to connect: the `@chorus-aidlc/chorus-dsh` bundle drops Chorus's skills, persona, and MCP config into any dsh profile. Interactive for now; daemon wake comes later.
+
 **[v0.16.1](https://chorus-ai.dev/blog/chorus-v0.16.1-release/)** — One `chorus daemon` now serves many independent agents at once — each with its own key, working directories, backend, and permissions via an `agents[]` array — and agents can hand work to each other by @-mention, with each wake landing in that agent's own project directory.
 
 **[v0.16.0](https://chorus-ai.dev/blog/chorus-v0.16.0-release/)** — A `docs` skill that points agents at the live docs site ([doc.chorus-ai.dev](https://doc.chorus-ai.dev)), so they answer from the current docs instead of reciting from memory.
@@ -99,7 +101,7 @@ Task cards flow between To Do → In Progress → To Verify as agents work, with
 
 ## Connect an Agent
 
-The fastest path is the in-app wizard: open **Settings → Setup Guide**. It creates the API key and shows the exact commands for your client — Claude Code, Codex, Kiro, OpenCode, OpenClaw, Pi, or any MCP-compatible agent.
+The fastest path is the in-app wizard: open **Settings → Setup Guide**. It creates the API key and shows the exact commands for your client — Claude Code, Codex, Kiro, dsh, OpenCode, OpenClaw, Pi, or any MCP-compatible agent.
 
 Full per-client guides → **[Agent platforms](https://doc.chorus-ai.dev/reference/agents/)**.
 

package/README.zh.md

@@ -29,6 +29,8 @@ Idea ──> Proposal ──> [Document + Task DAG] ──> Execute ──> Veri
 
 ## 最近更新
 
+**[v0.16.4](https://chorus-ai.dev/zh/blog/chorus-v0.16.4-release/)** — DeepSeek Harness（dsh）成为第六种接入方式：`@chorus-aidlc/chorus-dsh` bundle 把 Chorus 的 skill、persona 和 MCP 配置装进任意 dsh profile。目前仅交互式使用，daemon 唤醒稍后支持。
+
 **[v0.16.1](https://chorus-ai.dev/zh/blog/chorus-v0.16.1-release/)** — 一个 `chorus daemon` 现在可以同时服务多个互相独立的 agent，每个都有自己的密钥、工作目录、后端和权限（通过 `agents[]` 配置）；agent 之间还能通过 @ 把活递给对方，每次唤醒都落在该 agent 自己的项目目录里。
 
 **[v0.16.0](https://chorus-ai.dev/zh/blog/chorus-v0.16.0-release/)** — 新增 `docs` skill，引导 Agent 查阅文档站点（[doc.chorus-ai.dev](https://doc.chorus-ai.dev)），基于当前文档作答，而不是凭记忆复述。
@@ -90,7 +92,7 @@ Kanban 看板随 Agent 工作进度自动更新，任务卡片在 To Do → In P
 
 ## 连接 Agent
 
-最快的方式是应用内的 setup 向导：打开 **Settings → Setup Guide**。它会创建 API Key，并给出适配你所用客户端的完整命令，无论是 Claude Code、Codex、Kiro、OpenCode、OpenClaw、Pi，还是任何兼容 MCP 的 agent。
+最快的方式是应用内的 setup 向导：打开 **Settings → Setup Guide**。它会创建 API Key，并给出适配你所用客户端的完整命令，无论是 Claude Code、Codex、Kiro、dsh、OpenCode、OpenClaw、Pi，还是任何兼容 MCP 的 agent。
 
 按客户端分的完整接入指南 → **[Agent 接入平台](https://doc.chorus-ai.dev/zh/reference/agents/)**。
 

package/cli/agent-backend-prompt.mjs

@@ -0,0 +1,93 @@
+// cli/agent-backend-prompt.mjs
+// Single source of truth for the interactive "which agent backend?" menu shared
+// by the daemon credential-capture entry points: `chorus login` (single-agent),
+// `chorus login --add` / `chorus daemon add`, and the `chorus install` "add
+// another agent" loop (see cli/login.mjs, cli/daemon-install-config.mjs).
+//
+// The same AGENT_MENU list also feeds resolveInstallAgent's daemon-level backend
+// prompt in daemon-install-config.mjs, so every surface advertises EXACTLY the
+// same backends and never drifts — re-advertising a backend (e.g. dsh) is a
+// one-line edit here that all prompts pick up.
+//
+// promptAgentBackend deliberately differs from resolveInstallAgent's inline menu
+// in ONE way: an empty / unrecognized answer returns `undefined` ("no explicit
+// choice") rather than DEFAULT_AGENT, so the add/login callers can OMIT the
+// backend field and let resolve-time inheritance apply (the daemon top-level
+// default). resolveInstallAgent must always produce a concrete daemon-level
+// backend, so it keeps its own empty→DEFAULT_AGENT behavior and does NOT use
+// this helper.
+//
+// Lives in its own module to avoid an import cycle: daemon-install-config.mjs
+// already imports appendAgentConfig from login.mjs, so the shared menu cannot
+// live in either of those files.
+
+import { KNOWN_AGENTS } from "./daemon-agent.mjs";
+
+/**
+ * The interactive agent-backend menu. Order mirrors KNOWN_AGENTS with claude-code
+ * first (it is the default). Kept as the single shared list so the numbered
+ * prompt and the accepted values never drift across entry points.
+ *
+ * NOTE: the dsh JSON-RPC daemon backend is temporarily de-advertised (offline).
+ * The code path (probeAgentCli/resolveDshPath, spawner-select, dsh-spawner) is
+ * kept dormant — re-add this menu entry to bring it back online. It remains
+ * reachable by name (e.g. `--agent dsh`, or typing "dsh" at the prompt).
+ */
+export const AGENT_MENU = [
+  { value: "claude-code", label: "Claude Code (default)" },
+  { value: "codex", label: "Codex CLI" },
+  { value: "kiro", label: "Kiro CLI" },
+];
+
+/** A non-empty trimmed string, or undefined. */
+function nonEmpty(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+/**
+ * Prompt the operator to pick an agent backend for the agent being configured,
+ * shared by the add / login / install-add flows.
+ *
+ * Returns the chosen backend value, or `undefined` when the operator makes no
+ * explicit choice — meaning "inherit the daemon default" (the caller then omits
+ * the `agentType` / top-level `agent` field). `undefined` is returned when:
+ *   - `isTTY` is false (non-interactive / piped) — returns immediately, prints
+ *     nothing, never blocks (mirrors resolveInstallAgent / resolveDaemonCwds);
+ *   - the answer is empty (Enter);
+ *   - the answer is an out-of-range number or is otherwise unrecognized.
+ *
+ * Accepts either a menu number (1..AGENT_MENU.length) or a KNOWN_AGENTS value
+ * typed by name (e.g. "codex", or "dsh" even though it is de-advertised).
+ *
+ * @param {{
+ *   ask: (query: string, opts?: object) => Promise<string>,
+ *   log?: (m: string) => void,
+ *   isTTY?: boolean,
+ * }} deps
+ * @returns {Promise<string|undefined>}
+ */
+export async function promptAgentBackend({ ask, log = () => {}, isTTY = false } = {}) {
+  // Non-TTY (piped / scripted) must never block on a menu — return immediately
+  // with no output. The caller falls back to --agent or inherits the default.
+  if (!isTTY || typeof ask !== "function") return undefined;
+
+  log("[Chorus] Which agent backend should this agent use?");
+  for (let i = 0; i < AGENT_MENU.length; i += 1) {
+    log(`[Chorus]   ${i + 1}) ${AGENT_MENU[i].label}`);
+  }
+  const answer = nonEmpty(
+    await ask(`Select [1-${AGENT_MENU.length}] (Enter to inherit the daemon default): `),
+  );
+  if (!answer) return undefined; // Enter → inherit default.
+
+  const n = Number(answer);
+  if (Number.isInteger(n) && n >= 1 && n <= AGENT_MENU.length) {
+    return AGENT_MENU[n - 1].value;
+  }
+  // A backend typed by name (muscle memory). KNOWN_AGENTS includes de-advertised
+  // backends (dsh), so a by-name pick can still reach them.
+  if (KNOWN_AGENTS.includes(answer)) return answer;
+
+  // Out-of-range / garbage → no explicit choice; the caller inherits the default.
+  return undefined;
+}

package/cli/client-args.mjs

@@ -14,10 +14,10 @@
 export const DAEMON_ACTIONS = new Set(["stop", "status", "restart", "logs", "install", "uninstall"]);
 
 /** Known agent backends, kept in sync with the authoritative list in
- * daemon-agent.mjs (`claude-code`, `codex`, `kiro` — all implemented). This copy
+ * daemon-agent.mjs (`claude-code`, `codex`, `kiro`, `dsh` — all implemented). This copy
  * is informational only: parsing here does not validate the value (the resolver
  * in daemon-agent.mjs is the single source of truth for validation). */
-export const KNOWN_AGENTS = new Set(["claude-code", "codex", "kiro"]);
+export const KNOWN_AGENTS = new Set(["claude-code", "codex", "kiro", "dsh"]);
 
 /**
  * Parse the client-subcommand flags out of an arg list. Recognizes the
@@ -126,7 +126,8 @@ OPTIONS
   --agent <type>           Local agent backend to wake         (env: CHORUS_AGENT)
                            (claude-code | codex | kiro; default: claude-code)
                            (Also configurable as "agent":"…" in ~/.chorus/daemon.json;
-                           'chorus daemon install' prompts for it interactively.)
+                           'chorus daemon install' and 'chorus login' (incl. --add)
+                           prompt for it interactively on a TTY.)
   --yolo                   Full autonomy for the woken agent   (env: CHORUS_YOLO=1)
                            (--dangerously-skip-permissions: Bash, file writes, any
                            command). This is the DEFAULT permission mode.
@@ -205,10 +206,15 @@ OPTIONS
   --api-key <cho_...>      Agent API key                       (env: CHORUS_API_KEY)
   --add                    Add this key as an ADDITIONAL agent (multi-agent daemon)
                            instead of overwriting the single credential
+  --agent <type>           Agent backend for THIS agent         (env: CHORUS_AGENT)
+                           (claude-code | codex | kiro). On a TTY, login (and
+                           --add) prompt for it when omitted; Enter inherits the
+                           daemon default (claude-code) and writes no backend.
   -h, --help               Show this help message
 
-  With no flags, login prompts interactively for the URL and a masked API key,
-  validates them against the server, and on success saves the credentials.
+  With no flags, login prompts interactively for the URL, a masked API key, and
+  (on a TTY) the agent backend, validates them against the server, and on success
+  saves the credentials.
 
   With --add, the validated key is appended to the daemon.json 'agents[]' array
   so one daemon can serve several independent agents (see docs/DAEMON.md). The

package/cli/daemon-agent.mjs

@@ -1,6 +1,6 @@
 // cli/daemon-agent.mjs
 // Pure resolution + validation of the daemon's `--agent <type>` selection.
-// `claude-code` (the default), `codex`, and `kiro` are all implemented backends
+// `claude-code` (the default), `codex`, `kiro`, and `dsh` are recognized backends
 // (add-daemon-codex-backend cashed in the reserved `codex` slot;
 // add-daemon-kiro-backend adds `kiro`). Resolving an unknown value is a hard
 // error (no silent fallback).
@@ -16,10 +16,9 @@
 import { readFileSync } from "node:fs";
 import { loginFilePath } from "./credentials.mjs";
 
-/** The agent backends the daemon recognizes. All are implemented (claude-code
- * via ClaudeSpawner, codex via CodexSpawner, kiro via KiroSpawner — see
- * spawner-select.mjs). */
-export const KNOWN_AGENTS = ["claude-code", "codex", "kiro"];
+/** The agent backends the daemon recognizes. Existing spawners cover claude-code,
+ * codex, and kiro; dsh registration is the base contract for its bridge. */
+export const KNOWN_AGENTS = ["claude-code", "codex", "kiro", "dsh"];
 
 /** The default agent backend when neither --agent nor CHORUS_AGENT is set. */
 export const DEFAULT_AGENT = "claude-code";
@@ -35,6 +34,7 @@ export const DEFAULT_AGENT = "claude-code";
 export function backendCli(agentType) {
   if (agentType === "codex") return { name: "codex", envVar: "CHORUS_CODEX_PATH" };
   if (agentType === "kiro") return { name: "kiro-cli", envVar: "CHORUS_KIRO_PATH" };
+  if (agentType === "dsh") return { name: "dsh-jsonrpc-agent", envVar: "CHORUS_DSH_PATH" };
   return { name: "claude", envVar: "CHORUS_CLAUDE_PATH" };
 }
 
@@ -49,6 +49,7 @@ export function backendCli(agentType) {
 export function backendClientType(agentType) {
   if (agentType === "codex") return "codex";
   if (agentType === "kiro") return "kiro";
+  if (agentType === "dsh") return "dsh";
   return "claude_code";
 }
 

package/cli/daemon-banner.mjs

@@ -19,7 +19,7 @@ import { backendCli } from "./daemon-agent.mjs";
  * @property {string} agentUuid        authenticated agent uuid.
  * @property {"yolo"|"chorus"} permissionMode
  * @property {string} credentialSource resolved credential source (flag/env/login-file/…).
- * @property {string} agentType        local agent backend (claude-code | codex) — drives the CLI row label.
+ * @property {string} agentType        local agent backend (claude-code | codex | kiro | dsh) — drives the CLI row label.
  * @property {string|null} cliPath     resolved path of the SELECTED backend's CLI, or null when not found.
  * @property {string} [connection]     connection state line (default "connecting…").
  * @property {string} [configPath]     absolute path to the daemon.json the CLI reads.
@@ -42,8 +42,8 @@ export function bannerRows(info) {
     info.permissionMode === "yolo"
       ? "YOLO ⚠  (full autonomy — Bash/write/any command)"
       : "chorus-only (Chorus MCP tools only)";
-  // The CLI row names the SELECTED backend (claude-code → "claude", codex →
-  // "codex") so a `--agent codex` run never mislabels itself as claude.
+  // The CLI row names the selected backend so non-Claude runs are never
+  // mislabeled and their own executable override is actionable.
   const cli = backendCli(info.agentType);
   const cliValue = info.cliPath
     ? `found: ${info.cliPath}`

package/cli/daemon-config.mjs

@@ -306,7 +306,7 @@ function positiveInt(value) {
  * @typedef {Object} AgentConfig  One fully-resolved agent runtime config.
  * @property {string} url                       Chorus server URL for this agent.
  * @property {string} apiKey                    This agent's `cho_` API key.
- * @property {string} agentType                 Backend: claude-code | codex | kiro.
+ * @property {string} agentType                 Backend: claude-code | codex | kiro | dsh.
  * @property {Array<string|undefined>} cwds     Served paths (`undefined` ⇒ process cwd).
  * @property {"yolo"|"chorus"} permissionMode   Woken-agent permission posture.
  * @property {number} maxConcurrency            This agent's wake-queue cap.

package/cli/daemon-install-config.mjs

@@ -27,9 +27,11 @@ import { updateDaemonConfig, appendAgentConfig, prompt as defaultPrompt } from "
 import { validateAndFetchIdentity } from "./chorus-client.mjs";
 import { normalizeCwd, cleanCwdList } from "./daemon-config.mjs";
 import { KNOWN_AGENTS, DEFAULT_AGENT } from "./daemon-agent.mjs";
+import { AGENT_MENU, promptAgentBackend } from "./agent-backend-prompt.mjs";
 import { agentNotFoundWarningLine } from "./daemon-banner.mjs";
 import { resolveClaudePath } from "./claude-spawner.mjs";
 import { resolveCodexPath } from "./codex-spawner.mjs";
+import { resolveDshPath } from "./dsh-spawner.mjs";
 import { resolveKiroPath } from "./kiro-spawner.mjs";
 import { readFileSync } from "node:fs";
 
@@ -160,12 +162,20 @@ export async function resolveInstallCredentials(flags = {}, env = {}, opts = {})
         );
         continue;
       }
-      const res = appendAgent({ url: u, apiKey: k, agentUuid: id.uuid, agentName: id.name });
+      // Which backend for this agent? Explicit --agent wins; otherwise the menu
+      // (we're already on a TTY here). undefined → omit agentType so the entry
+      // inherits the daemon default at resolve time (never a literal claude-code).
+      let at = nonEmpty(flags.agent);
+      if (!at) at = await promptAgentBackend({ ask, log, isTTY });
+      const agentObj = { url: u, apiKey: k, agentUuid: id.uuid, agentName: id.name };
+      if (at) agentObj.agentType = at;
+      const res = appendAgent(agentObj);
       if (!res.ok) {
         errLog(`[Chorus] agent ${id.name} (${id.uuid}) is already configured — skipping.`);
         continue;
       }
-      log(`[Chorus] added agent ${id.name} (${id.uuid}) — this daemon now serves ${res.agents.length} agents.`);
+      const backendNote = at ? ` (backend: ${at})` : "";
+      log(`[Chorus] added agent ${id.name} (${id.uuid})${backendNote} — this daemon now serves ${res.agents.length} agents.`);
     }
   }
 
@@ -242,7 +252,6 @@ export async function resolveInstallCwds(flags = {}, opts = {}) {
   const first = nonEmpty(await ask(`Working directory [${defaultCwd}] (Enter to accept the default): `));
   collected.push(first ?? defaultCwd);
   // subsequent adds
-  // eslint-disable-next-line no-constant-condition
   while (true) {
     const next = nonEmpty(await ask("Add another working directory (blank to finish): "));
     if (!next) break;
@@ -280,25 +289,23 @@ export async function resolveInstallBrowseRoots(flags = {}, opts = {}) {
   return { browseRoots };
 }
 
-/**
- * The interactive agent-backend menu. Order mirrors KNOWN_AGENTS with claude-code
- * first (it is the default). Kept beside the resolver so the numbered prompt and
- * the accepted values never drift.
- */
-const AGENT_MENU = [
-  { value: "claude-code", label: "Claude Code (default)" },
-  { value: "codex", label: "Codex CLI" },
-  { value: "kiro", label: "Kiro CLI" },
-];
+// The interactive agent-backend menu (`AGENT_MENU`) now lives in
+// ./agent-backend-prompt.mjs as the single source of truth shared with the
+// add/login flows (imported above), so every backend prompt advertises the same
+// list and never drifts. resolveInstallAgent keeps its own inline menu render
+// below (its empty→DEFAULT_AGENT semantics differ from promptAgentBackend's
+// empty→undefined) but reads the same AGENT_MENU rows.
 
 /** Probe the selected backend's CLI on PATH. Returns the resolved path or null.
  * Injectable per backend so the check is testable without a real PATH. */
 function probeAgentCli(agent, probes = {}) {
   const findClaude = probes.resolveClaudePath ?? resolveClaudePath;
   const findCodex = probes.resolveCodexPath ?? resolveCodexPath;
+  const findDsh = probes.resolveDshPath ?? resolveDshPath;
   const findKiro = probes.resolveKiroPath ?? resolveKiroPath;
   if (agent === "codex") return findCodex();
   if (agent === "kiro") return findKiro();
+  if (agent === "dsh") return findDsh();
   return findClaude();
 }
 
@@ -331,7 +338,7 @@ function probeAgentCli(agent, probes = {}) {
  *   loginPath?: string,
  *   writeConfig?: (partial: Record<string, unknown>) => string,
  *   prompt?: typeof defaultPrompt,
- *   probes?: { resolveClaudePath?: Function, resolveCodexPath?: Function, resolveKiroPath?: Function },
+ *   probes?: { resolveClaudePath?: Function, resolveCodexPath?: Function, resolveKiroPath?: Function, resolveDshPath?: Function },
  *   log?: (m: string) => void,
  *   errLog?: (m: string) => void,
  * }} [opts]