cfsa-antigravity 1.0.0

package/template/.agent/workflows/write-fe-spec.md

@@ -0,0 +1,71 @@
+---
+description: Write a frontend specification — resolves cross-references, consumes IA accessibility/responsive specs, maps BE contracts to components
+pipeline:
+  position: 5b
+  stage: specification
+  predecessors: [write-architecture-spec]
+  successors: [plan-phase]
+  parallel-with: [write-be-spec] # can run in parallel
+  skills: [resolve-ambiguity, accessibility, error-handling-patterns, testing-strategist, technical-writer]
+  calls-bootstrap: true # may discover new frontend dependencies
+shards: [write-fe-spec-classify, write-fe-spec-write]
+---
+
+// turbo-all
+
+# Write Frontend Specification
+
+**Input**: A complete BE spec (and its IA source shard)
+**Output**: Full FE spec with components, routing, state, interactions, accessibility
+
+---
+
+## Skill Bootstrap
+
+Check installed skills for frontend-relevant coverage:
+- Frontend framework skill (e.g., React, Astro, Svelte)
+- Frontend design / UI/UX patterns skill
+- Accessibility / WCAG skill
+- CSS framework skills (e.g., `tailwind-css-patterns` for utilities, `tailwind-design-system` for tokens/CVA/theming)
+- Web performance optimization skill
+- i18n / localization skill (if needed)
+
+If a needed skill is missing, check if a matching entry exists in `.agent/skill-library/MANIFEST.md`. Read `.agent/workflows/bootstrap-agents.md` and execute its utility instructions immediately with the appropriate stack key to install it.
+
+---
+
+## Shard Overview
+
+| # | Shard | What It Does |
+|---|-------|-------------|
+| 1 | [`write-fe-spec-classify`](.agent/workflows/write-fe-spec-classify.md) | Classifies the target, loads skills, reads all source documents + cross-references + deep dives |
+| 2 | [`write-fe-spec-write`](.agent/workflows/write-fe-spec-write.md) | Writes the FE spec, updates indexes, runs ambiguity gate, checks for new dependencies |
+
+---
+
+## Orchestration
+
+### Step A — Run `.agent/workflows/write-fe-spec-classify.md`
+
+Identifies the target FE spec, classifies it (feature spec / cross-cutting), loads the skill bundle, reads all source documents (BE spec, IA shard, cross-shard references, deep dives with FE implications), and reads cross-cutting FE specs.
+
+### Step B — Run `.agent/workflows/write-fe-spec-write.md`
+
+Writes the FE spec to `docs/plans/fe/`, updates the FE index, runs cross-reference checks and the ambiguity gate, checks for new dependencies (firing bootstrap if needed), and presents for review.
+
+---
+
+## Quality Gate
+
+Before presenting to the user, verify:
+
+Read .agent/skills/code-review-pro/SKILL.md and apply its adversarial review discipline to each checklist item.
+
+- [ ] Every component has a props interface
+- [ ] Every interactive element has defined behavior
+- [ ] Every data field maps to a BE response field (if applicable)
+- [ ] Loading, error, and empty states defined for every data-fetching view
+- [ ] Accessibility requirements meet WCAG 2.1 AA
+- [ ] Responsive behavior specified for all breakpoints
+- [ ] IA shard's accessibility section fully consumed (not re-derived from BE spec)
+- [ ] Source Map is complete — no FE spec section lacks a traceable source

package/template/AGENTS.md

