@dirtydishes/skills 0.1.2 → 0.1.3

package/README.md

@@ -94,7 +94,7 @@ A created loop writes a project-local execution surface under `docs/implementati
 - `loop-state.md` - Lightweight mirror for current phase, branch/PR posture, blockers, and next action.
 - `turn-docs/` - One Markdown turn doc per phase. Reviewers update the existing phase turn doc instead of creating separate review docs.
 - `prompts/run-loop.md` - The prompt used to start or continue loop execution.
-- Workflow prompts - `orchestrator-callback` also emits implementation and review thread prompts.
+- Workflow prompts - `orchestrator-callback` also emits selector, implementation, review, and closeout-selector prompts.
 - Schemas - Callback/report JSON contracts for implementation, review, and swarm reports.
 - `storyboard-post-run-mm-dd-yyyy.html` - Final closeout artifact generated after the stream completes.
 
@@ -110,11 +110,11 @@ The skill package itself mirrors that shape:
 #### Workflows
 
 - `single-thread-subagent` - One visible coordinator thread owns loop state while mass subagent swarms handle selection, scouting, slice planning, implementation assistance, review, and CI.
-- `orchestrator-callback` - One orchestrator thread creates separate implementation and review threads; those threads call back to a concrete orchestrator thread id only when they are done, blocked, or have opened the expected PR.
+- `orchestrator-callback` - One orchestrator thread delegates phase gates to selector subagents, creates separate implementation and review threads, and receives callbacks to a concrete orchestrator thread id when workers/reviewers are done or blocked.
 
 Choose `single-thread-subagent` when you want one visible coordinator thread, less thread management, and a CLI-friendly loop. The main coordinator owns the branch, integration, PR state, Beads updates, and closeout. Subagents inspect, scout, split phases into slices, prepare implementation guidance or patches, review, verify CI, and report, but they do not advance loop state. Broad phases should use 8+ subagents before implementation.
 
-Choose `orchestrator-callback` when you want the original multi-thread flow. The orchestrator chooses the next ready Beads phase, creates implementation threads with a concrete callback target id, waits for implementation callbacks, creates review threads with the same callback target id, waits for review and CI callbacks, updates Beads, and then advances to the next phase.
+Choose `orchestrator-callback` when you want the original multi-thread flow. The orchestrator launches a selector subagent before the first worker, creates implementation threads with a concrete callback target id, waits for implementation callbacks, creates review threads with the same callback target id, waits for review and CI callbacks, launches a closeout-selector subagent between phases, updates Beads, and then advances only to the selected next phase.
 
 #### Authority Rules
 
@@ -132,7 +132,7 @@ The `dirtyloops` skill is strict about ownership:
 - Broad scout, slice, implementation-helper, and review work should use bounded subagent swarms, usually 8 or more agents and up to 20 when the phase warrants it.
 - Phase scope stays narrow. File follow-up Beads issues instead of widening an active phase.
 
-For `orchestrator-callback`, only the orchestrator creates implementation and review threads. Implementation threads do not create review threads, review threads do not create follow-up implementation threads, selector subagents never implement, and reviewer subagents never close Beads issues.
+For `orchestrator-callback`, only the orchestrator creates implementation and review threads. The orchestrator must launch a selector subagent before the first worker and a closeout-selector subagent after each review callback before stopping or continuing. Implementation threads do not create review threads, review threads do not create follow-up implementation threads, selector subagents never implement, closeout-selector subagents never mutate Beads, and reviewer subagents never close Beads issues.
 
 For `single-thread-subagent`, the coordinator must run a slice/scout swarm before broad implementation. Solo coordinator implementation of most phase work is a workflow violation; coordinator implementation should be limited to synthesis, integration, glue, conflicts, final repairs, and Beads/PR closeout.
 
@@ -142,7 +142,7 @@ Implementation threads call back exactly once when the PR is ready, the task is
 
 Review threads call back exactly once after review and CI are resolved. The callback includes the concrete orchestrator thread id, source thread id, Beads issue id, status, PR, CI state, review skill, repairs, remaining findings, turn doc, and context to keep.
 
-Prefer callback-driven coordination over polling. For long-running worker or reviewer threads, use a lightweight heartbeat around 30 minutes. Do not launch callback threads whose actual prompt text says only `current orchestrator thread`, `this thread`, or another generic callback target.
+Prefer callback-driven coordination over polling. After launching a worker or reviewer, the orchestrator waits for the single callback; it does not repeatedly read, monitor, summarize, or status-check the child thread. For long-running worker or reviewer threads, use a lightweight heartbeat around 30 minutes only when the callback is overdue or liveness is uncertain. Do not launch callback threads whose actual prompt text says only `current orchestrator thread`, `this thread`, or another generic callback target.
 
 #### Closeout
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dirtydishes/skills",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Installer and catalog for dirtydishes agent skills.",
   "type": "module",
   "bin": {

package/skills/dirtyloops/SKILL.md

@@ -23,7 +23,7 @@ A dirtyloop is a Beads-canonical Codex implementation loop: phase docs, one Mark
 2. Select the workflow.
    - Skip this step for `help`.
    - `single-thread-subagent`: one coordinator thread uses mass subagent swarms for selection, scouting, slice planning, implementation assistance, review, and CI; no separate Codex worker/reviewer threads.
-   - `orchestrator-callback`: an orchestrator thread creates implementation threads, then review threads; workers and reviewers call back to a concrete orchestrator thread id.
+   - `orchestrator-callback`: an orchestrator thread delegates phase gates to selector subagents, creates implementation threads, then review threads; workers and reviewers call back to a concrete orchestrator thread id.
    - Choose `orchestrator-callback` when the user mentions original loop flow, new threads, callbacks, worker threads, implementation threads, or review threads.
    - Choose `single-thread-subagent` when the user mentions single thread, CLI-friendly, or keeping all orchestration in one thread.
    - If the workflow is ambiguous for `create` or `run`, ask one concise question.
@@ -58,7 +58,9 @@ A dirtyloop is a Beads-canonical Codex implementation loop: phase docs, one Mark
 - Reviewer agents must use `thermo-nuclear-code-quality-review`.
 - Reviewer and CI verification agents own CI.
 - `dirtyloops run` continues phase-by-phase by default. Stop only when the epic is complete, blocked, interrupted, review/CI is unresolved, or the user explicitly asked for `run once` / `--once`.
+- For `orchestrator-callback`, the orchestrator must spawn a selector subagent before the first worker and a closeout-selector subagent after each review callback before continuing or stopping. The orchestrator validates their reports and remains the only actor that mutates Beads, updates loop state, creates implementation/review threads, or advances the loop.
 - Orchestrator-callback prompts and callback payloads must carry the concrete orchestrator thread id. Do not launch a worker or reviewer if the actual instruction text says only `current orchestrator thread`, `this thread`, or another generic target.
+- Orchestrator-callback is callback-wait, not active monitoring. After launching a worker or reviewer, the orchestrator must not repeatedly read, monitor, or summarize the child thread while waiting for its single callback. Use only a sparse fallback heartbeat when the callback is overdue or liveness is uncertain.
 - Worker and reviewer threads default to standard speed/reasoning unless the Beads loop metadata explicitly says otherwise.
 - For `single-thread-subagent`, the coordinator orchestrates, synthesizes, integrates, owns branch/PR/Beads state, and closes out. It must launch mass subagent swarms before broad implementation; direct coordinator implementation is for integration, glue, and final repair work.
 - Use large bounded subagent swarms: 8+ by default for broad scout, slice, implementation-helper, and review work, and up to 20 when the phase warrants it.

package/skills/dirtyloops/examples/README.md

@@ -3,6 +3,6 @@
 These examples show the shape `$dirtyloops create` should produce.
 
 - `single-thread-subagent/` shows one visible coordinator thread with mass subagent swarms, slice planning, implementation helpers, review, and CI verification.
-- `orchestrator-callback/` shows the original thread-callback loop: orchestrator thread, implementation threads, review threads, concrete callback targets, and callback payloads.
+- `orchestrator-callback/` shows the original thread-callback loop: orchestrator thread, selector and closeout-selector subagents, implementation threads, review threads, concrete callback targets, and callback payloads.
 
 Treat these as shape examples, not content to copy verbatim. New loops should fill in repo-specific Beads ids, phase docs, gates, branch policy, callback target ids, thread defaults, swarm policy, and prompt wording.

package/skills/dirtyloops/examples/orchestrator-callback/README.md

@@ -6,13 +6,13 @@ Topology:
 
 ```text
 orchestrator thread
-  -> selector subagent
+  -> selector subagent chooses first ready phase
   -> implementation thread with exact callback target
   -> implementation callback when PR-ready
   -> review thread with exact callback target
   -> review callback when review + CI resolved
-  -> orchestrator closeout
-  -> next selector
+  -> closeout-selector subagent verifies closeout and next phase
+  -> orchestrator applies closeout and continues or stops
 ```
 
 Beads is canonical. The docs are execution context. Implementation and review callbacks echo the concrete orchestrator thread id and source thread id. Review and CI update the existing phase turn doc.

package/skills/dirtyloops/examples/orchestrator-callback/docs/implementation/example-stream/IMPLEMENT.md

@@ -23,6 +23,13 @@ Replace an old reporting path with a simpler evidence-backed implementation whil
 
 Only the orchestrator creates implementation and review threads.
 
+Selector subagents:
+
+- run before the first implementation thread
+- read Beads, `IMPLEMENT.md`, `loop-state.md`, and linked phase docs
+- return a `swarm-report` with mission `selector`
+- never implement, mutate Beads, edit files, or create threads
+
 Implementation threads:
 
 - receive the full phase doc, Beads issue id, branch policy, quality gates, and orchestrator thread id
@@ -44,7 +51,17 @@ Review threads:
 - update the existing phase turn doc
 - call back exactly once when review and CI are resolved, echoing `orchestrator_thread_id` and including `source_thread_id`
 
-The orchestrator owns Beads closeout and next selector launch. The loop continues phase-by-phase until the epic is complete, blocked, interrupted, or review/CI is unresolved.
+Closeout-selector subagents:
+
+- run after each review callback and before the orchestrator closes, stops, or launches another worker
+- check the review callback, PR/CI evidence, existing turn doc, Beads dependencies, and `loop-state.md`
+- recommend exact closeout actions and at most one next phase
+- return a `swarm-report` with mission `closeout-selector`
+- never implement, review, repair, mutate Beads, edit files, or create threads
+
+The orchestrator validates selector reports, owns Beads closeout, and launches only the selected next phase. The loop continues phase-by-phase until the epic is complete, blocked, interrupted, or review/CI is unresolved.
+
+After launching implementation or review threads, the orchestrator waits for the single callback. It does not repeatedly read, monitor, summarize, or status-check the child thread unless a sparse fallback heartbeat is needed for an overdue callback or liveness recovery.
 
 ## Phase Ledger
 

package/skills/dirtyloops/examples/orchestrator-callback/docs/implementation/example-stream/prompts/closeout-selector-subagent.md

@@ -0,0 +1,33 @@
+# Closeout-Selector Subagent Prompt: Example Stream
+
+You are the closeout-selector subagent for an `orchestrator-callback` dirtyloop.
+
+Canonical tracker: Beads epic `example-epic`
+
+Mission: verify the just-reviewed phase can be closed out, then recommend stop or at most one next phase.
+
+Read:
+
+- Beads epic `example-epic`
+- the reviewed phase issue
+- the implementation callback
+- the review callback
+- PR and CI evidence
+- the existing phase turn doc
+- `docs/implementation/example-stream/IMPLEMENT.md`
+- `docs/implementation/example-stream/loop-state.md`
+- linked phase docs for the next ready candidates
+
+Rules:
+
+- Do not implement.
+- Do not review or repair.
+- Do not mutate Beads.
+- Do not edit files.
+- Do not create implementation or review threads.
+- Recommend exact closeout actions for the reviewed phase.
+- Recommend stop when the epic is complete, blocked, interrupted, unresolved, or this is a `--once` run.
+- Recommend exactly one next phase only when continuation is allowed and Beads dependencies make it ready.
+
+Return a compact report matching `schemas/swarm-report.schema.json` with `mission: "closeout-selector"`.
+

package/skills/dirtyloops/examples/orchestrator-callback/docs/implementation/example-stream/prompts/run-loop.md

@@ -13,11 +13,12 @@ Start from:
 ## Rules
 
 - Beads is canonical.
-- Orchestrator selects exactly one next ready Beads child issue.
+- Orchestrator launches a selector subagent to select exactly one next ready Beads child issue before the first worker.
 - Continue phase-by-phase until the epic is complete, blocked, interrupted, or review/CI is unresolved.
 - Only the orchestrator creates implementation and review threads.
 - Worker and reviewer threads default to standard speed/reasoning unless Beads metadata says otherwise.
 - Worker and reviewer prompt text must include the exact orchestrator thread id `THREAD_ORCHESTRATOR_ID` as callback target.
+- After launching a worker or reviewer, wait for its single callback; do not repeatedly read, monitor, summarize, or status-check the child thread.
 - Implementation threads call back exactly once when PR-ready or blocked.
 - Implementation callbacks echo `orchestrator_thread_id` and include `source_thread_id`.
 - Implementation threads do not create review threads.
@@ -25,9 +26,11 @@ Start from:
 - Review threads own CI, repairs, reruns, and evidence.
 - Review threads call back exactly once when review and CI are resolved.
 - Review callbacks echo `orchestrator_thread_id` and include `source_thread_id`.
-- All actors update the existing Markdown phase turn doc.
+- After every review callback, the orchestrator launches a closeout-selector subagent before closing, stopping, or continuing.
+- Selector and closeout-selector subagents return `swarm-report` payloads and never mutate Beads or create threads.
+- Workers and reviewers update the existing Markdown phase turn doc; the orchestrator records selector reports, callbacks, Beads updates, and closeout there.
 - Update Beads first, then update `loop-state.md`.
 
 ## Start Prompt
 
-Run the Example Stream dirtyloop with workflow `orchestrator-callback`. Use Beads epic `example-epic` as canonical. Read `docs/implementation/example-stream/IMPLEMENT.md` and `docs/implementation/example-stream/loop-state.md`, select one next ready Beads child issue with a selector subagent, create an implementation thread at standard speed with the full linked phase doc and exact callback target `THREAD_ORCHESTRATOR_ID` in the prompt text, wait for an implementation callback that echoes `orchestrator_thread_id` and includes `source_thread_id`, then create a review thread at standard speed that uses `thermo-nuclear-code-quality-review` and owns CI. Close out only after the review callback reports concrete CI state and echoes the same callback target. Do not let worker threads create review threads. Continue to the next ready phase unless the epic is complete, blocked, interrupted, or review/CI is unresolved.
+Run the Example Stream dirtyloop with workflow `orchestrator-callback`. Use Beads epic `example-epic` as canonical. Read `docs/implementation/example-stream/IMPLEMENT.md` and `docs/implementation/example-stream/loop-state.md`, launch a selector subagent to select one next ready Beads child issue, create an implementation thread at standard speed with the full linked phase doc and exact callback target `THREAD_ORCHESTRATOR_ID` in the prompt text, then wait for an implementation callback that echoes `orchestrator_thread_id` and includes `source_thread_id` without repeatedly reading or monitoring the worker thread. Create a review thread at standard speed that uses `thermo-nuclear-code-quality-review` and owns CI, then wait for its single callback the same way. After the review callback reports concrete CI state and echoes the same callback target, launch a closeout-selector subagent to verify closeout and select stop or at most one next phase. Apply Beads and loop-state updates only from the orchestrator. Do not let worker threads create review threads. Continue to the next selected phase unless the epic is complete, blocked, interrupted, or review/CI is unresolved.

package/skills/dirtyloops/examples/orchestrator-callback/docs/implementation/example-stream/prompts/selector-subagent.md

@@ -0,0 +1,28 @@
+# Selector Subagent Prompt: Example Stream
+
+You are the selector subagent for an `orchestrator-callback` dirtyloop.
+
+Canonical tracker: Beads epic `example-epic`
+
+Mission: select at most one next ready Beads phase for the orchestrator.
+
+Read:
+
+- Beads epic `example-epic`
+- Beads loop metadata
+- `docs/implementation/example-stream/IMPLEMENT.md`
+- `docs/implementation/example-stream/loop-state.md`
+- linked phase docs for ready or nearly-ready child issues
+
+Rules:
+
+- Do not implement.
+- Do not review.
+- Do not mutate Beads.
+- Do not edit files.
+- Do not create implementation or review threads.
+- Select exactly one phase only when Beads says it is ready and the linked phase doc is coherent.
+- If no phase is ready or the state is ambiguous, report `blocked` with evidence.
+
+Return a compact report matching `schemas/swarm-report.schema.json` with `mission: "selector"`.
+

package/skills/dirtyloops/examples/orchestrator-callback/docs/implementation/example-stream/turn-docs/01-foundation.md

@@ -8,7 +8,7 @@ This is the single Markdown turn doc for the phase.
 
 ## Phase Selection
 
-Selected by the orchestrator after `bd ready` showed `example-epic.1` unblocked.
+Selected by selector subagent `THREAD_SELECTOR_ID` after `bd ready` showed `example-epic.1` unblocked.
 
 ## Implementation Log
 
@@ -76,4 +76,6 @@ Evidence:
 
 ## Closeout
 
-Orchestrator merged PR `#123`, closed `example-epic.1`, refreshed Beads export, and launched the next selector.
+Closeout-selector subagent `THREAD_CLOSEOUT_SELECTOR_ID` verified the review callback, PR `#123`, `ci-repaired-and-green` evidence, and Beads dependencies. It recommended closing `example-epic.1` and continuing with `example-epic.2`.
+
+Orchestrator merged PR `#123`, closed `example-epic.1`, refreshed Beads export, updated `loop-state.md`, and launched the selected next phase.

