/autoplan

Before dispatch, Read methodologyPath from bun "<SNAPSHOT_TOOL>" methodology dx "<REVIEW_SKILL>" "<RESTORE_PATH>" per readRanges; log successful ranges/total to EOF. Skip-listed: load only.

Override rules:

• Mode selection: DX POLISH

• Persona: infer from README/docs, pick the most common developer type (P6)

• Competitive benchmark: research through Aside per the loaded skill's "Web research runs in Aside" section (WebSearch when Aside is not ready); use the reference benchmarks when neither is available (P1)

• Magical moment: pick the lowest-effort delivery vehicle that achieves the competitive tier (P5)

• Getting started friction: always optimize toward fewer steps (P5, simpler over clever)

• Error message quality: always require problem + cause + fix (P1, completeness)

• API/CLI naming: consistency wins over cleverness (P5)

• DX taste decisions (e.g., opinionated defaults vs flexibility): mark TASTE DECISION

• Dual voices: always run BOTH Claude subagent AND Codex if available (P6).

  Bind phase input: Run; use snapshotPath as <DX_INPUT> for both voices:

bun "<SNAPSHOT_TOOL>" create dx "<ACTIVE_PLAN>" "<RESTORE_PATH>" "<methodologyPath>"

Fresh Implementation plan only; excludes Review record.

