cfsa-antigravity 2.1.0 → 2.2.0

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

@@ -17,7 +17,7 @@ pipeline:
 
 # Ideate — Extract
 
-Classify the user's input, create the `ideation/` folder structure, and load skills.
+Classify the user's input, create the fractal `ideation/` folder structure, and load skills.
 
 **Prerequisite**: If invoked standalone (not from `/ideate`), verify the user has provided input — either an `@file` reference or a verbal description. If no input is provided, prompt: "What would you like to build? Describe your idea, or provide a file with `/ideate-extract @path/to/file.md`."
 
@@ -25,8 +25,7 @@ Classify the user's input, create the `ideation/` folder structure, and load ski
 
 ## 1. Input assessment
 
-Classify what the user has provided. This determines which mode the `idea-extraction` skill
-uses and how the rest of the workflow behaves.
+Classify what the user has provided. This determines which mode the `idea-extraction` skill uses.
 
 | Input Type | Detection | Extraction Mode |
 |---|---|---|
@@ -38,168 +37,133 @@ uses and how the rest of the workflow behaves.
 
 **For rich inputs (Extraction mode):**
 1. Read/ingest all provided documents
-2. **Proportionality check**: If the source document is over 50KB, the total ideation output (all domain files combined) must be at least 30% of the source document's line count. If it falls short, identify what was lost and recover it.
+2. **Proportionality check**: If source >50KB, total ideation output must be ≥30% of source line count
 3. Identify natural domain boundaries in the content
-4. Present the organized inventory to the user for confirmation: "Here's what I found, organized by domain. Is anything missing or wrong?"
-5. Identify gaps — domains or sub-topics not covered
-6. For each gap, note it for Interview Mode treatment in `/ideate-discover`
-7. Use idea-extraction skill to refine and deepen, not to re-derive what's already known
+4. Present organized inventory for user confirmation
+5. Identify gaps — note for Interview Mode in `/ideate-discover`
+6. Use idea-extraction skill to refine, not re-derive
 
 **For thin inputs (Expansion mode):**
-1. Read the input and identify domain boundaries
-2. For each domain area, identify depth level (surface → detailed → implementation-ready)
+1. Read input and identify domain boundaries
+2. Identify depth level per domain (surface → detailed → implementation-ready)
 3. Note shallowest domains for priority treatment in `/ideate-discover`
-4. Use idea-extraction skill to deepen each one
 
 **For verbal / no input (Interview mode):**
 1. Read `.agent/skills/idea-extraction/SKILL.md` and enter Interview mode
 2. Start with: "In one sentence, what problem does this solve and for whom?"
-3. **Immediately after**: Run Structural Classification (Step 1.3) — ask about audiences and surfaces before identifying domains
-4. From that sentence + classification, identify the key nouns — these become initial domains
-5. Proceed to folder seeding (Step 1.5) then domain exploration in `/ideate-discover`
+3. **Immediately after**: Run Structural Classification (Step 1.3)
+4. From that sentence + classification, identify initial domains
+5. Proceed to folder seeding (Step 1.5)
 
 ## 1.3. Structural Classification
 
 Read the **Structural Classification Protocol** in `.agent/skills/idea-extraction/SKILL.md`.
 
-This step determines the folder layout for all ideation output. It MUST run **before** any domain files are created (Step 1.5).
+This step determines the folder layout. It MUST run **before** any domain folders are created (Step 1.5).
 
 **For rich/thin document input:**
-1. Scan the document for surface signals:
-   - Distinct platform names in section headings (e.g., "Consumer Web Platform", "Shop Software")
-   - Different tech stacks per surface (e.g., "Astro for web", "Tauri for desktop")
-   - Surface-exclusive features (e.g., "Board Viewer (desktop only)")
-2. If signals detected → classify as **multi-product**
-3. If no signals → classify as **single-surface**
-4. If ambiguous → ask the user the two classification questions before proceeding
+1. Scan for surface signals (see detection table in skill)
+2. If multi-product signals detected, scan for hub-and-spoke vs peer signals:
+   - One surface described as "the platform" or "the API" → **hub-and-spoke**
+   - All surfaces access central database through one API → **hub-and-spoke**
+   - Surfaces described as equally independent → **peer**
+3. If no multi-product signals → **single-surface**
+4. If ambiguous → ask the user the classification questions
 
 **For interview / verbal input:**
 1. After the opening problem statement, ask:
-   - "Who are the distinct user types or audiences for this?"
+   - "Who are the distinct user types or audiences?"
    - "What platforms does this need to live on?" (web, mobile, desktop, API, CLI)
-2. Based on the answers, classify the project shape
-3. If the user's one-liner already specifies a single surface ("make me a website"), classify as **single-surface** without asking
+2. If multi-product → ask: "Is there a primary platform that others depend on, or are all surfaces independent peers?"
+3. Classify the project shape
 
-**Record the classification** in `ideation-index.md` under `## Structural Classification`:
+**Record the classification** in `ideation-index.md` under `## Structural Classification` per the super-index template.
 
-```markdown
-## Structural Classification
-
-- **Project Shape**: [single-surface | multi-surface-shared | multi-product]
-- **Surfaces**: [list of identified surfaces, e.g., "Web (Astro/React), Desktop (Rust/Tauri), Mobile (React Native)" — or "N/A" for single-surface]
-- **Classification Basis**: [how this was determined — "detected from document", "user interview", "inferred from one-liner"]
-```
+Four shapes: `single-surface`, `multi-surface-shared`, `multi-product-hub`, `multi-product-peer`.
 
 ## 1.4. Re-run check
 
 Before seeding, check whether `docs/plans/ideation/ideation-index.md` already exists.
 
-- If it **exists**: Present a summary of its current state (expansion mode, domain count, depth markers, cross-cut count). Ask: "An ideation folder already exists. Do you want to **continue from it** or **start fresh**?"
-  - **Continue** → skip seeding, jump directly to Step 1.6.
-  - **Start fresh** → archive existing folder to `docs/plans/ideation-archive-[timestamp]/`, then proceed with seeding.
+- If it **exists**: Present summary (expansion mode, domain count, depth markers). Ask: "An ideation folder already exists. **Continue** or **start fresh**?"
+  - **Continue** → skip seeding, jump to Step 1.6
+  - **Start fresh** → archive to `docs/plans/ideation-archive-[timestamp]/`, then seed
 - If it **does not exist**: proceed with seeding.
 
-## 1.5. Seed `ideation/` folder
+## 1.5. Seed fractal `ideation/` folder
 
-Read `.agent/skills/prd-templates/references/ideation-index-template.md` and the other ideation templates.
+Read these templates:
+- `.agent/skills/prd-templates/references/ideation-index-template.md` (super-index)
+- `.agent/skills/prd-templates/references/ideation-crosscut-template.md` (global CX)
+- `.agent/skills/prd-templates/references/fractal-node-index-template.md` (node index)
+- `.agent/skills/prd-templates/references/fractal-cx-template.md` (node CX)
+- `.agent/skills/prd-templates/references/fractal-feature-template.md` (feature file)
 
 Read `.agent/skills/technical-writer/SKILL.md` and follow its methodology.
 
-Read the **Structural Classification** from Step 1.3 and create the appropriate folder structure.
-
-**Single-surface layout** (project shape = `single-surface` or `multi-surface-shared`):
+**Create the base structure** (all project shapes):
 
 ```
 docs/plans/ideation/
-├── ideation-index.md
-├── meta/
-│   ├── problem-statement.md
-│   ├── personas.md
-│   ├── competitive-landscape.md
-│   └── constraints.md
-├── domains/
-│   └── (domain files created per identified domain)
-└── cross-cuts/
-    └── cross-cut-ledger.md
+├── ideation-index.md       ← super-index (from ideation-index-template)
+├── ideation-cx.md          ← global cross-cuts (from ideation-crosscut-template)
+└── meta/
+    ├── problem-statement.md
+    ├── personas.md
+    ├── competitive-landscape.md
+    └── constraints.md
 ```
 
-**Multi-product layout** (project shape = `multi-product`):
+**For multi-product projects**, additionally create `surfaces/` with sub-folders per surface.
 
-```
-docs/plans/ideation/
-├── ideation-index.md
-├── meta/
-│   ├── problem-statement.md
-│   ├── personas.md
-│   ├── competitive-landscape.md
-│   └── constraints.md
-├── surfaces/
-│   ├── {surface-1-name}/
-│   ├── {surface-2-name}/
-│   └── {surface-N-name}/
-├── domains/
-│   └── (shared/cross-cutting domain files)
-└── cross-cuts/
-    └── cross-cut-ledger.md
-```
+**Seed domains using the Node Classification Gate** (from `idea-extraction/SKILL.md`):
 
