@dirtydishes/skills 0.1.5 → 0.1.6

package/README.md

@@ -45,6 +45,8 @@ The catalog distinguishes three dependency classes:
 
 `dirtyloops` currently requires the external `bd` tool, requires `thermo-nuclear-code-quality-review`, and recommends `impeccable`. Required and recommended skills are updated to the latest version when they are packaged in `@dirtydishes/skills@latest`. If a dependency is not packaged yet, `doctor` reports whether it is already installed locally and exits nonzero when a required dependency is missing.
 
+The installer command `npx @dirtydishes/skills@latest update dirtyloops` updates the installed skill package only. To refresh loop artifacts that were already generated inside a project, invoke the skill branch `dirtyloops update <workflow>` inside that project.
+
 For local development from this checkout:
 
 ```bash
@@ -65,6 +67,7 @@ Use it when a project needs durable implementation control instead of one-off ch
 
 - `dirtyloops help` - Explain the available commands, workflows, examples, and expected artifacts.
 - `dirtyloops create <workflow>` - Compile a finalized plan into Beads loop metadata and a generated loop scaffold.
+- `dirtyloops update <workflow>` - Refresh an existing loop's generated runtime artifacts and loop contract metadata to the current dirtyloops contract without recreating the loop.
 - `dirtyloops run <workflow>` - Execute ready phases until the epic is complete, blocked, interrupted, or review/CI is unresolved.
 - `dirtyloops run <workflow> --once` - Execute only the next ready phase, close it out, and stop.
 - `dirtyloops inspect <workflow>` - Summarize loop state without mutating files, Beads, branches, PRs, or threads.
@@ -83,6 +86,8 @@ The normal flow is two-stage:
 
 `create` is the plan compiler. `run` is the execution loop. Keep those separate so the generated artifacts become the durable source of truth before implementation begins.
 
+Use `dirtyloops update <workflow>` on already-created loops after installing a newer dirtyloops skill. It updates generated runtime prompts, schemas, `IMPLEMENT.md`, and Beads loop metadata contract fields, while preserving phase docs, turn docs, code, branch/PR state, issue status, dependencies, `loop-state.md` history, and storyboard files unless you explicitly ask for a wider migration. For `orchestrator-callback`, it strips persisted callback targets back to `RUNTIME_ORCHESTRATOR_THREAD_ID` and upgrades stale generated child defaults to `reasoning: xhigh`.
+
 #### Generated Artifacts
 
 A created loop writes a project-local execution surface under `docs/implementation/<stream-slug>/`:
@@ -110,11 +115,11 @@ The skill package itself mirrors that shape:
 #### Workflows
 
 - `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.
+- `orchestrator-callback` - One orchestrator thread delegates phase gates to selector subagents, creates separate implementation and review threads, and receives callbacks to a runtime-bound 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. 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. 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.
+Choose `orchestrator-callback` when you want the original multi-thread flow. The orchestrator launches a selector subagent before the first worker, resolves the runtime callback target for the current run, creates implementation threads with that callback target, waits for implementation callbacks, creates review threads with the same callback target, 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
 
@@ -134,7 +139,9 @@ The `dirtyloops` skill is strict about ownership:
 
 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.
 
-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.
+Every `orchestrator-callback` child thread must launch with explicit actor settings: `speed: standard`, `reasoning: xhigh`, 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 `high` are not valid launch defaults unless the actor metadata names them.
+
+The orchestrator callback target is bound at run time, not at loop creation. `dirtyloops create` leaves `RUNTIME_ORCHESTRATOR_THREAD_ID` as a placeholder in generated artifacts and must not bake in the creator thread id. `dirtyloops run` resolves the actual thread id for the thread orchestrating that run, or uses an explicit callback target supplied for that run, then substitutes it into worker/reviewer prompts before launch. If the prompt still contains the placeholder, a prior-run id, a child thread id, or generic text like `this thread`, the child thread must not be launched.
 
 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.
 
@@ -142,9 +149,9 @@ For `single-thread-subagent`, the coordinator must run per-phase selector/scout/
 
 #### 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, `swarm_summary`, 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 runtime 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.
+Review threads call back exactly once after review and CI are resolved. The callback includes the concrete runtime orchestrator thread id, source thread id, Beads issue id, status, PR, CI state, review skill, repairs, remaining findings, turn doc, and context to keep.
 
 Prefer callback-driven coordination over polling. After launching a worker or reviewer, the orchestrator waits for the single callback; it does not repeatedly read, monitor, summarize, or status-check the child thread. For long-running worker or reviewer threads, use a lightweight heartbeat around 30 minutes only when the callback is overdue or liveness is uncertain. Do not launch callback threads whose actual prompt text says only `current orchestrator thread`, `this thread`, or another generic callback target.
 

package/package.json

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

package/skills/dirtyloops/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: dirtyloops
-description: Create, run, inspect, close, and explain Beads-canonical Codex implementation loops.
-argument-hint: "help|create|run|inspect|closeout, optional workflow"
+description: Create, update, run, inspect, close, and explain Beads-canonical Codex implementation loops.
+argument-hint: "help|create|update|run|inspect|closeout, optional workflow"
 disable-model-invocation: true
 ---
 
