/tracker-intake

Tracker Intake (Inline Reference)

This file is read by `/craft:cycle-design` when it is given a tracker issue key or URL. It reads the issue and every comment, copies them verbatim into a staging folder, finds the newest Go, states the stage first, and hands the normal cycle-design flow a source to record.

**DO NOT invoke this as a skill via the Skill tool.** The parent command Reads this file and executes the sections inline. No Skill invocations from this file.

**Status is never authority.** The issue's status (Done, In Progress, anything) is copied for reference and never read to grant or limit work. Only the newest Go grants a stage.

Detect

This runs when args are a bare uppercase key (`^[A-Z][A-Z0-9]*-[0-9]+$`, such as `DRO-21`), an issue URL, or when the request names an issue to pick up or work on. One issue per cycle: if the request names several, ask once which one the cycle starts from.

Set `KEY` to the issue key and `slug` to the key lowercased, with each run of characters outside `a-z0-9` replaced by one `-`.

Once the key is known, run `python3 "${CLAUDE_PLUGIN_ROOT}/hooks/scripts/find-issue-cycle.py" <KEY> "${CRAFT_PROJECT_ROOT:-.}"`. It prints `cycle_dir`, `status` and `matches`. On a non-empty `cycle_dir`, the issue already has a cycle: Read `${CLAUDE_PLUGIN_ROOT}/commands/references/tracker-refresh.md` and run it instead of the rest of this file: no gate, no new cycle.

Read

Use whatever tracker tools the host has. Fetch the issue (title, URL, status, type, description) and every comment. Follow pagination until the tool reports no more pages. Ask for creation order when the tool offers it, because some trackers default to update order. Then write oldest first by creation time.

If the host has no tracker tools, or a read fails, go to `## No tracker tools`.

Stage

Staging folder: `${CRAFT_PROJECT_ROOT:-.}/.craft/.intake/<slug>/`, emptied first. Stamp = `date -u +%Y-%m-%dT%H%MZ`. Files, named so they sort by time:

• `<slug>-issue-<stamp>.md`
• `<slug>-comments-<stamp>.md`
• `<slug>-go-<stamp>.md`, only when a Go is found

**Issue file:** `# <KEY>: <title>`, a blank line, then these two lines, a blank line, and the description verbatim:

Source: <url>
Status at retrieval: <status> (copied for reference; never a permission)

**Comments file:** the preamble `# <KEY> comments, oldest first`, then one block per comment:

## <Kind> <n> - <author> - <timestamp>

<body verbatim>

• `<Kind>` is `Reply` when the tracker marks a parent, `Inline` when the comment carries quoted description text (first body line `> <quoted text>`), otherwise `Comment`.
• `<n>` counts blocks from 1 in file order.
• `<author>` is the `onBehalfOf` name when set, else the author's name, as the tool shows it.
• `<timestamp>` is exactly what the tracker returns, never reformatted. The resolver parses it.
• The body is verbatim, including any `## ` lines inside it.

Then run:

python3 "${CLAUDE_PLUGIN_ROOT}/hooks/scripts/resolve-go.py" <comments-file> <KEY> <go-file>

It prints six `key=value` lines: `go`, `stage`, `go_author`, `go_date`, `go_comment`, `stage_line`.

**The first line you print is the `stage_line` value, verbatim.** Nothing comes before it.

If a Go was found and the issue description or a non-Go comment states a different stage or scope, the next line is exactly:

`<KEY>'s <description|comment N> says "<their words>"; the newest Go says <stage>, and the Go wins.`

**Hold:** when `stage=hold`, the next line is exactly:

`Nothing new starts on <KEY> until a newer Go.`

Then delete the staging folder and stop. No cycle and no stories. Do not offer to continue, and do not accept an in-session instruction to lift the hold: a newer Go on the issue is the only way (for example, ask Wright to post a build Go on <KEY>).

**Issue type:** when the tool gives the issue a type (Jira's issue type field; on Linear, a value from a `Type` label group), the issue file carries `Type: <type as the tool shows it>` right after the Status line. When the tool gives none, the file has no `Type:` line.

The brief

This runs only when the resolver printed `go=found` and the stage is not `hold`. It runs after the stage line and the optional "the Go wins" line. None, unreadable, paste and hold runs skip this section entirely.

Run:

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

It prints five `key=value` lines: `prompts`, `scope_line`, `rules_line`, `questions_line`, `answer_line`.

• Only on `prompts=answer`, print the non-empty values of `scope_line`, `rules_line`, `questions_line` and `answer_line`, in that order, each on its own line with nothing between them. The stage line is the brief's first line and is never repeated. The brief reads:

Stage: <stage>, per Go from <author> on <date>.
Scope: <scope line from the Go>
Run rules: last updated <date> (from your <reference name>), or none
Questions go to: here
I'll answer Craft's own prompts and stop only for product forks.

The first line is the stage line already printed, so only the last four are new. The fourth reads `Questions go to: the issue` instead when the Go's own Questions line says comments on this issue.

• On `bring` or `none`, print nothing, so the output is the stage line alone and Craft asks every prompt as usual.
• If the script exits non-zero, print exactly `I couldn't read the run rules in <KEY>'s newest Go, so I'll bring Craft's prompts to you.` and no Go run starts.

After printing the brief, print nothing more and Read `${CLAUDE_PLUGIN_ROOT}/commands/references/go-run.md`, which governs every prompt for the rest of this run. On `bring` or `none`, go-run.md is never read.

Copy

The staging folder is the copy. It becomes the cycle's `context/` folder once the cycle exists (see `## After the cycle exists`). Nothing is written under `.craft/cycles/` before the safety gate has been confirmed.

Into Step 1

Hand cycle-design Step 1 these values:

• T