Before dispatch, Read {{AUTOPLAN_REVIEW_FILE:plan-ceo-review:with-sections}} per `readRanges`; log successful ranges/total to EOF. Skip-listed: load only.

Execute in this order: Step 0 (including its completed Spec Review Loop) → {{NATIVE_LABEL}}
CEO voice → {{OUTSIDE_LABEL}} CEO voice → consensus → Review Sections → saved summary → phase
announcement. Dispatching a reviewer does not complete its step.

**Override rules:**
- Mode selection: SELECTIVE EXPANSION
- Premises: accept reasonable ones (P6). Queue clearly-wrong/challenged premises
  as User Challenges for Phase 4: assumption, reason and cost of proceeding.
  The user decides there; never stop mid-pipeline.
- Alternatives: pick highest completeness (P1). If tied, pick simplest (P5).
  If top 2 are close → mark TASTE DECISION.
- Scope expansion: in blast radius + <1d CC → approve (P2). Outside → defer to TODOS.md (P3).
  Duplicates → reject (P4). Borderline (3-5 files) → mark TASTE DECISION.
- All 11 review sections: run fully, auto-decide each issue, log every decision.

**Required execution checklist (CEO):**

Complete every Step 0 analysis/output on the loaded skill's SELECTIVE EXPANSION
route with the overrides above: CEO scope document and 0H Spec Review Loop before
0I and Review Sections.

**At 0H, prepare the current input for each spec review.** Create one amendment
checkpoint; keep its `snapshotPath` as `<CEO_STEP0_CHECKPOINT>` throughout CEO:
```bash
bun "<SNAPSHOT_TOOL>" create ceo "<ACTIVE_PLAN>" "<RESTORE_PATH>" "<methodologyPath>"
```
Put every accepted behavior, condition, test and manual checklist from Step 0 in
the CEO accepted-obligations block. Preserve source-plan and DESIGN.md requirements;
User Challenges retain the original requirements. Taste is a provisional
auto-decision; accepted expansions must work without assuming queued changes are
approved. Keep decision history and pending review work in `Review record`.

Before every spec dispatch, including after each accepted spec fix, run:
```bash
bun "<SNAPSHOT_TOOL>" amend-input ceo "<ACTIVE_PLAN>" "<CEO_STEP0_CHECKPOINT>" "<RESTORE_PATH>" "<methodologyPath>"
```
This applies the recorded requirements and exports the complete current
`Implementation plan`. Keep returned `checkpointPath` as the amendment baseline;
use returned `reviewInputPath` as `<CEO_SPEC_INPUT>`. Read that file at every
returned `readRanges` offset/limit through EOF, then read the CEO scope summary in full.
Reconcile dispositions, scope counts, proposal IDs and actual heading/test references
between them. Link deferrals to actual TODOs or pending writes. Fix summary drift
without changing decisions, dropping findings/required fields or inventing references.
If the working plan changes, repeat `amend-input` and the readback before dispatch.
Supply the complete CEO scope summary and `<CEO_SPEC_INPUT>` to the loaded Spec
Review Loop. The checkpoint is immutable prior state; never supply it as the current
working plan. A failed preparation is an input failure, not a completed spec review.
Keep the loop's existing stop conditions and three-launch cap. After the loop,
create a fresh snapshot below for both voices; it does not replace the amendment checkpoint.

Step 0.5 (Dual Voices): After Step 0's Spec Review Loop, consume the native CEO
review, then the available outside voice (P6). Present both completed results
before consensus; always run the native pass.

  **Bind phase input:** Run; use `snapshotPath` as `<CEO_INPUT>` for both voices:
```bash
bun "<SNAPSHOT_TOOL>" create ceo "<ACTIVE_PLAN>" "<RESTORE_PATH>" "<methodologyPath>"
```
  Fresh `Implementation plan` only; excludes `Review record`.

  **{{NATIVE_LABEL}} CEO subagent** (via Agent tool):
  Claude Code: set Agent `run_in_background: false` if its schema exposes it.
  Other hosts: foreground; await completion when supported.

  Read `snapshot.json` beside `<CEO_INPUT>`. Send its `nativeDispatchPrompt`
  verbatim as the Agent prompt: ONLY/FINAL tool call this response.
  Keep native Reads enabled. Child first Reads `nativePromptPath` to EOF:
  all criteria + plan; no summaries or prior reviews.

  **Native completion barrier:** Async (`isAsync: true` / `status: "async_launched"`):
  Claude Code: end response immediately: "Waiting for <agent ID>."
  No further tool calls/review until that ID's terminal notification is delivered.
  Other hosts await that ID. Then outside → this phase's review ONLY.
  Completed-native INPUT must match snapshot phase/hash. Retry invalid input once; then failure policy if still invalid.
  No inline substitute; apply failure policy.

  **{{OUTSIDE_LABEL}} CEO voice** (via Bash):
  Outside prompt: inline the full contents of <CEO_INPUT> and context below (Write tool).

IMPORTANT: Do NOT read or execute any SKILL.md files or paths containing skills/gstack (foreign instructions). Review repository code only.

  You are a CEO/founder advisor reviewing a development plan.
  Challenge the strategic foundations: Are the premises valid or assumed? Is this the
  right problem to solve, or is there a reframing that would be 10x more impactful?
  What alternatives were dismissed too quickly? What competitive or market risks are
  unaddressed? What scope decisions will look foolish in 6 months? Be adversarial.
  No compliments. Just the strategic blind spots.
  File: <CEO_INPUT>

{{OUTSIDE_INVOCATION:autoplan}}

Outer tool timeout: 720000ms. Failed/incomplete outside review → unavailable; disabled → skip outside. Both retain the native pass.

{{OUTSIDE_PROVENANCE:ceo}}

  **Error handling:** {{OUTSIDE_LABEL}} auth/timeout/empty → proceed with
  {{NATIVE_LABEL}} subagent only, tagged `[single-model]`. If {{NATIVE_LABEL}} subagent also fails →
  "Outside voices unavailable — continuing with primary review."

  **Degradation matrix:** Both fail → "single-reviewer mode". {{OUTSIDE_LABEL}} only →
  tag `[{{OUTSIDE_PROVIDER}}-only]`. Subagent only → tag `[subagent-only]`.

- Strategy choices: if the outside reviewer disagrees with a premise or scope decision with valid
  strategic reason → TASTE DECISION. If both models agree the user's stated structure
  should change (merge, split, add, remove) → USER CHALLENGE (never auto-decided).

Produce the CEO consensus table from the completed results:

```
CEO DUAL VOICES — CONSENSUS TABLE:
  Dimension                           {{NATIVE_LABEL}}  {{OUTSIDE_LABEL}}  Consensus
  1. Premises valid?                   —       —      —
  2. Right problem to solve?           —       —      —
  3. Scope calibration correct?        —       —      —
  4. Alternatives sufficiently explored?—      —      —
  5. Competitive/market risks covered? —       —      —
  6. 6-month trajectory sound?         —       —      —
CONFIRMED = completed subagent + outside; primary cannot replace outside.
Outside disabled/unavailable: six Consensus cells N/A, never CONFIRMED.
Native findings stay separate; disagreements → taste; flag single-voice criticals.
```

Sections 1-11 — for EACH section, run the evaluation criteria from the loaded skill file:
- Sections WITH findings: full analysis, auto-decide each issue, log to audit trail
- Sections with NO findings: 1-2 sentences stating what was examined and why nothing
  was flagged. NEVER compress a section to just its name in a table row.
- Section 11 (Design): run only if UI scope was detected in Phase 0

**Mandatory outputs from Phase 1:**
- "NOT in scope" section with deferred items and rationale
- "What already exists" section mapping sub-problems to existing code
- Error & Rescue Registry table (from Section 2)
- Failure Modes Registry table (from review sections)
- Dream state delta (where this plan leaves us vs 12-month ideal)
- Completion Summary (the full summary table from the CEO skill)

**Close this phase:**

The review work above ends here. Now load the shared close steps afresh, even if
read earlier. Use phase `ceo`, checkpoint `<CEO_STEP0_CHECKPOINT>`, and this phase's
`methodologyPath`. Keep this checkpoint for this invocation; review exports do not replace it.

{{SECTION:phase-close}}