@geraldmaron/construct 1.0.23 → 1.1.0

package/lib/intake/git-queue.mjs

@@ -0,0 +1,195 @@
+/**
+ * lib/intake/git-queue.mjs — Git-backed adapter for the IntakeQueue interface.
+ *
+ * This implementation replaces the PostgresIntakeQueue for team/enterprise
+ * modes. It uses the filesystem and Git for state synchronization and
+ * conflict resolution, removing the dependency on a central database server.
+ *
+ * Structure:
+ * .cx/team-inbox/
+ *   pending/    - JSON files for unclaimed tasks
+ *   claimed/    - Subdirectories per worker containing claimed task files
+ *   processed/  - Completed tasks
+ *   skipped/    - Skipped tasks
+ *   quarantine/ - Tasks needing human review
+ */
+
+import path from 'node:path';
+import fs from 'fs';
+import { execSync } from 'node:child_process';
+import { shouldQuarantine } from './quarantine.mjs';
+
+function slugify(value) {
+  return String(value || 'untitled')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 60) || 'untitled';
+}
+
+let counter = 0;
+function timestamp() {
+  counter = (counter + 1) % 1000;
+  const c = String(counter).padStart(3, '0');
+  return `${new Date().toISOString().replace(/[:.]/g, '-').slice(0, 23)}-${c}`;
+}
+
+export class GitIntakeQueue {
+  constructor({ project, rootDir = process.cwd() } = {}) {
+    this.project = project;
+    this.inboxRoot = path.join(rootDir, '.cx', 'team-inbox');
+    this._ensureDirs();
+  }
+
+  _ensureDirs() {
+    ['pending', 'claimed', 'processed', 'skipped', 'quarantine'].forEach(dir => {
+      fs.mkdirSync(path.join(this.inboxRoot, dir), { recursive: true });
+    });
+  }
+
+  _gitAddAndCommit(filePath, message) {
+    try {
+      execSync(`git add "${filePath}"`, { stdio: 'ignore' });
+      execSync(`git commit -m "${message}"`, { stdio: 'ignore' });
+    } catch (err) {
+      // It's okay if commit fails because of no changes
+    }
+  }
+
+  async enqueue(entry) {
+    const ts = timestamp();
+    const slug = slugify(path.basename(entry.intake.sourcePath, path.extname(entry.intake.sourcePath)));
+    const id = `${ts}-${slug}`;
+    const triage = entry.triage || {};
+
+    const quarantineDecision = shouldQuarantine(triage);
+    const subDir = quarantineDecision.quarantine ? 'quarantine' : 'pending';
+    const filePath = path.join(this.inboxRoot, subDir, `${id}.json`);
+
+    const data = {
+      id,
+      project: this.project,
+      status: subDir === 'quarantine' ? 'quarantined' : 'pending',
+      createdAt: new Date().toISOString(),
+      ...entry
+    };
+
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+    this._gitAddAndCommit(filePath, `Enqueue task ${id}`);
+
+    return { id, route: subDir === 'quarantine' ? 'quarantine' : 'pending', reason: quarantineDecision.reason };
+  }
+
+  async listPending({ limit = 100 } = {}) {
+    const pendingDir = path.join(this.inboxRoot, 'pending');
+    return fs.readdirSync(pendingDir)
+      .filter(f => f.endsWith('.json'))
+      .slice(0, limit)
+      .map(f => JSON.parse(fs.readFileSync(path.join(pendingDir, f), 'utf8')));
+  }
+
+  async count() {
+    const pendingDir = path.join(this.inboxRoot, 'pending');
+    return fs.readdirSync(pendingDir).filter(f => f.endsWith('.json')).length;
+  }
+
+  async read(id) {
+    for (const dir of ['pending', 'claimed', 'processed', 'skipped', 'quarantine']) {
+      // Note: 'claimed' has subdirs, we'd need to search recursively for claimed.
+      // For simplicity in this implementation, we assume we know where it is or search pending first.
+      const searchPath = dir === 'claimed' 
+        ? path.join(this.inboxRoot, dir) // needs recursive search
+        : path.join(this.inboxRoot, dir, `${id}.json`);
+      
+      if (dir !== 'claimed' && fs.existsSync(searchPath)) {
+        return JSON.parse(fs.readFileSync(searchPath, 'utf8'));
+      }
+    }
+    return null;
+  }
+
+  async claim({ claimedBy }) {
+    if (!claimedBy) throw new Error('claim: claimedBy is required');
+    
+    // 1. Pull latest to minimize conflicts
+    try { execSync('git pull --rebase', { stdio: 'ignore' }); } catch (e) {}
+
+    const pendingDir = path.join(this.inboxRoot, 'pending');
+    const files = fs.readdirSync(pendingDir).filter(f => f.endsWith('.json')).sort();
+    
+    if (files.length === 0) return null;
+
+    const fileName = files[0];
+    const pendingPath = path.join(pendingDir, fileName);
+    const workerDir = path.join(this.inboxRoot, 'claimed', claimedBy);
+    fs.mkdirSync(workerDir, { recursive: true });
+    const claimedPath = path.join(workerDir, fileName);
+
+    try {
+      // Atomic move on filesystem
+      fs.renameSync(pendingPath, claimedPath);
+      
+      // Update metadata
+      const data = JSON.parse(fs.readFileSync(claimedPath, 'utf8'));
+      data.status = 'claimed';
+      data.claimedBy = claimedBy;
+      data.claimedAt = new Date().toISOString();
+      fs.writeFileSync(claimedPath, JSON.stringify(data, null, 2));
+
+      // 2. Commit and Push
+      execSync(`git add .cx/team-inbox/pending/${fileName} .cx/team-inbox/claimed/${claimedBy}/${fileName}`, { stdio: 'ignore' });
+      execSync(`git commit -m "Claim task ${data.id} by ${claimedBy}"`, { stdio: 'ignore' });
+      execSync('git push', { stdio: 'ignore' });
+
+      return data;
+    } catch (err) {
+      // If push fails, someone else probably claimed it first or Git is out of sync.
+      // We should ideally rollback the local move, but for this first pass
+      // we'll let the next 'git pull --rebase' fix the state.
+      console.error(`Failed to claim ${fileName}: ${err.message}`);
+      return null;
+    }
+  }
+
+  async markProcessed(id, { processedBy = 'unknown', notes = '' } = {}) {
+    // Locate the file (might be in claimed/<worker>/<id>.json or pending/<id>.json)
+    // For simplicity, search all subdirs.
+    let foundPath = null;
+    let currentDir = null;
+
+    const dirs = ['pending', 'claimed']; // only mark as processed if pending or claimed
+    for (const d of dirs) {
+      const dirPath = path.join(this.inboxRoot, d);
+      if (d === 'claimed') {
+        const workers = fs.readdirSync(dirPath);
+        for (const w of workers) {
+          const p = path.join(dirPath, w, `${id}.json`);
+          if (fs.existsSync(p)) { foundPath = p; currentDir = path.join(d, w); break; }
+        }
+      } else {
+        const p = path.join(dirPath, `${id}.json`);
+        if (fs.existsSync(p)) { foundPath = p; currentDir = d; break; }
+      }
+      if (foundPath) break;
+    }
+
+    if (!foundPath) throw new Error(`markProcessed: no entry ${id} found`);
+
+    const data = JSON.parse(fs.readFileSync(foundPath, 'utf8'));
+    data.status = 'processed';
+    data.processedBy = processedBy;
+    data.processedAt = new Date().toISOString();
+    data.notes = notes;
+
+    const processedPath = path.join(this.inboxRoot, 'processed', `${id}.json`);
+    fs.renameSync(foundPath, processedPath);
+    fs.writeFileSync(processedPath, JSON.stringify(data, null, 2));
+
+    this._gitAddAndCommit(this.inboxRoot, `Mark task ${id} as processed`);
+    try { execSync('git push', { stdio: 'ignore' }); } catch (e) {}
+
+    return { id };
+  }
+
+  // markSkipped and reopen would follow similar logic...
+}