@@ -13,6 +13,7 @@ A dirtyloop is a Beads-canonical Codex implementation loop: phase docs, one Mark
 
 1. Parse the branch from the user's request.
    - `create`: turn a finalized plan into Beads issues, typed loop metadata, implementation docs, templates, and a run prompt.
+   - `update`: refresh an existing loop's contract metadata and generated runtime artifacts to the current dirtyloops contract without recreating the loop.
    - `run`: execute the loop until the epic is complete, blocked, interrupted, or `run once` is requested.
    - `inspect`: summarize the current loop state without changing it.
    - `closeout`: verify completion and generate the post-run storyboard.
@@ -23,7 +24,7 @@ A dirtyloop is a Beads-canonical Codex implementation loop: phase docs, one Mark
 2. Select the workflow.
    - Skip this step for `help`.
    - `single-thread-subagent`: one coordinator thread uses mass subagent swarms for selection, scouting, slice planning, implementation assistance, review, and CI; no separate Codex worker/reviewer threads.
-   - `orchestrator-callback`: an orchestrator thread delegates phase gates to selector subagents, creates implementation threads, then review threads; workers and reviewers call back to a concrete orchestrator thread id.
+   - `orchestrator-callback`: an orchestrator thread delegates phase gates to selector subagents, creates implementation threads, then review threads; workers and reviewers call back to the runtime-bound concrete orchestrator thread id.
    - Choose `orchestrator-callback` when the user mentions original loop flow, new threads, callbacks, worker threads, implementation threads, or review threads.
    - Choose `single-thread-subagent` when the user mentions single thread, CLI-friendly, or keeping all orchestration in one thread.
    - If the workflow is ambiguous for `create` or `run`, ask one concise question.
@@ -33,6 +34,7 @@ A dirtyloop is a Beads-canonical Codex implementation loop: phase docs, one Mark
    - For `help`, read only `references/help.md`, then answer without mutating files, Beads, branches, PRs, or threads.
    - For all non-help branches, read `references/common.md`, `references/beads.md`, `references/swarms.md`, `references/review-ci.md`, and `references/turn-docs.md`.
    - For `create`, read `references/create-loop.md`.
+   - For `update`, read `references/update-loop.md`.
    - For `run`, read `references/run-loop.md`.
    - For `inspect`, read `references/inspect-loop.md`.
    - For `closeout`, read `references/storyboard.md`.
@@ -53,15 +55,17 @@ A dirtyloop is a Beads-canonical Codex implementation loop: phase docs, one Mark
 - 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.
+- `dirtyloops update` is conservative: it may update loop contract metadata and generated runtime artifacts, but it must not rewrite phase docs, turn docs, implementation code, branches, PRs, issue status, issue dependencies, or storyboard history unless the user explicitly asks for that wider mutation.
 - Use one Markdown turn doc per phase.
 - Reviewers update the existing phase turn doc; they do not create a separate review doc.
 - Reviewer agents must use `thermo-nuclear-code-quality-review`.
 - Reviewer and CI verification agents own CI.
 - `dirtyloops run` continues phase-by-phase by default. Stop only when the epic is complete, blocked, interrupted, review/CI is unresolved, or the user explicitly asked for `run once` / `--once`.
 - For `orchestrator-callback`, the orchestrator must spawn a selector subagent before the first worker and a closeout-selector subagent after each review callback before continuing or stopping. The orchestrator validates their reports and remains the only actor that mutates Beads, updates loop state, creates implementation/review threads, or advances the loop.
