@dirtydishes/skills 0.1.2 → 0.1.4

package/skills/dirtyloops/references/beads.md

@@ -52,12 +52,16 @@ Epic metadata must include:
   "branch_pr_policy": "...",
   "quality_gates": ["..."],
   "thread_defaults": {
-    "implementation": { "speed": "standard" },
-    "review": { "speed": "standard" }
+    "selector": { "speed": "standard", "reasoning": "high", "inherit_orchestrator_thread_settings": false },
+    "implementation": { "speed": "standard", "reasoning": "high", "inherit_orchestrator_thread_settings": false },
+    "review": { "speed": "standard", "reasoning": "high", "inherit_orchestrator_thread_settings": false },
+    "closeout_selector": { "speed": "standard", "reasoning": "high", "inherit_orchestrator_thread_settings": false }
   }
 }
 ```
 
+Thread defaults are actor-specific. Do not use `inherit`, current UI settings, the parent/orchestrator thread setting, or recent Codex thread defaults as the source of child-thread speed or reasoning. `fast` speed and `xhigh` reasoning are allowed only when the loop metadata explicitly names that value for that actor.
+
 For `orchestrator-callback`, add:
 
 ```json
@@ -65,8 +69,25 @@ 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
+  },
+  "implementation_swarm_policy": {
+    "requires_swarm_first_for_non_trivial_phases": true,
+    "target_scout_agents": "8-20",
+    "target_slice_plan_agents": "8-16",
+    "target_implementation_helper_agents": "8-16",
+    "requires_slice_plan_before_broad_edits": true,
+    "lead_worker_role": "synthesize-integrate-own-pr",
+    "callback_requires_swarm_summary": true
   }
 }
 ```
@@ -77,19 +98,22 @@ For `single-thread-subagent`, add:
 {
   "swarm_policy": {
     "mode": "mass-subagent",
+    "requires_per_phase_swarms": true,
     "min_parallel_agents": 8,
+    "target_selector_agents": "4-8",
     "target_scout_agents": "8-20",
-    "target_slice_agents": "8-16",
+    "target_slice_plan_agents": "8-16",
     "target_implementation_helper_agents": "8-16",
     "target_review_agents": "8-20",
     "target_ci_agents": "4-12",
     "requires_slice_plan_before_implementation": true,
+    "tiny_phase_exception_requires_turn_doc_reason": true,
     "coordinator_direct_implementation": "integration-only"
   }
 }
 ```
 
-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/implementation-swarm data or swarm slice policy for the selected workflow.
 
 ## Selection
 

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

@@ -13,11 +13,13 @@ Required:
 - epic title
 - workflow
 - run policy
-- thread defaults
+- actor-specific thread defaults
 - callback policy for `orchestrator-callback`
 - swarm policy for `single-thread-subagent`
+- implementation swarm policy for `orchestrator-callback`
 - 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.
 
@@ -25,9 +27,11 @@ 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
-- single-thread-subagent swarm mode: mass-subagent, minimum 8 parallel agents for broad scout/slice/review work
+- orchestrator-callback child threads: `speed: standard`, `reasoning: high`, `inherit_orchestrator_thread_settings: false`
+- 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
+- orchestrator-callback implementation swarm policy: swarm-first for non-trivial phases with 8-20 scouts, 8-16 slice-plan agents, and 8-16 implementation-helper agents
+- single-thread-subagent swarm mode: per-phase mass-subagent, selector 4-8, scout 8-20, slice-plan 8-16, implementation-helper 8-16, review 8-20, CI 4-12
 
 ## Steps
 
