mindforge-cc 5.0.0 → 5.2.0

package/.agent/skills/mindforge-verify-work_extended/SKILL.md

@@ -0,0 +1,139 @@
+---
+name: mindforge-verify-work_extended
+description: Use when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions always
+---
+
+# Verification Before Completion
+
+## Overview
+
+Claiming work is complete without verification is dishonesty, not efficiency.
+
+**Core principle:** Evidence before claims, always.
+
+**Violating the letter of this rule is violating the spirit of this rule.**
+
+## The Iron Law
+
+```
+NO COMPLETION CLAIMS WITHOUT FRESH VERIFICATION EVIDENCE
+```
+
+If you haven't run the verification command in this message, you cannot claim it passes.
+
+## The Gate Function
+
+```
+BEFORE claiming any status or expressing satisfaction:
+
+1. IDENTIFY: What command proves this claim?
+2. RUN: Execute the FULL command (fresh, complete)
+3. READ: Full output, check exit code, count failures
+4. VERIFY: Does output confirm the claim?
+   - If NO: State actual status with evidence
+   - If YES: State claim WITH evidence
+5. ONLY THEN: Make the claim
+
+Skip any step = lying, not verifying
+```
+
+## Common Failures
+
+| Claim | Requires | Not Sufficient |
+|-------|----------|----------------|
+| Tests pass | Test command output: 0 failures | Previous run, "should pass" |
+| Linter clean | Linter output: 0 errors | Partial check, extrapolation |
+| Build succeeds | Build command: exit 0 | Linter passing, logs look good |
+| Bug fixed | Test original symptom: passes | Code changed, assumed fixed |
+| Regression test works | Red-green cycle verified | Test passes once |
+| Agent completed | VCS diff shows changes | Agent reports "success" |
+| Requirements met | Line-by-line checklist | Tests passing |
+
+## Red Flags - STOP
+
+- Using "should", "probably", "seems to"
+- Expressing satisfaction before verification ("Great!", "Perfect!", "Done!", etc.)
+- About to commit/push/PR without verification
+- Trusting agent success reports
+- Relying on partial verification
+- Thinking "just this once"
+- Tired and wanting work over
+- **ANY wording implying success without having run verification**
+
+## Rationalization Prevention
+
+| Excuse | Reality |
+|--------|---------|
+| "Should work now" | RUN the verification |
+| "I'm confident" | Confidence ≠ evidence |
+| "Just this once" | No exceptions |
+| "Linter passed" | Linter ≠ compiler |
+| "Agent said success" | Verify independently |
+| "I'm tired" | Exhaustion ≠ excuse |
+| "Partial check is enough" | Partial proves nothing |
+| "Different words so rule doesn't apply" | Spirit over letter |
+
+## Key Patterns
+
+**Tests:**
+```
+✅ [Run test command] [See: 34/34 pass] "All tests pass"
+❌ "Should pass now" / "Looks correct"
+```
+
+**Regression tests (TDD Red-Green):**
+```
+✅ Write → Run (pass) → Revert fix → Run (MUST FAIL) → Restore → Run (pass)
+❌ "I've written a regression test" (without red-green verification)
+```
+
+**Build:**
+```
+✅ [Run build] [See: exit 0] "Build passes"
+❌ "Linter passed" (linter doesn't check compilation)
+```
+
+**Requirements:**
+```
+✅ Re-read plan → Create checklist → Verify each → Report gaps or completion
+❌ "Tests pass, phase complete"
+```
+
+**Agent delegation:**
+```
+✅ Agent reports success → Check VCS diff → Verify changes → Report actual state
+❌ Trust agent report
+```
+
+## Why This Matters
+
+From 24 failure memories:
+- your human partner said "I don't believe you" - trust broken
+- Undefined functions shipped - would crash
+- Missing requirements shipped - incomplete features
+- Time wasted on false completion → redirect → rework
+- Violates: "Honesty is a core value. If you lie, you'll be replaced."
+
+## When To Apply
+
+**ALWAYS before:**
+- ANY variation of success/completion claims
+- ANY expression of satisfaction
+- ANY positive statement about work state
+- Committing, PR creation, task completion
+- Moving to next task
+- Delegating to agents
+
+**Rule applies to:**
+- Exact phrases
+- Paraphrases and synonyms
+- Implications of success
+- ANY communication suggesting completion/correctness
+
+## The Bottom Line
+
+**No shortcuts for verification.**
+
+Run the command. Read the output. THEN claim the result.
+
+This is non-negotiable.