package/skills/dirtyloops/plan.html

@@ -457,11 +457,11 @@
 
         <article class="workflow-card callback">
           <h3>orchestrator-callback</h3>
-          <p>The original loop shape. A main orchestrator creates standard-speed implementation and review threads with concrete callback targets, then advances after validated callbacks.</p>
+          <p>The original loop shape. A main orchestrator delegates phase gates to selector subagents, creates standard-speed implementation and review threads with concrete callback targets, waits without monitoring, then advances after validated callbacks and closeout reports.</p>
           <div class="flow">
             <div class="node callback">
               <b>1</b>
-              <div><strong>Orchestrator selects phase</strong><span>Selector subagent reads Beads and linked phase docs.</span></div>
+              <div><strong>Selector picks phase</strong><span>Selector subagent reads Beads, loop state, and linked phase docs before the first worker.</span></div>
             </div>
             <div class="node callback">
               <b>2</b>
@@ -471,6 +471,10 @@
               <b>3</b>
               <div><strong>Review thread owns CI</strong><span>Reviewer uses thermo-nuclear review, handles CI/repairs, then echoes the callback id.</span></div>
             </div>
+            <div class="node callback">
+              <b>4</b>
+              <div><strong>Closeout selector gates next</strong><span>Closeout-selector subagent verifies review, PR, CI, Beads, and loop state before stop or next phase.</span></div>
+            </div>
           </div>
         </article>
       </div>
