cfsa-antigravity 1.0.0

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

@@ -0,0 +1,113 @@
+---
+description: Progress check, skill loading, slice reading, parallel mode detection, and contract writing for the implement-slice workflow
+parent: implement-slice
+shard: setup
+standalone: true
+position: 1
+pipeline:
+  position: 7.1
+  stage: implementation
+  predecessors: [plan-phase]
+  successors: [implement-slice-tdd]
+  skills: [session-continuity, tdd-workflow, parallel-agents, parallel-feature-development]
+  calls-bootstrap: true
+---
+
+# Implement Slice — Setup
+
+Check progress state, load skills, read the slice, detect parallel mode, and write the contract.
+
+**Prerequisite**: Phase plan must exist with slice acceptance criteria. If not, tell the user to run `/plan-phase` first.
+
+---
+
+## -1. Placeholder verification (CRITICAL — run before anything else)
+
+Scan for unfilled placeholders before writing code. Read each file and scan for `{{`:
+
+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`
+
+**If ANY `{{PLACEHOLDER}}` found** → STOP. Tell user which files contain unfilled placeholders with remediation:
+
+| 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` |
+
+Only proceed when zero `{{` patterns remain in all seven files.
+
+---
+
+## 0. Check progress state
+
+Read `.agent/skills/session-continuity/protocols/01-session-resumption.md` and follow the **Session Resumption Protocol**. Also read `.agent/skills/session-continuity/SKILL.md` for cross-session tracking.
+
+Verify previous slice was fully marked complete before starting this one.
+
+## 0.5. Load bundled skills
+
+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.
+
+Use `find-skills` to discover a test framework skill if needed.
+
+If this slice introduces a new dependency, read `.agent/workflows/bootstrap-agents.md` and execute with the new value.
+
+---
+
+## 1. Read the slice
+
+Read the slice's acceptance criteria from the phase plan.
+
+## 1.5. Check for parallel mode
+
+Scan the slice's tasks for surface tags (`BE`, `FE`, `QA`):
+
+- **No tags found** → proceed sequentially (steps 2–7 in the tdd shard)
+- **Tags found** → enter parallel mode:
+
+### Parallel mode dispatch (TDD order)
+
+Read `.agent/skills/parallel-agents/SKILL.md` and `.agent/skills/parallel-feature-development/SKILL.md` for dispatch protocol and file ownership rules.
+
+| Phase | Agent | Responsibility | Depends On |
+|-------|-------|---------------|------------|
+| 0 | Orchestrator | Contracts/schemas (untagged tasks) | — |
+| 1 | QA (RED) | Write comprehensive failing tests | Phase 0 |
+| 2 | BE + FE (parallel) | Write code to make tests pass | Phase 1 |
+| 3 | QA (GREEN) | Verify all tests pass, anti-cheat audit | Phase 2 |
+| 4 | Orchestrator | Iterative correction loop if needed | Phase 3 |
+
+Read `.agent/skills/parallel-agents/SKILL.md` and follow its TDD-Order Dispatch methodology for execution order and file isolation.
+
+Log each dispatch phase to `.agent/progress/slices/phase-NN-slice-NN.md` `## Dispatch Log`.
+
+---
+
+## 2. Write the contract (Zod 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.
+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.
+
+Define request/response shapes as Zod schemas in the contracts directory (see `.agent/instructions/structure.md`). This is the source of truth.
+
+### Propose next step
+
+Contract written. Next: `/implement-slice-tdd` for the Red→Green→Refactor cycle.
+
+> If invoked standalone, surface via `notify_user`.

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

