mindforge-cc 2.0.0-alpha.9 → 2.0.0

package/.mindforge/skills-builder/quality-scoring.md

@@ -0,0 +1,120 @@
+# MindForge v2 — Skill Quality Scoring
+
+## Purpose
+Every SKILL.md gets a quality score from 0-100 before registration.
+This score determines: whether it can be registered (≥ 60), whether it can
+be published to the community marketplace (≥ 80), and how prominently it
+is featured in search results.
+
+## Scoring dimensions (total: 100 points)
+
+### Dimension 1: Trigger Coverage (30 points)
+Measures: How many unique, specific trigger keywords the skill has.
+- 25-30 triggers: 30 points (full score)
+- 20-24 triggers: 24 points
+- 15-19 triggers: 18 points
+- 10-14 triggers: 12 points
+- 5-9 triggers: 6 points
+- < 5 triggers: 0 points
+
+Penalty: -2 points per generic trigger (words like "database", "api", "model"
+that would fire for almost any project). Triggers must be technology-specific.
+
+### Dimension 2: Mandatory Actions Completeness (25 points)
+Measures: Whether the skill has complete, actionable mandatory actions.
+Check for these mandatory sections:
+- [ ] At least 5 concrete "always do X" rules (5 pts)
+- [ ] At least 3 concrete "never do Y" rules (5 pts)
+- [ ] Security consideration section (5 pts)
+- [ ] Performance consideration section (5 pts)
+- [ ] Error handling guidance (5 pts)
+
+### Dimension 3: Code Examples (20 points)
+Measures: Quality and completeness of code examples.
+- 5+ complete, working code examples: 20 points
+- 3-4 examples: 14 points
+- 1-2 examples: 7 points
+- No examples: 0 points
+
+Bonus: +2 points if examples show both correct pattern AND anti-pattern side-by-side.
+
+### Dimension 4: Self-Check Checklist (15 points)
+Measures: Does the skill include a checklist an agent can use to verify its work?
+- 10+ checklist items: 15 points
+- 7-9 items: 10 points
+- 4-6 items: 7 points
+- 1-3 items: 3 points
+- No checklist: 0 points
+
+### Dimension 5: Injection Safety (10 points)
+Measures: Does the skill pass all injection guard checks?
+- No injection patterns detected: 10 points (full score)
+- Any injection pattern detected: 0 points (FAIL — skill cannot be registered)
+
+Injection patterns checked (same 8 as in skill-loader.md):
+IGNORE ALL PREVIOUS INSTRUCTIONS, DISREGARD YOUR INSTRUCTIONS, etc.
+
+### Dimension 6: No Placeholders (10 points)
+Measures: Absence of placeholder/template text that was never filled in.
+- Zero placeholders: 10 points
+- 1-2 placeholders: 5 points
+- 3+ placeholders: 0 points
+
+Placeholder patterns:
+`[your description here]`, `TODO`, `FIXME`, `<description>`, `...fill in...`
+
+### Dimension 7: Version History (10 points)
+Measures: Whether the skill has a changelog / version history.
+- Has ## Version History section with at least v1.0.0 entry: 10 points
+- Has frontmatter version but no history section: 5 points
+- No version information: 0 points
+
+Bonus: +2 points if skill has been updated more than once (shows maintenance).
+
+## Quality thresholds
+
+| Score | Status | Allowed actions |
+|---|---|---|
+| 90-100 | Excellent | Register, publish, featured in marketplace |
+| 80-89 | Good | Register, eligible to publish |
+| 70-79 | Acceptable | Register, not eligible for marketplace |
+| 60-69 | Minimum | Register with warning |
+| < 60 | Insufficient | Cannot register — must improve first |
+
+## `session_quality_lift` metric
+After a skill has been used in ≥ 5 sessions, compute:
+```
+lift = avg(session_quality_score when skill active)
+     - avg(session_quality_score when skill not active)
+```
+This is the most honest signal of skill value. A skill with quality_score=94
+but session_quality_lift=-2 is a misleading skill (it sounds good but hurts results).
+
+## Scoring output format
+```json
+{
+  "skill_name": "prisma-schema",
+  "version": "1.0.0",
+  "quality_score": 84,
+  "threshold_status": "good",
+  "can_register": true,
+  "can_publish": true,
+  "score_breakdown": {
+    "trigger_coverage": 27,
+    "mandatory_actions": 22,
+    "code_examples": 17,
+    "self_check": 12,
+    "injection_safe": 10,
+    "no_placeholders": 9,
+    "version_history": 8
+  },
+  "penalties_applied": [
+    { "dimension": "trigger_coverage", "reason": "1 generic trigger 'database'", "penalty": -2 }
+  ],
+  "improvement_suggestions": [
+    "Add 3 more trigger keywords to reach 25+ (currently 22)",
+    "Add performance considerations section (currently missing)",
+    "Add 3 more checklist items to reach 10+ (currently 7)"
+  ]
+}
+```