@@ -0,0 +1,176 @@
+# Vibe to Production — the anti-MVP spec pipeline
+
+This is a **Constraint-First Specification Architecture (CFSA)** pipeline. It turns a raw idea into exhaustively specified, test-driven, production-quality code through a series of progressive gates. Stack-agnostic. Agent-agnostic. Cross-platform. Every line of code, every spec, every test is production-grade from the moment it's written. Phases control scope, never quality. There is no "fix it later."
+
+### Entry Point
+
+Start the pipeline with:
+
+```
+/ideate                              # From scratch — deep interview
+/ideate @path/to/your-idea.md        # From existing document
+```
+
+The `@file` pattern is natively supported by `/ideate` (with full multi-mode input classification) and as a simple document-read input by `/evolve-feature`, `/resolve-ambiguity`, and `/propagate-decision`. Other pipeline commands accept direct invocation; `@file` can be passed to them but no automatic input classification is applied — the workflow reads the file and treats it as inline context.
+
+### Progressive Decision Lock
+
+Decisions in this pipeline are **progressively locked**. Each pipeline stage builds on the locked decisions of previous stages:
+
+1. `/ideate` locks the **vision** — problem, personas, features, constraints
+2. `/create-prd` locks the **architecture** — tech stack, system design, security model
+3. `/decompose-architecture` locks the **domain boundaries** — shard structure, dependencies
+4. `/write-architecture-spec` locks the **interaction specs** — per-shard contracts, data models
+5. `/write-be-spec` locks the **backend contracts** — API endpoints, schemas, middleware
+6. `/write-fe-spec` locks the **frontend specs** — components, state, interactions
+7. `/plan-phase` locks the **implementation order** — dependency-ordered TDD slices
+7.5. `/verify-infrastructure` locks the **operational foundation** — CI/CD green, staging live, migrations clean, auth working
+8. `/implement-slice` locks the **code** — tests → implementation → validation
+
+Once a stage is locked, downstream stages may not contradict it. To change a locked decision, re-run the originating stage and cascade changes downstream.
+
+<!-- Pipeline table maintained by: (1) bootstrap-agents-fill.md Step 4 for project-config sections, (2) kit maintainer checklist for workflow rows — see KIT-ARCHITECTURE.md Kit Maintenance Checklist -->
+### Pipeline Workflow Table
+
+| # | Command | Input | Output | Stage |
+|---|---------|-------|--------|-------|
+| 1 | `/ideate` | Raw idea or `@file` | `docs/plans/vision.md` | Discovery |
+| ↳ | `/ideate-extract` | User input | Classified input + `docs/plans/ideation.md` + loaded skills | Discovery |
+| ↳ | `/ideate-discover` | Classified input | Domain map + feature inventory | Discovery |
+| ↳ | `/ideate-validate` | Domains + features | `docs/plans/vision.md` (compiled from `ideation.md`) | Discovery |
+| 2 | `/create-prd` | `vision.md` | `architecture-design.md` + `ENGINEERING-STANDARDS.md` + `data-placement-strategy.md` | Design |
+
+> **Persistent intermediary**: `docs/plans/ideation.md` — kept permanently as audit trail for the vision.
+
+| ↳ | `/create-prd-stack` | `vision.md` constraints | Tech stack decisions | Design |
+| ↳ | `/create-prd-design-system` | Tech stack + brand-guidelines | `docs/plans/design-system.md` | Design |
+| ↳ | `/create-prd-architecture` | Tech stack | System architecture + data strategy | Design |
+| ↳ | `/create-prd-security` | Architecture | Security model + integrations | Design |
+| ↳ | `/create-prd-compile` | All prior steps | `architecture-design.md` + `ENGINEERING-STANDARDS.md` | Design |
+
+> **Progressive working artifact**: `docs/plans/architecture-draft.md` — written incrementally by shards 1–3, read by shard 4 to compile the final `architecture-design.md`.
+
+| 3 | `/decompose-architecture` | `architecture-design.md` | IA shards + layer indexes | Design |
+| ↳ | `/decompose-architecture-structure` | Approved domains | Directory structure + shard skeletons + indexes | Design |
+| ↳ | `/decompose-architecture-validate` | Skeletons | Deep dives + type annotations + validation | Design |
+| 4 | `/write-architecture-spec` | Skeleton IA shard | Full interaction spec | Specification |
+| ↳ | `/write-architecture-spec-design` | Skeleton shard | Interactions + contracts + data models + access control | Specification |
+| ↳ | `/write-architecture-spec-deepen` | Drafted sections | Deepening passes + final spec + ambiguity gate | Specification |
+| 5 | `/write-be-spec` | IA shard | Backend specification | Specification |
+| ↳ | `/write-be-spec-classify` | IA shard | Classification + source material inventory | Specification |
+| ↳ | `/write-be-spec-write` | Classified shard | BE spec + indexes + ambiguity gate | Specification |
+| 6 | `/write-fe-spec` | BE spec + IA shard | Frontend specification | Specification |
+| ↳ | `/write-fe-spec-classify` | BE spec + IA shard | Classification + source material inventory | Specification |
+| ↳ | `/write-fe-spec-write` | Classified target | FE spec + indexes + ambiguity gate | Specification |
+| 7 | `/audit-ambiguity` | Any layer | Scored ambiguity report | Quality Gate |
+| ↳ | `/audit-ambiguity-rubrics` | Layer selection | Scope + documents + scoring rubrics | Quality Gate |
+| ↳ | `/audit-ambiguity-execute` | Rubrics + documents | Per-document audit + report + remediation | Quality Gate |
+| | `/resolve-ambiguity` | Any pipeline document or layer | Resolved gaps applied to source documents | Quality Gate |
+| | `/remediate-pipeline` | Existing pipeline output | Layer-by-layer audit + remediation + confirmation | Quality Gate |
+| ↳ | `/remediate-pipeline-assess` | Pipeline state | Remediation plan + layer status | Quality Gate |
+| ↳ | `/remediate-pipeline-execute` | Remediation plan | Clean layers + advancement | Quality Gate |
+| | `/propagate-decision` | Locked decision + downstream docs | Corrected specs + propagation record | Correction |
+| ↳ | `/propagate-decision-scan` | Decision type selection | Impact report (explicit + implicit) | Correction |
+| ↳ | `/propagate-decision-apply` | Impact report | Fixed specs + ambiguity flags | Correction |
+| | `/evolve-feature` | New feature/requirement description | Updated specs across all affected layers | Evolution |
+| ↳ | `/evolve-feature-classify` | Feature description | Classified change + new content at entry point | Evolution |
+| ↳ | `/evolve-feature-cascade` | Classified change + entry point | Layer-by-layer additions + implementation impact | Evolution |
+| 8 | `/plan-phase` | Architecture + specs | Dependency-ordered TDD slices | Planning |
+| 9 | `/implement-slice` | Slice acceptance criteria | Working code via Red→Green→Refactor | Implementation |
+| ↳ | `/implement-slice-setup` | Slice from phase plan | Progress check + skills + contracts + parallel mode | Implementation |
+| ↳ | `/implement-slice-tdd` | Contract + tests | Red→Green→Refactor + validation + progress tracking | Implementation |
+| 9.5 | `/verify-infrastructure` | Implemented infra or auth slice | Operational verification report | Verification |
+| 10 | `/validate-phase` | Completed phase | Full validation gate | Verification |
+| 11 | `/evolve-contract` | Changed Zod schema | Safe schema migration | Maintenance |
+
+> **Note**: Rows marked with ↳ are independently-invocable sub-workflows (shards)
+> of their parent command. The parent orchestrates them in sequence, but each shard
+> can also be run standalone with its own prerequisites. `/bootstrap-agents` is also
+> sharded into `/bootstrap-agents-fill` and `/bootstrap-agents-provision`.
+> `/resolve-ambiguity`, `/remediate-pipeline`, `/propagate-decision`, and `/evolve-feature` are utility commands callable from any stage — they are not sequential pipeline steps.
+
+> [!WARNING]
+> If `docs/plans/vision.md` does not exist, the pipeline has not started — run `/ideate` before any other workflow.
+
+> [!WARNING]
+> If `{{PLACEHOLDER}}` values appear anywhere in this file, bootstrap has not run — do not attempt implementation work.
+
+---
+
+## Project Configuration
+
+# {{PROJECT_NAME}}
+
+{{DESCRIPTION}}
+
+### Tech Stack
+
+**{{TECH_STACK_SUMMARY}}**
+
+### Architecture
+
+- [Architecture Design]({{ARCHITECTURE_DOC}}) — System design document
+- [Engineering Standards](docs/plans/ENGINEERING-STANDARDS.md) — Non-negotiable quality bar
+- [Data Placement Strategy](docs/plans/data-placement-strategy.md) — Entity placement + PII boundaries
+
+### Agent Instructions
+
+| Guide | Description |
+|-------|-------------|
+| 🛠️ [Workflow](.agent/instructions/workflow.md) | Execution sequence & principles |
+| 💻 [Tech Stack](.agent/instructions/tech-stack.md) | Technology decisions & skill mappings |
+| 📐 [Patterns](.agent/instructions/patterns.md) | Code conventions & architecture patterns |
+| 📁 [Structure](.agent/instructions/structure.md) | Directory layout & protected files |
+| ⌨️ [Commands](.agent/instructions/commands.md) | Dev, test, lint, build commands |
+
+### Agent Rules
+
+Rules in `.agent/rules/` are **always active** — they apply to every task, every session:
+
+| Rule | What It Enforces |
+|------|-----------------|
+| 🔒 [security-first](.agent/rules/security-first.md) | PII isolation, input validation, secret handling |
+| 📜🧪 [tdd-contract-first](.agent/rules/tdd-contract-first.md) | `{{CONTRACT_LIBRARY}}` schemas before implementation, tests ARE the spec |
+| 🔲 [vertical-slices](.agent/rules/vertical-slices.md) | All four surfaces or it's not done |
+| 🎯📏 [specificity-standards](.agent/rules/specificity-standards.md) | Testable acceptance criteria, exhaustive spec depth |
+| 🧩 [extensibility](.agent/rules/extensibility.md) | File limits, directory docs, anti-spaghetti |
+| 🚧 [boundary-not-placeholder](.agent/rules/boundary-not-placeholder.md) | Boundary stubs vs banned lazy placeholders |
+| 🗣️ [question-vs-command](.agent/rules/question-vs-command.md) | Questions = discuss, Commands = act, Ambiguous = ask |
+| 🎯 [decision-classification](.agent/rules/decision-classification.md) | Product = user, Architecture = options, Implementation = agent |
+| ✅ [completion-checklist](.agent/rules/completion-checklist.md) | Code ≠ done. Code + tests + tracking = done |
+
+### Installed Skills
+
+{{INSTALLED_SKILLS}}
+
+### Key Principles
+
+1. **Production-grade always** — No throwaway code, no shortcuts, no tech debt by design
+2. **Constraints before decisions** — Map what's already decided before presenting options
+3. **Contract-first** — `{{CONTRACT_LIBRARY}}` schema → failing test → implementation (never reverse)
+4. **TDD: failing test before code** — Red → Green → Refactor, every slice, every surface
+5. **Security-first** — PII never leaks, inputs validated, secrets server-side only
+
+### Decision Tree
+
+```mermaid
+graph TD
+    A[Task Received] --> B{Pipeline complete?}
+    B -->|No - vision.md missing| C[Run /ideate first]
+    B -->|No - placeholders unfilled| D[Run /create-prd first]
+    B -->|Yes| E[Read Rules]
+    E --> F[Read Instructions]
+    F --> G{Scan Skills}
+    G -->|Found| H[Load Skill]
+    G -->|None| I{Scan MCP}
+    I -->|Found| J[Use MCP Tools]
+    I -->|None| K[Plan: Contract → Test → Implement]
+    K --> L[Execute]
+    L --> M[MANDATORY: Run Validation]
+    M --> N[Update Progress Tracking]
+    N --> O[Complete]
+```
+
+### Mandatory Validation
+
+**CRITICAL:** Run `{{VALIDATION_COMMAND}}` after **EVERY** code change. Do not finish a task until all pass.

package/template/GEMINI.md

@@ -0,0 +1,177 @@
+# Vibe to Production — the anti-MVP spec pipeline
+
+This is a **Constraint-First Specification Architecture (CFSA)** pipeline. It turns a raw idea into exhaustively specified, test-driven, production-quality code through a series of progressive gates. Stack-agnostic. Agent-agnostic. Cross-platform. Every line of code, every spec, every test is production-grade from the moment it's written. Phases control scope, never quality. There is no "fix it later."
+
+### Entry Point
+
+Start the pipeline with:
+
+```
+/ideate                              # From scratch — deep interview
+/ideate @path/to/your-idea.md        # From existing document
+```
+
+The `@file` pattern is natively supported by `/ideate` (with full multi-mode input classification) and as a simple document-read input by `/evolve-feature`, `/resolve-ambiguity`, and `/propagate-decision`. Other pipeline commands accept direct invocation; `@file` can be passed to them but no automatic input classification is applied — the workflow reads the file and treats it as inline context.
+
+### Progressive Decision Lock
+
+Decisions in this pipeline are **progressively locked**. Each pipeline stage builds on the locked decisions of previous stages:
+
+1. `/ideate` locks the **vision** — problem, personas, features, constraints
+2. `/create-prd` locks the **architecture** — tech stack, system design, security model
+3. `/decompose-architecture` locks the **domain boundaries** — shard structure, dependencies
+4. `/write-architecture-spec` locks the **interaction specs** — per-shard contracts, data models
+5. `/write-be-spec` locks the **backend contracts** — API endpoints, schemas, middleware
+6. `/write-fe-spec` locks the **frontend specs** — components, state, interactions
+7. `/plan-phase` locks the **implementation order** — dependency-ordered TDD slices
+7.5. `/verify-infrastructure` locks the **operational foundation** — CI/CD green, staging live, migrations clean, auth working
+8. `/implement-slice` locks the **code** — tests → implementation → validation
+
+Once a stage is locked, downstream stages may not contradict it. To change a locked decision, re-run the originating stage and cascade changes downstream.
+
+<!-- Pipeline table maintained by: (1) bootstrap-agents-fill.md Step 4 for project-config sections, (2) kit maintainer checklist for workflow rows — see KIT-ARCHITECTURE.md Kit Maintenance Checklist -->
+### Pipeline Workflow Table
+
+| # | Command | Input | Output | Stage |
+|---|---------|-------|--------|-------|
+| 1 | `/ideate` | Raw idea or `@file` | `docs/plans/vision.md` | Discovery |
+| ↳ | `/ideate-extract` | User input | Classified input + `docs/plans/ideation.md` + loaded skills | Discovery |
+| ↳ | `/ideate-discover` | Classified input | Domain map + feature inventory | Discovery |
+| ↳ | `/ideate-validate` | Domains + features | `docs/plans/vision.md` (compiled from `ideation.md`) | Discovery |
+| 2 | `/create-prd` | `vision.md` | `architecture-design.md` + `ENGINEERING-STANDARDS.md` + `data-placement-strategy.md` | Design |
+
+> **Persistent intermediary**: `docs/plans/ideation.md` — kept permanently as audit trail for the vision.
+
+| ↳ | `/create-prd-stack` | `vision.md` constraints | Tech stack decisions | Design |
+| ↳ | `/create-prd-design-system` | Tech stack + brand-guidelines | `docs/plans/design-system.md` | Design |
+| ↳ | `/create-prd-architecture` | Tech stack | System architecture + data strategy | Design |
+| ↳ | `/create-prd-security` | Architecture | Security model + integrations | Design |
+| ↳ | `/create-prd-compile` | All prior steps | `architecture-design.md` + `ENGINEERING-STANDARDS.md` | Design |
+
+> **Progressive working artifact**: `docs/plans/architecture-draft.md` — written incrementally by shards 1–3, read by shard 4 to compile the final `architecture-design.md`.
+
+| 3 | `/decompose-architecture` | `architecture-design.md` | IA shards + layer indexes | Design |
+| ↳ | `/decompose-architecture-structure` | Approved domains | Directory structure + shard skeletons + indexes | Design |
+| ↳ | `/decompose-architecture-validate` | Skeletons | Deep dives + type annotations + validation | Design |
+| 4 | `/write-architecture-spec` | Skeleton IA shard | Full interaction spec | Specification |
+| ↳ | `/write-architecture-spec-design` | Skeleton shard | Interactions + contracts + data models + access control | Specification |
+| ↳ | `/write-architecture-spec-deepen` | Drafted sections | Deepening passes + final spec + ambiguity gate | Specification |
+| 5 | `/write-be-spec` | IA shard | Backend specification | Specification |
+| ↳ | `/write-be-spec-classify` | IA shard | Classification + source material inventory | Specification |
+| ↳ | `/write-be-spec-write` | Classified shard | BE spec + indexes + ambiguity gate | Specification |
+| 6 | `/write-fe-spec` | BE spec + IA shard | Frontend specification | Specification |
+| ↳ | `/write-fe-spec-classify` | BE spec + IA shard | Classification + source material inventory | Specification |
+| ↳ | `/write-fe-spec-write` | Classified target | FE spec + indexes + ambiguity gate | Specification |
+| 7 | `/audit-ambiguity` | Any layer | Scored ambiguity report | Quality Gate |
+| ↳ | `/audit-ambiguity-rubrics` | Layer selection | Scope + documents + scoring rubrics | Quality Gate |
+| ↳ | `/audit-ambiguity-execute` | Rubrics + documents | Per-document audit + report + remediation | Quality Gate |
+| | `/resolve-ambiguity` | Any pipeline document or layer | Resolved gaps applied to source documents | Quality Gate |
+| | `/remediate-pipeline` | Existing pipeline output | Layer-by-layer audit + remediation + confirmation | Quality Gate |
+| ↳ | `/remediate-pipeline-assess` | Pipeline state | Remediation plan + layer status | Quality Gate |
+| ↳ | `/remediate-pipeline-execute` | Remediation plan | Clean layers + advancement | Quality Gate |
+| | `/propagate-decision` | Locked decision + downstream docs | Corrected specs + propagation record | Correction |
+| ↳ | `/propagate-decision-scan` | Decision type selection | Impact report (explicit + implicit) | Correction |
+| ↳ | `/propagate-decision-apply` | Impact report | Fixed specs + ambiguity flags | Correction |
+| | `/evolve-feature` | New feature/requirement description | Updated specs across all affected layers | Evolution |
+| ↳ | `/evolve-feature-classify` | Feature description | Classified change + new content at entry point | Evolution |
+| ↳ | `/evolve-feature-cascade` | Classified change + entry point | Layer-by-layer additions + implementation impact | Evolution |
+| 8 | `/plan-phase` | Architecture + specs | Dependency-ordered TDD slices | Planning |
+| 9 | `/implement-slice` | Slice acceptance criteria | Working code via Red→Green→Refactor | Implementation |
+| ↳ | `/implement-slice-setup` | Slice from phase plan | Progress check + skills + contracts + parallel mode | Implementation |
+| ↳ | `/implement-slice-tdd` | Contract + tests | Red→Green→Refactor + validation + progress tracking | Implementation |
+| 9.5 | `/verify-infrastructure` | Implemented infra or auth slice | Operational verification report | Verification |
+| 10 | `/validate-phase` | Completed phase | Full validation gate | Verification |
+| 11 | `/evolve-contract` | Changed Zod schema | Safe schema migration | Maintenance |
+
+
+> **Note**: Rows marked with ↳ are independently-invocable sub-workflows (shards)
+> of their parent command. The parent orchestrates them in sequence, but each shard
+> can also be run standalone with its own prerequisites. `/bootstrap-agents` is also
+> sharded into `/bootstrap-agents-fill` and `/bootstrap-agents-provision`.
+> `/resolve-ambiguity`, `/remediate-pipeline`, `/propagate-decision`, and `/evolve-feature` are utility commands callable from any stage — they are not sequential pipeline steps.
+
+> [!WARNING]
+> If `docs/plans/vision.md` does not exist, the pipeline has not started — run `/ideate` before any other workflow.
+
+> [!WARNING]
+> If `{{PLACEHOLDER}}` values appear anywhere in this file, bootstrap has not run — do not attempt implementation work.
+
+---
+
+## Project Configuration
+
+# {{PROJECT_NAME}}
+
+{{DESCRIPTION}}
+
+### Tech Stack
+
+**{{TECH_STACK_SUMMARY}}**
+
+### Architecture
+
+- [Architecture Design]({{ARCHITECTURE_DOC}}) — System design document
+- [Engineering Standards](docs/plans/ENGINEERING-STANDARDS.md) — Non-negotiable quality bar
+- [Data Placement Strategy](docs/plans/data-placement-strategy.md) — Entity placement + PII boundaries
+
+### Agent Instructions
+
+| Guide | Description |
+|-------|-------------|
+| 🛠️ [Workflow](.agent/instructions/workflow.md) | Execution sequence & principles |
+| 💻 [Tech Stack](.agent/instructions/tech-stack.md) | Technology decisions & skill mappings |
+| 📐 [Patterns](.agent/instructions/patterns.md) | Code conventions & architecture patterns |
+| 📁 [Structure](.agent/instructions/structure.md) | Directory layout & protected files |
+| ⌨️ [Commands](.agent/instructions/commands.md) | Dev, test, lint, build commands |
+
+### Agent Rules
+
+Rules in `.agent/rules/` are **always active** — they apply to every task, every session:
+
+| Rule | What It Enforces |
+|------|-----------------|
+| 🔒 [security-first](.agent/rules/security-first.md) | PII isolation, input validation, secret handling |
+| 📜🧪 [tdd-contract-first](.agent/rules/tdd-contract-first.md) | `{{CONTRACT_LIBRARY}}` schemas before implementation, tests ARE the spec |
+| 🔲 [vertical-slices](.agent/rules/vertical-slices.md) | All four surfaces or it's not done |
+| 🎯📏 [specificity-standards](.agent/rules/specificity-standards.md) | Testable acceptance criteria, exhaustive spec depth |
+| 🧩 [extensibility](.agent/rules/extensibility.md) | File limits, directory docs, anti-spaghetti |
+| 🚧 [boundary-not-placeholder](.agent/rules/boundary-not-placeholder.md) | Boundary stubs vs banned lazy placeholders |
+| 🗣️ [question-vs-command](.agent/rules/question-vs-command.md) | Questions = discuss, Commands = act, Ambiguous = ask |
+| 🎯 [decision-classification](.agent/rules/decision-classification.md) | Product = user, Architecture = options, Implementation = agent |
+| ✅ [completion-checklist](.agent/rules/completion-checklist.md) | Code ≠ done. Code + tests + tracking = done |
+
+### Installed Skills
+
+{{INSTALLED_SKILLS}}
+
+### Key Principles
+
+1. **Production-grade always** — No throwaway code, no shortcuts, no tech debt by design
+2. **Constraints before decisions** — Map what's already decided before presenting options
+3. **Contract-first** — `{{CONTRACT_LIBRARY}}` schema → failing test → implementation (never reverse)
+4. **TDD: failing test before code** — Red → Green → Refactor, every slice, every surface
+5. **Security-first** — PII never leaks, inputs validated, secrets server-side only
+
+### Decision Tree
+
+```mermaid
+graph TD
+    A[Task Received] --> B{Pipeline complete?}
+    B -->|No - vision.md missing| C[Run /ideate first]
+    B -->|No - placeholders unfilled| D[Run /create-prd first]
+    B -->|Yes| E[Read Rules]
+    E --> F[Read Instructions]
+    F --> G{Scan Skills}
+    G -->|Found| H[Load Skill]
+    G -->|None| I{Scan MCP}
+    I -->|Found| J[Use MCP Tools]
+    I -->|None| K[Plan: Contract → Test → Implement]
+    K --> L[Execute]
+    L --> M[MANDATORY: Run Validation]
+    M --> N[Update Progress Tracking]
+    N --> O[Complete]
+```
+
+### Mandatory Validation
+
+**CRITICAL:** Run `{{VALIDATION_COMMAND}}` after **EVERY** code change. Do not finish a task until all pass.

