mindforge-cc 2.0.0 → 2.1.1

package/.agent/hooks/mindforge-statusline.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+// mindforge-hook-version: 1.28.0
+// Claude Code Statusline - MindForge Edition
+// Shows: model | current task | directory | context usage
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Read JSON from stdin
+let input = '';
+// Timeout guard: if stdin doesn't close within 3s (e.g. pipe issues on
+// Windows/Git Bash), exit silently instead of hanging. See #775.
+const stdinTimeout = setTimeout(() => process.exit(0), 3000);
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => input += chunk);
+process.stdin.on('end', () => {
+  clearTimeout(stdinTimeout);
+  try {
+    const data = JSON.parse(input);
+    const model = data.model?.display_name || 'Claude';
+    const dir = data.workspace?.current_dir || process.cwd();
+    const session = data.session_id || '';
+    const remaining = data.context_window?.remaining_percentage;
+
+    // Context window display (shows USED percentage scaled to usable context)
+    // Claude Code reserves ~16.5% for autocompact buffer, so usable context
+    // is 83.5% of the total window. We normalize to show 100% at that point.
+    const AUTO_COMPACT_BUFFER_PCT = 16.5;
+    let ctx = '';
+    if (remaining != null) {
+      // Normalize: subtract buffer from remaining, scale to usable range
+      const usableRemaining = Math.max(0, ((remaining - AUTO_COMPACT_BUFFER_PCT) / (100 - AUTO_COMPACT_BUFFER_PCT)) * 100);
+      const used = Math.max(0, Math.min(100, Math.round(100 - usableRemaining)));
+
+      // Write context metrics to bridge file for the context-monitor PostToolUse hook.
+      // The monitor reads this file to inject agent-facing warnings when context is low.
+      if (session) {
+        try {
+          const bridgePath = path.join(os.tmpdir(), `claude-ctx-${session}.json`);
+          const bridgeData = JSON.stringify({
+            session_id: session,
+            remaining_percentage: remaining,
+            used_pct: used,
+            timestamp: Math.floor(Date.now() / 1000)
+          });
+          fs.writeFileSync(bridgePath, bridgeData);
+        } catch (e) {
+          // Silent fail -- bridge is best-effort, don't break statusline
+        }
+      }
+
+      // Build progress bar (10 segments)
+      const filled = Math.floor(used / 10);
+      const bar = '█'.repeat(filled) + '░'.repeat(10 - filled);
+
+      // Color based on usable context thresholds
+      if (used < 50) {
+        ctx = ` \x1b[32m${bar} ${used}%\x1b[0m`;
+      } else if (used < 65) {
+        ctx = ` \x1b[33m${bar} ${used}%\x1b[0m`;
+      } else if (used < 80) {
+        ctx = ` \x1b[38;5;208m${bar} ${used}%\x1b[0m`;
+      } else {
+        ctx = ` \x1b[5;31m💀 ${bar} ${used}%\x1b[0m`;
+      }
+    }
+
+    // Current task from todos
+    let task = '';
+    const homeDir = os.homedir();
+    // Respect CLAUDE_CONFIG_DIR for custom config directory setups (#870)
+    const claudeDir = process.env.CLAUDE_CONFIG_DIR || path.join(homeDir, '.agent');
+    const todosDir = path.join(claudeDir, 'todos');
+    if (session && fs.existsSync(todosDir)) {
+      try {
+        const files = fs.readdirSync(todosDir)
+          .filter(f => f.startsWith(session) && f.includes('-agent-') && f.endsWith('.json'))
+          .map(f => ({ name: f, mtime: fs.statSync(path.join(todosDir, f)).mtime }))
+          .sort((a, b) => b.mtime - a.mtime);
+
+        if (files.length > 0) {
+          try {
+            const todos = JSON.parse(fs.readFileSync(path.join(todosDir, files[0].name), 'utf8'));
+            const inProgress = todos.find(t => t.status === 'in_progress');
+            if (inProgress) task = inProgress.activeForm || '';
+          } catch (e) {}
+        }
+      } catch (e) {
+        // Silently fail on file system errors - don't break statusline
+      }
+    }
+
+    // MindForge update available?
+    let mindforgeUpdate = '';
+    const cacheFile = path.join(claudeDir, 'cache', 'mindforge-update-check.json');
+    if (fs.existsSync(cacheFile)) {
+      try {
+        const cache = JSON.parse(fs.readFileSync(cacheFile, 'utf8'));
+        if (cache.update_available) {
+          mindforgeUpdate = '\x1b[33m⬆ /mindforge:update\x1b[0m │ ';
+        }
+        if (cache.stale_hooks && cache.stale_hooks.length > 0) {
+          mindforgeUpdate += '\x1b[31m⚠ stale hooks — run /mindforge:update\x1b[0m │ ';
+        }
+      } catch (e) {}
+    }
+
+    // Output
+    const dirname = path.basename(dir);
+    if (task) {
+      process.stdout.write(`${mindforgeUpdate}\x1b[2m${model}\x1b[0m │ \x1b[1m${task}\x1b[0m │ \x1b[2m${dirname}\x1b[0m${ctx}`);
+    } else {
+      process.stdout.write(`${mindforgeUpdate}\x1b[2m${model}\x1b[0m │ \x1b[2m${dirname}\x1b[0m${ctx}`);
+    }
+  } catch (e) {
+    // Silent fail - don't break statusline on parse errors
+  }
+});

package/.agent/hooks/mindforge-workflow-guard.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+// mindforge-hook-version: 1.28.0
+// MindForge Workflow Guard — PreToolUse hook
+// Detects when Claude attempts file edits outside a MindForge workflow context
+// (no active /mindforge: command or Task subagent) and injects an advisory warning.
+//
+// This is a SOFT guard — it advises, not blocks. The edit still proceeds.
+// The warning nudges Claude to use /mindforge:quick or /mindforge:fast instead of
+// making direct edits that bypass state tracking.
+//
+// Enable via config: hooks.workflow_guard: true (default: false)
+// Only triggers on Write/Edit tool calls to non-.planning/ files.
+
+const fs = require('fs');
+const path = require('path');
+
+let input = '';
+const stdinTimeout = setTimeout(() => process.exit(0), 3000);
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => input += chunk);
+process.stdin.on('end', () => {
+  clearTimeout(stdinTimeout);
+  try {
+    const data = JSON.parse(input);
+    const toolName = data.tool_name;
+
+    // Only guard Write and Edit tool calls
+    if (toolName !== 'Write' && toolName !== 'Edit') {
+      process.exit(0);
+    }
+
+    // Check if we're inside a MindForge workflow (Task subagent or /mindforge: command)
+    // Subagents have a session_id that differs from the parent
+    // and typically have a description field set by the orchestrator
+    if (data.tool_input?.is_subagent || data.session_type === 'task') {
+      process.exit(0);
+    }
+
+    // Check the file being edited
+    const filePath = data.tool_input?.file_path || data.tool_input?.path || '';
+
+    // Allow edits to .planning/ files (MindForge state management)
+    if (filePath.includes('.planning/') || filePath.includes('.planning\\')) {
+      process.exit(0);
+    }
+
+    // Allow edits to common config/docs files that don't need MindForge tracking
+    const allowedPatterns = [
+      /\.gitignore$/,
+      /\.env/,
+      /CLAUDE\.md$/,
+      /AGENTS\.md$/,
+      /GEMINI\.md$/,
+      /settings\.json$/,
+    ];
+    if (allowedPatterns.some(p => p.test(filePath))) {
+      process.exit(0);
+    }
+
+    // Check if workflow guard is enabled
+    const cwd = data.cwd || process.cwd();
+    const configPath = path.join(cwd, '.planning', 'config.json');
+    if (fs.existsSync(configPath)) {
+      try {
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        if (!config.hooks?.workflow_guard) {
+          process.exit(0); // Guard disabled (default)
+        }
+      } catch (e) {
+        process.exit(0);
+      }
+    } else {
+      process.exit(0); // No MindForge project — don't guard
+    }
+
+    // If we get here: MindForge project, guard enabled, file edit outside .planning/,
+    // not in a subagent context. Inject advisory warning.
+    const output = {
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        additionalContext: `⚠️ WORKFLOW ADVISORY: You're editing ${path.basename(filePath)} directly without a MindForge command. ` +
+          'This edit will not be tracked in STATE.md or produce a SUMMARY.md. ' +
+          'Consider using /mindforge:fast for trivial fixes or /mindforge:quick for larger changes ' +
+          'to maintain project state tracking. ' +
+          'If this is intentional (e.g., user explicitly asked for a direct edit), proceed normally.'
+      }
+    };
+
+    process.stdout.write(JSON.stringify(output));
+  } catch (e) {
+    // Silent fail — never block tool execution
+    process.exit(0);
+  }
+});

