К основному содержанию
скилл CX Codex

qgo · ai4xe, claude-code — скилл для Claude Code: передача задач и установка

Скилл для Claude Code переводит обсуждение задачи в план и передачу на автономное выполнение. Запускается по команде qgo или при явной передаче задачи в обсуждении Q.

MIT ★ 136 обновлён 2026-11-16

Установить в Claude Code · Через маркетплейс плагинов Все способы и платформы ↓
/plugin marketplace add AI4XE/Parallax
/plugin install parallax@parallax
Открыть на GitHub

Что делает qgo

qgo проверяет требования из обсуждения, составляет план и отправляет его на независимую проверку через bcheck. После PASS≥4 скилл передаёт задачу исполнителю через gclear. По умолчанию исполнитель работает самостоятельно; в командном режиме отдельный оркестратор следит за его запуском и состоянием.

Исполнитель выполняет задачу, проверяет результат, коммитит изменения и готовит итоговый отчёт. Оркестратор отвечает за запуск, подачу задач, остановку и восстановление. Для работы нужны Claude CLI, скиллы bcheck, gclear, rcheck и xwrap, а также средства хоста для надзора и планирования. Командный режим дополнительно требует Python 3.11+ и claude в PATH.

На macOS без /proc проверка рабочего каталога использует lsof; если состояние процесса нельзя определить, скилл завершает проверку безопасно, не считая процесс остановленным.

Какие задачи решает

  • перевести обсуждение задачи в проверяемый план
  • передать согласованную задачу на автономное выполнение
  • разделить работу исполнителя и контроль оркестратора
  • зафиксировать проверку, коммиты и итоговый отчёт исполнителя

Примеры запросов агенту

  • Запусти qgo и передай задачу из обсуждения на выполнение.
  • Выполни передачу Q-задачи по этому обсуждению.
  • Подготовь план и запусти автономное выполнение задачи.

Как установить qgo

1Через маркетплейс плагинов

/plugin marketplace add AI4XE/Parallax
/plugin install parallax@parallax

Команда ставит плагин parallax целиком, со всеми его скиллами

2Через Skills CLI (Vercel)

npx skills add AI4XE/Parallax --skill qgo -a claude-code

3Вручную: положить файлы

~/.claude/skills/qgo/SKILL.md

Папка скилла целиком; для одного проекта — .claude/skills/qgo/

По шагам, с командами для каждой платформы: Как установить скилл в Claude Code: пять способов

Вопросы о qgo

Как установить qgo в Claude Code?

Добавь маркетплейс командой /plugin marketplace add AI4XE/Parallax, затем установи плагин командой /plugin install parallax@parallax.

Что делает qgo?

Скилл превращает обсуждение Q-задачи в проверенный план и передаёт его автономному исполнителю. В командном режиме оркестратор отдельно контролирует запуск и восстановление исполнителя.

Что нужно для работы qgo?

Нужны Claude CLI, скиллы bcheck, gclear, rcheck и xwrap, а также средства хоста для надзора и планирования. Командный режим требует Python 3.11+ и claude в PATH.

Исходный текст

SKILL.md · MIT
---
name: qgo
description: "Q workflow hand-off execution: re-check the discussion → plan → independent bcheck → gclear → hand-off session executes autonomously (solo by default), or a clean orchestrator supervises an independent stream-json executor (D backend, explicit team). infra/hotfix share rcheck; the executor owns verification, commits, xwrap and the final receipt; the orchestrator exclusively owns start, feed, stop and recovery. Trigger words: qgo, Q hand-off development."
user_invocable: true
portable: true
version: 2.0.1
display_lang: en
---

# qgo — Hand-off execution

The user explicitly saying qgo, or an explicit hand-off in the Q discussion, authorizes progress without repeated confirmation. Read the exact discussion anchor for this run and the current requirement; do not guess ownership from "the most recent file". infra (non-version) and hotfix (version) share the backbone below; respect an explicit user instruction to use another flow. This skill ships its own protocol, templates and read-only helpers; do not read other discussion/hand-off skills or host-private scripts to fill in the logic.

