mindforge-cc 2.0.0 → 2.1.1

package/.claude/commands/mindforge/approve.md

@@ -1,18 +1,30 @@
-Process pending approvals and emergency overrides. Usage:
-`/mindforge:approve [approval-id] [--approve|--reject] [--reason "..."] [--emergency]`
+---
+name: mindforge:approve
+description: Process pending approvals and emergency overrides
+argument-hint: [approval-id] [--approve|--reject] [--reason "..."] [--emergency]
+allowed-tools:
+  - list_dir
+  - view_file
+  - write_to_file
+---
 
-## Listing approvals
-Scan `.planning/approvals/` and show only files with `status: pending` unless
- the user explicitly asks for historical records.
+<objective>
+Manage the governance layer by reviewing and confirming high-tier architectural or security changes, ensuring all sensitive operations have explicit human authorization.
+</objective>
 
-## Standard approval flow
-1. Read the approval file
-2. Confirm current identity from `git config user.email` or `$USER`
-3. Validate approver eligibility from `INTEGRATIONS-CONFIG.md`
-4. Record approval or rejection with timestamp and reason
+<execution_context>
+.claude/commands/mindforge/approve.md
+</execution_context>
 
-## Emergency overrides
-Emergency override requires the `--emergency` flag.
-Read `EMERGENCY_APPROVERS` from `INTEGRATIONS-CONFIG.md` and deny the request if
- the current identity is not listed. Document that git-config-based identity is
- a convenience layer, not a high-assurance identity proof.
+<context>
+Storage: .planning/approvals/
+Governance Config: INTEGRATIONS-CONFIG.md
+</context>
+
+<process>
+1. **List**: Scan for pending approval requests and present them to the user.
+2. **Identity Verification**: Confirm the user's identity via git config or environment.
+3. **Audit Eligibility**: Verify the user has sufficient permissions for the requested tier.
+4. **Record Verdict**: Update the approval file with status, timestamp, and the provided reason.
+5. **Emergency Override**: If `--emergency` is used, bypass standard checks if the identity matches the pre-defined emergency approver list.
+</process>

package/.claude/commands/mindforge/audit.md

@@ -1,30 +1,34 @@
-Query `.planning/AUDIT.jsonl` by phase, event, date, severity, integration, or
- agent. Usage: `/mindforge:audit [filters]`
+---
+name: mindforge:audit
+description: Query the .planning/AUDIT.jsonl log by phase, event, date, or severity
+argument-hint: [filters]
+allowed-tools:
+  - run_command
+  - view_file
+  - list_dir
+---
 
-## Supported options
-- `--phase N`
-- `--event NAME`
-- `--agent NAME`
-- `--severity LEVEL`
-- `--date YYYY-MM-DD`
-- `--summary`
-- `--verify`
-- `--export PATH`
+<objective>
+Provide a structured interface to query and validate the project's audit logs, ensuring accountability and traceability of all agent actions and system events.
+</objective>
 
-## Summary mode
-Summarise counts by event, severity, integration, and phase.
-Entries with `"phase": null` are reported as `project-level`, not dropped.
+<execution_context>
+.claude/commands/mindforge/audit.md
+</execution_context>
 
-## Verify mode
-Validate JSONL shape and chronological ordering.
-Timestamp comparison may use string comparison because ISO-8601 UTC timestamps
- with a `Z` suffix sort lexicographically.
+<context>
+Storage: .planning/AUDIT.jsonl
+Archive: .planning/audit-archive/
+Filters: --phase, --event, --agent, --severity, --date, --summary, --verify, --export
+</context>
 
-## Archive rotation
-If the active audit log exceeds 10,000 lines, rotate it into
- `.planning/audit-archive/` before continuing heavy writes. Rotation must never
- delete history; it archives then resets the active file.
-
-## Export safety
-Validate export paths stay inside the project directory. If a path traversal or
- unsafe destination is requested, export into `.planning/` instead.
+<process>
+1. **Parse Filters**: Identify the search criteria (phase, event, severity, etc.).
+2. **Execute Query**:
+    - Use `grep` or `jq` (if available via bash) to filter the JSONL file.
+    - If `--summary`: Aggregate counts by event and severity.
+    - If `--verify`: Check for JSON validity and chronological integrity.
+3. **Handle Large Logs**: If the log exceeds 10,000 lines, rotate it to the archive directory.
+4. **Export (Optional)**: If `--export` is used, write filtered results to the target path (ensuring project boundary safety).
+5. **Display**: Present the filtered log or summary to the user.
+</process>

