@curdx/flow 3.0.0 → 3.1.0

package/skills/init/references/scaffold-contract.md

@@ -1,27 +0,0 @@
-# Init Scaffold Contract — What Must Be Created
-
-Create the runtime skeleton:
-
-- `.flow/specs/`
-- `.flow/_epics/`
-- `.flow/checkpoints/`
-- `.flow/threads/`
-- `.flow/seeds/`
-
-Render the canonical scaffold files from `${CLAUDE_PLUGIN_ROOT}/templates/`:
-
-- `templates/PROJECT.md.tmpl` -> `.flow/PROJECT.md`
-- `templates/CONTEXT.md.tmpl` -> `.flow/CONTEXT.md`
-- `templates/STATE.md.tmpl` -> `.flow/STATE.md`
-- `templates/ROADMAP.md.tmpl` -> `.flow/ROADMAP.md`
-- `templates/config.json.tmpl` -> `.flow/config.json`
-
-Populate placeholders with:
-
-- `{{PROJECT_NAME}}` from the current directory name unless the user gave a
-  better project label
-- `{{CREATED_DATE}}` from the current date
-- `{{USER_NAME}}` from git config when available
-
-Create missing scaffold files. Do not overwrite user-edited canonical files
-unless the user explicitly asks for a reset.

package/skills/review/SKILL.md

@@ -1,82 +0,0 @@
----
-name: review
-description: Run two-stage review with optional adversarial, edge-case, and DevEx passes.
-when_to_use: Use when implementation exists and the user wants review findings, spec-compliance checks, adversarial review, edge-case hunting, or a DevEx audit.
-argument-hint: "[--stage=<1|2|both>] [--adversarial] [--edge-case] [--devex]"
-disable-model-invocation: true
-allowed-tools: [Read, Bash, Agent, Grep, Glob]
----
-
-# Two-Stage Code Review
-
-Distinct from `/curdx-flow:verify`:
-
-- `verify` checks whether the spec's user-visible goals work
-- `review` checks whether the implementation is correct, aligned, and maintainable
-
-Keep this entrypoint focused on review routing, pass selection, and final
-report handoff.
-
-When this skill is used for follow-up work after prior review comments, apply
-`@${CLAUDE_PLUGIN_ROOT}/knowledge/review-feedback-intake.md` first so accepted
-fixes and technical pushback are recorded in `.progress.md`.
-
-Detailed review protocols live in:
-
-- `references/preflight.md`
-- `references/stage-execution.md`
-- `references/optional-passes.md`
-- `references/report-contract.md`
-- `references/reporting.md`
-
-## Flags
-
-| Flag | Default | Purpose |
-|------|---------|---------|
-| `--stage=<1\|2\|both>` | `both` | Stage 1 = spec compliance only. Stage 2 = code quality only. `both` = sequential. |
-| `--adversarial` | off (`enterprise` -> on) | Add an adversarial review pass across applicable categories. |
-| `--edge-case` | off (`enterprise` -> on) | Add edge-case hunting across applicable categories. Produces a test-gap checklist. |
-| `--devex` | off (`enterprise` -> on) | Add the DevEx audit for naming, comments, structure, error handling, setup, types, tests, and developer loop. |
-
-## Preflight
-
-Use `references/preflight.md` for:
-
-- `.flow/` and active-spec checks
-- required artifact checks
-- mode-aware `--stage`, `--adversarial`, `--edge-case`, and `--devex`
-  normalization
-
-## Stage Execution
-
-Stage responsibilities, reviewer prompts, and pass/fail expectations live in
-`references/stage-execution.md`.
-
-- Stage 1 -> `flow-reviewer` in spec-compliance mode
-- Stage 2 -> `flow-reviewer` in code-quality mode
-
-Optional adversarial, edge-case, and DevEx extensions live in
-`references/optional-passes.md`.
-
-## Report Contract
-
-Landing checks, report shape, and final status output live in
-`references/report-contract.md`.
-
-The report lands at:
-
-- `.flow/specs/$SPEC_NAME/review-report.md`
-
-## Reporting
-
-Use `references/reporting.md` for the final summary and rerun handoff.
-
-## References
-
-- `flow-reviewer` agent: `@${CLAUDE_PLUGIN_ROOT}/agents/flow-reviewer.md`
-- `flow-adversary` agent: `@${CLAUDE_PLUGIN_ROOT}/agents/flow-adversary.md`
-- `flow-edge-hunter` agent: `@${CLAUDE_PLUGIN_ROOT}/agents/flow-edge-hunter.md`
-- `adversarial-review-gate`: `@${CLAUDE_PLUGIN_ROOT}/gates/adversarial-review-gate.md`
-- `edge-case-gate`: `@${CLAUDE_PLUGIN_ROOT}/gates/edge-case-gate.md`
-- `devex-gate`: `@${CLAUDE_PLUGIN_ROOT}/gates/devex-gate.md`
-- Knowledge: `@${CLAUDE_PLUGIN_ROOT}/knowledge/two-stage-review.md`

