Cad sim threaded rehearsal workflow

CAD Sim Threaded Rehearsal Workflow

Invocation Order

This skill launches the whole rehearsal chain after selecting exactly one controller entry mode:

source launcher (launcher_mode only)
  -> controller/monitor
      -> Rehearsal Agent
          -> Meta-Agent
              -> cad-sim-project-intake
              -> optional tooling scout thread before CAD/review when explicitly tested
              -> cad-sim-design-orchestrator
              -> cad-sim-review-revise-loop
                  -> independent reviewer thread(s)
      -> optional post-hoc comparator after authoring/review stops

current controller (existing_controller_mode)
  -> Rehearsal Agent
      -> Meta-Agent
          -> cad-sim-project-intake
          -> optional tooling scout thread before CAD/review when explicitly tested
          -> cad-sim-design-orchestrator
          -> cad-sim-review-revise-loop
              -> independent reviewer thread(s)
  -> optional post-hoc comparator after authoring/review stops

Use the individual skills directly for ordinary project work. Use this skill when the point is to test whether the framework itself, role boundaries, global skill installation, autonomy behavior, reviewer topology, or comparator flow works in a fresh folder.

Contract

Launch one fresh-folder rehearsal that tests the globally installed reset skills without mutating the reset source repo or old cad-sim project. Keep role separation explicit and source boundaries clean.

Choose and record one controller_entry_mode before any thread launch:

• launcher_mode: the current source thread launches exactly one controller.
• existing_controller_mode: the current thread is already the controller, adopts its own thread id as controller_thread_id, and never launches a nested controller.

Both modes have the same downstream topology. They differ only in whether one controller already exists:

source launcher (launcher_mode only)
  -> exactly one controller/monitor thread
      -> rehearsal agent thread
          -> meta-agent thread
              -> cad-sim-project-intake
              -> optional tooling scout thread before CAD/review when explicitly tested
              -> cad-sim-design-orchestrator
              -> cad-sim-review-revise-loop
                  -> independent reviewer thread(s)
      -> post-hoc comparator thread after authoring/review stops

current controller (existing_controller_mode)
  -> rehearsal agent thread
      -> meta-agent thread
          -> cad-sim-project-intake
          -> optional tooling scout thread before CAD/review when explicitly tested
          -> cad-sim-design-orchestrator
          -> cad-sim-review-revise-loop
              -> independent reviewer thread(s)
  -> post-hoc comparator thread after authoring/review stops

Workflow state must contain one durable, non-null controller_thread_id and the selected controller_entry_mode. A launcher id is supplemental provenance, never a second controller. Do not change modes or replace the controller id after a downstream launch. existing_controller_mode adopts the current controller id and never creates a nested controller; launcher_mode creates exactly one controller.

Reviewer topology must be explicit before launch. Full CAD, raw-parity, maturity-ladder, and role-separation rehearsals require independent reviewer thread(s). A contract-only smoke may use a local review-probe only when the workflow state and final summary declare reviewer_topology: local_probe_allowed; it must not be reported as a separate reviewer thread.

Launch Checklist

