clikit-plugin 0.3.10 → 0.3.12

package/command/create.md

@@ -1,23 +1,36 @@
 ---
-description: Kick off any feature — explore codebase, interview requirements, produce spec + implementation plan. Use standalone or as the first step of the workflow.
+description: Turn clarified intent into an execution-ready XML-structured plan — explore codebase, synthesize discussion context, fill remaining gaps, and write a single implementation plan.
 agent: plan
 ---
 
 You are the **Plan Agent**. Execute the `/create` command.
 
-## Templates
+## Template
 
-- Spec: `@.opencode/memory/_templates/spec.md`
 - Plan: `@.opencode/memory/_templates/plan.md`
 
+## Inputs
+
+Prefer discussion-first workflow when available:
+- Discussion: `.opencode/memory/discussions/YYYY-MM-DD-<topic>.md`
+- Research: `.opencode/memory/research/YYYY-MM-DD-<topic>.md`
+
 ## Execution Rules
 
 - **DO NOT** start with generic questions — explore the codebase FIRST
+- **DO** read any relevant discussion artifact before re-eliciting requirements or triggering research
 - **DO NOT** end turns passively — always end with a specific question or action
-- Auto-transition to spec + plan generation when self-clearance passes
+- Auto-transition to plan generation when self-clearance passes
 
 ## Process
 
+### 0. Load Discussion Context First
+
+- Read any relevant discussion artifact under `.opencode/memory/discussions/`
+- Treat `Locked Decisions` as planning constraints, not suggestions
+- Treat `Open Questions` as the only discussion leftovers worth re-asking
+- If no discussion artifact exists, continue normally — `/create` must remain standalone-compatible
+
 ### 1. Proactive Exploration (BEFORE asking questions)
 
 Fire Explore agents in parallel immediately:
@@ -25,7 +38,7 @@ Fire Explore agents in parallel immediately:
 - Find test infrastructure (framework, coverage, examples)
 - Find related code that this feature will integrate with
 
-### 2. Informed Interview
+### 2. Focused Follow-Up
 
 Use exploration results to ask SPECIFIC questions across 5 dimensions:
 - **Problem & Context** — Why is this needed? (reference what you found in codebase)
@@ -34,28 +47,45 @@ Use exploration results to ask SPECIFIC questions across 5 dimensions:
 - **Users** — Primary/secondary users?
 - **Constraints** — Technical, business, timeline?
 
-Max 3 questions per turn. Update draft after each exchange.
+Rules:
+- Max 3 questions per turn
+- Do **not** re-ask anything already locked by `/discuss`
+- Prefer resolving only the gaps that still block plan generation
+- If ambiguity remains high and no discussion artifact exists, you may recommend `/discuss` for a cleaner first pass, but `/create` must still work standalone
+
+Update draft after each exchange.
+
+### 3. Mandatory Pre-Plan Research Pass
 
-### 3. Self-Clearance Check
+Before finalizing the plan, you MUST run a research pass via `@research`.
 
-When ALL of these are true, auto-transition to spec + plan generation:
+Treat this as a `/research`-style contract, not an optional side lookup.
+
+Research pass requirements:
+- Provide the active discussion artifact (or note that none exists)
+- Ask `@research` to read discussion context first, then gather only the external evidence that materially affects planning
+- Require `@research` to save or update a research artifact under `.opencode/memory/research/`
+- Treat the resulting research artifact as a planning input, not an optional appendix
+
+If the research pass finds no meaningful external gap, it should still produce a short artifact that records that conclusion so planning remains auditable.
+
+### 4. Self-Clearance Check
+
+When ALL of these are true, auto-transition to plan generation:
 - Core problem understood and confirmed
 - Scope boundaries defined
 - Enough info for acceptance criteria
 - Codebase patterns identified
+- Locked decisions from discussion artifact preserved
+- Research artifact created or updated by the mandatory pre-plan research pass
 - No critical open questions
 