package/.claude/commands/mindforge/auto.md

@@ -1,22 +1,33 @@
-# /mindforge:auto [Phase N]
+---
+name: mindforge:auto
+description: Start the MindForge Autonomous Execution Engine
+argument-hint: [Phase N] [--resume] [--headless] [--dry-run]
+allowed-tools:
+  - run_command
+  - list_dir
+  - view_file
+  - write_to_file
+---
 
-**Purpose**: Starts the MindForge Autonomous Execution Engine for the
-specified phase. The agent will execute all waves, handle repairs, and
-perform compliance gates without requiring human confirmation.
+<objective>
+Execute a planned phase entirely unattended, coordinating wave fulfillment, self-repair of minor failures, and compliance gating while maintaining a persistent state checkpoint.
+</objective>
 
-## Usage
-- `/mindforge:auto --phase 3` (Standard unattended mode)
-- `/mindforge:auto --resume` (Resumes from last checkpoint)
-- `/mindforge:auto --headless` (CI/CD optimized output)
-- `/mindforge:auto --dry-run` (Show the wave DAG and plan without executing)
+<execution_context>
+.claude/commands/mindforge/auto.md
+</execution_context>
 
-## Behavior
-- **Zero-Interaction**: Auto-approves Tier 1/2 changes if gates pass.
-- **Self-Repair**: Tries RETRY/DECOMPOSE before asking for help.
-- **Checkpointing**: Constant state persistence in `HANDOFF.json`.
-- **Governance**: ESCALATES on Tier 3 changes (Auth/Payment/PII).
+<context>
+Storage: HANDOFF.json checkpoints.
+Governance: Auto-approves Tier 1/2; Escalates Tier 3.
+Notifications: Requires Slack/Discord webhooks for mission-critical alerts.
+</context>
 
-## Environment Variables
-- `AUTO_MODE_TIMEOUT_MINUTES`: Default 120.
-- `AUTO_PUSH_ON_WAVE_COMPLETE`: Default false.
-- `SLACK_WEBHOOK_URL`: Required for notifications.
+<process>
+1. **Boot**: Load the specifies phase or resume from the last known checkpoint in `HANDOFF.json`.
+2. **Wave Engine**: Execute the DAG of tasks sequentially or in parallel based on dependencies.
+3. **Self-Repair**: Automatically attempt to retry or decompose tasks that encounter recoverable errors.
+4. **Gating**: Evaluate compliance gates between waves. Escalates to human for Tier 3 changes.
+5. **Persistence**: Save state after every successful tool call or task completion.
+6. **Finalize**: Shift status to "Verify Pending" once all waves are complete.
+</process>

package/.claude/commands/mindforge/benchmark.md

@@ -1,33 +1,30 @@
-# MindForge — Benchmark Command
-# Usage: /mindforge:benchmark [--skill skill-name] [--compare skill-a skill-b]
+---
+name: mindforge:benchmark
+description: Measure skill effectiveness and project metrics over time
+argument-hint: [--skill skill-name] [--compare skill-a skill-b]
+allowed-tools:
+  - view_file
+  - list_dir
+---
 
-Measure skill effectiveness over time.
+<objective>
+Analyze command and skill performance by correlating usage data with verify pass rates and project quality scores, facilitating data-driven decisions on tool improvements.
+</objective>
 
-## Single skill benchmark
-For a named skill, analyse AUDIT.jsonl and skill-usage.jsonl:
-- How many times was the skill loaded this month?
-- What is the verify pass rate for tasks where this skill was loaded?
-- Are there anti-patterns less common after this skill is loaded?
-- What is the average session quality score when this skill is active?
+<execution_context>
+.claude/commands/mindforge/benchmark.md
+</execution_context>
 