-Create the surface folders based on the surfaces identified in Step 1.3.
+For each domain identified in Step 1:
+1. Run the Classification Gate — determine placement:
+   - Single-surface → create `docs/plans/ideation/{NN}-{slug}/`
+   - Hub-and-spoke → surface-exclusive in `surfaces/{surface}/{NN}-{slug}/`, shared in hub surface
+   - Peer → surface-exclusive in `surfaces/{surface}/{NN}-{slug}/`, shared in `shared/{NN}-{slug}/`
+2. Create the domain folder with: `{slug}-index.md` + `{slug}-cx.md`
+3. For rich document inputs, parse sub-areas into feature files within each domain folder
+4. Update `ideation-index.md` structure map with paths
 
 **Seeding behavior by input type:**
 
-- **Rich document**: Parse by domain → create one domain file per identified domain → seed each with relevant content from source. **For multi-product projects:** place each domain file in the correct surface folder or shared `domains/` folder based on the domain placement rules in the idea-extraction skill. Preserve all detail. Add reference at top of index: `> Source: path/to/original.md`. Do not modify the original. Run the **Source → Domain Files fidelity check**: every major section of the source maps to a domain file — nothing dropped during parsing.
-- **Chat transcript**: Run the noise filter (read full transcript, extract decisions/ideas/rejections, discard filler, present extracted signal to user for confirmation), then create domain files with the clean structured signal. Attribute decisions: `> Decided in conversation: [decision]`.
-- **Thin document**: Create domain files annotated with `[SURFACE]`, `[PARTIAL]`, or `[DEEP]` depth markers per sub-area.
-- **Verbal / one-liner**: Create domain files with scaffolding based on the initial description. Sub-areas are `[SURFACE]` placeholders.
-
-Populate `ideation-index.md` with the domain map and document map linking to all created files.
+- **Rich document**: Parse by domain → create fractal folders + feature files → seed with content. Run fidelity check: every major source section maps to a domain folder. Add `> Source: path/to/original.md` to index.
+- **Chat transcript**: Noise filter → extract signal → seed domain folders with structured output.
+- **Thin document**: Create domain folders with depth markers on feature files.
+- **Verbal / one-liner**: Create domain folders with scaffolding. Feature files are `[SURFACE]`.
 
 ## 1.6. User Intent Check (ALL input types)
 
 Read `.agent/skills/brainstorming/SKILL.md` and follow its methodology.
 
-After seeding, present a summary of what was captured and ask how the user wants to proceed. Framing adapts to input type:
-
-- **Rich document**: "I've organized your document into the ideation folder. Here's the domain map: [domain list with depth indicators]. How would you like to proceed?"
-- **Chat transcript**: "I've extracted the signal from your conversation — [N] decisions, [N] feature ideas, [N] rejected directions. Here's the domain map: [list]. How would you like to proceed?"
-- **Thin document**: "I've seeded the ideation folder with [N] domains. I found [N] sub-areas at surface depth, [N] at partial depth, [N] implementation-ready. How would you like to proceed?"
-- **Verbal / one-liner**: "I've scaffolded [N] initial domains based on your description. How would you like to approach this?"
+After seeding, present a summary and ask how the user wants to proceed. Present all options:
 
-Present all options for every input type:
-1. **Full exploration** *(recommended for 3+ domains)* — Recursive breadth-before-depth with Deep Think protocol — domain map → breadth sweep → vertical drilling, with cross-cut detection and hypothesis generation active throughout
-2. **Process as-is** — Proceed with what's captured; fill gaps via interview as they arise
+1. **Full exploration** *(recommended for 3+ domains)* — Recursive breadth-before-depth with Deep Think
+2. **Process as-is** — Proceed with what's captured; fill gaps as they arise
 3. **Expand vertically** — Drill deeper into existing features
 4. **Expand horizontally** — Add new feature domains not yet covered
-5. **Explore cross-cutting concerns** — Map how existing features interact and conflict
-6. **Combination** — User specifies which dimensions and order
-7. **Audit ambiguity first** — Run inline check on ideation folder before deciding
-
-Recommendation logic: suggest Full if 3+ domains, vertical if 1-2 domains, Full if no domains (verbal). Always present all options. **Wait for user answer — do not assume.**
+5. **Explore cross-cutting concerns** — Map how existing features interact
+6. **Combination** — User specifies dimensions and order
+7. **Audit ambiguity first** — Run inline check before deciding
 
