mindforge-cc 6.2.0-alpha → 6.2.0

package/.claude/commands/mindforge/status.md

@@ -1,30 +1,113 @@
 ---
-name: mindforge:status
-description: Display a rich dashboard of the current project state
-argument-hint: none
-allowed-tools:
-  - list_dir
-  - view_file
-  - run_command
+description: Display a rich dashboard of the current project state.
 ---
 
-<objective>
-Provide a high-level visual summary of the project's health, progress, requirement coverage, and recent activity by synthesizing data from the `.planning/` directory.
-</objective>
-
-<execution_context>
-.claude/commands/mindforge/status.md
-</execution_context>
-
-<context>
-Sources: STATE.md, AUDIT.jsonl, REQUIREMENTS.md, and phase directories.
-Focus: Real-time visibility into phase completion and open issues.
-</context>
-
-<process>
-1. **Gather Phase Data**: Read `STATE.md` and calculate progress percentage for active/planned phases.
-2. **Audit Requirements**: Count total, completed (verified), implemented (untested), and pending requirements from `REQUIREMENTS.md`.
-3. **Extract Recent Activity**: Parse the last few entries of `AUDIT.jsonl` (using efficient tail read).
-4. **Monitor Issues**: Check for critical security findings, open bugs, or execution blockers.
-5. **Render Dashboard**: Display the multi-section summary including header, progress bars, requirement counts, and activity logs.
-</process>
+# MindForge — Status Command
+# Usage: /mindforge:status
+
+Display a rich dashboard of the current project state.
+Pull data from STATE.md, AUDIT.jsonl, REQUIREMENTS.md, and the phases directory.
+
+## Dashboard sections
+
+### Section 1 — Project header
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+⚡ MindForge Status — [Project Name]
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  Last updated : [STATE.md last updated timestamp]
+  Current phase: Phase [N] — [phase description]
+  Status       : [status from STATE.md]
+```
+
+### Section 2 — Phase progress
+```
+Phase Progress
+───────────────────────────────────────────────────────
+  Phase 1  [████████████████████] 100% — Complete ✅
+  Phase 2  [████████░░░░░░░░░░░░]  40% — In progress
+  Phase 3  [░░░░░░░░░░░░░░░░░░░░]   0% — Not started
+  Phase 4  [░░░░░░░░░░░░░░░░░░░░]   0% — Not started
+```
+Calculate percentage from: tasks with SUMMARY files / total tasks in phase.
+Count ONLY SUMMARY files that contain `Status: Completed ✅` (or `Status` + `Completed`).
+Do not count failed tasks as progress.
+If VERIFICATION.md is missing for a phase: label it "In progress" not "0% verified".
+
+### Section 3 — Requirements coverage
+Read REQUIREMENTS.md and count:
+- Total v1 requirements
+- Requirements with a passing test (from VERIFICATION.md files)
+- Requirements implemented but untested
+- Requirements not yet started
+
+```
+Requirements (v1)
+───────────────────────────────────────────────────────
+  Total        : [N]
+  ✅ Done + tested  : [N]
+  ⚠️  Done, no test : [N]
+  🔴 Not started   : [N]
+```
+
+### Section 4 — Recent activity (from AUDIT.jsonl)
+Read the last 10 entries from AUDIT.jsonl and display:
+```
+Recent Activity
+───────────────────────────────────────────────────────
+  [timestamp]  task_completed  Plan 03: User API endpoints ✅
+  [timestamp]  task_completed  Plan 02: Product model ✅
+  [timestamp]  task_started    Plan 03: User API endpoints
+  [timestamp]  task_completed  Plan 01: User model ✅
+  [timestamp]  context_compaction  Phase 2, Plan 03 (72% context)
+```
+If AUDIT.jsonl is empty or missing, display:
+```
+Recent Activity
+───────────────────────────────────────────────────────
+  No activity logged yet. Activity will appear here
+  after running /mindforge:execute-phase.
+```
+
+### Section 5 — Open issues
+Check for:
+- Any open SECURITY-REVIEW files with CRITICAL or HIGH findings
+- Any BUGS.md files with open issues
+- Any failed tasks in WAVE-REPORT files
+- Any blockers in STATE.md
+
+```
+Open Issues
+───────────────────────────────────────────────────────
+  🔴 CRITICAL: [if any — from SECURITY-REVIEW]
+  🟠 HIGH:     [if any]
+  ✅ No open issues
+```
+
+### Section 7 — Sovereign Intelligence
+```
+Sovereign Intelligence (v6.2.0-alpha)
+───────────────────────────────────────────────────────
+  🛡️  PQAS Security : [ACTIVE | PASSIVE] (Dilithium-5)
+  🎯  Proactive Homing: [ENABLED | DISABLED]
+  🧠  Drift Recovery : [N] remediation events
+  🧬  Biometric Gate : [LOCKED | BYPASSED]
+```
+- PQAS Status: Check if `bin/governance/quantum-crypto.js` exists and if `PolicyEngine.js` has `highRiskBypass` enabled.
+- Proactive Homing: Check if `bin/autonomous/intent-harvester.js` is active in `AutoRunner.js`.
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+## Data sources (in priority order)
+1. STATE.md — authoritative for current status
+2. AUDIT.jsonl — authoritative for history
+3. REQUIREMENTS.md — authoritative for scope
+4. VERIFICATION.md files — authoritative for test coverage
+5. WAVE-REPORT files — authoritative for execution history
+6. HANDOFF.json — authoritative for session state
+
+## Performance notes
+- For recent activity, read only the last 500 bytes of AUDIT.jsonl:
+  `tail -c 500 .planning/AUDIT.jsonl | [parse last complete JSON objects]`
+- For requirement counts, count lines starting with `| FR-` instead of parsing the whole file.

package/.claude/commands/mindforge/steer.md

@@ -1,28 +1,17 @@
 ---
-name: mindforge:steer
-description: Inject mid-execution guidance into the running autonomous engine
-argument-hint: "[instruction]"
-allowed-tools:
-  - write_to_file
-  - view_file
+description: Injects mid-execution guidance into the running autonomous engine.
 ---
 
-<objective>
-Provide a mechanism for human course-correction during long-running autonomous waves, allowing the user to redirect the agent's focus or update constraints without stopping the process.
-</objective>
+# /mindforge:steer "[instruction]"
 
-<execution_context>
-.claude/commands/mindforge/steer.md
-</execution_context>
+**Purpose**: Injects mid-execution guidance into the running autonomous engine.
+Steering guidance is applied at the next task boundary to course-correct MindForge.
 
-<context>
-Lifecycle: Applied at the next task boundary in `/mindforge:auto` mode.
-Priority: Steering takes precedence over the original `PLAN.md` instructions.
-</context>
+## Usage
+- `/mindforge:steer "Use the new logger in all created files"`
+- `/mindforge:steer --task 3-05 "This plan is too broad, focus on login only"`
+- `/mindforge:steer --cancel` (Clears the steering queue)
 
-<process>
-1. **Queue Instruction**: Write the steering guidance to the active execution state.
-2. **Target (Optional)**: Explicitly target a future task ID for modification.
-3. **Validate**: Ensure steering does not violate core security or governance gates.
-4. **Cancel**: Clear the steering queue if instructions are no longer relevant.
-</process>
+## Precedence
+- Steering instructions take precedence over the original `PLAN-N-MM.md` actions.
+- Steering cannot override core security constraints or governance gates.

package/.claude/commands/mindforge/sync-confluence.md

@@ -1,30 +1,15 @@
 ---
-name: mindforge:sync-confluence
-description: Publish approved planning artifacts to Confluence
-argument-hint: [--architecture] [--phase N] [--milestone name]
-allowed-tools:
-  - run_command
-  - view_file
-  - write_to_file
+description: Publish approved planning artifacts to Confluence. Usage:
 ---
 
-<objective>
-Automate the publication of key project documentation and architectural decisions to Confluence, providing a durable and searchable record for the broader organization.
-</objective>
+Publish approved planning artifacts to Confluence. Usage:
+`/mindforge:sync-confluence [--architecture] [--phase N] [--milestone name]`
 
-<execution_context>
-.claude/commands/mindforge/sync-confluence.md
-</execution_context>
+## Behaviour
+- verify Confluence availability through `connection-manager.md`
+- publish idempotently by existing page title or page ID
+- never publish secrets, raw approval notes, or raw audit logs
+- log success, skip, or failure to AUDIT
 
-<context>
-Auth: Managed via `connection-manager.md`.
-Exclusion: Secrets, raw logs, and PII are strictly filtered before publication.
-</context>
-
-<process>
-1. **Assemble Content**: Gather target artifacts (ARCHITECTURE.md, Phase Plans, Milestone reports).
-2. **Filter & Sanitize**: Remove all sensitive data (passwords, tokens, raw audit trails).
-3. **Publish**: Update existing pages or create new ones in the specified Confluence space.
-4. **Indempotency**: Match pages by title or project-wide ID to avoid duplication.
-5. **Audit**: Log publication success or skipped files.
-</process>
+Publishing failures are non-fatal and create a pending manual action in
+ `STATE.md`.

package/.claude/commands/mindforge/sync-jira.md

@@ -1,32 +1,16 @@
 ---
-name: mindforge:sync-jira
-description: Synchronize MindForge phase and plan metadata to Jira
-argument-hint: [--phase N] [--plan M]
-allowed-tools:
-  - run_command
-  - view_file
-  - write_to_file
+description: Synchronise MindForge phase and plan metadata to Jira. Usage:
 ---
 
-<objective>
-Maintain parity between local MindForge planning state and the enterprise Jira issue tracker, ensuring stakeholders have visibility into phase progress and task status.
-</objective>
+Synchronise MindForge phase and plan metadata to Jira. Usage:
+`/mindforge:sync-jira [--phase N] [--plan M]`
 
-<execution_context>
-.claude/commands/mindforge/sync-jira.md
-</execution_context>
+## Behaviour
+- verify Jira availability through `connection-manager.md`
+- create or update Epic and Story mappings in `.planning/jira-sync.json`
+- use dynamic transition lookup, never hardcoded IDs
+- preserve manual Jira edits
+- log all actions to AUDIT
 
-<context>
-Metadata: .planning/jira-sync.json
-Auth: Managed via `connection-manager.md`.
-Resilience: Failures are non-fatal; state is logged in `STATE.md` for retry.
-</context>
-
-<process>
-1. **Verify Connection**: Ensure Jira API availability and auth tokens are valid.
-2. **Resolve Mappings**: Map Phase and Plan IDs to Jira Epics and Stories.
-3. **Transition Issues**: Update Jira statuses based on verification results (e.g., Verified -> Done).
-4. **Sync Content**: Push plan descriptions and requirements to the relevant Jira tickets.
-5. **Preserve Manual Edits**: Avoid overwriting manual comments or fields in Jira.
-6. **Audit**: Log the sync event with counts of updated and created tickets.
-</process>
+Integration failures are non-fatal and should be written to `STATE.md` for
+ manual retry.

package/.claude/commands/mindforge/tokens.md

@@ -1,27 +1,12 @@
 ---
-name: mindforge:tokens
-description: Analyze token consumption profile and efficiency
-argument-hint: [--phase N] [--session ID] [--window short|medium|long] [--optimise]
-allowed-tools:
-  - view_file
-  - run_command
+description: Display token consumption profile and efficiency analysis.
 ---
 
-<objective>
-Deeply analyze how tokens are being consumed across the project to identify waste, improve prompt efficiency, and optimize context budgeting.
-</objective>
+# MindForge — Token Usage Command
+# Usage: /mindforge:tokens [--phase N] [--session ID] [--window short|medium|long] [--optimise]
 
-<execution_context>
-.claude/commands/mindforge/tokens.md
-</execution_context>
+## Purpose
+Display token consumption profile and efficiency analysis.
+Helps identify where tokens are being spent and how to reduce waste.
 
-<context>
-Analysis Focus: Input vs Output tokens, cache hits/misses, compaction efficiency.
-</context>
-
-<process>
-1. **Fetch Profiles**: Read token usage data for the specified scope.
-2. **Identify Waste**: Detect large, repetitive context injections or missed cache opportunities.
-3. **Optimization Advice**: If `--optimise` is set, provide specific recommendations (e.g., "Summarize ARCHITECTURE.md to save 2k tokens/session").
-4. **Report**: Display the token consumption profile and efficiency score.
-</process>
+## Default output (no flags — last 5 sessions)

package/.claude/commands/mindforge/update.md

@@ -1,33 +1,46 @@
 ---
-name: mindforge:update
-description: Safely check for and apply MindForge framework updates
-argument-hint: [--apply] [--force] [--check] [--skip-changelog]
-allowed-tools:
-  - run_command
-  - view_file
-  - write_to_file
+description: Check for and apply MindForge framework updates in a safe, scope-preserving way.
 ---
 
-<objective>
-Keep the project's MindForge installation up to date with the latest features, bug fixes, and security patches while ensuring no data loss or architectural regression.
-</objective>
-
-<execution_context>
-.claude/commands/mindforge/update.md
-</execution_context>
-
-<context>
-Platform: bin/updater/self-update.js
-Scope: Local vs. Global detection.
-Security: Enforces schema migration during the update process.
-</context>
-
-<process>
-1. **Check**: Query the registry for the latest version and compare with the current installation.
-2. **Changelog**: Display relevant updates, highlighting **BREAKING CHANGES** for major versions.
-3. **Pre-update State**: Capture the `schema_version` from HANDOFF.json.
-4. **Apply**: If `--apply` is set, download and install the new version into the detected scope.
-5. **Migrate**: Run `/mindforge:migrate` to reconcile the project schema with the new framework version.
-6. **Verify**: Run `/mindforge:health` to confirm the update succeeded without introducing errors.
-7. **Audit**: Log `update_completed` with the jump range (X.Y.Z -> A.B.C).
-</process>
+# MindForge — Update Command
+# Usage: /mindforge:update [--apply] [--force] [--check] [--skip-changelog]
+
+## Purpose
+Check for and apply MindForge framework updates in a safe, scope-preserving way.
+
+## Execution flow
+
+### 1. Version check
+Execute `bin/updater/self-update.js` `checkAndUpdate()`.
+Always show: current version, latest version, update type (major/minor/patch).
+
+### 2. Changelog display (unless --skip-changelog)
+Fetch and display the relevant CHANGELOG.md section.
+For major updates: prefix with ⚠️ BREAKING CHANGES notice.
+Limit display to 3,000 characters — link to full CHANGELOG for the rest.
+
+### 3. Confirmation gate (unless --apply)
+Without --apply: show update info, stop. Do not modify any files.
+Message: "To apply this update: /mindforge:update --apply"
+
+### 4. Apply (with --apply)
+a. Detect original install scope (local vs global, claude vs antigravity)
+b. Read schema_version from HANDOFF.json (captures current version BEFORE update)
+c. Run `npx mindforge-cc@[latest] --[runtime] --[scope]`
+d. Run migration: `node bin/migrations/migrate.js` with captured schema_version
+e. Run /mindforge:health to verify update succeeded
+
+### 5. Post-update health check
+If health errors: surface them immediately with specific fix instructions.
+Common post-update issue: CLAUDE.md and .agent/CLAUDE.md drifted → auto-repair.
+
+## Error scenarios and recovery
+
+| Error | Recovery |
+|---|---|
+| npm registry unreachable | Message: "Check internet. Manual: npm info mindforge-cc version" |
+| Update download fails | Retry once, then suggest manual: `npx mindforge-cc@latest` |
+| Migration fails | Restored from backup automatically. Run /mindforge:migrate manually. |
+| Install scope detection fails | Prompt user: "Is your install global or local?" |
+
+## AUDIT entry

package/.claude/commands/mindforge/verify-phase.md

@@ -1,30 +1,66 @@
 ---
-name: mindforge:verify-phase
-description: Human acceptance testing (UAT) for a completed phase
-argument-hint: [N]
-allowed-tools:
-  - view_file
-  - write_to_file
+description: Human acceptance testing for a completed phase. Usage: /mindforge:verify-phase [N]
 ---
 
-<objective>
-Conduct a structured User Acceptance Testing (UAT) session for a completed phase, gathering human feedback on deliverables and identifying any required fixes.
-</objective>
-
-<execution_context>
-.claude/commands/mindforge/verify-phase.md
-</execution_context>
-
-<context>
-Arguments: $ARGUMENTS (Phase N)
-Prerequisite: .planning/phases/[N]/VERIFICATION.md must exist.
-Output: .planning/phases/[N]/UAT.md
-</context>
-
-<process>
-1. **Extract Deliverables**: Read requirements and plans to generate a list of checkable instructions for the user.
-2. **Interactive Walkthrough**: Present deliverables one at a time and ask the user for Pass/Fail status and observations.
-3. **Handle Failures**: If a task fails, spawn a debug subagent and create a `FIX-PLAN-[N]-[NN].md`.
-4. **Record Results**: Write `UAT.md` capturing testers, dates, results per deliverable, and overall sign-off status.
-5. **Update State**: If all pass, mark phase as verified in `STATE.md` and guide the user to `/mindforge:ship`.
-</process>
+Human acceptance testing for a completed phase. Usage: /mindforge:verify-phase [N]
+
+## Pre-check
+`.planning/phases/[N]/VERIFICATION.md` must exist.
+If it does not: instruct the user to run /mindforge:execute-phase [N] first.
+
+## Step 1 — Extract testable deliverables
+Read REQUIREMENTS.md and the phase PLAN files.
+Generate a list of testable deliverables — things the user can actually check.
+
+Format each as a clear, actionable test instruction:
+"Navigate to /login and submit a form with a valid email and password.
+ You should be redirected to /dashboard within 2 seconds."
+
+## Step 2 — Walk through each deliverable
+Present one at a time. After each:
+"Please test this now and tell me: pass ✅ or fail ❌ — and describe what you saw."
+
+Wait for the user's response before proceeding to the next.
+
+## Step 3 — Handle failures
+If the user reports a failure:
+1. Ask: "What exactly happened? (error message, wrong behaviour, nothing happened)"
+2. Spawn a debug subagent with: the failure description, the relevant PLAN file,
+   and the relevant source files. Instruct it to find the root cause.
+3. Create a fix plan: `.planning/phases/[N]/FIX-PLAN-[N]-[NN].md`
+   using the same XML format as regular plans.
+4. Ask the user: "Fix plan created. Run /mindforge:execute-phase [N] again
+   to apply the fixes?"
+
+## Step 4 — Write UAT record
+Write `.planning/phases/[N]/UAT.md`:
+
+```markdown
+# UAT — Phase [N]
+
+## Tester
+[User name or "developer"]
+
+## Date
+[ISO 8601 date]
+
+## Results
+
+| # | Deliverable                        | Result | Notes                  |
+|---|------------------------------------|--------|------------------------|
+| 1 | [description]                      | ✅     | [what was observed]    |
+| 2 | [description]                      | ❌     | [what went wrong]      |
+
+## Overall status
+All passed ✅ / Issues found — fix plans created ❌
+
+## Sign-off
+[Passed / Pending fixes]
+```
+
+## Step 5 — Update state if all pass
+If all deliverables pass:
+Update STATE.md: phase N = verified and signed off.
+Tell the user:
+"✅ Phase [N] verified and signed off.
+ Run /mindforge:ship [N] to create the release PR."

package/.claude/commands/mindforge/workspace.md

@@ -1,32 +1,33 @@
 ---
-name: mindforge:workspace
-description: Manage monorepo workspaces and cross-package dependencies
-argument-hint: [detect|list|plan phase N|test]
-allowed-tools:
-  - run_command
-  - list_dir
-  - view_file
-  - write_to_file
+description: Monorepo workspace management.
 ---
 
-<objective>
-Enable seamless development within monorepo environments by detecting package structures, managing cross-package dependencies, and coordinating multi-package phase planning and testing.
-</objective>
+# MindForge — Workspace Command
+# Usage: /mindforge:workspace [detect|list|plan phase N|test]
 
-<execution_context>
-.claude/commands/mindforge/workspace.md
-</execution_context>
+Monorepo workspace management.
 
-<context>
-Metadata: WORKSPACE-MANIFEST.json
-Engine: workspace-detector.md, cross-package-planner.md
-Subcommands: detect, list, plan, test.
-</context>
+## detect
+Run workspace detector from `.mindforge/monorepo/workspace-detector.md`.
+Write WORKSPACE-MANIFEST.json.
+Report: workspace type, packages found, dependency order.
 
-<process>
-1. **Detect**: Run the workspace detector to identify the monorepo type and generate `WORKSPACE-MANIFEST.json`.
-2. **List**: Present a structured view of all packages, their types, and dependency relationships.
-3. **Plan**: Generate a phase plan that spans multiple packages, ensuring execution follows the correct dependency order.
-4. **Test**: Execute the test suite for all packages in the correct topological order and aggregate results.
-5. **Confirm**: Update the user on workspace health and detected configurations.
-</process>
+## list
+Read WORKSPACE-MANIFEST.json and display package list:
+```
+Workspace: Turborepo (4 packages)
+  packages/shared    → @myapp/shared   (lib, 0 dependents)
+  apps/api           → @myapp/api      (api, depends on: shared)
+  apps/web           → @myapp/web      (web, depends on: shared, api)
+  apps/mobile        → @myapp/mobile   (mobile, depends on: shared)
+Execution order: shared → api → (web, mobile in parallel)
+```
+
+## plan phase N
+Create a phase plan that spans multiple packages.
+Uses cross-package-planner.md to determine package execution order.
+Each PLAN file includes a `<package>` and `<working-dir>` field.
+
+## test
+Run tests across all packages in dependency order.
+Report per-package test results and aggregate coverage.

package/.mindforge/engine/shard-controller.md

@@ -46,7 +46,7 @@ Every context item (Decision, Discovery, Task Result) is scored before compactio
 - **Deduplication**: Before appending to a shard, check for identical `topic` or `id` to avoid context cycles.
 - **Pruning**: Warm shards are archived to Cold storage upon Phase Completion.
 
-## 5. Beast Mode — Enterprise Hardening
+## 5. Enterprise-Grade — Hardening Phase
 - **Temporal Integrity**: Every shard entry must contain a `sha256` checksum. `bin/shard-helper.js --verify` ensures zero corruption.
 - **Semantic Indexing**: Shards are tagged automatically during compaction for O(1) keyword retrieval.
 - **Hindsight Injection**: If a "Warm" decision is corrected in a later session, the shard is updated with a `superseded_by` pointer.