Claude DX subagent (native 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 <DX_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.

Codex DX voice (via Bash): Outside prompt: inline the full contents of <DX_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.

Read the plan file at <DX_INPUT>. Evaluate this plan's developer experience.

Also consider these findings from prior review phases: CEO: <insert CEO consensus summary> Design: <insert Design consensus summary, or 'skipped, no UI scope'>

You are a developer who has never seen this product. Evaluate:

1. Time to hello world: how many steps from zero to working? Target is under 5 minutes.
2. Error messages: when something goes wrong, does the dev know what, why, and how to fix?
3. API/CLI design: are names guessable? Are defaults sensible? Is it consistent?
4. Docs: can a dev find what they need in under 2 minutes? Are examples copy-paste-complete?
5. Upgrade path: can devs upgrade without fear? Migration guides? Deprecation warnings? Be adversarial. Think like a developer who is evaluating this against 3 competitors.

Write the complete prompt and context, including actual plan/spec/source, to a private file. Substitute its shell-quoted path for <prepared-prompt-file>; never interpolate user text into shell source. Request a final Recommendation: <action> because <specific reason> line, including an explicit no-findings rationale.

# GSTACK_ACTIVE_HOST names the harness, never the model.
if { [ -n "${CODEX_THREAD_ID:-}" ] || [ -n "${CODEX_SANDBOX:-}" ] || [ "${GSTACK_ACTIVE_HOST:-}" = codex ]; }; then
  echo 'Codex outside review unavailable: harness mismatch; no outside process started. Missing coverage.' >&2
  if { [ -n "${CLAUDECODE:-}" ] || [ "${GSTACK_ACTIVE_HOST:-}" = claude ]; } && { [ -n "${CODEX_THREAD_ID:-}" ] || [ -n "${CODEX_SANDBOX:-}" ] || [ "${GSTACK_ACTIVE_HOST:-}" = codex ]; }; then
    echo 'Inherited harness markers conflict. Run setup --host <actual-harness> (claude or codex); do not guess a replacement provider.' >&2
  else
    echo 'Repair installed skills: run setup --host codex from your gstack checkout.' >&2
  fi
  exit 78
fi

_REPO_ROOT=$(git rev-parse --show-toplevel) || { echo 'ERROR: not in a git repo' >&2; exit 1; }
_OUTSIDE_TMP=$(mktemp -d "${TMPDIR:-/tmp}/gstack-outside.XXXXXXXX") || exit 1
trap 'rm -rf "$_OUTSIDE_TMP"' EXIT
_OUTSIDE_INPUT="$_OUTSIDE_TMP/prompt"
cat -- '<prepared-prompt-file>' >"$_OUTSIDE_INPUT" || exit 1

source "$HOME/.claude/skills/gstack/bin/gstack-codex-probe" || exit 1
_OUTSIDE_PROMPT=$(cat "$_OUTSIDE_INPUT") || exit 1
_OUTSIDE_EXIT=0
_gstack_codex_timeout_wrapper 600 codex exec "$_OUTSIDE_PROMPT" -C "$_REPO_ROOT" -s read-only -c "model=\"${GSTACK_CODEX_MODEL:-gpt-6-astra}\"" -c 'model_reasoning_effort="high"' -c 'web_search="cached"' < /dev/null >"$_OUTSIDE_TMP/text" 2>"$_OUTSIDE_TMP/stderr" || _OUTSIDE_EXIT=$?
# Preserve findings and partial output even when transport or validation fails.
cat "$_OUTSIDE_TMP/text" || { [ "$_OUTSIDE_EXIT" -ne 0 ] || _OUTSIDE_EXIT=1; }
if [ "$_OUTSIDE_EXIT" -eq 124 ]; then
  _gstack_codex_log_event "codex_timeout" "600" || true
  _gstack_codex_log_hang "autoplan" "0" || true
fi
cat "$_OUTSIDE_TMP/stderr" >&2 || { [ "$_OUTSIDE_EXIT" -ne 0 ] || _OUTSIDE_EXIT=1; }
if [ "$_OUTSIDE_EXIT" -ne 0 ]; then
  echo 'Codex outside review unavailable: execution failed; missing coverage. Check the provider diagnosis above.' >&2
  exit "$_OUTSIDE_EXIT"
fi
bun "$HOME/.claude/skills/gstack/lib/outside-review-result.ts" review "$_OUTSIDE_TMP/text" || exit 1

echo 'OUTSIDE_STATUS: completed provider=codex host=claude'

Show the full response in a tool-output fence. Require successful execution and valid markers. Refusal, empty/malformed output, missing score/severity/completion markers, timeout or CLI failure means outside_status: unavailable. Use the caller's fallback; missing coverage is never clean/PASS. After either outcome, delete only your private prompt; scratch cleanup is automatic.

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

Retain the historical review-log skill ID; add "host":"claude","outside_provider":"codex","outside_status":"completed|unavailable|disabled|skipped","phase":"dx". Record differing attempt outcomes separately. source:"codex" requires completed CLI output; native uses source:"in-host" (historical source:"claude": native Claude). Availability/native fallback is not outside completion. Preserve all reported modelUsage; unknown model identity stays unknown.

Error handling: Phase 1 failure/degradation policy applies.

• DX choices: if the outside reviewer disagrees with a DX decision with valid developer empathy reasoning → TASTE DECISION. Scope changes both models agree on → USER CHALLENGE.

Required execution checklist (DX):

1. Step 0 (DX Scope Assessment): Auto-detect product type. Map the developer journey. Rate initial DX completeness 0-10. Assess TTHW.

2. Step 0.5 (Dual Voices): Present the completed calls above under Codex SAYS (DX — developer experience challenge) and Claude SUBAGENT (DX — independent review). Produce DX consensus table:

DX DUAL VOICES — CONSENSUS TABLE:
  Dimension                           Claude  Codex  Consensus
  1. Getting started < 5 min?          —       —      —
  2. API/CLI naming guessable?         —       —      —
  3. Error messages actionable?        —       —      —
  4. Docs findable & complete?         —       —      —
  5. Upgrade path safe?                —       —      —
  6. Dev environment friction-free?    —       —      —
CONFIRMED = native + outside agree; primary cannot replace outside. DISAGREE → taste.
Missing/disabled voice = N/A, never CONFIRMED. Flag any single-voice critical finding.

3. Passes 1-8: Run each from loaded skill. Rate 0-10. Auto-decide each issue. DISAGREE items from consensus table → raised in the relevant pass with both perspectives.

4. DX Scorecard: Produce the full scorecard with all 8 dimensions scored.

Mandatory outputs from Phase 2.5:

• Developer journey map (9-stage table)
• Developer empathy narrative (first-person perspective)
• DX Scorecard with all 8 dimension scores
• DX Implementation Checklist
• TTHW assessment with target

Close this phase:

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

STOP. Before closing a review phase, after its reviews finish and before announcing completion or loading the next phase (read afresh at each exit), Read ~/.claude/skills/gstack/autoplan/sections/phase-close.md and execute it in full. Do not work from memory — that section is the source of truth for this step.