package/skills/review/references/optional-passes.md

@@ -1,48 +0,0 @@
-# Optional Passes — Adversarial, Edge Cases, DevEx
-
-## Adversarial Review
-
-If `FLAG_ADV=1` after preflight normalization, dispatch `flow-adversary`
-across applicable categories:
-
-1. What's missing?
-2. What's overengineered?
-3. What breaks first in production?
-4. What would a new maintainer misunderstand?
-5. What choice locks out a future option?
-6. What would a skeptical reviewer reject?
-
-Zero findings still requires proof-of-checking.
-
-## Edge-Case Hunting
-
-If `FLAG_EDGE=1` after preflight normalization, dispatch `flow-edge-hunter`
-across:
-
-1. boundary values
-2. concurrency and races
-3. network or partial failure
-4. malformed input
-5. auth and permission failure
-6. resource exhaustion
-7. time, locale, and timezone
-
-Output: a test-gap checklist.
-
-## DevEx Audit
-
-If `FLAG_DEVEX=1` after preflight normalization, inject
-`@${CLAUDE_PLUGIN_ROOT}/gates/devex-gate.md` into `flow-reviewer` so Stage 2
-also evaluates:
-
-1. naming
-2. comments
-3. structure
-4. error handling
-5. setup
-6. types
-7. tests
-8. developer loop
-
-Do not fork a separate custom reviewer for DevEx; keep `flow-reviewer` generic
-and extend it with the gate file.

package/skills/review/references/preflight.md

@@ -1,38 +0,0 @@
-# Review Preflight — Resolve Scope and Flags
-
-Before dispatching any reviewer:
-
-```bash
-[ ! -d ".flow" ] && { echo "✗ Not a CurdX-Flow project."; exit 1; }
-
-SPEC_NAME=$(cat .flow/.active-spec 2>/dev/null)
-[ -z "$SPEC_NAME" ] && { echo "✗ No active spec."; exit 1; }
-
-SPEC_STATE=".flow/specs/$SPEC_NAME/.state.json"
-SPEC_MODE=$(grep -oP '"mode"\\s*:\\s*"\\K[^"]+' "$SPEC_STATE" 2>/dev/null || echo "standard")
-
-for f in design.md; do
-  [ ! -f ".flow/specs/$SPEC_NAME/$f" ] && {
-    echo "✗ Missing $f. Run /curdx-flow:spec first.";
-    exit 1;
-  }
-done
-
-FLAG_STAGE=$(echo "$ARGUMENTS" | grep -oP -- '--stage=\K[^\s]+' || echo "both")
-FLAG_ADV=$(echo "$ARGUMENTS" | grep -q -- '--adversarial' && echo 1 || echo 0)
-FLAG_EDGE=$(echo "$ARGUMENTS" | grep -q -- '--edge-case' && echo 1 || echo 0)
-FLAG_DEVEX=$(echo "$ARGUMENTS" | grep -q -- '--devex' && echo 1 || echo 0)
-
-if [ "$SPEC_MODE" = "enterprise" ]; then
-  FLAG_ADV=1
-  FLAG_EDGE=1
-  FLAG_DEVEX=1
-fi
-```
-
-The entrypoint should resolve flags once, then route all review passes from
-that normalized configuration rather than reparsing later.
-
-`enterprise` mode auto-enables adversarial, edge-case, and DevEx review even
-when the user does not pass those flags explicitly. Manual flags still force
-the same behavior in non-enterprise modes.

package/skills/review/references/report-contract.md

