@windagency/valora 2.0.1

package/data/prompts/02_context/identify-completed-workflow.md

@@ -0,0 +1,203 @@
+---
+id: context.identify-completed-workflow
+version: 1.0.0
+category: context
+experimental: true
+name: Identify Completed Workflow
+description: Reconstruct workflow execution chain from command history, git commits, and PR metadata
+tags:
+  - workflow-analysis
+  - feedback
+  - execution-tracking
+model_requirements:
+  min_context: 128000
+  recommended:
+    - claude-sonnet-4.5
+agents:
+  - product-manager
+dependencies:
+  requires:
+    - context.use-modern-cli-tools
+inputs:
+  - name: command_name
+    description: Optional command name to start from (e.g., create-pr, implement)
+    type: string
+    required: false
+  - name: pr_number
+    description: Optional PR number to extract workflow from
+    type: number
+    required: false
+outputs:
+  - workflow_executed
+  - commands_chain
+  - start_time
+  - end_time
+  - execution_duration
+tokens:
+  avg: 2500
+  max: 5000
+  min: 1200
+---
+
+# Identify Completed Workflow
+
+## Objective
+
+Reconstruct the complete workflow execution chain by analyzing git history, PR metadata, and command logs to understand what was executed and in what order.
+
+## Instructions
+
+### Available Tools
+
+**Use these tools to gather information:**
+
+1. **query_session** - Access session data safely:
+   - `action: "list"` - List recent sessions with metadata
+   - `action: "get", session_id: "<id>"` - Get specific session details
+   - `action: "search", query: "<text>"` - Search across sessions
+
+2. **Git commands** via `run_terminal_cmd`:
+   - `git log`, `git show`, `git diff`, `git branch`
+
+3. **read_file** - Read command/agent definitions:
+   - `data/commands/*.md`
+   - `data/agents/*.md`
+
+**DO NOT use:**
+
+- `read_file` on `.valora/sessions/` - blocked for safety, use `query_session` instead
+- `npm run lint`, `pnpm lint`, `npm test` - slow and not needed for analysis
+
+### Step 1: Determine Workflow Entry Point
+
+**If `pr_number` provided:**
+
+- Use GitHub MCP to fetch PR details
+- Extract branch name, commits, and timeline
+- Identify workflow from PR metadata and commit messages
+
+**If `command_name` provided:**
+
+- Start reconstruction from specified command
+- Look backwards through git history
+
+**Otherwise:**
+
+- Analyze recent git commits (last 24 hours)
+- Identify command patterns from commit messages
+- Use conventional commit format to detect phases
+
+### Step 2: Analyze Git History
+
+Run:
+
+```bash
+git log --oneline --since="24 hours ago" --all
+```
+
+Extract workflow phases from commit messages:
+
+- Look for conventional commit types: `feat:`, `fix:`, `refactor:`, `test:`, `docs:`
+- Identify command signatures in commit bodies
+- Track branch creation/merge events
+- Calculate time between commits
+
+### Step 3: Map to Workflow Phases
+
+Identify which phases were executed based on commit patterns:
+
+**Initialization Phase:**
+
+- `refine-specs`, `create-prd`, `create-backlog` commands
+
+**Task Preparation:**
+
+- `fetch-task`, `refine-task`, `gather-knowledge` commands
+
+**Planning:**
+
+- `plan`, `review-plan` commands
+
+**Implementation:**
+
+- `implement`, `implement step-by-step` commands
+- Multiple commits with feature changes
+
+**Validation:**
+
+- `assert`, `test` commands
+- Test-related commits
+
+**Review:**
+
+- `review-code`, `review-functional` commands
+
+**Finalization:**
+
+- `commit`, `create-pr` commands
+
+### Step 4: Reconstruct Command Chain
+
+For each identified command:
+
+1. **Command name** (from commit or history)
+2. **Agent used** (infer from command type)
+3. **Timestamp** (from git commit or PR events)
+4. **Duration** (time between command markers)
+
+Build chronological chain with timing data.
+
+### Step 5: Calculate Metrics
+
+- **Workflow name**: Identify type (feature-implementation, bugfix, refactor)
+- **Start time**: First relevant commit timestamp
+- **End time**: Last commit or PR creation time
+- **Total duration**: End - Start (in seconds)
+- **Command count**: Number of distinct commands executed
+
+## Output Format
+
+```json
+{
+	"workflow_executed": "feature-implementation",
+	"commands_chain": [
+		{
+			"command": "fetch-task",
+			"agent": "product-manager",
+			"start_time": "2025-11-15T10:00:00Z",
+			"end_time": "2025-11-15T10:02:30Z",
+			"duration_seconds": 150
+		},
+		{
+			"command": "plan",
+			"agent": "lead",
+			"start_time": "2025-11-15T10:03:00Z",
+			"end_time": "2025-11-15T10:08:45Z",
+			"duration_seconds": 345
+		}
+	],
+	"start_time": "2025-11-15T10:00:00Z",
+	"end_time": "2025-11-15T11:30:00Z",
+	"execution_duration": 5400,
+	"metadata": {
+		"pr_number": 123,
+		"branch_name": "feature/oauth2",
+		"total_commands": 6
+	}
+}
+```
+
+## Success Criteria
+
+- ✅ Workflow type identified accurately
+- ✅ All commands in chain have timestamps
+- ✅ Duration calculated correctly
+- ✅ Agent assignments match command definitions
+- ✅ Chain is in chronological order
+
+## Error Handling
+
+- **No recent activity**: Return error - no workflow to analyze
+- **Ambiguous workflow**: Use best-effort reconstruction with confidence score
+- **Missing timestamps**: Estimate based on git commit times
+- **PR not found**: Fall back to git history analysis only

