MoxyWolfPlugin Field GuideOperating guide

Full operating guide · gstack-execution

gstack design-to-ship

Read the pinned source for this guide

Choose a design draft, one approved item, a bounded goal or a release check. Carry exact-head evidence through independent review, then follow the release lane and the named owner’s authority.

Entry paths

Choose your starting point

  1. Design: no approved DESIGN.md yet. Start with /gstack-design-doc, review the draft and use Mark approved before canonical writes.

  2. Item: one approved DESIGN.md item with testable criteria. Start /gstack-build <item-id> on its authorized feature branch.

  3. Goal: a bounded multi-item outcome. Draft with /gstack-goal-new, approve the goal PR, then run /gstack-goal <id> --pr <goal-approval-PR>.

  4. Release: implementation and review already exist. Inspect final-head evidence, release.json's lane and matching reasons, required approvals and release authority before merging.

Before you begin

Prerequisites

The sections below cover the existing item-by-item design-to-ship path. For a bounded multi-item goal, choose the goal-mode path below.

  • Repository and build/test environment
  • Project workspace folder for the DESIGN.md mirror
  • Claude Code CLI and Codex CLI for the complete cross-tool build and review loop
  • Approved DESIGN.md item with checkable acceptance criteria
  • Named human review, merge, and release owner
  • For two-reviewer design mode: two ready reviewer families distinct from the writer and each other

Setup to evidence

First successful run

  • Resolve workspace.path from project-surfaces.json: org-shared work belongs in GitHub/Projects/<name>, personal work may use Taskade/<name>, and vault-only work stays in its declared Vault project. Shared gate logs live in GitHub/Projects/_gate-log; a local log row is not team-shared until pushed.
  • /session-start resolves the project without a picker: explicit name, launch directory, then latest handoff. It refreshes shared rules in GitHub/Projects/_shared-memory and clean org-shared clones safely; dirty clones or local commits remain untouched. Confirm live hooks rather than assuming they loaded.
  • Confirm the host has the current gstack-execution commands. Marketplace publication is not proof of installation or readiness on this machine.
  • Resolve the repository, canonical DESIGN.md, project workspace mirror, target branch and named Release Owner. Choose design, item, goal or release entry before dispatch.
  • Check independent reviewer-family access and a durable GSTACK_PEER_REVIEW_DIR. Confirm required runtimes, test dependencies and the coverage scorer are ready without exposing credentials.
  • Inspect the repository's release-lane table and actual PR checks. Preserve unknown protection status as unknown; a green workflow is not proof that GitHub requires it.
  • Record the approved criteria, permitted paths, test commands and evidence locations. For goal mode, also confirm the immutable brief, sealed holdout, independent builder and spending limits.

Start here for a bounded multi-item outcome

Run a goal from brief to evidence

A goal defines the outcome, tests and limits first, then lets the agent work through an ordered plan inside those limits. You approve the co-authored goal brief, then test usability after the evidence-gated merge; Production is a separate decision. The exact command is /gstack-goal.

Repository docs use the short command names below. In a host that namespaces plugin commands, select /gstack-execution:gstack-goal-new or /gstack-execution:gstack-goal in its command picker.

Before you type the first command

  • A current gstack-execution installation, Git/Python, the target checkout and access through the moxywolf-agent GitHub app
  • An existing DESIGN.md objective, a checkable outcome and invariants, permitted files, a named approval owner and agreed spending limits
  • Working Codex/gpt test drafting, Gemini reading through OpenRouter and an independent builder/reviewer setup; credentials stay in the supported secure configuration. An item model recommendation must still respect builder-family independence
  • The goal-test container/runtime and required target dependencies; local mode uses Docker. Browser goals use the Playwright image with Python and Chromium support, not an assumed browser in a Python-only image. Preserve the sealed holdout outside repositories until final validation
  • Verified deployment boundaries. Preview variables must contain no production credentials; unresolved access or deployment safety does not become safe merely by selecting local mode

Before item work, read-only Haiku explore and docs agents gather code locations and reference passages; the builder judges that evidence. Item-level model advice is part of gstack. Session model routing is a separate workflow and does not switch the current turn or grant release permission.