-Report:
-```
-Skill Benchmark: security-review v1.0.0
-────────────────────────────────────────
-Usage (last 30 days): 47 task loads
-Trigger distribution: text match 68%, file-path 22%, file-name 10%
-Verify pass rate:     91% (vs. 84% baseline without this skill)
-Security findings:    8 HIGH caught (0 CRITICAL missed in tasks using this skill)
-Session quality lift: +6.2 points average when loaded
+<context>
+Sources: AUDIT.jsonl, skill-usage.jsonl
+Metrics: Pass rate, load frequency, anti-pattern reduction, quality lift.
+</context>
 
-Assessment: HIGH VALUE — clear quality improvement signal
-```
-
-## Skill comparison
-Compare two skills head-to-head:
-- Load frequency
-- Verify pass rate improvement
-- Anti-pattern detection rate
-- Context budget cost (token estimate)
-
-Helps decide: should you keep both skills, or deprecate the lower-performer?
+<process>
+1. **Gather Data**: Extract usage and outcome logs for the target skill(s).
+2. **Calculate Trends**: Determine pass rate vs baseline and session quality improvement.
+3. **Generate Assessment**:
+    - For single skill: Provide a usage distribution and quality lift report.
+    - For comparison: Provide a head-to-head comparison on cost and effectiveness.
+4. **Recommendation**: Advise on whether to keep, improve, or deprecate the targeted skills.
+</process>

package/.claude/commands/mindforge/browse.md

@@ -1,26 +1,28 @@
-# /mindforge:browse
+---
+name: mindforge:browse
+description: Control the persistent MindForge browser daemon for visual verification
+argument-hint: <url | action>
+allowed-tools:
+  - open_browser_url
+  - run_command
+---
 
-## Usage
-`@mindforge browse <url | action>`
+<objective>
+Enable the agent to interact with web interfaces, maintain persistent sessions, and perform visual audits of UI changes using an automated browser daemon.
+</objective>
 
-## Description
-Controls the persistent MindForge browser daemon. 
-Maintains session state (cookies/localStorage) for the AI.
+<execution_context>
+.claude/commands/mindforge/browse.md
+</execution_context>
 
-## Actions
-| Action | Description |
-|---|---|
-| `--start` | Initialize browser daemon |
-| `--stop` | Kill browser daemon |
-| `--status` | Show daemon health and active sessions |
-| `--session <name>` | Switch browser context |
-| `--import-session <name> --from <browser>` | Import cookies from host browser (chrome, arc, etc) |
-| `<url>` | Navigate the current page to URL |
-| `click <selector>` | Trigger click event |
-| `type <sel> <text>` | Fill input field |
-| `screenshot` | Capture current viewport |
+<context>
+Security: Daemon binds to 127.0.0.1. Sessions are gitignored.
+State: Supports cookie/localStorage persistence via named sessions.
+</context>
 
-## Security
-- Daemon binds to `127.0.0.1` only.
-- Session files are gitignored.
-- Use only for debugging and visual verification.
+<process>
+1. **Control Daemon**: Start, stop, or query the health/active sessions of the browser daemon.
+2. **Session Management**: Switch between browser contexts or import sessions from the host (Chrome/Arc).
+3. **Navigate & Interact**: Load URLs, click selectors, and type text into input fields.
+4. **Verify**: Capture screenshots of the current viewport for visual confirmation.
+</process>

package/.claude/commands/mindforge/complete-milestone.md

@@ -1,18 +1,32 @@
-Archive a completed milestone, generate a release report, and prepare the next
- milestone. Usage: `/mindforge:complete-milestone <name> <version>`
+---
+name: mindforge:complete-milestone
+description: Archive a completed milestone and prepare the next version
+argument-hint: <name> <version>
+allowed-tools:
+  - list_dir
+  - view_file
+  - write_to_file
+  - run_command
+---
 
-## Step 1 — Validate milestone completion
-Ensure every included phase is verified and has no pending blocking approvals.
+<objective>
+Finalize a project milestone by summarizing shipped value, archiving phase artifacts, and preparing the environment for the next development cycle.
+</objective>
 
-## Step 2 — Generate milestone report
-Summarise shipped phases, notable changes, risks, approvals, and unresolved
- follow-ups.
+<execution_context>
+.claude/commands/mindforge/complete-milestone.md
+</execution_context>
 
-## Step 3 — Archive milestone artifacts
-Archive only the phases included in the milestone, not the entire
- `.planning/phases/` directory. Preserve history in the archive while keeping
- active planning files available in place.
+<context>
+Validation: Ensures all included phases are verified and have no pending approvals.
+Storage: Moves phase files to a milestone-specific archive.
+</context>
 