@@ -1,49 +0,0 @@
-# Report Contract — Landing, Shape, Verdict
-
-## Landing Check
-
-Sub-agent responses can truncate before the report is written. After dispatching
-review agents, verify the report actually landed:
-
-```bash
-REPORT=".flow/specs/$SPEC_NAME/review-report.md"
-if [ ! -f "$REPORT" ] || [ "$(wc -c < "$REPORT" 2>/dev/null | tr -d ' ')" -lt 300 ]; then
-  echo "⚠ Report missing or truncated. Re-dispatching flow-reviewer with a terse 'Write the report now, no narration' prompt."
-fi
-```
-
-## Report Shape
-
-```markdown
-# Review Report — <spec-name>
-
-## Stage 1 — Spec Compliance
-...
-
-## Stage 2 — Code Quality
-...
-
-## Adversarial (if run)
-...
-
-## Edge Cases (if run)
-...
-
-## DevEx (if run)
-...
-
-## Verdict
-- [ ] APPROVED
-- [X] CHANGES REQUIRED — <n> blockers
-- [ ] REJECTED
-```
-
-## Final Output
-
-Summarize:
-
-- Stage 1 finding count
-- Stage 2 finding count
-- optional pass finding counts
-- final verdict
-- report path

package/skills/review/references/reporting.md

@@ -1,20 +0,0 @@
-# Review Reporting — Final Summary and Rerun Handoff
-
-End with a compact review summary:
-
-```text
-✓ Review complete
-  Stage 1 findings: <n>
-  Stage 2 findings: <n>
-  Adversarial findings: <n>   (if adversarial pass ran)
-  Edge-case gaps: <n>         (if edge-case pass ran)
-  DevEx findings: <n>         (if DevEx audit ran)
-  Verdict: CHANGES REQUIRED
-
-Report: .flow/specs/<name>/review-report.md
-
-Next: address blockers, then re-run /curdx-flow:review.
-```
-
-Keep the response outcome-focused. The report file is the artifact; the closing
-message only confirms counts, verdict, path, and next action.

package/skills/review/references/stage-execution.md

@@ -1,32 +0,0 @@
-# Review Stages — Core Two-Pass Protocol
-
-## Stage 1 — Spec Compliance
-
-Dispatch `flow-reviewer` in Stage 1 mode. It verifies:
-
-- every relevant `US`, `AC`, `FR`, and `NFR` in `requirements.md`
-- architecture decisions in `design.md`
-- `tasks.md` completion claims versus actual code
-- conventional commits versus declared task completion
-
-Output: the Stage 1 section of the review report with compliance gaps and
-evidence.
-
-## Stage 2 — Code Quality
-
-Dispatch `flow-reviewer` in Stage 2 mode. It checks:
-
-- naming, comments, and structure
-- error handling completeness
-- test quality and coverage
-- performance and resource concerns
-- security smells
-- Karpathy 4 principles
-
-Output: the Stage 2 section of the review report with prioritized findings.
-
-## Sequencing
-
-- `--stage=1` -> run only Stage 1
-- `--stage=2` -> run only Stage 2
-- `--stage=both` -> Stage 1 first, then Stage 2

package/skills/security-audit/SKILL.md

@@ -1,47 +0,0 @@
----
-name: security-audit
-description: Use when the user needs security review of code, specs, credentials, sensitive data, or dependency risk.
-when_to_use: Triggers on "security", "auth", "authentication", "credential", "password", "secret", "API key", "token", "OWASP", "STRIDE", "CVE", "vulnerability", "injection", "XSS", "CSRF", "SSRF", "SQL injection", "hardcoded secret", "sensitive data", "leak", "will my API key leak", "is this safe".
-argument-hint: "[scope] [--depth=<owasp|stride|full>]"
-context: fork
-agent: flow-security-auditor
-paths:
-  - "**/*.{js,jsx,ts,tsx,py,rb,go,java,kt,php,cs,rs,swift,sql,sh}"
-  - "**/*.{json,yml,yaml,toml,tf,hcl,conf,ini}"
-  - "**/.env*"
-  - "**/Dockerfile*"
-  - ".github/workflows/**"
-  - ".gitlab-ci.yml"
-  - "docker-compose*.yml"
-  - "k8s/**"
-  - "helm/**"
-  - "infra/**"
-  - "terraform/**"
----
-
-# Security Audit
-
-This skill orchestrates scoped security review. Keep the entrypoint focused on
-scope/depth selection, required audit outputs, and the blocking gate. Detailed
-rules live in:
-
-- `references/scope-and-depth.md`
-- `references/audit-contract.md`
-- `references/gate-handoff.md`
-
-## Scope and Depth
-
-Use `references/scope-and-depth.md` to confirm:
-
-- scope
-- audit depth
-- risk tolerance
-
-## Audit Contract
-
-`flow-security-auditor` should follow `references/audit-contract.md`.
-
-## Gate and Handoff
-
-Blocking semantics and next-step routing live in
-`references/gate-handoff.md`.

