mindforge-cc 9.0.0 → 10.0.1

package/.agent/workflows/mindforge-plant-seed.md

@@ -1,169 +0,0 @@
-<purpose>
-Capture a forward-looking idea as a structured seed file with trigger conditions.
-Seeds auto-surface during /mindforge-new-milestone when trigger conditions match the
-new milestone's scope.
-
-Seeds beat deferred items because they:
-- Preserve WHY the idea matters (not just WHAT)
-- Define WHEN to surface (trigger conditions, not manual scanning)
-- Track breadcrumbs (code references, related decisions)
-- Auto-present at the right time via new-milestone scan
-</purpose>
-
-<process>
-
-<step name="parse_idea">
-Parse `$ARGUMENTS` for the idea summary.
-
-If empty, ask:
-```
-What's the idea? (one sentence)
-```
-
-Store as `$IDEA`.
-</step>
-
-<step name="create_seed_dir">
-```bash
-mkdir -p .planning/seeds
-```
-</step>
-
-<step name="gather_context">
-Ask focused questions to build a complete seed:
-
-```
-AskUserQuestion(
-  header: "Trigger",
-  question: "When should this idea surface? (e.g., 'when we add user accounts', 'next major version', 'when performance becomes a priority')",
-  options: []  // freeform
-)
-```
-
-Store as `$TRIGGER`.
-
-```
-AskUserQuestion(
-  header: "Why",
-  question: "Why does this matter? What problem does it solve or what opportunity does it create?",
-  options: []
-)
-```
-
-Store as `$WHY`.
-
-```
-AskUserQuestion(
-  header: "Scope",
-  question: "How big is this? (rough estimate)",
-  options: [
-    { label: "Small", description: "A few hours — could be a quick task" },
-    { label: "Medium", description: "A phase or two — needs planning" },
-    { label: "Large", description: "A full milestone — significant effort" }
-  ]
-)
-```
-
-Store as `$SCOPE`.
-</step>
-
-<step name="collect_breadcrumbs">
-Search the codebase for relevant references:
-
-```bash
-# Find files related to the idea keywords
-grep -rl "$KEYWORD" --include="*.ts" --include="*.js" --include="*.md" . 2>/dev/null | head -10
-```
-
-Also check:
-- Current STATE.md for related decisions
-- ROADMAP.md for related phases
-- todos/ for related captured ideas
-
-Store relevant file paths as `$BREADCRUMBS`.
-</step>
-
-<step name="generate_seed_id">
-```bash
-# Find next seed number
-EXISTING=$(ls .planning/seeds/SEED-*.md 2>/dev/null | wc -l)
-NEXT=$((EXISTING + 1))
-PADDED=$(printf "%03d" $NEXT)
-```
-
-Generate slug from idea summary.
-</step>
-
-<step name="write_seed">
-Write `.planning/seeds/SEED-{PADDED}-{slug}.md`:
-
-```markdown
----
-id: SEED-{PADDED}
-status: dormant
-planted: {ISO date}
-planted_during: {current milestone/phase from STATE.md}
-trigger_when: {$TRIGGER}
-scope: {$SCOPE}
----
-
-# SEED-{PADDED}: {$IDEA}
-
-## Why This Matters
-
-{$WHY}
-
-## When to Surface
-
-**Trigger:** {$TRIGGER}
-
-This seed should be presented during `/mindforge-new-milestone` when the milestone
-scope matches any of these conditions:
-- {trigger condition 1}
-- {trigger condition 2}
-
-## Scope Estimate
-
-**{$SCOPE}** — {elaboration based on scope choice}
-
-## Breadcrumbs
-
-Related code and decisions found in the current codebase:
-
-{list of $BREADCRUMBS with file paths}
-
-## Notes
-
-{any additional context from the current session}
-```
-</step>
-
-<step name="commit_seed">
-```bash
-node ".agent/bin/mindforge-tools.cjs" commit "docs: plant seed — {$IDEA}" --files .planning/seeds/SEED-{PADDED}-{slug}.md
-```
-</step>
-
-<step name="confirm">
-```
-✅ Seed planted: SEED-{PADDED}
-
-"{$IDEA}"
-Trigger: {$TRIGGER}
-Scope: {$SCOPE}
-File: .planning/seeds/SEED-{PADDED}-{slug}.md
-
-This seed will surface automatically when you run /mindforge-new-milestone
-and the milestone scope matches the trigger condition.
-```
-</step>
-
-</process>
-
-<success_criteria>
-- [ ] Seed file created in .planning/seeds/
-- [ ] Frontmatter includes status, trigger, scope
-- [ ] Breadcrumbs collected from codebase
-- [ ] Committed to git
-- [ ] User shown confirmation with trigger info
-</success_criteria>

package/.agent/workflows/mindforge-pr-branch.md

@@ -1,129 +0,0 @@
-<purpose>
-Create a clean branch for pull requests by filtering out .planning/ commits.
-The PR branch contains only code changes — reviewers don't see MindForge artifacts
-(PLAN.md, SUMMARY.md, STATE.md, CONTEXT.md, etc.).
-
-Uses git cherry-pick with path filtering to rebuild a clean history.
-</purpose>
-
-<process>
-
-<step name="detect_state">
-Parse `$ARGUMENTS` for target branch (default: `main`).
-
-```bash
-CURRENT_BRANCH=$(git branch --show-current)
-TARGET=${1:-main}
-```
-
-Check preconditions:
-- Must be on a feature branch (not main/master)
-- Must have commits ahead of target
-
-```bash
-AHEAD=$(git rev-list --count "$TARGET".."$CURRENT_BRANCH" 2>/dev/null)
-if [ "$AHEAD" = "0" ]; then
-  echo "No commits ahead of $TARGET — nothing to filter."
-  exit 0
-fi
-```
-
-Display:
-```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- MindForge ► PR BRANCH
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-Branch: {CURRENT_BRANCH}
-Target: {TARGET}
-Commits: {AHEAD} ahead
-```
-</step>
-
-<step name="analyze_commits">
-Classify commits:
-
-```bash
-# Get all commits ahead of target
-git log --oneline "$TARGET".."$CURRENT_BRANCH" --no-merges
-```
-
-For each commit, check if it ONLY touches .planning/ files:
-
-```bash
-# For each commit hash
-FILES=$(git diff-tree --no-commit-id --name-only -r $HASH)
-ALL_PLANNING=$(echo "$FILES" | grep -v "^\.planning/" | wc -l)
-```
-
-Classify:
-- **Code commits**: Touch at least one non-.planning/ file → INCLUDE
-- **Planning-only commits**: Touch only .planning/ files → EXCLUDE
-- **Mixed commits**: Touch both → INCLUDE (planning changes come along)
-
-Display analysis:
-```
-Commits to include: {N} (code changes)
-Commits to exclude: {N} (planning-only)
-Mixed commits: {N} (code + planning — included)
-```
-</step>
-
-<step name="create_pr_branch">
-```bash
-PR_BRANCH="${CURRENT_BRANCH}-pr"
-
-# Create PR branch from target
-git checkout -b "$PR_BRANCH" "$TARGET"
-```
-
-Cherry-pick only code commits (in order):
-
-```bash
-for HASH in $CODE_COMMITS; do
-  git cherry-pick "$HASH" --no-commit
-  # Remove any .planning/ files that came along in mixed commits
-  git rm -r --cached .planning/ 2>/dev/null || true
-  git commit -C "$HASH"
-done
-```
-
-Return to original branch:
-```bash
-git checkout "$CURRENT_BRANCH"
-```
-</step>
-
-<step name="verify">
-```bash
-# Verify no .planning/ files in PR branch
-PLANNING_FILES=$(git diff --name-only "$TARGET".."$PR_BRANCH" | grep "^\.planning/" | wc -l)
-TOTAL_FILES=$(git diff --name-only "$TARGET".."$PR_BRANCH" | wc -l)
-PR_COMMITS=$(git rev-list --count "$TARGET".."$PR_BRANCH")
-```
-
-Display results:
-```
-✅ PR branch created: {PR_BRANCH}
-
-Original: {AHEAD} commits, {ORIGINAL_FILES} files
-PR branch: {PR_COMMITS} commits, {TOTAL_FILES} files
-Planning files: {PLANNING_FILES} (should be 0)
-
-Next steps:
-  git push origin {PR_BRANCH}
-  gh pr create --base {TARGET} --head {PR_BRANCH}
-
-Or use /mindforge-ship to create the PR automatically.
-```
-</step>
-
-</process>
-
-<success_criteria>
-- [ ] PR branch created from target
-- [ ] Planning-only commits excluded
-- [ ] No .planning/ files in PR branch diff
-- [ ] Commit messages preserved from original
-- [ ] User shown next steps
-</success_criteria>