cfsa-antigravity 2.7.0 → 2.9.0

package/template/.agent/workflows/ideate-validate.md

@@ -19,154 +19,98 @@ pipeline:
 
 Explore constraints, verify domain exhaustion, and compile the vision summary.
 
-**Prerequisite**: If invoked standalone, verify `docs/plans/ideation/ideation-index.md` exists with leaf nodes at `[DEEP]` or `[EXHAUSTED]` level. If not, prompt the user to run `/ideate-discover` first.
+**Prerequisite**: If invoked standalone, verify `docs/plans/ideation/ideation-index.md` exists with leaf nodes at `[DEEP]` or `[EXHAUSTED]` level. If not → **STOP**: "Run `/ideate-discover` first."
 
 ---
 
 ## 7.5. Read Engagement Tier
 
-Read `## Engagement Tier` from `docs/plans/ideation/ideation-index.md`. Apply to gates in this shard:
+Read `## Engagement Tier` from `docs/plans/ideation/ideation-index.md`.
 
-- **Auto**: Steps 8 (constraints, metrics, competitive positioning) → agent self-interviews using Deep Think, writes answers to files. Step 10.5 (below) provides a review checkpoint before compilation.
-- **Hybrid**: Steps 8 product decisions → pause for user. Structural checks → auto.
-- **Interactive**: All steps pause for user confirmation.
+Read `.agent/skills/prd-templates/references/engagement-tier-protocol.md` — apply the tier's gate behavior for this shard.
 
 ## 8. Constraints and metrics
 
-Read `.agent/skills/idea-extraction/SKILL.md` and follow its Deep Think Protocol.
+Read `.agent/skills/idea-extraction/SKILL.md` → Deep Think Protocol.
 
-Read `.agent/skills/prd-templates/references/ideation-meta-template.md` for the constraints template.
+Read `.agent/skills/prd-templates/references/constraint-exploration.md` — follow the constraint questions, tier-specific behavior, success metrics, and competitive positioning procedures.
 
-Explore constraints with the user. Write to `docs/plans/ideation/meta/constraints.md`:
+**Showstopper detection**: If any constraint is classified as a fundamental viability blocker (e.g., regulatory impossibility, technical impossibility with current tech, market size < viable threshold) → **STOP**. Present to the user:
 
-1. **Budget** — Self-funded? VC-backed? Monthly infrastructure ceiling?
-2. **Timeline** — Launch target? Phased rollout?
-3. **Team** — Solo dev? Small team? Skill gaps?
-4. **Compliance** — GDPR, PCI, COPPA, HIPAA, SOC 2? Age restrictions?
-5. **Performance** — Expected scale (users, requests, data)? Latency requirements?
-6. **Surface classification validation** — Verify the structural classification from `ideation-index.md` (set in `ideate-extract` Step 1.3) still holds. Have any new surfaces been discovered during exploration? Has the project shape changed (e.g., what started as single-surface now has a mobile app too)? If the classification needs updating, update it now and note any domain files that need to be relocated.
+> ⚠️ **Potential showstopper identified**: [constraint description]
+>
+> Options:
+> 1. **Pivot** — modify the idea to avoid this constraint
+> 2. **Accept risk** — proceed knowing this constraint exists
+> 3. **Abandon** — this idea is not viable
 
-**Deep Think**: "Based on the product type and user personas, what constraints would I expect that haven't been mentioned? For example, does this product handle payments (PCI)? Does it serve minors (COPPA)? Does it store health data (HIPAA)?"
+Wait for user decision. If pivot → update problem statement and loop back to re-explore affected domains. If accept risk → document in `meta/constraints.md` as accepted risk and continue. If abandon → end the workflow.
 
