菜单
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命令会保持在同一行。复制前请横向滚动并检查完整内容。
想先保存到本地？可下载 SkillsMP 当前能够提供的文件。
基于 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: