mother-brain 0.0.26 → 0.0.31

package/dist/cli.js

@@ -653,7 +653,7 @@ async function uninstall(options) {
 // src/cli.ts
 import { exec as exec3 } from "child_process";
 var program = new Command();
-var VERSION = "0.0.26";
+var VERSION = "0.0.31";
 program.name("mother-brain").description("AI-powered project management framework for GitHub Copilot CLI").version(VERSION);
 program.command("init").description("Initialize Mother Brain in the current project").option("-f, --force", "Overwrite existing skills").action(init);
 program.command("update").description("Update Mother Brain skills to the latest version").action(update);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mother-brain",
-  "version": "0.0.26",
+  "version": "0.0.31",
   "description": "AI-powered project management framework for GitHub Copilot CLI",
   "type": "module",
   "main": "dist/index.js",

package/skills/mother-brain/SKILL.md

@@ -482,11 +482,29 @@ This pattern ensures NO workflow ever traps the user—there's always an escape
    - **Minimal detection**: For new project detection, a single glob for `.mother-brain/` is sufficient
    - Goal: User sees menu within 1-2 tool calls, not 6+
    
-   **📦 SILENT AUTO-UPDATE (on startup, if project exists)**:
+   **📦 AUTO-UPDATE CHECK (on startup, if project exists)**:
    - If `.mother-brain/version.json` exists:
      1. Read installed version from file
      2. Check npm for latest: `npm view mother-brain version --json 2>$null`
-     3. If newer version available, **auto-update silently**:
+     3. If newer version available:
+        
+        **STEP A: Capture Local Improvements FIRST (before updating)**
+        - Check if user modified Mother Brain skills:
+          - Compare `.github/skills/mother-brain/SKILL.md` to npm version
+          - Use `git diff --stat` if available, or file size/hash comparison
+        - If modifications detected:
+          ```
+          📤 You've made improvements to Mother Brain!
+          
+          Before updating, I'll submit your changes as suggestions.
+          ```
+          - Run Step 2A.1 flow (automatic improvement submission):
+            - Extract diff/changes from local vs npm version
+            - Create GitHub issue on superdenby/MotherBrain
+            - Display: "✅ Improvement submitted as issue #[N]"
+          - Store improvement record in `.mother-brain/improvements-submitted.json`
+        
+        **STEP B: Update to Latest Version**
         - Run PowerShell to fetch and replace skills in one operation:
           ```powershell
           # Create temp dir, download, extract, copy skills, cleanup
@@ -504,12 +522,30 @@ This pattern ensures NO workflow ever traps the user—there's always an escape
           @{version=$latest} | ConvertTo-Json | Set-Content ".mother-brain\version.json"
           Remove-Item $temp -Recurse -Force
           ```
-        - Display brief confirmation after ASCII art:
+        
+        **STEP C: Preserve Project-Specific Files (NEVER overwritten)**
+        - These are NEVER touched during update:
+          - `.mother-brain/` folder (all project state)
+          - `.mother-brain/project-brain.md` (project learnings)
+          - `.mother-brain/docs/` (vision, roadmap, tasks)
+          - `.github/skills/` files that are NOT mother-brain/child-brain/skill-creator
+          - Project-specific skills remain untouched
+        
+        **STEP D: Restart Required**
+        - **CRITICAL: After updating, STOP and display restart message**:
           ```
-          ✅ Auto-updated to Mother Brain v[latest]
+          ⚠️ Mother Brain Updated to v[latest]
+          
+          ✅ Your improvements have been submitted as suggestions
+          ✅ Your project files are preserved
+          ✅ New Mother Brain skills installed
+          
+          👉 Please run /mother-brain again to use the new features.
           ```
+        - **DO NOT continue with the menu** - the user must restart for new features to take effect
+        - STOP execution here
      4. If check fails (offline), skip silently - don't block startup
-   - This entire check should complete in under 5 seconds and never block the menu
+     5. If already on latest version, continue silently
    
    - Check current directory for existing Mother Brain artifacts
    - Look for:
@@ -521,6 +557,16 @@ This pattern ensures NO workflow ever traps the user—there's always an escape
    
    **If project exists:**
    - Load session state from `docs/session-state.json`
+   
+   - **Git Check (ensure git is available)**:
+     - Check if `.git` folder exists in project root
+     - If NOT exists:
+       ```
+       ⚠️ Git repository not found - initializing...
+       ```
+       - Run: `git init && git add . && git commit -m "Initialize git for Mother Brain"`
+       - Display: "✅ Git repository initialized"
+     - Git is required for improvement submissions and change tracking
 
    - Display welcome back message:
      ```
@@ -1270,7 +1316,23 @@ This pattern ensures NO workflow ever traps the user—there's always an escape
    
    **Purpose**: One-click release - commit, version bump, push, tag, and publish.
    
-   **Prerequisite**: Must be in the mother-brain folder (not a project folder)
+   **Prerequisite**: Must be in the mother-brain framework folder (not a project folder)
+   
+   **⚡ MANDATORY RELEASE CHECKLIST (All items MUST be completed)**
+   
+   Every release MUST update ALL of the following:
+   ```
+   [ ] cli/package.json - version field
+   [ ] cli/src/cli.ts - version constant (if exists)
+   [ ] README.md - version badge AND version text
+   [ ] Git commit with changes
+   [ ] Git tag (v0.0.X)
+   [ ] Push to remote (main + tags)
+   [ ] GitHub Release (created automatically by workflow)
+   [ ] npm publish (triggered by tag push via workflow)
+   ```
+   
+   **⛔ BLOCKING RULE**: Do NOT return to menu until ALL items above are completed.
    
    **⚡ ONE-CLICK RELEASE FLOW (No prompts, no menus)**
    
@@ -1283,38 +1345,50 @@ This pattern ensures NO workflow ever traps the user—there's always an escape
    - If no changes: Display "Nothing to release" and return to menu
    
    **Step 2D.2: Auto-Determine Version**
-   - Read current version from `package.json`
-   - Scan learning-log.md entries since last release tag
+   - Read current version from `cli/package.json`
+   - Scan learning-log.md entries since last release tag (if exists)
    - **Auto-determine version bump**:
      - If any entry contains "breaking" or "major" → **major** bump (X.0.0)
      - If any entry contains "feature", "new", "add" → **minor** bump (0.X.0)
      - Otherwise → **patch** bump (0.0.X)
    - Do NOT ask user - auto-decide based on content
    
-   **Step 2D.3: Execute Release (all at once)**
-   - Stage all changes: `git add .`
-   - Auto-generate commit message from learning-log entries
-   - Commit: `git commit -m "[auto-generated message]"`
-   - Update `package.json` with new version
-   - Update README.md version badge (find `version-X.X.X-blue` and replace)
-   - Commit version bump: `git commit -am "chore: bump version to [version]"`
-   - Push to main: `git push super-state main`
-   - Create tag: `git tag -a "v[version]" -m "Release v[version]: [summary]"`
-   - Push tag: `git push super-state "v[version]"`
-   - Create GitHub Release: `gh release create "v[version]" ...`
-   
-   **Step 2D.4: Confirmation**
+   **Step 2D.3: Update ALL Version References (MANDATORY)**
+   - Update `cli/package.json`: `"version": "[new-version]"`
+   - Update `cli/src/cli.ts`: version constant (search for old version, replace with new)
+   - Update `README.md`:
+     - Find `version-X.X.X-blue` badge and replace with new version
+     - Find `**Version**: X.X.X` text and replace with new version
+   - **Verify all files updated before proceeding**
+   
+   **Step 2D.4: Sync Skills to CLI**
+   - Copy `.github/skills/*` to `cli/skills/` (overwrite)
+   
+   **Step 2D.5: Build CLI**
+   - Run `cd cli && npm run build`
+   - If build fails: STOP and display error
+   
+   **Step 2D.6: Execute Git Operations**
+   - Stage all changes: `git add -A`
+   - Commit: `git commit -m "[type]: [description] (v[version])"`
+   - Create tag: `git tag v[version]`
+   - Push to remote: `git push [remote] main --tags`
+   
+   **Step 2D.7: Confirmation**
+   - Wait for workflow to complete (or check status)
    - Display:
      ```
      ✅ Release v[version] Published!
      
-     Tag: v[version]
-     Release: https://github.com/super-state/mother-brain/releases/tag/v[version]
-     
-     Changes:
-     - [Brief summary from learning-log]
+     ✅ cli/package.json updated
+     ✅ cli/src/cli.ts updated
+     ✅ README.md updated
+     ✅ Git tag created and pushed
+     ✅ GitHub Release created (via workflow)
+     ✅ npm publish triggered (via workflow)
      
-     The framework update is now live!
+     Tag: v[version]
+     Release: https://github.com/superdenby/MotherBrain/releases/tag/v[version]
      ```
    
    - Use `ask_user` with choices:
@@ -1854,22 +1928,37 @@ This pattern ensures NO workflow ever traps the user—there's always an escape
    
    - **Note**: Project-specific skills created during Step 6 go in project's `.github/skills/`. Core skills are accessed from the framework.
    
-   **Step 3.6.4: Initialize Git (Optional)**
-   - Use `ask_user` with choices:
-     - "Initialize new git repo"
-     - "I'll connect to an existing repo later"
-     - "Skip git setup for now"
+   **Step 3.6.4: Initialize Git (MANDATORY)**
+   - Git is REQUIRED for Mother Brain to function properly:
+     - Improvement submissions require git diff
+     - Version tracking requires git tags
+     - Change detection requires git status
    
-   - If "Initialize new git repo":
+   - Check if git is already initialized:
      ```powershell
-     Set-Location "[project-path]"
-     git init
-     git add .
-     git commit -m "Initial project setup from Mother Brain"
+     $gitExists = Test-Path (Join-Path "[project-path]" ".git")
      ```
    
+   - If git already exists:
+     - Display: "✅ Git repository detected"
+     - Skip initialization
+   
+   - If git does NOT exist:
+     - Initialize automatically:
+       ```powershell
+       Set-Location "[project-path]"
+       git init
+       git add .
+       git commit -m "Initial project setup from Mother Brain"
+       ```
+     - Display: "✅ Git repository initialized"
+   
+   - Use `ask_user` with choices:
+     - "Continue (git is ready)"
+     - "I want to connect to a remote repository"
+   
    - If user wants to connect existing repo:
-     - Ask for repo URL
+     - Ask for repo URL with `ask_user` freeform
      - `git remote add origin [url]`
    
    **Step 3.6.5: Switch Context to Project Folder**
@@ -2821,24 +2910,26 @@ This pattern ensures NO workflow ever traps the user—there's always an escape
    - Update task document with final status
    - Update roadmap checklist
    
-   **⚠️ CRITICAL: After marking task complete, IMMEDIATELY proceed to Step 11 (Next Action Menu) using `ask_user` with proper choices. NEVER provide plain text options like "Continue or do something else?" - always use the structured menu.**
+   **⚠️ CRITICAL: After marking task complete, proceed through Steps 10B, 10C, and optionally 10D before reaching Step 11.**
    
-   **⛔ BLOCKING GATE - Step 10B is MANDATORY:**
+   **⛔ BLOCKING GATE - Steps 10B and 10C are MANDATORY:**
    ```
    Task marked complete by user
        ↓
-   [STOP] Run Step 10B (Post-Task Reflection) ← YOU ARE HERE
+   [STOP] Run Step 10B (Post-Task Reflection) ← Friction analysis via Child Brain
+       ↓
+   [STOP] Run Step 10C (Project Brain Checkpoint) ← Update living documentation
        ↓
-   Step 10B complete (friction logged or "none found" displayed)
+   IF last task in phase → Run Step 10D (Phase Feedback Checkpoint)
        ↓
    ONLY THEN proceed to Step 11 (Next Action Menu)
    ```
    
-   **DO NOT skip Step 10B.** Even if the task had no issues, Step 10B must:
-   1. Scan conversation for friction points (adjustments, errors, retries)
-   2. Display findings: "🔍 Post-Task Reflection - [X] friction points found" OR "🔍 Post-Task Reflection - No friction points found"
-   3. Apply any learnings (if friction found)
-   4. Only AFTER Step 10B completes → proceed to Step 11
+   **DO NOT skip Steps 10B or 10C.** Even if the task had no issues:
+   1. Step 10B: Scan for friction, invoke Child Brain if found
+   2. Step 10C: Update project documentation silently
+   3. Step 10D: If phase complete, gather user feedback
+   4. Only AFTER all checkpoints → proceed to Step 11
 
 ### 10A. **Friction Analysis via Child Brain**
    - When user provides negative/adjustment feedback in task validation:
@@ -2935,10 +3026,126 @@ This pattern ensures NO workflow ever traps the user—there's always an escape
    🛠️ SKILLS: [Created/updated - or "No skill changes"]
    ```
    
-   Proceed to Step 11 (Next Action Menu)
+   Proceed to Step 10C (Project Brain Checkpoint)
    
    **Key Principle**: Child Brain handles ALL learning analysis. Mother Brain only orchestrates when to invoke it.
 
+### 10C. **Project Brain Checkpoint** (Living Documentation)
+   - **When to run**: After Step 10B (Post-Task Reflection) completes
+   - **Purpose**: Silently update project documentation to ensure project stays on track
+   
+   **Step 10C.1: Check Project Alignment (Silent)**
+   
+   - Compare current progress against vision:
+     1. Load `vision.md` - what user wanted
+     2. Load `roadmap.md` - what's planned
+     3. Check completed tasks - what's been delivered
+     4. Identify gaps or drift
+   
+   **Step 10C.2: Update Living Documentation**
+   
+   Create/update these files in `.mother-brain/docs/` as needed:
+   
+   - **`research/[topic].md`** - Domain research findings
+     - Add research conducted during this task
+     - Note sources, best practices discovered
+     - Flag areas needing more research
+   
+   - **`requirements.md`** - Discovered requirements
+     - Add requirements that emerged during task
+     - Note user preferences revealed
+     - Track implicit requirements from feedback
+   
+   - **`data-models.md`** - Identified data structures
+     - Document data structures used/needed
+     - Track schema evolution
+     - Note relationships discovered
+   
+   - **`user-needs.md`** - User requirements discovered
+     - Track what user actually needs (vs. wants)
+     - Note workflow preferences
+     - Document pain points addressed
+   
+   - **`questions.md`** - Open questions and gaps
+     - What's unclear about the vision?
+     - What decisions need user input?
+     - What technical research is needed?
+   
+   **Step 10C.3: Feed Discoveries into Vision**
+   
+   - If significant new understanding emerged:
+     - Update `vision.md` with new discoveries
+     - Mark section as "Updated after Task [X]"
+     - Keep vision as living document, not static
+   
+   - Display only if updates made:
+     ```
+     📘 Project documentation updated
+     ```
+   
+   **Step 10C.4: Check Phase Completion**
+   
+   - Detect if this was the last task in current phase:
+     - Load roadmap, count remaining tasks in phase
+     - If 0 remaining → trigger **Step 10D (Phase Feedback Checkpoint)**
+   
+   - If more tasks remain in phase:
+     - Proceed to Step 11 (Next Action Menu)
+
+### 10D. **Phase Feedback Checkpoint** (User Reflection)
+   - **When to run**: When last task in a phase is completed
+   - **Purpose**: Gather user feedback before proceeding to next phase
+   
+   **Step 10D.1: Celebrate Phase Completion**
+   
+   - Display:
+     ```
+     🎉 Phase [Name] Complete!
+     
+     What was delivered:
+     - [Task 1] - [Brief description]
+     - [Task 2] - [Brief description]
+     - [Task 3] - [Brief description]
+     
+     Before we move to [Next Phase Name], I'd like your feedback.
+     ```
+   
+   **Step 10D.2: Gather User Feedback**
+   
+   - Use `ask_user` with freeform enabled:
+     ```
+     Now that you've seen Phase [Name] in action:
+     
+     1. What's working well?
+     2. What isn't quite right?
+     3. Any new ideas or changes in direction?
+     
+     (This helps me understand your evolving vision)
+     ```
+   
+   **Step 10D.3: Research Refresh**
+   
+   - Based on user feedback:
+     - Research any new domains/technologies mentioned
+     - Update skill candidates if new needs identified
+     - Store findings in `research/` folder
+   
+   **Step 10D.4: Update Roadmap if Needed**
+   
+   - If user feedback suggests changes:
+     - Offer to adjust roadmap
+     - Add new tasks if needed
+     - Reprioritize based on feedback
+   
+   - Display:
+     ```
+     📘 Feedback incorporated
+     
+     [Summary of what was learned/changed]
+     ```
+   
+   - Proceed to Step 11 (Next Action Menu)
+
 ### 11. **Next Action Menu**
    - After task completion, use `ask_user` with choices:
    - After task completion, use `ask_user` with choices: