/.agents/scratchpad/context/.md`, never committed. It has a section per ticket, an `## External hosts` list (every host the epic reaches: APIs, CDNs, share links) and a `## Findings` section workers append to. ## 3. Before you leave Run `ticket-loop`'s bedtime preflight (its Step 2) over the whole graph: every question only the user can answer gets asked now, in batched rounds, and each answer is recorded as a settled decision for its ticket. **Environment preflight.** Reach every host in the pack's `## External hosts` from this environment (`curl -sSI `) before any ticket starts. A blocked host is a blocker: say so and get the environment fixed now, not mid-ticket. Then create **one progress tracker for the run** with `progress-tracker` (not in Projects mode): - One step per ticket, in topological order: `title` is `# `, `note` names its blockers (`waits on #12, #13`) and owned files. - Status mapping: `todo` = waiting on blockers, `active` = worker building, `review` = PR open, `done` = merged, `blocked` = waiting on the user. - `meta/current.ticket` is the epic (or the single ticket); `now` is a one-line headline. Give the user the tracker link once. ## 4. Schedule Loop until every ticket in the graph is merged or the user stops the run. **Ready** = open, not `in-progress`, zero open blockers, and owned files disjoint from every live ticket's owned files. Dispatch ready tickets until **4 workers** are live (the user can change the cap per run). Parallel workers slow each other's verify runs (expect about 1.5x): give repo gates longer timeouts, and per ticket run only the fast gates plus the e2e specs for the area it touches. The full suite runs on `main` once per wave, not per ticket: when every ticket of a wave has merged, run it once (step 5 covers the last wave). For each dispatched ticket: 1. Claim it with the `in-progress` label (selection reference). 2. Write its kickoff with the template in `../ticket-loop/references/kickoff.md`, mode `push`. Include: `Orchestrator: []`; the context pack path and the ticket's section in it; owned files; the owned files of every other live ticket ("do not edit these; report kind 2 if you must"); the tracker URL and this ticket's step id; settled decisions; predecessor notes from blockers that merged. 3. Spawn it per `ticket-loop` Step 4 with `--permission-mode bypassPermissions --chrome --model opus --effort medium`, `--name issue-`, Remote Control `

 - `.
4. Set its tracker step to `active` and add a log line. For the run's first worker only, send
   "handshake ok?" and wait for the reply to prove delivery works.

Workers update their own step's `live` field in the tracker. If a worker cannot write to it,
update the step yourself from its reports.

**On each worker report:**

- **PR opened** → step `review`.
- **Blocked on a human / decision gate** → ask the user here (single ask surface), step
  `blocked` until answered, relay the answer.
- **Needs a file another live ticket owns** → tell it to wait until that ticket merges (then
  rebase), or, if the edit is tiny and the other ticket is early, let it proceed and warn the
  other worker. Never let two live workers edit one file blind.
- **Size overage** → clear a trivial one yourself, escalate a material one.
- **MERGED** → harvest per `ticket-loop` Step 6 (wrap-up handshake, idle check, kill). Step
  `done`. Carry its decisions and findings into the kickoffs of the tickets it unblocks.
  Recompute ready and dispatch immediately. Dependents always start from fresh `main` after
  the merge, never stacked on an open branch.

Waiting: push mode keeps one ~1800s fallback wakeup and otherwise sleeps until a report
arrives. Everything else (stuck workers, pane drafts, expired logins, merge blocks) follows
`../ticket-loop/references/orchestrator-gotchas.md`.

## 5. Integration check (epics and multi-ticket runs)

When the last ticket merges, first ask the user: "Start the integration check, or are more
tickets coming?" (skip the ask if they already said the epic is complete). Then, on fresh `main`:

1. Run the repo's full local CI-equivalent, including the suites CI runs that the docs skip.
   Failures on the repo's AGENTS.md "Known failures on main" list are not regressions.
2. Drive the feature end to end in the browser against the epic's acceptance list. Capture
   screenshots (desktop and phone width) and post them in a comment on the epic.
3. **Pass** → close the epic with a comment linking every PR. **Fail** → file a fix ticket into
   this run with the failure, its owned files and the context pack, and go back to step 4.

## 6. Exit

- Clean state: on `main`, only the main worktree, no `issue-*` tmux sessions, no lingering
  `in-progress` labels from this run.
- Tracker: every step `done`, `now` set to the outcome.
- One short report: what shipped (issue → PR → merged), the net backlog delta (closed vs opened),
  and anything left waiting on the user.

## 7. Retrospective

Same contract as `ticket-loop` Step 8 and the global AGENTS.md "Improving skills and memory"
rules: collect signals (dispatch collisions, file-ownership misses, context-pack gaps a worker
had to re-explore, questions that reached workers instead of being asked in step 3, glossary drift: an
`_Avoid_` alias merged or a term invented without asking), make the
smallest edit in the right file, run `skill-budget`, show the diff, log it in `CHANGELOG.md`.
Promote durable findings from the context pack to the repo's memory before deleting the pack.