@vcad/mcp 0.11.0-main.156 → 0.11.0-main.158

package/README.md

@@ -6,4 +6,7 @@ vcad's MCP server as a self-contained bundle (server + BRep kernel WASM).
 { "mcpServers": { "vcad": { "command": "npx", "args": ["-y", "@vcad/mcp"] } } }
 ```
 
-Built from f25f1fe6da5156d93d7d0709be48c3c434b30b85 at 2026-11-11T13:57:09.705Z. Source: https://github.com/ecto/vcad
+Or install vcad.app, which registers this server with your agents on first launch.
+The agent skill ships at `skill/SKILL.md`.
+
+Built from 7b415c4523c95991e41ee59c2aff357ff5f7205d at 2026-11-11T15:52:11.773Z. Source: https://github.com/muni-works/vcad

package/index.mjs

@@ -15178,17 +15178,17 @@ var init_parse = __esm({
       return result.issues.length === 0;
     };
     _encode = (_Err) => {
-      const parse4 = _parse(_Err);
+      const parse5 = _parse(_Err);
       const fn = (schema, value, _ctx, _params) => {
         const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-        return parse4(schema, value, ctx, finalizeParams(fn, _params));
+        return parse5(schema, value, ctx, finalizeParams(fn, _params));
       };
       return fn;
     };
     _decode = (_Err) => {
-      const parse4 = _parse(_Err);
+      const parse5 = _parse(_Err);
       const fn = (schema, value, _ctx, _params) => {
-        return parse4(schema, value, _ctx, finalizeParams(fn, _params));
+        return parse5(schema, value, _ctx, finalizeParams(fn, _params));
       };
       return fn;
     };
@@ -15802,7 +15802,7 @@ function capSize(inst, size) {
   if (!caps.length)
     return;
   const cap = Math.min(...caps.map((c) => c[0]));
-  const parse4 = inst._zod.parse;
+  const parse5 = inst._zod.parse;
   inst._zod.parse = (payload, ctx) => {
     const n = size(payload.value);
     if (n > cap && !ctx?.skipChecks && ctx?.direction !== "backward") {
@@ -15816,7 +15816,7 @@ function capSize(inst, size) {
         }
       }
     }
-    return parse4(payload, ctx);
+    return parse5(payload, ctx);
   };
 }
 function handleArrayResult(result, final, index) {
@@ -22332,8 +22332,8 @@ var init_zod_compat = __esm({
 });
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/interfaces.js
-function isTerminal(status) {
-  return status === "completed" || status === "failed" || status === "cancelled";
+function isTerminal(status2) {
+  return status2 === "completed" || status2 === "failed" || status2 === "cancelled";
 }
 var init_interfaces = __esm({
   "node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/interfaces.js"() {
@@ -23631,8 +23631,8 @@ var init_protocol = __esm({
             }
             return task;
           },
-          storeTaskResult: async (taskId, status, result) => {
-            await taskStore.storeTaskResult(taskId, status, result, sessionId);
+          storeTaskResult: async (taskId, status2, result) => {
+            await taskStore.storeTaskResult(taskId, status2, result, sessionId);
             const task = await taskStore.getTask(taskId, sessionId);
             if (task) {
               const notification = TaskStatusNotificationSchema.parse({
@@ -23648,15 +23648,15 @@ var init_protocol = __esm({
           getTaskResult: (taskId) => {
             return taskStore.getTaskResult(taskId, sessionId);
           },
-          updateTaskStatus: async (taskId, status, statusMessage) => {
+          updateTaskStatus: async (taskId, status2, statusMessage) => {
             const task = await taskStore.getTask(taskId, sessionId);
             if (!task) {
               throw new McpError(ErrorCode.InvalidParams, `Task "${taskId}" not found - it may have been cleaned up`);
             }
             if (isTerminal(task.status)) {
-              throw new McpError(ErrorCode.InvalidParams, `Cannot update task "${taskId}" from terminal status "${task.status}" to "${status}". Terminal states (completed, failed, cancelled) cannot transition to other states.`);
+              throw new McpError(ErrorCode.InvalidParams, `Cannot update task "${taskId}" from terminal status "${task.status}" to "${status2}". Terminal states (completed, failed, cancelled) cannot transition to other states.`);
             }
-            await taskStore.updateTaskStatus(taskId, status, statusMessage, sessionId);
+            await taskStore.updateTaskStatus(taskId, status2, statusMessage, sessionId);
             const updatedTask = await taskStore.getTask(taskId, sessionId);
             if (updatedTask) {
               const notification = TaskStatusNotificationSchema.parse({
@@ -27224,24 +27224,24 @@ var require_fast_uri = __commonJS({
     function normalize2(uri, options) {
       if (typeof uri === "string") {
         uri = /** @type {T} */
-        serialize(parse4(uri, options), options);
+        serialize(parse5(uri, options), options);
       } else if (typeof uri === "object") {
         uri = /** @type {T} */
-        parse4(serialize(uri, options), options);
+        parse5(serialize(uri, options), options);
       }
       return uri;
     }
     function resolve8(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
-      const resolved = resolveComponent(parse4(baseURI, schemelessOptions), parse4(relativeURI, schemelessOptions), schemelessOptions, true);
+      const resolved = resolveComponent(parse5(baseURI, schemelessOptions), parse5(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
       return serialize(resolved, schemelessOptions);
     }
     function resolveComponent(base, relative, options, skipNormalization) {
       const target = {};
       if (!skipNormalization) {
-        base = parse4(serialize(base, options), options);
-        relative = parse4(serialize(relative, options), options);
+        base = parse5(serialize(base, options), options);
+        relative = parse5(serialize(relative, options), options);
       }
       options = options || {};
       if (!options.tolerant && relative.scheme) {
@@ -27293,13 +27293,13 @@ var require_fast_uri = __commonJS({
     function equal(uriA, uriB, options) {
       if (typeof uriA === "string") {
         uriA = unescape(uriA);
-        uriA = serialize(normalizeComponentEncoding(parse4(uriA, options), true), { ...options, skipEscape: true });
+        uriA = serialize(normalizeComponentEncoding(parse5(uriA, options), true), { ...options, skipEscape: true });
       } else if (typeof uriA === "object") {
         uriA = serialize(normalizeComponentEncoding(uriA, true), { ...options, skipEscape: true });
       }
       if (typeof uriB === "string") {
         uriB = unescape(uriB);
-        uriB = serialize(normalizeComponentEncoding(parse4(uriB, options), true), { ...options, skipEscape: true });
+        uriB = serialize(normalizeComponentEncoding(parse5(uriB, options), true), { ...options, skipEscape: true });
       } else if (typeof uriB === "object") {
         uriB = serialize(normalizeComponentEncoding(uriB, true), { ...options, skipEscape: true });
       }
@@ -27368,7 +27368,7 @@ var require_fast_uri = __commonJS({
       return uriTokens.join("");
     }
     var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
-    function parse4(uri, opts) {
+    function parse5(uri, opts) {
       const options = Object.assign({}, opts);
       const parsed = {
         scheme: void 0,
@@ -27462,7 +27462,7 @@ var require_fast_uri = __commonJS({
       resolveComponent,
       equal,
       serialize,
-      parse: parse4
+      parse: parse5
     };
     module.exports = fastUri;
     module.exports.default = fastUri;
@@ -31246,10 +31246,10 @@ function diffViolations(before, after) {
   }
   return { introduced, fixed };
 }
-function blameOf(cause, status) {
-  if (status === "fixed")
+function blameOf(cause, status2) {
+  if (status2 === "fixed")
     return "credit";
-  if (status === "introduced") {
+  if (status2 === "introduced") {
     return "blame";
   }
   if (cause === "connectivity" || cause === "routing")
@@ -31270,13 +31270,13 @@ function bucketize(violations) {
   }
   return map;
 }
-function toGroup(b, status, count) {
+function toGroup(b, status2, count) {
   const cause = b.cause;
   return {
     rule: b.rep.rule,
     cause,
-    status,
-    blame: blameOf(cause, status),
+    status: status2,
+    blame: blameOf(cause, status2),
     count,
     message: b.rep.message,
     position: b.rep.position,
@@ -37182,7 +37182,7 @@ var init_chat_store = __esm({
           }
         ]
       })),
-      updateLastAssistant: (content, toolCalls, parts, status) => set((s) => {
+      updateLastAssistant: (content, toolCalls, parts, status2) => set((s) => {
         const last = s.messages[s.messages.length - 1];
         if (!last || last.role !== "assistant")
           return s;
@@ -37191,8 +37191,8 @@ var init_chat_store = __esm({
           updated.toolCalls = toolCalls;
         if (parts !== void 0)
           updated.parts = parts;
-        if (status !== void 0)
-          updated.status = status;
+        if (status2 !== void 0)
+          updated.status = status2;
         return { messages: [...s.messages.slice(0, -1), updated] };
       }),
       sendMessage: (content, context, attachments) => {
@@ -44759,6 +44759,98 @@ var init_CHANGELOG = __esm({
     CHANGELOG_default = {
       $schema: "./changelog.schema.json",
       entries: [
+        {
+          id: "2026-11-11-vcad-mcp-rust-core",
+          version: "0.11.0",
+          date: "2026-11-11",
+          category: "feat",
+          title: "`vcad mcp`: native Rust MCP server",
+          summary: "New `vcad mcp` runs one Rust MCP core (2026-07-28 and legacy eras) over stdio, loopback HTTP or a unix socket. Core tools run natively; others proxy to the node server.",
+          features: [
+            "mcp",
+            "cli"
+          ],
+          mcpTools: [
+            "server_info",
+            "open_document",
+            "get_document",
+            "close_document",
+            "create_cad_loon",
+            "load_document",
+            "inspect_cad",
+            "render_view",
+            "export_cad"
+          ]
+        },
+        {
+          id: "2026-11-11-one-breath-install",
+          version: "0.11.0",
+          date: "2026-11-11",
+          category: "feat",
+          title: "One-breath agent install + stale-server warning",
+          summary: "vcad.app connects Claude Code, Claude Desktop, Codex and Cursor in one consent dialog (undo in Settings); a new bundled skill; the MCP server warns when it's older than npm latest.",
+          features: [
+            "mcp",
+            "mac-app",
+            "skill"
+          ],
+          mcpTools: [
+            "server_info"
+          ]
+        },
+        {
+          id: "2026-11-11-live-receipt-badges",
+          version: "0.11.0",
+          date: "2026-11-11",
+          category: "feat",
+          title: "Live receipt badges and in-viewport agent questions",
+          summary: 'Clearance claims re-verify on every edit as green/gray/red badges in the Mac app; agents ask "which edge?" and confirms answered by clicking in the viewport.',
+          features: [
+            "receipts",
+            "mcp",
+            "elicitation",
+            "native-app"
+          ],
+          mcpTools: [
+            "assert_clearance",
+            "verify_receipts",
+            "accept_receipts",
+            "pick_in_viewport",
+            "ask_user"
+          ]
+        },
+        {
+          id: "2026-11-11-counterbore-breakout",
+          version: "0.11.0",
+          date: "2026-11-11",
+          category: "fix",
+          title: "Counterbores breaking into a bore cut correctly",
+          summary: "A counterbore or hole breaking out into a parallel bore was silently dropped or left an open mesh away from the origin; it now cuts analytically and closed.",
+          features: [
+            "booleans",
+            "kernel"
+          ]
+        },
+        {
+          id: "2026-11-11-agent-cursor",
+          version: "0.11.0",
+          date: "2026-11-11",
+          category: "feat",
+          title: "Agent cursor in the Mac app",
+          summary: "Agents see your selection through MCP resources, a labeled cursor shows where they edit, and each agent turn is one named undo step.",
+          features: [
+            "mcp",
+            "native-app",
+            "agent"
+          ],
+          mcpTools: [
+            "agent_turn",
+            "fillet_edges",
+            "select_edges",
+            "viewer_frame",
+            "open_in_app"
+          ]
+        },
         {
           id: "2026-11-10-window-drag-no-orbit",
           version: "0.11.0",
@@ -57130,15 +57222,15 @@ async function reconcileBeforeWrite(documentId, documents2, call = callApp) {
   const link = links.get(documentId);
   if (!link?.shown || link.viewOnly) return null;
   if (pushes.get(documentId)?.running) return null;
-  const status = await Promise.race([
+  const status2 = await Promise.race([
     call("link_status", { link_id: documentId }),
     wait(RECONCILE_WAIT_MS).then(() => null)
   ]);
-  if (status?.linked === false) {
+  if (status2?.linked === false) {
     loseWindow(documentId, LOST_WINDOW);
     return null;
   }
-  if (!status?.linked || !status.edited) return null;
+  if (!status2?.linked || !status2.edited) return null;
   const pulled = await call("link_status", { link_id: documentId, pull: true });
   if (!pulled?.document) return null;
   const document = pulled.document;
@@ -57568,9 +57660,9 @@ async function saveDocument(args, store) {
   if (savesToFiles(store)) {
     const path = resolveWithinRoot(`${name}.vcad`, stateRoot());
     writeFileSync2(path, JSON.stringify(doc));
-    const status = sourceStatus(doc);
+    const status2 = sourceStatus(doc);
     let sourcePath;
-    if (doc.source && !status.source_stale) {
+    if (doc.source && !status2.source_stale) {
       sourcePath = resolveWithinRoot(`${name}.loon`, stateRoot());
       writeFileSync2(sourcePath, doc.source.text);
       doc.source.path = sourcePath;
@@ -57584,8 +57676,8 @@ async function saveDocument(args, store) {
             name,
             path,
             ...sourcePath ? { source_path: sourcePath } : {},
-            ...doc.source && status.source_stale ? {
-              source_not_written: `${status.reason} The .loon was NOT written \u2014 it would not reproduce this document. The .vcad IR is the source of truth.`
+            ...doc.source && status2.source_stale ? {
+              source_not_written: `${status2.reason} The .loon was NOT written \u2014 it would not reproduce this document. The .vcad IR is the source of truth.`
             } : {}
           })
         }
@@ -57616,7 +57708,7 @@ async function saveDocument(args, store) {
           store.scope === "user" ? {
             saved: true,
             name: slug,
-            hint: `Saved durably to your account \u2014 reopen anytime with load_document({name: "${slug}"}). It also appears in your documents at vcad.io.`
+            hint: `Saved durably to your account \u2014 reopen anytime with load_document({name: "${slug}"}).`
           } : {
             saved: true,
             name: key3,
@@ -57878,7 +57970,7 @@ var init_session2 = __esm({
       {
         name: "save_document",
         pack: null,
-        description: "Persist a live session under a name so it can be reopened with load_document. On the hosted server the save is durable: a signed-in user's save goes to their vcad.io account under the (normalized) name; an anonymous save returns an unguessable `saved_\u2026` key to reopen with. On a local/stdio server it writes `<name>.vcad` under VCAD_MCP_STATE_DIR (or the working directory) \u2014 plus `<name>.loon` when the document knows the source it was authored from, so the file and the session can't diverge without someone choosing it.",
+        description: "Persist a live session under a name so it can be reopened with load_document. It writes `<name>.vcad` under VCAD_MCP_STATE_DIR (or the working directory) \u2014 plus `<name>.loon` when the document knows the source it was authored from, so the file and the session can't diverge without someone choosing it.",
         inputSchema: saveDocumentSchema,
         handler: (a, c) => saveDocument(a, c.sessionStore),
         behavior: behavior({})
@@ -59152,7 +59244,7 @@ async function getPreviewGlb(doc, engine, instances = false) {
             _vcad_glb: null,
             version: preview.version,
             error: "preview_too_large",
-            detail: `Model too large for inline preview (${mb} MB of GLB, budget ${(PREVIEW_MAX_BASE64 / 1e6).toFixed(1)} MB) \u2014 open it in vcad.io or use export_cad for the full geometry.`
+            detail: `Model too large for inline preview (${mb} MB of GLB, budget ${(PREVIEW_MAX_BASE64 / 1e6).toFixed(1)} MB) \u2014 open it in the vcad app (open_in_app) or use export_cad for the full geometry.`
           })
         }
       ]
@@ -59309,10 +59401,10 @@ var init_store = __esm({
       async getAuthorization(id, userId) {
         return memAuthz.get(memKey(userId, id)) ?? null;
       }
-      async setAuthorizationStatus(id, userId, status) {
+      async setAuthorizationStatus(id, userId, status2) {
         const a = memAuthz.get(memKey(userId, id));
         if (!a) return;
-        memAuthz.set(memKey(userId, id), { ...a, status });
+        memAuthz.set(memKey(userId, id), { ...a, status: status2 });
       }
       /**
        * Local mirror of the debit_wallet RPC contract — enough to exercise the
@@ -61448,8 +61540,8 @@ function pruneTasks() {
     }
   }
 }
-function touchTask(t2, status, message) {
-  if (status) t2.status = status;
+function touchTask(t2, status2, message) {
+  if (status2) t2.status = status2;
   if (message !== void 0) t2.statusMessage = message;
   t2.lastUpdatedAt = (/* @__PURE__ */ new Date()).toISOString();
   bus.emit(EVT_TASK, detailedTask(t2));
@@ -63005,7 +63097,7 @@ var init_continue_doc = __esm({
       properties: {
         token: {
           type: "string",
-          description: "Legacy vcad.io share token. Not available in the local build (hosted services were retired) \u2014 returns an error; use `doc`."
+          description: "Legacy hosted share token. Not available in the local build (hosted services were retired) \u2014 returns an error; use `doc`."
         },
         doc: {
           type: "string",
@@ -64689,7 +64781,7 @@ var init_part_stock = __esm({
     LCSC_RE = /^C\d{2,}$/i;
     JLC_SEARCH_URL = "https://jlcpcb.com/api/overseas-pcb-order/v1/shoppingCart/smtGood/selectSmtComponentList";
     LCSC_DETAIL_URL = "https://wmsc.lcsc.com/ftps/wm/product/detail?productCode=";
-    UA = "vcad-mcp parts-stock (+https://vcad.io)";
+    UA = "vcad-mcp parts-stock (+https://github.com/muni-works/vcad)";
     PartStockClient = class {
       fetchImpl;
       now;
@@ -68212,8 +68304,8 @@ function verifyClearanceClaims(doc, engine, receipt) {
       checks.push({ ...common, status: "Holds" });
     }
   }
-  const status = checks.some((c) => c.status === "Violated") ? "Violated" : checks.some((c) => c.status === "Stale") ? "Stale" : "Holds";
-  return { status, checks };
+  const status2 = checks.some((c) => c.status === "Violated") ? "Violated" : checks.some((c) => c.status === "Stale") ? "Stale" : "Holds";
+  return { status: status2, checks };
 }
 function hasClearanceClaims(receipt) {
   return (receipt.claims ?? []).some((c) => c.id.startsWith(CLEARANCE_CLAIM_PREFIX));
@@ -77532,14 +77624,14 @@ async function verifyReceipt2(args, engine) {
     if (!validity.valid) {
       return pcbValidationError("verify_receipt", validity, args.document_id ? String(args.document_id) : void 0);
     }
-    const status2 = await verifyReceipt(pcb, legacy);
-    if (!status2) {
+    const status3 = await verifyReceipt(pcb, legacy);
+    if (!status3) {
       return {
         content: [{ type: "text", text: "Error: ECAD engine unavailable" }],
         isError: true
       };
     }
-    statuses.push(status2);
+    statuses.push(status3);
     boardHash = legacy.board_hash;
   }
   let clearance;
@@ -77566,19 +77658,19 @@ async function verifyReceipt2(args, engine) {
   const boundHash = [raw, legacy, unified].map((r) => r?.[DOCUMENT_STATE_FIELD]).find((h) => typeof h === "string" && h.length > 0);
   const documentChanged = boundHash !== void 0 && boundHash !== await documentStateHash(ctx.doc);
   const measuredStatus = worstStatus(statuses);
-  const status = measuredStatus === "Holds" && documentChanged ? "Stale" : measuredStatus;
+  const status2 = measuredStatus === "Holds" && documentChanged ? "Stale" : measuredStatus;
   const documentState = boundHash === void 0 ? {
     bound: false,
     note: "This receipt predates document binding, so Holds covers only the claims it re-measured, not the rest of the document."
   } : {
     bound: true,
     changed: documentChanged,
-    ...status === "Stale" && measuredStatus === "Holds" ? {
+    ...status2 === "Stale" && measuredStatus === "Holds" ? {
       note: "The document changed since this receipt was built, but every claim re-measured unchanged: the edit is outside what the receipt measures. Rebuild the receipt to certify the current document."
     } : {}
   };
   const payload = {
-    status,
+    status: status2,
     document_state: documentState,
     ...boardHash ? { board_hash: boardHash } : {},
     ...clearance ? { clearance } : {},
@@ -88177,7 +88269,7 @@ var init_share = __esm({
     init_tool_def();
     init_session_core();
     init_session_store();
-    VCAD_DOWNLOAD_URL = "https://vcad.io/download";
+    VCAD_DOWNLOAD_URL = "https://github.com/muni-works/vcad/releases/latest";
     SESSION_ID_RE = /^[A-Za-z0-9_-]{1,128}$/;
     openInAppSchema = {
       type: "object",
@@ -91320,6 +91412,96 @@ var init_animate = __esm({
   }
 });
 
+// src/version-check.ts
+function parse4(v) {
+  const m = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+.*)?$/.exec(v.trim());
+  if (!m) return null;
+  return {
+    core: [Number(m[1]), Number(m[2]), Number(m[3])],
+    pre: m[4] ? m[4].split(".").map((p) => /^\d+$/.test(p) ? Number(p) : p) : []
+  };
+}
+function compareVersions(a, b) {
+  const pa = parse4(a);
+  const pb = parse4(b);
+  if (!pa || !pb) return null;
+  for (let i = 0; i < 3; i++) {
+    const d = pa.core[i] - pb.core[i];
+    if (d !== 0) return d;
+  }
+  if (pa.pre.length === 0 || pb.pre.length === 0) {
+    return pb.pre.length - pa.pre.length;
+  }
+  const n = Math.max(pa.pre.length, pb.pre.length);
+  for (let i = 0; i < n; i++) {
+    const x = pa.pre[i];
+    const y = pb.pre[i];
+    if (x === void 0) return -1;
+    if (y === void 0) return 1;
+    if (x === y) continue;
+    if (typeof x === "number" && typeof y === "number") return x - y;
+    if (typeof x === "number") return -1;
+    if (typeof y === "number") return 1;
+    return x < y ? -1 : 1;
+  }
+  return 0;
+}
+function judge(running, latest) {
+  const cmp = compareVersions(running, latest);
+  if (cmp === null) {
+    return { state: "unknown", running, reason: `unparseable version (${running} vs ${latest})` };
+  }
+  if (cmp >= 0) return { state: "current", running, latest };
+  return {
+    state: "stale",
+    running,
+    latest,
+    message: `This vcad MCP server is out of date: running ${running}, newest is ${latest}. Tools, fixes and previews may be missing. Restart the agent so \`npx -y @vcad/mcp\` picks up the new version (or update vcad.app).`
+  };
+}
+function getUpdateStatus() {
+  return status;
+}
+async function startUpdateCheck(running, fetchImpl = globalThis.fetch, timeoutMs = 3e3) {
+  if (process.env.VCAD_MCP_NO_UPDATE_CHECK === "1") {
+    status = { state: "unknown", running, reason: "disabled (VCAD_MCP_NO_UPDATE_CHECK=1)" };
+    return status;
+  }
+  status = { state: "unknown", running, reason: "checking" };
+  try {
+    const ctrl = new AbortController();
+    const t2 = setTimeout(() => ctrl.abort(), timeoutMs);
+    t2.unref?.();
+    const res = await fetchImpl(NPM_LATEST_URL, {
+      signal: ctrl.signal,
+      headers: { accept: "application/json" }
+    });
+    clearTimeout(t2);
+    if (!res.ok) throw new Error(`registry HTTP ${res.status}`);
+    const body = await res.json();
+    if (typeof body.version !== "string") throw new Error("registry reply has no version");
+    status = judge(running, body.version);
+    if (status.state === "stale") console.error(`[mcp] ${status.message}`);
+  } catch (e) {
+    status = { state: "unknown", running, reason: `lookup failed: ${e.message}` };
+  }
+  return status;
+}
+function takeResultWarning() {
+  if (status.state !== "stale" || warnedInResult) return null;
+  warnedInResult = true;
+  return `\u26A0 ${status.message}`;
+}
+var NPM_LATEST_URL, status, warnedInResult;
+var init_version_check = __esm({
+  "src/version-check.ts"() {
+    "use strict";
+    NPM_LATEST_URL = "https://registry.npmjs.org/@vcad/mcp/latest";
+    status = { state: "unknown", running: "", reason: "not checked yet" };
+    warnedInResult = false;
+  }
+});
+
 // src/server.ts
 import { createRequire as createRequire3 } from "node:module";
 import { randomUUID as randomUUID5 } from "node:crypto";
