菜单
Your bulletproof guide to executing implementation phases! Handles commits, detects when phases are too big, and knows when to bail cleanly. Load this whenever you're implementing a phase - it provides clean commit protocol and signals the orchestrator when things go sideways.
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
基于 SOC 职业分类
Guides creation of dubstack agent source files (agent.yaml + frontmatter.md + agent-body.md) through discovery, template selection, and iterative filling. Produces complete vera-cli native agent directories ready for `vera build`. Self-documenting templates teach the fill conversation; the skill orchestrates the process while the templates own the content knowledge. Primary entry point for adding a new agent to dubstack.
D-phase skill for the codesmith implementation workflow. Invokes render-design-doc-skeleton.py to overwrite the design.md placeholder with a tag-aware skeleton grounded in R-phase findings. Runs the always-interactive brain-surgery alignment conversation per Lock 6: agent presents each design section, human stress-tests via Question tool per substantive decision, iterate until aligned. Tracks the foundational-reversal strike counter per Lock 31. May identify multiple architecturally-distinct plans (NOT sub-tickets). Hands off to code-structure when D-phase is locked.
Q↔R loop skill for the codesmith implementation workflow. Applies Kipling structure (What/How/Who/When/Why/Where) × grill-with-docs discipline × per-tag emphasis matrix to derive code-layer questions. Composes research dispatch instructions (in-memory, NOT a written artifact) per the 7 composable research patterns. Dispatches `researcher` across the hide-the-intent boundary — researcher receives questions + scope only, not the ticket. Synthesizes returns into the bundle's research file. Updates CONTEXT.md inline as terms surface. Scaffolds Decision Records when the three-condition gate fires. Loops until five readiness criteria are met (problem scoped, current state mapped, impact understood, edge cases identified, agent can articulate unprompted). Hands off to code-design when readiness is confirmed.
I-phase orchestration skill per Lock 10. Iterates over the locked plan's slices in dependency order. For each slice: invokes worktree-setup (first slice only or once per parallel plan); dispatches `codesmith-worker` subagent with slice scope (plan + slice boundary + verification commands + commit convention + worktree path); awaits PHASE_COMPLETE or NEEDS_DECOMPOSITION; on decomposition triggers mini-replan per Lock 19; on completion invokes `code-verify` for the I-per-slice gate. Owns the plan-as-living-doc's structural sections; worker owns the per-slice log subsections. Tracks decomposition strike count (abort after 3 consecutive on the same slice per Lock 17.2).
Entry-point skill for the codesmith implementation workflow. Detects dual mode (planning vs execution) from initial input shape — ticket reference → planning mode; bundle directory → execution mode. In planning mode: loads the `status: ready` ticket, scaffolds the implementation bundle via scaffold-implementation-bundle.py, transitions ticket status `ready → active`, and hands off to code-grill. In execution mode: loads the existing bundle (ticket + design + structure + plans + optional research), confirms preconditions, and hands off to code-implement. Detects PR mode vs local-only mode based on remote configuration and user confirmation.
P-phase skill for the codesmith implementation workflow. Converts the structural skeleton into per-slice tactical steps (TDD vertical: failing test → minimal impl → green → verify → commit) per Lock 8. Produces one plan doc per plan identified in D-phase. Runs the Parallel-Safety Evaluation per Lock 27 to determine whether multiple plans execute in parallel worktrees or serialize. Spot-check user review; no open questions in the final plan. Hands off to worktree-setup (or directly to code-implement if Work-Tree is bypassed).
| name | phase-execution |
| description | Your bulletproof guide to executing implementation phases! Handles commits, detects when phases are too big, and knows when to bail cleanly. Load this whenever you're implementing a phase - it provides clean commit protocol and signals the orchestrator when things go sideways. |
Execute a single phase from an implementation plan with disciplined commit protocol and automatic detection of phases that are too large.
The orchestrator provides:
| Input | Description | Example |
|---|---|---|
| Plan path | Location of the implementation plan | thoughts/shared/plans/2026-01-03_core-graph.md |
| Phase number | Which phase to execute | Phase 2 |
| Worktree path | Working directory (if using worktrees) | .trees/plan-1-core-graph |
| Branch name | Git branch for commits | implement/plan-1-core-graph |
For each change in the phase:
Trigger conditions (any of these):
Escape hatch protocol:
1. STOP immediately
2. Discard uncommitted changes: git checkout .
3. Return to orchestrator with signal: "NEEDS_DECOMPOSITION"
4. Include: what was completed, what remains, estimated sub-phases
When phase is complete:
git add -APhase N: [Phase Title]
- [Key change 1]
- [Key change 2]
Plan: thoughts/shared/plans/[plan-file].md
git push origin [branch-name]Before returning to orchestrator:
On successful completion:
PHASE_COMPLETE
Commit: [SHA]
Checks:
- tests: ✓
- types: ✓
- lint: ✓
Manual verification needed:
- [item 1]
- [item 2]
On escape hatch trigger:
NEEDS_DECOMPOSITION
Completed:
- [what was done]
Remaining:
- [what remains]
- [what remains]
Suggested sub-phases:
- [sub-phase 1 description]
- [sub-phase 2 description]
git push after committing; the orchestrator and validator need your commits on the remote