package/template/docs/README.md

@@ -0,0 +1,187 @@
+# Vibe to Production
+### the anti-MVP spec pipeline
+
+> Designed for Antigravity — adaptable to other agents
+
+---
+
+## What This Is
+
+This is a **Constraint-First Specification Architecture (CFSA)** pipeline — a reusable workflow toolkit that builds production-grade software from line one. It turns a raw idea into exhaustively specified, test-driven, production-quality code through a series of progressive gates.
+
+Five principles define the architecture:
+
+1. **Constraints before decisions.** Every tech stack choice, every design direction, every architecture decision begins by mapping the constraints that already exist — compliance requirements, team expertise, budget, surfaces, existing infrastructure. Constraints narrow the option space before options are even presented. Some decisions become obvious. Others get a filtered set of viable choices scored against the constraints. No open-ended debates. No decision without context.
+
+2. **Exhaustive iteration over shallow speed.** The pipeline refuses to move forward with ambiguity. Each stage has quality gates that measure specification depth — not just "is something written" but "does it answer every question an implementer would ask." Ambiguity audits score documents on a rubric. If gaps exist, they're filled before the next stage begins. The output quality bar is constant regardless of input quality — a one-liner idea gets an exhaustive interview; a 50KB spec gets proportional extraction. Both produce the same depth.
+
+3. **Work shifted left, not deferred right.** Decisions that would normally be made during implementation — data placement, access control, error handling, edge cases — are made during specification. By the time code is written, the spec has already answered every question the developer would ask. Implementation becomes mechanical: translate the spec into code, write the failing test, make it pass. No design decisions remain.
+
+4. **Progressive decision locking.** Each pipeline stage locks decisions. Downstream stages build on locked decisions and may not contradict them. Vision locks the problem and personas. Architecture locks the tech stack and system design. Specifications lock the contracts and data models. Implementation locks the code. To change a locked decision, re-run the originating stage and cascade changes downstream. This prevents the "refactor everything" problem.
+
+5. **TDD as the implementation contract.** Tests are not an afterthought — they are the implementation specification. The contract (Zod schema) defines the shape. The test asserts the behavior. The implementation satisfies both. Red → Green → Refactor, never reversed. Every vertical slice touches all four surfaces: contract, test, backend, frontend. Nothing ships partially.
+
+**The core guarantee**: regardless of how you start — a 50KB detailed spec, a thin bullet list, a chat transcript, or a one-liner in the terminal — the pipeline produces the same output quality. Only the interview work differs. The output depth is constant.
+
+This is not an MVP toolkit. There is no "fix it later" because there is nothing to fix.
+
+---
+
+## How to Use It (Pipeline Walkthrough)
+
+The pipeline is a linear sequence of commands. Each step tells you what to run next.
+
+    Step 1: /ideate
+      You describe your idea (or point to a document with @file).
+      The pipeline interviews you until every domain is explored.
+      Output: docs/plans/vision.md
+
+    Step 2: /audit-ambiguity vision    ── MANDATORY ──
+      Scores the vision document against a rubric.
+      Agent auto-remediates any gaps found, then requires a fresh re-run.
+      Not optional — /ideate will not propose /create-prd until this passes.
+      Output: docs/audits/vision-audit.md
+
+> [!IMPORTANT]
+> **Fresh-run rule:** The session that fixed gaps cannot be the session that passes.
+> Re-run `/audit-ambiguity [layer]` as a new invocation so the agent re-reads the
+> updated source document from disk. The audit only passes when a clean session scores 0%.
+
+      /resolve-ambiguity [layer or @file]  ── UTILITY — callable at any stage ──
+        Targeted ambiguity resolution for any pipeline document or layer.
+        Use when a specific section needs clarification without a full audit cycle.
+        After resolving, re-run the relevant audit as a fresh invocation to confirm the fix.
+
+        Examples:
+          /resolve-ambiguity vision
+          /resolve-ambiguity architecture
+          /resolve-ambiguity @docs/plans/ia/auth.md
+
+    Step 3: /create-prd
+      Reads vision.md. Walks you through tech stack decisions one at a time.
+      Each confirmed decision fires bootstrap to fill templates and install skills.
+      Output: docs/plans/architecture-design.md
+              docs/plans/ENGINEERING-STANDARDS.md
+              docs/plans/data-placement-strategy.md
+
+    Step 4: /audit-ambiguity architecture (recommended)
+      Scores the architecture document on a rubric. Fills gaps before decomposition.
+      Output: docs/audits/architecture-audit.md
+      If gaps are found: agent auto-remediates, then re-run as a fresh invocation (see fresh-run rule above).
+
+    Step 5: /decompose-architecture
+      Breaks architecture into numbered domain shards.
+      Output: docs/plans/ia/ (shard index + skeleton shards)
+
+    Step 6: /write-architecture-spec       ← repeat for EVERY shard
+      Takes one skeleton shard. Writes full interaction spec — contracts, data models, RBAC, events.
+      Output: docs/plans/ia/[shard-name].md (filled)
+
+    ► /audit-ambiguity ia                  [MANDATORY — 0% before Step 7]
+      Runs after ALL IA shards are complete. Hard gate — no BE specs until this passes.
+      Output: docs/audits/ia-audit.md
+      If gaps are found: agent auto-remediates, then re-run as a fresh invocation (see fresh-run rule above).
+
+    Step 7: /write-be-spec                 ← repeat for EVERY shard
+      Reads IA shard. Writes backend spec — endpoints, schemas, middleware, DAL.
+      Output: docs/plans/be/[shard-name].md
+
+    ► /audit-ambiguity be                  [MANDATORY — 0% before Step 8]
+      Runs after ALL BE specs are complete. Hard gate — no FE specs until this passes.
+      Output: docs/audits/be-audit.md
+      If gaps are found: agent auto-remediates, then re-run as a fresh invocation (see fresh-run rule above).
+
+    Step 8: /write-fe-spec                 ← repeat for EVERY shard
+      Reads BE spec + IA shard. Writes frontend spec — components, state, interactions.
+      Output: docs/plans/fe/[shard-name].md
+
+    ► /audit-ambiguity fe                  [MANDATORY — 0% before Step 9]
+      Runs after ALL FE specs are complete. Hard gate — no planning until this passes.
+      Output: docs/audits/fe-audit.md
+      If gaps are found: agent auto-remediates, then re-run as a fresh invocation (see fresh-run rule above).
+
+    ─── ALL specs (IA + BE + FE) must be complete before Step 9 ───
+
+    Step 9: /plan-phase
+      Reads architecture + specs. Creates dependency-ordered TDD vertical slices.
+      Only runs after Phase N-1 is complete (skipped for Phase 1).
+      Output: docs/plans/phases/phase-[n].md
+
+    Step 10: /implement-slice (infrastructure slice)
+      First slice — CI/CD, environment, deployment, scaffolding, database.
+      Output: Working infrastructure + passing tests
+
+    Step 10.5: /verify-infrastructure      ── HARD GATE ──
+      Verifies CI/CD green, staging live, migrations clean. Must pass before feature slices.
+      Output: docs/audits/verify-infrastructure-[date].md
+
+    Step 11: /implement-slice (auth slice)
+      Auth middleware, registration, login, token management.
+      Output: Working auth + passing tests
+
+    Step 11.5: /verify-infrastructure      ── HARD GATE (auth pass) ──
+      Re-runs with auth smoke test enabled. Must pass before auth-dependent feature slices.
+      Output: docs/audits/verify-infrastructure-[date].md
+
+    Step 12: /implement-slice (remaining feature slices)
+      Takes one slice at a time. Red → Green → Refactor across all four surfaces.
+      Output: Working code + passing tests per slice
+
+    Step 13: /validate-phase
+      Full validation gate — tests, coverage, lint, type-check, build,
+      CI/CD verification, staging deployment, migration check.
+      Output: Pass/fail with details
+
+    ─── Repeat Steps 9–13 for each phase ───
+
+---
+
+## Getting Started
+
+### Prerequisites
+
+- Antigravity IDE (or any compatible agent that can read files, write files, and execute commands)
+
+### Installation
+
+Copy the `.agent/` and `docs/` directories into your target project:
+
+**Windows:**
+```cmd
+xcopy /E /I spec-pipeline-starter\.agent your-project\.agent
+xcopy /E /I spec-pipeline-starter\docs your-project\docs
+```
+
+**macOS / Linux:**
+```bash
+cp -r spec-pipeline-starter/.agent /path/to/your-project/
+cp -r spec-pipeline-starter/docs /path/to/your-project/
+```
+
+### Agent Setup
+
+| Agent | What to Do |
+|-------|------------|
+| **Antigravity** | Copy `GEMINI.md` to your project root — it's the system prompt |
+| **Claude Code** | Copy rules/instructions into `.claude/` using Claude's format |
+| **Cursor** | Reference from `.cursorrules` or your Cursor config |
+| **Windsurf** | Reference from `.windsurfrules` or equivalent |
+| **Other** | Follow your agent's convention for loading system instructions |
+
+### Start
+
+```
+/ideate
+```
+
+The pipeline tells you what to run next at every step. You never have to guess.
+
+---
+
+## The Skill System
+
+**Bundled skills** ship with the kit in `.agent/skills/`. These are universal capabilities every project needs regardless of tech stack — things like TDD workflow, clean code principles, accessibility auditing, brainstorming, and systematic debugging. They're always present, always loaded.
+
+**Skill library** lives in `.agent/skill-library/`. These are stack-specific and surface-specific skills that get provisioned by bootstrap as tech decisions are confirmed during `/create-prd`. They're never loaded directly — bootstrap copies the relevant ones into `.agent/skills/` and fills any placeholders with your project's confirmed values.
+
+Bootstrap fires once per confirmed decision — it fills only what was just decided and leaves everything else untouched.