@@ -91528,10 +91710,11 @@ async function createServer(existingEngine, context = { user: null }) {
   console.error(
     `[mcp] vcad ${VERSION_WITH_BUILD} (instance ${INSTANCE_ID}) \u2014 ${dispatchableTools.size} kernel tools; kernel WASM ${kernelWasmLoaded ? "ok" : "UNAVAILABLE"}`
   );
+  if (!process.env.VITEST) void startUpdateCheck(PKG_VERSION);
   const serverInfoDef = {
     name: "server_info",
     pack: null,
-    description: "Report the running build's identity: version, git sha (if stamped), tool count, enabled packs, whether the kernel WASM loaded, and whether sessions are durable (`durable` \u2014 saved to the local disk store and survive a restart, vs. in-memory only). Call this to confirm a tool exists in THIS build before assuming a stale or version-skewed deploy, and to check durable:true before relying on checkpoints across a long session.",
+    description: 'Report the running build\'s identity: version, git sha (if stamped), tool count, enabled packs, whether the kernel WASM loaded, and whether sessions are durable (`durable` \u2014 saved to the local disk store and survive a restart, vs. in-memory only). Call this to confirm a tool exists in THIS build before assuming a stale or version-skewed deploy, and to check durable:true before relying on checkpoints across a long session. `update` compares this build with the newest @vcad/mcp on npm; when `update.state` is "stale", tell the user and suggest restarting the agent.',
     inputSchema: serverInfoSchema,
     handler: async () => {
       const buildInfo = getBuildInfo();
@@ -91547,7 +91730,8 @@ async function createServer(existingEngine, context = { user: null }) {
               ...kernelWasmMissing.length > 0 ? { kernel_wasm_missing_exports: kernelWasmMissing } : {},
               kernel_tool_count: dispatchableTools.size,
               disabled_tool_count: disabledTools.size,
-              packs: packsSummary()
+              packs: packsSummary(),
+              update: getUpdateStatus()
             })
           }
         ]
