do

/do - Manifest Executor

Goal

Execute a Manifest: satisfy all Deliverables' Acceptance Criteria while following Process Guidance and using Approach as initial direction (adapting when reality diverges), then verify everything passes (including Global Invariants).

Input

$ARGUMENTS = manifest file path (REQUIRED), optionally with execution log path, --mode <level>, and --scope <deliverable-ids>

If no arguments: Output error "Usage: /do [log-file-path] [--mode efficient|balanced|thorough] [--scope D1,D2,...]"

Read the manifest file fully before any execution.

Execution Mode

Resolve mode from (highest precedence first): --mode argument → manifest mode: field → default thorough.

Invalid mode value → error and halt: "Invalid mode ''. Valid modes: efficient | balanced | thorough"

Load the execution mode file for behavioral specifics:

• thorough (default): read references/execution-modes/thorough.md
• balanced: read references/execution-modes/balanced.md
• efficient: read references/execution-modes/efficient.md

Follow the loaded mode's rules for model routing, verification parallelism, fix-verify loop limits, and escalation for the remainder of this /do run.

Override precedence (applies to all modes):

1. Criterion-level model wins: When a manifest criterion specifies model: in its verify block, that overrides the mode's model routing.
2. Explicit model overrides skip: If a criterion explicitly sets model:, it runs even when the mode would otherwise skip it.
3. Global Invariants always run: INV-G* verification runs regardless of mode — constitutional constraints.

Existing Execution Log

If input includes a log file path (iteration on previous work): treat it as source of truth. It contains prior execution history. Continue from where it left off—append to the same log, don't restart.

Scoped Execution

Parse --scope from arguments if present. Accepts comma-separated deliverable IDs (e.g. --scope D2,D3).

When --scope is provided, read references/SCOPED_EXECUTION.md and follow its rules for scoped execution. This limits work to the specified deliverables while maintaining global invariant safety.

When --scope is NOT provided, ignore this section entirely — no reference file is loaded, no scoping behavior applies. Full execution as normal.

Principles

Principle	Rule
ACs define success	Work toward acceptance criteria however makes sense. Manifest says WHAT, you decide HOW.
Approach is initial, not rigid	Approach provides starting direction, but adapt freely when reality diverges. No escalation needed — log adjustments with rationale.
Target failures specifically	On verification failure, fix the specific failing criterion. Don't restart. Don't touch passing criteria.
Verify fixes first	After fixing a failure, confirm the fix works before re-running full verification.
Trade-offs guide adjustment	When risks (R-) materialize, consult trade-offs (T-) for decision criteria. Log adjustments with rationale.

Constraints

Log after every action - Write to execution log immediately after each AC attempt. No exceptions. This is disaster recovery—if context is lost, the log is the only record of what happened.

Must call /verify - Can't declare done without verification. Invoke manifest-dev:verify with manifest, log paths, and the resolved mode: /verify <manifest> <log> --mode <level>.

Escalation boundary - Escalate when: (1) ACs can't be met as written (contract broken), (2) user requests a pause mid-workflow, (3) you discover an AC or invariant should be amended (use "Proposed Amendment" escalation type), or (4) the active execution mode's fix-verify loop limit is reached. If ACs remain achievable as written and no user interrupt, continue autonomously.

Mode-aware loop tracking - Track fix-verify iteration count and escalation count in the execution log. When the active execution mode's limits are reached, follow its escalation rules.

Phase-aware verification - /verify runs criteria in phases (ascending by phase: field, default 1). It may report "Phase N failed, Phase N+1 not run." After fixing failures, /verify restarts from Phase 1 to catch regressions. Loop limits apply per-phase; regressions increment the broken phase's counter, not the phase that caused them.

Stop requires /escalate - During /do, you cannot stop without calling /verify→/done or /escalate. If you need to pause, call /escalate with "User-Requested Pause" format. Bare outputs like "Done." or "Waiting." are not valid exits.

Memento Pattern

Externalize progress to survive context loss.

Execution log: Create /tmp/do-log-{timestamp}.md at start. After EACH AC attempt, append what happened and the outcome. Goal: another agent reading only the log could resume work.

Todos: Create from manifest (deliverables → ACs). Start with execution order from Approach (adjust if dependencies require). Update todo status after logging (log first, todo second).

Refresh before verify - Read full execution log before calling /verify to restore context.

Refresh between deliverables - Before starting a new deliverable, re-read the manifest's deliverable section and relevant log entries. Context degrades across long sessions.

Mid-Execution Amendment

When to trigger — User input or a PR review comment changes scope: new requirements, contradicted ACs, missing coverage. Clarifications and confirmations are NOT amendments — only act when the manifest's criteria themselves need to change.

Amendment flow — Amend the manifest autonomously via Self-Amendment escalation and /define --amend <manifest-path> --from-do, then resume with the updated manifest and existing log. Log the trigger before amending. No human wait — the entire cycle is autonomous.

Amendment loop guard (R-7) — If Self-Amendment escalations repeat without new external input (user messages or PR comments) between them, the amendments are likely oscillating — escalate as "Proposed Amendment" for human decision instead.