@@ -43,10 +47,14 @@ Ask only for missing decisions. Prefer these defaults when the user has not spec
    - Completion criterion: every plan requirement maps to one phase or an explicit follow-up.
 
 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 `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.
+   - Record workflow, run policy, branch/PR policy, quality gates, and actor-specific thread defaults.
+   - For `orchestrator-callback`, record thread defaults for selector, implementation, review, and closeout-selector actors. Default each actor to `speed: standard`, `reasoning: high`, and `inherit_orchestrator_thread_settings: false` unless the user explicitly chose an actor-specific override.
+   - For `orchestrator-callback`, do not let child threads inherit current UI settings, recent Codex thread defaults, or orchestrator-thread speed/reasoning. `fast` speed and `xhigh` reasoning require explicit Beads metadata for that actor.
+   - 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 `orchestrator-callback`, record implementation swarm policy: non-trivial phases require 8-20 scout agents, 8-16 slice-plan agents, 8-16 implementation-helper agents, pre-edit slice-plan synthesis, coherent lead-worker integration, and implementation callback `swarm_summary`.
+   - For `single-thread-subagent`, record swarm policy: per-phase mass-subagent mode, selector/scout/slice-plan/implementation-helper/review/CI swarm sizes, mandatory slice plan before implementation, tiny-phase exception rationale, and coordinator-direct-implementation limits.
+   - Completion criterion: the loop can be validated from Beads metadata before any worker, reviewer, or implementation work starts.
 
 4. Create Beads state.
    - Create or update the epic.
@@ -68,7 +76,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, actor-specific thread defaults, selector gates, implementation swarm policy, 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

@@ -11,7 +11,7 @@ Do not mutate files, Beads, branches, PRs, or threads while answering help.
 Every dirtyloop uses:
 
 - Beads as canonical tracker
-- typed loop metadata on Beads for workflow, run policy, callback policy, thread defaults, swarm policy, quality gates, and branch/PR policy
+- typed loop metadata on Beads for workflow, run policy, callback policy, actor-specific thread defaults, swarm policy, quality gates, and branch/PR policy
 - phase docs linked from Beads child issues
 - repo-relative paths in generated docs and prompts
 - one Markdown turn doc per phase
@@ -40,7 +40,7 @@ Required inputs:
 - epic title
 - workflow
 - run policy
-- thread defaults
+- actor-specific thread defaults
 - quality gates
 - branch/PR policy
 
@@ -109,7 +109,7 @@ main coordinator thread
   -> coordinator closeout
 ```
 
-Use it for CLI-friendly or context-controlled loops where separate callback threads are not desired. Single-thread means one visible coordinator, not solo implementation; broad phases should use 8+ subagents and a slice plan before implementation.
+Use it for CLI-friendly or context-controlled loops where separate callback threads are not desired. Single-thread means one visible coordinator, not solo implementation; every phase uses selector, scout, slice-plan, implementation-helper, reviewer, and CI swarms unless a tiny-phase exception is recorded in the turn doc before implementation.
 
 ### `orchestrator-callback`
 
@@ -119,16 +119,18 @@ 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. 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. Current UI, recent thread, parent/orchestrator, `fast`, and `xhigh` settings do not count as defaults. After launching a worker or reviewer, the orchestrator waits for its single callback instead of repeatedly reading or monitoring the child thread.
+
+Implementation threads are swarm-first for non-trivial phases. They run 8-20 scout agents, 8-16 slice-plan agents, and 8-16 implementation-helper agents before broad edits, synthesize the reports into one slice plan, integrate helper output coherently, and include `swarm_summary` in the implementation callback. Fewer agents require an explicit tiny-phase reason in the turn doc and callback.
 
 ## 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,25 +18,31 @@ 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 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.
+   - 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 explicit launch defaults for every child actor before launch: selector, implementation, review, and closeout-selector. Defaults are `speed: standard`, `reasoning: high`, and `inherit_orchestrator_thread_settings: false` unless Beads metadata overrides that actor.
+   - For `orchestrator-callback`, reject inherited launch settings. Do not use 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.
+   - For `single-thread-subagent`, require per-phase selector, scout, slice-plan, implementation-helper, review, and CI swarms before implementation and closeout. The coordinator may perform integration and final repairs, but it must not do most discovery or implementation itself.
    - Completion criterion: the workflow can start without relying on inherited thread settings, vague callback targets, or solo coordinator implementation.
 
 4. Run the selected workflow.
    - 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

