cfsa-antigravity 2.0.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,111 +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. From that sentence, identify the key nouns — these become initial domains
-4. 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. It MUST run **before** any domain folders are created (Step 1.5).
+
+**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
+
+**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
+
+**Record the classification** in `ideation-index.md` under `## Structural Classification` per the super-index template.
+
+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.
 
-Create the `docs/plans/ideation/` folder structure:
+**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
 ```
 
-**Seeding behavior by input type:**
+**For multi-product projects**, additionally create `surfaces/` with sub-folders per surface.
 
-- **Rich document**: Parse by domain → create one domain file per identified domain → seed each with relevant content from source. 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.
+**Seed domains using the Node Classification Gate** (from `idea-extraction/SKILL.md`):
 
-Populate `ideation-index.md` with the domain map and document map linking to all created files.
+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 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
+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
 
-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.**
-
-> **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.
 
 ---
 
@@ -36,11 +36,11 @@ Explore constraints with the user. Write to `docs/plans/ideation/meta/constraint
 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** — What platforms will this run on? (web, mobile, desktop, CLI, API)
+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.
 
 **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)?"
 
-Write the surface classification to `meta/constraints.md` — downstream workflows use this to determine which decision axes apply.
+Write constraints to `meta/constraints.md`. If the surface classification changed, update `ideation-index.md` `## Structural Classification` section.
 
 ### Success metrics
 
@@ -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 template structure? |
+| 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

@@ -4,8 +4,8 @@ pipeline:
   position: 1
   stage: vision
   predecessors: [] # entry point
-  successors: [create-prd]
-  skills: [brainstorming, idea-extraction, pipeline-rubrics, prd-templates, resolve-ambiguity, technical-writer]
+  successors: [audit-ambiguity, create-prd] # audit-ambiguity recommended before create-prd
+  skills: [brainstorming, idea-extraction, pipeline-rubrics, prd-templates, prompt-engineer, resolve-ambiguity, technical-writer]
   calls-bootstrap: false
 shards: [ideate-extract, ideate-discover, ideate-validate]
 ---
@@ -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-setup.md

@@ -23,25 +23,28 @@ Check progress state, load skills, read the slice, detect parallel mode, and wri
 
 ## -1. Placeholder verification (CRITICAL — run before anything else)
 
-Scan for unfilled placeholders before writing code. Read each file and scan for `{{`:
+Scan the surface stack map in `.agent/instructions/tech-stack.md` for completeness before writing code.
 
-1. `AGENTS.md`
-2. `GEMINI.md`
-3. `.agent/instructions/workflow.md`
-4. `.agent/instructions/commands.md`
-5. `.agent/instructions/structure.md`
-6. `.agent/instructions/patterns.md`
-7. `.agent/instructions/tech-stack.md`
+Verify:
+1. The slice's surface row has filled values for **all** required columns (Languages, Databases, BE Frameworks, FE Frameworks, ORMs, Unit Tests, E2E Tests, FE Design, State Mgmt)
+2. Cross-cutting categories have filled values (Auth, Security, CI/CD, Hosting, Accessibility)
+3. Commands section in `.agent/instructions/commands.md` has non-template values
 
-**If ANY `{{PLACEHOLDER}}` found** → STOP. Tell user which files contain unfilled placeholders with remediation:
+Also scan these instruction files for any remaining template markers:
+- `.agent/instructions/structure.md`
+- `.agent/instructions/patterns.md`
+- `.agent/instructions/tech-stack.md`
 
-| Unfilled pattern | Remediation |
-|-----------------|-------------|
-| `AGENTS.md`, `GEMINI.md`, `workflow.md`, `commands.md`, `tech-stack.md` | Run `/create-prd` |
-| `structure.md` (`{{PROJECT_STRUCTURE}}`, `{{ARCHITECTURE_TABLE}}`) | Run `/create-prd-compile` Step 9.5 |
-| `patterns.md` (`{{FRAMEWORK_PATTERNS}}`) | Run `/bootstrap-agents-provision` |
+**If the map has empty cells for this slice's surface** → STOP. Tell user which cells are empty with remediation:
 
-Only proceed when zero `{{` patterns remain in all seven files.
+| Empty Cell | Remediation |
+|---|---|
+| Languages / Databases / Frameworks | Run `/create-prd-stack` first |
+| Commands section | Run `/bootstrap-agents` |
+| `structure.md` (project structure) | Run `/create-prd-compile` Step 9.5 |
+| `patterns.md` (framework patterns) | Run `/bootstrap-agents-provision` |
+
+Only proceed when the map is fully populated for this slice's surface.
 
 ---
 
@@ -55,10 +58,9 @@ Verify previous slice was fully marked complete before starting this one.
 
 Read these skill SKILL.md files: `tdd-workflow`, `error-handling-patterns`, `git-workflow`, `code-review-pro`, `testing-strategist`, `clean-code`, `logging-best-practices`, `minimalist-surgical-development`, `systematic-debugging`. All are in `.agent/skills/[name]/SKILL.md`.
 
-Read .agent/skills/{{LANGUAGE_SKILL}}/SKILL.md and follow its language conventions.
-If this slice includes BE tasks: Read .agent/skills/{{ORM_SKILL}}/SKILL.md and follow its migration and schema conventions. Skip if no BE tasks or `{{ORM_SKILL}}` is not provisioned.
-Read .agent/skills/{{UNIT_TESTING_SKILL}}/SKILL.md and follow its test writing conventions.
-If this slice includes FE tasks: Read .agent/skills/{{STATE_MANAGEMENT_SKILL}}/SKILL.md and follow its state management conventions. Skip if no FE tasks or `{{STATE_MANAGEMENT_SKILL}}` is not provisioned.
+Determine which surface this slice belongs to from the phase plan. Read the surface stack map.
+
+Read `.agent/skills/prd-templates/references/skill-loading-protocol.md` and load skills for this slice's surface: Languages, Unit Tests, and conditionally ORMs (if BE tasks) and State Mgmt (if FE tasks).
 
 Use `find-skills` to discover a test framework skill if needed.
 
@@ -95,16 +97,16 @@ Log each dispatch phase to `.agent/progress/slices/phase-NN-slice-NN.md` `## Dis
 
 ---
 
-## 2. Write the contract (Zod schema)
+## 2. Write the contract ({{CONTRACT_LIBRARY}} schema)
 
 Before writing the schema, locate the BE endpoint(s) referenced by this slice's acceptance criteria. For each endpoint:
-1. Read the BE spec section that defines it. Copy the typed Zod contract completely — every request field, response field, error code, and validation rule.
+1. Read the BE spec section that defines it. Copy the typed {{CONTRACT_LIBRARY}} contract completely — every request field, response field, error code, and validation rule.
 2. Read the slice's acceptance criteria. Add any additional request/response shapes required by behavioral assertions that are not already present in the BE contract (e.g., query parameters implied by filter behavior, UI-specific error payloads).
 3. Verify the combined schema covers every acceptance criterion and every BE contract field. Flag any drift between the BE spec and the IA shard it implements.
 
-Read .agent/skills/{{LANGUAGE_SKILL}}/SKILL.md and follow its language conventions.
+Load the Languages skill(s) from this slice's surface row per the skill loading protocol.
 
-Define request/response shapes as Zod schemas in the contracts directory (see `.agent/instructions/structure.md`). This is the source of truth.
+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