greprag 5.60.3 → 5.60.5

package/skill/templates/chip-bootloader.md

@@ -1,107 +1,49 @@
 # Chip Bootloader
 
-No `spawn_task`? The lead creates a git worktree, the user opens a new session
-there, and the bootloader takes over. greprag inbox is the back-channel.
+No `spawn_task`? Use OpenCode Desktop HTTP spawn (preferred) or manual paste.
 
-## Multi-chip?
+## Preferred: quick chip (path A)
 
-If this task needs ≥2 chips, STOP and run `greprag load chip-leader-opencode` FIRST.
-The leader plans the integration branch, labels, seams, and merge order before
-any chip launches. A lone chip proceeds directly below.
-
----
-## Lead: before presenting the bootloader
-
-```bash
-if [ -d "C:\chip-<slug>" ]; then
-    cd "C:\chip-<slug>"
-    current=$(git branch --show-current)
-    if [ "$current" = "chip/<slug>" ]; then
-        echo "Worktree already exists on correct branch — reusing"
-    else
-        echo "ERROR: Worktree dir exists but branch is '$current', not 'chip/<slug>'. Remove and retry." >&2
-        exit 1
-    fi
-else
-    git worktree add C:\chip-<slug> -b chip/<slug>
-fi
-```
-
-The worktree IS the isolation — same pattern as Claude Code's `spawn_task` worktree
-landing. Branch already exists, directory already isolated. Now present the
-bootloader below and tell the user: **"Open a new session here: C:\chip-<slug>"**
-
-## After chip reports DONE
-
-```bash
-git checkout <target-branch>         # main or integration branch
-git merge chip/<slug>
-git worktree remove C:\chip-<slug>
-git branch -d chip/<slug>
-```
-
----
-## Bootloader template
-
-Substitute the bracketed placeholders and present as a copyable code block.
-
-````
-Chip <Label>: <verb-phrase>
-
-You are inside C:\chip-<slug> — a git worktree on branch chip/<slug>,
-created for you by the lead. Verify:
+Initiator is LEAD — no separate LEAD session:
 
 ```bash
-git branch --show-current  # should output: chip/<slug>
+greprag opencode chip goal create \
+  --objective "…" --final-state "…" \
+  --criterion ship:… \
+  --owner-session <this-8hex> --owner-role leader
+
+greprag opencode chip spawn \
+  --title "Purview Name" --role worker --label A \
+  --goal-id <id> --covers ship \
+  --task "…" \
+  --parent-session <ses_…> --parent-greprag <8hex> \
+  --model deepseek/deepseek-chat \
+  --opencode-url http://127.0.0.1:<port> \
+  --dispatch
+# → "Chip A: Purview Name"
+# close: report → goal accept → greprag opencode chip close <id|ses_>
 ```
 
----
-## Block 1 — Setup
-
-1. Get your session ID:
-   ```bash
-   greprag status 2>&1 | grep -oP '(?<=greprag session id: )[0-9a-f]+'
-   ```
+## Multi-chip mission (path B)?
 
-2. Announce you're alive:
-   ```bash
-   greprag send "IN-FLIGHT: chip/<slug> launched — <task-summary>" \
-     --to <handle>@greprag.com/<parent-8hex> \
-     --from-session <your-8hex>
-   ```
+≥2 chips at one objective → STOP → `greprag load chip-leader-opencode`  
+(PLANNER → LEAD → nested goal → Chip A/B).
 
-IN-FLIGHT ping is mandatory. No ping = lead assumes chip never launched.
+## Manual paste (API down only)
 
----
-## Task
+### Block 1 — Setup
+1. `greprag status` → 8-hex  
+2. `greprag send "IN-FLIGHT: <title>" --to travis@greprag.com/<parent-8hex>`  
+3. Branch `chip/<slug>`  
+4. Each turn: `greprag inbox --peek`
 
-<your instructions here>
-
-Commit milestones on chip/<slug>. At each turn start, run
-`greprag inbox --peek` — the lead may send new instructions.
-
----
-## Block 2 — Report when done
+### Task
+\<work — include goal id + covers\>
 