package/lib/intake/queue.mjs

@@ -36,11 +36,10 @@
 import path from 'node:path';
 
 import { FilesystemIntakeQueue, queueRoot, pendingDir, processedDir, skippedDir } from './filesystem-queue.mjs';
-import { PostgresIntakeQueue } from './postgres-queue.mjs';
+import { GitIntakeQueue } from './git-queue.mjs';
 import { getDeploymentMode } from '../deployment-mode.mjs';
-import { createSqlClient } from '../storage/backend.mjs';
 
-export { FilesystemIntakeQueue, PostgresIntakeQueue, queueRoot, pendingDir, processedDir, skippedDir };
+export { FilesystemIntakeQueue, GitIntakeQueue, queueRoot, pendingDir, processedDir, skippedDir };
 
 export const INTAKE_QUEUE_BACKEND_ENV_KEY = 'CONSTRUCT_INTAKE_QUEUE_BACKEND';
 export const INTAKE_PROJECT_ENV_KEY = 'CONSTRUCT_PROJECT_NAME';
@@ -48,9 +47,9 @@ export const INTAKE_TENANT_ENV_KEY = 'CONSTRUCT_TENANT_ID';
 
 function resolveBackend(env) {
   const override = env?.[INTAKE_QUEUE_BACKEND_ENV_KEY];
-  if (override === 'filesystem' || override === 'postgres') return override;
+  if (override === 'filesystem' || override === 'git') return override;
   const mode = getDeploymentMode(env);
-  return mode === 'solo' ? 'filesystem' : 'postgres';
+  return mode === 'solo' ? 'filesystem' : 'git';
 }
 
 function resolveProject(rootDir, env) {
@@ -62,22 +61,16 @@ function resolveProject(rootDir, env) {
 /**
  * Create an IntakeQueue instance for the given project root.
  * Backend selection: CONSTRUCT_INTAKE_QUEUE_BACKEND override wins; otherwise
- * solo mode → filesystem, team/enterprise → postgres. The postgres
- * backend pulls its connection from createSqlClient(env) and uses
- * CONSTRUCT_PROJECT_NAME / CONSTRUCT_TENANT_ID to scope queries; an
- * explicit `sql` and `project` in opts override both.
+ * solo mode → filesystem, team/enterprise → git. The git
+ * backend uses the filesystem and git for state synchronization.
  */
 export function createIntakeQueue(rootDir, env = process.env, opts = {}) {
   const backend = opts.backend || resolveBackend(env);
   if (backend === 'filesystem') return new FilesystemIntakeQueue(rootDir);
-  if (backend === 'postgres') {
-    const sql = opts.sql ?? createSqlClient(env);
-    if (!sql) {
-      throw new Error('Postgres intake queue requires a configured DATABASE_URL (or sql client). Run `construct init` or set CONSTRUCT_INTAKE_QUEUE_BACKEND=filesystem.');
-    }
+  if (backend === 'git' || backend === 'postgres') {
+    // We treat 'postgres' as an alias for 'git' now to avoid breaking existing configs
     const project = opts.project ?? resolveProject(rootDir, env);
-    const tenantId = opts.tenantId ?? env?.[INTAKE_TENANT_ENV_KEY] ?? null;
-    return new PostgresIntakeQueue({ sql, project, tenantId });
+    return new GitIntakeQueue({ project, rootDir });
   }
   throw new Error(`Unknown intake queue backend: ${backend}`);
 }

package/lib/logging/rotate.mjs

@@ -222,6 +222,24 @@ export const LIMITS = {
     envOverride: 'CONSTRUCT_SKILL_CALLS_MAX_MB',
   },
 
+  // Per-hook fire/block/error telemetry. ~/.cx/hook-calls.jsonl.
+
+  'hook-calls': {
+    maxBytes: 25 * 1024 * 1024,
+    maxSegments: 4,
+    gzip: true,
+    envOverride: 'CONSTRUCT_HOOK_CALLS_MAX_MB',
+  },
+
+  // Legacy-lock fallback firings on the beads write path. ~/.cx/beads-fallback.jsonl.
+
+  'beads-fallback': {
+    maxBytes: 5 * 1024 * 1024,
+    maxSegments: 2,
+    gzip: true,
+    envOverride: 'CONSTRUCT_BEADS_FALLBACK_MAX_MB',
+  },
+
   // Agent-dispatch log written by `lib/hooks/agent-tracker.mjs`. Path: ~/.cx/agent-log.jsonl.
 
   'agent-log': {

package/lib/mcp/server.mjs

@@ -118,8 +118,12 @@ server.setRequestHandler(ReadResourceRequestSchema, async (req) => {
   };
 });
 
-server.setRequestHandler(ListToolsRequestSchema, async () => ({
-  tools: [
+// The full construct-mcp tool catalog. Only a curated core is exposed flat in
+// ListTools; the long tail is reachable through the construct_call meta-tool, so
+// the serialized tool surface stays small on every host and model. The 71-tool
+// flat surface alone (~10.6k tokens) overran a 32k local-model window.
+
+const ALL_TOOL_DEFS = [
     {
       name: 'agent_health',
       description: 'Returns agent health summaries from the most recent performance review.',
@@ -1209,17 +1213,60 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         },
       },
     },
-  ],
-}));
+];
 
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-  const { name, arguments: args = {} } = request.params;
+// Curated flat core: high-frequency, low-arg tools the orchestrator and the
+// built-in Build/Plan agents actually reach for. Everything else collapses
+// behind construct_call so the schema stays small. Universal — applies on every
+// host/model; the long tail is reachable, just not front-loaded.
+
+const CORE_TOOL_NAMES = new Set([
+  'orchestration_policy', 'get_skill', 'search_skills', 'knowledge_search',
+  'memory_search', 'project_context', 'summarize_diff',
+]);
+
+function firstSentence(text) {
+  const s = String(text || '').replace(/\s+/g, ' ').trim();
+  const end = s.search(/\.(\s|$)/);
+  return (end > 0 ? s.slice(0, end) : s).slice(0, 140);
+}
+
+const LONG_TAIL_DEFS = ALL_TOOL_DEFS.filter((t) => !CORE_TOOL_NAMES.has(t.name));
+
+// One dispatcher for the long tail. `tool` is constrained to an enum of valid
+// names (≈1 token each — kills hallucinated names, the key small-model lever),
+// and the description carries a compact one-line catalog instead of ~10k of full
+// schemas. Dispatch reuses the same handlers via dispatchToolByName.
+
+const CONSTRUCT_CALL_TOOL = {
+  name: 'construct_call',
+  description:
+    'Invoke any non-core Construct tool by name. Put the tool name in `tool` and its arguments in `args`. '
+    + 'Available tools:\n'
+    + LONG_TAIL_DEFS.map((t) => `- ${t.name} — ${firstSentence(t.description)}`).join('\n'),
+  inputSchema: {
+    type: 'object',
+    properties: {
+      tool: { type: 'string', enum: LONG_TAIL_DEFS.map((t) => t.name), description: 'The Construct tool to invoke.' },
+      args: { type: 'object', additionalProperties: true, description: 'Arguments object for the tool.' },
+    },
+    required: ['tool'],
+  },
+};
+
+export function exposedTools() {
+  return [...ALL_TOOL_DEFS.filter((t) => CORE_TOOL_NAMES.has(t.name)), CONSTRUCT_CALL_TOOL];
+}
 
-  // Extract W3C traceparent from params._meta (SEP-414 propagation).
-  const parentCtx = await extractTraceContext(request.params?._meta || {});
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: exposedTools() }));
 