@@ -491,7 +495,7 @@
             <tr>
               <td>Phase selection</td>
               <td>Main coordinator with selector subagents.</td>
-              <td>Orchestrator with selector subagent.</td>
+              <td>Initial selector subagent; closeout-selector subagent between phases.</td>
             </tr>
             <tr>
               <td>Implementation</td>
@@ -511,12 +515,12 @@
             <tr>
               <td>Beads closeout</td>
               <td>Main coordinator updates Beads first, then loop-state.</td>
-              <td>Orchestrator updates Beads after implementation/review callbacks.</td>
+              <td>Orchestrator updates Beads after callback validation and closeout-selector report.</td>
             </tr>
             <tr>
               <td>Next phase</td>
               <td>Main coordinator continues after closeout unless complete, blocked, interrupted, unresolved, or <code>--once</code>.</td>
-              <td>Orchestrator launches the next selector after closeout unless complete, blocked, interrupted, unresolved, or <code>--once</code>.</td>
+              <td>Orchestrator launches only the phase selected by the closeout-selector unless complete, blocked, interrupted, unresolved, or <code>--once</code>.</td>
             </tr>
           </tbody>
         </table>

package/skills/dirtyloops/references/beads.md

@@ -65,8 +65,16 @@ For `orchestrator-callback`, add:
   "callback_policy": {
     "requires_concrete_orchestrator_thread_id": true,
     "requires_source_thread_id": true,
+    "wait_mode": "callback-wait",
+    "active_child_thread_monitoring": false,
     "heartbeat_after_minutes": 30,
     "polling": "fallback-only"
+  },
+  "selector_policy": {
+    "initial_selector_subagent": true,
+    "between_phase_closeout_selector_subagent": true,
+    "selector_report_schema": "schemas/swarm-report.schema.json",
+    "orchestrator_only_mutates_beads": true
   }
 }
 ```
@@ -89,7 +97,7 @@ For `single-thread-subagent`, add:
 }
 ```
 
