harness
/harness
Prowadzi jedną zmianę przez pętlę harness: plan, zatwierdzenie, pracę z testami na pierwszym miejscu, bramki weryfikacji i wydanie.
- Autor
- 90p-labs ↗
- Repozytorium
- harness ↗
- Licencja
- MIT
- Ostatnia zmiana repozytorium
- 13.11.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 6
- Skrypty
- 1
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 0
Brak sygnałów. Repozytorium zmienione 13.11.2026, bez odwołań do wycofanych modeli i API.
MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.
- 1 skrypt w paczce. Przejrzyj je przed instalacją, bo Claude może je uruchomić.
Skrypty: harness_test.go
Co robi i kiedy
Prowadzi jedną zmianę przez pętlę harness: plan, zatwierdzenie, pracę z testami na pierwszym miejscu, bramki weryfikacji i wydanie.
Argumenty
/harness [prompt | status | approve | abandon]
Oryginalny opis (EN)
Drives one change through the harness loop: plan, approval, test-first work, verify gates, review and ship. Use when the user types /90p:harness (Codex: $90p:harness) with a prompt, or with status, approve or abandon, in a repository that has .harness.yaml.
Jak działa
- Decision tree
- Binary
- Route the arguments
- Phases
- Guard
Podgląd SKILL.md
---
name: harness
description: "Drives one change through the harness loop: plan, approval, test-first work, verify gates, review and ship. Use when the user types /90p:harness (Codex: $90p:harness) with a prompt, or with status, approve or abandon, in a repository that has .harness.yaml."
argument-hint: "[prompt | status | approve | abandon]"
---
# Harness loop
The `harness` binary holds the run state and the gates. The plugin hooks run its guard on each tool call and each stop.
Arguments: `$ARGUMENTS`
## Decision tree
```
Start: run harness version ("Binary")
├── the argument → "Route the arguments", then the phase that it prints in "Phases"
├── harness init prints a lint-setup line → the `lint-setup` skill, one language at a time
├── the change touches a bounded context of a DDD project
│ └── load the `ddd` skill, and give its path to the explorer and the reviewer
├── the phase shipping → the `pr-open` skill
└── a deny of the guard → "Guard"
```
## Binary
- In each command below, `harness` means the full path `"${CLAUDE_PLUGIN_ROOT}/bin/harness"`. Write the full path in each command: a shell variable does not stay from one Bash call to the next.
- On Codex, `${CLAUDE_PLUGIN_ROOT}` shows unexpanded. Use `bin/harness` two folders above this `SKILL.md`.
- Run `harness version` first. The first call downloads or builds the binary. If it fails, stop and report the error.
- The repository needs `.harness.yaml` at its top level. Without it, the hooks do nothing: tell the user to set the repository up (README, section "Set up a repository").
- After `harness init`, read its output. For each line `next: run the lint-setup skill to set up the architecture rules for <language>`, start the `lint-setup` skill with that language as its argument, one language at a time. The skill stops and tells the user when the repository already has a manifest for another language.
- `harness run start` adds `.harness/runs/` to `.gitignore` when the line is missing. When its output prints `gitignore: added .harness/runs/`, add `.gitignore` to the owned files of the first task and to the final code tree. Then commit the file with that task.
## Route the arguments
- `status` or empty: run `harness run status`. When the run folder has a `handoff.md`, read it. Continue the open run from both.
- `approve`: ask the `Plan` question (phase 3 below). A plain reply in the chat records nothing.
- `abandon`: run `harness run abandon` and report.
- Any other text with no active run: run `harness run start "<text>"`.
Each `run` command prints the phase and a `next:` line. Do the `next:` step. When a `handoff:` line asks for it, write `handoff.md` in the run folder as a checkpoint, then continue with the `next:` step. Do not end the turn, except for a question to the user, such as the `Plan` question, or when your context is near its limit. In `shipping`, the turn may also end while the run waits on the merge after `harness run wait`. A new session resumes from `harness run status` and `handoff.md`.
## Phases
1. `planning`: start the `explorer` agent. Set the `model` field of the agent call to the model of the `explorer` role, from the `models:` line of `harness run start` or `harness run status`. Give it the prompt and the full path of the harness binary. It reads `docs/adr/index.md` first, then `CONTEXT.md`, the ADRs that the index names and the code that the change touches. It returns the facts, the evidence baseline or its `baseline: not needed` line, and the open decisions. The explorer builds the baseline only when the change modifies, replaces or removes existing behaviour that is not fully pinned.
- On `baseline: not needed`, record `- <date>: evidence baseline: not needed: <reason>` under `## Decisions` and plan as today.
- Record each `bug`, `accidental` and `ambiguous` item under `## Decisions` as `- <date>: evidence baseline: <class>: <behaviour>: <outcome>`.
- `intended`: keep it as a criterion, with its test in the proof. It needs no record.
- `bug`: the criterion states the intent, not the broken case. Report each bug to the user. The outcome is that the intent is kept and the bug is reported.
- `accidental`: write no criterion. The outcome is that the behaviour is not kept.
- `ambiguous`: ask all of them in one round of the question tool of the host, before you write `plan.md`. Follow `references/grill.md`. The outcome is the answer of the user, and this record replaces the grill form `<question>: <answer>`.
2. `planning`: on Claude, compare the session model with the model of the `lead` role in the `models:` line. When they differ, tell the user to run `/model` to switch, and continue: it is guidance, not a deny. Then write `plan.md` in the run folder. `harness plan --help` gives the format. Put each open decision under `## Open questions`, or `- none`. Write each diagram through `harness diagram`.
- Run `harness plan check`. It prints an advisor line from the plan complexity, then one line for each wave of tasks. The wave lines print only for a clean single-run plan.
- On `advisor: on, model <m>`, with or without the text `(light track, risky path)`, start the `advisor` agent, with the `model` field set to `<m>`, the model that the line names. It reads `plan.md` and the code that the plan touches. Fix `plan.md` for each finding that you accept.
- On `advisor: off`, start no advisor. Decide each open point yourself and record each decision under `## Decisions` in `plan.md`.
- Then run `harness run plan`.
3. `awaiting_approval`: show the plan. `harness run plan` wrote the page `plan.html` in the run folder, and it follows the run. The run opens the page in the browser on entering `awaiting_approval`. After each edit of `plan.md`, run `harness plan view` and ask the user to reload the page. Grill the open questions in rounds with the question tool of the host: `references/grill.md`. When `## Open questions` holds only `- none`, ask the `Plan` question with the options `Approve` (first) and `Change the plan`, then stop until the user answers.
- On `Approve`, the hook records the approval for the current `plan.md`. Run `harness run approve`.
- On `Change the plan`, ask what to change, edit `plan.md`, run `harness plan view`, and ask the `Plan` question again.
- `harness run approve` refuses with no record, after an edit of `plan.md`, on a plan check problem, and on an open question. Only when the user names a model for this run, run `harness run approve --by <model> --reason "<one line>"`.
4. `working`: you are the driver. You do not write the code of a task. `harness plan check` gives the waves (only for a clean single-run plan) and the model of each task.
- A light-track run can use `sonnet` as the lead. `harness plan check` prints `advisor: off (light track)` on a light track. The text `(light track, risky path)` on the `on` line marks a light-track plan with a guard, security or hook path. On a light track, the lead does not ask a `sonnet` session to switch.
- For each wave, start one `worker` agent for each task, in the background, with the `model` field set to the `Model` of the task. The model must be in the `worker` role list. Start the tasks of a wave in parallel when their owned files do not overlap. Give each worker, also a fix worker, the path of `plan.md`. Give each worker, also a fix worker and a self-check worker, the full path of the harness binary.
- Use low effort for a haiku task that is mundane: docs, a rename or a config change.
- Check each result: the owned files (`git diff --stat`), the red and green lines, and `harness verify`.
- Read a diff with `git diff --stat` first, then only the files that you check. Read a long output through `tail`, with `set -o pipefail` so that the exit code stays. Example: `set -o pipefail; go test ./... 2>&1 | tail -n 40`.
- Send a failed task once to a new `worker` agent, with the same `model` field. A plan conflict in the report goes to the lead in place of a new worker. The lead trims the task or amends the plan.
- Commit in plan order, one commit for each task.
- Run `harness verify --commits <default branch>` in the foreground, with a Bash timeout of 600000 ms (600 s). When it does not fit in 600 s, run it in the background.
- Before the self-check, run `harness review panel`. When it prints `light panel:`, the lead runs no self-check worker. The lead writes `self-check.md` itself from the output of `harness verify --commits <default branch>`, in the format below with the `Head` line. Then it runs plain `harness verify` and `harness run review`. Skip only the "Self-check" item below and its "The worker writes" item.
- On a light panel, the lead fills each check row of `self-check.md` from the verify output. For a row that verify cannot judge, such as `spec-scope` or `standards-judgement`, write `pass` with the evidence "light panel: the reviewer checks it". It writes one proof row for each criterion of `## Acceptance criteria`.
- Self-check: start one `worker` agent with the `model` field set to the first model of the `worker` role. It reads `git diff <default branch>...HEAD`, the lens checklists of `agents/reviewer.md` and `plan.md`. It runs each proof command of `## Acceptance criteria`. A `|` in a proof command is written `\|` in the proof table.
- The worker writes `self-check.md` in the run folder, in this format. The results are `pass`, `fixed` or `open`. The proof table has one row for each criterion.
```text
# Self-check
Head: <full sha of HEAD>
| Check | Result | Evidence |
|-------|--------|----------|
| spec-proof | pass | <criterion or file:line> |
| spec-scope | pass | <criterion or file:line> |
| spec-text | pass | <criterion or file:line> |
| standards-rules | pass | <criterion or file:line> |
| standards-judgement | pass | <criterion or file:line> |
| # | Proof | Exit |
|---|-------|------|
| 1 | `<proof command>` | 0 |
```
- `spec-proof`: each criterion has its code, and its proof fails without the code.
- `spec-scope`: each task changed only its owned files, with no missing or partial requirement and no scope creep.
- `spec-text`: each changed doc sentence agrees with the code and with the other docs.
- `standards-rules`: the diff follows `CLAUDE.md`, `AGENTS.md`, `CONTEXT.md`, the ADRs in `docs/adr/` and the lint rules.
- `standards-judgement`: edge cases, error paths, leaks, dead code and code smells.
- The worker does not change a value, a name or a limit that `plan.md` sets. When a fix needs one, the worker writes `open` with `plan conflict:` in the evidence. The lead takes each such row, and trims the fix or amends the plan.
- The worker fixes each miss test first. The lead commits each fix with `git commit --fixup=<sha>`, rebases with autosquash, and runs `harness verify --commits <default branch>` again. Each other `open` check goes to a fix worker.
- Run plain `harness verify` after the last commit. It records the proofs that `harness run review` needs, and `verify --commits` does not.
- Then the lead sets `Head` to the new `HEAD` and runs `harness run review`. The command refuses a run folder with no `self-check.md` or no `Head: <sha>` line.
- After `harness run rework`, read `references/reviewing.md` and do its Fix and Re-review steps.
5. `reviewing`: on entering `reviewing`, and after `harness run rework`, read `references/reviewing.md` and follow it.
6. `shipping`: run `harness run learn` and follow `references/learning.md`, then start the `pr-open` skill. It pushes the branch, runs `harness pr policy` and opens a draft or a ready pull request by that policy, with the body Why, What and How. With `merge: user`, the user merges. With `draft: optional` and `merge: agent`, the agent merges after the checks pass. In every other case, the user merges. Then run `harness run wait --pr <url>`, then `harness run report`, then `harness run done --pr <url>`.
- The turn may stop while the run waits on the merge. After a `resume` into `shipping`, run the wait again.
A plan with only `docs` commits and no open question skips the approval: `harness run plan` moves it to `working`.
To change the approved plan, edit `plan.md` first, then run `harness run amend`. When approval is needed, the run goes to `awaiting_approval`: ask the `Plan` question again, then run `harness run approve`. With `run.approval: false`, the run goes to `working` with no `Plan` answer.
A kept-structure amend needs a recorded approval and a kept structure. A docs-only amend needs a plan that took the docs-only waiver, with no recorded approval. Both skip the approval only in `working` with no live review round. Any other amend needs the `Plan` answer. `harness run plan` never follows an amend.
A kept-structure amend may change the prose of Goal, Decisions, Test first and DoD, the tree fences and the test paths. See `references/plan-template.md` for the rule.
## Guard
The guard denies some calls, for example a merge by default, a forced push, a read of a secret or a push before `verify --commits`. Read the deny reason and do the step that it names. Do not work around a deny with another command.
On Codex, the agent call has no `model` field. Leave it out: the guard lets the call pass.
Pliki w paczce (6)
- SKILL.md 13 KB
- harness_test.go 14 KB
- references/grill.md 4 KB
- references/learning.md 2 KB
- references/plan-template.md 10 KB
- references/reviewing.md 7 KB
Wersje
| Repozytorium | Wynik | Licencja |
|---|---|---|
| Ta strona · 90p-labs/harness | 100 | MIT |
| ericrisco/rsc-harness | 100 | MIT |
| AbdullahYA1/claude-codex-harness | 100 | MIT |
| mhmdsalameh/ai-native-harness | 100 | MIT |
| kcenon/claude-config | 100 | BSD-3-Clause |
| even-realities/everything-evenhub | 100 | MIT |
| SensorsIot/Universal-ESP32-Workbench | 100 | MIT |
| HikaruEgashira/agent-skills | 100 | Apache-2.0 |
| stellarlinkco/myclaude | 100 | AGPL-3.0 |
Migawka bazy z 13.11.2026 · wersja paczki 678fa4ff3b5c (skrót SHA-256 całej paczki)
Pobrania w ostatnich 30 dniach: 0 · ranking
Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.
Podobne skille
- 90harness-setup
Inicjalizuje albo aktualizuje konfigurację Oh My Harness w projekcie Codex. - 100harness-setup
Inicjuje i konfiguruje Harness w projekcie: CI, pamięć, przepływ duo i Codex, przy zakładaniu nowego projektu lub dodawaniu konfiguracji Harness. - 100agentic-harness-engineering
Ocenia i audytuje strukturę przestrzeni roboczej agenta według specyfikacji HARNESS.md i prowadzi jej poprawę na podstawie dowodów. - 100omh-loop
Uruchamia, kontynuuje lub zatrzymuje autonomiczną pętlę Oh My Harness sterowaną specyfikacją w Codex. - 95harness-docs
Opisuje instalację, katalog wtyczek i konfigurację Harness Kit, w tym pliki SKILL.md i harness.yaml oraz integracje z narzędziami. - 90codex-delegate
Deleguje zadania kodowe: Codex przygotowuje prompt, a osobna sesja wykonuje i weryfikuje zmianę.