Factory Init

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

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:

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)

Refresh Route (1 step + loop)

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 (ADR-361): 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/memory/ fallback, + indexes) | accepted decisions per layer | | docs/adlc/product/PRD.md, docs/adlc/architect/AD.md | compiled artifacts | | .adlc/coverage/coverage.md (if exists) | previous matrix → drift diff |

Output: .adlc/coverage/coverage.md (+ history/<date>-<run_id>.md)

1. Pivot: Area Coverage — row axis is the union of sub-systems ∪ feature-areas, reconciled by name/directory overlap with a mapping column; unreconciled rows stay separate and are flagged. Every cell cites evidence (record IDs, file paths) — no fabricated cells.

## Pivot: Area Coverage

| Area | Feature-Area | Sub-System | PDRs | ADRs | ChDRs | Code Evidence | Coverage |
|------|--------------|------------|------|------|-------|---------------|----------|
| payments | billing | payments | 3 | 1 | 4 | present (src/payments/) | 62% |

2. Relations — four pairwise, bidirectional; each section has a Coverage: N% line and gap lines citing record IDs or paths, each tagged [layer: ...]:

PDR↔ADR mapping requires textual overlap between records — proposed, never asserted.

Every gap line uses the form:

- Gap: <description citing PDR-NNN / ADR-NNN / ChDR-NNN or a file path> [layer: product|architecture|change|cross]

3. Severity model (family standard): constitution violation = CRITICAL; accepted decision contradicted by code = HIGH; undocumented/undecided mismatches = MEDIUM; unreconciled areas, style = LOW.

4. Drift section — ## Drift vs <previous date> sweep (or ## Baseline on first sweep): new gaps, closed gaps, regressed areas. On refresh, this diff IS the report.

5. Findings output — severity-ranked summary published as output_type: findings (comment bus if tracker-integrated, else runs/<run_id>/findings/sweep.md); every finding tagged [layer: ...] for correction routing (ADR-361). The matrix file itself is the artifact; the matrix never edits records — it reports, clarify fixes.