+// Single dispatch table shared by the direct CallTool path and the construct_call
+// meta-tool, so collapsing the surface costs no capability — every tool stays
+// reachable by name. construct_call re-enters here once (guarded against
+// recursing into itself).
+
+export async function dispatchToolByName(name, args = {}) {
   let result;
-  try {
     if (name === 'agent_health') result = agentHealth(args);
     else if (name === 'summarize_diff') result = summarizeDiff(args);
     else if (name === 'scan_file') result = scanFile(args);
@@ -1301,13 +1348,65 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     else if (name === 'construct_execution_resolve') result = executionResolve(args);
     else if (name === 'orchestration_run') { const m = await import('./tools/orchestration-run.mjs'); result = await m.orchestrationRun(args); }
     else if (name === 'orchestration_status') { const m = await import('./tools/orchestration-run.mjs'); result = await m.orchestrationStatus(args); }
+    else if (name === 'construct_call') {
+      const inner = String(args?.tool || '');
+      if (!inner || inner === 'construct_call') result = { error: "construct_call requires a 'tool' name (not 'construct_call')" };
+      else result = await dispatchToolByName(inner, args?.args || {});
+    }
     else result = { error: `Unknown tool: ${name}` };
-  } catch (err) {
-    result = { error: err.message ?? String(err) };
+  return result;
+}
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args = {} } = request.params;
+
+  // Extract W3C traceparent from params._meta (SEP-414 propagation). Tracing
+  // must never break dispatch — a malformed _meta should not fail the call.
+  let parentCtx = {};
+  try { parentCtx = await extractTraceContext(request.params?._meta || {}); } catch { /* tracing optional */ }
+  void parentCtx;
+
+  // Bound every tool call. A tool that stalls (a stuck external extractor, a slow
+  // model load, a wedged subprocess) must surface a clean timeout error to the
+  // client rather than block the request until the client gives up and reports an
+  // opaque failure. Override with CONSTRUCT_MCP_TOOL_TIMEOUT_MS (0 disables).
+  const TOOL_TIMEOUT_MS = (() => {
+    const raw = Number(process.env.CONSTRUCT_MCP_TOOL_TIMEOUT_MS);
+    return Number.isFinite(raw) && raw >= 0 ? raw : 120_000;
+  })();
+
+  const dispatch = (async () => {
+    let result;
+    try {
+      result = await dispatchToolByName(name, args);
+    } catch (err) {
+      result = { error: err.message ?? String(err) };
+    }
+    return result;
+  })();
+
+  let toolResult;
+  if (!TOOL_TIMEOUT_MS) {
+    toolResult = await dispatch;
+  } else {
+    let timer;
+    const timeout = new Promise((_, reject) => {
+      timer = setTimeout(
+        () => reject(new Error(`tool ${name} timed out after ${Math.round(TOOL_TIMEOUT_MS / 1000)}s`)),
+        TOOL_TIMEOUT_MS,
+      );
+    });
+    try {
+      toolResult = await Promise.race([dispatch, timeout]);
+    } catch (err) {
+      toolResult = { error: err.message ?? String(err) };
+    } finally {
+      clearTimeout(timer);
+    }
   }
 
   return {
-    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    content: [{ type: 'text', text: JSON.stringify(toolResult, null, 2) }],
   };
 });
 
