claude-code-workflow 7.2.11 → 7.2.13

package/.claude/commands/ddd/auto.md

@@ -1,359 +0,0 @@
----
-name: auto
-description: Chain command - automated document-driven development flow. Detects project state and runs the appropriate chain for new or existing projects.
-argument-hint: "[-y|--yes] [--skip-spec] [--skip-build] [--spec <session-id>] [--resume] \"project idea or task description\""
-allowed-tools: TodoWrite(*), Agent(*), AskUserQuestion(*), Read(*), Grep(*), Glob(*), Bash(*), Edit(*), Write(*)
----
-
-## Auto Mode
-
-When `--yes` or `-y`: All sub-commands run in auto mode. Minimal human intervention.
-
-# DDD Auto Command (/ddd:auto)
-
-## Purpose
-
-Orchestrate the full document-driven development lifecycle. **Adapts to project state** — works for both new projects and existing codebases.
-
-## Flow Variants
-
-### Variant 1: New Project (no code, no spec)
-```
-spec-generator → ddd:index-build → ddd:plan → ddd:execute → verify → ddd:sync
-```
-
-### Variant 2: Existing Project (has code, no spec)
-```
-ddd:scan → ddd:plan → ddd:execute → verify → ddd:sync
-```
-
-### Variant 3: Existing Project with Spec (has code + spec)
-```
-ddd:index-build → ddd:plan → ddd:execute → verify → ddd:sync
-```
-
-### Variant 4: Index Exists (has doc-index.json)
-```
-ddd:plan → ddd:execute → verify → ddd:sync
-```
-
-## Flow Diagram
-
-```
-┌────────────────────────────────────────────────────────────┐
-│                       /ddd:auto                            │
-│                                                            │
-│  Stage 0: Detect Project State                             │
-│  ┌───────────────────────────────────┐                     │
-│  │ has_codebase? has_spec? has_index?│                     │
-│  └────────────┬──────────────────────┘                     │
-│               │                                            │
-│    ┌──────────┼──────────────┐                             │
-│    ▼          ▼              ▼                              │
-│  No Code    Code Only    Code + Spec   Index Exists        │
-│    │          │              │              │               │
-│    ▼          │              │              │               │
-│  Stage 1     │              │              │               │
-│  Spec Gen    │              │              │               │
-│    │          │              │              │               │
-│    ▼          │              ▼              │               │
-│  Stage 2a   Stage 2b    Stage 2a          │               │
-│  index-build ddd:scan   index-build       │               │
-│  (Path A or Path B auto-detected)          │               │
-│    │                                       │               │
-│    └───────────────────┬───────────────────┘               │
-│                        ▼                                   │
-│              Stage 3: DDD Plan (enhanced)                  │
-│              (doc-index query + exploration +               │
-│               clarification + task planning)               │
-│                        │                                   │
-│                        ▼                                   │
-│              Stage 4: Execute                              │
-│              (ddd:execute = doc-aware execution)            │
-│                        │                                   │
-│                        ▼                                   │
-│              Stage 4.5: Verify Gate                        │
-│              (convergence + build + lint + tests            │
-│               → execution-manifest.json)                   │
-│                        │                                   │
-│                   PASS / WARN → continue                   │
-│                   FAIL → ask user                          │
-│                        │                                   │
-│                        ▼                                   │
-│              Stage 5: Doc Sync                             │
-│              (auto-triggered with --from-manifest,          │
-│               or manual /ddd:sync)                         │
-└────────────────────────────────────────────────────────────┘
-```
-
-## Stage 0: Project State Detection
-
-Automatically detect project state to determine which stages to run:
-
-```
-Check 1: doc-index.json exists?    → has_index
-Check 2: SPEC-* directories exist? → has_spec
-Check 3: Source code directories?   → has_codebase
-Check 4: project-tech.json exists?  → has_tech_analysis
-```
-
-### Decision Matrix
-
-| has_codebase | has_spec | has_index | Action |
-|:---:|:---:|:---:|--------|
-| No | No | No | Stage 1 (spec-gen) → Stage 2a (index-build) → Stage 3-5 |
-| No | Yes | No | Stage 2a (index-build) → Stage 3-5 |
-| Yes | No | No | **Stage 2b (ddd:scan)** → Stage 3-5 |
-| Yes | Yes | No | Stage 2a (index-build) → Stage 3-5 |
-| Yes | * | Yes | **Skip to Stage 3** (index exists) |
-
-### Override Flags
-
-| Flag | Effect |
-|------|--------|
-| `--skip-spec` | Never run spec-generator |
-| `--skip-build` | Never run index-build |
-| `--spec <id>` | Use specific spec session, force Path A |
-| `--from-scratch` | Rebuild index even if exists |
-
-## Stage 1: Specification (conditional)
-
-### Run When
-- No codebase AND no spec AND `--skip-spec` not set
-- User provides a new project idea (not an existing task description)
-
-### Skip When
-- `--skip-spec` flag
-- Codebase already exists (existing project)
-- `--spec <id>` pointing to existing session
-
-### Execution
-```
-Invoke /spec-generator with user input
-→ Output: .workflow/.doc-index/specs/SPEC-{slug}-{date}/
-```
-
-## Stage 2: Index Construction (conditional)
-
-### Run When
-- `doc-index.json` does not exist
-- OR `--from-scratch` flag
-
-### Route Selection
-
-```
-Has spec outputs → Stage 2a: /ddd:index-build (spec-first)
-No spec, has code → Stage 2b: /ddd:scan (code-first)
-```
-
-### Stage 2a: /ddd:index-build (has spec)
-```
-Invoke /ddd:index-build [-y] [-s <spec-id>]
-→ Output: doc-index.json from spec entities + code mapping
-```
-
-### Stage 2b: /ddd:scan (no spec, has code)
-```
-Invoke /ddd:scan [-y]
-→ Output: doc-index.json from code analysis + inferred features
-```
-
-### Skip When
-- `--skip-build` flag
-- `doc-index.json` exists AND NOT `--from-scratch`
-  - In this case, suggest `/ddd:update` for incremental refresh
-
-## Stage 3: Planning (always runs)
-
-### Execution
-
-```
-Invoke /ddd:plan [-y] "task description"
-```
-
-The enhanced `/ddd:plan` now performs:
-1. Doc-index query (instant context from features, requirements, components, ADRs)
-2. Doc-index-guided exploration (1-4 angles based on affected features)
-3. Clarification (aggregate ambiguities from exploration + doc-index gaps)
-4. Task planning (plan.json + TASK-*.json with doc_context traceability)
-5. Handoff selection
-
-Output:
-- `plan.json` — plan overview with doc_context
-- `.task/TASK-*.json` — individual tasks with doc_context
-- `exploration-{angle}.json` — exploration results (if Phase 2 ran)
-- `planning-context.md` — legacy context package
-
-### Handoff Decision
-
-After planning, `/ddd:plan` presents execution options:
-
-| Option | Description | Auto-Select When |
-|--------|-------------|-----------------|
-| **ddd:execute** | Document-aware execution (recommended) | Default in ddd workflow |
-| **lite-execute** | Standard execution (no doc awareness) | When doc traceability not needed |
-| **direct** | Start coding with context | User prefers manual |
-| **stop** | Just the plan context | Planning/research only |
-
-With `-y`: Auto-select `ddd:execute`.
-
-## Stage 4: Execution
-
-Based on Stage 3 handoff decision:
-
-| Mode | Delegates To |
-|------|-------------|
-| **ddd:execute** | `/ddd:execute --in-memory` with plan.json + doc-index enrichment |
-| lite-execute | `/workflow:lite-execute` with plan.json path |
-| direct | Output context package, developer works manually |
-| stop | End here, no execution |
-
-### ddd:execute Features (when selected)
-- Doc-enriched task prompts (feature context + component docs + ADR constraints)
-- Per-batch impact verification (changes stay within planned scope)
-- Result persistence (`TASK-*.result.json` per task, `execution-manifest.json` per session)
-- Post-execution verify gate (Stage 4.5, unless `--skip-verify`)
-- Post-completion auto-sync with manifest (Stage 5 triggered automatically)
-
-**Note**: When using `ddd:execute`, Stage 4.5 and Stage 5 are auto-triggered. For other modes, run Stage 5 manually.
-
-## Stage 4.5: Verify Gate
-
-Embedded within `ddd:execute` (Step 4.5). Runs after all batches complete, before doc sync.
-
-### Purpose
-
-Quality gate ensuring execution output is correct before committing to documentation updates. Prevents bad code from being "blessed" into the doc-index.
-
-### Checks Performed
-
-| Check | Description | Gate Behavior |
-|-------|-------------|---------------|
-| **Convergence** | Run `task.convergence.verification` for each task | FAIL if any critical task fails |
-| **Build** | Run project build command (`tsc --noEmit`, etc.) | FAIL on build errors |
-| **Lint** | Run project linter (`eslint`, etc.) | WARN only (non-blocking) |
-| **Regression** | Run full test suite, compare to baseline | FAIL on new test failures |
-
-### Gate Results
-
-| Result | Action |
-|--------|--------|
-| **PASS** | All checks passed → proceed to Stage 5 |
-| **WARN** | Non-critical issues (lint warnings) → proceed with warnings logged |
-| **FAIL** | Critical issues → ask user: fix now / skip sync / abort |
-| **FAIL + `-y`** | Log failures, set `error_state` in session, stop |
-
-### Output
-
-- `execution-manifest.json` — persisted to session folder, consumed by Stage 5
-- Contains: task results, files_modified (with task attribution), verify gate results
-
-## Stage 5: Post-Task Sync
-
-### Trigger
-- **Auto**: `/ddd:execute` triggers `/ddd:sync --from-manifest` automatically after verify gate passes
-- **Manual**: User runs `/ddd:sync` after completing work in direct/lite-execute mode
-- **Resume**: `/ddd:auto --resume` after task completion
-
-### Execution
-```
-# Auto mode (from ddd:execute): uses manifest for precise change tracking
-Invoke /ddd:sync [-y] --task-id <id> --from-manifest {session}/execution-manifest.json "task summary"
-
-# Manual mode (from direct/lite-execute): falls back to git diff
-Invoke /ddd:sync [-y] [--task-id <id>] "task summary"
-
-→ Updates: doc-index.json, feature-maps/, tech-registry/, action-logs/
-```
-
-## State Tracking
-
-### Session File: `.workflow/.doc-index/.auto-session.json`
-
-```json
-{
-  "session_id": "DAUTO-{timestamp}",
-  "input": "user's original input",
-  "detected_state": {
-    "has_codebase": true,
-    "has_spec": false,
-    "has_index": false,
-    "build_path": "code-first"
-  },
-  "stages_completed": ["detect", "index-build", "plan"],
-  "current_stage": "execute",
-  "spec_session": "SPEC-{slug}-{date}|null",
-  "plan_session": "planning/{task-slug}-{date}/",
-  "plan_context": "planning/{task-slug}-{date}/plan.json",
-  "execution_mode": "ddd:execute|lite-execute|direct|stop",
-  "execution_manifest": "planning/{task-slug}-{date}/execution-manifest.json|null",
-  "verify_gate": "PASS|WARN|FAIL|null",
-  "error_state": null,
-  "last_error": {
-    "stage": "execute",
-    "message": "Task TASK-002 failed: compilation error",
-    "timestamp": "ISO8601",
-    "recoverable": true
-  },
-  "created_at": "ISO8601",
-  "last_updated": "ISO8601"
-}
-```
-
-### Resume
-```
-/ddd:auto --resume    → Resume from current_stage in .auto-session.json
-```
-
-### Error Recovery
-```
-/ddd:auto --resume
-  IF error_state is set:
-    Display last error context
-    Ask: retry current stage / skip to next / abort
-  ELSE:
-    Resume from current_stage normally
-```
-
-## Example Workflows
-
-### New Project (Full Flow)
-```
-/ddd:auto "Build a task management API with user auth and team features"
-→ Stage 0: No code, no spec → need spec-gen
-→ Stage 1: spec-generator produces full spec
-→ Stage 2: index-build creates index from spec + empty codebase
-→ Stage 3: ddd:plan produces plan.json + TASK-*.json with doc_context
-→ Stage 4: ddd:execute runs tasks with feature context enrichment
-→ Stage 4.5: verify gate — convergence ✓, build ✓, tests ✓ → PASS
-→ Stage 5: ddd:sync --from-manifest auto-triggered, updates index
-```
-
-### Existing Project, No Spec (Code-First)
-```
-/ddd:auto "Add rate limiting to API endpoints"
-→ Stage 0: Has code, no spec, no index
-→ Stage 2b: ddd:scan analyzes code, infers features from codebase
-→ Stage 3: ddd:plan queries index, explores with security + patterns angles
-→ Stage 4: ddd:execute runs with rate-limit component docs as context
-→ Stage 4.5: verify gate — convergence ✓, tests 41/42 (1 regression) → WARN
-→ Stage 5: ddd:sync --from-manifest, registers new rate-limit component
-```
-
-### Existing Project with Index (Incremental)
-```
-/ddd:auto "Fix auth token expiration bug"
-→ Stage 0: Has code, has index → skip to plan
-→ Stage 3: ddd:plan finds feat-auth, REQ-002, tech-auth-service (Low complexity, skip exploration)
-→ Stage 4: ddd:execute runs single task with auth feature context
-→ Stage 4.5: verify gate — convergence ✓, build ✓, tests ✓ → PASS
-→ Stage 5: ddd:sync --from-manifest, updates tech-auth-service code locations
-```
-
-### Planning Only
-```
-/ddd:auto "Investigate payment module architecture"
-→ Stage 0-2: (as needed)
-→ Stage 3: ddd:plan shows full context with exploration results
-→ Stage 4: user selects "stop" → gets plan.json + context package only
-```