-## Step 4 — Release metadata
-Create the release tag, update `STATE.md` with milestone summary, and mark the
- project ready for the next version.
+<process>
+1. **Validate**: Confirm every phase in the milestone is signed off and verified.
+2. **Summarize**: Generate a MILESTONE-REPORT with shipped functionality, risks, and follow-ups.
+3. **Archive**: Move the included `.planning/phases/` directories to a persistent milestone archive.
+4. **Tag**: Create a git release tag for the milestone.
+5. **State Reset**: Update `STATE.md` to reflect the milestone completion and target the next version.
+6. **Audit**: Log `milestone_completed` event.
+</process>

package/.claude/commands/mindforge/costs.md

@@ -1,11 +1,28 @@
-# MindForge v2 — Costs Command
-# Usage: /mindforge:costs [--phase N] [--session ID] [--window 7d]
+---
+name: mindforge:costs
+description: Real-time cost tracking for AI model usage
+argument-hint: [--phase N] [--session ID] [--window 7d]
+allowed-tools:
+  - view_file
+  - run_command
+---
 
-## Purpose
-Real-time cost tracking for all AI model usage.
-Enforce daily budgets and see per-model spend.
+<objective>
+Monitor and control project expenses related to AI model usage, enforcing budget guardrails and providing granular spend analysis.
+</objective>
 
-## Metrics
-- Total spend: $X.XX
-- Daily limit usage: XX%
-- Per-model breakdown (Tokens/Cost)
+<execution_context>
+.claude/commands/mindforge/costs.md
+</execution_context>
+
+<context>
+Metrics: Total spend, daily limit usage, per-model breakdown.
+Sources: AUDIT.jsonl and local token logs.
+</context>
+
+<process>
+1. **Gather Usage Data**: Parse logs for the specified phase, session, or time window.
+2. **Calculate Spend**: Apply pricing models to the detected token counts per model.
+3. **Enforce Budgets**: Compare current spend against configured daily and project limits.
+4. **Display Report**: Present the total spend and limit usage as a percentage.
+</process>

package/.claude/commands/mindforge/cross-review.md

@@ -1,17 +1,31 @@
-# MindForge v2 — Cross-Review Command
-# Usage: /mindforge:cross-review [--phase N] [--models list] [--focus area]
+---
+name: mindforge:cross-review
+description: Get code reviewed by multiple AI models simultaneously for consensus validation
+argument-hint: [--phase N] [--models list] [--focus area]
+allowed-tools:
+  - run_command
+  - view_file
+  - write_to_file
+---
 
-## Purpose
-Get the same code diff reviewed by multiple AI models simultaneously.
-Claude finds what Claude finds. GPT-4o finds what GPT-4o finds.
-Consensus findings = high confidence issues.
+<objective>
+Increase review confidence by aggregating findings from multiple diverse AI models, identifying consensus issues and providing a multi-perspective quality assessment.
+</objective>
 
-## Round 1: Primary (Claude)
-Senior architect review.
+<execution_context>
+.claude/commands/mindforge/cross-review.md
+</execution_context>
 
-## Round 2: Adversarial (GPT-4o)
-Critical security and edge case review.
+<context>
+Models: Claude (Primary/Architectural), GPT-4o (Adversarial/Security).
+Focus: Specific area like "security", "performance", or "consistency".
+Pre-check: Models must be available via existing API integrations.
+</context>
 
-## Synthesis
-Consensus detector filters findings.
-Verdict is gating for `/mindforge:ship`.
+<process>
+1. **Round 1 (Primary)**: Execute architectural review using the primary model.
+2. **Round 2 (Adversarial)**: Execute security-focused review using the secondary model.
+3. **Synthesis**: Compare findings from both rounds. Identify consensus "high confidence" issues.
+4. **Final Verdict**: Issue a gating verdict that must be resolved for `/mindforge:ship`.
+5. **Log**: Record the multi-model review results in the audit trail.
+</process>

package/.claude/commands/mindforge/dashboard.md

