Claude-Code-Workflow/.codex/prompts/issue-discover-by-prompt.md

description, argument-hint

description	argument-hint
Discover issues from user prompt with iterative multi-agent exploration and cross-module comparison	<prompt> [--scope=src/**] [--depth=standard|deep] [--max-iterations=5]

Issue Discovery by Prompt (Codex Version)

Goal

Prompt-driven issue discovery with intelligent planning. Instead of fixed perspectives, this command:

1. Analyzes user intent to understand what to find
2. Plans exploration strategy dynamically based on codebase structure
3. Executes iterative exploration with feedback loops
4. Performs cross-module comparison when detecting comparison intent

Core Difference from issue-discover.md:

• issue-discover: Pre-defined perspectives (bug, security, etc.), parallel execution
• issue-discover-by-prompt: User-driven prompt, planned strategy, iterative exploration

Inputs

• Prompt: Natural language description of what to find
• Scope: --scope=src/** - File pattern to explore (default: **/*)
• Depth: --depth=standard|deep - standard (3 iterations) or deep (5+ iterations)
• Max Iterations: --max-iterations=N (default: 5)

Output Requirements

Generate Files:

1. .workflow/issues/discoveries/{discovery-id}/discovery-state.json - Session state with iteration tracking
2. .workflow/issues/discoveries/{discovery-id}/iterations/{N}/{dimension}.json - Per-iteration findings
3. .workflow/issues/discoveries/{discovery-id}/comparison-analysis.json - Cross-dimension comparison (if applicable)
4. .workflow/issues/discoveries/{discovery-id}/discovery-issues.jsonl - Generated issue candidates

Return Summary:

{
  "discovery_id": "DBP-YYYYMMDD-HHmmss",
  "prompt": "Check if frontend API calls match backend implementations",
  "intent_type": "comparison",
  "dimensions": ["frontend-calls", "backend-handlers"],
  "total_iterations": 3,
  "total_findings": 24,
  "issues_generated": 12,
  "comparison_match_rate": 0.75
}

Workflow

Step 1: Initialize Discovery Session

# Generate discovery ID
DISCOVERY_ID="DBP-$(date -u +%Y%m%d-%H%M%S)"
OUTPUT_DIR=".workflow/issues/discoveries/${DISCOVERY_ID}"

# Create directory structure
mkdir -p "${OUTPUT_DIR}/iterations"

Detect intent type from prompt:

• comparison: Contains "match", "compare", "versus", "vs", "between"
• search: Contains "find", "locate", "where"
• verification: Contains "verify", "check", "ensure"
• audit: Contains "audit", "review", "analyze"

Step 2: Gather Context

Use rg and file exploration to understand codebase structure:

# Find relevant modules based on prompt keywords
rg -l "<keyword1>" --type ts | head -10
rg -l "<keyword2>" --type ts | head -10

# Understand project structure
ls -la src/
cat .workflow/project-tech.json 2>/dev/null || echo "No project-tech.json"

Build context package:

{
  "prompt_keywords": ["frontend", "API", "backend"],
  "codebase_structure": { "modules": [...], "patterns": [...] },
  "relevant_modules": ["src/api/", "src/services/"]
}

Step 3: Plan Exploration Strategy

Analyze the prompt and context to design exploration strategy.

Output exploration plan:

{
  "intent_analysis": {
    "type": "comparison",
    "primary_question": "Do frontend API calls match backend implementations?",
    "sub_questions": ["Are endpoints aligned?", "Are payloads compatible?"]
  },
  "dimensions": [
    {
      "name": "frontend-calls",
      "description": "Client-side API calls and error handling",
      "search_targets": ["src/api/**", "src/hooks/**"],
      "focus_areas": ["fetch calls", "error boundaries", "response parsing"]
    },
    {
      "name": "backend-handlers",
      "description": "Server-side API implementations",
      "search_targets": ["src/server/**", "src/routes/**"],
      "focus_areas": ["endpoint handlers", "response schemas", "error responses"]
    }
  ],
  "comparison_matrix": {
    "dimension_a": "frontend-calls",
    "dimension_b": "backend-handlers",
    "comparison_points": [
      {"aspect": "endpoints", "frontend_check": "fetch URLs", "backend_check": "route paths"},
      {"aspect": "methods", "frontend_check": "HTTP methods used", "backend_check": "methods accepted"},
      {"aspect": "payloads", "frontend_check": "request body structure", "backend_check": "expected schema"},
      {"aspect": "responses", "frontend_check": "response parsing", "backend_check": "response format"}
    ]
  },
  "estimated_iterations": 3,
  "termination_conditions": ["All comparison points verified", "No new findings in last iteration"]
}

Step 4: Iterative Exploration

Execute iterations until termination conditions are met:

WHILE iteration < max_iterations AND shouldContinue:
  1. Plan iteration focus based on previous findings
  2. Explore each dimension
  3. Collect and analyze findings
  4. Cross-reference between dimensions
  5. Check convergence

For each iteration:

1. Search for relevant code using rg:

# Based on dimension focus areas
rg "fetch\s*\(" --type ts -C 3 | head -50
rg "app\.(get|post|put|delete)" --type ts -C 3 | head -50

2. Analyze and record findings:

{
  "dimension": "frontend-calls",
  "iteration": 1,
  "findings": [
    {
      "id": "F-001",
      "title": "Undefined endpoint in UserService",
      "category": "endpoint-mismatch",
      "file": "src/api/userService.ts",
      "line": 42,
      "snippet": "fetch('/api/users/profile')",
      "related_dimension": "backend-handlers",
      "confidence": 0.85
    }
  ],
  "coverage": {
    "files_explored": 15,
    "areas_covered": ["fetch calls", "axios instances"],
    "areas_remaining": ["graphql queries"]
  },
  "leads": [
    {"description": "Check GraphQL mutations", "suggested_search": "mutation.*User"}
  ]
}

3. Cross-reference findings between dimensions:

// For each finding in dimension A, look for related code in dimension B
if (finding.related_dimension) {
  searchForRelatedCode(finding, otherDimension);
}

4. Check convergence:

const convergence = {
  newDiscoveries: newFindings.length,
  confidence: calculateConfidence(cumulativeFindings),
  converged: newFindings.length === 0 || confidence > 0.9
};

Step 5: Cross-Analysis (for comparison intent)

If intent is comparison, analyze findings across dimensions:

for (const point of comparisonMatrix.comparison_points) {
  const aFindings = findings.filter(f => 
    f.related_dimension === dimension_a && f.category.includes(point.aspect)
  );
  const bFindings = findings.filter(f =>
    f.related_dimension === dimension_b && f.category.includes(point.aspect)
  );
  
  // Find discrepancies
  const discrepancies = compareFindings(aFindings, bFindings, point);
  
  // Calculate match rate
  const matchRate = calculateMatchRate(aFindings, bFindings);
}

Write to comparison-analysis.json:

{
  "matrix": { "dimension_a": "...", "dimension_b": "...", "comparison_points": [...] },
  "results": [
    {
      "aspect": "endpoints",
      "dimension_a_count": 15,
      "dimension_b_count": 12,
      "discrepancies": [
        {"frontend": "/api/users/profile", "backend": "NOT_FOUND", "type": "missing_endpoint"}
      ],
      "match_rate": 0.80
    }
  ],
  "summary": {
    "total_discrepancies": 5,
    "overall_match_rate": 0.75,
    "critical_mismatches": ["endpoints", "payloads"]
  }
}

Step 6: Generate Issues

Convert high-confidence findings to issues:

# For each finding with confidence >= 0.7 or priority critical/high
echo '{"id":"ISS-DBP-001","title":"Missing backend endpoint for /api/users/profile",...}' >> ${OUTPUT_DIR}/discovery-issues.jsonl

Step 7: Update Final State

{
  "discovery_id": "DBP-...",
  "type": "prompt-driven",
  "prompt": "...",
  "intent_type": "comparison",
  "phase": "complete",
  "created_at": "...",
  "updated_at": "...",
  "iterations": [
    {"number": 1, "findings_count": 10, "new_discoveries": 10, "confidence": 0.6},
    {"number": 2, "findings_count": 18, "new_discoveries": 8, "confidence": 0.75},
    {"number": 3, "findings_count": 24, "new_discoveries": 6, "confidence": 0.85}
  ],
  "results": {
    "total_iterations": 3,
    "total_findings": 24,
    "issues_generated": 12,
    "comparison_match_rate": 0.75
  }
}

Step 8: Output Summary

## Discovery Complete: DBP-...

**Prompt**: Check if frontend API calls match backend implementations
**Intent**: comparison
**Dimensions**: frontend-calls, backend-handlers

### Iteration Summary
| # | Findings | New | Confidence |
|---|----------|-----|------------|
| 1 | 10 | 10 | 60% |
| 2 | 18 | 8 | 75% |
| 3 | 24 | 6 | 85% |

### Comparison Results
- **Overall Match Rate**: 75%
- **Total Discrepancies**: 5
- **Critical Mismatches**: endpoints, payloads

### Issues Generated: 12
- 2 Critical
- 4 High
- 6 Medium

### Next Steps
- `/issue:plan DBP-001,DBP-002,...` to plan solutions
- `ccw view` to review findings in dashboard

Quality Checklist

Before completing, verify:

• Intent type correctly detected from prompt
• Dimensions dynamically generated based on prompt
• Iterations executed until convergence or max limit
• Cross-reference analysis performed (for comparison intent)
• High-confidence findings converted to issues
• Discovery state shows phase: complete

Error Handling

Situation	Action
No relevant code found	Report empty result, suggest broader scope
Max iterations without convergence	Complete with current findings, note in summary
Comparison dimension mismatch	Report which dimension has fewer findings
No comparison points matched	Report as "No direct matches found"

Use Cases

Scenario	Example Prompt
API Contract	"Check if frontend calls match backend endpoints"
Error Handling	"Find inconsistent error handling patterns"
Migration Gap	"Compare old auth with new auth implementation"
Feature Parity	"Verify mobile has all web features"
Schema Drift	"Check if TypeScript types match API responses"
Integration	"Find mismatches between service A and service B"

Start Discovery

Parse prompt and detect intent:

PROMPT="${1}"
SCOPE="${2:-**/*}"
DEPTH="${3:-standard}"

# Detect intent keywords
if echo "${PROMPT}" | grep -qiE '(match|compare|versus|vs|between)'; then
  INTENT="comparison"
elif echo "${PROMPT}" | grep -qiE '(find|locate|where)'; then
  INTENT="search"
elif echo "${PROMPT}" | grep -qiE '(verify|check|ensure)'; then
  INTENT="verification"
else
  INTENT="audit"
fi

echo "Intent detected: ${INTENT}"
echo "Starting discovery with scope: ${SCOPE}"

Then follow the workflow to explore and discover issues.