/go-run

Go Run (Inline Reference)

This file is read once, by `/craft:cycle-design`'s tracker intake, when the newest Go on a tracker issue says Craft should answer the workflow's own prompts. From then on it governs every prompt in the run: how Craft picks an answer, what still stops, and where the run ends.

**DO NOT invoke this as a skill via the Skill tool.** The parent flow Reads this file and applies it inline. Its only Skill invocation is `craft:craft-cycle-start` at `## At the stage ceiling`.

The reason for all of it: the Go already told Craft how far to go and how to run. Asking the same person the same routine questions again would turn a handed-off task back into a questionnaire. Real decisions stay theirs.

When a run is a Go run

A Go run starts only when this conversation's brief printed the line `I'll answer Craft's own prompts and stop only for product forks.` A Go found in a paste, or any other verdict, never starts one. The decision comes from the copied Go and nothing else, never from the session's autonomous flag or from the issue's status, because either can be left over from an unrelated run.

Re-derive the verdict from the copied Go at three points:

• right after intake's copy line, once the cycle exists,
• at cycle-start's Go paragraph,
• after compaction (see `## After compaction`).

Each time, run:

python3 "${CLAUDE_PLUGIN_ROOT}/hooks/scripts/go-brief.py" <cycle-dir>

Anything other than `prompts=answer` ends the Go run. Print exactly:

`The copied Go for <KEY> doesn't say to answer Craft's prompts anymore, so I'll bring them to you.`

From then on every prompt is asked as usual, so a newer or changed Go can never leave Craft answering for someone who asked to be consulted.

Answering a prompt

Check `## What still stops` first. A prompt that is not a stop is answered, never rendered, in this order:

1. Its row in `## Known prompts`. The table wins over any marker, because several prompts on this path list a neutral or misleading first option. 2. The option marked `(Recommended)`, `(recommended)`, or a card's `(proposed)` option `a.`, or the option its own step's prose recommends. 3. The first listed option.

A free-text question is answered with words quoted from the copied issue, or else one sentence drafted from it. Never invent a goal the issue does not support. A prose question with its own row in `## Known prompts` is not free text: it takes the row's answer.

The prompt is not shown. After the answer's effects and writes have landed, print one line so the run stays traceable:

• picker: `Answered '<header, else question text>' with '<label>' (recommended).`
• card: `Answered '<card question>' with 'a. <option title>' (recommended).`
• free text: `Answered '<question>' with '<answer>' (drafted from <KEY>).`
• prose question with a row: `Answered '<question>' with '<row answer>'.`

The line comes after the writes so it never claims something that has not happened.

What still stops

Each case prints its line as visible text (a plain message to the user, never only in your reasoning), copied word for word, in the same turn and immediately before the prompt or card is rendered. A paraphrase such as "this is a product fork, so I'm pausing" does not count. The prompt is then asked exactly as it would be without a Go, except a can-wait fork under `### Where a fork goes`, which is posted and not asked. After the user answers, the run goes back to answering.

• A product fork prints `This one is a product fork, so it's yours.` When forks are posted to the issue, the lines under `### What the session says` replace this one.
• A shared write (a push, a PR, a tracker or chat post, a shared config change) or a destructive step (deleting stories, files or branches, discarding uncommitted work) prints `This one needs your yes: <what it would change, in a few words>.` A question posted under ## Product forks is the one exception, because the Go's Questions line already says yes to it. The cycle-update post named in `## Known prompts` is the second exception, for the same reason.
• A prompt the Go gives no clear answer to prints `This one has no clear answer from the Go, so it's yours.`
• Going past the stage is stopped by intake's stage check and by `## At the stage ceiling`.

Host tool-permission prompts are never answered or changed: they belong to the person's own settings. The implement-auto path's own salvage-and-rollback failure handling is existing autonomous behavior and is not a destructive step here.

Product forks

A product fork is a choice only the user can make, where the plan is worse if Craft decides. These are always forks:

• (a) an alignment-check finding that survives that check's Step 2 filter, asked at its Step 3 (`${CLAUDE_PLUGIN_ROOT}/commands/references/alignment-check.md`);
• (b) a planning agent's PLAN FORK;
• (c) any Critical Blocker, including the research type in batch triage;
• (d) any other card or question that passes the same two-part test: only the user can choose, and the plan is worse if Craft decides. That always includes picking among creative directions (a creative-spark, a design-vibe or a mockup pick).

Where a fork goes

Posting applies only when this is a Go run and `go-brief.py <cycle-dir>` (or, before the cycle exists, the staged go file) prints `questions_line=Questions go to: the issue`. Otherwise forks are asked here, in this session, on their normal card, with the line from `## What still stops` above them, and nothing is posted. Posting to the tracker is a shared write, and the Go's own Questions line is the only permission for it.

Blocking or can wait

Decide this for every posted fork. The default is that it can wait. The fork test above decides whether Craft asks at all, not whether it blocks, and "the plan is worse if Craft decides" is never by itself a reason to block. A fork blocks only when one of these holds, and the decision names which one:

• it is a Critical Blocker;
• no option