vectorforce 0.3.3 → 0.3.4

package/CHANGELOG.md

@@ -7,6 +7,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [Unreleased]
+
+### Fixed
+- Cross-platform MCP availability: generated harness configs now use the absolute Node.js runtime (`process.execPath`) with `"type": "stdio"` instead of bare `node`, so GUI-launched clients on Windows, macOS, and Linux can spawn `vf mcp` even when `node` is not on their PATH.
+- MCP protocol compatibility: the stdio server negotiates `protocolVersion` (`2025-11-25`, `2025-06-18`, `2025-03-26`, `2024-11-05`), reports the package version, answers `resources/list`, `resources/templates/list`, `prompts/list`, and JSON-RPC batches, and keeps `stdout` reserved for JSON-RPC in `vf mcp` mode.
+- VS Code / Copilot: `.vscode/mcp.json` is now written under the top-level `servers` key (the only shape VS Code reads); legacy `mcpServers.vectorforce` entries are migrated on install and removed on uninstall.
+- Kiro IDE: workspace config is now written to `.kiro/settings/mcp.json` (the path Kiro reads) with steering in `.kiro/steering/vectorforce.md`; the legacy `.kiro/mcp.json` entry is migrated.
+- Meta Muse: `installMuseCode` now always ensures the global `~/.config/muse/settings.json` entry under the `mcpServers` key (the block Muse Code actually reads; a stale `mcp_servers.vectorforce` entry is migrated) with no workspace pin so one entry serves every project, and no longer deletes unrelated user keys.
+- Antigravity: global config prefers `~/.gemini/config/mcp_config.json` with fallback to `~/.gemini/antigravity/mcp_config.json`.
+- Codex TOML now embeds quoted absolute paths for both the Node runtime and `bin/vf.js`.
+
+### Changed
+- `vf init` no longer creates every harness config at once: it auto-detects harnesses already in use (marker files/dirs), installs only those, and otherwise creates none while printing the exact follow-up commands. Override with `vf init --harness <id[,...]|all|none>` or `vf init --all`.
+- Added `vf config list` showing supported harnesses with detected/configured status; `vf config install`/`uninstall` reject unknown harness names with that hint.
+- `vf doctor`, `vf status`, and `vf config doctor` now verify the VectorForce entry exists instead of only the file.
+
 ## [0.3.2] - 2026-11-01
 
 ### Added

package/README.md

@@ -27,6 +27,85 @@ VectorForce provides an immutable, cryptographic context layer that tracks:
 
 ---
 
+## Architecture & System Topology
+
+VectorForce is engineered with a strict **Local-First & Zero Runtime Dependency** design. It operates entirely through Node.js built-ins (`node:sqlite`, `node:crypto`, `node:http`, `node:fs`) and integrates seamlessly across local IDEs, multi-agent MCP bridges, and zero-knowledge cloud sync.
+
+```mermaid
+flowchart TD
+    subgraph AI_Harnesses["AI Coding Agent Ecosystem (MCP Protocol)"]
+        A1["⚡ Google Antigravity"]
+        A2["🦙 Meta Muse"]
+        A3["⌘ Claude / Command Code"]
+        A4["◈ OpenAI Codex"]
+        A5["🖱️ Cursor IDE"]
+        A6["🌊 Windsurf Cascade"]
+        A7["🐙 GitHub Copilot"]
+        A8["⚡ Kiro IDE"]
+    end
+
+    subgraph VectorForce_Core["VectorForce Core Engine (Zero Runtime Dependencies)"]
+        direction TB
+        MCP["MCP Server & JSON-RPC Bridge\n(src/mcp/mcp-server.js • stdio)"]
+        CLI["CLI Control Interface\n(bin/vf.js • init, status, drift, resume)"]
+        
+        AUTH["Zero-Leak Policy Authorizer\n(src/policy/authorizer.js • Symlink & Containment Guard)"]
+        
+        subgraph Operations["Operations & Synthesis Services"]
+            CHK["Checkpoint Service\n(Claims vs Evidence Fencing)"]
+            BRF["Briefing & Drift Service\n(Git HEAD & SHA-256 Hash Matching)"]
+            RSN["AI Reasoning Service\n(Meta Muse • Fireworks • Llama 3.3)"]
+            HDF["Handoff Service\n(HMAC-SHA256 Manifest Export/Import)"]
+        end
+
+        subgraph Providers["Zero-Dep Workspace Observers"]
+            GIT["Git Provider\n(Branch, Commit SHA, Diff, Dirty Tree)"]
+            DOC["Document Provider\n(Allowlisted Spec Reader & SHA-256 Hashes)"]
+            AST["Code Index Provider\n(AST Symbols & Import Dependency Graph)"]
+        end
+
+        DB[("Local SQLite WAL Store\n(.vectorforce/vectorforce.db\nnode:sqlite WAL mode)")]
+    end
+
+    subgraph Studio_UI["Local VectorForce Studio (Web UI)"]
+        WEB["Studio HTTP Server (127.0.0.1:3210)\nReact + Vite + Tailwind + XYFlow"]
+    end
+
+    subgraph Cloud_Layer["VectorForce Cloud (Modal.com / E2EE Sync)"]
+        REMOTE["Zero-Knowledge Wire & Hub\nX25519 ECDH + AES-256-GCM + Ed25519 Signature\n(Multi-Project Hub • PM Interpreter Portal)"]
+    end
+
+    %% Wiring
+    A1 & A2 & A3 & A4 & A5 & A6 & A7 & A8 <-->|"stdio JSON-RPC 2.0"| MCP
+    CLI --> AUTH
+    MCP --> AUTH
+    AUTH --> Operations
+    Operations <--> Providers
+    Operations <--> DB
+    DB <--> WEB
+    Operations <-->|"vf push / vf pull\n(Encrypted Ciphertext)"| REMOTE
+```
+
+---
+
+## Tech Stack Overview
+
+VectorForce adheres to strict architectural purity, ensuring rock-solid stability, privacy, and speed without bloated dependency chains.
+
+| Layer | Technology | Rationale / Key Capabilities |
+| :--- | :--- | :--- |
+| **Runtime & Core** | **Node.js (>= 22.5.0 ESM)** | Pure ES Modules, fast startup, native cross-platform support (macOS, Linux, Windows). |
+| **Backend Dependencies** | **Zero External Runtime Dependencies** | Powered 100% by Node.js built-ins: `node:sqlite`, `node:crypto`, `node:http`, `node:fs`, `node:child_process`, `node:os`. |
+| **Storage Engine** | **`node:sqlite` (WAL Mode)** | Local-first, zero-configuration database (`.vectorforce/vectorforce.db`) with Write-Ahead Logging for atomic concurrent reads/writes. |
+| **Cryptographic Security** | **`node:crypto` (HMAC-SHA256, AES-256-GCM, X25519, Ed25519)** | Tamper-evident handoffs, verifiable file digests, and end-to-end zero-knowledge multi-machine sync. |
+| **Protocol Integration** | **Model Context Protocol (MCP)** | JSON-RPC 2.0 over standard I/O (`stdio`), 9 deterministic tools, and auto-configuration for 8+ AI harnesses. |
+| **AI Reasoning Layer** | **Meta Muse & Llama 3.3** | Native adapters for **Meta Muse (`muse-spark-1.3`)**, **Meta Muse Spark Open** (Fireworks AI / OpenRouter), Local **Ollama**, **OpenAI**, and **Anthropic** with graceful offline briefing fallback. |
+| **AST & Code Indexer** | **Custom Zero-Dependency Regex/Tokenizer Indexer** | Extracts symbols (classes, functions, interfaces), imports, and module dependency graphs without heavy external parser bloat. |
+| **Local Studio Frontend** | **React 18 + Vite + Tailwind CSS + XYFlow** | Interactive architecture control center, live blast radius inspector, Claims vs Evidence timeline, and memory console. |
+| **Cloud Remote Sync** | **Modal.com Serverless Container (Debian + Node 22)** | Zero-Knowledge E2EE relay hub, scale-to-zero serverless deployment, PM Interpreter, and Multi-Project switcher. |
+
+---
+
 ## VectorForce Studio (Web UI)
 
 VectorForce includes a local-first engineering control center:
@@ -47,9 +126,12 @@ node bin/vf.js studio
 
 ## Quickstart
 
