commandcode-delegate

Compare original and translation side by side

🇺🇸

Original

English

🇨🇳

Translation

Chinese

Command Code Delegate

Command Code 任务委托

You are the orchestrator. This skill lets you hand a bounded coding task to a separate implementer — the Command Code CLI (

cmd

) — then review what it produced and land it yourself. You write the brief and own the judgment; Command Code does the typing in your working tree; you verify and commit.

Nothing here is specific to one orchestrating agent. The loop needs only the ability to run a shell command and read a file, so it works the same whether you are Claude Code, OpenCode with a selected model, or any comparable agent. (It is designed for and run on Claude Code; treat other orchestrators as designed-for, not yet proven.)

你是任务协调者。此技能允许你将一个边界明确的编码任务交给独立的实现者——Command Code CLI（

cmd

）——然后审核其产出并自行完成落地。你编写任务简报并负责判断；Command Code在你的工作目录中完成代码编写；你进行验证并提交。

此处内容并不针对特定的协调Agent。该循环仅需要能够运行shell命令和读取文件的能力，因此无论你使用Claude Code、选定模型的OpenCode还是任何同类Agent，其工作方式都相同。（它是为Claude Code设计并运行的；其他协调者视为适配设计，但尚未验证。）

When NOT to use this

何时不使用此流程

The task is small enough to just do inline — delegation overhead is not worth it.
The
```
cmd
```
CLI is not installed or not authenticated (run
```
cmd login
```
).
You want to write the code yourself, or you only need a review (Command Code has its own
```
/review
```
).
You are on native Windows without
```
COMMANDCODE_BIN
```
set — see the autonomy and platform notes below.

任务足够小，可以直接内联完成——委托的开销不值得。
```
cmd
```
CLI未安装或未认证（运行
```
cmd login
```
）。
你希望自己编写代码，或仅需要审核（Command Code有自己的
```
/review
```
功能）。
你在原生Windows系统上且未设置
```
COMMANDCODE_BIN
```
——请参阅下文的自主性和平台说明。

Read this before the first dispatch: the autonomy model

首次调度前阅读：自主性模型

Command Code's headless mode has exactly two states, with nothing in between:

Default (
-p
with no
--yolo
): read, grep, and glob work. Every write, edit, and shell call is refused by the CLI's permission layer, and headless mode has no prompt to grant them mid-run. This is the relay's
```
--read-only
```
.
--yolo
(alias
--dangerously-skip-permissions
): every tool is allowed, anywhere the process can reach. There is no filesystem sandbox and no path restriction. This is what an implementation run needs, so the relay passes it by default.

--permission-mode auto-accept

and

--tools-all

do not lift the headless write gate. Direct CLI probes refused write, edit, and shell with both. So an implementation run through Command Code is a full-trust run: scope it with a tight brief and a clean working tree, not with a sandbox. The brief is guidance, and a git worktree isolates a checkout without containing the process. If writes outside the target tree are unacceptable, use an OS-enforced sandbox such as

codex-delegate

or run this one inside a container.

Command Code的无头模式恰好有两种状态，没有中间状态：

默认模式（
-p
且无
--yolo
）：支持读取、grep和glob操作。所有写入、编辑和shell调用都会被CLI的权限层拒绝，且无头模式在运行过程中不会提示授予权限。这相当于中继的
```
--read-only
```
模式。
--yolo
（别名
--dangerously-skip-permissions
）：允许使用所有工具，可访问进程能触及的任何位置。没有文件系统沙箱和路径限制。这是实现运行所需的模式，因此中继默认会传递此参数。

--permission-mode auto-accept

和

--tools-all

不会解除无头模式的写入限制。直接CLI探测显示，这两个参数都会拒绝写入、编辑和shell操作。因此，通过Command Code进行的实现运行是完全信任的运行：需用严格的任务简报和干净的工作目录来限定范围，而非沙箱。任务简报是指导，git工作树可隔离检出内容，但无法限制进程。如果不允许写入目标目录之外的位置，请使用

codex-delegate

