---
name: minimap
description: "Lightweight plan-and-execute workflow for mid-size features. Single-file plan with phases, one round of agent critique, then hand off to /dispatch-loop. Use when /map is overkill but a one-shot is too risky — typically 2-5 commits of structured work."
argument-hint: "[feature description]"
disable-model-invocation: true
---

# /minimap

A lightweight cousin of `/map`. Produces a single-file plan after exploration
and one round of critique, then hands off to `/dispatch-loop` for execution.
Use when /map's per-phase docs, GitHub setup, FOSS comparison, and multi-round
critique are overkill — but the work is too structured to one-shot.

## Adaptability

The shape below is guidance. If a project doesn't fit (no git, unusual
structure, non-Rust language /map's templates assume), propose how you'll
adapt — don't silently skip sections.

## Usage

If `$ARGUMENTS` is empty, "help", or "?", show this and stop:

```
/minimap [feature description]

Plan a mid-size feature in a single file with one round of critique.
Produces .claude/minimap/{slug}.md, ready for /dispatch-loop execution.

Examples:
  /minimap add donut center-text and hover annotations
  /minimap make the dataframe panel scrollable
  /minimap port the parser tests to the new harness

Workflow:
  /minimap        Plan the work (you are here)
  /dispatch-loop  Execute the plan with subagents

For larger work needing FOSS comparison, expert critique, GitHub setup, and
per-phase docs: use /map instead.
```

## The feature

$ARGUMENTS

## Workflow (execute in order)

### Step 0 — Slug and path

Derive a kebab-case slug (2-4 words) from the feature description. The plan
lives at `.claude/minimap/{slug}.md`. Create `.claude/minimap/` if it
doesn't exist.

If a file already exists at that path, ask whether to overwrite, pick a new
slug, or load the existing plan and resume from where the checklist left off.

### Step 1 — Light interview (skip if obvious)

Only ask what's genuinely unclear from `$ARGUMENTS`. Cap at 2-3 questions.
Useful prompts:
- **Scope**: "what's the end state? what should work that doesn't today?"
- **Constraints**: "anything to avoid? perf, API compat, deps?"
- **Non-goals**: "what's explicitly out of scope?"

If the description is concrete, skip and explore.

### Step 2 — Explore

Spawn an `Explore` agent for a focused pass on the relevant code. Find:
- Current architecture in the area you'll change
- Key files / types / functions involved
- Existing patterns to follow
- Known limitations or rough edges in the area

Report findings to the user briefly. This is your one big exploration —
don't grow it into /map-shaped breadth.

### Step 3 — Draft the plan

Write `.claude/minimap/{slug}.md` using the template below.

**Each phase is one commit.** If a phase wants multiple commits, split it.
Phase headings MUST use `### Phase N — {name}` so /dispatch-loop's parser
picks them up. Don't change the heading shape.

```markdown
# Minimap: {feature}

**Slug**: {slug}
**Created**: {YYYY-MM-DD}

## Checklist

- [ ] Phase 1 — {short name}
- [ ] Phase 2 — {short name}
- [ ] Phase 3 — {short name}

> The orchestrator flips boxes as phases land and clear review. When
> driving via /dispatch-loop, edit this file alongside each per-commit
> task update.

## Goal

One paragraph — what we're building, in plain language.

## Current state

What exists today, grounded in real file paths from exploration.

## Target state

What exists when done. Concrete: types added, behavior changed,
files touched.

## Constraints

Non-negotiable rules from CLAUDE.md, style guides, `~/.claude/guides/*`,
decisions, and feedback memories that bear on this design. Cite the
source for each.

## Out of scope

What we're explicitly NOT doing here, and why. Future-work goes here,
not in phases.

## Phases

### Phase 1 — {name}

**Goal**: one sentence — what works after this commit that didn't before.
**Files**: explicit paths.
**Steps**:
1. ...
2. ...
**Exit criteria**: how the orchestrator knows this phase is done.

### Phase 2 — {name}

(same shape)

### Phase 3 — {name}

(same shape)

## Critique log

Round 1 — {date}: {what the Plan agent flagged, what we changed in
response}.
```

### Step 4 — One round of critique

Spawn a `Plan` agent with rigorous-and-constructive framing (NOT adversarial
— that produces noise):

> "Ultrathink. Evaluate this plan at `.claude/minimap/{slug}.md` rigorously
> and constructively. Look for ordering dependencies that don't hold, edge
> cases the plan hasn't accounted for, design choices that conflict with
> the project's style guide / feedback memories, and assumptions that
> don't survive grep-the-actual-code verification. Read the actual files;
> don't pattern-match. If the plan looks great, say so. Otherwise, list
> issues with severity and a concrete proposed fix."

Address every issue raised — fix the plan, or note explicitly why the issue
doesn't apply. Append the critique log.

**One round only.** If the agent surfaces a foundational architectural
problem, you've drifted into /map territory — surface that:

> "Critique flagged a foundational issue ({summary}). This may be bigger
> than /minimap is designed for. Options: (a) address inline and
> continue, (b) escalate to /map, (c) drop scope."

### Step 5 — User checkpoint

Show the user:
- Phase list with one-line summaries
- Files touched per phase
- What critique caught and how it changed the plan

Ask: "Plan ready at `.claude/minimap/{slug}.md`. Anything to adjust before
we hand off to dispatch?"

Wait for confirmation. Incorporate any corrections.

### Step 6 — Hand off to /dispatch-loop

Once approved, ask:

> "Drive execution now? Options:
> 1. Yes — run `/dispatch-loop .claude/minimap/{slug}.md` here
> 2. Yes, in a fresh chat (this chat preserves planning context)
> 3. Hold — I'll come back to it"

If (1): invoke /dispatch-loop with the plan path. /dispatch-loop parses
`### Phase N — …` headings as commit groups.

The minimap file's checklist tracks progress. After each commit lands and
clears /dispatch-loop's confidence review, the orchestrator edits the
plan file: `- [ ] Phase N` → `- [x] Phase N`. This is a single Edit per
commit, done alongside the per-commit task update.

If (2) or (3): stop here, leave the file untouched.

## Differences from /map

**Drops**: per-phase docs (phases inline in one file), goon.yaml,
SESSION_HANDOFF, GitHub project setup, FOSS comparison, expert-persona
critique, multi-round critique, Appendix A/B preambles.

**Inherits**: rigorous-and-constructive critique framing, slug-based
naming, exploration before drafting, user checkpoints at meaningful gates.

**Picks**: /minimap when the work is 2-5 commits in scope, the area is
already familiar, and you'd otherwise risk drift by one-shotting it.
/map when the work is foundational, multi-session, or needs cross-project
comparison.

## Rules

- One file. Don't split into per-phase docs (that's /map).
- Phase headings are `### Phase N — {name}` for /dispatch-loop compatibility.
- Each phase is one commit. To get multiple commits, add more phases.
- Cite real file paths from exploration. Don't pseudocode the plan.
- If critique surfaces /map-scope issues, escalate — don't push through.
- The checklist at the top is the source of truth for progress. Tick as
  you go.