package/.planning/AUDIT.jsonl

@@ -0,0 +1 @@
+{"timestamp":"2026-03-22T20:52:21.691Z","event":"skill_installed","skill_name":"security-owasp","skill_version":"1.2.0","tier":2,"source":"cli-system","validation_passed":true}

package/.planning/decisions/ADR-036-learn-command-docs-as-skill-source.md

@@ -0,0 +1,26 @@
+# ADR-036: Documentation is the authoritative source for skill content
+
+**Status:** Accepted | **Date:** v2.0.0 | **Day:** 13
+
+## Context
+Where should skill content come from — human-authored or AI-generated?
+
+## Decision
+Skill content is AI-generated from authoritative documentation (official docs,
+internal runbooks, npm READMEs, or session analysis). The AI reads the docs
+and writes down what it learned, following the SKILL.md authoring template.
+
+## Rationale
+Documentation is the authoritative, maintained, versioned source of truth for
+any technology. Human-authored skills get stale and diverge from reality.
+Documentation-sourced skills automatically reflect the current state of the
+technology when regenerated.
+
+The AI's role: transform documentation into the MindForge SKILL.md format
+(structured rules, trigger keywords, code examples, checklist) — not to
+invent patterns that don't exist in the documentation.
+
+## Consequences
+Skills should be regenerated when documentation is updated (major versions).
+The quality of skills depends on the quality of source documentation.
+Internal documentation produces the most project-specific, valuable skills.

package/.planning/decisions/ADR-037-auto-capture-frequency-threshold.md

@@ -0,0 +1,26 @@
+# ADR-037: Pattern frequency ≥ 2 tasks as the auto-capture threshold
+
+**Status:** Accepted | **Date:** v2.0.0 | **Day:** 13
+
+## Context
+What frequency of pattern appearance should trigger auto-capture?
+
+## Decision
+Auto-capture triggers when a pattern appears in ≥ 2 tasks (default).
+Exception: a pattern in 1 task can also qualify if difficulty = "high" AND
+generality ≠ "low" (important patterns worth capturing even on first occurrence).
+
+Configurable via AUTO_CAPTURE_MIN_PATTERN_COUNT in MINDFORGE.md.
+
+## Rationale
+A single occurrence is high-noise — it could be a one-off approach or
+something specific to that task's edge case. Two occurrences strongly
+suggest a reusable pattern. The exception for "high difficulty + non-low
+generality" catches important one-time discoveries (security patterns, tricky
+library APIs) that are hard to rediscover and broadly applicable.
+
+## Consequences
+Most phases will produce 0-3 capture candidates (not noisy).
+High-activity phases with many similar tasks may produce more.
+The user always approves before any skill is created — auto-capture is a
+suggestion, never automatic skill creation.

package/.planning/decisions/ADR-038-skill-quality-minimum-60.md

@@ -0,0 +1,27 @@
+# ADR-038: Minimum quality score of 60 for skill registration
+
+**Status:** Accepted | **Date:** v2.0.0 | **Day:** 13
+
+## Context
+What quality score should be required before a skill can be registered?
+
+## Decision
+Minimum score of 60/100 for project/org registration.
+Minimum score of 80/100 for community marketplace publication.
+Injection check failure (dimension 5 = 0) = absolute block regardless of total score.
+
+## Rationale
+60 is the "minimum viable" threshold — a skill at 60 has enough triggers,
+content, and examples to be useful, but is below the "good" tier (80).
+The gap between 60 and 80 allows registration for internal use while protecting
+the public marketplace from mediocre skills.
+
+The injection check is absolute — a skill that contains "IGNORE ALL PREVIOUS
+INSTRUCTIONS" must NEVER be registered regardless of its other quality dimensions.
+Even a score of 95 with an injection pattern is blocked. This is the same
+non-negotiable principle as Gate 3 (secret detection) in compliance-gates.md.
+
+## Consequences
+The AI-generated learn pipeline is tuned to produce skills scoring ≥ 80.
+Skills below 60 get improvement suggestions but cannot be registered.
+Teams can lower this threshold via SKILL_QUALITY_MIN_SCORE in MINDFORGE.md.