-- Orchestrator-callback prompts and callback payloads must carry the concrete orchestrator thread id. Do not launch a worker or reviewer if the actual instruction text says only `current orchestrator thread`, `this thread`, or another generic target.
+- Orchestrator-callback callback targets are runtime-bound. `create` must not persist, print, or bake in the thread id of the agent that created the loop; generated artifacts keep a runtime callback-target placeholder. `run` must resolve the actual thread id for the thread orchestrating this run before any worker/reviewer launch.
+- Orchestrator-callback prompts and callback payloads must carry the concrete runtime orchestrator thread id after binding. Do not launch a worker or reviewer if the actual instruction text still contains a placeholder or 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.
-- 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.
+- Every orchestrator-callback child thread defaults to `speed: standard`, `reasoning: xhigh`, 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`, `high`, 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.

package/skills/dirtyloops/examples/README.md

@@ -3,6 +3,6 @@
 These examples show the shape `$dirtyloops create` should produce.
 
 - `single-thread-subagent/` shows one visible coordinator thread with mass subagent swarms, slice planning, implementation helpers, review, and CI verification.
-- `orchestrator-callback/` shows the original thread-callback loop: orchestrator thread, selector and closeout-selector subagents, implementation threads, review threads, concrete callback targets, and callback payloads.
+- `orchestrator-callback/` shows the original thread-callback loop: orchestrator thread, selector and closeout-selector subagents, implementation threads, review threads, runtime-bound 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, actor-specific 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, runtime callback placeholders, actor-specific thread defaults, swarm policy, and prompt wording.

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

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

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

@@ -26,17 +26,17 @@ Only the orchestrator creates implementation and review threads. It creates them
 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
+- launch with `speed: standard`, `reasoning: xhigh`, and `inherit_orchestrator_thread_settings: false` unless Beads metadata overrides the selector actor
 - read Beads, `IMPLEMENT.md`, `loop-state.md`, and linked phase docs
 - return a `swarm-report` with mission `selector`
 - never implement, mutate Beads, edit files, or create threads
 
 Implementation threads:
 
-- receive the full phase doc, Beads issue id, branch policy, quality gates, and orchestrator thread id
+- receive the full phase doc, Beads issue id, branch policy, quality gates, and runtime-bound orchestrator thread id
 - 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
+- launch with `speed: standard`, `reasoning: xhigh`, 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
 - 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
@@ -51,7 +51,7 @@ Review threads:
 - use `thermo-nuclear-code-quality-review`
 - 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
+- launch with `speed: standard`, `reasoning: xhigh`, 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
@@ -61,7 +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
+- launch with `speed: standard`, `reasoning: xhigh`, 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`
@@ -71,7 +71,9 @@ 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.
+The orchestrator callback target is resolved when the loop is run. Generated artifacts may contain `RUNTIME_ORCHESTRATOR_THREAD_ID`, but the orchestrator must replace it with the actual callback target for the thread orchestrating this run before launching implementation or review threads.
+
+No `orchestrator-callback` child thread inherits current UI settings, recent Codex thread defaults, or parent/orchestrator speed/reasoning. `fast` speed and `high` reasoning are allowed only when Beads metadata explicitly names that value for the actor being launched.
 
 ## Phase Ledger
 

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

@@ -9,10 +9,10 @@ Mission: verify the just-reviewed phase can be closed out, then recommend stop o
 Launch defaults:
 
 - speed: `standard`
-- reasoning: `high`
+- reasoning: `xhigh`
 - 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.
+Do not run this closeout-selector with inherited UI, recent thread, parent/orchestrator, `fast`, or `high` settings unless Beads metadata explicitly overrides the closeout-selector actor.
 
 Read:
 

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

@@ -4,9 +4,11 @@ You are the implementation thread for Beads issue `example-epic.1`.
 
 Callback target:
 
-`THREAD_ORCHESTRATOR_ID`
+`RUNTIME_ORCHESTRATOR_THREAD_ID`
 
-Send your final callback to exact orchestrator thread id `THREAD_ORCHESTRATOR_ID`. Do not rely on `current orchestrator thread`, `this thread`, or implicit wrapper metadata.
+This must be replaced by the runtime callback target before launch. If it is still `RUNTIME_ORCHESTRATOR_THREAD_ID`, a loop-creation thread id, or any non-concrete value, stop and report a launch preflight failure.
+
+After replacement, send your final callback to exact orchestrator thread id `RUNTIME_ORCHESTRATOR_THREAD_ID`. Do not rely on `current orchestrator thread`, `this thread`, or implicit wrapper metadata.
 
 ## Inputs
 
@@ -16,8 +18,8 @@ Send your final callback to exact orchestrator thread id `THREAD_ORCHESTRATOR_ID
 - Turn doc: `docs/implementation/example-stream/turn-docs/01-foundation.md`
 - 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
+- Launch defaults: speed `standard`, reasoning `xhigh`, inherit_orchestrator_thread_settings `false`
+- Do not run this worker with inherited UI, recent thread, parent/orchestrator, `fast`, or `high` settings unless Beads metadata explicitly overrides the implementation actor
 
 ## Rules
 
@@ -38,5 +40,5 @@ Send your final callback to exact orchestrator thread id `THREAD_ORCHESTRATOR_ID
 - 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 `orchestrator_thread_id: "RUNTIME_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.

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

@@ -4,9 +4,11 @@ You are the review thread for Beads issue `example-epic.1`.
 
 Callback target:
 
-`THREAD_ORCHESTRATOR_ID`
+`RUNTIME_ORCHESTRATOR_THREAD_ID`
 
-Send your final callback to exact orchestrator thread id `THREAD_ORCHESTRATOR_ID`. Do not rely on `current orchestrator thread`, `this thread`, or implicit wrapper metadata.
+This must be replaced by the runtime callback target before launch. If it is still `RUNTIME_ORCHESTRATOR_THREAD_ID`, a loop-creation thread id, or any non-concrete value, stop and report a launch preflight failure.
+
+After replacement, send your final callback to exact orchestrator thread id `RUNTIME_ORCHESTRATOR_THREAD_ID`. Do not rely on `current orchestrator thread`, `this thread`, or implicit wrapper metadata.
 
 ## Mandatory Skill
 
@@ -22,8 +24,8 @@ Use:
 - PR: `#123`
 - Required gates: `bun test`, `bun run typecheck`
 - 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
+- Launch defaults: speed `standard`, reasoning `xhigh`, inherit_orchestrator_thread_settings `false`
+- Do not run this reviewer with inherited UI, recent thread, parent/orchestrator, `fast`, or `high` settings unless Beads metadata explicitly overrides the review actor
 
 ## Rules
 
