# delivery

Adopt this skill: https://proskills.md/skills/other/hieuphung97-dely-skills-delivery

Page: https://proskills.md/skills/other/hieuphung97-dely-skills-delivery
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: skills/delivery/SKILL.md
size: 8014
upstream: https://github.com/hieuphung97/dely/blob/main/skills/delivery/SKILL.md

```text
---
name: delivery
description: Deliver a change through an approved design contract, sequential implementation, independent review and exact-HEAD release. Use for any Bounded or Architectural change — including a small, one-line behavioral fix, which is the canonical Bounded case — so it gets design approval and independent review. Not for a Spike, which investigates and recommends without starting a delivery run.
---

# Delivery

Dely accepts a request that may still be vague, brings it to an approved
design contract, then automates sequential implementation, independent
review, and pull-request preparation. It is a thin control protocol, not an
orchestrator, SDLC framework, or second source of Git state.

Read `AGENTS.md` in the repository for this project's gate commands, artifact
paths, default branch, and per-phase harness/model/effort pins. This skill
never names them.

## Two human gates

1. Approve the design contract before candidate mutation.
2. Merge or publish after Dely has prepared the reviewed pull request.

Dely pauses outside those gates only for a scope or architecture change, a
destructive action, new authority, replan, or an unavailable required runtime.

## The control session

The current interactive session is Control. It owns the approval invariant,
task boundaries, exception handling, dispatch supervision, and release. It
does not implement or review the candidate, and does not prescribe question
count, order, format, or skill-selection precedence. Native Plan Mode and
active design skills govern their own surfaces under the harness's
precedence; neither bypasses approval. Before mutation, Control obtains
explicit human approval of a design contract. One approval covers that
scope; a material change needs a new one. Control surfaces uncertainty that
could materially change intent, acceptance, authority, public contract,
architecture, or consequential risk. Material assumptions must be explicit.

## Shape

Use the smallest contract that safely holds the change. Risk may promote an
otherwise small change; diff size never demotes data-loss, security,
permission, or public-compatibility risk.

| Shape | Use | Artifact | Review |
| --- | --- | --- | --- |
| Spike | Investigation only; no candidate is delivered | Approved probe and recommendation; no delivery run | none |
| Bounded | Small change, clear behaviour and ownership | Approved in-chat design and short execution envelope | one whole-change review |
| Architectural | Multiple behaviours, public-contract change, architecture decision, or promoted risk | Approved decision record, task plan, execution envelope | task review per task, then one integration review |

An approved design contract states intent and success criteria; scope and
authority; affected public contract or architecture; consequential risks and
material assumptions; and a plausible counterexample that distinguishes
correct behaviour from a present-but-wrong implementation. If no executable
instrument can discriminate, the contract names the manual inspection and
its limit.

Architectural work uses `templates/decision-record.md` (durable) and
`templates/plan.md` (transient, deleted in the release commit, before the
release-binding review). Commit both before implementation begins — that
commit is the review baseline.

### Acceptance

One table: each requirement, the instrument that proves it, the plausible
wrong implementation that instrument rejects, and where that rejection was
observed.

**An acceptance row is invalid until its instrument discriminates.** A row
that passes both before and after the change proves nothing and will be
found at review. Baseline-red is not enough: red only because the feature
is absent says nothing about catching an implementation that is present,
runs, returns a pass, and is wrong. Each row names such a wrong
implementation. "The feature is absent" does not satisfy Counterexample.
Where none exists, the row says so and a human reads the diff.

Record what the instruments cannot observe. Prefer the simplest instrument
that proves the contract. Any claim about extent — a scope, a count, a set
of call sites — names the command that produced it, reports its output, and
enumerates rather than samples. Naming the command is not the measurement;
the command must have been run.

## Execution envelope

Before mutation, Control resolves deployment preferences against the live
harness surface, starts Orca and verifies its required capabilities,
records the dirty baseline and exact-path ownership, and creates a feature
branch when starting on the default branch. The envelope freezes owned
scope and paths; protected pre-existing dirty paths; acceptance criteria,
counterexample, and focused instruments; branch, base, remote, and
pull-request target; resolved harness, model, and effort for dispatched
roles; and authority to branch, commit owned paths, run gates, push, and
open or update a pull request. It never authorises merge, force-push,
stash, reset, cleanup, or an edit outside owned scope. Dely stages and
commits only contract-owned paths. It never stashes, resets, cleans, or
silently absorbs the user's existing changes. If a path carries protected
baseline changes and Dely must also modify it, Control pauses rather than
combining ownership.

## Orca and the helper

Orca is the required execution plane. It launches and supervises fresh
native harness TUIs with the resolved harness, model, and effort.
Orchestration is a required Orca capability. `dely:delivery` starts Orca,
then Control loads `orca skills get orchestration` and follows its
supervised loop. It stops only when the CLI is missing, the runtime cannot
start, or a required capability is absent — there is no direct dispatch and
no headless fallback of any kind. The launcher is `scripts/dely` relative
to this skill. Control learns the helper's interface by running
`scripts/dely` with no arguments, which prints its identity and usage,
and does not read `scripts/dely.js`. Control's wake mode is that harness's
`controlWake` in `../../harnesses.json`. The preflight step runs in setup
and again after a `NO_ACK`; a delivery does not preflight before its first
dispatch. Run `dely preflight` and `dely dispatch` with no tool timeout, or
one of at least 300 s.

Write the prompt to an untracked file **inside the worktree**. Never inline
it in a shell argument: prompts carry backticks, quotes and newlines, and a
shell argument mangles them. A path outside the workspace can trigger a
second permission surface some harnesses still prompt for even when tool
approval is skipped. Do not stage that file. After the worker returns,
delete it: Control owns that dispatch artifact, not `git clean`. The handoff
is a file in the worktree; its path travels as `payload.reportPath` and the
message body stays short. `--spec` and `--body` are shell arguments, which
this skill already forbids for prompts.

The dispatch prompt carries the task, its scope, and the evidence required.
It does not define role dispositions or the conditions for reaching one —
those belong to this skill, and a prompt that restates them narrows or
contradicts them. Where the design contract states an acceptance row, the
prompt carries that row as written. Every dispatch goes through
`dely dispatch`. Control does not compose a worker launch or call
`worker-start` by hand. The helper reads the pins from `AGENTS.md` and
appends the acknowledgement instruction and a sentence that the Orca
preamble and the spec file are everything the worker needs and that it
should read no other skill. The `worker-start` receipt records
`launch.requested` and `launch.effective`; it does not establish that the
worker can serve the request or that it cannot. Orca applies the execution
plane's configured permission default and does not add a sandbox the project
did not pin.

**Name the model and effort on every dispatch.** The helper passes
`--model`/`--effort` when `../../harnesses.json` says that harne
```