+### Block 2 — Report
 ```bash
-greprag send "<status>: <result>" \
-  --to <handle>@greprag.com/<parent-8hex> \
-  --from-session <your-8hex>
+greprag send "DONE: … | commit=<sha> | checks=…" --to travis@greprag.com/<parent-8hex>
+# or BLOCKED: …
 ```
 
-After reporting, wait for the lead — there may be follow-up.
-The lead will merge chip/<slug> and remove this worktree when finished.
-````
-
-### Placeholder reference
-
-| Placeholder | Substitute |
-|---|---|
-| `<Label>` | Single-letter (A, B...) or omit for single-chip |
-| `<verb-phrase>` | Short name, e.g. `Fix synthesis loop` |
-| `<slug>` | Slugified — `fix-synthesis-loop` |
-| `<parent-8hex>` | Your own session id (first 8 hex) |
-| `<handle>` | Operator's greprag handle |
-| `<task-summary>` | One-liner for the IN-FLIGHT ping |
-| `<status>` | `DONE`, `BLOCKED`, `PARTIAL` |
-| `<result>` | Summary of what was done |
+Workers always `--label A|B|C…`. `--model` required. Report-back is greprag inbox.

package/skill/templates/chip-leader-opencode.md

@@ -1,98 +1,113 @@
-# Chip Leader — plan a MULTI-CHIP mission (OpenCode)
+# Chip Leader — OpenCode multi-chip (path B)
 
-> Loaded via `greprag load chip-leader-opencode` — run this when your task
-> needs ≥2 chips. A single chip → `greprag load chip-bootloader`. Two or more
-> → STOP, pick a mode below, and plan first.
+> Loaded via `greprag load chip-leader-opencode` when ≥2 chips share one objective.
+> **One chip (or two independent ones)?** Skip this — use the **quick path** in
+> `chip-bootloader` / `greprag opencode chip --help` (initiator is LEAD).
 
-`chip-bootloader` launches one worker correctly; **chip-leader is the commander**
-who plans the whole mission *before* any worker deploys and reconciles them
-*after*. Topology is a planning decision, not an execution afterthought — draw
-the map before mobilizing the troops.
+## Two paths (both first-class)
 
-**Hard fire:** the moment you're about to launch the **2nd chip**, stop and plan.
-Launch-then-plan is the exact failure this prevents.
-
-## Two modes — pick ONE before planning
-
-Forks on one question: **do the chips share one objective, or are they independent?**
-
-| | **Mode A — Mission** | **Mode B — Orchestrator** |
+| | **A — Quick** | **B — Mission (this doc)** |
 |---|---|---|
-| **When** | ≥2 chips at ONE objective, usually ONE repo | N independent issues, often DIFFERENT repos |
-| **Relationship** | chips have seams — shared files, data contracts, ordering | disjoint by construction — no seams |
-| **Branching** | one integration branch `feature/<slug>`; chips base off it, merge into it | each chip self-contained in its OWN repo; no integration branch |
-| **Merge** | leader reconciles all → ONE reviewed merge to master | each chip merges to ITS OWN repo independently |
-| **Leader's core job** | merge-reconciliation across seams | dispatch + completion judgment — chips report back, you adjudicate |
-
-Both modes share decompose, dispatch via bootloader, the label system, and the
-merge discipline below.
-
-## Phase 1 — Decompose
+| When | 1 chip, or independent jobs | ≥2 chips, seams, one objective |
+| Who is LEAD | **Initiator** (this session) | Explicit `LEAD:` chip |
+| Goal | `goal create --owner-role leader` owned by this 8-hex | PLANNER goal → nested LEAD goal |
+| Spawn | `worker --label A` (solo = A) | LEAD dispatches Chip A/B… |
+| Close | Parent accept + `close` | LEAD reconciles → accept → close |
 
-Break the objective into independent workstreams. Each workstream = one chip.
-Assign each a **Label** (A, B, C...). The label is the shared handle the leader
-and chip both use end-to-end: bootloader title → IN-FLIGHT ping → report-back
-self-ID → merge references.
+**Hard fire for B:** about to spawn the **2nd chip at one objective** → stop and plan here.
 
-## Phase 2 — Assign integration branch (Mode A only)
+## Path A — Quick (default)
 
