mirror of
https://github.com/catlog22/Claude-Code-Workflow.git
synced 2026-02-10 02:24:35 +08:00
Add JSON schemas for deep-dive results and dimension analysis
- Introduced `review-deep-dive-results-schema.json` to define the structure for deep-dive iteration analysis results, including root cause analysis, remediation plans, and impact assessments. - Added `review-dimension-results-schema.json` to outline the schema for dimension analysis results, capturing findings across various dimensions such as security and architecture, along with cross-references to related findings.
This commit is contained in:
catlog22
@@ -1,87 +0,0 @@
|
||||
---
|
||||
name: analyze
|
||||
description: Read-only codebase analysis using Gemini (default), Qwen, or Codex with auto-pattern detection and template selection
|
||||
argument-hint: "[--tool codex|gemini|qwen] [--enhance] analysis target"
|
||||
allowed-tools: SlashCommand(*), Bash(*), TodoWrite(*), Read(*), Glob(*), Task(*)
|
||||
---
|
||||
|
||||
# CLI Analyze Command (/cli:analyze)
|
||||
|
||||
## Purpose
|
||||
|
||||
Quick codebase analysis using CLI tools. **Read-only - does NOT modify code**.
|
||||
|
||||
**Tool Selection**:
|
||||
- **gemini** (default) - Best for code analysis
|
||||
- **qwen** - Fallback when Gemini unavailable
|
||||
- **codex** - Alternative for deep analysis
|
||||
|
||||
## Parameters
|
||||
|
||||
- `--tool <gemini|qwen|codex>` - Tool selection (default: gemini)
|
||||
- `--enhance` - Use `/enhance-prompt` for context-aware enhancement
|
||||
- `<analysis-target>` - Description of what to analyze
|
||||
|
||||
## Tool Usage
|
||||
|
||||
**Gemini** (Primary):
|
||||
```bash
|
||||
--tool gemini # or omit (default)
|
||||
```
|
||||
|
||||
**Qwen** (Fallback):
|
||||
```bash
|
||||
--tool qwen
|
||||
```
|
||||
|
||||
**Codex** (Alternative):
|
||||
```bash
|
||||
--tool codex
|
||||
```
|
||||
|
||||
## Execution Flow
|
||||
|
||||
Uses **cli-execution-agent** (default) for automated analysis:
|
||||
|
||||
```javascript
|
||||
Task(
|
||||
subagent_type="cli-execution-agent",
|
||||
description="Codebase analysis with pattern detection",
|
||||
prompt=`
|
||||
Task: ${analysis_target}
|
||||
Mode: analyze
|
||||
Tool: ${tool_flag || 'gemini'}
|
||||
Enhance: ${enhance_flag}
|
||||
|
||||
Execute codebase analysis with auto-pattern detection:
|
||||
|
||||
1. Context Discovery:
|
||||
- Extract keywords from analysis target
|
||||
- Auto-detect file patterns (auth→auth files, component→components, etc.)
|
||||
- Discover additional relevant files using MCP
|
||||
- Build comprehensive file context
|
||||
|
||||
2. Template Selection:
|
||||
- Auto-select analysis template based on keywords
|
||||
- Apply appropriate analysis methodology
|
||||
- Include @CLAUDE.md for project context
|
||||
|
||||
3. CLI Command Construction:
|
||||
- Tool: ${tool_flag || 'gemini'} (qwen fallback, codex for deep analysis)
|
||||
- Context: @CLAUDE.md + auto-detected patterns + discovered files
|
||||
- Mode: analysis (read-only)
|
||||
- Expected: Insights, recommendations, pattern analysis
|
||||
|
||||
4. Execution & Output:
|
||||
- Execute CLI tool with assembled context
|
||||
- Generate comprehensive analysis report
|
||||
- Save to .workflow/active/WFS-[id]/.chat/analyze-[timestamp].md (or .scratchpad/)
|
||||
`
|
||||
)
|
||||
```
|
||||
|
||||
## Core Rules
|
||||
|
||||
- **Read-only**: Analyzes code, does NOT modify files
|
||||
- **Auto-pattern**: Detects file patterns from keywords (auth→auth files, component→components, API→api/routes, test→test files)
|
||||
- **Output**: `.workflow/active/WFS-[id]/.chat/analyze-[timestamp].md` (or `.scratchpad/` if no session)
|
||||
@@ -1,82 +0,0 @@
|
||||
---
|
||||
name: chat
|
||||
description: Read-only Q&A interaction with Gemini/Qwen/Codex for codebase questions with automatic context inference
|
||||
argument-hint: "[--tool codex|gemini|qwen] [--enhance] inquiry"
|
||||
allowed-tools: SlashCommand(*), Bash(*), Task(*)
|
||||
---
|
||||
|
||||
# CLI Chat Command (/cli:chat)
|
||||
|
||||
## Purpose
|
||||
|
||||
Direct Q&A interaction with CLI tools for codebase analysis. **Read-only - does NOT modify code**.
|
||||
|
||||
**Tool Selection**:
|
||||
- **gemini** (default) - Best for Q&A and explanations
|
||||
- **qwen** - Fallback when Gemini unavailable
|
||||
- **codex** - Alternative for technical deep-dives
|
||||
|
||||
## Parameters
|
||||
|
||||
- `--tool <gemini|qwen|codex>` - Tool selection (default: gemini)
|
||||
- `--enhance` - Enhance inquiry with `/enhance-prompt`
|
||||
- `<inquiry>` (Required) - Question or analysis request
|
||||
|
||||
## Tool Usage
|
||||
|
||||
**Gemini** (Primary):
|
||||
```bash
|
||||
--tool gemini # or omit (default)
|
||||
```
|
||||
|
||||
**Qwen** (Fallback):
|
||||
```bash
|
||||
--tool qwen
|
||||
```
|
||||
|
||||
**Codex** (Alternative):
|
||||
```bash
|
||||
--tool codex
|
||||
```
|
||||
|
||||
## Execution Flow
|
||||
|
||||
Uses **cli-execution-agent** (default) for automated Q&A:
|
||||
|
||||
```javascript
|
||||
Task(
|
||||
subagent_type="cli-execution-agent",
|
||||
description="Codebase Q&A with intelligent context discovery",
|
||||
prompt=`
|
||||
Task: ${inquiry}
|
||||
Mode: chat
|
||||
Tool: ${tool_flag || 'gemini'}
|
||||
Enhance: ${enhance_flag}
|
||||
|
||||
Execute codebase Q&A with intelligent context discovery:
|
||||
|
||||
1. Context Discovery:
|
||||
- Parse inquiry to identify relevant topics/keywords
|
||||
- Discover related files using MCP/ripgrep (prioritize precision)
|
||||
- Include @CLAUDE.md + discovered files
|
||||
- Validate context relevance to question
|
||||
|
||||
2. CLI Command Construction:
|
||||
- Tool: ${tool_flag || 'gemini'} (qwen fallback, codex for deep dives)
|
||||
- Context: @CLAUDE.md + discovered file patterns
|
||||
- Mode: analysis (read-only)
|
||||
- Expected: Clear, accurate answer with code references
|
||||
|
||||
3. Execution & Output:
|
||||
- Execute CLI tool with assembled context
|
||||
- Validate answer completeness
|
||||
- Save to .workflow/active/WFS-[id]/.chat/chat-[timestamp].md (or .scratchpad/)
|
||||
`
|
||||
)
|
||||
```
|
||||
|
||||
## Core Rules
|
||||
|
||||
- **Read-only**: Provides answers, does NOT modify code
|
||||
- **Context**: `@CLAUDE.md` + inferred or all files (`@**/*`)
|
||||
- **Output**: `.workflow/active/WFS-[id]/.chat/chat-[timestamp].md` (or `.scratchpad/` if no session)
|
||||
@@ -1,519 +0,0 @@
|
||||
---
|
||||
name: codex-execute
|
||||
description: Multi-stage Codex execution with automatic task decomposition into grouped subtasks using resume mechanism for context continuity
|
||||
argument-hint: "[--verify-git] task description or task-id"
|
||||
allowed-tools: SlashCommand(*), Bash(*), TodoWrite(*), Read(*), Glob(*)
|
||||
---
|
||||
|
||||
# CLI Codex Execute Command (/cli:codex-execute)
|
||||
|
||||
## Purpose
|
||||
|
||||
Automated task decomposition and sequential execution with Codex, using `codex exec "..." resume --last` mechanism for continuity between subtasks.
|
||||
|
||||
**Input**: User description or task ID (automatically loads from `.task/[ID].json` if applicable)
|
||||
|
||||
## Core Workflow
|
||||
|
||||
```
|
||||
Task Input → Analyze Dependencies → Create Task Flow Diagram →
|
||||
Decompose into Subtask Groups → TodoWrite Tracking →
|
||||
For Each Subtask Group:
|
||||
For First Subtask in Group:
|
||||
0. Stage existing changes (git add -A) if valid git repo
|
||||
1. Execute with Codex (new session)
|
||||
2. [Optional] Git verification
|
||||
3. Mark complete in TodoWrite
|
||||
For Related Subtasks in Same Group:
|
||||
0. Stage changes from previous subtask
|
||||
1. Execute with `codex exec "..." resume --last` (continue session)
|
||||
2. [Optional] Git verification
|
||||
3. Mark complete in TodoWrite
|
||||
→ Final Summary
|
||||
```
|
||||
|
||||
## Parameters
|
||||
|
||||
- `<input>` (Required): Task description or task ID (e.g., "implement auth" or "IMPL-001")
|
||||
- If input matches task ID format, loads from `.task/[ID].json`
|
||||
- Otherwise, uses input as task description
|
||||
- `--verify-git` (Optional): Verify git status after each subtask completion
|
||||
|
||||
## Execution Flow
|
||||
|
||||
### Phase 1: Input Processing & Task Flow Analysis
|
||||
|
||||
1. **Parse Input**:
|
||||
- Check if input matches task ID pattern (e.g., `IMPL-001`, `TASK-123`)
|
||||
- If yes: Load from `.task/[ID].json` and extract requirements
|
||||
- If no: Use input as task description directly
|
||||
|
||||
2. **Analyze Dependencies & Create Task Flow Diagram**:
|
||||
- Analyze task complexity and scope
|
||||
- Identify dependencies and relationships between subtasks
|
||||
- Create visual task flow diagram showing:
|
||||
- Independent task groups (parallel execution possible)
|
||||
- Sequential dependencies (must use resume)
|
||||
- Branching logic (conditional paths)
|
||||
- Display flow diagram for user review
|
||||
|
||||
**Task Flow Diagram Format**:
|
||||
```
|
||||
[Group A: Auth Core]
|
||||
A1: Create user model ──┐
|
||||
A2: Add validation ─┤─► [resume] ─► A3: Database schema
|
||||
│
|
||||
[Group B: API Layer] │
|
||||
B1: Auth endpoints ─────┘─► [new session]
|
||||
B2: Middleware ────────────► [resume] ─► B3: Error handling
|
||||
|
||||
[Group C: Testing]
|
||||
C1: Unit tests ─────────────► [new session]
|
||||
C2: Integration tests ──────► [resume]
|
||||
```
|
||||
|
||||
**Diagram Symbols**:
|
||||
- `──►` Sequential dependency (must resume previous session)
|
||||
- `─┐` Branch point (multiple paths)
|
||||
- `─┘` Merge point (wait for completion)
|
||||
- `[resume]` Use `codex exec "..." resume --last`
|
||||
- `[new session]` Start fresh Codex session
|
||||
|
||||
3. **Decompose into Subtask Groups**:
|
||||
- Group related subtasks that share context
|
||||
- Break down into 3-8 subtasks total
|
||||
- Assign each subtask to a group
|
||||
- Create TodoWrite tracker with groups
|
||||
- Display decomposition for user review
|
||||
|
||||
**Decomposition Criteria**:
|
||||
- Each subtask: 5-15 minutes completable
|
||||
- Clear, testable outcomes
|
||||
- Explicit dependencies
|
||||
- Focused file scope (1-5 files per subtask)
|
||||
- **Group coherence**: Subtasks in same group share context/files
|
||||
|
||||
### File Discovery for Task Decomposition
|
||||
|
||||
Use `rg` or MCP tools to discover relevant files, then group by domain:
|
||||
|
||||
**Workflow**: Discover → Analyze scope → Group by files → Create task flow
|
||||
|
||||
**Example**:
|
||||
```bash
|
||||
# Discover files
|
||||
rg "authentication" --files-with-matches --type ts
|
||||
|
||||
# Group by domain
|
||||
# Group A: src/auth/model.ts, src/auth/schema.ts
|
||||
# Group B: src/api/auth.ts, src/middleware/auth.ts
|
||||
# Group C: tests/auth/*.test.ts
|
||||
|
||||
# Each group becomes a session with related subtasks
|
||||
```
|
||||
|
||||
File patterns: see intelligent-tools-strategy.md (loaded in memory)
|
||||
|
||||
### Phase 2: Group-Based Execution
|
||||
|
||||
**Pre-Execution Git Staging** (if valid git repository):
|
||||
```bash
|
||||
# Stage all current changes before codex execution
|
||||
# This makes codex changes clearly visible in git diff
|
||||
git add -A
|
||||
git status --short
|
||||
```
|
||||
|
||||
**For First Subtask in Each Group** (New Session):
|
||||
```bash
|
||||
# Start new Codex session for independent task group
|
||||
codex -C [dir] --full-auto exec "
|
||||
PURPOSE: [group goal]
|
||||
TASK: [subtask description - first in group]
|
||||
CONTEXT: @{relevant_files} @CLAUDE.md
|
||||
EXPECTED: [specific deliverables]
|
||||
RULES: [constraints]
|
||||
Group [X]: [group name] - Subtask 1 of N in this group
|
||||
" --skip-git-repo-check -s danger-full-access
|
||||
```
|
||||
|
||||
**For Related Subtasks in Same Group** (Resume Session):
|
||||
```bash
|
||||
# Stage changes from previous subtask (if valid git repository)
|
||||
git add -A
|
||||
|
||||
# Resume session ONLY for subtasks in same group
|
||||
codex exec "
|
||||
CONTINUE IN SAME GROUP:
|
||||
Group [X]: [group name] - Subtask N of M
|
||||
|
||||
PURPOSE: [continuation goal within group]
|
||||
TASK: [subtask N description]
|
||||
CONTEXT: Previous work in this group completed, now focus on @{new_relevant_files}
|
||||
EXPECTED: [specific deliverables]
|
||||
RULES: Build on previous subtask in group, maintain consistency
|
||||
" resume --last --skip-git-repo-check -s danger-full-access
|
||||
```
|
||||
|
||||
**For First Subtask in Different Group** (New Session):
|
||||
```bash
|
||||
# Stage changes from previous group
|
||||
git add -A
|
||||
|
||||
# Start NEW session for different group (no resume)
|
||||
codex -C [dir] --full-auto exec "
|
||||
PURPOSE: [new group goal]
|
||||
TASK: [subtask description - first in new group]
|
||||
CONTEXT: @{different_files} @CLAUDE.md
|
||||
EXPECTED: [specific deliverables]
|
||||
RULES: [constraints]
|
||||
Group [Y]: [new group name] - Subtask 1 of N in this group
|
||||
" --skip-git-repo-check -s danger-full-access
|
||||
```
|
||||
|
||||
**Resume Decision Logic**:
|
||||
```
|
||||
if (subtask.group == previous_subtask.group):
|
||||
use `codex exec "..." resume --last` # Continue session
|
||||
else:
|
||||
use `codex -C [dir] exec "..."` # New session
|
||||
```
|
||||
|
||||
### Phase 3: Verification (if --verify-git enabled)
|
||||
|
||||
After each subtask completion:
|
||||
```bash
|
||||
# Check git status
|
||||
git status --short
|
||||
|
||||
# Verify expected changes
|
||||
git diff --stat
|
||||
|
||||
# Optional: Check for untracked files that should be committed
|
||||
git ls-files --others --exclude-standard
|
||||
```
|
||||
|
||||
**Verification Checks**:
|
||||
- Files modified match subtask scope
|
||||
- No unexpected changes in unrelated files
|
||||
- No merge conflicts or errors
|
||||
- Code compiles/runs (if applicable)
|
||||
|
||||
### Phase 4: TodoWrite Tracking with Groups
|
||||
|
||||
**Initial Setup with Task Flow**:
|
||||
```javascript
|
||||
TodoWrite({
|
||||
todos: [
|
||||
// Display task flow diagram first
|
||||
{ content: "Task Flow Analysis Complete - See diagram above", status: "completed", activeForm: "Analyzing task flow" },
|
||||
|
||||
// Group A subtasks (will use resume within group)
|
||||
{ content: "[Group A] Subtask 1: [description]", status: "in_progress", activeForm: "Executing Group A subtask 1" },
|
||||
{ content: "[Group A] Subtask 2: [description] [resume]", status: "pending", activeForm: "Executing Group A subtask 2" },
|
||||
|
||||
// Group B subtasks (new session, then resume within group)
|
||||
{ content: "[Group B] Subtask 1: [description] [new session]", status: "pending", activeForm: "Executing Group B subtask 1" },
|
||||
{ content: "[Group B] Subtask 2: [description] [resume]", status: "pending", activeForm: "Executing Group B subtask 2" },
|
||||
|
||||
// Group C subtasks (new session)
|
||||
{ content: "[Group C] Subtask 1: [description] [new session]", status: "pending", activeForm: "Executing Group C subtask 1" },
|
||||
|
||||
{ content: "Final verification and summary", status: "pending", activeForm: "Verifying and summarizing" }
|
||||
]
|
||||
})
|
||||
```
|
||||
|
||||
**After Each Subtask**:
|
||||
```javascript
|
||||
TodoWrite({
|
||||
todos: [
|
||||
{ content: "Task Flow Analysis Complete - See diagram above", status: "completed", activeForm: "Analyzing task flow" },
|
||||
{ content: "[Group A] Subtask 1: [description]", status: "completed", activeForm: "Executing Group A subtask 1" },
|
||||
{ content: "[Group A] Subtask 2: [description] [resume]", status: "in_progress", activeForm: "Executing Group A subtask 2" },
|
||||
// ... update status
|
||||
]
|
||||
})
|
||||
```
|
||||
|
||||
## Codex Resume Mechanism
|
||||
|
||||
**Why Group-Based Resume?**
|
||||
- **Within Group**: Maintains conversation context for related subtasks
|
||||
- Codex remembers previous decisions and patterns
|
||||
- Reduces context repetition
|
||||
- Ensures consistency in implementation style
|
||||
- **Between Groups**: Fresh session for independent tasks
|
||||
- Avoids context pollution from unrelated work
|
||||
- Prevents confusion when switching domains
|
||||
- Maintains focused attention on current group
|
||||
|
||||
**How It Works**:
|
||||
1. **First subtask in Group A**: Creates new Codex session
|
||||
2. **Subsequent subtasks in Group A**: Use `codex resume --last` to continue session
|
||||
3. **First subtask in Group B**: Creates NEW Codex session (no resume)
|
||||
4. **Subsequent subtasks in Group B**: Use `codex resume --last` within Group B
|
||||
5. Each group builds on its own context, isolated from other groups
|
||||
|
||||
**When to Resume vs New Session**:
|
||||
```
|
||||
RESUME (same group):
|
||||
- Subtasks share files/modules
|
||||
- Logical continuation of previous work
|
||||
- Same architectural domain
|
||||
|
||||
NEW SESSION (different group):
|
||||
- Independent task area
|
||||
- Different files/modules
|
||||
- Switching architectural domains
|
||||
- Testing after implementation
|
||||
```
|
||||
|
||||
**Image Support**:
|
||||
```bash
|
||||
# First subtask with design reference
|
||||
codex -C [dir] -i design.png --full-auto exec "..." --skip-git-repo-check -s danger-full-access
|
||||
|
||||
# Resume for next subtask (image context preserved)
|
||||
codex exec "CONTINUE TO NEXT SUBTASK: ..." resume --last --skip-git-repo-check -s danger-full-access
|
||||
```
|
||||
|
||||
## Error Handling
|
||||
|
||||
**Subtask Failure**:
|
||||
1. Mark subtask as blocked in TodoWrite
|
||||
2. Report error details to user
|
||||
3. Pause execution for manual intervention
|
||||
4. Use AskUserQuestion for recovery decision:
|
||||
|
||||
```typescript
|
||||
AskUserQuestion({
|
||||
questions: [{
|
||||
question: "Codex execution failed for the subtask. How should the workflow proceed?",
|
||||
header: "Recovery",
|
||||
options: [
|
||||
{ label: "Retry Subtask", description: "Attempt to execute the same subtask again." },
|
||||
{ label: "Skip Subtask", description: "Continue to the next subtask in the plan." },
|
||||
{ label: "Abort Workflow", description: "Stop the entire execution." }
|
||||
],
|
||||
multiSelect: false
|
||||
}]
|
||||
})
|
||||
```
|
||||
|
||||
**Git Verification Failure** (if --verify-git):
|
||||
1. Show unexpected changes
|
||||
2. Pause execution
|
||||
3. Request user decision:
|
||||
- Continue anyway
|
||||
- Rollback and retry
|
||||
- Manual fix
|
||||
|
||||
**Codex Session Lost**:
|
||||
1. Detect if `codex exec "..." resume --last` fails
|
||||
2. Attempt retry with fresh session
|
||||
3. Report to user if manual intervention needed
|
||||
|
||||
## Output Format
|
||||
|
||||
**During Execution**:
|
||||
```
|
||||
Task Flow Diagram:
|
||||
[Group A: Auth Core]
|
||||
A1: Create user model ──┐
|
||||
A2: Add validation ─┤─► [resume] ─► A3: Database schema
|
||||
│
|
||||
[Group B: API Layer] │
|
||||
B1: Auth endpoints ─────┘─► [new session]
|
||||
B2: Middleware ────────────► [resume] ─► B3: Error handling
|
||||
|
||||
[Group C: Testing]
|
||||
C1: Unit tests ─────────────► [new session]
|
||||
C2: Integration tests ──────► [resume]
|
||||
|
||||
Task Decomposition:
|
||||
[Group A] 1. Create user model
|
||||
[Group A] 2. Add validation logic [resume]
|
||||
[Group A] 3. Implement database schema [resume]
|
||||
[Group B] 4. Create auth endpoints [new session]
|
||||
[Group B] 5. Add middleware [resume]
|
||||
[Group B] 6. Error handling [resume]
|
||||
[Group C] 7. Unit tests [new session]
|
||||
[Group C] 8. Integration tests [resume]
|
||||
|
||||
[Group A] Executing Subtask 1/8: Create user model
|
||||
Starting new Codex session for Group A...
|
||||
[Codex output]
|
||||
Subtask 1 completed
|
||||
|
||||
Git Verification:
|
||||
M src/models/user.ts
|
||||
Changes verified
|
||||
|
||||
[Group A] Executing Subtask 2/8: Add validation logic
|
||||
Resuming Codex session (same group)...
|
||||
[Codex output]
|
||||
Subtask 2 completed
|
||||
|
||||
[Group B] Executing Subtask 4/8: Create auth endpoints
|
||||
Starting NEW Codex session for Group B...
|
||||
[Codex output]
|
||||
Subtask 4 completed
|
||||
...
|
||||
|
||||
All Subtasks Completed
|
||||
Summary: [file references, changes, next steps]
|
||||
```
|
||||
|
||||
**Final Summary**:
|
||||
```markdown
|
||||
# Task Execution Summary: [Task Description]
|
||||
|
||||
## Subtasks Completed
|
||||
1. [Subtask 1]: [files modified]
|
||||
2. [Subtask 2]: [files modified]
|
||||
...
|
||||
|
||||
## Files Modified
|
||||
- src/file1.ts:10-50 - [changes]
|
||||
- src/file2.ts - [changes]
|
||||
|
||||
## Git Status
|
||||
- N files modified
|
||||
- M files added
|
||||
- No conflicts
|
||||
|
||||
## Next Steps
|
||||
- [Suggested follow-up actions]
|
||||
```
|
||||
|
||||
## Examples
|
||||
|
||||
**Example 1: Simple Task with Groups**
|
||||
```bash
|
||||
/cli:codex-execute "implement user authentication system"
|
||||
|
||||
# Task Flow Diagram:
|
||||
# [Group A: Data Layer]
|
||||
# A1: Create user model ──► [resume] ──► A2: Database schema
|
||||
#
|
||||
# [Group B: Auth Logic]
|
||||
# B1: JWT token generation ──► [new session]
|
||||
# B2: Authentication middleware ──► [resume]
|
||||
#
|
||||
# [Group C: API Endpoints]
|
||||
# C1: Login/logout endpoints ──► [new session]
|
||||
#
|
||||
# [Group D: Testing]
|
||||
# D1: Unit tests ──► [new session]
|
||||
# D2: Integration tests ──► [resume]
|
||||
|
||||
# Execution:
|
||||
# Group A: A1 (new) → A2 (resume)
|
||||
# Group B: B1 (new) → B2 (resume)
|
||||
# Group C: C1 (new)
|
||||
# Group D: D1 (new) → D2 (resume)
|
||||
```
|
||||
|
||||
**Example 2: With Git Verification**
|
||||
```bash
|
||||
/cli:codex-execute --verify-git "refactor API layer to use dependency injection"
|
||||
|
||||
# After each subtask, verifies:
|
||||
# - Only expected files modified
|
||||
# - No breaking changes in unrelated code
|
||||
# - Tests still pass
|
||||
```
|
||||
|
||||
**Example 3: With Task ID**
|
||||
```bash
|
||||
/cli:codex-execute IMPL-001
|
||||
|
||||
# Loads task from .task/IMPL-001.json
|
||||
# Decomposes based on task requirements
|
||||
```
|
||||
|
||||
## Best Practices
|
||||
|
||||
1. **Task Flow First**: Always create visual flow diagram before execution
|
||||
2. **Group Related Work**: Cluster subtasks by domain/files for efficient resume
|
||||
3. **Subtask Granularity**: Keep subtasks small and focused (5-15 min each)
|
||||
4. **Clear Boundaries**: Each subtask should have well-defined input/output
|
||||
5. **Git Hygiene**: Use `--verify-git` for critical refactoring
|
||||
6. **Pre-Execution Staging**: Stage changes before each subtask to clearly see codex modifications
|
||||
7. **Smart Resume**: Use `resume --last` ONLY within same group
|
||||
8. **Fresh Sessions**: Start new session when switching to different group/domain
|
||||
9. **Recovery Points**: TodoWrite with group labels provides clear progress tracking
|
||||
10. **Image References**: Attach design files for UI tasks (first subtask in group)
|
||||
|
||||
## Input Processing
|
||||
|
||||
**Automatic Detection**:
|
||||
- Input matches task ID pattern → Load from `.task/[ID].json`
|
||||
- Otherwise → Use as task description
|
||||
|
||||
**Task JSON Structure** (when loading from file):
|
||||
```json
|
||||
{
|
||||
"task_id": "IMPL-001",
|
||||
"title": "Implement user authentication",
|
||||
"description": "Create JWT-based auth system",
|
||||
"acceptance_criteria": [...],
|
||||
"scope": {...},
|
||||
"brainstorming_refs": [...]
|
||||
}
|
||||
```
|
||||
|
||||
## Output Routing
|
||||
|
||||
**Execution Log Destination**:
|
||||
- **IF** active workflow session exists:
|
||||
- Execution log: `.workflow/active/WFS-[id]/.chat/codex-execute-[timestamp].md`
|
||||
- Task summaries: `.workflow/active/WFS-[id]/.summaries/[TASK-ID]-summary.md` (if task ID)
|
||||
- Task updates: `.workflow/active/WFS-[id]/.task/[TASK-ID].json` status updates
|
||||
- TodoWrite tracking: Embedded in execution log
|
||||
- **ELSE** (no active session):
|
||||
- **Recommended**: Create workflow session first (`/workflow:session:start`)
|
||||
- **Alternative**: Save to `.workflow/.scratchpad/codex-execute-[description]-[timestamp].md`
|
||||
|
||||
**Output Files** (during execution):
|
||||
```
|
||||
.workflow/active/WFS-[session-id]/
|
||||
├── .chat/
|
||||
│ └── codex-execute-20250105-143022.md # Full execution log with task flow
|
||||
├── .summaries/
|
||||
│ ├── IMPL-001.1-summary.md # Subtask summaries
|
||||
│ ├── IMPL-001.2-summary.md
|
||||
│ └── IMPL-001-summary.md # Final task summary
|
||||
└── .task/
|
||||
├── IMPL-001.json # Updated task status
|
||||
└── [subtask JSONs if decomposed]
|
||||
```
|
||||
|
||||
**Examples**:
|
||||
- During session `WFS-auth-system`, executing multi-stage auth implementation:
|
||||
- Log: `.workflow/active/WFS-auth-system/.chat/codex-execute-20250105-143022.md`
|
||||
- Summaries: `.workflow/active/WFS-auth-system/.summaries/IMPL-001.{1,2,3}-summary.md`
|
||||
- Task status: `.workflow/active/WFS-auth-system/.task/IMPL-001.json` (status: completed)
|
||||
- No session, ad-hoc multi-stage task:
|
||||
- Log: `.workflow/.scratchpad/codex-execute-auth-refactor-20250105-143045.md`
|
||||
|
||||
**Save Results**:
|
||||
- Execution log with task flow diagram and TodoWrite tracking
|
||||
- Individual summaries for each completed subtask
|
||||
- Final consolidated summary when all subtasks complete
|
||||
- Modified code files throughout project
|
||||
|
||||
## Notes
|
||||
|
||||
**vs. `/cli:execute`**:
|
||||
- `/cli:execute`: Single-shot execution with Gemini/Qwen/Codex
|
||||
- `/cli:codex-execute`: Multi-stage Codex execution with automatic task decomposition and resume mechanism
|
||||
|
||||
**Input Flexibility**: Accepts both freeform descriptions and task IDs (auto-detects and loads JSON)
|
||||
|
||||
**Context Window**: `codex exec "..." resume --last` maintains conversation history, ensuring consistency across subtasks without redundant context injection.
|
||||
|
||||
**Output Details**:
|
||||
- Session management: see intelligent-tools-strategy.md
|
||||
- **⚠️ Code Modification**: This command performs multi-stage code modifications - execution log tracks all changes
|
||||
@@ -1,320 +0,0 @@
|
||||
---
|
||||
name: discuss-plan
|
||||
description: Multi-round collaborative planning using Gemini, Codex, and Claude synthesis with iterative discussion cycles (read-only, no code changes)
|
||||
argument-hint: "[--topic '...'] [--task-id '...'] [--rounds N]"
|
||||
allowed-tools: SlashCommand(*), Bash(*), TodoWrite(*), Read(*), Glob(*)
|
||||
---
|
||||
|
||||
# CLI Discuss-Plan Command (/cli:discuss-plan)
|
||||
|
||||
## Purpose
|
||||
|
||||
Orchestrates a multi-model collaborative discussion for in-depth planning and problem analysis. This command facilitates an iterative dialogue between Gemini, Codex, and Claude (the orchestrating AI) to explore a topic from multiple perspectives, refine ideas, and build a robust plan.
|
||||
|
||||
**This command is for discussion and planning ONLY. It does NOT modify any code.**
|
||||
|
||||
## Core Workflow: The Discussion Loop
|
||||
|
||||
The command operates in iterative rounds, allowing the plan to evolve with each cycle. The user can choose to continue for more rounds or conclude when consensus is reached.
|
||||
|
||||
```
|
||||
Topic Input → [Round 1: Gemini → Codex → Claude] → [User Review] →
|
||||
[Round 2: Gemini → Codex → Claude] → ... → Final Plan
|
||||
```
|
||||
|
||||
### Model Roles & Priority
|
||||
|
||||
**Priority Order**: Gemini > Codex > Claude
|
||||
|
||||
1. **Gemini (The Analyst)** - Priority 1
|
||||
- Kicks off each round with deep analysis
|
||||
- Provides foundational ideas and draft plans
|
||||
- Analyzes current context or previous synthesis
|
||||
|
||||
2. **Codex (The Architect/Critic)** - Priority 2
|
||||
- Reviews Gemini's output critically
|
||||
- Uses deep reasoning for technical trade-offs
|
||||
- Proposes alternative strategies
|
||||
- **Participates purely in conversational/reasoning capacity**
|
||||
- Uses resume mechanism to maintain discussion context
|
||||
|
||||
3. **Claude (The Synthesizer/Moderator)** - Priority 3
|
||||
- Synthesizes discussion from Gemini and Codex
|
||||
- Highlights agreements and contentions
|
||||
- Structures refined plan
|
||||
- Poses key questions for next round
|
||||
|
||||
## Parameters
|
||||
|
||||
- `<input>` (Required): Topic description or task ID (e.g., "Design a new caching layer" or `PLAN-002`)
|
||||
- `--rounds <N>` (Optional): Maximum number of discussion rounds (default: prompts after each round)
|
||||
- `--task-id <id>` (Optional): Associates discussion with workflow task ID
|
||||
- `--topic <description>` (Optional): High-level topic for discussion
|
||||
|
||||
## Execution Flow
|
||||
|
||||
### Phase 1: Initial Setup
|
||||
|
||||
1. **Input Processing**: Parse topic or task ID
|
||||
2. **Context Gathering**: Identify relevant files based on topic
|
||||
|
||||
### Phase 2: Discussion Round
|
||||
|
||||
Each round consists of three sequential steps, tracked via `TodoWrite`.
|
||||
|
||||
**Step 1: Gemini's Analysis (Priority 1)**
|
||||
|
||||
Gemini analyzes the topic and proposes preliminary plan.
|
||||
|
||||
```bash
|
||||
# Round 1: CONTEXT_INPUT is the initial topic
|
||||
# Subsequent rounds: CONTEXT_INPUT is the synthesis from previous round
|
||||
gemini -p "
|
||||
PURPOSE: Analyze and propose a plan for '[topic]'
|
||||
TASK: Provide initial analysis, identify key modules, and draft implementation plan
|
||||
MODE: analysis
|
||||
CONTEXT: @CLAUDE.md [auto-detected files]
|
||||
INPUT: [CONTEXT_INPUT]
|
||||
EXPECTED: Structured analysis and draft plan for discussion
|
||||
RULES: Focus on technical depth and practical considerations
|
||||
"
|
||||
```
|
||||
|
||||
**Step 2: Codex's Critique (Priority 2)**
|
||||
|
||||
Codex reviews Gemini's output using conversational reasoning. Uses `resume --last` to maintain context across rounds.
|
||||
|
||||
```bash
|
||||
# First round (new session)
|
||||
codex --full-auto exec "
|
||||
PURPOSE: Critically review technical plan
|
||||
TASK: Review the provided plan, identify weaknesses, suggest alternatives, reason about trade-offs
|
||||
MODE: analysis
|
||||
CONTEXT: @CLAUDE.md [relevant files]
|
||||
INPUT_PLAN: [Output from Gemini's analysis]
|
||||
EXPECTED: Critical review with alternative ideas and risk analysis
|
||||
RULES: Focus on architectural soundness and implementation feasibility
|
||||
" --skip-git-repo-check
|
||||
|
||||
# Subsequent rounds (resume discussion)
|
||||
codex --full-auto exec "
|
||||
PURPOSE: Re-evaluate plan based on latest synthesis
|
||||
TASK: Review updated plan and discussion points, provide further critique or refined ideas
|
||||
MODE: analysis
|
||||
CONTEXT: Previous discussion context (maintained via resume)
|
||||
INPUT_PLAN: [Output from Gemini's analysis for current round]
|
||||
EXPECTED: Updated critique building on previous discussion
|
||||
RULES: Build on previous insights, avoid repeating points
|
||||
" resume --last --skip-git-repo-check
|
||||
```
|
||||
|
||||
**Step 3: Claude's Synthesis (Priority 3)**
|
||||
|
||||
Claude (orchestrating AI) synthesizes both outputs:
|
||||
|
||||
- Summarizes Gemini's proposal and Codex's critique
|
||||
- Highlights agreements and disagreements
|
||||
- Structures consolidated plan
|
||||
- Presents open questions for next round
|
||||
- This synthesis becomes input for next round
|
||||
|
||||
### Phase 3: User Review and Iteration
|
||||
|
||||
1. **Present Synthesis**: Show synthesized plan and key discussion points
|
||||
2. **Continue or Conclude**: Use AskUserQuestion to prompt user:
|
||||
|
||||
```typescript
|
||||
AskUserQuestion({
|
||||
questions: [{
|
||||
question: "Round of discussion complete. What is the next step?",
|
||||
header: "Next Round",
|
||||
options: [
|
||||
{ label: "Start another round", description: "Continue the discussion to refine the plan further." },
|
||||
{ label: "Conclude and finalize", description: "End the discussion and save the final plan." }
|
||||
],
|
||||
multiSelect: false
|
||||
}]
|
||||
})
|
||||
```
|
||||
|
||||
3. **Loop or Finalize**:
|
||||
- Continue → New round with Gemini analyzing latest synthesis
|
||||
- Conclude → Save final synthesized document
|
||||
|
||||
## TodoWrite Tracking
|
||||
|
||||
Progress tracked for each round and model.
|
||||
|
||||
```javascript
|
||||
// Example for 2-round discussion
|
||||
TodoWrite({
|
||||
todos: [
|
||||
// Round 1
|
||||
{ content: "[Round 1] Gemini: Analyzing topic", status: "completed", activeForm: "Analyzing with Gemini" },
|
||||
{ content: "[Round 1] Codex: Critiquing plan", status: "completed", activeForm: "Critiquing with Codex" },
|
||||
{ content: "[Round 1] Claude: Synthesizing discussion", status: "completed", activeForm: "Synthesizing discussion" },
|
||||
{ content: "[User Action] Review Round 1 and decide next step", status: "in_progress", activeForm: "Awaiting user decision" },
|
||||
|
||||
// Round 2
|
||||
{ content: "[Round 2] Gemini: Analyzing refined plan", status: "pending", activeForm: "Analyzing refined plan" },
|
||||
{ content: "[Round 2] Codex: Re-evaluating plan [resume]", status: "pending", activeForm: "Re-evaluating with Codex" },
|
||||
{ content: "[Round 2] Claude: Finalizing plan", status: "pending", activeForm: "Finalizing plan" },
|
||||
{ content: "Discussion complete - Final plan generated", status: "pending", activeForm: "Generating final document" }
|
||||
]
|
||||
})
|
||||
```
|
||||
|
||||
## Output Routing
|
||||
|
||||
- **Primary Log**: Entire multi-round discussion logged to single file:
|
||||
- `.workflow/active/WFS-[id]/.chat/discuss-plan-[topic]-[timestamp].md`
|
||||
- **Final Plan**: Clean final version saved upon conclusion:
|
||||
- `.workflow/active/WFS-[id]/.summaries/plan-[topic].md`
|
||||
- **Scratchpad**: If no session active:
|
||||
- `.workflow/.scratchpad/discuss-plan-[topic]-[timestamp].md`
|
||||
|
||||
## Discussion Structure
|
||||
|
||||
Each round's output is structured as:
|
||||
|
||||
```markdown
|
||||
## Round N: [Topic]
|
||||
|
||||
### Gemini's Analysis (Priority 1)
|
||||
[Gemini's full analysis and proposal]
|
||||
|
||||
### Codex's Critique (Priority 2)
|
||||
[Codex's critical review and alternatives]
|
||||
|
||||
### Claude's Synthesis (Priority 3)
|
||||
**Points of Agreement:**
|
||||
- [Agreement 1]
|
||||
- [Agreement 2]
|
||||
|
||||
**Points of Contention:**
|
||||
- [Issue 1]: Gemini suggests X, Codex suggests Y
|
||||
- [Issue 2]: Trade-off between A and B
|
||||
|
||||
**Consolidated Plan:**
|
||||
[Structured plan incorporating both perspectives]
|
||||
|
||||
**Open Questions for Next Round:**
|
||||
1. [Question 1]
|
||||
2. [Question 2]
|
||||
```
|
||||
|
||||
## Examples
|
||||
|
||||
### Example 1: Multi-Round Architecture Discussion
|
||||
|
||||
**Command**: `/cli:discuss-plan --topic "Design a real-time notification system"`
|
||||
|
||||
**Round 1**:
|
||||
1. **Gemini**: Proposes WebSocket-based architecture with RabbitMQ message queue
|
||||
2. **Codex**: Critiques as overly complex for MVP. Suggests Server-Sent Events (SSE) for simplicity (one-way notifications). Questions RabbitMQ necessity, proposes simpler Redis Pub/Sub
|
||||
3. **Claude**: Synthesizes views:
|
||||
- **Plan A (Gemini)**: WebSockets + RabbitMQ (highly scalable, complex)
|
||||
- **Plan B (Codex)**: SSE + Redis (simpler, less overhead)
|
||||
- **Open Question**: Is bi-directional communication critical, or is simplicity priority?
|
||||
4. **User Action**: Opts for another round to explore trade-offs
|
||||
|
||||
**Round 2**:
|
||||
1. **Gemini**: Analyzes synthesized document. Notes that if features like "user is typing" indicators are roadmapped, WebSockets better long-term. Drafts plan starting with SSE/Redis but designing for easy migration
|
||||
2. **Codex**: Reviews migration plan. Reasons that migration itself could be complex. If feature set likely to expand, starting with WebSockets using managed service might be best cost/benefit
|
||||
3. **Claude**: Synthesizes new discussion:
|
||||
- **Consensus**: Simple SSE/Redis too short-sighted
|
||||
- **Refined Options**:
|
||||
1. Phased approach (SSE → WebSocket) with clear migration plan
|
||||
2. Direct WebSocket with managed service (Pusher, Ably) to reduce ops overhead
|
||||
- **Recommendation**: Option 2 most robust and future-proof
|
||||
4. **User Action**: Agrees with recommendation, concludes discussion
|
||||
|
||||
**Final Output**: Planning document saved with:
|
||||
- Chosen architecture (Managed WebSocket service)
|
||||
- Multi-round reasoning
|
||||
- High-level implementation steps
|
||||
|
||||
### Example 2: Feature Design Discussion
|
||||
|
||||
**Command**: `/cli:discuss-plan --topic "Design user permission system" --rounds 2`
|
||||
|
||||
**Round 1**:
|
||||
1. **Gemini**: Proposes RBAC (Role-Based Access Control) with predefined roles
|
||||
2. **Codex**: Suggests ABAC (Attribute-Based Access Control) for more flexibility
|
||||
3. **Claude**: Synthesizes trade-offs between simplicity (RBAC) vs flexibility (ABAC)
|
||||
|
||||
**Round 2**:
|
||||
1. **Gemini**: Analyzes hybrid approach - RBAC for core permissions, attributes for fine-grained control
|
||||
2. **Codex**: Reviews hybrid model, identifies implementation challenges
|
||||
3. **Claude**: Final plan with phased rollout strategy
|
||||
|
||||
**Automatic Conclusion**: Command concludes after 2 rounds as specified
|
||||
|
||||
### Example 3: Problem-Solving Discussion
|
||||
|
||||
**Command**: `/cli:discuss-plan --topic "Debug memory leak in data pipeline" --task-id ISSUE-042`
|
||||
|
||||
**Round 1**:
|
||||
1. **Gemini**: Identifies potential leak sources (unclosed handles, growing cache, event listeners)
|
||||
2. **Codex**: Adds profiling tool recommendations, suggests memory monitoring
|
||||
3. **Claude**: Structures debugging plan with phased approach
|
||||
|
||||
**User Decision**: Single round sufficient, concludes with debugging strategy
|
||||
|
||||
## Consensus Mechanisms
|
||||
|
||||
**When to Continue:**
|
||||
- Significant disagreement between models
|
||||
- Open questions requiring deeper analysis
|
||||
- Trade-offs need more exploration
|
||||
- User wants additional perspectives
|
||||
|
||||
**When to Conclude:**
|
||||
- Models converge on solution
|
||||
- All key questions addressed
|
||||
- User satisfied with plan depth
|
||||
- Maximum rounds reached (if specified)
|
||||
|
||||
## Comparison with Other Commands
|
||||
|
||||
| Command | Models | Rounds | Discussion | Implementation | Use Case |
|
||||
|---------|--------|--------|------------|----------------|----------|
|
||||
| `/cli:mode:plan` | Gemini | 1 | NO | NO | Single-model planning |
|
||||
| `/cli:analyze` | Gemini/Qwen | 1 | NO | NO | Code analysis |
|
||||
| `/cli:execute` | Any | 1 | NO | YES | Direct implementation |
|
||||
| `/cli:codex-execute` | Codex | 1 | NO | YES | Multi-stage implementation |
|
||||
| `/cli:discuss-plan` | **Gemini+Codex+Claude** | **Multiple** | **YES** | **NO** | **Multi-perspective planning** |
|
||||
|
||||
## Best Practices
|
||||
|
||||
1. **Use for Complex Decisions**: Ideal for architectural decisions, design trade-offs, problem-solving
|
||||
2. **Start with Broad Topic**: Let first round establish scope, subsequent rounds refine
|
||||
3. **Review Each Synthesis**: Claude's synthesis is key decision point - review carefully
|
||||
4. **Know When to Stop**: Don't over-iterate - 2-3 rounds usually sufficient
|
||||
5. **Task Association**: Use `--task-id` for traceability in workflow
|
||||
6. **Save Intermediate Results**: Each round's synthesis saved automatically
|
||||
7. **Let Models Disagree**: Divergent views often reveal important trade-offs
|
||||
8. **Focus Questions**: Use Claude's open questions to guide next round
|
||||
|
||||
## Breaking Discussion Loops
|
||||
|
||||
**Detecting Loops:**
|
||||
- Models repeating same arguments
|
||||
- No new insights emerging
|
||||
- Trade-offs well understood
|
||||
|
||||
**Breaking Strategies:**
|
||||
1. **User Decision**: Make executive decision when enough info gathered
|
||||
2. **Timeboxing**: Set max rounds upfront with `--rounds`
|
||||
3. **Criteria-Based**: Define decision criteria before starting
|
||||
4. **Hybrid Approach**: Accept multiple valid solutions in final plan
|
||||
|
||||
## Notes
|
||||
|
||||
- **Pure Discussion**: This command NEVER modifies code - only produces planning documents
|
||||
- **Codex Role**: Codex participates as reasoning/critique tool, not executor
|
||||
- **Resume Context**: Codex maintains discussion context via `resume --last`
|
||||
- **Priority System**: Ensures Gemini leads analysis, Codex provides critique, Claude synthesizes
|
||||
- **Output Quality**: Multi-perspective discussion produces more robust plans than single-model analysis
|
||||
- Command patterns and session management: see intelligent-tools-strategy.md (loaded in memory)
|
||||
- For implementation after discussion, use `/cli:execute` or `/cli:codex-execute` separately
|
||||
@@ -1,202 +0,0 @@
|
||||
---
|
||||
name: execute
|
||||
description: Autonomous code implementation with YOLO auto-approval using Gemini/Qwen/Codex, supports task ID or description input with automatic file pattern detection
|
||||
argument-hint: "[--tool codex|gemini|qwen] [--enhance] description or task-id"
|
||||
allowed-tools: SlashCommand(*), Bash(*), Task(*)
|
||||
---
|
||||
|
||||
# CLI Execute Command (/cli:execute)
|
||||
|
||||
## Purpose
|
||||
|
||||
Execute implementation tasks with **YOLO permissions** (auto-approves all confirmations). **MODIFIES CODE**.
|
||||
|
||||
**Intent**: Autonomous code implementation, modification, and generation
|
||||
**Supported Tools**: codex, gemini (default), qwen
|
||||
**Key Feature**: Automatic context inference and file pattern detection
|
||||
|
||||
## Core Behavior
|
||||
|
||||
1. **Code Modification**: This command MODIFIES, CREATES, and DELETES code files
|
||||
2. **Auto-Approval**: YOLO mode bypasses confirmation prompts for all operations
|
||||
3. **Implementation Focus**: Executes actual code changes, not just recommendations
|
||||
4. **Requires Explicit Intent**: Use only when implementation is intended
|
||||
|
||||
## Core Concepts
|
||||
|
||||
### YOLO Permissions
|
||||
Auto-approves: file pattern inference, execution, **file modifications**, summary generation
|
||||
|
||||
**WARNING**: This command will make actual code changes without manual confirmation
|
||||
|
||||
### Execution Modes
|
||||
|
||||
**1. Description Mode** (supports `--enhance`):
|
||||
- Input: Natural language description
|
||||
- Process: [Optional: Enhance] → Keyword analysis → Pattern inference → Execute
|
||||
|
||||
**2. Task ID Mode** (no `--enhance`):
|
||||
- Input: Workflow task identifier (e.g., `IMPL-001`)
|
||||
- Process: Task JSON parsing → Scope analysis → Execute
|
||||
|
||||
**3. Agent Mode** (default):
|
||||
- Input: Description or task-id
|
||||
- Process: 5-Phase Workflow → Context Discovery → Optimal Tool Selection → Execute
|
||||
|
||||
### Context Inference
|
||||
|
||||
Auto-selects files based on keywords and technology (each @ references one pattern):
|
||||
- "auth" → `@**/*auth* @**/*user*`
|
||||
- "React" → `@src/**/*.jsx @src/**/*.tsx`
|
||||
- "api" → `@**/api/**/* @**/routes/**/*`
|
||||
- Always includes: `@CLAUDE.md @**/*CLAUDE.md`
|
||||
|
||||
For precise file targeting, use `rg` or MCP tools to discover files first.
|
||||
|
||||
### Codex Session Continuity
|
||||
|
||||
**Resume Pattern** for related tasks:
|
||||
```bash
|
||||
# First task - establish session
|
||||
codex -C [dir] --full-auto exec "[task]" --skip-git-repo-check -s danger-full-access
|
||||
|
||||
# Related task - continue session
|
||||
codex --full-auto exec "[related-task]" resume --last --skip-git-repo-check -s danger-full-access
|
||||
```
|
||||
|
||||
Use `resume --last` when current task extends/relates to previous execution. See intelligent-tools-strategy.md for auto-resume rules.
|
||||
|
||||
## Parameters
|
||||
|
||||
- `--tool <codex|gemini|qwen>` - Select CLI tool (default: auto-select by agent based on complexity)
|
||||
- `--enhance` - Enhance input with `/enhance-prompt` first (Description Mode only)
|
||||
- `<description|task-id>` - Natural language description or task identifier
|
||||
- `--debug` - Verbose logging
|
||||
- `--save-session` - Save execution to workflow session
|
||||
|
||||
## Workflow Integration
|
||||
|
||||
**Session Management**: Auto-detects active session from `.workflow/active/` directory
|
||||
- Active session: Save to `.workflow/active/WFS-[id]/.chat/execute-[timestamp].md`
|
||||
- No session: Create new session or save to scratchpad
|
||||
|
||||
**Task Integration**: Load from `.task/[TASK-ID].json`, update status, generate summary
|
||||
|
||||
## Execution Flow
|
||||
|
||||
Uses **cli-execution-agent** (default) for automated implementation:
|
||||
|
||||
```javascript
|
||||
Task(
|
||||
subagent_type="cli-execution-agent",
|
||||
description="Autonomous code implementation with YOLO auto-approval",
|
||||
prompt=`
|
||||
Task: ${description_or_task_id}
|
||||
Mode: execute
|
||||
Tool: ${tool_flag || 'auto-select'}
|
||||
Enhance: ${enhance_flag}
|
||||
Task-ID: ${task_id}
|
||||
|
||||
Execute autonomous code implementation with full modification permissions:
|
||||
|
||||
1. Task Analysis:
|
||||
${task_id ? '- Load task spec from .task/' + task_id + '.json' : ''}
|
||||
- Parse requirements and implementation scope
|
||||
- Classify complexity (simple/medium/complex)
|
||||
- Extract keywords for context discovery
|
||||
|
||||
2. Context Discovery:
|
||||
- Discover implementation files using MCP/ripgrep
|
||||
- Identify existing patterns and conventions (CLAUDE.md)
|
||||
- Map dependencies and integration points
|
||||
- Gather related tests and documentation
|
||||
- Auto-detect file patterns from keywords
|
||||
|
||||
3. Tool Selection & Execution:
|
||||
- Complexity assessment:
|
||||
* Simple/Medium → Gemini/Qwen (MODE=write, --approval-mode yolo)
|
||||
* Complex → Codex (MODE=auto, --skip-git-repo-check -s danger-full-access)
|
||||
- Tool preference: ${tool_flag || 'auto-select based on complexity'}
|
||||
- Apply appropriate implementation template
|
||||
- Execute with YOLO auto-approval (bypasses all confirmations)
|
||||
|
||||
4. Implementation:
|
||||
- Modify/create/delete code files per requirements
|
||||
- Follow existing code patterns and conventions
|
||||
- Include comprehensive context in CLI command
|
||||
- Ensure working implementation with proper error handling
|
||||
|
||||
5. Output & Documentation:
|
||||
- Save execution log: .workflow/active/WFS-[id]/.chat/execute-[timestamp].md
|
||||
${task_id ? '- Generate task summary: .workflow/active/WFS-[id]/.summaries/' + task_id + '-summary.md' : ''}
|
||||
${task_id ? '- Update task status in .task/' + task_id + '.json' : ''}
|
||||
- Document all code changes made
|
||||
|
||||
⚠️ YOLO Mode: All file operations auto-approved without confirmation
|
||||
`
|
||||
)
|
||||
```
|
||||
|
||||
**Output**: `.workflow/active/WFS-[id]/.chat/execute-[timestamp].md` + `.workflow/active/WFS-[id]/.summaries/[TASK-ID]-summary.md` (or `.scratchpad/` if no session)
|
||||
|
||||
## Examples
|
||||
|
||||
**Basic Implementation** (modifies code):
|
||||
```bash
|
||||
/cli:execute "implement JWT authentication with middleware"
|
||||
# Agent Phase 1: Classifies intent=execute, complexity=medium, keywords=['jwt', 'auth', 'middleware']
|
||||
# Agent Phase 2: Discovers auth patterns, existing middleware structure
|
||||
# Agent Phase 3: Selects Gemini (medium complexity)
|
||||
# Agent Phase 4: Executes with auto-approval
|
||||
# Result: NEW/MODIFIED code files with JWT implementation
|
||||
```
|
||||
|
||||
**Complex Implementation** (modifies code):
|
||||
```bash
|
||||
/cli:execute "implement OAuth2 authentication with token refresh"
|
||||
# Agent Phase 1: Classifies intent=execute, complexity=complex, keywords=['oauth2', 'auth', 'token', 'refresh']
|
||||
# Agent Phase 2: MCP discovers auth patterns, existing middleware, JWT dependencies
|
||||
# Agent Phase 3: Enhances prompt with discovered patterns and best practices
|
||||
# Agent Phase 4: Selects Codex (complex task), executes with comprehensive context
|
||||
# Agent Phase 5: Saves execution log + generates implementation summary
|
||||
# Result: Complete OAuth2 implementation + detailed execution log
|
||||
```
|
||||
|
||||
**Enhanced Implementation** (modifies code):
|
||||
```bash
|
||||
/cli:execute --enhance "implement JWT authentication"
|
||||
# Step 1: Enhance to expand requirements
|
||||
# Step 2: Execute implementation with auto-approval
|
||||
# Result: Complete auth system with MODIFIED code files
|
||||
```
|
||||
|
||||
**Task Execution** (modifies code):
|
||||
```bash
|
||||
/cli:execute IMPL-001
|
||||
# Reads: .task/IMPL-001.json for requirements
|
||||
# Executes: Implementation based on task spec
|
||||
# Result: Code changes per task definition
|
||||
```
|
||||
|
||||
**Codex Implementation** (modifies code):
|
||||
```bash
|
||||
/cli:execute --tool codex "optimize database queries"
|
||||
# Executes: Codex with full file access
|
||||
# Result: MODIFIED query code, new indexes, updated tests
|
||||
```
|
||||
|
||||
**Qwen Code Generation** (modifies code):
|
||||
```bash
|
||||
/cli:execute --tool qwen --enhance "refactor auth module"
|
||||
# Step 1: Enhanced refactoring plan
|
||||
# Step 2: Execute with MODE=write
|
||||
# Result: REFACTORED auth code with structural changes
|
||||
```
|
||||
|
||||
## Comparison with Analysis Commands
|
||||
|
||||
| Command | Intent | Code Changes | Auto-Approve |
|
||||
|---------|--------|--------------|--------------|
|
||||
| `/cli:analyze` | Understand code | NO | N/A |
|
||||
| `/cli:chat` | Ask questions | NO | N/A |
|
||||
| `/cli:execute` | **Implement** | **YES** | **YES** |
|
||||
@@ -1,96 +0,0 @@
|
||||
---
|
||||
name: bug-diagnosis
|
||||
description: Read-only bug root cause analysis using Gemini/Qwen/Codex with systematic diagnosis template for fix suggestions
|
||||
argument-hint: "[--tool codex|gemini|qwen] [--enhance] [--cd path] bug description"
|
||||
allowed-tools: SlashCommand(*), Bash(*), Task(*)
|
||||
---
|
||||
|
||||
# CLI Mode: Bug Diagnosis (/cli:mode:bug-diagnosis)
|
||||
|
||||
## Purpose
|
||||
|
||||
Systematic bug diagnosis with root cause analysis template (`~/.claude/workflows/cli-templates/prompts/analysis/01-diagnose-bug-root-cause.txt`).
|
||||
|
||||
**Tool Selection**:
|
||||
- **gemini** (default) - Best for bug diagnosis
|
||||
- **qwen** - Fallback when Gemini unavailable
|
||||
- **codex** - Alternative for complex bug analysis
|
||||
|
||||
## Parameters
|
||||
|
||||
- `--tool <gemini|qwen|codex>` - Tool selection (default: gemini)
|
||||
- `--enhance` - Enhance bug description with `/enhance-prompt`
|
||||
- `--cd "path"` - Target directory for focused diagnosis
|
||||
- `<bug-description>` (Required) - Bug description or error details
|
||||
|
||||
## Tool Usage
|
||||
|
||||
**Gemini** (Primary):
|
||||
```bash
|
||||
# Uses gemini by default, or specify explicitly
|
||||
--tool gemini
|
||||
```
|
||||
|
||||
**Qwen** (Fallback):
|
||||
```bash
|
||||
--tool qwen
|
||||
```
|
||||
|
||||
**Codex** (Alternative):
|
||||
```bash
|
||||
--tool codex
|
||||
```
|
||||
|
||||
## Execution Flow
|
||||
|
||||
Uses **cli-execution-agent** (default) for automated bug diagnosis:
|
||||
|
||||
```javascript
|
||||
Task(
|
||||
subagent_type="cli-execution-agent",
|
||||
description="Bug root cause diagnosis with fix suggestions",
|
||||
prompt=`
|
||||
Task: ${bug_description}
|
||||
Mode: bug-diagnosis
|
||||
Tool: ${tool_flag || 'gemini'}
|
||||
Directory: ${cd_path || '.'}
|
||||
Enhance: ${enhance_flag}
|
||||
Template: ~/.claude/workflows/cli-templates/prompts/analysis/01-diagnose-bug-root-cause.txt
|
||||
|
||||
Execute systematic bug diagnosis and root cause analysis:
|
||||
|
||||
1. Context Discovery:
|
||||
- Locate error traces, stack traces, and log messages
|
||||
- Find related code sections and affected modules
|
||||
- Identify data flow paths leading to the bug
|
||||
- Discover test cases related to bug area
|
||||
- Use MCP/ripgrep for comprehensive context gathering
|
||||
|
||||
2. Root Cause Analysis:
|
||||
- Apply diagnostic template methodology
|
||||
- Trace execution to identify failure point
|
||||
- Analyze state, data, and logic causing issue
|
||||
- Document potential root causes with evidence
|
||||
- Assess bug severity and impact scope
|
||||
|
||||
3. CLI Command Construction:
|
||||
- Tool: ${tool_flag || 'gemini'} (qwen fallback, codex for complex bugs)
|
||||
- Directory: cd ${cd_path || '.'} &&
|
||||
- Context: @**/* + error traces + affected code
|
||||
- Mode: analysis (read-only)
|
||||
- Template: analysis/01-diagnose-bug-root-cause.txt
|
||||
|
||||
4. Output Generation:
|
||||
- Root cause diagnosis with evidence
|
||||
- Fix suggestions and recommendations
|
||||
- Prevention strategies
|
||||
- Save to .workflow/active/WFS-[id]/.chat/bug-diagnosis-[timestamp].md (or .scratchpad/)
|
||||
`
|
||||
)
|
||||
```
|
||||
|
||||
## Core Rules
|
||||
|
||||
- **Read-only**: Diagnoses bugs, does NOT modify code
|
||||
- **Template**: `~/.claude/workflows/cli-templates/prompts/analysis/01-diagnose-bug-root-cause.txt`
|
||||
- **Output**: `.workflow/active/WFS-[id]/.chat/bug-diagnosis-[timestamp].md` (or `.scratchpad/` if no session)
|
||||
@@ -1,98 +0,0 @@
|
||||
---
|
||||
name: code-analysis
|
||||
description: Read-only execution path tracing using Gemini/Qwen/Codex with specialized analysis template for call flow and optimization
|
||||
argument-hint: "[--tool codex|gemini|qwen] [--enhance] [--cd path] analysis target"
|
||||
allowed-tools: SlashCommand(*), Bash(*), Task(*)
|
||||
---
|
||||
|
||||
# CLI Mode: Code Analysis (/cli:mode:code-analysis)
|
||||
|
||||
## Purpose
|
||||
|
||||
Systematic code analysis with execution path tracing template (`~/.claude/workflows/cli-templates/prompts/analysis/01-trace-code-execution.txt`).
|
||||
|
||||
**Tool Selection**:
|
||||
- **gemini** (default) - Best for code analysis and tracing
|
||||
- **qwen** - Fallback when Gemini unavailable
|
||||
- **codex** - Alternative for complex analysis tasks
|
||||
|
||||
**Key Feature**: `--cd` flag for directory-scoped analysis
|
||||
|
||||
## Parameters
|
||||
|
||||
- `--tool <gemini|qwen|codex>` - Tool selection (default: gemini)
|
||||
- `--enhance` - Enhance analysis target with `/enhance-prompt` first
|
||||
- `--cd "path"` - Target directory for focused analysis
|
||||
- `<analysis-target>` (Required) - Code analysis target or question
|
||||
|
||||
## Tool Usage
|
||||
|
||||
**Gemini** (Primary):
|
||||
```bash
|
||||
/cli:mode:code-analysis --tool gemini "trace auth flow"
|
||||
# OR (default)
|
||||
/cli:mode:code-analysis "trace auth flow"
|
||||
```
|
||||
|
||||
**Qwen** (Fallback):
|
||||
```bash
|
||||
/cli:mode:code-analysis --tool qwen "trace auth flow"
|
||||
```
|
||||
|
||||
**Codex** (Alternative):
|
||||
```bash
|
||||
/cli:mode:code-analysis --tool codex "trace auth flow"
|
||||
```
|
||||
|
||||
## Execution Flow
|
||||
|
||||
Uses **cli-execution-agent** (default) for automated code analysis:
|
||||
|
||||
```javascript
|
||||
Task(
|
||||
subagent_type="cli-execution-agent",
|
||||
description="Execution path tracing and call flow analysis",
|
||||
prompt=`
|
||||
Task: ${analysis_target}
|
||||
Mode: code-analysis
|
||||
Tool: ${tool_flag || 'gemini'}
|
||||
Directory: ${cd_path || '.'}
|
||||
Enhance: ${enhance_flag}
|
||||
Template: ~/.claude/workflows/cli-templates/prompts/analysis/01-trace-code-execution.txt
|
||||
|
||||
Execute systematic code analysis with execution path tracing:
|
||||
|
||||
1. Context Discovery:
|
||||
- Identify entry points and function signatures
|
||||
- Trace call chains and execution flows
|
||||
- Discover related files (implementations, dependencies, tests)
|
||||
- Map data flow and state transformations
|
||||
- Use MCP/ripgrep for comprehensive file discovery
|
||||
|
||||
2. Analysis Execution:
|
||||
- Apply execution tracing template
|
||||
- Generate call flow diagrams (textual)
|
||||
- Document execution paths and branching logic
|
||||
- Identify optimization opportunities
|
||||
|
||||
3. CLI Command Construction:
|
||||
- Tool: ${tool_flag || 'gemini'} (qwen fallback, codex for complex analysis)
|
||||
- Directory: cd ${cd_path || '.'} &&
|
||||
- Context: @**/* + discovered execution context
|
||||
- Mode: analysis (read-only)
|
||||
- Template: analysis/01-trace-code-execution.txt
|
||||
|
||||
4. Output Generation:
|
||||
- Execution trace documentation
|
||||
- Call flow analysis with diagrams
|
||||
- Performance and optimization insights
|
||||
- Save to .workflow/active/WFS-[id]/.chat/code-analysis-[timestamp].md (or .scratchpad/)
|
||||
`
|
||||
)
|
||||
```
|
||||
|
||||
## Core Rules
|
||||
|
||||
- **Read-only**: Analyzes code, does NOT modify files
|
||||
- **Template**: `~/.claude/workflows/cli-templates/prompts/analysis/01-trace-code-execution.txt`
|
||||
- **Output**: `.workflow/active/WFS-[id]/.chat/code-analysis-[timestamp].md` (or `.scratchpad/` if no session)
|
||||
@@ -1,126 +0,0 @@
|
||||
---
|
||||
name: document-analysis
|
||||
description: Read-only technical document/paper analysis using Gemini/Qwen/Codex with systematic comprehension template for insights extraction
|
||||
argument-hint: "[--tool codex|gemini|qwen] [--enhance] [--cd path] document path or topic"
|
||||
allowed-tools: SlashCommand(*), Bash(*), Task(*), Read(*)
|
||||
---
|
||||
|
||||
# CLI Mode: Document Analysis (/cli:mode:document-analysis)
|
||||
|
||||
## Purpose
|
||||
|
||||
Systematic analysis of technical documents, research papers, API documentation, and technical specifications.
|
||||
|
||||
**Tool Selection**:
|
||||
- **gemini** (default) - Best for document comprehension and structure analysis
|
||||
- **qwen** - Fallback when Gemini unavailable
|
||||
- **codex** - Alternative for complex technical documents
|
||||
|
||||
**Key Feature**: `--cd` flag for directory-scoped document discovery
|
||||
|
||||
## Parameters
|
||||
|
||||
- `--tool <gemini|qwen|codex>` - Tool selection (default: gemini)
|
||||
- `--enhance` - Enhance analysis target with `/enhance-prompt`
|
||||
- `--cd "path"` - Target directory for document search
|
||||
- `<document-path-or-topic>` (Required) - File path or topic description
|
||||
|
||||
## Tool Usage
|
||||
|
||||
**Gemini** (Primary):
|
||||
```bash
|
||||
/cli:mode:document-analysis "README.md"
|
||||
/cli:mode:document-analysis --tool gemini "analyze API documentation"
|
||||
```
|
||||
|
||||
**Qwen** (Fallback):
|
||||
```bash
|
||||
/cli:mode:document-analysis --tool qwen "docs/architecture.md"
|
||||
```
|
||||
|
||||
**Codex** (Alternative):
|
||||
```bash
|
||||
/cli:mode:document-analysis --tool codex "research paper in docs/"
|
||||
```
|
||||
|
||||
## Execution Flow
|
||||
|
||||
Uses **cli-execution-agent** for automated document analysis:
|
||||
|
||||
```javascript
|
||||
Task(
|
||||
subagent_type="cli-execution-agent",
|
||||
description="Systematic document comprehension and insights extraction",
|
||||
prompt=`
|
||||
Task: ${document_path_or_topic}
|
||||
Mode: document-analysis
|
||||
Tool: ${tool_flag || 'gemini'}
|
||||
Directory: ${cd_path || '.'}
|
||||
Enhance: ${enhance_flag}
|
||||
Template: ~/.claude/workflows/cli-templates/prompts/analysis/02-analyze-technical-document.txt
|
||||
|
||||
Execute systematic document analysis:
|
||||
|
||||
1. Document Discovery:
|
||||
- Locate target document(s) via path or topic keywords
|
||||
- Identify document type (README, API docs, research paper, spec, tutorial)
|
||||
- Detect document format (Markdown, PDF, plain text, reStructuredText)
|
||||
- Discover related documents (references, appendices, examples)
|
||||
- Use MCP/ripgrep for comprehensive file discovery
|
||||
|
||||
2. Pre-Analysis Planning (Required):
|
||||
- Determine document structure (sections, hierarchy, flow)
|
||||
- Identify key components (abstract, methodology, implementation details)
|
||||
- Map dependencies and cross-references
|
||||
- Assess document scope and complexity
|
||||
- Plan analysis approach based on document type
|
||||
|
||||
3. CLI Command Construction:
|
||||
- Tool: ${tool_flag || 'gemini'} (qwen fallback, codex for complex docs)
|
||||
- Directory: cd ${cd_path || '.'} &&
|
||||
- Context: @{document_paths} + @CLAUDE.md + related files
|
||||
- Mode: analysis (read-only)
|
||||
- Template: analysis/02-analyze-technical-document.txt
|
||||
|
||||
4. Analysis Execution:
|
||||
- Apply 6-field template structure (PURPOSE, TASK, MODE, CONTEXT, EXPECTED, RULES)
|
||||
- Execute multi-phase analysis protocol with pre-planning
|
||||
- Perform self-critique before final output
|
||||
- Generate structured report with evidence-based insights
|
||||
|
||||
5. Output Generation:
|
||||
- Comprehensive document analysis report
|
||||
- Structured insights with section references
|
||||
- Critical assessment with evidence
|
||||
- Actionable recommendations
|
||||
- Save to .workflow/active/WFS-[id]/.chat/doc-analysis-[timestamp].md (or .scratchpad/)
|
||||
`
|
||||
)
|
||||
```
|
||||
|
||||
## Core Rules
|
||||
|
||||
- **Read-only**: Analyzes documents, does NOT modify files
|
||||
- **Evidence-based**: All claims must reference specific sections/pages
|
||||
- **Pre-planning**: Requires analysis approach planning before execution
|
||||
- **Precise language**: Direct, accurate wording - no persuasive embellishment
|
||||
- **Output**: `.workflow/active/WFS-[id]/.chat/doc-analysis-[timestamp].md` (or `.scratchpad/` if no session)
|
||||
|
||||
## Document Types Supported
|
||||
|
||||
| Type | Focus Areas | Key Outputs |
|
||||
|------|-------------|-------------|
|
||||
| README | Purpose, setup, usage | Integration steps, quick-start guide |
|
||||
| API Documentation | Endpoints, parameters, responses | API usage patterns, integration points |
|
||||
| Research Paper | Methodology, findings, validity | Applicable techniques, implementation feasibility |
|
||||
| Specification | Requirements, standards, constraints | Compliance checklist, implementation requirements |
|
||||
| Tutorial | Learning path, examples, exercises | Key concepts, practical applications |
|
||||
| Architecture Docs | System design, components, patterns | Design decisions, integration points, trade-offs |
|
||||
|
||||
## Best Practices
|
||||
|
||||
1. **Scope Definition**: Clearly define what aspects to analyze before starting
|
||||
2. **Layered Reading**: Structure/Overview → Details → Critical Analysis → Synthesis
|
||||
3. **Evidence Trail**: Track section references for all extracted information
|
||||
4. **Gap Identification**: Note missing information or unclear sections explicitly
|
||||
5. **Actionable Output**: Focus on insights that inform decisions or actions
|
||||
@@ -1,93 +0,0 @@
|
||||
---
|
||||
name: plan
|
||||
description: Read-only architecture planning using Gemini/Qwen/Codex with strategic planning template for modification plans and impact analysis
|
||||
argument-hint: "[--tool codex|gemini|qwen] [--enhance] [--cd path] topic"
|
||||
allowed-tools: SlashCommand(*), Bash(*), Task(*)
|
||||
---
|
||||
|
||||
# CLI Mode: Plan (/cli:mode:plan)
|
||||
|
||||
## Purpose
|
||||
|
||||
Strategic software architecture planning template (`~/.claude/workflows/cli-templates/prompts/planning/01-plan-architecture-design.txt`).
|
||||
|
||||
**Tool Selection**:
|
||||
- **gemini** (default) - Best for architecture planning
|
||||
- **qwen** - Fallback when Gemini unavailable
|
||||
- **codex** - Alternative for implementation planning
|
||||
|
||||
## Parameters
|
||||
|
||||
- `--tool <gemini|qwen|codex>` - Tool selection (default: gemini)
|
||||
- `--enhance` - Enhance task with `/enhance-prompt`
|
||||
- `--cd "path"` - Target directory for focused planning
|
||||
- `<planning-task>` (Required) - Architecture planning task or modification requirements
|
||||
|
||||
## Tool Usage
|
||||
|
||||
**Gemini** (Primary):
|
||||
```bash
|
||||
--tool gemini # or omit (default)
|
||||
```
|
||||
|
||||
**Qwen** (Fallback):
|
||||
```bash
|
||||
--tool qwen
|
||||
```
|
||||
|
||||
**Codex** (Alternative):
|
||||
```bash
|
||||
--tool codex
|
||||
```
|
||||
|
||||
## Execution Flow
|
||||
|
||||
Uses **cli-execution-agent** (default) for automated planning:
|
||||
|
||||
```javascript
|
||||
Task(
|
||||
subagent_type="cli-execution-agent",
|
||||
description="Architecture planning with impact analysis",
|
||||
prompt=`
|
||||
Task: ${planning_task}
|
||||
Mode: plan
|
||||
Tool: ${tool_flag || 'gemini'}
|
||||
Directory: ${cd_path || '.'}
|
||||
Enhance: ${enhance_flag}
|
||||
Template: ~/.claude/workflows/cli-templates/prompts/planning/01-plan-architecture-design.txt
|
||||
|
||||
Execute strategic architecture planning:
|
||||
|
||||
1. Context Discovery:
|
||||
- Analyze current architecture structure
|
||||
- Identify affected components and modules
|
||||
- Map dependencies and integration points
|
||||
- Assess modification impacts (scope, complexity, risks)
|
||||
|
||||
2. Planning Analysis:
|
||||
- Apply strategic planning template
|
||||
- Generate modification plan with phases
|
||||
- Document architectural decisions and rationale
|
||||
- Identify potential conflicts and mitigation strategies
|
||||
|
||||
3. CLI Command Construction:
|
||||
- Tool: ${tool_flag || 'gemini'} (qwen fallback, codex for implementation guidance)
|
||||
- Directory: cd ${cd_path || '.'} &&
|
||||
- Context: @**/* (full architecture context)
|
||||
- Mode: analysis (read-only, no code generation)
|
||||
- Template: planning/01-plan-architecture-design.txt
|
||||
|
||||
4. Output Generation:
|
||||
- Strategic modification plan
|
||||
- Impact analysis and risk assessment
|
||||
- Implementation roadmap
|
||||
- Save to .workflow/active/WFS-[id]/.chat/plan-[timestamp].md (or .scratchpad/)
|
||||
`
|
||||
)
|
||||
```
|
||||
|
||||
## Core Rules
|
||||
|
||||
- **Read-only**: Creates modification plans, does NOT generate code
|
||||
- **Template**: `~/.claude/workflows/cli-templates/prompts/planning/01-plan-architecture-design.txt`
|
||||
- **Output**: `.workflow/active/WFS-[id]/.chat/plan-[timestamp].md` (or `.scratchpad/` if no session)
|
||||
Reference in New Issue
Block a user