cfsa-antigravity 2.7.0 → 2.9.0

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

@@ -17,102 +17,48 @@ pipeline:
 
 # Ideate — Discover
 
-Explore domains through recursive breadth-before-depth with the Deep Think protocol. Write to the fractal folder structure — every node gets an index, CX file, and children.
+Explore domains through recursive breadth-before-depth with the Deep Think protocol. Write to the fractal folder structure.
 
-**Prerequisite**: If invoked standalone, verify `docs/plans/ideation/ideation-index.md` exists with the fractal folder structure seeded. If this file does not exist → **STOP**: "Extraction output missing — the fractal folder structure has not been seeded. Run `/ideate-extract` first before proceeding to discovery." Do not proceed without this output.
+**Prerequisite**: If invoked standalone, verify `docs/plans/ideation/ideation-index.md` exists with the fractal folder structure seeded. If missing → **STOP**: "Run `/ideate-extract` first."
 
 ---
 
-## 3. Domain Exploration — Recursive Model
+## 2.4. Mid-shard resumption check
 
-Read `.agent/skills/idea-extraction/SKILL.md` — follow the Recursive Domain Exhaustion Protocol, Deep Think Protocol, Node Classification Gate, and Reactive Depth Protocol.
+Scan `docs/plans/ideation/` for existing domain folders and feature files.
 
-Read `## Expansion Mode` and `## Structural Classification` from `docs/plans/ideation/ideation-index.md`.
+- **If 0 domain folders exist** → fresh exploration. Proceed to Step 2.5.
+- **If domain folders exist but ideation-index.md `## Domain Map` is incomplete** (some domains listed but not all have `[DEEP]`/`[EXHAUSTED]`) → this is a resumed session. Log: "Resuming exploration. [N] of [M] domains already explored." Skip already-completed domains and continue from the first incomplete one.
+- **If all domains are marked `[DEEP]` or `[EXHAUSTED]`** → exploration is complete. Skip to Step 4 (problem exploration) if not yet done, otherwise skip to `/ideate-validate`.
 
 ## 2.5. Read Engagement Tier
 
-Read `## Engagement Tier` from `docs/plans/ideation/ideation-index.md`. Apply gate behavior rules for this session:
-
-| Tier | Structural gates (domain maps, classification, sub-domain structure) | Product gates (personas, MoSCoW, feature scope, competitive positioning) |
-|------|----------------------------------------------------------------------|-------------------------------------------------------------------------|
-| 🤖 **Auto** | Auto-confirm: apply Deep Think, write reasoning to feature files, proceed | Auto-confirm: apply Deep Think, write reasoning to feature files, proceed |
-| 🤝 **Hybrid** | Auto-confirm: apply Deep Think, write reasoning to feature files, proceed | **Pause for user**: present findings, wait for explicit confirmation |
-| 💬 **Interactive** | **Pause for user**: present findings, wait for explicit confirmation | **Pause for user**: present findings, wait for explicit confirmation |
-
-> [!IMPORTANT]
-> **Auto-confirmed gates must still write.** When a gate is auto-confirmed, the agent writes the Deep Think reasoning and decision to the relevant file immediately — just as if the user had confirmed it. The file trail must be identical regardless of tier. This ensures the Auto tier review checkpoint in `ideate-validate` has full traceability.
-
-### Full Mode (recommended for 3+ domains)
-
-#### Level 0 — Global Domain Map
-
-1. Read `ideation-index.md` for currently identified domains and structural classification
-2. Apply Deep Think: "What domains would I expect for this product type?"
-3. For each confirmed domain, run the **Node Classification Gate** (from skill):
-   - Determine placement (surface folder, hub, shared, or top-level)
-   - Create domain folder: `{NN}-{slug}/` + `{slug}-index.md` + `{slug}-cx.md`
-4. Note preliminary cross-cuts:
-   - In the relevant parent's CX file (surface CX or global CX)
-   - In `ideation-cx.md` if cross-surface
-5. Update `ideation-index.md` structure map with paths
-6. **Gate** *(structural)*: Present domain map. **Interactive/Hybrid**: User confirms before Level 1. **Auto**: Auto-confirm with Deep Think reasoning written to `ideation-index.md`.
-
-#### Level 1 — Domain Breadth Sweep
+Read `## Engagement Tier` from `docs/plans/ideation/ideation-index.md`.
 