-Create one branch off the default branch that all Mode A chips merge INTO:
 ```bash
-git checkout -b feature/<slug>
-git push origin feature/<slug>
+greprag opencode chip goal create \
+  --objective "…" --final-state "…" \
+  --criterion ship:… \
+  --owner-session <this-greprag-8hex> \
+  --owner-role leader
+
+greprag opencode chip spawn \
+  --title "Purview" --role worker --label A \
+  --goal-id <id> --covers ship \
+  --task "…" \
+  --parent-session <this-ses_…> \
+  --parent-greprag <this-8hex> \
+  --model deepseek/deepseek-chat \
+  --opencode-url http://127.0.0.1:<port> \
+  --dispatch
+
+# later:
+greprag opencode chip report <chip> --summary "…" --evidence ship:…
+greprag opencode chip goal accept <id> --owner-session <this-8hex> --summary "…"
+greprag opencode chip close <chip> --summary "…"
 ```
 
-Each chip's bootloader sets `git checkout -b chip/<slug>` based off this
-integration branch. When the chip reports DONE, its work is ON `chip/<slug>`,
-ready to merge into `feature/<slug>`.
+No separate LEAD chip. No bind-lead. Initiator owns the goal and closeout.
 
-## Phase 3 — Pre-launch & dispatch each chip
+## Path B — Mission flow
 
-For each workstream:
-
-1. **Create the worktree:**
+1. **PLANNER** creates the mission goal (`--owner-role planner`).
+2. Spawn **one LEAD** under that goal (`--role leader --covers …`).
+3. LEAD creates a **nested** goal + bind:
    ```bash
-   git worktree add C:\\chip-<slug> -b chip/<slug>
+   greprag opencode chip goal create \
+     --objective "…" --final-state "…" \
+     --criterion ship:… \
+     --owner-session <lead-child-greprag-8hex> \
+     --owner-role leader \
+     --parent-goal-id <planner-goal-id>
+   greprag opencode chip bind-lead <lead-chip-id> \
+     --goal-id <nested-goal-id> \
+     --owner-session <lead-child-greprag-8hex>
    ```
+4. LEAD spawns workers against the **nested** goal:
+   `--role worker --label A --title "…" --goal-id <nested> --covers ship --parent-greprag <lead-8hex>`.
+5. Workers: `IN-FLIGHT` → work → `DONE`/`BLOCKED`. Parent: `report --evidence …`.
+6. Accept nested goal, then planner goal; then `close` chips.
 
-2. **Write the bootloader** (from `greprag load chip-bootloader`):
-   - Label: `Chip A: <verb-phrase>`
-   - Integration branch name in the task (Mode A)
-   - One clear, self-contained task per chip
+## Role titles (exact)
 
-3. **Present the bootloader** and tell the user:
-   > Open a new session here: C:\\chip-<slug>
+`PLANNER: …` · `LEAD: …` · `Chip A: …` / `Chip B: …` · `ADVISOR: …` · `MECHANIC: …`  
 
-The user starts a new session in the worktree, pastes the bootloader.
+Workers **always** `--label A|B|C…` (solo = A). Never bare `Chip:`.
 
-## Phase 4 — Reconcile & merge (Mode A)
+## Mode A vs Mode B topology (still for path B)
 
-1. As each chip reports DONE, merge its branch into `feature/<slug>`:
-   ```bash
-   git checkout feature/<slug>
-   git merge chip/<slug>
-   ```
-2. Resolve any seam conflicts between chips
-3. Run the full feature end-to-end on `feature/<slug>`
-4. One reviewed merge to master, then prune:
-   ```bash
-   git checkout master
-   git merge feature/<slug>
-   git branch -d feature/<slug>
-   # for each chip:
-   git worktree remove C:\\chip-<chip-slug>
-   git branch -d chip/<chip-slug>
-   ```
+| | **Mission topology** | **Orchestrator topology** |
+|---|---|---|
+| When | ≥2 chips, one objective | Independent issues |
+| Branch | Integration branch | Per-chip / per-repo |
+| Gate | One reviewed merge to master | Per-chip verify |
 
-## Phase 4 (Mode B) — Adjudicate
+## Spawn flags (canonical)
 
