@dirtydishes/skills 0.1.2 → 0.1.4

package/README.md

@@ -90,11 +90,11 @@ A created loop writes a project-local execution surface under `docs/implementati
 - `IMPLEMENT.md` - Agent-facing index for the stream, including workflow rules, phase links, quality gates, and operating contract.
 - `00-roadmap.md` - Human-readable map of the implementation stream and phase ordering.
 - `NN-phase-name.md` - One phase doc per Beads child issue.
-- Beads loop metadata - Canonical workflow, run policy, callback policy, thread defaults, swarm policy, quality gates, and branch/PR policy.
+- Beads loop metadata - Canonical workflow, run policy, callback policy, actor-specific thread defaults, swarm policy, quality gates, and branch/PR policy.
 - `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, implementation-swarm, 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.
 
@@ -109,19 +109,19 @@ 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.
+- `single-thread-subagent` - One visible coordinator thread owns loop state while per-phase mass subagent swarms handle selection, scouting, slice planning, implementation assistance, review, and CI.
+- `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 `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. Every phase uses selector, scout, slice-plan, implementation-helper, reviewer, and CI swarms; subagents inspect, split phases into slices, prepare implementation guidance or patches, review, verify CI, and report, but they do not advance loop state. Fewer agents require an explicit tiny-phase reason in the turn doc 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. Implementation threads are swarm-first for non-trivial phases: they run scout, slice-plan, and implementation-helper swarms, synthesize a coherent slice plan, integrate helper output, and only then open the PR.
 
 #### Authority Rules
 
 The `dirtyloops` skill is strict about ownership:
 
 - Beads is canonical for status, ordering, blockers, dependencies, and completion.
-- Beads stores typed dirtyloop metadata for workflow, run policy, callback policy, thread defaults, swarm policy, quality gates, and branch/PR policy.
+- Beads stores typed dirtyloop metadata for workflow, run policy, callback policy, actor-specific thread defaults, swarm policy, quality gates, and branch/PR policy.
 - Generated docs and prompts use repo-relative paths so they can move between machines.
 - Phase docs are execution context linked from Beads child issues.
 - One Markdown turn doc exists per phase.
@@ -132,17 +132,21 @@ 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.
+Every `orchestrator-callback` child thread must launch with explicit actor settings: `speed: standard`, `reasoning: high`, and `inherit_orchestrator_thread_settings: false`, unless Beads metadata overrides that actor. This applies to selector, implementation, review, and closeout-selector threads. Current UI settings, recent Codex thread defaults, parent/orchestrator settings, `fast`, and `xhigh` are not valid launch defaults unless the actor metadata names them.
+
+For `orchestrator-callback`, implementation threads must not do broad solo implementation. For non-trivial phases, they run 8-20 scout agents, 8-16 slice-plan agents, and 8-16 implementation-helper agents before broad edits. The implementation thread synthesizes reports into the existing turn doc, integrates helper output coherently, owns gates and PR state, and includes a `swarm_summary` in the implementation callback. If a phase is tiny enough to use fewer agents, the reason is recorded in the turn doc and callback.
+
+For `single-thread-subagent`, the coordinator must run per-phase selector/scout/slice-plan/implementation-helper/reviewer/CI swarms. 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.
 
 #### Callback Contracts
 
-Implementation threads call back exactly once when the PR is ready, the task is complete but PR creation is blocked, or the phase is genuinely blocked. The callback includes the concrete orchestrator thread id, source thread id, Beads issue id, status, branch, PR, commits, turn doc, local gates, changed files, blockers, and context to keep.
+Implementation threads call back exactly once when the PR is ready, the task is complete but PR creation is blocked, or the phase is genuinely blocked. The callback includes the concrete orchestrator thread id, source thread id, Beads issue id, status, branch, PR, commits, turn doc, local gates, changed files, `swarm_summary`, blockers, and context to keep.
 
 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.4",
   "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.
@@ -50,7 +50,7 @@ A dirtyloop is a Beads-canonical Codex implementation loop: phase docs, one Mark
 ## Hard Requirements
 
 - Beads is canonical for status, ordering, blockers, dependencies, and completion.
-- Beads records typed dirtyloop metadata: workflow, run policy, branch/PR policy, quality gates, callback policy, thread defaults, and swarm policy.
+- Beads records typed dirtyloop metadata: workflow, run policy, branch/PR policy, quality gates, callback policy, actor-specific thread defaults, and swarm policy.
 - Phase docs are execution context linked from Beads.
 - Generated docs, prompts, examples, and callback payloads use repo-relative paths. Do not include user-specific home directories or usernames in generated loop artifacts.
 - Use one Markdown turn doc per phase.
@@ -58,10 +58,13 @@ 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.
-- 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.
+- 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.
+- Every orchestrator-callback child thread defaults to `speed: standard`, `reasoning: high`, and `inherit_orchestrator_thread_settings: false` unless Beads loop metadata explicitly overrides that actor. This applies to selector, implementation, review, and closeout-selector threads. Do not launch child threads with inherited `fast`, `xhigh`, current UI, or orchestrator-thread settings.
+- Orchestrator-callback implementation threads are swarm-first for non-trivial phases: they must run massive bounded scout, slice-plan, and implementation-helper swarms before broad edits, synthesize one coherent slice plan, integrate helper output, and include `swarm_summary` in the implementation callback.
+- For `single-thread-subagent`, the coordinator orchestrates, synthesizes, integrates, owns branch/PR/Beads state, and closes out. Each phase must launch per-phase selector, scout, slice-plan, implementation-helper, review, and CI swarms unless the phase is explicitly tiny and the reason is recorded in the turn doc. Direct coordinator implementation is for integration, glue, conflict resolution, and final repair work.
+- Use large bounded subagent swarms: per-phase for `single-thread-subagent`, swarm-first inside non-trivial `orchestrator-callback` implementation threads, 8+ by default for scout, slice-plan, implementation-helper, and review work, and up to 20 when the phase warrants it.
 - Closeout generates `storyboard-post-run-mm-dd-yyyy.html`.
 - The storyboard should use `impeccable` when present. If it is missing, continue without it and add a brief note that the skill was not found and was skipped during closeout.
 - Closeout must install `@pierre/diffs` in the target repo if missing, then use `@pierre/diffs/ssr` for every storyboard diff. SSR is required for every diff block.

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.
+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, actor-specific thread defaults, swarm policy, and prompt wording.

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

