@dirtydishes/skills 0.1.3 → 0.1.5

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 selector, implementation, review, and closeout-selector 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.
+- `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 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.
+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,13 +132,17 @@ 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. 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 `orchestrator-callback`, only the orchestrator creates implementation and review threads. It must create them in the intended Codex project worktree using first-class thread environment control; launching a generic thread and telling it to `cd` into the worktree is a workflow violation. Worker and reviewer prompts include expected repo root/worktree plus branch/ref for verification, and a child that starts in the wrong environment blocks and calls back instead of self-relocating. 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.
 

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@dirtydishes/skills",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Installer and catalog for dirtydishes agent skills.",
   "type": "module",
   "bin": {
-    "skills": "./bin/skills.js"
+    "skills": "bin/skills.js"
   },
   "files": [
     "bin/",

package/skills/dirtyloops/SKILL.md

@@ -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.
@@ -61,9 +61,10 @@ A dirtyloop is a Beads-canonical Codex implementation loop: phase docs, one Mark
 - 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.
+- 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

@@ -5,4 +5,4 @@ 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, 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

@@ -8,6 +8,8 @@ Topology:
 orchestrator thread
   -> 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

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
@@ -21,11 +21,12 @@ Replace an old reporting path with a simpler evidence-backed implementation whil
 
 ## Thread Topology
 
-Only the orchestrator creates implementation and review threads.
+Only the orchestrator creates implementation and review threads. It creates them in the intended Codex project worktree using first-class thread environment control; launching a generic thread and telling it to `cd` into the worktree is a workflow violation.
 
 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
@@ -33,18 +34,24 @@ Selector subagents:
 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
+- start in the intended repo/worktree environment before prompt execution
+- verify repo root, worktree, and branch/ref before edits; block and call back if the launch environment is wrong
+- 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
+- start in the intended repo/worktree environment before prompt execution
+- verify repo root, worktree, and branch/ref before review or repair; block and call back if the launch environment is wrong
+- 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
@@ -54,6 +61,7 @@ Review threads:
 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`
@@ -63,6 +71,8 @@ The orchestrator validates selector reports, owns Beads closeout, and launches o
 
 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
 
 | Beads Issue | Phase | Phase Doc | Depends On | Status |

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

@@ -6,6 +6,14 @@ 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`
@@ -30,4 +38,3 @@ Rules:
 - 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

@@ -14,17 +14,29 @@ Send your final callback to exact orchestrator thread id `THREAD_ORCHESTRATOR_ID
 - Phase doc: `docs/implementation/example-stream/01-foundation.md`
 - 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
+- Expected repo/worktree and branch/ref: create or use `example-stream/01-foundation`
+- Launch environment: this thread must already be bound to the intended Codex project worktree before this prompt runs
+- 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
 
+- Before edits, verify `pwd`, `git rev-parse --show-toplevel`, and the current branch/ref match the expected repo/worktree and branch/ref.
+- Do not `cd` into the target worktree as setup or recovery. If the launch environment is wrong, stop and send a blocked callback to the orchestrator.
 - 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,16 @@ 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 environment: this thread must already be bound to the intended Codex project worktree before this prompt runs
+- 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
 
+- Before review or repair, verify `pwd`, `git rev-parse --show-toplevel`, and the current branch/ref match the PR branch/commit.
+- Do not `cd` into the target worktree as setup or recovery. If the launch environment is wrong, stop and send a blocked callback to the orchestrator.
 - 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

@@ -16,9 +16,14 @@ Start from:
 - 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.
+- Implementation and review threads must be created in the intended Codex project worktree using first-class thread environment control. Do not launch a generic thread and ask it to `cd` into the worktree.
+- 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.
+- Worker and reviewer prompt text lists the expected repo root/worktree and branch/ref for verification only. A child that starts in the wrong environment blocks and calls back instead of self-relocating.
 - 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.
@@ -33,4 +38,4 @@ Start from:
 
 ## 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`, 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.
