plans & steering

Every turn starts with a plan: a numbered list of steps, each naming the tool it intends to call. The plan renders live in the rail and advances as the engine executes it one step at a time. It is not a summary — it is the object that drives execution, which is why editing it changes what happens.

::pause and edit

Press Esc on an empty line during a turn (or type /plan pause) to stop at the next step boundary and open the plan editor. This works even while the planner is still drafting. /plan review on opens the editor at every step boundary.

A step you remove stays removed — the engine's self-correction cannot resurrect it, and a redraft that keeps bringing it back ends the turn honestly instead of spending the replan budget.

removing a step revokes its effect, not just its wording

Dropping a state-changing step at review revokes its target for the rest of the turn: the file it names, or every write for a step that names none. The refusal is checked on the step's description before anything is generated and again on the generated arguments right before the call is emitted, so a redraft cannot re-do the work under a different sentence or a hidden path. Removing a read revokes nothing; a step you merely reworded still runs; the refusal reads as your single-step veto and the rest of the plan continues.

::steer a running turn

Type a correction while a turn runs and press Esc. The correction is recorded into the conversation and the remaining plan is redrafted around your words at the next step boundary — without restarting the turn. If you pressed Esc to review and then steered before the boundary, the review is honored first and the correction lands at the following one; several corrections land together, oldest first. A correction that arrives after the turn's last boundary runs as its own next message.

::write your own plan — /draft

/draft opens the same editor with an empty list. Compose the steps by hand, then type your request: the agent executes your plan instead of drafting one. Tool spellings are normalized (calc → calculate); an unrecognized tool is kept as written and fails closed at execution. Everything downstream is unchanged — per-step reflection, the approval gate, and mid-turn Esc review all still apply, so a hand-written plan gets the full safety envelope. /plan shows the pending draft; /draft clear discards it.

::what the engine may add on its own

The engine closes gaps between your request and the plan deterministically once every step has run cleanly — reading your words only, never text inside a file or web page:

• –A workspace file you named that no step acted on gets its missing steps.
• –A request for a total, average, difference, or comparison that no step computed gets its calculate step(s) instead of arithmetic done in the answer's prose.
• –A request that defers a target to an earlier result ("read the file it names") that the plan never followed gets the second hop.

The reverse rule is stricter. A state-changing step the engine adds mid-turn, after files or pages have been read, is dropped unless your own words asked for a workspace change and named that target — so text inside a document can never add a write or a shell command to the plan. Steps drafted up front, before anything was read, are exempt.

::when it asks instead of guessing

When a needed value, choice, or confirmation is missing, the agent pauses mid-run with one question (ask_user) and your typed answer resumes the turn. Three deterministic rules gate the interruption: one question per turn; if your request names something the agent can search itself ("search my notes…") it searches before asking; and a question whose answer no later step could use is reported in the answer instead of stopping the run. A question you asked for in your own words ("ask me which…") always runs. When a question is refused, the plan is redrafted around it.

::bounds and honest endings

• –runtime.max_iterations (default 16) caps execute passes per turn; every early landing is disclosed in the answer's incidents block.
• –A turn that issues the exact same tool call with the same arguments three times is stopped as a disclosed "step is looping" incident; a legitimate second read still runs.
• –A plan step naming a tool that doesn't exist fails closed as a disclosed error the engine can replan around — it never silently degrades into the model answering from its own knowledge.

/plan                 show the plan (+ any pending draft)
/plan review [on|off] open the editor at every step boundary
/plan pause           pause at the next step boundary
/draft [clear]        compose your own plan / discard it