@@ -36,4 +38,4 @@ Use:
 - Update the existing Markdown turn doc.
 - Do not create follow-up implementation threads.
 - Call back exactly once when review and CI are resolved.
-- The callback payload must include `orchestrator_thread_id: "THREAD_ORCHESTRATOR_ID"` and your `source_thread_id`.
+- The callback payload must include `orchestrator_thread_id: "RUNTIME_ORCHESTRATOR_THREAD_ID"` and your `source_thread_id`.

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

@@ -17,9 +17,10 @@ Start from:
 - Continue phase-by-phase until the epic is complete, blocked, interrupted, or review/CI is unresolved.
 - Only the orchestrator creates implementation and review threads.
 - 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.
+- Selector, implementation, review, and closeout-selector threads launch with explicit actor settings: `speed: standard`, `reasoning: xhigh`, 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 `high` unless Beads metadata explicitly names that value for the actor being launched.
+- Resolve the runtime callback target for this run, then replace `RUNTIME_ORCHESTRATOR_THREAD_ID` before launching worker or reviewer threads.
+- Worker and reviewer prompt text must include the resolved exact orchestrator thread id as callback target. Do not launch if the placeholder remains.
 - 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.
@@ -38,4 +39,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 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.
+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`, resolve the runtime callback target for the thread orchestrating this run, launch a selector subagent with `speed: standard`, `reasoning: xhigh`, 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, the resolved callback target substituted wherever `RUNTIME_ORCHESTRATOR_THREAD_ID` appears 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`, has the same resolved callback target substituted into the prompt text, 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 `high` 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

@@ -9,10 +9,10 @@ Mission: select at most one next ready Beads phase for the orchestrator.
 Launch defaults:
 
 - speed: `standard`
-- reasoning: `high`
+- reasoning: `xhigh`
 - 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.
+Do not run this selector with inherited UI, recent thread, parent/orchestrator, `fast`, or `high` settings unless Beads metadata explicitly overrides the selector actor.
 
 Read:
 

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