+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 in the intended Codex project worktree with those same explicit defaults, the full linked phase doc, exact callback target `THREAD_ORCHESTRATOR_ID` in the prompt text, and expected repo root/worktree plus branch/ref for verification. The implementation thread must block and call back if its launch environment is wrong; it must not self-relocate with `cd`. 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 in the intended Codex project worktree with those same explicit defaults that uses `thermo-nuclear-code-quality-review`, verifies repo root/worktree plus branch/ref before review or repair, owns CI, and blocks with callback if its launch environment is wrong. 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

@@ -6,6 +6,14 @@ 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`
@@ -25,4 +33,3 @@ Rules:
 - 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

@@ -13,6 +13,8 @@ Selected by selector subagent `THREAD_SELECTOR_ID` after `bd ready` showed `exam
 ## 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 selector subagent `THREAD_SELECTOR_ID` after `bd ready` showed `exam
   "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."]
 }

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,7 +457,7 @@
 
         <article class="workflow-card callback">
           <h3>orchestrator-callback</h3>
-          <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>
+          <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>
@@ -465,7 +465,7 @@
             </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>
@@ -500,7 +500,7 @@
             <tr>
               <td>Implementation</td>
               <td>Mass subagents split and assist; coordinator integrates glue, conflicts, and final repairs.</td>
-              <td>Implementation thread created by orchestrator with exact callback target and standard defaults.</td>
+              <td>Implementation thread created by orchestrator in the intended Codex project worktree with exact callback target and standard defaults.</td>
             </tr>
             <tr>
               <td>Review</td>
@@ -580,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>

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
@@ -75,6 +79,15 @@ For `orchestrator-callback`, add:
     "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
   }
 }
 ```
@@ -85,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/selector 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,9 +13,10 @@ 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`
@@ -26,10 +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 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
-- single-thread-subagent swarm mode: mass-subagent, minimum 8 parallel agents for broad scout/slice/review work
+- 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
 
@@ -45,11 +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.
+   - 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 `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.
+   - 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.
@@ -71,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, selector gates, 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`
 
@@ -128,7 +128,9 @@ orchestrator thread
   -> 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. 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.
+Only the orchestrator creates implementation and review threads. It must create them in the intended Codex project worktree using first-class thread environment control; launching a generic thread and telling it to `cd` into the worktree is a workflow violation. Worker threads do not create review threads. Worker and reviewer prompts must contain the concrete orchestrator thread id as callback target and must list expected repo root/worktree plus branch/ref for verification. A child that starts in the wrong environment blocks and calls back instead of self-relocating. 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

@@ -18,10 +18,14 @@ 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 the orchestrator to bind each implementation/review thread to the intended Codex project worktree at thread creation time. Use the Codex project/worktree launch target or equivalent first-class thread environment control; do not launch a generic thread and tell it to `cd` into the worktree.
+   - For `orchestrator-callback`, worker/reviewer prompts must list the expected repo root/worktree and branch/ref as verification inputs only. The child thread must verify `pwd`, `git rev-parse --show-toplevel`, and current branch/ref before edits or review. If the launch environment is wrong, the child must send a blocked callback; it must not self-relocate with `cd` as setup or recovery.
+   - For `orchestrator-callback`, stop as blocked before launch when the orchestrator cannot create the child thread in the intended worktree environment. Do not rely on shell cwd, prompt discipline, or a hidden wrapper to repair a wrong thread environment after launch.
    - 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.
+   - 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, shell cwd repair, wrong thread environments, or solo coordinator implementation.
 
 4. Run the selected workflow.
    - Follow the selected workflow reference.

package/skills/dirtyloops/references/swarms.md

@@ -1,6 +1,6 @@
 # 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
 
@@ -13,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
 
@@ -29,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
 

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

@@ -8,7 +8,8 @@ Use this workflow for the original loop style: a main orchestrator thread delega
 orchestrator thread
   -> 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