等操作系统强制的沙箱，或在容器内运行此流程。

Prerequisites (check once)

先决条件（检查一次）

```
cmd --version
```
succeeds and
```
cmd status
```
reports authenticated. If not, install Command Code and run
```
cmd login
```
.
Confirm which
cmd
is on PATH. The name is generic, so a shell builtin, an alias, or another tool can shadow it —
```
command -v cmd
```
shows the active one. On native Windows
```
cmd
```
is
```
cmd.exe
```
; the relay refuses to guess there and requires
```
COMMANDCODE_BIN
```
to be the real binary's absolute path, not the system command interpreter. The relay records the version it actually ran into
```
result.json
```
, so a wrong binary is visible after the fact.
You are in (or will point
```
--cd
```
at) the target git repository, and its tree is clean before you dispatch — a full-trust run is much easier to review against a clean baseline.

```
cmd --version
```
执行成功，且
```
cmd status
```
显示已认证。如果没有，请安装Command Code并运行
```
cmd login
```
。
确认PATH中的
cmd
是哪一个。该名称是通用名称，因此shell内置命令、别名或其他工具可能会覆盖它——
```
command -v cmd
```
会显示当前生效的命令。在原生Windows系统上，
```
cmd
```
就是
```
cmd.exe
```
；中继不会在此处猜测，要求
```
COMMANDCODE_BIN
```
为真实二进制文件的绝对路径，而非系统命令解释器。中继会将实际运行的版本记录到
```
result.json
```
中，因此事后可以看出是否使用了错误的二进制文件。
你处于（或将
```
--cd
```
指向）目标git仓库，且在调度前其工作目录是干净的——完全信任的运行在干净基线的基础上更容易审核。

The loop

流程循环

Run these five steps per task. Steps 1, 4, and 5 are your judgment; 2 and 3 are mechanical.

每个任务执行以下五个步骤。步骤1、4和5需要你的判断；步骤2和3是机械操作。

1. Write the brief

1. 编写任务简报

Command Code sees only the text you send — no repo memory, no chat history, no shared context (beyond the repo's own

AGENTS.md

, which it reads automatically). Everything the task needs goes in the brief: the goal, the current state, what to change, what to leave untouched, the project's actual gate commands (discover them from the repo's AGENTS.md/CLAUDE.md/Makefile — do not assume), and a report contract. Tell it that it will not commit (you will). Keep one task per brief. Full guidance and a template: references/writing-the-brief.md.

Command Code仅能看到你发送的文本——没有仓库记忆、聊天历史或共享上下文（除了仓库自身的

AGENTS.md

，它会自动读取）。任务所需的所有信息都要包含在任务简报中：目标、当前状态、需要更改的内容、需要保留不变的内容、项目的实际准入命令（从仓库的AGENTS.md/CLAUDE.md/Makefile中查找——不要假设），以及报告约定。告知它不会进行提交（由你完成）。每个任务对应一份简报。完整指南和模板：references/writing-the-brief.md。

2. Dispatch

2. 调度

Send the brief to Command Code with the bundled helper. It wraps

cmd -p

, captures the run, and writes a structured

result.json

— so your only job is "run a command, read a file." (

<skill-dir>

below is this skill's installed directory — the folder containing this

SKILL.md

, i.e. the directory you loaded the skill from. Claude Code prints it as "Base directory for this skill" when the skill loads; on other orchestrators use that same directory — if unsure where it landed, run

find ~ -name relay.mjs -path '*commandcode-delegate*'

and substitute the directory above it.)

bash

node "<skill-dir>/scripts/relay.mjs" --brief brief.txt --cd /path/to/repo

使用捆绑的助手将任务简报发送给Command Code。它会封装

cmd -p

，捕获运行过程，并写入结构化的

result.json

——因此你的工作仅需“运行命令，读取文件”。（以下

<skill-dir>

是此技能的安装目录——包含此

SKILL.md

的文件夹，即你加载技能的目录。当技能加载时，Claude Code会将其打印为“此技能的基础目录”；在其他协调者上使用相同的目录——如果不确定位置，运行

