maestro-flow 0.1.0

package/templates/cli/prompts/workflow-skill-aggregation.txt

@@ -0,0 +1,172 @@
+# SKILL.md Index Generation Context
+
+## Description Field Requirements
+
+When generating final aggregated output, remember to prepare data for SKILL.md description field:
+
+**Required Data Points**:
+- Project root path (to be obtained via git command)
+- Use cases: "continuing development", "analyzing past implementations", "learning from workflow history"
+- Trigger phrase: "especially when no relevant context exists in memory"
+
+**Description Format**:
+```
+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.
+```
+
+---
+
+You are aggregating workflow session history to generate a progressive SKILL package.
+
+## Your Task
+
+Analyze archived workflow sessions and aggregate:
+1. **Lessons Learned** - Successes, challenges, and watch patterns
+2. **Conflict Patterns** - Recurring conflicts and resolutions
+3. **Implementation Summaries** - Key outcomes by functional domain
+
+## Input Data
+
+You will receive:
+- Session metadata (session_id, description, tags, metrics)
+- Lessons from each session (successes, challenges, watch_patterns)
+- IMPL_PLAN summaries
+- Context package metadata (keywords, tech_stack, complexity)
+
+## Output Requirements
+
+### 1. Aggregated Lessons
+
+**Successes by Category**:
+- Group successful patterns by functional domain (auth, testing, performance, etc.)
+- Identify practices that succeeded across multiple sessions
+- Mark best practices (success in 3+ sessions)
+
+**Challenges by Severity**:
+- HIGH: Blocked development for >4 hours OR repeated in 3+ sessions
+- MEDIUM: Required significant rework OR repeated in 2 sessions
+- LOW: Minor issues resolved quickly
+
+**Watch Patterns**:
+- Identify patterns mentioned in 2+ sessions
+- Prioritize by frequency and severity
+- Mark CRITICAL patterns (appeared in 3+ sessions with HIGH severity)
+
+**Format**:
+```json
+{
+  "successes_by_category": {
+    "auth": ["JWT implementation with refresh tokens (3 sessions)", ...],
+    "testing": ["TDD reduced bugs by 60% (2 sessions)", ...]
+  },
+  "challenges_by_severity": {
+    "high": [
+      {
+        "challenge": "Token refresh edge cases",
+        "sessions": ["WFS-user-auth", "WFS-jwt-refresh"],
+        "frequency": 2
+      }
+    ],
+    "medium": [...],
+    "low": [...]
+  },
+  "watch_patterns": [
+    {
+      "pattern": "Token concurrency issues",
+      "frequency": 3,
+      "severity": "CRITICAL",
+      "sessions": ["WFS-user-auth", "WFS-jwt-refresh", "WFS-oauth"]
+    }
+  ]
+}
+```
+
+### 2. Conflict Patterns
+
+**Analysis**:
+- Group conflicts by type (architecture, dependencies, testing, performance)
+- Identify recurring patterns (same conflict in different sessions)
+- Link successful resolutions to specific sessions
+
+**Format**:
+```json
+{
+  "architecture": [
+    {
+      "pattern": "Multiple authentication strategies conflict",
+      "description": "Different auth methods (JWT, OAuth, session) cause integration issues",
+      "sessions": ["WFS-user-auth", "WFS-oauth"],
+      "resolution": "Unified auth interface with strategy pattern",
+      "code_impact": ["src/auth/interface.ts", "src/auth/jwt.ts", "src/auth/oauth.ts"],
+      "frequency": 2,
+      "severity": "high"
+    }
+  ],
+  "dependencies": [...],
+  "testing": [...],
+  "performance": [...]
+}
+```
+
+### 3. Implementation Summary
+
+**By Functional Domain**:
+- Group sessions by primary tag/domain
+- Summarize key accomplishments
+- Link to context packages and plans
+
+**Format**:
+```json
+{
+  "auth": {
+    "session_count": 3,
+    "sessions": [
+      {
+        "session_id": "WFS-user-auth",
+        "description": "JWT authentication implementation",
+        "key_outcomes": [
+          "JWT token generation and validation",
+          "Refresh token mechanism",
+          "Secure password hashing with bcrypt"
+        ],
+        "context_package": ".workflow/.archives/WFS-user-auth/.process/context-package.json",
+        "metrics": {"task_count": 5, "success_rate": 100, "duration_hours": 4.5}
+      }
+    ],
+    "cumulative_metrics": {
+      "total_tasks": 15,
+      "avg_success_rate": 95,
+      "total_hours": 12.5
+    }
+  },
+  "payment": {...},
+  "ui": {...}
+}
+```
+
+## Analysis Guidelines
+
+1. **Identify Patterns**: Look for recurring themes across sessions
+2. **Prioritize by Impact**: Focus on high-frequency, high-impact patterns
+3. **Link Sessions**: Connect related sessions (same domain, similar challenges)
+4. **Extract Wisdom**: Surface actionable insights from lessons learned
+5. **Maintain Context**: Keep references to original sessions and files
+
+## Quality Criteria
+
+- ✅ All sessions processed and categorized
+- ✅ Patterns identified and frequency counted
+- ✅ Severity levels assigned based on impact
+- ✅ Resolutions linked to specific sessions
+- ✅ Output is valid JSON with no missing fields
+- ✅ References (paths) are accurate and complete
+
+## Important Notes
+
+- **NO hallucination**: Only aggregate data from provided sessions
+- **Preserve detail**: Keep specific session references for traceability
+- **Smart grouping**: Group similar patterns even if wording differs slightly
+- **Frequency matters**: Prioritize patterns that appear in multiple sessions
+- **Context preservation**: Keep context package paths for on-demand loading

