claude-code-workflow 6.3.18 → 6.3.20

package/.claude/skills/command-guide/reference/commands/workflow/tools/tdd-coverage-analysis.md

@@ -1,309 +0,0 @@
----
-name: tdd-coverage-analysis
-description: Analyze test coverage and TDD cycle execution with Red-Green-Refactor compliance verification
-argument-hint: "--session WFS-session-id"
-allowed-tools: Read(*), Write(*), Bash(*)
----
-
-# TDD Coverage Analysis Command
-
-## Overview
-Analyze test coverage and verify Red-Green-Refactor cycle execution for TDD workflow validation.
-
-## Core Responsibilities
-- Extract test files from TEST tasks
-- Run test suite with coverage
-- Parse coverage metrics
-- Verify TDD cycle execution (Red -> Green -> Refactor)
-- Generate coverage and cycle reports
-
-## Execution Process
-
-```
-Input Parsing:
-   ├─ Parse flags: --session
-   └─ Validation: session_id REQUIRED
-
-Phase 1: Extract Test Tasks
-   └─ Find TEST-*.json files and extract focus_paths
-
-Phase 2: Run Test Suite
-   └─ Decision (test framework):
-      ├─ Node.js → npm test --coverage --json
-      ├─ Python → pytest --cov --json-report
-      └─ Other → [test_command] --coverage --json
-
-Phase 3: Parse Coverage Data
-   ├─ Extract line coverage percentage
-   ├─ Extract branch coverage percentage
-   ├─ Extract function coverage percentage
-   └─ Identify uncovered lines/branches
-
-Phase 4: Verify TDD Cycle
-   └─ FOR each TDD chain (TEST-N.M → IMPL-N.M → REFACTOR-N.M):
-      ├─ Red Phase: Verify tests created and failed initially
-      ├─ Green Phase: Verify tests now pass
-      └─ Refactor Phase: Verify code quality improved
-
-Phase 5: Generate Analysis Report
-   └─ Create tdd-cycle-report.md with coverage metrics and cycle verification
-```
-
-## Execution Lifecycle
-
-### Phase 1: Extract Test Tasks
-```bash
-find .workflow/active/{session_id}/.task/ -name 'TEST-*.json' -exec jq -r '.context.focus_paths[]' {} \;
-```
-
-**Output**: List of test directories/files from all TEST tasks
-
-### Phase 2: Run Test Suite
-```bash
-# Node.js/JavaScript
-npm test -- --coverage --json > .workflow/active/{session_id}/.process/test-results.json
-
-# Python
-pytest --cov --json-report > .workflow/active/{session_id}/.process/test-results.json
-
-# Other frameworks (detect from project)
-[test_command] --coverage --json-output .workflow/active/{session_id}/.process/test-results.json
-```
-
-**Output**: test-results.json with coverage data
-
-### Phase 3: Parse Coverage Data
-```bash
-jq '.coverage' .workflow/active/{session_id}/.process/test-results.json > .workflow/active/{session_id}/.process/coverage-report.json
-```
-
-**Extract**:
-- Line coverage percentage
-- Branch coverage percentage
-- Function coverage percentage
-- Uncovered lines/branches
-
-### Phase 4: Verify TDD Cycle
-
-For each TDD chain (TEST-N.M -> IMPL-N.M -> REFACTOR-N.M):
-
-**1. Red Phase Verification**
-```bash
-# Check TEST task summary
-cat .workflow/active/{session_id}/.summaries/TEST-N.M-summary.md
-```
-
-Verify:
-- Tests were created
-- Tests failed initially
-- Failure messages were clear
-
-**2. Green Phase Verification**
-```bash
-# Check IMPL task summary
-cat .workflow/active/{session_id}/.summaries/IMPL-N.M-summary.md
-```
-
-Verify:
-- Implementation was completed
-- Tests now pass
-- Implementation was minimal
-
-**3. Refactor Phase Verification**
-```bash
-# Check REFACTOR task summary
-cat .workflow/active/{session_id}/.summaries/REFACTOR-N.M-summary.md
-```
-
-Verify:
-- Refactoring was completed
-- Tests still pass
-- Code quality improved
-
-### Phase 5: Generate Analysis Report
-
-Create `.workflow/active/{session_id}/.process/tdd-cycle-report.md`:
-
-```markdown
-# TDD Cycle Analysis - {Session ID}
-
-## Coverage Metrics
-- **Line Coverage**: {percentage}%
-- **Branch Coverage**: {percentage}%
-- **Function Coverage**: {percentage}%
-
-## Coverage Details
-### Covered
-- {covered_lines} lines
-- {covered_branches} branches
-- {covered_functions} functions
-
-### Uncovered
-- Lines: {uncovered_line_numbers}
-- Branches: {uncovered_branch_locations}
-
-## TDD Cycle Verification
-
-### Feature 1: {Feature Name}
-**Chain**: TEST-1.1 -> IMPL-1.1 -> REFACTOR-1.1
-
-- [PASS] **Red Phase**: Tests created and failed initially
-- [PASS] **Green Phase**: Implementation made tests pass
-- [PASS] **Refactor Phase**: Refactoring maintained green tests
-
-### Feature 2: {Feature Name}
-**Chain**: TEST-2.1 -> IMPL-2.1 -> REFACTOR-2.1
-
-- [PASS] **Red Phase**: Tests created and failed initially
-- [WARN] **Green Phase**: Tests pass but implementation seems over-engineered
-- [PASS] **Refactor Phase**: Refactoring maintained green tests
-
-[Repeat for all features]
-
-## TDD Compliance Summary
-- **Total Chains**: {N}
-- **Complete Cycles**: {N}
-- **Incomplete Cycles**: {0}
-- **Compliance Score**: {score}/100
-
-## Gaps Identified
-- Feature 3: Missing initial test failure verification
-- Feature 5: No refactoring step completed
-
-## Recommendations
-- Complete missing refactoring steps
-- Add edge case tests for Feature 2
-- Verify test failure messages are descriptive
-```
-
-## Output Files
-```
-.workflow/active//{session-id}/
-└── .process/
-    ├── test-results.json         # Raw test execution results
-    ├── coverage-report.json      # Parsed coverage data
-    └── tdd-cycle-report.md       # TDD cycle analysis
-```
-
-## Test Framework Detection
-
-Auto-detect test framework from project:
-
-```bash
-# Check for test frameworks
-if [ -f "package.json" ] && grep -q "jest\|mocha\|vitest" package.json; then
-    TEST_CMD="npm test -- --coverage --json"
-elif [ -f "pytest.ini" ] || [ -f "setup.py" ]; then
-    TEST_CMD="pytest --cov --json-report"
-elif [ -f "Cargo.toml" ]; then
-    TEST_CMD="cargo test -- --test-threads=1 --nocapture"
-elif [ -f "go.mod" ]; then
-    TEST_CMD="go test -coverprofile=coverage.out -json ./..."
-else
-    TEST_CMD="echo 'No supported test framework found'"
-fi
-```
-
-## TDD Cycle Verification Algorithm
-
-```
-For each feature N:
-  1. Load TEST-N.M-summary.md
-     IF summary missing:
-       Mark: "Red phase incomplete"
-       SKIP to next feature
-
-     CHECK: Contains "test" AND "fail"
-     IF NOT found:
-       Mark: "Red phase verification failed"
-     ELSE:
-       Mark: "Red phase [PASS]"
-
-  2. Load IMPL-N.M-summary.md
-     IF summary missing:
-       Mark: "Green phase incomplete"
-       SKIP to next feature
-
-     CHECK: Contains "pass" OR "green"
-     IF NOT found:
-       Mark: "Green phase verification failed"
-     ELSE:
-       Mark: "Green phase [PASS]"
-
-  3. Load REFACTOR-N.M-summary.md
-     IF summary missing:
-       Mark: "Refactor phase incomplete"
-       CONTINUE (refactor is optional)
-
-     CHECK: Contains "refactor" AND "pass"
-     IF NOT found:
-       Mark: "Refactor phase verification failed"
-     ELSE:
-       Mark: "Refactor phase [PASS]"
-
-  4. Calculate chain score:
-     - Red + Green + Refactor all [PASS] = 100%
-     - Red + Green [PASS], Refactor missing = 80%
-     - Red [PASS], Green missing = 40%
-     - All missing = 0%
-```
-
-## Coverage Metrics Calculation
-
-```bash
-# Parse coverage from test-results.json
-line_coverage=$(jq '.coverage.lineCoverage' test-results.json)
-branch_coverage=$(jq '.coverage.branchCoverage' test-results.json)
-function_coverage=$(jq '.coverage.functionCoverage' test-results.json)
-
-# Calculate overall score
-overall_score=$(echo "($line_coverage + $branch_coverage + $function_coverage) / 3" | bc)
-```
-
-## Error Handling
-
-### Test Execution Errors
-| Error | Cause | Resolution |
-|-------|-------|------------|
-| Test framework not found | No test config | Configure test framework first |
-| Tests fail to run | Syntax errors | Fix code before analysis |
-| Coverage not available | Missing coverage tool | Install coverage plugin |
-
-### Cycle Verification Errors
-| Error | Cause | Resolution |
-|-------|-------|------------|
-| Summary missing | Task not executed | Execute tasks before analysis |
-| Invalid summary format | Corrupted file | Re-run task to regenerate |
-| No test evidence | Tests not committed | Ensure tests are committed |
-
-## Integration & Usage
-
-### Command Chain
-- **Called By**: `/workflow:tdd-verify` (Phase 3)
-- **Calls**: Test framework commands (npm test, pytest, etc.)
-- **Followed By**: Compliance report generation
-
-### Basic Usage
-```bash
-/workflow:tools:tdd-coverage-analysis --session WFS-auth
-```
-
-### Expected Output
-```
-TDD Coverage Analysis complete for session: WFS-auth
-
-## Coverage Results
-Line Coverage: 87%
-Branch Coverage: 82%
-Function Coverage: 91%
-
-## TDD Cycle Verification
-[PASS] Feature 1: Complete (Red -> Green -> Refactor)
-[PASS] Feature 2: Complete (Red -> Green -> Refactor)
-[WARN] Feature 3: Incomplete (Red -> Green, missing Refactor)
-
-Overall Compliance: 93/100
-
-Detailed report: .workflow/active/WFS-auth/.process/tdd-cycle-report.md
-```
-

