Auto

Task (may be empty): $ARGUMENTS

yah <project> sends this as the first prompt, so the user types nothing. Decide the step from the state, say it in one line, then run it. The other yah skills do the work: call them with the Skill tool (yah:start, yah:phases, yah:wrap, yah:deep), never retype their rules.

PY is python on Windows and python3 elsewhere; use py -3 only if both fail.

Autopilot: an open plan phase goes to a detached yah run --plan (section 4), which goes on after this session closes. The task here opts out: where a row or step says start the run, run yah:start hands-on instead, with the NEXT line or the next phase's label and title.

1. Read the state

Use the [yah] SessionStart block already in context. Run PY "${CLAUDE_SKILL_DIR}/../../scripts/where.py" --json only when there is no block, or it has a PR or a RUN you must check; for a RUN alone, add --no-gh. Read no docs, plans or long files to orient.

2. Pick the first row that matches

A given task or a NEXT already says what to do, so Q1 and Q2 come only when nothing does, and a tiny task skips the ## Bet and Q3 too. Ask each in one AskUserQuestion, recommended option first.

Q1, the aim (once per project): "Who is this project primarily for, and what should it help them accomplish?" Offer 2-3 aims as Help [primary user] [outcome] when [situation], drafted only from README's first 40 lines and the PROD line; never explore further. Put the one you would pick first. Write the answer as AIM: <sentence> on its own line under the # title of the file at store.path in where.py --json --no-gh, which may be NOW.md or the main checkout's STATE.md (create that file with a # title if it is missing; a file with no # title gets the line at its top). Never create a second STATE.md beside it: it would shadow the project's state. A user who declines gets AIM: none, so Q1 is never asked again.

Q2, the pick: rank the follow-ups against the AIM, judging each only from its own text (the whole line, fields after | included):

• impact H/M/L (how much it moves the AIM) and effort S/M/L, each resting on words you quote from the item; say absent where the text gives nothing, never an estimate.
• An item the text says blocks others comes first. An item whose effort is absent is offered as a discovery task: find out what it takes, done when that is written down.
• Never read code or docs to rank; the item's text is the evidence.

Show the top three as rows A/B/C | id title | outcome | impact/effort | evidence | done-when, then ask "Take A, B or C? I recommend A; 'auto' lets me choose", with Other for a new task. auto takes A. Route the pick (or the new task) as a given task.

3. Plan it

A task that is not tiny, one PR or several, gets every decision asked now, while the user is here, so the run can go on unattended.

1. Enter plan mode. Explore only what the task touches; send wide searches to an Explore agent.
2. Draft the phases in the plan file plan mode names, one or several. Each phase gets its own ### P<n> <title> section (a session reads only its own) with what it changes, a done-when, a branch and a base: the first phase's base is the trunk, or the branch the work builds on, and each later phase's base is the branch before it, so the phases stack. yah run --plan stops at a phase with no branch. Under the branch line, add an After it merges: line saying in plain words what changes for the user, and a Files: block that /yah:tree draws. Each entry starts with its mark, not a - bullet: + new, ~ changed, - removed, > renamed. End the block with a blank line, or the next bullet is read as a removal:

   After it merges: checkout takes Apple Pay.
   Files:
   + src/pay/applepay.ts — the Apple Pay button
   ~ src/pay/PaymentForm.tsx — mounts it
   > src/pay/old.ts -> src/pay/card.ts — renamed

   Then add a ## Bet section: the outcome (one line, tied to the AIM when there is one), non-goals, appetite: $<X> and <H>h, and two stop if <signal> by <checkpoint> lines. The appetite is what PY "${CLAUDE_SKILL_DIR}/../../scripts/run.py" --appetite-hint <phases> prints; when it prints nothing or fails, use $7 and 0.6h a phase.
3. Run yah:deep with a brief that stands alone: the goal, the draft phases in full, the key files and the constraints you know. Ask it which decisions the plan leaves open (scope, behavior, names, trade-offs, anything outward-facing such as a new repo or a publish) and which risks could stop a phase with nobody there. Add the AIM and the ## Bet to the brief, and ask for a pre-mortem (the two likeliest reasons the plan fails, each as a stop-if for the Bet) and for any phase that does not serve the AIM.
4. Ask every open decision before ExitPlanMode, in AskUserQuestion rounds of at most 4 questions, recommended option first. Keep asking until none is left, including questions an answer opens. Leave no decision to a headless session: NEEDS-HUMAN: is only for what nobody could foresee. The last round ends with Q3: "Is <outcome> worth <appetite>, done when <done-when>, stopping if <stop-ifs>?" with run / shrink / skip. Shrink: cut phases with the user, fix the Bet, and ask Q3 again. Skip: drop the plan, say so, exit plan mode and stop.
5. Write the answers under ## Decisions in the plan file, one line each, and change the phases they touch. Then draw the map: run PY "${CLAUDE_SKILL_DIR}/../../scripts/phasemap.py" all --no-gh --spec "<plan file>" and put its output as is at the end of the plan file under ## Map, in a text code block, replacing any ## Map already there, so the approval view shows each phase's stack line, after line and file tree. Then ExitPlanMode.
6. Approved: if another plan has an open phase and no run is live, park it first (STATE.md only): its [~] phase goes back to [ ] (with no [~], its first [ ] phase stays [ ]), with - Parked: NEXT was <NEXT> as a log line under it. Wrap claims it back when the new plan's last phase closes. Then run yah:phases with the plan file, then start the run. Not approved: change the plan as asked, run yah:deep again only if the phases changed, ask what that opened, draw the map again, and exit plan mode again.

4. Start the run

1. If the tree is dirty, say what is uncommitted and ask first: the run's sessions commit whatever is in the tree.
2. Run PY "${CLAUDE_SKILL_DIR}/../../scripts/run.py" --plan --detach. A rerun of a run that had no --plan (run.plan false) is run.py <run.target> --detach, with a PR target's # dropped (#12 becomes 12): the shell reads # as a comment and would drop --detach with it. Keep --detach last; never start a run in the foreground, since it holds this session for hours.
3. Exit 0: the run holds its lock. Say what it runs and where its log is, that this session can close, and that /yah:where or yah <project> shows its RUN line. Then stop, and do no work in this checkout while it runs. Any other exit: it stopped at once. Show its output and do not retry.

5. While working

• The user says "deep", or a bug survived two attempts: run yah:deep with a question that stands alone (goal, files, what was tried, what happened). This holds on every plan tier. Without Fable access, Claude Code runs it on the session's model.
• A new multi-phase plan gets approved: run yah:phases before its first phase.
• The step is done, the phase is done, or the context guard says wrap: run yah:wrap.
• Never merge a PR yourself, and never push a protected branch. Only the run driver merges, and only when auto_merge is on.