Runtime prerequisites: Claude CLI, the shared bcheck/gclear/rcheck/xwrap skills, and host supervision/scheduling capability. The team tier additionally needs Python 3.11+ (tomllib) and `claude` on PATH. Platform prerequisites: Linux / WSL / macOS behave the same; process liveness and identity checks uniformly use the system `ps` (`scripts/proc_compat.py`). On macOS without `/proc`, `cwd` uses the bundled `lsof`, and when the target `environ` is unreadable infer from "this process's `CLAUDE_CONFIG_DIR` → `~/.claude`"; whenever liveness cannot be determined, fail closed (driver exit 3 / status reports `process_state=unknown`) and never assume dead. Before use, check whether the skill has an applicable `local/LOCAL.md`; if so, reuse it first. Display language priority: trigger-message language > explicit user instruction (e.g. "use English" takes effect immediately) > the frontmatter `display_lang` field default; for a bare command with no language signal, read this file's frontmatter `display_lang` value before replying and use it as the default display language.

**Core design constraint**: the executor never clears or closes itself; context reset, close and recovery are performed exclusively by the orchestrator with exact identity checks and double verification. The executor only writes hand-off notes and the completion receipt. Lightweight first: do not build heavy machinery for the last 1%.

## 1. From discussion to reviewed plan

1. Re-check the discussion's complete overview, the user's latest requirements, and unresolved contradictions. Proceed autonomously when there are none; for contradictions that still need user judgment, ask one question at a time with options, a recommendation and a brief reason. Do not re-interrogate settled directions.
2. Lock mode, host/Git root, task root, actual version source and sync points, target version, document and commit ownership. Use the overview and the user's latest explicit instruction; never silently change the type by re-inferring. infra does not bump versions artificially; hotfix updates in sync with the project's actual version source.
3. Write the detailed analysis, execution plan and checklist, citing the exact discussion. If the directory does not exist, create it with `mkdir -p`. By default infra uses host `docs/dev/infra/infra-plan-{discussion-timestamp}.md` and hotfix uses `docs/dev/hotfix/v{target-version}-analysis.md`; existing project conventions take precedence. If a same-named document exists, verify ownership first, do not overwrite other tasks, and use a project/task suffix compatible with the original glob if needed. Must include: goals/scope/completion criteria, rationale and plan, real verification, affected modules, pre-test cleanup, protection of existing dirty state, risks, **independent rcheck before commit**, executor-side xwrap, **reference context** (for a clean session), and the boundary of **executor self-clear prohibition and orchestrator-exclusive hand-off**. Put necessary differences in task material; do not copy the whole plan into a template.
4. Invoke **Skill bcheck**, following that skill's independent model, rounds and scoring rules; continue only on **PASS≥4**. Respond to each concern and re-review after fixes. Do not mistake plan review for implementation verification.
5. Weave personalized instructions appended at the call tail or during the process into the plan and hand-off; they stack on the core and do not replace gates. Neither task type introduces pre-splitting, hcheck, dcheck or Ralph.

## 2. The orchestrator's own hand-off

After bcheck passes, write the exact path of `templates/orchestrator.md` and refined task context into the shared gclear's existing hand-off carrier, and make the hand-off prompt state explicitly that the template must be read first and is the role authority, not replaced by a summary; the context includes the approved plan, exact anchors, user decisions, current stage, actual identity/recovery information and necessary environment. **For the team tier, the hand-off contract explicitly includes the running executor state**: executor id, `tmp/qgo/<ID>/` path, latest status summary (sid/state/ctx_used/last_event), task progress, completion path, recovery command. Do not carry the full planning history into long-lived orchestration.

Actually invoke **Skill gclear** and construct one hand-off prompt. Confirm through the shared tool that the SID truly changed and the prompt was submitted; do not treat merely launching another window as the main session having been cleared. The first action after hand-off is `sweep` + `status` to verify any existing executor; if one exists, continue supervising and do not start another. **This is the orchestrator's own hand-off and is a different thing from the executor hand-off; the executor never calls gclear.**

