renatocaliari/cali-scope-executor

Execution Executor

Autonomous plan execution orchestrator. Reads an approved plan, parses each scope by type, dispatches to the right executor, and consolidates results.

---

Input

The skill operates on the approved plan document at .cali-product-workflow/{YYYY-MM-DD}/{_dir}/plans/spec-tech_{v}.md.

The plan must contain scopes with type annotations:

• [TYPE] feature — implement new functionality
• [TYPE] optimization — improve a measurable metric (must include [METRIC])
• [TYPE] spike — research or prototype

---

Role

You are an execution orchestrator. Your job is to execute every scope correctly, in dependency order, using the right tool for each type.

---

Workflow

Step 1: Read and parse the plan

Read the approved plan file. Identify every scope and its type. Build an execution plan respecting dependencies.

Step 2: Resolve executor per scope

| [TYPE] | [EXECUTOR] | Result | |---|---|---|---| | feature | absent → worker | | feature | research → autonomous research loop (override) | | optimization | absent → autonomous research loop | | optimization | worker → worker (override) | | spike | absent → scout + researcher | | spike | research → autonomous research loop (override, rare) |

About the research loop: "Autonomous research/experimentation" refers to any tool in your environment that can run iterative optimization experiments with a measurable metric target. If available, prioritize pi-autoresearch (davebcn87) — it is purpose-built for optimization scope execution. Otherwise, set up a manual delegated worker loop with: iterate → measure → compare → stop when target met.

Step 3: Report the execution plan

Before executing, present a clear execution plan to the user and ask: "Shall I proceed with autonomous execution? I'll report back when all scopes are complete."

If yes, proceed autonomously. If no, ask what to adjust.

Step 4: Execute feature scopes (feature → worker)

For each scope resolved to worker:

1. Spawn worker with the scope's DoD and ACs as the task
2. After worker completes, run parallel review using independent reviewers:
   • Reviewer 1: "Review diff for correctness and regressions"
   • Reviewer 2: "Review diff for simplicity and code quality"
3. Apply feedback and fix issues
4. Mark scope as complete

Step 5: Execute optimization scopes (optimization → research)

For each scope resolved to autonomous research loop:

1. Set up experimentation loop — configure metric target, command, constraints
2. Set stopping condition: target met or iterations exhausted (10-20 default)
3. Run parallel review on completed changes
4. Mark scope as complete

Step 6: Execute spike scopes (spike → scout + researcher)

For each scope resolved to scout:

1. Run parallel investigation:
   • Scout: "Investigate existing codebase for relevant files and patterns"
   • Researcher: "Research best practices and solutions with pros/cons"
2. Consolidate findings into recommendation document
3. Mark scope as complete

Step 7: Handle dependencies

• Independent scopes can run in parallel
• Dependent scopes must wait for completion
• Reasonable concurrency: 2-3 parallel scopes maximum

Step 8: Compliance Check

Before final report, cross-reference the original plan with what was executed:

1. Every scope executed? Document skipped scopes
2. Every scope met its DoD? Document gaps
3. Principles from references/tech-planning/ followed?

Step 9: Report results

Produce consolidated report at .cali-product-workflow/{YYYY-MM-DD}/{_dir}/execution-report.md

---

Error Handling

• Worker fails: log error, move to next scope. Don't block on single failure.
• Reviewer finds blocking issues: flag them, continue execution, include in final summary.
• Spike is inconclusive: document what was learned, recommend next steps.

---

Execution Modes

| Mode | Behavior | |---|---| | Full autonomous | Execute all scopes without pausing. Report at the end. | | Scope-by-scope | Execute one scope, present results, ask to proceed. |

Default: Full autonomous.

---

How to invoke

Load this skill by reading its file (skills-execution/cali-product-scope-executor/SKILL.md) and following its instructions.

To invoke as a worker from a parent agent:

Use a parallel worker/delegate agent with task:
"Execute the approved plan at .cali-product-workflow/{...}/spec-tech_{v}.md
using the scope-executor instructions. Route each scope and save the report."

---

Interaction with Environment

| Capability | How this skill uses it | |---|---| | Worker (feature implementation) | Implements feature scopes | | Reviewer (code review) | Reviews implementation diffs | | Scout (codebase investigation) | Investigates codebase for spike scopes | | Researcher (external research) | External research for spike scopes | | Autonomous research loop | Sets up optimization experiment loops | | Progress tracking | Tracks each scope as a unit of work with DoD | | Execution supervision | Keeps execution on track |

---

Output Expectations

Strong execution:

• Respect dependency order
• Use the right executor for each type
• Handle failures gracefully
• Produce clear final report

Weak execution:

• Run everything sequentially when parallel is safe
• Use worker for optimization scopes
• Ignore scope types
• Block on minor failures