/implement

Összefoglaló

Portable, runtime-független skill, amely egy meglévő tervfájlt vagy feladatbontó fájlt hajt végre. Egy bevezető módkulcsszó választja ki a viselkedést: vagy csak a következő el nem végzett feladatot valósítja meg, vagy végigmegy minden hátralévő feladaton — minden feladat teszt-elsőként (TDD) épül, önmagát /iterative-review-vel ellenőrzi, blokkoló teszteket futtat, kipipálja magát, és saját commitba kerül. Egy feladat, egy commit. Bármilyen harness-ben működik (Claude Code, Cursor, OpenCode, omp, claude -p), hook-függőség nélkül.

Három korábbi parancsot egyesít. Az /implement leváltja a külön /implement-next, /implement-all és /implement-all-safe parancsokat — a mód mostantól egy átadott kulcsszó, nem külön parancs. ALL módban feladatonként egy subagentet indít, valahányszor a harness kínál subagent-indító toolt — a Claude Code Agent toolja (a headless claude -p-t is beleértve), az OpenCode Task-ja, az omp task-ja, a Cursor Task-ja —, és csak akkor esik vissza inline ciklusra (subagentek nélkül), ha a harness egyáltalán nem kínál subagent toolt.

Mikor használd

Akkor használd az /implement parancsot, ha van egy tervfájlod (vagy feladatbontó fájlod) egy vagy több - [ ] feladattal, és a teljes minőségi szűrőcsomaggal akarod megvalósítani őket: TDD-ciklus, /iterative-review-hurok, blokkoló tesztfutás, kipipált checkbox és tiszta, feladatonkénti commit.

• Pontosan egy feladatot akarsz megvalósítani és megnézni az eredményt — használd a NEXT módot.
• Van egy kész terved, és feladatonként, kézi beavatkozás nélkül akarod felépíteni — használd az ALL módot.
• Olyan harness-ben vagy, amely egyáltalán nem kínál subagent toolt, és inline akarod futtatni a ciklust — használd a kényszerített INLINE-t, vagy hagyd, hogy az ALL mód automatikusan visszaessen rá.
• Egy részben befejezett futást folytatsz, és a következő el nem végzett feladatnál akarsz továbblépni.

Kísérő tervek. A feloldott fájl lehet önálló, vagy olyan feladatbontó fájl, amelynek S#/C# szcenárió/szerződés definíciói, architektúrája és elfogadási kritériumai külön kísérő tervben vannak. Ezt előbb a ## References szakasz Plan: linkjéből oldja fel (ez a kanonikus, akkor is helyes, ha a tervet áthelyezték), és csak ennek hiányában esik vissza a frontmatter plan: kulcsára (testvérfájlként). Ha bármelyik mechanizmus által megnevezett kísérő terv hiányzik a lemezről, a futás megáll, nem folytatódik kontextus nélkül. A kísérő terv csak olvasható kontextus — soha nem pipálja ki, nem stage-eli és nem commitolja.

Nem erre való: tervek létrehozására vagy frissítésére (az a /plan-maker), és nem tervfájl által vezérelt eseti kódmódosításokra.

Hívás

A $ARGUMENTS egy opcionális bevezető módkulcsszót és a tervfájl elérési útját tartalmazza. Az első, szóközzel elválasztott token csak akkor módkulcsszó, ha pontosan next, all vagy inline (kis- és nagybetűtől függetlenül); minden más az útvonal része. A felismert kulcsszó(k) utáni minden az útvonal — a szóközt tartalmazó útvonalat szó szerint veszi.

/implement next <plan-file-path>
/implement all <plan-file-path>
/implement all inline <plan-file-path>
/implement <plan-file-path>

A négy hívási forma:

• /implement next <file> → NEXT mód: csak a következő el nem végzett feladatot valósítja meg (lásd a lenti NEXT-mód 1–7. lépéseit).
• /implement all <file> → ALL mód: végigmegy minden hátralévő feladaton. Feladatonként EGY subagentet indít, valahányszor a harness kínál subagent-indító toolt (a Claude Code Agent toolja — a headless claude -p-t is beleértve —, az OpenCode Task-ja, az omp task-ja, a Cursor Task-ja); csak akkor esik vissza az inline ciklusra (subagentek nélkül), ha a harness egyáltalán nem kínál subagent toolt.
• /implement all inline <file> (illetve inline all <file> vagy inline <file>) → ALL mód kényszerített INLINE: soha nem indít subagentet, minden lépés az aktuális kontextusban fut.
• /implement <file> (kulcsszó nélkül) → megszámolja a hátralévő feladatokat: 0 → jelenti, hogy már kész, és megáll; pontosan 1 → NEXT módban folytatja; több mint 1 → rákérdez, hogy csak a következő feladatot vagy mindet végezze el. Nem interaktív / headless futásban (pl. claude -p) NEM akad el — NEXT módra vált alapértelmezetten, és kiír egy egysoros megjegyzést (add hozzá az all-t a teljes terv futtatásához).

Argumentum nélkül megáll, és tervfájl elérési útját kéri.

NEXT mód — 7 lépés feladatonként:

1. 1. lépés — Haladás kijelzése: Feloldja a $BASE-t (a skill könyvtárát) és a tervet + kísérő tervet, majd lefuttatja a bash "$BASE/scripts/plan-progress.sh" <plan-path>-t. Exit 0 → kiírja a blokkot és beolvassa a NEXT_TASK_NAME-et; exit 1 → minden feladat kész, megáll; bármely más exit / a szkript nem található → visszaesik a bundle-ölt progress-header-*.template fájlokra, a tervből számolja ki a helyőrzőket, és folytatódik.
2. 2. lépés — Implementáció (TDD): A feladathoz legmegfelelőbb ágenstípust indítja. Ha kísérő terv van, az ágens ELŐBB azt olvassa el, hogy feloldja a feladat által completes-ált S#/C# azonosítókat. SCOPE: pontosan egy feladat, csak ami ahhoz szükséges. TILOS: a feladatbontó fájlt vagy a kísérő tervet módosítani, vagy commitot létrehozni. Kódnál: előbb bukó tesztek (red) → implementáció (green) → teljes pass. Dokumentációnál/confignál: közvetlen megvalósítás.
3. 3. lépés — Kritikai review: Lefuttatja az /iterative-review-t a difen és a feladat specifikációján (a kísérő terv útvonalát is átadva, ha van). Miután visszatér — bármi is a verdiktje — azonnal a 4. lépés következik; a Review Summary nem befejezési jelzés.
4. 4. lépés — Tesztek futtatása: Lefuttatja a teljes suite-ot. Mivel a Claude Code Bash foreground plafonja ~120 mp, a hosszabb suite run_in_background-dal indul, és a Monitor tool tartja életben; a Monitor nélküli harness-ek a feladat-releváns részhalmazra esnek vissza, és a 7. lépésben jelzik a részleges scope-ot. Minden futás előtt ellenőrzi, hogy nem fut-e még egy korábbi futás (ne halmozódjanak a pytest workerek). A javító ágensek 3-szor próbálkoznak.
5. 5. lépés — Kipipálás: A megvalósított feladatot és minden elkészült alpontot [x]-szel jelöl a feladatbontó fájlban — csak azt, ami ténylegesen elkészült és ellenőrzött.
6. 6. lépés — Commit: Egy feladat = egy commit. Stage-eli az implementációs fájlokat ÉS a frissített feladatbontó fájlt; a commit üzenete a feladat tartalmából származik. A kísérő terv soha nincs commitolva. A --no-verify / --amend / bundle-ölés tilos.
7. 7. lépés — Riport: Rögzített formájú riportot ad: mit valósított meg, tesztek, feature-veszteség vagy eltérés, megoldhatatlan oszcillációk, és a feladat kipipált sora + a teljes commit-hash.

ALL mód — a ciklus:

1. -1. lépés — Végrehajtási mód kiválasztása (subagentek vagy inline): Képesség, nem harness-márka vagy -verzió alapján dönt: subagenteket használ, valahányszor a harness kínál subagent-indító toolt (a Claude Code Agent toolja, a headless claude -p-t is beleértve; az OpenCode Task-ja; az omp task-ja; a Cursor Task-ja), és csak akkor vált az inline ciklusra, ha a harness egyáltalán nem kínál subagent toolt. Jelzi a felhasználónak, melyik módot választotta és miért. A kényszerített INLINE ezt kihagyja, és egyből inline megy.
2. 0. lépés — Tervfájl feloldása (és a kísérő terv) a közös feloldási szabályok szerint.
3. Ciklustörzs (addig ismétlődik, amíg a plan-progress.sh exit 1 = minden kész): (1) lefuttatja a plan-progress.sh-t, és szó szerint, átformázás nélkül mutatja az első két sort — exit 2/3 vagy bármely váratlan kód megállítja; (2) kiírja a Launching task <NAME> at [HH:MM:SS]-t (inline-nál Starting task …), majd futtatja a feladatot — Agent tool subagenttel (general-purpose, háttérben) vagy inline NEXT módban — szigorúan szkópolt prompttal (pontosan egy feladat; A–F elfogadási kritériumok; tiltja a --no-verify/--amend-et, a bundle-ölést, a beágyazott ALL ciklusokat, és bármi más módosítását a feladat checkboxán kívül); (3) recovery check — ellenőrzi, hogy a feladat ki van-e pipálva és a fájljai commitolva vannak-e. Nincs kipipálva → újraindítás/újracsinálás (max 3 próba, aztán megáll kézi beavatkozásra); kipipálva de commitolatlan → csak az adott feladat fájljait commitolja explicit útvonal alapján (soha nem git add -A), és jelenti a szabálysértést.

1. példa — Csak a következő feladat megvalósítása (szemléltető példa)

/implement next plans/FEAT-001-skill-command-script-handouts.md

Progress   : [████████░░░░] 68%  (13/19 tasks, 2/6 phases)
Next task  : 3.4  **File**: `handout/cmd-implement.html`

NEXT_TASK_NAME=**File**: `handout/cmd-implement.html`
NEXT_TASK_PHASE=3
NEXT_TASK_NUMBER=4

[Step 2] Spawning implementation agent for Task 3.4…
  → Reads skills/implement/SKILL.md
  → Writes handout/cmd-implement.html with 7 sections and 2 examples

[Step 3] /iterative-review: no critical/major/moderate issues found (PASS)

[Step 4] Full test suite: 14 structural checks pass (CLEAN)

[Step 5] Plan updated: Task 3.4 marked [x]

[Step 6] Commit: feat(handout): Task 3.4 — cmd-implement.html
  → handout/cmd-implement.html (new) + plan file (task checked off)

[Step 7] Report: Task 3.4 complete. 7 sections, 2 examples.

2. példa — ALL mód subagent tool nélküli harness-ben (szemléltető példa)

/implement all plans/FEAT-004-legacy-refactor.md
(subagent-indító toolt nem kínáló harness-ben futtatva)

No subagent-spawning tool available in this harness.
Running the ALL loop inline (no subagents).

Progress   : [░░░░░░░░░░░░] 0%  (0/5 tasks, 0/2 phases)
Next task  : 1.1  **File**: `README.md`

Starting task 1.1 at [11:02:47]
(runs NEXT mode inline: TDD cycle, /iterative-review, tests, check-off, commit)

Task 1.1 ✅ — checked (line 18) and committed (d4e5f60). Checkpoint verified (checkbox + commit).

… (4 more iterations) …

Progress   : all tasks complete (exit 1)
All tasks complete.

Kapcsolódó eszközök

• /iterative-review — A kritikai review-hurok, amelyet a NEXT-mód 3. lépése hív; párhuzamos devil's advocate ágenseket és javító ágenseket indít, amíg nem marad kritikus/súlyos/közepes probléma.
• scripts-plan — A plan-progress.sh szkript, amelyet az /implement a NEXT-mód 1. lépésében és minden ALL-mód iteráció elején futtat; a bundle-je mostantól a skills/implement/scripts/ alatt van.
• /plan-maker — Előállítja a terv- és feladatbontó fájlokat, amelyeket az /implement végrehajt.