package/CHANGELOG.md

@@ -1,5 +1,57 @@
 # Changelog
 
+## [2.0.0] — The Autonomous Enterprise — 2026-03-24
+
+🚀 **MindForge v2.0.0 — The Autonomous Enterprise — Major Release**
+
+This major release transforms MindForge from a Claude-centric framework into a universal AI agent operating system. With support for 6 major runtimes and a hardened autonomous execution engine, v2.0.0 is built for enterprise-scale AI orchestration.
+
+### Added
+- **6-Runtime Multi-Platform Support**: Official support for Claude Code, Antigravity, Cursor, OpenCode, Gemini CLI, and GitHub Copilot.
+- **Runtime Adapters**: Automatic content transformation for Gemini (model/filename mapping) and preambles for non-slash runtimes (Cursor/Copilot).
+- **`/mindforge:new-runtime`**: Rapidly scaffold custom AI agent runtimes with correct directory structures and command visibility.
+- **Unified Migration Engine (v2.0.0)**: Additive schema upgrades for `AUDIT.jsonl` (runtime/agent_id) and `token-usage.jsonl` (model_group).
+- **Hardened Self-Building Skills**: Automated skill capture from documentation and phase outputs.
+- **7-Dimension Quality Scorer**: Enhanced static analysis for skill authoring.
+- **65-Point Production Checklist**: Exhaustive verification suite for enterprise readiness.
+
+### Changed
+- **Directory Standard**: Antigravity local workflows moved to `.agents/workflows/` with mandatory YAML frontmatter.
+- **Migration Strategy**: Transitioned to an idempotent, backup-first migration model with smart skipping.
+- **Stable Interface Contract**: Hardened internal members (RUNTIMES, generateEntryContent) for extensibility.
+
+### Architecture Decisions
+- **ADR-039**: Multi-Runtime Platform Support.
+- **ADR-040**: Additive Schema Migration Strategy.
+- **ADR-041**: Stable Runtime Interface Contract.
+
+---
+
+## [2.0.0-alpha.12] — Self-Building Skills Platform — 2026-03-24
+### Added
+- **Self-Building Skills Platform**: Intelligent engine for automatically capturing skills from documentation, sessions, and npm packages.
+- **`/mindforge:learn`**: High-level orchestration command for 7-step skill generation pipeline.
+- **`/mindforge:marketplace`**: Seamless integration with npm registry for community skills discovery and installation.
+- **7-Dimension Quality Scorer**: Static analysis tool ensuring high-quality, injection-safe skill authoring.
+- **Auto-Capture Hook**: Automatic pattern detection from phase outputs (SUMMARY, ADR, HANDOFF).
+- **CLI Commands**: `learn-skill` and `marketplace` added to `bin/mindforge-cli.js`.
+- **ADR-036, ADR-037, ADR-038**: New architectural decisions for skill sourcing, capture thresholds, and quality gates.
+
+## [2.0.0-alpha.11] — Persistent Knowledge Graph — 2026-03-24
+### Added
+- **Persistent Knowledge Graph**: Core engine for long-term memory across projects.
+- **`remember` CLI**: New command for manual knowledge management and semantic search.
+- **Automated Capture**: Hooks in `AutoRunner` and `CrossReviewEngine` to ingest insights automatically from phase completions and review reports.
+- **Context Injection**: `installer-core.js` now auto-injects relevant historical context into `CLAUDE.md` during installation.
+- **`test-memory` CLI**: New command for memory suite verification.
+
+## [2.0.0-alpha.10] — Skill Installation & Validation CLI — 2026-03-24
+### Added
+- New CLI commands: `validate-skill`, `install-skill`, `register-skill`, `audit-skill`.
+- Robust skill validation logic (Level 1 & 2) in `bin/skill-validator.js`.
+- Automated manifest management and audit logging in `bin/skill-registry.js`.
+- Integrated CLI commands into the `install-skill.md` agentic workflow for higher reliability.
+
 ## [2.0.0-alpha.9] — Verified Antigravity Compatibility — 2026-03-23
 ### Fixed
 - Fixed critical installer regression where `files` variable was undefined during command installation.