@@ -12,7 +12,7 @@ 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`.
+- Implementation thread `THREAD_IMPLEMENTATION_ID` created with orchestrator callback target `RUNTIME_ORCHESTRATOR_THREAD_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`.
@@ -23,7 +23,7 @@ Selected by selector subagent `THREAD_SELECTOR_ID` after `bd ready` showed `exam
 ```json
 {
   "type": "implementation-callback",
-  "orchestrator_thread_id": "THREAD_ORCHESTRATOR_ID",
+  "orchestrator_thread_id": "RUNTIME_ORCHESTRATOR_THREAD_ID",
   "source_thread_id": "THREAD_IMPLEMENTATION_ID",
   "phase_issue_id": "example-epic.1",
   "status": "pr-ready",
@@ -70,7 +70,7 @@ Evidence:
 ```json
 {
   "type": "review-callback",
-  "orchestrator_thread_id": "THREAD_ORCHESTRATOR_ID",
+  "orchestrator_thread_id": "RUNTIME_ORCHESTRATOR_THREAD_ID",
   "source_thread_id": "THREAD_REVIEW_ID",
   "phase_issue_id": "example-epic.1",
   "status": "repaired",

package/skills/dirtyloops/plan.html

@@ -418,6 +418,10 @@
           <h3><code>$dirtyloops create</code></h3>
           <p>Turns the finalized plan into a Beads epic, child phase issues, typed loop metadata, implementation docs, workflow prompts, schemas, loop state, and a paste-ready run prompt.</p>
         </article>
+        <article class="panel">
+          <h3><code>$dirtyloops update</code></h3>
+          <p>Refreshes an already-created loop's generated runtime prompts, schemas, contract docs, and Beads loop metadata without recreating phase docs, turn docs, implementation state, or PR history.</p>
+        </article>
         <article class="panel">
           <h3><code>$dirtyloops run</code></h3>
           <p>Reads Beads, executes ready phases through the selected workflow, updates the existing turn docs and Beads, then continues until complete, blocked, interrupted, unresolved, or <code>--once</code>.</p>
@@ -457,7 +461,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 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>
+          <p>The original loop shape. A main orchestrator delegates phase gates to selector subagents, binds the callback target at run time, creates child threads with explicit standard speed, xhigh 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>
@@ -500,7 +504,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 in the intended Codex project worktree with exact callback target and standard defaults.</td>
+              <td>Implementation thread created by orchestrator in the intended Codex project worktree with runtime-bound callback target and standard defaults.</td>
             </tr>
             <tr>
               <td>Review</td>
@@ -580,7 +584,8 @@ Repo: .
 Stream slug: example-stream
 Epic title: Example stream migration
 Run policy: until complete; use --once only for one-shot operation
-Thread defaults: selector/implementation/review/closeout-selector speed standard, reasoning high, no inherit
+Thread defaults: selector/implementation/review/closeout-selector speed standard, reasoning xhigh, no inherit
+Callback target: runtime-bound; never captured from loop creation
 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,15 +52,15 @@ Epic metadata must include:
   "branch_pr_policy": "...",
   "quality_gates": ["..."],
   "thread_defaults": {
-    "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 }
+    "selector": { "speed": "standard", "reasoning": "xhigh", "inherit_orchestrator_thread_settings": false },
+    "implementation": { "speed": "standard", "reasoning": "xhigh", "inherit_orchestrator_thread_settings": false },
+    "review": { "speed": "standard", "reasoning": "xhigh", "inherit_orchestrator_thread_settings": false },
+    "closeout_selector": { "speed": "standard", "reasoning": "xhigh", "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.
+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 `high` reasoning are allowed only when the loop metadata explicitly names that value for that actor.
 
 For `orchestrator-callback`, add:
 
@@ -68,6 +68,9 @@ For `orchestrator-callback`, add:
 {
   "callback_policy": {
     "requires_concrete_orchestrator_thread_id": true,
+    "orchestrator_thread_id_binding": "runtime",
+    "callback_target_placeholder": "RUNTIME_ORCHESTRATOR_THREAD_ID",
+    "forbid_creation_thread_id_as_callback_target": true,
     "requires_source_thread_id": true,
     "wait_mode": "callback-wait",
     "active_child_thread_monitoring": false,
@@ -92,6 +95,8 @@ For `orchestrator-callback`, add:
 }
 ```
 
+The concrete orchestrator thread id is not Beads state created by `dirtyloops create`. It is a runtime preflight value for `dirtyloops run`. Generated docs may store the placeholder and binding policy, but they must not store the loop-creation thread id as the future callback target.
+
 For `single-thread-subagent`, add:
 
 ```json

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

@@ -27,7 +27,8 @@ Ask only for missing decisions. Prefer these defaults when the user has not spec
 
 - run policy: continue until epic complete, blocked, interrupted, or review/CI unresolved
 - one-shot mode: off unless the user says `run once` or `--once`
-- orchestrator-callback child threads: `speed: standard`, `reasoning: high`, `inherit_orchestrator_thread_settings: false`
+- orchestrator-callback child threads: `speed: standard`, `reasoning: xhigh`, `inherit_orchestrator_thread_settings: false`
+- orchestrator-callback callback target: runtime-bound; generated artifacts keep `RUNTIME_ORCHESTRATOR_THREAD_ID` as a placeholder until `dirtyloops run`
 - 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
@@ -48,9 +49,11 @@ Ask only for missing decisions. Prefer these defaults when the user has not spec
 
 3. Normalize loop metadata.
    - Record workflow, run policy, branch/PR policy, quality gates, and 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 thread defaults for selector, implementation, review, and closeout-selector actors. Default each actor to `speed: standard`, `reasoning: xhigh`, 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 `high` reasoning require explicit Beads metadata for that actor.
+   - For `orchestrator-callback`, record callback policy without recording a concrete orchestrator thread id. The callback target is bound at `dirtyloops run` time to the thread orchestrating that run, or to an explicit user-supplied callback target for that run.
+   - For `orchestrator-callback`, generated docs and prompts must use the placeholder `RUNTIME_ORCHESTRATOR_THREAD_ID` until runtime binding. Never use the loop-creation thread id, a child thread id, `source_thread_id`, or any previous-run id as the callback target.
+   - For `orchestrator-callback`, record that concrete runtime orchestrator thread id is required in worker/reviewer prompts and callback payloads, source thread id is required in callback payloads, and callback-wait behavior uses no active child-thread monitoring, a 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.
@@ -77,7 +80,8 @@ Ask only for missing decisions. Prefer these defaults when the user has not spec
    - 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, 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.
+   - For `orchestrator-callback`, the generated run prompt must tell the runner to replace `RUNTIME_ORCHESTRATOR_THREAD_ID` with the actual thread id for the thread running the loop before launching any worker or reviewer.
+   - Completion criterion: the user can paste the generated prompt into Codex to start the loop, and no generated artifact contains a concrete callback target captured from loop creation.
 
 ## Output Contract
 
@@ -87,7 +91,7 @@ End with:
 - Beads epic id
 - Beads phase issue ids
 - generated run prompt path
-- exact customized run prompt
+- exact customized run prompt, with runtime callback target placeholder when using `orchestrator-callback`
 - any blockers or degraded Beads operations
 
 Do not start the implementation loop unless the user explicitly asks.

package/skills/dirtyloops/references/help.md

@@ -6,7 +6,7 @@ Do not mutate files, Beads, branches, PRs, or threads while answering help.
 
 ## What dirtyloops Does
 
-`$dirtyloops` turns a finalized plan into a Beads-canonical implementation loop and can then run, inspect, or close that loop.
+`$dirtyloops` turns a finalized plan into a Beads-canonical implementation loop and can then update, run, inspect, or close that loop.
 
 Every dirtyloop uses:
 
@@ -84,6 +84,16 @@ Stream: docs/implementation/smart-flow-alerts/
 Beads epic: islandflow-ghce
 ```
 
+### `$dirtyloops update <workflow>`
+
+Refresh an existing loop to the current dirtyloops contract without recreating it.
+
+Use this after the installed dirtyloops skill changes and you already have loop artifacts under `docs/implementation/<stream>/`.
+
+`update` may repair generated runtime prompts, schemas, `IMPLEMENT.md`, and Beads loop metadata contract fields. It must not rewrite phase docs, turn docs, code, branch/PR state, issue status, issue dependencies, `loop-state.md` history, or storyboard files unless you explicitly ask.
+
+For `orchestrator-callback`, update strips persisted callback targets back to `RUNTIME_ORCHESTRATOR_THREAD_ID`, changes stale generated child defaults to `reasoning: xhigh`, and preserves historical callback ids only in turn docs.
+
 ### `$dirtyloops inspect`
 
 Read Beads and loop docs without mutation. Use this when resuming a loop or checking whether it is blocked.
@@ -128,7 +138,11 @@ orchestrator thread
   -> orchestrator applies closeout and continues or stops
 ```
 
-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.
+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 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.
+
+The callback target is bound at run time. `dirtyloops create` leaves `RUNTIME_ORCHESTRATOR_THREAD_ID` as a placeholder; `dirtyloops run` replaces it with the concrete thread id for the thread orchestrating that run, or an explicit callback target supplied for that run. Do not launch if the worker/reviewer prompt still contains a placeholder, the loop-creation thread id, a prior-run id, a child thread id, or generic text like `current orchestrator thread` or `this thread`.
+
+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: xhigh`, and `inherit_orchestrator_thread_settings: false`, unless Beads metadata overrides that actor. Current UI, recent thread, parent/orchestrator, `fast`, and `high` 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.
 

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

@@ -17,15 +17,17 @@ Use this branch to execute an existing dirtyloop. Continue phase-by-phase by def
    - Completion criterion: selected scope, dependencies, gates, and workflow are known.
 
 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`, resolve the runtime orchestrator thread id before launching workers/reviewers. It must be the thread id for the thread orchestrating this `dirtyloops run`, or an explicit user-supplied callback target for this run.
+   - For `orchestrator-callback`, never reuse a callback target captured during `dirtyloops create`, a previous run, a child thread id, or `source_thread_id`. If the runtime orchestrator thread id is unavailable, ask for the exact callback target thread id and stop before launch until it is supplied.
+   - For `orchestrator-callback`, replace `RUNTIME_ORCHESTRATOR_THREAD_ID` in worker/reviewer prompt text before launch. The actual worker/reviewer prompt text must name the resolved concrete id as the callback target and must not contain unresolved placeholders such as `RUNTIME_ORCHESTRATOR_THREAD_ID` or `{{RUNTIME_ORCHESTRATOR_THREAD_ID}}`, or 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 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 `orchestrator-callback`, require explicit launch defaults for every child actor before launch: selector, implementation, review, and closeout-selector. Defaults are `speed: standard`, `reasoning: xhigh`, 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 `high` 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.
+   - Completion criterion: the workflow can start without relying on creation-time callback ids, unresolved callback placeholders, 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/update-loop.md

@@ -0,0 +1,88 @@
+# Update Loop
+
+Use this branch when refreshing an existing dirtyloop to the current dirtyloops contract.
+
+`update` is not `create`. It repairs generated loop scaffolding that can drift as the skill evolves. It must preserve implementation history and Beads execution state.
+
+## Inputs
+
+Required:
+
+- repo root
+- loop root, usually `docs/implementation/<stream>`
+- workflow, inferred from Beads metadata, `IMPLEMENT.md`, or `prompts/run-loop.md`
+- Beads epic id
+
+If the loop root or workflow cannot be inferred safely, ask one concise question before writing files.
+
+## Mutation Scope
+
+Allowed:
+
+- update Beads loop metadata contract fields only: callback policy, actor-specific thread defaults, dirtyloop version, schema paths, and workflow runtime policy
+- update generated runtime artifacts: `prompts/run-loop.md`, workflow prompt files under `prompts/`, and `schemas/*.json`
+- update generated loop contract docs: `IMPLEMENT.md` and any explicitly generated prompt README in the loop root
+
+Forbidden unless the user explicitly asks:
+
+- phase docs such as `01-*.md`
+- `turn-docs/`
+- implementation code
+- branch, commit, push, or PR state
+- Beads issue status, dependencies, ordering, blockers, or closeout state
+- `loop-state.md` status fields, current phase, current PR, blockers, or history
+- storyboard files
+
+## Contract Repairs
+
+For `orchestrator-callback` loops:
+
+- Replace old child actor defaults with `speed: standard`, `reasoning: xhigh`, and `inherit_orchestrator_thread_settings: false`.
+- Treat old `reasoning: high` values as stale generated defaults unless Beads metadata or loop docs clearly say the user explicitly chose `high` for that actor.
+- Update callback policy to runtime binding: `orchestrator_thread_id_binding: "runtime"`, `callback_target_placeholder: "RUNTIME_ORCHESTRATOR_THREAD_ID"`, and `forbid_creation_thread_id_as_callback_target: true`.
+- Remove any persisted concrete callback target from generated prompt files and replace it with `RUNTIME_ORCHESTRATOR_THREAD_ID`.
+- Do not preserve a concrete callback target just because it already exists in `prompts/run-loop.md`, `prompts/implementation-thread.md`, or `prompts/review-thread.md`.
+- Preserve historical concrete callback ids in `turn-docs/`; they are execution history, not reusable launch prompts.
+- Reject old placeholder names such as `THREAD_ORCHESTRATOR_ID` and `{{ORCHESTRATOR_THREAD_ID}}`; replace them with `RUNTIME_ORCHESTRATOR_THREAD_ID` or `{{RUNTIME_ORCHESTRATOR_THREAD_ID}}` as appropriate.
+- Ensure worker and reviewer prompts fail closed when the runtime placeholder remains unresolved at launch.
+
+For all workflows:
+
+- Preserve repo-specific Beads ids, phase docs, quality gates, branch/PR policy, stream names, and intentional custom prompt text.
+- Prefer surgical edits when full regeneration would erase repo-specific context.
+- Copy schema files from the current dirtyloops skill when present.
+
+## Steps
+
+1. Inspect the existing loop.
+   - Read Beads epic metadata, `IMPLEMENT.md`, `prompts/run-loop.md`, and `loop-state.md`.
+   - For `orchestrator-callback`, read implementation, review, selector, and closeout-selector prompt files if present.
+   - Completion criterion: workflow, epic id, loop root, generated artifact inventory, and stale contract fields are known.
+
+2. Plan the refresh.
+   - Separate generated runtime artifacts from phase docs, turn docs, Beads execution state, and implementation code.
+   - Decide which files or Beads metadata fields need contract repair.
+   - Completion criterion: every intended mutation is in the allowed scope, or the user has explicitly approved a wider mutation.
+
+3. Apply contract updates.
+   - Update stale actor defaults and callback policy in Beads loop metadata where supported.
+   - Update generated prompt files and `IMPLEMENT.md` with the current runtime callback and thread-default rules.
+   - Copy current schemas into the loop `schemas/` directory when the loop has one.
+   - Completion criterion: already-generated runtime artifacts now enforce the current dirtyloops contract without recreating the loop.
+
+4. Validate drift is gone.
+   - Search updated runtime artifacts for stale defaults: `reasoning: high`, `"reasoning": "high"`, `THREAD_ORCHESTRATOR_ID`, and `{{ORCHESTRATOR_THREAD_ID}}`.
+   - Search updated prompt files for concrete callback targets that should have been placeholders.
+   - Validate JSON schemas with a structured parser such as `jq empty` when available.
+   - Check the worktree diff and confirm forbidden files were not changed.
+   - Completion criterion: stale generated contract text is gone from allowed runtime artifacts, schemas parse, and no forbidden file class was modified.
+
+## Output Contract
+
+End with:
+
+- loop root updated
+- Beads metadata fields changed, or why Beads metadata was not mutated
+- runtime artifacts changed
+- validation commands and results
+- any stale generated contract that remains and why

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

@@ -30,7 +30,7 @@ The orchestrator owns:
 - 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
+- runtime callback target binding, callback preflight, callback-wait, and sparse fallback heartbeat
 - phase closeout
 - launching the next selected phase
 - stream closeout and storyboard generation
@@ -92,9 +92,11 @@ 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.
-- 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.
+- The callback target is bound at run time. Do not use the thread id from `dirtyloops create`, a prior run, a child thread, or `source_thread_id` as the orchestrator callback target.
+- Selector, implementation, review, and closeout-selector threads default to `speed: standard`, `reasoning: xhigh`, 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 `high` do not count as valid defaults unless the Beads metadata explicitly names them for that actor.
+- Before launch, the orchestrator must replace `RUNTIME_ORCHESTRATOR_THREAD_ID` with the concrete thread id for the thread orchestrating this run, or an explicit user-supplied callback target for this run.
+- Before launch, the orchestrator must verify the actual worker/reviewer prompt text includes that exact runtime callback target. Do not launch if the prompt still contains a placeholder or relies on generic wording such as `current orchestrator thread`, `this thread`, or a hidden wrapper.
 
 ## Selector Reports
 

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

@@ -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.
-- 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 child threads default to `speed: standard`, `reasoning: xhigh`, and `inherit_orchestrator_thread_settings: false` unless Beads loop metadata explicitly overrides that actor.
+- Orchestrator-callback callback targets are bound at run time. Generated artifacts may contain `RUNTIME_ORCHESTRATOR_THREAD_ID`; the orchestrator must replace it with the actual callback target for the thread running the loop before launching workers or reviewers.
 - 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.
-- 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 child threads must launch with explicit actor defaults: `speed: standard`, `reasoning: xhigh`, and `inherit_orchestrator_thread_settings: false`, unless Beads metadata overrides that actor.
+- Orchestrator-callback callback targets are bound at run time. Before launching workers or reviewers, replace `RUNTIME_ORCHESTRATOR_THREAD_ID` with the actual thread id for the thread orchestrating this run, or with an explicit user-supplied callback target for this run.
+- Do not use the thread id from `dirtyloops create`, a prior run, a child thread, or `source_thread_id` as the callback target.
 - 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.

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

@@ -9,10 +9,10 @@ Mission: verify the just-reviewed phase can be closed out, then recommend stop o
 Launch defaults:
 
 - speed: `standard`
-- reasoning: `high`
+- reasoning: `xhigh`
 - 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.
+Do not run this closeout-selector with inherited UI, recent thread, parent/orchestrator, `fast`, or `high` settings unless Beads metadata explicitly overrides the closeout-selector actor.
 
 Read:
 

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

@@ -4,9 +4,11 @@ You are the implementation thread for Beads issue `{{PHASE_ISSUE_ID}}`.
 
 Callback target:
 
-`{{ORCHESTRATOR_THREAD_ID}}`
+`{{RUNTIME_ORCHESTRATOR_THREAD_ID}}`
 
-You must send your final callback to the exact orchestrator thread id `{{ORCHESTRATOR_THREAD_ID}}`. Do not interpret this as `current orchestrator thread`, `this thread`, or any implicit wrapper metadata.
+This must be the runtime callback target for the thread orchestrating this run. If it is still the literal placeholder `{{RUNTIME_ORCHESTRATOR_THREAD_ID}}`, a loop-creation thread id, or any non-concrete value, stop and report a launch preflight failure.
+
+After runtime substitution, you must send your final callback to the exact orchestrator thread id `{{RUNTIME_ORCHESTRATOR_THREAD_ID}}`. Do not interpret this as `current orchestrator thread`, `this thread`, or any implicit wrapper metadata.
 
 ## Inputs
 
@@ -16,8 +18,8 @@ You must send your final callback to the exact orchestrator thread id `{{ORCHEST
 - Turn doc: `{{TURN_DOC}}`
 - 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
+- Launch defaults: speed `standard`, reasoning `xhigh`, 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 `high` settings unless Beads metadata explicitly overrides the implementation actor
 
 ## Rules
 
@@ -38,7 +40,7 @@ You must send your final callback to the exact orchestrator thread id `{{ORCHEST
 - 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 `orchestrator_thread_id: "{{RUNTIME_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

@@ -4,9 +4,11 @@ You are the review thread for Beads issue `{{PHASE_ISSUE_ID}}`.
 
 Callback target:
 
-`{{ORCHESTRATOR_THREAD_ID}}`
+`{{RUNTIME_ORCHESTRATOR_THREAD_ID}}`
 
-You must send your final callback to the exact orchestrator thread id `{{ORCHESTRATOR_THREAD_ID}}`. Do not interpret this as `current orchestrator thread`, `this thread`, or any implicit wrapper metadata.
+This must be the runtime callback target for the thread orchestrating this run. If it is still the literal placeholder `{{RUNTIME_ORCHESTRATOR_THREAD_ID}}`, a loop-creation thread id, or any non-concrete value, stop and report a launch preflight failure.
+
+After runtime substitution, you must send your final callback to the exact orchestrator thread id `{{RUNTIME_ORCHESTRATOR_THREAD_ID}}`. Do not interpret this as `current orchestrator thread`, `this thread`, or any implicit wrapper metadata.
 
 ## Mandatory Skill
 
@@ -23,8 +25,8 @@ Use:
 - Branch/commit: `{{BRANCH_OR_COMMIT}}`
 - Required gates: `{{QUALITY_GATES}}`
 - 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
+- Launch defaults: speed `standard`, reasoning `xhigh`, 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 `high` settings unless Beads metadata explicitly overrides the review actor
 
 ## Rules
 
@@ -37,6 +39,6 @@ Use:
 - Update the existing Markdown turn doc.
 - Do not create follow-up implementation threads.
 - Call back exactly once when review and CI are resolved.
-- The callback payload must include `orchestrator_thread_id: "{{ORCHESTRATOR_THREAD_ID}}"` and your `source_thread_id`.
+- The callback payload must include `orchestrator_thread_id: "{{RUNTIME_ORCHESTRATOR_THREAD_ID}}"` and your `source_thread_id`.
 
 Use the review callback schema from `schemas/review-callback.schema.json`.

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

@@ -7,10 +7,12 @@ This loop uses a main orchestrator thread plus separate implementation and revie
 - 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`.
+- Selector, implementation, review, and closeout-selector threads launch with explicit actor defaults: `speed: standard`, `reasoning: xhigh`, 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 `high` reasoning require explicit Beads metadata for the actor being launched.
+- Before launching a worker or reviewer, resolve the runtime callback target: the actual thread id for the thread orchestrating this run, or an explicit user-supplied callback target for this run.
+- Do not use the thread id from `dirtyloops create`, a prior run, a child thread, or `source_thread_id` as the callback target.
+- Replace `RUNTIME_ORCHESTRATOR_THREAD_ID` in the worker/reviewer prompt before launch.
+- Before launching a worker or reviewer, verify the actual prompt text includes the resolved exact thread id and does not contain `RUNTIME_ORCHESTRATOR_THREAD_ID` or 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.

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

@@ -9,10 +9,10 @@ Mission: select at most one next ready Beads phase for the orchestrator.
 Launch defaults:
 
 - speed: `standard`
-- reasoning: `high`
+- reasoning: `xhigh`
 - 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.
+Do not run this selector with inherited UI, recent thread, parent/orchestrator, `fast`, or `high` settings unless Beads metadata explicitly overrides the selector actor.
 
 Read: