map-fast git:20260519.121a302A

Immutable. This exact content never changes and is served at /api/v1/blob/2fc8473970499f5f.

---
name: map-fast
description: |
  Minimal MAP workflow for small low-risk changes (40-50% token savings, no Predictor/Reflector). Use when the change is small, low-risk, and learning is not needed. Do NOT use for risky or complex work; use map-efficient.
effort: low
disable-model-invocation: true
argument-hint: "[task description]"
---
# MAP Fast Workflow

**⚠️ WARNING: Use for small, low-risk production changes only. Do not skip tests.**

Minimal agent sequence (40-50% token savings). Skips: Predictor, Reflector.

**Consequences:** No impact analysis, no quality scoring, no learning.

Implement the following:

**Task:** $ARGUMENTS

## Effort and Parallelism Policy

```yaml
thinking_policy: low/direct
parallel_tool_policy: sequential_by_default
```

- Keep reasoning brief and action-oriented; this workflow exists to avoid heavyweight orchestration for bounded, low-risk work.
- Do not add research, Predictor, Evaluator, Reflector, or extra self-audit steps unless the task no longer fits `/map-fast`; switch to `/map-efficient` instead.
- Run agent phases sequentially. Parallelize only independent read-only file inspection or independent check commands when there are no state transitions or edits involved.

## When Not To Expand Scope

- Do not add discovery, design review, impact analysis, or learning steps to keep this workflow busy.
- Do not refactor nearby code unless the selected small task cannot work without that exact change.
- If the task becomes risky, multi-stage, or ambiguous, stop using `/map-fast` and switch to `/map-efficient` or `/map-plan` instead.

## Workflow Overview

Minimal agent sequence (token-optimized, reduced analysis depth):

```
1. DECOMPOSE → task-decomposer
2. FOR each subtask:
   3. IMPLEMENT → actor (edits files directly)
   4. VALIDATE → monitor (reads written files)
   5. If invalid: provide feedback, go to step 3 (max 3 iterations)
   6. ACCEPT Actor's already-written changes
```

**Agents INTENTIONALLY SKIPPED:**
- Predictor (no impact analysis)
- Reflector (no lesson extraction)

**Scope boundary:** This is not the full MAP workflow. Learning and impact analysis are disabled by design.

## Step 1: Task Decomposition

Break down the task into subtasks:

```
Task(
  subagent_type="task-decomposer",
  description="Decompose task into subtasks",
  prompt="Break down this task into atomic subtasks (≤8):

Task: $ARGUMENTS

JSON contract reference: [Decomposition Output](../../references/map-json-output-contracts.md#decomposition-output).

Output JSON with:
- subtasks: array of {id, description, acceptance_criteria, estimated_complexity, depends_on}
- total_subtasks: number
- estimated_duration: string

Each subtask must be:
- Atomic (can't be subdivided further)
- Testable (clear acceptance criteria)
- Independent where possible"
)
```

## Step 2: For Each Subtask - Minimal Loop

### 2.1 Call Actor to Implement

```
Task(
  subagent_type="actor",
  description="Implement subtask [ID]",
  prompt="Implement this subtask:

**Subtask:** [description]
**Acceptance Criteria:** [criteria]

JSON contract reference: [Actor Change Summary](../../references/map-json-output-contracts.md#actor-change-summary).

Output JSON with:
  - approach: string (implementation strategy)
  - files_changed: array of file paths actually edited
  - tests_run: array of commands run, or [] if deferred to the orchestrator
  - trade_offs: array of strings
  - remaining_risks: array of strings

Apply changes directly with Edit/Write tools. Do not serialize full file contents in your response."
)
```

### 2.2 Call Monitor to Validate

```
Task(
  subagent_type="monitor",
  description="Validate implementation",
  prompt="Validate written code for this subtask:

**Written Files:** [files_changed from Actor]
**Subtask:** [description]
**Acceptance Criteria:** [criteria]

Check for:
- Actual repo state in each written file
- Basic code correctness
- Obvious errors
- Test coverage

JSON contract reference: [Monitor Verdict](../../references/map-json-output-contracts.md#monitor-verdict).

Output JSON with:
- valid: boolean
- issues: array of {severity, category, description, file_path}
- verdict: 'approved' | 'needs_revision' | 'rejected'
- feedback: string (actionable guidance)"
)
```

### 2.3 Decision Point

**If monitor.valid === false:**
- Provide monitor feedback to actor
- Go back to step 2.1 (max 3 iterations)

**If monitor.valid === true:**
- Changes are already applied by Actor
- Move to next subtask

## Step 3: Final Summary

After all subtasks completed:

1. Run basic tests (if applicable)
2. Create commit with message
3. Summarize what was implemented

**Note:** Learning disabled (Reflector skipped).

## Critical Constraints

- MAX 3 iterations per subtask
- NO learning cycle (Reflector skipped)
- NO impact analysis (Predictor skipped)
- NO quality scoring

Begin now with minimal workflow.


## Examples

```
/map-fast <typical args>
```

## Troubleshooting

- **Issue:** Workflow doesn't behave as expected. **Fix:** Re-read the section above titled 'What this command CANNOT do' (if present) and ensure prerequisites are met. Run `/map-resume` to recover from interruptions.