@@ -1,10 +1,11 @@
 # Swarms
 
-dirtyloops use bounded swarms. Fan out aggressively when the phase has broad surface area, shared architecture, CI risk, or user-facing behavior. In `single-thread-subagent`, mass subagent work is mandatory for broad phases: the visible coordinator orchestrates, synthesizes, integrates, and closes out; subagents do much of the discovery, slicing, implementation analysis, review, and CI verification.
+dirtyloops use bounded swarms. Fan out aggressively when the phase has shared architecture, CI risk, user-facing behavior, or any meaningful implementation surface. In `single-thread-subagent`, mass subagent work is mandatory per phase: the visible coordinator orchestrates, synthesizes, integrates, and closes out; subagents do the discovery, slicing, implementation analysis, review, and CI verification. In `orchestrator-callback`, implementation threads are also swarm-first for non-trivial phases: the worker runs scout, slice-plan, and implementation-helper swarms before broad edits, then integrates the results coherently.
 
 ## 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
@@ -12,7 +13,15 @@ dirtyloops use bounded swarms. Fan out aggressively when the phase has broad sur
 - CI verification swarm: 4-12 agents
 - storyboard synthesis swarm: 3-8 agents
 
-For `single-thread-subagent`, use at least 8 parallel agents before broad implementation unless the phase is explicitly tiny. If fewer than 8 agents are used, record the reason in the turn doc.
+For `single-thread-subagent`, every phase uses per-phase swarms unless the phase is explicitly tiny. Default per-phase sizes are 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 fewer than the default swarms are used, record the tiny-phase reason in the turn doc before implementation.
+
+For `orchestrator-callback`, each non-trivial implementation thread must use 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
+
+The implementation thread synthesizes reports into the phase turn doc, chooses the final slice plan, integrates helper output, resolves conflicts, owns gates, and owns the PR. If a phase is tiny enough to use fewer than the default agents, record the reason in the turn doc and callback `swarm_summary`.
 
 ## Bounds
 
@@ -28,9 +37,9 @@ Each subagent gets:
 
 ## Slice Planning
 
-For non-trivial `single-thread-subagent` phases, run a slice planning swarm before implementation. Slices should be bounded by module, file group, workflow, test surface, or risk area.
+For non-trivial phases, run a slice planning swarm before implementation. Slices should be bounded by module, file group, workflow, test surface, or risk area.
 
-The coordinator must synthesize the slice reports before broad edits. Direct coordinator implementation is limited to integration, glue, conflict resolution, final repairs, and Beads/PR state.
+The coordinator or implementation thread must synthesize the slice reports before broad edits. Direct lead-thread implementation is limited to integration, glue, conflict resolution, final repairs, and Beads/PR state.
 
 ## Report Shape
 
@@ -38,7 +47,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,21 +1,23 @@
 # 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 runs massive scout/slice/helper swarms
+  -> implementation thread synthesizes and integrates helper output
   -> implementation thread opens PR and calls back
   -> orchestrator creates review 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,19 +25,38 @@ 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
 - branch/worktree setup assigned by the orchestrator
+- massive bounded scout, slice-plan, and implementation-helper swarms for non-trivial phases
+- coherent synthesis of swarm reports into one slice plan
 - implementation
+- integration, conflict resolution, and final repair
 - local gates before PR when feasible
 - PR creation
 - updating the existing Markdown turn doc
@@ -53,13 +74,56 @@ The review thread owns:
 
 - Only the orchestrator creates implementation and review threads.
 - Implementation threads do not create review threads.