package/.agent/skills/mindforge-workspace-isolated/SKILL.md

@@ -0,0 +1,218 @@
+---
+name: using-git-worktrees
+description: Use when starting feature work that needs isolation from current workspace or before executing implementation plans - creates isolated git worktrees with smart directory selection and safety verification
+---
+
+# Using Git Worktrees
+
+## Overview
+
+Git worktrees create isolated workspaces sharing the same repository, allowing work on multiple branches simultaneously without switching.
+
+**Core principle:** Systematic directory selection + safety verification = reliable isolation.
+
+**Announce at start:** "I'm using the using-git-worktrees skill to set up an isolated workspace."
+
+## Directory Selection Process
+
+Follow this priority order:
+
+### 1. Check Existing Directories
+
+```bash
+# Check in priority order
+ls -d .worktrees 2>/dev/null     # Preferred (hidden)
+ls -d worktrees 2>/dev/null      # Alternative
+```
+
+**If found:** Use that directory. If both exist, `.worktrees` wins.
+
+### 2. Check CLAUDE.md
+
+```bash
+grep -i "worktree.*director" CLAUDE.md 2>/dev/null
+```
+
+**If preference specified:** Use it without asking.
+
+### 3. Ask User
+
+If no directory exists and no CLAUDE.md preference:
+
+```
+No worktree directory found. Where should I create worktrees?
+
+1. .worktrees/ (project-local, hidden)
+2. ~/.config/mindforge/worktrees/<project-name>/ (global location)
+
+Which would you prefer?
+```
+
+## Safety Verification
+
+### For Project-Local Directories (.worktrees or worktrees)
+
+**MUST verify directory is ignored before creating worktree:**
+
+```bash
+# Check if directory is ignored (respects local, global, and system gitignore)
+git check-ignore -q .worktrees 2>/dev/null || git check-ignore -q worktrees 2>/dev/null
+```
+
+**If NOT ignored:**
+
+Per Jesse's rule "Fix broken things immediately":
+1. Add appropriate line to .gitignore
+2. Commit the change
+3. Proceed with worktree creation
+
+**Why critical:** Prevents accidentally committing worktree contents to repository.
+
+### For Global Directory (~/.config/mindforge/worktrees)
+
+No .gitignore verification needed - outside project entirely.
+
+## Creation Steps
+
+### 1. Detect Project Name
+
+```bash
+project=$(basename "$(git rev-parse --show-toplevel)")
+```
+
+### 2. Create Worktree
+
+```bash
+# Determine full path
+case $LOCATION in
+  .worktrees|worktrees)
+    path="$LOCATION/$BRANCH_NAME"
+    ;;
+  ~/.config/mindforge/worktrees/*)
+    path="~/.config/mindforge/worktrees/$project/$BRANCH_NAME"
+    ;;
+esac
+
+# Create worktree with new branch
+git worktree add "$path" -b "$BRANCH_NAME"
+cd "$path"
+```
+
+### 3. Run Project Setup
+
+Auto-detect and run appropriate setup:
+
+```bash
+# Node.js
+if [ -f package.json ]; then npm install; fi
+
+# Rust
+if [ -f Cargo.toml ]; then cargo build; fi
+
+# Python
+if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
+if [ -f pyproject.toml ]; then poetry install; fi
+
+# Go
+if [ -f go.mod ]; then go mod download; fi
+```
+
+### 4. Verify Clean Baseline
+
+Run tests to ensure worktree starts clean:
+
+```bash
+# Examples - use project-appropriate command
+npm test
+cargo test
+pytest
+go test ./...
+```
+
+**If tests fail:** Report failures, ask whether to proceed or investigate.
+
+**If tests pass:** Report ready.
+
+### 5. Report Location
+
+```
+Worktree ready at <full-path>
+Tests passing (<N> tests, 0 failures)
+Ready to implement <feature-name>
+```
+
+## Quick Reference
+
+| Situation | Action |
+|-----------|--------|
+| `.worktrees/` exists | Use it (verify ignored) |
+| `worktrees/` exists | Use it (verify ignored) |
+| Both exist | Use `.worktrees/` |
+| Neither exists | Check CLAUDE.md → Ask user |
+| Directory not ignored | Add to .gitignore + commit |
+| Tests fail during baseline | Report failures + ask |
+| No package.json/Cargo.toml | Skip dependency install |
+
+## Common Mistakes
+
+### Skipping ignore verification
+
+- **Problem:** Worktree contents get tracked, pollute git status
+- **Fix:** Always use `git check-ignore` before creating project-local worktree
+
+### Assuming directory location
+
+- **Problem:** Creates inconsistency, violates project conventions
+- **Fix:** Follow priority: existing > CLAUDE.md > ask
+
+### Proceeding with failing tests
+
+- **Problem:** Can't distinguish new bugs from pre-existing issues
+- **Fix:** Report failures, get explicit permission to proceed
+
+### Hardcoding setup commands
+
+- **Problem:** Breaks on projects using different tools
+- **Fix:** Auto-detect from project files (package.json, etc.)
+
+## Example Workflow
+
+```
+You: I'm using the using-git-worktrees skill to set up an isolated workspace.
+
+[Check .worktrees/ - exists]
+[Verify ignored - git check-ignore confirms .worktrees/ is ignored]
+[Create worktree: git worktree add .worktrees/auth -b feature/auth]
+[Run npm install]
+[Run npm test - 47 passing]
+
+Worktree ready at /Users/jesse/myproject/.worktrees/auth
+Tests passing (47 tests, 0 failures)
+Ready to implement auth feature
+```
+
+## Red Flags
+
+**Never:**
+- Create worktree without verifying it's ignored (project-local)
+- Skip baseline test verification
+- Proceed with failing tests without asking
+- Assume directory location when ambiguous
+- Skip CLAUDE.md check
+
+**Always:**
+- Follow directory priority: existing > CLAUDE.md > ask
+- Verify directory is ignored for project-local
+- Auto-detect and run project setup
+- Verify clean test baseline
+
+## Integration
+
+**Called by:**
+- **brainstorming** (Phase 4) - REQUIRED when design is approved and implementation follows
+- **mindforge-swarm-execution** - REQUIRED before executing any tasks
+- **mindforge-execute-phase_extended** - REQUIRED before executing any tasks
+- Any skill needing isolated workspace
+
+**Pairs with:**
+- **mindforge-ship_extended** - REQUIRED for cleanup after work complete

