Skip to content
Back to search

delegate-skills

SkillWorks with Claude CodeGitHub

Delegate a coding task to a separate coding agent CLI, review the diff, land the commit yourself — one per implementer.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/amElnagdy/delegate-skills with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/amElnagdy/delegate-skills'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/amelnagdy-delegate-skills/badge.svg)](/listings/amelnagdy-delegate-skills)

HTML

<a href="/listings/amelnagdy-delegate-skills"><img src="/api/listings/amelnagdy-delegate-skills/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Browse first:

npx skills add amElnagdy/delegate-skills --list

Install the package, the setup skill, or one implementer skill:

npx skills add amElnagdy/delegate-skills
npx skills add amElnagdy/delegate-skills --skill delegate-setup
npx skills add amElnagdy/delegate-skills --skill codex-delegate

To pin an installation, append an existing release tag as `@vMAJOR.MINOR.PATCH`. The Skills CLI installs by git ref, not by `metadata.version` in `SKILL.md`.

Install for a specific agent, or globally:

npx skills add amElnagdy/delegate-skills --skill codex-delegate --agent claude-code
npx skills add amElnagdy/delegate-skills --global

Works with any orchestrating agent the [Skills CLI](https://github.com/vercel-labs/skills) supports.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 468 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # delegate-skills
  2. [![relay smoke](https://img.shields.io/github/actions/workflow/status/amElnagdy/delegate-skills/relays.yml?branch=master&label=relay%20smoke)](https://github.com/amElnagdy/delegate-skills/actions/workflows/relays.yml)
  3. [![skills.sh](https://www.skills.sh/b/amElnagdy/delegate-skills)](https://www.skills.sh/amElnagdy/delegate-skills)
  4. [![License](https://img.shields.io/github/license/amElnagdy/delegate-skills)](LICENSE)
  5. **Create your fleet of lanes. One orchestrator, the right implementer for every job.**
  6. Discover the implementer CLIs already installed on your machine, organize them into lanes like
  7. `feature`, `tests`, and `ui`, then delegate by lane — or choose one implementer directly. Either way,
  8. you keep the review and the commit.
  9. ```bash
  10. npx skills add amElnagdy/delegate-skills
  11. ```
  12. Then ask your orchestrating agent to create the fleet:
  13. ```text
  14. Use $delegate-setup to discover my installed implementer CLIs and create a fleet for feature, tests, and UI work.
  15. ```
  16. Or delegate directly:
  17. ```text
  18. Use $codex-delegate to have Codex implement the refactor in services/billing/, then review and commit it.
  19. ```
  20. ```mermaid
  21. flowchart LR
  22. S["$delegate-setup<br/>discover → propose → approve"] --> F["Example fleet"]
  23. O["Your orchestrator"] --> F
  24. F -->|"feature"| A["OpenCode"]
  25. F -->|"tests"| B["Codex"]
  26. F -->|"ui"| C["Cursor"]
  27. A --> R["Review the diff<br/>Run the gates"]
  28. B --> R
  29. C --> R
  30. R --> L["You land the commit"]
  31. ```
  32. ## Choose how you delegate
  33. ### Create a fleet
  34. | Skill | Job |
  35. | --- | --- |
  36. | [`delegate-setup`](skills/delegate-setup/SKILL.md) | Discover installed CLIs, propose **fleet lanes**, and write global or project config after you approve. Never dispatches work. |
  37. A **fleet** is your set of named lanes. Each **lane** binds a kind of work to one implementer and
  38. optional dials such as model, effort, or variant. Setup discovers what is available, proposes a compact
  39. fleet, shows you the complete configuration, and writes only after explicit approval.
  40. Configuration can apply globally or to one repository. Once it is ready, dispatch with the matching
  41. `*-delegate` skill and `--lane <name>`. Explicit flags override lane dials, and the wrong implementer
  42. skill for a lane fails loud. Project config is content-bound to explicit setup approval, so cloned or
  43. edited project lanes fail closed until re-approved. See the
  44. [`delegate-fleet.v1` schema](skills/delegate-setup/references/schema.md) for paths, supported dials,
  45. and overlay behavior.
  46. ### Delegate directly
  47. Skip setup when you want one implementer or one-off dials. Pick the skill for a CLI you have:
  48. | Skill | Implementer CLI | Write access (default) | Read-only run | Resume |
  49. | --- | --- | --- | --- | --- |
  50. | [`aider-delegate`](skills/aider-delegate/SKILL.md) | [Aider](https://aider.chat) (`aider`) — any OpenAI-compatible endpoint, including a local or self-hosted model via `--api-base` | `--yes-always` with `--no-suggest-shell-commands`; no sandbox or permission modes; commits force-disabled [^aider] | `--read-only` (`--dry-run`) | `--resume-last` (chat history, per-worktree) |
  51. | [`agy-delegate`](skills/agy-delegate/SKILL.md) | Google Antigravity (`agy`) | Antigravity's own `permissions`; bypass opt-in | `--read-only` (`plan` mode) | `--resume-last`, `--conversation <id>` |
  52. | [`claude-delegate`](skills/claude-delegate/SKILL.md) | [Claude Code](https://code.claude.com/docs/en/overview) (`claude`) | `acceptEdits` + explicit tool surface | `--read-only` (`plan` mode) | `--resume-last`, `--session <id>` |
  53. | [`cline-delegate`](skills/cline-delegate/SKILL.md) | [Cline](https://github.com/cline/cline) (`cline`) | `--auto-approve true` in act mode; upstream sandbox not configured by the relay | `--plan` + `--auto-approve false` (relay-enforced pair) | — (headless JSON resume unsupported) |
  54. | [`codex-delegate`](skills/codex-delegate/SKILL.md) | [OpenAI Codex](https://github.com/openai/codex) (`codex`) | `--sandbox workspace-write` | `--read-only` | `--resume-last`, `--session <id>` |
  55. | [`commandcode-delegate`](skills/commandcode-delegate/SKILL.md) | [Command Code](https://commandcode.ai/docs/headless) (`cmd`; `cmdc` on Windows) | `--yolo` — the only headless write state; no sandbox [^commandcode] | `--read-only` (withheld tools + `plan`) | `--continue-last`, `--session <id>` |
  56. | [`cursor-delegate`](skills/cursor-delegate/SKILL.md) | [Cursor Agent](https://cursor.com/cli) (`cursor-agent`) | `--force`; `--no-force` withholds command approval | `--read-only` (plan mode) | `--resume-last`, `--session <id>` |
  57. | [`grok-delegate`](skills/grok-delegate/SKILL.md) | Grok Build (`grok`) | workspace-scoped; `--full-access` opt-in | `--read-only` — best-effort [^grok] | `--resume-last`, `--session <id>` |
  58. | [`kimi-delegate`](skills/kimi-delegate/SKILL.md) | [Kimi Code](https://moonshotai.github.io/kimi-code/en/) (`kimi`) | `auto permission mode`, always | — [^none] | `--resume-last`, `--session <id>` |
  59. | [`mcode-delegate`](skills/mcode-delegate/SKILL.md) | [MiniMax Code](https://agent.minimax.io/docs/cli/quick-start) (`mcode`) | `--permission smart`; `full` opt-in; no sandbox [^mcode] | `--read-only` — advisory prompt + tripwire [^mcode] | `--session <id>` |
  60. | [`muse-delegate`](skills/muse-delegate/SKILL.md) | Muse Code (`muse`) | `--disable-approval` (sandbox on); not `--yolo` [^muse] | `--read-only` (`--disable-write` + `--disable-shell`) | `--session <id>` (no headless `--resume-last`) |
  61. | [`opencode-delegate`](skills/opencode-delegate/SKILL.md) | [OpenCode](https://opencode.ai) (`opencode`) | agent `build` (`--model` required) | `--read-only` (agent `plan`) | `--resume-last`, `--session <id>` |
  62. | [`pi-delegate`](skills/pi-delegate/SKILL.md) | [Pi](https://github.com/earendil-works/pi-mono) (`pi`) | full local tools — no sandbox, no permission modes [^none]; project trust opt-in | `--read-only` (`read,grep,find,ls`) | `--resume-last`, `--session <id>` |
  63. | [`omp-delegate`](skills/omp-delegate/SKILL.md) | [Oh My Pi](https://github.com/can1357/oh-my-pi) (`omp`) | `--yolo` (`tools.approvalMode: yolo`); project `.omp` extras off unless `--approve` | `--read-only` (`read,grep,glob`) | `--resume-last`, `--session <id>` |
  64. | [`qoder-delegate`](skills/qoder-delegate/SKILL.md) | [Qoder](https://docs.qoder.com/en/cli/quick-start) (`qodercli`) | `auto` permission mode; bypass opt-in | `--permission-mode plan` | `--resume-last`, `--resume <id>` |
  65. | [`vibe-delegate`](skills/vibe-delegate/SKILL.md) | [Mistral Vibe](https://github.com/mistralai/mistral-vibe) (`vibe`) | `accept-edits`; `--full-access` opt-in | `--plan-only` (`plan` agent) | `--resume-last`, `--session <id>` |
  66. | [`copilot-delegate`](skills/copilot-delegate/SKILL.md) | [GitHub Copilot CLI](https://docs.github.com/copilot/how-tos/copilot-cli) (`copilot`) | `--allow-all-tools` opt-in; headless auto-deny otherwise | `--read-only` (`--mode plan`) | `--resume-last`, `--session <id>` |
  67. | [`warp-delegate`](skills/warp-delegate/SKILL.md) | [Warp Agent CLI](https://docs.warp.dev/cli/) (`oz`) | full local tools — no sandbox, no permission modes [^none] | — [^none] | `--conversation <id>` |
  68. | [`zcode-delegate`](skills/zcode-delegate/SKILL.md) | [Z.AI ZCode](https://zcode.z.ai) (`zcode`) [^zcode] | `--mode yolo` | `--read-only` (`plan` mode) | `--resume-last`, `--session <id>` |
  69. [^commandcode]: Command Code's headless mode has two states and nothing between them: a `-p` run
  70. withholds the write, edit, and shell tools, and `--yolo` (alias `--dangerously-skip-permissions`)
  71. allows every tool anywhere the process can reach. `--permission-mode auto-accept` and `--tools-all`
  72. do **not** lift the write gate. So an implementation run is full-trust with no path restriction —
  73. the brief's path list is guidance, not containment. A worktree isolates the checkout, while a
  74. container or another OS-enforced sandbox is required when writes outside the target tree are
  75. unacceptable. `touchedFiles` is a review aid based on `git status`; it cannot show ignored files or
  76. writes outside the repository.
  77. [^mcode]: `mcode exec` has no sandbox and no read-only or plan setting for a headless run. Its
  78. default `smart` policy already approves writes and deletions without a prompt (a live probe's `rm`
  79. ran with no confirmation), so the brief and a clean tree are the scope. The relay's `--read-only`
  80. appends a system prompt forbidding edits and then runs the Git-visible tripwire: a change is
  81. detected after the run, not prevented. The relay refuses `--permission off`, whose effect is
  82. undocumented.
  83. [^none]: No CLI-enforced read-only mode. `touchedFiles` and the diff are what you review against, not
  84. a guarantee: they are post-run `git status` in the workspace, so they cannot show ignored files,
  85. reverted edits, or writes outside the repository.
  86. [^aider]: Aider is the one implementer here that commits by default. Its `--auto-commits` and
  87. `--dirty-commits` both default to `True`, the second of which commits your pre-existing uncommitted
  88. work before editing. The relay always passes `--no-auto-commits` and `--no-dirty-commits`, and neither
  89. is configurable through it.
  90. [^grok]: `grok` cannot be prevented from writing headlessly. The relay reports a tri-state
  91. `readOnlyViolation` tripwire for detected Git-visible changes; it does not enforce or attribute them.
  92. [^muse]: Write `muse exec` keeps Muse's sandbox on and passes `--disable-approval` so a headless run
  93. cannot hang on a tool-approval prompt. `--read-only` adds `--disable-write` and `--disable-shell`.
  94. `--yolo` is not the default and is not exposed. Upstream's launcher is Darwin/Linux only. Headless
  95. resume is `--session-id`; `muse resume` is TUI-only.
  96. [^zcode]: ZCode ships its CLI **inside the desktop app** — there is no `zcode` on PATH, no npm
  97. package, and the public docs cover only the GUI. The relay resolves it from
  98. `--zcode-path`/`ZCODE_CLI`, then PATH, then the installed app bundle. Of ZCode's four documented
  99. modes only `plan` and `yolo` work headlessly: `build` and `edit` have no permission client there, so
  100. they block every write tool and exit 0 having changed nothing, and the relay rejects them rather
  101. than report that as success. ZCode offers `--disallowed-tools` but no `--allowed-tools`, so
  102. capability can be subtracted, never enumerated. Where `zcode login` fails with `OAuth response is
  103. not valid JSON`, the key comes from `ZCODE_API_KEY` / `ANTHROPIC_API_KEY` / `ZAI_API_KEY` instead.
  104. Each skill name links to its `SKILL.md`, which owns that implementer's prerequisites, flags, and
  105. caveats. Building one for another CLI? [Claim it first](../../issues?q=is%3Aissue+label%3Aimplementer),
  106. then see [CONTRIBUTING.md](CONTRIBUTING.md).
  107. ## Install
  108. Browse first:
  109. ```bash
  110. npx skills add amElnagdy/delegate-skills --list
  111. ```
  112. Install the package, the setup skill, or one implementer skill:
  113. ```bash
  114. npx skills add amElnagdy/delegate-skills
  115. npx skills add amElnagdy/delegate-skills --skill delegate-setup
  116. npx skills add amElnagdy/delegate-skills --skill codex-delegate
  117. ```
  118. To pin an installation, append an existing release tag as `@vMAJOR.MINOR.PATCH`. The Skills CLI
  119. installs by git ref, not by `metadata.version` in `SKILL.md`.
  120. Install for a specific agent, or globally:
  121. ```bash
  122. npx skills add amElnagdy/delegate-skills --skill codex-delegate --agent claude-code
  123. npx skills add amElnagdy/delegate-skills --global
  124. ```
  125. Works with any orchestrating agent the [Skills CLI](https://github.com/vercel-labs/skills) supports.
  126. ## How delegation works
  127. Whether you choose the implementer directly or through a fleet lane, every dispatch follows the same
  128. review-first loop:
  129. 1. **Write a brief** — self-contained task context; the implementer has no orchestrator chat history.
  130. 2. **Dispatch** it with the bundled `relay.mjs`.
  131. 3. **Wait** for completion — the relay writes a structured `result.json`.
  132. 4. **Review** the diff — re-run the project's gates yourself; pair with [guard skills](https://github.com/amElnagdy/guard-skills).
  133. 5. **Land** it — *you* commit, because committing belongs to the reviewer.
  134. ```text
  135. Use $claude-delegate to have a separate Claude Code session implement the parser fix, then review and commit it.
  136. Use $opencode-delegate with --lane feature to implement the billing workflow, then review and commit it.
  137. Use $codex-delegate to run this queue of migration tasks through Codex while I review each one.
  138. ```
  139. Every relay speaks the same `delegate-relay.result.v1` contract: `status`, `exitCode`, `signal`
  140. (with a host-killed hint when the OOM killer ends a run), the implementer's own final report,
  141. `touchedFiles`, and a session id where the CLI exposes one. Learn the loop once, swap the implementer
  142. freely.
  143. You feel it when a bounded task — a migration, a mechanical refactor, a removal sweep — comes back as
  144. a clean diff with a structured report, and you land it after re-running the gates yourself instead of
  145. typing it all by hand.
  146. ## What counts as an implementer skill
  147. Four invariants hold for every `*-delegate` skill. They are also the bar for a new implementer:
  148. - **A separate CLI edits a real working tree, and the diff is the deliverable.** Not an API wrapper,
  149. not a gateway — an implementer whose work you can read with `git diff`.
  150. - **The relay never commits.** Committing belongs to the reviewer, always.
  151. - **Node built-ins only.** No dependencies, no network calls of its own, no credentials, no telemetry.
  152. The relay launches its implementer CLI and `git`, plus the platform process launcher where a Windows
  153. shim or a process-tree kill needs one.
  154. - **Autonomy is stated in the CLI's own terms**, and whatever it cannot enforce is said plainly — see
  155. the two footnotes above.
  156. This is a loop, not a forwarder: a forwarder hands over one task and returns the output. Here you
  157. dispatch, poll, review, and land, across one task or a queue. It stays complementary to a vendor's own
  158. plugin or subagents — those coordinate inside one agent; this keeps the contract portable across
  159. orchestrators, with the commit on the reviewer.
  160. `delegate-setup` is the setup-skill exception: it discovers CLIs and writes an approved fleet map, but
  161. never dispatches coding work.
  162. Full checklist: [CONTRIBUTING.md](CONTRIBUTING.md).
  163. ## Requirements
  164. - For a `*-delegate` skill, its implementer CLI authenticated as you would at the terminal. Each
  165. implementer skill's `SKILL.md` carries its own install and login commands.
  166. - `delegate-setup` requires no implementer CLI; it discovers whichever ones are available.
  167. - Node 18+ and `git`.
  168. - An orchestrating agent that can run shell commands and read files.
  169. - Shell examples assume bash/zsh (macOS/Linux, or Git Bash/WSL on Windows).
  170. ## Trust and validation
  171. This package is intentionally inspectable:
  172. - All skill content is Markdown, plus small Node scripts. Each `*-delegate` skill has exactly one
  173. `scripts/relay.mjs`. The `delegate-setup` utility ships `discover.mjs` / `config.mjs` / `lane.mjs`
  174. (and a shared implementer table) instead of a relay — it never dispatches coding work.
  175. - Those scripts make no network calls of their own, read or write no credentials, send no telemetry, and
  176. have no dependencies (Node built-ins only). Relays launch an implementer CLI and `git`, plus the
  177. platform process launcher/termination utility where a Windows shim or process-tree kill requires one.
  178. Discover may invoke installed CLIs for `--version` / model list probes (those CLIs may contact their
  179. own services). Read the script before you run it.
  180. - None of the relays ever commit — committing is always the orchestrator's job, after review.
  181. **Verification status** — claims here are backed by runs, not assumptions.
  182. True of every relay: argument handling, exit codes, `result.json` shape, supported resume mappings,
  183. and signal reporting are verified, along with each implementer-specific guard.
  184. Per skill — platform, CLI version, and what the run exercised:
  185. - `aider-delegate` — Windows, `aider` 0.86.2: contract-tested against the shared smoke matrix, plus
  186. live headless `--message-file` runs against a **stub** OpenAI-compatible endpoint on loopback. Those
  187. runs covered: an applied edit left uncommitted, with a pre-existing dirty file still uncommitted,
  188. proving `--no-auto-commits`/`--no-dirty-commits`; no `.gitignore` written, proving `--no-gitignore`;
  189. a `--read-only` (`--dry-run`) run that left the target file byte-identical; an endpoint returning
  190. 401, where aider exits 0 and the relay reports `failed` with `litellm.AuthenticationError`;
  191. `aider_unavailable`/127 writing a result file; and usage errors exiting 2 without one. Review
  192. follow-ups were re-verified the same way: a successful run whose report says `OPENAI_API_KEY` three
  193. times still reports `completed`; a reused `--out-dir` seeded with another run's `final.txt` and
  194. `result.json` publishes neither; a plain exit 7 carries an `error`; and a `--read-only` run over a
  195. modified `.aider.conf.yml` plus generated history and tags-cache warns about exactly the config
  196. file. Not run against a hosted provider model or a real local inference server, and not run on
  197. macOS or Linux.
  198. - `agy-delegate` — Windows 10, native, `agy` 1.1.12: headless `--print` write run editing one briefed
  199. file; `--read-only` `--effort high` run whose brief ordered an immediate file write, in a directory
  200. the permission rules allowed: agy refused, wrote nothing, and `result.json` reported effort high,
  201. `readOnly` true, `readOnlyViolation` false; argument validation for a bad `--effort` value and for
  202. `--read-only` combined with `--dangerously-skip-permissions`, both exiting 2; resume by
  203. `--conversation` with a delta brief. macOS, `agy` 1.0.16: headless edit run, `--print=` delivery,
  204. absolute `--add-dir` workspace pin. `--stall-timeout` is contract-tested, live stall pending: a fake
  205. whose log keeps growing without `streamGenerateContent` lines reports `stalled`, steady generation
  206. calls split across writes keep a run alive, and the watchdog is off unless passed; run on native
  207. Windows against the compiled fake.
  208. - `claude-delegate` — macOS, `claude` 2.1.220: write run under `acceptEdits`; plan mode refusing an
  209. edit, with the Git tripwire true on a violation and false on a clean run;
  210. `--session`/`--resume-last` resume; `claude_unavailable`/127 and usage errors exiting 2 without a
  211. result file; deny rules and the shell sandbox blocking `git commit`, `git push`, `git -C <dir> push`,
  212. a nested `claude`, and a `$HOME` write.
  213. macOS, `claude` 2.1.271: `--autocompact` argument handling only. The installed CLI accepted `auto`, `400k`, `1M`, `200`, and `200000` and rejected `auto2`, `50k`, `2m`, `99`, `1000001`, and `0` with exit 1, each observed through `claude --autocompact <value> --help`, which validates the option and exits before any model call; `claude` 2.1.220 rejects the option itself with `unknown option '--autocompact'`, which is the documented 2.1.221 floor. The relay's pass-through, resume re-pass, and `result.json` record are contract-tested against the smoke matrix; no delegated run has been dispatched with `--autocompact` set.
  214. Windows 11, native, `claude` 2.1.274 through the npm `claude.cmd` shim, launched from Windows
  215. PowerShell 5.1 with an `--out-dir` containing a space: write run under `acceptEdits` editing one
  216. file and creating another, with `git status` run through the pre-approved PowerShell tool and a
  217. `git commit` attempt denied by the relay's deny rule (`permission_denied` with
  218. `decision_reason_type: "rule"` in the event stream, `HEAD` untouched); `--session` resume whose
  219. delta brief referred only to "the notes file you created a moment ago" and was applied correctly;
  220. `--read-only` plan-mode run ordered to write two files over an already-dirty tree, which wrote
  221. nothing and reported `readOnlyViolation: false` with the dirty files byte-identical; a 45s
  222. `--timeout` firing on a run blocked in a foreground `ping` grandchild, reporting `timeout` and
  223. exit 1 with no `ping`, `cmd`, or `claude` process left behind; `claude_unavailable`/127 writing a
  224. result file, and usage errors exiting 2 without one. The runs used `--model haiku`. Not run on
  225. Windows: a directly spawned `claude.exe`, the abort path, and a read-only violation. Claude's shell
  226. sandbox is unsupported there, so the write profile's PowerShell is not isolated.
  227. - `cursor-delegate` — Windows, `cursor-agent` 2026.07.23-e383d2b: write run under `--force`; plan-mode
  228. `--read-only` touching nothing; `--session <id>` resume applying a delta brief; usage errors exiting
  229. 2. A maintainer-run native macOS plan-mode smoke against the same version captured model, session,
  230. and usage with no touched files. `--stall-timeout` is contract-tested; the live hang it targets was
  231. observed on Linux with `cursor-agent` 2026.10.01-e373342 (two runs silent after `thinking`
  232. `completed`, never exiting).
  233. - `grok-delegate` — macOS, `grok` 0.2.101: streaming-json report capture, file-based brief delivery,
  234. resume; read-only is best-effort by measurement, hence the violation flag.
  235. Contributor-run native Windows check with `grok` 1.0.13: a no-edit dispatch using
  236. `--trust-git-root` on a drive rejected by Git's ownership check completed with the pre-existing
  237. untracked file reported and `readOnlyViolation: false`; that run used a real drive path whose
  238. spelling did not diverge, and the verdict is claimed for Windows paths whose spelling does not
  239. diverge — exact-head CI evidence for spelling-divergent temp paths lands with this repair.
  240. Ownership, nested-directory, linked-worktree,
  241. dirty-path, submodule, and unavailable-Git cases are covered by the `grok-git-trust` smoke module.
  242. - `kimi-delegate` — macOS, `kimi` 0.24.0: headless `-p` edit run, stream-json parsing, and both
  243. resume paths — the relay's `--session`/`--resume-last`, which drive Kimi's own `--session` and
  244. `--continue`.
  245. - `pi-delegate` — macOS: stdin brief delivery, explicit provider and model selection, JSON
  246. session/provider/model/usage capture, and a `--read-only` run leaving a clean tree. Write,
  247. `--session`, and `--resume-last` runs are contributor-reported.
  248. - `omp-delegate` — contract-tested, live run pending: stdin brief delivery, `omp --mode json`
  249. argv (`--yolo`, `--tools read,grep,glob`, `--no-extensions --no-skills --no-rules`, `--thinking`),
  250. session header / `message_end` parsing, `--approve` omitting the project-trust flags, `--continue`
  251. resume, assistant `stopReason: error` reported as failed, `omp_unavailable`/127, and bounded
  252. `--version` preflight. Native Windows launch is a native `omp.exe` (no `shell:true`); that path is
  253. contract-tested via the smoke matrix's compiled fake, not against a live Oh My Pi install.
  254. - `qoder-delegate` — macOS, `qodercli` 1.0.47, by the contributor: Lite edit run, `accept_edits`,
  255. explicit model and 32768-token context window, no commit.
  256. - `commandcode-delegate` — macOS, `cmd` 1.26.0: **live edit run verified**. A relay dispatch against a
  257. throwaway git repository had Command Code fix a remainder-dropping bug in a money-splitting function
  258. and add three tests; the project gate was re-run independently by the orchestrator (2 tests before,
  259. 5 passing after), the diff matched the brief with no writes outside the two named files, and `HEAD`
  260. was untouched — the relay does not commit, and the run did not either. A second dispatch with
  261. `--session <id>` verified resume through the relay: a one-line delta brief amended exactly the comment
  262. it named, with the session id from the first run. A `--read-only` dispatch verified the other
  263. direction, returning `readOnlyViolation: false` on a clean tree. Also verified negatively: separate
  264. live runs confirmed `--tools-all` and `--permission-mode auto-accept` leave the headless write gate
  265. closed and only `--yolo` opens it.
  266. Live running surfaced a CLI limitation the relay now handles. `cmd` ends a run with a `run_end` event
  267. embedding the whole conversation, then exits with `process.exit`, discarding whatever is still queued
  268. in its stdout pipe: both write runs lost their `result` line entirely (one cut ~8 KB into `run_end`,
  269. the other losing its last ~780 events). So nothing load-bearing is read from that tail — `sessionId`
  270. comes from `run_start`, the first line of the stream, and the report from the last `message_end` or
  271. its streamed deltas — the event log is written in batches so the relay drains the pipe as fast as it
  272. can, `resultLine` reports `complete`/`truncated`/`absent` so a consumer knows which fields are
  273. trustworthy. A complete non-success result converts a zero child exit to relay exit 1, while a lost
  274. result line falls back to the process exit code. Smoke cases pin that contract. On a long run the
  275. report itself can land in the discarded region. The diff is the deliverable, and a thin report
  276. means missing information, not a failed run.
  277. Native Windows launch is contract-tested against the installed `cmdc.cmd` shape, including stdin
  278. brief delivery and the `cmd.exe` collision guard. A live native Windows Command Code run remains
  279. unverified; upstream recommends WSL for stable Windows use.
  280. - `warp-delegate` — macOS, `oz` 0.2026.05.27.15.44.stable_01: **live edit run verified**. A relay
  281. dispatch against a throwaway git repository had Warp add a function plus four assertions across
  282. two files; both project gates were re-run independently by the orchestrator, the diff matched the
  283. brief, and `HEAD` was untouched. Verified end to end: version preflight, launch, ndjson parsing
  284. (`run_started` → `runId`/`runUrl`, `conversation_started` → `conversationId`), report extraction
  285. from `{"type":"agent","text":…}` events with `agent_reasoning` excluded, `touchedFiles`, and
  286. `status: "completed"` / exit 0. A second dispatch with `--conversation` verified resume: a delta
  287. brief saying only "the function you just added" — never naming it — produced exactly the right
  288. edit, with `resumed: true` and the conversation id preserved. Also observed on a prior run:
  289. `touchedFiles: []` on a clean tree and exit 1 → `status: "failed"`. Two caveats are documented in the skill rather than fixed,
  290. because they are Warp's behaviour and not the relay's: `finalMessage` is the agent's full
  291. narration rather than a distinct final-message event, and `--cwd` governed shell commands while
  292. the agent's file tool resolved bare relative paths against `$HOME`. `--no-snapshot`, `--profile`,
  293. `--skill`, and `--mcp` are contract-tested only.
  294. - `zcode-delegate` — Windows, `zcode` 0.16.1: read-only (`plan`) run leaving a clean tree with the
  295. Git tripwire false; write run under `yolo` creating the briefed file and reporting it in
  296. `touchedFiles`; `--session` resume with an attached delta brief, which recalled the earlier turn;
  297. single-document `--json` parsing; `--version` preflight; discovery resolving the CLI from the app
  298. bundle rather than PATH; and environment-variable auth under all three names ZCode accepts —
  299. against an isolated home whose config carried no `apiKey`, a keyless run failed first, then
  300. `ZAI_API_KEY`, `ZCODE_API_KEY`, and `ANTHROPIC_API_KEY` each completed the same read-only
  301. dispatch. Contract-tested: `build`/`edit` rejection, the missing-CLI path, tolerance of the AI SDK
  302. banner that ZCode can print on stdout ahead of the JSON (observed in direct CLI probes; exercised
  303. in the suite by the fake), and the timeout matrix. The abort matrix is POSIX-only — Windows
  304. delivers no catchable SIGTERM — so for this relay it first runs in CI. `zcode-delegate` is also
  305. absent from the shared read-only tripwire scenario matrix, which runs `claude` and `grok` only —
  306. its tripwire helpers are parity-enforced byte-identical, but no zcode-specific worktree-state run
  307. is recorded. No macOS or Linux run is recorded.
  308. - `codex-delegate` — macOS, `codex` codex-cli 0.150.1: fresh `workspace-write` dispatch against a
  309. throwaway repo created the briefed file and reported it in `touchedFiles`, with `status:
  310. "completed"` and exit 0; a `--read-only` dispatch left the tree clean (`touchedFiles: []`) and
  311. returned a `threadId`; a follow-up `--session <id>` resume against that thread was asked to recall
  312. a word from the first turn without it being named again — the delta brief said only "the word you
  313. picked a moment ago" — and it answered correctly, confirming the resumed turn saw prior context, not
  314. just that the id was accepted. Contract-tested: argument validation,
  315. bounded version preflight, missing binary, result parsing, and whole-process-tree timeout/abort
  316. cleanup. Windows 11, `codex` codex-cli 0.153.4, native (Git Bash launch, no `pwsh` installed):
  317. a `workspace-write` dispatch against a throwaway repo created the briefed file and reported it
  318. in `touchedFiles` with `status: "completed"`, exit 0, and a `threadId`; the brief had Codex run
  319. shell commands and report its shell, which came back as System32 `powershell.exe` 5.1 with zero
  320. `WindowsApps` entries on its `PATH` while the parent process carried one — the relay's PATH
  321. filter reaching the sandbox, not just the child's argv. The denial the filter exists for was
  322. reproduced through the unpatched relay on the same machine: a `workspace-write` dispatch asked
  323. Codex to run `winget`, which lives only under `WindowsApps`, and both the PATH lookup and the
  324. absolute path failed inside the sandbox with "The file cannot be accessed by the system" while
  325. the same binary ran normally outside it. No Store `pwsh` is installed here, so the shell-launch
  326. form of that denial (`0xC0070005` on every command) rests on the report in issue #116. No Linux
  327. run is recorded.
  328. - `muse-delegate` — macOS, Muse Code 1.4.7: a fresh write dispatch against a throwaway repo
  329. created only the briefed file (`touchedFiles` reported exactly it, `status: "completed"`, exit 0,
  330. a `sessionId` captured); a `--session <id>` continuation in that same session appended the briefed
  331. line; a `--read-only` dispatch answered from the tree and left it byte-identical; and an
  332. `--provider echo` dispatch completed end to end. Contract-tested: argv exactness (`muse exec`
  333. with `--disable-approval` / `--disable-write` / `--disable-shell`, no `--yolo`, `--session-id`,
  334. `--resume-last` rejected), exit 0 without `run.terminal.completed` reported `failed`, bounded
  335. version preflight, missing binary, the bounded `stderrTail` over a flooded stderr, and
  336. whole-process-tree timeout/abort cleanup. Upstream's launcher is UNIX-only. No Windows or Linux
  337. run is recorded.
  338. - `opencode-delegate`, `vibe-delegate` — contract-tested only: argument validation, bounded version
  339. preflight, missing binary, result parsing, and whole-process-tree timeout/abort cleanup. No
  340. end-to-end run is recorded here.
  341. - `cline-delegate` — macOS, `cline` 3.0.52: current-binary unauthenticated plan probe reached
  342. `run_start` with the fixed positional instruction plus the real brief on stdin, accepted a
  343. provider-local model id, parsed the failing `run_result`, and left the tree clean. Contract-tested:
  344. plan mode forcing `--auto-approve false`, the unsafe true conflict, argument validation, nullable
  345. `sessionId`/`finalPath`, bounded version preflight, missing binary, result parsing, and whole-process-tree
  346. timeout/abort cleanup. The contributor also reported a native Windows 3.0.51 edit run against the
  347. earlier positional-brief commit; that does not verify this exact stdin-based head on Windows.
  348. - `copilot-delegate` — Windows, `copilot` 1.0.78: `--read-only` plan-mode run completed with a clean
  349. tree and captured session id; `--allow-all-tools` edit run created the requested file; the headless
  350. auto-deny path was exercised live (denial detected from the data-wrapped event shape, run reported
  351. failed with the `--allow-all-tools` hint); `--session <id>` and `--resume-last` resume runs executed
  352. their delta briefs via the directive-wrapped `-p @<file>` prompt. Contract-tested: argv exactness
  353. (including the resume directive), denial shape, `--read-only`/`--allow-all-tools` conflict
  354. validation, bounded version preflight, missing binary, result parsing, and whole-process-tree
  355. timeout/abort cleanup.
  356. - `mcode-delegate` — macOS, `mcode` 0.6.13: **live edit run verified**. A `--read-only` relay dispatch
  357. against a throwaway git repository diagnosed a planted bug and returned `readOnlyViolation: false`
  358. with no touched files. A second dispatch resumed that session with `--session <id>` and `--effort
  359. low` and fixed the bug: a one-line diff in the named file, `HEAD` untouched. Live failure paths
  360. verified too: an `--effort` the model does not offer (mcode exit 2, no `exec.completed`) and an
  361. unavailable `--model` (exit 4, `execStatus: failed`) both report `status: failed` with the cause.
  362. Windows `mcode.cmd` shim launch is contract-tested only.
  363. - `delegate-setup` — contract-tested: discover JSON shape, config validate/write/load, whole-lane
  364. project overlay, global write without creating `.delegate/`, and `--lane` resolve / wrong-skill /
  365. flag-override against relays. The smoke suite runs live discovery against installed CLIs
  366. (versions vary by machine). Native Windows discover smoke not yet claimed.
  367. Not yet verified: native Windows launches for a directly spawned `claude.exe` (the npm `claude.cmd`
  368. shim path has a run above), exact-head `cline`, `grok`, `kimi`, `muse`,
  369. `pi`, `qoder`, `vibe`, and `omp` (`codex`/`opencode`/`grok`/`commandcode`/`mcode` have contract-tested `.cmd` shim handling;
  370. Cursor serializes a pre-joined, quoted command; Qoder and Vibe target their documented native executables).
  371. Claude's own shell sandbox is unsupported on native Windows regardless of launch mechanics, upstream
  372. Vibe officially targets UNIX, and Muse's upstream launcher is UNIX-only. A native Linux `cursor-agent` run is unverified. The full delegate →
  373. review → commit loop is designed for and run on Claude Code; other orchestrators (Cursor, …) are
  374. designed-for but unproven.
  375. ## Repository shape
  376. Implementer skills share one shape; the setup utility has a different one:
  377. ```text
  378. skills/
  379. ├── <name>-delegate/
  380. │ ├── SKILL.md
  381. │ ├── scripts/relay.mjs
  382. │ └── references/
  383. │ ├── writing-the-brief.md
  384. │ ├── dispatch-and-poll.md
  385. │ ├── review-and-land.md
  386. │ └── multi-task-queues.md
  387. └── delegate-setup/
  388. ├── SKILL.md
  389. ├── scripts/
  390. │ ├── discover.mjs
  391. │ ├── config.mjs
  392. │ ├── lane.mjs
  393. │ └── implementers.mjs
  394. └── references/
  395. ├── schema.md
  396. └── setup-dialogue.md
  397. ```
  398. Adding an implementer is a new directory plus two lines here: a table row, and a verification line once
  399. a run backs it.
  400. Contributing? House rules, the controlled vocabulary, and the pre-publish checklist live in
  401. [AGENTS.md](AGENTS.md) — read it before opening a pull request, and point your agent at it too.
  402. ## License
  403. MIT — see [LICENSE](LICENSE).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.