factory-init
Use when onboarding a brownfield repo onto ADLC end-to-end, or running the recurring PDR↔ADR↔ChDR↔code alignment sweep (--refresh).
tikalk · Static checks on file
Installation
Read the source and dependencies before running a command. Copying does not install or execute anything.
npx skills add tikalk/adlc-team-skills --skill factory-initAbout this skill
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-productandfactory-architect(specify routes) instead. - Single-layer work →
factory-product/factory-architect/factory-learndirectly. - 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-analyzeCRITICAL/HIGH → route back to their own track's clarify⭐ (executor default, bounded bymax_corrections, default 2).sweepCRITICAL/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).crossfindings route to the track owning the cited record; ambiguous → halt for the human (hybrid gate). Bounded bymax_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/