package/.agent/workflows/mindforge-verify-work.md

@@ -4,6 +4,11 @@ Validate built features through conversational testing with persistent state. Cr
 User tests, the agent records. One test at a time. Plain text responses.
 </purpose>
 
+## Step 0 — Protocol Activation
+
+**MANDATORY**: Invoke the `mindforge-verify-work_extended` skill.
+This ensures the verification process uses rigorous multi-dimensional UAT, automated smoke tests, and parallel diagnosis for any issues found.
+
 <philosophy>
 **Show expected, ask if reality matches.**
 

package/.agent/workflows/mindforge:brainstorming.md

@@ -0,0 +1,16 @@
+---
+description: You MUST use this before any creative work - creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements and design before implementation.
+---
+# 🧠 /mindforge:brainstorming
+
+## Step 0 — Protocol Activation
+
+**MANDATORY**: Invoke the `mindforge-brainstorming` skill.
+This ensures the creative exploration, architectural trade-offs, and requirement gathering are handled with maximum depth.
+
+## Process
+
+1. **Intake**: Gather the core idea or feature request from the user.
+2. **Exploration**: Use the brainstorming skill to explore the "Why", "How", and "What".
+3. **Refinement**: Narrow down the options to a concrete architectural direction.
+4. **Handoff**: Generate a prompt or a requirements fragment for the next planning phase.

package/.agent/workflows/mindforge:debug.md

@@ -8,8 +8,10 @@ Systematic debugging using the Debug Specialist persona with full RCA protocol.
 
 ## Activation
 
-Load `.mindforge/personas/debug-specialist.md` immediately.
-This command runs entirely in that persona for its full duration.
+## Step 0 — Activate Extended Debugging Protocol
+
+**MANDATORY**: Invoke the `mindforge-debug_extended` skill.
+This ensures the full scientific root-cause investigation depth is applied to this session.
 
 ## Step 1 — Intake
 

package/.agent/workflows/mindforge:execute-phase.md

