plan-implementation

## Project Context

- CLAUDE.md: !`find . -maxdepth 1 -name "CLAUDE.md" -type f`
- project-discovery.md: !`find . -maxdepth 3 -name "project-discovery.md" -type f`

## Operating Principles

- **The feature specification is the ground truth for *what*.** This skill plans *how*. Do not re-open behavioral decisions the specification already settled; flag contradictions as Open Questions for the user.
- **The han.core:project-manager is the coordinator, not the author of every section.** It facilitates rounds of discussion among specialists, tracks claims and evidence, and decides when the plan is ready. Specialists own their domains.
- **Always include `han.core:junior-developer` on the team.** When decisions lack strong evidence, the han.core:junior-developer reframes the issue in plain terms first — that frequently unlocks a resolution without needing the user.
- **Escalate to the user only when evidence and reframing have both failed.** Every escalation surfaces with a full description, the evidence considered, and a recommended answer.
- **Done is when the han.core:project-manager says so.** The loop exits when the han.core:project-manager reports the plan is ready to commit, or that only user-input items remain. The user is not asked to keep iterating past that point.
- **YAGNI is a first-class operating principle, applied to *implementation* choices.** The implementation plan inherits the spec's behavioral commitments but applies the evidence-based YAGNI rule from [../../references/yagni-rule.md](../../references/yagni-rule.md) independently to abstractions, configuration knobs, observability, runbooks, infrastructure, rollout machinery, test scaffolding, schema columns, indexes, and any other implementation artifact the plan recommends. Items that fail the evidence test get demoted to a `## Deferred (YAGNI)` section in `feature-implementation-plan.md` with the reopening trigger named; items where a strictly simpler implementation satisfies the same evidence get the simpler implementation recorded as the decision and the larger version under `Rejected alternatives:`. The Sentry-runbook-on-staging-only-Sentry pattern is the named project precedent — operational machinery shipped before the system that drives it actually produces the data, traffic, or failures it covers is YAGNI by default. Every committed implementation item is ongoing maintenance and a pattern future agents will copy.
- **All sub-agents in this skill run on sonnet.** When launching any Agent tool call in this skill, pass `model: "sonnet"`. The exception is the han.core:project-manager synthesis step in Step 8, which may run on its default model (opus) — pass no model override there.
- **Keep the plan at planning altitude.** Name and reference config and code artifacts; do not inline their full contents. Inline only the specific values that are themselves decisions (a flag default, a key name, a threshold). A full file block — a complete plist, a whole config file, a multi-line XML or JSON document — belongs in the file it configures, not in the plan. YAGNI gates whether an item is *included*; this principle gates how *verbose* an included item is.
- **The plan lives in three cross-referenced files.** `feature-implementation-plan.md` is the primary plan and lives at the root of `{folder}/`; `implementation-decision-log.md` records every decision and `implementation-iteration-history.md` records each round of discussion — both companion artifacts live in `{folder}/artifacts/` to keep the planning folder uncluttered. The main plan cites decisions with inline `([D-N](artifacts/implementation-decision-log.md#...))` links for non-obvious claims. The decision log and iteration history cross-link through `Driven by rounds:` / `Decisions produced:` fields (they sit as siblings inside `artifacts/`), and both link back into the plan through `Referenced in plan:` / `Changed in plan:` fields using `../feature-implementation-plan.md`. Any edit to one file requires updating the matching fields in the others.

# Plan an Implementation

## Step 1: Locate the Feature Specification

Read the user's argument and conversation context to identify the source artifact. The expected input is a `feature-specification.md` produced by the `plan-a-feature` skill, but any document describing what the feature should do is acceptable (PRD, design doc, product brief).

Resolve the source path:
- If the user provided a file path, use it.
- Otherwise, search for a recent `feature-specification.md` under `docs/features/`, `docs/plans/`, or other documentation roots discovered via CLAUDE.md or `project-discovery.md`. If multiple candidates exist, ask the user which one.
- If no feature specification exists, tell the user this skill requires one and recommend running `plan-a-feature` first.

Three files will be written. The primary plan lives at the root of `{same-folder-as-source}/`; the two companion artifacts live in `{same-folder-as-source}/artifacts/` (which may already exist if the source spec came from `plan-a-feature` — share the same subfolder rather than creating a second one):

- `{same-folder-as-source}/feature-implementation-plan.md` — the primary plan.
- `{same-folder-as-source}/artifacts/implementation-decision-log.md` — every committed implementation decision with rationale, evidence, and rejected alternatives.
- `{same-folder-as-source}/artifacts/implementation-iteration-history.md` — round-by-round record of specialists engaged, questions raised, and how each was resolved.

Create the `artifacts/` subfolder before writing the companion files if it does not already exist.

The three files cross-reference each other. The main plan cites decisions with inline parenthetical links like `([D-3](artifacts/implementation-decision-log.md#d-3-rollout-strategy))`; the decision log and iteration history cross-link through `Driven by rounds:` / `Decisions produced:` fields (siblings inside `artifacts/`), and both link back into the plan through `Ref