executing-plans

# Executing Plans

## Overview

Load plan, review critically, execute all tasks, report when complete.

**Announce at start:** "I'm using the executing-plans skill to implement this plan."

For non-trivial execution, include `Aegis Visibility`: briefly tie the active
slice to its plan, checkpoint, drift or verification boundary. At completion,
pass plan adherence, evidence, complexity and residual risk to
`verification-before-completion` for the unified receipt.

If subagents are available and the plan has genuinely independent tasks,
prefer `subagent-driven-development`; lack of subagent support does not block
inline execution. Same-task agents share one workspace, and the coordinator
remains the only Git mutation owner.

## The Process

### Step 1: Load and Review Plan
1. Read plan file
2. If the plan or active checkpoint includes an `Execution Readiness View`,
   read it before implementation and compare the plan against its intent lock,
   scope fence, baseline lock, owner / contract constraints, compatibility
   boundary, retirement boundary, test obligations, review gates, drift /
   rewind rules, and evidence required before completion.
3. Review critically - identify any questions or concerns about the plan
4. If the view contradicts the plan, baseline, or current worktree evidence,
   return to plan review or refresh the advisory handoff before editing.
5. Run the TDD Route Guard before implementation: confirm `Mode`, `Decision`, `Strict authority`,
   strict signals, light eligibility, `Test posture`, and verification. Strict
   steps require either an explicit user/project request or a recorded auto
   decision; plan approval or risk labels alone are not authority. An
   off-mode missing record may be repaired only as `Mode: off / Decision:
   skipped` without loading TDD. Missing/unsupported auto decisions return to
   plan review. An auto-light record is unsupported when any strict signal is
   present or when its tiny/low-risk/single-owner/no-behavior-change proof is
   incomplete. Only `Decision: strict` with recorded strict authority may
   authorize steps named `Write failing test`, `Verify RED`, `GREEN`, or
   `REFACTOR`. Do not infer `strict` during execution.
6. If concerns: Raise them with your human partner before starting
7. Before the first write, capture `TaskStartSnapshot`: root, `HEAD`, branch or
   detached state, upstream divergence, staged/unstaged/untracked paths, active
   Git operations, and `git worktree list --porcelain`. Preserve task-preexisting
   state; do not stash, reset, clean, or commit it.
8. Reuse the current branch unless rules require independent history or another
   goal owns it. If justified, switch/create it in the
   current workspace when safe; a worktree still requires
   concurrent checkout or blocking dirty state.
9. If no concerns: Create TodoWrite and proceed

### Step 1.5: Long-Task Checkpoint Setup

If the plan has multiple tasks, may span sessions, or includes architecture / contract / workflow changes:

1. Announce: "I'm using the long-task-continuation skill to keep this plan checkpointed and drift-aware."
2. Load aegis:long-task-continuation.
3. Create the initial checkpoint from the plan:
   - current todo
   - active task
   - completed tasks
   - evidence refs
   - blockers
   - next step
4. Before each task, restate the current checkpoint.
5. After each task, update checkpoint, evidence refs, and drift check.

Before a verification-driven unplanned edit, read retained `PatchShape`,
`CanonicalOwner`, `UpwardDrillSignal`, outcome, and evidence refs. Route their
comparison with the candidate to `systematic-debugging` before editing; it
decides whether the directions converge. A proven independent canonical-owner
root stays on the normal plan path.

### Step 2: Execute Tasks

For each task:
1. Mark as in_progress
2. Follow each step exactly (plan has bite-sized steps)
3. Before any new source-code path is added by a task, restate the plan's
   `Change Necessity` or create a compact one if the plan failed to carry it
   forward. Plan approval is not by itself proof that a new helper, small guard,
   new branch, fallback, adapter, or owner is necessary.

   ```text
   Change Necessity:
   - User-visible need:
   - No-change / non-code option:
   - Why code change is necessary:
   - Minimum change boundary:
   - Decision: no-change | docs/config-only | code-change | needs-clarification
   ```

   If the decision is not `code-change`, pause execution and return to plan
   review instead of editing. If the decision is `code-change`, carry the
   minimum boundary into the edit and verification scope.
4. Before any non-trivial source edit, run the plan's
   `Pre-Edit Complexity Check` or create a compact one:

   Use `using-aegis/references/complexity-governance.md` for shared artifact
   classes, pressure signals, and `over-budget` handling.

   ```text
   Complexity Budget:
   - Artifact class:
   - Target files / artifacts:
   - Current pressure:
   - Projected post-change pressure:
   - Budget result: within-budget | at-risk | over-budget
   - Planned governance:

   Pre-Edit Complexity Check:
   - Target edit file:
   - Existing pressure signal:
   - Safer edit boundary:
   - Decision: edit-in-place | extract helper | add owner file | split task | pause for plan update

   Pre-Edit Owner-Fit Decision:
   - Edit intent: wiring-only | move-out / extract-first | local-fix-without-new-responsibility | new-responsibility | emergency / compatibility patch
   - Owner fit:
   - Safer edit boundary:
   - Decision: edit-in-place | extract helper | add owner file | split task | pause for plan update
   ```

   If the check contradicts the plan's file boundary, pause and return to plan
   review instead of silently stuffing logic into an overloaded owner. If the
   budget result is `over-budget` and the task does not also govern that
   overrun, stop execution and return to plan review rather than pushing the
   task through as if it wer