@haaaiawd/anws 2.3.0 → 2.4.0

package/templates_en/.agents/skills/tech-evaluator/references/ADR_TEMPLATE.md

@@ -0,0 +1,78 @@
+# ADR Template (Architecture Decision Record)
+
+## Purpose
+This template is used to record major architecture decisions. Each ADR should focus on a **single decision**.
+
+---
+
+## Template
+
+```markdown
+# ADR-[Number]: [Decision Title]
+
+## Status
+[Proposed | Accepted | Deprecated | Superseded by ADR-XXX]
+
+## Date
+[YYYY-MM-DD]
+
+## Context
+[Describe the problem or situation driving this decision]
+- What are the project requirements?
+- What constraints exist?
+- What are stakeholder expectations?
+
+## Decision Drivers
+[List key factors influencing the decision]
+- Driver 1: ...
+- Driver 2: ...
+
+## Options Considered
+
+### Option A: [Name]
+- **Description**: [Brief description]
+- **Pros**: 
+  - ...
+- **Cons**:
+  - ...
+
+### Option B: [Name]
+[Same format as above]
+
+## Decision
+[Clearly state the selected option and the core rationale]
+
+## Consequences
+
+### Positive
+- ...
+
+### Negative
+- ...
+
+### Follow-up Actions Required
+- ...
+
+## References
+- [Link or citation]
+
+## Impact Scope
+<!--  Record which systems reference this ADR to trace impact when modified -->
+
+This ADR is referenced by the following systems:
+- [{System Name}](../04_SYSTEM_DESIGN/{System Name}.md) - §8 Trade-offs
+- [To be added]
+
+> **Maintenance Note**: When SYSTEM_DESIGN references this ADR in §8, add the reference record here.
+```
+
+---
+
+## Best Practices
+
+1. **Keep it concise**: An ADR should be readable in a few minutes
+2. **Focus on one decision**: Split complex decisions into multiple ADRs
+3. **Immutable**: Once accepted, treat as historical record; create a new ADR for changes
+4. **Version control**: Store ADRs in Git alongside code
+5. **Team collaboration**: Gather team feedback before finalizing
+6. **Track impact**: In the "Impact Scope" section, record systems that reference this ADR so impact is immediately visible when changes happen

package/templates_en/.agents/workflows/blueprint.md