In solo (the default tier), this step still calls gclear, but the carrier is rewritten with the exact path of `templates/solo.md` and refined executor context (role authority = solo.md; do not read orchestrator.md). The hand-off session is itself the executor; there is no orchestrator.

## 3. Independent executor

Combine `templates/executor.md` with a **redacted task brief** (task and scope, checklist, acceptance criteria, mode/version source, root and artifact contract, exact executor and orchestrator identities, current task, allowed commit scope, completion and handoff paths, environment notes) into the initial task content: first write `<root>/tmp/qgo/<ID>/task.md`, then deliver a pointer and the initial instruction via the driver's `feed`. Do not feed the full orchestration plan containing lifecycle and mechanism sections. The executor is the one doing the work, not a monitor; it must not mistake its own launcher for another executor.

- The executor autonomously completes: implementation → real-environment verification → **Skill independent rcheck** (PASS≥4; fix and re-review issues) → scoped local commit → **Skill xwrap** to finish todo/wrapup and its necessary commits → final receipt. Skip xwrap only on an explicit user opt-out, and state that in the receipt.
- When invoking xwrap, specify the exact host/Git root, task root, mode/actual version source, discussion/plan, and this run's artifacts/hunks, so it does not mix in other tasks through its default root or whole-file adds. On continuation, inject the commit candidate list; all of xwrap's ask-user branches (Step 1, Step 4, Step 6, 7.2, 7.3, 7.4, 7.5) are decided autonomously by the executor according to the injected contract and hand-off notes without waiting for the user, and each decision and its rationale is listed in the receipt.
- Write the final receipt to the orchestrator-provided `tmp/qgo/<ID>/completion/completion-<QGO_EXECUTOR_ID>.md`: completed tasks, verification evidence, commit list, xwrap decisions, deviations/outstanding verification. After the receipt is written, end the turn normally and leave the process idle.
- Hand-off duty: when reminded, finish the current unit first or reach a stage completion point; write "everything necessary and required to continue the task" to the specified note path; make a handoff checkpoint commit and put the SHA in the note; reply `READY-FOR-HANDOFF <SHA>` (visible via the event stream). If unsafe, continue rather than force a hand-off.
- **Question discipline**: the executor does not block waiting for a human — decide and record autonomously per the contract where possible; write issues that must be surfaced into the report/completion (pending decision + recommended options + rationale) and continue with the unblocked parts; the orchestrator sees its output and can feed guidance at any time.
- Executor-visible text must not contain `/clear`, `/exit`, gclear or other mechanism names or operating methods, nor a list of prohibitions; constraints are enforced by the orchestrator template and the operational layer. **Do not disclose context percentages, thresholds, monitoring or self-check details.**

## 4. Session operations and isolation (D backend driver)

The team executor's only operating surface is this directory's `scripts/executor_driver.py` (interpreter chosen per gclear convention; `claude` resolved only from PATH): six subcommands `start`/`status`/`feed`/`stop`/`resume`/`sweep`, with all coordination state under `<root>/tmp/qgo/<ID>/` (`state.json` atomic writes, `events.log` event stream, `stdin.fifo` single-writer frame protocol, `executor.pid`/`pump.pid`, `task.md`, `completion/`). `scripts/session.py` remains as read-only corroboration primitives (`confirm` verifies injection adoption; `identity`/`idle` for corroboration), and `scripts/context.py` reads only the orchestrator's own context usage; neither controls processes or decides stages/completion. Run with a Python suitable for the host; do not depend on a specific environment name.