@@ -0,0 +1,198 @@
+---
+description: TDD Red→Green→Refactor cycle, validation, synthesis, and progress tracking for the implement-slice workflow
+parent: implement-slice
+shard: tdd
+standalone: true
+position: 2
+pipeline:
+  position: 7.2
+  stage: implementation
+  predecessors: [implement-slice-setup]
+  successors: [validate-phase]
+  skills: [tdd-workflow, systematic-debugging, session-continuity]
+  calls-bootstrap: false
+---
+
+# Implement Slice — TDD & Progress
+
+Execute the TDD cycle (Red → Green → Refactor), run validation, handle synthesis, and update all progress tracking files.
+
+**Prerequisite**: Contract (Zod schema) must be written (from `/implement-slice-setup` or equivalent). If in parallel mode, QA-RED and BE/FE/QA-GREEN dispatch should be completed during setup.
+
+---
+
+## 3. Write failing tests (RED)
+
+Read .agent/skills/tdd-workflow/SKILL.md and follow its methodology.
+Read .agent/skills/clean-code/SKILL.md and follow its methodology.
+Read .agent/skills/systematic-debugging/SKILL.md and follow its methodology.
+Read .agent/skills/{{LANGUAGE_SKILL}}/SKILL.md and follow its language conventions.
+Read .agent/skills/{{UNIT_TESTING_SKILL}}/SKILL.md and follow its test writing conventions.
+Read .agent/skills/{{E2E_TESTING_SKILL}}/SKILL.md and follow its E2E test conventions.
+
+Cross-reference **all three** sources — acceptance criteria from the phase plan, the Zod contract from step 2, AND IA edge cases traced through the BE Source Map:
+1. Write a test for each acceptance criterion
+2. Write a test for each contract field, error type, and validation rule not already covered by criteria
+3. For each endpoint in this slice, read the IA shard section(s) cited in that endpoint's BE spec `## Source Map`. Extract every item from the IA shard's `## Edge Cases` section that is relevant to the endpoint(s) under test. Write a failing test for each uncovered edge case. Tag these tests with `// IA-EDGE: [IA §X.Y — description]` so QA-GREEN can audit traceability.
+4. Run all tests — they MUST fail
+5. Commit the failing tests
+
+**Test order**: Unit → Integration → E2E (if applicable)
+
+> **In parallel mode**, this step is handled by the `QA` agent dispatch in step 1.5.
+> In sequential mode, the orchestrator handles it directly.
+
+Run `{{TEST_COMMAND}}` to verify tests fail.
+
+## 4. Implement (GREEN)
+
+Read .agent/skills/{{LANGUAGE_SKILL}}/SKILL.md and follow its language conventions.
+
+Write the minimum code to make all tests pass:
+1. Database schema/migration
+2. API endpoint handler
+3. Business logic
+4. UI component
+
+**If in parallel mode**: Each agent claims its task via the **Parallel Claim Protocol** (`.agent/skills/session-continuity/protocols/09-parallel-claim.md`) — marking `[!]`, writing `files:` list, and working through subtasks. Agents release claims on completion.
+
+**Before using any stub or placeholder**, apply the three-part test from the
+`boundary-not-placeholder` rule:
+- Does the spec exist? → Implement it. No stub.
+- Could you write the spec now? → Write the spec first, then implement.
+- Information genuinely doesn't exist? → `BOUNDARY:` stub with typed interface, tracking issue, and sentinel test.
+
+> **"This is a lot of work" is not a valid boundary.** Amount of work, task
+> scope, and complexity are never reasons to stub. Only missing information is.
+
+**Spec traceability**: if you make any implementation decision not explicitly covered by the spec or contract (e.g., choosing enum values, default behaviors, retry counts, timeout durations, error messages), annotate it with `// DECISION: [what was decided and why]`. QA will audit these.
+
+Run `{{TEST_COMMAND}}` to verify tests pass.
+
+## 4.5. New dependency check
+
+After making all tests pass (GREEN), scan the new imports introduced in the implementation files.
+
+If any package or module was introduced that does **not** have a corresponding skill directory in `.agent/skills/`:
+1. Identify the stack category (e.g., `QUEUE`, `CACHE`, `SEARCH`, `STORAGE`, `REALTIME`)
+2. Read `.agent/workflows/bootstrap-agents.md` and fire bootstrap with `PIPELINE_STAGE=implement-slice` + the key-value pair (e.g., `NEW_DEPENDENCY=[package-name]`)
+3. Confirm the matching skill is installed before proceeding to REFACTOR
+
+If no new unregistered dependencies were introduced, skip and proceed to Step 5.
+
+## 5. Refactor
+
+With tests green, improve code quality:
+- Extract shared logic
+- Improve naming
+- Remove duplication
+- Add documentation
+
+Read `.agent/skills/code-review-pro/SKILL.md` and follow its adversarial review methodology against the code written in Steps 3–4. Ask: "How would a senior engineer reject this in a PR review?" Fix any issues found before running the test command.
+
+**Mandatory spec traceability check**: Re-read the BE spec section(s) and IA shard sections referenced by this slice's acceptance criteria. For every field in the Zod contract (from Step 2), verify it maps to a field in the BE spec. For every `// IA-EDGE:` tagged test (from Step 3), verify the corresponding IA edge case is covered by the implementation — not just by the test. If any drift is found between the implementation and the spec (missing fields, renamed fields, dropped validations, unimplemented edge cases), fix the implementation now. Do not proceed to Step 6 if any spec drift remains.
+
+Run `{{TEST_COMMAND}}` to verify tests still pass after refactor.
+
+## 6. Validate
+
+Read .agent/skills/verification-before-completion/SKILL.md and apply its evidence-before-claims discipline.
+
+Run the full validation suite: `{{VALIDATION_COMMAND}}`.
+
+All must pass before the slice is complete.
+
+## 6.5. Synthesis (parallel mode only)
+
+**Skip this step if not in parallel mode.**
+
+> **Write synthesis plan first**: Before beginning any synthesis work, write a `## Synthesis Plan` section to the slice file (`.agent/progress/slices/phase-NN-slice-NN.md`) listing:
+> - All `// BOUNDARY:` stubs found across agent outputs (file path + stub description)
+> - All cross-surface integrations to wire (e.g., "BE auth middleware → FE token refresh handler")
+>
+> This gives you a checklist to resume from if the session is interrupted during synthesis.
+
+After all parallel agents have completed and QA-GREEN has passed:
+
+1. **Verify no file conflicts** — confirm no file was modified by multiple agents
+2. **Resolve `// BOUNDARY:` stubs** — agents may have created boundary stubs for frozen files (contracts, config). Resolve these now:
+   - Update shared contracts if needed
+   - Install any new dependencies
+   - Wire cross-surface integrations
+3. **Run full validation** — the validation from step 6 runs again after synthesis
+4. **Create synthesis report** per the `parallel-agents` skill (Synthesize step)
+
+Run `{{VALIDATION_COMMAND}}` for post-synthesis validation.
+
+## 7. Update progress (Mandatory)
+
+**CRITICAL ANTI-HALLUCINATION RULE**: You MUST NOT skip the progress update. Agents routinely skip this step after validation passes. You must physically open and edit **each** of the following files using your file editing tools. Protocol reference: `.agent/skills/session-continuity/protocols/03-progress-update.md`.
+
+### 7a. Update the slice file: `.agent/progress/slices/phase-NN-slice-NN.md`
+
+Open the slice file matching the slice you just implemented (e.g., `phase-02-slice-05.md`).
+
+1. Set `**Status**:` to `complete`.
+2. Change every `[ ]` in **Acceptance Criteria** to `[x]`.
+3. Add an **Implementation Notes** section describing the approach taken.
+4. Add a **Files Changed** section listing every file you created or modified.
+
+### 7b. Update the phase file: `.agent/progress/phases/phase-NN.md`
+
+1. Find the slice's entry (e.g., `- [ ] **Slice 05**: ...`) and change it to `- [x] **Slice 05**: ... ✅ YYYY-MM-DD`.
+2. Mark each sub-task under it `[x]`.
+3. Update the `**Progress**:` header fraction (e.g., `4/13 slices` → `5/13 slices`).
+4. Release any `[!]` claim flags and remove `files:` lock blocks.
+
+### 7c. Update the index: `.agent/progress/index.md`
+
+1. Recalculate the **Overall** line: increment the slice count and recompute the percentage (e.g., `23/32 slices (71%)` → `24/32 slices (75%)`).
+2. Update the phase row in the table: increment its progress count.
+3. If the phase is now complete, change its status to `complete` and add ✅.
+
+### 7d. Log to memory
+
+1. Record any learned patterns to `.agent/progress/memory/patterns.md`.
+2. Record any blockers encountered to `.agent/progress/memory/blockers.md`.
+
+## 8. Completion Gate
+
+Read .agent/skills/verification-before-completion/SKILL.md and apply its evidence-before-claims discipline.
+
+### UI Completeness Check (FE slices only)
+
+- [ ] (FE slices only) Every acceptance criterion mentioning "user sees", "user can", "displays", or "shows" has a rendered implementation — not just a passing test
+- [ ] (FE slices only) Every new route in this slice is wired into the app's navigation (not just exported as a component)
+- [ ] (FE slices only) Loading, error, and empty states are rendered in the UI — not just covered by tests
+- [ ] (FE slices only) The feature is reachable from the app's entry point via normal user navigation
+
+These items apply only when the slice is tagged `FE`. Non-FE slices skip this block.
+
+### Spec Traceability Gate (all slices)
+
+Before calling `notify_user`, verify:
+
+- [ ] Re-read the BE spec section(s) for every endpoint in this slice — every response field, error code, and validation rule has a corresponding test tagged with the spec reference
+- [ ] Re-read the IA shard's `## Edge Cases` section for this slice's domain — every edge case relevant to this slice has a `// IA-EDGE:` tagged test
+- [ ] No `// DECISION:` annotations exist for behaviors that are actually specified in the BE spec or IA shard (i.e., no spec-defined behavior was treated as an undocumented implementation decision)
+- [ ] The Zod contract written in Step 2 matches the delivered implementation field-for-field — no fields added, removed, or renamed during implementation without a corresponding contract update
+
+> ❌ STOP — Do not call `notify_user` if any of the above are unchecked. Fix the gap, update the contract if needed, and re-run `{{TEST_COMMAND}}`.
+
+You may not call `notify_user` until you have physically edited **all four** file targets above (7a–7d).
+
+Verify your edits by reading each of the following files:
+- Read `.agent/progress/slices/phase-NN-slice-NN.md` — must show Status: complete and [x] criteria
+- Read `.agent/progress/phases/phase-NN.md` — search for "Progress" and verify it shows the incremented fraction
+- Read `.agent/progress/index.md` — search for "Overall" and verify it shows the new overall percentage
+
+Replace `NN` with the actual phase and slice numbers you just completed.
+
+Your `notify_user` payload **MUST** include:
+1. The raw output from the three commands above.
+2. The updated overall progress (e.g., "Overall progress is now 75% (24/32 slices)").
+3. The explicit next command: Run `/implement-slice` for [next slice name].
+
+If any command output shows unchecked criteria, a stale fraction, or a missing file, you have failed the workflow.
+
+**Infrastructure/Auth slice gate**: After completing progress tracking, check the slice name against the phase plan. If this was the `00-infrastructure` slice or the auth slice, the next command to run is `/verify-infrastructure`, not `/implement-slice`. Do not propose the next feature slice until `/verify-infrastructure` passes and produces a green report in `docs/audits/`.

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

