oscaner/skills/cdd-dev

Kairos CDD-Dev

Executes planned tasks through the engine's implement / review / fix chain — its own orchestrator decisions (mode chain, final review) following the engine's next: face, with no installed-engine precondition (npx pulls the engine on demand); on closure that face carries the pipeline continuation.

Invocation discipline — every engine command runs via npx -y @oscaner-skills/cdd-engine@latest <subcommand> as a background dispatch: launch it in the background and await the completion notification — never poll — then read the full output (stdout/stderr). Output filtering is forbidden — no piping to tail/head, no 2>&1 |, no EXIT=$? capture. Dispatch boundary — the obligation runs both ways: a dispatched child carries every verification / build command to completion inside its own turn, never ending that turn to await a background task it launched itself — ending the turn terminates the child, so the awaited notification never arrives and the round dies half-finished while still looking successful; the launching side certifies success by the terminal contract (a clean working tree and the target action actually completed), never by exit code 0. Round rhythm — one review pass per dispatch; a fix round re-enters the review while the route is not done; the implement child commits its own work; ensure the working tree is clean before entering review (dirty → BLOCKED); the orchestrator writes no tree during dispatch. Approval gate — before the first implement / review / fix dispatch of a slug, submit the plan this dispatch implements together with the self-check conclusion that approved it to the author and stop; dispatch only after an explicit approval, and a dispatch without one is a violation — the submitted line declares the plan's authorship plainly: this document was written by the orchestrator in this session. Write authority — the spec's and the plan's creation stays the orchestrator's, written in this session and never handed wholesale to a subagent; the dispatched implement and fix rounds may amend their content face (facts, file lists, steps, acceptance detail, cited line numbers), never their structure face — the plan's Task id set and every task's DependsOn set — which the engine snapshots at dispatch and judges hard on a round-internal change. Round logs — every dispatch child's own output lands in .kairos/cdd/<slug>/logs/<stem>.log, and a failing round's CDD_BLOCKED line on stderr names that path: read the child's output there, never from stdout. Failure face — cross-node failure handling lives in the Failure Modes table below (the single source); node Fail entries keep only local behavior.

Flow Digraph

flowchart TD
  A[determine-base] --> B[set-base]
  B --> C[implement-wave]
  C --> L[NEXT-LOOP]
  L -->|until next is terminal| L
  L -->|no next| Z1((BLOCKED))

Node Definitions

determine-base

• Do: Resolve the base branch — inference sources in order: plan base field → branch upstream (git rev-parse --abbrev-ref @{u}) → conversation context; if none yields a definitive base, ask the user — do not guess. The base may already be present in the artifact (npx -y @oscaner-skills/cdd-engine@latest base get --plan <path>); skip inference when the artifact is present.
• Read: plan document + git upstream + conversation context + npx -y @oscaner-skills/cdd-engine@latest base get --plan <path>
• Exit: base resolved → set-base
• Fail: user refuses to confirm → BLOCKED: base-undecided

set-base

• Do: Persist the base via the engine CLI — npx -y @oscaner-skills/cdd-engine@latest base set --plan <path> --base <branch> --source <enum>, where source is plan-field | branch-upstream | conversation-context | user-confirmed. The engine is the sole write/read path for the artifact — never hand-write it; set is idempotent, refusals and validation errors are engine-handled.
• Read: npx -y @oscaner-skills/cdd-engine@latest base get --plan <path> (the artifact on stdout)
• Exit: artifact written (or already present) → implement-wave
• Fail: engine refusal / validation error → report to user; user decides (no hand-written artifact)

implement-wave

• Do: Dispatch npx -y @oscaner-skills/cdd-engine@latest implement --tasks <n|n,n,…> --plan <path> — one dispatch wave per iteration; dispatch each wave as the engine returns it, never a hand-picked subset. A pre-flight row reading plan leads ledger by N tasks is a hint, not an error — the plan legitimately runs ahead of the ledger, so dispatch the new wave as usual. A round cut short is recovered from the working tree: look at the working tree first, commit the changes that work, discard the ones that are broken.
• Read: the full stdout — its conclusion and the engine's next: face; a BLOCKED round's reason rides stderr
• Exit: dispatch complete → NEXT-LOOP
• Fail: nested CLI exits with no output → BLOCKED: engine-error (report via kairos:cdd-report（pi：/skill:cdd-report）)

NEXT-LOOP

• Do: Run the wave review-fix rhythm through the engine — one review pass per dispatch. Dispatch the wave review (npx -y @oscaner-skills/cdd-engine@latest review --type wave --tasks <n|n,n,…> --plan <path>); every later hop follows the engine's next: face — including the branch line, which the engine routes on its own. Fixes dispatch via the fix round — never an in-place edit as a substitute; a BLOCKED/TIMEOUT round's carried reason is reported, never overridden; a soft-cap suggestion is a user decision point — report it, never retry past it.
• Read: the full stdout — the review conclusion, the findings handoff path, and the engine's next: face
• Exit: each fix / next-wave pass re-enters this hub while that route keeps the loop alive (the until next is terminal self-loop); a route that leaves the loop ends this skill's flow
• Fail: review exits with no output → BLOCKED: engine-error

Invariants

Failure Modes

Cross-node failure handling (complements node Fail fields):

Fail-open vs BLOCKED convention:

• BLOCKED: explicit terminal state; requires user intervention to recover.
• implicit fail-open: node-level failure (not in digraph); flow stops + reports to user.