map-fast

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

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.
• Do not edit unrelated files or add, remove, or upgrade dependencies unless the task explicitly requires 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.

Mutation Boundary Constraints

These constraints apply to the Actor implementation prompt:

• Do not edit unrelated files, even if they are nearby or easy to clean up.
• Do not add, remove, or upgrade dependencies unless the current task explicitly names that dependency change.
• Do not refactor neighboring code unless the acceptance criteria cannot pass without that exact refactor.
• If a dependency change, broad refactor, or scope expansion seems necessary, report it as a blocker/tradeoff instead of doing it silently.

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.
Do not edit unrelated files, add or upgrade dependencies, or refactor neighboring code unless the current subtask explicitly requires it. Report any required scope expansion as a blocker/tradeoff."
)

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 add a --verbose flag to the status command
/map-fast fix the off-by-one error in the pagination offset

Troubleshooting

• Issue: Task turns out risky, multi-stage, or ambiguous. Fix: Stop using /map-fast; switch to /map-efficient or /map-plan (see "When Not To Expand Scope").
• Issue: A subtask exceeds 3 iterations without passing Monitor. Fix: Report it as a blocker/tradeoff — do not loop or fake-complete (see "Critical Constraints").
• Issue: The session was interrupted mid-workflow. Fix: Run /map-resume to recover.