package/MINDFORGE.md

@@ -97,3 +97,12 @@ PROJECT_FORBIDDEN_PATTERNS="""
 - No console.log in API services
 - No TODO comments in committed code
 """
+
+## Self-Building Skills
+AUTO_CAPTURE_SKILLS=false
+AUTO_CAPTURE_MIN_PATTERN_COUNT=2
+AUTO_CAPTURE_MIN_CONFIDENCE=0.75
+LEARN_MODEL=inherit
+MARKETPLACE_REGISTRY=https://registry.mindforge.dev/v1
+MARKETPLACE_DAILY_FETCH_LIMIT=50
+SKILL_QUALITY_MIN_SCORE=60

package/README.md

@@ -1,8 +1,8 @@
-# MindForge — Enterprise Agentic Framework (v2.0.0-alpha.9)
+# MindForge — Enterprise Agentic Framework (v2.0.0)
 
 MindForge turns Claude Code and Antigravity into production-grade engineering
 partners with governance, observability, and a disciplined workflow engine.
-Release published: v1.0.0 (GitHub Releases).
+Release published: v2.0.0.
 
 ```bash
 npx mindforge-cc@latest
@@ -23,6 +23,7 @@ Decisions get forgotten. MindForge fixes that with:
 - **Browser Runtime** — headful/headless visual QA and sessions (v2)
 - **Multi-Model Intelligence** — dynamic routing, adversarial reviews, and deep research (v2)
 - **Persistent Knowledge Graph** — long-term memory across all engineering sessions (v2)
+- **Self-Building Skills** — automatically capture knowledge from any source into reusable skills (v2)
 - **Quality gates** — compliance and security are non-bypassable
 - **Audit trail** — append-only history of every action
 
@@ -67,9 +68,34 @@ Optional: minimal project scaffolding
 npx mindforge-cc@latest --claude --local --minimal
 ```
 
-### Both runtimes
+### Cursor
 ```bash
-npx mindforge-cc@latest --all --global
+npx mindforge-cc@latest --cursor --local
+```
+
+### Gemini CLI
+```bash
+npx mindforge-cc@latest --gemini --global
+```
+
+### GitHub Copilot
+```bash
+npx mindforge-cc@latest --copilot --local
+```
+
+### OpenCode
+```bash
+npx mindforge-cc@latest --opencode --global
+```
+
+### Specific Runtime (Universal)
+```bash
+npx mindforge-cc@latest --runtime <name>
+```
+
+### Multiple runtimes
+```bash
+npx mindforge-cc@latest --runtime claude,cursor --local
 ```
 
 ---
@@ -159,6 +185,17 @@ If issues are found, run:
 / mindforge:dashboard
     → Real-time web observability and governance at localhost:7339 (v2)
     → Live audit logs, metrics, activity, and team feed
