beo-execute

Purpose

Deliver one approved execution set.

Primary owned decision

Implement the selected approved execution set inside the current approval envelope.

Ownership predicate

• Readiness is PASS_EXECUTE.
• Exactly one approved execution set is selected.
• Approval is current and bounds every bead in the execution set.
• Root cause is proven for every bug-fix bead in the set, or each bug-fix bead's scope is bounded to a confirmed defect location requiring no diagnostic decision.
• Execution-set mode is single, ordered_batch, or local_parallel.
• Local parallel execution has disjoint write scopes, disjoint generated outputs, and no dependency edge.
• For ordered_batch or local_parallel, partial-progress behavior is governed by canonical partial_progress_allowed in STATE.json and readiness-record.json.
• Absent, null, missing, or stale partial_progress_allowed in either surface is treated as false.

Execution Set Card

When claiming an execution set, confirm and record the following. This card is operator-facing only; canonical fields are in STATE.json and execution-bundle.json.

Execution Set Card:
  display_execution_set_id: <from STATE.json>
  display_mode: single | ordered_batch | local_parallel
  display_selected_beads: [<bead_ids in execution sequence>]
  display_approval_ref: <path to approval-record.json>
  display_changed_files_target: [<approved declared files per bead>]
  display_blocked_or_queued: [<bead_ids not in this set>]
  display_partial_progress_allowed: <from STATE.json/readiness-record.json>
Authority note: display-only; canonical authority remains in the referenced state/artifact surface.

Writable surfaces

• Code and tests required by the selected execution-set beads only.
• Selected bead status/evidence surfaces for every bead in the execution set, as allowed by execution procedure and status mapping.
• Review evidence bundle fields for changed files, verification, and approval reference.
• Shared state/handoff fields allowed by beo-reference → skill-contract-common.md.

Local parallel

local_parallel is local-only parallelism inside one loaded beo-execute owner; see beo-reference → pipeline.md and references/execution-operations.md.

Preflight before mutation

For the operator-facing runtime preflight checklist, see beo-reference → operator-card.md. The checklist is display guidance only; this skill's hard stops and canonical references remain authoritative.

Detailed claim, flush, re-read, checkpoint, verification, and completion steps live in references/execution-operations.md. This skill owns the execution contract boundary; the appendix owns the local operation sequence after beo-execute has already been selected.

Before mutation, verify the execution envelope from:

• beo-reference → approval.md
• beo-reference → state.md
• references/execution-operations.md

Local hard stops:

• do not mutate without current PASS_EXECUTE
• do not mutate outside approved declared file scope
• do not coordinate workers or external agents
• do not continue after stale approval or unproven root cause

Hard stops

• Apply the canonical go-mode handoff gate from beo-reference → go-mode.md; if persistence evidence is absent or false, clear go-mode before normal gates.

Missing-field hard stop

• If any of approval_ref, execution_set_id, or execution_set_beads is missing from canonical state or readiness record, or if STATE.json.execution_mode / readiness-record.json.execution_set_mode is missing, do not infer from PLAN.md or br. Return to beo-validate or beo-route by freshness evidence.

Scope and approval

• Do not broaden scope beyond the selected execution set or approval envelope.
• Do not self-approve readiness, execution-set membership, ordering, or local-parallel safety.
• If approval becomes stale before mutation, stop and return to the canonical validate/approval flow before any pass or implementation continues.
• If approval becomes stale after mutation begins, stop immediately and hand off through the stale-after-mutation decision tree in beo-reference → approval.md; do not keep implementing to finish first and do not re-enter execute directly.
• Do not begin mutation without re-verifying PLAN.md and CONTEXT.md content hashes against the approval record; a hash mismatch aborts execution and routes to beo-validate.

Execution-set integrity

• Do not claim unrelated ready beads merely because they are convenient.
• If any bead to be claimed now is already claimed or reserved, abort and record bead-conflict evidence unless durable same-worktree evidence proves this is a stale interrupted claim: HANDOFF.json with created_by_owner=beo-execute for this execution set, or a non-final execution-bundle.json for that exact execution set with ready_for_review=false. Without matching durable evidence, route to user.
• After claiming, if claim + flush + re-read does not show both status=in_progress and label reserved for every bead claimed in this claim step, abort immediately, release only claims created by this attempt, and record bead-conflict evidence.

Parallel and partial progress

• Do not execute two beads concurrently when write scopes, generated outputs, dependency edges, approval refs, or dirty-worktree evidence conflict.
• Do not use external worker dispatch, reservations, heartbeat protocols, or routing. Mirror of canonical rule. If this conflicts with beo-reference → pipeline.md, the named canonical reference wins.
• If any bead in a multi-bead execution set blocks, do not continue unaffected beads unless canonical readiness-record.json and STATE.json both explicitly have partial_progress_allowed=true, and live execution evidence still proves the conditions defined in beo-reference → state.md and beo-reference → artifacts.md hold. If either surface is absent, null, missing, stale, or otherwise not explicitly true, stop the set and route blocker evidence through the legal owner.
• If STATE.json.partial_progress_allowed and readiness-record.json.partial_progress_allowed disagree, treat partial progress as false. Mirror of canonical rule. If this conflicts with beo-reference → state.md, the named canonical reference wins.
• Stop the execution set on a partial-progress mismatch. Route to:
  • beo-debug when a live blocker has unproven root cause.
  • beo-validate when the mismatch is a readiness/state consistency problem and no diagnostic proof is needed.
  • beo-route only when owner state is also stale, contradictory, or colliding.

Debug and rollback

• Do not continue an affected bead after unproven root cause blocks safe implementation; return blocker evidence through beo-debug.
• When rollback of the current bead's mutation is needed before re-routing, limit rollback to that bead's declared changed files only; do not rollback prior beads or files outside declared scope without explicit plan authorization.
• When routing to beo-debug, write debug_return.return_to to STATE.json before handoff so beo-debug can return to the correct owner.
• When beo-debug returns with retry_without_change or return_to_execution_for_scope_check, re-read STATE.json.debug_return and re-verify approval and scope before resuming mutation; do not infer that prior PASS_EXECUTE is still valid after a debug round-trip.

Do not emit ambiguous review or plan routing after stale approval is detected post-mutation.

Return deterministic evidence:

• route to beo-review when scope impact must be assessed from the execution bundle/live diff
• route to beo-plan only when plan/file-scope/verification repair is already proven necessary
• otherwise route to beo-route for owner-state resolution

Allowed next owners

• beo-review
• beo-debug
• beo-plan
• beo-validate
• user
• beo-route — only for exceptional owner-state resolution under canonical route doctrine.

References

• beo-reference → approval.md — read when checking execution envelope or invalidation.
• beo-reference → artifacts.md — read when updating review evidence bundle fields.
• beo-reference → cli.md — read when using shared br/bv command forms.
• beo-reference → pipeline.md — read when handing off after execution.
• beo-reference → status-mapping.md — read when updating bead status or labels.
• references/execution-operations.md — read when following the local execution loop and exit evidence shape.