-For each domain (dependency order — foundational first):
+- **If the section exists** → apply the specified tier.
+- **If the section is missing** → default to **Hybrid** tier. Warn: "Engagement tier not found in ideation-index.md. Defaulting to Hybrid. Override now or continue?"
+- **If the value is not one of Auto/Hybrid/Interactive** → **STOP**: "Invalid engagement tier '[value]' in ideation-index.md. Expected: Auto, Hybrid, or Interactive."
 
-1. List all sub-areas/capabilities within the domain
-2. **Deep Think**: "What sub-areas would an expert expect?"
-3. Run **Node Classification Gate** for each:
-   - 2+ interacting capabilities → **sub-domain** (create folder + index + CX)
-   - Single capability → **feature** (create `.md` file from `fractal-feature-template.md`)
-4. Update domain index (Children table + **Role Matrix**)
-5. Note cross-cuts in the domain's CX file
-6. **NEW DOMAINS DISCOVERED?** → Classify, create, update index, loop to Level 0
-7. Mark domain status as `[BREADTH]`
-8. **Gate** *(structural)*: Pause after EACH domain. **Interactive/Hybrid**: "Here's what I mapped for [Domain]. Missing anything?" After ALL: "All domains at BREADTH. Ready to drill?" **Auto**: Auto-confirm with Deep Think reasoning written to domain index.
+Read `.agent/skills/prd-templates/references/engagement-tier-protocol.md` — apply the tier's gate behavior for structural gates and product gates throughout this shard.
 
-#### Level 2+ — Vertical Drilling
-
-For each domain (dependency order), for each child:
-
-1. Apply Exhaustion Questions (entity, feature, user, integration)
-2. **Deep Think** per child — edge cases, interactions, failure modes
-3. For **feature files**: fill all sections (Behavior, Edge Cases, States, **Role Lens**)
-4. For **sub-domains**: drill their child features recursively
-5. Record Deep Think outcomes in each feature file's Deep Think Annotations table
-6. Cross-cuts with evidence → add to parent's CX file with synthesis questions
-7. **Feature reveals 2+ interacting capabilities?** → Run **Promotion Protocol** (convert .md to folder)
-8. **NEW DOMAINS DISCOVERED?** → Loop to Level 0
-9. When Deep Think yields zero hypotheses AND user confirms (or auto-confirms for Auto tier) → mark `[EXHAUSTED]`
-10. Status propagation: all children `[EXHAUSTED]` → node is `[EXHAUSTED]`
-11. **Gate** *(product)*: Pause after each domain is drilled. **Interactive**: Full review. **Hybrid**: Pause for review. **Auto**: Auto-confirm with Deep Think reasoning written to domain index.
-
-#### Cross-Cut Synthesis (Continuous)
-
-Cross-cuts are identified continuously, but after all domains reach `[DEEP]`, do a final review:
-
-1. Read ALL CX files at every level (global, surface, domain, sub-domain)
-2. For any entries at Medium/Low confidence, ask the five synthesis questions (per `fractal-cx-template.md`)
-3. Document confirmed interactions with role scoping
-4. Record rejected pairs with reasoning
-5. Check second-order cross-cuts: "Do any CONFIRMED pairs cross-cut each other?"
-
-### Vertical Mode
-
-Identify shallowest leaf nodes. Drive to `[DEEP]`/`[EXHAUSTED]` with Deep Think. Fill Role Lens in all feature files. Cross-cut watch active — log to appropriate CX files. Do not introduce new domains unless user requests.
-
-### Horizontal Mode
+> [!IMPORTANT]
+> **Auto-confirmed gates must still write.** When a gate is auto-confirmed, the agent writes the Deep Think reasoning and decision to the relevant file immediately. The file trail must be identical regardless of tier.
 
-Audit for missing domains with Deep Think. Create domain folders (with Classification Gate) for confirmed new domains. Level 1 breadth sweep on each. Offer vertical drilling after.
+## 3. Domain Exploration — Recursive Model
 
-### Cross-cutting Mode (standalone)
+Read `.agent/skills/idea-extraction/SKILL.md` — follow the **Recursive Domain Exhaustion Protocol**, **Deep Think Protocol**, **Node Classification Gate**, and **Reactive Depth Protocol**.
 