@@ -28,6 +29,7 @@ The orchestrator owns:
 - validating selector outputs before advancing the loop
 - implementation thread creation
 - review thread creation
+- child thread environment binding to the intended Codex project worktree
 - concrete callback target, callback preflight, callback-wait, and sparse fallback heartbeat
 - phase closeout
 - launching the next selected phase
@@ -51,8 +53,12 @@ The closeout-selector subagent owns:
 The implementation thread owns:
 
 - exactly one selected Beads issue
-- branch/worktree setup assigned by the orchestrator
+- working only in the repo/worktree environment already bound by the orchestrator
+- verifying its repo root, worktree, and branch/ref before edits, then blocking if the launch environment is wrong
+- 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
@@ -61,6 +67,8 @@ The implementation thread owns:
 The review thread owns:
 
 - thermo-nuclear review
+- working only in the repo/worktree environment already bound by the orchestrator
+- verifying its repo root, worktree, and branch/ref before review or repair, then blocking if the launch environment is wrong
 - reviewer subagent swarms
 - CI inspection, diagnosis, repair, rerun, and evidence
 - updating the existing Markdown turn doc
@@ -69,7 +77,12 @@ The review thread owns:
 ## Non-Negotiable Thread Rules
 
 - Only the orchestrator creates implementation and review threads.
+- The orchestrator must create implementation and review threads in the intended Codex project worktree using first-class thread environment control. Do not launch a generic thread and ask it to `cd` into the worktree.
+- Worker/reviewer prompts may list the expected repo root/worktree and branch/ref for verification, but they must not use `cd` as setup or recovery. A child thread that starts in the wrong environment must send a blocked callback.
 - 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.
@@ -79,7 +92,8 @@ The review thread owns:
 - 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.
+- 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
@@ -139,6 +153,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": []
 }

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/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
@@ -30,7 +30,8 @@ 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.
+- Orchestrator-callback implementation/review threads must be created in the intended Codex project worktree. A child that starts in the wrong repo/worktree blocks and calls back instead of self-relocating.
 
 ## Review And CI
 

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

@@ -23,7 +23,9 @@ 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.
+- Orchestrator-callback implementation/review threads must be created in the intended Codex project worktree using first-class thread environment control. Worker/reviewer prompts verify repo/worktree and branch/ref; they do not repair a wrong launch environment with shell cwd changes.
+- 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

@@ -6,6 +6,14 @@ 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}}`
@@ -30,4 +38,3 @@ Rules:
 - 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`.
+

package/skills/dirtyloops/templates/workflows/orchestrator-callback/implementation-thread-prompt.md.template

@@ -14,20 +14,32 @@ You must send your final callback to the exact orchestrator thread id `{{ORCHEST
 - Phase doc: `{{PHASE_DOC}}`
 - Implementation index: `{{IMPLEMENT_MD}}`
 - Turn doc: `{{TURN_DOC}}`
-- Branch/worktree instructions: `{{BRANCH_WORKTREE_INSTRUCTIONS}}`
-- Thread default: standard speed/reasoning unless the orchestrator prompt explicitly says otherwise
+- Expected repo/worktree and branch/ref: `{{BRANCH_WORKTREE_INSTRUCTIONS}}`
+- Launch environment: this thread must already be bound to the intended Codex project worktree before this prompt runs
+- Launch defaults: speed `standard`, reasoning `high`, inherit_orchestrator_thread_settings `false`, unless Beads metadata explicitly overrides the implementation actor
+- 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
 
+- Before edits, verify `pwd`, `git rev-parse --show-toplevel`, and the current branch/ref match the expected repo/worktree and branch/ref.
+- Do not `cd` into the target worktree as setup or recovery. If the launch environment is wrong, stop and send a blocked callback to the orchestrator.
 - 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.
 - The callback payload must include `orchestrator_thread_id: "{{ORCHESTRATOR_THREAD_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.
 
 ## Callback States
 