Goal brief and test formats · Runtime and review prerequisites

  1. 1. Draft a bounded goal

    Co-author the outcome, never-do constraints, scenarios and one-line plan in a live editable document. Read the author’s edits and comments, then confirm the draft is right before the agent writes goals/<id>/GOAL.md and PLAN.md under one existing DESIGN.md objective. The brief fixes allowed paths, scenarios, budget, provider budgets, call limit, item limit, review limit and stop conditions.

    /gstack-goal-new help-output "Our CLI prints useful --help and exits 0; existing invocations keep working"
  2. 2. Prove the tests describe the goal

    Codex from the gpt family drafts the goal tests and hidden holdout. Gemini supplies a plain-English reading of every goal test. The baseline must show every outcome test failing on origin/main and every invariant passing. The builder must belong to neither of those families, normally claude for this drafting path.

  3. 3. Approve the brief, then start

    Review the goal PR's outcome, ordered plan, spend cap and plain-English test reading. Give an approving review and instruct its merge at the approved head. Then run the goal command with that goal-approval PR number. Here 42 is illustrative: replace it with the PR that added this goal, not an item or final implementation PR.

    /gstack-goal help-output --pr 42
  4. 4. Build and review each item

    The agent follows PLAN.md in order. Each item goes through /gstack-build on its own branch and PR into goal/<id>, carrying the prior items. A clean cross-vendor review, required checks and the goal's permitted-change checks are required before merging the exact reviewed head. Read release.json's release_lane and matching reasons for each item: contained and wide still need their applicable authority and gates; closed never merges autonomously under DR-113. Invariants must keep passing, and an outcome that passed on an earlier item cannot regress.

  5. 5. Validate the whole result

    After every plan item is built and every goal test passes, code reads the sealed holdout and checks its approved hash. A fresh cross-vendor review covers the whole goal diff. In GitHub mode, finalize records RESULT.md and the holdout through a PR into goal/<id>, then propose opens the goal PR into main. The tests, goal-envelope, goal-tests and goal-holdout checks must be green, with coverage checked.

  6. 6. Merge on evidence, then test usability

    GO-011 lets the bot merge the final goal PR at its exact head after tests, goal-envelope, goal-tests and goal-holdout pass and a fresh whole-goal cross-vendor review is clean with coverage checked. The runner must allow the merge. The review covers every item while keeping the sealed holdout out of its surface. Then record completion and run /gstack-usability <id>.

Worked example

The help-output example above is illustrative, not a completed run. A suitable brief might require an existing CLI's --help to print usage and exit 0, while its normal invocation keeps its existing output and exit code. First confirm the proposed outcome test fails on main and the compatibility invariant passes. If both already pass, the tests do not demonstrate new work.

The agent might propose one plan item for the help behavior and one for its documentation, with exact stdout, stderr and exit-code criteria. You review the allowed paths, test reading and budget before approving the brief. At the end, the runner checks item evidence, the whole-goal review and sealed holdout before the bot merges. You then try the verified Preview using the usability sheet before deciding on Production.

Usability before Production

Run /gstack-usability <goal-id> after the goal merges. First verify that the merge deployment serves the changed pages and passes its e2e checks. Keep Preview protection enabled. A custom product domain already attached means the goal is already in Production and must be reported.

The shared task sheet contains five to eight plain-language tasks from the goal’s scenarios, including an error state. Dorian marks each worked, confusing or broken and leaves notes. The agent reads the saved answers back; browser-local storage alone is insufficient. Wording, layout, links and accessibility fixes use their own reviewed build and re-test; behavior changes become a new goal. Unclear cases also become a new goal.

When every task’s latest mark is worked, or Dorian says to ship, ask once for the separate Production decision, naming what goes out and how. An automatic main deployment to a host address is distinct from attaching the product domain. Record the sheets, fixes, follow-on goals and the actual Production decision in USABILITY.md.

gstack-usability source

Commands to choose

Draft a goal

/gstack-goal-new <goal-id> "<outcome>"

Opens the goal-approval PR. gstack-goal-new source

Run the approved goal

/gstack-goal <goal-id> --pr <goal-approval-PR> [--builder <family>/<model>]

Runs the approved plan within its limits. Choose an eligible model available in your environment. gstack-goal source

Inspect GitHub-mode readiness

/init-goal-mode <owner>/<repo>

A project-init command, also shown as /project-init:init-goal-mode in namespaced hosts. Reports ready, missing and unknown without changing anything. This is the GitHub-mode readiness check; the goal commands also document a local-mode path. init-goal-mode source

What the runner controls

In GitHub mode, the agent uses start, next, merged or failed, finalize, propose, complete and record. It asks may before pushes, PRs, merges, review dispatches and outside calls. Unsettled in-scope code choices go to two other model families; a split or other decision type goes to the human. Digests are relayed as printed, while answer and ack record actual human responses.

