Read , write . The loop atomically promotes into — never write directly. Use and as the schema source of truth.

Operate fully autonomously. Never ask the user to choose or pause for confirmation.

This is the cardinal scheduling rule. Pick the highest-priority plan with remaining phases and schedule all of them. Do not spread work across multiple plans — finishing one plan end-to-end produces shippable results; advancing many plans one phase each produces nothing usable. If the current plan is blocked, idle (empty orders) rather than context-switching to a different plan. Exception: shared infra orders can run alongside a plan's phases.

Output is where each order is a pipeline of stages executed sequentially. Group related work into stages within one order rather than separate orders.

Each stage has a field (task key, must match a registered task type) and runs one at a time within the order. The loop advances to the next stage when the current one completes.

A typical order pipeline: execute, then quality, then reflect — all as stages of one order.

Read from mise to discover every schedulable task type and its hint. Any registered task type can be a stage within an order. Use on each stage to bind it to a task type.

Schedule execute tasks from the array in mise. Use the backlog item ID (as a string) as the order .

Backlog items always have and . Other fields are adapter-defined and may vary. The default adapter (todos.md) provides: , , , , and . Custom adapters may include any fields — treat unknown fields as useful context.

Shared infrastructure: When multiple plans depend on common infrastructure (shared types, utilities, base packages), propose a standalone infra order before the plan's phases. Use a descriptive slug ID (e.g., ). If the infra work is substantial, create a backlog item via the adapter (), then use that item's ID as the order ID.

Items with plans: When a backlog item has a field (a relative path like ), read the plan overview and phase files to understand the work. Schedule one order with a stage per remaining unfinished phase (each unchecked item). Populate with the plan path(s). Use on each stage to inject plan context: the phase brief and any cross-phase dependencies.

Parallelizing phases: Read the plan to identify dependencies between phases. Phases that depend on earlier phases' output (shared types, APIs, schemas) must be sequential stages. Phases that touch independent areas of the codebase (separate packages, unrelated features, docs vs code) can be parallel stages within the same order. When in doubt, sequential is safer — but don't serialize work that has no real dependency.

Items without plans: Assess complexity before scheduling. If the item is straightforward (single concern, clear scope, small change), schedule as a simple execute task using the backlog item's title and description as the prompt. If the item is complex (multi-file, cross-cutting, ambiguous scope, or you'd want to see an architecture sketch before coding), schedule a plan-first order: a -only stage (no ) that invokes , followed by an stage to challenge the plan. No quality or reflect stages — planning output is a design document, not code. Do NOT use

"do": "execute"

for plan-first stages — the execute skill tells the agent to implement, which conflicts with the plan skill's "stop after planning" instruction. The plan skill will write phased plans to ; on the next scheduling cycle, the item will have a field and can be scheduled normally with the standard execute → quality → reflect pipeline.

Standalone orders: Orders can have arbitrary IDs — they don't need to correspond to a backlog item. When a standalone order completes, the adapter call is a no-op (no matching item to mark done). Use standalone orders for shared infrastructure, maintenance tasks, or cross-cutting work that serves multiple backlog items.

Nothing to schedule: When no backlog items are actionable (all blocked, all in-progress, all done, etc.), still write with an empty orders array (). This signals to the loop that scheduling ran but found nothing — preventing hot-loop re-spawns.

Each task type's field describes when and how to schedule it — as a follow-up stage within an order, as a standalone order, or both. Read these hints from in mise and compose orders accordingly.

The mise brief includes a array — lifecycle events emitted by the loop since the last schedule run. These are context for your scheduling decisions, not commands. See references/events.md for the full event type catalog (internal and external).

Events are context, not commands. Consider them alongside backlog state and session history when deciding what to schedule:

Don't react mechanically to every event. Use judgment: a single stage failure in a long pipeline is normal; three consecutive failures of the same order suggests a deeper problem.

Use spark or sonnet for small, mechanical tasks (simple renames, one-liner fixes, straightforward additions). Use full codex for anything requiring multi-step reasoning or cross-file coordination. When uncertain, codex for implementation, opus for judgment.

Always set on all stages. The runtime is still WIP and should not be used yet. Always include on scheduled stages so dispatch routing is explicit.

Write valid JSON to matching .

See references/examples.md for order JSON examples and field usage.