@@ -91816,9 +92000,14 @@ async function createServer(existingEngine, context = { user: null }) {
           // client that remembers the last pair learns about a restart on the
           // very next call, instead of when a dead document_id finally fails.
           boot_token: currentBootToken(),
-          session_durable: isSessionStoreDurable()
+          session_durable: isSessionStoreDurable(),
+          update: getUpdateStatus().state
         }
       };
+      const warning = takeResultWarning();
+      if (warning && Array.isArray(result.content)) {
+        result.content = [...result.content, { type: "text", text: warning }];
+      }
     } catch {
     }
   };
@@ -92147,11 +92336,11 @@ function noteSessionDurability(result, documentId) {
   ];
 }
 function noteSourceDivergence(result, documentId) {
-  const status = sourceStatus(documents.get(documentId));
-  if (!status.source_stale) return;
+  const status2 = sourceStatus(documents.get(documentId));
+  if (!status2.source_stale) return;
   result.content = [
     ...result.content ?? [],
-    { type: "text", text: JSON.stringify(status) }
+    { type: "text", text: JSON.stringify(status2) }
   ];
 }
 function effectiveDocId(result, args) {
@@ -92257,12 +92446,13 @@ var init_server3 = __esm({
     init_enclosure();
     init_sim_replay();
     init_animate();
+    init_version_check();
     setParameterAssetResolver((doc, base_dir, engine) => {
       resolveLoonAssets(doc, { base_dir }, engine);
     });
     PKG_VERSION = (() => {
-      if ("0.11.0-main.156") {
-        return "0.11.0-main.156";
+      if ("0.11.0-main.158") {
+        return "0.11.0-main.158";
       }
       try {
         const req = createRequire3(import.meta.url);
@@ -92271,8 +92461,8 @@ var init_server3 = __esm({
         return "0.0.0";
       }
     })();
-    BUILD_SHA = "f25f1fe6da5156d93d7d0709be48c3c434b30b85";
-    BUILD_TIME = "2026-11-11T13:57:09.705Z";
+    BUILD_SHA = "7b415c4523c95991e41ee59c2aff357ff5f7205d";
+    BUILD_TIME = "2026-11-11T15:52:11.773Z";
     SHORT_SHA = BUILD_SHA === "unknown" ? "unknown" : BUILD_SHA.slice(0, 7);
     VERSION_WITH_BUILD = SHORT_SHA === "unknown" ? PKG_VERSION : `${PKG_VERSION}+${SHORT_SHA}`;
     INSTANCE_ID = randomUUID5().slice(0, 8);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vcad/mcp",
-  "version": "0.11.0-main.156",
+  "version": "0.11.0-main.158",
   "description": "vcad MCP server — parametric CAD + PCB design tools for AI agents (self-contained: bundled server + kernel WASM)",
   "license": "MIT",
   "type": "module",
@@ -15,11 +15,11 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/ecto/vcad"
+    "url": "https://github.com/muni-works/vcad"
   },
-  "homepage": "https://vcad.io",
+  "homepage": "https://github.com/muni-works/vcad",
   "vcadBuild": {
-    "sha": "f25f1fe6da5156d93d7d0709be48c3c434b30b85",
-    "builtAt": "2026-11-11T13:57:09.705Z"
+    "sha": "7b415c4523c95991e41ee59c2aff357ff5f7205d",
+    "builtAt": "2026-11-11T15:52:11.773Z"
   }
 }

package/skill/SKILL.md

@@ -0,0 +1,89 @@
+---
+name: vcad
+description: Design real, manufacturable parts with vcad — a local parametric CAD kernel your agent drives over MCP. Use when the user asks for a 3D part, bracket, enclosure, mechanism, assembly, PCB-adjacent mechanical work, or anything they want to 3D print, machine, or cut. Author in loon, verify with inspect/render/receipts, and the user watches edits land live in vcad.app.
+---
+
+# vcad
+
+vcad is a parametric CAD system with its own BRep kernel. It runs entirely on
+the user's machine — no accounts, no cloud, no share links. You drive it through
+the `vcad` MCP server; the user watches in **vcad.app**.
+
+## The one flow
+
+1. **Open vcad.** The user launches vcad.app. On first launch it registered
+   itself with their agents, so you are already attached — the `vcad` tools are
+   in your tool list. (No app? The same server runs as `npx -y @vcad/mcp`.)
+2. **Author in loon.** Write the whole part as loon source in one
+   `create_cad_loon` call. That returns a `document_id`; every later tool takes it.
+3. **Verify before you claim.** Measure with `inspect_cad`, look with
+   `render_view`, prove with receipts (below). Never describe a dimension you
+   haven't measured.
+4. **Edits appear live.** In vcad.app, each authoring call shows up in the
+   viewport as one named undo step the user can step back through. Under npx,
+   hand the result over with `open_in_app` (a `vcad://` link).
+5. **Ship it.** `export_cad` writes STL / GLB / STEP; `save_document` writes a
+   `.vcad` (plus the `.loon` source) the user owns.
+
+## Loon in 60 seconds
+
+Lisp-like, square brackets, millimetres, **Z-up**. Operations are
+*subject-last*, so they thread through `pipe`.
+
+```loon
+[defparam wall 3.0]
+[defparam bore 8.2]
+
+[let plate [extrude 0 0 wall
+  [sketch 0 0 0 1 0 0 0 1 0
+    #[[polygon #[0 0 60 0 60 40 0 40]
+               #[#[8 8 2.2] #[52 8 2.2] #[8 32 2.2] #[52 32 2.2]]]]]]]
+
+[root [pipe plate
+  [union [translate 30 20 0 [cylinder 9 20]]]
+  [difference [translate 30 20 -1 [cylinder bore 22]]]]
+  "aluminum"]
+```
+
+- `[cube x y z]` sits with its corner at the origin; `[cylinder r h]` /
+  `[cone rb rt h]` stand on the XY plane along +Z; `[sphere r]` is centred.
+- Booleans: `[difference tool subject]`, `[union other subject]`.
+- Plates with holes: ONE `[polygon outline #[holes]]` extruded — not a stack
+  of difference cutters.
+- `[defparam name value]` survives into the document — change it later with
+  `set_parameters` instead of re-authoring. `[let …]` does not.
+- Never hand-mirror by negating coordinates: `[mirror-x s]`,
+  `[mirror-pattern-x s]`, `[mirror-group-x "-r" side]` for assemblies.
+- The full vocabulary (sweeps, lofts, sheet metal, assemblies and joints,
+  imports, modules) is in the `create_cad_loon` tool description. Read it.
+
+## Verify
+
+| Question | Tool |
+|---|---|
+| Size, volume, mass, centre of mass | `inspect_cad` |
+| What does it look like? | `render_view` (look at it — every time) |
+| Do these parts collide / keep a gap? | `check_clearance` (labeled assertions persist) |
+| Will it print / machine? | `dfm_check` |
+| Is every claim still true after edits? | `build_receipt`, then `verify_receipt` |
+
+Receipts are fail-closed: a claim is **Holds**, **Stale** (the geometry changed
+since it was checked) or **Violated**. Predicted values from simulation are
+*provisional* until measured. Report the receipt verdict, not your own summary.
+
+## When something looks broken
+
+Call `server_info` first.
+
+- Low `uptime_s` or a changed `instance_id` → the server restarted; re-run the
+  last authoring call. It is not a renderer bug.
+- `update.state: "stale"` → this server is older than the newest release.
+  Tell the user and suggest restarting their agent (or updating vcad.app).
+- `durable: false` → sessions won't survive a restart; keep the loon source.
+
+## Ground rules
+
+- vcad has no hosted services. Never send the user to a website to view,
+  share, or order a part; use `open_in_app` and local files.
+- One `create_cad_loon` for a whole part beats dozens of tiny edits.
+- Units are millimetres unless the user says otherwise; say which you used.