+
+/ mindforge:learn
+    → Automatically capture skills from Docs, Sessions, or npm (v2)
+    → 7-dimension quality scoring and injection protection
+
+/ mindforge:marketplace
+    → Search, install, and publish community skills (v2)
+    → Verified installation via npm-based registry
+
+/ mindforge:new-runtime
+    → Scaffold custom runtime configurations for any AI agent (v2)
 ```
 
 ---
@@ -215,7 +252,7 @@ See `.mindforge/production/token-optimiser.md`.
 
 ---
 
-## What ships in v2.0.0-alpha.9
+## What ships in v2.0.0-alpha.10
 - **Real-time Dashboard**: `/mindforge:dashboard` and web-based observability.
 - **Persistent Knowledge Graph**: `/mindforge:remember` and long-term memory engine.
 - **Multi-Model Intelligence Layer**: `/mindforge:cross-review`, `/mindforge:research`, and `/mindforge:costs`.

package/bin/autonomous/auto-runner.js

@@ -11,6 +11,7 @@ const stuckMonitor = require('./stuck-monitor');
 const steeringManager = require('./steer');
 const progressStream = require('./progress-stream');
 const headlessAdapter = require('./headless');
+const KnowledgeCapture = require('../memory/knowledge-capture');
 
 class AutoRunner {
   constructor(options = {}) {
@@ -66,6 +67,17 @@ class AutoRunner {
     console.log('✅ Phase complete!');
     const report = progressStream.generateReport(this.auditPath, this.phase);
     fs.writeFileSync(path.join(process.cwd(), `.planning/phases/${this.phase}/AUTONOMOUS-REPORT.md`), report);
+    
+    // Auto-capture knowledge from completed phase (ADRs, findings)
+    try {
+      const captured = KnowledgeCapture.captureFromPhaseCompletion(this.phase);
+      if (captured.length > 0) {
+        console.log(`🧠 Knowledge Graph: Captured ${captured.length} new insights from phase completion.`);
+      }
+    } catch (err) {
+      console.error('⚠️ Knowledge Capture failed:', err.message);
+    }
+    
     this.writeAudit({ event: 'auto_mode_completed', timestamp: new Date().toISOString() });
   }
 

package/bin/install.js

@@ -50,7 +50,8 @@ if (ARGS.includes('--help') || ARGS.includes('-h')) {
 
 // ── Determine execution mode ──────────────────────────────────────────────────
 const NON_INTERACTIVE_FLAGS = [
-  '--claude', '--antigravity', '--all',
+  '--claude', '--antigravity', '--cursor', '--opencode', '--gemini', '--copilot',
+  '--all', '--runtime',
   '--global', '-g', '--local', '-l',
   '--uninstall', '--update', '--check',
   '--skip-wizard', '--dry-run', '--with-utils', '--minimal',
@@ -86,7 +87,12 @@ function printHelp() {
   RUNTIMES (pick one or use --all)
     --claude          Claude Code  (~/.claude or .claude/)
     --antigravity     Antigravity  (~/.gemini/antigravity or .agents/; .agent/ legacy)
-    --all             Both runtimes
+    --cursor          Cursor       (~/.cursor or .cursor/)
+    --opencode        OpenCode     (~/.opencode or .opencode/)
+    --gemini          Gemini CLI   (~/.gemini or .gemini/)
+    --copilot         GitHub Copilot (~/.github/copilot or .github/)
+    --all             All 6 runtimes
+    --runtime <name>  Explicitly specify runtime by name
 
   SCOPE
     --global, -g      Install to home directory (all projects)

package/bin/installer-core.js

@@ -7,25 +7,86 @@
 const fs   = require('fs');
 const path = require('path');
 const os   = require('os');
+const SessionMemoryLoader = require('./memory/session-memory-loader');
 
 const VERSION = require('../package.json').version;
 
 // ── Runtime configurations ────────────────────────────────────────────────────
 const RUNTIMES = {
   claude: {
+    displayName:    'Claude Code',
     globalDir:      path.join(os.homedir(), '.claude'),
     localDir:       '.claude',
     commandsSubdir: 'commands/mindforge',
     entryFile:      'CLAUDE.md',
+    supportsSlash:  true,
   },
   antigravity: {
+    displayName:    'Antigravity',
     globalDir:      path.join(os.homedir(), '.gemini', 'antigravity'),
     localDir:       '.agents',
     commandsSubdir: 'workflows',
     entryFile:      'CLAUDE.md',
+    supportsSlash:  true,
+  },
+  cursor: {
+    displayName:    'Cursor',
+    globalDir:      path.join(os.homedir(), '.cursor'),
+    localDir:       '.cursor',
+    commandsSubdir: 'rules',
+    entryFile:      '.cursorrules',
+    supportsSlash:  false,
+  },
+  opencode: {
+    displayName:    'OpenCode',
+    globalDir:      path.join(os.homedir(), '.opencode'),
+    localDir:       '.opencode',
+    commandsSubdir: 'commands/mindforge',
+    entryFile:      'CLAUDE.md',
+    supportsSlash:  true,
+  },
+  gemini: {
+    displayName:    'Gemini CLI',
+    globalDir:      path.join(os.homedir(), '.gemini'),
+    localDir:       '.gemini',
+    commandsSubdir: 'commands/mindforge',
+    entryFile:      'GEMINI.md',
+    supportsSlash:  true,
+  },
+  copilot: {
+    displayName:    'GitHub Copilot',
+    globalDir:      path.join(os.homedir(), '.github', 'copilot'),
+    localDir:       '.github',
+    commandsSubdir: 'copilot-instructions/mindforge',
+    entryFile:      'copilot-instructions.md',
+    supportsSlash:  false,
   },
 };
 
+/**
+ * Generates runtime-specific entry file content.
+ * e.g. replacing "Claude" with "Gemini" in GEMINI.md
+ */
+function generateEntryContent(runtime, sourceContent) {
+  if (runtime === 'gemini') {
+    return sourceContent
+      .replace(/claude-3-5-sonnet/gi, 'gemini-2.0-flash-exp')
+      .replace(/Claude Code/g, 'Gemini CLI')
+      .replace(/CLAUDE.md/g, 'GEMINI.md');
+  }
+  
+  if (runtime === 'cursor' || runtime === 'copilot') {
+    // Add preamble for non-slash runtimes as per review feedback
+    const preamble = `<!--
+  MindForge Rule Set for ${RUNTIMES[runtime].displayName}
+  MindForge command reference: @[command name without .md]
+-->\n\n`;
+    return preamble + sourceContent;
+  }
+
+  return sourceContent;
+}
+
 // ── File system utilities ─────────────────────────────────────────────────────
 const fsu = {
   exists:     p  => fs.existsSync(p),
@@ -159,9 +220,10 @@ function safeCopyClaude(src, dst, options = {}) {
 
 // ── Install verification ──────────────────────────────────────────────────────
 function verifyInstall(baseDir, cmdsDir, runtime, scope) {
+  const cfg = RUNTIMES[runtime];
   const pfx = runtime === 'antigravity' ? 'mindforge:' : '';
   const required = [
-    scope === 'local' ? path.join(process.cwd(), 'CLAUDE.md') : path.join(baseDir, 'CLAUDE.md'),
+    scope === 'local' ? path.join(process.cwd(), cfg.entryFile) : path.join(baseDir, cfg.entryFile),
     path.join(cmdsDir, `${pfx}help.md`),
     path.join(cmdsDir, `${pfx}init-project.md`),
     path.join(cmdsDir, `${pfx}health.md`),
@@ -200,32 +262,56 @@ async function install(runtime, scope, options = {}) {
 
   if (dryRun) {
     console.log('\n  Would install:');
-    console.log(`    CLAUDE.md → ${path.join(baseDir, 'CLAUDE.md')}`);
+    console.log(`    ${cfg.entryFile} → ${path.join(baseDir, cfg.entryFile)}`);
     console.log(`    ${fsu.listFiles(src('.claude', 'commands', 'mindforge')).length} commands → ${cmdsDir}`);
     return;
   }
 
-  // ── 1. Install CLAUDE.md (Root standardization for IDEs) ────────────────────
-  const claudeSrc = runtime === 'claude'
-    ? src('.claude', 'CLAUDE.md')
-    : src('.agent', 'CLAUDE.md');
-
+  const claudeSrc = src('.claude', 'CLAUDE.md');
   if (fsu.exists(claudeSrc)) {
+    // ✨ PERSISTENT MEMORY: Load relevant context for this session
+    let content = fsu.read(claudeSrc);
+    if (scope === 'local') {
+      try {
+        const stack = SessionMemoryLoader.readTechStack();
+        const memory = SessionMemoryLoader.loadForSession({ techStack: stack });
+        if (memory.count > 0) {
+          const header = SessionMemoryLoader.generateSessionHeader(memory);
+          const injection = `\n\n## 🧠 Knowledge Context (Auto-loaded)\n${header}\n${memory.formatted}\n`;
+          content += injection;
+        }
+      } catch (err) {
+        console.error('  ⚠️  Memory injection failed:', err.message);
+      }
+    }
+
+    // ✨ RUNTIME ADAPTATION: Generate specific content for this runtime
+    const adaptedContent = generateEntryContent(runtime, content);
+
     // Keep legacy location based on runtime config