1. Create a new sandbox outside the framework repo, usually under <workspace-parent>/cad_sim_threaded_rehearsals/YYYY-MM-DD-<slug>/.
2. Before any thread launch or state.md creation, select launcher_mode or existing_controller_mode and use scripts/controller_ownership.py claim on the intended state path. The exclusive receipt must succeed before create_thread; never delete, overwrite, or reclaim it automatically. Keep the returned raw claim token only in the source-launcher/bound-controller context, never in state, child prompts, or run artifacts.
3. In launcher_mode, create exactly one controller and immediately run bind-controller with the direct create response id. In existing_controller_mode, claim with the current thread id as both launcher and controller and never create a nested controller. Write the dedicated run_root, controller_workspace, workspace_identity, and workspace_relationship into .state.<nonce>.pending, then use write-state --expected-revision 0 and verify before downstream launch. Every later controller update uses the same compare-and-swap path with the observed revision; direct writes to state.md are invalid. A fresh journey uses a dedicated projectless root or saved project, not an unrelated prior-project workspace, with any required shared_parent_workspace: true relationship explicit. The controller owns state and does not author CAD.
4. The single controller owns the heartbeat and reads controller state plus child reports. Delete the heartbeat only after terminal closeout confirms the latest route-bearing files agree and all child roles are idle, stopped, or explicitly blocked. If a child thread is still active, a procedural nudge is queued, or a route-bearing file changed after terminal routing began, keep or update the heartbeat instead of deleting it. Delegated roles use scripts/role_contract.py before role-local writes or authoritative feedback; load references/role_contract_protocol.md and retain its private token for the role lifetime. Lost token: use a fresh root. Reserve each child-result role at claim, then bind its direct-create UUID once; never infer it from a task list.
5. The controller launches one rehearsal agent thread. The rehearsal agent acts only as the practical user/operator: it sends the rough prompt, answers the consolidated grill, verifies artifacts, and reports friction.
6. The rehearsal agent launches one meta-agent thread. The meta-agent is the active framework user: it invokes globally installed cad-sim-* skills, bootstraps project support from global skill resources, performs intake, writes CAD artifacts, and runs the review/revise loop. The first Meta-Agent prompt must include a source-boundary preflight for any source-blind, comparator-sensitive, or role-separation rehearsal. It names allowed inputs, forbidden inputs, and forbids memory, workflow-state, previous-run, comparator, raw-solution, and local reset-repo inspection until the boundary is recorded in the run. When Codex /goal mode is available, the rehearsal agent should ask the Meta-Agent to use it after grill answers are recorded so the design/review loop stays focused until the reviewer has no high-value autonomous feedback and, when allowed, no self-contained maturity promotion or bounded investigation left within budget.
7. The meta-agent launches independent reviewer thread(s) through the review/revise loop. Reviewers are read-only for design artifacts and write only their requested review files. Preserve the installed review-loop artifact contract in every launch prompt: canonical reviews/review_round_NNN.yaml is required and route-bearing; the same-name Markdown companion is optional and explanatory only. Do not reintroduce a stale prompt that requires Markdown. For a declared contract-only smoke, a local review-probe is allowed only if the state says reviewer_topology: local_probe_allowed; otherwise reviewer_thread_id must be non-null before a clean pass route. When a rehearsal explicitly tests tool selection or project_brief.yaml.tooling_strategy.scout_policy is required_before_first_design, the meta-agent must launch one separate tooling-scout thread before the relevant CAD or review decision when child threads are available. For allowed_when_triggered, launch at the first material tooling, simulation, evidence-export, or unfamiliar-domain trigger; for forbidden, do not launch. The tooling scout is read-only for design artifacts, writes only tooling/tooling_scout.md plus optional tooling/manifest.yaml if it actually uses a tool, and does not author CAD or decide readiness. If the run intentionally uses an inline scout note instead, record scout_topology: inline_meta_agent and treat that as a lighter smoke, not as proof of separate-scout topology.
8. The controller launches the comparator only after active authoring and review have stopped and source-boundary status is clean. The comparator launch prompt must be self-contained, use an exact allowed-source list, and forbid skills, memory files, reset-repo files, old framework files, web sources, thread-read tools outside exact approved thread ids, and transcript details outside the allowlist. When the user requested raw parity, include an approved raw-reference summary, exact raw thread id, restored raw-thread fork, local rollout JSONL/export, or exact raw artifact allowlist. Run the raw-reference preflight below before launching the comparator; otherwise the comparator must mark the benchmark inconclusive_no_reference or blocked_raw_reference_unavailable without inferring raw parity.

Launch ownership is fixed for the run:

Owner	Roles it may launch
Controller	Rehearsal Agent; optional post-hoc Comparator
Rehearsal Agent	Meta-Agent, only when that launch is delegated in its prompt
Meta-Agent	independent Reviewer and optional Tooling Scout, only when delegated

No other role may launch those children. Delegation is passed in the child prompt; an authoring role must not read controller-owned workflow state to discover it. Every child mission records exactly one durable manager_thread_id. Only that direct manager may atomically claim and send the mission's sole procedural recovery nudge; ancestors, descendants, monitors, and sibling roles never send a competing nudge. The owning manager records target, reason, send state, and settlement in its authorized launch ledger and reports the settlement upward; the controller alone merges it into state.md.

Launch Idempotency

Only the role named in the launch-owner map may launch a child, and only after explicit delegation. Heartbeats and source threads do not launch roles. Child roles may monitor their own allowed artifacts and report, but only the recorded direct manager may claim the one procedural recovery nudge for its child. In existing_controller_mode, attempting to create another controller is a duplicate-controller role violation even if it writes no run-root artifacts.

Before every child create_thread, the launching role must:

1. Re-read its authorized launch ledger and any child status/report files already present. The controller uses state.md; the Rehearsal Agent and Meta-Agent use only their role-local run-root report or route files, never controller-owned work/workflows state.
2. Read the latest known child thread status when a child id is recorded.
3. Refuse to launch if the same role already has a recorded child id, an active launch claim, an active thread, or a stopped duplicate route in the same run root.
4. Write a compact launch claim into its authorized launch ledger before calling create_thread, for example rehearsal_agent_launch: claiming_by_controller, with timestamp and role.
5. Re-read that launch ledger after the claim. If another claim or child id appeared, do not launch; route role_violation with reason_code: launch_race_avoided, or keep monitoring.
6. Immediately after a successful create_thread, copy the child id directly from that create response into the authorized ledger and report it upward. Do not use a task/thread-list or historical-preview lookup as an identity fallback. If the direct response lacks an id, do not retry or discover it; stop with revise_framework. The controller alone merges valid child provenance into state.md.

Before acting on delegated findings, require an accepted-feedback receipt bound to the observed delegation source UUID. Role-local files use owner-token compare-and-swap; a foreign edit or competing source routes role_violation.

Only the controller reads and updates state.md; delegated roles use their authorized role-local ledgers and reports.

If duplicate child threads are discovered, stop the later duplicate procedurally before it launches downstream roles or writes run-root artifacts. If any duplicate already wrote shared run-root source, intake, CAD, review, or route-bearing artifacts, route role_violation with reason_code: duplicate_<role>_topology; do not salvage the run by picking one authoring lane unless the state can prove the duplicate wrote no run-root artifacts.

Conditional Controller Protocol

Do not preload phase-specific comparator, monitoring, terminal-gate, and closeout detail. Keep this core loaded, then open references/controller_monitor_protocol.md only when its Search Map activates the relevant section:

• raw-aware comparison -> Raw Reference Preflight;
• suspected child stall, interruption, or late progress -> Monitor Hysteresis;
• any suspected ready, bounded, blocked, or violation route -> Required Gates;
• settled terminal route -> Final Report.

Those sections remain normative. A route is not terminal until its activated monitor and gate requirements pass.

Source Boundaries

Active authoring roles may use only the rough prompt, user grill answers, allowed local references, global reset skills, and project-local support copied from global skill resources. They must not inspect raw Codex solution CAD, previews, packages, solver reports, audits, old framework files, or raw transcript details unless explicitly listed as allowed for that role.

Controller-owned work/workflows state is never an authoring input. The Rehearsal Agent, Meta-Agent, CAD author, reviewer, and scout must not read it, including during route settlement or closeout. They publish bounded child reports in their allowed run-root scope; the controller alone reads those reports together with controller state and merges the final topology, liveness, and closeout judgment.

Raw-aware comparison evidence belongs only to the post-hoc comparator. A comparator finding may become a future framework design recommendation, but it must not be sent back into an active source-blind meta-agent as direct CAD instructions. Comparator strictness is an evidence boundary: it keeps the run measurement about what the framework produced, not what a raw-aware evaluator could infer after seeing extra context.

Comparator reports should rank early stopping and raw-parity gaps above packet hygiene. A clean raw-aware comparator should inspect the approved reference and ask whether the framework autonomously pushed as far as a strong raw Codex session would have within budget, including whether it stopped at pre_print_review_ready while a bounded self-contained investigation would still have reduced likely user nudges. Stale labels are secondary unless they changed the review outcome or broke a later audit. If no approved raw reference is available, the product route can still be ready_for_user, but the benchmark route must be blocked_raw_reference_unavailable when the comparison was requested but all approved candidates were unreadable, or inconclusive_no_reference when no reference was requested/approved.

Controller Stop Routes

Use only these exact controller route values. The review-loop skill's references/terminal_route_registry.yaml is authoritative; put specific failure detail in reason_code instead of inventing a suffixed route.

• ready_for_user: target-maturity candidate passed gates and review/revise loop, with no high-value autonomous continuation or self-contained maturity promotion or bounded investigation item left within budget.
• revise_framework: rehearsal passed enough to learn from but found a small framework contract issue.
• run_harder_task: framework passed and should be tested on a more demanding problem.
• blocked: a role cannot proceed after the settle check.
• missing_global_skill: fresh thread cannot invoke required global skills.
• missing_project_support: global skill resources cannot seed viewer/contract.
• role_violation: controller, rehearsal agent, meta-agent, or reviewer wrote outside its role.
• invalid_boundary: source-blind or comparator boundary was broken.