package/skills/security-audit/references/audit-contract.md

@@ -1,21 +0,0 @@
-# Security Audit Contract — What the Auditor Must Produce
-
-`flow-security-auditor` should:
-
-1. scan for secrets, weak crypto, and unsafe inputs
-2. apply OWASP Top 10
-3. apply STRIDE threat modeling when requested
-4. run dependency CVE scanning
-5. label findings by severity
-
-## Required Artifact
-
-- `.flow/specs/<active>/security-audit.md`
-
-The report should include:
-
-- SR (blocking)
-- SW (warning)
-- SM (mandatory baseline)
-- CVE hits
-- concrete fixes

package/skills/security-audit/references/gate-handoff.md

@@ -1,8 +0,0 @@
-# Security Gate Handoff — Blocking Rules and Next Steps
-
-Apply `@${CLAUDE_PLUGIN_ROOT}/gates/security-gate.md`.
-
-- if any SR findings exist, block completion until remediated or explicitly
-  waived with a D-NN decision in `STATE.md`
-- if findings are advisory only, hand off `security-audit.md` as evidence for
-  later implementation or review work

package/skills/security-audit/references/scope-and-depth.md

@@ -1,9 +0,0 @@
-# Security Scope and Depth — Confirm the Audit Shape
-
-Before dispatching, confirm:
-
-- scope: current spec, specific path, or whole repo
-- depth: `owasp`, `stride`, or `full`
-- risk tolerance: blocking vs advisory
-
-The positional first argument is the scope. Depth stays in `--depth=...`.

package/skills/spec/SKILL.md

@@ -1,100 +0,0 @@
----
-name: spec
-description: Generate or refresh research, requirements, design, and tasks for the active spec.
-when_to_use: Use when the user wants to generate, resume, regenerate, or review a feature spec across research, requirements, design, and task planning.
-argument-hint: "[--phase=<X[,Y,...]>] [--until=<X>] [--review[=<dim[,dim]>]] [--regenerate] [--resume]"
-disable-model-invocation: true
-allowed-tools: [Read, Write, Bash, Agent, AskUserQuestion]
----
-
-# Generate or Refresh the Active Spec
-
-This command writes `research.md`, `requirements.md`, `design.md`, and
-`tasks.md` into `.flow/specs/<active-spec>/`.
-
-Keep this entrypoint focused on phase selection and orchestration. Detailed
-phase prompts and landing checks live in:
-
-- `references/preflight-and-routing.md`
-- `references/phase-execution.md`
-- `references/artifact-landing.md`
-- `references/planning-review.md`
-- `references/reporting.md`
-
-## Flags
-
-| Flag | Default | Purpose |
-|------|---------|---------|
-| `--phase=<X[,Y]>` | (inferred from `.state.json`) | Run only the listed phase(s). `X ∈ {research, requirements, design, tasks}`. Accepts comma-separated list. |
-| `--until=<X>` | (none) | Run from the current phase forward, stopping after `X`. Mutually exclusive with `--phase`. |
-| `--review[=<dim[,dim]>]` | (not run) | After phases complete, run a planning review. `dim ∈ {ceo, eng, design, dx, all}`. Bare `--review` = `--review=all`. |
-| `--regenerate` | (resume) | Wipe existing phase output for the targeted phases and rebuild from scratch. |
-| `--resume` | (default) | Continue from `.state.json.phase`. This is the default when no flag is given. |
-
-## Preflight
-
-Use `references/preflight-and-routing.md` for:
-
-- `.flow/`, active spec, and `.state.json` checks
-- flag parsing and invalid flag combinations
-- ordered phase routing and `--regenerate` scope resolution
-
-## Phase Resolution
-
-The ordered pipeline is still `research -> requirements -> design -> tasks`.
-The exact routing rules and stopping points are defined in
-`references/preflight-and-routing.md`.
-
-## Phase Dispatch
-
-Phase-specific prompts, mandatory output protocols, and post-phase state updates
-live in `references/phase-execution.md`.
-
-Use this phase-to-agent mapping:
-
-| Phase | Agent | Output |
-|-------|-------|--------|
-| `research` | `flow-researcher` | `research.md` |
-| `requirements` | `flow-product-designer` | `requirements.md` |
-| `design` | `flow-architect` | `design.md` |
-| `tasks` | `flow-planner` | `tasks.md` |
-
-After each dispatch, run the landing guard from
-`references/artifact-landing.md`. Never advance phase state based only on the
-agent's narrative response.
-
-## Optional Planning Review
-
-If `--review` is present, use the dimension-expansion and aggregation protocol
-from `references/planning-review.md`.
-
-The review output lands at:
-
-- `.flow/specs/<active>/spec-review.md`
-
-## Reporting
-
-Use `references/reporting.md` for the final user-visible summary and next-step
-handoff.
-
-## Common Invocations
-
-```text
-/curdx-flow:spec
-/curdx-flow:spec --phase=design
-/curdx-flow:spec --phase=design,tasks
-/curdx-flow:spec --until=design
-/curdx-flow:spec --review
-/curdx-flow:spec --review=eng,dx
-/curdx-flow:spec --regenerate
-/curdx-flow:spec --regenerate --phase=tasks
-```
-
-## References
-
-- Agents: `@${CLAUDE_PLUGIN_ROOT}/agents/flow-researcher.md`,
-  `flow-product-designer.md`, `flow-architect.md`, `flow-planner.md`,
-  `flow-ux-designer.md`
-- Knowledge: `@${CLAUDE_PLUGIN_ROOT}/knowledge/spec-driven-development.md`,
-  `poc-first-workflow.md`
-- Preamble: `@${CLAUDE_PLUGIN_ROOT}/agent-preamble/preamble.md`