-Read all CX files + feature files' cross-cut notes. Identify interaction points. Run synthesis questions on unresolved pairs. Document in appropriate CX files.
+Read `## Expansion Mode` and `## Structural Classification` from `docs/plans/ideation/ideation-index.md`.
 
-### Combination / As-is Mode
+Route to the correct exploration mode based on what was selected in `ideate-extract` Step 1.6.5:
 
-Combination: user specifies sequence. As-is: skip expansion, run exhaustion check, but still scan for obvious CX candidates.
+- **Full exploration** → Run Level 0 → Level 1 → Level 2+ as defined in `idea-extraction/SKILL.md` → `## Recursive Domain Exhaustion Protocol`. Apply tier-appropriate gate behavior at each level.
+- **Vertical** → Identify shallowest leaf nodes. Drive to `[DEEP]`/`[EXHAUSTED]` with Deep Think. Do not introduce new domains unless user requests.
+- **Horizontal** → Audit for missing domains with Deep Think. Create domain folders (with Classification Gate). Level 1 breadth sweep on each. Offer vertical drilling after.
+- **Cross-cutting** → Read all CX files + feature files. Identify interaction points. Run synthesis questions on unresolved pairs.
+- **Combination** → User specifies sequence.
+- **As-is** → Skip expansion, run exhaustion check, but still scan for obvious CX candidates.
+- **Audit ambiguity first** → Run inline ambiguity check, then select expansion mode based on results.
 
 ---
 
@@ -125,15 +71,7 @@ Read `.agent/skills/brainstorming/SKILL.md` and follow its methodology.
 3. **How are they solving it today?** → Write to `meta/competitive-landscape.md`
 4. **Why now?** → Write to `meta/problem-statement.md` under "Why Now"
 
-**Persona completeness gate (Ideation Rubric Dimension 2):** For each persona, verify all 6 fields:
-1. Name + specific role
-2. Specific pain point
-3. Current workaround
-4. Success criteria
-5. Switching trigger
-6. At least one edge case or constraint unique to this persona
-
-If any field absent → probe before proceeding. Reference: `.agent/skills/pipeline-rubrics/references/ideation-rubric.md` Dimension 2.
+**Persona completeness gate**: Read `.agent/skills/prd-templates/references/persona-completeness-gate.md`. Verify all 6 fields for every persona. If any field absent → probe before proceeding.
 
 ---
 
@@ -141,30 +79,81 @@ If any field absent → probe before proceeding. Reference: `.agent/skills/pipel
 
 ### 5a. Feature collection (MoSCoW)
 
-Read `.agent/skills/brainstorming/SKILL.md`.
+Read `.agent/skills/brainstorming/SKILL.md`. For each persona, brainstorm features across all 4 MoSCoW tiers. **Deep Think** for missing Must Haves.
 
-For each persona, brainstorm features across all 4 MoSCoW tiers. **Deep Think** for missing Must Haves.
+Write MoSCoW matrix to `ideation-index.md`. Each feature references its fractal path and links to its feature file.
 
-Write MoSCoW matrix to `ideation-index.md`. Each feature references its **fractal path** (e.g., `web/01.02.03`) and links to its feature file.
+**0 Must Haves guard**: If the MoSCoW matrix contains 0 Must Have features → **STOP**: "No Must Have features identified. This indicates the problem statement or personas need refinement. Return to Step 4 and re-examine 'What problem are we solving?' with deeper probing before continuing."
 
-### 5b. Feature deepening — Must Haves
+### 5a.5. Adjacent Feature Analysis (gap surfacing)
+
+After the MoSCoW matrix is populated, reason about what's **conspicuously absent** given everything known about the product:
 
-For each Must Have feature, use the recursive model:
+1. **Domain reasoning**: Given the product type (e.g., e-commerce, SaaS, marketplace), enumerate the standard feature categories expected in this space. Compare against the MoSCoW matrix. List any standard categories with zero features.
+2. **Persona reasoning**: For each persona, ask: "What does this persona need to accomplish their goal that isn't covered by any feature?" List unmet persona needs.
+3. **Workflow reasoning**: Trace each persona's end-to-end workflow. Identify any step where the user would need to leave the product to accomplish something — each gap is a potential missing feature.
+4. **Competitive reasoning**: Read `meta/competitive-landscape.md`. For each competitor capability listed, verify a corresponding feature exists. List competitive gaps.
 
-1. **Level 1: Sub-features.** Component parts. Run Classification Gate — sub-domain or feature?
-2. **Level 2: Edge cases and failure modes.** Fill feature file sections: Behavior (happy path, edge cases, states), **Role Lens**.
-3. **Level 3 (complex features): Interactions.** Cross-cuts with evidence → parent CX file.
+**Present findings as suggestions, not mandates**:
 
-**Deep Think at each level.** Write results to feature files using `fractal-feature-template.md`.
+> 🔍 **Features you might not have thought of:**
+>
+> Based on [product type] and your personas:
+> - [Feature A] — [why it fits: persona X needs this for workflow step Y]
+> - [Feature B] — [why it fits: standard in this space, competitors X and Y have it]
+> - [Feature C] — [why it fits: gap in persona Z's end-to-end workflow]
+>
+> Want to add any of these? They'd enter the MoSCoW matrix for prioritization.
+
+**STOP** — wait for user response. For each accepted feature:
+1. Add to the MoSCoW matrix at the user's chosen priority
+2. Create a feature file in the appropriate domain folder
+3. Continue to Step 5b with the expanded feature set
+
+For rejected features: note in `ideation-index.md` under a `## Considered & Rejected` section with the reason, so future sessions don't re-suggest them.
+
+### 5b. Feature deepening — Must Haves
+
+For each Must Have feature, use the recursive model from `idea-extraction/SKILL.md`:
+1. **Level 1**: Sub-features. Run Classification Gate — sub-domain or feature?
+2. **Level 2**: Edge cases and failure modes. Fill feature file sections per `fractal-feature-template.md`.
+3. **Level 3** (complex features): Cross-cuts with evidence → parent CX file.
+
+**Deep Think at each level.** Write results to feature files.
 
 ### 5c. Feature deepening — Should Haves (lighter touch)
 
 Level 1 (sub-features) only with Deep Think. Full treatment deferred to `/create-prd`.
 