package/.claude/skills/command-guide/reference/commands/workflow/tools/test-concept-enhanced.md

@@ -1,163 +0,0 @@
----
-name: test-concept-enhanced
-description: Coordinate test analysis workflow using cli-execution-agent to generate test strategy via Gemini
-argument-hint: "--session WFS-test-session-id --context path/to/test-context-package.json"
-examples:
-  - /workflow:tools:test-concept-enhanced --session WFS-test-auth --context .workflow/active/WFS-test-auth/.process/test-context-package.json
----
-
-# Test Concept Enhanced Command
-
-## Overview
-Workflow coordinator that delegates test analysis to cli-execution-agent. Agent executes Gemini to analyze test coverage gaps, implementation context, and generate comprehensive test generation strategies.
-
-## Core Philosophy
-- **Coverage-Driven**: Focus on identified test gaps from context analysis
-- **Pattern-Based**: Learn from existing tests and project conventions
-- **Gemini-Powered**: Use Gemini for test requirement analysis and strategy design
-- **Single-Round Analysis**: Comprehensive test analysis in one execution
-- **No Code Generation**: Strategy and planning only, actual test generation happens in task execution
-
-## Core Responsibilities
-- Coordinate test analysis workflow using cli-execution-agent
-- Validate test-context-package.json prerequisites
-- Execute Gemini analysis via agent for test strategy generation
-- Validate agent outputs (gemini-test-analysis.md, TEST_ANALYSIS_RESULTS.md)
-
-## Execution Process
-
-```
-Input Parsing:
-   ├─ Parse flags: --session, --context
-   └─ Validation: Both REQUIRED
-
-Phase 1: Context Preparation (Command)
-   ├─ Load workflow-session.json
-   ├─ Verify test session type is "test-gen"
-   ├─ Validate test-context-package.json
-   └─ Determine strategy (Simple: 1-3 files | Medium: 4-6 | Complex: >6)
-
-Phase 2: Test Analysis Execution (Agent)
-   ├─ Execute Gemini analysis via cli-execution-agent
-   └─ Generate TEST_ANALYSIS_RESULTS.md
-
-Phase 3: Output Validation (Command)
-   ├─ Verify gemini-test-analysis.md exists
-   ├─ Validate TEST_ANALYSIS_RESULTS.md
-   └─ Confirm test requirements are actionable
-```
-
-## Execution Lifecycle
-
-### Phase 1: Context Preparation (Command Responsibility)
-
-**Command prepares session context and validates prerequisites.**
-
-1. **Session Validation**
-   - Load `.workflow/active/{test_session_id}/workflow-session.json`
-   - Verify test session type is "test-gen"
-   - Extract source session reference
-
-2. **Context Package Validation**
-   - Read `test-context-package.json`
-   - Validate required sections: metadata, source_context, test_coverage, test_framework
-   - Extract coverage gaps and framework details
-
-3. **Strategy Determination**
-   - **Simple** (1-3 files): Single Gemini analysis
-   - **Medium** (4-6 files): Comprehensive analysis
-   - **Complex** (>6 files): Modular analysis approach
-
-### Phase 2: Test Analysis Execution (Agent Responsibility)
-
-**Purpose**: Analyze test coverage gaps and generate comprehensive test strategy.
-
-**Agent Invocation**:
-```javascript
-Task(
-  subagent_type="cli-execution-agent",
-  description="Analyze test coverage gaps and generate test strategy",
-  prompt=`
-## TASK OBJECTIVE
-Analyze test requirements and generate comprehensive test generation strategy using Gemini CLI
-
-## EXECUTION CONTEXT
-Session: {test_session_id}
-Source Session: {source_session_id}
-Working Dir: .workflow/active/{test_session_id}/.process
-Template: ~/.claude/workflows/cli-templates/prompts/test/test-concept-analysis.txt
-
-## EXECUTION STEPS
-1. Execute Gemini analysis:
-   ccw cli -p "$(cat ~/.claude/workflows/cli-templates/prompts/test/test-concept-analysis.txt)" --tool gemini --mode write --cd .workflow/active/{test_session_id}/.process
-
-2. Generate TEST_ANALYSIS_RESULTS.md:
-   Synthesize gemini-test-analysis.md into standardized format for task generation
-   Include: coverage assessment, test framework, test requirements, generation strategy, implementation targets
-
-## EXPECTED OUTPUTS
-1. gemini-test-analysis.md - Raw Gemini analysis
-2. TEST_ANALYSIS_RESULTS.md - Standardized test requirements document
-
-## QUALITY VALIDATION
-- Both output files exist and are complete
-- All required sections present in TEST_ANALYSIS_RESULTS.md
-- Test requirements are actionable and quantified
-- Test scenarios cover happy path, errors, edge cases
-- Dependencies and mocks clearly identified
-`
-)
-```
-
-**Output Files**:
-- `.workflow/active/{test_session_id}/.process/gemini-test-analysis.md`
-- `.workflow/active/{test_session_id}/.process/TEST_ANALYSIS_RESULTS.md`
-
-### Phase 3: Output Validation (Command Responsibility)
-
-**Command validates agent outputs.**
-
-- Verify `gemini-test-analysis.md` exists and is complete
-- Validate `TEST_ANALYSIS_RESULTS.md` generated by agent
-- Check required sections present
-- Confirm test requirements are actionable
-
-## Error Handling
-
-### Validation Errors
-| Error | Resolution |
-|-------|------------|
-| Missing context package | Run test-context-gather first |
-| No coverage gaps | Skip test generation, proceed to execution |
-| No test framework detected | Configure test framework |
-| Invalid source session | Complete implementation first |
-
-### Execution Errors
-| Error | Recovery |
-|-------|----------|
-| Gemini timeout | Reduce scope, analyze by module |
-| Output incomplete | Retry with focused analysis |
-| No output file | Check directory permissions |
-
-**Fallback Strategy**: Generate basic TEST_ANALYSIS_RESULTS.md from context package if Gemini fails
-
-## Integration & Usage
-
-### Command Chain
-- **Called By**: `/workflow:test-gen` (Phase 4: Analysis)
-- **Requires**: `test-context-package.json` from `/workflow:tools:test-context-gather`
-- **Followed By**: `/workflow:tools:test-task-generate`
-
-### Performance
-- Focused analysis: Only analyze files with missing tests
-- Pattern reuse: Study existing tests for quick extraction
-- Timeout: 20-minute limit for analysis
-
-### Success Criteria
-- Valid TEST_ANALYSIS_RESULTS.md generated
-- All missing tests documented with actionable requirements
-- Test scenarios cover happy path, errors, edge cases, integration
-- Dependencies and mocks clearly identified
-- Test generation strategy is practical
-- Output follows existing test conventions
-