package/.agent/mindforge/add-backlog.md

@@ -0,0 +1,32 @@
+---
+name: mindforge:add-backlog
+description: Capture ideas in a "parking lot" to keep them out of the active phase sequence
+argument-hint: <description>
+allowed-tools:
+  - view_file
+  - write_to_file
+  - replace_file_content
+  - multi_replace_file_content
+---
+
+<objective>
+Capture an idea, task, or feature request in a "parking lot" section of the ROADMAP.md to prevent it from cluttering the active development phases.
+</objective>
+
+<execution_context>
+.claude/commands/mindforge/add-backlog.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS (The description of the backlog item)
+Target File: ROADMAP.md
+State: Uses 999.x numbering scheme for backlog items.
+</context>
+
+<process>
+1. **Read ROADMAP.md**: Locate the `## Backlog` or `## Future Milestones` section.
+2. **Initialize if missing**: If no backlog section exists, create `## Backlog` at the end of the file.
+3. **Determine numbering**: Find the last `999.x` item. If none, start with `999.1`.
+4. **Append item**: Add the new backlog item with the determined number and the provided description.
+5. **Confirm**: Notify the user that the item has been parked in the backlog.
+</process>

package/.agent/mindforge/agent.md

@@ -0,0 +1,31 @@
+---
+name: mindforge:agent
+description: Spawn or invoke a specialized enterprise persona from the MindForge library
+argument-hint: "[persona-name] [prompt]"
+allowed-tools:
+  - list_dir
+  - view_file
+---
+
+<objective>
+Provide an on-demand mechanism to "spawn" any of the 13+ standardized MindForge personas. This allows the user to switch the AI assistant's context, role, and process to a specific specialized mode (e.g., Roadmapper, Security Reviewer, Analyst).
+</objective>
+
+<execution_context>
+.claude/commands/mindforge/agent.md
+</execution_context>
+
+<context>
+Personas Directory: `.mindforge/personas/`
+State: Loads the persona's XML-tagged structure into the active system context.
+</context>
+
+<process>
+1. **List Personas**: If no arguments are provided, list all available `.md` files in `.mindforge/personas/` with their name and description (parsed from YAML).
+2. **Load Persona**: If a name is provided:
+    - Locate `.mindforge/personas/[name].md`.
+    - Read the file content.
+    - Present the persona's role and success criteria to the user.
+3. **Switch Mode**: Instruct the AI (through the current session context) to adopt the role, philosophy, and process defined in the loaded file.
+4. **Initial Task**: If a prompt is provided as the second argument, immediately execute that prompt using the newly adopted persona.
+</process>

package/.agent/mindforge/discuss-phase.md

@@ -58,7 +58,7 @@ Do not batch questions (unless `--batch` flag is provided).
 5. "Data retention requirements? When can records be deleted?"
 
 ### Integration phases — ask about:
-1. "Have you already chosen the third-party service / API? If so, which?"
+1. "Have you already chosen the third-party service / API? If so, which? (I will query Context7 for current docs if available)"
 2. "What should happen if the third-party service is down? Queue / fail / fallback?"
 3. "Webhooks or polling for receiving updates?"
 4. "Any rate limits you know about on their end?"

package/.agent/mindforge/do.md