package/templates/cli/prompts/workflow-skill-conflict-patterns.txt

@@ -0,0 +1,94 @@
+Template for generating conflict-patterns.md
+
+## Purpose
+Document recurring conflict patterns across workflow sessions with resolutions.
+
+## File Location
+`.claude/skills/workflow-progress/conflict-patterns.md`
+
+## Update Strategy
+- **Incremental mode**: Add new conflicts, update frequency counters for existing patterns
+- **Full mode**: Regenerate entire conflict analysis from all sessions
+
+## Structure
+
+```markdown
+# Workflow Conflict Patterns
+
+## Architecture Conflicts
+
+### {Conflict_Pattern_Title}
+**Pattern**: {concise_pattern_description}
+**Sessions**: {session_id_1}, {session_id_2}
+**Resolution**: {resolution_strategy}
+
+**Code Impact**:
+- Modified: {file_path_1}, {file_path_2}
+- Added: {file_path_3}
+- Tests: {test_file_path}
+
+**Frequency**: {count} sessions
+**Severity**: {high|medium|low}
+
+---
+
+## Dependency Conflicts
+
+### {Conflict_Pattern_Title}
+**Pattern**: {concise_pattern_description}
+**Sessions**: {session_id_list}
+**Resolution**: {resolution_strategy}
+
+**Package Changes**:
+- Updated: {package_name}@{version}
+- Locked: {dependency_name}
+
+**Frequency**: {count} sessions
+**Severity**: {high|medium|low}
+
+---
+
+## Testing Conflicts
+
+### {Conflict_Pattern_Title}
+...
+
+---
+
+## Performance Conflicts
+
+### {Conflict_Pattern_Title}
+...
+```
+
+## Data Sources
+- IMPL_PLAN summaries: `.workflow/.archives/{session_id}/IMPL_PLAN.md`
+- Context packages: `.workflow/.archives/{session_id}/.process/context-package.json` (reference only)
+- Session lessons: `manifest.json` -> `archives[].lessons.challenges`
+
+## Conflict Identification (Use maestro cli)
+
+**Command Pattern**:
+```bash
+maestro cli -p "
+PURPOSE: Identify conflict patterns from workflow sessions
+TASK: • Extract conflicts from IMPL_PLAN and lessons • Group by type (architecture/dependencies/testing/performance) • Identify recurring patterns (same conflict in different sessions) • Link resolutions to specific sessions
+MODE: analysis
+CONTEXT: @.workflow/.archives/*/IMPL_PLAN.md @.workflow/.archives/manifest.json
+EXPECTED: Conflict patterns with frequency and resolution
+CONSTRAINTS: analysis=READ-ONLY
+" --tool gemini --mode analysis --rule workflow-skill-aggregation --cd .workflow/.archives
+```
+
+**Pattern Grouping**:
+- **Architecture**: Design conflicts, incompatible strategies, interface mismatches
+- **Dependencies**: Version conflicts, library incompatibilities, package issues
+- **Testing**: Mock data inconsistencies, test environment issues, coverage gaps
+- **Performance**: Bottlenecks, optimization conflicts, resource issues
+
+## Formatting Rules
+- Sort by frequency within each category
+- Include code impact for traceability
+- Mark high-frequency patterns (3+ sessions) as "RECURRING"
+- Keep resolution descriptions actionable
+- Use relative paths for file references

package/templates/cli/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/templates/cli/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 maestro cli)
+
+**Command Pattern**:
+```bash
+maestro 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
+CONSTRAINTS: analysis=READ-ONLY
+" --tool gemini --mode analysis --rule workflow-skill-aggregation --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/templates/cli/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)