@@ -6,13 +6,15 @@ Topology:
 
 ```text
 orchestrator thread
-  -> selector subagent
+  -> selector subagent chooses first ready phase
   -> implementation thread with exact callback target
+  -> scout/slice-plan/implementation-helper swarms
+  -> worker integrates one coherent PR
   -> 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

@@ -13,7 +13,7 @@ Replace an old reporting path with a simpler evidence-backed implementation whil
 ## Sources Of Truth
 
 - Beads epic: `example-epic`
-- Beads loop metadata: workflow, run policy, callback policy, thread defaults, quality gates, and branch/PR policy
+- Beads loop metadata: workflow, run policy, callback policy, actor-specific thread defaults, quality gates, and branch/PR policy
 - Roadmap: `docs/implementation/example-stream/00-roadmap.md`
 - Loop state mirror: `docs/implementation/example-stream/loop-state.md`
 - Phase docs linked from Beads child issues
@@ -23,28 +23,51 @@ 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
+- launch with `speed: standard`, `reasoning: high`, and `inherit_orchestrator_thread_settings: false` unless Beads metadata overrides the selector actor
+- 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
-- default to standard speed/reasoning unless Beads metadata explicitly overrides it
+- launch with `speed: standard`, `reasoning: high`, and `inherit_orchestrator_thread_settings: false` unless Beads metadata overrides the implementation actor
 - have prompt text that names the exact orchestrator thread id as callback target
-- may use bounded subagents
+- run 8-20 scout agents, 8-16 slice-plan agents, and 8-16 implementation-helper agents for non-trivial phases
+- synthesize swarm reports into one coherent slice plan before broad edits
+- integrate helper output, resolve conflicts, and own final branch/PR state
 - update the existing phase turn doc
 - open the PR
-- call back exactly once when PR-ready or blocked, echoing `orchestrator_thread_id` and including `source_thread_id`
+- call back exactly once when PR-ready or blocked, echoing `orchestrator_thread_id`, including `source_thread_id`, and reporting `swarm_summary`
 - do not create review threads
 
 Review threads:
 
 - use `thermo-nuclear-code-quality-review`
-- default to standard speed/reasoning unless Beads metadata explicitly overrides it
+- launch with `speed: standard`, `reasoning: high`, and `inherit_orchestrator_thread_settings: false` unless Beads metadata overrides the review actor
 - have prompt text that names the exact orchestrator thread id as callback target
 - may use reviewer and CI verification subagents
 - own CI, repairs, reruns, and evidence
 - 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
+- launch with `speed: standard`, `reasoning: high`, and `inherit_orchestrator_thread_settings: false` unless Beads metadata overrides the closeout-selector actor
+- 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.
+
+No `orchestrator-callback` child thread inherits current UI settings, recent Codex thread defaults, or parent/orchestrator speed/reasoning. `fast` speed and `xhigh` reasoning are allowed only when Beads metadata explicitly names that value for the actor being launched.
 
 ## Phase Ledger
 

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

@@ -0,0 +1,40 @@
+# 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.
+
+Launch defaults:
+
+- speed: `standard`
+- reasoning: `high`
+- inherit_orchestrator_thread_settings: `false`
+
+Do not run this closeout-selector with inherited UI, recent thread, parent/orchestrator, `fast`, or `xhigh` settings unless Beads metadata explicitly overrides the closeout-selector actor.
+
+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/implementation-swarm-subagent.md

@@ -0,0 +1,29 @@
+# Implementation Swarm Subagent Prompt: Example Stream
+
+You are an implementation swarm subagent inside an `orchestrator-callback` implementation thread.
+
+Mission: `scout|slice-plan|implementation-helper`
+
+Allowed missions:
+
+- `scout`: inspect a bounded surface and report facts, risks, likely files, and tests
+- `slice-plan`: propose non-overlapping implementation slices and integration order
+- `implementation-helper`: work one assigned slice in parallel and return patch guidance, changed files, gates, and integration notes
+
+Inputs:
+
+- Beads issue: `example-epic.1`
+- Phase doc: `docs/implementation/example-stream/01-foundation.md`
+- Turn doc: `docs/implementation/example-stream/turn-docs/01-foundation.md`
+- Slice id: assigned by the implementation thread
+- Assigned scope: assigned by the implementation thread
+
+Rules:
+
+- Stay inside the assigned scope.
+- Do not mutate Beads.
+- Do not create PRs or review threads.
+- Do not own loop state or callback.
+- Implementation-helper agents may prepare patches or concrete edit guidance only for their assigned slice.
+- Return compact structured output matching `schemas/swarm-report.schema.json`.
+

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

@@ -15,16 +15,25 @@ Send your final callback to exact orchestrator thread id `THREAD_ORCHESTRATOR_ID
 - Implementation index: `docs/implementation/example-stream/IMPLEMENT.md`
 - Turn doc: `docs/implementation/example-stream/turn-docs/01-foundation.md`
 - Branch policy: create or use `example-stream/01-foundation`
-- Thread default: standard speed/reasoning
+- Launch defaults: speed `standard`, reasoning `high`, inherit_orchestrator_thread_settings `false`
+- Do not run this worker with inherited UI, recent thread, parent/orchestrator, `fast`, or `xhigh` settings unless Beads metadata explicitly overrides the implementation actor
 
 ## Rules
 
 - Implement exactly this phase.
 - Do not widen scope.
