Copilot Delegate

You are the orchestrator. Delegate a bounded coding task to a separate implementer — the

GitHub Copilot CLI — then review what it produced and land it yourself. You write the brief and own

the judgment; the implementer makes changes in its own session in a clean working tree; you verify

and commit.

The loop needs only a shell command and file access, so any comparable orchestrator can drive it.

When NOT to use this

• The task is small enough to do inline; delegation overhead is not worth it.

• The copilot CLI is not installed or authenticated.

• You need a hard sandbox. Copilot exposes sandbox controls, but they are upstream-experimental

(MXC-based, controlled via the /sandbox command and settings, disabled by default) — this relay

does not configure them. --read-only only disables edit tools (--mode plan); shell commands

still run. If project files must not change at all, dispatch against a clean or isolated worktree.

Prerequisites (check once)

• Install copilot (npm install -g @github/copilot; the CLI requires Node 22+, the relay

itself runs on Node 18+ — the relay probes copilot version).

• Authenticate: run copilot login (interactive web/device flow), or set

COPILOT_GITHUB_TOKEN / GH_TOKEN / GITHUB_TOKEN in the environment.

• Confirm copilot version succeeds.

• Work in, or point --cd at, the target git repository.

Choose the model (optional)

Copilot picks a default model (auto). To choose another, pass --model <name>.

The relay accepts letters, digits, and . _ : / - only (the value reaches a shell on Windows).

Choose the effort (optional)

Copilot supports a reasoning effort dial: --effort <level> with values

low, medium, high, xhigh, or max. The relay rejects any other value

before dispatch.

The loop

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

1. Write a brief

Copilot sees only the text you send. It cannot read your conversation: the brief must stand alone

with the goal, current state, what to change, what to leave untouched, the project's real

gates, and a report contract. Keep each brief to a single task. Write it to a file and pass it as

the relay's --brief. See references/writing-the-brief.md.

2. Dispatch

For Codex orchestration of background work, install and configure the separate

codex-background support utility first. If its MCP tools or registry are missing, stop and

report the setup requirement; do not silently fall back to model-driven polling. Then invoke its

registered delegate_run MCP tool once in place of the shell example below.

Follow that skill for structured common arguments, unchanged provider flags and reattachment by

runId. Keep the request pending until completion, then continue this skill's review and landing

steps. Other orchestrators keep the shell workflow below.

Use the bundled relay. It runs copilot -p with --output-format json --no-color --stream off,

captures the JSONL event stream, and writes result.json.

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

# choose a model:                    add --model <name>

# set reasoning effort:              add --effort <level>

# read-only planning pass:           add --read-only  (forces --mode plan)

# full tool autonomy:                add --allow-all-tools

# hard time limit (watchdog):        add --timeout 2h   (the 30m default suits brief runs)

# resume a session:                  add --session <id>  or  --resume-last

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

The child's cwd pins the workspace. The relay writes artifacts under the system temp dir by

default and never commits. See references/dispatch-and-poll.md.

3. Wait for completion

Codex using codex-background keeps the original MCP request pending: no model-driven sleep,

status or log polling. Use delegate_wait only to reattach after an interrupted request.

The relay blocks until copilot finishes. Run it with the orchestrator's background-command

facility, or background it in the shell and poll for result.json. A pre-run usage error exits 2

and writes no result; a missing copilot exits 127 and writes status: "copilot_unavailable".

Completion means the process exited and result.json exists — trust process state and the

working tree, not the progress display. Copilot's final assistant message is the finalMessage

field of result.json.

4. Review — do not trust the self-report

• Re-run the project's gates yourself.

• Read the diff against the brief, starting with touchedFiles.

• Run relevant guard skills if installed.

See references/review-and-land.md.

5. Land it

If the work is good, commit it. The relay never commits — the diff and result.json are the

record; run git status and git diff first to confirm exactly what changed. If the group has a

PR flow, make the commit and push a branch; let human review happen. If the diff is wrong or

incomplete, re-dispatch a corrected brief in a fresh run and review again.

Autonomy and permissions

Without --allow-all-tools, copilot auto-denies tool calls in headless mode: the process exits 0

but the relay detects the denial events and reports status: "failed" with the CLI's own error

message and a hint to pass --allow-all-tools. This is the honest default — the orchestrator sees

the failure rather than a silent no-op.

--allow-all-tools explicitly grants full tool autonomy. --read-only selects --mode plan,

which disables edit tools so project files can't be changed by direct edits; it works without

--allow-all-tools. Shell commands still run in plan mode, so it guards against edits, not

against everything. The two flags are mutually exclusive.

Copilot also exposes sandbox controls, but they are upstream-experimental (MXC-based, controlled

via the /sandbox command and settings, disabled by default). This relay does not configure them.

Authorization model

Delegation is something the human opts into. Once briefed, copilot works as a tool you approved use

of. The boundary is: do not accept conclusions from the self-report; verify everything on

disk. For anything touching credentials, production data, or irreversible operations, stop and ask

the human first instead of encoding it in a brief.

References

• references/writing-the-brief.md — structure, scope, gates,

brief delivery.

• references/dispatch-and-poll.md — flags, artifacts,

result.json, and failure recovery.

• references/review-and-land.md — what to verify before calling

the diff done, at the end of a run.

• references/multi-task-queues.md — sequential queues,

constraint carry-forward, progress tracking, and the final coherence pass.