/factory-init

name: factory-init
description: Use when onboarding a brownfield repo onto ADLC end-to-end, or running the recurring PDR↔ADR↔ChDR↔code alignment sweep (--refresh).
disable-model-invocation: true

factory-init

What this skill does

`factory-init` orchestrates the **unified brownfield bootstrap**: one command that reverse-engineers an existing codebase onto all three project-memory layers and measures how well they align with the code.

It coordinates the leaf lifecycle skills directly — `product-init`, `product-clarify`, `product-implement`, `product-analyze`, `architect-init`, `architect-clarify`, `architect-implement`, `architect-analyze`, `change-init`, `change-clarify`, `change-publish` — **never** the peer orchestrators `factory-product` / `factory-architect` / `factory-learn`.

Its own final step, the **sweep**, is the only cross-layer analysis in the factory: it builds the **coverage matrix** (`.adlc/coverage/coverage.md`) — a feature-area pivot plus the four traceability relations PDR↔ADR, PDR↔code, ADR↔code, ChDR↔code — and diffs it against the previous sweep to detect drift.

It operates as a **Kind-A DAG orchestrator** in alignment with the shared executor engine contract in `factory-mission/references/executor.md`.

**Scope boundary**: project-local memory only (PDR, ADR, ChDR + code). Team context directives (CDR / `team-init`) are NOT bootstrapped here — they publish to the external `team-ai-directives` repo and are owned by `factory-learn`. The sweep's final output includes a prose recommendation to run `factory-learn` / `/team-init` for reusable patterns spotted during bootstrap.

---

When to use

• You adopt ADLC on an **existing repo** (code exists, no/partial PDRs, ADRs, ChDRs) and want the full bootstrap in one run.
• You want a **recurring cross-layer alignment audit** (`--refresh`): which decisions are undocumented, which code is undecreed, where product and architecture disagree.

**When NOT to use**:

• Greenfield / empty project → run `factory-product` and `factory-architect` (specify routes) instead.
• Single-layer work → `factory-product` / `factory-architect` / `factory-learn` directly.
• CDR / team-directives contribution → `factory-learn`.
• Feature implementation → `factory-mission`.

---

Route Classification

| Condition | Route | |--|--| | Code exists, no memory records | **Bootstrap** (full pipeline) | | `.adlc/coverage/coverage.md` exists, or `--refresh` | **Refresh** (sweep only) | | Partial state | Bootstrap with **per-layer skip** (below) | | No code | Halt: greenfield — use `factory-product` / `factory-architect` specify routes |

**Per-layer skip** — each track classifies independently; a layer whose memory AND compiled artifact both exist skips its init/implement and runs only its analyze:

| Layer | Skip init/implement when | Always runs | |--|--|--| | product | `docs/adlc/memory/pdr/` (legacy `.adlc/memory/pdr/` fallback — either non-empty) AND `docs/adlc/product/PRD.md` exists | product-analyze | | architecture | `docs/adlc/memory/adr/` (legacy `.adlc/memory/adr/` fallback — either non-empty) AND `docs/adlc/architect/AD.md` exists | architect-analyze | | change | `docs/adlc/memory/chdr/` (legacy `.adlc/memory/chdr/` fallback — either non-empty) AND `docs/adlc/memory/chdr.md` exists | (ChDRs feed the sweep directly) |

---

Lifecycle DAG & Step Resolution

`factory-init` implements a **fixed named-skill DAG** (`fixed` step resolution). Tracks run **sequentially** — each track completes before the next starts. Rationale: the human gets one coherent review session per domain; `architect-clarify` reads the accepted PDR decisions as context (architecture serves product); the sweep receives the most mature inputs.

Bootstrap Route (12 steps, 3 clarify gates + final matrix review)

| # | Step | Skill | Phase | output_type | |--|--|--|--|--| | 1 | `product-init` | product-init | generate | draft (`.adlc/drafts/pdr/`) | | 2 | `product-clarify`⭐ | product-clarify | clarify | decision | | 3 | `product-implement` | product-implement | build | artifact-ref (`docs/adlc/product/PRD.md`) | | 4 | `architect-init` | architect-init | generate | draft (`.adlc/drafts/adr/`) | | 5 | `architect-clarify`⭐ | architect-clarify (reads accepted PDR list) | clarify | decision | | 6 | `architect-implement` | architect-implement | build | artifact-ref (`docs/adlc/architect/AD.md`) | | 7 | `change-init` | change-init | generate | draft (`.adlc/drafts/chdr/`) | | 8 | `change-clarify`⭐ | change-clarify | clarify | decision | | 9 | `change-publish` | change-publish | build | artifact-ref (`docs/adlc/memory/chdr/`) | | 10 | `product-analyze` | product-analyze | analyze | findings | | 11 | `architect-analyze` | architect-analyze | analyze | findings | | 12 | `sweep` | inline (this skill, §The Sweep Step) | analyze | findings (`.adlc/coverage/coverage.md` + history) |

Refresh Route (1 step + loop)

| # | Step | Phase | output_type | |--|--|--|--| | 1 | `sweep` (rescan + rebuild + drift diff) | analyze | findings |

Correction Loops

• `product-analyze` / `architect-analyze` CRITICAL/HIGH → route back to **their own track's clarify**⭐ (executor default, bounded by `max_corrections`, default 2).
• `sweep` CRITICAL/HIGH findings route **by layer tag** : every finding carries `[layer: product|architecture|change|cross]` and routes to the matching track's clarify (`product-clarify` / `architect-clarify` / `change-clarify`). `cross` findings route to the track owning the cited record; ambiguous → halt for the human (hybrid gate). Bounded by `max_corrections`.

---

The Sweep Step (inline composite step)

The sweep is executed by this orchestrator (step `skill: factory-init`, prompt = this section), not by a leaf skill.

Inputs (all read-only)

| Source | Yields | |--| | `product-init` + `architect-init` setup scripts (re-run; idempotent JSON scanners) | sub-systems, feature-areas, tech stack | | `docs/adlc/memory/{pdr,adr,chdr}/` (legacy `.adlc/