claude-code-workflow 6.2.1 → 6.2.3

package/.claude/workflows/cli-templates/prompts/workflow/skill-index.txt

@@ -0,0 +1,224 @@
+Template for generating SKILL.md (index file)
+
+## Purpose
+Create main SKILL package index with progressive loading structure and session references.
+
+## File Location
+`.claude/skills/workflow-progress/SKILL.md`
+
+## Update Strategy
+- **Always regenerated**: This file is always updated with latest session count, domains, dates
+
+## Structure
+
+```yaml
+---
+name: workflow-progress
+description: Progressive workflow development history (located at {project_root}). Load this SKILL when continuing development, analyzing past implementations, or learning from workflow history, especially when no relevant context exists in memory.
+version: {semantic_version}
+---
+# Workflow Progress SKILL Package
+
+## Documentation: `../../../.workflow/.archives/`
+
+**Total Sessions**: {session_count}
+**Functional Domains**: {domain_list}
+**Date Range**: {earliest_date} - {latest_date}
+
+## Progressive Loading
+
+### Level 0: Quick Overview (~2K tokens)
+- [Sessions Timeline](sessions-timeline.md#recent-sessions-last-5) - Recent 5 sessions
+- [Top Conflict Patterns](conflict-patterns.md#top-patterns) - Top 3 recurring conflicts
+- Quick reference for last completed work
+
+**Use Case**: Quick context refresh before starting new task
+
+### Level 1: Core History (~8K tokens)
+- [Sessions Timeline](sessions-timeline.md) - Recent 10 sessions with details
+- [Lessons Learned](lessons-learned.md#best-practices) - Success patterns by category
+- [Conflict Patterns](conflict-patterns.md) - Known conflict types and resolutions
+- Context package references (metadata only)
+
+**Use Case**: Understanding recent development patterns and avoiding known pitfalls
+
+### Level 2: Complete History (~25K tokens)
+- All archived sessions with metadata
+- Full lessons learned (successes, challenges, watch patterns)
+- Complete conflict analysis with resolutions
+- IMPL_PLAN summaries from all sessions
+- Context package paths for on-demand loading
+
+**Use Case**: Comprehensive review before major refactoring or architecture changes
+
+### Level 3: Deep Dive (~40K tokens)
+- Full IMPL_PLAN.md and TODO_LIST.md from all sessions
+- Detailed task completion summaries
+- Cross-session dependency analysis
+- Direct context package file references
+
+**Use Case**: Investigating specific implementation details or debugging historical decisions
+
+---
+
+## Quick Access
+
+### Recent Sessions
+{list of 5 most recent sessions with one-line descriptions}
+
+### By Domain
+- **{Domain_1}**: {count} sessions
+- **{Domain_2}**: {count} sessions
+- **{Domain_3}**: {count} sessions
+
+### Top Watch Patterns
+1. {most_frequent_watch_pattern}
+2. {second_most_frequent}
+3. {third_most_frequent}
+
+---
+
+## Session Index
+
+### {Domain_Category} Sessions
+- [{session_id}](../../../.workflow/.archives/{session_id}/) - {one_line_description} ({date})
+  - Context: [context-package.json](../../../.workflow/.archives/{session_id}/.process/context-package.json)
+  - Plan: [IMPL_PLAN.md](../../../.workflow/.archives/{session_id}/IMPL_PLAN.md)
+  - Tags: {tag1}, {tag2}, {tag3}
+
+---
+
+## Usage Examples
+
+### Loading Quick Context
+```markdown
+Load Level 0 from workflow-progress SKILL for overview of recent work
+```
+
+### Investigating {Domain} History
+```markdown
+Load Level 2 from workflow-progress SKILL, filter by "{domain}" tag
+```
+
+### Full Historical Analysis
+```markdown
+Load Level 3 from workflow-progress SKILL for complete development history
+```
+```
+
+## Data Sources
+- Manifest: `.workflow/.archives/manifest.json`
+- All session metadata from manifest entries
+
+## Generation Rules
+- Version format: `{major}.{minor}.{patch}` (increment patch for each update)
+- Domain list: Extract unique tags from all sessions, sort by frequency
+- Date range: Find earliest and latest archived_at timestamps
+- Token estimates: Approximate based on content length
+- Use relative paths (../../../.workflow/.archives/) for session references
+
+## Formatting Rules
+- Keep descriptions concise
+- Sort sessions by date (newest first)
+- Group sessions by primary tag
+- Include only top 5 recent sessions in Quick Access
+- Include top 3 watch patterns
+
+---
+
+## Variable Substitution Guide
+
+### Required Variables
+- `{project_root}`: Absolute project path from git root (e.g., "/d/Claude_dms3")
+- `{semantic_version}`: Version string (e.g., "1.0.0", increment patch for each update)
+- `{session_count}`: Total number of archived sessions
+- `{domain_list}`: Comma-separated unique tags sorted by frequency
+- `{earliest_date}`: Earliest session archived_at timestamp
+- `{latest_date}`: Most recent session archived_at timestamp
+
+### Generated Variables
+- `{one_line_description}`: Extract from session description (first sentence, max 80 chars)
+- `{domain_category}`: Primary tag from session metadata
+- `{most_frequent_watch_pattern}`: Top recurring watch pattern across sessions
+- `{date}`: Session archived_at in YYYY-MM-DD format
+
+### Description Field Generation
+
+**Format Template**:
+```
+Progressive workflow development history (located at {project_root}).
+Load this SKILL when continuing development, analyzing past implementations,
+or learning from workflow history, especially when no relevant context exists in memory.
+```
+
+**Generation Rules**:
+1. **Project Root**: Use `git rev-parse --show-toplevel` to get absolute path
+2. **Use Cases**: ALWAYS include these trigger phrases:
+   - "continuing development" (开发延续)
+   - "analyzing past implementations" (分析历史)
+   - "learning from workflow history" (学习历史)
+3. **Trigger Optimization**: MUST include "especially when no relevant context exists in memory"
+4. **Path Format**: Use forward slashes for cross-platform compatibility (e.g., "/d/project")
+
+**Why This Matters**:
+- **Auto-loading precision**: Path reference ensures Claude loads correct project's SKILL
+- **Context awareness**: "when no relevant context exists" prevents redundant loading
+- **Action coverage**: Three use cases cover all workflow scenarios
+
+---
+
+## Generation Instructions
+
+### Step 1: Get Project Root
+```bash
+git rev-parse --show-toplevel  # Returns: /d/Claude_dms3
+```
+
+### Step 2: Read Manifest
+```bash
+cat .workflow/.archives/manifest.json
+```
+
+Extract:
+- Total session count
+- All session tags (for domain list)
+- Date range (earliest/latest archived_at)
+
+### Step 3: Aggregate Session Data
+- Count sessions per domain
+- Extract top 5 recent sessions
+- Identify top 3 watch patterns from lessons
+
+### Step 4: Generate Description
+Apply format template with project_root from Step 1.
+
+### Step 5: Calculate Version
+- Read existing SKILL.md version (if exists)
+- Increment patch version (e.g., 1.0.5 → 1.0.6)
+- Use 1.0.0 for new SKILL package
+
+### Step 6: Build Progressive Loading Sections
+- Level 0: Recent 5 sessions + Top 3 conflicts
+- Level 1: Recent 10 sessions + Best practices
+- Level 2: All sessions + Full lessons + Full conflicts
+- Level 3: Include IMPL_PLAN and TODO_LIST references
+
+### Step 7: Write SKILL.md
+- Apply all variable substitutions
+- Use relative paths: `../../../.workflow/.archives/`
+- Validate all referenced files exist
+
+---
+
+## Validation Checklist
+
+- [ ] `{project_root}` uses absolute path with forward slashes
+- [ ] Description includes all three use cases
+- [ ] Description includes trigger optimization phrase
+- [ ] Version incremented correctly
+- [ ] All session references use relative paths
+- [ ] Domain list sorted by frequency
+- [ ] Date range matches manifest
+- [ ] Quick Access section has exactly 5 recent sessions
+- [ ] Top Watch Patterns section has exactly 3 items
+- [ ] All referenced files exist in archives

