forge-dev-framework 1.1.0 → 1.2.0

package/.claude/commands/forge/init.md

@@ -1,85 +1,21 @@
 ---
 name: forge:init
-description: Initialize FORGE in the current project directory. Use this when the user says "forge init" or wants to set up FORGE in an existing project.
+description: Initialize FORGE in the current project directory.
 argument-hint: [--quick]
 allowed-tools:
   - Read
   - Write
   - Bash
+  - TeamCreate
 ---
 
-<objective>
-Initialize FORGE in the current project directory with complete project structure and configuration.
+Initialize FORGE in current directory. Use `--quick` to skip prompts.
 
-Purpose: Set up FORGE's multi-agent development system in an existing or new project.
-Output: Complete FORGE directory structure, state engine, templates, and CLI configuration.
-</objective>
+**Steps:**
 
-<execution_context>
-**Load these files NOW:**
-
-- @CLAUDE.md (FORGE architecture)
-- @ROADMAP.md (Implementation plan)
-- @src/cli/init.ts (Init command implementation)
-</execution_context>
-
-<context>
-**Target Directory:** Current working directory (process.cwd())
-**Initialization Mode:** Standard or --quick (skip interactive prompts)
-
-**Actions Performed:**
-- Create state/, contracts/, .planning/, .claude/, src/ directories
-- Copy CLAUDE.md template
-- Initialize state/STATE.json
-- Create .gitignore if needed
-- Configure forge.config.json
-</context>
-
-<process>
-**Execute the init command:**
-
-1. **Directory Structure**
-   ```bash
-   mkdir -p state/events
-   mkdir -p contracts
-   mkdir -p .planning
-   mkdir -p .claude/rules
-   mkdir -p src/{cli,commands,generators,git,utils}
-   mkdir -p .github/workflows
-   mkdir -p .worktrees
-   ```
-
-2. **Core Artifacts**
-   - Copy CLAUDE.md template → project root
-   - Create state/STATE.json with initial project state
-   - Create .planning/forge.config.json with default configuration
-
-3. **Git Setup**
-   - Create/update .gitignore with FORGE patterns
-   - Initialize git repository if not exists
-   - Set up pre-commit hooks
-
-4. **Dependencies**
-   - Create package.json if not exists
-   - Install FORGE dependencies: chalk, commander, execa, zod, handlebars
-   - Add build scripts: build, test, dev
-
-5. **Verification**
-   - Run `npm run build` (if TypeScript)
-   - Check `forge status` output
-   - Verify directory structure
-
-6. **Output**
-   - Show created files
-   - Display next steps
-   - Offer `forge help` for available commands
-</process>
-
-<deliverables>
-- Complete FORGE directory structure
-- state/STATE.json (initial state)
-- .planning/forge.config.json (configuration)
-- CLAUDE.md (project constitution)
-- .gitignore with FORGE patterns
-- package.json with dependencies
-</deliverables>
+1. Create dirs: state/events, contracts, .planning, .claude/rules, src/{cli,commands,generators,git,utils}, .github/workflows, .worktrees
+2. Generate CLAUDE.md template, state/STATE.json, .planning/forge.config.json
+3. If no AgentTeam.md, analyze codebase via Explore subagent and generate one. Create team with TeamCreate.
+4. Git setup: .gitignore, init repo, pre-commit hooks
+5. Dependencies: package.json, install chalk/commander/execa/zod/handlebars
+6. Verify: `npm run build`, `/forge:status`

package/.claude/commands/forge/insert-phase.md