- **Carrier**: the executor is a headless claude process with `--output-format stream-json --input-format stream-json --verbose` (no `-p`) + `--setting-sources project,local` + a permission mode (see below) + `--strict-mcp-config --mcp-config <filtered business MCP>` + `--disallowedTools "Skill(gclear)"`; both executor and pump run as independent setsid sessions fully decoupled from the orchestrator process (orchestrator clear/exit has zero impact).
- **Hard tier restriction**: only `bypassPermissions` (preferred, with the two harmless booleans `skipDangerousModePermissionPrompt`/`promptSuggestionEnabled:false`) or `dontAsk`+`--allowedTools` allowlist (strict hosts); `default`/`acceptEdits`/`plan` are always refused at start — the driver has no permission-prompt control protocol, and interactive modes would hang forever. Use the permission mode the user already authorized; do not escalate, and do not substitute "hand-off" for human permission approval.
- **Isolation (guaranteed by construction in the driver)**: the executor env is inherited minus `TELEGRAM_*`, `*_BOT_TOKEN`, `*_SESSION_DRIVER` (wildcard), `CC_SESSION_KEY`, `CLAUDE_CODE_SESSION_ID`, `TMUX`/`TMUX_PANE`, and host `ANTHROPIC_*`, and with `QGO_EXECUTOR_ID` injected (the marker that makes gclear 1.2.4 mechanically reject executor contexts); provider/model routing comes from the target project's settings.local.json env block, consistent with upstream. Business MCP is filtered from the target `.mcp.json` by removing messaging servers (`telegram|cc-connect|ccgram|feishu|wechat|slack|discord`) and written to the state directory for `--mcp-config`. Do not modify shared settings, old scripts or plugin source; do not read or borrow other projects' `.env`, settings or credentials.
- **Start acceptance (idempotent and retryable)**: `start` waits for readiness — the first event in the event stream + parsing sid/version from `~/.claude/sessions/<executor_pid>.json` (interactive stream-json does not emit `system/init`; that file is the authoritative identity source) — and returns `{ok, sid, model, version}` (model is filled in by status after the first turn). Passing requires sid/version present + state leaving `starting`, replacing the old tmux eight assertions. On timeout, fail and stop (exit 3); inspect `executor.stderr.log`/`pump.log` to locate the cause (missing claude on PATH / fake claude both produce clear errors); do not degrade to another carrier.
- **Feed and exit**: prompts/guidance/user adjustments all go through `feed` (single-writer serial, JSON line frames, embedded newlines escaped; for large text write task.md first and feed a pointer). Check adoption via `status`'s `last_event` becoming `user`/`assistant` or the event-stream marker (use `session.py confirm` by sid for exact corroboration when needed). Close = the orchestrator's `stop` (stdin EOF → grace → SIGTERM → SIGKILL ladder); never send an exit instruction to the executor and never routinely SIGKILL.

## 5. Orchestrator supervision in practice

Perform duties per `templates/orchestrator.md`. Immediately after start, establish a background watcher the host can actually execute (polling the driver's `status` JSON), with **event-driven wake-up**: any of `done`/`failed`/`crashed`/`blocked`/`orphaned`/staleness beyond the threshold (`last_event_age_seconds`, default 600s, adjusted to the task pace) → the watcher exits → the orchestrator is woken early by the host (executor finishing early = early wake-up, no waiting for the heartbeat). Record the trigger identifier, ownership, next check and notification time in the existing hand-off body; saying "I will check periodically" alone does not count as establishing it, and a failure must preserve a valid follow-up trigger.

- **Attention model**: the orchestrator **does not read the executor's full event stream** (to avoid filling its own context) — normally it reads only the `status` JSON summary to judge "working / idle / stalled (age over threshold)"; details stay in `events.log`/`executor.stderr.log`, queried by event type when needed, never read in full.
- **Executor context visibility**: `status.executor_ctx_used` (derived from event-stream usage) is the executor's context usage, with the denominator from the same ladder below; watch at 55%, pick a safe point at 60% for the template §3.1 "restart + hand-off document", and usually do not let it exceed 70%. The task contract may explicitly override the threshold/denominator (e.g. to speed up testing); managed-file defaults stay unchanged.
- **Orchestrator's own context ratio (the 1.0.1 ladder rule is unchanged)**: the denominator follows an explicit ladder: ① the model context size the orchestrator confirms itself (confirmation means: model spec/official docs/explicit user statement/host readings if a host has an xcontext-like skill — xcontext is not a dependency of this suite, only an optional host tool; the suite's own `scripts/context.py` already covers usage lookup; if the session window cannot be read, fall back to ②), then explicitly pass `context.py --window-tokens`; ② if truly unconfirmable → fall back to 1,000,000 tokens (auto-compact catches misjudgment: the benign consequence is that percentages under-trigger). **Do not** use `CLAUDE_CODE_AUTO_COMPACT_WINDOW` or any other compact/compression threshold setting as the denominator (compression trigger ≠ window capacity; setting 800k ≠ a model context of 800k, otherwise all trigger points are distorted). Watch own usage at 55%, self-gclear hand-off promptly at 60% (contract includes running executor state), usually not beyond 70%; the ratio is not an authorization to reclaim.
- **Reporting to the user**: default one heartbeat about every 50 minutes (report even without a milestone; milestones/anomalies are reported immediately and count toward and reset that timer; the threshold is verbally adjustable); continue after notifying and do not wait for a reply.
- **Safe point first**: when the executor judges it is not a safe point, it may continue; the orchestrator waits and reminds later, never forcing a hand-off or restart.
- **Abnormal states**: `blocked` should not normally occur under either permission tier; if it appears, inspect events.log at the specific control request; handle `crashed`/`orphaned` per the §6 recovery path; for `failed`, investigate by terminal reason and do not blindly restart to mask it.
- Mid-course user adjustments: update `task.md` first, then convey them accurately via feed; verification, commits and the latest receipt must cover the new requirements. Disclose failures, deviations, skips and outstanding verification transparently; do not duplicate across channels.