-### 1. Initialize a Project
+### 1. Initialize a Project (auto-detects your AI harness)
 ```bash
 node bin/vf.js init
+# Only detected harnesses are configured; repos with no harness get no MCP files yet.
+node bin/vf.js config list                  # supported harnesses + detected/configured status
+node bin/vf.js config install cursor       # or: --harness on init, or install all
 ```
 
 ### 2. Create and Select a Task
@@ -139,19 +221,19 @@ node bin/vf.js studio
 
 VectorForce exposes a standard stdio JSON-RPC MCP server for direct integration into **Google Antigravity**, **Claude Code**, **Command Code**, **Meta Muse**, **OpenAI Codex**, **Cursor**, **Windsurf**, **GitHub Copilot**, and **Kiro IDE**.
 
-> **How MCP Starts:** You **never** need to run `vf mcp` manually in a terminal. Each AI coding agent reads its configuration file below and automatically spawns VectorForce in the background over `stdio`.
+> **How MCP Starts:** You **never** need to run `vf mcp` manually in a terminal. Each AI coding agent reads its configuration file below and automatically spawns VectorForce in the background over `stdio`. Generated entries use the absolute Node.js runtime path, so GUI-launched clients find it even when `node` is not on their PATH (common on Windows).
 
 | AI Coding Client | Config File Read by Client | 1-Command Auto-Setup |
 |---|---|---|
-| **Google Antigravity** | `.agents/mcp_config.json` & `~/.gemini/antigravity/mcp_config.json` | `node bin/vf.js config install antigravity` |
+| **Google Antigravity** | `.agents/mcp_config.json` & `~/.gemini/config/mcp_config.json` (or `~/.gemini/antigravity/mcp_config.json`) | `node bin/vf.js config install antigravity` |
 | **Claude Code (`claude`)** | `.mcp.json` (project root) | `node bin/vf.js config install claude-code` |
 | **Command Code (`cmd`)** | `.mcp.json` & `commandcode.json` | `node bin/vf.js config install command-code` |
-| **Meta Muse (`muse`)** | `.muse/mcp_config.json` & `~/.config/muse/settings.json` | `node bin/vf.js config install muse` |
+| **Meta Muse (`muse`)** | `~/.config/muse/settings.json` (global `mcpServers`; `.muse/mcp_config.json` kept as mirror) | `node bin/vf.js config install muse` |
 | **OpenAI Codex (`codex`)** | `.codex/config.toml` & `~/.codex/config.toml` | `node bin/vf.js config install codex` |
 | **Cursor IDE** | `.cursor/mcp.json` & `.cursorrules` | `node bin/vf.js config install cursor` |
 | **Windsurf (Codeium)** | `.windsurf/mcp_config.json` & `.windsurfrules` | `node bin/vf.js config install windsurf` |
-| **GitHub Copilot / VS Code** | `.vscode/mcp.json` & `.github/copilot-instructions.md` | `node bin/vf.js config install copilot` |
-| **Kiro IDE** | `.kiro/mcp.json` & `kiro.json` | `node bin/vf.js config install kiro` |
+| **GitHub Copilot / VS Code** | `.vscode/mcp.json` (top-level `servers`) & `.github/copilot-instructions.md` | `node bin/vf.js config install copilot` |
+| **Kiro IDE** | `.kiro/settings/mcp.json` & `kiro.json` | `node bin/vf.js config install kiro` |
 
 ### Automated Configuration & Health Check
 ```bash
@@ -167,7 +249,7 @@ node bin/vf.js status
 {
   "mcpServers": {
     "vectorforce": {
-      "command": "node",
+      "command": "/absolute/path/to/node",
       "args": ["/absolute/path/to/VectorForce/bin/vf.js", "mcp"]
     }
   }
@@ -177,7 +259,7 @@ node bin/vf.js status
 ### TOML Configuration (OpenAI Codex CLI: `.codex/config.toml`)
 ```toml
 [mcp_servers.vectorforce]
-command = "node"
+command = "/absolute/path/to/node"
 args = ["/absolute/path/to/VectorForce/bin/vf.js", "mcp"]
 [mcp_servers.vectorforce.env]
 VF_HARNESS = "codex"

package/bin/vf.js

