execute
/execute
Implements a plan step by step, verifies named tests or explicit manual scenarios, enforces the product-behavior guardrail and five-attempt retry limit, and completes with the plan's automated regression gate or validated manual evidence. Use when executing a plan that plan-the-work already wrote.
- Author
- insideout-ai ↗
- Repository
- make-it-work ↗
- Licence
- MIT
- Last repository change
- 12.11.2026
Assessment and security
- Files in this package
- 7
- Scripts
- 4
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 12.11.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
- 4 scripts in this package. Review them before installing, as Claude may execute them.
Scripts: scripts/plan-status.mjs, scripts/plan-status.test.mjs, scripts/step-control.mjs, scripts/step-control.test.mjs
What it does and when to use it
Implements a plan step by step, verifies named tests or explicit manual scenarios, enforces the product-behavior guardrail and five-attempt retry limit, and completes with the plan's automated regression gate or validated manual evidence. Use when executing a plan that plan-the-work already wrote.
Original author description
Implements a plan step by step, verifies named tests or explicit manual scenarios, enforces the product-behavior guardrail and five-attempt retry limit, and completes with the plan's automated regression gate or validated manual evidence. Use when executing a plan that plan-the-work already wrote.
How it works
- Usage
- Autopilot Mode
- Phase 0 — Locate the plan and resolve execution context
- Phase 1 — Guardrail and retry-limit policy
- Phase 2 — Work through the plan's steps
- Phase 3 — Guardrail / retry-limit stop handling
- Phase 4 — Completion gate
- Phase 5 — Final report
- When run by implement
SKILL.md preview
---
name: execute
description: "Implements a plan step by step, verifies named tests or explicit manual scenarios, enforces the product-behavior guardrail and five-attempt retry limit, and completes with the plan's automated regression gate or validated manual evidence. Use when executing a plan that plan-the-work already wrote."
disable-model-invocation: true
---
# Execute
## Usage
```
/make-it-work:execute [TICKET-ID | path/to/plan.md] [--autopilot]
```
- Pass a ticket key (e.g. `PROJ-123`), an explicit path to a plan file, or nothing (the skill derives the key from the current branch). `--autopilot` may appear anywhere in the invocation — strip it from the argument before Phase 0 point 2's ticket/path resolution runs, so it is never mistaken for the ticket key or the plan path.
- **No `--autopilot`** — interactive. Every `AskUserQuestion` and checkpoint below pauses for a human, exactly as documented.
- **`--autopilot`** — unattended. At every interactive point below, apply the Autopilot Mode policy instead of pausing.
## Autopilot Mode
When invoked with `--autopilot`, still **construct** every question/options payload exactly as the interactive path below would — option counts, labels, and the `(Recommended)` rule all still apply and get exercised on every run — just don't call `AskUserQuestion` or wait at a checkpoint. Auto-resolve per the table below instead.
**Hard-stop exception:** no destructive action exists in this skill — `execute` never deletes or overwrites user content beyond the plan file's own `## Execution Status` bookkeeping, and it never runs `git commit` (Phase 1's "Never git-commit" rule, unaffected by `--autopilot`). Five sites nonetheless remain unconditional stops under `--autopilot`, identical to the interactive path, because autopilot cannot safely infer an answer for any of them — these are missing-input or malformed-plan stops, not a destructive-action analog, but are listed here for completeness per this section's own disclosure requirement:
- Phase 0 point 1's ambiguous repo/workspace selection among unrelated clones with no unifying doc — there is no way to infer which of several unrelated repos is the right one, so this stays a stop under both modes.
- Phase 0 point 1's "Could not identify the project root" message.
- Phase 0 point 2's underivable `<TICKET>` key / plan path.
- Phase 0 point 2's "No plan found at `make-it-work/<TICKET>/<TICKET>-plan.md`..." message.
- Phase 2's inconsistent dependency ordering (a step's `**Depends on:**` line names a later-numbered step) — the plan itself is malformed; autopilot does not attempt to reorder execution to satisfy it.
Separately, the Execution Mode question's "review the plan first" alternative (Phase 0 point 3) is never auto-selected under `--autopilot` — autopilot always resolves Mode via the `(Recommended)`-label rule below instead, so in practice this path is structurally unreachable under autopilot, the same way `go-deep`'s destructive "Run fresh onboarding" path becomes unreachable once its own Recommended option is always chosen. If some caller nonetheless forces a pause here under `--autopilot`, do not resolve it by treating silence as "review the plan first" — stop and require a human. The fresh-Inline-choice follow-up question (Phase 0 point 3) is similarly unreachable under `--autopilot` — Mode never freshly resolves to Inline there, so that specific follow-up never fires from a fresh choice. It is reachable, and resolved, only via the two sites the table below names separately: the Phase 0 legacy backfill (`inline-pause-mode-backfill`, for a plan already recording `Inline` from an earlier interactive run) and the Phase 2 per-step override (`inline-step-pause-override`, for a plan that also already recorded "Stop after each step").
**Not autopilot-governed at all:** the guardrail and the 5-attempt retry limit (Phase 1) are correctness halts built into this skill, not interactive points — they fire identically with or without `--autopilot`, and when either fires the run ends with Phase 3's fixed report exactly as documented; autopilot never retries further, guesses an answer, or suppresses the report. Likewise, `run-regression`'s own stop-and-ask (e.g. "Could not find a full-suite test command for `<repo>`...") is not resolved here either — Phase 4 treats it as a non-interactive FAIL-equivalent stop. When this skill itself runs with `--autopilot`, it forwards that flag to `run-regression` as well so the nested run is auditable. `execute` makes one `run-regression` call whose explicit argument — `full`, or the mixed token string Phase 4 builds — plus the forwarded `--autopilot` means no mode-selection prompt is reached.
**Decision log:** write `make-it-work/<TICKET>/execute-autopilot-log.jsonl` at repo root. Initialize it fresh (truncate/overwrite) the first time this run resolves any site — it describes this run only, never a prior one — then **append one line each time a further site is resolved later in the same run**: do not write it once near the start and leave it there unchanged. Subagent-Driven mode's per-step continuation (Phase 2) is no longer a distinct autopilot resolution — it behaves identically with or without `--autopilot` (see Phase 2's own Dispatch mechanics) — so it produces no log line of its own. Two newer sites can still produce lines over the course of a run: a resumed `Inline`-mode plan missing the `**Inline pause mode:**` line produces exactly one `inline-pause-mode-backfill` line (Phase 0, once); and an `Inline` + `Stop after each step` plan run under `--autopilot` produces one `inline-step-pause-override` line *per step* (Phase 2, since the override fires every time it actually overrides a recorded pause) — both described in the table below. If a run ends up resolving zero sites at all (e.g. Mode was already recorded with its `**Inline pause mode:**` line intact and reading 'Run straight through,' or Mode was freshly recorded as Subagent-Driven and every step completed normally), the file is still written, with zero lines. Field shape follows the shared schema in `docs/autopilot-log-schema.md` — this skill uses only `"askUserQuestion"` and `"checkpoint"` (it has no non-enumerable `open_text` sites), `multiSelect` is always `false` (every question this skill asks is single-select), so `chosen` is only ever a label or `null` — never an array or free text. Every line also still includes `rationale` (one sentence), per the shared schema's core fields. `phase` examples: `"Phase 0"`, `"Phase 2"`. `site` examples: `"mode-choice"`, `"inline-pause-mode-backfill"`, `"inline-step-pause-override"`.
When Bash is permitted, use the shared writer in `docs/autopilot-log-schema.md` with `--ticket "<TICKET>"` for this log: `write` at the first resolved site, `append` for later sites, or `init` if no site resolves. Invoke each writer command in its own Bash tool call, separately from any call to the plan-status script. If Bash is unavailable, use Write/Edit for the same log contract. Do not invoke the Bash writer after a Write/Edit denial or try another path to bypass a denied log write; report the denial while continuing the otherwise valid execution workflow.
A hard-stop site that actually fires is still logged, per the shared schema's `chosen: null` convention — this is distinct from a site that's merely moot this run: a site skipped because Mode was already recorded, or a step/phase never reached because an earlier stop condition halted the plan before reaching it, is not logged at all.
**Resolution table** (one row per interactive site, in the order they appear):
| Phase | Site | `kind` | Autopilot resolution |
|---|---|---|---|
| Phase 0 | ambiguous repo/workspace selection (unrelated clones, no unifying doc) | `checkpoint` | Unconditional stop, unaffected by autopilot — see Hard-stop exception above. |
| Phase 0 | "Could not identify the project root" | `checkpoint` | Unconditional stop, unaffected by autopilot. |
| Phase 0 | underivable `<TICKET>` key / plan path | `checkpoint` | Unconditional stop, unaffected by autopilot. |
| Phase 0 | "No plan found at `make-it-work/<TICKET>/<TICKET>-plan.md`..." | `checkpoint` | Unconditional stop, unaffected by autopilot. |
| Phase 0 | Execution Mode choice (`AskUserQuestion`, `multiSelect: false`, 2 options: Subagent-Driven / Inline) | `askUserQuestion` | Choose the option labeled `(Recommended)` — today "Subagent-Driven". The "review the plan first" free-text alternative is never auto-selected (hard-stop exception above) — it is not one of the 2 enumerated options to begin with. Write the plan file's `## Execution Status → Mode` line exactly as the chosen branch already specifies. |
| Phase 0 | Mode already recorded from a prior run | — | Not a decision site this run — proceed under the recorded mode without asking, and log nothing for it. **Exception:** when the recorded mode is Inline and its `**Inline pause mode:**` line is missing, this is not this row's case at all — see the `inline-pause-mode-backfill` row immediately below instead. |
| Phase 0 | Mode already recorded as Inline, but `**Inline pause mode:**` line is missing (site slug: `inline-pause-mode-backfill`) | `askUserQuestion` | Choose the option labeled `(Recommended)` — "Run straight through". Write the `**Inline pause mode:**` line with that value, and log it. This site *is* reachable under `--autopilot`, unlike a fresh Inline choice (Mode never freshly resolves to Inline under autopilot) — a plan can already carry `Mode: Inline` from an earlier interactive run before being resumed under `--autopilot` later. |
| Phase 2 | a step's `**Depends on:**` line names a later-numbered step | `checkpoint` | Unconditional stop, unaffected by autopilot — see Hard-stop exception above. The plan's dependency ordering is inconsistent; name the two step numbers involved rather than guessing at a fix. |
| Phase 2 (Inline mode, "Stop after each step" recorded) | the per-step pause that mode would otherwise take (site slug: `inline-step-pause-override`) | `checkpoint` | Auto-confirm: relay the step's outcome to the user as chat text, append one `inline-step-pause-override` line to the decision log for this step, then continue to the next step's implementation within that same response (or proceed to Phase 3/4 if this was the last step, or a stop condition fired), without ending the turn to wait for a reply — identical reasoning to Subagent-Driven's own unconditional non-pause. This fires on every step of such a run, not once; a plan recording "Run straight through" never reaches this row at all, since there is no pause to override. |
Subagent-Driven mode's per-step continuation is no longer listed above because it is no longer an autopilot-specific resolution — Phase 2's own Dispatch mechanics now relay-and-continue automatically under interactive use too, identically with or without `--autopilot`. Nothing is logged for it.
At the end of an autopilot run that reaches a terminal report (Phase 3's report, Phase 4's FAIL stop, or Phase 5's success report), print a short human-readable summary of every auto-resolved decision and the log file's path, so someone can audit the run afterward.
## Phase 0 — Locate the plan and resolve execution context
**Controller-enabled runs:** When the supplied implement state has `controller_version: 1`, read [references/step-control.md](references/step-control.md). Its required helper replaces manual retry counting, next-step/batch selection, shared evidence writes and direct Progress completion below. The orchestrator completes steps from returned actual evidence; subagents do not write shared Progress/ledger files in this path. Other step semantics, guardrail reasoning and user choices remain unchanged.
For those runs, choose Mode through implement's `execution-mode` controller event (see `../implement/references/controller.md`), instead of separately calling plan-status set-mode and logging a generic decision. Supply `mode`, explicit user provenance or the permitted autonomous default, and `pause_mode` for Inline. The event persists the plan setting and state/audit decision before dispatch. Standalone execution retains plan-status mode selection.
1. **Repo/workspace detection** — reuse `plan-the-work`'s Step 1a logic verbatim to decide whether this is a **single repo** or a **coordinated multi-repo workspace**, since it determines which repo's `Affected Code` table (and, later, where each repo's test commands come from — its `.claude/skills/test-strategy/SKILL.md` when present) this run applies to. The distinction is not "does the parent hold other repos" — a bare folder of unrelated clones is not a workspace. It is "are these repos documented as one system": a **workspace-root orientation file** (a top-level `CLAUDE.md` / service map describing the sibling repos and how they call each other) is the signal that turns a folder of repos into a workspace.
- **`.git` exists here.** This repo is a project root. Then:
- If the **parent** holds a workspace-root orientation file that describes this repo as one service among siblings → you are inside one service of a multi-repo workspace; the **workspace root** is the parent (`..`).
- Otherwise → **single-repo project**, root is here — even if the parent happens to contain other, unrelated repos.
- **No `.git` here, but subdirectories have their own `.git`.** If a workspace-root orientation file ties them together → multi-repo workspace, root is here. If they are just unrelated clones with no unifying doc → ask the user which repo (or workspace) to execute against, rather than guessing (autopilot: see Autopilot Mode — this is an unconditional stop).
- **None of these resolve** → tell the user: "Could not identify the project root. Please launch from the repo root, a service subdirectory, or the workspace root." and stop (autopilot: see Autopilot Mode — this is an unconditional stop).
All paths below are relative to the root identified here. In a single-repo project, "each affected repo" simply means the one repo. When unsure between single and multi, prefer single-repo.
2. **Locate the plan** — resolve the plan file from the invocation argument, adapting `plan-the-work`'s Step 1b spec-resolution logic to `-plan.md` files instead of `-spec.md` files:
- **If the argument is an explicit path to a file**, use it directly and skip the rest of this resolution.
- **Otherwise, determine the `<TICKET>` key:**
- If the argument looks like a ticket key, use it.
- If the argument is empty, derive the key from `git branch --show-current` in the current (or most recently modified) repo, e.g. `feature/PROJ-123-add-x` → `PROJ-123`.
- If no argument was given and no key can be derived from the branch (e.g. on `main` or a branch that doesn't encode a key), do not proceed with an undefined `<TICKET>`: ask the user for the ticket key or an explicit plan path, and stop until they answer (autopilot: see Autopilot Mode — this is an unconditional stop).
- Once a `<TICKET>` is known, resolve `make-it-work/<TICKET>/<TICKET>-plan.md`. If it does not exist, tell the user: "No plan found at `make-it-work/<TICKET>/<TICKET>-plan.md`. Run `/make-it-work:plan-the-work` first." and stop (autopilot: see Autopilot Mode — this is an unconditional stop).
- Read the resolved plan file in full before proceeding. If it has a concrete `## Verification Policy` table, read `<base>/references/verification-policy.md` and validate it before making changes. Its explicit gate/evidence rules replace the legacy gate selection below; retry, guardrail, ordering and Progress rules still apply.
3. **Resolve Execution Status → Mode** — read the plan file's `## Execution Status → Mode` line.
- **If it reads "Not yet chosen"**, ask the user to choose, before doing anything else — even if you were only handed this file with no memory of it being created — using the same two options `plan-the-work`'s own Step 6 offers. Call `AskUserQuestion` with `multiSelect: false` and exactly these two options (autopilot: see Autopilot Mode):
1. `{ label: "Subagent-Driven (Recommended)", description: "Dispatch a fresh subagent per step (via the Agent tool), reviewed between steps. Best for complex multi-repo plans; keeps each step's context clean." }`
2. `{ label: "Inline Execution", description: "Execute steps in this session with a checkpoint after each step's Verify." }`
The question text itself may also invite reviewing the plan first ("Which approach? (or: review the plan first, then decide)") — this is a free-text alternative reply the user can give instead of picking an option, not a third enumerated option in the `AskUserQuestion` call.
- If the user picks **Subagent-Driven**, run the `set-mode --mode subagent-driven` command below; it replaces the "Not yet chosen" line and its two bullet options with `**Mode:** Subagent-Driven — dispatch a fresh subagent per step (via the Agent tool), reviewed between steps.` Then proceed to point 4.
- If the user picks **Inline**, run `set-mode --mode inline` below; it replaces that same block with `**Mode:** Inline — execute steps in this session, checkpointed after each step's Verify.` Then ask one follow-up `AskUserQuestion` (`multiSelect: false`): *'Inline mode: stop after each step for review, or run straight through?'*, with exactly these two options: `{ label: "Run straight through (Recommended)", description: "No pause between steps — the same behavior Inline already has today." }` and `{ label: "Stop after each step", description: "Relay each step's outcome and wait for your go-ahead before starting the next one." }`. Run the matching `set-pause` command below; it inserts the chosen pause line immediately after `**Mode:**`.
- If the user asks to review the plan first, stop here and wait — write nothing back until they come back with one of the two choices above (autopilot: see Autopilot Mode — never auto-selected).
- **If a mode is already recorded** (the line already reads `Subagent-Driven` or `Inline` rather than "Not yet chosen" — set by a prior `plan-the-work` or `execute` run), proceed under that mode without asking again (autopilot: nothing to resolve or log here when Mode is Subagent-Driven, or when Mode is Inline with its pause-mode line already present — see the one exception immediately below, and Autopilot Mode). When the recorded mode is Inline, also check for an existing `**Inline pause mode:**` line immediately after it. If present, proceed under that stored choice without asking again — same treatment as Mode itself. **If absent** (a plan recorded `Mode: Inline` before this line existed): this is a newly-added decision point being resolved for the first time on an existing plan, not a fresh Inline choice — ask the same follow-up question as above before proceeding to point 4 (autopilot: see Autopilot Mode — this specific site, named `inline-pause-mode-backfill`, auto-resolves to the Recommended default rather than stopping, since it is reachable under `--autopilot` whenever a plan already recorded `Inline` from an earlier **interactive** run).
4. **Resolve Progress / resume point** — parse the plan file's `## Execution Status → Progress` line ("Step N of M complete").
- First run `node "<base>/../../scripts/validate-plan.mjs" steps --plan "<plan path>"`; invalid numbering, total or dependencies stop execution before any dispatch. This checks legacy plans without imposing newly added sections.
- If `N` equals `M`, every implementation/test step is already done — skip directly to Phase 4 (the completion gate); only the gate remains, or needs re-running.
- Otherwise, resume from step `N+1` once Phase 2 begins working through the plan's steps.
**Execution Status bookkeeping is scripted.** Resolve `<base>` to this skill's directory. Use `node "<base>/scripts/plan-status.mjs" inspect --plan "<plan path>"` to read Mode, Inline pause mode, completed steps, and total steps as JSON. For every later write to this section, invoke the same script rather than editing Markdown by hand:
| When | Command after `node "<base>/scripts/plan-status.mjs"` |
| --- | --- |
| Mode choice | `set-mode --plan "<plan path>" --mode subagent-driven` or `--mode inline` |
| Inline pause choice or legacy backfill | `set-pause --plan "<plan path>" --pause straight-through` or `--pause after-each-step` |
| One step's Verify passed | `complete-step --plan "<plan path>" --step <N>` |
| Every member of a real concurrent batch passed | `complete-batch --plan "<plan path>" --through <highest step number>` |
| A mistaken Progress claim must be rolled back | `correct-progress --plan "<plan path>" --completed <last verified step>` |
The script changes only `## Execution Status`, writes atomically, and rejects skipped steps, conflicting choices, malformed status, or an invalid correction. Its command does **not** decide whether Verify passed, whether a batch was eligible, or whether a rollback is justified; apply this skill's rules first. A nonzero exit leaves the plan unchanged: investigate the discrepancy before dispatching the next step. When invoked by `implement` with a dashboard state path, append `--dashboard-state "<state path>"` to `complete-step` or `complete-batch`; the command then renders the dashboard as part of that successful Progress update. If the option is omitted, the command also finds and refreshes a matching active Execute dashboard beside the plan. Pass the same script path, command, and dashboard state path to a single-step subagent when it owns the Progress write; batch subagents still never write Progress themselves.
Invoke each status-script command in its own Bash tool call. Do not join it with an autopilot decision-log write: a denied log write must not prevent the status update from running. If the log write is denied, handle that separately; it must not suppress a valid plan-status update.
5. **Re-derive the recommended executor tier** — `plan-the-work`'s own Step 6 computes a "Recommended executor tier" (low/standard/high) but only prints it in chat; it is not persisted as a field in the plan file. Re-derive it yourself, directly against the plan file Phase 0 point 2 resolved, using the exact same criteria `plan-the-work`'s Step 6 documents:
- **low** — mechanical, few files, additive, no data-migration / state-transition / security risk, steps fully specified.
- **standard** — moderate: a few domains or repos, some risk, mostly-specified steps.
- **high** — multiple repos with logic changes, security / state transitions / data migrations / cross-service flows, or steps that still need judgment during execution.
Read this off the plan file's own sections only — no new investigation of the target codebase: the **Affected Code** table (repo/file count), the **Risks** table (severity surface — the Overall risk values), and the **Steps** (count, and whether they read as additive or invasive). Under **Subagent-Driven** mode, pass a model matching this tier as the `model` argument on every subsequent `Agent` dispatch in Phase 2 (Work through the plan's steps), so every step runs at the recommended level. Under **Inline** mode, the current session's model can't be changed programmatically — note the tier for the user, but take no further action here.
## Phase 1 — Guardrail and retry-limit policy
Every step in Phase 2 applies the two stop conditions defined here, plus the one standing rule at the end of this section. Do not proceed past either stop condition on your own judgment — both hand control to Phase 3, which owns how the halt is reported.
### Diagnosis before a corrective attempt
Before changing code to address an observed failed check, record what failed (expected versus observed), the actual evidence and affected path, the suspected cause, the bounded next change, and the observation that would support or reject it. Apply the product-behavior guardrail below before choosing a correction. This applies to the first correction after failure and every later correction, in both execution modes; ordinary initial implementation and read-only investigation do not need an attempt record.
If the cause is unknown, say so and run a targeted diagnostic check that can distinguish plausible causes before editing. Read-only probes and test invocations do not consume fix attempts. After an unsuccessful correction, also record what its result taught you and why the next change is justified by new evidence or a revised explanation. Rewording the same unsuccessful patch is not a diagnosis. If no supported correction is available, report the blocker through the existing execution-failure stop path rather than spending the remaining budget on guesses; requirements uncertainty still uses the guardrail.
For controller-enabled runs, save this through `begin-attempt` per [Durable step control](references/step-control.md) before editing; a failed checkpoint blocks that correction. The helper retains the diagnosis with the attempt and writes an audit result when a workflow state is available. Standalone/legacy runs retain the same information in their existing execution notes and include it in any stop report. Pass this requirement to step subagents with the retry policy. A script checks that the record exists, not whether its causal explanation is correct.
### Retry limit
A step's own named test(s) — the `**Tests:**` field's command(s), each run from its own repo root, or (when that repo has no test-strategy location and no configured framework) the corresponding row(s) in the plan's shared `## Test Plan` table — are that step's sole success criterion. A Tests line recorded as `not runnable locally` is never run, retried, or counted as an attempt; it is reported in the step's checkpoint instead. When a fix attempt is made and the test(s) are re-run:
- Count every attempt to change the code in pursuit of making that step's failing test(s) pass as one "attempt," starting from 1.
- If the test(s) still fail after **5** such attempts, stop working on that step immediately. Do not make a 6th attempt, and do not fall back to a "best effort, moving on anyway" outcome — a step whose test still fails is not done, regardless of how close the 5th attempt looked.
- Reaching the retry limit is a distinct stop condition from the guardrail below: it fires when the code itself simply isn't passing the test after genuine fix attempts, with no indication the test or the plan's intent is in question. If, during those attempts, it becomes clear the disagreement is actually about what the test (or the code) *should* be doing rather than a plain bug, stop counting retries and apply the guardrail below instead — the two conditions are not both charged against the same step for the same discrepancy.
### Guardrail (test bug vs. product-behavior question)
This check applies specifically when fixing a step's failing test appears to require changing the test itself (its assertions, fixtures, or setup) rather than only the implementation code. Work through it in this order, every time:
1. **First, check for a genuine test bug — but never on pattern-matching alone.** A test assertion that merely *looks* mechanically wrong (an apparently off-by-one or inverted value, a suspicious-looking fixture) is not yet confirmed as a genuine test bug — it only becomes one once it's actually checked against what the plan's own `## Goal`/`## Requirement Summary` document as the intended behavior for this case (the same source point 2 below consults). Before concluding "this is just a mechanical bug in the test" and fixing it, briefly confirm the plan's documented intent doesn't actually match what the test currently asserts — if it does match (the test was "wrong-looking" but is in fact what's documented), this is not a mechanical bug at all; skip straight to point 2's classification instead of fixing it here. Only once that check comes back clean — the documented intent doesn't call for what the test currently asserts, and the test's flaw is narrow and mechanical (a bad assertion, e.g. it asserts the wrong value, checks the wrong field, or has an off-by-one/inverted condition; or a wrong fixture, e.g. stale test data, a setup step that doesn't match what the step under test actually needs) — fix the test, and never in a way that weakens or deletes what the test was actually trying to verify (e.g. do not loosen an assertion, delete a check, or broaden a match just to make it pass). Then continue implementing the step normally: re-run the corrected test and proceed as usual (including still being subject to the retry limit above if further fix attempts are needed).
2. **If it is not a mechanical test bug**, apply this operationalized check to classify the discrepancy — do not skip straight to a guess:
- Locate what the plan's own `## Goal` and `## Requirement Summary` sections say about the behavior in question. If those sections are silent or ambiguous about this specific behavior, also read the spec's Acceptance Criteria they trace to (the spec file's path is given in the plan's own header, e.g. `> **Spec:** ...`) before drawing any conclusion — do not stop at "the plan doesn't say" without checking the spec it was built from.
- Compare three things: (i) what the failing test expects, (ii) what the code currently does, and (iii) what the Goal/Requirement Summary (and, where consulted, the spec's Acceptance Criteria) documents as the intended behavior.
- **If the code's behavior contradicts that documented intent, while the test's expectation matches it** — this is an ordinary bug, not a product-behavior question: the code is the side that's wrong. Fix the code; leave the test's expectation as it is. Then continue implementing the step as normal.
- **If the test's own expectation contradicts that documented intent** — e.g. the test asserts something the Goal/Requirement Summary (or the spec's AC) explicitly says should not happen, or asserts the opposite of what an AC scenario describes — this is a real product-behavior question, not a test bug. Do not silently rewrite the test to match the code, and do not silently change the code to match the test's expectation either. Stop and hand off to Phase 3.
- **If neither the test nor the code looks wrong relative to what's documented (having checked both the plan and, where the plan was silent, the spec's AC), yet the two still disagree with each other** — this, too, is a real product-behavior question. Stop and hand off to Phase 3.
- **Whenever this comparison is genuinely uncertain** — the documented intent (plan and, where consulted, spec) is ambiguous, silent on the specific case, or could reasonably be read either way — resolve the uncertainty toward treating it as a real product-behavior question, never toward picking a side and continuing. It is always acceptable to hand off to Phase 3 when unsure; it is never acceptable to guess and keep going.
In short: the classification hinges entirely on matching each side (test, code) against the plan's (and, when needed, the spec's) own documented intent, not on which side is more convenient to change, which side was written first, or which side is easier to fix.
### Halt scope
Both stop conditions above — the retry limit and the guardrail — halt the **entire remaining plan**, not only the current step or that step's dependents. Once either condition fires:
- Do not attempt any later step in the plan, including one that has no dependency at all on the flagged/stalled step and could technically run on its own.
- Do not continue working step-by-step on the theory that the flagged step can be revisited later — the whole plan pauses in place, and only resumes via the handling Phase 3 defines (a fresh decision from the user).
- This applies identically under both execution modes: under Subagent-Driven mode, do not dispatch the next step's subagent once a stop condition has fired inside the current step's subagent; under Inline mode, do not proceed to the next step's implementation in this same session.
### Never git-commit
`execute` never runs `git commit` on the user's behalf, at any point in this process:
- Not after any individual step's tests turn green.
- Not after the guardrail or retry-limit stop conditions fire.
- Not at the end of the plan, and not even after the completion gate (Phase 4) passes.
All implemented code, fixed tests, and any other changes made while working through the plan are left uncommitted in the working tree throughout — for the user to review and commit themselves, on their own schedule and in whatever grouping they choose. This rule governs every step in Phase 2 and every phase of this skill; nothing later in this skill overrides it.
## Phase 2 — Work through the plan's steps
This phase does the actual implementation work. It drives the plan forward from the resume point Phase 0 point 4 established, through the plan's own **last** step, **inclusive**.
### Scope: resume point through the last step, inclusive — no exceptions
The plan's `## Steps` section numbers its steps 1 through `M`, where `M` is the same `M` that appears in `## Execution Status → Progress` ("Step N of M complete"). This phase's job is not finished, and control does not pass to **Phase 4**, until step `M` itself — the highest-numbered step in the plan, whatever its own heading calls it — has been implemented, had its tests confirmed passing, and had Progress updated to read "Step M of M complete." The only way to leave this phase before that point is the early exit described in the per-step procedure below: a Phase 1 stop condition (guardrail or retry limit) firing on some step, which hands control to Phase 3 instead — never a routine step completion, and never simply reaching a step that looks like a wrap-up.
This holds regardless of what kind of step `M` is. A plan with manual verification ends with "Verify manual scenarios" (older plans may call it "Write tests"). This is a numbered execution step: perform its Test Plan walkthroughs against actual behavior, run its Verify checks, record observed evidence, and then update Progress. It cannot be silently skipped or treated as a wrap-up. For a controller run, the explicit user-waiver route in references/step-control.md may record a final manual step as skipped; it establishes no passing manual evidence and does not waive the automated completion gate. Do not claim an automated test suite passed when the step verifies manual scenarios.
Concretely: if Phase 0 point 4 determined the resume point is step `N+1`, this phase's loop begins at step `N+1` and continues, step by step, up to and including step `M`. If `N+1` already equals `M` (only the last step remains), this phase still runs — it performs step `M` itself, the same as any other step; it is never skipped just because it is also the final step. The loop only ends, successfully, once step `M`'s own Progress update ("Step M of M complete") has been written to the plan file. Ending the loop earlier — for any reason other than a Phase 1 stop condition firing — is not a valid outcome of this phase. Once Progress reads "Step M of M complete," this phase's work is done — proceed to Phase 4 (the completion gate).
### Working order: respecting each step's own dependency markers
Work through the steps in the numeric order the plan lists them. Progress is a single linear counter ("Step N of M complete"), so this loop never actually reorders steps at runtime — reordering would let a resumed run silently skip whatever was jumped ahead of. Each step's own `**Depends on:**` and `**Can run in parallel with:**` markers are honored as follows:
- Before starting any step, confirm every step named in its `**Depends on:**` line has a number less than or equal to `N` (i.e. it is already recorded as complete in Progress, either from an earlier step in this same run or from an earlier resumed run). In a well-formed plan this is always true by the time numeric order reaches that step, because a step cannot depend on a later-numbered step. If a step's `**Depends on:**` line ever names a step whose number is greater than the current step's own number, the plan itself is malformed — do not attempt to reorder execution to satisfy it; stop and tell the user the plan's dependency ordering is inconsistent (naming the two step numbers involved) rather than guessing at a fix.
- A step's `**Can run in parallel with:**` line names another step that has no ordering constraint against it: neither depends on the other, so either could validly come first. By default this still means only that the two steps' relative order is unconstrained, not that they run concurrently — take them in the plan's listed numeric order, like any other adjacent pair. **Exception — true concurrent batching, Subagent-Driven mode only, when this run was given a `dispatch order` input of `parallel`** (see `## When run by implement`'s Inputs — this never applies to a standalone run, which has no such input, or to the original plan's own steps, which always dispatch one at a time regardless): before dispatching the next not-yet-done step, compute the largest batch of contiguous, not-yet-done steps starting at the current resume point that satisfies **all four** of: (1) every step in the batch is the next contiguous not-yet-done step in numeric order (never skip ahead over an undone lower-numbered step); (2) every pair within the batch is mutually marked `**Can run in parallel with:**` each other; (3) every step's own `**Depends on:**` line is already satisfied (at or below the current Progress watermark); (4) every step's own path set — the union of its `**Files:**` line and, when present, its `**Tests:**` field's own file path(s) — is disjoint from every other batched step's own same union. This file-and-test-disjointness check is independent of, and in addition to, the plan's own marker, since that marker has only ever meant "order-unconstrained" and was never authored with true concurrency in mind; a step whose `**Files:**` line reads `none` contributes only its `**Tests:**` paths (if any) to this union, and a step with neither contributes nothing — trivially disjoint from every other step, same as it is harmless today. Any not-yet-done step that fails any of these four is dispatched alone (a batch of one), exactly as every step is dispatched today.
### Per-step procedure
For every step from the resume point through step `M`, inclusive, perform these four actions in order:
1. **Implement.** Make the code change(s) the step's own **What to do** field describes. When planned tests change, follow `<base>/../../docs/test-map-contract.md` to update their identities, evidence and relationships in the product repo's map. Save only reviewed metadata updates named in the plan, preserving user decisions; mapping work never adds/changes source/test annotations. Before the scoped completion gate inspect/reassess affected map inputs and retain unresolved portions. Touch only the files listed on that step's own **Files:** line — do not edit a file that isn't listed there, even if it seems related, and do not fold in work that belongs to a different, later step.
2. **Verify.** Run the step's **Verify** check.
- If the step has its own `**Tests:**` field (meaning the target repo has a configured test framework and `plan-the-work`'s per-step test-writing sub-phase recorded a scoped command for this step), run the exact scoped test command that field records, and confirm the specific named test(s) it identifies now pass — not merely that some tests somewhere pass. This field lists one line per in-scope repo, test-scope repos included (`<repo>: <file path(s)> [<layer>], <command>, <state>`) — run each line's command from its own repo root and confirm each one's named test(s) pass. Find that root the same way `run-regression`'s "Finding a token's repo" does: cwd's git toplevel when its basename matches `<repo>`, otherwise a same-named subdirectory of cwd, otherwise one of the workspace root Phase 0 point 1 detected. A line with no `<repo>:` prefix runs from Phase 0's root. A line whose state is `regression not runnable locally — <reason>` or `progression written — not runnable locally (<reason>)` is not run or retried: list it in the step's report/checkpoint as `not run locally — <reason>`; the step still needs its runnable lines and Verify to pass. A repo omitted from this field has no test-strategy location and no configured framework and is covered by the no-`**Tests:**` case below instead, for that repo only.
- If the step has no `**Tests:**` field (meaning that repo has no configured test framework), it has no scoped command to run. In addition to running the step's own **Verify** line as written, locate the row(s) in the plan's shared `## Test Plan` table that correspond to this step (by scenario description or by the file/command column referencing this step's own changes) and manually confirm each identified scenario behaves as that row describes. A step with no `**Tests:**` field is not exempt from verification — its corresponding Test Plan row(s) are its test, and they must be walked through and confirmed exactly as the row describes before the step counts as passing.
3. **On failure, apply Phase 1's policy before re-attempting.** If the Verify check (the scoped test command, or the manual Test Plan walkthrough) fails, apply the retry-limit and guardrail policy defined in Phase 1 — do not simply try again ad hoc. Specifically: check whether fixing the failure requires changing the test/scenario itself (triggering the guardrail's test-bug-vs-product-behavior check) or only the implementation code (counting as one retry-limit attempt); keep re-attempting only within whichever of those two policies applies, exactly as Phase 1 defines. The instant either policy's stop condition fires — the guardrail identifies a real product-behavior question, or the 5th attempt still fails — stop working on this step immediately and proceed to Phase 3. Do not attempt any later step (including one satisfying "Can run in parallel with" this one) once a stop condition has fired; Phase 1's "halt scope" rule governs here without exception.
4. **Update Progress immediately once the step passes.** As soon as this step's Verify check is confirmed passing (per point 2), update `## Execution Status → Progress` in the plan file to read "Step N of M complete" (substituting this step's own number for `N`) before doing anything else — in particular, before starting the next step's implementation. Do not batch Progress updates, and do not defer this update until later steps also finish; each step's own completion is written to the plan file the moment that step is done, so a resumed run always has an accurate resume point even if the session ends unexpectedly right after this step. **Exception — a step dispatched as part of a real batch** (more than one step, per Working order's batching exception above): this step does **not** write Progress itself at all. The orchestrating session owns writing Progress once for the whole batch, only after every batched sibling has reported, per the batch-dispatch bullet in Dispatch mechanics below — never derived from, or overwritten by, any individual batched subagent's own write. A step dispatched alone (a batch of one — the ordinary case, and every case before this item existed) is unaffected by this exception and still writes its own Progress exactly as this point already describes.
**Implement dashboard checkpoint.** When this run received an `implement` dashboard state path (see **When run by implement**), append `--dashboard-state "<dashboard state path>"` to the `plan-status.mjs complete-step` command that a single-step subagent runs, or to the orchestrator's `complete-batch` command for a real batch. The status command writes Progress and renders the dashboard in one required checkpoint; do not run a separate best-effort render afterward. If that command fails — including a renderer failure — do not relay completion, dispatch another step, or proceed to the completion gate; return `EXECUTE_STOPPED` with the exact error so `implement` can checkpoint the stop. A standalone `execute` run, and an older `implement` run which did not supply a dashboard state path, has no dashboard to refresh and omits this option.
**Report each step's start as well as completion.** Before every subagent dispatch or Inline step, controller-enabled runs must perform the step-control `start` checkpoint in [references/step-control.md](references/step-control.md), including the exact dashboard state path when present. It records the running step/title (or whole eligible batch) and refreshes HTML before work begins, without advancing verified Progress or consuming a retry. The helper supplies standardized activity text; do not leave the phase's original "Starting execution" description in place. Completion and terminal stops refresh it again. On resume inspect the saved active dispatch and reconcile its real agent/result before continuing; a saved start alone is not proof of a live process. Older runs without step control use the existing activity checkpoint before each actual step/batch, naming its number, title and verified count; their completion helper records a fresh verified-count message. A step/batch boundary does not apply queued autonomy.
For an `implement` run carrying `verification_version: 1`, or any plan with a concrete verification policy, read `../implement/references/verification.md` before dispatching the first step. Its one-step evidence write and validator call sit between passing Verify and the Progress update in point 4; "before doing anything else" means before the next implementation step, not before recording required evidence. On resume, validate that each already-complete step has an entry before dispatch. Pass the artifact root, ledger path, and contract to a single-step subagent so it records and validates its own entry before Progress. For a true concurrent batch, subagents report the actual checks but do not write the shared ledger; after all pass, the orchestrating session records and validates all batch entries before its one Progress update. On batch failure, leave Progress and the ledger at their pre-batch values. Legacy runs without either opt-in keep their original reports.
### Dispatch mechanics, by mode
How points 1–4 above are actually carried out differs by the `Mode` Phase 0 point 3 resolved:
**Subagent-Driven mode.** For each numbered step, dispatch a single fresh subagent via the Agent tool to perform that one step. This includes a trailing manual verification or "Write tests" step with `**Files:** none`: its Test Plan walkthrough and Verify still belong to its own fresh subagent. The orchestrating session must not perform that step itself or mark it complete after inspecting an earlier subagent's work; only Inline mode executes a step in this session. Before Phase 4, confirm every step newly completed in this run has its own Agent dispatch (or belongs to an eligible concurrent batch of Agent dispatches). Then follow these dispatch rules:
- Pass the executor tier Phase 0 point 5 computed for this plan as the subagent dispatch's `model` argument, so every step's subagent runs at the plan's recommended tier.
- Give the subagent, as its prompt, everything it needs to complete points 1–4 above without needing to ask this session anything mid-step:
- this step's own fields verbatim — **What to do**, **Files:**, **Verify**, and, when present, the step's own **Tests:** field (the exact test command(s), with each line's resolved repo root); when the step has no **Tests:** field, the relevant row(s) of the plan's shared `## Test Plan` table instead;
- Phase 1's policy **in full**, including the retry limit, the guardrail's operationalized check, the halt-scope rule, and the never-git-commit rule — not a paraphrase or a subset of it, since a subagent working alone is exactly where a stray `git commit` or an uncounted retry would otherwise happen;
- Phase 3's two fixed report shapes (Case 1 — Guardrail fired; Case 2 — Retry limit reached), verbatim, so the subagent already knows exactly what shape to return, with every field filled in from what it actually observed, the instant either of Phase 1's stop conditions fires inside it — rather than reporting back in free-form prose the orchestrating session would then have to reconstruct into shape after the fact;
- the plan file's own path, this step's number `N`, and the total step count `M`, together with an explicit instruction that the subagent itself is responsible for updating `## Execution Status → Progress` in that plan file to "Step N of M complete" the moment its Verify (and, where applicable, Test Plan row(s)) pass — per point 4 above — before it returns its report — **except when this step is being dispatched as part of a real batch** (see the batch-dispatch bullet below): in that case, the prompt instead explicitly tells the subagent **not** to write `## Execution Status → Progress` itself under any circumstance. Everything else about the report is unchanged — the subagent still returns its full account of what it implemented on a pass, or the full Case 1/Case 2 shape (per the bullet below) the instant a Phase 1 stop condition fires; "not under any circumstance" governs only the Progress claim, never the rest of the report's own content. The orchestrating session owns the Progress write for the whole batch.
- The dispatched subagent is responsible for performing points 1–4 above on its own: implementing the change, running Verify, retrying internally (up to Phase 1's 5-attempt limit) on an ordinary failure, applying the guardrail check itself if a fix looks like it needs to change the test, writing the Progress update itself once it passes, and reporting back once the step either passes or hits a Phase 1 stop condition — **except when dispatched as part of a real batch** (see the batch-dispatch bullet below), where it does everything in this list except the Progress write, which it never performs under any circumstance; the orchestrating session owns that write for the whole batch instead. Do not re-dispatch a new subagent mid-step for a retry — the same subagent iterates internally.
- Once the subagent returns its report, review it before doing anything else: read what it implemented, then re-read the plan file's own `## Execution Status → Progress` line directly (not merely the subagent's prose claim) to confirm it now reads "Step N of M complete" for this step, or that a Phase 1 stop condition fired per the report. The subagent is the one that writes Progress; only if the file's Progress line was not actually updated despite the subagent reporting success does this session write it directly, as a correction, before proceeding. **Exception for a batch step** (see the batch-dispatch bullet below): this per-step correction does not apply at all. A batched subagent never writes Progress, by design (per its own prompt instruction above), so the file correctly shows no update for it the whole time its batch is in flight — this is expected, not something to correct, and Progress for that step is owned entirely by the batch-dispatch bullet's own single, whole-batch write (or, on a partial failure, its own deliberate no-write). Once Progress is confirmed, either continue to the next step (if this step passed) or proceed to Phase 3 (if a stop condition fired). This review happens for every step, interactive or `--autopilot` alike — but it is no longer a stopping point: once the report is reviewed, relayed to the user as chat text, and Progress is confirmed, dispatch the next step's subagent **within that same response**, without ending the turn to wait for a reply (the same mechanics the Autopilot Mode section previously described only for `--autopilot` now apply unconditionally). Never dispatch two steps' subagents with no relayed report in between — the review and relay still happen for every step — but never end the turn waiting for the user's go-ahead before dispatching the next one either — **unless dispatching a real batch per Working order's exception** (more than one step, genuinely eligible to run concurrently): there, every batch member's subagent is intentionally dispatched together in one response, with their reports relayed together once every one of them has arrived, per the batch-dispatch bullet immediately below. This rule still means exactly what it says for any two steps that are *not* part of the same eligible batch.
- **When dispatching a real batch** (Working order's exception above determined more than one not-yet-done step is eligible to batch together): construct each batched step's own self-contained prompt exactly as the bullets above describe (including the no-self-written-Progress instruction), one per step, and dispatch all of them as separate `Agent` tool calls within the same response — never one at a time with an intervening wait. Then wait for **every** subagent in the batch to return its own report before acting on any of them; `Agent` dispatch in this harness is asynchronous, so a report arriving does not mean the batch is done — do not relay, write Progress, or dispatch anything further until every batched subagent has reported. Once all have reported: **if every one passed**, review and relay each report, in the batch's own ascending step-number order (for a stable, readable narrative), then the orchestrating session itself writes `## Execution Status → Progress` to the batch's own highest step number, exactly once — never read back or trust any individual subagent's own claim about Progress, since none of them wrote it — and continue to the next not-yet-done step or batch within that same response. **If any one subagent's report shows a Phase 1 stop condition fired:** let every other already-dispatched sibling in this same batch finish and report in before doing anything else (they cannot be recalled mid-flight); **before stopping, re-read `## Execution Status → Progress` directly** — never trust any batched subagent's own prose claim — to confirm it still reads exactly its pre-batch value; a subagent is instructed never to write Progress inside a batch, but if one did so anyway despite that instruction, correct the file back to the batch's actual pre-batch value now, the same self-healing role the single-step "only if the file's Progress line was not actually updated... does this session write it directly, as a correction" rule already plays outside a batch. Do **not** write Progress to any step's own number for this batch, regardless of how many siblings individually passed — Progress must read exactly its pre-batch value, corrected if necessary, before this run stops; then stop the entire run — do not dispatch any further step or batch, in this round or any other — and proceed to Phase 3, whose report must list every sibling's own individual outcome (which passed, which hit a stop condition, and how), per Phase 3's own extended report shape below, not only the one that stopped. A batch of exactly one step (the common case when dispatch order is `sequential`, or when a step failed the eligibility check above) is handled by the existing per-step bullets, unchanged — this bullet only applies when the batch actually contains more than one step.
**Inline mode.** Perform points 1–4 above directly in this session, for each step in turn:
- Implement the step's change, run its Verify check, and apply Phase 1's policy on failure, all within this same session — no subagent dispatch.
- Phase 0 point 3 records Inline mode's Mode line as 'checkpointed after each step's Verify' — that phrase refers only to point 4's Progress write (the plan file gets an accurate, durable checkpoint after every step), not to a pause for user review on its own. Whether a routine step completion is *also* a stopping point now depends on the plan file's own `**Inline pause mode:**` line (set at Mode-selection time, Phase 0 point 3): **Run straight through** — proceed immediately and directly to the next step's implementation once Progress is updated, exactly as Inline has always behaved; a routine step completion is never a stopping point, and (together with Phase 3's two stop conditions) this remains the only way this session stops mid-plan. **Stop after each step** — once Progress is updated for a step, relay a short summary of what that step did to the user in chat, then end the turn and wait for the user's go-ahead before starting the next step's implementation; this intentional, per-step stop is distinct from, and in addition to, Phase 3's two stop conditions, and is not an early exit from this phase's 'no exceptions' scope rule above — it is simply where one step's own per-step procedure ends and the next one's begins. **Under `--autopilot`, this pause is always overridden** (autopilot: see Autopilot Mode — this per-step override is its own named site, `inline-step-pause-override`, distinct from the Phase 0 `inline-pause-mode-backfill` site): relay the step's outcome and continue within the same response, exactly like Subagent-Driven's own unconditional behavior, regardless of what `**Inline pause mode:**` records — an unattended run must never actually wait, no matter what an earlier interactive session recorded.
## Phase 3 — Guardrail / retry-limit stop handling
Phase 2 hands control here the instant either of Phase 1's two stop conditions fires while working a step — the guardrail identifying a real product-behavior question (Phase 1, "Guardrail"), or that step's test(s) still failing after the 5th fix attempt (Phase 1, "Retry limit"). Per Phase 1's "Halt scope," reaching this phase means the entire remaining plan pauses in place: no later step is attempted, including one with no dependency on the flagged/stalled step, and this step itself is not retried any further once this phase is reached. This phase does exactly one thing — assemble and deliver whichever of the two fixed reports below applies — and the run ends there. Both stop conditions get the same halt scope and the same reporting treatment, per Phase 1's Halt scope: there is no third, lesser halt behavior for either condition, and nothing here resumes automatically. The only way the plan continues is a fresh invocation of `execute`, after the user has reviewed the report and supplied whatever guidance resolves it (e.g. an edited plan step, an updated spec, or an explicit call on which side — test or code — was actually wrong).
### Precedence when both conditions could apply to the same step
Phase 1's "Retry limit" section already states this, and it governs here too: if, at any point during a step's retry attempts — including as early as the very first attempt, well before a 5th attempt is ever reached — the guardrail's test-bug-vs-product-behavior check identifies a real product-behavior question, stop counting retries immediately and apply the guardrail instead. In that situation this phase always uses **Case 1 — Guardrail fired** below, never Case 2, even though fewer than 5 attempts occurred. The two conditions are never both charged against the same step for the same discrepancy, and a step is never reported under both formats.
### Which side detects the stop condition and originates the report
Phase 2's dispatch mechanics differ by mode, and so does which side of the run actually notices the stop condition first and is responsible for producing the report:
- **Subagent-Driven mode.** The dispatched subagent working the stalled/flagged step is the one applying Phase 1's policy internally (Phase 2, "Dispatch mechanics, by mode"), so it is the subagent — not the orchestrating session — that first detects the stop condition and is the only party that actually knows the discrepancy de
[…] pełny plik w paczce .zip
Files in this package (7)
- SKILL.md 93 KB
- references/step-control.md 9 KB
- references/verification-policy.md 4 KB
- scripts/plan-status.mjs 11 KB
- scripts/plan-status.test.mjs 7 KB
- scripts/step-control.mjs 23 KB
- scripts/step-control.test.mjs 31 KB
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · insideout-ai/make-it-work | 100 | MIT |
| yaleh/quay | 100 | MIT |
| jkaloger/lazyspec | 100 | MIT |
| shakestzd/htmlgraph | 100 | MIT |
| shakestzd/htmlgraph | 100 | MIT |
| shakestzd/htmlgraph | 100 | MIT |
| crbnos/carbon | 100 | AGPL-3.0 |
| alirezarezvani/claude-skills | 100 | MIT |
| gridconsole/grid-plugins | 100 | MIT |
Database snapshot: 13.11.2026 · package version 9373424adf42 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100executing-plans
Use when you have an implementation plan ready to execute. Triggers: 'run the plan', 'start building', 'execute the tasks', 'implement the steps', 'next task in the plan', 'work through the plan'. Also invoked by develop after planning phase completes. NOT for: creating plans (use writing-plans). - 92plan-execute
Execute the user's plan that has been iteratively refined, step by step, with resume on failure. Use when the user runs /plan-execute or asks to execute an existing plan. - 100execute-plan
Carry out an approved plan step by step, test first, with a check and a progress note per step and a review of the whole change at the end, also in goal mode or with workers. Use it whenever there is a written plan to build from or the user says to go ahead with one. - 84execute-plan
Execute implementation plans step-by-step. Use when user says "execute the plan", "implement the plan we created", "start building based on the plan", "go ahead and implement it", "proceed with the implementation", "execute as a stack", "create a PR stack while implementing",… - 90implement
Execute an implementation plan step by step with verification checkpoints and progress tracking. Use when the user asks to "implement the plan", "execute the steps", "start implementing", or has an approved plan ready to implement. - 90build-from-plan
Implements an approved plan from the feature worktree with scoped tests and verification. Use when the user says implement the plan, execute tasks, or build the feature.