@@ -79,7 +79,7 @@ Decimal phase format: `X.Y` where X is parent phase, Y increments (0.1, 0.2, etc
 9. **Confirm**
    - Show inserted phase info
    - List any updated dependencies
-   - Suggest next: `forge discuss <phase>` or `forge plan <phase>`
+   - Suggest next: `/forge:discuss <phase-number>` or `/forge:plan <phase-number>`
 </process>
 
 <deliverables>
@@ -92,7 +92,8 @@ Decimal phase format: `X.Y` where X is parent phase, Y increments (0.1, 0.2, etc
 </deliverables>
 
 <next_steps>
-- Run `forge discuss <phase>` to capture phase context
-- Run `forge plan <phase>` to generate task breakdown
+- Run `/forge:discuss <phase-number>` to capture phase context
+- Run `/forge:plan <phase-number>` to generate task breakdown
 - Notify team of dependency changes
+- Tip: Use `/clear` to start from a fresh context
 </next_steps>

package/.claude/commands/forge/new-milestone.md

@@ -88,7 +88,7 @@ Updates ROADMAP.md structure and routes to requirements gathering for the new mi
    ```
 
 8. **Route to Requirements**
-   - Suggest: Run `forge generate requirements` or manual requirements gathering
+   - Suggest: Run `/forge:generate requirements` or manual requirements gathering
    - Ask: "Do you want to gather requirements now?"
      - Yes: Route to requirements workflow
      - No: Complete, user can gather later

package/.claude/commands/forge/new-project.md

@@ -1,103 +1,24 @@
 ---
 name: forge:new-project
-description: Initialize a new FORGE project with team coordination, state engine, and artifact generation. Use this when the user asks to "create a FORGE project", "start a new FORGE project", "initialize FORGE", or wants to use FORGE for multi-agent development.
+description: Initialize a new FORGE project with team coordination and state engine.
 argument-hint: [project-name]
 allowed-tools:
   - Read
   - Write
   - Bash
+  - TeamCreate
   - AskUserQuestion
 ---
 
-<objective>
-Initialize a new FORGE project with complete project structure, state engine, team coordination system, and artifact generation capabilities.
+Create a new FORGE multi-agent development project.
 
-Purpose: Set up a new multi-agent development project using FORGE's architecture.
-Output: Complete FORGE project structure with CLAUDE.md, state engine, templates, and CLI commands.
-</objective>
+**Steps:**
 
-<execution_context>
-**Load these files NOW (before proceeding):**
-
-- @CLAUDE.md (FORGE's architecture and patterns)
-- @ROADMAP.md (FORGE's implementation plan)
-- @REQUIREMENTS.md (Milestone 1 acceptance criteria)
-- @bin/forge.ts (CLI entry point)
-</execution_context>
-
-<context>
-**Project Location:** Current working directory or specified project-name argument
-**Project Type:** New FORGE multi-agent development project
-
-**FORGE Capabilities:**
-- Event-sourced state engine with single-writer merge
-- Contract-first protocol for cross-agent coordination
-- Template-based artifact generation (CLAUDE.md, REQUIREMENTS.md, etc.)
-- Git worktree isolation for parallel task execution
-- 5-6 task limit enforcement per phase
-- Atomic commit enforcement with conventional format
-</context>
-
-<process>
-**Follow this workflow to initialize a new FORGE project:**
-
-1. **Project Setup**
-   - Create project directory if name provided
-   - Run `forge init` or initialize structure manually
-   - Create state/, contracts/, .planning/, .claude/rules/, src/ directories
-
-2. **Core Artifacts**
-   - Generate CLAUDE.md with project constitution
-   - Create initial REQUIREMENTS.md with project-specific requirements
-   - Set up ROADMAP.md with milestone breakdown
-   - Create PLAN.md with dependency graph
-
-3. **State Engine**
-   - Initialize state/STATE.json with project metadata
-   - Create state/STATE.schema.json for validation
-   - Set up state/events/ directory for append-only event log
-
-4. **Team Configuration**
-   - Create .claude/rules/ with project-specific rules
-   - Set up CODEOWNERS for file ownership boundaries
-   - Configure agent roles and permissions
-
-5. **Template System**
-   - Copy FORGE templates to src/templates/
-   - Configure token limits for artifacts
-   - Set up template engine integration
-
-6. **Git Integration**
-   - Initialize git repository if needed
-   - Create .worktrees/ directory structure
-   - Set up pre-commit hooks for conventional commits
-   - Create .github/workflows/ for CI/CD
-
-7. **Verification**
-   - Run `npm run build` to verify TypeScript compilation
-   - Run `npm test` to verify test suite
-   - Check `forge status` to confirm project initialization
-
-8. **Handoff**
-   - Provide user with next steps (forge discuss, forge plan)
-   - Show available commands with `forge help`
-   - Explain how to use agent teams for development
-</process>
-
-<deliverables>
-- Complete FORGE project structure
-- CLAUDE.md with project constitution
-- Initial REQUIREMENTS.md and ROADMAP.md
-- Configured state engine with STATE.json
-- Template system ready for artifact generation
-- Git repository with proper hooks
-- Build passing with zero errors
-</deliverables>
-
-<next_steps>
-After project initialization:
-1. Run `forge discuss <phase>` to capture project context
-2. Run `forge plan <phase>` to generate atomic task breakdown
-3. Use agent teams for parallel task execution
-4. Track progress with `forge status`
-</next_steps>
+1. Create project directory (if name provided), create FORGE structure: state/, contracts/, .planning/, .claude/rules/, src/
+2. Generate CLAUDE.md, REQUIREMENTS.md, ROADMAP.md, PLAN.md
+3. Initialize state/STATE.json, STATE.schema.json, state/events/
+4. Create FORGE team with TeamCreate, set up .claude/rules/ and CODEOWNERS
+5. Set up templates in src/templates/, configure token limits
+6. Git init, .worktrees/, pre-commit hooks, .github/workflows/
+7. Verify: `npm run build`, `npm test`, `/forge:status`
+8. Show next steps: `/forge:discuss` → `/forge:plan` → `/forge:execute`

package/.claude/commands/forge/pause-work.md

@@ -79,7 +79,7 @@ Use when: You need to stop work mid-phase and want to resume later with full con
 
    ---
    **Paused:** {timestamp}
-   **Resume:** Run `forge resume-work`
+   **Resume:** Run `/forge:resume`
    ```
 
 4. **Git Commit**
@@ -105,7 +105,7 @@ Use when: You need to stop work mid-phase and want to resume later with full con
 </deliverables>
 
 <next_steps>
-- When ready to continue: `forge resume-work`
+- When ready to continue: `/forge:resume`
 - Handoff file will be automatically loaded
 - All context preserved
 </next_steps>

package/.claude/commands/forge/plan.md

@@ -1,144 +1,129 @@
 ---
 name: forge:plan
-description: Generate research-backed atomic task breakdown for a phase. Use when user says "forge plan <phase>" or wants to create a detailed task plan.
-argument-hint: <phase-name>
+description: Research-first multi-plan generation with wave-based execution ordering.
+argument-hint: <phase-name> [--research] [--skip-research] [--gaps] [--skip-verify]
 allowed-tools:
   - Read
   - Write
   - Bash
+  - Glob
+  - Grep
   - Task
+  - TaskCreate
+  - TeamCreate
+  - WebSearch
+  - WebFetch
+  - AskUserQuestion
 ---
 
-<objective>
-Generate atomic task breakdown (5-6 tasks max) with dependency graph for a specific phase, backed by research and verified against requirements.
-
-Purpose: Create executable plan with clear tasks, dependencies, and acceptance criteria.
-Output: PLAN.md with task breakdown, Mermaid dependency graph, and verification criteria.
-</objective>
-
-<execution_context>
-**Load these files NOW:**
-
-- @CLAUDE.md (5-6 task limit rule)
-- @REQUIREMENTS.md (Verification requirements)
-- @ROADMAP.md (Milestone context)
-- @.planning/phases/<phase>/CONTEXT.md (if exists)
-- @state/STATE.json (Current state)
-</execution_context>
-
-<context>
-**Phase:** $ARGUMENTS
-**Task Limit:** 5-6 atomic tasks maximum (FORGE hard rule)
-**Requirement:** Must verify against REQUIREMENTS.md
-
-**Planning Constraints:**
-- Tasks must be atomic (one concept, one owner)
-- Dependencies explicit and acyclic
-- Each task has clear acceptance criteria
-- Total tasks ≤ 6 (break into sub-phases if needed)
-</context>
-
-<process>
-**Execute planning workflow:**
-
-1. **Context Loading**
-   - Read CONTEXT.md if exists (from forge discuss)
-   - Load REQUIREMENTS.md for verification
-   - Check STATE.json for current milestone
-
-2. **Research Phase** (if gray areas identified)
-   ```
-   Spawn research agents for unknowns:
-   - gs-phase-researcher → domain research
-   - Returns: RESEARCH.md with findings
+Generate research-backed multi-plan breakdown for phase $ARGUMENTS. Each research finding that needs addressing becomes a separate plan file with 2-3 tasks. Plans are grouped into waves for parallel execution.
+
+**Read first:** REQUIREMENTS.md, ROADMAP.md, .planning/phases/{phase}/CONTEXT.md (if exists), state/STATE.json
+
+**Steps:**
+
+1. **Parse arguments** — Extract phase name and flags from `$ARGUMENTS`:
+   - `--research` — force re-run research even if RESEARCH.md exists
+   - `--skip-research` — skip research step entirely
+   - `--gaps` — generate gap closure plans only (used after verify)
+   - `--skip-verify` — skip plan verification step
+
+2. **Check for existing plans** — Look for `.planning/phases/{phase}/*-PLAN.md` files.
+   - If plan files exist, use AskUserQuestion with options:
+     a) "Add more plans" — continue numbering from highest existing plan number
+     b) "Verify existing plans" — route to `/forge:verify {phase}`
+     c) "Execute existing plans" — route to `/forge:execute {phase}`
+     d) "Replan from scratch" — delete existing plan files, regenerate from research
+   - If no plans exist, proceed to research.
+
+3. **Research phase** (unless `--skip-research` or `--gaps`):
+   - Check if `.planning/phases/{phase}/{phase}-RESEARCH.md` exists.
+   - If exists and no `--research` flag, ask: use existing research or re-run?
+   - If research needed, spawn a researcher agent via Task tool (subagent_type: "general-purpose"):
+     - **Researcher reads:** CONTEXT.md to constrain research scope:
+       - **Locked decisions** → research these deeply, find best practices, don't explore alternatives
+       - **Claude's discretion** → research multiple options, recommend one with rationale
+       - **Deferred ideas** → ignore completely, do not research
+     - **Researcher uses:** WebSearch (include current year in queries), WebFetch (official docs), Grep/Glob (codebase patterns to follow)
+     - **Researcher produces** `{phase}-RESEARCH.md` with sections:
+       ```
+       # {Phase} Research
+       ## User Constraints (from CONTEXT.md)
+       ## Summary
+       ## Recommended Stack (specific versions)
+       ## Architecture Patterns
+       ## Don't Hand-Roll (use existing libraries)
+       ## Common Pitfalls
+       ## Code Examples
+       ## Sources
+       [Each with confidence: HIGH | MEDIUM | LOW]
+       ```
+     - Each major research finding becomes a candidate for a separate plan
+
+4. **Generate multi-plan breakdown** — Spawn a planner agent via Task tool (subagent_type: "general-purpose"):
+   - **Planner reads:** CONTEXT.md (locked decisions), RESEARCH.md, REQUIREMENTS.md, STATE.json, existing codebase patterns
+   - **Planner decomposes** the phase into multiple plan files, each covering one coherent unit of work with 2-3 tasks
+   - **Each plan file** gets YAML frontmatter:
+     ```yaml
+     ---
+     phase: {phase-name}
+     plan: 01
+     wave: 1
+     depends_on: []
+     files_modified: [src/foo.ts, src/bar.ts]
+     autonomous: true
+     gap_closure: false
+     ---
+     ```
+   - **Plan body** contains:
+     - Objective (what this plan builds and why)
+     - Context references (which CONTEXT.md decisions apply)
+     - Tasks in XML format:
+       ```xml
+       <task name="descriptive-name" type="auto">
+         <files>src/foo.ts, src/bar.ts</files>
+         <action>What to implement, specifically</action>
+         <verify>npm test, specific checks</verify>
+         <done>Concrete completion criteria</done>
+       </task>
+       ```
+     - Success criteria for the plan as a whole
+   - **Write to:** `.planning/phases/{phase}/{phase}-01-PLAN.md`, `{phase}-02-PLAN.md`, etc.
+   - **Build dependency graph and assign waves:**
+     - Independent plans → same wave (can execute in parallel)
+     - Plans that depend on others → higher wave number
+     - `wave = max(waves[dep] for dep in depends_on) + 1`
+     - Wave 1 plans have no dependencies
+
+5. **Verify plans** (unless `--skip-verify`):
+   - Check: requirements coverage across all plans, task completeness, dependency correctness, no circular deps, scope matches CONTEXT.md (no deferred ideas included)
+   - If issues found, revision loop (max 3 iterations): targeted fixes, not full replan
+   - If passes, proceed
+
+6. **Present results:**
    ```
+   Phase {X}: {Name} — {N} plan(s) in {M} wave(s)
 
-3. **Task Generation** (5-6 task limit enforced)
+   | Wave | Plans | What it builds |
+   |------|-------|----------------|
+   | 1    | 01, 02 | [objectives]  |
+   | 2    | 03     | [objective]   |
 
-   For each task, define:
-   ```
-   - ID: milestone-number-task (e.g., api-003, ui-002)
-   - Name: Clear, concise title
-   - Owner: Specialist role
-   - Type: feat, fix, test, docs, refactor
-   - Dependencies: Array of task IDs
-   - Files: Owned file paths
-   - Contracts: Required API contracts
-   - Acceptance: Given/When/Then criteria
-   - Verify: Test command or verification method
-   ```
+   Research: {Completed | Used existing | Skipped}
+   Verification: {Passed | Skipped}
 
-4. **Dependency Graph**
-   ```mermaid
-   graph TD
-     api-001[Create user model] --> api-002[Implement user CRUD]
-     api-002 --> api-003[Add authentication]
-     core-001[Database setup] --> api-001
+   Next: /forge:execute {phase}
    ```
 
-5. **Requirements Verification**
-   - Map each task to REQUIREMENTS.md entries
-   - Ensure all requirements covered
-   - Identify gaps and add tasks as needed
-   - Verify no requirement orphaned
-
-6. **Write PLAN.md**
-   ```markdown
-   # <Phase Name> Plan
-
-   ## Overview
-   [Phase purpose and goals]
-
-   ## Tasks (5-6 max)
-   | ID | Name | Owner | Dependencies | Status |
-   |----|------|-------|--------------|--------|
-   | api-001 | ... | backend | - | pending |
-   ...
-
-   ## Dependency Graph
-   [Mermaid graph]
-
-   ## Requirements Coverage
-   - REQ-1: Covered by api-001, api-002
-   - REQ-2: Covered by core-001
-   ...
-
-   ## Definition of Done
-   - All tasks complete
-   - All tests passing
-   - Requirements verified
-   - Integration tested
-   ```
-
-7. **State Update**
-   - Submit PHASE_PLANNED event
-   - Update STATE.json with task list
-   - Add tasks to STATE.tasks array
-
-8. **Route to Execution**
-   - Offer `forge execute <phase>` to run tasks
-   - Or show manual task assignment
-</process>
-
-<deliverables>
-- .planning/phases/<phase>/PLAN.md (task breakdown)
-- Event: PHASE_PLANNED in state/events/
-- STATE.json updated with tasks
-- Requirements coverage matrix
-</deliverables>
-
-<verification>
-Before completing plan:
-- ✅ Total tasks ≤ 6
-- ✅ All tasks atomic (single owner)
-- ✅ Dependency graph acyclic
-- ✅ All requirements covered
-- ✅ Acceptance criteria defined
-- ✅ Verification methods specified
-</verification>
-
-<next_steps>
-- Run `forge execute <phase>` to execute plan with agent teams
-- Or manually assign tasks to specialists
-- Track progress with `forge status`
-</next_steps>
+**Plan frontmatter reference:**
+```yaml
+---
+phase: M2-planning-engine       # Phase identifier
+plan: 01                        # Sequential plan number
+wave: 1                         # Execution wave (parallel within wave)
+depends_on: []                  # Plan numbers this depends on
+files_modified: [src/foo.ts]    # Files this plan touches
+autonomous: true                # false if has checkpoints needing user input
+gap_closure: false              # true for gap remediation plans
+---
+```

package/.claude/commands/forge/quick.md

@@ -10,121 +10,32 @@ allowed-tools:
   - Grep
   - Bash
   - Task
+  - TaskCreate
+  - TeamCreate
   - AskUserQuestion
 ---
 
-<objective>
-Execute small, ad-hoc tasks with FORGE guarantees (atomic commits, STATE.json tracking) while skipping optional workflows.
+Execute quick ad-hoc task "$ARGUMENTS" with atomic commits and state tracking. Skips research/verification.
 
-Quick mode is the same system with a shorter path:
-- Spawns planner + executor(s)
-- Skips research, plan-checker, verifier
-- Quick tasks live in `.planning/quick/` separate from planned phases
-- Updates STATE.json "Quick Tasks Completed" table (NOT ROADMAP.md)
+**Read:** state/STATE.json
 
-Use when: You know exactly what to do and the task is small enough to not need research or verification.
-</objective>
+**Steps:**
 
-<execution_context>
-@state/STATE.json
-@CLAUDE.md
-</execution_context>
+1. Generate task ID `quick-{timestamp}`, create `.planning/quick/{taskId}/PLAN.md` with description, steps (1-3), and acceptance criteria
 
-<context>
-**Task Description:** $ARGUMENTS
+2. **Ensure FORGE team AND teammates are running:**
+   - Check `~/.claude/teams/forge/config.json` exists. If not, create team with TeamCreate.
+   - Read `.planning/AgentTeam.md` to get the list of teammates that should be active.
+   - Read `~/.claude/teams/forge/config.json` members list to see who is registered.
+   - For each teammate defined in AgentTeam.md that is NOT in the team config (or if team was just created), spawn them using the Task tool with `team_name: "forge"` and `name: "{teammate-name}"` and their full prompt from AgentTeam.md.
+   - This ensures teammates are always running when any FORGE command executes, even after session restarts.
 
-**Quick Task Workflow:**
-1. Validate task is appropriate for quick mode
-2. Create minimal task plan (1-3 atomic steps)
-3. Execute task with atomic commits
-4. Update STATE.json quick tasks table
-5. Verify with basic validation
-</context>
+3. Validate quick mode fit (well-understood, small, 1-3 steps). If too big, suggest `/forge:plan`.
 
-<process>
-**Execute quick task workflow:**
+4. Execute steps: make changes → atomic commit `feat({taskId}): {desc}` → update PLAN.md checklist after each
 
-1. **Validate Quick Mode Appropriateness**
-   Ask: "Is this task appropriate for quick mode?"
-   - Quick mode tasks should:
-     - Be well-understood (no research needed)
-     - Be small (1-3 atomic steps)
-     - Not require verification workflows
+5. Optionally delegate to teammates via TaskCreate + Task if complex enough
 
-   If task doesn't fit:
-   - Suggest: Use `forge plan <phase>` for proper planning
-   - Or: Continue with quick mode anyway
+6. Finalize PLAN.md (mark completed, list commits), update STATE.json `quickTasksCompleted` table, submit QUICK_TASK_COMPLETED event to state/events/
 
-2. **Create Quick Task Entry**
-   - Generate task ID: `quick-{timestamp}`
-   - Create quick task directory:
-     ```bash
-     mkdir -p .planning/quick/{taskId}/
-     ```
-
-3. **Generate Minimal Task Plan**
-   - Break task into 1-3 atomic steps
-   - Define acceptance criteria
-   - Identify files to change
-   - Create simple plan in `.planning/quick/{taskId}/PLAN.md`
-
-4. **Execute Task**
-   For each step:
-   - Read necessary files
-   - Make changes (Edit or Write)
-   - Run validation if applicable
-   - **Atomic commit after each step:**
-     ```bash
-     git add <changed-files>
-     git commit -m "feat({taskId}): {step-description}"
-     ```
-
-5. **Update STATE.json**
-   Add to "quickTasksCompleted" table:
-   ```json
-   {
-     "quickTasksCompleted": [
-       {
-         "taskId": "quick-{timestamp}",
-         "description": "{task-description}",
-         "completedAt": "{timestamp}",
-         "commitHash": "{hash}"
-       }
-     ]
-   }
-   ```
-
-6. **Submit Event**
-   - Event type: QUICK_TASK_COMPLETED
-   - Include: taskId, description, commitHash
-   - Write to state/events/
-
-7. **Verify**
-   - Basic validation (does it work?)
-   - No formal verification workflow in quick mode
-
-8. **Confirm**
-   - Show task completion summary
-   - List commits made
-   - Show updated STATE.json
-</process>
-
-<deliverables>
-- .planning/quick/{taskId}/PLAN.md (minimal plan)
-- Completed task with atomic commits
-- STATE.json updated (quickTasksCompleted table)
-- Event: QUICK_TASK_COMPLETED in state/events/
-</deliverables>
-
-<success_criteria>
-- [ ] Task completed successfully
-- [ ] Atomic commits for each step
-- [ ] STATE.json updated
-- [ ] Basic validation passed
-</success_criteria>
-
-<next_steps>
-- Continue with more quick tasks: `forge quick <description>`
-- Or plan a full phase: `forge plan <phase>`
-- Check progress: `forge status`
-</next_steps>
+7. Show completion summary with commits and PLAN.md location

package/.claude/commands/forge/remove-phase.md

@@ -85,7 +85,8 @@ Use when: Phase is no longer needed, duplicate, or superseded by another phase.
 </deliverables>
 
 <next_steps>
-- Review updated roadmap with `forge status`
+- Review updated roadmap with `/forge:status`
 - Update any dependent phases manually if needed
-- Continue work with `forge execute <phase>`
+- Continue work with `/forge:execute <phase-number>`
+- Tip: Use `/clear` to start from a fresh context
 </next_steps>