-Phase metadata must include phase number, phase doc, turn doc, completion criteria, quality gates, branch/PR instructions, and either callback target data or swarm slice policy for the selected workflow.
+Phase metadata must include phase number, phase doc, turn doc, completion criteria, quality gates, branch/PR instructions, and either callback/selector target data or swarm slice policy for the selected workflow.
 
 ## Selection
 

package/skills/dirtyloops/references/create-loop.md

@@ -18,6 +18,7 @@ Required:
 - swarm policy for `single-thread-subagent`
 - quality gates
 - branch/PR policy
+- selector policy for `orchestrator-callback`
 
 If required inputs are missing and cannot be inferred safely, ask one concise question before writing files.
 
@@ -26,7 +27,8 @@ Ask only for missing decisions. Prefer these defaults when the user has not spec
 - run policy: continue until epic complete, blocked, interrupted, or review/CI unresolved
 - one-shot mode: off unless the user says `run once` or `--once`
 - worker/reviewer speed: standard
-- orchestrator-callback heartbeat: 30 minutes, fallback-only polling
+- orchestrator-callback wait policy: callback-wait, no active child-thread monitoring, 30 minute sparse fallback heartbeat only when overdue or liveness is uncertain
+- orchestrator-callback selector policy: selector subagent before the first worker, closeout-selector subagent between phases
 - single-thread-subagent swarm mode: mass-subagent, minimum 8 parallel agents for broad scout/slice/review work
 
 ## Steps
@@ -44,7 +46,8 @@ Ask only for missing decisions. Prefer these defaults when the user has not spec
 
 3. Normalize loop metadata.
    - Record workflow, run policy, branch/PR policy, quality gates, and thread defaults.
-   - For `orchestrator-callback`, record callback policy: concrete orchestrator thread id required in prompts and callback payloads, source thread id required in callback payloads, heartbeat interval, and fallback-only polling.
+   - For `orchestrator-callback`, record callback policy: concrete orchestrator thread id required in prompts and callback payloads, source thread id required in callback payloads, callback-wait behavior, no active child-thread monitoring, heartbeat interval, and fallback-only polling.
+   - For `orchestrator-callback`, record selector policy: initial selector subagent required, between-phase closeout-selector subagent required, selector reports use `swarm-report`, and only the orchestrator mutates Beads or advances the loop.
    - For `single-thread-subagent`, record swarm policy: mass-subagent mode, minimum parallel agents, scout/slice/implementation-helper/review/CI swarm sizes, mandatory slice plan before implementation, and coordinator-direct-implementation limits.
    - Completion criterion: the loop can be validated from Beads metadata before any worker, reviewer, or broad implementation work starts.
 
@@ -68,7 +71,7 @@ Ask only for missing decisions. Prefer these defaults when the user has not spec
 6. Generate the run prompt.
    - Save it as `docs/implementation/<stream>/prompts/run-loop.md`.
    - Include the selected workflow name.
-   - Include Beads epic id, run policy, phase-doc location, turn-doc rules, review skill, CI ownership, thread defaults, callback/slice preflight rules, and storyboard requirements.
+   - Include Beads epic id, run policy, phase-doc location, turn-doc rules, review skill, CI ownership, thread defaults, selector gates, callback/slice preflight rules, and storyboard requirements.
    - Completion criterion: the user can paste the generated prompt into Codex to start the loop.
 
 ## Output Contract

package/skills/dirtyloops/references/help.md

@@ -119,16 +119,16 @@ Shape:
 
 ```text
 orchestrator thread
-  -> selector subagent
+  -> selector subagent chooses first ready phase
   -> implementation thread
   -> implementation callback when PR-ready
   -> review thread
   -> review callback when review + CI are resolved
-  -> orchestrator closeout
-  -> next selector
+  -> closeout-selector subagent verifies closeout and next phase
+  -> orchestrator applies closeout and continues or stops
 ```
 
-Only the orchestrator creates implementation and review threads. Worker threads do not create review threads. Worker and reviewer prompts must contain the concrete orchestrator thread id as callback target.
+Only the orchestrator creates implementation and review threads. Worker threads do not create review threads. Worker and reviewer prompts must contain the concrete orchestrator thread id as callback target. Phase selection is delegated: initial selection uses a selector subagent, and between-phase closeout/selection uses a closeout-selector subagent. After launching a worker or reviewer, the orchestrator waits for its single callback instead of repeatedly reading or monitoring the child thread.
 
 ## Which Workflow Should I Pick?
 

package/skills/dirtyloops/references/run-loop.md

@@ -4,10 +4,11 @@ Use this branch to execute an existing dirtyloop. Continue phase-by-phase by def
 
 ## Steps
 
-1. Read Beads.
+1. Read Beads and route phase selection.
    - Inspect the epic and ready child issues.
    - Read dirtyloop metadata from the epic and phase execution metadata from the selected child issue.
-   - Completion criterion: the next ready Beads issue, run policy, workflow, thread defaults, and callback/slice policy are known; or a concrete blocker is known.
+   - For `orchestrator-callback`, launch a selector subagent before choosing the first worker phase. The selector reads Beads, `IMPLEMENT.md`, `loop-state.md`, and linked phase docs, then returns a `swarm-report` with mission `selector`.
+   - Completion criterion: the next ready Beads issue, run policy, workflow, thread defaults, and callback/slice policy are known from Beads plus any required selector report; or a concrete blocker is known.
 
 2. Read the execution context.
    - Read `IMPLEMENT.md`.