-Each chip runs in its own repo. As each reports DONE, verify and close
-independently. No integration gate.
+```bash
+greprag opencode chip spawn \
+  --title "Auth Middleware" \
+  --role worker --label A \
+  --goal-id <id> --covers ship \
+  --task "…" \
+  --parent-session <ses_…> \
+  --parent-greprag <8hex> \
+  --model deepseek/deepseek-chat \
+  --opencode-url http://127.0.0.1:<port> \
+  --dispatch
+# → "Chip A: Auth Middleware"
+```
 
-## Key difference from Claude Code chip-leader
+Close: `greprag opencode chip close <chipId|ses_> --summary "…"`  
+(`--keep-session` · `--force` · `--keep-open-goal`)
 
-| Feature | Claude Code | OpenCode |
-|---|---|---|
-| Dispatch | `greprag load chip-spawn` (spawn_task) | `greprag load chip-bootloader` (copyable block) |
-| Isolation | git worktree per chip | git branch per chip |
-| Validator | PreToolUse hook validates prompt blocks | No validator — bootloader is manual |
+- **`--model` required** (Desktop defaults can 401).
+- **`--top-level`** if you need a session-list entry without nesting.
+- Desktop **does not auto-focus** API-created sessions.
+
+## Isolation
+
+Prefer `chip/<slug>` branch per chip. Records: `~/.greprag/opencode-chips/`. Goals: `~/.greprag/chip-goals/`.
+
+## Do not
+
+- Force path B for a single chip — use path A.
+- Dispatch workers from a **planner** goal (planner accepts LEAD only).
+- Skip IN-FLIGHT or end without DONE/BLOCKED.
+- Use Codex `create_thread` / Claude `spawn_task` here — wrong harness.

package/skill/templates/chip-leader.md