package/template/docs/audits/README.md

@@ -0,0 +1,10 @@
+# Audit Reports
+
+Audit reports created by `/audit-ambiguity` and `/validate-phase`.
+
+## Report Types
+
+| Format | Created By | Description |
+|---|---|---|
+| `[layer]-ambiguity-report.md` | `/audit-ambiguity` | Ambiguity scores and gap analysis for a spec layer (vision, architecture, ia, be, fe, all) |
+| `phase-N-validation.md` | `/validate-phase` | Full validation results for a completed phase — tests, coverage, lint, types, build, security, performance |

package/template/docs/plans/README.md

@@ -0,0 +1,21 @@
+# Plans
+
+Core planning artifacts live here. Created by `/ideate` and `/create-prd`.
+
+## Expected Files
+
+| File | Created By | Description |
+|---|---|---|
+| `vision.md` | `/ideate` | Exhaustive vision document — the single source of truth for what the product is |
+| `YYYY-MM-DD-architecture-design.md` | `/create-prd` | System design document — tech stack, architecture, data strategy, security model |
+| `ENGINEERING-STANDARDS.md` | `/create-prd` | Non-negotiable quality bar — test coverage, performance targets, accessibility requirements |
+| `data-placement-strategy.md` | `/create-prd` | N-tier data placement map — what each tier stores, encryption, GDPR lifecycle |
+
+## Subdirectories
+
+| Directory | Created By | Description |
+|---|---|---|
+| `ia/` | `/decompose-architecture`, `/write-architecture-spec` | Information Architecture shards |
+| `be/` | `/write-be-spec` | Backend specifications |
+| `fe/` | `/write-fe-spec` | Frontend specifications |
+| `phases/` | `/plan-phase` | Phase plans with vertical slices |