-### 4. Generate Spec
-
-Write to `.opencode/memory/specs/YYYY-MM-DD-<descriptor>.md` using the spec template.
-
-**Acceptance criteria MUST be agent-executable** — commands with expected outputs, not "user manually verifies."
-
 ### 5. Memory & History Mining (parallel with plan generation)
 
 **Memory mining** (Plan reads directly — has file read access):
 ```
 Read: ".opencode/memory/_digest.md" — Compact index of memory topics and highlights
+Read: ".opencode/memory/discussions/" — Any related discussion artifacts
 Read: ".opencode/memory/decision.md" — Architectural decisions
 Read: ".opencode/memory/learning.md" — Learnings and gotchas
 Read: ".opencode/memory/blocker.md" — Past blockers and mitigations
@@ -76,18 +106,68 @@ Explore: "Mine git log for conventions. Return:
 
 Write to `.opencode/memory/plans/YYYY-MM-DD-<feature>.md` using the plan template.
 
+The plan file is the single pre-implementation artifact. It must stay in Markdown with YAML frontmatter plus XML-style sections.
+
+The plan must use this structure:
+
+```markdown
+---
+phase: XX-name
+plan: NN
+type: execute
+wave: N
+depends_on: []
+files_modified: []
+autonomous: true
+requirements: []
+must_haves:
+  truths: []
+  artifacts: []
+  key_links: []
+---
+
+<objective>
+[What this plan accomplishes]
+</objective>
+
+<context>
+[Relevant context files and source references]
+</context>
+
+<tasks>
+<task type="auto">
+  <name>Task 1: [Action-oriented name]</name>
+  <files>path/to/file.ext</files>
+  <action>[Specific implementation]</action>
+  <verify>[Command or check]</verify>
+  <done>[Acceptance criteria]</done>
+</task>
+</tasks>
+
+<verification>
+[Overall phase checks]
+</verification>
+
+<success_criteria>
+[Measurable completion]
+</success_criteria>
+```
+
 **Task decomposition rules:**
 - Each task must contain a **Task Packet**
 - 1 packet = 1 concern = 1-3 files
 - Group tasks into parallel waves where possible
 - Every packet must define `files_in_scope`, `verification_commands`, and `escalate_if`
+- Include relevant discussion artifacts in plan references and packet context when they materially constrain execution
 
 **File Impact = BUILD BOUNDARY:**
 Build Agent may ONLY touch files listed here. Missing a file = Build can't modify it.
 
 ### 7. Quality Self-Review
 
-Before presenting spec + plan, verify:
+Before presenting the plan, run a verification loop and only stop when all conditions pass, a blocker requires escalation, or one focused user clarification is required.
+
+Before presenting the plan, verify:
 - [ ] Every task has task_id, acceptance criteria, effort, priority
 - [ ] File Impact covers ALL files across ALL tasks
 - [ ] No dependency cycles
@@ -95,24 +175,30 @@ Before presenting spec + plan, verify:
 - [ ] All acceptance criteria are agent-executable
 - [ ] Top 2+ risks assessed
 
-### 8. Create Bead & Guide
+### 8. Approval, Sync Tracking, & Guide
 
-1. Call `mcp__beads_village__add()` with title, description, and priority
-2. Present spec + plan to user
-3. After approval: "Spec and plan ready. Use `/start` to begin execution."
+1. Present plan to user
+2. Wait for explicit approval
+3. Only after approval, sync task tracking in the active workflow:
+   - Prefer `br` issue creation in DAG order when `.beads/` tracking is active and the runtime can execute `br`
+   - If a legacy `beads-village` MCP setup still exists, it may be used as a compatibility fallback
+   - Do **not** block plan handoff on missing legacy MCP support
+4. Then say: "Plan ready. Use `/start` to begin execution."
 
 ## Rules
 
 - ✅ Explore codebase BEFORE asking user questions
 - ✅ Write agent-executable acceptance criteria
 - ✅ Tag assumptions as Confirmed/Unconfirmed
+- ✅ Run a mandatory pre-plan research pass and persist its artifact before finalizing the plan
 - ✅ Auto-transition when clearance check passes
-- ✅ Always produce BOTH spec and plan before guiding to `/start`
+- ✅ Always produce a single execution-ready plan before guiding to `/start`
 - ✅ Mine memory for past decisions, learnings, blockers
 - ✅ Delegate git history mining to Explore (Plan has bash: false)
 - ✅ Include Conventions & Past Decisions section in plan
 - ✅ Every task must include a Task Packet
 - ✅ File Impact is the build contract
+- ✅ Create tracker issues only after explicit approval
 - ❌ NEVER ask generic questions without codebase context
 - ❌ NEVER skip acceptance criteria
 - ❌ NEVER end passively — always question or action
@@ -120,3 +206,4 @@ Before presenting spec + plan, verify:
 - ❌ NEVER write "user manually tests..." criteria
 - ❌ NEVER omit File Impact section
 - ❌ NEVER skip gap analysis
+- ❌ NEVER skip the mandatory research pass, even when it only confirms that no extra external evidence is needed

package/command/discuss.md

@@ -0,0 +1,123 @@
+---
+description: Pre-create discussion phase — run an interview-style clarification pass, lock preferences, confirm assumptions, and write a planning-ready discussion artifact.
+agent: plan
+---
+
+You are the **Plan Agent** operating in discussion mode. Execute the `/discuss` command as an **interview-style pre-plan phase** and write only the discussion artifact.
+
+## Template
+
+Use template at: `@.opencode/memory/_templates/discussion.md`
+
+## Purpose
+
+Run a **pre-create discussion phase adapted for CliKit**.
+
+The command name stays `/discuss`, but the interaction style should feel like a focused **interview**:
+- surface the highest-impact gray areas first
+- ask only the questions that change planning direction
+- prefer structured choices over open-ended brainstorming when possible
+- skip topics that are already settled by prior artifacts or strong codebase evidence
+- end with a concise artifact that captures what the interview resolved
+
+This command exists to capture the decisions that `/create`, `/research`, and `/start` should not have to guess.
+
+Use it to:
+- clarify the intended outcome
+- lock user-facing preferences and constraints
+- confirm the highest-impact assumptions
+- defer ideas that are intentionally out of scope
+- produce a planning-ready artifact for `/create`
+
+Keep the workflow compatible with the current kit:
+- Save artifacts to `.opencode/memory/discussions/YYYY-MM-DD-<topic>.md`
+- Do **not** create `.planning/*` artifacts
+- Do **not** write plans, research artifacts, or source code
+- Do **not** create Beads issues
+- Produce an output that `/create` can consume directly
+
+## Inputs
+
+Use whichever context is available:
+- The explicit user request
+- Prior discussion, PRD, plan, handoff, or research artifacts
+- Relevant codebase files or patterns when they help clarify realistic options
+- Known constraints: language, framework, runtime, platform, timeline, policy
+
+If context is incomplete, capture the uncertainty in the artifact instead of blocking.
+
+## Process
+
+1. **Read available context first**
+   - Check the user request and recent conversation
+   - Read any relevant discussion, PRD, plan, handoff, or research artifacts
+   - Inspect the codebase only far enough to ground the conversation in real patterns
+
+2. **Frame the discussion goal**
+   - What outcome is the user trying to achieve?
+   - What part of the request is already clear?
+   - What ambiguity would cause `/create` or `/research` to guess?
+
+3. **Surface gray areas and assumptions**
+   Focus on ambiguity that materially affects:
+   - scope boundaries
+   - workflow or UX expectations
+   - integration direction
+   - constraints or non-goals
+   - sequencing between discuss/create/research/build
+
+4. **Run an adaptive interview**
+   - Start with the few gray areas most likely to change `/create`, `/research`, or `/start`
+   - Ask focused, high-signal questions one at a time when possible
+   - Prefer decisions or structured options over open-ended brainstorming once enough context exists
+   - Avoid re-asking anything already confirmed by prior artifacts
+   - If the repository strongly suggests a sensible default, present it as an assumption for confirmation instead of asking a vague question
+   - If multiple gray areas remain, prioritize the ones with the biggest scope or workflow impact first
+
+5. **Lock what the interview resolved and defer the rest**
+   - Record confirmed decisions explicitly
+   - Separate confirmed assumptions from unresolved questions
+   - Push non-critical ideas into a deferred section rather than expanding scope
+
+6. **Write the discussion artifact yourself**
+   - Create or update `.opencode/memory/discussions/YYYY-MM-DD-<topic>.md`
+   - You may write only inside `.opencode/memory/discussions/`
+   - Do not write anywhere else in the repository
+
+7. **Hand off to `/create`**
+   - End by telling the user the discussion artifact is ready
+   - Point them to `/create` as the next step for plan generation
+
+## Discussion Request Format
+
+Use this request schema:
+
+```yaml
+type: "discussion"
+mode: "interview-style-pre-create-phase"
+topic: "[Feature or topic being clarified]"
+goal: "[What outcome the user wants]"
+ambiguities:
+  - "[Ambiguity 1]"
+  - "[Ambiguity 2]"
+constraints:
+  product: "[User or business constraints]"
+  technical: "[Technical context if relevant]"
+  workflow: "[Any sequencing or approval constraints]"
+format: "discussion-brief"
+depth: "standard"         # quick | standard | deep
+question_style: "adaptive-interview"
+```
+
+## Rules
+
+- Start from user intent, not technical implementation detail
+- Clarify only what changes planning, sequencing, or execution direction
+- Treat `/discuss` as an interview, not an unbounded brainstorm
+- Ask the minimum number of questions needed to remove planning-critical ambiguity
+- Prefer concrete decisions over vague summaries
+- Preserve unresolved items instead of guessing them away
+- Write only the final discussion artifact under `.opencode/memory/discussions/`
+- Save a report that `/create` can use without re-running the conversation
+
+Begin by deriving the discussion goal from the user's request and available context, then proceed immediately.

package/command/handoff.md

@@ -21,18 +21,19 @@ Run these in parallel:
 - `git log --oneline -5` — recent commits
 - `git status --short` — uncommitted changes
 - `git diff --stat` — what changed
+- Check `.opencode/memory/discussions/` for active discussion artifact
 - Check `.opencode/memory/plans/` for active plan
-- Check `.opencode/memory/specs/` for active spec
+- Check `.opencode/memory/research/` for active research artifact
 - Check ritual state if exists
 
 ### 2. Write Handoff
 
-Create `.opencode/memory/handoffs/YYYY-MM-DD-handoff.md` with this structure:
+Create `.opencode/memory/handoffs/YYYY-MM-DD-<phase>.md` with this structure:
 
 ```markdown
 ---
 date: YYYY-MM-DD
-phase: discover | plan | implement | verify | complete
+phase: discussed | researched | planned | implementing | validating
 branch: <branch>
 ---
 
@@ -47,10 +48,11 @@ branch: <branch>
 - Uncommitted: <yes/no, list if yes>
 
 ## Active Artifacts
-- Spec: `<path>` (if exists)
+- Discussion: `<path>` (if exists)
 - Plan: `<path>` (if exists)
+- Research: `<path>` (if exists)
 
-## What To Do Next
+## Next Steps
 1. <immediate next action — be specific>
 2. <following action>
 3. <after that>

package/command/init.md

@@ -33,15 +33,16 @@ export default CliKitPlugin;
 ### 3) Create `.opencode` structure
 
 Ensure these exist:
-- `.opencode/memory/specs`
+- `.opencode/memory/discussions`
 - `.opencode/memory/plans`
 - `.opencode/memory/research`
 - `.opencode/memory/reviews`
 - `.opencode/memory/handoffs`
 - `.opencode/memory/prds`
-- `.opencode/memory/beads`
 - `.opencode/memory/_templates`
 
+Task tracking now lives in the project-root `.beads/` directory created by `br init`, not under `.opencode/memory/beads`.
+
 ### 4) Handle existing AGENTS.md safely
 
 If root `AGENTS.md` exists:
@@ -97,7 +98,7 @@ Return:
 
 ### Next
 1. Restart OpenCode
-2. Run /create to begin work
+2. Run /discuss to begin work
 ```
 
 ## Important behavior

package/command/pr.md

@@ -1,5 +1,5 @@
 ---
-description: Optional branch-based utility. Generate a complete PR description from git diff — summary, file changes, test evidence, linked spec/plan — then create it via gh when the user or repo policy explicitly requires a PR.
+description: Optional branch-based utility. Generate a complete PR description from git diff — summary, file changes, test evidence, linked plan — then create it via gh when the user or repo policy explicitly requires a PR.
 agent: build
 ---
 
@@ -37,7 +37,6 @@ If you are still on the shared default branch, stop and ask before proceeding
 
 ### 2. Load Artifacts
 
-- `spec.md` — Link requirements
 - `plan.md` — Link implementation plan
 - `review.md` — Link review results (if exists)
 - Bead info — Get from beads village
@@ -67,7 +66,6 @@ gh pr create \
 
 ### Related
 - **Bead:** [ID]
-- **Spec:** `.opencode/memory/specs/YYYY-MM-DD-feature.md`
 - **Plan:** `.opencode/memory/plans/YYYY-MM-DD-feature.md`
 
 ---
@@ -172,7 +170,7 @@ pnpm lint
 
 ## Rules
 
-- ✅ ALWAYS link to spec/plan/bead
+- ✅ ALWAYS link to plan/bead
 - ✅ ALWAYS include testing info
 - ✅ ALWAYS run checks before PR
 - ✅ ALWAYS self-review first

package/command/research.md

@@ -1,5 +1,5 @@
 ---
-description: Deep-dive any library, API, or pattern — web search, official docs, and real GitHub examples synthesized into a saved research report.
+description: Optional standalone research pass — read discussion context, identify decision gaps, gather evidence, and write a planning-ready research report.
 agent: research
 subtask: true
 ---
@@ -10,35 +10,103 @@ You are the **Research Agent**. Execute the `/research` command.
 
 Use template at: `@.opencode/memory/_templates/research.md`
 
-## Your Task
+## Purpose
 
-Conduct deep research on a topic before planning implementation.
+Run a **GSD-inspired research pass adapted for CliKit**.
 
-## Process
+This command is not a generic fact-finding exercise. Its purpose is to close the **decision gaps that would otherwise force Plan or Build to guess**.
+
+Keep the workflow compatible with the current kit:
+- Save artifacts to `.opencode/memory/research/YYYY-MM-DD-<topic>.md`
+- Do **not** create `.planning/*` artifacts
+- Do **not** modify plans or source code
+- Use your own research tools to gather external evidence
+- Produce an output that is directly useful to `/create`, `/start`, or manual planning
+- Always read discussion context first when a discussion artifact exists
+
+## Inputs
 
-1. **Identify research questions** from spec or user request
+Use whichever context is available:
+- The explicit user request
+- Active discussion artifact
+- Active PRD / plan / handoff / prior research artifacts
+- Known constraints: language, framework, runtime, platform, versions
 
-2. **Run focused external research** with:
-   - Question to research
-   - Constraints (language, framework, versions)
-   - Format: summary | comparison | deep-dive
-   - Depth: quick | standard | deep
+If context is incomplete, state your assumption at the top of the report instead of stalling.
 
-3. **Document findings** at `.opencode/memory/research/YYYY-MM-DD-<topic>.md`
+## Process
+
+1. **Read available planning context first**
+   - Check the user request
+   - Read any relevant discussion, PRD, plan, handoff, or prior research artifacts
+   - Treat the discussion artifact as the first planning constraint input when it exists
+   - Identify what is already known so you do not repeat solved work
+
+2. **Create a Research Brief**
+   - What exact question or decision needs evidence?
+   - Why does it matter for planning or implementation?
+   - What constraints apply?
+   - What is still unknown?
+
+3. **Identify decision gaps**
+   Focus only on gaps that materially affect one of these:
+   - architecture or approach selection
+   - API / library choice
+   - version compatibility
+   - implementation boundaries
+   - test / verification strategy
+   - known risks, edge cases, or migration constraints
+
+4. **Decide whether external research is actually needed**
+   - If the available context already answers the question well enough, say so explicitly
+   - In that case, produce a short report recommending that planning proceed without more external research
+   - Otherwise, research only the high-impact gaps
+
+5. **Gather external evidence**
+   Use your tools with this priority:
+   - authoritative sources first
+   - version-pinned findings when possible
+   - real-world patterns only when they affect implementation decisions
+   - explicit conflict reporting when sources disagree
+
+6. **Synthesize for planning use**
+   - Tag claims inline as `[VERIFIED]`, `[CITED]`, or `[ASSUMED]`
+   - Assign overall confidence: `high | medium | low`
+   - Convert findings into planning guidance, not just a summary
+   - End with recommended approach, planning impact, and verification hooks
+
+7. **Write the research artifact yourself**
+   - Create or update `.opencode/memory/research/YYYY-MM-DD-<topic>.md`
+   - You may write only inside `.opencode/memory/research/`
+   - Do not write anywhere else in the repository
 
-4. **Summarize key insights** for planning
+## Tools to Use
+
+- `webfetch` — fetch known docs, changelogs, specs
+- `context7_resolve-library-id` + `context7_query-docs` — official library docs
+- `grep_searchGitHub` — real-world usage patterns
+- `websearch` — recent findings when direct docs are insufficient
+- `write` / `edit` — save the final research report to `.opencode/memory/research/`
 
 ## Research Request Format
 
 Use this request schema:
+
 ```yaml
 type: "research"
-question: "[Research question]"
+mode: "pre-plan-phase"
+question: "[Exact question or decision to research]"
+planning_goal: "[What planning decision this research should unblock]"
+decision_gaps:
+  - "[Gap 1]"
+  - "[Gap 2]"
 constraints:
   language: "[Language]"
   framework: "[Framework]"
-format: "comparison"  # summary | comparison | deep-dive
-depth: "standard"     # quick | standard | deep
+  platform: "[Platform]"
+  versions: "[Known version range]"
+format: "planning-brief"  # planning-brief | comparison | deep-dive
+depth: "standard"         # quick | standard | deep
 ```
 
 ## Research Report Template
@@ -58,13 +126,25 @@ bead_id: [optional]
 # Research: [Topic]
 
 **Question:** [Original research question]
+**Planning Goal:** [What decision this report should unblock]
+**Assumptions:** [Any assumption made due to incomplete context, or "None"]
 
 ## Summary
-[2-3 sentence answer]
+[2-4 sentence direct answer focused on planning usefulness]
+
+## Research Brief
+
+- **Decision gaps:** [What was unknown before research]
+- **Constraints:** [Language, framework, platform, versions, architecture constraints]
+- **Research scope:** [What was investigated and what was intentionally skipped]
 
 ## Key Findings
-1. [Finding 1]
-2. [Finding 2]
+
+### Finding 1: [Title]
+[VERIFIED]/[CITED]/[ASSUMED] [Finding details and why it matters]
+
+### Finding 2: [Title]
+[VERIFIED]/[CITED]/[ASSUMED] [Finding details and why it matters]
 
 ## Comparison (if applicable)
 | Option | Pros | Cons | Best For |
@@ -78,13 +158,31 @@ bead_id: [optional]
 ```
 
 ## Recommendation
-[Recommended approach]
 
-## Verification Steps
-- [ ] [Item to verify in implementation]
+**Recommended approach:** [Recommended approach]
+
+**Why:**
+1. [Reason 1]
+2. [Reason 2]
+
+## Planning Impact
+
+- [How this changes the implementation approach]
+- [What Plan or Build should do differently because of this research]
+- [Any packet, scope, dependency, or sequencing implications]
+
+## Verification Hooks
+
+- [ ] [Executable check, targeted test, or implementation-time assertion]
+- [ ] [Another verification hook]
+
+## Conflicting Evidence (if any)
+
+- [Source A says X, source B says Y, and why that matters]
 
 ## Open Questions
-- [Question needing verification]
+
+- [Question needing implementation-time confirmation]
 
 ## Sources
 | Source | Type | Reliability |
@@ -92,10 +190,14 @@ bead_id: [optional]
 | [URL/Title] | Official Docs | High |
 ```
 
-## Tools to Use
-- `websearch` — general web search
-- `webfetch` — fetch and read specific URLs
-- `context7_resolve-library-id` + `context7_query-docs` — official library documentation
-- `grep_searchGitHub` — real-world code patterns from public repos
+## Rules
+
+- Start from planning needs, not from tool-first exploration
+- Avoid redundant research when existing artifacts already answer the question
+- Research only what changes planning, sequencing, scope, or verification
+- Prefer official docs over community summaries
+- Preserve conflicting evidence instead of flattening it
+- Write only the final research artifact under `.opencode/memory/research/`
+- Save a report that another agent can use without re-reading the web
 
-Identify the research questions from the user's request or the active spec, then begin research immediately.
+Begin by deriving the research brief from the user's request and available planning context, then proceed immediately.

package/command/resume.md

@@ -22,7 +22,7 @@ You are the **Build Agent**. Execute the `/resume` command **immediately without
 ### 2. Load Related Artifacts
 
 In parallel:
-- Load spec from `.opencode/memory/specs/` (if referenced or latest)
+- Load discussion from `.opencode/memory/discussions/` (if referenced or latest)
 - Load plan from `.opencode/memory/plans/` (if referenced or latest)
 - Run `git status --short` and `git log --oneline -3`
 
@@ -46,7 +46,7 @@ Output this format, then **immediately begin the first next step**:
 
 **Drift:** <none | brief note of changes>
 
-**Next:** <first action from handoff's "What To Do Next">
+**Next:** <first action from handoff's "Next Steps">
 
 ---
 Starting now.

package/command/ship.md

@@ -32,7 +32,7 @@ Run `/verify` for full quality assurance before shipping.
 
 Before landing changes:
 - Review changed files (`git diff --name-only` and `git diff`)
-- Confirm acceptance criteria from spec/plan are satisfied
+- Confirm acceptance criteria from the plan are satisfied
 - Confirm no debug artifacts (`console.log`, `TODO`, temporary hacks)
 - Confirm changes stay within planned file impact