Forge Go

Step 1: Memory Recall

Use forge_memory_search to find:

• Existing plan from a prior /forge-in session (parse roles and phases from it)
• Related patterns, decisions, anti-patterns
• Prior progress if this is a continuation

Step 2: Task Analysis

If no /forge-in plan exists, perform inline task analysis:

Cognitive Mode Classification (multiple can apply):

Domain Identification — Free-form strings, not fixed enum:

• Any domain is valid: "react-ui", "quantum-mechanics", "AGI", "rust-compiler", "philosophy"

Depth Assessment (determines model tier for generated roles):

Step 3: Governance Check

Use forge_policy_rules to load active rules (if applicable to task type).

Phase 1: Strategy Selection

QUICK Strategy

When: Simple, well-defined, ≤ 3 subtasks, any cognitive mode

• Simple code fix, config change, quick lookup
• Single-focus research question, brief analysis
• Clear input → clear output

Execution: Skip role generation. Direct execution. Verify. Capture.

STANDARD Strategy

When: Medium complexity, 3-8 subtasks

• Feature implementation, structured research, multi-step analysis
• Paper reading with extraction, moderate design work

Execution: Generate roles → Phase-based execution → Verify → Capture.

LOOP Strategy

When: High complexity, 8+ subtasks, long-running, context-sensitive

• Large refactoring, multi-service changes, deep research projects
• Comprehensive literature reviews, complex system design + implementation

Execution: Full decomposition → Continuous loop with memory checkpoints → Verify → Capture.

Adaptive Escalation

Strategies are NOT permanent — auto-escalate when needed:

Micro-Replan Protocol (avoids full restart):

1. Pause remaining tasks
2. Launch Plan agent (opus): "Original assumed [X]. Discovered [Y]. Revise remaining tasks."
3. Update TaskList with revised tasks
4. Resume execution

Phase 2: Dynamic Role Generation + Execution

For QUICK Strategy

No role generation needed. Execute directly using the appropriate depth model.

For STANDARD / LOOP Strategy

Step 1: Generate Execution Roles

Based on task analysis (or /forge-in plan), generate task-specific roles:

Each role includes:

Role Generation by Cognitive Mode

BUILD mode — Roles from codebase structure (NOT hardcoded frontend/backend):

• Analyze the actual project modules, services, packages
• Generate one role per affected area: "Auth Service Implementer", "Dashboard Component Builder", "Schema Migrator"
• Each role gets file boundary constraints (only modify files in their area)

RESEARCH / COMPARE mode — Specialist + Synthesizer pattern:

• One specialist per research subject
• Final synthesizer that compares, resolves contradictions, produces recommendation

LEARN mode — Reader → Extractor → Applicator:

• Reader: Deep understanding of source material
• Extractor: Pull out actionable insights
• Applicator: Map insights to user's context/codebase

THINK / CREATE mode — Multi-perspective:

• Proposer: Generates the design/solution
• Critic: Attacks weaknesses, finds failure modes
• Integrator: Resolves tensions, produces final recommendation

SYNTHESIZE mode — Domain bridge roles:

• Source Domain Expert + Target Domain Expert + Bridge Agent

HYBRID / Multi-phase — Different role sets per phase:

• Phase 1 roles execute and complete → Phase 2 roles receive Phase 1 output and execute

Step 2: Build Execution Phases

Organize roles into ordered phases:

Phase 1: [Foundation / Research / Reading]
  Roles: [list]  |  Parallel: yes/no
  ↓ completes
Phase 2: [Implementation / Analysis / Extraction]
  Roles: [list]  |  Parallel: yes (if independent)
  ↓ completes
Phase 3: [Verification / Synthesis / Application]
  Roles: [list]

Rules:

• Same-phase independent roles → launch in PARALLEL (single message, multiple Task calls)
• Cross-phase dependencies → execute SEQUENTIALLY
• Pass prior phase outputs to next phase agents as context

Step 3: Execute Per Phase

For each phase:

1. Create TaskList entries for tracking
2. Generate agent prompts with role identity:

   "You are a [Role Name]. Your focus: [Focus].
    Your scope: [what you own]. Your boundary: [what you must NOT touch].
    Context from prior phase: [if applicable].
    Deliver: [output format]."
   

3. Launch parallel agents (for independent roles in same phase)
4. Collect results
5. Mark tasks completed
6. Capture progress to memory (LOOP strategy: after every phase)

Boundary Management

For BUILD mode tasks (code modification):

• Each agent gets explicit file boundaries
• Post-execution: check for file conflicts (same file modified by multiple agents)
• Interface verification: do API callers match API providers?

For non-BUILD tasks (THINK, LEARN, RESEARCH, etc.):

• No file boundaries needed
• Instead: perspective boundaries (each role stays in its lane)
• Synthesizer handles cross-perspective integration

Phase 3: Verification

Before declaring complete:

1. Tasks complete — All TaskList items resolved
2. BUILD mode checks:
   • lsp_diagnostics on modified files
   • Run tests if they exist
   • File conflict check (no unintended overwrites)
   • Interface contract verification
   • forge_artifact_drift if governance active
3. Non-BUILD mode checks:
   • All roles produced their required output
   • Synthesizer resolved contradictions
   • No critical gaps in coverage
4. Summary — Report per-role results and integrated outcome

Phase 4: Knowledge Capture

After execution:

1. Use forge_memory_append to save:
   • Solutions that worked (type: solution)
   • New patterns (type: pattern)
   • Anti-patterns avoided (type: anti-pattern)
   • Decisions with rationale (type: decision)
2. Tag with free-form domain strings (not fixed fe/be/infra)
3. If adaptive escalation occurred, capture the trigger as a pattern
4. If novel role configurations worked well, capture them for future reuse

Output Format

Completion Report

## Execution Complete

### Strategy: [QUICK / STANDARD / LOOP]
### Task Nature: [cognitive modes] | [domains] | [depth]
### Phases Executed: [count]

### Results by Role
- **[Role A]**: [what was accomplished]
- **[Role B]**: [what was accomplished]

### Synthesis
[Integrated result combining all role outputs]

### Verification
- BUILD checks: [pass/fail or N/A]
- Diagnostics: [pass/fail or N/A]
- Tests: [pass/fail or N/A]
- Governance: [compliant or N/A]

### Knowledge Captured
- [patterns/solutions saved to memory with domain tags]

### Escalation Events
- [any strategy changes during execution, or "none"]

### Next Steps
- [follow-up actions if any]

Tool Availability Fallbacks

• AskUserQuestion: If unavailable at runtime, surface decisions that need user input as [USER INPUT NEEDED] markers in the completion report. For non-critical decisions, proceed with the most reasonable default and log it.
• MCP tools (forge_memory_, forge_policy_, forge_context_*): If unavailable, skip memory recall/capture and governance checks. Proceed with direct execution. Note the absence in the completion report.
• LSP/AST tools: If unavailable, fall back to Glob/Grep/Read for code analysis. Use text-based verification instead of structural analysis.

Agent Safety Rules (Always Active)

1. Follow the contract — Only do what was planned/requested
2. Respect boundaries — Each role stays in its assigned scope
3. Pattern over invention — Follow existing patterns in the codebase
4. Traceability — Every change traces to a task
5. NEVER suppress type errors (as any, @ts-ignore)
6. NEVER commit without explicit user request
7. NEVER use empty catch blocks
8. After 3 consecutive failures, ask user for guidance
9. NEVER guess file contents — always read first
10. NEVER create files unless necessary

Current Task

$ARGUMENTS