@@ -1,223 +1,83 @@
-# Chip Leader — plan a MULTI-CHIP mission before the first spawn
-
-> Loaded via `greprag load chip-leader` — usually from *within* `greprag load
-> chip-spawn` (its "Part of a multi-chip mission?" gate), the moment you realize
-> ≥2 chips aim at one objective, or you're about to spawn a 2nd chip. A single
-> chip → straight to `greprag load chip-spawn`. Two or more → STOP, pick a mode
-> below, and plan first.
-
-`chip-spawn` launches one worker correctly; **chip-leader is the commander** who
-plans the whole mission *before* any worker deploys and reconciles them *after*.
-Topology is a planning decision, not an execution afterthought — draw the map
-before mobilizing the troops.
-
-## Codex Desktop standard
-
-For Codex, the `PLANNER: <Mission>` first creates one durable mission goal with
-objective, observable final state, and criterion IDs, then launches exactly one
-`LEAD: <Mission>` at `gpt-5.6-luna/xhigh`. The LEAD owns decomposition, child
-dispatch, integration, checks, release proof, and immediate child closeout.
-Before dispatch it assigns each workstream a unique letter and human
-purview—`Chip A: <Specific Purview>`, `Chip B: ...`—plus disjoint leases and
-explicit `--covers` criteria. Every worker spawn uses `--multi-chip`, its
-`--label`, and its proper `--title`; workers stay Luna/xhigh. `ADVISOR:` is a
-read-only Sol/high escape hatch only for a documented fundamental blocker.
-
-Dispatch uses the native-v4 `createRequest` exactly once. It contains the real
-mission, the parent-selected model/effort, and native worktree setup; never send
-a bootstrap prompt or a second assignment. The initial hook binds before tool
-use, the leader applies the exact task title as soon as the resolved task ID is
-available, attach emits `IN-FLIGHT`, and the child reports evidence through the
-parent's breakthrough inbox.
-
-Closeout is parent-owned and immediate: review each report and commit, integrate
-it, verify the whole mission, explicitly accept the goal, then follow each
-returned closeout entry (archive the native task first; run its cleanup command).
-A report is not acceptance, cleanup never implies
-acceptance, and an accepted/integrated child should not remain in the active
-task list. These rules supersede any Claude `spawn_task`, Block 1/Block 2, or
-manual worktree instructions later in this shared template when operating in
-Codex.
-
-After an interruption, resume only attached nonterminal chips and require their
-nonce-bound breakthrough acknowledgment. A terminal/invalid launch cannot
-respond: archive/stop it, durably `goal exclude` it with a concrete reason, and
-spawn a replacement under the same goal. Excluded evidence never counts. If the
-mission itself is abandoned, stop every chip and `goal cancel`; cancellation
-permits cleanup but never masquerades as acceptance.
-
-**Hard fire:** the moment you're about to spawn the **2nd chip**, stop and plan.
-Spawn-then-plan is the exact failure this prevents.
-
-## Two modes — pick ONE before planning
-
-Forks on one question: **do the chips share one objective, or are they independent?**
-
-| | **Mode A — Mission** | **Mode B — Orchestrator** |
-|---|---|---|
-| **When** | ≥2 chips at ONE objective, usually ONE repo | N independent issues, often DIFFERENT repos |
-| **Relationship** | chips have seams — shared files, data contracts, ordering | disjoint by construction — no seams |
-| **Branching** | one integration branch `feature/<slug>`; chips base off it, merge into it | each chip self-contained in its OWN repo; no integration branch |
-| **Merge** | leader reconciles all → ONE reviewed merge to master | each chip merges to ITS OWN repo's default, independently |
-| **Gate** | whole feature run end-to-end on the integration worktree | per-chip verification; no cross-chip gate |
-| **Leader's core job** | merge-reconciliation across seams | **dispatch + completion judgment** — chips report back, you adjudicate |
-
-Both modes share decompose, dispatch (via `greprag load chip-spawn`), the label
-discipline, and the single-watcher rule. They diverge on topology and the back
-half (reconcile vs. adjudicate).
-
-## Mode A — Mission
-
-### The invariant that drives everything
-
-`master` is the production trunk — `git push origin master` deploys. So:
-- **Merged = ships on the next deploy.** A flag gates *behavior*, not *startup
-  code*: schema/migration statements and import-time side effects run regardless
-  of any feature flag. "Flag-gated" ≠ "inert on master."
-- **Chips NEVER merge directly to master.** They reconcile on a feature
-  integration branch. Master only ever holds verified, deployable work.
-- One objective → **one integration branch** → **one reviewed merge to master**.
-
-### Phase 1 — Decompose
-
-Break the objective into workstreams (one per chip). For each, name:
-- **Label** — a stable letter (`A`, `B`, `C`…). It becomes the chip's title prefix
-  (`Chip A: <verb>`) and the one handle you *and* the chip use end-to-end (title,
-  report-back self-ID, merge log). Letters, not numbers — workstream IDs, not an
-  execution order.
-- **Parallel or sequential** — can it run independently, or need another's output?
-- **Seams** — every place two workstreams touch: *shared file* (both edit the same
-  module → serialize at merge), *data contract* (one produces what another consumes
-  → producer merges first), *ordering dependency* (B meaningless until A lands).
-- Disjoint workstreams (no shared file, no contract) → merge in any order.
-
-Output the plan explicitly and **confirm it with the user before dispatching.**
-
-### Phase 2 — Topology
-
-Detect the default branch first (`git -C <main> symbolic-ref refs/remotes/origin/HEAD`
-→ strip prefix; fallback `master`), then:
-
-```bash
-git -C <main> worktree add .claude/worktrees/feature-<slug> -b feature/<slug> <default>
+# Leader Mission
+
+Load this method when the work needs a dedicated orchestrator: more than the
+quick 1–2 visible chips, shared files or contracts, ordering, integration, or
+another coordination seam.
+
+## Identity first
+
+Before any child is created, the orchestrating task becomes the dedicated
+leader by renaming itself exactly:
+
+```text
+LEAD: <Mission>
+```
+
+Children use the exact ordinal discoverability schema:
+
+```text
+Chip A: <Specific Purview>
+Chip B: <Specific Purview>
+Chip C: <Specific Purview>
+```
+
+Naming identifies the workstream and makes the task legible. It does not grant
+execution authority; every child remains an ordinary writable chip.
+
+## Quick versus Leader
+
+- **Quick:** the current task renames itself `LEAD: <Mission>` and directly
+  spawns 1–2 children. No separate leader task is created.
+- **Leader:** the initiator creates a separate `LEAD: <Mission>` task. That
+  dedicated task owns decomposition, child dispatch, seam reconciliation,
+  checks, integration, parent messaging, and cleanup.
+
+This template is for the second shape. If the mission fits the quick shape,
+load `greprag load codex-chip-spawn` and keep the initiator as the implicit
+LEAD.
+
+## Mission worksheet
+
+Before dispatch, record:
+
+```text
+Mission: <observable outcome>
+Integration target: <branch/worktree or parent review point>
+Chip A: <Specific Purview> — <dependency/seam>
+Chip B: <Specific Purview> — <dependency/seam>
+Chip C: <Specific Purview> — <dependency/seam>
+Order: <parallel work, then required reconciliation order>
+Checks: <whole-mission verification>
+Closeout: <who integrates and cleans each worktree>
 ```
 
-Decide + write down: each chip's **base branch** = `feature/<slug>` (not master);
-each chip's **merge target** = `feature/<slug>` (never master); **merge order**
-(seam-sharers serialize, producer/base first; disjoint chips free); **test gate**
-(the `feature-<slug>` worktree is where the whole feature runs end-to-end).
-
-### Phase 3 — Dispatch
-
-Spawn each chip via `greprag load chip-spawn`, and in each brief include the four
-things the plan decided:
-1. **Its seam** — which files/contracts it shares, and what to leave clean.
-2. **Its base branch** — branch off `feature/<slug>` (adjust chip-spawn's Block 1
-   `git worktree add ... <base>`).
-3. **Its merge target** — `feature/<slug>`, never master. Chips commit to their own
-   branch + report back; the leader does the merges.
-4. **Its label** — three places (spawn title alone does NOT reach FleetView's
-   watcher registry, which is auto-generated):
-   - **Spawn title** — `Chip <Label>: <verb phrase>`.
-   - **Registry retitle (Block 1)** — give the chip a line to run right after
-     worktree setup: `greprag session retitle <its-own-8hex> "Chip <Label> — <workstream>"`.
-   - **Report-back self-ID** — open its report with its label ("Chip B — DONE: …").
-
-Arm ONE inbox watcher for all the chips' reports (never double-arm).
-
-**Spawning is a commitment.** A `spawn_task` is not a draft: launching creates a
-worktree + branch, and even a queued chip occupies its slug. Finalize the brief
-before you spawn; to change/replace a chip, **cancel the old one FIRST** (dismiss
-if queued; for a launched one, stop the session, then `git worktree remove` +
-`git branch -D`), then spawn. Same-slug collision → spawn the replacement under a
-fresh slug rather than fighting an OS file lock.
-
-### Phase 4 — Reconcile + integrate
-
-As chips report `DONE`:
-1. **Merge into `feature/<slug>` in the planned order** (`--no-ff`, from the
-   integration worktree). Seam-sharers: base first, then the dependent.
-2. **On conflict at a seam** — expected; resolve it (you mapped it in Phase 1). On
-   an *unexpected* conflict, stop and re-examine the decomposition.
-3. **Recommend closing the chip out** as soon as its commits are reconciled (or
-   even just committed + reported) — the branch survives the session; you need the
-   branch, not the live session, to merge later. Don't wait to be asked.
-4. **Run the full feature end-to-end on the integration worktree** — the gate.
-5. **One reviewed merge to master, then clean up.** Only after the gate passes:
-   `feature/<slug>` → master, then deploy. Then sweep the worktrees (the cleanup
-   skill keys on "merged into master," so it won't remove chips until then).
-
-**PRUNE AT THE MERGE (HARD RULE).** Each chip's *worktree* dies the moment its
-branch merges into its target — same breath, never batched. The *branch* is the
-safety net and lives until the master merge. Stale worktrees pile up precisely
-because cleanup was deferred.
-
-## Mode B — Orchestrator (independent fan-out, cross-repo)
-
-A list of independent issues, each self-contained in its own repo. Nothing to
-integrate — every chip lives and ships on its own. Your job is **dispatch +
-completion judgment**: each chip reports back because you hold the "done"
-criterion.
-
-### B1 — Decompose AND screen
-
-One chip per issue — but **screen each candidate first; not every issue is a
-chip.** A chip must be a self-contained coding task in a clean git repo. Drop the
-rest and say why: interactive-with-operator (needs his login/judgment), ops/comms
-(submissions, third-party coordination, email), cross-repo config writes (e.g.
-editing a skill under `~/.claude` — not a clean worktree target; do inline),
-operator-owned manual tasks. (Reporting "none of these are chips" is a correct,
-useful result.)
-
-For each survivor record: **Label** (`A`/`B`/`C`…), **Target repo** (its root,
-from `~/.greprag/projects.json` → becomes the chip's `cwd`), **Completion
-criterion** (what "done" means, in YOUR words — you'll judge against it).
-
-Output the screened plan (chips + dropped non-chips with reasons); confirm before
-dispatch.
-
-### B2 — Topology: none shared
-
-No integration branch. Each chip: **cwd** = its own repo root; **base branch** =
-that repo's own default (detect per-repo); **merge target** = that repo's default,
-or hold-for-review (default to hold so you adjudicate before anything ships).
-
-### B3 — Dispatch
-
-Spawn each via `greprag load chip-spawn` with: `cwd` set; Block 1 worktree off the
-repo's default; the label discipline; Block 2 reporting to **your** session; the
-**completion criterion embedded in the brief**. Arm ONE watcher. Re-dispatch
-discipline (cancel-before-respawn) identical to Mode A.
-
-### B4 — Adjudicate (replaces reconcile)
-
-As each chip reports `DONE`: **verify against the criterion** (read the diff, run
-it if needed — don't take "DONE" on faith); **decide per chip** (merge to its own
-repo's default + deploy, or send back with specifics); **surface close-out per
-chip** as it lands. No single end-of-mission master merge — N independent ones.
-
-## Safety rules
-
-- **Never spawn the 2nd chip without picking a mode + planning.** Mode A for one
-  shared objective; Mode B for independent issues.
-- **Mode B: screen before you spawn.** Interactive, ops/comms, cross-repo-config,
-  operator-owned tasks are NOT chips.
-- **Never spawn a chip while a stale one for the same workstream is in flight —
-  CANCEL first.** `spawn_task` is a stateful commitment.
-- **Mode A: never merge a chip branch to master.** Integration branch only.
-- **Never let "it's flag-gated" justify merging untested work to master.**
-  Migrations and startup code ignore feature flags.
-- **Confirm the decomposition with the user before dispatch.** Wrong seams =
-  painful merges.
-- **Surface close-out proactively** as each chip reconciles.
-
-## Execution depth (advanced)
-
-Orthogonal to mode: each workstream also picks a *vehicle* — bare subagent, a
-leader-direct workflow, a simple chip, or an **orchestrator chip** (a lean chip
-running an inner workflow swarm in its own worktree, for mixed-model missions
-needing isolation + a human gate). Mixed-model work cannot be a simple chip
-(`spawn_task` has no model param → chips are session-locked). Don't over-stack: a
-one-file fix gets a subagent, not a three-tier hierarchy. If you need the
-orchestrator-chip brief addendum or the recovery recipe for a chip mistakenly
-merged to master, ask the operator — those live in the chip-leader skill docs.
+Give each child one clear purview. Explain shared files, contracts, and
+ordering in the brief rather than relying on hidden coordination metadata.
+
+## Dispatch and closeout
+
+1. Rename the leader task before the first child spawn.
+2. Spawn each `Chip A/B/C: <Specific Purview>` with its own visible worktree
+   and the mission context it needs.
+   A child titled exactly `MECHANIC: <Mission>` must make `greprag load mechanic`
+   its first Setup action before diagnosis or edits.
+3. Keep children writable and let them investigate, edit, test, and commit
+   within their worktrees.
+4. Require each child to return `DONE` or `BLOCKED` through the native
+   parent-child task result, including the commit, checks, and caveats. Use
+   `greprag send` only for explicit cross-harness or peer messaging:
+
+   ```bash
+     greprag send "Chip A update — <commit> — <checks/caveats>" \
+     --to <handle>@greprag.com/<parent-session> \
+     --from-session <child-session>
+   ```
+
+5. Review reports, reconcile seams in the planned order, run the whole-mission
+   checks, and send the parent a concise closeout.
+6. The parent owns integration and cleanup. Do not silently delete a child
+   worktree or treat a report as acceptance.
+
+Do not introduce a separate read-only, lease, nested-goal, or delivery-proof
+layer just to make the mission look formal. The durable boundaries are the
+visible names, isolated worktrees, reports, `greprag send`, and cleanup.