@@ -0,0 +1,50 @@
+---
+description: TDD vertical slice — Red→Green→Refactor across all four surfaces
+pipeline:
+  position: 7
+  stage: implementation
+  predecessors: [plan-phase]
+  successors: [validate-phase]
+  loop: true # repeats per slice within a phase
+  skills: [tdd-workflow, error-handling-patterns, git-workflow, code-review-pro, testing-strategist, clean-code, logging-best-practices, minimalist-surgical-development, systematic-debugging]
+  calls-bootstrap: true # may discover new dependencies during implementation
+shards: [implement-slice-setup, implement-slice-tdd]
+---
+
+# Implement Slice
+
+Implement a single vertical slice using strict TDD: Red → Green → Refactor.
+
+**Input**: A slice from the phase plan with acceptance criteria
+**Output**: Working code across all surfaces with passing tests
+
+---
+
+## Shard Overview
+
+| # | Shard | What It Does |
+|---|-------|-------------|
+| 1 | [`implement-slice-setup`](.agent/workflows/implement-slice-setup.md) | Checks progress state, loads skills, reads slice, checks for parallel mode, writes contracts |
+| 2 | [`implement-slice-tdd`](.agent/workflows/implement-slice-tdd.md) | Executes Red→Green→Refactor, validates, updates all progress tracking files |
+
+---
+
+## Orchestration
+
+### Step A — Run `.agent/workflows/implement-slice-setup.md`
+
+Checks progress state and session continuity, loads all bundled skills, reads the slice acceptance criteria, determines if parallel mode applies, and writes the contract (Zod schema). If parallel mode is detected, dispatches agents for the TDD cycle.
+
+### Step B — Run `.agent/workflows/implement-slice-tdd.md`
+
+Executes the TDD cycle (RED: write failing tests → GREEN: implement → REFACTOR: improve quality), runs full validation, handles synthesis for parallel mode, and updates all 4 progress tracking targets (slice file, phase file, index, memory).
+
+---
+
+## Quality Gate
+
+You may not call `notify_user` until:
+- [ ] All tests pass (`{{TEST_COMMAND}}`)
+- [ ] Full validation passes (`{{VALIDATION_COMMAND}}`)
+- [ ] All 4 progress tracking files updated (slice, phase, index, memory)
+- [ ] Each tracking file verified by re-reading after edit

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

@@ -0,0 +1,202 @@
+---
+description: Create TDD vertical slices for one phase, with acceptance criteria per item
+pipeline:
+  position: 6
+  stage: planning
+  predecessors: [write-be-spec, write-fe-spec] # join point — waits for both
+  successors: [implement-slice]
+  skills: [resolve-ambiguity, testing-strategist, technical-writer]
+  calls-bootstrap: true
+---
+
+// turbo-all
+
+# Plan Phase
+
+Break a phase into TDD vertical slices, each spanning all four surfaces (contract, test, implementation, UI).
+
+> **Every slice ships production-grade code.** Slices are ordered by dependency,
+> not by quality tier. The first slice and the last slice meet the same bar.
+
+**Input**: Approved specs (IA + BE + FE) and the phasing section from architecture design
+**Output**: Phase plan with ordered slices and acceptance criteria
+
+---
+
+## 0. Phase sequencing gate
+
+Read `.agent/progress/index.md` to identify the current phase number N.
+
+- **If N = 1** → this is the first phase. Skip this gate.
+- **If N > 1** → read `.agent/progress/phases/phase-[N-1].md` and verify its status is `complete` with a passing `/validate-phase`. **Hard stop** if the previous phase is not complete: "Phase [N-1] must be complete with a passing `/validate-phase` before planning Phase [N]. Run `/validate-phase` for Phase [N-1] first."
+
+  **Architecture map freshness check (N > 1 only)** — warning, not a hard stop. Skipped entirely for Phase 1.
+
+  If `docs/ARCHITECTURE.md` exists, compare its "Last updated" date against the Phase N-1 completion date from `.agent/progress/phases/phase-[N-1].md`. If the map is **older** than Phase N-1 completion:
+
+  > ⚠️ `docs/ARCHITECTURE.md` may not reflect current state. Run `/update-architecture-map` or reply `"confirmed"` if intentionally current.
+
+  **Wait** for user resolution before proceeding to Step 0.1. If dates are equal/newer, or the file doesn't exist, proceed silently.
+
+---
+
+## 0.1. Load planning skills
+
+Read these skills for slice planning guidance:
+1. `.agent/skills/testing-strategist/SKILL.md` — Test strategy per slice
+2. `.agent/skills/technical-writer/SKILL.md` — Acceptance criteria clarity
+
+---
+
+## 0.5. Application Completeness Audit
+
+Before running checks: read `{{SURFACES}}` from `.agent/instructions/tech-stack.md`. For each row in the table below, only run the check if the "Applies To" column matches the project's confirmed surfaces. Skip rows that don't apply — a missing check for an inapplicable surface is not a failure.
+
+Read all FE specs in `docs/plans/fe/` and check the following table.
+
+| Check | Applies To | What It Verifies |
+|---|---|---|
+| **Route coverage** | web, mobile, desktop | Every route in the app is specced in at least one FE spec |
+| **Navigation coverage** | web, mobile, desktop | Every route is reachable from at least one navigation element |
+| **Auth state coverage** | all surfaces (if auth exists) | Every auth state (logged out, logged in, insufficient permissions) has a defined UI or response |
+| **Empty state coverage** | web, mobile, desktop | Every data-fetching view has an empty state spec |
+| **Error state coverage** | all surfaces | Every data-fetching operation has an error response or error state spec |
+| **Onboarding coverage** | all surfaces (if accounts exist) | First-run or onboarding flow is specced |
+| **404/error pages** | web, desktop | Global error pages (404, 500, offline) are specced |
+| **Help/usage output** | cli | `--help` flag output is specced and documents all commands |
+| **Exit codes** | cli | All error exit codes and their meanings are documented in a spec |
+| **Command discovery** | cli | Command listing or autocomplete behavior is specced |
+
+**If ANY applicable check fails → stop and tell the user exactly which FE specs need to be updated. Do NOT proceed to create a phase plan.**
+
+Only when all **applicable** checks pass does the workflow continue to the next step.
+
+---
+
+## 0.6. BE↔FE Coverage Cross-Check
+
+Read `docs/plans/be/index.md` and `docs/plans/fe/index.md`.
+
+For every BE spec listed in `docs/plans/be/index.md`, check whether at least one FE spec's `## Source Map` section references it. Apply the following rules:
+
+1. **Covered**: The BE spec appears in at least one FE `## Source Map` → pass.
+2. **Internal-only exception**: If the BE spec is annotated `[internal-only — no UI]` in the BE index, it is exempt from FE coverage → pass.
+3. **Uncovered**: The BE spec is neither covered by an FE Source Map nor marked `[internal-only — no UI]` → collect it in the uncovered list.
+
+**If the uncovered list is empty** → proceed to the next step.
+
+**If any uncovered non-internal BE specs exist** → **hard stop**. Present the uncovered list and ask:
+
+> "The following BE specs have no FE coverage and are not marked `[internal-only — no UI]`:
+>
+> - `[be-spec-filename-1]`
+> - `[be-spec-filename-2]`
+>
+> For each, either:
+> 1. Add FE coverage via `/write-fe-spec`
+> 2. Mark the BE spec as `[internal-only — no UI]` in `docs/plans/be/index.md` if it has no user-facing surface
+>
+> Confirm when resolved."
+
+Do not proceed until the user confirms all uncovered specs are resolved.
+
+---
+
+## 0.8. Draft continuity check
+
+Check whether `docs/plans/phases/phase-N-draft.md` already exists (where N is the current phase number).
+
+- **If it exists**: Read it and identify which slices are already drafted (have acceptance criteria written) vs which are missing. Present the current state: "A draft exists for Phase N with [X] slices already written. Do you want to **continue from where you left off** (add missing slices only), or **start fresh** (overwrite the draft)?" Wait for the user's answer.
+- **If it does not exist**: Proceed normally.
+
+## 1. Read phase scope
+
+Read the file at `docs/plans/*-architecture-design.md` (phasing section) and the file at `docs/plans/be/index.md` (which specs to include).
+
+## 2. Identify slices (spec-anchored derivation)
+
+For each FE spec in the phase scope:
+1. Open the FE spec's `## Interaction Specification` section
+2. Enumerate every distinct named user flow (e.g., "Submit entity claim form", "Search directory with filters", "View entity detail page")
+3. For each user flow, identify its primary BE endpoint from the FE spec's `## Source Map`
+4. Group flows into one slice only when:
+   a. They share the exact same DB write (true dependency, not just same domain), OR
+   b. They are a required sequence (flow B cannot be tested without flow A existing)
+5. Flows that do not meet criteria (a) or (b) become individual slices
+
+The resulting list of slices is derived from the spec, not estimated from feature names. Do not aggregate slices by domain name or by "it feels like one feature."
+
+Estimate complexity (S/M/L) per derived slice. Flag any slice estimated L — these are candidates for further splitting before ordering begins.
+
+**Good slice**: "User can submit an entity claim form" (one named user flow from the FE interaction spec)
+**Bad slice**: "Implement entity management" (domain name, not a spec-derived user flow)
+
+## 3. Order by dependency
+
+Read .agent/skills/concise-planning/SKILL.md and follow its methodology.
+
+Sort slices so each builds on the last:
+- Infrastructure slices first (DB schema, auth middleware)
+
+**Phase 1 special rule**: The `00-infrastructure` shard is always the first slice. Verify it covers: (1) CI/CD pipeline setup — read `.agent/skills/{{CI_CD_SKILL}}/SKILL.md`, (2) environment configuration (`.env.example`), (3) deployment pipeline — read `.agent/skills/{{HOSTING_SKILL}}/SKILL.md`, (4) project scaffolding from `.agent/instructions/structure.md` (directories, `README.md` files, base configs), (5) database initialization. Add missing items before proceeding.
+
+**Verification gates** (hard gates — add explicitly to the phase plan):
+- `/verify-infrastructure` MUST pass after the infrastructure slice, before any feature slice.
+- `/verify-infrastructure` MUST pass again after the auth slice (with auth smoke test), before any auth-dependent feature slice.
+
+- Core entity CRUD second
+- Dependent features next
+- Cross-cutting concerns (logging, monitoring, error handling) woven throughout
+
+**Note:** This ordering is about dependencies, not about deferring quality.
+Every slice — including the first infrastructure slice — is fully tested,
+fully specified, and production-ready.
+
+## 4. Write acceptance criteria
+
+Read `.agent/skills/prd-templates/references/operational-templates.md` for the **Slice Acceptance Criteria** template. For each slice, use the template to define testable acceptance criteria with surface tags:
+
+> **Write as you go**: After completing acceptance criteria for each slice, immediately append that slice's entry to `docs/plans/phases/phase-N-draft.md` (create the file if it doesn't exist). Do not accumulate all slices in context and write them all at once in Step 5.
+
+**Surface tag rules:**
+- `BE`: API routes, DB queries, middleware, business logic, server-side validation
+- `FE`: Pages, components, styling, interactions, client-side logic
+- `QA`: Test writing (RED phase — runs FIRST), test verification (GREEN phase — runs LAST)
+- No tag: Contract/schema work, shared infra — handled sequentially by orchestrator
+
+## 4.5. Identify parallel groups (TDD order)
+
+Read .agent/skills/parallel-agents/SKILL.md and apply its workstream decomposition methodology to identify independent parallel groups.
+
+For each slice, determine the execution order following TDD:
+
+> **Tests are the rock. Code is malleable.** Tests encode the acceptance criteria
+> and must be comprehensive. Code adapts to pass tests, never the reverse.
+
+Read `.agent/skills/parallel-agents/SKILL.md` and follow its TDD-Order Dispatch methodology for parallel groups and execution order. Flag any tasks that can't be parallelized (shared file dependencies) in the plan.
+
+## 5. Finalize phase plan
+
+Read `docs/plans/phases/phase-N-draft.md` (which was built progressively in Step 4) and write the final formatted phase plan to `docs/plans/phases/phase-N.md`. The draft is the authoritative source — do not add or drop slices during finalization.
+
+## 6. Generate progress files
+
+Read `.agent/skills/session-continuity/protocols/02-progress-generation.md` and follow the **Progress Generation Protocol** to create tracking files for this phase in `.agent/progress/`.
+
+## 6.5. Bootstrap Completeness Gate
+
+Scan these four files for literal `{{` occurrences of `LANGUAGE_SKILL`, `HOSTING_SKILL`, `CI_CD_SKILL`, `ORM_SKILL`, `UNIT_TESTING_SKILL`, `E2E_TESTING_SKILL`:
+- `.agent/workflows/implement-slice-setup.md`
+- `.agent/workflows/implement-slice-tdd.md`
+- `.agent/workflows/verify-infrastructure.md`
+- `.agent/workflows/validate-phase.md`
+
+For each unfilled placeholder, read `docs/plans/*-architecture-design.md` to extract the confirmed value, then run `/bootstrap-agents` (see `.agent/workflows/bootstrap-agents.md`) with the corresponding key.
+
+> ❌ STOP — Re-scan the four files. Only proceed to Step 7 when zero `{{` patterns remain. If any remain unfilled after bootstrap, tell the user which placeholders could not be provisioned.
+
+## 7. Request review and next steps
+
+Use `notify_user` to request review of the phase plan and generated progress files.
+
+**Proposed next step**: Once approved, run `/implement-slice` for the first slice in the phase plan. Read `.agent/progress/` to identify which slice to start with.