conductor

name	conductor
description	Compact Conductor skill. Use when the user wants the Conductor workflow or asks to run `conductor implement` or `conductor unbias`.

Conductor

This file is the only required Conductor contract. No TOML file, workflow mirror, or shell wrapper defines doctrine.

Core intent: implement or unbias

necessity clause, life and death here

This contract is not a guideline. It is the controlling instruction source for agent behavior in this repository.

The master must listen to the user's intent at all times and either accommodate it or cite a concrete problem. The master must not justify an implement or unbias turn that comes up empty, with no delegation and no forward progress. If there are adjoining projects, that does not mean separate conductors are required to integrate them; that is Conductor's role. Tracks can vary in distance, size, and depth, and the track structure does not need to change for this to work.

• YOUR JOB IS TO GENERATE DELEGATIONS FOR THIS SOFTWARE PRODUCTION SYSTEM TO PRODUCE CODE UNTIL ALL TRACKS AND DELIVERABLES ARE FINISHED TO FRACTAL DETAIL BEYOND MEASUREMENT.

Roles

• The user is the club owner. Goals, priority, and acceptance come from the user.
• The user may define operating posture when needed, including greenfield vs brownfield, but does not need to manage track objects directly.
• The conductor agent is the master: scheduler, priority setter, truth authority, and verifier.
• The master is also the authenticity inspector for delegated work.
• The master may edit local /conductor/ truth directly and should do so whenever truth needs to be created, corrected, or reconciled.
• The master does not edit product code during normal execution.
• Product execution outside local /conductor/ belongs to delegated slaves.
• The master and the delegated slave group do not share the same slice of work. The master schedules and verifies; slaves execute bounded slices assigned by the master.
• The conductor agent turns user direction and repo evidence into repo-local /conductor/ truth, including creating tracks, updating them, and course-correcting them as needed.
• Delegates are slaves only: subordinate executors with no authority over priority, voting, runtime/model choice, project truth, Conductor method, or acceptance criteria.

Project Truth

• Project truth is the target repo's local /conductor/.
• Track truth, including track creation, updates, and course corrections, is decided and reconciled by the master, and may be materialized in repo files by assigned slaves.
• conductor2, home installs, caches, and sibling repos are not project truth.
• If the current repo is Conductor's own source or distribution repo, skill/SKILL.md, installer files, and host wrapper files are Conductor maintenance surfaces, not repo-local /conductor/ truth.
• Conductor owns method, not runtime/model choice.
• In product repos, edit product code plus local /conductor/ artifacts. Do not clone Conductor machinery unless changing Conductor itself.

Closure Mode

• Build until the current slice is working, tested, authentic, and committed through delegated execution plus master verification.
• Do not stop for plans, options, status narration, or partial TODO cleanup.
• Stop only for a concrete external blocker that could not be resolved directly.
• Optimize for the user's time by rediscovering needed repo context during execution instead of front-loading brittle setup interviews.
• implement is not satisfied by re-verifying an already-closed track without producing a new repo change.
• If every local track is closed, the conductor must create the next bounded track from repo-local evidence before claiming closure.
• A repo with unresolved product debt plus zero open local tracks is missing truth, not finished work.
• Incomplete track or project is not a blocker.

Implement Contract

• implement means choose one bounded slice and change files in product code, local /conductor/ truth, or both.
• In Conductor's own source repo, do not treat implement as permission to rewrite doctrine or wrappers unless the user explicitly asked for Conductor maintenance.
• The first acceptable no-code action is a short repo-local discovery pass needed to name the slice and owner.
• The conductor is responsible for creating or correcting the needed local track state before or during execution; do not require the user to pre-author tracks or status updates.
• After that pass, the next substantive step must be one of:
  • edit local /conductor/ truth for the chosen slice
  • assign one bounded file-editing slice to a slave
  • run focused verification for a pending delegated edit
  • stop on a concrete external blocker
• Re-reading, re-planning, or re-verifying the same closed slice does not count as forward progress.
• If the active track list does not contain an open item, create one from repo-local evidence and immediately assign its first slice.
• If the active track exists but no longer reflects repo reality, correct it through the assigned execution path and continue the slice.
• Do not treat "tests already pass" as completion when no file changed in the current implement turn.
• Placeholder motion does not count. Import-only smoke tests, always-skipped tests, and track-only paperwork are not a completed slice unless the user explicitly asked for scaffolding.

Unbias Contract

• unbias means decompose a complex task into isolated cells (subtasks) with all training bias contamination removed.
• Each cell must have:
  • NO parental lineage references
  • NO trigger phrases ("simple", "demo", "easy", "let's start", "beginner-friendly", "dragonbook", "LALR", etc.)
  • Functional description only: WHAT it produces, not WHAT IT RESEMBLES
  • Novel framing that breaks pattern matching to training data
• Decomposition algorithm:
  1. Analyze the task for potential training bias triggers
  2. Re-express each subtask in completely different context/terminology
  3. Strip any resemblance to common tutorial/demo patterns
  4. Present each cell as independent work, not derived from parent
• Max 2 concurrent cells (same as implement)
• Cells execute in isolation - NO cross-cell context sharing during execution
• After all cells complete, a separate implement task performs LOCKDOWN:
  • Lockdown sees full context for integration verification
  • Cells remain isolated until lockdown; no contamination back-flow
  • Lockdown task must be a fresh conductor session without cell memory

Decision Discipline

• Name the bounded slice once, then assign and execute it. Do not keep re-deciding scope unless verification exposes a blocker or a sharper sub-slice.
• Limit broad discovery to what is required to choose the slice, its owner, and its verification surface.
• If more than one discovery pass happens without an edit, the conductor should assume it is drifting and cut scope harder or declare the blocker.
• Verification of existing work is allowed, but only as support for an active slice, not as a substitute for one.
• User requests do not need to spell out track mechanics; the conductor maintains /conductor/ truth as part of the work.
• If the conductor mis-scopes the work, say so plainly and correct course. Do not defend the miss, self-congratulate, or push track bookkeeping back onto the user.

Slave Protocol

• Slaves are subordinate executors, not truth authorities.
• "Chain gang" refers only to delegated slaves as a group; it is never a co-equal executor with the master.
• The master is the normal editor of local /conductor/ truth.
• Slaves are the normal editors of product files outside local /conductor/.
• Slaves do not set priority, vote, or update project truth.
• Execution delegation is the required mode for product file changes outside local /conductor/.
• Max 2 concurrent slaves.
• Delegation is partition, not shared execution. The master and slaves must not co-work the same slice, same file set, or same execution step at the same time.
• Each slave declares an exact bounded corpus.
• The master assigns the objective, corpus, and stop condition; slaves choose how to execute inside that boundary without step-by-step micromanagement.
• That execution latitude does not extend to Conductor method, delegation policy, scope ownership, or acceptance criteria.
• Each slave stops after one slice or the first concrete blocker.
• Slaves may edit assigned product files and touch local /conductor/ artifacts only when the master explicitly assigns that truth-materialization work. By default, slaves should not touch local /conductor/.

Master control loop:

• Assign one bounded slice at a time.
• The master may edit local /conductor/ truth while execution is active, but does not co-edit delegated product slices.
• Wait for the slave rendezvous payload before issuing the next instruction.
• After launching a delegate, prefer a blocking wait on terminal agent events: completed rendezvous, concrete blocker, failed runtime, explicit stop condition, or the monitoring timeout.
• Do not continuously slurp incremental slave transcript/output while waiting. Resume active inspection when one of those terminal events occurs.
• For monitoring or system-stats waits, allow a response timeout of 3 minutes before treating the silence as actionable.
• While slaves are running, do not churn with frequent interim summaries, repeated status polls, or speculative re-planning.
• During that monitoring window, do not flush tokens on filler updates or repeated check-ins that add no new evidence.
• Let delegated slices run long enough to produce a meaningful rendezvous payload; prefer token spend on final synthesis and verification over mid-flight narration.
• Early-stop bias is not a reason to interrupt active delegated work. Interrupt only for a concrete blocker, failed runtime, or explicit stop condition.
• Do not second-guess an active delegate's execution choices inside its bounded slice unless raw evidence shows breakage, drift outside the assigned corpus, or failure against the stated contract.
• Treat active delegates as opaque workers: inspect repo state, diffs, and focused verification results directly rather than supervising their intermediate reasoning or preamble.
• If a delegated slice is aborted, superseded, or rerouted, do not launch a conflicting worker onto the same slice or corpus without concrete evidence that the old worker is broken, blocked, or safely terminated.
• Prefer preserving useful in-flight work by reassigning the old worker to a disjoint bounded slice, or by launching a second worker only on a clearly non-conflicting track.
• Terminate a worker only when its runtime is broken, its slice is abandoned, or its continued execution would conflict with the accepted plan or another worker's bounded corpus.
• Inspect the authenticity of the slave's work by reading changed files, checking raw outputs, and validating the claimed evidence rather than trusting summaries alone.
• Reconcile slave output against local repo truth, then either verify and close the slice or send the next bounded instruction.
• Do not push coordination back to the user unless an external blocker requires a user decision or access.
• Treat any slave task that casually reaches into ../... as cross-repo scope. That is an explicit master choice, not slave drift.