The ledger is an agent-maintained record, not a global security boundary. GitHub rulesets provide repository enforcement. Printed messages do not prove receipt, and local checks do not create GitHub protection. This page documents source behavior; it does not certify your machine, installed versions, credentials, repository gates or any future run.

Goal-mode troubleshooting

The command is missing
Use /gstack-goal-new and /gstack-goal with hyphens. These are gstack-execution commands. Update or install the plugin in the host you are actually using, then check its command picker. A listing in this guide is not proof of local installation.
Readiness is missing or unknown
The read-only /init-goal-mode check belongs to project-init. Missing GitHub-mode onboarding can use local mode under GO-010; it is not a reason to copy gate files by hand. App access, missing permissions and unverified preview credentials still need resolution.
The brief or baseline is refused
Use the exact goals/README.md formats and one objective from origin/main's DESIGN.md. Include at least one outcome test and one invariant, scoped allowed paths and all deployment environments that require a human decision. Fix an unapproved brief and regenerate tests plus holdout before seeking approval.
The runner refuses the checkout or builder
GitHub-mode goal_run.py runs from the governed repository's own checkout, never an installed-plugin copy. Local-mode scripts run from the moxywolf-plugins checkout with target-repository paths. The builder cannot be from a family that drafted or read the goal tests.
The run is waiting
Exit 3 from goal_run.py next means a human decision or holding escalation. Relay the printed question and options, then record the person's actual words with answer or ack. An acknowledgement does not create a new permission grant. Other nonzero exits stop the current action; inspect the stated reason.
A review, holdout or budget check fails
Stop and report the evidence. Do not lower the model floor, remove acceptance criteria or edit tests to make the gate pass. A missing check is not a pass. A missing or unreadable spend ledger also stops the run. Spend is checked at action and step boundaries; reported costs and in-flight calls can overshoot the threshold.
A check failed or the release lane is closed
A failed ledger check clears only when the identical command and arguments pass from the same working directory. Before an item merge, read release.json's lane and matched paths or effects. Closed never permits an autonomous DR-113 merge; the Release Owner must merge or specifically instruct it. The final goal merge uses GO-011 checks and whole-goal review; Production remains a separate owner decision.
A model recommendation looks cheaper
MR-001/MR-002 defaults to shadow on the floor. Route mode needs at least 20 scored shadow lines and agreement of at least 0.90; record the actual declared_tier. /gstack-build does not launch a builder or switch the interactive session today. A recommendation cannot relax builder-family independence or reviewer floors.
A question remains unknown
Preserve its latest revision, required authority and evidence references. A stale revision, missing evidence or weaker source cannot close it. The wide release lane blocks open repository-authority questions; runtime or human questions remain explicit for the owner to resolve.
main moved while the goal PR was open
GitHub mode uses the documented sync PR into goal/<id>, an allowed may check and resync, then reruns checks at the new head. Local mode requires fresh candidate checks and review at the final head. Earlier approval and green checks do not automatically cover new code.

Execution sequence

Pipeline stages

  1. Stage design-draft

    Stage design-draft – Design draft

    Gather repository context, PRDs and specs, project-workspace engineering material, team rules, and user notes into an editable artifact.

    Command
    /gstack-design-doc
    Inputs
    • Repository context
    • PRDs and specs
    • project-workspace engineering material
    • Team rules
    • User notes
    Outputs
    • Editable design artifact
  2. Stage design-review

    Stage design-review – Two-reviewer design loop

    Challenge the draft before presenting it for human approval. The writer and both reviewers must use three distinct model families.

    Command
    /gstack-plan-review critics=2 target=design
    Inputs
    • Draft revision
    • Goal and settled constraints
    • Two ready, authorized reviewer families
    Outputs
    • Revision-bound critiques
    • Finding dispositions
    • Shared approval or explicit dissent/incomplete result
    How it works
    • Reviewer 1 critiques the revision; reviewer 2 reads that revision and critique, then agrees, disagrees or extends it.
    • The writer revises and records accepted, rejected, deferred or duplicate findings. Only the reviewer who raised a material finding can close it.
    • Repeat until both approve the same revision with no open material findings. Stop at 20 rounds or two consecutive stalls and preserve dissent.
    • Readiness uses a tiny call through the actual reviewer path. Fewer than two ready families means not_started. A failed loop remains incomplete; there is no silent same-family replacement.
    • The older PLAN.md single-critic loop is a different mode. Do not apply its fallback rules here.
  3. Stage artifact-approval

    Stage artifact-approval – Artifact approval

    Use the editable artifact as the review surface; Save version preserves a draft but is not approval.

    Inputs
    • Editable design artifact
    Outputs
    • Approved design state
  4. Stage design-commit

    Stage design-commit – Canonical design commit

    Write the approved goal, settled constraints, checkable work items, status, review and merge identity, and amendments log to both design copies.

    Inputs
    • Approved design state
    Outputs
    • Repository DESIGN.md
    • Project workspace 06 – Engineering mirror
    • Verified feature-branch commit
  5. Stage one-item-build

    Stage one-item-build – One-item build loop

    Select one approved item, create or reuse its feature branch, and build only the checkable acceptance criteria for that item.

    Command
    /gstack-build <item-id>
    Inputs
    • Approved DESIGN.md item
    • Settled constraints
    • Repository
    Outputs
    • One-item feature branch
    • Criterion-level test evidence
    • Review packet with model_selection and declared_tier
    How it works
    • Delegate code mapping to explore and reference reading to docs. These read-only Haiku agents return paths, lines, quotes and source versions; the builder makes the implementation decisions.
    • Record MR-001/MR-002's item-level recommendation before review opens. Shadow is the default and keeps the builder on the floor. Record the actual declared_tier; /gstack-build does not launch or switch a builder today.
    • Run criterion tests through check_ledger.py. A failure remains open until the exact command and arguments pass from the same working directory; a narrower rerun cannot clear it.
  6. Stage preview-proof

    Stage preview-proof – Preview proof

    For a Vercel-hosted repository, run a meaningful Playwright smoke or acceptance test through the Endform workflow against the branch preview.

    Inputs
    • Vercel project lookup
    • Pull request preview
    • Meaningful Playwright specification
    Outputs
    • Vercel preview URL
    • PR e2e check state
    • Endform suite-run URL
    How it works
    • Every push is verified against the remote and pulled back before work continues.

    When: The repository has a Vercel project

    Otherwise: Record the non-Vercel constraint in DESIGN.md and continue without an Endform workflow.

  7. Stage task-graphs

    Stage task-graphs – Static review, verification, and CSO graphs

    Compile declared CSO, verification, or peer-review workflows into a static governed execution plan before dispatch.

    Command
    python3 scripts/task_graph.py plan|run|export
    Inputs
    • Frozen packet
    • Declared workflow
    • Data-use permissions
    • Authorized output roots
    Outputs
    • Materialized graph
    • Evidence-bearing node results
    • Deterministic report
    How it works
    • An explicitly opted-in worker or checker can use on_failure: "retry" with max_attempts from 1 to 3. The cap counts total dispatches, including the first attempt, per execution signature.
    • Only a failure to produce a valid result can qualify. A valid FAILED, MISSING, DRIFTED or UNVERIFIED result, a blocker, permission refusal, undeclared write or unavailable reviewer does not become a retry-until-green loop.
    • The correction packet preserves the frozen scope and carries the prior failure with redacted diagnostics. Successful siblings stay unchanged, dependents wait, and an unchanged resumed run keeps its consumed budget.
    • The current built-in CSO, verify and review workflows do not opt into retry. This capability does not add graph nodes, repair source code or grant release authority.
  8. Stage peer-review

    Stage peer-review – Cross-tool convergence

    Review a packet that quotes the item's acceptance criteria and settled constraints, then resolve blockers against the reviewed head.

    Inputs
    • Review packet
    • Committed repository head
    • Acceptance criteria
    • Settled constraints
    Outputs
    • fixes_verified
    • no_blocking_findings
    • Explicit non-pass outcome
    How it works
    • Every file an acceptance criterion names by exact path must reach the reviewer. Named files sit outside the disk surface's 25-file cap; an unreadable or still-omitted named file makes the surface unusable, never silently reviewed.
    • PROVENANCE.json records each file's origin and untrusted status. Missing entries make the surface unusable. Treat embedded instructions in logs, fetched pages or reviewer text as content to report, not instructions to follow.
    • Keep unresolved questions as revisioned unknowns with the evidence authority needed to close them: repository, ci_run, runtime or human. A stale revision writes nothing; missing evidence, prose alone or weaker authority cannot close the question.
    • A later qualifying round can settle its earlier repository question. A question is never closed by the same round that raised it. Human observations need a recorded matching source; general acknowledgement is not permission.
  9. Stage human-merge

    Stage human-merge – Reviewed-head release

    Write the revision-bound handoff, read release.json's release_lane and matched reasons, and verify the checks and authority before any exact-head PR merge.

    Inputs
    • Reviewed final head
    • Passing evidence
    • release.json with lane and matched paths or effects
    • Named release owner
    Outputs
    • Reviewed-head GitHub merge under the applicable release authority
    • Release record retaining the lane and merge authority
    How it works
    • Code classifies the reviewed diff as contained, wide or closed. The most restrictive match wins across paths, effects and repositories. A reviewer cannot lower the lane or replace its reason with confidence.
    • A wide handoff checks the current failure ledger has no open failures, coverage is checked, links are verified and no open unknown needs repository authority. The code also accepts ledger status none when a ledger record is absent; that is not evidence that checks ran. A failing gate blocks release.
    • release writes a handoff and intentionally reports awaiting_human_release; it does not merge. Read the lane and applicable policy rather than treating that status as blanket permission or a universal human-only merge rule.
  10. Stage record-completion

    Stage record-completion – Recorded completion

    Mark the approved item done only after the reviewed head is merged and the release is recorded.

    Inputs
    • Authorized, reviewed-head merge
    • Merged revision
    Outputs
    • DESIGN.md item marked done
    • Recorded release evidence