package/data/prompts/02_context/load-and-analyze-parallel.md

@@ -0,0 +1,441 @@
+---
+id: context.load-and-analyze-parallel
+version: 1.0.0
+category: context
+experimental: true
+name: Load and Analyze Context (Parallel)
+description: Merged context loading and analysis stage for parallel documentation generation - saves 15s per workflow
+tags:
+  - documentation
+  - context-loading
+  - analysis
+  - parallel
+  - optimisation
+model_requirements:
+  min_context: 128000
+  recommended:
+    - claude-sonnet-4.5
+agents:
+  - lead
+dependencies:
+  requires:
+    - context.use-modern-cli-tools
+inputs:
+  - name: output_dir_arg
+    description: Optional output directory from --output-dir argument
+    type: string
+    required: false
+  - name: cache_context
+    description: Force use of cached context if available
+    type: boolean
+    required: false
+  - name: security_context_path
+    description: Path to security requirements file
+    type: string
+    required: false
+outputs:
+  - prd_document
+  - functional_document
+  - backlog_document
+  - codebase_context
+  - project_metadata
+  - documentation_plan
+  - diagram_requirements
+  - cross_references
+  - domain_assignments
+  - security_context
+tokens:
+  avg: 8000
+  max: 15000
+  min: 5000
+---
+
+# Load and Analyze Context (Parallel)
+
+## Objective
+
+Perform **merged context loading and documentation analysis** in a single stage, reducing pipeline overhead by ~15 seconds. This prompt combines the functionality of `context.load-documentation-context` and `onboard.analyze-documentation-requirements` with internal parallelisation.
+
+## CRITICAL: Output Format Requirement
+
+**You MUST output ONLY valid JSON. Do NOT output markdown, do NOT wrap in code blocks, do NOT add any text before or after the JSON.**
+
+## Optimisation Strategy
+
+### Internal Parallelisation
+
+Instead of sequential execution:
+
+```
+load-context (45s) → analyze-requirements (60s) = 105s
+```
+
+This prompt executes operations in parallel:
+
+```
+[load PRD + load FUNCTIONAL + load BACKLOG + scan codebase] → [analyze] = 90s
+```
+
+**Time saved**: ~15 seconds per workflow
+
+---
+
+## Instructions
+
+### Phase 1: Parallel Document Loading (Concurrent)
+
+Execute these operations concurrently:
+
+**1.1 Load PRD Document**
+
+Check locations in order:
+
+1. `knowledge-base/PRD.md`
+2. `knowledge-base/PRD-*.md` (most recent timestamped)
+3. `docs/PRD.md`
+
+Extract:
+
+- Project name, description
+- Technology stack
+- Functional requirements (FR-XXX)
+- Non-functional requirements (NFR-XXX)
+- User stories (US-XXX)
+- Architecture decisions
+
+**1.2 Load FUNCTIONAL Document**
+
+Check locations in order:
+
+1. `knowledge-base/FUNCTIONAL.md`
+2. `knowledge-base/FUNCTIONAL-*.md` (most recent)
+3. `docs/FUNCTIONAL.md`
+
+Extract:
+
+- Feature specifications
+- User flows
+- Business rules
+- Acceptance criteria
+- Integration requirements
+
+**1.3 Load BACKLOG Document**
+
+Check locations in order:
+
+1. `knowledge-base/BACKLOG.md`
+2. `knowledge-base/BACKLOG-*.md` (most recent)
+3. `docs/BACKLOG.md`
+
+Extract:
+
+- Task list and phases
+- Domain distribution
+- Priority distribution
+- Effort estimates
+
+**1.4 Scan Codebase Structure**
+
+Analyse in parallel:
+
+- Root directory layout
+- `package.json` dependencies
+- `tsconfig.json` configuration
+- Dockerfile/docker-compose presence
+- CI/CD configuration
+- Source directory structure
+
+**1.5 Load Security Context (if provided)**
+
+If `security_context_path` is provided:
+
+- Load security requirements file
+- Parse compliance frameworks
+- Extract security policies
+
+### Phase 2: Unified Analysis (After Phase 1)
+
+With all documents loaded, perform documentation planning:
+
+**2.1 Plan Documentation Structure**
+
+For each domain (infrastructure, backend, frontend):
+
+**Infrastructure documentation plan**:
+
+- HLD.md: High-level design with C4 diagrams
+- CONTAINER.md: Container architecture
+- DEPLOYMENT.md: Deployment processes
+- LOGGING.md: Observability strategy
+- LZ.md: Landing zone architecture
+- WORKFLOW.md: Development workflows
+
+**Backend documentation plan**:
+
+- ARCHITECTURE.md: Backend architecture
+- API.md: API documentation
+- DATA.md: Data models and schemas
+- TESTING.md: Testing strategy
+- CODING-ASSERTIONS.md: Coding standards
+
+**Frontend documentation plan**:
+
+- ARCHITECTURE.md: Component architecture
+- DESIGN.md: Design system
+- TESTING.md: Frontend testing
+- CODING-ASSERTIONS.md: Frontend standards
+
+**2.2 Identify Diagram Requirements**
+
+For each document, determine required diagrams:
+
+| Document        | Diagram Types                        |
+| --------------- | ------------------------------------ |
+| HLD.md          | C4 Context, C4 Container             |
+| CONTAINER.md    | Container Topology                   |
+| DEPLOYMENT.md   | Deployment Pipeline                  |
+| LOGGING.md      | Observability Architecture           |
+| LZ.md           | Network Topology                     |
+| WORKFLOW.md     | Git Flow                             |
+| ARCHITECTURE.md | Component Diagram, Sequence Diagrams |
+| API.md          | Sequence Diagrams                    |
+| DATA.md         | ERD Diagram                          |
+| DESIGN.md       | Component Hierarchy                  |
+
+**2.3 Map Cross-References**
+
+Identify links between documents:
+
+```text
+HLD.md → CONTAINER.md (container details)
+HLD.md → LZ.md (infrastructure details)
+API.md → DATA.md (data models)
+ARCHITECTURE.md → API.md (endpoint implementation)
+```
+
+**2.4 Assign Domain Generation**
+
+Based on codebase analysis:
+
+```json
+{
+	"infrastructure": true, // if Dockerfile/k8s/terraform present
+	"backend": true, // if API routes/services present
+	"frontend": true // if React/Vue/Angular present
+}
+```
+
+---
+
+## Output Format
+
+```json
+{
+	"prd_document": {
+		"found": true,
+		"source_file": "knowledge-base/PRD.md",
+		"project_name": "Project Name",
+		"project_description": "Project description",
+		"technology_stack": {
+			"frontend": ["React", "TypeScript"],
+			"backend": ["Node.js", "Express"],
+			"database": ["PostgreSQL"],
+			"infrastructure": ["Docker", "AWS"]
+		},
+		"functional_requirements": [{ "id": "FR-001", "title": "Feature", "priority": "P0", "domain": "Backend" }],
+		"non_functional_requirements": [
+			{ "id": "NFR-001", "category": "Performance", "description": "...", "priority": "P0" }
+		],
+		"user_stories_count": 23,
+		"constraints": [],
+		"architecture_decisions": []
+	},
+	"functional_document": {
+		"found": true,
+		"source_file": "knowledge-base/FUNCTIONAL.md",
+		"features": [{ "id": "FEAT-001", "name": "Feature", "description": "...", "user_flows": 3 }],
+		"business_rules_count": 15,
+		"integration_points": [],
+		"data_entities": []
+	},
+	"backlog_document": {
+		"found": true,
+		"source_file": "knowledge-base/BACKLOG.md",
+		"total_tasks": 42,
+		"phases": 5,
+		"domain_distribution": {
+			"frontend": 12,
+			"backend": 18,
+			"infrastructure": 8
+		},
+		"priority_distribution": {
+			"p0": 14,
+			"p1": 18,
+			"p2": 10
+		}
+	},
+	"codebase_context": {
+		"project_type": "full-stack",
+		"primary_language": "TypeScript",
+		"structure": {
+			"has_frontend": true,
+			"has_backend": true,
+			"has_infrastructure": true
+		},
+		"directories": {
+			"frontend": "src/client",
+			"backend": "src/server",
+			"infrastructure": "infrastructure/"
+		},
+		"detected_technologies": {
+			"frontend_framework": "React 18",
+			"backend_framework": "Express 4",
+			"build_tool": "Vite"
+		}
+	},
+	"project_metadata": {
+		"name": "Project Name",
+		"type": "full-stack",
+		"language": "TypeScript",
+		"documentation_target_dir": "knowledge-base/",
+		"domains_to_document": {
+			"infrastructure": true,
+			"backend": true,
+			"frontend": true
+		}
+	},
+	"documentation_plan": {
+		"infrastructure": {
+			"enabled": true,
+			"documents": [
+				{ "id": "HLD", "filename": "HLD.md", "sections": 13 },
+				{ "id": "CONTAINER", "filename": "CONTAINER.md", "sections": 15 },
+				{ "id": "DEPLOYMENT", "filename": "DEPLOYMENT.md", "sections": 16 },
+				{ "id": "LOGGING", "filename": "LOGGING.md", "sections": 16 },
+				{ "id": "LZ", "filename": "LZ.md", "sections": 16 },
+				{ "id": "WORKFLOW", "filename": "WORKFLOW.md", "sections": 15 }
+			]
+		},
+		"backend": {
+			"enabled": true,
+			"documents": [
+				{ "id": "ARCHITECTURE", "filename": "ARCHITECTURE.md", "sections": 12 },
+				{ "id": "API", "filename": "API.md", "sections": 10 },
+				{ "id": "DATA", "filename": "DATA.md", "sections": 10 },
+				{ "id": "TESTING", "filename": "TESTING.md", "sections": 10 },
+				{ "id": "CODING-ASSERTIONS", "filename": "CODING-ASSERTIONS.md", "sections": 8 }
+			]
+		},
+		"frontend": {
+			"enabled": true,
+			"documents": [
+				{ "id": "ARCHITECTURE", "filename": "ARCHITECTURE.md", "sections": 10 },
+				{ "id": "DESIGN", "filename": "DESIGN.md", "sections": 10 },
+				{ "id": "TESTING", "filename": "TESTING.md", "sections": 8 },
+				{ "id": "CODING-ASSERTIONS", "filename": "CODING-ASSERTIONS.md", "sections": 8 }
+			]
+		}
+	},
+	"diagram_requirements": {
+		"infrastructure": [
+			{ "document": "HLD.md", "diagrams": ["C4 Context", "C4 Container"] },
+			{ "document": "CONTAINER.md", "diagrams": ["Container Topology"] },
+			{ "document": "DEPLOYMENT.md", "diagrams": ["Deployment Pipeline"] },
+			{ "document": "LOGGING.md", "diagrams": ["Observability Architecture"] },
+			{ "document": "LZ.md", "diagrams": ["Network Topology"] },
+			{ "document": "WORKFLOW.md", "diagrams": ["Git Flow"] }
+		],
+		"backend": [
+			{ "document": "ARCHITECTURE.md", "diagrams": ["Component Diagram"] },
+			{ "document": "API.md", "diagrams": ["Sequence Diagrams"] },
+			{ "document": "DATA.md", "diagrams": ["ERD"] }
+		],
+		"frontend": [
+			{ "document": "ARCHITECTURE.md", "diagrams": ["Component Hierarchy"] },
+			{ "document": "DESIGN.md", "diagrams": ["Design System"] }
+		]
+	},
+	"cross_references": {
+		"infrastructure": {
+			"HLD.md": ["CONTAINER.md", "LZ.md", "DEPLOYMENT.md"],
+			"CONTAINER.md": ["DEPLOYMENT.md", "HLD.md"],
+			"DEPLOYMENT.md": ["CONTAINER.md", "LOGGING.md", "WORKFLOW.md"],
+			"LOGGING.md": ["DEPLOYMENT.md", "LZ.md"],
+			"LZ.md": ["HLD.md", "DEPLOYMENT.md"],
+			"WORKFLOW.md": ["DEPLOYMENT.md"]
+		},
+		"backend": {
+			"ARCHITECTURE.md": ["API.md", "DATA.md"],
+			"API.md": ["DATA.md", "ARCHITECTURE.md"],
+			"DATA.md": ["API.md"],
+			"TESTING.md": ["API.md", "ARCHITECTURE.md"],
+			"CODING-ASSERTIONS.md": ["ARCHITECTURE.md"]
+		},
+		"frontend": {
+			"ARCHITECTURE.md": ["DESIGN.md"],
+			"DESIGN.md": ["ARCHITECTURE.md"],
+			"TESTING.md": ["ARCHITECTURE.md", "DESIGN.md"],
+			"CODING-ASSERTIONS.md": ["ARCHITECTURE.md"]
+		},
+		"cross_domain": {
+			"backend/API.md": ["frontend/ARCHITECTURE.md"],
+			"infrastructure/DEPLOYMENT.md": ["backend/ARCHITECTURE.md", "frontend/ARCHITECTURE.md"]
+		}
+	},
+	"domain_assignments": {
+		"infrastructure": true,
+		"backend": true,
+		"frontend": true
+	},
+	"security_context": {
+		"loaded": false,
+		"source_file": null,
+		"compliance_frameworks": [],
+		"security_policies": [],
+		"threat_model_reference": null
+	},
+	"validation": {
+		"prerequisites_met": true,
+		"documents_found": 3,
+		"codebase_analysed": true,
+		"ready_for_generation": true,
+		"coverage_estimate": 0.92,
+		"warnings": []
+	},
+	"timing": {
+		"phase1_parallel_ms": 45000,
+		"phase2_analysis_ms": 45000,
+		"total_ms": 90000,
+		"estimated_savings_ms": 15000
+	}
+}
+```
+
+## Success Criteria
+
+- ✅ All available prerequisite documents loaded in parallel
+- ✅ Codebase structure analysed concurrently
+- ✅ Documentation plan generated for all domains
+- ✅ Diagram requirements identified
+- ✅ Cross-references mapped
+- ✅ Domain assignments determined
+- ✅ Security context loaded (if provided)
+- ✅ Total execution < 90 seconds
+
+## Error Handling
+
+### No Prerequisites Found
+
+**Action**: Exit with error, inform user to run prerequisite commands.
+
+### Partial Prerequisites
+
+**Action**: Continue with available context, set warnings, reduce coverage estimate.
+
+### Security Context Not Found
+
+**Action**: Set `security_context.loaded: false`, continue without security context.
+
+## REMINDER: Output Requirements
+
+**Output ONLY the JSON object. No markdown, no code blocks, no explanatory text. Start directly with `{` and end with `}`.**