code-forge

# Code Forge

## Required Skills

Read, apply:

1. `framework:knowledge-priming` -- Load proj context (stack, arch, conventions) so impl matches real proj (always)
2. `framework:context-anchoring` -- Load/find context anchor doc; enrich as impl decisions made (always)
3. `framework:learning-harvest` -- Load prior operational learnings inform impl; harvest new patterns at session end (always)
4. `framework:collaborative-judgment` -- Surface real judgment calls w/ structured opts vs silent assume (always)
5. `framework:architecture` -- Layer place, dep direction, struct valid (always)
6. `framework:clean-code` -- Craft rails: SRP, naming, complexity, err handle (always)
7. `framework:domain-driven-design` -- Aggregates, entities, VOs, domain svcs (conditional: only when touch domain folder)
8. `framework:secure-coding` -- Trust bounds, injection prevent, secrets mgmt (conditional: only boundary-cross code)
9. `framework:test-quality` -- AAA struct, isolation, assert quality, naming (always when write tests)

## Workflow

### Step 1: Establish Implementation Context

Use `framework:learning-harvest` Load behavior. Focus hint: "implementation session — focus: implementation craft, quality signals, reliability". Prior learnings about coding patterns, recurring quality issues, and failure modes inform implementation from the start — e.g., learnings say "anemic domain models keep appearing," push behavior into entities. Learnings flag "missing input validation on VOs," validate in constructors from start.

Use `framework:context-anchoring` Doc Discovery check existing context anchor doc for feature impl.

- **If found** → Load (context-anchor Load behavior). Present struct ack -- feature name, decision count, open Qs, constraints. Honor all logged decisions/constraints as active commits.
- **If not found** → Nudge user: "Have design doc/blueprint for feature? Or work from discussed?" Accept either graceful.
  - User provides doc → load, follow.
  - Proceed without → all atom rails still apply; just no struct blueprint ref. Work from verbal reqs in convo.

### Step 2: Plan Implementation Order

**With blueprint**: Extract component list, layer assigns from context anchor doc. Use L2 (Components) decisions for layer place, L3 (Interactions) for dep flow.

**Without blueprint**: Classify req components→arch layers using layer defs from `framework:architecture`. Each component, determine:

- Primary responsibility? (biz rules, data access, coord, external I/O)
- Which layer in loaded arch doc matches responsibility?
- Dep constraints for that layer?

If `framework:architecture` no loaded layer defs (neither defaults nor custom doc resolved), warn: "No arch rules avail. Run `/architecture-refiner` define arch standards. Proceed w/o arch guidance." Continue w/ only remaining atom rails.

Present proposed layer assigns→user for approval before proceed.

Both cases, plan **inside-out impl order** following dep direction from loaded arch doc — start innermost layer (no outward deps), work outward. Each layer's deps should exist when built.

Classify each op per flow patterns in loaded arch doc (e.g., cmd vs query flows, or equiv distinction your arch style).

Present impl plan -- ordered component list, layer assigns, flow classifs -- confirm w/ user before write code.

After plan approved, ask user choose **review mode**:

> "How review impl?"
> 1. **Layer-by-layer** (rec) -- Impl each layer fully, pause for review before next. One review pt/layer.
> 2. **Full autonomy** -- Impl everything end-to-end, present complete result. One review pt at end. (If blueprint exists, still pause any deviation from approved design.)
> 3. **Component-by-component** -- Pause after each individual component for feedback. Max review pts.

Default **layer-by-layer** if user no preference.

### Step 3: Implement Per Component

Each component in planned order, gen **code+tests together** -- tests not afterthought.

Every component:

- **Place correct arch layer** per `framework:architecture`. Valid dep direction follows loaded arch rules.
- **Apply `framework:clean-code` self-valid** during gen. Run inline checks: SRP comply, meaningful naming, low cyclomatic complexity, proper err handle, no magic vals, clean func sigs, no dead code, appropriate abstract level, clear control flow, minimal comments (code self-doc).
- **Write tests** using `framework:test-quality` self-valid.

Conditional checks per component:

- **If domain layer** → Apply `framework:domain-driven-design` self-valid.
- **If trust boundary** (HTTP handler, external API call, user input process, file I/O) → Apply `framework:secure-coding` self-valid.
- **If blueprint exists** → Verify component fulfills L4 (Contracts) spec. Flag any deviation from agreed contract.

**Post-Gen Verification** (applies every component, all review modes):

After gen each component, before present→user:

1. Run **Self-Valid Checklist** from each applicable atom against every func/class this component. Atoms use imperative STOP-verify lang -- follow literally.
2. Run **Active Anti-Pattern Scan** from each applicable atom. Check every box scan list.
3. Violations found → fix before present. Don't present code you know violates atom checklist.
4. Judgment calls flagged (see each atom's Ambiguity Signals) → collect. Present using `framework:collaborative-judgment` protocol before show code. Don't silent resolve.
5. All checks pass, no flagged judgment calls → present w/ brief comply note (e.g., "All clean-code, DDD checks pass"). Keep one line when clean -- only verbose when report violations, fixes.

**Pacing -- follow user's chosen review mode**:

- **Layer-by-layer**: Impl all components within layer, present full layer (code+tests) for review before next layer.
- **Full autonomy**: Impl all layers continuous. Present complete impl (all code+tests) at end. Skip→Step 4 (Cross-Component Verif) after all components done.
- **Component-by-component**: Present each component w/ tests in