Skip to content

Quick Task

Quick Task runs a bounded multi-step non-development task as Plan → Approve → Execute → Review → Accept; in autonomous mode the approval and acceptance steps are skipped (see Operating mode). It keeps complete task, plan, review, decision, change, and evidence records in an execution-specific filesystem workspace. Workflow context carries only bounded file references, the plan’s unit titles and length, the execution cursor, a one-line result, and short values used for routing.

Terminal window
mcp__moira__execution({ action: "prepare", workflowId: "moira/quick-task", parentExecutionId: "none" })
mcp__moira__execution({ action: "execute", startAttemptId: "<Start attempt ID from prepare>" })

Intake → independent plan review → approval → sequential execution → independent result review → acceptance. Findings return to a separate repair owner; changed plans and results pass the same review again.

The intake step derives the complete task contract from the triggering conversation, asking only for a material fact that cannot be discovered. It creates a workspace correlated with the Moira execution:

./moira-ws/quick-task-<executionId>/ holds the task contract, execution evidence and immutable plan/result-review iterations, including exact decisions and changes. process-id.txt identifies the execution for recovery.

Numeric iteration directories are published only after their record is complete. Existing completed iterations are not overwritten. A resumed node verifies and reuses its complete current record instead of duplicating it.

Returned paths are constrained by JSON Schema for shape and length. File existence, completeness, and correctness remain part of the creating node’s directive and completion condition; a path-shaped string alone does not prove completion.

The planner writes between one and ten meaningful ordered work units. Each unit states its action, expected result, and a verification method appropriate to the work, and fixes that outcome rather than carrying the deliverable itself: after the plan is approved, work an intelligent executor still has to do remains. The rule matters most where the result is prose — a document, briefs for other agents, an investigation’s answer — because there plan and result share a medium. The repair node that precedes approval answers for the whole plan; the revision node, which also runs mid-flight, answers for the units it shapes, because already executed units stay at their positions as they were executed. The plan body stays in plan.md; the workflow receives its bounded path and plan_steps — one short title per unit, in plan order — from which it derives the unit count. The titles are the plan list people see in notifications and on the run page.

An independent reviewer reads task.md and the current plan.md directly. It writes the complete reproducible blocking finding set to review.md and returns the report path and issues_count together with the bounded current planning-progress outcome required by the response schema. A nonzero count routes to a separate repair node, which writes a new immutable plan iteration before returning to the same reviewer. Zero findings is valid and reaches the approval gate.

The user’s exact decision and feedback are written to decision.md. Context receives only the decision-file path and yes/no routing value. Requested revisions read the exact feedback from disk, create a new plan iteration, and pass through independent review again.

The plan length becomes authoritative for execution only after the current plan has a clean review and, in interactive mode, explicit user approval.

The first step resolves operating_mode as autonomous or interactive. The agent reuses a mode you already stated, infers an unambiguous one — including a run started by an already autonomous parent process — and asks once only when the mode is neither stated nor derivable.

Before completing intake, the agent persists the actual task name through guarded Progress/execution metadata. The reusable naming contract is included in agent presentations. Optional execution_note is arbitrary nonempty text of at most 120 characters, independent of headings. Authorized scope changes at revision, rework or replan update the same name; tactics, reordering and ordinary repair retain it without granting new authority.

In interactive mode nothing changes. In autonomous mode the plan-approval gate is bypassed and the final step presents the result without asking for acceptance. Both independent reviews and their repair loops are identical in either mode, and the delivery stays honest: unfinished or unverified work is reported as such rather than silently accepted.

The run page and progress image show the current role, latest confirmed outcome and plan items. A revised plan replaces obsolete current/future projections while retaining still-valid completed work. Progress is display-only: it does not grant authority, change routing or prove completion. See Process view.

The engine owns a zero-based cursor. For each position, the agent reads the approved plan.md, executes only that work unit, applies technical judgment, and verifies the actual result. Before advancing, it writes exactly one concise evidence entry of at most 500 characters for that position to execution.md.

Evidence is not returned through workflow context. If work is incomplete or blocked, the agent reports the verified reason and remains at the current directive; the workflow does not convert failure into a status code or advance the cursor. Quick Task has no automatic retry counter or skip-as-success route.

When the approved plan itself stops fitting reality — new facts appear, scope was missed, or an executed unit’s outcome invalidates the remaining plan — the agent jumps to the replan entry instead of finishing a plan it knows is wrong:

mcp__moira__execution({ action: "step", processId, attemptId, teleportTo: "teleport-replan" })

No step leads into that node, so a replan is always a deliberate decision, and it is not a way around the other owners: a blocking plan-review finding belongs to the plan repair loop, a defect in the produced result to the result fix loop, a plan you reject at the approval gate to the ordinary revision route, and a unit that is merely hard or blocked to the rule above.

The jump states why the plan no longer fits; the same plan revision responsibility then publishes the next immutable plan iteration with its change.md. Units already executed keep their positions — the cursor is preserved, so finished work is not repeated and its evidence entries stay as written. The new plan goes back through the independent plan review and, in interactive mode, through your approval, before execution continues.

After all approved units, an independent reviewer reads the task, approved plan, plan decision, execution evidence, and actual artifacts. Each result state receives an immutable numeric review record. The reviewer writes all current blocking defects to review.md and returns its path and issues_count together with the bounded current review-progress outcome required by the response schema, and result_summary: the result as it stands, in one sentence a person reads in a notification.

A nonzero count routes to a separate fix node. The fix reads the complete report, reproduces and corrects confirmed defects, and writes change.md; the changed result then returns through the same independent review. A clean review reaches user presentation.

The user’s exact acceptance or rework request is written to decision.md. Rework reads that file, changes the result, writes change.md, and returns through independent review. Only explicit acceptance reaches End.

Quick Task notifies through the user’s configured channels. Every message is headed by the flow name and the run’s task, linked to the run page; none carries a file path or an image.

Interactive runs announce the reviewed plan with approval/revision choices, then the reviewed result with acceptance/rework choices. Autonomous runs announce that the reviewed plan goes ahead. Both announce the final result and completed units.

A rejected plan, and a plan revised mid-run after a replan, is announced again in its revised form with the units already done kept as done; a rework is followed by a new result message. The messages are in English. Nothing sent in an autonomous run asks for a decision. Because the flow notifies, starting it for a user with no configured channel is refused with an instruction; an agent that wants to run without notifications prepares the start again with skipNotificationCheck: true.

The plan approval and the result review are marked as steps that wait for you: while an interactive run stands on one, the run page and the run’s progress say waiting for you with what you are asked, and the message that asks ends with 🙋 waiting for you. The flow’s own message is the first notification about the wait; if nobody answers for a day, Moira sends one reminder with a link to the run. Autonomous runs go around both steps and never wait for you.

  • Complete plans, reviews, decisions, feedback, changes, and evidence have one durable source on disk instead of duplicated context payloads.
  • Every returned dynamic path has a typed schema and a named downstream consumer.
  • Review and mutation remain separate; every changed plan or result returns through the appropriate independent review.
  • Automatic review loops advance only after a new artifact or result state exists. A non-reproducible or incomplete repair does not call execution with action: "step".
  • Mechanical checks prove only the properties they directly test; the executing and reviewing agents still judge the actual result.
  • End has an empty terminal projection and does not expose internal file-backed records.
  • Quick Task requires filesystem access. It does not provide Robust Task’s stronger failure-recovery policy.