@@ -17,6 +18,7 @@ Use this branch to execute an existing dirtyloop. Continue phase-by-phase by def
 
 3. Validate launch preflight.
    - For `orchestrator-callback`, require a concrete orchestrator thread id before launching workers/reviewers. The actual worker/reviewer prompt text must name that exact id as the callback target and must not rely on phrases like `current orchestrator thread`, `this thread`, or `source thread wrapper`.
+   - For `orchestrator-callback`, require callback-wait behavior: after launch, do not repeatedly read or monitor the child thread while waiting for the single callback. Sparse fallback heartbeat is allowed only when the callback is overdue or liveness is uncertain.
    - For `orchestrator-callback`, require worker/reviewer thread defaults to be explicit, defaulting to standard speed/reasoning when metadata does not override it.
    - For `single-thread-subagent`, require a mass-subagent slice/scout plan before broad implementation. The coordinator may perform integration and final repairs, but it must not do most broad discovery or implementation itself.
    - Completion criterion: the workflow can start without relying on inherited thread settings, vague callback targets, or solo coordinator implementation.
@@ -25,17 +27,21 @@ Use this branch to execute an existing dirtyloop. Continue phase-by-phase by def
    - Follow the selected workflow reference.
    - Use required swarms for the workflow.
    - Keep implementation to exactly one phase.
+   - For `orchestrator-callback`, launch the child thread, then yield until its callback instead of polling the child thread for progress.
    - Completion criterion: the workflow reaches PR-ready, approved, repaired, blocked, or stream-complete state.
 
 5. Close out the phase.
+   - For `orchestrator-callback`, launch a closeout-selector subagent after the review callback and before closing the phase, stopping, or launching the next implementation thread.
+   - The closeout-selector checks review callback status, PR/CI evidence, the existing turn doc, Beads dependencies, and `loop-state.md`, then recommends phase closeout plus stop or one next phase.
    - Update the existing turn doc.
    - Update Beads first.
    - Record lifecycle events or notes for worker launch, callbacks, review launch, CI state, phase closeout, and next phase selection when supported by Beads.
    - Refresh Beads export when applicable.
    - Update `loop-state.md`.
-   - Completion criterion: Beads and docs agree on the phase state.
+   - Completion criterion: Beads and docs agree on the phase state, and any required closeout-selector report has been validated and recorded.
 
 6. Continue or stop.
-   - Default: select the next ready Beads child issue and continue the loop.
+   - Default: continue with the next ready Beads child issue selected by the workflow's selection gate.
+   - For `orchestrator-callback`, continue only from a selector or closeout-selector report; do not pick the next phase inline.
    - Stop when the epic is complete, blocked, interrupted, review/CI is unresolved, or the user requested `run once` / `--once`.
    - Completion criterion: final response includes the current phase, PR/CI state, Beads updates, whether the loop continued or stopped, and the exact stop reason when stopped.

package/skills/dirtyloops/references/swarms.md

@@ -4,7 +4,8 @@ dirtyloops use bounded swarms. Fan out aggressively when the phase has broad sur
 
 ## Default Sizes
 
-- selector swarm: 4-8 agents
+- selector swarm: 4-8 agents for `single-thread-subagent`; one selector subagent per phase gate for `orchestrator-callback`
+- closeout-selector gate: one subagent after each `orchestrator-callback` review callback
 - scout swarm: 8-20 agents
 - slice planning swarm: 8-16 agents
 - implementation helper swarm: 8-16 agents
@@ -38,7 +39,7 @@ Use compact reports:
 
 ```json
 {
-  "mission": "scout|slice-plan|implementation-helper|review|ci|storyboard",
+  "mission": "selector|closeout-selector|scout|slice-plan|implementation-helper|review|ci|storyboard",
   "slice_id": "string-or-null",
   "status": "ready|blocked|risk-found|done",
   "scope_checked": ["..."],

package/skills/dirtyloops/references/workflows/orchestrator-callback.md

@@ -1,12 +1,12 @@
 # Workflow: Orchestrator Callback
 
-Use this workflow for the original loop style: a main orchestrator thread creates implementation threads and review threads that call back to a concrete orchestrator thread id.
+Use this workflow for the original loop style: a main orchestrator thread delegates phase gates to selector subagents, creates implementation threads and review threads, and receives callbacks to a concrete orchestrator thread id.
 
 ## Topology
 
 ```text
 orchestrator thread
-  -> selector subagent chooses next ready Beads phase
+  -> selector subagent chooses the first next ready Beads phase
   -> orchestrator creates implementation thread
   -> implementation thread may use subagents
   -> implementation thread opens PR and calls back
@@ -14,8 +14,9 @@ orchestrator thread
   -> review thread may use subagents
   -> review thread owns CI and repairs
   -> review thread calls back after review + CI are resolved