-> **Note**: Cross-cut detection is always-on regardless of mode. Even if the user picks vertical-only, maintain the cross-cut ledger and surface it at the end.
+**Wait for user answer — do not assume.**
 
 ## 1.7. Expansion Mode Routing
 
-Based on the user's choice, write the expansion mode to `ideation-index.md`:
-
-```
-## Expansion Mode
-- Type: [full | vertical | horizontal | cross-cutting | combination | as-is]
-- Targets: [list of domains/features to focus on, if applicable]
-- Cross-cut Detection: always-on
-- Deep Think Protocol: active
-```
+Write the expansion mode to `ideation-index.md` per the super-index template.
 
 This flag is read by `ideate-discover.md` to shape exploration behavior.
 
 ## 2. Load skills
 
-Read `.agent/skills/idea-extraction/SKILL.md` and follow its methodology throughout this workflow.
+Read `.agent/skills/idea-extraction/SKILL.md` and follow its methodology throughout.
 
-Also read `.agent/skills/resolve-ambiguity/SKILL.md` — use it reactively when encountering ambiguity that can be resolved without user input (technical/factual questions). For intent/choice questions, use the decision classification rule.
+Also read `.agent/skills/resolve-ambiguity/SKILL.md` — use reactively when encountering ambiguity that can be resolved without user input.
 
 ### Propose next step
 
-Once input is classified, folder is seeded, and skills are loaded, proceed to `/ideate-discover` to explore domains using the recursive breadth-before-depth model.
+Proceed to `/ideate-discover` to explore domains using the recursive breadth-before-depth model with the fractal structure.
 
-> If this shard was invoked standalone (not from `/ideate`), surface this via `notify_user`. If invoked by the parent `/ideate`, this is a natural handoff — the parent orchestrates the transition.
+> If invoked standalone, surface this via `notify_user`. If invoked by parent `/ideate`, this is a natural handoff.

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

@@ -19,7 +19,7 @@ pipeline:
 
 Explore constraints, verify domain exhaustion, and compile the vision summary.
 
-**Prerequisite**: If invoked standalone, verify `docs/plans/ideation/ideation-index.md` exists with domains 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, prompt the user to run `/ideate-discover` first.
 
 ---
 
@@ -64,37 +64,41 @@ If not already explored in `/ideate-discover` Step 4, explore competitive landsc
 
 This is the final validation gate before compilation.
 
-### Read the full domain map
+### Read the fractal tree
 
-Read `docs/plans/ideation/ideation-index.md` and review:
-- Every domain's status marker
-- Every domain file's sub-area status markers
-- The cross-cut ledger's pending items
+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
 
 ### Exhaustion criteria
 
 | Check | Criteria | Action if Fail |
 |-------|----------|----------------|
-| All domains ≥ `[DEEP]` | Every domain in index is `[DEEP]` or `[EXHAUSTED]` | Drill remaining domains |
-| All Must Have features ≥ Level 2 | Every Must Have has sub-features AND edge cases explored | Deep Think + drill |
-| Deep Think zero hypotheses | Final Deep Think pass across ALL domains yields no new hypotheses | Present any new hypotheses, drill if confirmed |
-| Cross-cut ledger clean | No `pending` entries remain — all are `confirmed` or `rejected` | Run synthesis questions on pending pairs |
+| 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 |
 
 ### Execute exhaustion check
 
-1. Scan index for domains below `[DEEP]`. If any:
-   - "Domain [X] is still at [status]. Should we drill deeper, or is it intentionally minimal?"
-   - If user says "drill" → return to `/ideate-discover` for those domains
-   - If user says "intentionally minimal" → note in domain file and proceed
+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
 
-2. Run **final Deep Think pass**: For each `[DEEP]` (not `[EXHAUSTED]`) domain, apply the four Deep Think questions one more time. Present any new hypotheses.
-   - If new hypotheses are confirmed → drill them, update domain files
-   - If zero hypotheses generated → mark domain as `[EXHAUSTED]`
+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
 
-3. Check cross-cut ledger for `pending` entries. Resolve each.
+3. Walk ALL CX files at every level. Resolve any Medium/Low confidence entries.
 
-4. Update `ideation-index.md` progress summary with final counts.
+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).
 
 ---
 