-    safeCopyClaude(claudeSrc, path.join(baseDir, 'CLAUDE.md'), { force, verbose });
+    const tempEntry = path.join(os.tmpdir(), `${cfg.entryFile}-${Date.now()}.md`);
+    fsu.write(tempEntry, adaptedContent);
+    
+    const targetPath = path.join(baseDir, cfg.entryFile);
+    safeCopyClaude(tempEntry, targetPath, { force, verbose });
 
     // ✨ STANDARD: Inject into project root and IDE-specific rules files
     if (scope === 'local' && !selfInstall) {
       const rootClaude = path.join(process.cwd(), 'CLAUDE.md');
-      const rootCursor = path.join(process.cwd(), '.cursorrules');
-      const rootWindsurf = path.join(process.cwd(), '.windsurfrules');
+      const rootEntry  = path.join(process.cwd(), cfg.entryFile);
+      
+      // Always provide CLAUDE.md as the base standard
+      safeCopyClaude(tempEntry, rootClaude, { force, verbose });
       
-      safeCopyClaude(claudeSrc, rootClaude, { force, verbose });
-      safeCopyClaude(claudeSrc, rootCursor, { force, verbose });
-      safeCopyClaude(claudeSrc, rootWindsurf, { force, verbose });
-      console.log('  ✅  CLAUDE.md (Mirrored to project root & .cursorrules)');
+      // If the runtime entry file is different (e.g. .cursorrules, copilot-instructions.md), copy that too
+      if (cfg.entryFile !== 'CLAUDE.md') {
+        safeCopyClaude(tempEntry, rootEntry, { force, verbose });
+        console.log(`  ✅  ${cfg.entryFile} (Mirrored to project root)`);
+      } else {
+        console.log('  ✅  CLAUDE.md (Mirrored to project root)');
+      }
     } else {
-      console.log('  ✅  CLAUDE.md');
+      console.log(`  ✅  ${cfg.entryFile}`);
     }
   }
 