@@ -146,7 +146,7 @@ function printUsage() {
 VectorForce (vf) - Git for AI Engineering Context
 
 Usage:
-  vf init [project_name]                     Initialize current workspace
+  vf init [project_name] [--harness <id|all|none>]  Init workspace (auto-detects harnesses)
   vf task <id> [title]                       Create or register a task
   vf tasks [active|completed|all]            List tasks in workspace
   vf policy list                             List allowed document paths
@@ -162,7 +162,7 @@ Usage:
   vf studio [options]                        Launch VectorForce Studio web control center
   vf ui [options]                            Alias for vf studio
   vf mcp                                     Start stdio MCP server for Antigravity / Command Code
-  vf config                                  Display MCP configuration snippet for harnesses
+  vf config list|install|doctor               List, install, or check harness MCP integrations
   vf help                                    Show this help
 
 Checkpoint options:
@@ -235,7 +235,15 @@ function parseFlags(args) {
         rationale: parts.slice(2).join(':') || 'Approved architecture decision'
       });
     } else if (arg === '--harness' && args[i + 1]) {
-      flags.harness = args[++i];
+      const harnessValue = args[++i];
+      flags.harness = harnessValue;
+      flags.harnessList = (flags.harnessList || []).concat(
+        harnessValue.split(',').map((value) => value.trim()).filter(Boolean)
+      );
+    } else if (arg === '--all') {
+      flags.all = true;
+    } else if (arg === '--none') {
+      flags.none = true;
     } else if (arg === '--author' && args[i + 1]) {
       flags.author = args[++i];
     } else if (arg === '--next' && args[i + 1]) {
@@ -330,14 +338,34 @@ async function main() {
       case 'init': {
         const name = args[1] && !args[1].startsWith('--') ? args[1] : null;
         const project = projectService.initProject(cwd, name);
-        HarnessConfig.installAntigravity(cwd);
-        HarnessConfig.installCommandCode(cwd);
-        HarnessConfig.installMuseCode(cwd);
-        HarnessConfig.installCodex(cwd);
-        HarnessConfig.installCursor(cwd);
-        HarnessConfig.installWindsurf(cwd);
-        HarnessConfig.installCopilot(cwd);
-        HarnessConfig.installKiro(cwd);
+        const harnessRequest = flags.harnessList && flags.harnessList.length > 0 ? flags.harnessList : null;
+        let harnessTargets = [];
+        if (flags.all || (harnessRequest && harnessRequest.some((h) => h.toLowerCase() === 'all'))) {
+          harnessTargets = HarnessConfig.getSupportedHarnesses().map((h) => h.id);
+        } else if (flags.none || (harnessRequest && harnessRequest.some((h) => h.toLowerCase() === 'none'))) {
+          harnessTargets = [];
+        } else if (harnessRequest) {
+          const unknown = [];
+          for (const requested of harnessRequest) {
+            const resolved = HarnessConfig.resolveHarnessId(requested);
+            if (resolved && !harnessTargets.includes(resolved)) harnessTargets.push(resolved);
+            else if (!resolved) unknown.push(requested);
+          }
+          if (unknown.length > 0) {
+            console.error(`Unknown harness: ${unknown.join(', ')}. Run "vf config list" for supported values.`);
+            process.exit(1);
+          }
+        } else {
+          harnessTargets = HarnessConfig.detectHarnesses(cwd).map((h) => h.id);
+        }
+        const installedHarnesses = [];
+        for (const id of harnessTargets) {
+          try {
+            installedHarnesses.push({ id, path: HarnessConfig.installHarness(cwd, id) });
+          } catch (err) {
+            console.warn(`Warning: failed to configure ${id}: ${err.message}`);
+          }
+        }
         const agentsMdPath = join(cwd, 'AGENTS.md');
         if (!existsSync(agentsMdPath)) {
           writeFileSync(
@@ -347,6 +375,13 @@ async function main() {
           );
         }
         console.log(`Initialized VectorForce project: ${project.name} (${project.project_id})`);
+        if (installedHarnesses.length > 0) {
+          console.log(`Configured harness integration(s): ${installedHarnesses.map((h) => h.id).join(', ')}`);
+          console.log('For other harnesses, run "vf config list" or "vf config install <harness|all>".');
+        } else {
+          console.log('No harness detected, so no MCP configs were created.');
+          console.log('Run "vf config list" to see supported harnesses, then "vf config install <harness>".');
+        }
         break;
       }
 
@@ -551,6 +586,8 @@ async function main() {
       }
 
       case 'mcp': {
+        console.log = (...args) => console.error(...args);
+        console.info = (...args) => console.error(...args);
         const server = new McpServer({ store, projectService, checkpointService, briefingService, handoffService, reasoningService }, cwd);
         server.connect(process.stdin, process.stdout);
         process.on('SIGINT', () => {
@@ -568,57 +605,63 @@ async function main() {
       case 'config': {
         const sub = args[1];
         if (sub === 'install' || sub === 'setup') {
-          const target = (args[2] || 'all').toLowerCase();
-          const installed = [];
-          if (target === 'antigravity' || target === 'all') {
-            const p = HarnessConfig.installAntigravity(cwd);
-            installed.push(`Google Antigravity -> ${p} (+ ~/.gemini/antigravity/mcp_config.json)`);
-          }
-          if (target === 'command-code' || target === 'cmd' || target === 'claude' || target === 'claude-code' || target === 'all') {
-            const p = HarnessConfig.installCommandCode(cwd);
-            installed.push(`Command Code / Claude Code -> .mcp.json & ${p}`);
-          }
-          if (target === 'muse' || target === 'muse-code' || target === 'all') {
-            const p = HarnessConfig.installMuseCode(cwd);
-            installed.push(`Meta Muse -> ${p} (+ ~/.config/muse/settings.json)`);
-          }
-          if (target === 'codex' || target === 'all') {
-            const p = HarnessConfig.installCodex(cwd);
-            installed.push(`Codex -> ${p} (+ ~/.codex/config.toml)`);
-          }
-          if (target === 'cursor' || target === 'all') {
-            const p = HarnessConfig.installCursor(cwd);
-            installed.push(`Cursor -> ${p} (+ .cursorrules)`);
-          }
-          if (target === 'windsurf' || target === 'all') {
-            const p = HarnessConfig.installWindsurf(cwd);
-            installed.push(`Windsurf -> ${p} (+ .windsurfrules)`);
+          const raw = (args[2] || 'all').toLowerCase();
+          const installNotes = {
+            antigravity: (p) => `Google Antigravity -> ${p} (+ global ~/.gemini MCP config when present)`,
+            'command-code': (p) => `Command Code / Claude Code -> .mcp.json & ${p}`,
+            muse: (p) => `Meta Muse -> ${p} (+ ~/.config/muse/settings.json)`,
+            codex: (p) => `Codex -> ${p} (+ ~/.codex/config.toml)`,
+            cursor: (p) => `Cursor -> ${p} (+ .cursorrules)`,
+            windsurf: (p) => `Windsurf -> ${p} (+ .windsurfrules)`,
+            copilot: (p) => `GitHub Copilot / VS Code -> ${p} (+ .github/copilot-instructions.md)`,
+            kiro: (p) => `Kiro IDE -> ${p} (+ kiro.json)`
+          };
+          let targets = [];
+          if (raw === 'all') {
+            targets = HarnessConfig.getSupportedHarnesses().map((h) => h.id);
+          } else {
+            const resolved = HarnessConfig.resolveHarnessId(raw);
+            if (!resolved) {
+              console.error(`Unknown harness "${args[2]}". Run "vf config list" for supported values.`);
+              process.exit(1);
+            }
+            targets = [resolved];
           }
-          if (target === 'copilot' || target === 'github-copilot' || target === 'vscode' || target === 'all') {
-            const p = HarnessConfig.installCopilot(cwd);
-            installed.push(`GitHub Copilot / VS Code -> ${p} (+ .github/copilot-instructions.md)`);
-          }
-          if (target === 'kiro' || target === 'kiro-ide' || target === 'all') {
-            const p = HarnessConfig.installKiro(cwd);
-            installed.push(`Kiro IDE -> ${p} (+ kiro.json)`);
+          const installed = [];
+          for (const id of targets) {
+            installed.push(installNotes[id](HarnessConfig.installHarness(cwd, id)));
           }
           console.log(`\n✔ Configured harness integration(s):\n  - ${installed.join('\n  - ')}`);
           console.log(`\n💡 Next step: Restart or reload your AI agent, then ask in chat:\n   "List active VectorForce tasks and check workspace drift"`);
           break;
         }
 
+        if (sub === 'list' || sub === 'harnesses') {
+          const detected = new Set(HarnessConfig.detectHarnesses(cwd).map((h) => h.id));
+          console.log(`\nSupported AI harnesses (${cwd}):\n`);
+          for (const harness of HarnessConfig.getSupportedHarnesses()) {
+            const aliases = harness.aliases ? ` (aliases: ${harness.aliases.join(', ')})` : '';
+            const detectedMark = detected.has(harness.id) ? 'detected' : 'not detected';
+            const configuredMark = HarnessConfig.isHarnessConfigured(cwd, harness.id) ? 'configured' : 'not configured';
+            console.log(`  ${harness.id}${aliases}: ${harness.label} [${detectedMark}] [${configuredMark}]`);
+          }
+          console.log('\nSetup one harness: vf config install <harness>   (e.g. vf config install cursor)');
+          console.log('Setup all harnesses: vf config install all\n');
+          break;
+        }
+
         if (sub === 'doctor' || sub === 'check') {
           const checks = [
             { name: 'SQLite Database (.vectorforce/vectorforce.db)', ok: existsSync(getDbPath(cwd)), path: getDbPath(cwd) },
             { name: 'Agent Protocol Rules (AGENTS.md)', ok: existsSync(join(cwd, 'AGENTS.md')), path: join(cwd, 'AGENTS.md') },
-            { name: 'Google Antigravity (.agents/mcp_config.json)', ok: existsSync(join(cwd, '.agents', 'mcp_config.json')), path: join(cwd, '.agents', 'mcp_config.json') },
-            { name: 'Claude Code & Command Code (.mcp.json)', ok: existsSync(join(cwd, '.mcp.json')), path: join(cwd, '.mcp.json') },
-            { name: 'Meta Muse (.muse/mcp_config.json)', ok: existsSync(join(cwd, '.muse', 'mcp_config.json')), path: join(cwd, '.muse', 'mcp_config.json') },
-            { name: 'OpenAI Codex (.codex/config.toml)', ok: existsSync(join(cwd, '.codex', 'config.toml')), path: join(cwd, '.codex', 'config.toml') },
-            { name: 'Cursor (.cursor/mcp.json)', ok: existsSync(join(cwd, '.cursor', 'mcp.json')), path: join(cwd, '.cursor', 'mcp.json') },
-            { name: 'Windsurf (.windsurf/mcp_config.json)', ok: existsSync(join(cwd, '.windsurf', 'mcp_config.json')), path: join(cwd, '.windsurf', 'mcp_config.json') },
-            { name: 'GitHub Copilot / VS Code (.vscode/mcp.json)', ok: existsSync(join(cwd, '.vscode', 'mcp.json')), path: join(cwd, '.vscode', 'mcp.json') },
-            { name: 'Kiro IDE (.kiro/mcp.json)', ok: existsSync(join(cwd, '.kiro', 'mcp.json')), path: join(cwd, '.kiro', 'mcp.json') }
+            { name: 'Google Antigravity (.agents/mcp_config.json)', ok: HarnessConfig.isHarnessConfigured(cwd, 'antigravity'), path: join(cwd, '.agents', 'mcp_config.json') },
+            { name: 'Claude Code & Command Code (.mcp.json)', ok: HarnessConfig.isHarnessConfigured(cwd, 'command-code'), path: join(cwd, '.mcp.json') },
+            { name: 'Meta Muse (.muse/mcp_config.json)', ok: HarnessConfig.isHarnessConfigured(cwd, 'muse'), path: join(cwd, '.muse', 'mcp_config.json') },
+            { name: 'OpenAI Codex (.codex/config.toml)', ok: HarnessConfig.isHarnessConfigured(cwd, 'codex'), path: join(cwd, '.codex', 'config.toml') },
+            { name: 'Cursor (.cursor/mcp.json)', ok: HarnessConfig.isHarnessConfigured(cwd, 'cursor'), path: join(cwd, '.cursor', 'mcp.json') },
+            { name: 'Windsurf (.windsurf/mcp_config.json)', ok: HarnessConfig.isHarnessConfigured(cwd, 'windsurf'), path: join(cwd, '.windsurf', 'mcp_config.json') },
+            { name: 'GitHub Copilot / VS Code (.vscode/mcp.json)', ok: HarnessConfig.isHarnessConfigured(cwd, 'copilot'), path: join(cwd, '.vscode', 'mcp.json') },
+            { name: 'Kiro IDE (.kiro/settings/mcp.json)', ok: HarnessConfig.isHarnessConfigured(cwd, 'kiro'), path: join(cwd, '.kiro', 'settings', 'mcp.json') }
           ];
           console.log(`\nVectorForce Workspace & MCP Health Check (${cwd}):\n`);
           for (const c of checks) {
@@ -631,31 +674,22 @@ async function main() {
         }
 
         if (sub === 'uninstall' || sub === 'remove') {
-          const target = (args[2] || 'all').toLowerCase();
-          const uninstalled = [];
-          if (target === 'antigravity' || target === 'all') {
-            if (HarnessConfig.uninstallAntigravity(cwd)) uninstalled.push('Antigravity');
-          }
-          if (target === 'command-code' || target === 'cmd' || target === 'all') {
-            if (HarnessConfig.uninstallCommandCode(cwd)) uninstalled.push('Command Code');
+          const raw = (args[2] || 'all').toLowerCase();
+          const displayNames = { antigravity: 'Antigravity', 'command-code': 'Command Code', muse: 'Muse Code', codex: 'Codex', cursor: 'Cursor', windsurf: 'Windsurf', copilot: 'GitHub Copilot / VS Code', kiro: 'Kiro IDE' };
+          let targets = [];
+          if (raw === 'all') {
+            targets = HarnessConfig.getSupportedHarnesses().map((h) => h.id);
+          } else {
+            const resolved = HarnessConfig.resolveHarnessId(raw);
+            if (!resolved) {
+              console.error(`Unknown harness "${args[2]}". Run "vf config list" for supported values.`);
+              process.exit(1);
+            }
+            targets = [resolved];
           }
-          if (target === 'muse' || target === 'muse-code' || target === 'all') {
-            if (HarnessConfig.uninstallMuseCode(cwd)) uninstalled.push('Muse Code');
-          }
-          if (target === 'codex' || target === 'all') {
-            if (HarnessConfig.uninstallCodex(cwd)) uninstalled.push('Codex');
-          }
-          if (target === 'cursor' || target === 'all') {
-            if (HarnessConfig.uninstallCursor(cwd)) uninstalled.push('Cursor');
-          }
-          if (target === 'windsurf' || target === 'all') {
-            if (HarnessConfig.uninstallWindsurf(cwd)) uninstalled.push('Windsurf');
-          }
-          if (target === 'copilot' || target === 'github-copilot' || target === 'vscode' || target === 'all') {
-            if (HarnessConfig.uninstallCopilot(cwd)) uninstalled.push('GitHub Copilot / VS Code');
-          }
-          if (target === 'kiro' || target === 'kiro-ide' || target === 'all') {
-            if (HarnessConfig.uninstallKiro(cwd)) uninstalled.push('Kiro IDE');
+          const uninstalled = [];
+          for (const id of targets) {
+            if (HarnessConfig.uninstallHarness(cwd, id)) uninstalled.push(displayNames[id]);
           }
           console.log(`\n✔ Removed harness integration(s): ${uninstalled.length ? uninstalled.join(', ') : 'none found'}`);
           break;
@@ -879,7 +913,7 @@ VectorForce Harness Configuration:
    {
      "mcpServers": {
        "vectorforce": {
-         "command": "node",
+         "command": "${process.execPath}",
          "args": ["${binPath}", "mcp"]
        }
      }
@@ -891,7 +925,7 @@ VectorForce Harness Configuration:
    {
      "mcpServers": {
        "vectorforce": {
-         "command": "node",
+         "command": "${process.execPath}",
          "args": ["${binPath}", "mcp"],
          "env": { "VF_HARNESS": "muse-code" }
        }
@@ -906,7 +940,7 @@ VectorForce Harness Configuration:
    File: .codex/config.toml (or codex.json)
    Content:
    [mcp_servers.vectorforce]
-   command = "node"
+   command = "${process.execPath}"
    args = ["${binPath}", "mcp"]
    [mcp_servers.vectorforce.env]
    VF_HARNESS = "codex"
@@ -943,6 +977,9 @@ VectorForce Harness Configuration:
      VF_OPENROUTER_MODEL=deepseek/deepseek-v4.1-flash-1017  # default
 
    Privacy: set VF_LLM_ALLOW_CODE=false (or run with --no-code) to keep source out of the prompt.
+
+   Harnesses: run "vf config list" to see detected/configured harnesses,
+   then "vf config install <harness|all>" to configure one or all of them.
 `);
         break;
       }
@@ -983,9 +1020,15 @@ VectorForce Harness Configuration:
         const remoteProjectId = flags.project || remote.remoteProjectId || 'default';
         const project = projectService.getProjectForWorkspace(cwd);
         const tasks = store.listTasks(project.project_id);
-        const machineId = `${hostname()}-local`;
+        const rawHost = hostname();
+        const machineId = flags.machine || (
+          rawHost.toLowerCase().includes('lenovo') ? `Lenovo Laptop (${rawHost})` :
+          rawHost.toLowerCase().includes('macbook') || process.platform === 'darwin' ? `MacBook Pro (${rawHost})` :
+          `${rawHost} (${process.platform})`
+        );
+        const devIdentity = flags.dev || `${process.env.USER || 'developer'}`;
 
-        console.log(`🔄 Pushing local context (${project.name}) -> ${targetUrl} ...`);
+        console.log(`🔄 Pushing local context (${project.name}) -> ${targetUrl} [Machine: ${machineId}] ...`);
 
         for (const t of tasks) {
           if (flags.task && t.task_id !== flags.task) continue;
@@ -999,8 +1042,8 @@ VectorForce Harness Configuration:
               projectId: remoteProjectId,
               taskId: t.task_id,
               title: t.title || t.task_id,
-              assignee: `${process.env.USER || 'developer'}@local-mac`,
-              role: `Local Workspace (${basename(cwd)})`,
+              assignee: devIdentity,
+              role: `Workspace (${basename(cwd)})`,
               priority: 'P0',
               machineId,
               harness: flags.harness || 'antigravity'
@@ -1025,13 +1068,17 @@ VectorForce Harness Configuration:
               taskId: cp.task_id,
               senderMachineId: machineId,
               recipientMachineId: 'computer-2-meta-muse-cloud',
-              authorName: `${cp.author?.name || process.env.USER || 'developer'} (${basename(cwd)})`,
-              authorHarness: cp.author?.harness || 'antigravity',
+              authorName: `${cp.author?.name || devIdentity} (${basename(cwd)})`,
+              authorHarness: cp.author?.harness || flags.harness || 'antigravity',
               summary: cp.summary,
               goals: cp.claims?.goals || [],
               constraints: cp.claims?.constraints || [],
               decisions: cp.claims?.decisions || [],
-              nextSteps: cp.claims?.next_steps || []
+              nextSteps: cp.claims?.next_steps || [],
+              gitCommit: cp.evidence?.git?.commit || null,
+              gitBranch: cp.evidence?.git?.branch || 'main',
+              gitDirty: cp.evidence?.git?.dirty !== undefined ? Boolean(cp.evidence.git.dirty) : false,
+              documents: (cp.evidence?.documents || []).map((d) => d.path)
             })
           });
           lastResp = await res.json();
@@ -1134,14 +1181,14 @@ VectorForce Harness Configuration:
         const checks = [
           { name: 'SQLite Database (.vectorforce/vectorforce.db)', ok: existsSync(getDbPath(cwd)) },
           { name: 'Agent Protocol Rules (AGENTS.md)', ok: existsSync(join(cwd, 'AGENTS.md')) },
-          { name: 'Google Antigravity (.agents/mcp_config.json)', ok: existsSync(join(cwd, '.agents', 'mcp_config.json')) },
-          { name: 'Claude Code & Command Code (.mcp.json)', ok: existsSync(join(cwd, '.mcp.json')) },
-          { name: 'Meta Muse (.muse/mcp_config.json or musecode.json)', ok: existsSync(join(cwd, '.muse', 'mcp_config.json')) || existsSync(join(cwd, 'musecode.json')) },
-          { name: 'OpenAI Codex (.codex/config.toml)', ok: existsSync(join(cwd, '.codex', 'config.toml')) },
-          { name: 'Cursor (.cursor/mcp.json)', ok: existsSync(join(cwd, '.cursor', 'mcp.json')) },
-          { name: 'Windsurf (.windsurf/mcp_config.json)', ok: existsSync(join(cwd, '.windsurf', 'mcp_config.json')) },
-          { name: 'GitHub Copilot / VS Code (.vscode/mcp.json)', ok: existsSync(join(cwd, '.vscode', 'mcp.json')) },
-          { name: 'Kiro IDE (.kiro/mcp.json)', ok: existsSync(join(cwd, '.kiro', 'mcp.json')) }
+          { name: 'Google Antigravity (.agents/mcp_config.json)', ok: HarnessConfig.isHarnessConfigured(cwd, 'antigravity') },
+          { name: 'Claude Code & Command Code (.mcp.json)', ok: HarnessConfig.isHarnessConfigured(cwd, 'command-code') },
+          { name: 'Meta Muse (.muse/mcp_config.json or musecode.json)', ok: HarnessConfig.isHarnessConfigured(cwd, 'muse') },
+          { name: 'OpenAI Codex (.codex/config.toml)', ok: HarnessConfig.isHarnessConfigured(cwd, 'codex') },
+          { name: 'Cursor (.cursor/mcp.json)', ok: HarnessConfig.isHarnessConfigured(cwd, 'cursor') },
+          { name: 'Windsurf (.windsurf/mcp_config.json)', ok: HarnessConfig.isHarnessConfigured(cwd, 'windsurf') },
+          { name: 'GitHub Copilot / VS Code (.vscode/mcp.json)', ok: HarnessConfig.isHarnessConfigured(cwd, 'copilot') },
+          { name: 'Kiro IDE (.kiro/settings/mcp.json)', ok: HarnessConfig.isHarnessConfigured(cwd, 'kiro') }
         ];
         console.log(`\nVectorForce Workspace & MCP Status (${cwd}):\n`);
         for (const c of checks) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vectorforce",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "description": "Portable engineering context platform - Git for AI context",
   "type": "module",
   "main": "src/index.js",

package/src/mcp/harness-config.js

@@ -1,4 +1,4 @@
-import { join, resolve } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 import { homedir, tmpdir } from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { readFileSync, writeFileSync, existsSync, mkdirSync, realpathSync } from 'node:fs';
@@ -19,7 +19,177 @@ export class HarnessConfig {
    * Get the absolute path to bin/vf.js (cross-platform: macOS, Linux, Windows)
    */
   static getBinPath() {
-    return fileURLToPath(new URL('../../bin/vf.js', import.meta.url));
+    const raw = fileURLToPath(new URL('../../bin/vf.js', import.meta.url));
+    return process.platform === 'win32' ? raw.replace(/\\/g, '/') : raw;
+  }
+
+  /**
+   * Absolute path of the Node.js runtime used to spawn `vf mcp`.
+   * GUI-spawned MCP clients (VS Code, Cursor, ...) on Windows often lack
+   * `node` on PATH, so generated configs must never rely on bare `node`.
+   */
+  static getNodeCommand() {
+    return process.execPath;
+  }
+
+  /**
+   * Escape a value for embedding in a TOML basic string.
+   */
+  static _tomlString(value) {
+    return '"' + String(value).split('\\').join('\\\\').split('"').join('\\"') + '"';
+  }
+
+  /**
+   * Canonical registry of supported harnesses.
+   * markers: workspace-relative files/dirs whose presence indicates the harness is in use.
+   */
+  static getSupportedHarnesses() {
+    return [
+      { id: 'antigravity', label: 'Google Antigravity', markers: ['.agents', '.gemini'], files: ['.agents/mcp_config.json'] },
+      { id: 'command-code', label: 'Claude Code / Command Code', aliases: ['claude-code', 'claude', 'cmd'], markers: ['.mcp.json', 'commandcode.json', '.claude', 'CLAUDE.md'], files: ['.mcp.json', 'commandcode.json'] },
+      { id: 'muse', label: 'Meta Muse', aliases: ['muse-code'], markers: ['.muse', 'musecode.json'], files: ['.muse/mcp_config.json', 'musecode.json'] },
+      { id: 'codex', label: 'OpenAI Codex', markers: ['.codex', 'codex.json'], files: ['.codex/config.toml', 'codex.json'] },
+      { id: 'cursor', label: 'Cursor', markers: ['.cursor', '.cursorrules'], files: ['.cursor/mcp.json'] },
+      { id: 'windsurf', label: 'Windsurf', markers: ['.windsurf', '.windsurfrules'], files: ['.windsurf/mcp_config.json'] },
+      { id: 'copilot', label: 'GitHub Copilot / VS Code', aliases: ['github-copilot', 'vscode'], markers: ['.vscode', '.github/copilot-instructions.md', '.github/muse-instructions.md'], files: ['.vscode/mcp.json'] },
+      { id: 'kiro', label: 'Kiro IDE', aliases: ['kiro-ide'], markers: ['.kiro', 'kiro.json'], files: ['.kiro/settings/mcp.json'] }
+    ];
+  }
+
+  /**
+   * Resolve a user-supplied harness name or alias to its canonical id.
+   * @returns {string|null}
+   */
+  static resolveHarnessId(input) {
+    const normalized = String(input || '').trim().toLowerCase();
+    if (!normalized) return null;
+    for (const harness of HarnessConfig.getSupportedHarnesses()) {
+      if (harness.id === normalized || (harness.aliases || []).includes(normalized)) {
+        return harness.id;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Detect harnesses already in use by the workspace (marker files/dirs).
+   * @returns {{ id: string, label: string, matched: string[] }[]}
+   */
+  static detectHarnesses(workspacePath) {
+    const detected = [];
+    for (const harness of HarnessConfig.getSupportedHarnesses()) {
+      const matched = (harness.markers || []).filter((marker) => {
+        try {
+          return existsSync(join(workspacePath, marker));
+        } catch {
+          return false;
+        }
+      });
+      if (matched.length > 0) {
+        detected.push({ id: harness.id, label: harness.label, matched });
+      }
+    }
+    return detected;
+  }
+
+  /**
+   * Install (or merge) the VectorForce entry for one canonical harness id.
+   * @returns {string|null} primary config file path, or null for unknown ids
+   */
+  static installHarness(workspacePath, id) {
+    switch (id) {
+      case 'antigravity': return HarnessConfig.installAntigravity(workspacePath);
+      case 'command-code': return HarnessConfig.installCommandCode(workspacePath);
+      case 'muse': return HarnessConfig.installMuseCode(workspacePath);
+      case 'codex': return HarnessConfig.installCodex(workspacePath);
+      case 'cursor': return HarnessConfig.installCursor(workspacePath);
+      case 'windsurf': return HarnessConfig.installWindsurf(workspacePath);
+      case 'copilot': return HarnessConfig.installCopilot(workspacePath);
+      case 'kiro': return HarnessConfig.installKiro(workspacePath);
+      default: return null;
+    }
+  }
+
+  /**
+   * Remove the VectorForce entry for one canonical harness id.
+   */
+  static uninstallHarness(workspacePath, id) {
+    switch (id) {
+      case 'antigravity': return HarnessConfig.uninstallAntigravity(workspacePath);
+      case 'command-code': return HarnessConfig.uninstallCommandCode(workspacePath);
+      case 'muse': return HarnessConfig.uninstallMuseCode(workspacePath);
+      case 'codex': return HarnessConfig.uninstallCodex(workspacePath);
+      case 'cursor': return HarnessConfig.uninstallCursor(workspacePath);
+      case 'windsurf': return HarnessConfig.uninstallWindsurf(workspacePath);
+      case 'copilot': return HarnessConfig.uninstallCopilot(workspacePath);
+      case 'kiro': return HarnessConfig.uninstallKiro(workspacePath);
+      default: return false;
+    }
+  }
+
+  /**
+   * Whether the workspace currently carries a VectorForce entry the harness will read.
+   */
+  static isHarnessConfigured(workspacePath, id) {
+    const readJson = (relPath) => {
+      try {
+        const full = join(workspacePath, relPath);
+        if (!existsSync(full)) return null;
+        return JSON.parse(readFileSync(full, 'utf8'));
+      } catch {
+        return null;
+      }
+    };
+    const hasEntry = (config) => Boolean(config?.mcpServers?.vectorforce);
+    switch (id) {
+      case 'antigravity':
+        return hasEntry(readJson(join('.agents', 'mcp_config.json')));
+      case 'command-code':
+        return hasEntry(readJson('.mcp.json')) || hasEntry(readJson('commandcode.json'));
+      case 'muse':
+        return hasEntry(readJson(join('.muse', 'mcp_config.json')))
+          || hasEntry(readJson('musecode.json'))
+          || HarnessConfig._isMuseGlobalConfigured(workspacePath);
+      case 'codex': {
+        try {
+          const tomlPath = join(workspacePath, '.codex', 'config.toml');
+          if (existsSync(tomlPath) && readFileSync(tomlPath, 'utf8').includes('[mcp_servers.vectorforce]')) {
+            return true;
+          }
+        } catch {}
+        return hasEntry(readJson('codex.json'));
+      }
+      case 'cursor':
+        return hasEntry(readJson(join('.cursor', 'mcp.json')));
+      case 'windsurf':
+        return hasEntry(readJson(join('.windsurf', 'mcp_config.json')));
+      case 'copilot': {
+        const config = readJson(join('.vscode', 'mcp.json'));
+        return Boolean(config?.servers?.vectorforce || config?.mcpServers?.vectorforce);
+      }
+      case 'kiro':
+        return hasEntry(readJson(join('.kiro', 'settings', 'mcp.json')))
+          || hasEntry(readJson(join('.kiro', 'mcp.json')))
+          || hasEntry(readJson('kiro.json'));
+      default:
+        return false;
+    }
+  }
+
+  /**
+   * Whether the global Muse Code settings already register VectorForce.
+   * Temp workspaces never consult global state (tests stay hermetic).
+   */
+  static _isMuseGlobalConfigured(workspacePath) {
+    if (isTempWorkspace(workspacePath)) return false;
+    try {
+      const settingsPath = join(homedir(), '.config', 'muse', 'settings.json');
+      if (!existsSync(settingsPath)) return false;
+      const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+      return Boolean(settings?.mcpServers?.vectorforce);
+    } catch {
+      return false;
+    }
   }
 
   /**
@@ -27,7 +197,8 @@ export class HarnessConfig {
    */
   static getAntigravityServerEntry() {
     return {
-      command: 'node',
+      type: 'stdio',
+      command: HarnessConfig.getNodeCommand(),
       args: [HarnessConfig.getBinPath(), 'mcp']
     };
   }
@@ -81,9 +252,12 @@ export class HarnessConfig {
 
     if (!isTempWorkspace(workspacePath)) {
       try {
-        const globalAgyDir = join(homedir(), '.gemini', 'antigravity');
-        if (existsSync(globalAgyDir)) {
-          const globalMcpPath = join(globalAgyDir, 'mcp_config.json');
+        const globalCandidates = [
+          join(homedir(), '.gemini', 'config', 'mcp_config.json'),
+          join(homedir(), '.gemini', 'antigravity', 'mcp_config.json')
+        ];
+        const globalMcpPath = globalCandidates.find((candidate) => existsSync(dirname(candidate)));
+        if (globalMcpPath) {
           let globalConfig = {};
           if (existsSync(globalMcpPath)) {
             try {
@@ -95,7 +269,8 @@ export class HarnessConfig {
           globalConfig.mcpServers = {
             ...(globalConfig.mcpServers || {}),
             vectorforce: {
-              command: 'node',
+              type: 'stdio',
+              command: HarnessConfig.getNodeCommand(),
               args: [HarnessConfig.getBinPath(), 'mcp', '--workspace', workspacePath],
               env: {
                 VF_WORKSPACE: workspacePath,
@@ -141,7 +316,7 @@ export class HarnessConfig {
   static getCommandCodeServerEntry() {
     return {
       type: 'stdio',
-      command: 'node',
+      command: HarnessConfig.getNodeCommand(),
       args: [HarnessConfig.getBinPath(), 'mcp']
     };
   }
@@ -179,12 +354,19 @@ export class HarnessConfig {
       }
     }
 
+    const mcpServers = { ...(mcpCurrent?.mcpServers || {}) };
+    for (const [name, server] of Object.entries(mcpServers)) {
+      if (server && typeof server === 'object' && server.serverUrl && !server.url) {
+        server.url = server.serverUrl;
+        delete server.serverUrl;
+        if (!server.type) server.type = 'sse';
+      }
+    }
+    mcpServers.vectorforce = HarnessConfig.getCommandCodeServerEntry();
+
     const mcpMerged = {
       ...mcpCurrent,
-      mcpServers: {
-        ...(mcpCurrent?.mcpServers || {}),
-        vectorforce: HarnessConfig.getCommandCodeServerEntry()
-      }
+      mcpServers
     };
 
     const cliCommand = `cmd mcp add --transport stdio vectorforce -- node ${HarnessConfig.getBinPath()} mcp`;
@@ -251,7 +433,8 @@ export class HarnessConfig {
    */
   static getMuseCodeServerEntry() {
     return {
-      command: 'node',
+      type: 'stdio',
+      command: HarnessConfig.getNodeCommand(),
       args: [HarnessConfig.getBinPath(), 'mcp'],
       env: {
         VF_HARNESS: 'muse-code'
@@ -294,6 +477,42 @@ export class HarnessConfig {
     };
   }
 
+  /**
+   * Merge the VectorForce entry into global Muse Code settings (pure, no I/O).
+   * Muse Code reads MCP servers from the camelCase `mcpServers` block of the
+   * user settings file. A stale snake_case `mcp_servers.vectorforce` entry
+   * (written by older VectorForce releases) is migrated, never duplicated.
+   * The global entry carries no workspace pin, so one entry serves every
+   * project: the server resolves its workspace from its launch directory.
+   */
+  static _mergeMuseGlobalSettings(settings) {
+    const merged = { ...(settings || {}) };
+    if (merged.schema_version === undefined) {
+      merged.schema_version = 1;
+    }
+    const servers = { ...(merged.mcpServers || {}) };
+    servers.vectorforce = {
+      mode: 'optional',
+      transport: 'stdio',
+      command: HarnessConfig.getNodeCommand(),
+      args: [HarnessConfig.getBinPath(), 'mcp'],
+      env: {
+        VF_HARNESS: 'muse-code'
+      }
+    };
+    merged.mcpServers = servers;
+    if (merged.mcp_servers?.vectorforce) {
+      const remaining = { ...merged.mcp_servers };
+      delete remaining.vectorforce;
+      if (Object.keys(remaining).length === 0) {
+        delete merged.mcp_servers;
+      } else {
+        merged.mcp_servers = remaining;
+      }
+    }
+    return merged;
+  }
+
   /**
    * Install Muse Code MCP configuration reversibly.
    * @param {string} workspacePath
@@ -309,25 +528,28 @@ export class HarnessConfig {
 
     if (!isTempWorkspace(workspacePath)) {
       try {
-        const globalMuseDir = join(homedir(), '.config', 'muse');
-        const globalSettingsPath = join(globalMuseDir, 'settings.json');
-        if (existsSync(globalSettingsPath)) {
-          const settings = JSON.parse(readFileSync(globalSettingsPath, 'utf8'));
-          settings.mcp_servers = {
-            ...(settings.mcp_servers || {}),
-            vectorforce: {
-              transport: 'stdio',
-              command: 'node',
-              args: [HarnessConfig.getBinPath(), 'mcp'],
-              env: {
-                VF_HARNESS: 'muse-code',
-                VF_WORKSPACE: workspacePath
-              },
-              mode: 'optional'
+        const globalCandidates = [
+          join(homedir(), '.config', 'muse', 'settings.json'),
+          ...(process.platform === 'win32' ? [
+            join(process.env.APPDATA || join(homedir(), 'AppData', 'Roaming'), 'muse', 'settings.json'),
+            join(homedir(), '.muse', 'settings.json')
+          ] : [])
+        ];
+        for (const globalSettingsPath of globalCandidates) {
+          const globalMuseDir = dirname(globalSettingsPath);
+          if (globalSettingsPath.includes('.config') || existsSync(globalMuseDir)) {
+            mkdirSync(globalMuseDir, { recursive: true });
+            let settings = {};
+            if (existsSync(globalSettingsPath)) {
+              try {
+                settings = JSON.parse(readFileSync(globalSettingsPath, 'utf8'));
+              } catch {
+                settings = {};
+              }
             }
-          };
-          delete settings.mcpServers;
-          writeFileSync(globalSettingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf8');
+            settings = HarnessConfig._mergeMuseGlobalSettings(settings);
+            writeFileSync(globalSettingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf8');
+          }
         }
       } catch {}
     }
@@ -368,12 +590,26 @@ export class HarnessConfig {
 
     if (!isTempWorkspace(workspacePath)) {
       try {
-        const globalSettingsPath = join(homedir(), '.config', 'muse', 'settings.json');
-        if (existsSync(globalSettingsPath)) {
-          const settings = JSON.parse(readFileSync(globalSettingsPath, 'utf8'));
-          if (settings?.mcp_servers?.vectorforce) {
-            delete settings.mcp_servers.vectorforce;
-            writeFileSync(globalSettingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf8');
+        const globalCandidates = [
+          join(homedir(), '.config', 'muse', 'settings.json'),
+          ...(process.platform === 'win32' ? [
+            join(process.env.APPDATA || join(homedir(), 'AppData', 'Roaming'), 'muse', 'settings.json'),
+            join(homedir(), '.muse', 'settings.json')
+          ] : [])
+        ];
+        for (const globalSettingsPath of globalCandidates) {
+          if (existsSync(globalSettingsPath)) {
+            const settings = JSON.parse(readFileSync(globalSettingsPath, 'utf8'));
+            let changed = false;
+            for (const key of ['mcpServers', 'mcp_servers']) {
+              if (settings?.[key]?.vectorforce) {
+                delete settings[key].vectorforce;
+                changed = true;
+              }
+            }
+            if (changed) {
+              writeFileSync(globalSettingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf8');
+            }
           }
         }
       } catch {}
@@ -387,7 +623,8 @@ export class HarnessConfig {
    */
   static getCodexServerEntry() {
     return {
-      command: 'node',
+      type: 'stdio',
+      command: HarnessConfig.getNodeCommand(),
       args: [HarnessConfig.getBinPath(), 'mcp'],
       env: {
         VF_HARNESS: 'codex'
@@ -401,8 +638,9 @@ export class HarnessConfig {
    * @returns {string} merged TOML
    */
   static _mergeCodexToml(existingToml) {
-    const binPath = HarnessConfig.getBinPath().replace(/\\/g, '\\\\');
-    const serverBlock = `[mcp_servers.vectorforce]\ncommand = "node"\nargs = ["${binPath}", "mcp"]\n[mcp_servers.vectorforce.env]\nVF_HARNESS = "codex"\n`;
+    const nodeCommand = HarnessConfig._tomlString(HarnessConfig.getNodeCommand());
+    const binPath = HarnessConfig._tomlString(HarnessConfig.getBinPath());
+    const serverBlock = `[mcp_servers.vectorforce]\ncommand = ${nodeCommand}\nargs = [${binPath}, "mcp"]\n[mcp_servers.vectorforce.env]\nVF_HARNESS = "codex"\n`;
 
     if (!existingToml || !existingToml.trim()) {
       return serverBlock;
@@ -553,7 +791,8 @@ export class HarnessConfig {
    */
   static getCursorServerEntry() {
     return {
-      command: 'node',
+      type: 'stdio',
+      command: HarnessConfig.getNodeCommand(),
       args: [HarnessConfig.getBinPath(), 'mcp'],
       env: {
         VF_HARNESS: 'cursor'
@@ -630,7 +869,8 @@ export class HarnessConfig {
           globalConfig.mcpServers = {
             ...(globalConfig.mcpServers || {}),
             vectorforce: {
-              command: 'node',
+              type: 'stdio',
+              command: HarnessConfig.getNodeCommand(),
               args: [HarnessConfig.getBinPath(), 'mcp', '--workspace', workspacePath],
               env: {
                 VF_WORKSPACE: workspacePath,
@@ -676,7 +916,8 @@ export class HarnessConfig {
    */
   static getWindsurfServerEntry() {
     return {
-      command: 'node',
+      type: 'stdio',
+      command: HarnessConfig.getNodeCommand(),
       args: [HarnessConfig.getBinPath(), 'mcp'],
       env: {
         VF_HARNESS: 'windsurf'
@@ -753,7 +994,8 @@ export class HarnessConfig {
           globalConfig.mcpServers = {
             ...(globalConfig.mcpServers || {}),
             vectorforce: {
-              command: 'node',
+              type: 'stdio',
+              command: HarnessConfig.getNodeCommand(),
               args: [HarnessConfig.getBinPath(), 'mcp', '--workspace', workspacePath],
               env: {
                 VF_WORKSPACE: workspacePath,
@@ -799,7 +1041,8 @@ export class HarnessConfig {
    */
   static getCopilotServerEntry() {
     return {
-      command: 'node',
+      type: 'stdio',
+      command: HarnessConfig.getNodeCommand(),
       args: [HarnessConfig.getBinPath(), 'mcp'],
       env: {
         VF_HARNESS: 'copilot'
@@ -822,18 +1065,31 @@ export class HarnessConfig {
         current = {};
       }
     }
+    // VS Code reads only the top-level `servers` key; migrate any legacy
+    // `mcpServers.vectorforce` entry this tool wrote previously.
+    const migratedLegacy = Boolean(current?.mcpServers?.vectorforce);
     const mergedContent = {
       ...(current || {}),
-      mcpServers: {
-        ...(current?.mcpServers || {}),
+      servers: {
+        ...(current?.servers || {}),
         vectorforce: HarnessConfig.getCopilotServerEntry()
       }
     };
+    if (mergedContent.mcpServers?.vectorforce) {
+      const remaining = { ...mergedContent.mcpServers };
+      delete remaining.vectorforce;
+      if (Object.keys(remaining).length === 0) {
+        delete mergedContent.mcpServers;
+      } else {
+        mergedContent.mcpServers = remaining;
+      }
+    }
     return {
       filePath,
       exists: existsSync(filePath),
       currentContent: current,
-      mergedContent
+      mergedContent,
+      migratedLegacy
     };
   }
 
@@ -878,10 +1134,14 @@ export class HarnessConfig {
     if (existsSync(filePath)) {
       try {
         const config = JSON.parse(readFileSync(filePath, 'utf8'));
-        if (config?.mcpServers?.vectorforce) {
-          delete config.mcpServers.vectorforce;
+        for (const key of ['servers', 'mcpServers']) {
+          if (config?.[key]?.vectorforce) {
+            delete config[key].vectorforce;
+            removed = true;
+          }
+        }
+        if (removed) {
           writeFileSync(filePath, JSON.stringify(config, null, 2) + '\n', 'utf8');
-          removed = true;
         }
       } catch {}
     }
@@ -897,7 +1157,8 @@ export class HarnessConfig {
    */
   static getKiroServerEntry() {
     return {
-      command: 'node',
+      type: 'stdio',
+      command: HarnessConfig.getNodeCommand(),
       args: [HarnessConfig.getBinPath(), 'mcp'],
       env: {
         VF_HARNESS: 'kiro'
@@ -910,9 +1171,10 @@ export class HarnessConfig {
    * @param {string} workspacePath
    */
   static previewKiro(workspacePath) {
-    const dir = join(workspacePath, '.kiro');
+    const dir = join(workspacePath, '.kiro', 'settings');
     const filePath = join(dir, 'mcp.json');
     const kiroJsonPath = join(workspacePath, 'kiro.json');
+    const legacyPath = join(workspacePath, '.kiro', 'mcp.json');
 
     let current = null;
     if (existsSync(filePath)) {
@@ -949,6 +1211,7 @@ export class HarnessConfig {
     return {
       filePath,
       kiroJsonPath,
+      legacyPath,
       exists: existsSync(filePath) || existsSync(kiroJsonPath),
       currentContent: current,
       mergedContent,
@@ -962,19 +1225,34 @@ export class HarnessConfig {
    * @returns {string} filePath
    */
   static installKiro(workspacePath) {
-    const { filePath, kiroJsonPath, mergedContent, mergedKiroJson } = HarnessConfig.previewKiro(workspacePath);
-    const dir = join(workspacePath, '.kiro');
+    const { filePath, kiroJsonPath, legacyPath, mergedContent, mergedKiroJson } = HarnessConfig.previewKiro(workspacePath);
+    const dir = join(workspacePath, '.kiro', 'settings');
     if (!existsSync(dir)) {
       mkdirSync(dir, { recursive: true, mode: 0o755 });
     }
     writeFileSync(filePath, JSON.stringify(mergedContent, null, 2) + '\n', 'utf8');
     writeFileSync(kiroJsonPath, JSON.stringify(mergedKiroJson, null, 2) + '\n', 'utf8');
 
-    // Create .kiro/rules.md if missing
-    const rulesPath = join(dir, 'rules.md');
-    if (!existsSync(rulesPath)) {
+    // Migrate the legacy .kiro/mcp.json entry (Kiro only reads .kiro/settings/mcp.json).
+    if (legacyPath && existsSync(legacyPath)) {
+      try {
+        const legacy = JSON.parse(readFileSync(legacyPath, 'utf8'));
+        if (legacy?.mcpServers?.vectorforce) {
+          delete legacy.mcpServers.vectorforce;
+          writeFileSync(legacyPath, JSON.stringify(legacy, null, 2) + '\n', 'utf8');
+        }
+      } catch {}
+    }
+
+    // Create the Kiro steering file if missing.
+    const steeringDir = join(workspacePath, '.kiro', 'steering');
+    if (!existsSync(steeringDir)) {
+      mkdirSync(steeringDir, { recursive: true, mode: 0o755 });
+    }
+    const steeringPath = join(steeringDir, 'vectorforce.md');
+    if (!existsSync(steeringPath)) {
       writeFileSync(
-        rulesPath,
+        steeringPath,
         `# VectorForce Agent Steering (Kiro IDE)\n\nThis workspace uses VectorForce for architectural continuity and drift prevention.\n- Use VectorForce MCP tools: 'list_tasks', 'check_workspace_drift', 'get_resume_briefing', 'save_checkpoint'.\n- Strictly adhere to invariant constraints and architectural decisions.\n`,
         'utf8'
       );
@@ -989,27 +1267,20 @@ export class HarnessConfig {
    * @returns {boolean} whether removed
    */
   static uninstallKiro(workspacePath) {
-    const filePath = join(workspacePath, '.kiro', 'mcp.json');
-    const kiroJsonPath = join(workspacePath, 'kiro.json');
+    const candidates = [
+      join(workspacePath, '.kiro', 'settings', 'mcp.json'),
+      join(workspacePath, '.kiro', 'mcp.json'),
+      join(workspacePath, 'kiro.json')
+    ];
     let removed = false;
 
-    if (existsSync(filePath)) {
-      try {
-        const config = JSON.parse(readFileSync(filePath, 'utf8'));
-        if (config?.mcpServers?.vectorforce) {
-          delete config.mcpServers.vectorforce;
-          writeFileSync(filePath, JSON.stringify(config, null, 2) + '\n', 'utf8');
-          removed = true;
-        }
-      } catch {}
-    }
-
-    if (existsSync(kiroJsonPath)) {
+    for (const candidate of candidates) {
+      if (!existsSync(candidate)) continue;
       try {
-        const config = JSON.parse(readFileSync(kiroJsonPath, 'utf8'));
+        const config = JSON.parse(readFileSync(candidate, 'utf8'));
         if (config?.mcpServers?.vectorforce) {
           delete config.mcpServers.vectorforce;
-          writeFileSync(kiroJsonPath, JSON.stringify(config, null, 2) + '\n', 'utf8');
+          writeFileSync(candidate, JSON.stringify(config, null, 2) + '\n', 'utf8');
           removed = true;
         }
       } catch {}

package/src/mcp/mcp-server.js

@@ -1,6 +1,34 @@
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { ErrorCode, VectorForceError } from '../core/errors.js';
 
-export const MCP_PROTOCOL_VERSION = '2024-11-05';
+export const MCP_PROTOCOL_VERSION = '2025-11-25';
+
+export const MCP_SUPPORTED_PROTOCOL_VERSIONS = [
+  '2025-11-25',
+  '2025-06-18',
+  '2025-03-26',
+  '2024-11-05'
+];
+
+function readServerVersion() {
+  try {
+    const pkgPath = join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'package.json');
+    return JSON.parse(readFileSync(pkgPath, 'utf8')).version || '0.3.2';
+  } catch {
+    return '0.3.2';
+  }
+}
+
+export const MCP_SERVER_VERSION = readServerVersion();
+
+export function negotiateProtocolVersion(clientVersion) {
+  if (clientVersion && MCP_SUPPORTED_PROTOCOL_VERSIONS.includes(clientVersion)) {
+    return clientVersion;
+  }
+  return MCP_PROTOCOL_VERSION;
+}
 
 export const MCP_TOOLS = [
   {
@@ -214,14 +242,31 @@ export class McpServer {
       return;
     }
 
+    // JSON-RPC batch: dispatch each entry; entries without an id are notifications.
+    if (Array.isArray(req)) {
+      if (req.length === 0) {
+        this._sendError(null, -32600, 'Invalid Request: empty batch');
+        return;
+      }
+      for (const sub of req) {
+        this._dispatch(sub);
+      }
+      return;
+    }
+
+    this._dispatch(req);
+  }
+
+  _dispatch(req) {
+    if (!req || typeof req !== 'object' || Array.isArray(req)) {
+      this._sendError(null, -32600, 'Invalid Request');
+      return;
+    }
+
     const { id, method, params } = req;
 
-    // Notifications (no id)
+    // Notifications (no id) are acknowledged silently, never answered.
     if (id === undefined || id === null) {
-      if (method === 'notifications/initialized') {
-        // Client handshake complete
-        return;
-      }
       return;
     }
 
@@ -229,15 +274,17 @@ export class McpServer {
       switch (method) {
         case 'initialize': {
           this._sendResult(id, {
-            protocolVersion: MCP_PROTOCOL_VERSION,
+            protocolVersion: negotiateProtocolVersion(params?.protocolVersion),
             serverInfo: {
               name: 'vectorforce',
-              version: '0.1.0'
+              version: MCP_SERVER_VERSION
             },
             capabilities: {
               tools: {
                 listChanged: false
-              }
+              },
+              resources: {},
+              prompts: {}
             }
           });
           break;
@@ -255,6 +302,31 @@ export class McpServer {
           break;
         }
 
+        case 'resources/list': {
+          this._sendResult(id, { resources: [] });
+          break;
+        }
+
+        case 'resources/templates/list': {
+          this._sendResult(id, { resourceTemplates: [] });
+          break;
+        }
+
+        case 'resources/read': {
+          this._sendError(id, -32602, `Unknown resource: ${params?.uri || '(missing uri)'}`);
+          break;
+        }
+
+        case 'prompts/list': {
+          this._sendResult(id, { prompts: [] });
+          break;
+        }
+
+        case 'prompts/get': {
+          this._sendError(id, -32602, `Unknown prompt: ${params?.name || '(missing name)'}`);
+          break;
+        }
+
         case 'tools/call': {
           this._handleToolCall(id, params);
           break;

package/src/operations/project-service.js

@@ -1,6 +1,7 @@
 import { Authorizer } from '../policy/authorizer.js';
 import { sha256 } from '../core/hash.js';
 import { basename, dirname } from 'node:path';
+import { execFileSync } from 'node:child_process';
 import { ErrorCode, VectorForceError } from '../core/errors.js';
 
 export class ProjectService {
@@ -13,6 +14,8 @@ export class ProjectService {
 
   /**
    * Initialize or retrieve a project for a workspace directory.
+   * Derives a deterministic project identity from Git remote URL if present,
+   * ensuring that multiple developers cloning the same repo share the identical project ID.
    * @param {string} workspacePath
    * @param {string} [customName]
    * @returns {{ project_id: string, canonical_path: string, name: string, created_at: string }}
@@ -23,7 +26,21 @@ export class ProjectService {
     if (existing) {
       return existing;
     }
-    const idHash = sha256(canonical).slice(0, 16);
+
+    let identitySeed = canonical;
+    try {
+      const gitRemote = execFileSync('git', ['config', '--get', 'remote.origin.url'], {
+        cwd: canonical,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+        timeout: 1000
+      }).trim();
+      if (gitRemote) {
+        identitySeed = gitRemote.toLowerCase();
+      }
+    } catch {}
+
+    const idHash = sha256(identitySeed).slice(0, 16);
     const projectId = `proj-${idHash}`;
     const name = customName || basename(canonical);
     return this.store.registerProject(projectId, canonical, name);