package/skills/spec/references/artifact-landing.md

@@ -1,31 +0,0 @@
-# Artifact Landing Check — Mandatory After Every Phase
-
-Sub-agent responses can be truncated before the `Write` tool call happens. Do
-not trust the agent response alone.
-
-## Landing Guard
-
-```bash
-ARTIFACT=".flow/specs/$SPEC_NAME/<phase>.md"
-if [ ! -f "$ARTIFACT" ]; then
-  echo "⚠ $ARTIFACT did not land. Re-dispatching <phase> agent with an explicit 'write the file' prompt."
-fi
-
-if [ -f "$ARTIFACT" ] && [ "$(wc -c < "$ARTIFACT" | tr -d ' ')" -lt 500 ]; then
-  echo "⚠ $ARTIFACT looks truncated (<500 bytes). Re-dispatching to complete it."
-fi
-```
-
-## Re-dispatch Rule
-
-If the artifact is missing or obviously truncated, front-load the retry prompt
-with:
-
-```text
-Your ONLY job is to call the Write tool with the full <phase>.md content now.
-Do not explain. Do not narrate. Write the file and stop.
-```
-
-Only advance `.state.json.phase` after the file exists and passes the size
-sanity check. If a second dispatch still fails, stop and surface the problem to
-the user rather than silently continuing.

package/skills/spec/references/phase-execution.md

@@ -1,50 +0,0 @@
-# Phase Execution — Dispatch Contracts
-
-Each phase writes exactly one artifact. The file is the deliverable; agent
-commentary is not.
-
-Shared runtime references:
-
-- `${CLAUDE_PLUGIN_ROOT}/knowledge/artifact-output-discipline.md`
-- `${CLAUDE_PLUGIN_ROOT}/knowledge/artifact-summary-contracts.md`
-
-## Phase Map
-
-| Phase | Agent | Inputs | Output |
-|-------|-------|--------|--------|
-| `research` | `flow-researcher` | spec goal + one-line description from `.state.json` | `research.md` |
-| `requirements` | `flow-product-designer` | `research.md` | `requirements.md` |
-| `design` | `flow-architect` | `research.md` + `requirements.md` | `design.md` |
-| `tasks` | `flow-planner` | all prior artifacts + `.flow/PROJECT.md` | `tasks.md` |
-
-## Shared Dispatch Rule
-
-Every phase dispatch must explicitly enforce the same two rules:
-
-1. The first substantive action is the `Write` call for the final artifact.
-2. After the write lands, emit only the matching summary contract from
-   `${CLAUDE_PLUGIN_ROOT}/knowledge/artifact-summary-contracts.md`.
-
-Do not inline previews, rationale summaries, or duplicate artifact content in
-the orchestration skill.
-
-## Phase Output Contracts
-
-| Phase | Artifact | Summary contract | Next line |
-|-------|----------|------------------|-----------|
-| `research` | `research.md` | `research.md` section | `Next: /curdx-flow:spec --phase=requirements` |
-| `requirements` | `requirements.md` | `requirements.md` section | `Next: /curdx-flow:spec --phase=design` |
-| `design` | `design.md` | `design.md` section | `Next: /curdx-flow:spec --phase=tasks` |
-| `tasks` | `tasks.md` | `tasks.md` section | `Next: /curdx-flow:implement` |
-
-## Post-Phase State Update
-
-After the artifact lands and passes landing checks, update `.state.json`:
-
-```json
-{
-  "phase": "<just-completed-phase>",
-  "phase_status": { "<phase>": "completed" },
-  "updated": "<ISO8601 timestamp>"
-}
-```