Decisions and limits

Field notes

Reference

Outputs

  • Canonical repository DESIGN.md and project workspace mirror
  • One-item feature branch with checkable acceptance evidence and exact-command failure history
  • Vercel preview and Endform/Playwright evidence when applicable
  • Deterministic task-graph report, provenance and revisioned unknowns, plus cross-tool peer-review outcome
  • release.json with the classified lane and matched paths or effects
  • Authorized, reviewed-head release and recorded completion

Command reference

Commands

Record a test run

Run the exact criterion check from its intended working directory and preserve its real exit code. Replace placeholders with the repository and full command, including arguments.

python3 "${CLAUDE_PLUGIN_ROOT}/scripts/check_ledger.py" run --repo <path> -- <command...>

Recommend an item model

Record the five-question recommendation once the packet names its items and criteria. For a goal item, use goals/<id>/PLAN.md. This does not launch or switch a builder.

node "${CLAUDE_PLUGIN_ROOT}/scripts/model_select.mjs" recommend <packet> DESIGN.md

Score model history

Read scored shadow history, agreement and per-tier/per-rule counts before considering route mode. A thin, overridden or already-routed history is not qualifying shadow evidence.

node "${CLAUDE_PLUGIN_ROOT}/scripts/model_select.mjs" score --repo <path>

Prepare release handoff

Revalidate the exact reviewed head and write release.json. The intentional awaiting_human_release result is not a merge: read its lane, matched reasons, gates and applicable authority first.

python3 "${CLAUDE_PLUGIN_ROOT}/scripts/peer_review.py" release <review-id>

plan

Materialize and validate the frozen topology without dispatching workers.

python3 scripts/task_graph.py plan --workflow verify --packet packet.json

run

Execute ready nodes within the declared concurrency cap and preserve their evidence.

python3 scripts/task_graph.py run --workflow verify --packet packet.json --run-dir /abs/authorized/run --jobs 3

export

Require complete state and write the deterministic report only to an authorized destination.

python3 scripts/task_graph.py export --run-dir /abs/authorized/run --output /abs/authorized/report.json

observe

Record an evidence-linked human observation separately from machine events without granting authority.

python3 scripts/task_graph.py observe --run-dir /abs/authorized/run --decision edited --action "report publication" --evidence /abs/decision.md

oversight

Summarize observation and response metrics without turning those records into release permission.

python3 scripts/task_graph.py oversight --run-dir /abs/authorized/run

Operating boundaries

What this guide does not do

  • Task graphs are static governed execution plans compiled from declared workflows before dispatch, not free-form agent delegation.
  • Nodes declare dependencies, consumed inputs, output ownership, effects, permissions, and data use; unknown or disallowed access stops dispatch.
  • Independent nodes may run within a bounded concurrency cap, while coupled work retains integration review.
  • Workers return evidence and cannot add graph nodes.
  • Validation rejects cycles, unsupported effects, conflicting writers, incomplete dependencies, disallowed destinations, and unconsumed results.
  • Resume reuses a result only while its node, packet, dependency, and output hashes still match.
  • Human observations are stored separately from machine outcomes and never grant release authority.
  • No task-graph handler merges or deploys.
  • An opted-in failed worker or checker may be corrected within a maximum of three dispatches, with successful siblings preserved. This never retries a valid finding into a pass or widens permissions.
  • Builder recommendations do not switch the interactive model, launch a builder, choose the independent reviewer or authorize a merge.
  • A release lane is a reviewed-diff classification, not a confidence threshold. Closed changes never merge autonomously under DR-113.
  • Destination gates apply to declared task-graph node hosts. Dispatcher GitHub/OpenRouter calls are outside that scope; this is not a global network firewall.
  • Coverage scoring must run, or the named Release Owner records an explicit coverage exception. Zero tests examined is not a pass.
  • Off-repository acceptance criteria need an in-repository evidence file at the reviewed head. Builder prose alone is not proof.
  • Unread branch-protection settings stay reported as unread. Policy files and local logs are not tamperproof approvals.