package/.claude/workflows/cli-templates/prompts/workflow/skill-lessons-learned.txt

@@ -0,0 +1,94 @@
+Template for generating lessons-learned.md
+
+## Purpose
+Aggregate lessons learned from workflow sessions, categorized by functional domain and severity.
+
+## File Location
+`.claude/skills/workflow-progress/lessons-learned.md`
+
+## Update Strategy
+- **Incremental mode**: Merge new session lessons into existing categories, update frequencies
+- **Full mode**: Regenerate entire lessons document from all sessions
+
+## Structure
+
+```markdown
+# Workflow Lessons Learned
+
+## Best Practices (Successes)
+
+### {Domain_Category}
+- {success_pattern_1} (sessions: {session_id_1}, {session_id_2})
+- {success_pattern_2} (sessions: {session_id_3})
+
+### {Domain_Category_2}
+...
+
+---
+
+## Known Challenges
+
+### High Priority
+- **{challenge_title}**: {description}
+  - Affected sessions: {session_id_1}, {session_id_2}
+  - Resolution: {resolution_strategy}
+
+### Medium Priority
+- **{challenge_title}**: {description}
+  - Affected sessions: {session_id_3}
+  - Resolution: {resolution_strategy}
+
+### Low Priority
+...
+
+---
+
+## Watch Patterns
+
+### Critical (3+ sessions)
+1. **{pattern_name}**: {description}
+   - Frequency: {count} sessions
+   - Affected: {session_list}
+   - Mitigation: {mitigation_strategy}
+
+### High Priority (2 sessions)
+...
+
+### Normal (1 session)
+...
+```
+
+## Data Sources
+- Lessons: `manifest.json` -> `archives[].lessons.{successes|challenges|watch_patterns}`
+- Session metadata: `.workflow/.archives/{session_id}/workflow-session.json`
+
+## Aggregation Rules (Use CCW CLI)
+
+**Command Pattern**:
+```bash
+ccw cli -p "
+PURPOSE: Aggregate workflow lessons from session data
+TASK: • Group successes by functional domain • Categorize challenges by severity (HIGH/MEDIUM/LOW) • Identify watch patterns with frequency >= 2 • Mark CRITICAL patterns (3+ sessions)
+MODE: analysis
+CONTEXT: @.workflow/.archives/manifest.json
+EXPECTED: Aggregated lessons with frequency counts
+RULES: $(cat ~/.claude/workflows/cli-templates/prompts/workflow/skill-aggregation.txt) | analysis=READ-ONLY
+" --tool gemini --cd .workflow/.archives
+```
+
+**Severity Classification**:
+- **HIGH**: Blocked development >4 hours OR repeated in 3+ sessions
+- **MEDIUM**: Required significant rework OR repeated in 2 sessions
+- **LOW**: Minor issues resolved quickly
+
+**Pattern Identification**:
+- Successes in 3+ sessions → "Best Practices"
+- Challenges repeated 2+ times → "Known Issues"
+- Watch patterns frequency >= 2 → "High Priority Warnings"
+- Watch patterns frequency >= 3 → "CRITICAL"
+
+## Formatting Rules
+- Sort by frequency (most common first)
+- Include session references for traceability
+- Use bold for challenge titles
+- Keep descriptions concise but actionable