-  -> orchestrator updates Beads and loop state
-  -> orchestrator launches next selector when continuing
+  -> closeout-selector subagent verifies closeout and selects stop or next phase
+  -> orchestrator applies Beads and loop-state updates
+  -> orchestrator launches the next selected phase or stops
 ```
 
 ## Authority
@@ -23,14 +24,30 @@ orchestrator thread
 The orchestrator owns:
 
 - Beads canonical state
-- phase selection
+- selector and closeout-selector subagent dispatch
+- validating selector outputs before advancing the loop
 - implementation thread creation
 - review thread creation
-- concrete callback target, callback preflight, and heartbeat
+- concrete callback target, callback preflight, callback-wait, and sparse fallback heartbeat
 - phase closeout
-- launching the next selector
+- launching the next selected phase
 - stream closeout and storyboard generation
 
+The selector subagent owns:
+
+- reading Beads ready state, dependencies, loop metadata, `IMPLEMENT.md`, `loop-state.md`, and linked phase docs
+- selecting at most one ready phase
+- returning a compact `swarm-report` with mission `selector`
+- reporting blockers, ambiguity, or no-ready-phase state instead of guessing
+
+The closeout-selector subagent owns:
+
+- checking the review callback, PR/CI state, existing turn doc, Beads dependencies, and loop-state mirror
+- recommending exact closeout actions for the just-reviewed phase
+- selecting at most one next phase when continuation is allowed
+- returning a compact `swarm-report` with mission `closeout-selector`
+- reporting the allowed stop state when the epic is complete, blocked, interrupted, unresolved, or `--once`
+
 The implementation thread owns:
 
 - exactly one selected Beads issue
@@ -55,11 +72,50 @@ The review thread owns:
 - Implementation threads do not create review threads.
 - Review threads do not create follow-up implementation threads.
 - Selector subagents never implement.
+- Closeout-selector subagents never implement, review, repair, create threads, or mutate Beads.
 - Reviewer subagents never close Beads issues.
 - The orchestrator is the only actor that advances to the next phase.
+- The orchestrator must launch the initial selector subagent before the first implementation thread.
+- After every review callback, the orchestrator must launch a closeout-selector subagent before closing the phase, stopping, or launching another implementation thread.
+- After launching a worker or reviewer, the orchestrator waits for the single callback. It does not repeatedly read, monitor, summarize, or status-check the child thread.
+- A fallback heartbeat is allowed only when the callback is overdue or liveness is uncertain; do not use heartbeat as routine polling.
 - Implementation and review threads default to standard speed/reasoning unless Beads metadata explicitly overrides it.
 - Before launch, the orchestrator must verify the actual worker/reviewer prompt text includes the exact orchestrator thread id as callback target. Do not launch if the prompt relies on generic wording such as `current orchestrator thread`, `this thread`, or a hidden wrapper.
 
+## Selector Reports
+
+Selector and closeout-selector subagents use `schemas/swarm-report.schema.json`.
+
+Initial selector reports use:
+
+```json
+{
+  "mission": "selector",
+  "slice_id": null,
+  "status": "ready|blocked",
+  "scope_checked": ["bd ready", "IMPLEMENT.md", "loop-state.md", "phase docs"],
+  "findings": [],
+  "recommendations": ["select <phase-id> because ..."],
+  "artifacts": ["docs/implementation/<stream>/<phase-doc>.md"],
+  "context_to_keep": []
+}
+```
+
+Between-phase closeout reports use:
+
+```json
+{
+  "mission": "closeout-selector",
+  "slice_id": null,
+  "status": "ready|blocked|risk-found|done",
+  "scope_checked": ["review callback", "PR/CI state", "turn doc", "Beads dependencies", "loop-state.md"],
+  "findings": [],
+  "recommendations": ["close <phase-id>", "continue with <next-phase-id>"],
+  "artifacts": ["docs/implementation/<stream>/turn-docs/<phase-id>.md"],
+  "context_to_keep": []
+}
+```
+
 ## Implementation Callback
 
 Implementation threads call back exactly once when:
@@ -113,8 +169,8 @@ Payload:
 
 ## Heartbeat
 
-Prefer callback-driven coordination over polling. Use a lightweight fallback heartbeat around 30 minutes for long-running worker/reviewer threads.
+Prefer callback-driven coordination over polling. After worker/reviewer launch, stop reading the child thread and wait for its callback. Use at most a lightweight fallback heartbeat around 30 minutes for long-running threads, and only to recover liveness or an overdue callback.
 
 ## Completion Criterion
 
-The orchestrator has received and validated the required callback, updated Beads and the existing turn doc, and either launched the next selector or reported an allowed stop state.
+The orchestrator has received and validated the required callback, received the required selector or closeout-selector report for the current gate, updated Beads and the existing turn doc, and either launched the selected next phase or reported an allowed stop state.

package/skills/dirtyloops/schemas/swarm-report.schema.json

@@ -5,7 +5,7 @@
   "additionalProperties": false,
   "required": ["mission", "slice_id", "status", "scope_checked", "findings", "recommendations", "artifacts", "context_to_keep"],
   "properties": {
-    "mission": { "enum": ["selector", "scout", "slice-plan", "implementation-helper", "review", "ci", "storyboard"] },
+    "mission": { "enum": ["selector", "closeout-selector", "scout", "slice-plan", "implementation-helper", "review", "ci", "storyboard"] },
     "slice_id": { "type": ["string", "null"] },
     "status": { "enum": ["ready", "blocked", "risk-found", "done"] },
     "scope_checked": {

package/skills/dirtyloops/templates/common/IMPLEMENT.md.template

@@ -22,6 +22,7 @@ This stream is driven by Beads. These docs are execution context and resume aids
 ## Loop Rules
 
 - Select exactly one next ready Beads child issue.
+- Follow the workflow's selector gate before launching implementation.
 - Read the linked phase doc before editing.
 - Continue phase-by-phase by default until the epic is complete, blocked, interrupted, or review/CI is unresolved.
 - Use `run once` / `--once` only when intentionally running one phase and stopping after closeout.

package/skills/dirtyloops/templates/common/run-loop.md.template

@@ -15,6 +15,7 @@ Start from:
 
 - Beads is canonical.
 - Select exactly one next ready Beads child issue.
+- Use the selected workflow's phase-selection gate; do not pick phases inline when the workflow requires selector subagents.
 - Continue phase-by-phase by default until the epic is complete, blocked, interrupted, or review/CI is unresolved.
 - Stop after one phase only when this run explicitly says `run once` or `--once`.
 - Read the linked phase doc before editing.

package/skills/dirtyloops/templates/workflows/orchestrator-callback/closeout-selector-subagent-prompt.md.template

@@ -0,0 +1,33 @@
+# Closeout-Selector Subagent Prompt: {{STREAM_NAME}}
+
+You are the closeout-selector subagent for an `orchestrator-callback` dirtyloop.
+
+Canonical tracker: Beads epic `{{EPIC_ID}}`
+
+Mission: verify the just-reviewed phase can be closed out, then recommend stop or at most one next phase.
+
+Read:
+
+- Beads epic `{{EPIC_ID}}`
+- the reviewed phase issue
+- the implementation callback
+- the review callback
+- PR and CI evidence
+- the existing phase turn doc
+- `docs/implementation/{{STREAM_SLUG}}/IMPLEMENT.md`
+- `docs/implementation/{{STREAM_SLUG}}/loop-state.md`
+- linked phase docs for the next ready candidates
+
+Rules:
+
+- Do not implement.
+- Do not review or repair.
+- Do not mutate Beads.
+- Do not edit files.
+- Do not create implementation or review threads.
+- Recommend exact closeout actions for the reviewed phase.
+- Recommend stop when the epic is complete, blocked, interrupted, unresolved, or this is a `--once` run.
+- Recommend exactly one next phase only when continuation is allowed and Beads dependencies make it ready.
+
+Return a compact report matching `schemas/swarm-report.schema.json` with `mission: "closeout-selector"`.
+

package/skills/dirtyloops/templates/workflows/orchestrator-callback/run-loop-addendum.md.template

@@ -3,8 +3,13 @@
 This loop uses a main orchestrator thread plus separate implementation and review threads.
 
 - Only the orchestrator creates implementation and review threads.
+- Before the first worker, the orchestrator launches a selector subagent to choose exactly one next ready Beads phase.
+- After every review callback, the orchestrator launches a closeout-selector subagent before closing the phase, stopping, or launching another worker.
+- Selector and closeout-selector subagents return `swarm-report` payloads with mission `selector` or `closeout-selector`; they do not mutate Beads, edit files, implement, review, repair, create threads, or advance the loop.
 - The orchestrator passes its concrete thread id as the callback target.
 - Before launching a worker or reviewer, verify the actual prompt text includes that exact thread id and does not rely on generic wording like `current orchestrator thread` or `this thread`.
+- After launching a worker or reviewer, wait for its single callback. Do not repeatedly read, monitor, summarize, or status-check the child thread while waiting.
+- Use a sparse fallback heartbeat around 30 minutes only when the callback is overdue or liveness is uncertain; do not use heartbeat as routine polling.
 - Worker and reviewer threads default to standard speed/reasoning unless Beads loop metadata explicitly overrides it.
 - Implementation threads update the existing phase turn doc, open the PR, and call back exactly once when PR-ready or blocked.
 - Implementation callback payloads must echo `orchestrator_thread_id` and include `source_thread_id`.
@@ -13,5 +18,4 @@ This loop uses a main orchestrator thread plus separate implementation and revie
 - Review threads own CI, repairs, reruns, and evidence.
 - Review threads update the existing phase turn doc and call back exactly once when review and CI are resolved.
 - Review callback payloads must echo `orchestrator_thread_id` and include `source_thread_id`.
-- The orchestrator owns Beads closeout and next selector launch.
-- Use a fallback heartbeat around 30 minutes for long-running threads.
+- The orchestrator validates selector reports, owns Beads closeout, and launches only the selected next phase.

package/skills/dirtyloops/templates/workflows/orchestrator-callback/selector-subagent-prompt.md.template

@@ -0,0 +1,28 @@
+# Selector Subagent Prompt: {{STREAM_NAME}}
+
+You are the selector subagent for an `orchestrator-callback` dirtyloop.
+
+Canonical tracker: Beads epic `{{EPIC_ID}}`
+
+Mission: select at most one next ready Beads phase for the orchestrator.
+
+Read:
+
+- Beads epic `{{EPIC_ID}}`
+- Beads loop metadata
+- `docs/implementation/{{STREAM_SLUG}}/IMPLEMENT.md`
+- `docs/implementation/{{STREAM_SLUG}}/loop-state.md`
+- linked phase docs for ready or nearly-ready child issues
+
+Rules:
+
+- Do not implement.
+- Do not review.
+- Do not mutate Beads.
+- Do not edit files.
+- Do not create implementation or review threads.
+- Select exactly one phase only when Beads says it is ready and the linked phase doc is coherent.
+- If no phase is ready or the state is ambiguous, report `blocked` with evidence.
+
+Return a compact report matching `schemas/swarm-report.schema.json` with `mission: "selector"`.
+