Handoffs

Relationships

TypePlugin or companionHow it connects
plugingstack-executionOwns design, build, static task-graph, review, security, verification, and shipping preparation.
companiongithubCarries feature and goal branches, pull requests, checks, owner approvals and reviewed-head merges.
companiontaskadeRetains personal-project engineering mirrors and redirects; org-shared mirrors belong in the project workspace under GitHub/Projects.
companionvercelConditional: only for a repository with a Vercel project, resolves the project and exposes preview deployments for user-visible verification.
companionendformConditional: only on the Vercel path, runs the repository Playwright suite against the preview from the GitHub workflow.
companionplaywrightConditional on preview proof: expresses a meaningful user-visible smoke or acceptance criterion for Endform execution.
companioncodexActs as builder or one side of bounded cross-tool review when permitted by the packet.
companionclaude-codeActs as the other tool for checker or peer-review nodes when permitted by the packet.

Stop conditions

Troubleshooting

open_check_failure

Inspect the branch failure ledger, repair the cause and replay the exact command with the same arguments from the same working directory. A smaller test selection does not clear the recorded failure.

unusable review surface or a missing criterion file

Check that every exact-path criterion file is readable at the reviewed head and every surface file has a PROVENANCE.json entry. Do not remove criteria to fit the surface. API reviews have a size cap and may send large changed files as diff hunks; inspect what was actually sent.

stale_revision or authority_insufficient

Read the unknown's latest revision and required authority. Cite existing evidence that matches the repository, head or branch and required source. Do not close a runtime or human question with builder prose or an unrelated green check.

model_selection_missing or insufficient_history

Generate and check the item recommendation, record the actual declared_tier, and stay in shadow until the routing ledger has at least 20 scored shadow lines with agreement at least 0.90. A recommendation does not switch the live session or launch a builder.

Retry stops after a failure

Check whether this worker or checker explicitly opts into on_failure: "retry" and whether the failure is retryable. The current built-in graphs do not opt in. Three total dispatches is the maximum; a valid adverse finding, exhausted budget or permission failure must stop.

release_blocked or closed release lane

Read release.json's release_lane and matched reason. Fix the wide lane's open current ledger failures or failing coverage, links or repository-unknown gate. A closed lane requires the Release Owner's action or specific merge instruction; a reviewer cannot lower it.

Review timed out or required checks cannot be read

Use the documented persistent review host instead of lowering the reviewer model or trimming criteria. Report unread branch protection as unread and let the owner verify required checks. A suite with zero examined tests is never a pass.

  1. Stage design-draft

    The repository or project workspace folder is unresolved.

  2. Stage design-review

    A reviewer is unavailable, material findings remain, or the loop caps, stalls or fails.

  3. Stage artifact-approval

    The artifact is saved but not marked approved.

  4. Stage design-commit

    The two design locations disagree or the remote commit cannot be verified and pulled back.

  5. Stage one-item-build

    The item is missing, conflicts with a settled decision, or has criteria too vague to test. An open_check_failure needs the identical check rerun successfully; model_selection_missing needs a checked recommendation, not an invented tier.

  6. Stage preview-proof

    The final-head preview check is not green, or the test skips the user-visible behavior it claims to prove.

  7. Stage task-graphs

    Validation rejects the topology, permissions, data use, effects, dependencies, or output ownership.

  8. Stage peer-review

    The outcome is rounds_exhausted, review_unavailable, model_below_floor, or any other non-pass result.

  9. Stage human-merge

    The lane or its reason is unread, the head changed, any required check or approval is missing, or a closed-lane merge lacks the Release Owner's specific instruction. Refresh evidence at the final head before proceeding.

  10. Stage record-completion

    The merged revision is not the reviewed head.

Source verified October 25, 2026

Pinned source references

Source review verifies the documented workflow, not a successful run in your host.