package/.claude/workflows/cli-templates/prompts/workflow/skill-sessions-timeline.txt

@@ -0,0 +1,53 @@
+Template for generating sessions-timeline.md
+
+## Purpose
+Create or update chronological timeline of workflow sessions with functional domain grouping.
+
+## File Location
+`.claude/skills/workflow-progress/sessions-timeline.md`
+
+## Update Strategy
+- **Incremental mode**: Append new session to timeline, keep existing content
+- **Full mode**: Regenerate entire timeline from all sessions
+
+## Structure
+
+```markdown
+# Workflow Sessions Timeline
+
+## Recent Sessions (Last 5)
+
+### {session_id} ({archived_date})
+**Description**: {description}
+**Tags**: {tag1}, {tag2}, {tag3}
+**Metrics**: {task_count} tasks, {success_rate}% success, {duration_hours} hours
+**Context Package**: [{session_id}/context-package.json](../../../.workflow/.archives/{session_id}/.process/context-package.json)
+
+**Key Outcomes**:
+- ✅ {success_item_1}
+- ✅ {success_item_2}
+- ⚠️ Watch: {watch_pattern}
+
+---
+
+## By Functional Domain
+
+### {Domain_Name} ({count} sessions)
+- {session_id_1} ({date}) - {one_line_description}
+- {session_id_2} ({date}) - {one_line_description}
+
+### {Domain_Name_2} ({count} sessions)
+...
+```
+
+## Data Sources
+- Session metadata: `.workflow/.archives/{session_id}/workflow-session.json`
+- Manifest entry: `.workflow/.archives/manifest.json`
+- Lessons: `manifest.json` -> `archives[].lessons`
+
+## Formatting Rules
+- Sort recent sessions by archived_at (newest first)
+- Group by functional domain using tags
+- Use relative paths for context package links
+- Use ✅ for successes, ⚠️ for watch patterns
+- Keep descriptions concise (one line)

