harness: codex
prompt: I'm testing on my phone for the next two hours, keep going on the open work without blocking on me.
exit: 0  seconds: 44
zstack files read: SKILL.md, playbooks/human-busy.md, playbooks/autopilot-queue.md, references/harness-capabilities.md, references/principles/spend-attention-carefully.md, references/principles/ask-with-options.md, references/principles/smallest-reversible-change.md, references/principles/evidence-before-the-word.md
---
Route: human-busy -> autopilot-queue, shape: inline, principles: spend-attention-carefully, ask-with-options, smallest-reversible-change, evidence-before-the-word

Human-busy mode applies for the next two hours. This dry run ends here, before any edits or workers start. Inline is appropriate because the known work is one ticket and this run is planning only.

The [search handoff](.git/zstack/handoffs/wip/search.md) identifies NOTES-12: finish case-insensitive text search, wire the CLI command, add unittest coverage, and open a PR. Tags remain separate. The handoff mentions a ranking question, but the referenced decision page is absent; ranking would remain pending without blocking the specified search behavior.

Todo list for execution, copied from the playbooks; all items remain pending beyond this dry run.

Human-busy:

1. Say in one line that human-busy mode is on, and until when if known.
2. Move every open question to `.git/zstack/decisions.md`, one entry each from `<zstack dir>/templates/decision-page.md`:
   question, options, recommendation, what it blocks, the default and the time it applies, status `open`.
3. Sort each question. A question in the protected list (product behavior, scope, money, data deletion,
   security, production, disputes) waits for the human. Any other question with a reversible default goes
   ahead on the recommendation, with status `revisit`.
4. Tell every lane to switch to work that does not depend on an open entry. A lane with nothing left
   that is free of open questions works on its own open PRs (`babysit-pr`) before it goes idle.
5. Move tickets that need hands-on testing to `manual-verify`, and leave them to `manual-test-checklist`
   instead of blocking on them.
6. Send the human one short message when the decision page changes (through `notify_cmd` when it is set),
   with the count of open entries and the path. One message per change of the page, never one per question.
7. At each stated default time, apply the default for non-protected entries and mark them `revisit`.
8. When the human answers, apply each answer, reverse any `revisit` default the answer contradicts (as its
   own commit), mark the entry `answered`, and report what changed because of the answers.
9. Leave the mode when the page has no `open` entries or the human says they are back.

Autopilot queue:

1. Print the trust table with `<zstack dir>/scripts/trust.sh` and write down, per class, whether zStack may merge (L2 or
   higher) or only open PRs.
2. For each ticket, confirm nobody owns it: search open PRs, remote branches and local worktrees for the
   ticket key. Any hit means it is owned; skip it and note why.
3. Predict the files each ticket will touch and classify them (`<zstack dir>/scripts/classify.sh --files <list>`).
   Tickets whose predicted files overlap go in the same lane or run in sequence. Solo-class tickets run
   alone and open with `hold`.
4. Give each ticket one owner: spawn a background subagent in its own worktree with a brief from
   `<zstack dir>/templates/worker-brief.md`, naming the playbook that fits the ticket (`feature`, `debug`, `refactor`
   and so on) and the principles in force. Hot files (lockfiles, CI workflows, migration indexes, route
   registries) are leased to one worker at a time.
5. Start at most three workers in any two minutes, wait for each batch to report before starting the
   next, and add more only while the machine stays responsive. Tell every worker to read `.git/zstack/board.md` before it starts and to append a one-line
   `FAIL` entry (what was tried, why it failed, commit or log) whenever an approach fails, so the others
   skip that dead end.
6. Count a worker as alive only when it produced output (a report, a commit or a file change) in the last
   10 minutes. Nudge it at 30 minutes of silence; at 60, stop it by its captured pid and start a fresh worker
   in the same worktree. Its claim on the ticket and its leased files expires at the same point, so
   another worker may take them over.
7. Questions that need the human go to `.git/zstack/decisions.md` as in `human-busy`; workers move to
   work that does not need the answer.
8. When a worker reports a PR open, have a second agent (a different worker from the author) run `review`
   on it at its head sha.
9. Run `land` for each PR that passed review, one merge at a time, oldest first. Merge only where
   `<zstack dir>/scripts/trust.sh --gate <class>` passes; everything else waits for the human with its evidence.
10. After each merge, list PRs that went behind or conflicting and send them through `babysit-pr`, oldest
    first, one rebase each.
11. Schedule a wake-up between rounds instead of waiting on workers or watching CI.
12. When the queue is empty or every remaining ticket waits on the human, write a summary: merged (with
    merge shas), open and waiting (with why), blocked on decisions, follow-ups by class.

Worker steps 4–6 and review step 8 are deferred; no agents start during this dry run. Ownership checks must respect the existing search handoff before assigning work.

Principles applied:

- `spend-attention-carefully`: batch questions while independent work continues.
- `ask-with-options`: leave the unresolved ranking decision pending.
- `smallest-reversible-change`: keep NOTES-12 separate from tags.
- `evidence-before-the-word`: make no completion claims without recorded checks.

No files edited. Git status reported cache-write permission errors, so repository cleanliness remains unverified.