@@ -0,0 +1,31 @@
+---
+name: mindforge:do
+description: Smart natural language dispatcher to route intent to the right MindForge command
+argument-hint: <text>
+allowed-tools:
+  - list_dir
+  - view_file
+---
+
+<objective>
+Provide a high-level, natural language interface for users to interact with MindForge without needing to remember specific command names. Routes user intent to the most appropriate internal command.
+</objective>
+
+<execution_context>
+.claude/commands/mindforge/do.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS (The user's intent in plain English)
+Knowledge: Must be aware of all available `.claude/commands/mindforge/*.md` definitions.
+</context>
+
+<process>
+1. **Analyze input**: Parse the user's natural language request.
+2. **Match command**: Compare the intent against the descriptions and objectives of all known MindForge commands.
+3. **Execute match**:
+    - If a clear match is found, immediately pivot to that command's logic.
+    - If multiple matches are possible, ask the user for clarification.
+    - If no match is found, suggest the most relevant command or offer `/mindforge:help`.
+4. **Learn (Optional)**: If the user confirms a routing was correct, record the mapping for future intent resolution.
+</process>

package/.agent/mindforge/help.md

@@ -20,4 +20,4 @@ If `.planning/PROJECT.md` is missing, treat the project as "Not initialised".
    "Next step:       [read STATE.md next action]"
 
 5. If CLAUDE.md has not been read this session, remind the user to ensure
-   it is loaded as the agent's system context.
+   it is loaded as MindForge's system context.

package/.agent/mindforge/learn.md

@@ -37,10 +37,11 @@ load automatically whenever relevant work begins.
 ### Learn from npm package docs
 ```
 /mindforge:learn npm:zod
+/mindforge:learn context7:zod
 /mindforge:learn npm:drizzle-orm
-/mindforge:learn npm:@tanstack/react-query
+/mindforge:learn context7:drizzle-orm
 ```
-→ Fetches README from npm registry
+→ Fetches README from npm registry or real-time docs from Context7
 → Extracts patterns from the package documentation
 
 ### Learn from current session

package/.agent/mindforge/note.md

@@ -0,0 +1,35 @@
+---
+name: mindforge:note
+description: Capture an idea, task, or issue that surfaces during a session as a quick note for later
+argument-hint: <text> [list|promote N]
+allowed-tools:
+  - list_dir
+  - view_file
+  - write_to_file
+  - multi_replace_file_content
+---
+
+<objective>
+Provide a zero-friction way to capture ephemeral thoughts, bugs, or todos during an active session without interrupting the current flow, with the ability to later promote them to official tasks.
+</objective>
+
+<execution_context>
+.claude/commands/mindforge/note.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS (The note text or subcommand like `list` or `promote`)
+Storage: .planning/notes/
+Target for Promotion: ROADMAP.md or STATE.md
+</context>
+
+<process>
+1. **Route Subcommand**:
+    - If `list`: Read all files in `.planning/notes/` and present them.
+    - If `promote <N>`: Read note N, add it to current phase/milestone in STATE.md or ROADMAP.md, then move the note to `.planning/notes/archived/`.
+    - Else (default): Capture the text.
+2. **Capture Flow**:
+    - Ensure `.planning/notes/` directory.
+    - Create a file `note_[timestamp].md` with the content.
+3. **Confirm**: Quick confirmation of capture or promotion result.
+</process>

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

@@ -0,0 +1,31 @@
+---
+name: mindforge:plant-seed
+description: Capture speculative ideas with triggers that surface automatically when relevant
+argument-hint: <idea>
+allowed-tools:
+  - list_dir
+  - write_to_file
+  - view_file
+---
+
+<objective>
+Capture speculative or long-term ideas (seeds) and store them in a way that they can be automatically resurfaced when a relevant future milestone or phase is started.
+</objective>
+
+<execution_context>
+.claude/commands/mindforge/plant-seed.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS (The speculative idea)
+Storage: .planning/seeds/
+Trigger mechanism: Files in this directory are checked during `init-project` or `milestone` creation.
+</context>
+
+<process>
+1. **Ensure storage**: Verify `.planning/seeds/` exists; create if not.
+2. **Generate filename**: Create a slugified filename based on the idea or a timestamp.
+3. **Write seed**: Create a markdown file with the idea, any inferred triggers (tags/keywords), and the current timestamp.
+4. **Link to system**: Add a note to the master seed index if one exists.
+5. **Confirm**: Let the user know the seed has been planted and what might trigger its resurrection.
+</process>

package/.agent/mindforge/research.md

@@ -3,9 +3,10 @@
 
 ## Purpose
 Deep research using Gemini 1.5 Pro's 1-million-token context window.
-Incorporate local code context and remote documentation simultaneously.
+Uses **Context7 MCP** as the primary engine for real-time documentation and code example retrieval.
 
 ## Capabilities
-- Ingest full library documentation.
+- Ingest full library documentation via Context7.
 - Codebase-wide architectural analysis.
 - Regulatory compliance audits.
+- Real-time resolution of version-specific API contracts.

package/.agent/mindforge/review-backlog.md

@@ -0,0 +1,34 @@
+---
+name: mindforge:review-backlog
+description: Review and promote backlog items to the active phase sequence
+argument-hint: [optional filters]
+allowed-tools:
+  - view_file
+  - write_to_file
+  - replace_file_content
+  - multi_replace_file_content
+---
+
+<objective>
+Review items currently parked in the ROADMAP.md backlog and facilitate their promotion to the active development plan.
+</objective>
+
+<execution_context>
+.claude/commands/mindforge/review-backlog.md
+</execution_context>
+
+<context>
+Target File: ROADMAP.md, STATE.md
+State: Resolves the next available phase number from STATE.md for promotion.
+</context>
+
+<process>
+1. **Read ROADMAP.md**: Extract all items under the `## Backlog` section (999.x).
+2. **Present to User**: List the backlog items and ask which one(s) should be promoted.
+3. **Determine Promotion Slot**: Read STATE.md to find the next sequential phase number.
+4. **Promote Item**:
+    - Move the item from the backlog to the active milestone list.
+    - Renumber the item to the next available phase number.
+5. **Update STATE.md**: Add the new phase to STATE.md in `unplanned` or `planned` status as appropriate.
+6. **Confirm**: Summarize the promotion to the user.
+</process>

package/.agent/mindforge/session-report.md

@@ -0,0 +1,39 @@
+---
+name: mindforge:session-report
+description: Generate a post-session summary document capturing work performed and resource usage
+argument-hint: none
+allowed-tools:
+  - run_command
+  - view_file
+  - write_to_file
+  - list_dir
+---
+
+<objective>
+Generate a comprehensive summary of an active coding session, providing a clear trail of work for stakeholders and a diagnostic record of resource usage (tokens, time, etc.).
+</objective>
+
+<execution_context>
+.claude/commands/mindforge/session-report.md
+</execution_context>
+
+<context>
+Storage: .planning/reports/
+Data sources: Git logs, terminal history, `STATE.md`, and session memory.
+</context>
+
+<process>
+1. **Gather Data**:
+    - Get recent git commits and diff summaries.
+    - Read the current `STATE.md` for phase/plan status updates.
+    - Extract key decisions or findings from the session.
+2. **Profile Resources**:
+    - Estimate token usage if possible.
+    - Calculate session duration.
+3. **Draft Report**: Create `SESSION_REPORT_[timestamp].md` containing:
+    - Summary of Work Performed
+    - Outcomes achieved (Plans "completed")
+    - Key Decisions
+    - Resource Usage Profile
+4. **Confirm**: Notify the user and provide a link to the report.
+</process>

package/.agent/mindforge/steer.md

@@ -1,7 +1,7 @@
 # /mindforge:steer "[instruction]"
 
 **Purpose**: Injects mid-execution guidance into the running autonomous engine.
-Steering guidance is applied at the next task boundary to course-correct the agent.
+Steering guidance is applied at the next task boundary to course-correct MindForge.
 
 ## Usage
 - `/mindforge:steer "Use the new logger in all created files"`

package/.agent/mindforge/ui-phase.md

@@ -0,0 +1,34 @@
+---
+name: mindforge:ui-phase
+description: Generate a UI Design Contract (UI-SPEC.md) for the current phase
+argument-hint: [N]
+allowed-tools:
+  - view_file
+  - write_to_file
+  - list_dir
+---
+
+<objective>
+Generate a detailed UI design contract (UI-SPEC.md) for a frontend development phase to ensure consistent spacing, typography, color palettes, and accessibility standards before implementation.
+</objective>
+
+<execution_context>
+.claude/commands/mindforge/ui-phase.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS (The phase number [N], optional)
+Configuration: MINDFORGE.md `UI_PHASE_ACCESSIBILITY_STANDARD`
+State: Resolves the phase from STATE.md if N is not provided.
+</context>
+
+<process>
+1. **Identify Phase**: Get the current or targeted phase number.
+2. **Read Inputs**: Read `REQUIREMENTS.md` and `DESIGN_SYSTEM.md`.
+3. **Generate UI-SPEC.md**:
+    - Define component-level spacing and layout for the phase.
+    - Specify required colors and typography from the design system.
+    - List accessibility requirements (WCAG level).
+4. **Finalize**: Write `UI-SPEC.md` to the phase's planning directory or the root `.planning/`.
+5. **Confirm**: Provide a link to the user for review.
+</process>

package/.agent/mindforge/ui-review.md

@@ -0,0 +1,36 @@
+---
+name: mindforge:ui-review
+description: Perform a retroactive visual audit of implemented UI against the DESIGN_SYSTEM.md and UI-SPEC.md
+argument-hint: [N]
+allowed-tools:
+  - view_file
+  - write_to_file
+  - read_browser_page
+  - open_browser_url
+---
+
+<objective>
+Perform a retroactive, multi-pillar visual audit of implemented UI features against the defined Design System and UI-SPEC.md to ensure pixel-perfect fidelity and accessibility compliance.
+</objective>
+
+<execution_context>
+.claude/commands/mindforge/ui-review.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS (The phase number [N], optional)
+Sources: `DESIGN_SYSTEM.md`, `UI-SPEC.md`, and the live application UI.
+</context>
+
+<process>
+1. **Identify Target**: Determine the phase to review.
+2. **Audit Application**:
+    - Use the browser tool to inspect the implemented features.
+    - Compare against the `UI-SPEC.md` for spacing, colors, and layout.
+    - Audit for accessibility (ARIA labels, contrast, keyboard navigation).
+3. **Generate UI-REVIEW.md**:
+    - Grade each pillar (Layout, Color, Typography, etc.).
+    - List specific "Needs Work" items.
+    - Provide "Approved" status if all criteria are met.
+4. **Finalize**: Notify the user of the audit results.
+</process>

package/.agent/mindforge/validate-phase.md

@@ -0,0 +1,31 @@
+---
+name: mindforge:validate-phase
+description: Audit the current phase for requirement coverage and test gaps
+argument-hint: [N]
+allowed-tools:
+  - view_file
+  - list_dir
+---
+
+<objective>
+Audit a completed project phase to ensure every requirement has been addressed and that corresponding automated tests have been implemented and are passing.
+</objective>
+
+<execution_context>
+.claude/commands/mindforge/validate-phase.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS (The phase number [N], optional)
+Knowledge: `STATE.md`, `REQUIREMENTS.md`, and the codebase test suite.
+</context>
+
+<process>
+1. **Identify Phase**: Resolve the targeted phase.
+2. **Cross-reference**:
+    - List all requirements in `REQUIREMENTS.md` marked for this phase.
+    - Verify implementation of each requirement in the code.
+    - Check for the existence of passing tests for each requirement.
+3. **Analyze Gaps**: Identify any "orphaned" requirements or features missing tests.
+4. **Report Findings**: Summarize coverage and call out specific gaps to the user.
+</process>

package/.agent/mindforge/workstreams.md

@@ -0,0 +1,35 @@
+---
+name: mindforge:workstreams
+description: Manage parallel feature tracks with isolated state
+argument-hint: [list|create|switch|status|complete]
+allowed-tools:
+  - list_dir
+  - view_file
+  - write_to_file
+  - run_command
+---
+
+<objective>
+Enable developers to work on multiple features or bugs concurrently within the same codebase without state collision. Provides isolated tracking for each "workstream".
+</objective>
+
+<execution_context>
+.claude/commands/mindforge/workstreams.md
+</execution_context>
+
+<context>
+Arguments: $ARGUMENTS (Switch subcommand)
+Storage: .planning/workstreams/
+State: Each workstream maintains its own subset of `STATE.md` or a local context file.
+</context>
+
+<process>
+1. **Route Subcommand**:
+    - `list`: Show all active and archived workstreams in `.planning/workstreams/`.
+    - `create <name>`: Initialize a new workstream directory and baseline state.
+    - `switch <name>`: Update the global pointer in `STATE.md` to the targeted workstream.
+    - `status`: Show the current active workstream and its progress.
+2. **Manage Isolation**:
+    - When switching, ensure current work is saved or stashed if necessary.
+3. **Confirm**: Success/Failure status message to user.
+</process>