-**Interactive/Hybrid**: Present each constraint question to user, wait for answers. Write each confirmed constraint to `meta/constraints.md` immediately.
-
-**Auto**: Self-interview using Deep Think. Write all answers with reasoning to `meta/constraints.md` immediately. Mark each answer as `[AUTO-CONFIRMED]` for traceability.
-
-If the surface classification changed, update `ideation-index.md` `## Structural Classification` section.
-
-### Success metrics
-
-For each persona, define concrete success metrics. Write to `ideation-index.md` (or link to domain files where the metric applies):
-
-- What metric proves this product solves the persona's problem?
-- What's the target number? (specific — not "good response times")
-- What's the measurement method?
-
-### Competitive positioning
-
-If not already explored in `/ideate-discover` Step 4, explore competitive landscape now. Write to `docs/plans/ideation/meta/competitive-landscape.md`:
-
-- Name 2-4 direct competitors
-- For each: what they do well, where they fail, how we differentiate
-- What's the moat? (network effects, data, expertise, switching costs)
+If the surface classification changed during constraint exploration, update `ideation-index.md` `## Structural Classification` section.
 
 ---
 
 ## 9. Domain exhaustion check
 
-This is the final validation gate before compilation.
-
-### Read the fractal tree
+Read `.agent/skills/prd-templates/references/domain-exhaustion-criteria.md` — apply all criteria and follow the execution procedure.
 
-Read `docs/plans/ideation/ideation-index.md` and recursively review:
-- Every node's status marker (surface → domain → sub-domain → feature)
-- All leaf feature files' status markers
-- All CX files at every level for pending entries
+If any criterion fails → take the specified action. If proportionality fails → return to `/ideate-discover` for under-explored areas.
 
-### Exhaustion criteria
+### 9.5. Domain Gap Reasoning (missing domain detection)
 
-| Check | Criteria | Action if Fail |
-|-------|----------|----------------|
-| All leaf nodes ≥ `[DEEP]` | Every feature file in the tree is `[DEEP]` or `[EXHAUSTED]` | Drill remaining feature files |
-| Status propagation correct | Parent nodes reflect their children's status | Update parent indexes |
-| All Must Have features ≥ Level 2 | Every Must Have has sub-features AND edge cases AND Role Lens | Deep Think + drill |
-| Deep Think zero hypotheses | Final Deep Think pass across ALL leaf nodes yields no new hypotheses | Present any new hypotheses, drill if confirmed |
-| All CX files clean | No Medium/Low confidence entries remain at any level — all are High or rejected | Run synthesis questions on pending pairs |
-| Role Lens complete | Every feature file has a populated Role Lens table | Fill missing Role Lens entries |
-| User confirmation | User explicitly confirms "nothing else" for each domain | Ask for each under-explored domain |
+After verifying existing domains are deep enough, reason about whether **entire domains are missing**:
 