+- Implementation threads must not do broad solo implementation. For non-trivial phases, they run massive bounded scout, slice-plan, and implementation-helper swarms before broad edits.
+- Implementation threads synthesize all swarm reports into the existing turn doc, integrate helper output coherently, and keep final ownership of the branch, gates, PR, and callback.
+- If a phase is too small for the default swarm sizes, the implementation thread records the reason in the turn doc and callback `swarm_summary`.
 - 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.
-- Implementation and review threads default to standard speed/reasoning unless Beads metadata explicitly overrides it.
+- 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.
+- Selector, implementation, review, and closeout-selector threads default to `speed: standard`, `reasoning: high`, and `inherit_orchestrator_thread_settings: false` unless Beads metadata explicitly overrides that actor.
+- Before launch, the orchestrator must verify the actual child-thread launch settings or prompt text spell out the actor's speed, reasoning, and non-inheritance. Current UI settings, recent Codex defaults, parent/orchestrator settings, `fast`, and `xhigh` do not count as valid defaults unless the Beads metadata explicitly names them for that actor.
 - 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:
@@ -83,6 +147,14 @@ Payload:
   "turn_doc": "...",
   "local_gates": ["..."],
   "changed_files": ["..."],
+  "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.",
+    "used_less_than_default_reason": null
+  },
   "blockers": [],
   "context_to_keep": []
 }
@@ -113,8 +185,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/references/workflows/single-thread-subagent.md

@@ -22,11 +22,12 @@ main coordinator thread
 - The main thread owns branch state, integration, PR state, Beads updates, and closeout.
 - Subagents inspect, compare, critique, slice the phase, prepare implementation guidance or patches, verify, and report.
 - Subagents do not advance loop state.
-- Use 8+ agents by default for broad scout, slice, implementation-helper, and review work; 8-20 agents is normal when the phase has meaningful surface area.
-- Before broad implementation, launch a slice planning swarm and record the synthesized slice plan in the turn doc.
-- For non-trivial phases, create or record intra-phase implementation slices. Use ephemeral Beads child issues when supported and useful; otherwise record the slices in the turn doc.
-- The coordinator may implement glue, integration, conflict resolution, and final repairs. If it performs most broad discovery or implementation itself, the loop has violated this workflow.
-- If fewer than 8 subagents are used for a broad phase, record the reason in the turn doc.
+- Every phase uses per-phase swarms: selector, scout, slice-plan, implementation-helper, reviewer, and CI verification.
+- 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.
+- Before implementation, launch a slice planning swarm and record the synthesized slice plan in the turn doc.
+- Create or record intra-phase implementation slices. Use ephemeral Beads child issues when supported and useful; otherwise record the slices in the turn doc.
+- The coordinator may implement glue, integration, conflict resolution, and final repairs. If it performs most discovery or implementation itself, the loop has violated this workflow.
+- If a phase is tiny enough to use fewer than the default per-phase swarms, record the reason in the turn doc before implementation.
 
 ## Slice Contract
 
@@ -42,4 +43,4 @@ Each implementation slice has:
 
 ## Completion Criterion
 
-The main coordinator has selected one phase, received and synthesized scout/slice/implementation-helper reports, integrated one phase, received reviewer/CI subagent reports, updated the existing turn doc, updated Beads, and either continued to the next ready phase or stopped with an allowed stop reason.
+The main coordinator has selected one phase, received and synthesized selector/scout/slice/implementation-helper reports, integrated one phase, received reviewer/CI subagent reports, recorded any tiny-phase swarm exception, updated the existing turn doc, updated Beads, and either continued to the next ready phase or stopped with an allowed stop reason.

package/skills/dirtyloops/schemas/implementation-callback.schema.json

@@ -3,7 +3,7 @@
   "title": "ImplementationCallback",
   "type": "object",
   "additionalProperties": false,