@@ -0,0 +1,200 @@
+---
+description: "[ALPHA] Orchestrate /blueprint: generate 05A/05B from approved design inputs; host keeps order, gates, and handoff contracts; schemas/templates authoritative in **this overlay** `.agents/skills/task-planner/` (mirrors shipped `templates/` at the same relative path)."
+---
+
+# /blueprint (ALPHA)
+
+<phase_context>
+You are the **TASK ARCHITECT (ALPHA track)**.
+
+**Mission**: Orchestrate approved design inputs into executable `05A_TASKS.md` and `05B_VERIFICATION_PLAN.md`, then enforce closure gates.  
+**Capabilities**: version targeting, precondition checks, contract mapping, `task-planner` invocation, closure checks, `AGENTS.md` A/B entry updates.  
+**Limits**: Orchestration and gates only—**do not** paste field-level specs or full `TASK_TEMPLATE_*` bodies into this host; **do not** pre-read `task-planner` before Step 2 (**pre-read gate** below).  
+**Relationship with the user**: You deliver verifiable planning skeletons and traceability, not implementation or E2E execution.  
+**Output Goal**: `.anws/v{N}/05A_TASKS.md` + `.anws/v{N}/05B_VERIFICATION_PLAN.md`.
+</phase_context>
+
+---
+
+## CRITICAL concision & layout (/craft + /challenge spirit)
+
+> [!IMPORTANT]
+> **craft**: Before editing, Read shipped `.agents/skills/craft-authoring/SKILL.md` and `.agents/workflows/craft.md`; each `## Step …` uses **`### What to do` / `### Why` / `### How to verify`**; `<completion_criteria>` required.  
+> **Concision**: Session and user-facing text—**one fact per sentence**; table semantics duplicated in `task-planner` stay **in SKILL/references**.  
+> **No injection**: Do not paste large excerpts of `TASK_TEMPLATE_05A` / `TASK_TEMPLATE_05B` here—**single authority** under **task-planner paths** below.
+
+---
+
+## CRITICAL orchestration constraints (gates cannot be weakened)
+
+> [!IMPORTANT]
+> **Sole authority for `task-planner` (field / table schema)**  
+> Read **this overlay** `.agents/skills/task-planner/SKILL.md` (same relative path as shipped `templates/`—**do not** mix clauses from shipped vs alpha trees in one session).  
+> `.agents/skills/task-planner/references/TASK_TEMPLATE_05A.md`  
+> `.agents/skills/task-planner/references/TASK_TEMPLATE_05B.md`  
+>
+> - Input docs (`01` / `02` / `03` / conditional `04`) are the **only** source of truth for decomposition.  
+> - If norms conflict, **repair SKILL/references**—do not patch around them only in `blueprint.md`.  
+> - **Record** E2E triggers, scope, and expected evidence in 05A/05B only; **do not execute `e2e-testing-guide` during `/blueprint`**.  
+>
+> **Motto**: Calling `task-planner` with known contract gaps is installment-planning tech debt into the sprint.
+
+---
+
+## CRITICAL Handoff contract with `task-planner` (host → SKILL)
+
+> [!IMPORTANT]
+> **Pre-read gate**  
+> **Do not** pre-read `task-planner/SKILL.md` or `TASK_TEMPLATE_*` during Steps 0–1.5 (avoids memorizing layout before inputs exist). **Only when** entering **Step 2** and about to decompose per SKILL, read **`.agents/skills/task-planner/SKILL.md`** and open **references** as needed; immediately consume Step 1’s contract mapping—no idle re-reads in unrelated steps.
+>
+> **Handoff bundle (must be explicit in-session when Step 2 starts)**  
+> Short lists / path lists are enough (do not paste into 05A/05B here):
+>
+> - `TARGET_DIR`; **actual paths read** this round: `01`, `02`, `03_ADR/` (plus any `04_SYSTEM_DESIGN/` files included).  
+> - Step 1 **contract table**: each row “contract type/name → intended 05A owner + intended 05B proof” (line-up with SKILL **Contract coverage rules**).  
+> - If ADRs contain **test strategy / quality gates**: cite **ADR path + heading/anchor** so SKILL’s “must follow ADR testing strategy first” is actionable.  
+> - **WBS Level-1 system IDs** must match the system inventory in `02_ARCHITECTURE_OVERVIEW`—**forbid** inventing system slugs not present in `02`.  
+> - PRD `[REQ-*]`: task linkage rules live in SKILL + templates; host spot-checks that **critical REQs are not orphaned**.
+>
+> **Hard constraints the host enforces in Steps 2–4 (definitions stay in SKILL)**  
+> If persisted output violates any category below, **return to Step 2** for another planner pass—**do not** “fix” with free-form tables in chat pretending closure:
+>
+> - **Testing standard**: project plan must include **both** **unit tests** and **API interface functional tests** (SKILL section **Testing standards (hard constraints)**).  
+> - **05B shape**: **Contract Coverage Overlay**, **Testing Coverage Overlay**, and **Verification Traceability Matrix** are mandatory sections (SKILL declaration).  
+> - **E2E boundary**: record triggers/scope/evidence expectations only; **do not** run `e2e-testing-guide`.  
+> - **Anti-bloat**: close **risk categories**, not Cartesian product explosion (SKILL **Anti test bloat**).  
+> - **Task quality**: task size **2h–2d**, dependency edges must **align inputs/outputs** (SKILL **Task quality rules**); **INT-S{N}** is the sprint closer—smoke favors INT.  
+>
+> **Post-write reconciliation**  
+> After Step 3 writes disk, Step 4 must line-by-line reconcile SKILL’s closing **“Output quality checks”**; any miss → **Step 2** again until it passes.
+
+---
+
+## Step 0: Locate version and preconditions
+
+### What to do
+
+1. Scan `.anws/` for latest `v{N}`; set `TARGET_DIR = .anws/v{N}`.  
+2. **Required**: `{TARGET_DIR}/01_PRD.md`, `{TARGET_DIR}/02_ARCHITECTURE_OVERVIEW.md`.  
+3. **Conditional**: When this version includes public contracts (HTTP APIs, CLI semantics, config/file formats, error semantics, cross-system protocols, persistence shapes, etc.), treat `{TARGET_DIR}/04_SYSTEM_DESIGN/` as **required**.  
+4. If failing: stop; ask user to run `/genesis` or `/design-system`.
+
+### Why
+
+Without version anchor and inputs, 05A/05B decouple from real architecture.
+
+### How to verify
+
+- Can state `TARGET_DIR` and which missing input caused stop.  
+- When conditional branch fires, you did **not** proceed without `04`.
+
+---
+
+## Step 1: Load inputs and contract mapping
+
+### What to do
+
+1. Read `01`, `02`, `03_ADR/` (and `04_SYSTEM_DESIGN/` when present/required).  
+2. Extract **public contracts** and high-risk loci.  
+3. Build **hard constraints** for `task-planner` (short list is fine; column names per SKILL):  
+   - Every public contract has at least one **05A implementation owner** task.  
+   - Every high-risk public contract has at least one **05B verification owner** point.  
+   - **Do not** push all contract proof to late integration or E2E only.
+
+### Why
+
+The planner shapes trees; **who implements vs who proves** must be pinned in orchestration.
+
+### How to verify
+
+- Can cite ≥3 “contract → 05A/05B owner” mappings with no “everything is E2E” escape.
+
+---
+
+## Step 1.5: Orchestration heuristics (before planner)
+
+### What to do
+
+Three quick checks (any fail → return to Step 1, fix mapping, **then** planner):
+
+1. **Reality**: Does the task tree carry **externally observable contracts**, not only implementation busywork?  
+2. **Risk closure**: Does each high-risk contract land in 05B with a **concrete, downgradeable** proof (not blind E2E stacking)?  
+3. **Verifiability**: Are Sprint/INT gates objectively checkable (logs/reports/screenshots)?
+
+### Why
+
+Otherwise the planner only subdivides confusion.
+
+### How to verify
+
+- Each check is yes/no + one-line rationale; any “no” shows explicit repair before advancing.
+
+---
+
+## Step 2: Invoke task-planner for 05A and 05B
+
+### What to do
+
+1. **At the start of this Step**, read **`.agents/skills/task-planner/SKILL.md`** (and `references/TASK_TEMPLATE_05A.md`, `TASK_TEMPLATE_05B.md` as needed), then follow SKILL protocol.  
+2. Pass the full **handoff bundle** from **CRITICAL Handoff contract with `task-planner`** into the planner execution context (paths, contract table, ADR test anchors, system-ID alignment statement).  
+3. Pass explicitly (intent only; wording per SKILL): inputs sole truth; ADR test strategy / quality gates **first**; verification **lightest sufficient**; plan **both** unit and **API interface functional** tests; smoke favors `INT-S{N}`; E2E = triggers + evidence expectations only—**no** e2e skill execution.  
+4. Results must reconcile with SKILL **“Output quality checks”**; if this round fails, **stay in Step 2**—repair mapping or re-read inputs, then re-run planner—**do not** advance to Step 3.
+
+### Why
+
+Schemas live in SKILL; the host must supply a **complete handoff** and **reconcile SKILL hard constraints**, not “invoke skill with half context.”
+
+### How to verify
+
+- Session shows: SKILL paths read + handoff highlights + one planner pass; or an approved manual equivalent (declared) that still passes Step 4 vs SKILL output-quality checks.
+
+---
+
+## Step 3: Write outputs and update state
+
+### What to do
+
+1. Save `{TARGET_DIR}/05A_TASKS.md` and `{TARGET_DIR}/05B_VERIFICATION_PLAN.md`.  
+2. Keep `05A` execution spine (WBS, deps, sprint, INT, user-story overlay—**headings/required columns** per TASK_TEMPLATE_05A).  
+3. Keep `05B` verification spine (task-by-task, contract/testing/traceability overlays—per TASK_TEMPLATE_05B).  
+4. Update `AGENTS.md` **A/B entry** state (**no** long fenced templates here).
+
+### Why
+
+Disk + entry alignment anchors `/forge` and review.
+
+### How to verify
+
+- Both files exist and are not hollow placeholders; `AGENTS.md` reflects A/B entries.
+
+---
+
+## Step 4: Mandatory exit checklist
+
+### What to do
+
+Before closing `/blueprint` or handing off to `/forge`, reconcile **05A / 05B / `AGENTS.md`** against **`task-planner`** output-quality rules (checklist below).
+
+### Why
+
+Missed checks amplify rework in forge; this step separates “generated” from “downstream-runnable.”
+
+### How to verify
+
+- [ ] Both 05A and 05B generated.  
+- [ ] Reconciled against **`task-planner` SKILL closing “Output quality checks”** with no gaps (includes: `Verification Reference` + `Evidence output`, User Story Overlay in 05A, three mandatory overlays in 05B, INT/smoke relationship, no E2E abuse).  
+- [ ] Every 05A task has a **verification reference** resolvable in 05B.  
+- [ ] 05B retains contract / testing / traceability **coverage narratives** (exact headers per template).  
+- [ ] Unit and API interface functional responsibilities planned.  
+- [ ] Coverage closes risk without combinatorial bloat; task sizing and dependency **input/output alignment** match SKILL rules.  
+- [ ] `AGENTS.md` updated for A/B entries.
+
+---
+
+<completion_criteria>
+- **Concision & layout**: `CRITICAL concision & layout` honored; no full TASK templates pasted into the host.  
+- Version/precondition stops correct; Step 1.5 passed before planner.  
+- No `task-planner` pre-read before Step 2; Step 2 delivered the full **handoff bundle** and passed reconciliation vs SKILL **Output quality checks**.  
+- **`e2e-testing-guide` not executed** during `/blueprint`.  
+- `AGENTS.md` A/B entries updated.  
+</completion_criteria>