package/skills/dirtyloops/templates/workflows/orchestrator-callback/review-thread-prompt.md.template

@@ -22,12 +22,16 @@ Use:
 - PR: `{{PR_URL_OR_ID}}`
 - Branch/commit: `{{BRANCH_OR_COMMIT}}`
 - Required gates: `{{QUALITY_GATES}}`
-- Thread default: standard speed/reasoning unless the orchestrator prompt explicitly says otherwise
+- Launch environment: this thread must already be bound to the intended Codex project worktree before this prompt runs
+- Launch defaults: speed `standard`, reasoning `high`, inherit_orchestrator_thread_settings `false`, unless Beads metadata explicitly overrides the review actor
+- 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
 
+- Before review or repair, verify `pwd`, `git rev-parse --show-toplevel`, and the current branch/ref match the PR branch/commit.
+- Do not `cd` into the target worktree as setup or recovery. If the launch environment is wrong, stop and send a blocked callback to the orchestrator.
 - 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 by the orchestrator prompt.
 - Update the existing Markdown turn doc.

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

@@ -3,14 +3,17 @@
 This loop uses a main orchestrator thread plus separate implementation and review threads.
 
 - Only the orchestrator creates implementation and review threads.
+- The orchestrator creates implementation and review threads in the intended Codex project worktree using first-class thread environment control. Do not launch a generic thread and ask it to `cd` into the worktree.
 - 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.
+- Selector, implementation, review, and closeout-selector threads launch with explicit actor defaults: `speed: standard`, `reasoning: high`, and `inherit_orchestrator_thread_settings: false`, unless Beads metadata overrides that actor.
+- Do not inherit current UI settings, recent Codex defaults, or orchestrator-thread speed/reasoning. `fast` speed and `xhigh` reasoning require explicit Beads metadata for the actor being launched.
 - 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`.
+- Before launching a worker or reviewer, verify the child thread launch target is the intended project worktree. Prompt text may include expected repo root/worktree and branch/ref for verification only; it must not use `cd` as setup or recovery.
 - 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`.
 - Implementation threads do not create review threads.
@@ -19,3 +22,5 @@ This loop uses a main orchestrator thread plus separate implementation and revie
 - 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 validates selector reports, owns Beads closeout, and launches only the selected next phase.
+- 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.
+- The implementation thread synthesizes swarm reports into the existing turn doc, integrates helper output coherently, and includes `swarm_summary` in the implementation callback.

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

@@ -6,6 +6,14 @@ Canonical tracker: Beads epic `{{EPIC_ID}}`
 
 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 `{{EPIC_ID}}`
@@ -25,4 +33,3 @@ Rules:
 - 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/templates/workflows/single-thread-subagent/run-loop-addendum.md.template

@@ -3,10 +3,11 @@
 This loop runs in one visible Codex coordinator thread. Single-thread means one coordinator, not solo implementation.
 
 - Do not create separate Codex worker or reviewer threads.
-- Use selector, scout, slice-planning, implementation-helper, reviewer, and CI subagent swarms inside this thread.
-- Use 8+ subagents by default for broad scout, slice, implementation-helper, and review work. If fewer than 8 are used for a broad phase, record why in the turn doc.
-- Before broad implementation, run a slice planning swarm and synthesize the slice plan into the turn doc.
+- For every phase, use selector, scout, slice-planning, implementation-helper, reviewer, and CI subagent swarms inside this thread.
+- 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.
+- Before implementation, run a slice planning swarm and synthesize the slice plan into the turn doc.
 - The main thread owns integration, branch state, PR state, Beads updates, and closeout.
 - Subagents inspect, compare, critique, split the phase into slices, prepare implementation guidance or patches, verify, and report.
 - Subagents do not own loop state.
-- The coordinator may implement glue, integration, conflict resolution, and final repairs. It must not do most broad discovery or implementation itself.
+- The coordinator may implement glue, integration, conflict resolution, and final repairs. It must not do most discovery or implementation itself.