enumerate

name	enumerate
user-invocable	false
description	Generate a list of items from a higher-level spec — the **unfold** (1→N) primitive. Turn an outline into chapters, a feature into tasks, a goal into a checklist. Output is an items.json array that `/agentflow:foreach` (map) or `/agentflow:group` (partition) consume. The complement of `/agentflow:reduce` (N→1). USE when the user wants to break something down into a list to act on next — "break this outline into chapters", "list the tasks for this feature", "what are the steps, then do each", "turn this into a checklist". Producing the list itself takes judgment. DON'T use when the list already exists (a file, a glob, a markdown checklist) — point /agentflow:foreach at it directly; or when you need a single synthesized output (→ /agentflow:reduce). Explicit: `/agentflow:enumerate --prompt "<what to produce>" [--input <source>]`.
allowed-tools	Bash, Read, Write, Agent
argument-hint	--prompt "<instructions>" [--input <path>] [--model haiku|sonnet|opus] [--execution main-thread|subagent]

/agentflow:enumerate — unfold (1 → N)

Make it visible: the moment you start, say so in one line (skill + run-id) so it's clear an Agent Flow run is happening; /agentflow:board then lists every run on disk — the audit trail.

Produce a JSON array of items from a spec. You are the single writer of run state; the generator agent only writes the items file.

Step 1 — init

node "${CLAUDE_PLUGIN_ROOT}/dist/state/enumerate.js" init <run-id> \
  --prompt "<generation instructions>" \
  [--input <path-to-source-material>] \
  [--model haiku|sonnet|opus|inherit] \
  [--execution main-thread|subagent]

--prompt is the core config (the instructions for what list to produce). --input optionally points at source material to expand (an outline, a spec, a transcript). Model and subagent are optional.

Step 2 — generate the list

Mark the run started, then produce the items:

• execution = subagent (default): dispatch ONE Agent that reads the run's task_prompt (and --input content if set) and writes a JSON array to a file.
• execution = main-thread: produce the array yourself inline and Write it to the file — no subagent. Use this for cheap/short generations.

Each element is {"id": "<stable-id>", "data": { ... }}. Give items human-stable ids (e.g. a slug) so re-runs and downstream views line up.

Step 3 — complete

node "${CLAUDE_PLUGIN_ROOT}/dist/state/enumerate.js" complete <run-id> --items-path <file>

Validates the file is a JSON array and records it as the run's result_pointer.

Step 4 — hand off

The items.json is now consumable:

• /agentflow:foreach --items <file> to apply an operation to each item;
• /agentflow:group --input-source <descriptor> to partition them;
• inside a /agentflow:pipe, wire {{stages.<this-stage>.result_pointer}} into the next stage's input.

Output schema

A JSON array. Minimal item: {"id": "ch-1", "data": {"title": "Introduction", "brief": "..."}}. data carries whatever the downstream operation needs (a prompt, a path, a spec).