threads: make the Phase 2 plan loop-runnable

Adjust the unattended loop contract for Phase 2: the Done condition targets M1
through M11 (M1-M6 being checked is no longer Done), the loop branches off the
current main into a new branch (Phase 1's threading is merged), and each green
milestone pushes the working branch to origin (main stays a human merge).

docs/threading-plan.md

@@ -52,8 +52,11 @@ fixed in *Locked decisions*; the checkboxes are the only state. A loop iteration
 
 1. **Resume** at the first milestone that still has an unchecked `- [ ]`. (All earlier
    milestones are done — do not revisit them.)
-2. **Work on a branch.** On the first iteration, branch off `main` (e.g. `threading`);
-   never commit threading work to `main`. All work stays local — **do not push**.
+2. **Work on a branch.** On the first iteration, branch off the current `main` into a new
+   branch (e.g. `threading-phase2` — Phase 1's `threading` is already merged); never
+   commit to `main` directly. Push that **branch** to `origin` after each milestone (step
+   5) so progress is backed up remotely; **do not push `main`** — merging Phase 2 into
+   `main` stays a human step.
 3. **Implement** every unchecked item in that milestone, including adding its
    `-Dtest-case` to `CASES` in [test/qemu_test.py](../test/qemu_test.py) (with
    `smp: true` / a `mem` bump where noted) so the gate is runnable.
@@ -64,8 +67,9 @@ fixed in *Locked decisions*; the checkboxes are the only state. A loop iteration
      the whole guardrail set passes, `zig build` is clean, and host tests are green.
      → tick this milestone's boxes **and** its `**Gate:**`-referenced case, `git commit`
      (`threads(M<n>): <summary>`, no `Co-Authored-By` trailer per
-     [coding-standards.md](coding-standards.md)), and continue to the next milestone in
-     the same iteration if budget remains; otherwise let the loop re-fire.
+     [coding-standards.md](coding-standards.md)), then **`git push` the working branch to
+     `origin`** (use `-u` on the first push to set upstream). Continue to the next
+     milestone in the same iteration if budget remains; otherwise let the loop re-fire.
    - **Red** = anything above fails. Diagnose from the captured serial log
      (`zig-out/qemu-test/<case>-failed-serial.log`) and fix in place, then re-run — up to
      **3 fix attempts** for that gate. A concurrency case that fails then passes on a
@@ -79,14 +83,18 @@ fixed in *Locked decisions*; the checkboxes are the only state. A loop iteration
 
 **The only stop conditions:**
 
-- **Done** — every milestone box is checked (M1–M6), `zig build` clean, whole
-  `thread-*` suite + guardrail green. Update threading.md's status line to "built" (that
-  is M6's own task) and stop.
+- **Done** — every milestone box **in this plan** is checked (M1 through M11), `zig build`
+  clean, the whole `thread-*` suite + guardrail green. Phase 1 (M1–M6) is *already*
+  checked, so do **not** read that as Done: the loop's real work is the first plan section
+  that still has unchecked boxes — Phase 2 (M7–M11). Only stop when M7–M11 are all checked
+  too. Update threading.md's status line, push the final branch state to `origin`, and
+  stop. The branch is on `origin` for review; **merging Phase 2 into `main` is the user's
+  step**, not the loop's.
 - **Blocked** — a gate is still red after 3 fix attempts, or a step needs something
   outside the repo (a toolchain change, new hardware, a decision no locked decision
   covers). Append `> **BLOCKED (M<n>):** <what failed, what was tried, the serial
-  marker missing>` under that milestone, commit the WIP on the branch, and stop. Do not
-  thrash further and do not silently skip the milestone.
+  marker missing>` under that milestone, commit **and push** the WIP on the branch, and
+  stop. Do not thrash further and do not silently skip the milestone.
 
 Nothing else warrants stopping — not "should I proceed?", not "is this right?". The
 checkboxes + git history are the resumable record; the next iteration picks up from the