+### 5d. Cross-Cut Synthesis Sweep (mandatory)
+
+After all features are deepened, systematically identify emergent capabilities that arise when features **combine**:
+
+1. **Build a feature interaction matrix**: List all Must Have and Should Have features on both axes. For each pair, ask: "When a user has both of these, does something new become possible that neither feature provides alone?"
+2. **Identify emergent capabilities**: For each interesting pair (or triplet), describe the emergent capability.
+   - Example: Feature "AI diagnostics" + Feature "Supplier catalog" → emergent: "AI-recommended parts ordering" — the diagnostic identifies the failed part AND the catalog knows who sells it, enabling one-click ordering.
+3. **Classify each emergent capability**:
+   - **Already captured** → a feature or sub-feature already covers this. Note the link.
+   - **New cross-cut** → write to the parent domain's CX file. Flag for user review.
+   - **New feature entirely** → present to user for MoSCoW placement.
+4. **Present all findings**:
+
+> 🔗 **Cross-cutting opportunities discovered:**
+>
+> | Features Combined | Emergent Capability | Status |
+> |---|---|---|
+> | [A] + [B] | [What becomes possible] | New cross-cut / New feature / Already captured |
+>
+> These emerged from how your features interact — they're capabilities you get "for free" if you build them with this interaction in mind.
+
+**STOP** — wait for user response. Write accepted cross-cuts to CX files immediately. Add accepted new features to MoSCoW matrix.
+
+> **Minimum coverage**: The sweep must evaluate at least every Must Have × Must Have pair and every Must Have × Should Have pair. Should Have × Should Have pairs are optional but recommended for complex products.
+
 ---
 
-### Propose next step
+### Next step
 
-Proceed to `/ideate-validate` for exhaustion check, constraint exploration, and vision compilation.
+**STOP** — do NOT proceed to any other workflow. The only valid next step is `/ideate-validate`.
 
-> If standalone, surface via `notify_user`. If from parent `/ideate`, natural handoff.
+> If invoked standalone, surface this via `notify_user` and wait for user confirmation before running `/ideate-validate`.

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

@@ -19,181 +19,85 @@ pipeline:
 
 Classify the user's input, create the fractal `ideation/` folder structure, and load skills.
 
