@geraldmaron/construct 1.0.21 → 1.0.24

package/lib/mcp/tools/memory.mjs

@@ -56,13 +56,13 @@ export async function memorySearch(args) {
   };
 }
 
-export function memoryAddObservations(args) {
+export async function memoryAddObservations(args) {
   const cwd = args.cwd ? resolve(String(args.cwd)) : process.cwd();
   const project = args.project || cwd.split('/').pop() || 'unknown';
   const observations = (args.observations || []).slice(0, 10);
   const created = [];
   for (const obs of observations) {
-    const record = addObservation(cwd, {
+    const record = await addObservation(cwd, {
       role: obs.role || 'unknown',
       category: obs.category || 'insight',
       summary: obs.summary || '',

package/lib/mcp/tools/orchestration-run.mjs

@@ -0,0 +1,125 @@
+/**
+ * lib/mcp/tools/orchestration-run.mjs — MCP client for the local orchestration daemon.
+ *
+ * Executes a real multi-specialist run by driving the daemon's HTTP API
+ * (ADR-0022), so MCP hosts with no subagent primitive — VS Code/Copilot, Cursor —
+ * reach orchestrated outcomes through a tool they actually expose: the engine
+ * owns orchestration; this tool is the thin client. The daemon URL resolves from
+ * dashboard state (else the default loopback port) and the bearer token from
+ * ~/.construct/config.env. When the daemon is unreachable the tool fails fast
+ * with an actionable error rather than silently degrading to a single-persona
+ * pass — the absence of an executable path is made loud, not hidden.
+ */
+
+import { readDashboardState } from '../../service-manager.mjs';
+import { getDashboardToken } from '../../server/auth.mjs';
+
+const TERMINAL = ['completed', 'completed-with-failures', 'cancelled', 'error'];
+
+function resolveDaemon(env = process.env) {
+  const state = readDashboardState();
+  const base = (env.CONSTRUCT_ORCHESTRATION_URL || state?.url || `http://${env.BIND_HOST || '127.0.0.1'}:${env.PORT || '4242'}`).replace(/\/$/, '');
+  return { base, token: getDashboardToken(), daemonRunning: Boolean(state) };
+}
+
+// A reachability failure is the fail-fast signal MCP hosts need: report how to
+// start the engine instead of letting the host fall back to a manual pass.
+
+function unreachable(base, detail) {
+  return {
+    error: `Orchestration daemon not reachable at ${base}: ${detail}. Start it with \`construct dashboard\`, then retry. The engine runs orchestration; this host is a thin client (ADR-0022).`,
+    daemon: base,
+    failFast: true,
+  };
+}
+
+export async function orchestrationRun(args = {}, { fetchImpl = fetch, env = process.env } = {}) {
+  const {
+    request,
+    workflow_type,
+    requested_strategy = 'auto',
+    worker_backend,
+    host,
+    host_model,
+    host_provider,
+    file_count,
+    module_count,
+    wait = true,
+    timeout_ms = 120000,
+  } = args;
+
+  if (!request || typeof request !== 'string') return { error: 'Missing "request" string describing the work to orchestrate.' };
+
+  const { base, token } = resolveDaemon(env);
+  const headers = { 'Content-Type': 'application/json', ...(token ? { Authorization: `Bearer ${token}` } : {}) };
+  const body = JSON.stringify({
+    request,
+    workflowType: workflow_type,
+    requestedStrategy: requested_strategy,
+    workerBackend: worker_backend,
+    host,
+    hostModel: host_model,
+    hostProvider: host_provider,
+    fileCount: file_count,
+    moduleCount: module_count,
+  });
+
+  let started;
+  try {
+    const res = await fetchImpl(`${base}/api/orchestration/runs`, { method: 'POST', headers, body });
+    if (res.status === 401 || res.status === 403) {
+      return { error: `Daemon rejected the request (HTTP ${res.status}). The dashboard token is missing or wrong — check CONSTRUCT_DASHBOARD_TOKEN in ~/.construct/config.env.`, daemon: base, failFast: true };
+    }
+    const envelope = await res.json();
+    if (!res.ok) return { error: `Daemon error (HTTP ${res.status}): ${envelope.error || 'unknown'}`, daemon: base };
+    started = envelope.data;
+  } catch (err) {
+    return unreachable(base, err.message);
+  }
+
+  if (!wait) {
+    return { runId: started.runId, status: started.status, executionMode: started.execution?.executionMode, daemon: base, poll: 'orchestration_status with run_id' };
+  }
+
+  const deadline = Date.now() + timeout_ms;
+  let run = started;
+  while (!TERMINAL.includes(run.status)) {
+    if (Date.now() > deadline) {
+      return { runId: started.runId, status: run.status, timedOut: true, daemon: base, note: 'Run is still executing; poll it with orchestration_status.' };
+    }
+    await new Promise((r) => setTimeout(r, 250));
+    try {
+      const res = await fetchImpl(`${base}/api/orchestration/runs/${encodeURIComponent(started.runId)}`, { headers });
+      const envelope = await res.json();
+      if (!res.ok) return { error: `Daemon error while polling (HTTP ${res.status}): ${envelope.error || 'unknown'}`, runId: started.runId, daemon: base };
+      run = envelope.data;
+    } catch (err) {
+      return { error: `Lost connection to the daemon while polling run ${started.runId}: ${err.message}`, runId: started.runId, daemon: base, failFast: true };
+    }
+  }
+
+  return {
+    runId: run.runId,
+    status: run.status,
+    executionMode: run.execution?.executionMode,
+    degraded: run.execution?.degraded ?? false,
+    degradationReason: run.execution?.degradationReason ?? null,
+    tasks: (run.tasks || []).map((t) => ({ id: t.id, role: t.role, status: t.status, executor: t.executor, output: t.output ?? null, reasoning: t.reasoning ?? null, error: t.error ?? null })),
+    daemon: base,
+  };
+}
+
+export async function orchestrationStatus(args = {}, { fetchImpl = fetch, env = process.env } = {}) {
+  const { run_id, limit = 20 } = args;
+  const { base, token } = resolveDaemon(env);
+  const headers = token ? { Authorization: `Bearer ${token}` } : {};
+  const path = run_id ? `/api/orchestration/runs/${encodeURIComponent(run_id)}` : `/api/orchestration/runs?limit=${encodeURIComponent(limit)}`;
+  try {
+    const res = await fetchImpl(`${base}${path}`, { headers });
+    const envelope = await res.json();
+    if (!res.ok) return { error: `Daemon error (HTTP ${res.status}): ${envelope.error || 'unknown'}`, daemon: base };
+    return envelope.data;
+  } catch (err) {
+    return unreachable(base, err.message);
+  }
+}

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

@@ -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.');
 }
 
 /**

package/lib/model-registry.mjs

@@ -20,17 +20,14 @@ import path from 'node:path';
  * 1. Environment variables (CX_MODEL_*): Emergency overrides
  * 2. User config (~/.construct/config.env): Personal defaults
  * 3. Registry (specialists/registry.json): Project recommendations
- * 4. Built-in defaults: Last resort fallbacks
- * 
- * Primary resolution path. All code must use this function.
+ *
+ * Construct ships with NO implicit model defaults (ADR-0027,
+ * tests/model-router-no-defaults.test.mjs). When none of the three sources
+ * resolves a tier, that tier returns null with source 'not configured'.
+ * Callers must surface a clear remediation hint rather than silently
+ * substituting a vendor-specific default.
  */
 
-const BUILTIN_DEFAULTS = {
-  reasoning: 'anthropic/claude-3-5-sonnet',
-  standard: 'anthropic/claude-3-haiku',
-  fast: 'anthropic/claude-3-haiku',
-};
-
 const ENV_PREFIX = 'CX_MODEL';
 
 // ---------------------------------------------------------------------------
@@ -86,28 +83,30 @@ export function resolveModelTiers(options = {}) {
       }
     }
     
-    // Built-in default
-    result[tier] = BUILTIN_DEFAULTS[tier];
-    sources[tier] = 'default';
+    // No source resolved this tier — leave null + 'not configured' so callers
+    // can surface a clear remediation hint. Aligns with the wired path
+    // (lib/model-router.mjs:resolveTierAssignments) and the no-defaults
+    // contract locked in by tests/model-router-no-defaults.test.mjs.
+
+    result[tier] = null;
+    sources[tier] = 'not configured';
   }
-  
-  // Validation
+
   const configured = Object.values(result).filter(Boolean).length;
-  
+
   if (strict && configured < 3) {
     const missing = Object.entries(result)
       .filter(([, v]) => !v)
       .map(([k]) => k);
     errors.push(`Missing configuration for tiers: ${missing.join(', ')}`);
   }
-  
+
   return {
     models: result,
     sources,
     configured,
     complete: configured === 3,
     errors: errors.length > 0 ? errors : null,
-    defaultsUsed: Object.values(sources).filter(s => s === 'default').length,
   };
 }
 
@@ -117,7 +116,7 @@ export function resolveModelTiers(options = {}) {
 
 export function getModelForTier(tier, options = {}) {
   const resolved = resolveModelTiers(options);
-  return resolved.models[tier] || BUILTIN_DEFAULTS[tier];
+  return resolved.models[tier];
 }
 
 export function getModelSource(tier, options = {}) {
@@ -131,12 +130,15 @@ export function getModelSource(tier, options = {}) {
 
 export function validateModelTiers(options = {}) {
   const resolved = resolveModelTiers({ ...options, strict: true });
-  
+  const unconfigured = Object.entries(resolved.sources)
+    .filter(([, source]) => source === 'not configured')
+    .map(([tier]) => tier);
+
   return {
     valid: resolved.complete && !resolved.errors,
     errors: resolved.errors,
-    warnings: resolved.defaultsUsed > 0 
-      ? [`Using ${resolved.defaultsUsed} built-in default(s). Consider configuring custom models.`]
+    warnings: unconfigured.length > 0
+      ? [`Unconfigured tier${unconfigured.length === 1 ? '' : 's'}: ${unconfigured.join(', ')}. Run 'construct models --apply' or set CX_MODEL_<TIER>.`]
       : [],
     resolution: resolved,
   };
@@ -144,25 +146,30 @@ export function validateModelTiers(options = {}) {
 
 export function formatModelStatus(options = {}) {
   const resolved = resolveModelTiers(options);
-  
+
   let output = 'Model Configuration:\n\n';
-  
+
   for (const tier of ['reasoning', 'standard', 'fast']) {
     const model = resolved.models[tier];
     const source = resolved.sources[tier];
-    const icon = source === 'default' ? '⚠' : '✓';
-    
-    output += `${icon} ${tier.padEnd(10)} ${model}\n`;
+    const icon = source === 'not configured' ? '⚠' : '✓';
+    const display = model ?? '(not configured)';
+
+    output += `${icon} ${tier.padEnd(10)} ${display}\n`;
     output += `  Source: ${source}\n\n`;
   }
-  
-  if (resolved.defaultsUsed > 0) {
-    output += '\nNote: Using built-in defaults. To customize:\n';
-    output += '  export CX_MODEL_REASONING=your-model\n';
-    output += '  export CX_MODEL_STANDARD=your-model\n';
-    output += '  export CX_MODEL_FAST=your-model\n';
+
+  const unconfigured = Object.entries(resolved.sources)
+    .filter(([, source]) => source === 'not configured')
+    .map(([tier]) => tier);
+  if (unconfigured.length > 0) {
+    output += `\nUnconfigured: ${unconfigured.join(', ')}. To configure:\n`;
+    output += '  construct models --apply        (interactive, picks from available providers)\n';
+    output += '  export CX_MODEL_REASONING=...   (env override)\n';
+    output += '  export CX_MODEL_STANDARD=...\n';
+    output += '  export CX_MODEL_FAST=...\n';
   }
-  
+
   return output;
 }