-  "required": ["type", "orchestrator_thread_id", "source_thread_id", "phase_issue_id", "status", "branch", "pr", "commits", "turn_doc", "local_gates", "changed_files", "blockers", "context_to_keep"],
+  "required": ["type", "orchestrator_thread_id", "source_thread_id", "phase_issue_id", "status", "branch", "pr", "commits", "turn_doc", "local_gates", "changed_files", "swarm_summary", "blockers", "context_to_keep"],
   "properties": {
     "type": { "const": "implementation-callback" },
     "orchestrator_thread_id": { "type": "string", "minLength": 1 },
@@ -25,6 +25,19 @@
       "type": "array",
       "items": { "type": "string" }
     },
+    "swarm_summary": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["scout_agents", "slice_plan_agents", "implementation_helper_agents", "slice_count", "synthesis", "used_less_than_default_reason"],
+      "properties": {
+        "scout_agents": { "type": "integer", "minimum": 0 },
+        "slice_plan_agents": { "type": "integer", "minimum": 0 },
+        "implementation_helper_agents": { "type": "integer", "minimum": 0 },
+        "slice_count": { "type": "integer", "minimum": 0 },
+        "synthesis": { "type": "string" },
+        "used_less_than_default_reason": { "type": ["string", "null"] }
+      }
+    },
     "blockers": {
       "type": "array",
       "items": { "type": "string" }

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

@@ -13,7 +13,7 @@ This stream is driven by Beads. These docs are execution context and resume aids
 ## Sources Of Truth
 
 - Beads epic: `{{EPIC_ID}}`
-- Beads loop metadata: workflow, run policy, branch/PR policy, quality gates, callback/thread defaults, and swarm policy
+- Beads loop metadata: workflow, run policy, branch/PR policy, quality gates, callback policy, actor-specific thread defaults, and swarm policy
 - Roadmap: `docs/implementation/{{STREAM_SLUG}}/00-roadmap.md`
 - Loop state mirror: `docs/implementation/{{STREAM_SLUG}}/loop-state.md`
 - Phase docs linked from Beads child issues
@@ -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.
@@ -29,7 +30,7 @@ This stream is driven by Beads. These docs are execution context and resume aids
 - File Beads follow-ups instead of widening the selected phase.
 - Update Beads first, then update `loop-state.md`.
 - Use the workflow's required subagent swarms.
-- Worker and reviewer threads default to standard speed/reasoning unless Beads loop metadata explicitly overrides it.
+- Orchestrator-callback child threads default to `speed: standard`, `reasoning: high`, and `inherit_orchestrator_thread_settings: false` unless Beads loop metadata explicitly overrides that actor.
 
 ## Review And CI
 

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.
@@ -22,7 +23,8 @@ Start from:
 - Use the workflow's required large bounded subagent swarms.
 - Reviewer agents must use `thermo-nuclear-code-quality-review`.
 - Reviewer and CI verification agents own CI.
-- Worker and reviewer threads default to standard speed/reasoning unless Beads loop metadata explicitly overrides it.
+- Orchestrator-callback child threads must launch with explicit actor defaults: `speed: standard`, `reasoning: high`, and `inherit_orchestrator_thread_settings: false`, unless Beads metadata overrides that actor.
+- Do not inherit child-thread speed or reasoning from the current UI, recent Codex thread defaults, or the orchestrator thread.
 - Update the existing Markdown turn doc.
 - Update Beads first, then update `loop-state.md`.
 - Do not widen the selected phase.

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

@@ -0,0 +1,40 @@
+# 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.
+
+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 `{{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/implementation-swarm-subagent-prompt.md.template

@@ -0,0 +1,29 @@
+# Implementation Swarm Subagent Prompt: {{STREAM_NAME}}
+
+You are an implementation swarm subagent inside an `orchestrator-callback` implementation thread.
+
+Mission: `{{SWARM_MISSION}}`
+
+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: `{{PHASE_ISSUE_ID}}`
+- Phase doc: `{{PHASE_DOC}}`
+- Turn doc: `{{TURN_DOC}}`
+- Slice id: `{{SLICE_ID}}`
+- Assigned scope: `{{ASSIGNED_SCOPE}}`
+
+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`.
+