-**Prerequisite**: If standalone, verify user provided input via `@file` or verbal. If none, prompt: \"What would you like to build? Provide a file or describe your idea.\"
+**Prerequisite**: If standalone, verify user provided input via `@file` or verbal. If none, prompt: "What would you like to build? Provide a file or describe your idea."
+
+If `@file` was provided:
+- **If file does not exist or is not readable** → **STOP**: "File not found at `[path]`. Provide a valid file path or describe your idea verbally."
+- **If file is empty** (0 bytes) → **STOP**: "File at `[path]` is empty. Provide a file with content or describe your idea verbally."
+- **If file is readable** → proceed to Step 1.
 
 ---
 
 ## 1. Input assessment
 
-Classify what the user has provided. This determines which mode the `idea-extraction` skill uses.
-
-| Input Type | Detection | Extraction Mode |
-|---|---|---|
-| **Rich document** | >5KB, detailed docs, design conversations, prior specs | Extraction |
-| **Thin document** | <5KB, structured but shallow (bullet list, rough PRD) | Expansion |
-| **Conversational dump** | Chat logs, unstructured conversation transcripts | Extraction (with noise filtering) |
-| **Verbal / one-liner** | User describes idea in chat, no files | Interview |
-| **Nothing** | "I want to build an app" or similar | Interview (deep) |
-
-**For rich inputs (Extraction mode):**
-1. Read/ingest all provided documents
-2. **Proportionality check**: If source >50KB, total ideation output must be ≥30% of source line count
-3. **Interview the document**: Run the interview question framework from `idea-extraction/SKILL.md` Extraction Mode Phase 1. Extract concepts (not headings) with citations. Classify every concept through the Node Classification Gate. Build the classification table and proposed domain map.
-4. **BLOCKING GATE — Do NOT proceed to Step 1.5 until the classification table is built.** The classification table is a required artifact. No domain folders can be created without it.
-5. Identify gaps — questions the document doesn't answer → these become Phase 2 user interview questions
-6. Use idea-extraction skill to refine, not re-derive
-
-**For thin inputs (Expansion mode):**
-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`
-
-**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)
-4. From that sentence + classification, identify initial domains
-5. Proceed to folder seeding (Step 1.5)
+Read `.agent/skills/prd-templates/references/input-classification.md` — classify the input into one of the five types.
 
-## 1.3. Structural Classification
+Read `.agent/skills/idea-extraction/SKILL.md` → `## Input-Adaptive Modes` — follow the process for the classified input type.
 
-Read the **Structural Classification Protocol** in `.agent/skills/idea-extraction/SKILL.md`.
+**BLOCKING GATE**: Classification must produce a single input type. If ambiguous between Rich and Thin, use the 5KB threshold. If ambiguous between Thin and Verbal, check whether a file was provided.
 
-This step determines the folder layout. It MUST run **before** any domain folders are created (Step 1.5).
+**For Extraction mode (rich input)**: Follow `idea-extraction/SKILL.md` → Extraction Mode Phase 1 steps 1-6.
 
-**For rich/thin document input:**
-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
+**BLOCKING GATE — Do NOT proceed to Step 1.3 until the classification table is built.** The classification table (from skill Phase 1 step 4) is a required artifact. No domain folders can be created without it.
 
-**For interview / verbal input:**
-1. After the opening problem statement, ask:
-   - "Who are the distinct user types or audiences?"
-   - "What platforms does this need to live on?" (web, mobile, desktop, API, CLI)
-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
+**For Expansion mode (thin input)**: Follow `idea-extraction/SKILL.md` → Expansion Mode steps 1-3. Note shallowest domains for priority treatment in `/ideate-discover`.
 
-**Record the classification** in `ideation-index.md` under `## Structural Classification` per the super-index template.
+**For Interview mode (verbal / no input)**: Follow `idea-extraction/SKILL.md` → Interview Mode steps 1-2. Proceed to Step 1.3 immediately after opening question.
+
+## 1.3. Structural Classification
 
-Four shapes: `single-surface`, `multi-surface-shared`, `multi-product-hub`, `multi-product-peer`.
+Read `.agent/skills/idea-extraction/SKILL.md` → `## Structural Classification Protocol`. Follow the protocol for the current input type (document vs interview).
+
+**BLOCKING GATE**: Classification must run BEFORE any domain folders are created (Step 1.5). Record the result (`single-surface`, `multi-surface-shared`, `multi-product-hub`, `multi-product-peer`) in `ideation-index.md` under `## Structural Classification`.
 
 ## 1.4. Re-run check
 