@@ -162,7 +166,7 @@ Read `.agent/skills/pipeline-rubrics/references/ideation-rubric.md` before apply
 | 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 | **Folder Structure Compliance** | Does the folder match the classified structure? (flat `domains/` for single-surface, `surfaces/` + `domains/` for multi-product) |
+| 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 — don't present a document with known gaps. Loop back to the relevant step and work through it with the user.
 

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

@@ -29,7 +29,7 @@ shards: [ideate-extract, ideate-discover, ideate-validate]
 | One-liner / verbal | User describes idea in chat, no files | Interview (deep) — builds vision from scratch domain by domain |
 | Full exploration | Any input with 3+ domains | Full — Recursive breadth-before-depth with Deep Think protocol, cross-cut detection active throughout |
 
-**Quality guarantee**: All input types produce the **same output quality**. The ideation output that emerges from a one-liner is structurally and substantively identical to one produced from a rich document. Only the amount of interview work differs.
+**Quality guarantee**: All input types produce the **same output quality** using the same fractal structure. The ideation output from a one-liner is structurally identical to one from a rich document. Every node has an index, CX file, and children. Every feature has a Role Lens. Only the amount of interview work differs.
 
 Transform a raw idea into comprehensive, structured ideation output through exhaustive recursive exploration with the Deep Think protocol.
 
@@ -46,9 +46,9 @@ Transform a raw idea into comprehensive, structured ideation output through exha
 
 | # | Shard | What It Does |
 |---|-------|-------------|
-| 1 | [`ideate-extract`](.agent/workflows/ideate-extract.md) | Classifies input, creates `ideation/` folder structure, seeds domain files, runs user intent check, sets expansion mode, loads skills |
-| 2 | [`ideate-discover`](.agent/workflows/ideate-discover.md) | Recursive breadth-before-depth domain exploration with Deep Think — writes directly to domain files. Cross-cut detection + ledger active throughout. |
-| 3 | [`ideate-validate`](.agent/workflows/ideate-validate.md) | Constraints, metrics, competitive positioning, domain exhaustion check, vision summary compilation |
+| 1 | [`ideate-extract`](.agent/workflows/ideate-extract.md) | Classifies input, determines structural classification (4 shapes), creates fractal `ideation/` folder structure using Node Classification Gate, seeds domain folders, runs user intent check, sets expansion mode, loads skills |
+| 2 | [`ideate-discover`](.agent/workflows/ideate-discover.md) | Recursive breadth-before-depth exploration with Deep Think. Creates fractal nodes (folders with index + CX) and leaf feature files (with Role Lens). Hierarchical CX detection active throughout. |
+| 3 | [`ideate-validate`](.agent/workflows/ideate-validate.md) | Constraints, metrics, competitive positioning, leaf-node exhaustion check, fractal structure compliance, vision summary compilation |
 
 ---
 
@@ -56,15 +56,15 @@ Transform a raw idea into comprehensive, structured ideation output through exha
 
 ### Step 1 — Run `.agent/workflows/ideate-extract.md`
 
-Classifies the user's input (rich doc, thin PRD, chat transcript, verbal), checks for an existing ideation folder (re-run check), creates the `docs/plans/ideation/` folder structure from the input, runs the universal user intent check to determine expansion mode, sets the expansion mode flag in `ideation-index.md`, and loads the idea-extraction and resolve-ambiguity skills.
+Classifies the user's input (rich doc, thin PRD, chat transcript, verbal), determines structural classification (single-surface, multi-surface-shared, multi-product-hub, multi-product-peer), checks for existing ideation folder (re-run check), creates the fractal `docs/plans/ideation/` folder structure using the Node Classification Gate, runs user intent check to determine expansion mode, sets the expansion mode flag in `ideation-index.md`, and loads skills.
 
 ### Step 2 — Run `.agent/workflows/ideate-discover.md`
 
-Recursive breadth-before-depth exploration: Level 0 (global domain map) → Level 1 (domain breadth sweep) → Level 2+ (vertical drilling). Deep Think protocol active at every level. Writes directly to domain files. Cross-cut ledger accumulated continuously.
+Recursive breadth-before-depth exploration: Level 0 (global domain map) → Level 1 (domain breadth sweep with Node Classification Gate) → Level 2+ (vertical drilling with Reactive Depth and Promotion Protocol). Deep Think active at every level. Writes to fractal feature files with Role Lens. Hierarchical CX files accumulated at every level.
 
 ### Step 3 — Run `.agent/workflows/ideate-validate.md`
 