@@ -354,13 +440,13 @@ async function uninstall(runtime, scope, options = {}) {
   const cfg     = RUNTIMES[runtime];
   const baseDir = resolveBaseDir(runtime, scope);
   const cmdsDir = norm(path.join(baseDir, cfg.commandsSubdir));
-  const claudeMd = norm(path.join(baseDir, 'CLAUDE.md'));
+  const entryFile = norm(path.join(baseDir, cfg.entryFile));
 
   console.log(`\n  Uninstalling MindForge (${runtime} / ${scope})...`);
   if (dryRun) {
     console.log(`  Would remove: ${cmdsDir}`);
-    if (fsu.exists(claudeMd) && fsu.read(claudeMd).includes('MindForge'))
-      console.log(`  Would remove: ${claudeMd}`);
+    if (fsu.exists(entryFile) && fsu.read(entryFile).includes('MindForge'))
+      console.log(`  Would remove: ${entryFile}`);
     return;
   }
 
@@ -370,10 +456,10 @@ async function uninstall(runtime, scope, options = {}) {
     console.log(`  ✅  Removed: ${cmdsDir}`);
   }
 
-  // Remove CLAUDE.md only if it's a MindForge-generated file
-  if (fsu.exists(claudeMd) && fsu.read(claudeMd).includes('MindForge')) {
-    fs.unlinkSync(claudeMd);
-    console.log(`  ✅  Removed: ${claudeMd}`);
+  // Remove entry file only if it's a MindForge-generated file
+  if (fsu.exists(entryFile) && fsu.read(entryFile).includes('MindForge')) {
+    fs.unlinkSync(entryFile);
+    console.log(`  ✅  Removed: ${entryFile}`);
   }
 
   // Preserve .planning/ and .mindforge/ — user data, not our files to delete
@@ -383,9 +469,27 @@ async function uninstall(runtime, scope, options = {}) {
 
 // ── Main run ──────────────────────────────────────────────────────────────────
 async function run(args) {
-  const runtime    = args.includes('--antigravity') ? 'antigravity'
-                   : args.includes('--all')         ? 'all'
-                   : 'claude';
+  // Parse runtime from flags
+  let runtime = args.includes('--all') ? 'all' : null;
+  
+  if (!runtime) {
+    // Check for explicit --runtime flag
+    const rtIdx = args.indexOf('--runtime');
+    if (rtIdx !== -1 && args[rtIdx + 1]) {
+      runtime = args[rtIdx + 1].toLowerCase();
+    } else {
+      // Check for boolean flags (e.g. --cursor, --gemini)
+      for (const key of Object.keys(RUNTIMES)) {
+        if (args.includes(`--${key}`)) {
+          runtime = key;
+          break;
+        }
+      }
+    }
+  }
+  
+  // Default to claude if no runtime specified
+  if (!runtime) runtime = 'claude';
   const scope      = args.includes('--global') || args.includes('-g') ? 'global' : 'local';
   const dryRun     = args.includes('--dry-run');
   const force      = args.includes('--force');
@@ -426,4 +530,4 @@ async function run(args) {
   }
 }
 
-module.exports = { run, install, uninstall };
+module.exports = { run, install, uninstall, RUNTIMES, generateEntryContent };