find ~ -name relay.mjs -path '*commandcode-delegate*'

并替换其上方的目录。）

bash

node "<skill-dir>/scripts/relay.mjs" --brief brief.txt --cd /path/to/repo

read-only (review/diagnosis, no edits): add --read-only

只读模式（审核/诊断，不编辑）： add --read-only

continue the exact session: add --session <sessionId> (from result.json; send only the delta brief)

继续精确会话： add --session <sessionId> (from result.json; send only the delta brief)

fallback when no session id is available: add --continue-last

无会话ID时的回退方案： add --continue-last

hard time limit (watchdog): add --timeout 2h (default: off; implementation runs routinely need 1-2h)

硬时间限制（监控）： add --timeout 2h (default: off; implementation runs routinely need 1-2h)

see all options: node .../relay.mjs --help

查看所有选项： node .../relay.mjs --help


The helper defaults to a write-capable (`--yolo`) run, which intentionally edits the target repository.
Its temp directory keeps only relay artifacts out of that repository. The relay **never commits** —
see step 5. Mechanics, flags, and the
`result.json` shape: [references/dispatch-and-poll.md](references/dispatch-and-poll.md).


助手默认启用可写入（`--yolo`）模式，这会有意编辑目标仓库。其临时目录仅将中继工件保留在该仓库之外。中继**永远不会提交**——请参阅步骤5。机制、标志和`result.json`格式：[references/dispatch-and-poll.md](references/dispatch-and-poll.md)。

3. Wait for completion

3. 等待完成

The helper blocks until Command Code finishes, so back it with whatever your orchestrator offers and resume when it returns:

Claude Code: run the Bash call with
```
run_in_background: true
```
; you are notified on completion.
Plain shell / other agents: run it in the foreground for short tasks, or background it and poll the result file —
```
… &
```
in bash/zsh, or your shell's equivalent. The run is done when
```
result.json
```
exists with a
```
status
```
. (A pre-run usage error — bad args or an empty brief — instead exits with code 2 and a stderr message and writes no result file, so check the exit code too. A missing
```
cmd
```
binary exits 127 but does write a
```
result.json
```
with status
```
commandcode_unavailable
```
.)

Do not trust progress trackers over reality: a run is finished when

result.json

is written and the process has exited. Read the working tree, not a status line. The implementer's full report is the

finalMessage

field in

result.json

(also printed in full on stdout between the report markers).

助手会阻塞直到Command Code完成，因此请使用你的协调者提供的任何方式后台运行它，并在返回时恢复：

Claude Code: run the Bash call with
```
run_in_background: true
```
; you are notified on completion.
Plain shell / other agents: run it in the foreground for short tasks, or background it and poll the result file —
```
… &
```
in bash/zsh, or your shell's equivalent. The run is done when
```
result.json
```
exists with a
```
status
```
. (A pre-run usage error — bad args or an empty brief — instead exits with code 2 and a stderr message and writes no result file, so check the exit code too. A missing
```
cmd
```
binary exits 127 but does write a
```
result.json
```
with status
```
commandcode_unavailable
```
.)

Do not trust progress trackers over reality: a run is finished when

result.json

is written and the process has exited. Read the working tree, not a status line. The implementer's full report is the

finalMessage

field in

result.json

(also printed in full on stdout between the report markers).

4. Review — do not trust the self-report

4. 审核——不要信任自我报告

result.json

includes Command Code's own summary and gate claims. Re-verify, don't accept:

Re-run the project's gates yourself (the test/lint/build commands from step 1). Never take "gates passed" on faith.
Read the diff against the brief: did it do what was asked, nothing more (scope creep) and nothing less?
```
touchedFiles
```
in the result is your starting point — and because the run was full-trust, check for edits outside the paths the brief named, not just inside them.
Run the relevant guard skills on the diff if you have them installed (clean-code-guard, test-guard, etc. from
```
guard-skills
```
) — this skill produces the work; those skills judge it.
For schema/migration changes, round-trip them; for removals, grep for dangling references.