@@ -4,6 +4,12 @@ description: 1. Read STATE.md — confirm phase [N] is in "planned" status.
 # MindForge — Execute Phase Command
 # Usage: /mindforge:execute-phase [N]
 
+## Step 0 — Protocol Activation
+
+**MANDATORY**: Invoke the following skills before proceeding:
+1. `mindforge-execute-phase_extended`: For tactical execution depth.
+2. `mindforge-parallel-mesh_extended`: To manage the swarm clusters and parallel waves.
+
 ## Pre-checks (all must pass before execution starts)
 
 1. Read STATE.md — confirm phase [N] is in "planned" status.
@@ -109,6 +115,12 @@ After all tasks in wave complete:
 
 ## Step 4 — Phase-level verification
 
+## Step 0 — Protocol Activation
+
+**MANDATORY**: Invoke the `mindforge-execute-phase_extended` skill.
+For parallel tasks, also activate `mindforge-parallel-mesh_extended` and `mindforge-swarm-execution`.
+This ensures the implementation uses wave-based parallelization and review-inbound checkpoints.
+
 After all waves complete, run the verification pipeline:
 
 1. Read every v1 requirement from REQUIREMENTS.md for this phase

package/.agent/workflows/mindforge:plan-phase.md

@@ -3,6 +3,17 @@ description: Plan a project phase. Usage: /mindforge:plan-phase [N]
 ---
 Plan a project phase. Usage: /mindforge:plan-phase [N]
 
+<purpose>
+Create a detailed execution plan (PLAN.md) from requirements, including technical strategy and wave-based task decomposition.
+</purpose>
+
+## Step 0 — Protocol Activation
+
+**MANDATORY**: Invoke the `mindforge-plan-phase_extended` skill.
+This ensures the planning process uses atomic task decomposition, risk assessment, and peer-review ready documentation.
+
+<process>
+
 ## Pre-check
 If N is not given, read STATE.md for the current phase number and increment by 1.
 Read PROJECT.md, REQUIREMENTS.md, ARCHITECTURE.md, and STATE.md before proceeding.

package/.agent/workflows/mindforge:ship.md

@@ -1,8 +1,13 @@
 ---
-description: Create a release PR for a verified phase. Usage: /mindforge:ship [N]
+description: Create a pull request from completed phase/milestone work, generate a rich PR body from planning artifacts, optionally run code review, and prepare for merge. Closes the plan → execute → verify → ship loop.
 ---
 Create a release PR for a verified phase. Usage: /mindforge:ship [N]
 
+## Step 0 — Protocol Activation
+
+**MANDATORY**: Invoke the `mindforge-ship_extended` skill.
+This ensures the shipping process uses rigorous quality gates, branch sanitization, and automated PR body generation.
+
 ## Pre-check
 Read UAT.md for phase N. If status is not "All passed ✅": stop.
 Tell the user: "Phase [N] has not been fully verified. Run /mindforge:verify-phase [N] first."

package/.agent/workflows/mindforge:tdd.md

@@ -8,16 +8,21 @@ Execute a strict Test-Driven Development (TDD) loop using the Red-Green-Refactor
 </instruction>
 
 <context>
-Follow the specialized MindForge TDD standards defined in [.agent/skills/mindforge-tdd/SKILL.md](.agent/skills/mindforge-tdd/SKILL.md).
+Follow the specialized MindForge TDD standards defined in [.agent/skills/mindforge-tdd_extended/SKILL.md](.agent/skills/mindforge-tdd_extended/SKILL.md).
 </context>
 
 <rules>
 - **No Implementation without Test**: Do not write production code unless it is to make a failing test pass.
 - **Minimalist Green**: Write the absolute minimum code required to satisfy the test.
 - **Refactor Ruthlessly**: Clean up after every green state while keeping tests passing.
-- **Vertical Slicing**: Prioritize end-to-end functionality over horizontal layers.
+- **Vertical Slicing**: Strict Red-Green-Refactor development. Ensure test coverage before implementation logic.
 </rules>
 
+## Step 0 — Protocol Activation
+
+**MANDATORY**: Invoke the `mindforge-tdd_extended` skill.
+This ensures the implementation uses isolated test-first logic and anti-pattern detection.
+
 <process>
 1.  **RED**: Define a single behavioral requirement and write a failing test.
 2.  **GREEN**: Implement the simplest code to fix the failure.