# Product Plan Workflow

<template_meta>
name: product-plan
version: 1
requires_project: false
artifact_dir: .sf/workflows/product-plan/
</template_meta>

<purpose>
Plan the product increment before development starts. This workflow turns a
product idea into a concrete product model, capability boundary, implementation
slice plan, and readiness review so engineering work has a real consumer,
acceptance path, and verification strategy.
</purpose>

<phases>
1. model - Document the product, users, value flow, and domain entities
2. scope - Define the target capability, MVP boundary, non-goals, and risks
3. slice - Break the work into implementation slices with evidence
4. ready - Confirm blockers, tests, release needs, and follow-up decisions
</phases>

<process>

## Phase 1: Model Product

**Goal:** Establish what product is being built and why it should exist.

1. Read the user request, existing docs, README, product surfaces, routes, APIs, tests, and current plans if present.
2. Identify users, customers, operators, organizations/accounts, core workflows, value moments, and domain entities.
3. Separate confirmed product facts from assumptions and open questions.
4. Produce `PRODUCT.md` in the artifact directory.

**Completion evidence:**
- The product model names real users or production consumers.
- Core workflows and entities are explicit.
- Unknowns are listed instead of guessed.

## Phase 2: Scope Target Capability

**Goal:** Turn the product model into a bounded increment that can be developed.

1. Define the capability or MVP boundary in user-facing terms.
2. Name what is in scope, out of scope, and deliberately deferred.
3. Identify integration points, data needs, permissions, UX/API surfaces, and operational constraints.
4. Define acceptance criteria and falsifiers for the planned capability.
5. Produce `SCOPE.md` in the artifact directory.

**Completion evidence:**
- The target capability can be explained without implementation details.
- Non-goals and release assumptions are explicit.
- Acceptance criteria describe observable behavior.

## Phase 3: Plan Implementation Slices

**Goal:** Create a buildable plan that preserves product intent through implementation.

1. Break the capability into ordered slices.
2. For each slice, state purpose, consumer, files or modules likely affected, dependencies, tests, and integration closure.
3. Identify telemetry, audit, docs, migration, or support work that must ship with the product.
4. Produce `PLAN.md` in the artifact directory.

**Completion evidence:**
- Each slice has a real consumer and a verification path.
- Dependencies and sequencing are explicit.
- Cross-cutting concerns are recorded as slices or follow-up work.

## Phase 4: Confirm Readiness

**Goal:** Decide whether development can begin without re-deciding the product.

1. Review the product model, scope, and slice plan for missing purpose, missing consumers, untestable behavior, and unresolved blockers.
2. Decide whether product tracking should run now or later. If now, hand off to `/start product-tracking`.
3. Record verification commands, release gates, remaining open questions, and implementation start criteria.
4. Produce `READY.md` in the artifact directory.

**Completion evidence:**
- The plan is ready for implementation or blocked with named decisions.
- Verification and release gates are known.
- Telemetry and product-audit follow-ups are explicit.

</process>