-- Use bounded implementation/scout subagents when useful.
+- Do not do broad solo implementation.
+- For non-trivial phases, run massive bounded swarms before broad edits:
+  - 8-20 scout agents across files, modules, risks, tests, and integration edges
+  - 8-16 slice-plan agents to propose non-overlapping implementation slices
+  - 8-16 implementation-helper agents assigned to slices in parallel
+- If this phase is tiny enough to use fewer than the default agents, record the reason in the turn doc and callback `swarm_summary`.
+- Synthesize swarm reports into one coherent slice plan before broad edits.
+- Integrate helper output yourself; own conflicts, final repairs, gates, branch state, PR state, and callback.
 - Update the existing Markdown turn doc.
 - Run local gates before PR when feasible.
 - Open or update the PR.
 - Do not create the review thread.
 - Call back exactly once to the orchestrator when PR-ready or blocked.
 - The callback payload must include `orchestrator_thread_id: "THREAD_ORCHESTRATOR_ID"` and your `source_thread_id`.
+- The callback payload must include `swarm_summary` with scout, slice-plan, implementation-helper, slice, synthesis, and under-default rationale fields.

package/skills/dirtyloops/examples/orchestrator-callback/docs/implementation/example-stream/prompts/review-thread.md

@@ -21,12 +21,13 @@ Use:
 - Turn doc: `docs/implementation/example-stream/turn-docs/01-foundation.md`
 - PR: `#123`
 - Required gates: `bun test`, `bun run typecheck`
-- Thread default: standard speed/reasoning
+- Launch defaults: speed `standard`, reasoning `high`, inherit_orchestrator_thread_settings `false`
+- Do not run this reviewer with inherited UI, recent thread, parent/orchestrator, `fast`, or `xhigh` settings unless Beads metadata explicitly overrides the review actor
 
 ## Rules
 
 - Be ambitious about structural simplification.
-- Use reviewer and CI verification subagents when useful.
+- Use reviewer and CI verification subagents for review and CI evidence. If the phase is tiny enough to use fewer than the default review/CI agents, record why in the turn doc.
 - Own CI through green, repaired-and-green, unavailable-with-evidence, or blocked-with-cause.
 - Apply safe in-scope repairs when assigned.
 - Update the existing Markdown turn doc.

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

@@ -13,11 +13,15 @@ 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.
+- Selector, implementation, review, and closeout-selector threads launch with explicit actor settings: `speed: standard`, `reasoning: high`, and `inherit_orchestrator_thread_settings: false`, unless Beads metadata overrides that actor.
+- Do not inherit current UI settings, recent Codex thread defaults, parent/orchestrator settings, `fast`, or `xhigh` unless Beads metadata explicitly names that value for the actor being launched.
 - 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 are swarm-first for non-trivial phases: 8-20 scout agents, 8-16 slice-plan agents, and 8-16 implementation-helper agents before broad edits.
+- Implementation threads synthesize swarm reports into the turn doc, integrate helper output coherently, and include `swarm_summary` in the callback.
 - 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 +29,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 with `speed: standard`, `reasoning: high`, and `inherit_orchestrator_thread_settings: false` to select one next ready Beads child issue, create an implementation thread with those same explicit defaults, the full linked phase doc, and exact callback target `THREAD_ORCHESTRATOR_ID` in the prompt text. The implementation thread must run 8-20 scout agents, 8-16 slice-plan agents, and 8-16 implementation-helper agents for non-trivial phases, synthesize their reports into one coherent slice plan, integrate helper output, and include `swarm_summary` in its callback. 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 with those same explicit defaults 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 with those same explicit defaults to verify closeout and select stop or at most one next phase. Do not inherit current UI, recent thread, parent/orchestrator, `fast`, or `xhigh` settings unless Beads metadata explicitly overrides the actor being launched. 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,35 @@
+# 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.
+
+Launch defaults:
+
+- speed: `standard`
+- reasoning: `high`
+- inherit_orchestrator_thread_settings: `false`
+
+Do not run this selector with inherited UI, recent thread, parent/orchestrator, `fast`, or `xhigh` settings unless Beads metadata explicitly overrides the selector actor.
+
+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,11 +8,13 @@ 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
 
 - Implementation thread `THREAD_IMPLEMENTATION_ID` created with orchestrator callback target `THREAD_ORCHESTRATOR_ID`.
+- Worker launched 12 scout agents, 8 slice-plan agents, and 10 implementation-helper agents.
+- Worker synthesized swarm reports into five file-group slices, integrated helper output, and resolved final test wiring in the main worker thread.
 - Worker created branch `example-stream/01-foundation`.
 - Worker opened PR `#123`.
 
@@ -31,6 +33,14 @@ Selected by the orchestrator after `bd ready` showed `example-epic.1` unblocked.
   "turn_doc": "docs/implementation/example-stream/turn-docs/01-foundation.md",
   "local_gates": ["bun test: passed"],
   "changed_files": ["src/reporting/model.ts", "src/reporting/model.test.ts"],
+  "swarm_summary": {
+    "scout_agents": 12,
+    "slice_plan_agents": 8,
+    "implementation_helper_agents": 10,
+    "slice_count": 5,
+    "synthesis": "Scout findings were collapsed into five file-group slices; helper outputs were integrated by the worker before PR.",
+    "used_less_than_default_reason": null
+  },
   "blockers": [],
   "context_to_keep": ["The new model boundary is report-in/report-out and does not know UI concerns."]
 }
@@ -76,4 +86,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/examples/single-thread-subagent/README.md

@@ -12,3 +12,4 @@ main coordinator thread
 ```
 
 Beads is canonical. Subagents are bounded and disposable. The main thread owns loop state, branch/PR state, integration, and closeout. Broad implementation starts only after a mass subagent slice plan.
+Every phase uses selector, scout, slice-plan, implementation-helper, reviewer, and CI swarms unless the coordinator records an explicit tiny-phase exception in the turn doc before implementation.

package/skills/dirtyloops/examples/single-thread-subagent/docs/implementation/example-stream/IMPLEMENT.md

@@ -23,7 +23,7 @@ Replace an old reporting path with a simpler evidence-backed implementation whil
 
 The main coordinator thread owns integration, branch state, PR state, Beads updates, and closeout.
 
-Subagents are bounded swarms:
+Every phase uses bounded swarms:
 
 - selector swarm: 4-8 agents
 - scout swarm: 8-20 agents
@@ -34,7 +34,7 @@ Subagents are bounded swarms:
 
 Subagents split the phase into slices, inspect, prepare implementation guidance or patches, review, verify, and report. They do not own loop state.
 
-The coordinator runs a slice planning swarm before broad implementation. Direct coordinator implementation is limited to synthesis, integration, glue, conflicts, final repairs, and Beads/PR closeout.
+The coordinator runs a slice planning swarm before implementation. Direct coordinator implementation is limited to synthesis, integration, glue, conflicts, final repairs, and Beads/PR closeout. If a phase is tiny enough to use fewer than the default per-phase swarms, the coordinator records the reason in the turn doc before implementation.
 
 ## Phase Ledger
 

package/skills/dirtyloops/examples/single-thread-subagent/docs/implementation/example-stream/prompts/run-loop.md

@@ -10,13 +10,14 @@ Canonical tracker: Beads epic `example-epic`
 - Do not create separate Codex worker or reviewer threads.
 - Continue phase-by-phase until the epic is complete, blocked, interrupted, or review/CI is unresolved.
 - The main thread owns integration, branch state, PR state, Beads updates, and closeout.
-- Use bounded selector/scout/slice/implementation-helper/reviewer/CI subagent swarms.
-- Use 8+ subagents by default for broad scout, slice, implementation-helper, and review work.
-- Run a slice planning swarm before broad implementation.
+- For every phase, use selector, scout, slice-plan, implementation-helper, reviewer, and CI subagent swarms.
+- Default per-phase sizes: selector 4-8 agents, scout 8-20 agents, slice-plan 8-16 agents, implementation-helper 8-16 agents, reviewer 8-20 agents, and CI verification 4-12 agents.
+- If a phase is tiny enough to use fewer than the default per-phase swarms, record why in the turn doc before implementation.
+- Run a slice planning swarm before implementation.
 - Reviewer agents use `thermo-nuclear-code-quality-review`.
 - Reviewer and CI verification agents own CI evidence.
 - Update the existing Markdown turn doc.
 
 ## Start Prompt
 
-Run the Example Stream dirtyloop with workflow `single-thread-subagent`. 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, use mass subagent swarms for selector/scout/slice/implementation-helper/review/CI work, synthesize the slice plan before broad implementation, integrate only the selected phase in the main thread, update the existing Markdown turn doc, update Beads first, then update `loop-state.md`. 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 `single-thread-subagent`. 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, use per-phase mass subagent swarms for selector/scout/slice-plan/implementation-helper/review/CI work, synthesize the slice plan before implementation, integrate only the selected phase in the main thread, update the existing Markdown turn doc, update Beads first, then update `loop-state.md`. If a phase is tiny enough to use fewer than the default per-phase swarms, record why in the turn doc before implementation. Continue to the next ready phase unless the epic is complete, blocked, interrupted, or review/CI is unresolved.

package/skills/dirtyloops/examples/single-thread-subagent/docs/implementation/example-stream/turn-docs/01-foundation.md

@@ -11,11 +11,11 @@ Selected by the main coordinator after Beads showed `example-epic.1` ready.
 ## Subagent Swarms
 
 - Selector swarm confirmed no dependencies.
-- Scout swarm checked old reporting behavior.
-- Slice planning swarm split implementation into `slice-model-boundary`, `slice-tests`, and `slice-adapter-cleanup`.
-- Implementation helper swarm prepared patch guidance for each slice.
-- Reviewer swarm used `thermo-nuclear-code-quality-review`.
-- CI verification swarm resolved gate evidence.
+- Scout swarm used 12 agents to check old reporting behavior, likely files, tests, and integration risks.
+- Slice planning swarm used 8 agents to split implementation into `slice-model-boundary`, `slice-tests`, and `slice-adapter-cleanup`.
+- Implementation helper swarm used 10 agents to prepare patch guidance for each slice.
+- Reviewer swarm used 12 agents with `thermo-nuclear-code-quality-review`.
+- CI verification swarm used 4 agents to resolve gate evidence.
 
 ## Implementation Log
 

package/skills/dirtyloops/plan.html

@@ -438,7 +438,7 @@
       <div class="workflow">
         <article class="workflow-card">
           <h3>single-thread-subagent</h3>
-          <p>One visible coordinator owns loop state, integration, PRs, and closeout. Mass subagent swarms handle scouting, slice planning, implementation help, review, and CI.</p>
+          <p>One visible coordinator owns loop state, integration, PRs, and closeout. Every phase uses mass selector, scout, slice-plan, implementation-helper, review, and CI swarms unless a tiny-phase exception is recorded.</p>
           <div class="flow">
             <div class="node">
               <b>1</b>
@@ -446,7 +446,7 @@
             </div>
             <div class="node">
               <b>2</b>
-              <div><strong>Mass swarms split the phase</strong><span>Scout, slice, implementation-helper, reviewer, and CI agents return compact reports.</span></div>
+              <div><strong>Per-phase swarms split the phase</strong><span>Selector, scout, slice-plan, implementation-helper, reviewer, and CI agents return compact reports.</span></div>
             </div>
             <div class="node">
               <b>3</b>
@@ -457,20 +457,24 @@
 
         <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 child threads with explicit standard speed, high reasoning, and no inherited settings, requires swarm-first implementation workers, 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>
-              <div><strong>Implementation thread opens PR</strong><span>Worker uses the exact callback id, updates the turn doc, and calls back once.</span></div>
+              <div><strong>Implementation thread swarms</strong><span>Worker runs scout, slice-plan, and implementation-helper swarms, then integrates one coherent PR.</span></div>
             </div>
             <div class="node callback">
               <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>
@@ -576,7 +580,7 @@ Repo: .
 Stream slug: example-stream
 Epic title: Example stream migration
 Run policy: until complete; use --once only for one-shot operation
-Thread defaults: implementation standard, review standard
+Thread defaults: selector/implementation/review/closeout-selector speed standard, reasoning high, no inherit
 Quality gates: bun test, bun run typecheck, targeted browser QA
 Branch/PR policy: one active implementation PR at a time</code></pre>
     </section>