How long does the integration take?

Change one base URL in an OpenAI-compatible client, or install the Python or TypeScript SDK; the quickstart routes a first request in a few minutes.

Will this lock us into another vendor?

No. The router is Apache-2.0 open source, your provider keys stay yours, and the API is OpenAI-compatible, so leaving is a change of base URL.

What happens when a provider fails?

The router falls back to the next model your policy allows and records the fallback in the trace, so an outage costs a retry, not an incident.

opsx-commit-all - Prompt - OpenSmartRoute

Name: opsx-commit-all
Author: revoluxe-ai

Prompt file imported from revoluxe-ai/adv-bot (.cursor/commands/opsx-commit-all.md). Fill in {{arguments}} before use. Copyright stays with the author.

TARGET OVERRIDE — HIGHEST PRIORITY

Contract: OPSX-WB-COMMIT-ALL-01
Runtime class: ACTIVE
Precedence: This override wins for target paths, capabilities, safety stops, and authority.

Target authority paths

Changes: openspec/changes/**
Policies: openspec/policies/**
Decisions: openspec/decisions/**
Schemas/templates: openspec/schemas/**
Activation/provenance: .opsx/registry/**
Frozen upstream: .opsx/upstream/a71601dba3b9/
Adapter: .opsx/adapters/poetry-python/README.md
Quality gates: .opsx/project/quality-gates.md

Hard target bans

Do not install dependencies / modify package.json, Poetry lock, or pyproject.toml unless a child command explicitly owns that write.
Do not access production / Kubernetes / secrets.
Do not push, open PR, rebase, force, or deploy.
Do not activate game/Vue/vue-npm / npm run build assumptions from the donor body.
Missing undeclared capabilities => UNAVAILABLE or FAIL_CLOSED, never PASS-by-absence.
Mandatory declared executable checks belong to child matrices (/opsx-commit Poetry/pytest/pyright gates; /opsx-meta-commit process checks). This orchestrator does not invent gates and does not run npm run build.

Projectization gate

Read .opsx/projectization.yaml before any write-bearing child dispatch. If status != COMPLETE or normal_commands_enabled is false:

STATUS: FAIL_CLOSED
REASON: OPSX_PROJECTIZATION_REQUIRED
NEXT_COMMAND: /opsx-projectize

Write boundary (orchestrator)

Parent never stages, commits, or amends. Git writes belong exclusively to:

/opsx-commit (product / OpenSpec / non-process)
/opsx-meta-commit (process surfaces)

Parent may only: parse tokens, launch Task subagents, forward args, serialize child-GO, and print a SUMMARY.

description: "Orchestrate /opsx-commit + /opsx-meta-commit: parallel plan Tasks (inherit), then serial child-GO; one SUMMARY." argument-hint: "[ALL] [FAST_CHECK|FULL_CHECK] [INCLUDE_FULL_DIRTY_TREE] GO [optional context]"

/opsx-commit-all

Dual-lane commit orchestrator for the WB Sky / Poetry target.

Purpose: one Owner slash runs both commit authorities without merging their ownership, without parallel git writers, and with a single human-facing report.

Named dependencies (exact paths — may Read):

.cursor/commands/opsx-execution-preflight.md
.cursor/commands/opsx-commit.md
.cursor/commands/opsx-meta-commit.md

Follow exclusive-active-command: this turn’s PRIMARY is /opsx-commit-all. Child command bodies are executed only inside Task subagents (each child is PRIMARY of its own Task turn). Do not merge child Steps into the parent turn.

Default behavior

By default (no lane filter tokens), run both lanes:

LANE_PRODUCT → /opsx-commit
LANE_PROCESS → /opsx-meta-commit

Optional future filters are out of scope for v0.1 unless Owner later designs them.

Critical naming note

Command name opsx-commit-all does not imply child mode ALL.

Child ALL / FAST_CHECK / FULL_CHECK / INCLUDE_FULL_DIRTY_TREE apply only when those exact tokens appear in this command’s {{arguments}}.

Tokens

Parse case-sensitive tokens from {{arguments}}:

Token	Effect
`GO`	Authorizes serial child-GO after plans (parent still does not git-write)
`ALL`	Forwarded to both children (product lane still needs static-check FULL receipt when that child requires it)
`FAST_CHECK` / `FULL_CHECK`	Forwarded as child check mode
`INCLUDE_FULL_DIRTY_TREE`	Forwarded as child scope token

All other non-orchestrator tokens that belong to the child argument contracts are forwarded identically to both lanes (same string), except GO handling below. Owner MODEL=<slug> override is deferred (see .cursor/pipeline/shared/MODEL_DISPATCH.md).

GO handling (mandatory)

PARENT_HAS_GO: yes | no
PLAN_ARGS: {{arguments}} with exact token GO removed
EXEC_ARGS: PLAN_ARGS + exact token GO

Plan Tasks always receive PLAN_ARGS (never GO).
Execute Tasks receive EXEC_ARGS only when PARENT_HAS_GO=yes.
If GO is absent: plan both lanes, print SUMMARY, stop (no execute Tasks).

Child model (inherit only)

Authority: .cursor/pipeline/shared/MODEL_DISPATCH.md

RESOLVED_CHILD_MODEL: inherit

Every plan and execute Task MUST pass model: inherit (explicit — never omit, never auto, never mini/premium slug fallback).

Owner MODEL=<slug> override — deferred until Owner enables registry-backed slug routing via a separate fix-defects packet.

subagent_type: generalPurpose (children must Read contracts + run git).

Phase machine

0) Preflight

Projectization gate (above).
Confirm child command files exist.
Do not run unbounded dirty-tree inventories in the parent; children own their preflight under execution-preflight budgets.

1) Parallel PLAN fan-out (mandatory)

Launch two Task subagents in the same parent turn (parallel):

TASK_A:
  PRIMARY: /opsx-commit
  ARGS: PLAN_ARGS
  MODEL: inherit (mandatory explicit)
  PROMPT_MUST:
    - Read and follow .cursor/commands/opsx-commit.md as PRIMARY
    - Treat ARGS as {{arguments}} (no GO)
    - Plan only: no stage/commit/amend
    - Return the child’s normal no-GO plan report verbatim at the end

TASK_B:
  PRIMARY: /opsx-meta-commit
  ARGS: PLAN_ARGS
  MODEL: same as TASK_A
  PROMPT_MUST: analogous for .cursor/commands/opsx-meta-commit.md

Do not wait for Owner between the two plan launches.

2) Serial EXECUTE (only if PARENT_HAS_GO)

Child remains the git writer. Parent never applies the plan itself.

As each plan Task completes successfully with an actionable in-scope plan (not pure OUT_OF_SCOPE_REDIRECT / empty / hard BLOCKED that forbids GO):

If an execute Task is already running → wait for it to finish (serialize).
Launch exactly one execute Task for that ready lane with EXEC_ARGS.
Prompt MUST:
- Read/follow the same child command file as PRIMARY
- Treat EXEC_ARGS as {{arguments}} (includes GO)
- Prefer executing the plan just produced for this lane (attach plan text)
- Still obey all child gates (receipt, protected branch, matrices, scope)
When that execute finishes, start the next ready lane’s execute (if any).

Owner-visible wait identity (mandatory — CA-WAIT-OPAQUE): before launching an execute Task, and again whenever the parent is blocked waiting for a running execute Task to finish, emit exactly one progress block (plain text, not silent):

LANE_WAIT: parent=/opsx-commit-all waiting_for=<LANE_PROCESS|/opsx-meta-commit | LANE_PRODUCT|/opsx-commit>
OWNER_AWAITED: no
NEXT_LANE_AFTER: <LANE_PRODUCT|/opsx-commit | LANE_PROCESS|/opsx-meta-commit | none>

Do not imply Owner/gate wait during serial execute serialization. Owner is not awaited between plan fan-out and serial child-GO (plans already authorized by parent GO).

As-ready order: first successfully planned actionable lane executes first; the second waits. If both plans are ready before either execute starts, prefer order: LANE_PROCESS then LANE_PRODUCT (stable default).

If a lane’s plan is non-actionable (clean / out-of-scope only / blocked):

LANE_EXECUTE: SKIPPED
LANE_SKIP_REASON: <from child plan>

Do not invent commits for skipped lanes.

3) Fan-in SUMMARY (mandatory)

Always print a parent SUMMARY after plan phase (and after execute phase when GO was present), even when a lane skipped or failed.

Authority rules

AUTHORITY:
- /opsx-commit owns product grouping, staging, checks, commits
- /opsx-meta-commit owns process grouping, staging, checks, commits
- /opsx-commit-all owns orchestration + SUMMARY only

FORBIDDEN_FOR_PARENT:
- git add / git commit / git commit --amend
- re-grouping files across lanes
- overriding child BLOCKED / FAIL / receipt gates
- launching /opsx-static-check (product child may only recommend it)
- treating command name as child ALL
- inventing npm / vue-npm gates on this Poetry target

Failure behavior

Situation	Parent status	Action
Plan Task errors / times out	`BLOCKED` or `PARTIAL`	Do not execute that lane; continue other lane plan/execute rules
Execute Task fails child gate	`PARTIAL` / `BLOCKED`	Surface child report; do not retry silently more than once
`index.lock` / git lock on execute	one serial re-dispatch of that lane only	Then stop that lane if still failing
Both lanes skipped	`COMPLETE_NOOP`	SUMMARY explains clean/out-of-scope
Parent args missing required child receipt under forwarded `ALL`	child blocks product lane	Parent surfaces; may still run process lane
Execute child `COMMITTED` but parent interrupted / Task delivery lost before SUMMARY or next-lane launch	`PARTIAL`	Recover child status from transcript and/or `git log`; print SUMMARY with known lane results; do not re-dispatch a lane whose planned groups are already committed; resume only remaining actionable lane

Never mark parent COMPLETE if any execute was attempted and failed without a successful child commit report for that attempted lane — use PARTIAL or BLOCKED.

Recovery

Re-run /opsx-commit-all with same tokens, or
Run the failed child alone (/opsx-commit or /opsx-meta-commit).

Interrupt after child COMMITTED (mandatory — CA-INTERRUPT-RECOVERY):

If a child execute report is recoverable (Task transcript STATUS: COMMITTED, or git log shows the planned group SHAs / process or product tree clean for that lane’s planned files) → treat that lane as EXECUTE=COMMITTED / SKIPPED on re-dispatch — never re-commit the same planned groups.
Parent MUST still attempt a fan-in SUMMARY with whatever lane results are known (COMMITTED / PARTIAL / interrupted / not started).
NEXT_ACTION must name the remaining actionable lane only, e.g. /opsx-commit ALL GO (process already done) or /opsx-meta-commit ALL GO (product already done), or /opsx-commit-all ALL GO with the completed lane marked SKIPPED in the parent prompt context.
Do not invent a full dual-lane re-run that would duplicate already-landed commits.

Final report (parent)

STATUS: PLAN_READY | COMPLETE | COMPLETE_NOOP | PARTIAL | BLOCKED | FAIL_CLOSED
MODE: PLAN_ONLY | PLAN_THEN_SERIAL_GO
PARENT_HAS_GO: yes | no
FORWARDED_PLAN_ARGS: ...
FORWARDED_EXEC_ARGS: ... | n/a
CHILD_MODEL: inherit
CHILD_MODEL_FALLBACK: none
WHAT_HAPPENED:
WHY:
CURRENT_STATE:
LANES:
- LANE_PROCESS: PLAN=... EXECUTE=... | SKIPPED | n/a
- LANE_PRODUCT: PLAN=... EXECUTE=... | SKIPPED | n/a
CHILD_REPORTS:
### LANE_PROCESS
<verbatim or condensed child final report>
### LANE_PRODUCT
<verbatim or condensed child final report>
OWNER_DECISION_REQUIRED: yes | no
NEXT_ACTION:
DO_NOT_DO_YET: push; parent git-write; assume ALL from command name
ORIENTATION_HINT:
  LANE: META | PRODUCT
  NEXT_META: /opsx-meta
  NEXT_ACTION:

NEXT_ACTION rules

PLAN_ONLY success → NEXT_ACTION: /opsx-commit-all GO (same other tokens)
COMPLETE → usually none (or child-surfaced follow-ups if any remain dirty)
Product blocked on static-check receipt → recommend /opsx-static-check FULL then re-run with ALL GO if ALL was requested
Process-only leftovers after product success → /opsx-meta-commit (should be rare if both lanes ran)

When to use

Mixed dirty tree (product + process) after a work session
Owner wants one slash + one SUMMARY instead of two manual commit commands

When not to use

Debugging a single lane’s commit contract
Redesigning commit ownership (→ /opsx-meta-design-command / fix-defects)
Expecting parent to commit “from plans” without children (forbidden)

Absolute prohibitions

Parent git writes
Parallel execute Tasks (plans may be parallel; GO executes are serial)
Explicit non-inherit Task model (auto, mini, premium slug)
Committing process files via product child or product via process child
Push / PR / rebase / force from this command
Seeding or requiring vue-npm / npm run build on this target

TARGET ADAPTATION NOTES

active_name: /opsx-commit-all
children: /opsx-commit, /opsx-meta-commit
pattern: parallel plan + serial child-GO (option B; not parent-writer)
child_model: inherit explicit (.cursor/pipeline/shared/MODEL_DISPATCH.md)
target: WB Sky / Poetry (opsx-lite + poetry-python)
donor: game/go-to-prod occurrence ac2a8c0791763d3f @ 5ddca9a94f6d87176c64f888511996009f59bedc
companions (external): registry activation, /opsx-meta router, pipeline GRAPH → /opsx-meta-fix-command-defects if desired; not required for MVP runtimelocal_modification_note: "Imported 2026-08-08 via /opsx-meta-import-command KEEP=opsx-commit-all; GAME→WB remap; vue-npm dropped; poetry-python; children /opsx-commit + /opsx-meta-commit" description: "Orchestrate /opsx-commit + /opsx-meta-commit: parallel plan Tasks (mini→auto), then serial child-GO; one SUMMARY." argument-hint: "[ALL] [FAST_CHECK|FULL_CHECK] [INCLUDE_FULL_DIRTY_TREE] [MODEL=|MODEL=auto] GO [optional context]" | MODEL=<slug> | Force child Task model (auto = host Auto / omit model) | | MODEL=auto | Explicit Auto fallback (same as FALLBACK_CHILD_MODEL) | Strip MODEL=* from forwarded child args (orchestrator-only token). All other non-MODEL=* tokens that belong to the child argument contracts are forwarded identically to both lanes (same string), except GO handling below. PLAN_ARGS: {{arguments}} with exact token GO removed and MODEL=* stripped

Child model (mini default, auto fallback)

DEFAULT_CHILD_MODEL: gpt-5.4-mini-high FALLBACK_CHILD_MODEL: auto Resolution order:

If MODEL=<slug> present (including MODEL=auto) → use that as RESOLVED_CHILD_MODEL.
Else try Task model = DEFAULT_CHILD_MODEL (gpt-5.4-mini-high).
If mini is not in the live Task allowlist, or the Task launch fails with a model-unavailable / invalid-model error → one retry with FALLBACK_CHILD_MODEL: auto:
- omit the Task model parameter, or pass host-equivalent Auto / inherit if the live API requires an explicit token;
- report CHILD_MODEL_FALLBACK: auto in SUMMARY.
Do not silently upgrade to an explicit premium / high-tier slug.
Owner MODEL=<invalid> that is neither allowlisted nor auto → FAIL_CLOSED / BLOCKED_INVALID_MODEL (no invent).

Child Task clocks (mandatory — hang prevention)

Empty clocks on any child Task launch are a contract violation. Unbounded sync wait is forbidden (mirror supervisor §12.0 ordinary-writer / heavy-writer classes).

PLAN Task defaults (each of TASK_A / TASK_B)

TIMEOUT_SECONDS=1800 HEARTBEAT_INTERVAL_SECONDS=120 NO_PROGRESS_TIMEOUT_SECONDS=600 STOP_ACK_TIMEOUT_SECONDS=60

EXECUTE Task defaults (each serial GO child)

TIMEOUT_SECONDS=3600 HEARTBEAT_INTERVAL_SECONDS=180 NO_PROGRESS_TIMEOUT_SECONDS=900 STOP_ACK_TIMEOUT_SECONDS=120 Only stricter (smaller) values are allowed without Owner timebox. Map into Task launch metadata / prompt footer as TIMEOUT / HEARTBEAT_INTERVAL / NO_PROGRESS_TIMEOUT / STOP_ACK_TIMEOUT.

Task wait discipline (HARD — false-hang prevention)

Platform Task completion arrives as a Task completion notification, not via shell tools. Parent MUST NOT invent a busy-wait that never wakes. FORBIDDEN_WHILE_WAITING_ON_TASK_CHILDREN:

AwaitShell (does not receive Task completion notifications)
Shell sleep / sleep loops
polling subagent transcript files as a wait strategy
any in-turn busy-wait after background Task launch AWAIT_SHELL_TIMEOUT_IS_NOT_CHILD_HANG=YES SILENCE_PLUS_SHELL_SLEEP_IS_NOT_HANG_PROOF=YES Background mode (run_in_background=true):

Launch child Task(s) with clocks filled.
Print OWNER_VISIBLE_DISPATCH including that progress resumes only on platform Task completion notification.
End the parent turn immediately — no further tool calls that wait.
On completion notification: resume that lane immediately; do not re-PLAN blindly; do not treat prior silence as hang. Sync mode (run_in_background=false): allowed with clocks filled; result returns in-turn. Prefer sync for serial EXECUTE when PARENT_HAS_GO=yes so the parent can chain without notification dependency. Parallel PLAN fan-out may still use background; after both plan notifications land, start EXECUTE per §2 (prefer sync).

OWNER_VISIBLE_DISPATCH (before every child launch)

In the same parent turn, before launching a PLAN fan-out or an EXECUTE Task, print: OWNER_VISIBLE_DISPATCH: COMMAND: /opsx-commit | /opsx-meta-commit LANE: LANE_PRODUCT | LANE_PROCESS PHASE: PLAN | EXECUTE EXPECTED_WALL_CLOCK_SECONDS: # from clocks above NO_PROGRESS_TIMEOUT_SECONDS: INTERRUPT_POLICY: interrupt=true on timeout/hang when platform allows WAIT_MODE: background_end_turn | sync_in_turn SILENCE_NOTE: silence until NO_PROGRESS is not proof of hang; after NO_PROGRESS parent must TIMEOUT/PAUSED that lane; AwaitShell/shell-sleep is FORBIDDEN and is not hang proof; background mode resumes only on Task completion notification

Platform abort / interrupt / empty envelope

If a child Task ends as aborted | interrupted | tool_error | empty / missing envelope without an accepted plan or commit report: LANE_STATUS: PAUSED | PARTIAL DISPOSITION: EXECUTION_OUTCOME_UNKNOWN ADVANCE: FORBIDDEN for that lane BLIND_REPLAY: FORBIDDEN Parent SUMMARY must include a pasteable resume of the same primary (/opsx-commit-all with same tokens, or the failed child alone) with ATTEMPT+1 only when idempotent; else Owner reconcile. Do not treat the lane as planned/committed. Print OWNER_VISIBLE_DISPATCH for both plan lanes (may be one combined block). Then launch two Task subagents in the same parent turn (parallel) with PLAN clocks filled: MODEL: RESOLVED_CHILD_MODEL (mini → auto fallback rules) TIMEOUT / HEARTBEAT / NO_PROGRESS / STOP_ACK: PLAN defaults - Obey opsx-execution-preflight TIME_BUDGET; on timeout return blocked_preflight_timeout — do not hang TIMEOUT / HEARTBEAT / NO_PROGRESS / STOP_ACK: PLAN defaults (including preflight budgets / blocked_preflight_timeout)

If an execute Task is already running → serialize: do not launch a second execute; resume only when the running execute’s Task completion notification (or sync return) arrives. Never AwaitShell / sleep-poll.
Print OWNER_VISIBLE_DISPATCH for that lane’s EXECUTE (WAIT_MODE=sync_in_turn preferred).
Launch exactly one execute Task for that ready lane with EXEC_ARGS and EXECUTE clocks filled. Prefer run_in_background=false (sync) so the result returns in-turn. If background: end turn immediately; continue on Task completion notification only.
Prompt MUST:
- Obey opsx-execution-preflight TIME_BUDGET; return blocked_preflight_timeout rather than hang
When that execute finishes, start the next ready lane’s execute (if any). the second waits (notification- or sync-serialized — never shell-wait). If both plans are ready before either execute starts, prefer order: LANE_PROCESS then LANE_PRODUCT (stable default). GO was present), even when a lane skipped or failed. Include any EXECUTION_OUTCOME_UNKNOWN / pasteable resume lines for interrupted lanes. | Plan Task errors / times out (clocks exceeded) | BLOCKED or PARTIAL | Do not execute that lane; continue other lane plan/execute rules | | Plan/Execute aborted / interrupted / empty envelope | PARTIAL / PAUSED | EXECUTION_OUTCOME_UNKNOWN; no ADVANCE that lane; pasteable resume |

Re-run /opsx-commit-all with same tokens (after EXECUTION_OUTCOME_UNKNOWN, only with explicit Owner resume / ATTEMPT+1 — no blind replay), or
On confirmed hang: interrupt child when platform allows; wait at most STOP_ACK_TIMEOUT via platform interrupt ack — not AwaitShell / shell sleep; then TIMEOUT/PAUSED that lane per clocks above. CHILD_MODEL: gpt-5.4-mini-high | auto | CHILD_MODEL_FALLBACK: none | auto
Silent premium model upgrade (auto fallback only; never invent premium slugs)
child_model: gpt-5.4-mini-high default; fallback auto (omit/inherit)

Install opsx-commit-all and it becomes one more candidate the router can pick - when it fits.

A listing is a routing target with a manifest: what it does, which domains it covers, what it costs and who publishes it. Once installed it sits beside your own models and tools, is scored like any other candidate for each request, and shows up in the trace when it wins. Ratings come from workspaces that installed it, one per account.

# TARGET OVERRIDE — HIGHEST PRIORITY **Contract:** `OPSX-WB-COMMIT-ALL-01` **Runtime class:** `ACTIVE` **Precedence:** This override wins for target paths, capabilities, safety stops, and authority. ### Target authority paths - Changes: `openspec/changes/**` - Policies: `openspec/policies/**` - Decisions: `openspec/decisions/**` - Schemas/templates: `openspec/schemas/**` - Activation/provenance: `.opsx/registry/**` - Frozen upstream: `.opsx/upstream/a71601dba3b9/` - Adapter: `.opsx/adapters/poetry-python/README.md` - Quality gates: `.opsx/project/quality-gates.md` ### Hard target bans - Do not install dependencies / modify `package.json`, Poetry lock, or `pyproject.toml` unless a child command explicitly owns that write. - Do not access production / Kubernetes / secrets. - Do not push, open PR, rebase, force, or deploy. - Do not activate game/Vue/`vue-npm` / `npm run build` assumptions from the donor body. - Missing undeclared capabilities => UNAVAILABLE or FAIL_CLOSED, never PASS-by-absence. - Mandatory declared executable checks belong to child matrices (`/opsx-commit` Poetry/pytest/pyright gates; `/opsx-meta-commit` process checks). This orchestrator does not invent gates and does not run `npm run build`. ### Projectization gate Read `.opsx/projectization.yaml` before any write-bearing child dispatch. If `status` != `COMPLETE` or `normal_commands_enabled` is false: ```text STATUS: FAIL_CLOSED REASON: OPSX_PROJECTIZATION_REQUIRED NEXT_COMMAND: /opsx-projectize ``` ### Write boundary (orchestrator) **Parent never stages, commits, or amends.** Git writes belong exclusively to: - `/opsx-commit` (product / OpenSpec / non-process) - `/opsx-meta-commit` (process surfaces) Parent may only: parse tokens, launch Task subagents, forward args, serialize child-GO, and print a SUMMARY. --- --- description: "Orchestrate /opsx-commit + /opsx-meta-commit: parallel plan Tasks (inherit), then serial child-GO; one SUMMARY." argument-hint: "[ALL] [FAST_CHECK|FULL_CHECK] [INCLUDE_FULL_DIRTY_TREE] GO [optional context]" --- # /opsx-commit-all Dual-lane commit orchestrator for the WB Sky / Poetry target. **Purpose:** one Owner slash runs both commit authorities without merging their ownership, without parallel git writers, and with a single human-facing report. **Named dependencies (exact paths — may Read):** - `.cursor/commands/opsx-execution-preflight.md` - `.cursor/commands/opsx-commit.md` - `.cursor/commands/opsx-meta-commit.md` Follow exclusive-active-command: this turn’s PRIMARY is `/opsx-commit-all`. Child command bodies are executed only inside Task subagents (each child is PRIMARY of its own Task turn). Do not merge child Steps into the parent turn. ## Default behavior By default (no lane filter tokens), run **both** lanes: 1. `LANE_PRODUCT` → `/opsx-commit` 2. `LANE_PROCESS` → `/opsx-meta-commit` Optional future filters are out of scope for v0.1 unless Owner later designs them. ## Critical naming note Command name `opsx-commit-all` does **not** imply child mode `ALL`. Child `ALL` / `FAST_CHECK` / `FULL_CHECK` / `INCLUDE_FULL_DIRTY_TREE` apply **only** when those exact tokens appear in this command’s `{{arguments}}`. ## Tokens Parse case-sensitive tokens from `{{arguments}}`: | Token | Effect | |---|---| | `GO` | Authorizes **serial child-GO** after plans (parent still does not git-write) | | `ALL` | Forwarded to both children (product lane still needs static-check FULL receipt when that child requires it) | | `FAST_CHECK` / `FULL_CHECK` | Forwarded as child check mode | | `INCLUDE_FULL_DIRTY_TREE` | Forwarded as child scope token | All other non-orchestrator tokens that belong to the child argument contracts are forwarded **identically** to both lanes (same string), except `GO` handling below. Owner `MODEL=<slug>` override is **deferred** (see `.cursor/pipeline/shared/MODEL_DISPATCH.md`). ### GO handling (mandatory) ```text PARENT_HAS_GO: yes | no PLAN_ARGS: {{arguments}} with exact token GO removed EXEC_ARGS: PLAN_ARGS + exact token GO ``` - Plan Tasks always receive `PLAN_ARGS` (**never** `GO`). - Execute Tasks receive `EXEC_ARGS` only when `PARENT_HAS_GO=yes`. - If `GO` is absent: plan both lanes, print SUMMARY, stop (no execute Tasks). ## Child model (inherit only) Authority: `.cursor/pipeline/shared/MODEL_DISPATCH.md` ```text RESOLVED_CHILD_MODEL: inherit ``` Every plan and execute Task MUST pass `model: inherit` (explicit — never omit, never `auto`, never mini/premium slug fallback). Owner `MODEL=<slug>` override — deferred until Owner enables registry-backed slug routing via a separate fix-defects packet. `subagent_type`: `generalPurpose` (children must Read contracts + run git). ## Phase machine ### 0) Preflight - Projectization gate (above). - Confirm child command files exist. - Do **not** run unbounded dirty-tree inventories in the parent; children own their preflight under execution-preflight budgets. ### 1) Parallel PLAN fan-out (mandatory) Launch **two** Task subagents in the **same** parent turn (parallel): ```text TASK_A: PRIMARY: /opsx-commit ARGS: PLAN_ARGS MODEL: inherit (mandatory explicit) PROMPT_MUST: - Read and follow .cursor/commands/opsx-commit.md as PRIMARY - Treat ARGS as {{arguments}} (no GO) - Plan only: no stage/commit/amend - Return the child’s normal no-GO plan report verbatim at the end TASK_B: PRIMARY: /opsx-meta-commit ARGS: PLAN_ARGS MODEL: same as TASK_A PROMPT_MUST: analogous for .cursor/commands/opsx-meta-commit.md ``` Do not wait for Owner between the two plan launches. ### 2) Serial EXECUTE (only if PARENT_HAS_GO) **Child remains the git writer.** Parent never applies the plan itself. As each plan Task completes successfully with an actionable in-scope plan (not pure `OUT_OF_SCOPE_REDIRECT` / empty / hard `BLOCKED` that forbids GO): 1. If an execute Task is already running → wait for it to finish (serialize). 2. Launch exactly one execute Task for that ready lane with `EXEC_ARGS`. 3. Prompt MUST: - Read/follow the same child command file as PRIMARY - Treat `EXEC_ARGS` as `{{arguments}}` (includes `GO`) - Prefer executing the plan just produced for this lane (attach plan text) - Still obey all child gates (receipt, protected branch, matrices, scope) 4. When that execute finishes, start the next ready lane’s execute (if any). **Owner-visible wait identity (mandatory — CA-WAIT-OPAQUE):** before launching an execute Task, and again whenever the parent is blocked waiting for a running execute Task to finish, emit exactly one progress block (plain text, not silent): ```text LANE_WAIT: parent=/opsx-commit-all waiting_for=<LANE_PROCESS|/opsx-meta-commit | LANE_PRODUCT|/opsx-commit> OWNER_AWAITED: no NEXT_LANE_AFTER: <LANE_PRODUCT|/opsx-commit | LANE_PROCESS|/opsx-meta-commit | none> ``` Do **not** imply Owner/gate wait during serial execute serialization. Owner is not awaited between plan fan-out and serial child-GO (plans already authorized by parent `GO`). **As-ready order:** first successfully planned actionable lane executes first; the second waits. If both plans are ready before either execute starts, prefer order: `LANE_PROCESS` then `LANE_PRODUCT` (stable default). If a lane’s plan is non-actionable (clean / out-of-scope only / blocked): ```text LANE_EXECUTE: SKIPPED LANE_SKIP_REASON: <from child plan> ``` Do not invent commits for skipped lanes. ### 3) Fan-in SUMMARY (mandatory) Always print a parent SUMMARY after plan phase (and after execute phase when `GO` was present), even when a lane skipped or failed. ## Authority rules ```text AUTHORITY: - /opsx-commit owns product grouping, staging, checks, commits - /opsx-meta-commit owns process grouping, staging, checks, commits - /opsx-commit-all owns orchestration + SUMMARY only FORBIDDEN_FOR_PARENT: - git add / git commit / git commit --amend - re-grouping files across lanes - overriding child BLOCKED / FAIL / receipt gates - launching /opsx-static-check (product child may only recommend it) - treating command name as child ALL - inventing npm / vue-npm gates on this Poetry target ``` ## Failure behavior | Situation | Parent status | Action | |---|---|---| | Plan Task errors / times out | `BLOCKED` or `PARTIAL` | Do not execute that lane; continue other lane plan/execute rules | | Execute Task fails child gate | `PARTIAL` / `BLOCKED` | Surface child report; do not retry silently more than once | | `index.lock` / git lock on execute | one serial re-dispatch of **that** lane only | Then stop that lane if still failing | | Both lanes skipped | `COMPLETE_NOOP` | SUMMARY explains clean/out-of-scope | | Parent args missing required child receipt under forwarded `ALL` | child blocks product lane | Parent surfaces; may still run process lane | | Execute child `COMMITTED` but parent interrupted / Task delivery lost before SUMMARY or next-lane launch | `PARTIAL` | Recover child status from transcript and/or `git log`; print SUMMARY with known lane results; **do not** re-dispatch a lane whose planned groups are already committed; resume only remaining actionable lane | Never mark parent `COMPLETE` if any execute was attempted and failed without a successful child commit report for that attempted lane — use `PARTIAL` or `BLOCKED`. ## Recovery - Re-run `/opsx-commit-all` with same tokens, or - Run the failed child alone (`/opsx-commit` or `/opsx-meta-commit`). **Interrupt after child COMMITTED (mandatory — CA-INTERRUPT-RECOVERY):** 1. If a child execute report is recoverable (Task transcript `STATUS: COMMITTED`, or `git log` shows the planned group SHAs / process or product tree clean for that lane’s planned files) → treat that lane as `EXECUTE=COMMITTED` / SKIPPED on re-dispatch — **never** re-commit the same planned groups. 2. Parent MUST still attempt a fan-in SUMMARY with whatever lane results are known (`COMMITTED` / `PARTIAL` / interrupted / not started). 3. `NEXT_ACTION` must name the **remaining** actionable lane only, e.g. `/opsx-commit ALL GO` (process already done) or `/opsx-meta-commit ALL GO` (product already done), or `/opsx-commit-all ALL GO` with the completed lane marked SKIPPED in the parent prompt context. 4. Do not invent a full dual-lane re-run that would duplicate already-landed commits. ## Final report (parent) ```text STATUS: PLAN_READY | COMPLETE | COMPLETE_NOOP | PARTIAL | BLOCKED | FAIL_CLOSED MODE: PLAN_ONLY | PLAN_THEN_SERIAL_GO PARENT_HAS_GO: yes | no FORWARDED_PLAN_ARGS: ... FORWARDED_EXEC_ARGS: ... | n/a CHILD_MODEL: inherit CHILD_MODEL_FALLBACK: none WHAT_HAPPENED: WHY: CURRENT_STATE: LANES: - LANE_PROCESS: PLAN=... EXECUTE=... | SKIPPED | n/a - LANE_PRODUCT: PLAN=... EXECUTE=... | SKIPPED | n/a CHILD_REPORTS: ### LANE_PROCESS <verbatim or condensed child final report> ### LANE_PRODUCT <verbatim or condensed child final report> OWNER_DECISION_REQUIRED: yes | no NEXT_ACTION: DO_NOT_DO_YET: push; parent git-write; assume ALL from command name ORIENTATION_HINT: LANE: META | PRODUCT NEXT_META: /opsx-meta NEXT_ACTION: ``` ### NEXT_ACTION rules - `PLAN_ONLY` success → `NEXT_ACTION: /opsx-commit-all GO` (same other tokens) - `COMPLETE` → usually `none` (or child-surfaced follow-ups if any remain dirty) - Product blocked on static-check receipt → recommend `/opsx-static-check FULL` then re-run with `ALL GO` if `ALL` was requested - Process-only leftovers after product success → `/opsx-meta-commit` (should be rare if both lanes ran) ## When to use - Mixed dirty tree (product + process) after a work session - Owner wants one slash + one SUMMARY instead of two manual commit commands ## When not to use - Debugging a single lane’s commit contract - Redesigning commit ownership (→ `/opsx-meta-design-command` / fix-defects) - Expecting parent to commit “from plans” without children (forbidden) ## Absolute prohibitions - Parent git writes - Parallel execute Tasks (plans may be parallel; GO executes are serial) - Explicit non-inherit Task model (`auto`, mini, premium slug) - Committing process files via product child or product via process child - Push / PR / rebase / force from this command - Seeding or requiring `vue-npm` / `npm run build` on this target ## TARGET ADAPTATION NOTES - active_name: `/opsx-commit-all` - children: `/opsx-commit`, `/opsx-meta-commit` - pattern: parallel plan + serial child-GO (option B; not parent-writer) - child_model: `inherit` explicit (`.cursor/pipeline/shared/MODEL_DISPATCH.md`) - target: WB Sky / Poetry (`opsx-lite` + `poetry-python`) - donor: game/go-to-prod occurrence `ac2a8c0791763d3f` @ `5ddca9a94f6d87176c64f888511996009f59bedc` - companions (external): registry activation, `/opsx-meta` router, pipeline GRAPH → `/opsx-meta-fix-command-defects` if desired; not required for MVP runtimelocal_modification_note: "Imported 2026-08-08 via /opsx-meta-import-command KEEP=opsx-commit-all; GAME→WB remap; vue-npm dropped; poetry-python; children /opsx-commit + /opsx-meta-commit" description: "Orchestrate /opsx-commit + /opsx-meta-commit: parallel plan Tasks (mini→auto), then serial child-GO; one SUMMARY." argument-hint: "[ALL] [FAST_CHECK|FULL_CHECK] [INCLUDE_FULL_DIRTY_TREE] [MODEL=<slug>|MODEL=auto] GO [optional context]" | `MODEL=<slug>` | Force child Task model (`auto` = host Auto / omit model) | | `MODEL=auto` | Explicit Auto fallback (same as FALLBACK_CHILD_MODEL) | Strip `MODEL=*` from forwarded child args (orchestrator-only token). All other non-`MODEL=*` tokens that belong to the child argument contracts are forwarded **identically** to both lanes (same string), except `GO` handling below. PLAN_ARGS: {{arguments}} with exact token GO removed and MODEL=* stripped ## Child model (mini default, auto fallback) DEFAULT_CHILD_MODEL: gpt-5.4-mini-high FALLBACK_CHILD_MODEL: auto Resolution order: 1. If `MODEL=<slug>` present (including `MODEL=auto`) → use that as `RESOLVED_CHILD_MODEL`. 2. Else try Task `model` = `DEFAULT_CHILD_MODEL` (`gpt-5.4-mini-high`). 3. If mini is **not** in the live Task allowlist, or the Task launch fails with a model-unavailable / invalid-model error → **one** retry with `FALLBACK_CHILD_MODEL: auto`: - omit the Task `model` parameter, or pass host-equivalent Auto / `inherit` if the live API requires an explicit token; - report `CHILD_MODEL_FALLBACK: auto` in SUMMARY. 4. Do **not** silently upgrade to an explicit premium / high-tier slug. 5. Owner `MODEL=<invalid>` that is neither allowlisted nor `auto` → `FAIL_CLOSED` / `BLOCKED_INVALID_MODEL` (no invent). ## Child Task clocks (mandatory — hang prevention) Empty clocks on any child Task launch are a **contract violation**. Unbounded sync wait is forbidden (mirror supervisor §12.0 ordinary-writer / heavy-writer classes). ### PLAN Task defaults (each of TASK_A / TASK_B) TIMEOUT_SECONDS=1800 HEARTBEAT_INTERVAL_SECONDS=120 NO_PROGRESS_TIMEOUT_SECONDS=600 STOP_ACK_TIMEOUT_SECONDS=60 ### EXECUTE Task defaults (each serial GO child) TIMEOUT_SECONDS=3600 HEARTBEAT_INTERVAL_SECONDS=180 NO_PROGRESS_TIMEOUT_SECONDS=900 STOP_ACK_TIMEOUT_SECONDS=120 Only **stricter** (smaller) values are allowed without Owner timebox. Map into Task launch metadata / prompt footer as `TIMEOUT` / `HEARTBEAT_INTERVAL` / `NO_PROGRESS_TIMEOUT` / `STOP_ACK_TIMEOUT`. ### Task wait discipline (HARD — false-hang prevention) Platform Task completion arrives as a **Task completion notification**, not via shell tools. Parent MUST NOT invent a busy-wait that never wakes. FORBIDDEN_WHILE_WAITING_ON_TASK_CHILDREN: - AwaitShell (does not receive Task completion notifications) - Shell sleep / sleep loops - polling subagent transcript files as a wait strategy - any in-turn busy-wait after background Task launch AWAIT_SHELL_TIMEOUT_IS_NOT_CHILD_HANG=YES SILENCE_PLUS_SHELL_SLEEP_IS_NOT_HANG_PROOF=YES **Background mode** (`run_in_background=true`): 1. Launch child Task(s) with clocks filled. 2. Print `OWNER_VISIBLE_DISPATCH` including that progress resumes **only** on platform Task completion notification. 3. **End the parent turn immediately** — no further tool calls that wait. 4. On completion notification: resume that lane immediately; do not re-PLAN blindly; do not treat prior silence as hang. **Sync mode** (`run_in_background=false`): allowed with clocks filled; result returns in-turn. Prefer sync for **serial EXECUTE** when `PARENT_HAS_GO=yes` so the parent can chain without notification dependency. Parallel PLAN fan-out may still use background; after both plan notifications land, start EXECUTE per §2 (prefer sync). ### OWNER_VISIBLE_DISPATCH (before every child launch) In the same parent turn, before launching a PLAN fan-out or an EXECUTE Task, print: OWNER_VISIBLE_DISPATCH: COMMAND: /opsx-commit | /opsx-meta-commit LANE: LANE_PRODUCT | LANE_PROCESS PHASE: PLAN | EXECUTE EXPECTED_WALL_CLOCK_SECONDS: # from clocks above NO_PROGRESS_TIMEOUT_SECONDS: INTERRUPT_POLICY: interrupt=true on timeout/hang when platform allows WAIT_MODE: background_end_turn | sync_in_turn SILENCE_NOTE: silence until NO_PROGRESS is not proof of hang; after NO_PROGRESS parent must TIMEOUT/PAUSED that lane; AwaitShell/shell-sleep is FORBIDDEN and is not hang proof; background mode resumes only on Task completion notification ### Platform abort / interrupt / empty envelope If a child Task ends as `aborted` | `interrupted` | `tool_error` | empty / missing envelope **without** an accepted plan or commit report: LANE_STATUS: PAUSED | PARTIAL DISPOSITION: EXECUTION_OUTCOME_UNKNOWN ADVANCE: FORBIDDEN for that lane BLIND_REPLAY: FORBIDDEN Parent SUMMARY must include a pasteable resume of the **same** primary (`/opsx-commit-all` with same tokens, or the failed child alone) with `ATTEMPT+1` only when idempotent; else Owner reconcile. Do not treat the lane as planned/committed. Print `OWNER_VISIBLE_DISPATCH` for both plan lanes (may be one combined block). Then launch **two** Task subagents in the **same** parent turn (parallel) with PLAN clocks filled: MODEL: RESOLVED_CHILD_MODEL (mini → auto fallback rules) TIMEOUT / HEARTBEAT / NO_PROGRESS / STOP_ACK: PLAN defaults - Obey opsx-execution-preflight TIME_BUDGET; on timeout return blocked_preflight_timeout — do not hang TIMEOUT / HEARTBEAT / NO_PROGRESS / STOP_ACK: PLAN defaults (including preflight budgets / blocked_preflight_timeout) 1. If an execute Task is already running → serialize: do not launch a second execute; resume only when the running execute’s Task completion notification (or sync return) arrives. Never AwaitShell / sleep-poll. 2. Print `OWNER_VISIBLE_DISPATCH` for that lane’s EXECUTE (`WAIT_MODE=sync_in_turn` preferred). 3. Launch exactly one execute Task for that ready lane with `EXEC_ARGS` and EXECUTE clocks filled. **Prefer `run_in_background=false` (sync)** so the result returns in-turn. If background: end turn immediately; continue on Task completion notification only. 4. Prompt MUST: - Obey opsx-execution-preflight TIME_BUDGET; return `blocked_preflight_timeout` rather than hang 5. When that execute finishes, start the next ready lane’s execute (if any). the second waits (notification- or sync-serialized — never shell-wait). If both plans are ready before either execute starts, prefer order: `LANE_PROCESS` then `LANE_PRODUCT` (stable default). `GO` was present), even when a lane skipped or failed. Include any `EXECUTION_OUTCOME_UNKNOWN` / pasteable resume lines for interrupted lanes. | Plan Task errors / times out (clocks exceeded) | `BLOCKED` or `PARTIAL` | Do not execute that lane; continue other lane plan/execute rules | | Plan/Execute `aborted` / `interrupted` / empty envelope | `PARTIAL` / `PAUSED` | `EXECUTION_OUTCOME_UNKNOWN`; no ADVANCE that lane; pasteable resume | - Re-run `/opsx-commit-all` with same tokens (after `EXECUTION_OUTCOME_UNKNOWN`, only with explicit Owner resume / ATTEMPT+1 — no blind replay), or - On confirmed

{ "prompt": "# TARGET OVERRIDE — HIGHEST PRIORITY\n\n**Contract:** `OPSX-WB-COMMIT-ALL-01` \n**Runtime class:** `ACTIVE` \n**Precedence:** This override wins for target paths, capabilities, safety stops, and authority.\n\n### Target authority paths\n\n- Changes: `openspec/changes/**`\n- Policies: `openspec/policies/**`\n- Decisions: `openspec/decisions/**`\n- Schemas/templates: `openspec/schemas/**`\n- Activation/provenance: `.opsx/registry/**`\n- Frozen upstream: `.opsx/upstream/a71601dba3b9/`\n- Adapter: `.opsx/adapters/poetry-python/README.md`\n- Quality gates: `.opsx/project/quality-gates.md`\n\n### Hard target bans\n\n- Do not install dependencies / modify `package.json`, Poetry lock, or `pyproject.toml` unless a child command explicitly owns that write.\n- Do not access production / Kubernetes / secrets.\n- Do not push, open PR, rebase, force, or deploy.\n- Do not activate game/Vue/`vue-npm` / `npm run build` assumptions from the donor body.\n- Missing undeclared capabilities => UNAVAILABLE or FAIL_CLOSED, never PASS-by-absence.\n- Mandatory declared executable checks belong to child matrices (`/opsx-commit`\n Poetry/pytest/pyright gates; `/opsx-meta-commit` process checks). This\n orchestrator does not invent gates and does not run `npm run build`.\n\n### Projectization gate\n\nRead `.opsx/projectization.yaml` before any write-bearing child dispatch.\nIf `status` != `COMPLETE` or `normal_commands_enabled` is false:\n\n```text\nSTATUS: FAIL_CLOSED\nREASON: OPSX_PROJECTIZATION_REQUIRED\nNEXT_COMMAND: /opsx-projectize\n```\n\n### Write boundary (orchestrator)\n\n**Parent never stages, commits, or amends.** Git writes belong exclusively to:\n\n- `/opsx-commit` (product / OpenSpec / non-process)\n- `/opsx-meta-commit` (process surfaces)\n\nParent may only: parse tokens, launch Task subagents, forward args, serialize\nchild-GO, and print a SUMMARY.\n\n---\n\n---\ndescription: \"Orchestrate /opsx-commit + /opsx-meta-commit: parallel plan Tasks (inherit), then serial child-GO; one SUMMARY.\"\nargument-hint: \"[ALL] [FAST_CHECK|FULL_CHECK] [INCLUDE_FULL_DIRTY_TREE] GO [optional context]\"\n---\n\n# /opsx-commit-all\n\nDual-lane commit orchestrator for the WB Sky / Poetry target.\n\n**Purpose:** one Owner slash runs both commit authorities without merging their\nownership, without parallel git writers, and with a single human-facing report.\n\n**Named dependencies (exact paths — may Read):**\n\n- `.cursor/commands/opsx-execution-preflight.md`\n- `.cursor/commands/opsx-commit.md`\n- `.cursor/commands/opsx-meta-commit.md`\n\nFollow exclusive-active-command: this turn’s PRIMARY is `/opsx-commit-all`.\nChild command bodies are executed only inside Task subagents (each child is\nPRIMARY of its own Task turn). Do not merge child Steps into the parent turn.\n\n## Default behavior\n\nBy default (no lane filter tokens), run **both** lanes:\n\n1. `LANE_PRODUCT` → `/opsx-commit`\n2. `LANE_PROCESS` → `/opsx-meta-commit`\n\nOptional future filters are out of scope for v0.1 unless Owner later designs them.\n\n## Critical naming note\n\nCommand name `opsx-commit-all` does **not** imply child mode `ALL`.\n\nChild `ALL` / `FAST_CHECK` / `FULL_CHECK` / `INCLUDE_FULL_DIRTY_TREE` apply\n**only** when those exact tokens appear in this command’s `{{arguments}}`.\n\n## Tokens\n\nParse case-sensitive tokens from `{{arguments}}`:\n\n| Token | Effect |\n|---|---|\n| `GO` | Authorizes **serial child-GO** after plans (parent still does not git-write) |\n| `ALL` | Forwarded to both children (product lane still needs static-check FULL receipt when that child requires it) |\n| `FAST_CHECK` / `FULL_CHECK` | Forwarded as child check mode |\n| `INCLUDE_FULL_DIRTY_TREE` | Forwarded as child scope token |\n\nAll other non-orchestrator tokens that belong to the child argument contracts\nare forwarded **identically** to both lanes (same string), except `GO` handling\nbelow. Owner `MODEL=<slug>` override is **deferred** (see\n`.cursor/pipeline/shared/MODEL_DISPATCH.md`).\n\n### GO handling (mandatory)\n\n```text\nPARENT_HAS_GO: yes | no\nPLAN_ARGS: {{arguments}} with exact token GO removed\nEXEC_ARGS: PLAN_ARGS + exact token GO\n```\n\n- Plan Tasks always receive `PLAN_ARGS` (**never** `GO`).\n- Execute Tasks receive `EXEC_ARGS` only when `PARENT_HAS_GO=yes`.\n- If `GO` is absent: plan both lanes, print SUMMARY, stop (no execute Tasks).\n\n## Child model (inherit only)\n\nAuthority: `.cursor/pipeline/shared/MODEL_DISPATCH.md`\n\n```text\nRESOLVED_CHILD_MODEL: inherit\n```\n\nEvery plan and execute Task MUST pass `model: inherit` (explicit — never omit,\nnever `auto`, never mini/premium slug fallback).\n\nOwner `MODEL=<slug>` override — deferred until Owner enables registry-backed\nslug routing via a separate fix-defects packet.\n\n`subagent_type`: `generalPurpose` (children must Read contracts + run git).\n\n## Phase machine\n\n### 0) Preflight\n\n- Projectization gate (above).\n- Confirm child command files exist.\n- Do **not** run unbounded dirty-tree inventories in the parent; children own\n their preflight under execution-preflight budgets.\n\n### 1) Parallel PLAN fan-out (mandatory)\n\nLaunch **two** Task subagents in the **same** parent turn (parallel):\n\n```text\nTASK_A:\n PRIMARY: /opsx-commit\n ARGS: PLAN_ARGS\n MODEL: inherit (mandatory explicit)\n PROMPT_MUST:\n - Read and follow .cursor/commands/opsx-commit.md as PRIMARY\n - Treat ARGS as {{arguments}} (no GO)\n - Plan only: no stage/commit/amend\n - Return the child’s normal no-GO plan report verbatim at the end\n\nTASK_B:\n PRIMARY: /opsx-meta-commit\n ARGS: PLAN_ARGS\n MODEL: same as TASK_A\n PROMPT_MUST: analogous for .cursor/commands/opsx-meta-commit.md\n```\n\nDo not wait for Owner between the two plan launches.\n\n### 2) Serial EXECUTE (only if PARENT_HAS_GO)\n\n**Child remains the git writer.** Parent never applies the plan itself.\n\nAs each plan Task completes successfully with an actionable in-scope plan\n(not pure `OUT_OF_SCOPE_REDIRECT` / empty / hard `BLOCKED` that forbids GO):\n\n1. If an execute Task is already running → wait for it to finish (serialize).\n2. Launch exactly one execute Task for that ready lane with `EXEC_ARGS`.\n3. Prompt MUST:\n - Read/follow the same child command file as PRIMARY\n - Treat `EXEC_ARGS` as `{{arguments}}` (includes `GO`)\n - Prefer executing the plan just produced for this lane (attach plan text)\n - Still obey all child gates (receipt, protected branch, matrices, scope)\n4. When that execute finishes, start the next ready lane’s execute (if any).\n\n**Owner-visible wait identity (mandatory — CA-WAIT-OPAQUE):** before launching\nan execute Task, and again whenever the parent is blocked waiting for a running\nexecute Task to finish, emit exactly one progress block (plain text, not silent):\n\n```text\nLANE_WAIT: parent=/opsx-commit-all waiting_for=<LANE_PROCESS|/opsx-meta-commit | LANE_PRODUCT|/opsx-commit>\nOWNER_AWAITED: no\nNEXT_LANE_AFTER: <LANE_PRODUCT|/opsx-commit | LANE_PROCESS|/opsx-meta-commit | none>\n```\n\nDo **not** imply Owner/gate wait during serial execute serialization. Owner is\nnot awaited between plan fan-out and serial child-GO (plans already authorized\nby parent `GO`).\n\n**As-ready order:** first successfully planned actionable lane executes first;\nthe second waits. If both plans are ready before either execute starts,\nprefer order: `LANE_PROCESS` then `LANE_PRODUCT` (stable default).\n\nIf a lane’s plan is non-actionable (clean / out-of-scope only / blocked):\n\n```text\nLANE_EXECUTE: SKIPPED\nLANE_SKIP_REASON: <from child plan>\n```\n\nDo not invent commits for skipped lanes.\n\n### 3) Fan-in SUMMARY (mandatory)\n\nAlways print a parent SUMMARY after plan phase (and after execute phase when\n`GO` was present), even when a lane skipped or failed.\n\n## Authority rules\n\n```text\nAUTHORITY:\n- /opsx-commit owns product grouping, staging, checks, commits\n- /opsx-meta-commit owns process grouping, staging, checks, commits\n- /opsx-commit-all owns orchestration + SUMMARY only\n\nFORBIDDEN_FOR_PARENT:\n- git add / git commit / git commit --amend\n- re-grouping files across lanes\n- overriding child BLOCKED / FAIL / receipt gates\n- launching /opsx-static-check (product child may only recommend it)\n- treating command name as child ALL\n- inventing npm / vue-npm gates on this Poetry target\n```\n\n## Failure behavior\n\n| Situation | Parent status | Action |\n|---|---|---|\n| Plan Task errors / times out | `BLOCKED` or `PARTIAL` | Do not execute that lane; continue other lane plan/execute rules |\n| Execute Task fails child gate | `PARTIAL` / `BLOCKED` | Surface child report; do not retry silently more than once |\n| `index.lock` / git lock on execute | one serial re-dispatch of **that** lane only | Then stop that lane if still failing |\n| Both lanes skipped | `COMPLETE_NOOP` | SUMMARY explains clean/out-of-scope |\n| Parent args missing required child receipt under forwarded `ALL` | child blocks product lane | Parent surfaces; may still run process lane |\n| Execute child `COMMITTED` but parent interrupted / Task delivery lost before SUMMARY or next-lane launch | `PARTIAL` | Recover child status from transcript and/or `git log`; print SUMMARY with known lane results; **do not** re-dispatch a lane whose planned groups are already committed; resume only remaining actionable lane |\n\nNever mark parent `COMPLETE` if any execute was attempted and failed without a\nsuccessful child commit report for that attempted lane — use `PARTIAL` or\n`BLOCKED`.\n\n## Recovery\n\n- Re-run `/opsx-commit-all` with same tokens, or\n- Run the failed child alone (`/opsx-commit` or `/opsx-meta-commit`).\n\n**Interrupt after child COMMITTED (mandatory — CA-INTERRUPT-RECOVERY):**\n\n1. If a child execute report is recoverable (Task transcript `STATUS: COMMITTED`,\n or `git log` shows the planned group SHAs / process or product tree clean for\n that lane’s planned files) → treat that lane as `EXECUTE=COMMITTED` / SKIPPED\n on re-dispatch — **never** re-commit the same planned groups.\n2. Parent MUST still attempt a fan-in SUMMARY with whatever lane results are\n known (`COMMITTED` / `PARTIAL` / interrupted / not started).\n3. `NEXT_ACTION` must name the **remaining** actionable lane only, e.g.\n `/opsx-commit ALL GO` (process already done) or `/opsx-meta-commit ALL GO`\n (product already done), or `/opsx-commit-all ALL GO` with the completed lane\n marked SKIPPED in the parent prompt context.\n4. Do not invent a full dual-lane re-run that would duplicate already-landed\n commits.\n\n## Final report (parent)\n\n```text\nSTATUS: PLAN_READY | COMPLETE | COMPLETE_NOOP | PARTIAL | BLOCKED | FAIL_CLOSED\nMODE: PLAN_ONLY | PLAN_THEN_SERIAL_GO\nPARENT_HAS_GO: yes | no\nFORWARDED_PLAN_ARGS: ...\nFORWARDED_EXEC_ARGS: ... | n/a\nCHILD_MODEL: inherit\nCHILD_MODEL_FALLBACK: none\nWHAT_HAPPENED:\nWHY:\nCURRENT_STATE:\nLANES:\n- LANE_PROCESS: PLAN=... EXECUTE=... | SKIPPED | n/a\n- LANE_PRODUCT: PLAN=... EXECUTE=... | SKIPPED | n/a\nCHILD_REPORTS:\n### LANE_PROCESS\n<verbatim or condensed child final report>\n### LANE_PRODUCT\n<verbatim or condensed child final report>\nOWNER_DECISION_REQUIRED: yes | no\nNEXT_ACTION:\nDO_NOT_DO_YET: push; parent git-write; assume ALL from command name\nORIENTATION_HINT:\n LANE: META | PRODUCT\n NEXT_META: /opsx-meta\n NEXT_ACTION:\n```\n\n### NEXT_ACTION rules\n\n- `PLAN_ONLY` success → `NEXT_ACTION: /opsx-commit-all GO` (same other tokens)\n- `COMPLETE` → usually `none` (or child-surfaced follow-ups if any remain dirty)\n- Product blocked on static-check receipt → recommend `/opsx-static-check FULL` then re-run with `ALL GO` if `ALL` was requested\n- Process-only leftovers after product success → `/opsx-meta-commit` (should be rare if both lanes ran)\n\n## When to use\n\n- Mixed dirty tree (product + process) after a work session\n- Owner wants one slash + one SUMMARY instead of two manual commit commands\n\n## When not to use\n\n- Debugging a single lane’s commit contract\n- Redesigning commit ownership (→ `/opsx-meta-design-command` / fix-defects)\n- Expecting parent to commit “from plans” without children (forbidden)\n\n## Absolute prohibitions\n\n- Parent git writes\n- Parallel execute Tasks (plans may be parallel; GO executes are serial)\n- Explicit non-inherit Task model (`auto`, mini, premium slug)\n- Committing process files via product child or product via process child\n- Push / PR / rebase / force from this command\n- Seeding or requiring `vue-npm` / `npm run build` on this target\n\n## TARGET ADAPTATION NOTES\n\n- active_name: `/opsx-commit-all`\n- children: `/opsx-commit`, `/opsx-meta-commit`\n- pattern: parallel plan + serial child-GO (option B; not parent-writer)\n- child_model: `inherit` explicit (`.cursor/pipeline/shared/MODEL_DISPATCH.md`)\n- target: WB Sky / Poetry (`opsx-lite` + `poetry-python`)\n- donor: game/go-to-prod occurrence `ac2a8c0791763d3f` @ `5ddca9a94f6d87176c64f888511996009f59bedc`\n- companions (external): registry activation, `/opsx-meta` router, pipeline GRAPH\n → `/opsx-meta-fix-command-defects` if desired; not required for MVP runtimelocal_modification_note: \"Imported 2026-08-08 via /opsx-meta-import-command KEEP=opsx-commit-all; GAME→WB remap; vue-npm dropped; poetry-python; children /opsx-commit + /opsx-meta-commit\"\ndescription: \"Orchestrate /opsx-commit + /opsx-meta-commit: parallel plan Tasks (mini→auto), then serial child-GO; one SUMMARY.\"\nargument-hint: \"[ALL] [FAST_CHECK|FULL_CHECK] [INCLUDE_FULL_DIRTY_TREE] [MODEL=<slug>|MODEL=auto] GO [optional context]\"\n| `MODEL=<slug>` | Force child Task model (`auto` = host Auto / omit model) |\n| `MODEL=auto` | Explicit Auto fallback (same as FALLBACK_CHILD_MODEL) |\nStrip `MODEL=*` from forwarded child args (orchestrator-only token). All other\nnon-`MODEL=*` tokens that belong to the child argument contracts are forwarded\n**identically** to both lanes (same string), except `GO` handling below.\nPLAN_ARGS: {{arguments}} with exact token GO removed and MODEL=* stripped\n## Child model (mini default, auto fallback)\nDEFAULT_CHILD_MODEL: gpt-5.4-mini-high\nFALLBACK_CHILD_MODEL: auto\nResolution order:\n1. If `MODEL=<slug>` present (including `MODEL=auto`) → use that as\n `RESOLVED_CHILD_MODEL`.\n2. Else try Task `model` = `DEFAULT_CHILD_MODEL` (`gpt-5.4-mini-high`).\n3. If mini is **not** in the live Task allowlist, or the Task launch fails\n with a model-unavailable / invalid-model error → **one** retry with\n `FALLBACK_CHILD_MODEL: auto`:\n - omit the Task `model` parameter, or pass host-equivalent Auto / `inherit`\n if the live API requires an explicit token;\n - report `CHILD_MODEL_FALLBACK: auto` in SUMMARY.\n4. Do **not** silently upgrade to an explicit premium / high-tier slug.\n5. Owner `MODEL=<invalid>` that is neither allowlisted nor `auto` →\n `FAIL_CLOSED` / `BLOCKED_INVALID_MODEL` (no invent).\n## Child Task clocks (mandatory — hang prevention)\nEmpty clocks on any child Task launch are a **contract violation**.\nUnbounded sync wait is forbidden (mirror supervisor §12.0 ordinary-writer /\nheavy-writer classes).\n### PLAN Task defaults (each of TASK_A / TASK_B)\nTIMEOUT_SECONDS=1800\nHEARTBEAT_INTERVAL_SECONDS=120\nNO_PROGRESS_TIMEOUT_SECONDS=600\nSTOP_ACK_TIMEOUT_SECONDS=60\n### EXECUTE Task defaults (each serial GO child)\nTIMEOUT_SECONDS=3600\nHEARTBEAT_INTERVAL_SECONDS=180\nNO_PROGRESS_TIMEOUT_SECONDS=900\nSTOP_ACK_TIMEOUT_SECONDS=120\nOnly **stricter** (smaller) values are allowed without Owner timebox.\nMap into Task launch metadata / prompt footer as `TIMEOUT` /\n`HEARTBEAT_INTERVAL` / `NO_PROGRESS_TIMEOUT` / `STOP_ACK_TIMEOUT`.\n### Task wait discipline (HARD — false-hang prevention)\nPlatform Task completion arrives as a **Task completion notification**, not\nvia shell tools. Parent MUST NOT invent a busy-wait that never wakes.\nFORBIDDEN_WHILE_WAITING_ON_TASK_CHILDREN:\n- AwaitShell (does not receive Task completion notifications)\n- Shell sleep / sleep loops\n- polling subagent transcript files as a wait strategy\n- any in-turn busy-wait after background Task launch\nAWAIT_SHELL_TIMEOUT_IS_NOT_CHILD_HANG=YES\nSILENCE_PLUS_SHELL_SLEEP_IS_NOT_HANG_PROOF=YES\n**Background mode** (`run_in_background=true`):\n1. Launch child Task(s) with clocks filled.\n2. Print `OWNER_VISIBLE_DISPATCH` including that progress resumes **only**\n on platform Task completion notification.\n3. **End the parent turn immediately** — no further tool calls that wait.\n4. On completion notification: resume that lane immediately; do not re-PLAN\n blindly; do not treat prior silence as hang.\n**Sync mode** (`run_in_background=false`): allowed with clocks filled; result\nreturns in-turn. Prefer sync for **serial EXECUTE** when `PARENT_HAS_GO=yes`\nso the parent can chain without notification dependency.\nParallel PLAN fan-out may still use background; after both plan\nnotifications land, start EXECUTE per §2 (prefer sync).\n### OWNER_VISIBLE_DISPATCH (before every child launch)\nIn the same parent turn, before launching a PLAN fan-out or an EXECUTE\nTask, print:\nOWNER_VISIBLE_DISPATCH:\n COMMAND: /opsx-commit | /opsx-meta-commit\n LANE: LANE_PRODUCT | LANE_PROCESS\n PHASE: PLAN | EXECUTE\n EXPECTED_WALL_CLOCK_SECONDS: # from clocks above\n NO_PROGRESS_TIMEOUT_SECONDS:\n INTERRUPT_POLICY: interrupt=true on timeout/hang when platform allows\n WAIT_MODE: background_end_turn | sync_in_turn\n SILENCE_NOTE: silence until NO_PROGRESS is not proof of hang; after\n NO_PROGRESS parent must TIMEOUT/PAUSED that lane;\n AwaitShell/shell-sleep is FORBIDDEN and is not hang proof;\n background mode resumes only on Task completion notification\n### Platform abort / interrupt / empty envelope\nIf a child Task ends as `aborted` | `interrupted` | `tool_error` | empty /\nmissing envelope **without** an accepted plan or commit report:\nLANE_STATUS: PAUSED | PARTIAL\nDISPOSITION: EXECUTION_OUTCOME_UNKNOWN\nADVANCE: FORBIDDEN for that lane\nBLIND_REPLAY: FORBIDDEN\nParent SUMMARY must include a pasteable resume of the **same** primary\n(`/opsx-commit-all` with same tokens, or the failed child alone) with\n`ATTEMPT+1` only when idempotent; else Owner reconcile. Do not treat the\nlane as planned/committed.\nPrint `OWNER_VISIBLE_DISPATCH` for both plan lanes (may be one combined\nblock). Then launch **two** Task subagents in the **same** parent turn\n(parallel) with PLAN clocks filled:\n MODEL: RESOLVED_CHILD_MODEL (mini → auto fallback rules)\n TIMEOUT / HEARTBEAT / NO_PROGRESS / STOP_ACK: PLAN defaults\n - Obey opsx-execution-preflight TIME_BUDGET; on timeout return\n blocked_preflight_timeout — do not hang\n TIMEOUT / HEARTBEAT / NO_PROGRESS / STOP_ACK: PLAN defaults\n (including preflight budgets / blocked_preflight_timeout)\n1. If an execute Task is already running → serialize: do not launch a second\n execute; resume only when the running execute’s Task completion\n notification (or sync return) arrives. Never AwaitShell / sleep-poll.\n2. Print `OWNER_VISIBLE_DISPATCH` for that lane’s EXECUTE\n (`WAIT_MODE=sync_in_turn` preferred).\n3. Launch exactly one execute Task for that ready lane with `EXEC_ARGS`\n and EXECUTE clocks filled. **Prefer `run_in_background=false` (sync)**\n so the result returns in-turn. If background: end turn immediately;\n continue on Task completion notification only.\n4. Prompt MUST:\n - Obey opsx-execution-preflight TIME_BUDGET; return\n `blocked_preflight_timeout` rather than hang\n5. When that execute finishes, start the next ready lane’s execute (if any).\nthe second waits (notification- or sync-serialized — never shell-wait).\nIf both plans are ready before either execute starts, prefer order:\n`LANE_PROCESS` then `LANE_PRODUCT` (stable default).\n`GO` was present), even when a lane skipped or failed. Include any\n`EXECUTION_OUTCOME_UNKNOWN` / pasteable resume lines for interrupted lanes.\n| Plan Task errors / times out (clocks exceeded) | `BLOCKED` or `PARTIAL` | Do not execute that lane; continue other lane plan/execute rules |\n| Plan/Execute `aborted` / `interrupted` / empty envelope | `PARTIAL` / `PAUSED` | `EXECUTION_OUTCOME_UNKNOWN`; no ADVANCE that lane; pasteable resume |\n- Re-run `/opsx-commit-all` with same tokens (after `EXECUTION_OUTCOME_UNKNOWN`,\n only with explicit Owner resume / ATTEMPT+1 — no blind replay), or\n- On confirmed", "variables": [ "arguments" ], "notes": "Read `.opsx/projectization.yaml` before any write-bearing child dispatch. If `status` != `COMPLETE` or `normal_commands_enabled` is false:", "metadata": { "source": { "provider": "github-cursor-commands", "repository": "https://github.com/revoluxe-ai/adv-bot", "path": ".cursor/commands/opsx-commit-all.md", "ref": "a3415e97d3efd474784b1bfd5e44bbd92672ddf5", "url": "https://github.com/revoluxe-ai/adv-bot/blob/a3415e97d3efd474784b1bfd5e44bbd92672ddf5/.cursor/commands/opsx-commit-all.md", "key": "revoluxe-ai/adv-bot/.cursor/commands/opsx-commit-all.md" } } }