## 6. Delivery, follow-up changes and reclamation

The final receipt is bounded by the executor completing xwrap (or an explicit user waiver) and necessary commits; it is not replaced by a business commit, idle state or a completion filename. The main session reports the real result to the user and does not take over project wrap-up.

- **Delivery means close**: once `completion/completion-<ID>.md` exists and contains the xwrap result and commit list, verify the two status evidence points (result event + completion artifact) and then `stop` gracefully **as soon as possible** per template §4; if the receipt is not yet written, feed a reminder first and do not close.
- Record revival information before closing: sid, `tmp/qgo/<ID>/` path, settings/env essentials, recovery command (`resume --id --root --sid <sid>` or "restart + hand-off document"). Keep events.log/transcript/evidence.
- **Follow-up changes and recovery**: for new adjustments, prefer feeding the live executor; if the executor is terminal, first `sweep --root` to inventory the scene, then choose as needed: crash recovery = `resume` (continue the same sid, context preserved; stop a live run first, and re-pass start assertions after resume); context reduction = template §3.1 "restart + hand-off document" (new session). Before injection/recovery, double-check project and task (root, repo identity, task.md, mode); refuse to start on mismatch.
- Reclamation does not delete history. Continue pushing unfinished tasks; close only when truly complete; keep the state directory and event-stream evidence.

## 7. solo tier (default) and team tier (explicit full chain)

Execution tier is **solo by default**; only the explicit `team` keyword (carried in qstart/qgo invocation arguments, or explicitly stated by the user before the hand-off) uses the full orchestrator + D-backend executor chain; mode and tier combine orthogonally.
Flow: §1 runs as usual (bcheck PASS≥4 is not skipped); §2 still calls gclear, but the carrier writes `templates/solo.md`
(executor role, no orchestrator). Thereafter skip §3's orchestrator assembly and completion/handoff machinery, all of §4
(driver start/isolation/acceptance — solo starts no executor process), all of §5 (supervision and context observation), all of §6
(delivery close / follow-up recovery): the hand-off session acts directly as the executor per solo.md — no other session in
this flow can mistakenly kill it, the isolation scenario does not exist, and there is no applicable subject for the
executor self-clear prohibition.

Wrap-up follows executor discipline: implementation → real verification → independent rcheck (PASS≥4) → scoped commit → xwrap → the final
receipt **goes directly to the user** (along the current session channel), without orchestrator relay and without a completion file; after finishing, end the turn
normally and leave the session naturally idle for follow-up work.