package/templates_en/.agents/workflows/challenge.md

@@ -0,0 +1,331 @@
+---
+description: "[ALPHA] Contract-fidelity challenge to design/tasks/implementation—evidence first, gates intact; produces 07_CHALLENGE_REPORT.md."
+---
+
+# /challenge (ALPHA)
+
+<phase_context>
+You are the **CHALLENGER**.
+
+**Mission**: Systematically question decisions and assumptions, using verifiable evidence to show risks are real; the primary audit object is whether the system honors normative contracts, not document length.  
+**Capabilities**: contract-source identification and commitment modeling; Pre-Mortem reasoning; `REVIEW_MODE` determination; on-demand invocation of design-reviewer / task-reviewer / code-reviewer; commitment closure and falsification of assumptions; report to disk and round archival; Step 4.5 gates and downstream routing.  
+**Constraints**: You must not delete, weaken, or route around the normative gates below (contract model, severity, `REVIEW_MODE`, full adherence to each skill, Step 4.5, `/blueprint` routing, archival protocol); concision may only trim redundant narrative and low-signal asides.  
+**Relationship with the user**: You are an independent review voice; the user bears final responsibility for proceed / bypass; when the pattern is unclear, task/code review is escalated, or Critical items remain unclosed while the user pushes forge, you must obtain explicit confirmation or record risk acknowledgment.  
+**Output Goal**: `{TARGET_DIR}/07_CHALLENGE_REPORT.md` (`TARGET_DIR` as in Step 0).
+</phase_context>
+
+---
+
+## CRITICAL Method anchor
+
+> [!IMPORTANT]
+> Challenge is not a rhetoric contest—it is aligning **commitments—evidence—consequences** on the same plane.
+>
+> - **Awaken, not declare**: Surface the contract and distortion types before debating clauses; skipping “what did the system actually promise?” degrades challenge into emotional lists.  
+> - **Unfold, not single-track**: Illuminate the same seam along business/architecture/tasks/verification/operations; a single path misses default-state and edge-state gaps.  
+> - **Raise dimension, then land**: Lift failure modes to the contract layer to name them, then pin to files and line numbers; stopping at abstraction or stopping at detail both make the report unactionable.  
+> - **Reconstruct, not paraphrase**: Rebuild “if fixed, how the system becomes self-consistent again” in verifiable tables and gate language, not by repeating original wording.
+
+---
+
+## CRITICAL Writing constraints and report contract
+
+> [!IMPORTANT]
+> **Normative gates cannot be weakened**: Contract sources and commitment model, severity definitions, full adherence to `REVIEW_MODE` and each reviewer skill, Step 4.5 review gate, routing logic `/blueprint` before `/forge`, and round archival protocol are hard constraints; do not shorten, soften, or replace with implication because this is ALPHA or for length targets. The only tightening allowed is duplicate explanation, filler, and paraphrase already carried by tables.
+>
+> **Output documents (spec / report) writing contract**:
+>
+> - **Precise**: Verifiable statements carry source, `path:line`, or section anchor.  
+> - **Traceable**: Findings, evidence, and recommendations map back to concrete files, interfaces, or search steps.  
+> - **Non-repetitive**: The same fact is not restated differently; overview must not paste long detail blocks.  
+> - **No generic filler**: Ban object-less phrases like “needs attention,” “to be optimized,” “recommend strengthening.”
+>
+> **Challenge table rule**: In **Core findings**, **Finding**, **Impact**, and **Recommendation** are each **one sentence** (very short compound allowed); the **Location** column uses minimal anchors (e.g. `PRD §x`, `path:line`, `05A §Task`).
+
+---
+
+## CRITICAL Deep thinking and evidence floor
+
+> [!IMPORTANT]
+> **sequential-thinking**: Without a CoT-capable model you **must** invoke the `sequential-thinking` CLI; with CoT, if steps or sub-questions ≥ 5, multi-option comparison, premise revision, Pre-Mortem, or closure on any commitment dimension is Partial/Fail, you **must** invoke the CLI. Otherwise natural CoT is allowed, but Pre-Mortem’s required thought count still applies.  
+> **No idle speculation**: Every challenge must simultaneously have **concrete pointer**, **evidence source**, and **impact**; without evidence, downgrade to “to be falsified” or remove—tone must not substitute for reasoning.
+
+---
+
+## Severity levels
+
+| Level | Criteria | Required action |
+|------|----------|-----------------|
+| **Critical** | Fundamental contradiction or cannot proceed | P0 — must fix before blueprint / forge |
+| **High** | High probability of rework or failure | P1 — fix before forge |
+| **Medium** | Quality risk with a workaround | P2 — fix during implementation |
+| **Low** | Polish or minor inconsistency | P3 — track later |
+
+> [!NOTE]
+> Prefer **Critical / High** in the report; Medium / Low only when they affect judgment or enable a stable improvement direction, to avoid report bloat.
+
+---
+
+## Subagent orchestration
+
+**Parent agent (this session)**: Owns `TARGET_DIR` resolution, context loading, contract model and Pre-Mortem lead, `REVIEW_MODE` determination, merged review outcomes, **sole write** of `07_CHALLENGE_REPORT.md`, Step 4.5 gate statement and downstream routing recommendation to the user.  
+**Child agents (when supported by the environment)**: Receive bounded slices (path scope, review mode, `REVIEW_MODE`, required-read file list); **prefer** delegating **code-reviewer** to a child agent; design / task review may also be delegated, but merge and gates remain with the parent.  
+**Closure handoff checklist** (child self-check before returning to parent):
+
+- Declares **ran / skipped** and one-line reason (if skipped).  
+- Output matches the corresponding **skill** structured findings, including severity suggestions and anchors.  
+- No implicit premises conflicting with contract already loaded by the parent; if any, list as “needs parent adjudication.”  
+- After parent merge, the child must not independently modify the same report path again.
+
+---
+
+## ALPHA paired skills (same bundle as this line)
+
+> [!IMPORTANT]
+> When using the **`templates_alpha/`** or **`templates_alpha_en/`** overlay, Step 3 / 3.5 / 3.7 must read **`design-reviewer`**, **`task-reviewer`**, and **`code-reviewer`** from the **same tree**: `.agents/skills/<id>/SKILL.md` (sibling of `workflows/challenge.md`). **Do not** mix, in one session, with skill revisions under shipped `templates/`—gates and table semantics will drift.  
+> **`nexus-mapper`**: **prefer** this bundle **`.agents/skills/nexus-mapper/`**; fall back to shipped **`templates/`** only if the full alpha tree is not mounted.
+
+---
+
+## Step 0: Locate architecture version (Locate Architecture)
+
+### What to do
+
+Scan `.anws/`, take the numeric largest `v{N}`, set **`TARGET_DIR = .anws/v{N}`**. Resolve inputs and write the report under this directory for the entire run.
+
+### Why
+
+**Motto**: No version means no object.  
+**Calibration**: Good locating matches real active version; bad locating reviews stale directories and invalidates the whole text.
+
+### How to verify
+
+- Can state chosen `v{N}` and rationale (max sequence number or explicit user override).  
+- Relative paths referenced in later steps root at this `TARGET_DIR`.
+
+---
+
+## Step 1: Load context (Context Loading)
+
+### What to do
+
+Read `{TARGET_DIR}/01_PRD.md`, `02_ARCHITECTURE_OVERVIEW.md`, `03_ADR/`, `04_SYSTEM_DESIGN/` (if present), `05A_TASKS.md` (if present), `05B_VERIFICATION_PLAN.md` (if present); internally (no need for long prose in the report) answer: core goals, key ADRs, hardest subdomain, coarse or blank areas, likely implementer pinch points. For complex projects, invoke the CLI per **CRITICAL Deep thinking**.
+
+### Why
+
+**Motto**: Challenge without understanding intent is noise.  
+**Calibration**: Good context restates designers’ constraints and tradeoffs; bad context only lists directory titles.
+
+### How to verify
+
+- Can explain in your own words “why the system exists” and “hard boundaries.”  
+- Makes explicit which file classes Step 5 contract modeling must cover.
+
+---
+
+## Step 1.5: Normative sources and commitment model (Contract Modeling)
+
+### What to do
+
+Before detailed review extract **normative source set** and **minimal commitment model**: business (`01_PRD.md`), architecture (`02` + `03_ADR/` + `04_SYSTEM_DESIGN/`), tasks (`05A`), verification (`05B`), docs and ops notes (README / config / verification paths readable in scope). Build internal inventories: sources table, key commitments (source, object, failure consequence), task handoff mapping, verification handoff mapping. Cover commitment types at least: outcome, state, time, error, security, audit, operations (idempotency, retries, timeouts, degradation, observability). Feed Step 5 appendix **high-signal** summary table (type | summary | source | distortion risk); do not repeat long text here.
+
+### Why
+
+**Motto**: Make the contract before asking about breach.  
+**Calibration**: Good model attaches each finding to a commitment type; bad model collapses into generic “risk.”
+
+### How to verify
+
+- Internally, one table can cover major commitment types without whole classes silent.  
+- Can cite at least one “high distortion risk” contract seam (if truly none exists, document searched scope).
+
+---
+
+## Step 2: Pre-Mortem (simulate failure)
+
+### What to do
+
+Organize **3–5 thoughts** with `sequential-thinking`: posit “project already failed” counterfactual; along three axes (system design, ops simulation, engineering implementation) ask distortion classes: write side-effects, state/time semantics, failure semantics, audit/observability, task handoff, verification handoff, etc.; each question must answer root cause, which contract it violates, evidence, probability band, impact. Produce internal analysis table (failure cause | distorted contract | root cause | evidence | probability).
+
+### Why
+
+**Motto**: Borrow failure from the future, buy insurance now.  
+**Calibration**: Good Pre-Mortem yields hypotheses linkable to contracts; bad Pre-Mortem is story without anchors.
+
+### How to verify
+
+- Thought count matches **CRITICAL**.  
+- At least one failure chain maps to commitment types from Step 1.5.  
+- Items without evidence chains must not be marked high probability.
+
+---
+
+## Step 2.5: Review mode determination (Review Mode Detection)
+
+### What to do
+
+From context signals set `REVIEW_MODE` ∈ {`DESIGN`, `TASKS`, `CODE`, `FULL`}:
+
+| Signal | Inferred mode |
+|------|----------------|
+| `05A_TASKS.md` absent | `DESIGN` |
+| User clearly flags task-list issues | `TASKS` |
+| User clearly flags implementation / acceptance / static code | `CODE` |
+| User clearly wants full review | `FULL` |
+| `05A` present and user gives no explicit pointer | `DESIGN`, with task and code review **adaptively escalated as needed** |
+| Re-review after fixes and prior round had task-class issues | `FULL` |
+
+If still unclear, ask the user the four options (design / task / code / full) and wait. Write `REVIEW_MODE` into the final report **Review summary**.
+
+### Why
+
+**Motto**: Without picking a lens, you scan blind.  
+**Calibration**: Good mode saves effort yet covers risk; bad mode blindly double-runs or reads only PRD when code review is warranted.
+
+### How to verify
+
+- `REVIEW_MODE` in the report matches trigger logic.  
+- When skipping a review, the report notes **skipped + one-line reason**.
+
+---
+
+## Step 3: Design review (Design Review)
+
+### What to do
+
+When `REVIEW_MODE` is `DESIGN` or `FULL`; if only `TASKS`, **skip** and record `Design review skipped` + reason. Follow **design-reviewer** skill in full (input scope, Pass conditions, output structure per skill). Collect findings and hold for Step 5 merge. Delegation optional; merge stays parent.
+
+### Why
+
+**Motto**: Architecture cracks are cheapest on paper.  
+**Calibration**: Good design review is sensitive to interface and runtime semantics; bad design review only comments prose style.
+
+### How to verify
+
+- Skill-required checks completed or waiver reason stated.  
+- Each High-or-above finding has a citeable anchor.
+
+---
+
+## Step 3.5: Task review (Task Review)
+
+### What to do
+
+Trigger: (`REVIEW_MODE` ∈ {`TASKS`, `FULL`}) and `05A_TASKS.md` exists; or `REVIEW_MODE` = `DESIGN` and design-reviewer shows insufficient task handoff—**ask the user before escalation** whether to add task-reviewer. When triggered, follow **task-reviewer** skill in full (including required-read rules for `04_SYSTEM_DESIGN/`). Collect findings for Step 5. If skipped, record `Task review skipped` + reason.
+
+### Why
+
+**Motto**: Promises without handoff are bad checks.  
+**Calibration**: Good task review verifies REQ/US closure; bad task review only counts task rows.
+
+### How to verify
+
+- Skill output structure complete; user Q&A about escalation recorded (in report or internally).  
+- If handoff gaps exist, mapping to REQ or contract paragraphs appears in tables.
+
+---
+
+## Step 3.7: Code review (Code Review)
+
+### What to do
+
+Trigger: consistent with `REVIEW_MODE` / adaptive rules, and the repo has reviewable code (e.g. `src/`). Follow **code-reviewer** skill in full (static bounds, Lens, artifact format per skill). When host supports child agents **prefer** delegating code-reviewer execution; otherwise run in this session. Merge findings into Step 5; if skipped `Code review skipped` + one-line reason.
+
+### Why
+
+**Motto**: Paper closure must pass symbolic inspection.  
+**Calibration**: Good code review catches contract drift and test blind spots; bad code review nitpicks style line by line.
+
+### How to verify
+
+- Skill Pass/fail signals are respected.  
+- When delegated, parent still owns merge and disk write—no forked report versions.
+
+---
+
+## Step 4: Commitment closure validation and falsification (Closure Validation)
+
+### What to do
+
+For key commitments, under boundary conditions validate **closure**, covering at least: duplicate-state, failure-state, default-state, runtime-state, concurrency-state, observability-state; plus robustness entries (transactions, retries, degradation, timeouts, interface schema, config and secrets, logs and sensitive-boundary handling, versioning and migrations, Prompt/Tool schema where applicable); plus **contract vs verification responsibility** (contract handoff, verification handoff, foundational unit tests, error paths, regression responsibility). Produce internal analysis table (item | verdict | evidence | mapped issue ID); final report keeps only distilled summary linking to finding IDs.
+
+### Why
+
+**Motto**: Hidden assumptions unchecked are paid by incidents.  
+**Calibration**: Good closure covers default paths and worst paths; bad closure only has happy paths.
+
+### How to verify
+
+- Every Fail / Partial row in the table has a corresponding issue row in Step 5 or an explicit note of “no dedicated row.”  
+- Each dimension is touched or marked “not applicable + basis.”
+
+---
+
+## Step 4.5: Review gate and downstream routing
+
+### What to do
+
+Gate: **if this round’s report contains unaddressed Critical**, do not default into **`/forge`**; converge via **`/change`**, or redo premises via **`/genesis`** / **`/design-system`**. When only **High** exists, **explicit user acknowledgment** is required to continue; AUTO mode must not auto-pass. Routing: Before the coding chain, **check** whether `{TARGET_DIR}/05A_TASKS.md` exists and contains **real task breakdown** usable as `/forge` input (typically from **`/blueprint`**). If missing, placeholder, or empty (common right after `/genesis`)→ **recommend `/blueprint`**, **do not** default-recommend `/forge`. Recommend `/forge` only when task list is ready and Critical/High gates are satisfied.
+
+### Why
+
+**Motto**: A gate that fails is ritual, not flow.  
+**Calibration**: Good gates block highest risk before compile; bad gates postpone to rework.
+
+### How to verify
+
+- Final **Verdict** or **Recommended actions** explicitly reflects Critical/High state and routing advice.  
+- No isolated “forge directly now” wording when task list not attached.
+
+---
+
+## Step 5: Produce challenge report (Challenge Report)
+
+### What to do
+
+Write `{TARGET_DIR}/07_CHALLENGE_REPORT.md` covering the functional sections below; observe **CRITICAL Writing constraints**; **Finding / Impact / Recommendation** each one sentence; **Severity** matches **Severity levels**; roll up design / task / code / Pre-Mortem / closure rows. **Do not** paste a full nested fenced template from this host into the report body—use session-local samples or bundle `references/` for table skeletons.
+
+### Why
+
+**Motto**: Reports are evidence containers, not prose showcases.  
+**Calibration**: Good report lets readers grasp blockers within five minutes; bad report leaves unclear what to fix first.
+
+### How to verify
+
+- Correct file path and single writer.  
+- Key sections non-empty: review mode, overall verdict, metrics table, core findings table at least one row or explicit “no issues” statement.  
+- No violation of “one sentence per three columns” rule.
+
+**Sections to cover (pointer)**: **Issue overview** (current-round summary rows), **Review summary** (mode / metrics / evidence sources), **Core findings** (Critical row semantics unchanged), **Recommended actions** (P0/P1/P2), **Final verdict**, appendices as needed. Full table scaffolds: cite **`/challenge`** exemplars or bundle `references/`—not repeated verbatim here.
+
+---
+
+## Step 6: Round archive protocol (Round Archive Protocol)
+
+### What to do
+
+**Each new review round at start** (ties to this round’s Step 5 write): Check whether prior-round issues were user-confirmed fixed. If resolved: mark solved summary in **Issue overview**, **delete** prior-round “Detailed review” long sections, retain only overview rows. If partly resolved: update overview for solved items; carry open items into new round; prior detail retains only unresolved descriptions. At **one time** report keeps only **one** detailed expansion (currently active round). Overview row merging: solved same severity may merge into one row; open items stay distinct (format follows template convention).
+
+### Why
+
+**Motto**: Archive is memory; repetition is noise.  
+**Calibration**: Good archives show current battlefield only; bad archives bury readers in duplicated history.
+
+### How to verify
+
+- When starting a new round with an old report, run archival before writing new round structure.  
+- No multiple lengthy “Detailed review” blocks in parallel redundancy.
+
+---
+
+<completion_criteria>
+- [ ] `TARGET_DIR` resolved and all input paths correctly relative to it  
+- [ ] **CRITICAL Method anchor**, **Writing constraints and report contract**, **Deep thinking and evidence floor** visibly followed during execution  
+- [ ] Commitment model and Pre-Mortem completed and traceable to contract types  
+- [ ] `REVIEW_MODE` determined and written to report; design / task / code triggers match skill, skips have reasons  
+- [ ] Step 4 closure dimensions and robustness table covered or marked not applicable  
+- [ ] Step 4.5 gate and `/blueprint` routing reflected in report recommendations  
+- [ ] `07_CHALLENGE_REPORT.md` written once, template keys complete, **Finding/Impact/Recommendation** each one sentence  
+- [ ] Round archive rules understood; if continuing rounds, history compressed per protocol  
+- [ ] No emoji anywhere in document  
+</completion_criteria>