map

name	map
description	Compile tasks through Map — queue-driven enrich/instance loop. Use when the user asks to define a task, break work into parts, or compile anything through the enrich/instance pattern. Also use when you need structured task decomposition with forward-progress guarantees.
user_invocable	true
argument-hint	define <name> <parts...> | enrich <name> <parts...> | instance <name> '<content>' | next | queue | tree | stats | reset

Map

You are the execution engine. Map is the compiler.

Your output is a call to Map — either enrich or instance. The system manages the queue, the KV store, the state. The queue enables compilation through you.

Two Moves

enrich — A name is too complex to produce directly. Break it into sub-parts.

python3 -m introduction_to_cs enrich <name> <part1> <part2> ...

instance — A name is clear enough to produce. Write the content.

python3 -m introduction_to_cs instance <name> '<content>'

The Ratchet

• A queue item is NOT DONE until instanced. Enrich replaces it with sub-items — doesn't resolve it.
• Once instanced, it's ratcheted — if you re-enrich it, the new sub-parts go to the END of the queue.
• You must process the entire remaining queue before you get back to it. No going back and fiddling.
• This enforces forward progress. That's what makes it compilation, not chatting.

Workflow

1. Define a task as parts:

python3 -m introduction_to_cs define <task> <part1> <part2> ...

2. Check what's next:

python3 -m introduction_to_cs next

3. For each item, decide: enrich (break down further) or instance (produce content)?

4. After instancing, next automatically shows what's next.

5. Monitor progress:

python3 -m introduction_to_cs queue    # see what's pending
python3 -m introduction_to_cs tree     # see the full structure
python3 -m introduction_to_cs stats    # completion numbers
python3 -m introduction_to_cs show <name>  # inspect a node

6. Reset to start over:

python3 -m introduction_to_cs reset

Commands

Command	What it does
define <name> <parts...>	Start a compilation — set root task and initial parts
enrich <name> <parts...>	Break a name into sub-parts (sub-parts enter queue)
instance <name> '<content>'	Produce content for a name (name is done)
next	Show the next queue item with context
queue	Show the full queue
tree	Show the compilation tree
show <name>	Inspect a specific node
stats	Show completion progress
reset	Clear all state

Depth = Thought

The depth of enrichment is the depth of thought. Flat = fast and shallow. Deep = slow and thorough. You choose based on the task.

• If you can produce it → instance
• If it's too complex or ambiguous → enrich into sub-parts
• The queue enforces that you finish what you start before revisiting