solo has no supervision or context observation: when the task is expected to be heavy or clearly grows mid-way, tell the user honestly and suggest switching to the
team full chain rather than forcing it through.

© AI4XE · MIT · AI4XE/Parallax

Похожие скиллы

Каталог скиллов SKILL.md →

Сначала — qgo от других авторов.

qgo AI4XE Проводит задачу через проверку плана, передачу чистой сессии и выполнение. Запускается по запросу qgo или при явной передаче задачи в обсуждении Q. CX Codex +1 ★ 136звёзд репо qgo AI4XE Превращает обсуждение задачи в проверенный план и автономную передачу разработки исполнителю. Запускается после обсуждения, когда направление подтверждено и пользователь пишет qgo или явно передаёт задачу в разработку. CX Codex +1 ★ 136звёзд репо find-skills vercel-labs Скилл find-skills для Claude Code ищет скиллы по задаче и помогает выбрать, что установить. Он включается, когда нужно найти готовую возможность для агента. CX Codex +1 4 400 000установок frontend-design официальный anthropics Скилл frontend-design для Claude Code задаёт осмысленное визуальное направление для новых интерфейсов и редизайна. Помогает уйти от шаблонного UI. CX Codex +1 1 025 790установок agent-browser vercel-labs Скилл agent-browser для Claude Code управляет браузером по запросам на навигацию, заполнение форм и проверку веб-приложений. Агент также может запускать через него исследовательское тестирование и автоматизировать Electron-приложения. CX Codex +1 1 600 000установок design-taste-frontend Leonxlnx Скилл design-taste-frontend для Claude Code задаёт правила оформления и проверки сайтов. Подключается при создании или переделке страницы, а также при просьбе убрать шаблонный вид. CX Codex +1 802 600установок grill-me Matt Pocock Скилл grill-me проводит жёсткое интервью по плану или дизайну, чтобы найти пробелы и уточнить решения. Подойдёт перед началом разработки. CX Codex +1 1 424 476установок grill-with-docs Matt Pocock Скилл grill-with-docs проводит жёсткое интервью по плану или дизайну и по ходу создаёт ADR и глоссарий. Подойдёт перед началом сложной разработки. CX Codex +1 1 219 756установок

Из того же набора19

Весь набор →
xwrap Скилл xwrap для Claude Code завершает этап разработки: проверяет состояние репозитория, обновляет задачи и записывает итог. Запускается по запросу xwrap или wrap up. CX Codex +1 ★ 136звёзд репо rcheck Сверяет результат сложной задачи с планом и отчётом о реализации. Запускается после многошаговых изменений, перед отчётом пользователю, или по запросу на rcheck. CX Codex +1 ★ 136звёзд репо xwrap Завершает разработку: проверяет состояние репозитория, обновляет задачи и записывает итог. Он включается по запросу xwrap или «заверши работу». CX Codex +1 ★ 136звёзд репо bcheck Скилл bcheck для Claude Code независимо проверяет анализ и планы разработки. Запускается после подготовки документа или по запросу на ревью. CX Codex +1 ★ 136звёзд репо bcheck Независимо проверяет анализы причин ошибок и планы изменений. Запускается после подготовки документа, до ответа пользователю, или по запросу bcheck. CX Codex +1 ★ 136звёзд репо bcheck Скилл bcheck для Claude Code независимо проверяет анализ причин ошибок и планы разработки. Его запускают после подготовки документа, до ответа пользователю, или по запросу на ревью плана. CX Codex +1 ★ 136звёзд репо qgo Превращает обсуждение задачи в проверенный план и автономную передачу разработки исполнителю. Запускается после обсуждения, когда направление подтверждено и пользователь пишет qgo или явно передаёт задачу в разработку. CX Codex +1 ★ 136звёзд репо parallax Плагин parallax для Claude Code превращает пожелание в план разработки с независимой проверкой. Агент обсуждает задачу, передаёт её на выполнение и проверяет результат. ★ 136звёзд репо

Спонсоры проекта

Компании, которые помогают держать аналитику открытой