vectorforce 0.3.2 → 0.3.4

package/CHANGELOG.md

@@ -7,6 +7,44 @@ 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
+- **First-Class Support for 4 Additional AI Harnesses**:
+  - **Cursor IDE**: Added automated configuration for `.cursor/mcp.json` and `.cursorrules` in `HarnessConfig.installCursor`.
+  - **Windsurf (Codeium Cascade)**: Added automated configuration for `.windsurf/mcp_config.json` and `.windsurfrules` in `HarnessConfig.installWindsurf`.
+  - **GitHub Copilot / VS Code**: Added automated workspace configuration for `.vscode/mcp.json` and `.github/copilot-instructions.md` in `HarnessConfig.installCopilot`.
+  - **Kiro IDE**: Added automated configuration for `.kiro/mcp.json`, `kiro.json`, and `.kiro/rules.md` in `HarnessConfig.installKiro`.
+- **Harness Policy & Tool Schema Expansion**:
+  - Updated `APPROVED_DESTINATIONS` in `Authorizer` to approve `cursor`, `windsurf`, `github-copilot`, `copilot`, `kiro`, and `kiro-ide`.
+  - Updated MCP tool schemas for `get_resume_briefing`, `export_handoff`, `get_timeline`, and `reason_about_task` to accept all newly supported harnesses.
+- **Universal MCP Configuration Guide in Documentation**:
+  - Added dedicated installation instructions to `README.md` for Cline / Roo Code, Zed Editor, JetBrains IDEs (IntelliJ, WebStorm, PyCharm), Sourcegraph Cody, Aider, and generic stdio MCP clients.
+- **Comprehensive Unit & Security Test Coverage**:
+  - Added automated reversible install/uninstall tests for Cursor, Windsurf, GitHub Copilot, and Kiro IDE (test suite expanded to 79 tests).
+
+### Changed
+- `vf init`, `vf config install all`, `vf config doctor`, and `vf status` now inspect and provision all 9 AI coding harnesses.
+- Pruned `package.json` package `files` whitelist to strictly include runtime artifacts (`bin/`, `src/`, `studio/dist/`, `CHANGELOG.md`, `LICENSE`, `README.md`).
+
+---
+
 ## [0.2.0] - 2026-10-31
 
 ### 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
@@ -137,33 +219,37 @@ node bin/vf.js studio
 
 ## Model Context Protocol (MCP)
 
-VectorForce exposes a standard stdio JSON-RPC MCP server for direct integration into **Google Antigravity**, **Claude Code**, **Command Code**, **Meta Muse**, and **OpenAI Codex**.
+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` (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
-# Auto-configure all supported AI harnesses at once:
+# Auto-configure all 9 supported AI harnesses at once:
 node bin/vf.js config install all
 
 # Verify SQLite DB, AGENTS.md, and all MCP client configs:
 node bin/vf.js status
 ```
 
-### JSON Configuration (Antigravity, Claude Code, Command Code, Muse)
+### JSON Configuration (Antigravity, Claude Code, Command Code, Muse, Cursor, Windsurf, VS Code, Kiro)
 ```json
 {
   "mcpServers": {
     "vectorforce": {
-      "command": "node",
+      "command": "/absolute/path/to/node",
       "args": ["/absolute/path/to/VectorForce/bin/vf.js", "mcp"]
     }
   }
@@ -173,12 +259,102 @@ 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"
 ```
 