-### Execute exhaustion check
+1. **Product archetype analysis**: Identify the product archetype (e.g., marketplace, SaaS tool, social platform, developer tool). List the standard domain categories for this archetype.
+2. **Gap identification**: Compare the standard domain list against the actual domain folders in `docs/plans/ideation/domains/`. List any standard domains with no corresponding folder.
+3. **Cross-feature gap detection**: Read all CX files. For each unresolved cross-cut, ask: "Does this cross-cut imply a domain that doesn't exist yet?" (Example: if multiple features reference "notifications" but no notifications domain exists, that's a structural gap.)
+4. **Present missing domains**:
 
-1. Walk the fractal tree. For each leaf node below `[DEEP]`:
-   - "Feature [X] in [domain] is still at [status]. Drill deeper or intentionally minimal?"
-   - If "drill" → return to `/ideate-discover`
-   - If "intentionally minimal" → note in feature file and proceed
+> 🏗️ **Potential missing domains:**
+>
+> Given this is a [product archetype], these domains are standard but not present:
+> - **[Domain A]** — [why it's expected: most [archetype] apps have this because...]
+> - **[Domain B]** — [why it's expected: cross-cuts between features X and Y imply this]
+>
+> These are suggestions. You may have intentionally excluded them. Want to add any?
 
-2. Run **final Deep Think pass**: For each `[DEEP]` leaf node, apply the four Deep Think questions. Present any new hypotheses.
-   - If confirmed → drill, update feature files
-   - If zero hypotheses → mark `[EXHAUSTED]`, propagate status upward
+**STOP** — wait for user response. For each accepted domain:
+1. Create the domain folder with index and CX files
+2. Run a quick Level 1 breadth sweep (from idea-extraction skill)
+3. Re-run the exhaustion check on the expanded domain set
 
-3. Walk ALL CX files at every level. Resolve any Medium/Low confidence entries.
+For rejected domains: add to `ideation-index.md` `## Considered & Rejected` section.
 
-4. Verify all feature files have populated Role Lens tables.
-
-5. Update `ideation-index.md` progress summary with final counts (total leaf nodes, exhausted count, CX entries confirmed).
-
----
-
-## 10. Vision deepening (if needed)
-
-After the exhaustion check, verify proportionality:
-
-- **Rich inputs**: Total domain file content (all files combined) should be at least 30% of the original source document's line count. If short, identify what was lost.
-- **All inputs**: Each domain with `[DEEP]` or `[EXHAUSTED]` status should have at least 3 sub-areas drilled with edge cases.
-
-If proportionality fails, return to `/ideate-discover` for the under-explored areas.
+**Loop guard**: Track how many times this shard has returned to `/ideate-discover` for exhaustion remediation.
+- **1st return** → normal. Run discover again on the flagged areas.
+- **2nd return** → warn: "This is the second remediation loop. Remaining gaps: [list]. Resolve these specifically or they will be escalated."
+- **3rd return** → **STOP**: "Exhaustion check has failed 3 times. Remaining gaps: [list]. Present these to the user as known gaps and ask: accept as-is, or manually provide the missing content?"
 
 ---
 
 ## 10.5. Auto Tier Review Checkpoint (Auto tier only)
 
-If engagement tier is **Auto**, present a comprehensive review before compilation:
+If engagement tier is **Auto**:
 
-1. **List all auto-confirmed decisions** with their Deep Think reasoning — from domain classification, feature drilling, constraints, personas, competitive positioning
-2. **Highlight any `[AUTO-CONFIRMED]` entries** in `meta/constraints.md`, `meta/personas.md`, and `meta/competitive-landscape.md`
-3. **Present for review**: "I explored your idea independently. Here's everything I decided and why. Override anything before I compile the vision."
-4. **Wait for user response.** Apply any overrides. Write corrections to files immediately.
+1. List all auto-confirmed decisions with their Deep Think reasoning
+2. Highlight any `[AUTO-CONFIRMED]` entries in `meta/constraints.md`, `meta/personas.md`, `meta/competitive-landscape.md`
+3. Present: "I explored your idea independently. Here's everything I decided and why. Override anything before I compile the vision."
+4. **Wait for user response.** Apply any overrides. Write corrections immediately.
 
-For **Hybrid** and **Interactive** tiers, skip this step — the user already confirmed during exploration.
+For **Hybrid** and **Interactive** tiers → skip this step.
 
 ---
 
 ## 11. Compile vision document
 
-Read `.agent/skills/prd-templates/references/vision-template.md` for the output template.
+Read `.agent/skills/prd-templates/references/vision-template.md` for the output template and required sections.
 
 Read `.agent/skills/technical-writer/SKILL.md` and follow its methodology.
 
-Compile `docs/plans/vision.md` as a **human-readable executive summary** of the ideation output. This is the "sales pitch" — it is NOT consumed by the pipeline. The pipeline reads `ideation-index.md` directly.
-
-**Vision.md contents (Option B — Executive Summary):**
-
-1. **Problem Statement** — Condensed from `meta/problem-statement.md`
-2. **Target Users** — Condensed persona summaries from `meta/personas.md` (name + role + pain point + success criteria — not the full 6-field exploration)
-3. **Solution Overview** — 2-3 paragraphs describing what the product does
-4. **Domain Map** — One paragraph per domain (condensed from domain files, not the full exploration)
-5. **MoSCoW Feature Matrix** — Feature names + domain links (not the drill-down details)
-6. **Key Differentiators + Competitive Landscape** — From `meta/competitive-landscape.md`
-7. **Constraints Summary** — From `meta/constraints.md`
-8. **Key Decisions** — Numbered list from `ideation-index.md` decision log
-
-Add a header note:
-
-```markdown
-> **This is a human-readable project summary.** For pipeline-grade detail, see
-> [ideation-index.md](ideation/ideation-index.md) and the domain files it references.
-```
+Compile `docs/plans/vision.md` as a human-readable executive summary. This is NOT consumed by the pipeline — the pipeline reads `ideation-index.md` directly.
 
 ### Fidelity check
 
-Verify that every domain in `ideation-index.md` appears in `vision.md`. Nothing dropped during compilation. This is a summary, not a filter.
+Verify every domain in `ideation-index.md` appears in `vision.md`. Nothing dropped during compilation.
 
 ---
 
@@ -174,30 +118,12 @@ Verify that every domain in `ideation-index.md` appears in `vision.md`. Nothing
 
 ### Self-check against Ideation rubric
 
-Before presenting to the user, self-check the ideation output:
-
-Read `.agent/skills/pipeline-rubrics/references/ideation-rubric.md` before applying the self-check dimensions.
+Read `.agent/skills/pipeline-rubrics/references/ideation-rubric.md` and apply all 12 dimensions as the self-check.
 
-| # | Dimension | Check |
-|---|-----------|-------|
-| 1 | Problem Clarity | Is the problem one sentence, specific, and testable? |
-| 2 | Persona Specificity | Are personas named with all 6 fields? |
-| 3 | Feature Completeness | Is MoSCoW complete? Are Must Haves at ≥Level 2 depth? |
-| 4 | Constraint Explicitness | Are all axes (budget, timeline, team, compliance, performance) addressed? |
-| 5 | Success Measurability | Are there concrete numbers/thresholds? |
-| 6 | Competitive Positioning | Are competitors named with differentiation? |
-| 7 | Open Question Resolution | Do all open questions have owners + deadlines? |
-| 8 | **Input-Output Proportionality** | Is the ideation output proportional to input richness? |
-| 9 | **Domain Coverage** | Are all domains at `[DEEP]` or `[EXHAUSTED]`? |
-| 10 | **Deep Think Coverage** | Were hypotheses tracked? Are all resolved (confirmed/rejected)? |
-| 11 | **Cross-Cut Completeness** | Is the ledger clean? No pending entries? |
-| 12 | **Fractal Structure Compliance** | Does every folder have an index + CX file? Do leaf nodes use the feature template? Does hub-and-spoke placement match classification? Are Role Matrix and Role Lens populated? |
+For any dimension that scores ⚠️ or ❌ → resolve it NOW. Loop back to the relevant step. Do not present a document with known gaps.
 
-For any dimension that scores ⚠️ or ❌, resolve it NOW — don't present a document with known gaps. Loop back to the relevant step and work through it with the user.
-
-> **Note**: This is an internal self-check, not a formal audit. For a rigorous,
-> independent audit with evidence citations, run `/audit-ambiguity ideation` as a
-> separate step after this workflow completes.
+**Remediation loop guard**: Track remediation attempts per dimension.
+- After **3 failed attempts** on the same dimension → **STOP**: "Dimension '[name]' has failed remediation 3 times. Presenting to user as a known gap with context: [what was tried, why it failed]." Include it in the review presentation as an unresolved item for user decision.
 
 ### Present for review
 
@@ -205,14 +131,12 @@ Use `notify_user` to request review of:
 - `docs/plans/ideation/ideation-index.md` — the pipeline key file
 - `docs/plans/vision.md` — the human summary
 
-Include:
-- Summary of the self-check results (all 12 dimensions)
-- Any areas where you resolved gaps during the self-check
-- The final domain coverage map
-- Count of Deep Think hypotheses: N presented, N confirmed, N rejected
+Include: self-check results (all 12 dimensions), any resolved gaps, final domain coverage map, Deep Think hypothesis counts.
+
+**STOP** — do NOT proceed until the user explicitly approves.
 
-The ideation must be approved before proceeding. Do NOT proceed until the user sends a message explicitly approving. Wait for explicit approval.
+### Next step
 
-### Proposed next steps
+**STOP** — do NOT propose `/create-prd` or any other pipeline workflow. The only valid next step is:
 
-**Mandatory next step**: Run `/audit-ambiguity ideation` for all inputs, regardless of input type. Even a rich document can have gaps the agent missed. The audit is cheap; the cost of a gap propagating to architecture is high. Do not propose `/create-prd` until `/audit-ambiguity ideation` has run.
+- `/audit-ambiguity ideation` — mandatory coverage verification before `/create-prd` can begin.

package/template/.agent/workflows/ideate.md

@@ -33,22 +33,7 @@ shards: [ideate-extract, ideate-discover, ideate-validate]
 
 After input classification, the user chooses how much involvement they want. All tiers are available for all input types — the pipeline recommends a default but the user picks.
 
-| Tier | Gate behavior | Default for |
-|------|---------------|-------------|
-| 🤖 **Auto** | Pipeline uses Deep Think to self-interview at every gate. User reviews compiled output at the end. | — |
-| 🤝 **Hybrid** | Structural/mechanical gates auto-confirm. Product decisions (personas, MoSCoW, competitive positioning, constraints) pause for user. | Rich doc, thin doc, chat transcript |
-| 💬 **Interactive** | Every gate pauses for explicit user confirmation. | Verbal / one-liner |
-
-**Full matrix — Input × Tier:**
-
-| Input Type | 🤖 Auto | 🤝 Hybrid | 💬 Interactive |
-|---|---|---|---|
-| Rich document | AI extracts + self-interviews gaps | AI extracts, pauses for product calls | AI extracts, pauses at every gate |
-| Thin document | AI expands all domains independently | AI expands, pauses for product calls | AI expands with user at every step |
-| Chat transcript | AI filters noise + self-interviews | AI filters, pauses for product calls | AI filters with user validation |
-| Verbal / one-liner | AI generates vision from scratch via Deep Think | AI generates, pauses for product calls | Full traditional interview |
-
-**Quality guarantee**: All input types and engagement tiers produce the **same output quality** using the same fractal structure. The ideation output from an Auto one-liner is structurally identical to an Interactive rich document. Every node has an index, CX file, and children. Every feature has a Role Lens. Only the amount of human involvement differs.
+Read the engagement tier protocol (`.agent/skills/prd-templates/references/engagement-tier-protocol.md`) — apply the tier behavior for ideation decisions. The user chooses their tier after input classification. All tiers produce the **same output quality** using the same fractal structure — only the amount of human involvement differs.
 
 Transform a raw idea into comprehensive, structured ideation output through exhaustive recursive exploration with the Deep Think protocol.
 
@@ -66,7 +51,32 @@ Transform a raw idea into comprehensive, structured ideation output through exha
 Check whether `docs/plans/ideation/ideation-index.md` already exists.
 
 - **If it does NOT exist** → This is a fresh ideation. Proceed to Shard 1.
-- **If it DOES exist** → **STOP**. Present to the user:
+- **If it exists but is corrupt** (file size < 100 bytes OR missing `## Structural Classification` section) → Treat as fresh. Warn: "Found a corrupt ideation-index.md — treating as a fresh start." Delete the corrupt file and proceed to Shard 1.
+- **If it DOES exist and is valid** → Check for downstream artifacts before offering overwrite:
+
+### 0.1. Downstream cascade check
+
+Scan for downstream pipeline output:
+- `docs/plans/*-architecture-design.md`
+- `docs/plans/ia/` (any `.md` files besides `index.md`)
+- `docs/plans/be/` (any `.md` files besides `index.md`)
+- `docs/plans/fe/` (any `.md` files besides `index.md`)
+
+**If downstream artifacts exist** → **STOP**. Present:
+
+> ⚠️ **Ideation output AND downstream specs exist.**
+>
+> Re-running `/ideate` will invalidate **all** downstream work:
+> - Architecture design document
+> - IA specs (N shards)
+> - BE specs (N specs)
+> - FE specs (N specs)
+>
+> You would need to re-run the entire pipeline from `/create-prd` forward.
+>
+> **Overwrite** (start fresh, accept cascade invalidation) or **Abort**?
+
+**If no downstream artifacts exist** → Present the standard overwrite prompt:
 
 > ⚠️ **Ideation output already exists** at `docs/plans/ideation/ideation-index.md`.
 >
@@ -109,7 +119,10 @@ Explores constraints, success metrics, and competitive positioning. Runs leaf-no
 > The quality self-check and review request are handled by `ideate-validate.md` (Step 12).
 > The parent does not duplicate shard-level quality gates.
 
-### Proposed next steps
+### Next step
+
+**STOP** — do NOT propose `/create-prd` or any other pipeline workflow. The only valid next step is:
 
-**Mandatory next step**: Run `/audit-ambiguity ideation` for all inputs, regardless of input type. Even a rich document can have gaps the agent missed. The audit is cheap; the cost of a gap propagating to architecture is high. Do not propose `/create-prd` until `/audit-ambiguity ideation` has run.
+- `/audit-ambiguity ideation` — mandatory coverage verification before `/create-prd` can begin.
 
+> If the user wants to pause, save progress and note where to resume. When resuming, the next step remains `/audit-ambiguity ideation`.

package/template/.agent/workflows/implement-slice-setup.md

@@ -17,7 +17,7 @@ pipeline:
 
 Check progress state, load skills, read the slice, detect parallel mode, and write the contract.
 
-**Prerequisite**: Phase plan must exist with slice acceptance criteria. If not, tell the user to run `/plan-phase` first.
+**Prerequisite**: Phase plan must exist with slice acceptance criteria. If the phase plan file does not exist → **STOP**: tell the user to run `/plan-phase` first.
 
 ---
 
@@ -64,7 +64,7 @@ Read `.agent/skills/prd-templates/references/skill-loading-protocol.md` and load
 
 Use `find-skills` to discover a test framework skill if needed.
 
-If this slice introduces a new dependency, read `.agent/workflows/bootstrap-agents.md` and execute with the new value.
+If this slice introduces a new dependency, read `.agent/workflows/bootstrap-agents.md` and execute with the new value. **HARD GATE**: Follow the bootstrap verification protocol (`.agent/skills/prd-templates/references/bootstrap-verification-protocol.md`).
 
 ---
 
@@ -72,6 +72,16 @@ If this slice introduces a new dependency, read `.agent/workflows/bootstrap-agen
 
 Read the slice's acceptance criteria from the phase plan.
 
+## 1.25. Load spec context
+
+For each acceptance criterion, trace its spec citation (e.g., `[BE §3.2]`, `[FE §LoginForm]`) back to the source spec:
+
+1. Read the full §section from every cited BE spec — not just the contract shape, but the error handling, edge cases, access control rules, rate limits, and concurrency notes
+2. Read the full §section from every cited FE spec — component props, states, interactions, responsive behavior, accessibility rules
+3. Read any IA shard sections cited by the BE spec's Source Map — especially `## Edge Cases` and `## Access Control`
+
+This context persists throughout the TDD cycle. The acceptance criteria define WHAT to test; the spec context defines HOW DEEP to test it.
+
 ## 1.5. Check for parallel mode
 
 Scan the slice's tasks for surface tags (`BE`, `FE`, `QA`):
@@ -108,8 +118,8 @@ Load the Languages skill(s) from this slice's surface row per the skill loading
 
 Define request/response shapes as {{CONTRACT_LIBRARY}} schemas in the contracts directory (see `.agent/instructions/structure.md`). This is the source of truth.
 
-### Propose next step
+### Next step
 
-Contract written. Next: `/implement-slice-tdd` for the Red→Green→Refactor cycle.
+**STOP** — do NOT proceed to any other workflow. The only valid next step is `/implement-slice-tdd`.
 
-> If invoked standalone, surface via `notify_user`.
+> If invoked standalone, surface via `notify_user` and wait for user confirmation.

package/template/.agent/workflows/implement-slice-tdd.md

@@ -43,6 +43,10 @@ Read `.agent/skills/prd-templates/references/tdd-testing-policy.md` and apply it
 
 Run the Test Cmd from this slice's surface row in the surface stack map to verify tests fail.
 
+**RED test count validation**: Count the failing tests. Compare against the acceptance criteria count from the phase plan.
+- If failing tests **< acceptance criteria count** → missing coverage. Review which criteria lack tests and add them before proceeding to GREEN.
+- If failing tests **= 0** → **STOP**: "No tests are failing. Either tests were not written or they are incorrectly passing. Review test logic."
+
 ## 4. Implement (GREEN)
 
 Load the Languages skill(s) from this slice's surface row per the skill loading protocol.
@@ -71,16 +75,20 @@ Read `.agent/skills/systematic-debugging/SKILL.md` and follow its ACH methodolog
 2. Contract mismatch → re-read BE spec — contract wrong or implementation?
 3. Logic error → ACH per debugging skill
 4. Integration issue → check cross-surface wiring, env vars, service connectivity
-5. Maximum 3 iterations before escalating to user
+5. Maximum 3 iterations before escalating to user with:
+   - Summary of each iteration's hypothesis and result
+   - Current failing test output
+   - Files modified during debug attempts
+   - Recommended next steps (e.g., "may need manual env inspection" or "possible spec error in BE spec §X")
 
 Run the Test Cmd after each iteration.
 
 ## 4.5. New dependency check
 
 After GREEN, scan new imports. If any package lacks a corresponding skill directory in `.agent/skills/`:
-1. Identify the stack category (e.g., `QUEUE`, `CACHE`, `SEARCH`)
-2. Read `.agent/workflows/bootstrap-agents.md` and fire bootstrap with `PIPELINE_STAGE=implement-slice` + the key-value pair
-3. Confirm skill installed before proceeding to REFACTOR
+1. Identify the technology or library
+2. Read `.agent/workflows/bootstrap-agents.md` and invoke `/bootstrap-agents PIPELINE_STAGE=implement-slice` + the new dependency key
+3. **HARD GATE**: Follow the bootstrap verification protocol (`.agent/skills/prd-templates/references/bootstrap-verification-protocol.md`). Confirm the matching skill is installed before proceeding to REFACTOR.
 
 No new unregistered dependencies → skip to Step 5.
 
@@ -90,7 +98,15 @@ With tests green, improve code quality: extract shared logic, improve naming, re
 
 Read `.agent/skills/code-review-pro/SKILL.md` and apply its adversarial review: "How would a senior engineer reject this in a PR review?"
 
-**Spec traceability check**: Re-read the BE spec and IA shard for this slice. Verify every contract field maps to a BE spec field and every `// IA-EDGE:` test's edge case is covered by the implementation. Fix spec drift before proceeding.
+**Structured spec completeness check**: Re-read the full BE spec section and FE spec section for this slice (loaded in setup Step 1.25). For each element, verify implementation coverage:
+
+1. **Field coverage**: For every field in the BE spec's request/response schemas, verify it appears in the implementation. Flag any spec field with no corresponding code.
+2. **Validation coverage**: For every validation rule in the BE spec (required fields, format constraints, range limits), verify it's enforced in the implementation. Flag any unimplemented validation.
+3. **Error code coverage**: For every error code specified, verify the implementation can produce it and the test suite asserts it.
+4. **Edge case coverage**: For every `// IA-EDGE:` test, verify the implementation handles it (not just that the test passes — the handling must be correct per the spec).
+5. **Access control coverage**: For every role mentioned in the spec's access control, verify the implementation enforces it.
+
+For any gap found: fix the implementation (not the spec). If the gap suggests the spec is wrong, flag it: "Spec may need update: [what was found]. Fix implementation to match spec, or update spec via `/propagate-decision`?"
 
 Run the Test Cmd to verify tests still pass.
 

package/template/.agent/workflows/plan-phase-write.md

@@ -43,9 +43,36 @@ The resulting list of slices is derived from the spec, not estimated from featur
 
 Estimate complexity (S/M/L) per derived slice. Flag any slice estimated L — these are candidates for further splitting before ordering begins.
 
+**L-slice enforcement**: Any slice marked **L** MUST be reviewed for splitting before Step 3. Present L slices to user: "These slices are estimated Large. Split each into 2-3 smaller slices, or confirm L is acceptable?" Wait for confirmation. Do not proceed to ordering with unreviewed L slices.
+
+**Slice count sanity check**: After splitting, count total slices.
+- **1-15 slices** → normal.
+- **16-25 slices** → warn: "Phase has [N] slices. Consider splitting into two phases if unrelated domains are grouped together."
+- **>25 slices** → **STOP**: "Phase has [N] slices — this is too many for one phase. Split into Phase N and Phase N+1, keeping dependency order intact."
+
 **Good slice**: "User can submit an entity claim form" (one named user flow from the FE interaction spec)
 **Bad slice**: "Implement entity management" (domain name, not a spec-derived user flow)
 
+## 2.5. Spec coverage verification
+
+After all slices are identified, verify that the slices collectively cover ALL spec content for this phase:
+
+1. **BE endpoint coverage**: List every endpoint in every BE spec included in this phase's scope. For each endpoint, identify which slice covers it. Build a table:
+
+| BE Endpoint | Slice | Status |
+|---|---|---|
+| `POST /api/entities` | Slice 3: Create entity | ✅ Covered |
+| `GET /api/entities/:id` | — | ❌ Uncovered |
+
+2. **FE component coverage**: List every named component in every FE spec included in this phase's scope. For each, identify which slice covers it.
+
+3. **Resolution**: For each uncovered item:
+   - Add it to an existing slice (if it's a natural fit)
+   - Create a new slice for it
+   - Document it as explicitly deferred to Phase N+1 with reason
+
+**BLOCKING GATE**: Do NOT proceed to Step 3 until every BE endpoint and FE component is either assigned to a slice or explicitly deferred.
+
 ## 3. Order by dependency
 
 Read .agent/skills/concise-planning/SKILL.md and follow its methodology.
@@ -73,6 +100,8 @@ fully specified, and production-ready.
 
 Read `.agent/skills/prd-templates/references/operational-templates.md` for the **Slice Acceptance Criteria** template. For each slice, use the template to define testable acceptance criteria with surface tags:
 
+**Spec citation requirement**: Every acceptance criterion MUST include a spec source citation. Format: `[BE §section.subsection]`, `[FE §ComponentName]`, or `[IA §NN.EdgeCase.N]`. This ensures no criterion is invented without a traceable spec source. If a criterion cannot be traced to a spec → either the spec is incomplete (fix the spec first) or the criterion is speculative (remove it).
+
 > **Write as you go**: After completing acceptance criteria for each slice, immediately append that slice's entry to `docs/plans/phases/phase-N-draft.md` (create the file if it doesn't exist). Do not accumulate all slices in context and write them all at once in Step 5.
 
 **Surface tag rules:**
@@ -107,4 +136,4 @@ Read the surface stack map from `.agent/instructions/tech-stack.md`. Verify all
 
 Use `notify_user` to request review of the phase plan and generated progress files.
 
-**Proposed next step**: Once approved, run `/implement-slice` for the first slice in the phase plan. Read `.agent/progress/` to identify which slice to start with.
+**STOP** — do NOT proceed until the user explicitly approves the phase plan. The only valid next step after approval is `/implement-slice` for the first slice. Read `.agent/progress/` to identify which slice to start with.