-Explores constraints, success metrics, and competitive positioning. Runs domain exhaustion check (all domains ≥ `[DEEP]`, Deep Think yields zero hypotheses, cross-cut ledger clean). Compiles `docs/plans/vision.md` as a human-readable executive summary.
+Explores constraints, success metrics, and competitive positioning. Runs leaf-node exhaustion check (all leaf features ≥ `[DEEP]`, Role Lens complete, Deep Think yields zero hypotheses, all CX files clean). Verifies fractal structure compliance. Compiles `docs/plans/vision.md` as a human-readable executive summary.
 
 ---
 

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

@@ -94,6 +94,31 @@ Read `.agent/skills/code-review-pro/SKILL.md` and apply its adversarial review:
 
 Run the Test Cmd to verify tests still pass.
 
+### 5.5. Query optimization check
+
+For each database query introduced or modified in this slice:
+
+1. **N+1 detection**: Review all data-fetching code for loop-based queries. If a query inside a loop fetches related data that could be eagerly loaded or batched, flag as an N+1 pattern and fix using the installed ORM/DB skill's recommended approach (e.g., `include` for Prisma, `with` for Drizzle, JOIN for raw SQL, graph traversal for SurrealDB)
+2. **Index coverage**: For each new WHERE clause, ORDER BY, or JOIN condition, verify a supporting index exists in the migration/schema. If no index exists and the table is expected to exceed 10,000 rows, add one
+3. **Query plan verification** (if test DB is available): Run EXPLAIN ANALYZE (or equivalent) on queries targeting tables with >1,000 rows in seed data. Flag any sequential scan on a table expected to grow beyond 10,000 rows
+
+If `docs/plans/ENGINEERING-STANDARDS.md` defines `### DB Query Time` budgets, annotate each new query with its expected tier in a code comment: `// DB-TIER-2: uncached read, p95 target < 50ms`
+
+### 5.6. Resource cleanup verification
+
+Review all new code in this slice for resource acquisition patterns. For each resource acquired, verify matching cleanup exists:
+
+| Resource Type | Required Cleanup | Example |
+|--------------|-----------------|---------|
+| DB connection/client | `disconnect()`/`close()` in `finally` | Prisma `$disconnect()`, pg `pool.end()` |
+| Event listener | `removeEventListener()` or equivalent on unmount/destroy | React `useEffect` cleanup return |
+| Subscription | `unsubscribe()`/`kill()` on unmount/destroy | RxJS, SurrealDB live queries, WebSocket |
+| Timer (interval/timeout) | `clearInterval()`/`clearTimeout()` | Polling loops, debounce timers |
+| File handle/stream | `close()`/`destroy()` | fs reads, HTTP response streams |
+| Worker thread | `terminate()` | Web Workers, Node Worker Threads |
+
+If any cleanup is missing, add it before proceeding. Run the Test Cmd after adding cleanup to verify tests still pass.
+
 ## 6. Validate
 
 Read `.agent/skills/verification-before-completion/SKILL.md` and apply its evidence-before-claims discipline.

package/template/.agent/workflows/remediate-pipeline-assess.md

@@ -71,7 +71,7 @@ Check which layers have content by verifying the presence of key files:
 
 | Layer | Key Files to Check | Has Content If… |
 |-------|-------------------|-------------------|
-| Ideation | `docs/plans/ideation/ideation-index.md` | File exists and domains at `[DEEP]`+ |
+| Ideation | `docs/plans/ideation/ideation-index.md` | File exists, ≥1 domain folder under `domains/` (or `surfaces/`) with `*-index.md` + `*-cx.md`, and domains at `[DEEP]`+ in Structure Map |
 | Architecture | `docs/plans/*-architecture-design.md` | At least one dated file exists |
 | IA | `docs/plans/ia/index.md` | File exists with ≥1 shard listed |
 | BE | `docs/plans/be/index.md` | File exists with ≥1 spec listed |
@@ -80,6 +80,7 @@ Check which layers have content by verifying the presence of key files:
 For each layer with content, also note:
 - How many documents it contains (shards/specs count)
 - Whether any deep dive files exist (IA layer only)
+- For ideation: count of domain folders, total feature files, and CX files across the fractal tree
 
 ---
 

package/template/.agent/workflows/resolve-ambiguity.md

@@ -18,7 +18,7 @@ Targeted ambiguity resolution for any pipeline document or layer. Uses the `reso
 | Invocation | Behavior |
 |---|---|
 | `/resolve-ambiguity` | Interactive — asks which document or layer to resolve |
-| `/resolve-ambiguity ideation` | Targets `docs/plans/ideation/ideation-index.md` + domain files |
+| `/resolve-ambiguity ideation` | Targets `ideation-index.md` + `ideation-cx.md` + all fractal tree files |
 | `/resolve-ambiguity architecture` | Targets the architecture design documents |
 | `/resolve-ambiguity @path/to/spec.md` | Targets a specific file |
 
@@ -29,7 +29,7 @@ Targeted ambiguity resolution for any pipeline document or layer. Uses the `reso
 If no argument was provided, ask the user which document or layer to resolve. Accept a layer name (`vision`, `architecture`, `ia`, `be`, `fe`) or a direct `@file` path.
 
 For layer names, resolve to the canonical document(s):
-- `ideation` → `docs/plans/ideation/ideation-index.md` + all domain files (in `docs/plans/ideation/domains/` and `docs/plans/ideation/surfaces/*/` for multi-product projects)
+- `ideation` → `docs/plans/ideation/ideation-index.md` + `ideation-cx.md` + all `*-index.md`, `*-cx.md`, and feature `.md` files recursively under `domains/` (and `surfaces/` for multi-product projects)
 - `architecture` → `docs/plans/YYYY-MM-DD-architecture-design.md` + `docs/plans/ENGINEERING-STANDARDS.md` + `docs/plans/data-placement-strategy.md`
 - `ia` → all files in `docs/plans/ia/` (excluding `index.md`)
 - `be` → all files in `docs/plans/be/` (excluding `index.md`)

package/template/.agent/workflows/validate-phase-quality.md