+---
+
+## How to Configure & Update MCP for Any Other AI Coding Harness
+
+If your AI assistant or IDE is not in the auto-configured list above, you can connect it to VectorForce in seconds using standard MCP configuration:
+
+### 1. Cline & Roo Code (VS Code Extension)
+Open VS Code Settings or click the **MCP** icon in the Cline panel:
+- Open `cline_mcp_settings.json` (or `roo-cline_mcp_settings.json`) located at:
+  - **macOS:** `~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json`
+  - **Linux:** `~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json`
+  - **Windows:** `%APPDATA%\Code\User\globalStorage\saoudrizwan.claude-dev\settings\cline_mcp_settings.json`
+- Add the VectorForce entry:
+```json
+{
+  "mcpServers": {
+    "vectorforce": {
+      "command": "npx",
+      "args": ["-y", "vectorforce", "mcp"],
+      "disabled": false,
+      "autoApprove": [
+        "list_tasks",
+        "check_workspace_drift",
+        "get_resume_briefing",
+        "save_checkpoint",
+        "reason_about_task"
+      ]
+    }
+  }
+}
+```
+
+### 2. Zed Editor
+Zed natively supports MCP context servers. Open your Zed configuration (`~/.config/zed/settings.json` or `cmd-,`):
+```json
+{
+  "context_servers": {
+    "vectorforce": {
+      "command": {
+        "path": "npx",
+        "args": ["-y", "vectorforce", "mcp"]
+      }
+    }
+  }
+}
+```
+
+### 3. JetBrains IDEs (IntelliJ IDEA, WebStorm, PyCharm, RustRover)
+For JetBrains IDEs supporting MCP or AI Assistant:
+1. Open **Settings / Preferences** (`Ctrl+Alt+S` or `Cmd+,`).
+2. Search for **Model Context Protocol** or **AI Assistant → Context Providers**.
+3. Click **Add Stdio Server**:
+   - **Name:** `vectorforce`
+   - **Command:** `node` (or `npx`)
+   - **Arguments:** `/path/to/VectorForce/bin/vf.js mcp` (or `-y vectorforce mcp`)
+   - **Environment Variables:** `VF_HARNESS=jetbrains`
+
+### 4. Sourcegraph Cody
+In Sourcegraph Cody settings (`cody.experimental.mcp.servers` in VS Code or JetBrains):
+```json
+{
+  "cody.experimental.mcp.servers": {
+    "vectorforce": {
+      "command": "node",
+      "args": ["/path/to/VectorForce/bin/vf.js", "mcp"]
+    }
+  }
+}
+```
+
+### 5. Aider (`aider-chat`)
+Aider integrates directly with Git and can ingest VectorForce's immutable architectural briefings:
+```bash
+# Pipe VectorForce briefing directly to Aider on session start:
+node bin/vf.js resume --task <task_id> --dest cli --raw | aider
+
+# Or generate project conventions before running aider:
+node bin/vf.js resume --task <task_id> --dest cli --raw > CONVENTIONS.md
+aider
+```
+
+### 6. Generic MCP Client (Any Tool Speaking JSON-RPC 2.0 over Stdio)
+For any agent running locally, pass:
+- **Executable:** `node`
+- **Arguments:** `["/path/to/bin/vf.js", "mcp"]`
+- **Working Directory:** Path to your project workspace
+- **Environment:** `VF_WORKSPACE=/path/to/project` (optional if working directory matches)
+
+Whenever you update VectorForce (`npm update -g vectorforce`), simply restart your AI agent or IDE window to immediately use the latest MCP tools.
+
 ### Available MCP Tools
 | Tool | Purpose |
 |---|---|

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,19 +338,50 @@ 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);
+        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(
             agentsMdPath,
-            `# Agent Continuity Protocol — ${project.name}\n\nThis repository uses **VectorForce** ("Git for AI Context") across Google Antigravity, Meta Muse, Claude Code, Command Code, and OpenAI Codex.\n\n## Workflow\n1. **Start/Resume Task**: Run \`vf tasks active\`, \`vf drift --task <id>\`, and \`vf resume --task <id> --dest <harness>\` (or MCP tools \`list_tasks\`, \`check_workspace_drift\`, \`get_resume_briefing\`, \`reason_about_task\`).\n2. **Save Checkpoint Before Switching IDE**: Run \`vf checkpoint --task <id> --summary "<summary>" --goal "<goal>" --constraint "<constraint>" --decision "<ID>:<Title>:<Rationale>" --next "<next>" --doc "AGENTS.md"\` (or MCP tool \`save_checkpoint\`).\n`,
+            `# Agent Continuity Protocol — ${project.name}\n\nThis repository uses **VectorForce** ("Git for AI Context") across Google Antigravity, Meta Muse, Claude Code, Command Code, OpenAI Codex, Cursor, Windsurf, GitHub Copilot, and Kiro IDE.\n\n## Workflow\n1. **Start/Resume Task**: Run \`vf tasks active\`, \`vf drift --task <id>\`, and \`vf resume --task <id> --dest <harness>\` (or MCP tools \`list_tasks\`, \`check_workspace_drift\`, \`get_resume_briefing\`, \`reason_about_task\`).\n2. **Save Checkpoint Before Switching IDE**: Run \`vf checkpoint --task <id> --summary "<summary>" --goal "<goal>" --constraint "<constraint>" --decision "<ID>:<Title>:<Rationale>" --next "<next>" --doc "AGENTS.md"\` (or MCP tool \`save_checkpoint\`).\n`,
             'utf8'
           );
         }
         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;
       }
 
@@ -547,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', () => {
@@ -564,37 +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}`);
+          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 === '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)`);
+          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: '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) {
@@ -607,19 +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');
-          }
-          if (target === 'muse' || target === 'muse-code' || target === 'all') {
-            if (HarnessConfig.uninstallMuseCode(cwd)) uninstalled.push('Muse 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 === 'codex' || target === 'all') {
-            if (HarnessConfig.uninstallCodex(cwd)) uninstalled.push('Codex');
+          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;
@@ -843,7 +913,7 @@ VectorForce Harness Configuration:
    {
      "mcpServers": {
        "vectorforce": {
-         "command": "node",
+         "command": "${process.execPath}",
          "args": ["${binPath}", "mcp"]
        }
      }
@@ -855,7 +925,7 @@ VectorForce Harness Configuration:
    {
      "mcpServers": {
        "vectorforce": {
-         "command": "node",
+         "command": "${process.execPath}",
          "args": ["${binPath}", "mcp"],
          "env": { "VF_HARNESS": "muse-code" }
        }
@@ -870,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"
@@ -907,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;
       }
@@ -947,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;
@@ -963,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'
@@ -989,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();
@@ -1098,10 +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: '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) {
@@ -1109,7 +1196,7 @@ VectorForce Harness Configuration:
         }
         console.log(`\n💡 How it works:`);
         console.log(`  1. You do NOT need to run "vf mcp" manually.`);
-        console.log(`  2. Your AI agent (Antigravity, Claude Code, Command Code, Muse, Codex) reads its config file above and automatically spawns "vf mcp" over stdio.`);
+        console.log(`  2. Your AI agent (Antigravity, Claude Code, Command Code, Muse, Codex, Cursor, Windsurf, Copilot, Kiro) reads its config file above and automatically spawns "vf mcp" over stdio.`);
         console.log(`  3. To verify in your AI chat, ask: "List active VectorForce tasks and check workspace drift"\n`);
         break;
       }

package/package.json

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