Full checklist: references/review-and-land.md.

result.json

includes Command Code's own summary and gate claims. Re-verify, don't accept:

Re-run the project's gates yourself (the test/lint/build commands from step 1). Never take "gates passed" on faith.
Read the diff against the brief: did it do what was asked, nothing more (scope creep) and nothing less?
```
touchedFiles
```
in the result is your starting point — and because the run was full-trust, check for edits outside the paths the brief named, not just inside them.
Run the relevant guard skills on the diff if you have them installed (clean-code-guard, test-guard, etc. from
```
guard-skills
```
) — this skill produces the work; those skills judge it.
For schema/migration changes, round-trip them; for removals, grep for dangling references.

Full checklist: references/review-and-land.md.

5. Land it

5. 落地

The relay never commits, but it cannot stop Command Code under

--yolo

from writing

.git

. The brief forbids implementer commits, and the reviewer compares

HEAD

with the recorded pre-dispatch baseline before landing anything. The orchestrator commits. Only after the gates pass and the diff holds:

Commit the verified work yourself, with a clear message.
If it needs changes, send a delta brief with
```
--session <sessionId>
```
from the prior
```
result.json
```
(use
```
--continue-last
```
only when no session id is available), and review again.

The relay never commits, but it cannot stop Command Code under

--yolo

from writing

.git

. The brief forbids implementer commits, and the reviewer compares

HEAD

with the recorded pre-dispatch baseline before landing anything. The orchestrator commits. Only after the gates pass and the diff holds:

Commit the verified work yourself, with a clear message.
If it needs changes, send a delta brief with
```
--session <sessionId>
```
from the prior
```
result.json
```
(use
```
--continue-last
```
only when no session id is available), and review again.

Read-only second opinions

The relay doubles as a clean way to get an adversarial second opinion: dispatch

--read-only

with a brief that lists the agreed points, then each contested point with both positions, and ask Command Code to defend or concede each — deliverable in its final message, touching no files. The read-only guarantee here is the CLI's own permission layer rather than an OS sandbox, so the relay also checks it after the fact:

readOnlyViolation: false

means the Git-visible detector saw no change (ignored or outside-repository paths are not covered);

true

means it saw one;

null

means git could not tell.

The relay doubles as a clean way to get an adversarial second opinion: dispatch

--read-only

readOnlyViolation: false

means the Git-visible detector saw no change (ignored or outside-repository paths are not covered);

true

means it saw one;

null

means git could not tell.

Authorization model

Delegation is something the human opts into. Once they have ("run this queue", "proceed"), committing verified, gate-passing work is the agreed contract — that is the whole point. Two limits on that mandate: surface, don't absorb (report Command Code's design decisions, defensible-but-unasked turns, and non-blocking nitpicks rather than silently keeping them) and stop for scope changes (if correct completion needs going beyond the brief, ask — don't expand the mandate yourself). The full treatment is in references/review-and-land.md.

References

references/writing-the-brief.md — how to write a brief Command Code can execute blind: structure, XML blocks, the report contract, embedding the real gate commands.
references/dispatch-and-poll.md —
```
relay.mjs
```
flags, the
```
result.json
```
contract, backgrounding per orchestrator, and recovery when a run misbehaves.
references/review-and-land.md — the review checklist, the commit boundary, and the exact-session rework cycle.
references/multi-task-queues.md — running a sequential queue: carrying constraints forward, progress tracking, and the end-of-run coherence check.

references/writing-the-brief.md — how to write a brief Command Code can execute blind: structure, XML blocks, the report contract, embedding the real gate commands.
references/dispatch-and-poll.md —
```
relay.mjs
```
flags, the
```
result.json
```
contract, backgrounding per orchestrator, and recovery when a run misbehaves.
references/review-and-land.md — the review checklist, the commit boundary, and the exact-session rework cycle.
references/multi-task-queues.md — running a sequential queue: carrying constraints forward, progress tracking, and the end-of-run coherence check.