メニュー
Wire the governed runtime into Claude Code agent teams. Classifies work into R1–R5, spawns bounded swarm teams for R3/R4, manages packet execution with reviewer barriers, enforces postflight gates, and sends completion notifications.
デフォルトでは、最初にソースを確認する Prompt が選択されています。直接コマンドに切り替えるか、ローカルコピーをダウンロードすることもできます。
インストールを決める前に、SKILL.md と SkillsMP に表示されている付属ファイルをお読みください。
Codex または Claude でインストール この Prompt をコピーして Codex、Claude、または他のアシスタントに貼り付けると、Skill ページを確認してインストールできます。
直接コマンドでは確認用 Prompt が省略されます。実行前にソースを確認してください。
npx skills add https://github.com/Chaddacus/chad_claude_configs --skill governコマンドは1行のまま表示されます。コピー前に横へスクロールして全体を確認してください。
ローカルで確認しますか？SkillsMP が現在取得できるファイルをダウンロードできます。
Your Codex companion pet — show stats, level progress, pet it, hatch it
Debug live Zoom meeting-agent failures for Rebecca/Bighead. Use when messages are missed, meeting jobs are stuck, transcripts stop, or live triage needs an event tail.
Toolkit for interacting with and testing local web applications using Playwright. Supports verifying frontend functionality, debugging UI behavior, capturing browser screenshots, and viewing browser logs.
SOC 職業分類に基づく
SKILL.md を表示中
| name | govern |
| description | Wire the governed runtime into Claude Code agent teams. Classifies work into R1–R5, spawns bounded swarm teams for R3/R4, manages packet execution with reviewer barriers, enforces postflight gates, and sends completion notifications. |
| effort | high |
| policy_doc_kind | skill |
| classification | canonical |
| canonical_owner | self |
| authority_level | procedural |
| in_verifier_scope | true |
| lexical_guard_profile | stale_names,destructive_rollback,branch_policy_live |
This skill is the runtime interpreter for the route manifest (~/.claude/state/route_manifest.json)
and the enforcer of the canonical 9-phase workflow (~/.claude/standards/WORKFLOW_PHASES.md).
It classifies work, enforces route-specific execution discipline, spawns agent teams for bounded swarms,
and gates closure on convergence and postflight evidence.
Phase mapping: govern's internal phases map to the canonical workflow as follows:
Phase 0 (Memory Retrieval) = WF Phase 3 (Research). Phase 1 (Route Classification) = WF Phase 2
(Classify). Phase 2 (Execute by Route) spans WF Phases 4–9 (Blueprint → Validate), with
/planning-gate owning Phase 5 (Plan) and the orchestration loop covering Phases 7–8
(Implement → Test). See WORKFLOW_PHASES.md for the full sequence and route × phase matrix.
/govern Add a helper function to utils.ts
/govern Add JWT auth to the API with refresh tokens
/govern --route R2 Fix the typo in the README
/govern --dry-run Refactor the billing module
| Flag | Effect |
|---|---|
(none) | Classify and execute with full governance |
--route R{n} | Override auto-classification (still enforces route constraints) |
--dry-run | Classify and show plan, but do not execute |
--no-team | Force single-lane execution even for R3/R4 |
--via-hermes | Route the whole task through Hermes phase orchestrator (~/chad_work/hermes, REST :3345) instead of in-session dispatch. R3/R4 only. Greenfield uses 8 phases (plan/design/backend/frontend/test/e2e/security/validate); refactor uses 5 (index/plan/refactor/test/validate). Falls back to standard dispatch if Hermes is unreachable and --strict-hermes is not set. |
--worker-runtime {claude|goose|opencode} | Override the dispatch profile's worker_runtime for this run. goose routes through ~/.claude/bin/goose_dispatch.py (ACP → Pro/Max subscription, no per-token cost). opencode routes through anthropic-concurrency-system. Default inherits from route_manifest.json profile. |
~/.claude/state/route_manifest.json~/.claude/agents/*.md~/.claude/skills/planning-gate/references/contracts.mdreferences/contracts.mdBefore any classification or execution:
memory_retrieval_evidence for the implementation contractIf memory is weak or low-confidence, surface that weakness — do not pretend the context is strong.
Extract task characteristics from the user prompt:
Run the classifier:
echo '<task_json>' | python3 ~/.claude/skills/govern/scripts/classify_route.py
Display the route decision:
Route: R3 (non_trivial_impl) | Shape: bounded_swarm | Risk: medium | Swarm cap: 4
If --dry-run was specified, display the full classification and stop.
Answer directly. No gates, no team, no postflight, no planning-gate. Skip to Phase 5 (notification).
compile_intent → initialize_session → compile_plan → verify_plan → validate_planecho '<route_json>' | python3 ~/.claude/skills/govern/scripts/build_team_spec.py
TeamCreate:
govern-<track-id>govern-<track-id>TaskCreate:
addBlockedBy for DAG dependencies between packetsdispatch_track blocks
with missing_reviewer_ack until this runs:
python3 ~/.claude/bin/auto_runtime.py record-ack --track-id <track_id> \
--by reviewer --ref '<criteria hash or ack message>'
Same as R3 with tighter constraints:
adaptation_generated_packetsCodex delegation: For complex investigation or fix sub-tasks within R4, use /codex:rescue to hand off asynchronously while Claude coordinates:
/codex:rescue --background investigate <specific problem>
/codex:rescue --resume apply the top fix from the last run
/codex:status # check progress
/codex:result # retrieve findings
Use codex resume <session-id> (from /codex:result output) to hand off into Codex directly.
The session running /govern acts as team lead (coordinator):
LOOP:
1. TaskList → get current task states
2. Compute runnable set:
- Tasks whose blockedBy are all completed
- Respect lane_caps (don't exceed per-lane concurrent limit)
- Respect route_swarm_cap (total concurrent active tasks)
3. Dispatch in frontier_dispatch_order:
validator → explorer → worker → reviewer
For each dispatchable task:
- TaskUpdate: set owner = agent name, status = in_progress
- SendMessage: packet instructions + acceptance checks + scope constraints
4. Wait for agent completion messages
5. On task completion:
- Handoff-integrity check FIRST (see "Truncation tripwire" below);
a result that fails it is a FAILED dispatch, not a completion
- TaskUpdate: mark completed with evidence
- Check reviewer_barrier_points:
- "closure": all required packets must be reviewer-approved before closing
- "high_risk_boundary_shrink": reviewer approves any scope reduction
- "adaptation_generated_packets" (R4): reviewer approves generated work
- If barrier hit → dispatch reviewer task, wait for verdict
- If reviewer rejects → create rework tasks, continue loop
- Recompute runnable set
6. Check terminal conditions:
- All required packets accepted + convergence → OBJECTIVE_COMPLETE
- No runnable packets + all blocked → ESCALATION_REQUIRED
- Retry budget exhausted (max 2 same-strategy) → boundary shrink
- No frontier movement for 2 cycles → escalate
7. If not terminal → GOTO 1
Timeout safety (no-nudge policy):
CI=1 npm install --no-audit --no-fund, or split the packet). "Nudge #3" must
never exist: babysitting a stalled context costs more than a clean window.noop_cycle_count and no_frontier_movement_cycle_count per manifest thresholdsTruncation tripwire (handoff integrity):
maxTurns truncation cuts the END of an agent's output, so a turn-capped agent
looks like a finished one unless you check. Worker/planner/test-strategist
handoffs are contractually required to end with the literal final line
HANDOFF-COMPLETE. On any completion message:
HANDOFF-COMPLETE final line, OR missing mandatory handoff artifacts
(worker: diff + test output + criterion mapping + verify:<slice-id>:exit=<code>
token) → treat as a FAILED dispatch. Never grade prose; never accept partial
artifacts as "close enough".Retry policy:
Effort escalation on rework dispatch:
When re-dispatching a slice that entered rework (via update-node --state rework), the auto-runtime records a suggested bumped effort in governance.slice_escalations[slice_id]. Resolve the effective effort for the dispatch via:
EFFORT=$(python3 ~/.claude/bin/auto_runtime.py effort-for-slice \
--track-id <track_id> --slice-id <slice_id> --base-effort <route_manifest_effort>)
Use $EFFORT when invoking the agent for the retry. The helper returns base-effort unchanged if no escalation is recorded, so it's safe to always call. Ladder: low → medium → high → xhigh; ceiling is xhigh.
plan.json from planning phaseimpl.json from execution evidencereview.json from reviewer verdictsplanning_artifacts/<track-id>/~/.claude/bin/claude_run --finalize-attempt \
--route-class <route_id> --track-id <track_id> \
--plan-json <path> --impl-json <path> --review-json <path> \
--workspace-root $PWD -- exec "<prompt>"
claude_run handles auto-continue loop (up to 3 iterations per manifest)If claude_run is not available, fall back to manual postflight:
validate_impl.py and finalize_gate.py from planning-gatefinalize_gate.py ok=true as approvalSend completion notification:
~/.claude/bin/notify_done.sh --status <success|blocked> \
--task "<objective>" --details "<route_id> | <N> packets | postflight: <result>"
If notify_done.sh is not available, document the notification gap.
Persist to memory:
Report final status using the governed closure vocabulary:
Before delivering, verify:
Challenge:
Report: