vectorforce 0.1.0 → 0.3.0

package/bin/vf.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
-import { homedir } from 'node:os';
-import { resolve, join, dirname } from 'node:path';
+import { homedir, hostname } from 'node:os';
+import { resolve, join, dirname, basename } from 'node:path';
 import { mkdirSync, existsSync, readFileSync, writeFileSync } from 'node:fs';
 import {
   SqliteStore,
@@ -232,8 +232,12 @@ function parseFlags(args) {
       flags.decisions.push({
         id: parts[0] || 'DEC',
         title: parts[1] || parts[0],
-        rationale: parts[2] || 'Approved architecture decision'
+        rationale: parts.slice(2).join(':') || 'Approved architecture decision'
       });
+    } else if (arg === '--harness' && args[i + 1]) {
+      flags.harness = args[++i];
+    } else if (arg === '--author' && args[i + 1]) {
+      flags.author = args[++i];
     } else if (arg === '--next' && args[i + 1]) {
       flags.nextSteps.push(args[++i]);
     } else if (arg === '--doc' && args[i + 1]) {
@@ -260,11 +264,53 @@ function parseFlags(args) {
       flags.workspace = resolve(args[++i]);
     } else if (arg === '--db' && args[i + 1]) {
       flags.db = resolve(args[++i]);
+    } else if ((arg === '--url' || arg === '--remote') && args[i + 1]) {
+      flags.url = args[++i];
+    } else if (arg === '--key' && args[i + 1]) {
+      flags.key = args[++i];
+    } else if (arg === '--project' && args[i + 1]) {
+      flags.project = args[++i];
     }
   }
   return flags;
 }
 
+function getRemoteConfig(cwd) {
+  const defaultUrl = process.env.VF_CLOUD_URL || 'https://omprakash-pce2011--vectorforce-cloud-vectorforce-cloud-web.modal.run';
+  const defaultKey = process.env.VF_SUBSCRIPTION_KEY || 'vf_live_sub_98a7bc65f012e4d9';
+  const cfgPath = join(cwd, '.vectorforce', 'config.json');
+  try {
+    if (existsSync(cfgPath)) {
+      const parsed = JSON.parse(readFileSync(cfgPath, 'utf8'));
+      return {
+        remoteUrl: (parsed.remoteUrl || defaultUrl).replace(/\/+$/, ''),
+        subscriptionKey: parsed.subscriptionKey || defaultKey,
+        remoteProjectId: parsed.remoteProjectId || 'proj-bistro-pos'
+      };
+    }
+  } catch {}
+  return {
+    remoteUrl: defaultUrl.replace(/\/+$/, ''),
+    subscriptionKey: defaultKey,
+    remoteProjectId: 'proj-bistro-pos'
+  };
+}
+
+function saveRemoteConfig(cwd, updates) {
+  const vfDir = join(cwd, '.vectorforce');
+  mkdirSync(vfDir, { recursive: true, mode: 0o700 });
+  const cfgPath = join(vfDir, 'config.json');
+  let existing = {};
+  try {
+    if (existsSync(cfgPath)) {
+      existing = JSON.parse(readFileSync(cfgPath, 'utf8'));
+    }
+  } catch {}
+  const merged = { ...existing, ...updates };
+  writeFileSync(cfgPath, JSON.stringify(merged, null, 2), 'utf8');
+  return merged;
+}
+
 async function main() {
   const args = process.argv.slice(2);
   const command = args[0] || 'help';
@@ -282,8 +328,20 @@ async function main() {
   try {
     switch (command) {
       case 'init': {
-        const name = args[1] || null;
+        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 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`,
+            'utf8'
+          );
+        }
         console.log(`Initialized VectorForce project: ${project.name} (${project.project_id})`);
         break;
       }
@@ -300,12 +358,14 @@ async function main() {
           console.log(`Task marked as completed: ${task.title} (${task.task_id}) [${task.status}]`);
           break;
         }
-        const taskId = sub;
+        const isCreateSub = sub === 'create' || sub === 'add';
+        const rawArgs = isCreateSub ? args.slice(2) : args.slice(1);
+        const taskId = rawArgs[0];
         if (!taskId) {
           console.error('Error: task id required (e.g. vf task feat-sqlite "Implement SQLite store")');
           process.exit(1);
         }
-        const title = args.slice(2).join(' ') || taskId;
+        const title = rawArgs.slice(1).join(' ') || taskId;
         const task = projectService.createTask(cwd, taskId, title);
         console.log(`Task registered: ${task.title} (${task.task_id}) [${task.status}]`);
         break;
@@ -362,8 +422,8 @@ async function main() {
           nextSteps: flags.nextSteps,
           requestedDocuments: flags.docs,
           includeGit: flags.includeGit,
-          authorName: process.env.USER || 'developer',
-          authorHarness: 'cli'
+          authorName: flags.author || process.env.VF_AUTHOR || process.env.USER || 'developer',
+          authorHarness: flags.harness || process.env.VF_HARNESS || 'cli'
         });
         console.log(`Checkpoint saved: ${receipt.reference_id} [${receipt.status}]`);
         if (receipt.warnings.length > 0) {
@@ -508,21 +568,41 @@ async function main() {
           const installed = [];
           if (target === 'antigravity' || target === 'all') {
             const p = HarnessConfig.installAntigravity(cwd);
-            installed.push(`Antigravity -> ${p}`);
+            installed.push(`Google Antigravity -> ${p} (+ ~/.gemini/antigravity/mcp_config.json)`);
           }
-          if (target === 'command-code' || target === 'cmd' || target === 'all') {
+          if (target === 'command-code' || target === 'cmd' || target === 'claude' || target === 'claude-code' || target === 'all') {
             const p = HarnessConfig.installCommandCode(cwd);
-            installed.push(`Command Code -> ${p}`);
+            installed.push(`Command Code / Claude Code -> .mcp.json & ${p}`);
           }
           if (target === 'muse' || target === 'muse-code' || target === 'all') {
             const p = HarnessConfig.installMuseCode(cwd);
-            installed.push(`Muse Code -> ${p}`);
+            installed.push(`Meta Muse -> ${p} (+ ~/.config/muse/settings.json)`);
           }
           if (target === 'codex' || target === 'all') {
             const p = HarnessConfig.installCodex(cwd);
-            installed.push(`Codex -> ${p}`);
+            installed.push(`Codex -> ${p} (+ ~/.codex/config.toml)`);
           }
           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 === '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') }
+          ];
+          console.log(`\nVectorForce Workspace & MCP Health Check (${cwd}):\n`);
+          for (const c of checks) {
+            console.log(`  ${c.ok ? '✔ [READY]  ' : '○ [MISSING]'} ${c.name}`);
+          }
+          console.log(`\nHow to verify inside your AI agent chat:`);
+          console.log(`  Ask: "Check active VectorForce tasks and workspace drift"`);
+          console.log(`  Your agent will automatically call MCP tools: list_tasks & check_workspace_drift\n`);
           break;
         }
 
@@ -590,6 +670,32 @@ async function main() {
           break;
         }
 
+        if (sub === 'fireworks') {
+          const key = args[2];
+          const model = args[3] || 'accounts/fireworks/models/muse-spark-open';
+          if (!key) {
+            console.error('Usage: node bin/vf.js config fireworks <API_KEY> [MODEL]');
+            process.exit(1);
+          }
+          const vfDir = join(cwd, '.vectorforce');
+          mkdirSync(vfDir, { recursive: true, mode: 0o700 });
+          const cfgPath = join(vfDir, 'config.json');
+          let existing = {};
+          if (existsSync(cfgPath)) {
+            try { existing = JSON.parse(readFileSync(cfgPath, 'utf8')); } catch {}
+          }
+          existing.VF_LLM_PROVIDER = 'fireworks';
+          existing.FIREWORKS_API_KEY = key;
+          existing.VF_FIREWORKS_MODEL = model;
+          existing.VF_FIREWORKS_BASE_URL = 'https://api.fireworks.ai/inference/v1';
+          writeFileSync(cfgPath, JSON.stringify(existing, null, 2) + '\n', 'utf8');
+          console.log(`\n✔ Configured Fireworks AI (Meta Muse Spark Open) in ${cfgPath}`);
+          console.log(`  Provider: fireworks`);
+          console.log(`  Model:    ${model}`);
+          console.log(`  Base URL: https://api.fireworks.ai/inference/v1`);
+          break;
+        }
+
         if (sub === 'muse') {
           const key = args[2];
           const model = args[3] || 'muse-spark-1.3';
@@ -615,6 +721,108 @@ async function main() {
           break;
         }
 
+        if (sub === 'ollama') {
+          const model = args[2] || 'llama3.1:8b';
+          const baseUrl = args[3] || 'http://127.0.0.1:11434';
+          const vfDir = join(cwd, '.vectorforce');
+          mkdirSync(vfDir, { recursive: true, mode: 0o700 });
+          const cfgPath = join(vfDir, 'config.json');
+          let existing = {};
+          if (existsSync(cfgPath)) {
+            try { existing = JSON.parse(readFileSync(cfgPath, 'utf8')); } catch {}
+          }
+          existing.VF_LLM_PROVIDER = 'ollama';
+          existing.VF_OLLAMA_MODEL = model;
+          existing.VF_OLLAMA_BASE_URL = baseUrl;
+          writeFileSync(cfgPath, JSON.stringify(existing, null, 2) + '\n', 'utf8');
+          console.log(`\n✔ Configured Local Ollama in ${cfgPath}`);
+          console.log(`  Provider: ollama (100% Local & Private)`);
+          console.log(`  Model:    ${model}`);
+          console.log(`  Base URL: ${baseUrl}`);
+          break;
+        }
+
+        if (sub === 'openai' || sub === 'codex') {
+          const key = args[2];
+          const model = args[3] || 'o3-mini';
+          const baseUrl = args[4] || 'https://api.openai.com/v1';
+          if (!key) {
+            console.error('Usage: node bin/vf.js config openai <API_KEY> [MODEL] [BASE_URL]');
+            process.exit(1);
+          }
+          const vfDir = join(cwd, '.vectorforce');
+          mkdirSync(vfDir, { recursive: true, mode: 0o700 });
+          const cfgPath = join(vfDir, 'config.json');
+          let existing = {};
+          if (existsSync(cfgPath)) {
+            try { existing = JSON.parse(readFileSync(cfgPath, 'utf8')); } catch {}
+          }
+          existing.VF_LLM_PROVIDER = 'openai';
+          existing.VF_LLM_API_KEY = key;
+          existing.VF_LLM_MODEL = model;
+          existing.VF_LLM_BASE_URL = baseUrl;
+          writeFileSync(cfgPath, JSON.stringify(existing, null, 2) + '\n', 'utf8');
+          console.log(`\n✔ Configured OpenAI in ${cfgPath}`);
+          console.log(`  Provider: openai`);
+          console.log(`  Model:    ${model}`);
+          console.log(`  Base URL: ${baseUrl}`);
+          break;
+        }
+
+        if (sub === 'anthropic') {
+          const key = args[2];
+          const model = args[3] || 'claude-sonnet-4-20250514';
+          const baseUrl = args[4] || 'https://api.anthropic.com/v1';
+          if (!key) {
+            console.error('Usage: node bin/vf.js config anthropic <API_KEY> [MODEL] [BASE_URL]');
+            process.exit(1);
+          }
+          const vfDir = join(cwd, '.vectorforce');
+          mkdirSync(vfDir, { recursive: true, mode: 0o700 });
+          const cfgPath = join(vfDir, 'config.json');
+          let existing = {};
+          if (existsSync(cfgPath)) {
+            try { existing = JSON.parse(readFileSync(cfgPath, 'utf8')); } catch {}
+          }
+          existing.VF_LLM_PROVIDER = 'anthropic';
+          existing.VF_LLM_API_KEY = key;
+          existing.VF_LLM_MODEL = model;
+          existing.VF_LLM_BASE_URL = baseUrl;
+          writeFileSync(cfgPath, JSON.stringify(existing, null, 2) + '\n', 'utf8');
+          console.log(`\n✔ Configured Anthropic in ${cfgPath}`);
+          console.log(`  Provider: anthropic`);
+          console.log(`  Model:    ${model}`);
+          console.log(`  Base URL: ${baseUrl}`);
+          break;
+        }
+
+        if (sub === 'byok') {
+          const baseUrl = args[2];
+          const key = args[3];
+          const model = args[4] || 'llama-3.3-70b-versatile';
+          if (!baseUrl || !key) {
+            console.error('Usage: node bin/vf.js config byok <BASE_URL> <API_KEY> [MODEL]');
+            process.exit(1);
+          }
+          const vfDir = join(cwd, '.vectorforce');
+          mkdirSync(vfDir, { recursive: true, mode: 0o700 });
+          const cfgPath = join(vfDir, 'config.json');
+          let existing = {};
+          if (existsSync(cfgPath)) {
+            try { existing = JSON.parse(readFileSync(cfgPath, 'utf8')); } catch {}
+          }
+          existing.VF_LLM_PROVIDER = 'byok';
+          existing.VF_LLM_BASE_URL = baseUrl;
+          existing.VF_LLM_API_KEY = key;
+          existing.VF_LLM_MODEL = model;
+          writeFileSync(cfgPath, JSON.stringify(existing, null, 2) + '\n', 'utf8');
+          console.log(`\n✔ Configured Custom BYOK Endpoint in ${cfgPath}`);
+          console.log(`  Provider: byok`);
+          console.log(`  Model:    ${model}`);
+          console.log(`  Base URL: ${baseUrl}`);
+          break;
+        }
+
         if (sub === 'show' || sub === 'status') {
           const cfg = resolveLlmConfig(process.env, {}, cwd);
           console.log('\nVectorForce AI Reasoning Configuration:');
@@ -703,18 +911,213 @@ VectorForce Harness Configuration:
         break;
       }
 
+      case 'remote': {
+        const sub = args[1] || 'show';
+        if (sub === 'set' || sub === 'add') {
+          const urlArg = args[2] && !args[2].startsWith('--') ? args[2] : flags.url;
+          if (!urlArg) {
+            console.error('Usage: vf remote set <CLOUD_URL> [--key <SUBSCRIPTION_KEY>] [--project <PROJECT_ID>]');
+            process.exit(1);
+          }
+          const saved = saveRemoteConfig(cwd, {
+            remoteUrl: urlArg.replace(/\/+$/, ''),
+            ...(flags.key ? { subscriptionKey: flags.key } : {}),
+            ...(flags.project ? { remoteProjectId: flags.project } : {})
+          });
+          console.log(`✔ Remote VectorForce Cloud configured in .vectorforce/config.json:`);
+          console.log(`  Remote URL:  ${saved.remoteUrl}`);
+          console.log(`  Project ID:  ${saved.remoteProjectId || 'proj-bistro-pos'}`);
+          break;
+        }
+        const remote = getRemoteConfig(cwd);
+        console.log(`\nVectorForce Cloud Remote (${cwd}):`);
+        console.log(`  Remote URL:       ${remote.remoteUrl}`);
+        console.log(`  Remote Project:   ${remote.remoteProjectId}`);
+        console.log(`  Subscription Key: ${remote.subscriptionKey.slice(0, 12)}...`);
+        break;
+      }
+
+      case 'push': {
+        const remote = getRemoteConfig(cwd);
+        const targetUrl = (flags.url || remote.remoteUrl).replace(/\/+$/, '');
+        const remoteProjectId = flags.project || remote.remoteProjectId || 'proj-bistro-pos';
+        const project = projectService.getProjectForWorkspace(cwd);
+        const tasks = store.listTasks(project.project_id);
+        const machineId = `${hostname()}-local`;
+
+        console.log(`🔄 Pushing local context (${project.name}) -> ${targetUrl} ...`);
+
+        for (const t of tasks) {
+          if (flags.task && t.task_id !== flags.task) continue;
+          await fetch(`${targetUrl}/api/cloud/tasks`, {
+            method: 'POST',
+            headers: {
+              'Content-Type': 'application/json',
+              Authorization: `Bearer ${remote.subscriptionKey}`
+            },
+            body: JSON.stringify({
+              projectId: remoteProjectId,
+              taskId: t.task_id,
+              title: t.title || t.task_id,
+              assignee: `${process.env.USER || 'developer'}@local-mac`,
+              role: `Local Workspace (${basename(cwd)})`,
+              priority: 'P0',
+              machineId,
+              harness: flags.harness || 'antigravity'
+            })
+          });
+        }
+
+        const checkpoints = store.getCheckpoints(project.project_id, { limit: 50 });
+        let pushedCount = 0;
+        let lastResp = null;
+
+        for (const cp of checkpoints) {
+          if (flags.task && cp.task_id !== flags.task) continue;
+          const res = await fetch(`${targetUrl}/api/cloud/sync/push`, {
+            method: 'POST',
+            headers: {
+              'Content-Type': 'application/json',
+              Authorization: `Bearer ${remote.subscriptionKey}`
+            },
+            body: JSON.stringify({
+              projectId: remoteProjectId,
+              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',
+              summary: cp.summary,
+              goals: cp.claims?.goals || [],
+              constraints: cp.claims?.constraints || [],
+              decisions: cp.claims?.decisions || [],
+              nextSteps: cp.claims?.next_steps || []
+            })
+          });
+          lastResp = await res.json();
+          pushedCount++;
+        }
+
+        console.log(`✔ Pushed ${pushedCount} checkpoint(s) [E2EE AES-256-GCM + X25519 + Ed25519] to ${targetUrl}`);
+        if (lastResp?.checkpoint_id) {
+          console.log(`  Latest Cloud Checkpoint: ${lastResp.checkpoint_id}`);
+        }
+        break;
+      }
+
+      case 'pull': {
+        const remote = getRemoteConfig(cwd);
+        const targetUrl = (flags.url || remote.remoteUrl).replace(/\/+$/, '');
+        const remoteProjectId = flags.project || remote.remoteProjectId || 'proj-bistro-pos';
+
+        console.log(`🔓 Pulling & Decrypting latest context from ${targetUrl} ...`);
+        const res = await fetch(`${targetUrl}/api/cloud/sync/pull`, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${remote.subscriptionKey}`
+          },
+          body: JSON.stringify({
+            projectId: remoteProjectId,
+            taskId: flags.task || undefined
+          })
+        });
+        const data = await res.json();
+        if (!res.ok || data.verified === false) {
+          console.error(`Error pulling from remote: ${data.error || res.statusText}`);
+          process.exit(1);
+        }
+
+        const payload = data.decrypted_on_computer_2?.payload;
+        if (payload) {
+          let project;
+          try {
+            project = projectService.getProjectForWorkspace(cwd);
+          } catch {
+            project = projectService.initProject(cwd, basename(cwd));
+          }
+          const targetTaskId = flags.task || payload.task_id || 'cloud-sync-task';
+          if (!store.getTask(project.project_id, targetTaskId)) {
+            store.createTask(project.project_id, targetTaskId, `Synced Task: ${targetTaskId}`);
+          }
+          const leaves = store.getLeafCheckpoints(project.project_id, targetTaskId);
+          const parentId = leaves.length > 0 ? leaves[0].checkpoint_id : undefined;
+
+          const receipt = checkpointService.captureCheckpoint({
+            workspacePath: cwd,
+            taskId: targetTaskId,
+            parentId,
+            authorName: payload.author?.name || 'cloud-sync',
+            authorHarness: payload.author?.harness || 'muse-code',
+            summary: `[Pulled from Cloud] ${payload.summary}`,
+            goals: payload.claims?.goals?.length ? payload.claims.goals : ['Continue cloud-synced task'],
+            constraints: payload.claims?.constraints || [],
+            decisions: payload.claims?.decisions || [],
+            nextSteps: payload.claims?.next_steps?.length ? payload.claims.next_steps : ['Inspect pulled context'],
+            requestedDocuments: ['AGENTS.md'],
+            includeGit: true
+          });
+          console.log(`✔ Verified Ed25519 signature, decrypted (X25519 + AES-256-GCM), and reconciled into local SQLite!`);
+          console.log(`  Local Checkpoint Committed: ${receipt.reference_id} [${receipt.status}]`);
+        }
+
+        if (data.muse_reasoning) {
+          console.log(`\n🧠 Cloud AI Briefing (${data.muse_reasoning.model}):`);
+          console.log(`  Summary: ${data.muse_reasoning.where_computer_1_left_off}`);
+          for (const step of data.muse_reasoning.recommended_next_actions_for_computer_2 || []) {
+            console.log(`  Next -> ${step}`);
+          }
+        }
+        break;
+      }
+
+      case 'recap':
+      case 'timeline': {
+        const flags = parseFlags(args.slice(1));
+        const days = flags.days ? parseInt(flags.days, 10) : 7;
+        const recap = briefingService.generateRecap({
+          workspacePath: cwd,
+          days,
+          taskId: flags.task,
+          destination: flags.dest || 'cli'
+        });
+        console.log(recap.recapText);
+        break;
+      }
+
+      case 'doctor':
+      case 'status': {
+        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')) }
+        ];
+        console.log(`\nVectorForce Workspace & MCP Status (${cwd}):\n`);
+        for (const c of checks) {
+          console.log(`  ${c.ok ? '✔ [READY]  ' : '○ [MISSING]'} ${c.name}`);
+        }
+        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(`  3. To verify in your AI chat, ask: "List active VectorForce tasks and check workspace drift"\n`);
+        break;
+      }
+
       case 'studio':
       case 'ui': {
         const flags = parseFlags(args.slice(1));
         const port = flags.port || 3210;
         const studio = createStudioServer({
-          dbPath: getDbPath(),
+          dbPath: getDbPath(cwd),
           workspacePath: cwd,
           port
         });
         const url = await studio.start();
         console.log(`\n🚀 VectorForce Studio is running at: ${url}`);
-        console.log(`   Connected to SQLite: ${getDbPath()}`);
+        console.log(`   Connected to SQLite: ${getDbPath(cwd)}`);
         console.log(`   Interactive Topology & AI Memory: ${url}`);
         console.log(`   Press Ctrl+C to stop.\n`);
 

package/musecode.json

@@ -4,14 +4,10 @@
       "command": "node",
       "args": [
         "/Users/omprakashprajapat/AgentAI/VectorForce/bin/vf.js",
-        "mcp",
-        "--workspace",
-        "/Users/omprakashprajapat/AgentAI/VectorForce"
+        "mcp"
       ],
       "env": {
-        "VF_HARNESS": "muse-code",
-        "VF_WORKSPACE": "/Users/omprakashprajapat/AgentAI/VectorForce",
-        "VF_DB_PATH": "/Users/omprakashprajapat/AgentAI/VectorForce/.vectorforce/vectorforce.db"
+        "VF_HARNESS": "muse-code"
       }
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vectorforce",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Portable engineering context platform - Git for AI context",
   "type": "module",
   "main": "src/index.js",
@@ -9,7 +9,10 @@
     "vectorforce": "bin/vf.js"
   },
   "scripts": {
-    "test": "node --test test/**/*.test.js"
+    "build": "npm --prefix studio run build",
+    "prepublishOnly": "npm --prefix studio run build && npm test",
+    "test": "node --test \"test/**/*.test.js\"",
+    "test:practical": "node scripts/practical-test-env.js"
   },
   "engines": {
     "node": ">=22.5.0"
@@ -19,6 +22,7 @@
     "src",
     "studio/dist",
     "AGENTS.md",
+    "CHANGELOG.md",
     "commandcode.json",
     "musecode.json",
     "codex.json",