---
name: sdd-implement
description: Use when selecting an executable task range, or executing or resuming a bounded SDD implementation workflow driven by TASKS or FEATURE-TASKS, completing pending task work, coordinating tests and documentation, verifying results, marking completion, committing and pushing each task, or stopping at a requested checkpoint.
---

# Implement a selected task range

For Markdown output or document work within this skill's scope, apply the shared [Markdown style](../sdd-conventions/references/markdown-style.md): blank lines after headings and around top-level lists and code blocks, plus four-space structural indentation, including nested lists, with exactly one space after each list marker. This applies to direct calls as well as coordinated work; it does not expand editing or review authority.

Execute the user's requested task-list boundary. **sdd-manage** coordinates authorization, prerequisites, and focused capabilities; an implementation request authorizes work within its established scope without repeated confirmation for routine steps. Use a current **sdd-orient** handoff at startup for repository instructions, Git and task state, dirty-path ownership, and environment. Read the relevant references: Load [environment recovery](references/environment-recovery.md) when installation/runtime facilities block selected work; load its browser guidance only for relevant browser checks.

| Work | Load |
| --- | --- |
| Push outstanding commits, resume pending work, and select the range | [startup and continuation](references/startup-and-continuation.md) |
| Resolve next task, next N tasks, milestone, or phase requests | [range selection](references/range-selection.md) |
| Establish tracking decision and phase readiness before task execution, including direct calls/resume | **sdd-manage**: [tracking decision](../sdd-manage/references/tracking-decision.md) and [phase activation](../sdd-manage/references/phase-activation.md) |
| Execute tasks with tests, documentation, and verification | [task execution](references/task-execution.md) |
| Bootstrap disclosure and usage records before the first SDD commit | **sdd-manage**: `skills/sdd-manage/references/repository-bootstrap.md` (bundled dependency) |
| Mark completion, commit and push, reconcile issues, and stop | [completion and checkpoints](references/completion-and-checkpoints.md) |

For a selection-only request, use the range-selection reference and return the IDs, dependencies, and stopping point without mutations. For an implementation request, follow this protocol:

1. **Push first.** Using the established repository and branch, push all outstanding commits before task selection, tests, or edits, even when the worktree is clean. Confirm the remote contains the commits. Stop on an unresolved push blocker before beginning further implementation.
2. **Resume before advancing.** Use orientation's last task commit, owning checklist, pending changes, and existing evidence. Finish a completed task awaiting commit without repeating its implementation, or resume the identified incomplete task. Preserve valid work and resolve ambiguous ownership or task identity before the affected mutation.
3. **Select the boundary.** Resolve the requested TASKS or FEATURE-TASKS range, dependencies, and stopping point using the range-selection reference. Record selected task IDs and exit conditions. After startup pushing, require **sdd-manage**'s preparation integration gate before creating a dependent execution branch: accepted design-docs preparation explicitly merged, verified and published into the actual default branch; branch from that checkpoint afterward. Establish or reuse the scoped working branch and target before new task edits. Preserve campaign-record and continuation ownership. Do not expand the range or invent requirements to bypass a blocker.
4. **Check readiness and execute one task at a time.** After publishing retained verified commits and before further task implementation edits or task tests, load and apply the manager's [tracking decision](../sdd-manage/references/tracking-decision.md) and [phase activation](../sdd-manage/references/phase-activation.md), including direct calls and resume. Requested/confirmed tracking requires verified eligible-phase objects and initial associations; missing/partial/unknown projection blocks affected execution unless the human explicitly overrides this gate. Preserve pending work and return the missing evidence to the manager; do not silently downgrade to local-only mode. After push-first and before new task work/projection, apply **sdd-manage**'s **Document QC gates** reference (`skills/sdd-manage/references/document-qc-gates.md`, bundled dependency) to the selected owning inputs; report missing/stale gates and coordinate focused review within scope rather than silently rewriting requirements. Selection-only remains read-only and can return candidate IDs with blocked execution eligibility. Coordinate **sdd-tdd**, apply production changes, maintain documentation through **sdd-docs**, and obtain acceptance evidence through **sdd-verify**. Repair failures within scope and repeat affected checks as needed.
5. **Make each result durable.** Mark the task complete only after its implementation, tests, documentation, and required verification are complete. Use **sdd-report** for `[<owning-task-id>] <imperative description>` with exactly one leading owning ID. Under the [task commit contract](references/completion-and-checkpoints.md#task-commit-contract), close exactly one executable task per commit with its result, required evidence and initial completion checkbox together; cumulative task commits and separate initial checkbox commits are forbidden. Inspect staged and actual committed composition, then push before advancing. When hosted tracking is active, coordinate verified issue closure through **sdd-forge**.
6. **Integrate and stop.** Execute the selected explicit review/report tasks, verify milestone/phase exits, persist their reports and coordinate issue then milestone closures through sdd-forge when tracking is active. Update eligible parent checkboxes using the shared backend lifecycle. Coordinate selected feature-document incorporation when required, verify the completed boundary, then apply the workflow integration gate: main task work merges only a complete verified phase; an incomplete phase pushes and pauses. Other coherent authorized boundaries integrate explicitly under the Git protocol. Return an evidence-backed report. Stop at the requested boundary or an unresolved blocker; do not start steering or additional tasks automatically.

This skill owns executable range selection, task execution, repairs, completion updates, commits, pushes, and issue-closure coordination. **sdd-tasks** owns task-list creation and review; **sdd-integrate-feature** owns feature-delta reconciliation. Human-commanded checkpoint amendments to existing development documents and prior implementation belong to **sdd-steer**. Report governing-document changes needed outside the selected implementation scope to the user rather than silently rewriting the requirements.

Apply the shared [per-commit publication](../sdd-manage/references/git-workflows.md#publish-each-commit) rule to every owned commit, including ancillary report/status commits, not only task-result commits. Preserve its explicit user-directed local-only exception and block advancement on unresolved publication.

Git commits and the owning checklist provide continuation state. No transaction journal, recovery state directory, or separate recovery skill is required. Return completed task IDs and implemented capabilities, verification evidence and gaps, commit and push results, hosted reconciliation, remaining work, and the stopping boundary through **sdd-report**.