package/.claude/commands/ddd/doc-generate.md

@@ -1,222 +0,0 @@
----
-name: doc-generate
-description: Generate full document tree from doc-index.json. Layer 3 (components) → Layer 2 (features) → Layer 1 (indexes/overview). Standalone or called by scan/index-build.
-argument-hint: "[-y|--yes] [--layer <3|2|1|all>] [--force] [--skip-overview] [--skip-schema]"
-allowed-tools: TodoWrite(*), Agent(*), AskUserQuestion(*), Read(*), Grep(*), Glob(*), Bash(*), Edit(*), Write(*)
----
-
-## Auto Mode
-
-When `--yes` or `-y`: Auto-generate all layers without confirmation prompts.
-
-# DDD Doc Generate Command (/ddd:doc-generate)
-
-## Purpose
-
-Generate the complete document tree from `doc-index.json`. **Single source of truth** for all document generation logic, following bottom-up Layer 3 → 2 → 1 strategy.
-
-```
-doc-index.json → tech-registry/*.md (L3) → feature-maps/*.md (L2) → _index.md + README + ARCHITECTURE (L1)
-```
-
-## When to Use
-
-| Scenario | Use |
-|----------|-----|
-| After `/ddd:scan` builds doc-index.json | **doc-generate** (auto-called by scan) |
-| After `/ddd:index-build` builds doc-index.json | **doc-generate** (auto-called by index-build) |
-| Rebuild all docs from existing index | **doc-generate --force** |
-| Regenerate only component docs | **doc-generate --layer 3** |
-| Regenerate only overview/index docs | **doc-generate --layer 1** |
-
-## Prerequisite
-
-- `doc-index.json` must exist at `.workflow/.doc-index/doc-index.json`
-- If not found → error: "No doc-index.json found. Run /ddd:scan or /ddd:index-build first."
-
-## Storage Output
-
-```
-.workflow/.doc-index/
-├── doc-index.json              ← Input (read-only, not modified)
-├── SCHEMA.md                   ← Schema documentation
-├── README.md                   ← Project overview (Layer 1)
-├── ARCHITECTURE.md             ← Architecture overview (Layer 1)
-├── feature-maps/               ← Feature documentation (Layer 2)
-│   ├── _index.md
-│   └── {feature-slug}.md
-├── tech-registry/              ← Component documentation (Layer 3)
-│   ├── _index.md
-│   └── {component-slug}.md
-└── planning/                   ← Planning sessions (Layer 1)
-    ├── _index.md               ← Planning sessions index
-    └── {task-slug}-{date}/     ← Individual session folders
-```
-
-## Phase 1: Load & Validate
-
-### 1.1 Load doc-index.json
-
-```
-Read .workflow/.doc-index/doc-index.json
-Validate: features[], technicalComponents[] are non-empty arrays
-```
-
-### 1.2 Schema Version Check
-
-```javascript
-const schemaVersion = docIndex.schema_version || '0.0';
-if (schemaVersion !== '1.0') {
-  warn(`Schema version mismatch: found ${schemaVersion}, expected 1.0`);
-}
-```
-
-### 1.3 Determine Generation Scope
-
-```
-IF --layer 3:  generate Layer 3 only
-IF --layer 2:  generate Layer 2 only (requires Layer 3 exists)
-IF --layer 1:  generate Layer 1 only (requires Layer 2 exists)
-IF --layer all (default): generate Layer 3 → 2 → 1
-```
-
-### 1.4 Check Existing Docs
-
-```
-IF docs already exist AND NOT --force:
-  Warn: "Documents already exist. Use --force to overwrite."
-  Ask user (unless -y → overwrite)
-```
-
-## Phase 2: Layer 3 -- Component Documentation
-
-For each component in `technicalComponents[]`, call the generate_ddd_docs endpoint:
-
-```bash
-for COMPONENT_ID in "${technicalComponents[@]}"; do
-  ccw tool exec generate_ddd_docs '{"strategy":"component","entityId":"'"$COMPONENT_ID"'","tool":"gemini"}'
-done
-```
-
-The endpoint handles:
-- Loading the component entity from doc-index.json
-- Building YAML frontmatter (layer: 3, component_id, name, type, features, code_locations, generated_at)
-- Constructing the CLI prompt with code context paths
-- **Including Change History section**: Pull related entries from `doc-index.json.actions[]` where `affectedComponents` includes this component ID. Display as timeline (date, action type, description)
-- Writing output to `.workflow/.doc-index/tech-registry/{slug}.md`
-- Tool fallback (gemini -> qwen -> codex) on failure
-
-Output: `.workflow/.doc-index/tech-registry/{component-slug}.md`
-
-## Phase 3: Layer 2 -- Feature Documentation
-
-For each feature in `features[]`, call the generate_ddd_docs endpoint:
-
-```bash
-for FEATURE_ID in "${features[@]}"; do
-  ccw tool exec generate_ddd_docs '{"strategy":"feature","entityId":"'"$FEATURE_ID"'","tool":"gemini"}'
-done
-```
-
-The endpoint handles:
-- Loading the feature entity from doc-index.json
-- Building YAML frontmatter (layer: 2, feature_id, name, epic_id, status, requirements, components, tags, generated_at)
-- Constructing the CLI prompt referencing Layer 3 component docs
-- **Including Change History section**: Pull related entries from `doc-index.json.actions[]` where `affectedFeatures` includes this feature ID. Display as timeline (date, action type, description)
-- Writing output to `.workflow/.doc-index/feature-maps/{slug}.md`
-- Tool fallback (gemini -> qwen -> codex) on failure
-
-Output: `.workflow/.doc-index/feature-maps/{feature-slug}.md`
-
-## Phase 4: Layer 1 -- Index & Overview Documentation
-
-### 4.1 Index Documents
-
-Generate catalog files for each subdirectory:
-
-```bash
-# Feature maps index
-ccw tool exec generate_ddd_docs '{"strategy":"index","entityId":"feature-maps","tool":"gemini"}'
-
-# Tech registry index
-ccw tool exec generate_ddd_docs '{"strategy":"index","entityId":"tech-registry","tool":"gemini"}'
-
-# Action logs index
-ccw tool exec generate_ddd_docs '{"strategy":"index","entityId":"action-logs","tool":"gemini"}'
-
-# Planning sessions index
-ccw tool exec generate_ddd_docs '{"strategy":"index","entityId":"planning","tool":"gemini"}'
-```
-
-Or generate all indexes at once (omit entityId):
-
-```bash
-ccw tool exec generate_ddd_docs '{"strategy":"index","tool":"gemini"}'
-```
-
-### 4.2 README.md (unless --skip-overview)
-
-```bash
-ccw tool exec generate_ddd_docs '{"strategy":"overview","tool":"gemini"}'
-```
-
-### 4.3 ARCHITECTURE.md (unless --skip-overview)
-
-```bash
-ccw tool exec generate_ddd_docs '{"strategy":"overview","entityId":"architecture","tool":"gemini"}'
-```
-
-## Phase 5: SCHEMA.md (unless --skip-schema)
-
-### 5.1 Generate Schema Documentation
-
-```bash
-ccw tool exec generate_ddd_docs '{"strategy":"schema","tool":"gemini"}'
-```
-
-### 5.2 Versioning Policy
-
-**Semantic Versioning**:
-- **Major** (X.0): Breaking changes (field removal, type changes, incompatible structure)
-- **Minor** (X.Y): Non-breaking additions (new optional fields, new sections)
-
-**Migration Protocol**:
-1. Detect version mismatch in ddd:plan/ddd:sync
-2. Log warning with migration instructions
-3. Provide migration script or regeneration option
-4. Update schema_version after successful migration
-
-## Phase 6: Generation Report
-
-```
-Document Generation Report
-
-Project: {name}
-Source: doc-index.json (build_path: {spec-first|code-first})
-
-Generated:
-  Layer 3 (Components): {N} documents in tech-registry/
-  Layer 2 (Features):   {N} documents in feature-maps/
-  Layer 1 (Indexes):    {N} documents (_index.md, README, ARCHITECTURE)
-  Schema:               SCHEMA.md
-
-Total: {N} documents generated
-```
-
-## Flags
-
-| Flag | Effect |
-|------|--------|
-| `-y, --yes` | Auto-confirm all decisions |
-| `--layer <3\|2\|1\|all>` | Generate specific layer only (default: all) |
-| `--force` | Overwrite existing documents |
-| `--skip-overview` | Skip README.md, ARCHITECTURE.md, planning/_index.md |
-| `--skip-schema` | Skip SCHEMA.md generation |
-
-## Integration Points
-
-- **Input from**: `doc-index.json` (from `/ddd:scan` or `/ddd:index-build`)
-- **Called by**: `/ddd:scan` (after index assembly), `/ddd:index-build` (after index assembly)
-- **Standalone**: Can be run independently on any project with existing doc-index.json
-- **Output**: Complete document tree in `.workflow/.doc-index/`
-- **Endpoint**: `ccw tool exec generate_ddd_docs` handles prompt construction, frontmatter, tool fallback, and file creation