@@ -1,98 +1,35 @@
-# MindForge v2 — Dashboard Command
-# Usage: /mindforge:dashboard [--port 7339] [--open] [--stop] [--status]
-# Version: v2.0.0-alpha.5
-
-## Purpose
-Start the MindForge real-time web dashboard — a live observability UI for the
-entire team. Shows execution progress, quality metrics, pending approvals,
-knowledge graph, and team activity without requiring CLI access.
-
-## Design
-The dashboard is a localhost-only web server:
-- No build step — single HTML file, no bundler, no npm packages on client
-- No authentication — binding to 127.0.0.1 is the security model
-- Live updates via Server-Sent Events — no WebSocket library needed
-- Designed for screensharing at standups, not external access
-
-## Usage
-
-### Start the dashboard
-```
-/mindforge:dashboard
-→ Dashboard running at: http://localhost:7339
-→ Press CTRL+C to stop (or /mindforge:dashboard --stop)
-```
-
-### Start and open in browser
-```
-/mindforge:dashboard --open
-→ Opens http://localhost:7339 in your default browser
-```
-
-### Custom port
-```
-/mindforge:dashboard --port 7340
-→ Useful if 7339 is already in use
-```
-
-### Stop the dashboard
-```
-/mindforge:dashboard --stop
-→ Finds the running dashboard process (from PID file) and sends SIGTERM
-```
-
-### Check dashboard status
-```
-/mindforge:dashboard --status
-→ Checks if dashboard is running, shows port and PID
-→ Also shows: http://localhost:7339/api/status
-```
-
-## Dashboard pages
-
-### Activity (default)
-- Phase name, auto mode status (RUNNING/PAUSED/ESCALATED/IDLE)
-- Wave progress bar (tasks completed / total)
-- Live AUDIT event feed with color-coded event types
-- Steering input: send guidance to auto mode without touching the CLI
-
-### Quality Metrics
-- Session quality score trend (last 20 sessions)
-- Verify pass rate over time
-- Security findings by severity (CRITICAL/HIGH/MEDIUM/LOW)
-- Cost per session trend
-
-### Approvals
-- All pending Tier 2/3 governance requests
-- [Approve] and [Reject] buttons — no CLI needed for approval
-- Tier, phase/plan, description, time since requested, expiry warning
-- Recent approval history
-
-### Knowledge
-- Search the knowledge graph from the browser
-- Entries filtered by confidence, type, tags
-- Color-coded by knowledge type
-
-### Team
-- Active developers (by git email, from AUDIT.jsonl)
-- What each person is working on (last task)
-- File conflict warnings (two developers recently touching the same file)
-
-## Security rules
-1. Never expose the dashboard on 0.0.0.0 — localhost only
-2. Never forward the port externally (no ngrok, no port forwarding)
-3. For remote team visibility: screenshare your browser instead
-4. The dashboard shows project details including code patterns and decisions
-
-## Integration with auto mode
-When `/mindforge:auto` is running and the dashboard is open:
-- Activity feed updates live as tasks complete
-- Wave progress bar advances in real-time
-- Any escalations appear immediately with red indicator
-- The Steering input is active — inject guidance without a second terminal
-
-## AUDIT entry
-```json
-{ "event": "dashboard_started", "port": 7339, "pid": 12345 }
-{ "event": "dashboard_stopped", "pid": 12345 }
-```
+---
+name: mindforge:dashboard
+description: Start the MindForge real-time web dashboard
+argument-hint: [--port N] [--open] [--stop] [--status]
+allowed-tools:
+  - run_command
+  - list_dir
+  - view_file
+  - open_browser_url
+---
+
+<objective>
+Provide a real-time web-based observability interface for the project, allowing the team to monitor execution progress, quality metrics, pending approvals, and team activity.
+</objective>
+
+<execution_context>
+.claude/commands/mindforge/dashboard.md
+</execution_context>
+
+<context>
+Port: Default 7339 (configurable via --port).
+Security: Binding to 127.0.0.1 (local only).
+Features: Server-Sent Events for live updates, no-auth by design.
+</context>
+
+<process>
+1. **Handle Flags**:
+    - If `--stop`: Find the PID from the PID file and terminate the process.
+    - If `--status`: Check if the dashboard is running and report the URL/PID.
+    - Default: Start the server.
+2. **Start Server**: Execute the dashboard binary/script on the specified port.
+3. **Open Browser**: If `--open` is provided, trigger the default system browser to the dashboard URL.
+4. **Monitor**: Listen for steering inputs from the dashboard and route them to the active MindForge session.
+5. **Log**: Record `dashboard_started` or `dashboard_stopped` in the audit log.
+</process>