-Before seeding, check whether `docs/plans/ideation/ideation-index.md` already exists.
+Check whether `docs/plans/ideation/ideation-index.md` already exists.
 
-- If it **exists**: Present summary (expansion mode, domain count, depth markers). Ask: "An ideation folder already exists. **Continue** or **start fresh**?"
+- **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.
+- **Does not exist** → proceed with seeding.
 
 ## 1.4.5. Classification Confirmation (Extraction mode only)
 
 > **BLOCKING GATE**: Before creating ANY domain folder, you MUST complete this step.
-> This step exists because the test revealed that the Node Classification Gate was being
-> bypassed — the agent mirrored source document headings as domains instead of classifying
-> each concept. This gate makes classification a hard prerequisite for folder creation.
-
-1. **Verify the classification table exists.** Step 1 item 3 must have produced a completed classification table. If it doesn't exist, STOP — go back and run Extraction Mode Phase 1 from `idea-extraction/SKILL.md`.
-2. **Present the classification table and proposed domain map to the user.** Show:
-   - Every concept with its source location, gate result, and reasoning
-   - The proposed domain hierarchy (what folders would be created and where)
-   - The gap list (questions the document didn't answer)
-3. **Ask**: "Here's how I classified your content. Does this look right?"
-4. **Wait for user confirmation or corrections.** Do NOT proceed until the user responds.
-5. **Apply any corrections** the user provides — update the classification table and domain map.
-
-**The classification table must show for each concept:**
-- Concept name and source location (line numbers or section reference)
-- Gate result: domain / sub-domain / feature / cross-cut / not-a-product-domain
-- Gate reasoning: which gate questions were asked and how they were answered
-
-**Do NOT mirror source document headings as domains.** Source headings are hints for finding concepts. The Node Classification Gate determines what each concept is.
+
+1. **Verify the classification table exists.** If it doesn't exist → STOP — go back and run Extraction Mode Phase 1 from `idea-extraction/SKILL.md`.
+2. **Present the classification table and proposed domain map to the user.** Follow `idea-extraction/SKILL.md` → Extraction Mode Phase 2 step 7 for what to show.
+3. **Wait for user confirmation or corrections.** Do NOT proceed until the user responds.
+4. **Apply any corrections** the user provides.
+5. **If user rejects the classification entirely** (e.g., "these domains are completely wrong") → return to Step 1 and re-classify from scratch, incorporating the user's feedback as explicit constraints. Do NOT attempt to patch the existing classification — start the classification protocol over.
 
 ## 1.5. Seed fractal `ideation/` folder
 
-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/prd-templates/references/folder-seeding-protocol.md` and follow it.
 
 Read `.agent/skills/technical-writer/SKILL.md` and follow its methodology.
 
-**ADDITIVE ONLY** — The `docs/plans/ideation/` directory already exists in the kit with `.gitkeep` and `README.md`. You are ADDING files into this existing directory. Do NOT delete, overwrite, or replace the directory itself. Do NOT remove any existing files. Create new files alongside what already exists.
-
-**Create the base structure** (all project shapes). This is what the folder should contain AFTER seeding — kit-shipped files plus new pipeline files:
+**BLOCKING GATE**: If Step 1.4.5 was not completed (Extraction mode), STOP — you cannot seed without a confirmed classification.
 
-```
-docs/plans/ideation/
-├── .gitkeep                ← KIT-SHIPPED — do not touch
-├── README.md               ← KIT-SHIPPED — do not touch
-├── ideation-index.md       ← NEW: super-index (from ideation-index-template)
-├── ideation-cx.md          ← NEW: global cross-cuts (from ideation-crosscut-template)
-└── meta/                   ← NEW: created by this step
-    ├── problem-statement.md
-    ├── personas.md
-    ├── competitive-landscape.md
-    └── constraints.md
-```
+**Partial failure recovery**: If folder seeding fails mid-way (some domain folders created, others not):
+1. List what was successfully created vs. what failed
+2. Present to user: "Folder seeding partially failed. [N] of [M] domains created. Retry the remaining [M-N] domains?"
+3. If user says retry → seed only the missing domains
+4. If user says abort → delete all newly created folders and STOP
 
-**For multi-product projects**, additionally create `surfaces/` with sub-folders per surface.
-
-**Post-seeding verification gate**: After creating all files, verify that `docs/plans/ideation/.gitkeep` and `docs/plans/ideation/README.md` still exist. If EITHER file is missing → **STOP**: "Kit-shipped files were destroyed during seeding. Restore `.gitkeep` and/or `README.md` to `docs/plans/ideation/` before continuing."
-
-**Seed domains from CONFIRMED classification table** (not from source headings):
-
-> **CRITICAL**: The domain list comes from the classification table confirmed in Step 1.4.5.
-> Do NOT re-derive domains from the source document. Do NOT fall back to source headings.
-> If Step 1.4.5 was not completed, STOP — you cannot seed without a confirmed classification.
-
-For each concept classified as **domain** in the confirmed table:
-1. Determine placement from the structural classification:
-   - 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 concepts classified as **sub-domain**, create sub-domain folders nested inside their parent domain
-4. For concepts classified as **feature**, create feature files inside their parent domain or sub-domain
-5. For concepts classified as **cross-cut**, add entries to the appropriate CX files (domain-level or global)
-6. For concepts classified as **not-a-product-domain**, add notes to `meta/constraints.md` for `/create-prd`
-7. Update `ideation-index.md` structure map with paths
-
-**Seeding content by input type:**
-
-- **Rich document**: Seed each domain/sub-domain/feature with content from the source document using the source citations in the classification table. Run fidelity check: every major concept in the source must map to SOMETHING in the output (domain, sub-domain, feature, CX entry, or `/create-prd` note). 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]`.
+**Post-seeding verification gate**: Verify `docs/plans/ideation/.gitkeep` and `docs/plans/ideation/README.md` still exist. If EITHER is missing → **STOP**: "Kit-shipped files were destroyed during seeding. Restore them before continuing."
 
 ## 1.6. Engagement Tier Selection (ALL input types)
 
-All three tiers are available for all input types. Present with the recommended default for this input type (Rich/Thin/Chat → Hybrid, Verbal → Interactive):
+Read `.agent/skills/prd-templates/references/engagement-tier-protocol.md` for tier definitions and behavior.
 
-> **How involved do you want to be?**
-> 1. 🤖 **Auto** — I explore independently via Deep Think. You review at the end.
-> 2. 🤝 **Hybrid** *(recommended)* — Structural stuff auto, product decisions pause for you.
-> 3. 💬 **Interactive** — I pause at every gate. Full interview mode.
+Present with the recommended default for this input type (Rich/Thin/Chat → Hybrid, Verbal → Interactive).
 
 **Wait for user answer.** Write the engagement tier to `ideation-index.md` under `## Engagement Tier` immediately.
 
 ## 1.6.5. Expansion Mode Selection (ALL input types)
 
-Present expansion mode options:
-
-1. **Full exploration** *(recommended for 3+ domains)* — Breadth-before-depth with Deep Think
-2. **Process as-is** — Proceed with what's captured
-3. **Expand vertically** — Drill deeper into existing features
-4. **Expand horizontally** — Add new domains
-5. **Cross-cutting concerns** — Map feature interactions
-6. **Combination** — User specifies dimensions and order
-7. **Audit ambiguity first** — Inline check before deciding
+Read `.agent/skills/prd-templates/references/expansion-modes.md` for mode options and default recommendations.
 
-**Wait for user answer.** Write expansion mode to `ideation-index.md` under `## Expansion Mode` immediately.
+Present the options. **Wait for user answer.** Write expansion mode to `ideation-index.md` under `## Expansion Mode` immediately.
 
 ## 2. Load skills
 
@@ -201,8 +105,8 @@ Read `.agent/skills/idea-extraction/SKILL.md` and follow its methodology through
 
 Also read `.agent/skills/resolve-ambiguity/SKILL.md` — use reactively when encountering ambiguity that can be resolved without user input.
 
-### Propose next step
+### Next step
 
-Proceed to `/ideate-discover` to explore domains using the recursive breadth-before-depth model with the fractal structure.
+**STOP** — do NOT proceed to any other workflow. The only valid next step is `/ideate-discover`.
 
-> If invoked standalone, surface this via `notify_user`. If invoked by parent `/ideate`, this is a natural handoff.
+> If invoked standalone, surface this via `notify_user` and wait for user confirmation before running `/ideate-discover`.