## File: README.md
upstream: https://github.com/hieuphung97/dely/blob/main/README.md

````text
# dely

<picture>
  <source media="(prefers-color-scheme: dark)" srcset="assets/logo.svg">
  <img src="assets/logo-light.svg" alt="dely" width="72" height="72">
</picture>

Ask for a change; Dely takes it through design approval, implementation,
independent review, and a pull request you merge.

https://github.com/user-attachments/assets/83ec539a-6551-4807-8517-0c73e5d171d7

[YouTube](https://www.youtube.com/watch?v=6pRWkhlQSAc)

## Contents

- [Quickstart](#quickstart)
- [How Dely works](#how-dely-works)
- [Choose a harness for each role](#choose-a-harness-for-each-role)
- [Install Orca](#install-orca)
- [Install Dely](#install-dely)
- [Configure a project](#configure-a-project)
- [Log](#log)
- [Troubleshooting](#troubleshooting)

## Quickstart

1. [Install Orca](#install-orca).
2. [Install Dely](#install-dely) in the harness you will talk to.
3. Open that harness in your project. Run `dely:setup` to choose which harness
   and model run each role, or use the project's existing pins. If no pin names
   a phase, it runs on Control's harness.
4. Ask for a change.

## How Dely works

You ask. Control designs. You approve. The implementer builds. The reviewer
checks. Control opens the pull request. You merge.

**Control** is the session you talk to. It writes the design, waits for your
approval, starts the other two sessions, and opens the pull request. Install
Dely here.

**Implementer** is a session Control starts to make the change.

**Reviewer** is a session Control starts to check the change independently
before the pull request. The implementer and the reviewer are the workers.

A Spike investigates only — no delivery run. One that dispatches workers opens its own Orca Run and keeps their files in that Run's folder.

## Choose a harness for each role

Before the first delivery in a project, open each harness you chose there once
and answer its trust question. Setup opens them for you. Claude Code needs no
such step on Orca 1.4.220 and later, which by default trusts the folder when
it starts Claude; with Orca's "Trust the folder when Orca starts an agent"
setting off, or a failed trust write, Claude still asks and the preflight
failure names the dialog. OMP has no trust question; Pi asks only when the project or a parent folder has `.pi/` or
`.agents/skills`.

✓ works · ⚠ works, read the note · ✗ not supported

| Harness | Control | Implementer | Reviewer | Watch out for |
| --- | --- | --- | --- | --- |
| Claude Code | ✓ | ✓ | ✓ | Put @AGENTS.md in CLAUDE.md. |
| Codex CLI | ⚠ | ✓ | ✓ | Use Codex CLI 0.159.2 or newer with Orca 1.4.217 or newer. As Control, it can start the next Dely step before the last one finishes. |
| Grok Build | ⚠ | ⚠ | ⚠ | Answer the trust question once in every project. As a worker, you cannot choose the model. As Control, a free account ran out of usage mid-delivery. |
| Antigravity CLI | ✓ | ⚠ | ⚠ | Choose the effort through the model name. Avoid gemini-3-flash-preview. As a worker, the first launch in a new folder can lose the task and show 'not signed in' while signed in; Dely retries once, then asks you to open agy there. |
| Kiro CLI | ✗ | ✗ | ✗ | Workers never start in Orca. |
| Cursor Agent CLI | ✓ | ✓ | ✓ | Choose the effort through the model name, for example cursor-grok-4.6-high. |
| GitHub Copilot CLI | ✓ | ⚠ | ⚠ | At the first launch, answer No, thanks to the app prompt; until then a launch can leave the task unsent. Answer the folder trust question once in every project and choose to remember the folder; Orca does not see it, so a missed one shows as NO_ACK. As a worker, you cannot choose the model. |
| OMP | ⚠ | ⚠ | ⚠ | It never asks for trust, so use it only in repositories you trust. As a worker, use Orca 1.4.224 or newer, which does not show OMP's status (stablyai/orca#24436), so Dely reports a working OMP worker as needing attention. As Control, run dely wait with your largest job timeout (3600 s); a shorter timeout kills the wait before it ends. |
| Pi | ⚠ | ⚠ | ⚠ | As Control, run Dely's commands with no time limit. As a worker, to pin a model, install Dely in Pi, then check the model in Pi's session log. |

Other agents Orca can launch may work too;
[`harnesses.json`](harnesses.json) records what was measured.

## Install Orca

Orca runs each session and launches the workers.

1. Install the [desktop app](https://www.onorca.dev/docs/install).
2. Register the CLI: Settings → General → Orca CLI. See the
   [CLI overview](https://www.onorca.dev/docs/cli/overview).
3. Enable orchestration: Settings → Experimental. See
   [orchestration](https://www.onorca.dev/docs/cli/orchestration).
4. Check it:

```bash
orca open
orca status --json
orca orchestration run-list --json
```

On Linux, the binary is `orca-ide`.

## Install Dely

**Install Dely only in the harness you use as the Control session.** A harness
used only as implementer or reviewer needs Orca and its own login. Workers
read no Dely skill. **A pinned Pi worker also needs that harness's
Dely install below**, which loads `dely-pin.ts`.

Have Node 18 or newer on PATH. Open Control in your project and ask for a
change using `dely:delivery`. To choose the implementer and reviewer, run
`dely:setup` first; see [Configure a project](#configure-a-project). If no pin
names a phase, it runs on Control's harness with its default model and effort.
Use the invocation spelling listed below for your harness.

### Claude Code

```bash
claude plugin marketplace add https://github.com/hieuphung97/dely.git
claude plugin install dely@dely
claude plugin list                 # verify
claude plugin update dely          # update; restart to apply
claude plugin uninstall dely       # remove
```

Put `@AGENTS.md` in `CLAUDE.md` so Claude reads the routing line setup adds.
Invoke `/dely:delivery` or `/dely:setup`.

### Codex CLI

```bash
codex plugin marketplace add https://github.com/hieuphung97/dely.git
codex plugin add dely@dely
codex plugin list                  # verify
codex plugin marketplace upgrade   # update; open a new session
codex plugin remove dely@dely       # remove
```

If add keeps a stale marketplace, remove the marketplace and plugin, then add
again. Pin a tag or full commit SHA with
`codex plugin marketplace add --ref <ref> https://github.com/hieuphung97/dely.git`.
Do not use `codex plugin install`.
Invoke `$delivery (dely:delivery)` or `$setup (dely:setup)`.

### Cursor Agent CLI

```bash
cursor-agent plugin marketplace add https://github.com/hieuphung97/dely.git
cursor-agent plugin marketplace list          # verify marketplace
cursor-agent plugin marketplace update dely   # re-index only; does not fetch
cursor-agent plugin marketplace remove dely   # remove marketplace only
```

In a session, open `/plugin` → Marketplace → dely → Install for you.
To update, remove and re-add the marketplace, then uninstall and reinstall
Dely in `/plugin`. To remove Dely, use `/plugin` → Installed → dely → Uninstall.
Type `/dely` to find `/delivery` and `/setup`. Local snapshot installs are
unavailable; Cursor can read the Claude plugin cache.

### GitHub Copilot CLI

```bash
copilot plugin install https://github.com/hieuphung97/dely.git
copilot plugin install /path/to/dely       # local alternative
copilot skill list                        # verify delivery and setup
copilot plugin update dely                # update git or local install
copilot plugin uninstall dely             # remove
```

Invoke `/dely:delivery` or `/dely:setup`. Direct installs print a deprecation
warning. A same-named project or personal skill can hide the plugin skill.

### Antigravity CLI

```bash
agy plugin install https://github.com/hieuphung97/dely.git
agy plugin install /path/to/dely           # local alternative
agy plugin list                           # verify dely with skills
agy plugin install https://github.com/hieuphung97/dely.git   # update git install
agy plugin uninstall dely                 # remove
```

There is no plugin update subcommand. Re-run install with the same target t
````