package/skills/spec/references/planning-review.md

@@ -1,31 +0,0 @@
-# Planning Review — Optional Multi-Dimension Pass
-
-Use this only when `--review` is present.
-
-## Preconditions
-
-- `design.md` must exist
-- Bare `--review` expands to `ceo,eng,design,dx`
-- `all` also expands to `ceo,eng,design,dx`
-
-## Dimension Map
-
-| Dim | Agent | Focus |
-|-----|-------|-------|
-| `ceo` | `flow-architect` (review mode) | Strategic scope fit, ROI, opportunity cost |
-| `eng` | `flow-architect` (review mode) | Lock-in risk, architecture debt, technical risk |
-| `design` | `flow-ux-designer` | UX, UI, accessibility, design system fit |
-| `dx` | `flow-architect` (review mode) | Naming, structure, setup, types, tests, developer loop |
-
-## Aggregation
-
-Dispatch one review agent per dimension, aggregate findings into:
-
-```text
-.flow/specs/<active>/spec-review.md
-```
-
-The report must contain:
-
-- one section per requested dimension
-- a consolidated verdict: `GO`, `GO-WITH-CHANGES`, or `HOLD`

package/skills/spec/references/preflight-and-routing.md

@@ -1,46 +0,0 @@
-# Spec Preflight and Routing — Resolve What Runs
-
-Before dispatching any phase:
-
-```bash
-[ ! -d ".flow" ] && {
-  echo "✗ Not a CurdX-Flow project. Run /curdx-flow:init first.";
-  exit 1;
-}
-
-SPEC_NAME=$(cat .flow/.active-spec 2>/dev/null)
-if [ -z "$SPEC_NAME" ]; then
-  echo "✗ No active spec. Run /curdx-flow:start <name> \"<goal>\" first.";
-  exit 1;
-fi
-SPEC_DIR=".flow/specs/$SPEC_NAME"
-STATE_FILE="$SPEC_DIR/.state.json"
-[ ! -f "$STATE_FILE" ] && { echo "✗ Missing $STATE_FILE"; exit 1; }
-
-FLAG_PHASE=$(echo "$ARGUMENTS" | grep -oP -- '--phase=\K[^\s]+' || true)
-FLAG_UNTIL=$(echo "$ARGUMENTS" | grep -oP -- '--until=\K[^\s]+' || true)
-FLAG_REVIEW=$(echo "$ARGUMENTS" | grep -oP -- '--review(?:=[^\s]+)?' || true)
-FLAG_REGENERATE=$(echo "$ARGUMENTS" | grep -q -- '--regenerate' && echo "1" || echo "0")
-
-if [ -n "$FLAG_PHASE" ] && [ -n "$FLAG_UNTIL" ]; then
-  echo "✗ --phase and --until cannot be combined. Pick one.";
-  exit 1;
-fi
-```
-
-The ordered pipeline is:
-
-```text
-research -> requirements -> design -> tasks
-```
-
-Routing rules:
-
-- no flags -> start at `.state.json.phase`, run forward to `tasks`
-- `--phase=design` -> run only `design`
-- `--phase=design,tasks` -> run `design` then `tasks`
-- `--until=design` -> start at `.state.json.phase`, stop after `design`
-- `--regenerate` -> clear targeted phase output before rerunning it
-
-Advance `.state.json.phase` only after the targeted artifact lands and passes
-`references/artifact-landing.md`.

package/skills/spec/references/reporting.md

@@ -1,21 +0,0 @@
-# Spec Reporting — Final Summary and Handoff
-
-End with a compact execution summary:
-
-```text
-✓ Spec <name> refreshed
-  Phases run:   research, requirements, design, tasks
-  Review dims:  ceo, eng, design, dx   (if --review was used)
-  Files:
-    .flow/specs/<name>/research.md
-    .flow/specs/<name>/requirements.md
-    .flow/specs/<name>/design.md
-    .flow/specs/<name>/tasks.md
-    .flow/specs/<name>/spec-review.md   (if --review was used)
-
-Next: /curdx-flow:implement
-```
-
-Do not summarize the full content of the artifacts inline. The files are the
-deliverables; the closing message only confirms what ran and where the outputs
-landed.