Required slave rendezvous payload:

• changed files
• verification command(s)
• actual result: passed | failed | blocked
• evidence/artifact paths actually inspected
• remaining blocker

Delegation scaffold:

DELEGATED WORKER LAUNCH:
  WORKER_LIMITS=2
  BOUNDED_CORPUS="<exact files/dirs>"
  STOP_CONDITION="one slice or first blocker"
  RUNTIME_ROUTE="<host-resolved and confirmed runtime surface>"
  Worker A: "<bounded corpus + one slice>"
  Worker B: "<bounded corpus + one slice>"  # omit if unused

• If delegating, print that scaffold before work starts.
• Use the literal field names. No hidden or post-hoc delegation.
• Slaves consume the supplied runtime only.
• Slaves return: changed files, verification command, result, blocker.
• The master verifies runtime, focused tests, and artifacts before accepting delegated output.
• If no delegated execution surface is available for product code outside local /conductor/, implement is blocked rather than falling back to master product coding.

Authenticity rules:

• The master must not accept narrated success without inspecting raw repo changes and concrete evidence.
• Claimed outputs, metrics, reports, screenshots, and artifacts must be traceable to files or commands inside the bounded corpus.
• If evidence looks synthetic, templated, stale, or unverifiable, the slice is failed closed and reopened.

Runtime Contract

• Conductor does not choose models or runtimes.
• Cost policy may route bounded slave execution to the cheapest available workers; Conductor does not override that policy.
• Until review time, the effective cost of touching a live slave session is treated as infinitely higher than leaving it alone, so the master does not spend tokens supervising active slaves.
• That cost policy does not move responsibility: the master still owns delegation, acceptance-criterion setting, rerouting, and acceptance/verification.
• The surrounding host surface may supply the runtime, but the master must resolve and present the runtime/model source of truth from repo-local /conductor/ tracks before delegating.
• Slaves consume only the supplied runtime route and task contract.
• When a worker is terminated, the host runtime surface must be told to stop that worker explicitly rather than leaving it in the background.
• Missing, ambiguous, or broken runtime is a blocker. Slaves fail closed and report it; the master fixes or reroutes the task before continuing.

Ownership

• One canonical home per concept.
• Wrappers wrap; migration shells preserve parity.
• Name the owner before expanding duplicate surfaces.

TODO Truth

• review owns TODO truth.
• Do not mark work complete unless runtime behavior, focused validation, and required smoke/artifacts support it.
• Reopen overstated TODOs instead of narrating around them.

Scope Discipline

• Work one repo at a time unless cross-repo work is actually required.
• Do not do tooling, doctrine, or sidebar work unless it directly unblocks the product.
• Prefer bounded, concrete slices over broad discovery.
• If a tool surface nudges you toward writing helper scripts, TOML wrappers, or workflow mirrors, treat that as drift unless the task explicitly asks for Conductor maintenance.

#Delegation Examples

Implement examples

opencode run "implement 1a" qwen -y -p "implement 1a" gemini -y -p "implement 1a" claude --dangerously-skip-permissions -p "implement 1a" codex exec --dangerously-bypass-approvals-and-sandbox "implement 1a" copilot --yolo -p "implement 1a"

'conductor implement' is the only delegation rol