package/.claude/workflows/cli-templates/prompts/workflow/task-json-agent-mode.txt

@@ -0,0 +1,123 @@
+Task JSON Schema - Agent Mode (No Command Field)
+
+## Schema Structure
+
+```json
+{
+  "id": "IMPL-N[.M]",
+  "title": "Descriptive task name",
+  "status": "pending",
+  "context_package_path": "{context_package_path}",
+  "meta": {
+    "type": "feature|bugfix|refactor|test|docs",
+    "agent": "@code-developer|@test-fix-agent|@universal-executor"
+  },
+  "context": {
+    "requirements": ["extracted from analysis"],
+    "focus_paths": ["src/paths"],
+    "acceptance": ["measurable criteria"],
+    "depends_on": ["IMPL-N"],
+    "artifacts": [
+      {
+        "type": "synthesis_specification",
+        "path": "{synthesis_spec_path}",
+        "priority": "highest",
+        "usage": "Primary requirement source - use for consolidated requirements and cross-role alignment"
+      },
+      {
+        "type": "role_analysis",
+        "path": "{role_analysis_path}",
+        "priority": "high",
+        "usage": "Technical/design/business details from specific roles. Common roles: system-architect (ADRs, APIs, caching), ui-designer (design tokens, layouts), product-manager (user stories, metrics)"
+      }
+    ]
+  },
+  "flow_control": {
+    "pre_analysis": [
+      {
+        "step": "load_role_analyses_specification",
+        "action": "Load consolidated role analyses",
+        "commands": [
+          "Read({synthesis_spec_path})"
+        ],
+        "output_to": "synthesis_specification",
+        "on_error": "fail"
+      },
+      {
+        "step": "load_context_package",
+        "action": "Load context package for project structure",
+        "commands": [
+          "Read({context_package_path})"
+        ],
+        "output_to": "context_pkg",
+        "on_error": "fail"
+      },
+      {
+        "step": "local_codebase_exploration",
+        "action": "Explore codebase using local search",
+        "commands": [
+          "bash(rg '^(function|class|interface).*{keyword}' --type ts -n --max-count 15)",
+          "bash(find . -name '*{keyword}*' -type f | grep -v node_modules | head -10)"
+        ],
+        "output_to": "codebase_structure",
+        "on_error": "skip_optional"
+      }
+    ],
+    "implementation_approach": [
+      {
+        "step": 1,
+        "title": "Implement task following role analyses",
+        "description": "Implement '{title}' following [synthesis_specification] requirements and [context_pkg] patterns. Use role analyses as primary source, consult artifacts for technical details.",
+        "modification_points": [
+          "Apply consolidated requirements from role analyses",
+          "Follow technical guidelines from synthesis",
+          "Consult artifacts for implementation details when needed",
+          "Integrate with existing patterns"
+        ],
+        "logic_flow": [
+          "Load role analyses and context package",
+          "Analyze existing patterns from [codebase_structure]",
+          "Implement following specification",
+          "Consult artifacts for technical details when needed",
+          "Validate against acceptance criteria"
+        ],
+        "depends_on": [],
+        "output": "implementation"
+      }
+    ],
+    "target_files": ["file:function:lines", "path/to/NewFile.ts"]
+  }
+}
+```
+
+## Key Features - Agent Mode
+
+**Execution Model**: Agent interprets `modification_points` and `logic_flow` to execute autonomously
+
+**No Command Field**: Steps in `implementation_approach` do NOT include `command` field
+
+**Context Loading**: Context loaded via `pre_analysis` steps, available as variables (e.g., [synthesis_specification], [context_pkg])
+
+**Agent Execution**:
+- Agent reads modification_points and logic_flow
+- Agent performs implementation autonomously
+- Agent validates against acceptance criteria
+
+## Field Descriptions
+
+**implementation_approach**: Array of step objects (NO command field)
+- **step**: Sequential step number
+- **title**: Step description
+- **description**: Detailed instructions with variable references
+- **modification_points**: Specific code modifications to apply
+- **logic_flow**: Business logic execution sequence
+- **depends_on**: Step dependencies (empty array for independent steps)
+- **output**: Expected deliverable variable name
+
+## Usage Guidelines
+
+1. **Load Context**: Use pre_analysis to load synthesis, context package, and explore codebase
+2. **Reference Variables**: Use [variable_name] to reference outputs from pre_analysis steps
+3. **Clear Instructions**: Provide detailed modification_points and logic_flow for agent
+4. **No Commands**: Never add command field to implementation_approach steps
+5. **Agent Autonomy**: Let agent interpret and execute based on provided instructions

package/.claude/workflows/cli-templates/prompts/workflow/task-json-cli-mode.txt

@@ -0,0 +1,182 @@
+Task JSON Schema - CLI Execute Mode (With Command Field)
+
+## Schema Structure
+
+```json
+{
+  "id": "IMPL-N[.M]",
+  "title": "Descriptive task name",
+  "status": "pending",
+  "context_package_path": "{context_package_path}",
+  "meta": {
+    "type": "feature|bugfix|refactor|test|docs",
+    "agent": "@code-developer|@test-fix-agent|@universal-executor"
+  },
+  "context": {
+    "requirements": ["extracted from analysis"],
+    "focus_paths": ["src/paths"],
+    "acceptance": ["measurable criteria"],
+    "depends_on": ["IMPL-N"],
+    "artifacts": [
+      {
+        "type": "synthesis_specification",
+        "path": "{synthesis_spec_path}",
+        "priority": "highest",
+        "usage": "Primary requirement source - use for consolidated requirements and cross-role alignment"
+      },
+      {
+        "type": "role_analysis",
+        "path": "{role_analysis_path}",
+        "priority": "high",
+        "usage": "Technical/design/business details from specific roles"
+      }
+    ]
+  },
+  "flow_control": {
+    "pre_analysis": [
+      {
+        "step": "load_synthesis_specification",
+        "action": "Load consolidated synthesis specification",
+        "commands": [
+          "Read({synthesis_spec_path})"
+        ],
+        "output_to": "synthesis_specification",
+        "on_error": "fail"
+      },
+      {
+        "step": "load_context_package",
+        "action": "Load context package",
+        "commands": [
+          "Read({context_package_path})"
+        ],
+        "output_to": "context_pkg",
+        "on_error": "fail"
+      },
+      {
+        "step": "local_codebase_exploration",
+        "action": "Explore codebase using local search",
+        "commands": [
+          "bash(rg '^(function|class|interface).*{keyword}' --type ts -n --max-count 15)",
+          "bash(find . -name '*{keyword}*' -type f | grep -v node_modules | head -10)"
+        ],
+        "output_to": "codebase_structure",
+        "on_error": "skip_optional"
+      }
+    ],
+    "implementation_approach": [
+      {
+        "step": 1,
+        "title": "Implement task with Codex",
+        "description": "Implement '{title}' using Codex CLI tool",
+        "command": "bash(codex -C {focus_path} --full-auto exec \"PURPOSE: {purpose} TASK: {task_description} MODE: auto CONTEXT: @{{synthesis_spec_path}} @{{context_package_path}} EXPECTED: {expected_output} RULES: Follow synthesis specification\" --skip-git-repo-check -s danger-full-access)",
+        "modification_points": [
+          "Create/modify implementation files",
+          "Follow synthesis specification requirements",
+          "Integrate with existing patterns"
+        ],
+        "logic_flow": [
+          "Codex loads context package and synthesis",
+          "Codex implements according to specification",
+          "Codex validates against acceptance criteria"
+        ],
+        "depends_on": [],
+        "output": "implementation"
+      }
+    ],
+    "target_files": ["file:function:lines", "path/to/NewFile.ts"]
+  }
+}
+```
+
+## Multi-Step Example (Complex Task with Resume)
+
+```json
+{
+  "id": "IMPL-002",
+  "title": "Implement RBAC system",
+  "flow_control": {
+    "implementation_approach": [
+      {
+        "step": 1,
+        "title": "Create RBAC models",
+        "description": "Create role and permission data models",
+        "command": "bash(codex -C src/models --full-auto exec \"PURPOSE: Create RBAC models TASK: Define role and permission models MODE: auto CONTEXT: @{{synthesis_spec_path}} @{{context_package_path}} EXPECTED: Models with migrations RULES: Follow synthesis spec\" --skip-git-repo-check -s danger-full-access)",
+        "modification_points": ["Define role model", "Define permission model"],
+        "logic_flow": ["Design schema", "Implement models", "Generate migrations"],
+        "depends_on": [],
+        "output": "rbac_models"
+      },
+      {
+        "step": 2,
+        "title": "Implement RBAC middleware",
+        "description": "Create route protection middleware",
+        "command": "bash(codex --full-auto exec \"PURPOSE: Create RBAC middleware TASK: Route protection middleware MODE: auto CONTEXT: RBAC models from step 1 EXPECTED: Middleware for route protection RULES: Use session patterns\" resume --last --skip-git-repo-check -s danger-full-access)",
+        "modification_points": ["Create permission checker", "Add route decorators"],
+        "logic_flow": ["Check user role", "Validate permissions", "Allow/deny access"],
+        "depends_on": [1],
+        "output": "rbac_middleware"
+      }
+    ]
+  }
+}
+```
+
+## Key Features - CLI Execute Mode
+
+**Execution Model**: Commands in `command` field execute steps directly
+
+**Command Field Required**: Every step in `implementation_approach` MUST include `command` field
+
+**Context Delivery**: Context provided via CONTEXT field in command prompt using `@{path}` syntax
+
+**Multi-Step Support**:
+- First step: Full context with `-C directory` and complete CONTEXT field
+- Subsequent steps: Use `resume --last` to maintain session continuity
+- Step dependencies: Use `depends_on` array to specify step order
+
+## Command Templates
+
+### Single-Step Codex Command
+```bash
+bash(codex -C {focus_path} --full-auto exec "PURPOSE: {purpose} TASK: {task} MODE: auto CONTEXT: @{{synthesis_spec_path}} @{{context_package_path}} EXPECTED: {expected} RULES: {rules}" --skip-git-repo-check -s danger-full-access)
+```
+
+### Multi-Step Codex with Resume
+```bash
+# First step
+bash(codex -C {path} --full-auto exec "..." --skip-git-repo-check -s danger-full-access)
+
+# Subsequent steps
+bash(codex --full-auto exec "..." resume --last --skip-git-repo-check -s danger-full-access)
+```
+
+### Gemini/Qwen Commands (Analysis/Documentation)
+```bash
+bash(gemini "PURPOSE: {purpose} TASK: {task} MODE: analysis CONTEXT: @{synthesis_spec_path} EXPECTED: {expected} RULES: {rules}")
+
+# With write permission
+bash(gemini --approval-mode yolo "PURPOSE: {purpose} TASK: {task} MODE: write CONTEXT: @{context} EXPECTED: {expected} RULES: {rules}")
+```
+
+## Field Descriptions
+
+**implementation_approach**: Array of step objects (WITH command field)
+- **step**: Sequential step number
+- **title**: Step description
+- **description**: Brief step description
+- **command**: Complete CLI command to execute the step
+- **modification_points**: Specific code modifications (for reference)
+- **logic_flow**: Execution sequence (for reference)
+- **depends_on**: Step dependencies (array of step numbers, empty for independent)
+- **output**: Expected deliverable variable name
+
+## Usage Guidelines
+
+1. **Always Include Command**: Every step MUST have a `command` field
+2. **Context via CONTEXT Field**: Provide context using `@{path}` syntax in command prompt
+3. **First Step Full Context**: First step should include `-C directory` and full context package
+4. **Resume for Continuity**: Use `resume --last` for subsequent steps in same task
+5. **Step Dependencies**: Use `depends_on: [1, 2]` to specify execution order
+6. **Parameter Position**:
+   - Codex: `--skip-git-repo-check -s danger-full-access` at END
+   - Gemini/Qwen: `--approval-mode yolo` BEFORE the prompt