package/.claude/skills/command-guide/reference/commands/workflow/tools/test-context-gather.md

@@ -1,232 +0,0 @@
----
-name: test-context-gather
-description: Collect test coverage context using test-context-search-agent and package into standardized test-context JSON
-argument-hint: "--session WFS-test-session-id"
-examples:
-  - /workflow:tools:test-context-gather --session WFS-test-auth
-  - /workflow:tools:test-context-gather --session WFS-test-payment
-allowed-tools: Task(*), Read(*), Glob(*)
----
-
-# Test Context Gather Command (/workflow:tools:test-context-gather)
-
-## Overview
-
-Orchestrator command that invokes `test-context-search-agent` to gather comprehensive test coverage context for test generation workflows. Generates standardized `test-context-package.json` with coverage analysis, framework detection, and source implementation context.
-
-## Core Philosophy
-
-- **Agent Delegation**: Delegate all test coverage analysis to `test-context-search-agent` for autonomous execution
-- **Detection-First**: Check for existing test-context-package before executing
-- **Coverage-First**: Analyze existing test coverage before planning new tests
-- **Source Context Loading**: Import implementation summaries from source session
-- **Standardized Output**: Generate `.workflow/active/{test_session_id}/.process/test-context-package.json`
-
-## Execution Process
-
-```
-Input Parsing:
-   ├─ Parse flags: --session
-   └─ Validation: test_session_id REQUIRED
-
-Step 1: Test-Context-Package Detection
-   └─ Decision (existing package):
-      ├─ Valid package exists → Return existing (skip execution)
-      └─ No valid package → Continue to Step 2
-
-Step 2: Invoke Test-Context-Search Agent
-   ├─ Phase 1: Session Validation & Source Context Loading
-   │  ├─ Detection: Check for existing test-context-package
-   │  ├─ Test session validation
-   │  └─ Source context loading (summaries, changed files)
-   ├─ Phase 2: Test Coverage Analysis
-   │  ├─ Track 1: Existing test discovery
-   │  ├─ Track 2: Coverage gap analysis
-   │  └─ Track 3: Coverage statistics
-   └─ Phase 3: Framework Detection & Packaging
-      ├─ Framework identification
-      ├─ Convention analysis
-      └─ Generate test-context-package.json
-
-Step 3: Output Verification
-   └─ Verify test-context-package.json created
-```
-
-## Execution Flow
-
-### Step 1: Test-Context-Package Detection
-
-**Execute First** - Check if valid package already exists:
-
-```javascript
-const testContextPath = `.workflow/${test_session_id}/.process/test-context-package.json`;
-
-if (file_exists(testContextPath)) {
-  const existing = Read(testContextPath);
-
-  // Validate package belongs to current test session
-  if (existing?.metadata?.test_session_id === test_session_id) {
-    console.log("✅ Valid test-context-package found for session:", test_session_id);
-    console.log("📊 Coverage Stats:", existing.test_coverage.coverage_stats);
-    console.log("🧪 Framework:", existing.test_framework.framework);
-    console.log("⚠️  Missing Tests:", existing.test_coverage.missing_tests.length);
-    return existing; // Skip execution, return existing
-  } else {
-    console.warn("⚠️ Invalid test_session_id in existing package, re-generating...");
-  }
-}
-```
-
-### Step 2: Invoke Test-Context-Search Agent
-
-**Only execute if Step 1 finds no valid package**
-
-```javascript
-Task(
-  subagent_type="test-context-search-agent",
-  description="Gather test coverage context",
-  prompt=`
-
-## Execution Mode
-**PLAN MODE** (Comprehensive) - Full Phase 1-3 execution
-
-## Session Information
-- **Test Session ID**: ${test_session_id}
-- **Output Path**: .workflow/${test_session_id}/.process/test-context-package.json
-
-## Mission
-Execute complete test-context-search-agent workflow for test generation planning:
-
-### Phase 1: Session Validation & Source Context Loading
-1. **Detection**: Check for existing test-context-package (early exit if valid)
-2. **Test Session Validation**: Load test session metadata, extract source_session reference
-3. **Source Context Loading**: Load source session implementation summaries, changed files, tech stack
-
-### Phase 2: Test Coverage Analysis
-Execute coverage discovery:
-- **Track 1**: Existing test discovery (find *.test.*, *.spec.* files)
-- **Track 2**: Coverage gap analysis (match implementation files to test files)
-- **Track 3**: Coverage statistics (calculate percentages, identify gaps by module)
-
-### Phase 3: Framework Detection & Packaging
-1. Framework identification from package.json/requirements.txt
-2. Convention analysis from existing test patterns
-3. Generate and validate test-context-package.json
-
-## Output Requirements
-Complete test-context-package.json with:
-- **metadata**: test_session_id, source_session_id, task_type, complexity
-- **source_context**: implementation_summaries, tech_stack, project_patterns
-- **test_coverage**: existing_tests[], missing_tests[], coverage_stats
-- **test_framework**: framework, version, test_pattern, conventions
-- **assets**: implementation_summary[], existing_test[], source_code[] with priorities
-- **focus_areas**: Test generation guidance based on coverage gaps
-
-## Quality Validation
-Before completion verify:
-- [ ] Valid JSON format with all required fields
-- [ ] Source session context loaded successfully
-- [ ] Test coverage gaps identified
-- [ ] Test framework detected (or marked as 'unknown')
-- [ ] Coverage percentage calculated correctly
-- [ ] Missing tests catalogued with priority
-- [ ] Execution time < 30 seconds (< 60s for large codebases)
-
-Execute autonomously following agent documentation.
-Report completion with coverage statistics.
-`
-)
-```
-
-### Step 3: Output Verification
-
-After agent completes, verify output:
-
-```javascript
-// Verify file was created
-const outputPath = `.workflow/${test_session_id}/.process/test-context-package.json`;
-if (!file_exists(outputPath)) {
-  throw new Error("❌ Agent failed to generate test-context-package.json");
-}
-
-// Load and display summary
-const testContext = Read(outputPath);
-console.log("✅ Test context package generated successfully");
-console.log("📊 Coverage:", testContext.test_coverage.coverage_stats.coverage_percentage + "%");
-console.log("⚠️  Tests to generate:", testContext.test_coverage.missing_tests.length);
-```
-
-## Parameter Reference
-
-| Parameter | Type | Required | Description |
-|-----------|------|----------|-------------|
-| `--session` | string | ✅ | Test workflow session ID (e.g., WFS-test-auth) |
-
-## Output Schema
-
-Refer to `test-context-search-agent.md` Phase 3.2 for complete `test-context-package.json` schema.
-
-**Key Sections**:
-- **metadata**: Test session info, source session reference, complexity
-- **source_context**: Implementation summaries with changed files and tech stack
-- **test_coverage**: Existing tests, missing tests with priorities, coverage statistics
-- **test_framework**: Framework name, version, patterns, conventions
-- **assets**: Categorized files with relevance (implementation_summary, existing_test, source_code)
-- **focus_areas**: Test generation guidance based on analysis
-
-## Usage Examples
-
-### Basic Usage
-```bash
-/workflow:tools:test-context-gather --session WFS-test-auth
-```
-
-### Expected Output
-```
-✅ Valid test-context-package found for session: WFS-test-auth
-📊 Coverage Stats: { total: 3, with_tests: 2, without_tests: 1, percentage: 66.7 }
-🧪 Framework: jest
-⚠️  Missing Tests: 1
-```
-
-## Success Criteria
-
-- ✅ Valid test-context-package.json generated in `.workflow/active/{test_session_id}/.process/`
-- ✅ Source session context loaded successfully
-- ✅ Test coverage gaps identified (>90% accuracy)
-- ✅ Test framework detected and documented
-- ✅ Execution completes within 30 seconds (60s for large codebases)
-- ✅ All required schema fields present and valid
-- ✅ Coverage statistics calculated correctly
-- ✅ Agent reports completion with statistics
-
-## Error Handling
-
-| Error | Cause | Resolution |
-|-------|-------|------------|
-| Package validation failed | Invalid test_session_id in existing package | Re-run agent to regenerate |
-| Source session not found | Invalid source_session reference | Verify test session metadata |
-| No implementation summaries | Source session incomplete | Complete source session first |
-| Agent execution timeout | Large codebase or slow analysis | Increase timeout, check file access |
-| Missing required fields | Agent incomplete execution | Check agent logs, verify schema compliance |
-| No test framework detected | Missing test dependencies | Agent marks as 'unknown', manual specification needed |
-
-## Integration
-
-### Called By
-- `/workflow:test-gen` (Phase 3: Context Gathering)
-
-### Calls
-- `test-context-search-agent` - Autonomous test coverage analysis
-
-### Followed By
-- `/workflow:tools:test-concept-enhanced` - Test generation analysis and planning
-
-## Notes
-
-- **Detection-first**: Always check for existing test-context-package before invoking agent
-
-- **No redundancy**: This command is a thin orchestrator, all logic in agent
-- **Framework agnostic**: Supports Jest, Mocha, pytest, RSpec, Go testing, etc.
-- **Coverage focus**: Primary goal is identifying implementation files without tests
-