@@ -0,0 +1,155 @@
+---
+description: Code quality gates — tests, coverage, lint, type-check, build, CI/CD, staging deploy, migrations, spec coverage for the validate-phase workflow
+parent: validate-phase
+shard: quality
+standalone: true
+position: 1
+pipeline:
+  position: 8.1
+  stage: verification
+  predecessors: [implement-slice]
+  successors: [validate-phase-readiness]
+  skills: [code-review-pro, deployment-procedures, testing-strategist, verification-before-completion]
+  calls-bootstrap: false
+---
+
+// turbo-all
+
+# Validate Phase — Code Quality Gates
+
+Run all code quality checks for a completed implementation phase.
+
+---
+
+## 0. Load validation skills
+
+Read these skills before running checks:
+1. `.agent/skills/testing-strategist/SKILL.md` — Coverage strategy and test quality
+2. `.agent/skills/code-review-pro/SKILL.md` — Review checklist for self-audit
+3. `.agent/skills/deployment-procedures/SKILL.md` — Build and release readiness
+
+---
+
+## 0.5. Parallel dispatch option
+
+If the phase contains independent slices that don't share files, validation can run in parallel:
+
+1. **Identify independent slices** — slices that don't import from or export to each other
+2. **Dispatch parallel validation** — run Steps 1–5 concurrently for independent slices using the `parallel-agents` skill
+3. **Sequential for shared** — slices that share contracts or utilities must validate sequentially
+
+This is an optimization, not a requirement. Sequential validation is always correct.
+
+## 1. Run test suite
+
+Run the Test Cmd from `.agent/instructions/commands.md`. All tests must pass. Zero tolerance.
+
+## 2. Check coverage
+
+Run the Test Coverage Cmd from `.agent/instructions/commands.md`.
+
+Read `docs/plans/ENGINEERING-STANDARDS.md` and use the coverage thresholds defined in the "Test Coverage" section. If the file doesn't exist or thresholds aren't defined, fall back to these defaults:
+- Statements: 80%
+- Branches: 90% (critical paths: auth, payments, data mutations, permission checks), 75% (non-critical paths)
+- Functions: 80%
+- Lines: 80%
+
+Critical paths are defined as: auth flows, payment processing, data mutations, and permission/authorization checks.
+
+## 2.5. Mutation testing (critical paths)
+
+**Optional but recommended.** If the project's test tooling supports mutation testing (e.g., Stryker for JS/TS, mutmut for Python, cargo-mutants for Rust):
+
+1. Run the mutation testing tool against critical path modules only (auth, payments, data mutations, permission checks)
+2. **Required**: Mutation score ≥ 70% on critical paths — if below, the tests are passing but not actually catching bugs
+3. **Recommended**: Mutation score ≥ 50% on non-critical paths — log as a finding but don't block
+
+If mutation testing is not available in the project's tooling, skip and note in the validation report that mutation testing was not run.
+
+## 3. Lint
+
+Run the Lint Cmd from the surface stack map.
+
+Zero lint errors. Warnings should be reviewed and addressed.
+
+## 4. Type check
+
+Run the Type Check Cmd from the surface stack map.
+
+Zero type errors. Strict mode must be enabled.
+
+## 5. Build
+
+Run the Build Cmd from the surface stack map.
+
+Build must succeed with no errors.
+
+---
+
+## 5.5. CI/CD pipeline verification
+
+Verify the CI/CD pipeline is green for this phase's changes:
+
+1. Check that a CI/CD configuration file exists (e.g., `.github/workflows/`, `.gitlab-ci.yml`)
+2. Verify the pipeline has run for the latest commit in this phase
+3. Verify ALL CI/CD jobs are passing (not just the test job — include lint, type-check, build, and any deployment jobs)
+
+**If CI/CD is red** → red path: **STOP immediately.** Do not mark this phase as complete. List the failing jobs and their error output. Fix them and re-run `/validate-phase` after fixes.
+
+**Pass criteria**: CI/CD pipeline is green for the latest commit in this phase.
+
+---
+
+## 5.6. Staging deployment gate
+
+1. Deploy to staging using `.agent/skills/deployment-procedures/SKILL.md`
+2. Verify deployment succeeded (no rollback triggered, no error logs in the deployment output)
+3. Run smoke tests against the staging environment:
+   - Health check endpoint returns 200
+   - At least one authenticated route works with a valid token
+   - At least one protected route returns 401/403 for unauthenticated requests
+4. **If smoke tests fail** → red path: Capture the failing test output, rollback the staging deployment, and fix the issue before re-running `/validate-phase`
+5. **If deployment fails** → red path: Do not mark this phase as complete — diagnose the deployment failure, fix it, and re-run `/validate-phase`
+
+**Pass criteria**: Staging deployment succeeds and all smoke tests pass.
+
+---
+
+## 5.6.5. Deployment strategy verification
+
+Read the project's architecture design document (`docs/plans/*-architecture-design.md`) and look for a `## Deployment Strategy` section.
+
+**If no deployment strategy is defined** → Log: "No deployment strategy in architecture doc. Using direct deploy." Proceed.
+
+**If a deployment strategy is defined**:
+1. Verify the deployment in Step 5.6 followed the documented strategy (e.g., canary → verify traffic was gradually shifted; blue-green → verify old environment is still available for rollback; rolling → verify instances were replaced sequentially)
+2. If the architecture documents feature flags as the rollout mechanism → verify the new features in this phase are behind flags
+3. Verify the documented rollback trigger mechanism is configured (error rate monitoring, latency threshold alert, or manual switch — whatever the architecture specifies)
+
+**Pass criteria**: Deployment follows the architecture-documented strategy, or no strategy is documented.
+
+---
+
+## 5.7. Migration verification
+
+1. Run the migration status command (e.g., `prisma migrate status`, `drizzle-kit status`, or equivalent)
+2. Verify there are no pending migrations and no failed migrations
+3. Verify the CI/CD pipeline ran migrations successfully as part of this phase's deployment
+4. Check that rollback scripts exist for each migration in this phase
+5. If migrations are pending or failed → red path: do not mark this phase as complete — run the pending migrations, verify they succeed, and re-run `/validate-phase`
+
+**Pass criteria**: Migration status is clean. All migrations from this phase ran successfully in the CI/CD environment. Rollback scripts are present.
+
+---
+
+## 5.8. Spec coverage sweep
+
+Read `.agent/skills/prd-templates/references/spec-coverage-sweep.md` and follow its full procedure for FE spec, BE spec, and IA shard coverage. Apply its hard-stop rule for any uncovered items.
+
+---
+
+### Propose next step
+
+Code quality gates complete. Next: Run `.agent/workflows/validate-phase-readiness.md` for production readiness checks.
+
+> If this shard was invoked standalone (not from `/validate-phase`), surface this via `notify_user`.