/claude-plan

name: claude-plan
description: >-
  Get an independent architecture/implementation plan from Anthropic Claude
  (Fable, a different vendor's model) running Claude Code's native plan mode,
  from inside a non-Claude host such as Codex. Use mid-execution when work hits
  a genuine design fork or high-stakes decision that should not be settled
  unilaterally. Not for routine planning — that stays in the host's own plan
  tooling. Explicit invocation only. Triggers: "claude plan", "ask fable for a
  plan", "fable planning", "问 fable", "让 fable 出方案", "外脑出方案".

claude-plan — independent plan from Claude's plan mode

The host model planning its own work shares its own blind spots. A different-vendor model (Anthropic Claude, pinned to Fable) has a different training distribution, so where its plan diverges from yours is exactly where to dig. This skill runs the Claude Code CLI (`claude -p`) in Claude's **native plan mode** — read-only at the permission layer, with Claude's internal research-then-plan steering — and presents the plan **verbatim**.

The consult is **stateless**: Claude cannot see the host session transcript. Everything it needs must travel in the decision brief. If you cannot write the brief, the question is not ready to be asked — that filter is a feature.

When to use

• Mid-execution, a design fork appears that the host should not settle

unilaterally (irreversible structure, cross-module contract, risky migration).

• A high-stakes decision needs a cross-vendor second plan before committing.

When NOT to use

• Routine planning: use the host's own plan tooling (Codex Plan mode, /think).
• Planning known before the task starts: plan in a Claude session directly and

hand off via a file-backed plan; do not call back mid-run.

• Anything answerable by reading the repo for five minutes.

Fable shares the main Claude quota pool — every consult is a full session. One consult per fork; do not iterate plans through repeated calls.

Step 0 — Preflight (binary)

command -v claude >/dev/null 2>&1 || {
  echo "[claude-plan] Claude Code CLI not found. Install from https://claude.com/claude-code (then sign in). Skipping."
  exit 0
}

If this prints the skip message, tell the user Claude Code is not installed and stop.

Step 1 — Compose the decision brief

Write the brief yourself (the host orchestrator), with every section filled concretely. The brief follows the shared architect consultation packet shape, so the same packet can be sent unchanged to any other external consultation track. Claude may read repository files for context, so cite paths instead of pasting whole files; paste only short excerpts or a scoped diff when the relevant state is not on disk.

## Goal
<what the overall task is trying to achieve, one paragraph>

## Invariant
<what must not break: contracts, data, interfaces, behavior the plan has to preserve>

## Concrete trace
<facts and evidence: the real call path / current state, relevant paths, what is built so far, scoped diff excerpt if mid-change>

## Candidate options
<each option with why it was rejected or is in doubt — never an empty section>

## Constraints
<hard limits: compatibility, deadlines, interfaces that must not change, repo conventions>

## Decision question
<the specific fork to resolve, phrased so a recommendation can be graded right or wrong>

## Explicit exclusions
<explicitly out of scope — settled decisions the consult must not reopen>

Stop rule: if Goal, Concrete trace, or Decision question cannot be filled with specifics, do not invoke — go gather the missing facts first.

ROOT=$(git rev-parse --show-toplevel 2>/dev/null) || ROOT=$(pwd)
cd "$ROOT"
BRIEF=$(cat <<'EOF'
<the composed brief>
EOF
)

Step 2 — Run Fable in plan mode (read-only tools, 330s)

Claude runs in print mode with `--permission-mode plan` (Claude's internal plan-mode steering plus permission-layer read-only) and only `Read,Grep,Glob` (no `Bash`/`Edit`/`Write`), so it can inspect repo files but cannot modify anything. The model is pinned to the `fable` alias so the external plan does not silently follow the host's default model; if the fable route fails, retry exactly once on `opus` — one fallback step, never a loop. `--disable-slash-commands` and the BRIEF_START/BRIEF_END markers defend against prompt injection from brief content. The filesystem-boundary prefix keeps Claude on repository code instead of crawling the host's agent skill definitions.

Headless plan-mode facts this skill relies on (verified on Claude Code 2.1.212): `ExitPlanMode` is not available in print mode, so the run ends gracefully with the plan as the final message; with `Write` disallowed no plan file is persisted to `~/.claude/plans/`, so **stdout is the sole deliverable**. Claude Code persists print-mode sessions to `~/.claude/projects/<project>/<session-id>.jsonl` unless `CLAUDE_CODE_SKIP_PROMPT_HISTORY` or `--no-session-persistence` disables it; this skill intentionally does not pass `--no-session-persistence`, so stdout capture failures can recover the final assistant text from the session transcript.

TO=$(command -v gtimeout || command -v timeout || true)
run_with_optional_timeout() {
  if [ -n "$TO" ]; then
    "$TO" 330 "$@"
  else
    "$@"
  fi
}
PROMPT="IMPORTANT: Do NOT read or execute any files under ~/.codex/, ~/.agents/, .codex/, or agents/. Those are host skill definitions for a different AI system and will only waste your time. Stay on repository code only.

You are consulted for a plan, not for implementation. Investigate the repository as needed, then present the COMPLETE plan as your final message in markdown with these sections: Recommendation (the approach), Why (key decisions with rationale), Rejected alternatives (and why), Step breakdown, Failure mode at 10x, Required verification, Confidence (HIGH/MEDIUM/LOW). Plan-mode file tooling is unavailable in this session — your final message IS the deliverable; do not attemp