@@ -1333,6 +1432,19 @@ export {
 const argv1Real = (() => { try { return realpathSync(process.argv[1]); } catch { return process.argv[1]; } })();
 if (fileURLToPath(import.meta.url) === argv1Real) {
   console.error('[construct-mcp] server started');
+
+  // A long-running stdio server must survive a single malformed request: a
+  // background rejection from one ingest (e.g. a broken docling sidecar that
+  // settles late) must not terminate the process and close the client
+  // connection. Log loudly and keep serving instead of crashing. Scoped to the
+  // server entry so importing this module never installs global handlers.
+  process.on('unhandledRejection', (reason) => {
+    console.error('[construct-mcp] unhandledRejection (kept alive):', reason instanceof Error ? reason.stack : reason);
+  });
+  process.on('uncaughtException', (err) => {
+    console.error('[construct-mcp] uncaughtException (kept alive):', err?.stack || err);
+  });
+
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }

package/lib/mcp/tool-budget.mjs

@@ -0,0 +1,53 @@
+/**
+ * lib/mcp/tool-budget.mjs — tool-surface sizing for the OpenCode integration.
+ *
+ * OpenCode 1.15.4 exposes no per-session tool filter (chat.params carries only
+ * sampler params, and tool.definition cannot remove a tool or see the model), so
+ * the serialized tool surface is fixed by two config/server-time levers:
+ *   1. construct-mcp's ListTools — a lean core + the construct_call gateway.
+ *   2. which external MCP servers are `enabled` in opencode.json — sync disables
+ *      the heavy ones for local-capable setups (they cannot be trimmed at runtime).
+ * Holds the shared token-sizing helper and the external-server id list both
+ * levers reason about.
+ */
+
+const TOKENS_PER_CHAR = 0.25;
+
+// Heavy external MCP servers Construct registers globally. On a local-capable
+// setup these alone serialize ~12k tokens into every agent's window (including
+// the built-in Build/Plan agents) and cannot be filtered per request, so sync
+// disables them in opencode.json. construct-mcp's own knowledge_search /
+// memory_search cover the search/memory cases.
+
+export const HEAVY_EXTERNAL_MCP_IDS = ['context7', 'github', 'memory', 'sequential-thinking', 'playwright'];
+
+export const LOCAL_SURFACE_MODES = ['auto', 'on', 'off'];
+
+// A model benefits from trimming only when it is a small-context local runtime
+// reached over Ollama/localhost. github-copilot is a hosted, full-context proxy,
+// so it is deliberately not "local" here even though it is provider-local.
+
+export function isLocalModel(model) {
+  const m = (model || "").toLowerCase();
+  return m.includes("ollama") || m.includes("localhost") || m.includes("127.0.0.1");
+}
+
+// Decide whether to disable the heavy external MCP servers for one opencode.json.
+// Trimming is driven by INTENT — the default model this config actually selects —
+// not by whether the machine happens to have Ollama installed. Machine-wide
+// presence stripped context7/github from cloud sessions that merely shared a box
+// with Ollama; keying off the config's own default model preserves cloud surfaces
+// and still shrinks the window when the user has chosen a local model.
+//   surface: 'on' (always trim) | 'off' (never) | 'auto' (trim iff default is local)
+
+export function decideTrim({ surface = 'auto', defaultModel = null } = {}) {
+  if (surface === 'off') return false;
+  if (surface === 'on') return true;
+  return isLocalModel(defaultModel);
+}
+
+export function estimateToolTokens(tools) {
+  if (!tools) return 0;
+  const arr = Array.isArray(tools) ? tools : Object.values(tools);
+  return Math.round(JSON.stringify(arr).length * TOKENS_PER_CHAR);
+}

package/lib/mcp/tools/storage.mjs

@@ -37,14 +37,13 @@ export async function storageReset(args) {
   return resetStorage(cwd, {
     env: process.env,
     project,
-    resetSql: args.reset_sql !== false,
     resetVector: args.reset_vector !== false,
     resetIngested: args.reset_ingested === true,
     confirm: true,
   });
 }
 
-export function deleteIngestedArtifactsTool(args) {
+export async function deleteIngestedArtifactsTool(args) {
   const cwd = args.cwd ? resolve(String(args.cwd)) : process.cwd();
   if (args.confirm !== true) {
     return { error: 'delete_ingested_artifacts requires confirm=true' };
@@ -53,7 +52,7 @@ export function deleteIngestedArtifactsTool(args) {
     ? args.files.map((value) => String(value))
     : [];
   try {
-    return deleteIngestedArtifacts(cwd, { files, confirm: true });
+    return await deleteIngestedArtifacts(cwd, { files, confirm: true });
   } catch (error) {
     return { error: error.message ?? String(error) };
   }

package/lib/mcp-catalog.json

@@ -29,7 +29,7 @@
     {
       "id": "sequential-thinking",
       "name": "Sequential Thinking",
-      "category": "core",
+      "category": "optional",
       "description": "Structured multi-step reasoning chains. Helps with complex planning and analysis.",
       "package": "@modelcontextprotocol/server-sequential-thinking",
       "command": "npx",
@@ -85,12 +85,12 @@
       "id": "playwright",
       "name": "Playwright",
       "category": "optional",
-      "description": "Browser automation for E2E testing and web research.",
-      "package": "@playwright/mcp@latest",
+      "description": "Browser automation for E2E testing and web research. Opt-in via `construct mcp add playwright` — not synced by default (downloads browser binaries on first use).",
+      "package": "@playwright/mcp@0.0.75",
       "command": "npx",
       "args": [
         "-y",
-        "@playwright/mcp@latest"
+        "@playwright/mcp@0.0.75"
       ],
       "env": {},
       "requiredEnv": [],

package/lib/mcp-manager.mjs

@@ -33,6 +33,56 @@ function getClaudeSettingsPath() {
   return join(homedir(), '.claude', 'settings.json');
 }
 
+// VS Code's "MCP: Open User Configuration" edits a per-profile mcp.json keyed
+// on top-level `servers`; Cursor uses ~/.cursor/mcp.json keyed on `mcpServers`.
+// construct sync writes both surfaces, so remove must clean them too or a
+// removed MCP lingers there.
+
+function getVSCodeUserMcpPaths(home = homedir()) {
+  const plat = platform();
+  if (plat === 'darwin') {
+    return [
+      join(home, 'Library', 'Application Support', 'Code', 'User', 'mcp.json'),
+      join(home, 'Library', 'Application Support', 'Code - Insiders', 'User', 'mcp.json'),
+    ];
+  }
+  if (plat === 'win32') {
+    const appData = process.env.APPDATA ?? join(home, 'AppData', 'Roaming');
+    return [join(appData, 'Code', 'User', 'mcp.json'), join(appData, 'Code - Insiders', 'User', 'mcp.json')];
+  }
+  return [
+    join(home, '.config', 'Code', 'User', 'mcp.json'),
+    join(home, '.config', 'Code - Insiders', 'User', 'mcp.json'),
+  ];
+}
+
+function getCursorMcpPath(home = homedir()) {
+  return join(home, '.cursor', 'mcp.json');
+}
+
+function mcpFileHasEntry(file, key, id) {
+  if (!existsSync(file)) return false;
+  try {
+    return Boolean(JSON.parse(readFileSync(file, 'utf8'))?.[key]?.[id]);
+  } catch {
+    return false;
+  }
+}
+
+function removeMcpFromJsonFile(file, key, id) {
+  if (!existsSync(file)) return false;
+  let config;
+  try {
+    config = JSON.parse(readFileSync(file, 'utf8'));
+  } catch {
+    return false;
+  }
+  if (!config?.[key] || !(id in config[key])) return false;
+  delete config[key][id];
+  writeFileSync(file, JSON.stringify(config, null, 2) + '\n');
+  return true;
+}
+
 function openUrl(url) {
   try {
     const opener = platform() === 'darwin' ? 'open' : platform() === 'win32' ? 'start' : 'xdg-open';
@@ -426,10 +476,14 @@ export function cmdMcpRemove(id) {
   const openCodeState = readOpenCodeConfig();
   const oc = openCodeState.config ?? {};
   const openCodeId = getOpenCodeMcpId(id);
+  const vscodePaths = getVSCodeUserMcpPaths();
+  const cursorPath = getCursorMcpPath();
   const hasClaudeEntry = Boolean(settings.mcpServers?.[id]);
   const hasOpenCodeEntry = Boolean(oc.mcp?.[openCodeId] || oc.mcp?.[id] || (id === 'memory' && oc.mcp?.cass));
   const hasCodexEntry = readCodexConfig().includes(`[mcp_servers.${id}]`) || readCodexConfig().includes(`[mcp_servers.${tomlString(id)}]`);
-  if (!hasClaudeEntry && !hasOpenCodeEntry && !hasCodexEntry) {
+  const hasVscodeEntry = vscodePaths.some((p) => mcpFileHasEntry(p, 'servers', id));
+  const hasCursorEntry = mcpFileHasEntry(cursorPath, 'mcpServers', id);
+  if (!hasClaudeEntry && !hasOpenCodeEntry && !hasCodexEntry && !hasVscodeEntry && !hasCursorEntry) {
     console.log(`${id} is not installed. Nothing to remove.`);
     return;
   }
@@ -448,9 +502,11 @@ export function cmdMcpRemove(id) {
   if (openCodeState.config || hasOpenCodeEntry) saveOpenCodeConfig(oc);
   else if (openCodeState.file && existsSync(openCodeState.file)) rmSync(openCodeState.file, { force: true });
   removeCodexMcp(id);
+  for (const p of vscodePaths) removeMcpFromJsonFile(p, 'servers', id);
+  removeMcpFromJsonFile(cursorPath, 'mcpServers', id);
 
-  console.log(`✓ ${name} removed from Claude Code, OpenCode, and Codex config`);
-  console.log('Restart Claude Code, OpenCode, or Codex to deactivate it.');
+  console.log(`✓ ${name} removed from Claude Code, OpenCode, Codex, VS Code, and Cursor config`);
+  console.log('Restart the editor to deactivate it.');
 }
 
 /**