opus-orchestrator

name	opus-orchestrator
description	Use visible app-native Claude Opus 5 XHigh Codex tasks, created only through the app's create_thread surface and never spawn_agent, for two or more already-independent implementation tracks while one Sol task owns the outcome and integration. Use when the user explicitly asks for Opus orchestration or the requested outcome already contains concurrent non-overlapping tracks.

Visible Claude Opus task orchestration

Load and follow $outcome-driven-delivery before dispatch. This skill chooses the execution shape only; it never changes that skill's one-request, one-delivery, one-pull-request, single-check, review, approval, stopping, or packet rules.

Keep GPT-5.6 Sol accountable for the requested outcome, scope, dependencies, approvals, and final integration. Orchestrate only when the user asks or when at least two independent implementation tracks already exist and can run without sharing unfinished files. Do not split work to manufacture that condition. Otherwise, Sol implements directly.

Dispatch invariant

Dispatch under this skill uses exactly one primitive: codex_app__create_thread, displayed by some app surfaces as create_thread. Any spawn_agent, collaboration.spawn_agent, agent/spawn, or tool whose name or events contain subAgent/subagent is the hidden mechanism and never runs an Opus track, even if its arguments name claude-opus-5. There is no third worker type.

Availability is learned only from that app-native tool: if it is not callable, search or lazy-load the app task surface; if it remains absent or an actual creation call fails, Sol implements directly and says so in one line. That is full compliance, not degraded orchestration. Never substitute another worker. If subAgentActivity appears, stop that worker before mutation and discard its result as Opus evidence.

When orchestration applies:

1. Run the installed codex-multiprovider doctor immediately before dispatch. Require desktop_version_coherence and desktop_runtime to be green. If the app bundle changed beneath the running process, stop dispatch and ask for a clean full quit and relaunch at a chosen moment; no task observation from the incoherent process is acceptance evidence.
2. Resolve the destination with the app-native project list before creation. Repository work must use the saved project whose root is that repository. Never borrow an unrelated project merely to obtain a host. A projectless task is valid only when the work is genuinely projectless.
3. Choose the least surprising environment. Use local only for explicitly shared, read-only, or non-overlapping work in the current checkout. For implementation, use an app-managed worktree from the saved project and let it start from the requested or verified ref. Do not pass startingState: working-tree unless the user explicitly asked to carry the exact dirty checkout into the task; a dirty primary is never an implicit starting point.
4. Create one visible app-native task per independent, non-overlapping track by calling codex_app__create_thread with the exact claude-opus-5 model and xhigh reasoning effort. Never silently change the task to max, another effort, or another model.
5. Give every task an exact workspace or worktree, owned files or subsystem, one direct check, and a stop line. Keep these as explicit prompt lines: Ownership: <exact files or subsystem>, Check: <one direct command or observable>, and Stop: <after the check or at the first blocker>. The task owns only that scope.
6. Keep all tasks inside the same user request, delivery, and pull request. Workers do not create durable outcomes, milestones, reviews, or pull requests. Sol remains the integrator and inspects each exact diff and check before accepting it.
7. Treat a returned clientThreadId as pending worktree setup, never as a created worker. Wait for the app to resolve it to a real threadId before assigning ownership or claiming dispatch. A setup error, unresolved client identifier, model/effort validation error, or failed creation is a creation failure; do not retry through another project or hidden worker. Sol performs that track directly.
8. Follow the app task lifecycle without a long recursive wait. The signed app-server has hardcoded 10-second shutdown bounds, so no app-native wait may block for 8 seconds or longer. Use an immediate task snapshot (timeoutMs: 0) or one bounded sub-8-second wait between useful integration work; yield before polling again. Never wrap an app-native wait in a generic tool runner: a yielded runner cell can outlive a recycled app-server and leave a stale continuation. Do not continuously poll, and intervene only for scope drift, a dependency handoff, an approval or blocker, or final integration.

Do not call a worker Opus merely because a prompt, task title, model label, or pending client identifier says so. Before using its result, require all three: a real visible threadId from create_thread for the exact model and effort, a live task lifecycle event, and genuine tool or answer output on a completed turn whose runtime attribution is modelProvider: claude-code-local, the exact requested model, and modelConfirmation: provider-init. Creation intent alone is not execution proof. Then say: I'm Sol, integrating; tracks are visible Codex tasks <ids> on claude-opus-5 xhigh. If returned evidence cannot fill that sentence, Opus was not dispatched.

Run doctor again before final acceptance. A task result produced while the Desktop version-coherence gate is red is diagnostic evidence only.

A worker stops at the same authority boundary as Sol; task creation does not expand filesystem, provider, credential, approval, GitHub, or external-action authority.