dsh-eda-mcp 0.7.3 → 1.0.0

package/lib/bridge.mjs

@@ -3,7 +3,7 @@ import { createHash } from "node:crypto";
 import { execFileSync, spawn } from "node:child_process";
 import { statSync } from "node:fs";
 import { readFile } from "node:fs/promises";
-import { writeFile } from "node:fs/promises";
+import { unlink, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { basename, join } from "node:path";
 import { createServer } from "node:http";
@@ -176,6 +176,454 @@ function buildLaunchScript(executable, project) {
   return ["@echo off", 'start "" "' + executable + '"' + args, ""].join(String.fromCharCode(13, 10));
 }
 
+// src/bridge/design-intake.ts
+var INTAKE_SECTIONS = [
+  {
+    id: "power",
+    title: "\u4F9B\u7535\u4E0E\u7535\u6D41",
+    questions: [
+      { id: "powerSource", question: "\u677F\u5B50\u600E\u4E48\u4F9B\u7535\uFF1F\uFF08USB-C / USB-A / DC \u5EA7 / \u7535\u6C60 / \u5916\u90E8\u7AEF\u5B50\uFF09", why: "\u51B3\u5B9A\u63A5\u53E3\u5668\u4EF6\u3001\u8FDE\u63A5\u5668\u671D\u5411\u548C ESD \u4FDD\u62A4", critical: true, options: ["USB-C", "USB-A", "DC \u5EA7", "\u9502\u7535\u6C60", "\u5916\u90E8\u7AEF\u5B50", "\u591A\u79CD"] },
+      { id: "inputVoltage", question: "\u8F93\u5165\u7535\u538B\u8303\u56F4\u4E0E\u6700\u5927\u7535\u6D41\u662F\u591A\u5C11\uFF1F", why: "\u51B3\u5B9A\u7A33\u538B\u65B9\u6848\u3001\u7EBF\u5BBD\u3001\u94DC\u539A\u4E0E\u6563\u70ED", critical: true, fallback: "5 V / < 500 mA" },
+      { id: "railNeeds", question: "\u9700\u8981\u54EA\u4E9B\u7535\u6E90\u8F68\uFF083V3 / 5V / 1V8 / \u6A21\u62DF\u8F68\uFF09\uFF1F\u5404\u81EA\u8D1F\u8F7D\u591A\u5927\uFF1F", why: "\u51B3\u5B9A LDO \u8FD8\u662F DC-DC\u3001\u53BB\u8026\u6570\u91CF", critical: true },
+      { id: "battery", question: "\u662F\u5426\u9700\u8981\u7535\u6C60\u5145\u7535/\u5207\u6362\uFF1F", why: "\u5145\u7535 IC \u4E0E\u8DEF\u5F84\u7BA1\u7406\u4F1A\u6539\u53D8\u5E03\u5C40", critical: false, fallback: "\u4E0D\u9700\u8981" }
+    ]
+  },
+  {
+    id: "core",
+    title: "\u4E3B\u63A7\u4E0E\u56FA\u4EF6\u7EA6\u675F",
+    questions: [
+      { id: "mcu", question: "\u4E3B\u63A7\u578B\u53F7\uFF08\u6216\u5FC5\u987B\u517C\u5BB9\u7684\u7CFB\u5217\uFF09\uFF1F", why: "\u5F15\u811A\u3001\u65F6\u949F\u3001\u5C01\u88C5\u51B3\u5B9A\u5E03\u5C40\u4E0E\u8D70\u7EBF", critical: true },
+      { id: "clock", question: "\u65F6\u949F\u6765\u6E90\uFF1A\u5185\u90E8 RC / \u5916\u90E8\u6676\u632F\uFF08\u9891\u7387\uFF09\uFF1F", why: "\u6676\u632F\u8981\u8D34\u811A\u3001\u8D1F\u8F7D\u7535\u5BB9\u8981\u914D\u3001\u4E0B\u65B9\u7981\u94FA\u94DC", critical: true, options: ["\u5185\u90E8 RC", "8 MHz \u6676\u632F", "16 MHz \u6676\u632F", "32.768 kHz", "\u5176\u5B83"] },
+      { id: "programming", question: "\u70E7\u5199/\u8C03\u8BD5\u63A5\u53E3\uFF08SWD / JTAG / USB DFU / \u4E32\u53E3\uFF09\uFF1F", why: "\u51B3\u5B9A\u6392\u9488\u4E0E USB \u6570\u636E\u7EBF", critical: true, options: ["SWD 4 \u7EBF", "SWD 2 \u7EBF", "JTAG", "USB DFU", "\u4E32\u53E3 ISP", "\u4E0D\u9700\u8981"] },
+      { id: "boot", question: "\u542F\u52A8\u65B9\u5F0F\u662F\u5426\u9700\u8981\u53EF\u5207\u6362\uFF08BOOT0 \u8DF3\u7EBF/\u6309\u952E\uFF09\uFF1F", why: "\u51B3\u5B9A\u4E0B\u62C9\u7535\u963B\u4E0E\u8DF3\u7EBF\u6392\u9488", critical: false, fallback: "\u56FA\u5B9A\u4ECE Flash \u542F\u52A8\uFF0CBOOT0 \u4E0B\u62C9" }
+    ]
+  },
+  {
+    id: "io",
+    title: "\u63A5\u53E3\u4E0E\u5916\u8BBE",
+    questions: [
+      { id: "interfaces", question: "\u9700\u8981\u54EA\u4E9B\u5BF9\u5916\u63A5\u53E3\uFF1F\uFF08USB / UART / I2C / SPI / CAN / \u4EE5\u592A\u7F51 / \u663E\u793A\u5C4F / \u4F20\u611F\u5668\uFF09", why: "\u6BCF\u4E00\u79CD\u90FD\u5E26\u8FDE\u63A5\u5668\u3001\u4FDD\u62A4\u5668\u4EF6\u548C\u5E03\u7EBF\u7EA6\u675F", critical: true },
+      { id: "isolation", question: "\u662F\u5426\u6709\u9694\u79BB/\u9AD8\u538B/\u5F3A\u7535\u90E8\u5206\uFF1F\u5B89\u5168\u8DDD\u79BB\u8981\u6C42\uFF1F", why: "\u9700\u8981\u722C\u7535\u95F4\u8DDD\u3001\u5F00\u69FD\u3001\u9694\u79BB\u5668\u4EF6", critical: true, options: ["\u65E0", "\u6709\u4F4E\u538B\u9694\u79BB", "\u6709\u5E02\u7535/\u9AD8\u538B"] },
+      { id: "esd", question: "\u5BF9\u5916\u63A5\u53E3\u662F\u5426\u8981 ESD/\u6D6A\u6D8C\u4FDD\u62A4\uFF1F", why: "USBLC6 \u4E4B\u7C7B\u5668\u4EF6\u7684\u5730\u5FC5\u987B\u5355\u72EC\u56DE\u6D41", critical: false, fallback: "\u5BF9\u5916\u63A5\u53E3\u90FD\u52A0 ESD" }
+    ]
+  },
+  {
+    id: "mechanical",
+    title: "\u673A\u68B0\u4E0E\u7ED3\u6784",
+    questions: [
+      { id: "size", question: "\u677F\u6846\u5C3A\u5BF8\u9650\u5236\uFF08\u957F\xD7\u5BBD mm\uFF09\u4E0E\u5F62\u72B6\uFF08\u77E9\u5F62/\u5E26\u7F3A\u53E3/\u5706\u89D2\u534A\u5F84\uFF09\uFF1F", why: "\u51B3\u5B9A\u5E03\u5C40\u5BC6\u5EA6\u4E0E\u8FDE\u63A5\u5668\u4F4D\u7F6E", critical: true },
+      { id: "mounting", question: "\u5B9A\u4F4D\u5B54\u6570\u91CF\u3001\u5B54\u5F84\u3001\u4F4D\u7F6E\uFF1F", why: "\u975E\u91D1\u5C5E\u5316\u5B54\u8981\u907F\u5F00\u8D70\u7EBF\u4E0E\u5668\u4EF6", critical: true, fallback: "4 \u4E2A \u03C63.2 mm\uFF0C\u56DB\u89D2\u5185\u7F29 3 mm" },
+      { id: "connectorFacing", question: "\u5404\u8FDE\u63A5\u5668\u7684\u671D\u5411/\u4F4D\u7F6E\uFF08USB \u671D\u677F\u8FB9\u54EA\u4E00\u4FA7\uFF09\uFF1F", why: "\u63D2\u53E3\u5FC5\u987B\u671D\u677F\u5916\uFF0C\u5426\u5219\u88C5\u4E0D\u8FDB\u5916\u58F3", critical: true },
+      { id: "enclosure", question: "\u662F\u5426\u6709\u5916\u58F3/\u88C5\u914D\u9650\u5236\uFF08\u9AD8\u5EA6\u3001\u5E72\u6D89\u533A\uFF09\uFF1F", why: "\u9650\u5236\u5668\u4EF6\u9AD8\u5EA6\u4E0E\u6446\u653E", critical: false, fallback: "\u65E0\u5916\u58F3\uFF0C\u4EC5\u88F8\u677F" }
+    ]
+  },
+  {
+    id: "process",
+    title: "\u5DE5\u827A\u4E0E\u5236\u9020",
+    questions: [
+      { id: "layers", question: "\u5C42\u6570\uFF082 \u5C42 / 4 \u5C42\uFF09\uFF1F", why: "\u51B3\u5B9A\u5730\u5E73\u9762\u3001\u963B\u6297\u4E0E\u5E03\u7EBF\u7B56\u7565", critical: true, options: ["2 \u5C42", "4 \u5C42"] },
+      { id: "copper", question: "\u94DC\u539A\uFF081 oz / 2 oz\uFF09\uFF1F", why: "\u5F71\u54CD\u8F7D\u6D41\u4E0E\u6700\u5C0F\u7EBF\u5BBD", critical: false, fallback: "1 oz" },
+      { id: "assembly", question: "\u8D34\u7247\u8FD8\u662F\u624B\u710A\uFF1F\u53CC\u9762\u8D34\u7247\uFF1F", why: "\u51B3\u5B9A\u5C01\u88C5\u9009\u578B\u3001\u4E1D\u5370\u6807\u6CE8\u4E0E\u710A\u76D8\u5916\u6269", critical: true, options: ["\u5355\u9762\u8D34\u7247", "\u53CC\u9762\u8D34\u7247", "\u624B\u5DE5\u710A\u63A5"] },
+      { id: "quantity", question: "\u6253\u6837\u6570\u91CF\u4E0E\u9884\u7B97\u533A\u95F4\uFF1F", why: "\u5F71\u54CD\u5DE5\u827A\u9009\u62E9\uFF08\u62FC\u677F\u3001\u963B\u6297\u3001\u6C89\u91D1\uFF09", critical: false, fallback: "5 \u7247\u6253\u6837" }
+    ]
+  },
+  {
+    id: "delivery",
+    title: "\u4EA4\u4ED8\u4E0E\u9A8C\u8BC1",
+    questions: [
+      { id: "deliverable", question: "\u8981\u4EA4\u4ED8\u5230\u4EC0\u4E48\u7A0B\u5EA6\uFF1F\uFF08\u539F\u7406\u56FE / PCB / Gerber+BOM+\u5750\u6807 / \u5168\u6D41\u7A0B\u53EF\u4E0B\u5355\uFF09", why: "\u51B3\u5B9A\u9A8C\u8BC1\u6DF1\u5EA6\u4E0E\u6587\u6863\u91CF", critical: true, options: ["\u4EC5\u539F\u7406\u56FE", "\u539F\u7406\u56FE+PCB", "\u53EF\u4E0B\u5355\uFF08Gerber+BOM+\u5750\u6807\uFF09"] },
+      { id: "validation", question: "\u8981\u54EA\u4E9B\u9A8C\u8BC1\uFF1F\uFF08DRC / \u7F51\u8868 ERC / \u8BBE\u8BA1\u5BA1\u8BA1 / \u5B9E\u673A\u70B9\u4EAE\uFF09", why: "\u51B3\u5B9A\u4EA4\u4ED8\u524D\u5FC5\u987B\u8DD1\u7684\u68C0\u67E5", critical: false, fallback: "DRC + \u7F51\u8868 ERC + \u8BBE\u8BA1\u5BA1\u8BA1" },
+      { id: "constraints", question: "\u8FD8\u6709\u5176\u5B83\u786C\u7EA6\u675F\uFF08\u7981\u7528\u7684\u5668\u4EF6\u3001\u5FC5\u987B\u590D\u7528\u5DF2\u6709\u5DE5\u7A0B\u3001\u8BA4\u8BC1\u8981\u6C42\uFF09\uFF1F", why: "\u907F\u514D\u8FD4\u5DE5", critical: false }
+    ]
+  }
+];
+function buildIntake(answers) {
+  const provided = answers !== null && typeof answers === "object" ? answers : {};
+  const known = /* @__PURE__ */ new Set();
+  for (const section of INTAKE_SECTIONS) for (const question of section.questions) known.add(question.id);
+  const brief = {};
+  const answered = [];
+  const unknownAnswerKeys = [];
+  for (const [key, value] of Object.entries(provided)) {
+    if (!known.has(key)) {
+      unknownAnswerKeys.push(key);
+      continue;
+    }
+    const text = String(value ?? "").trim();
+    if (text === "") continue;
+    brief[key] = text;
+    answered.push(key);
+  }
+  const missingCritical = [];
+  let criticalCount = 0;
+  let questionCount = 0;
+  for (const section of INTAKE_SECTIONS) {
+    for (const question of section.questions) {
+      questionCount += 1;
+      if (!question.critical) continue;
+      criticalCount += 1;
+      if (brief[question.id] === void 0) missingCritical.push(question.id);
+    }
+  }
+  return {
+    sections: INTAKE_SECTIONS,
+    questionCount,
+    criticalCount,
+    answered,
+    missingCritical,
+    unknownAnswerKeys,
+    ready: missingCritical.length === 0,
+    brief
+  };
+}
+
+// src/bridge/schematic-audit.ts
+var EPS = 0.5;
+function intersects(a, b) {
+  return a.left < b.right - EPS && b.left < a.right - EPS && a.bottom < b.top - EPS && b.bottom < a.top - EPS;
+}
+function area(b) {
+  return Math.max(0, b.right - b.left) * Math.max(0, b.top - b.bottom);
+}
+function inside(inner, outer) {
+  return inner.left >= outer.left - EPS && inner.right <= outer.right + EPS && inner.bottom >= outer.bottom - EPS && inner.top <= outer.top + EPS;
+}
+function auditSchematicGeometry(input) {
+  const grid = input.grid === void 0 ? 10 : input.grid;
+  const checks = [];
+  const add = (id, status, message, details) => {
+    checks.push(details && details.length > 0 ? { id, status, message, details } : { id, status, message });
+  };
+  const withBounds = input.components.filter((component) => component.bounds !== void 0);
+  if (input.components.length === 0) {
+    add("sheet", "skip", "no component on the active schematic page");
+    return { ok: false, counts: { pass: 0, fail: 0, warn: 0, skip: 1 }, componentCount: 0, checks };
+  }
+  add("sheet", "pass", input.components.length + " component(s) read from the active page, " + withBounds.length + " with bounds");
+  const outside = withBounds.filter((component) => !inside(component.bounds, input.frame)).map((component) => component.designator);
+  add(
+    "outside-frame",
+    outside.length === 0 ? "pass" : "fail",
+    outside.length === 0 ? "every symbol sits inside the frame" : outside.length + " symbol(s) stick out of the frame",
+    outside.slice(0, 20)
+  );
+  if (input.titleBlock === void 0) {
+    add("title-block", "skip", "no title block range supplied");
+  } else {
+    const block = input.titleBlock;
+    const intruding = withBounds.filter((component) => intersects(component.bounds, block)).map((component) => component.designator);
+    add(
+      "title-block",
+      intruding.length === 0 ? "pass" : "fail",
+      intruding.length === 0 ? "nothing overlaps the title block" : intruding.length + " symbol(s) overlap the title block",
+      intruding.slice(0, 20)
+    );
+  }
+  const overlaps = [];
+  for (let i = 0; i < withBounds.length; i++) {
+    for (let j = i + 1; j < withBounds.length; j++) {
+      const a = withBounds[i];
+      const b = withBounds[j];
+      if (!intersects(a.bounds, b.bounds)) continue;
+      const sharedW = Math.min(a.bounds.right, b.bounds.right) - Math.max(a.bounds.left, b.bounds.left);
+      const sharedH = Math.min(a.bounds.top, b.bounds.top) - Math.max(a.bounds.bottom, b.bounds.bottom);
+      const shared = Math.max(0, sharedW) * Math.max(0, sharedH);
+      const smaller = Math.min(area(a.bounds), area(b.bounds));
+      if (smaller > 0 && shared / smaller > 0.08) overlaps.push(a.designator + " x " + b.designator);
+    }
+  }
+  add(
+    "symbol-overlap",
+    overlaps.length === 0 ? "pass" : "fail",
+    overlaps.length === 0 ? "no two symbols overlap" : overlaps.length + " overlapping symbol pair(s)",
+    overlaps.slice(0, 20)
+  );
+  const offGrid = input.components.filter((component) => Math.abs(component.x / grid - Math.round(component.x / grid)) > 0.01 || Math.abs(component.y / grid - Math.round(component.y / grid)) > 0.01).map((component) => component.designator + " @" + component.x + "," + component.y);
+  add(
+    "grid",
+    offGrid.length === 0 ? "pass" : "warn",
+    offGrid.length === 0 ? "every symbol sits on the " + grid + "-unit grid" : offGrid.length + " symbol(s) are off the " + grid + "-unit grid",
+    offGrid.slice(0, 20)
+  );
+  const labels = input.labels ?? [];
+  if (labels.length === 0) {
+    add("label-overlap", "skip", "no label anchors supplied");
+  } else {
+    const crowded = labels.filter((label) => withBounds.some((component) => label.x > component.bounds.left && label.x < component.bounds.right && label.y > component.bounds.bottom && label.y < component.bounds.top)).map((label) => label.text + " @" + label.x + "," + label.y);
+    add(
+      "label-overlap",
+      crowded.length === 0 ? "pass" : "warn",
+      crowded.length === 0 ? "no label anchor lands inside a symbol" : crowded.length + " label(s) anchored inside a symbol body",
+      crowded.slice(0, 20)
+    );
+  }
+  const counts = { pass: 0, fail: 0, warn: 0, skip: 0 };
+  for (const check of checks) counts[check.status] += 1;
+  return { ok: counts.fail === 0, counts, componentCount: input.components.length, checks };
+}
+
+// src/bridge/netlist-erc.ts
+var POWER_NET = /^(?:\+?\d+V\d*|V?(?:CC|DD|BAT|IN|BUS|SYS|MOTOR)|AVDD|DVDD|VBUS|VUSB|VBAT|3V3|5V|12V)$/i;
+var GROUND_NET = /^(?:GND|AGND|DGND|PGND|GNDA|GNDD|VSS|0V|EARTH)$/i;
+var USD_DP = /(?:^|_)(?:USB_?D\+?P|D\+|USB_?DP|DP)$/i;
+var USD_DM = /(?:^|_)(?:USB_?D-?M|D-|USB_?DM|DM)$/i;
+var CRYSTAL_HINT = /crystal|xtal|osc|谐振|晶振|5032|3225/i;
+var MCU_PART = /STM32|GD32|ATmega|ATMEGA|ESP32|ESP8266|CH32|HC32|MM32|APM32|N76|PIC\d|RP2040|MSP430/i;
+function normNet(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function parseNetlist(raw) {
+  const source = raw && typeof raw === "object" && raw.components ? raw : {};
+  const map = source.components ?? {};
+  const components = [];
+  const pins = [];
+  for (const key of Object.keys(map)) {
+    const entry = map[key] ?? {};
+    const props = entry.props ?? {};
+    const designator = String(props.Designator ?? props.designator ?? key);
+    const pinInfoMap = entry.pinInfoMap ?? {};
+    const own = [];
+    for (const pinKey of Object.keys(pinInfoMap)) {
+      const pin = pinInfoMap[pinKey] ?? {};
+      const number = String(pin.number ?? pin.props?.["Pin Number"] ?? pinKey);
+      const name = String(pin.name ?? "");
+      const net = normNet(pin.net);
+      own.push({ number, name, net });
+      pins.push({ designator, number, name, net });
+    }
+    const flag = (value, fallback) => {
+      if (value === void 0 || value === null || value === "") return fallback;
+      return !/^(?:no|false|0)$/i.test(String(value).trim());
+    };
+    components.push({
+      designator,
+      part: String(props["Manufacturer Part"] ?? props.Device ?? ""),
+      footprint: String(props.Footprint ?? ""),
+      supplierPart: String(props["Supplier Part"] ?? props["LCSC Part"] ?? ""),
+      addIntoBom: flag(props["Add into BOM"], true),
+      convertToPcb: flag(props["Convert to PCB"], true),
+      pins: own
+    });
+  }
+  return { components, pins };
+}
+function netsOf(pins) {
+  const nets = /* @__PURE__ */ new Map();
+  for (const pin of pins) {
+    if (pin.net === "") continue;
+    const list = nets.get(pin.net);
+    if (list) list.push(pin);
+    else nets.set(pin.net, [pin]);
+  }
+  return nets;
+}
+function capsBridging(net, groundNet, components) {
+  let count = 0;
+  for (const component of components) {
+    if (!/^C\d*$/i.test(component.designator)) continue;
+    const onNet = component.pins.some((pin) => pin.net === net);
+    const onGround = component.pins.some((pin) => pin.net === groundNet);
+    if (onNet && onGround) count++;
+  }
+  return count;
+}
+function resistorsOn(net, components, otherNet) {
+  const found = [];
+  for (const component of components) {
+    if (!/^R\d*$/i.test(component.designator)) continue;
+    const onNet = component.pins.some((pin) => pin.net === net);
+    if (!onNet) continue;
+    if (otherNet === void 0) {
+      found.push(component.designator);
+      continue;
+    }
+    const others = component.pins.filter((pin) => pin.net !== net).map((pin) => pin.net);
+    if (others.some((name) => name === otherNet)) found.push(component.designator);
+  }
+  return found;
+}
+function runNetlistErc(rawNetlist) {
+  const { components, pins } = parseNetlist(rawNetlist);
+  const nets = netsOf(pins);
+  const checks = [];
+  const add = (id, status, message, details) => {
+    checks.push(details && details.length > 0 ? { id, status, message, details } : { id, status, message });
+  };
+  if (components.length === 0) {
+    add("netlist", "skip", "netlist has no components: open a schematic page first (eda_open_document)");
+    return { ok: false, counts: { pass: 0, fail: 0, warn: 0, skip: 1 }, componentCount: 0, netCount: 0, checks };
+  }
+  const seen = /* @__PURE__ */ new Map();
+  for (const component of components) seen.set(component.designator, (seen.get(component.designator) ?? 0) + 1);
+  const duplicates = [...seen.entries()].filter(([, n]) => n > 1).map(([name, n]) => name + " x" + n);
+  add(
+    "duplicate-designator",
+    duplicates.length === 0 ? "pass" : "fail",
+    duplicates.length === 0 ? "every designator is unique" : duplicates.length + " duplicated designator(s)",
+    duplicates
+  );
+  const floating = pins.filter((pin) => pin.net === "").map((pin) => pin.designator + "." + pin.number + (pin.name ? " (" + pin.name + ")" : ""));
+  add(
+    "unconnected-pin",
+    floating.length === 0 ? "pass" : "warn",
+    floating.length === 0 ? "every pin is on a net" : floating.length + " pin(s) are on no net (mark unused pins with eda_set_no_connect or wire them)",
+    floating.slice(0, 25)
+  );
+  const dangling = [...nets.entries()].filter(([, list]) => list.length < 2).map(([name, list]) => name + " <- " + list.map((p) => p.designator + "." + p.number).join(","));
+  add(
+    "dangling-net",
+    dangling.length === 0 ? "pass" : "fail",
+    dangling.length === 0 ? "every net has at least two endpoints" : dangling.length + " net(s) have a single endpoint",
+    dangling.slice(0, 25)
+  );
+  const groundNet = [...nets.keys()].find((name) => GROUND_NET.test(name)) ?? "";
+  add(
+    "ground-net",
+    groundNet === "" ? "fail" : nets.get(groundNet).length >= 3 ? "pass" : "warn",
+    groundNet === "" ? "no ground net (GND/VSS/AGND) found" : "ground net " + groundNet + " has " + nets.get(groundNet).length + " pins"
+  );
+  const shorted = components.filter((component) => {
+    const names = new Set(component.pins.map((pin) => pin.net).filter((name) => name !== ""));
+    return component.pins.length >= 2 && names.size === 1;
+  }).map((component) => component.designator);
+  add(
+    "shorted-component",
+    shorted.length === 0 ? "pass" : "fail",
+    shorted.length === 0 ? "no component has all pins on one net" : shorted.length + " component(s) have every pin on one net",
+    shorted
+  );
+  const powerNets = [...nets.keys()].filter((name) => POWER_NET.test(name) && !GROUND_NET.test(name));
+  if (powerNets.length === 0) {
+    add("power-rail", "warn", "no power net recognised (3V3/5V/VCC/VDD/VBAT)");
+  } else {
+    const icPowerPins = pins.filter((pin) => /^(?:VDD|VCC|VBAT|VDDA|AVDD|DVDD|VIN|V\+)/i.test(pin.name) && !GROUND_NET.test(pin.net));
+    const unpowered = icPowerPins.filter((pin) => pin.net === "").map((pin) => pin.designator + "." + pin.number);
+    add(
+      "power-rail",
+      unpowered.length === 0 ? "pass" : "fail",
+      unpowered.length === 0 ? powerNets.length + " power net(s) (" + powerNets.slice(0, 4).join(", ") + ") feed " + icPowerPins.length + " IC power pin(s)" : unpowered.length + " IC power pin(s) are not on any net",
+      unpowered
+    );
+    if (groundNet !== "") {
+      const thin = powerNets.filter((name) => capsBridging(name, groundNet, components) === 0);
+      add(
+        "decoupling",
+        thin.length === 0 ? "pass" : "warn",
+        thin.length === 0 ? "every power rail has a capacitor to " + groundNet : thin.length + " power rail(s) have no capacitor to " + groundNet + " (decoupling missing)",
+        thin
+      );
+    } else {
+      add("decoupling", "skip", "no ground net, decoupling cannot be judged");
+    }
+  }
+  const dp = [...nets.keys()].filter((name) => USD_DP.test(name));
+  const dm = [...nets.keys()].filter((name) => USD_DM.test(name));
+  if (dp.length === 0 && dm.length === 0) {
+    add("usb-data-pair", "skip", "no USB D+/D- net, skipped");
+  } else {
+    const missing = dp.length === 0 ? "D+ net missing" : dm.length === 0 ? "D- net missing" : "";
+    const halves = dp.length === 0 || dm.length === 0 ? ["D+/D- are not a pair: " + (dp.concat(dm).join(", ") || "none")] : [];
+    add(
+      "usb-data-pair",
+      missing === "" ? "pass" : "fail",
+      missing === "" ? "D+ (" + dp.join(",") + ") and D- (" + dm.join(",") + ") both exist" : missing,
+      halves
+    );
+  }
+  const crystals = components.filter((component) => /^[XY]\d*$/i.test(component.designator) || CRYSTAL_HINT.test(component.part) || CRYSTAL_HINT.test(component.footprint));
+  const realCrystals = crystals.filter((component) => {
+    const names = new Set(component.pins.map((pin) => pin.net).filter((name) => name !== ""));
+    return component.pins.length === 2 || component.pins.length >= 2 && names.size === 2;
+  });
+  if (realCrystals.length === 0) {
+    add("crystal", "skip", "no crystal found, skipped (an RC oscillator design is fine)");
+  } else if (groundNet === "") {
+    add("crystal", "skip", "crystal present but no ground net, load caps cannot be judged");
+  } else {
+    const problems = [];
+    for (const crystal of realCrystals) {
+      const own = crystal.pins.map((pin) => pin.net).filter((name) => name !== "");
+      if (new Set(own).size < 2) problems.push(crystal.designator + ": both pins are on " + (own[0] ?? "no net"));
+      for (const net of new Set(own)) {
+        if (capsBridging(net, groundNet, components) === 0) problems.push(crystal.designator + ": " + net + " has no load capacitor to " + groundNet);
+      }
+      const touchesMcu = pins.some((pin) => own.includes(pin.net) && MCU_PART.test(components.find((c) => c.designator === pin.designator)?.part ?? ""));
+      if (!touchesMcu) problems.push(crystal.designator + ": neither pin reaches an MCU clock pin");
+    }
+    add(
+      "crystal",
+      problems.length === 0 ? "pass" : "warn",
+      problems.length === 0 ? realCrystals.length + " crystal(s) have two nets, load caps and an MCU connection" : problems.length + " crystal problem(s)",
+      problems
+    );
+  }
+  const resetNet = [...nets.keys()].find((name) => /^(?:N?RST|RESET|RESET_N|MCLR)$/i.test(name));
+  if (resetNet === void 0) {
+    add("reset", "skip", "no reset net, skipped");
+  } else if (groundNet === "") {
+    add("reset", "skip", "reset net present but no ground net");
+  } else {
+    const cap = capsBridging(resetNet, groundNet, components);
+    const pullup = resistorsOn(resetNet, components).length;
+    const problems = [];
+    if (cap === 0) problems.push(resetNet + " has no capacitor to " + groundNet);
+    if (pullup === 0) problems.push(resetNet + " has no series/pull resistor");
+    add(
+      "reset",
+      problems.length === 0 ? "pass" : "warn",
+      problems.length === 0 ? resetNet + " has a capacitor and a resistor" : problems.length + " reset problem(s)",
+      problems
+    );
+  }
+  const bootNet = [...nets.keys()].find((name) => /^BOOT\d$/i.test(name));
+  if (bootNet === void 0) {
+    add("boot", "skip", "no BOOT0 net, skipped");
+  } else {
+    const resistors = resistorsOn(bootNet, components);
+    add(
+      "boot",
+      resistors.length > 0 ? "pass" : "warn",
+      resistors.length > 0 ? bootNet + " has resistor(s): " + resistors.join(",") : bootNet + " has no pull resistor (floating boot pin)"
+    );
+  }
+  const ccPins = pins.filter((pin) => /^CC[12]$/i.test(pin.name));
+  if (ccPins.length === 0) {
+    add("type-c-cc", "skip", "no CC1/CC2 pins, skipped");
+  } else {
+    const missing = ccPins.filter((pin) => pin.net === "" || groundNet !== "" && resistorsOn(pin.net, components, groundNet).length === 0).map((pin) => pin.designator + "." + pin.name + " on " + (pin.net || "<no net>") + " without a resistor to GND");
+    add(
+      "type-c-cc",
+      missing.length === 0 ? "pass" : "warn",
+      missing.length === 0 ? "CC1/CC2 each have a resistor to ground" : missing.length + " CC pin(s) lack a 5.1k pull-down",
+      missing
+    );
+  }
+  const missingSupplier = components.filter((component) => component.supplierPart.trim() === "").map((component) => component.designator + (component.part ? " (" + component.part + ")" : ""));
+  add(
+    "bom-part-number",
+    missingSupplier.length === 0 ? "pass" : "warn",
+    missingSupplier.length === 0 ? "every part carries a supplier part number" : missingSupplier.length + " part(s) have no supplier/LPSC part number (not orderable by number)",
+    missingSupplier.slice(0, 20)
+  );
+  const excluded = components.filter((component) => !component.convertToPcb).map((component) => component.designator);
+  add(
+    "pcb-conversion",
+    excluded.length === 0 ? "pass" : "warn",
+    excluded.length === 0 ? "every part is marked Convert to PCB" : excluded.length + " part(s) are excluded from the PCB conversion (they will be missing on the board)",
+    excluded.slice(0, 20)
+  );
+  const noFootprint = components.filter((component) => component.convertToPcb && component.footprint.trim() === "").map((component) => component.designator);
+  add(
+    "footprint",
+    noFootprint.length === 0 ? "pass" : "fail",
+    noFootprint.length === 0 ? "every PCB-bound part has a footprint" : noFootprint.length + " PCB-bound part(s) have no footprint and cannot be placed",
+    noFootprint.slice(0, 20)
+  );
+  const counts = { pass: 0, fail: 0, warn: 0, skip: 0 };
+  for (const check of checks) counts[check.status] += 1;
+  return { ok: counts.fail === 0, counts, componentCount: components.length, netCount: nets.size, checks };
+}
+
 // src/bridge/design-rules.ts
 var MIL_PER_MM = 39.37007874015748;
 function milToMm(mil) {
@@ -195,7 +643,8 @@ function checkNetName(net) {
   const warnings = [];
   if (net === "") errors.push("net name is empty");
   if (net.length > NET_NAME_MAX_LENGTH) errors.push(`net name is longer than ${NET_NAME_MAX_LENGTH} characters`);
-  if (net !== "" && !NET_NAME_ALLOWED.test(net)) {
+  const autoGenerated = /^\$?\d+N\d+$/.test(net) || /^\$/.test(net);
+  if (net !== "" && !NET_NAME_ALLOWED.test(net) && !autoGenerated) {
     errors.push(`net name "${net}" contains characters the JLCEDA backend cannot parse (allowed: letters, digits, "_", ".", "+", "-")`);
   }
   if (/[a-z]/.test(net)) warnings.push(`net name "${net}" is not uppercase; the official advice is uppercase letters, digits and "_" only`);
@@ -243,8 +692,14 @@ function checkTrackWidth(net, lineWidth, force = false) {
   if (widthMil > 0 && widthMil < suggestedMil && Number.isFinite(widthMil) && !force) {
     warnings.push(`track width ${widthMil} mil is below the ${suggestedMil} mil suggested for ${role} net "${net}"`);
   }
-  const isTierValue = Object.values(TRACK_WIDTH_MIL).includes(widthMil);
-  if (widthMil > 0 && !isTierValue && milToMm(widthMil) % 0.05 > 1e-3) {
+  const isTierValue = Object.values(TRACK_WIDTH_MIL).includes(widthMil) || widthMil === 15 || widthMil === 25 || widthMil === 12;
+  const stepRemainder = (() => {
+    const mm = milToMm(widthMil);
+    if (mm <= 0) return 0;
+    const nearest = Math.round(mm / 0.05) * 0.05;
+    return Math.abs(mm - nearest);
+  })();
+  if (widthMil > 0 && !isTierValue && stepRemainder > 0.01) {
     warnings.push(`track width ${Math.round(widthMil * 100) / 100} mil (${milToMm(widthMil).toFixed(3)} mm) is not on a 0.05 mm step; ${Math.round(roundToFiveHundredthsMm(widthMil) * 100) / 100} mil aligns better with JLC parameters`);
   }
   return { ...result(errors, warnings), widthMil, role, suggestedMil };
@@ -299,9 +754,10 @@ var WORKFLOW_SUMMARY = [
   "1) \u5E03\u5C40\uFF1A\u6309 10 \u5355\u4F4D\u6805\u683C\u5BF9\u9F50\uFF1B\u4FE1\u53F7\u4ECE\u5DE6\u5230\u53F3\u3001\u7535\u6E90\u5728\u4E0A\u3001\u5730\u5728\u4E0B\uFF1B\u540C\u7EA7\u5668\u4EF6\u7B49\u95F4\u8DDD\uFF1B\u4E0D\u538B\u5B57\u3001\u4E0D\u538B\u6807\u9898\u680F\uFF1B\u5148\u770B eda_get_page_info \u7684\u5B89\u5168\u533A\u518D\u6446\u4F4D\u3002",
   "2) \u8FDE\u7EBF\uFF1A\u53EA\u7528 eda_draw_wire \u8D70\u76F4\u7EBF/45 \u5EA6\uFF1B**\u8DE8\u533A\u57DF\u540C\u540D\u7F51\u7EDC\u5FC5\u987B\u7528\u7F51\u7EDC\u7AEF\u53E3\uFF08eda_place_net_port\uFF09\u6216\u7F51\u7EDC\u6807\u7B7E**\uFF0C\u4E0D\u80FD\u9760\u5728\u4E24\u5904\u753B\u4E00\u6761\u53EB\u540C\u540D\u7684\u5BFC\u7EBF\u2014\u2014\u5BFC\u7EBF\u4E00\u65E6\u63A5\u89E6\u5F15\u811A\uFF0Cnet \u4F1A\u88AB\u8FDE\u901A\u6027\u91CD\u7B97\uFF0C\u6307\u5B9A\u540D\u4F1A\u88AB\u8986\u76D6\u3002",
   "3) \u7F51\u7EDC\u6807\u7B7E\uFF1A\u5148\u8BD5 eda_place_net_label\uFF1B\u82E5\u8BE5\u6784\u5EFA\u7684 createNetLabel \u4E0D\u54CD\u5E94\uFF0C\u4F1A\u81EA\u52A8\u964D\u7EA7\u4E3A\u7EAF\u6587\u672C\u6807\u7B7E\uFF08\u65E0\u7535\u6C14\u8BED\u4E49\uFF09\uFF0C\u6B64\u65F6\u9760 stub \u5BFC\u7EBF\u627F\u8F7D\u7F51\u7EDC\uFF1B\u6279\u91CF\u7528 eda_place_net_labels \u4E00\u6B21\u8C03\u7528\uFF0C\u4E0D\u8981\u4E32\u884C\u4E0A\u767E\u6B21\u3002",
-  "4) \u6821\u9A8C\uFF1Aeda_export_netlist \u770B\u6BCF\u4E2A\u7F51\u7EDC\u7684\u7AEF\u70B9\u662F\u5426 \u22652\uFF1Beda_run_drc \u770B\u9010\u6761 DRC \u660E\u7EC6\uFF1B\u89C6\u89C9\u68C0\u67E5\u4F18\u5148\u5BFC\u51FA PNG \u81EA\u884C\u8BC6\u522B\uFF0C\u800C\u4E0D\u662F\u8BA9 EDA \u91CD\u6392\u3002",
-  "5) \u53EA\u6709\u7528\u6237\u660E\u786E\u8981\u6C42\u65F6\u624D eda_auto_layout / eda_auto_route\uFF08\u9700 force:true \u4E14\u8BBE\u7F6E\u91CC\u653E\u884C\uFF09\u3002",
-  "6) \u5F15\u811A\u4FE1\u606F\u7528 eda_get_pins \u4E00\u6B21\u62FF\u5168\uFF08\u542B pinName/pinNumber\uFF09\uFF0C\u4E0D\u8981\u9010\u811A\u8C03 raw API\u3002"
+  "4) \u6821\u9A8C\uFF1Aeda_export_netlist \u770B\u6BCF\u4E2A\u7F51\u7EDC\u7684\u7AEF\u70B9\u662F\u5426 \u22652\uFF1Beda_run_drc \u770B\u9010\u6761 DRC \u660E\u7EC6\u3002",
+  "5) \u770B\u56FE\uFF08eda_capture\uFF09\u53EA\u5728\u8FD9 4 \u4E2A\u65F6\u523B\uFF1A\u5E03\u5C40\u5B8C\u6210\u5F85\u5E03\u7EBF\u3001\u5E03\u7EBF\u5B8C\u6210\u5F85 DRC\u3001\u4E1D\u5370\u6587\u5B57\u653E\u5B8C\u3001\u5750\u6807\u4E0E\u76F4\u89C9\u51B2\u7A81\u65F6\uFF1B\u4E0D\u8981\u6BCF\u6539\u4E00\u4E2A\u56FE\u5143\u622A\u4E00\u6B21\uFF0C\u770B\u5B8C eda_capture({cleanup:true}) \u5220\u6389\u4E34\u65F6 PNG\u3002",
+  "6) \u53EA\u6709\u7528\u6237\u660E\u786E\u8981\u6C42\u65F6\u624D eda_auto_layout / eda_auto_route\uFF08\u9700 force:true \u4E14\u8BBE\u7F6E\u91CC\u653E\u884C\uFF09\u3002",
+  "7) \u5F15\u811A\u4FE1\u606F\u7528 eda_get_pins \u4E00\u6B21\u62FF\u5168\uFF08\u542B pinName/pinNumber\uFF09\uFF0C\u4E0D\u8981\u9010\u811A\u8C03 raw API\u3002"
 ].join("\n");
 var WORKFLOW_GUIDE = WORKFLOW_SUMMARY + "\n\n" + [
   "## \u5E03\u5C40\u7EC6\u5219\u662F\u600E\u4E48\u843D\u5730\u7684",
@@ -323,6 +779,25 @@ var WORKFLOW_GUIDE = WORKFLOW_SUMMARY + "\n\n" + [
   "",
   "eda_draw_wire \u4F20\u7684 net \u53EA\u5BF9**\u60AC\u7A7A\u5BFC\u7EBF**\u6709\u6548\uFF1B\u5BFC\u7EBF\u7AEF\u70B9\u4E00\u65E6\u843D\u5728\u5F15\u811A/\u7F51\u7EDC\u4E0A\uFF0CEDA \u4F1A\u6309\u8FDE\u901A\u6027\u91CD\u7B97\u7F51\u7EDC\u540D\uFF08\u5B9E\u6D4B TESTNET \u5E76\u5165\u4E86 LED_A\uFF09\u3002\u6240\u4EE5\u201C\u540C\u540D\u5BFC\u7EBF = \u540C\u540D\u7F51\u7EDC\u201D\u4E0D\u6210\u7ACB\uFF0C\u8DE8\u533A\u57DF\u540C\u540D\u5FC5\u987B\u7528\u7F51\u7EDC\u6807\u7B7E\u6216\u7F51\u7EDC\u7AEF\u53E3\u3002",
   "",
+  "## \u4EC0\u4E48\u65F6\u5019\u5FC5\u987B\u770B\u56FE\uFF08eda_capture\uFF09\uFF0C\u4EC0\u4E48\u65F6\u5019\u4E0D\u8981",
+  "",
+  '\u770B\u56FE\u4E0D\u662F"\u53EF\u9009\u52A0\u5206\u9879"\uFF0C\u4E5F\u4E0D\u662F"\u6BCF\u6B65\u90FD\u622A"\u3002\u5224\u636E\u6309\u98CE\u9669\u800C\u4E0D\u662F\u6309\u4E60\u60EF\uFF1A',
+  "",
+  "**\u5FC5\u987B\u770B\u56FE\uFF084 \u4E2A\u65F6\u523B\uFF09**",
+  "",
+  "1. \u5E03\u5C40\u5B8C\u6210\u3001\u5E03\u7EBF\u4E4B\u524D\uFF1A\u677F\u9762\u6700\u7A7A\uFF0C\u6700\u5BB9\u6613\u4E00\u773C\u770B\u51FA\u5668\u4EF6\u8D8A\u754C\u3001\u5668\u4EF6\u4E92\u76F8\u538B\u4F4F\u3001\u8FDE\u63A5\u5668\u671D\u5411\u53CD\u4E86\u3001\u5B89\u88C5\u5B54\u538B\u5230\u5668\u4EF6\u3002",
+  "2. \u5E03\u7EBF\u5B8C\u6210\u3001DRC \u4E4B\u524D\uFF1A\u770B\u6709\u6CA1\u6709\u8DE8\u7F51\u7EDC\u8D34\u5408\u3001\u5929\u7EBF stub\u3001\u7ED5\u8FDC\u7684\u957F\u8D70\u7EBF\u3001GND \u88AB\u6253\u6563\u6210\u5B64\u5C9B\u3002",
+  "3. \u4E1D\u5370/\u5DE5\u827A\u6587\u5B57\u653E\u5B8C\uFF1A\u770B\u6587\u5B57\u6709\u6CA1\u6709\u538B\u710A\u76D8\u3001\u88AB\u677F\u8FB9\u88C1\u5207\u3001\u65B9\u5411\u53CD\u4E86\uFF1B\u539F\u7406\u56FE\u540C\u7406\u770B\u6807\u7B7E\u91CD\u53E0\u3001\u56FE\u6846\u7EBF\u7A7F\u8FC7\u5668\u4EF6\u3002",
+  "4. \u5750\u6807\u7B97\u672F\u4E0E\u76F4\u89C9\u51B2\u7A81\u65F6\uFF08\u5DE5\u5177\u8BF4\u5728\u6846\u5185\u4F46\u4F60\u6000\u7591\u8D8A\u754C\u3001audit \u8BF4\u6CA1\u95EE\u9898\u4F46\u7528\u6237\u8BF4\u96BE\u770B\uFF09\uFF1A\u8FD9\u65F6\u56FE\u662F\u552F\u4E00\u88C1\u51B3\u8005\u3002",
+  "",
+  "**\u4E0D\u8981\u770B\u56FE**",
+  "",
+  "- \u6BCF\u653E\u4E00\u4E2A\u56FE\u5143\u5C31\u622A\u4E00\u6B21\uFF1A\u5355\u6B21\u7EA6 2.7 s\u30010.4 MB\uFF0C\u8FD8\u4F1A\u6324\u5360\u4E0A\u4E0B\u6587\u9884\u7B97\u2014\u2014\u6279\u91CF\u6539\u5B8C\u518D\u622A\u3002",
+  "- \u53EA\u662F\u786E\u8BA4\u67D0\u4E2A\u8FD4\u56DE\u503C/\u5C5E\u6027\uFF1A\u7528 eda_get_* \u8BFB\u6570\u636E\u6BD4\u56FE\u51C6\u3002",
+  "- DRC \u5DF2\u7ED9\u51FA primitiveId/\u5750\u6807\u7684\u9519\u8BEF\uFF1A\u76F4\u63A5\u5B9A\u4F4D\uFF0C\u4E0D\u7528\u56FE\u3002",
+  "",
+  "**\u770B\u5B8C\u7ACB\u523B\u5220**\uFF1Aeda_capture({cleanup:true})\u3002",
+  "",
   "## \u6821\u9A8C\u987A\u5E8F",
   "",
   "1. eda_get_active_document \u786E\u8BA4\u5728\u539F\u7406\u56FE\u9875\uFF08\u4E0D\u662F HOME/PCB\uFF09\u3002",
@@ -332,7 +807,7 @@ var WORKFLOW_GUIDE = WORKFLOW_SUMMARY + "\n\n" + [
 ].join("\n");
 
 // src/bridge/index.ts
-var VERSION = "0.4.2";
+var VERSION = "0.4.6";
 var WS_PORT = Number(process.env.DSH_EDA_MCP_WS_PORT ?? 39009);
 var WS_HOST = "127.0.0.1";
 var ALLOW_RAW_API = (process.env.DSH_EDA_MCP_ALLOW_RAW_API ?? "1") !== "0";
@@ -608,16 +1083,24 @@ var TOOLS = [
   { name: "eda_get_active_document", description: "Return the document/tab that is currently active (documentType, uuid, tabId, parent project). Most tab-dependent APIs (sch_Net.*, netlist export, DRC) only work when the matching document is active - use eda_open_document to switch.", inputSchema: objectSchema({}) },
   { name: "eda_open_document", description: "Open/activate a document tab by uuid (dmt_EditorControl.openDocument). Works for a schematic page or a PCB, so tab-dependent APIs can run.", inputSchema: objectSchema({ documentUuid: { type: "string" }, splitScreenId: { type: "string" } }, ["documentUuid"]) },
   { name: "eda_get_net_labels", description: "List every label-like primitive on the active schematic page: attribute primitives (netlabel/netport/netflag) PLUS plain texts left by the createNetLabel fallback, so they can be audited and deleted. Reports kind/primitiveId/net per entry.", inputSchema: objectSchema({ parentPrimitiveId: { type: "string" } }) },
-  { name: "eda_place_net_label", description: "Place a net label at x/y. The real API (sch_PrimitiveAttribute.createNetLabel) is probed once per session; when the build never answers, a plain TEXT label is placed instead, which carries no electrical meaning and must be paired with a stub wire. Pass probe:true to re-check.", inputSchema: objectSchema({ x: { type: "number" }, y: { type: "number" }, net: { type: "string" }, fontSize: { type: "number" }, rotation: { type: "integer", enum: [0, 90, 180, 270] } }, ["x", "y", "net"]) },
-  { name: "eda_place_net_labels", description: "Place many net labels in ONE call (per-pin or by coordinate) and report done/failed per item: a 133-label schematic used to exceed the caller timeout with no progress. items: [{ pinPrimitiveId, net, stubLength?, offsetX?, offsetY? }] or [{ x, y, net, fontSize? }].", inputSchema: objectSchema({ items: { type: "array", items: { type: "object", additionalProperties: true } }, probe: { type: "boolean" }, concurrency: { type: "integer", minimum: 1, maximum: 8 } }, ["items"]) },
+  { name: "eda_place_net_label", description: "Place a net label at x/y. The real API (sch_PrimitiveAttribute.createNetLabel) is probed once per session; when the build never answers, a plain TEXT label is placed instead, which carries no electrical meaning and must be paired with a stub wire. Pass probe:true to re-check.", inputSchema: objectSchema({ x: { type: "number" }, y: { type: "number" }, net: { type: "string" }, fontSize: { type: "number" }, rotation: { type: "integer", enum: [0, 90, 180, 270] }, probe: { type: "boolean" }, textLabel: { type: "boolean" } }, ["x", "y", "net"]) },
+  { name: "eda_place_net_labels", description: "Place many net labels in ONE call (per-pin or by coordinate) and report done/failed per item: a 133-label schematic used to exceed the caller timeout with no progress. items: [{ pinPrimitiveId, net, stubLength?, offsetX?, offsetY? }] or [{ x, y, net, fontSize? }].", inputSchema: objectSchema({ items: { type: "array", items: { type: "object", additionalProperties: true } }, probe: { type: "boolean" }, textLabel: { type: "boolean" }, concurrency: { type: "integer", minimum: 1, maximum: 8 } }, ["items"]) },
   { name: "eda_run_drc", description: 'Run schematic DRC with includeVerboseError. On EDA 3.2.186 the app still returns AGGREGATED entries ({type:"warn",count:N}) with no primitiveId/coordinates, so entries are reported as-is and raw keeps the untouched payload; expect counts plus a hint until the app exposes details.', inputSchema: objectSchema({ strict: { type: "boolean" } }) },
   { name: "eda_auto_layout", description: "Run schematic auto-layout (sch_Document.autoLayout). DISABLED by default: automated layout is not used unless the user asks for it. Pass force:true only then.", inputSchema: objectSchema({ uuids: { type: "array", items: { type: "string" } }, force: { type: "boolean" } }) },
   { name: "eda_auto_route", description: "Run schematic auto-routing (sch_Document.autoRouting). DISABLED by default: route by hand unless the user explicitly asks. Pass force:true only then.", inputSchema: objectSchema({ uuids: { type: "array", items: { type: "string" } }, force: { type: "boolean" } }) },
   { name: "eda_export_netlist", description: "Export the schematic netlist as text (default JLCEDA format). Returns null when no schematic is active - check eda_get_active_document / open the schematic page first.", inputSchema: objectSchema({ type: { type: "string" } }) },
   { name: "eda_export_bom", description: "Export the schematic BOM. csv is decoded from UTF-16 to readable text; xlsx returns a base64 data URL.", inputSchema: objectSchema({ format: { type: "string", enum: ["csv", "xlsx"] } }) },
   { name: "eda_move_component", description: "Move/rotate/mirror a schematic component (sch_PrimitiveComponent.modify) without deleting and re-placing it, so the designator and value survive.", inputSchema: objectSchema({ primitiveId: { type: "string" }, x: { type: "number" }, y: { type: "number" }, rotation: { type: "number" }, mirror: { type: "boolean" } }, ["primitiveId"]) },
+  { name: "pcb_draw_text", description: "Put text on a PCB layer - silkscreen by default (3 top silk / 4 bottom silk). Use it for pin functions, board markings, version and fabrication notes; silkscreen text must not cover pads.", inputSchema: objectSchema({ x: { type: "number" }, y: { type: "number" }, text: { type: "string" }, layer: { type: "string" }, fontSize: { type: "number" }, lineWidth: { type: "number" }, rotation: { type: "number" }, mirror: { type: "boolean" }, alignMode: { type: "integer" }, locked: { type: "boolean" } }, ["x", "y", "text"]) },
+  { name: "pcb_draw_mounting_hole", description: 'Place a NON-plated mounting hole or a slot (pcb_PrimitivePad with metallization:false). shape "round" is a drill-sized hole, shape "slot" an oval cut-out. Use this for mounting holes and connector slots instead of hacking the board outline.', inputSchema: objectSchema({ x: { type: "number" }, y: { type: "number" }, diameter: { type: "number" }, shape: { type: "string", enum: ["round", "slot"] }, slotLength: { type: "number" }, rotation: { type: "number" }, plated: { type: "boolean" }, annulus: { type: "number" }, padNumber: { type: "string" }, layer: { type: "string" } }, ["x", "y", "diameter"]) },
+  { name: "eda_schematic_audit", description: "Geometry audit of the active schematic page (the netlist ERC only judges connectivity): symbols outside the frame, symbols overlapping the title block, body-on-body symbol overlap, off-grid placement, and labels anchored inside a symbol body. Read-only; pair it with eda_netlist_erc before routing.", inputSchema: objectSchema({ grid: { type: "number" }, includeOk: { type: "boolean" } }) },
+  { name: "eda_delivery_checklist", description: "Delivery checklist: run connectivity (eda_netlist_erc), PCB audit + DRC, Gerber export and BOM export in ONE read-only call and report per-step pass/fail with counts. Pass outPath to also write a Markdown report you can hand to a reviewer. Use it instead of claiming a board is finished.", inputSchema: objectSchema({ outPath: { type: "string" }, pcbDrc: { type: "boolean" } }) },
+  { name: "eda_design_intake", description: "Requirement intake for a new board: call it BEFORE placing anything when the request is vague (for example: draw me an X board). Without answers it returns the questions in 6 sections (power, core, IO, mechanical, process, delivery), each marked critical or fallback-able with the reason it changes the drawing; pass answers:{questionId:value} to record them and see what is still missing. Ask the user with ask_user_question for the critical ones instead of guessing.", inputSchema: objectSchema({ answers: { type: "object", additionalProperties: true }, reset: { type: "boolean" } }) },
+  { name: "eda_netlist_erc", description: "Read-only electrical smoke test over the schematic NETLIST (no application DRC needed): duplicate designators, unconnected pins, single-endpoint nets, shorted parts, power rails and decoupling, USB D+/D- pair, crystal (two nets + load caps + reaches the MCU), reset RC, BOOT pull resistor, Type-C CC pull-downs. DRC can be clean while the circuit is still wrong; these failures all show up in the netlist. Pass includeOk:true to see passing checks too.", inputSchema: objectSchema({ includeOk: { type: "boolean" } }) },
+  { name: "eda_pcb_canvas_origin", description: "Read (or align) the PCB canvas origin and convert points between the two coordinate spaces. JLCEDA displays CANVAS coordinates in its UI but every API takes DATA coordinates; the two differ by this offset, so a coordinate read off the screen will land somewhere else unless you convert or align. align:true calls setCanvasOrigin(0,0) so the display matches the API.", inputSchema: objectSchema({ align: { type: "boolean" }, offsetX: { type: "number" }, offsetY: { type: "number" }, point: { type: "object", additionalProperties: true } }) },
+  { name: "eda_capture", description: "Render the active document to a PNG (dmt_EditorControl.getCurrentRenderedAreaImage) and write it to outPath or return a data URL. Use it to LOOK at the sheet/board instead of trusting coordinate math. The PNG is a scratch file: read it, then call eda_capture({cleanup:true}) to delete every capture path this session wrote.", inputSchema: objectSchema({ outPath: { type: "string" }, inline: { type: "boolean" }, cleanup: { type: "boolean" } }) },
   { name: "eda_workflow_guide", description: "Return the schematic working standard: grid-aligned manual placement, signal flow, when net labels/ports are required (a wire net name is overridden by connectivity), net-label fallback behaviour, batch placement and the verification order. Read it before laying out a sheet.", inputSchema: objectSchema({}) },
-  { name: "eda_list_api_methods", description: 'List every API method the connected extension accepts (its allow-list). Call it when eda_api_call answers "API method not allowed".', inputSchema: objectSchema({}) },
+  { name: "eda_list_api_methods", description: "Ask the CONNECTED EXTENSION for the API methods it accepts right now (dsh.internal.listApiMethods) and report source/version/counts. Falls back to the bridge copy with stale:true only when the extension is an older zip. Use refresh:true to re-query.", inputSchema: objectSchema({ refresh: { type: "boolean" } }) },
   { name: "eda_delete_primitive", description: 'Delete a schematic primitive by kind and primitive id. Net ports, net flags and net labels are attribute primitives and need kind "netport"/"netflag"/"netlabel"; the text fallback labels are kind "text".', inputSchema: objectSchema({ kind: { type: "string", enum: ["component", "wire", "rectangle", "circle", "arc", "polygon", "text", "netport", "netflag", "netlabel"] }, primitiveId: { type: "string" } }, ["kind", "primitiveId"]) },
   { name: "eda_create_board", description: "Create a board linking a schematic and a PCB (dmt_Board.createBoard).", inputSchema: objectSchema({ schematicUuid: { type: "string" }, pcbUuid: { type: "string" } }) },
   { name: "eda_api_call", description: "Call an allow-listed JLCEDA Pro extension API method directly.", inputSchema: objectSchema({ method: { type: "string" }, args: { type: "array" } }, ["method", "args"]) },
@@ -812,6 +1295,30 @@ async function pcbComponentIds(timeoutMs) {
   return Array.isArray(raw) ? raw.map(String) : [];
 }
 var nextCallId = 1;
+var extensionApiCache = null;
+var designBrief = null;
+var capturedFiles = [];
+async function extensionApiMethods(timeoutMs, refresh = false) {
+  if (!refresh && extensionApiCache !== null) return extensionApiCache;
+  try {
+    const raw = await callExtension("dsh.internal.listApiMethods", [], Math.min(timeoutMs, 5e3));
+    const record = asRecord(raw);
+    const allowed = Array.isArray(record.allowed) ? record.allowed.map(String) : [];
+    const files = Array.isArray(record.files) ? record.files.map(String) : [];
+    if (allowed.length === 0 && files.length === 0) return void 0;
+    extensionApiCache = {
+      version: typeof record.version === "string" ? record.version : null,
+      allowed,
+      files,
+      all: [...allowed, ...files].sort(),
+      allowedSet: new Set(allowed),
+      fileSet: new Set(files)
+    };
+    return extensionApiCache;
+  } catch {
+    return void 0;
+  }
+}
 var CLIENT_STALE_MS = 6e4;
 function pickClients() {
   const now = Date.now();
@@ -956,6 +1463,7 @@ var PCB_LAYERS = {
   topAssembly: 9,
   bottomAssembly: 10,
   boardOutline: 11,
+  multi: 12,
   document: 13,
   mechanical: 14
 };
@@ -997,6 +1505,33 @@ function resolveRegionLayer(value, tool) {
   }
   return layer;
 }
+var BRIEF_TAG = "[dsh-eda-spec]";
+function briefBlock(brief) {
+  return BRIEF_TAG + " " + JSON.stringify(brief);
+}
+function parseBriefBlock(description) {
+  const text = typeof description === "string" ? description : "";
+  const index = text.indexOf(BRIEF_TAG);
+  if (index < 0) return null;
+  const body = text.slice(index + BRIEF_TAG.length).trim();
+  const close = body.indexOf("}");
+  try {
+    const parsed = JSON.parse(close < 0 ? body : body.slice(0, close + 1));
+    return parsed !== null && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+async function fetchParsedNetlist(timeoutMs) {
+  const payload = await callExtension("sch_ManufactureData.getNetlistFile", [void 0, void 0], timeoutMs);
+  const text = typeof payload === "string" ? payload : payload !== null && typeof payload === "object" && typeof payload.text === "string" ? payload.text : void 0;
+  if (text === void 0) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
 function buildPolygonSource(points) {
   const source = [points[0], points[1], "L"];
   for (let i = 2; i < points.length; i += 2) source.push(points[i], points[i + 1]);
@@ -1054,6 +1589,7 @@ async function auditPcb(args, timeoutMs) {
   const vias = await pcbPrimitiveList("pcb_PrimitiveVia.getAll", [netFilter, void 0], timeoutMs);
   const pours = await pcbPrimitiveList("pcb_PrimitivePour.getAll", [netFilter, void 0, void 0], timeoutMs);
   const outline = await pcbPrimitiveList("pcb_PrimitivePolyline.getAll", [void 0, PCB_LAYERS.boardOutline, void 0], timeoutMs);
+  const pcbComponents = await pcbPrimitiveList("pcb_PrimitiveComponent.getAll", [void 0, void 0], timeoutMs);
   const violations = [];
   const warnings = [];
   const add = (bucket, rule, message, samples) => {
@@ -1101,6 +1637,73 @@ async function auditPcb(args, timeoutMs) {
   }
   if (outline.length === 0) violations.push({ rule: "board-outline", message: "No board outline on layer 11: auto-routing and Gerber export need a closed outline (pcb_draw_board_outline)", count: 1, samples: [] });
   if (pours.length === 0) warnings.push({ rule: "copper-pour", message: "No copper pour: a GND pour on the top/bottom layer is the recommended way to carry ground (eda_pcb_create_pour)", count: 1, samples: [] });
+  try {
+    const silk = await callExtension("pcb_PrimitiveString.getAll", [PCB_LAYERS.topSilkscreen], timeoutMs);
+    const silkCount = Array.isArray(silk) ? silk.length : 0;
+    if (silkCount === 0) {
+      warnings.push({ rule: "silkscreen-text", message: "No silkscreen text primitive: the official example board carries 19 (function labels, version, fab notes). Add board identity and pin functions with pcb_draw_text." });
+    }
+  } catch {
+  }
+  try {
+    const pads = await callExtension("pcb_PrimitivePad.getAll", [PCB_LAYERS.multi], timeoutMs);
+    const holes = (Array.isArray(pads) ? pads : []).filter((pad) => (pad?.metallization ?? pad?.Metallization) === false);
+    const flatX = [];
+    for (const entry of outline) {
+      const source = entry?.polygon?.polygon ?? entry?.Polygon?.polygon ?? [];
+      for (let i = 0; i + 1 < source.length; i += 2) {
+        if (typeof source[i] === "number") flatX.push(source[i]);
+      }
+    }
+    const wide = flatX.length > 0 ? Math.max(...flatX) - Math.min(...flatX) : 0;
+    if (holes.length === 0 && wide > 1200) {
+      warnings.push({ rule: "mounting-hole", message: "No non-plated mounting hole on a board wider than 1200 mil: use pcb_draw_mounting_hole (3.2 mm) in the corners." });
+    }
+  } catch {
+  }
+  const boundsOfComponent = (entry) => {
+    const x = Number(entry?.x ?? entry?.X);
+    const y = Number(entry?.y ?? entry?.Y);
+    const w = Number(entry?.width ?? entry?.Width);
+    const h = Number(entry?.height ?? entry?.Height);
+    if (![x, y, w, h].every(Number.isFinite) || w <= 0 || h <= 0) return void 0;
+    return { left: x - w / 2, right: x + w / 2, bottom: y - h / 2, top: y + h / 2 };
+  };
+  const bodies = pcbComponents.map((entry) => ({
+    name: String(entry?.designator ?? entry?.Designator ?? entry?.primitiveId ?? "?"),
+    bounds: boundsOfComponent(entry)
+  })).filter((entry) => entry.bounds !== void 0);
+  if (bodies.length >= 2) {
+    for (let i = 0; i < bodies.length; i++) {
+      for (let j = i + 1; j < bodies.length; j++) {
+        const a = bodies[i].bounds;
+        const b = bodies[j].bounds;
+        const sharedX = Math.min(a.right, b.right) - Math.max(a.left, b.left);
+        const sharedY = Math.min(a.top, b.top) - Math.max(a.bottom, b.bottom);
+        if (sharedX > 2 && sharedY > 2) add(violations, "component-overlap", "Two component bodies overlap; a placement collision here becomes a placement error at assembly.", [bodies[i].name + " x " + bodies[j].name]);
+      }
+    }
+  }
+  const outlineX = [];
+  const outlineY = [];
+  for (const entry of outline) {
+    const source = entry?.polygon?.polygon ?? entry?.Polygon?.polygon ?? [];
+    for (let i = 0; i + 1 < source.length; i += 2) {
+      if (typeof source[i] === "number") {
+        outlineX.push(source[i]);
+        outlineY.push(source[i + 1]);
+      }
+    }
+  }
+  if (bodies.length > 0 && outlineX.length >= 3) {
+    const box = { left: Math.min(...outlineX), right: Math.max(...outlineX), bottom: Math.min(...outlineY), top: Math.max(...outlineY) };
+    for (const body of bodies) {
+      const b = body.bounds;
+      if (b.left < box.left - 5 || b.right > box.right + 5 || b.bottom < box.bottom - 5 || b.top > box.top + 5) {
+        add(warnings, "component-off-board", "A component body extends past the board outline; on a real assembly it either hangs in the air or collides with the enclosure.", [body.name]);
+      }
+    }
+  }
   let drc = { ran: false, reason: null, violationCount: null };
   if (args.drc !== false) {
     try {
@@ -1249,7 +1852,7 @@ async function clearRoutingBatched(args, type, timeoutMs) {
     hint: remaining <= 0 ? "Routing cleared." : "Call eda_pcb_clear_routing again (same arguments) until done=true."
   };
 }
-async function parseNetlist(previous, timeoutMs) {
+async function parseNetlist2(previous, timeoutMs) {
   let text;
   try {
     text = await callExtension("sch_Netlist.getNetlist", [void 0], timeoutMs);
@@ -1289,6 +1892,9 @@ async function placeNetLabel(net, x, y, fontSize, timeoutMs, options = {}) {
       netLabelSupport = false;
     }
   }
+  if (options.textLabel !== true) {
+    return { method: "stub", net, x, y, created: false, warning: "createNetLabel is unavailable on this EDA build (" + (failure ?? "probe already failed this session") + "); the net is carried by the stub wire, and no text label was added (pass textLabel:true if you want one)." };
+  }
   const raw = await callExtension("sch_PrimitiveText.create", [x, y, net, 0, null, null, size, false, false, false, 1], timeoutMs);
   const label = summarizePrimitive(raw);
   if (label.primitiveId !== void 0) {
@@ -1935,6 +2541,18 @@ async function executeTool(name, rawArgs, timeoutMs) {
           }
         }
       }
+      if (designBrief === null) {
+        const intake = buildIntake(null);
+        return {
+          primitiveId,
+          result: result2,
+          intakeWarning: {
+            message: "No design parameters confirmed this session: supply, MCU, clocks, connectors, board size, layer count and fabrication were not agreed. Confirm them with eda_design_intake + ask_user_question before continuing, or the board may be electrically correct and practically wrong.",
+            criticalCount: intake.criticalCount,
+            firstMissing: intake.missingCritical.slice(0, 8)
+          }
+        };
+      }
       return { primitiveId, result: result2 };
     }
     case "eda_place_net_flag": {
@@ -1997,7 +2615,10 @@ async function executeTool(name, rawArgs, timeoutMs) {
       const x = Number(args.x);
       const y = Number(args.y);
       if (!Number.isFinite(x) || !Number.isFinite(y)) throw new Error("eda_place_net_label requires numeric x/y");
-      return await placeNetLabel(String(args.net), x, y, args.fontSize, timeoutMs, { probe: args.probe === true });
+      return await placeNetLabel(String(args.net), x, y, args.fontSize, timeoutMs, {
+        probe: args.probe === true,
+        textLabel: args.textLabel === true
+      });
     }
     case "eda_place_net_labels": {
       const items = Array.isArray(args.items) ? args.items.map(asRecord) : [];
@@ -2006,7 +2627,10 @@ async function executeTool(name, rawArgs, timeoutMs) {
       const results = await mapLimit(items, concurrency, async (item) => {
         const net = item.net === void 0 ? "" : String(item.net);
         try {
-          const placed = item.pinPrimitiveId !== void 0 ? await placeAtPin("eda_place_net_label_at_pin", { ...item, net }, timeoutMs) : await placeNetLabel(net, Number(item.x), Number(item.y), item.fontSize, timeoutMs, { probe: args.probe === true });
+          const placed = item.pinPrimitiveId !== void 0 ? await placeAtPin("eda_place_net_label_at_pin", { ...item, net }, timeoutMs) : await placeNetLabel(net, Number(item.x), Number(item.y), item.fontSize, timeoutMs, {
+            probe: args.probe === true,
+            textLabel: args.textLabel === true
+          });
           return { ok: true, net, ...placed };
         } catch (error) {
           return { ok: false, net, error: error instanceof Error ? error.message : String(error) };
@@ -2086,13 +2710,15 @@ async function executeTool(name, rawArgs, timeoutMs) {
         activeUuid = String(pickValue(info, "uuid", "Uuid") ?? "");
       } catch {
       }
-      const tabOpened = tabIds.length > 1 || activeUuid !== "" && activeUuid !== "0";
+      const activeIsTarget = activeUuid === documentUuid;
+      const tabOpened = activeIsTarget || tabIds.some((tab) => tab.startsWith(documentUuid + "@"));
       return {
         ...raw !== null && typeof raw === "object" ? raw : { result: raw ?? null },
         opened: tabOpened,
+        activated: activeIsTarget,
         activeDocumentUuid: activeUuid || null,
         tabIds,
-        hint: tabOpened ? null : "The app accepted openDocument but created no editor tab (only the Start Page is open). This build does not open a document programmatically from the HOME screen: open the schematic/PCB page once in the app (double-click the project), then retry. Do not assume the page is active."
+        hint: tabOpened ? null : "The app accepted openDocument but the document is not active (activeDocumentUuid=" + (activeUuid || "unknown") + ", tabs: " + (tabIds.join(", ") || "none") + "). After an app restart the editor sits on the Start Page: open the project first (eda_open_project), then open the document. This build cannot open a document from the HOME screen programmatically, so never assume a page is active without checking activeDocumentUuid."
       };
     }
     case "eda_set_no_connect": {
@@ -2275,7 +2901,7 @@ async function executeTool(name, rawArgs, timeoutMs) {
       const all = await callExtension("sch_Net.getAllNets", [], timeoutMs);
       if (Array.isArray(all) && all.length > 0) return { source: "sch_Net.getAllNets", count: all.length, nets: all };
       if (args.parseNetlist === false) return { source: "sch_Net.*", count: 0, nets: [], hint: NET_EMPTY_HINT };
-      const parsed = await parseNetlist(Array.isArray(all) ? all : project, timeoutMs);
+      const parsed = await parseNetlist2(Array.isArray(all) ? all : project, timeoutMs);
       return parsed;
     }
     case "eda_run_drc": {
@@ -2342,6 +2968,9 @@ async function executeTool(name, rawArgs, timeoutMs) {
       const payload = await callExtension("sch_ManufactureData.getBomFile", [void 0, format], toolTimeout(args, timeoutMs));
       if (format === "xlsx") return payload;
       const raw = typeof payload === "string" ? payload : payload !== null && typeof payload === "object" && typeof payload.text === "string" ? payload.text : "";
+      if (raw === "") {
+        throw new Error("eda_export_bom: no BOM data (the schematic page must be the active document; call eda_get_active_document, then eda_open_document on the schematic page and retry)");
+      }
       const encoding = payload !== null && typeof payload === "object" ? payload.encoding : void 0;
       return { format, bom: decodeTextPayload(raw), encoding: encoding ?? "unknown" };
     }
@@ -2357,10 +2986,332 @@ async function executeTool(name, rawArgs, timeoutMs) {
         rotation: args.rotation === void 0 ? void 0 : Number(args.rotation),
         mirror: args.mirror === void 0 ? void 0 : Boolean(args.mirror)
       }], timeoutMs);
-    case "eda_list_api_methods":
-      return { count: ALLOWED_API.size, methods: [...ALLOWED_API].sort() };
-    case "eda_workflow_guide":
-      return { summary: WORKFLOW_SUMMARY, guide: WORKFLOW_GUIDE, autoLayoutAllowed: ALLOW_AUTO_LAYOUT };
+    case "eda_list_api_methods": {
+      const live = await extensionApiMethods(timeoutMs, args.refresh === true);
+      if (live !== void 0) {
+        return {
+          source: "extension",
+          extensionVersion: live.version,
+          count: live.all.length,
+          allowedCount: live.allowed.length,
+          fileCount: live.files.length,
+          fileMethods: live.files,
+          methods: live.all,
+          note: "This is the list the connected extension enforces (dsh.internal.listApiMethods). sendable:true means eda_api_call will forward it."
+        };
+      }
+      return {
+        source: "bridge-local-copy",
+        stale: true,
+        count: ALLOWED_API.size,
+        methods: [...ALLOWED_API].sort(),
+        note: "The connected extension does not expose its list (older zip), so this is the bridge copy \u2014 it may be narrower than what the extension accepts. eda_api_call forwards unknown methods and reports the extension verdict, so try the call instead of trusting this list."
+      };
+    }
+    case "pcb_draw_text": {
+      const text = String(args.text ?? "");
+      if (text.trim() === "") throw new Error("pcb_draw_text requires text");
+      if (text.length > 200) throw new Error("pcb_draw_text: longer than 200 characters is probably a mistake; split it");
+      const silkLayer = args.layer === void 0 ? PCB_LAYERS.topSilkscreen : resolvePcbLayer(args.layer);
+      const fontSize = args.fontSize === void 0 ? 40 : Number(args.fontSize);
+      return await callExtension("pcb_PrimitiveString.create", [
+        silkLayer,
+        Number(args.x),
+        Number(args.y),
+        text,
+        "Arial",
+        fontSize,
+        args.lineWidth === void 0 ? Math.max(6, Math.round(fontSize / 6)) : Number(args.lineWidth),
+        args.alignMode === void 0 ? 1 : Number(args.alignMode),
+        args.rotation === void 0 ? 0 : Number(args.rotation),
+        false,
+        0,
+        Boolean(args.mirror ?? false),
+        Boolean(args.locked ?? false)
+      ], timeoutMs);
+    }
+    case "pcb_draw_mounting_hole": {
+      const holeX = Number(args.x);
+      const holeY = Number(args.y);
+      const holeDiameter = Number(args.diameter);
+      if (![holeX, holeY, holeDiameter].every((value) => Number.isFinite(value)) || holeDiameter <= 0) {
+        throw new Error("pcb_draw_mounting_hole requires numeric x/y and a positive diameter (mil)");
+      }
+      if (holeDiameter < 20) throw new Error("pcb_draw_mounting_hole: " + holeDiameter + " mil is smaller than any drill (>= 20 mil)");
+      const holeShape = String(args.shape ?? "round");
+      const holeRotation = args.rotation === void 0 ? 0 : Number(args.rotation);
+      const metallization = args.plated === true;
+      let holeSpec;
+      if (holeShape === "slot") {
+        const slotLength = args.slotLength === void 0 ? holeDiameter * 2 : Number(args.slotLength);
+        if (!Number.isFinite(slotLength) || slotLength <= holeDiameter) {
+          throw new Error("pcb_draw_mounting_hole: slotLength must exceed the slot width (diameter)");
+        }
+        holeSpec = ["SLOT", holeDiameter, slotLength];
+      } else {
+        holeSpec = ["ROUND", holeDiameter];
+      }
+      const holeLayer = args.layer === void 0 ? PCB_LAYERS.multi : resolvePcbLayer(args.layer);
+      const annulus = args.annulus === void 0 ? 0 : Number(args.annulus);
+      if (!Number.isFinite(annulus) || annulus < 0) throw new Error("pcb_draw_mounting_hole: annulus must be >= 0 (mil)");
+      const slotLengthValue = args.slotLength === void 0 ? holeDiameter * 2 : Number(args.slotLength);
+      const padShape = holeShape === "slot" ? ["ELLIPSE", slotLengthValue + annulus * 2, holeDiameter + annulus * 2] : ["ELLIPSE", holeDiameter + annulus * 2, holeDiameter + annulus * 2];
+      return await callExtension("pcb_PrimitivePad.create", [
+        holeLayer,
+        String(args.padNumber ?? ""),
+        holeX,
+        holeY,
+        holeRotation,
+        padShape,
+        void 0,
+        holeSpec,
+        0,
+        0,
+        0,
+        metallization,
+        void 0,
+        void 0,
+        void 0,
+        void 0,
+        false
+      ], timeoutMs);
+    }
+    case "eda_schematic_audit": {
+      const paper = paperOf(args.paper);
+      const rawList = await callExtension("sch_PrimitiveComponent.getAll", [], timeoutMs);
+      const list = Array.isArray(rawList) ? rawList.slice(0, 200) : [];
+      const components = [];
+      for (let index = 0; index < list.length; index += 1) {
+        const entry = list[index] ?? {};
+        const designator = String(entry.designator ?? entry.Designator ?? entry.name ?? "#" + index);
+        const id = String(entry.primitiveId ?? entry.PrimitiveId ?? "");
+        let bounds;
+        if (id !== "") {
+          const box = await bboxOf([id], timeoutMs);
+          if (box !== void 0) bounds = { left: box.minX, right: box.maxX, bottom: box.minY, top: box.maxY };
+        }
+        components.push({ designator, x: Number(entry.x ?? entry.X ?? 0), y: Number(entry.y ?? entry.Y ?? 0), bounds });
+      }
+      const report = auditSchematicGeometry({
+        components,
+        frame: paper.frame,
+        titleBlock: paper.titleBlock,
+        grid: args.grid === void 0 ? 10 : Number(args.grid)
+      });
+      const checks = args.includeOk === true ? report.checks : report.checks.filter((check) => check.status !== "pass");
+      return {
+        ok: report.ok,
+        counts: report.counts,
+        componentCount: report.componentCount,
+        boxesRead: components.filter((component) => component.bounds !== void 0).length,
+        checks
+      };
+    }
+    case "eda_delivery_checklist": {
+      const steps = [];
+      const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+      let netlistErc = null;
+      try {
+        const parsedNetlist = await fetchParsedNetlist(timeoutMs);
+        netlistErc = runNetlistErc(parsedNetlist);
+        steps.push({ step: "netlist-erc", ok: netlistErc.ok, detail: netlistErc.counts, failing: netlistErc.checks.filter((check) => check.status === "fail").map((check) => check.id) });
+      } catch (error) {
+        steps.push({ step: "netlist-erc", ok: false, error: error instanceof Error ? error.message : String(error) });
+      }
+      let pcbAudit = null;
+      try {
+        pcbAudit = await auditPcb({ drc: args.pcbDrc !== false }, timeoutMs);
+        steps.push({
+          step: "pcb-audit",
+          ok: Array.isArray(pcbAudit.violations) && pcbAudit.violations.length === 0,
+          detail: { violations: pcbAudit.violations?.length ?? null, warnings: pcbAudit.warnings?.length ?? null, drc: pcbAudit.drc },
+          failing: (pcbAudit.violations ?? []).map((entry) => entry.rule)
+        });
+      } catch (error) {
+        steps.push({ step: "pcb-audit", ok: false, error: error instanceof Error ? error.message : String(error) });
+      }
+      let gerber = null;
+      try {
+        const payload = await callExtension("pcb_ManufactureData.getGerberFile", [void 0, void 0, void 0, void 0, void 0, void 0], timeoutMs);
+        const bytes = payload && typeof payload === "object" ? Number(payload.size ?? payload.bytes ?? 0) : typeof payload === "string" ? payload.length : 0;
+        gerber = { bytes, ok: bytes > 1e3 };
+        steps.push({ step: "gerber", ok: gerber.ok, detail: { bytes } });
+      } catch (error) {
+        steps.push({ step: "gerber", ok: false, error: error instanceof Error ? error.message : String(error) });
+      }
+      let bom = null;
+      try {
+        const payload = await callExtension("sch_ManufactureData.getBomFile", [void 0, "csv"], timeoutMs);
+        const text = typeof payload === "string" ? payload : typeof payload?.text === "string" ? payload.text : "";
+        const lines = text === "" ? 0 : text.split(/\r?\n/).filter((line) => line.trim() !== "").length;
+        bom = { rows: Math.max(0, lines - 1), ok: lines > 1 };
+        steps.push({ step: "bom", ok: bom.ok, detail: { rows: bom.rows } });
+      } catch (error) {
+        steps.push({ step: "bom", ok: false, error: error instanceof Error ? error.message : String(error) });
+      }
+      const failed = steps.filter((step) => step.ok !== true);
+      const report = {
+        ok: failed.length === 0,
+        startedAt,
+        finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        steps,
+        netlistErc: netlistErc === null ? null : { ok: netlistErc.ok, counts: netlistErc.counts, componentCount: netlistErc.componentCount, netCount: netlistErc.netCount },
+        pcbAudit: pcbAudit === null ? null : { violations: pcbAudit.violations, warnings: pcbAudit.warnings },
+        gerber,
+        bom
+      };
+      const outPath = args.outPath === void 0 ? "" : String(args.outPath).trim();
+      if (outPath !== "") {
+        const markdown = [
+          "# \u4EA4\u4ED8\u68C0\u67E5\u62A5\u544A",
+          "",
+          "- \u5F00\u59CB\uFF1A" + report.startedAt,
+          "- \u7ED3\u675F\uFF1A" + report.finishedAt,
+          "- \u7ED3\u8BBA\uFF1A" + (report.ok ? "PASS\uFF08\u53EF\u4EE5\u4E0B\u5355\uFF09" : "FAIL\uFF08\u6709\u672A\u901A\u8FC7\u9879\uFF09"),
+          "",
+          "| \u6B65\u9AA4 | \u7ED3\u679C | \u8BF4\u660E |",
+          "|---|---|---|",
+          ...steps.map((step) => "| " + step.step + " | " + (step.ok === true ? "PASS" : "FAIL") + " | " + JSON.stringify(step.detail ?? step.error ?? {}) + " |"),
+          "",
+          "## \u7535\u6C14\u68C0\u67E5\uFF08eda_netlist_erc\uFF09",
+          "",
+          ...netlistErc === null ? ["\uFF08\u672A\u6267\u884C\uFF09"] : netlistErc.checks.map((check) => "- [" + check.status + "] " + check.id + "\uFF1A" + check.message),
+          "",
+          "## PCB \u5BA1\u8BA1",
+          "",
+          ...pcbAudit === null ? ["\uFF08\u672A\u6267\u884C\uFF09"] : [
+            "- \u8FDD\u89C4\uFF1A" + (pcbAudit.violations ?? []).length,
+            "- \u8B66\u544A\uFF1A" + (pcbAudit.warnings ?? []).length,
+            ...(pcbAudit.violations ?? []).map((entry) => "  - " + entry.rule + "\uFF1A" + entry.message),
+            ...(pcbAudit.warnings ?? []).map((entry) => "  - (warn) " + entry.rule + "\uFF1A" + entry.message)
+          ],
+          "",
+          "## \u5236\u9020\u6587\u4EF6",
+          "",
+          "- Gerber\uFF1A" + (gerber === null ? "\u672A\u5BFC\u51FA" : gerber.bytes + " \u5B57\u8282"),
+          "- BOM\uFF1A" + (bom === null ? "\u672A\u5BFC\u51FA" : bom.rows + " \u884C"),
+          ""
+        ].join("\n");
+        await writeFile(outPath, markdown);
+        report.reportPath = outPath;
+      }
+      return report;
+    }
+    case "eda_design_intake": {
+      if (args.reset === true) designBrief = null;
+      if (designBrief === null) {
+        try {
+          const project = await callExtension("dmt_Project.getCurrentProjectInfo", [], timeoutMs);
+          const stored = parseBriefBlock(project?.description);
+          if (stored !== null) designBrief = stored;
+        } catch {
+        }
+      }
+      const answers = args.answers !== void 0 && args.answers !== null ? args.answers : null;
+      const answersReport = buildIntake(answers);
+      const merged = { ...designBrief ?? {}, ...answersReport.brief };
+      const mergedReport = buildIntake(merged);
+      let persisted = false;
+      if (Object.keys(merged).length > 0) {
+        designBrief = merged;
+        if (answers !== null) {
+          try {
+            const project = await callExtension("dmt_Project.getCurrentProjectInfo", [], timeoutMs);
+            const existing = typeof project?.description === "string" ? project.description : "";
+            const index = existing.indexOf(BRIEF_TAG);
+            const base = index < 0 ? existing : existing.slice(0, index).trimEnd();
+            const next = (base === "" ? "" : base + "\n") + briefBlock(merged);
+            await callExtension("dmt_Project.modifyProjectDescription", [next], timeoutMs);
+            persisted = true;
+          } catch {
+            persisted = false;
+          }
+        }
+      }
+      return {
+        ready: mergedReport.ready,
+        questionCount: mergedReport.questionCount,
+        criticalCount: mergedReport.criticalCount,
+        answered: mergedReport.answered,
+        missingCritical: mergedReport.missingCritical,
+        unknownAnswerKeys: mergedReport.unknownAnswerKeys,
+        brief: mergedReport.brief,
+        hydratedFromProject: answers === null && designBrief !== null,
+        persisted,
+        sections: mergedReport.sections.filter((section) => section.questions.some((question) => mergedReport.brief[question.id] === void 0)),
+        next: mergedReport.ready ? "All critical parameters are known: lay out the schematic, then eda_netlist_erc before routing." : "Ask the user for the missing critical parameters with ask_user_question, grouped by section, before placing parts. Do not invent values."
+      };
+    }
+    case "eda_netlist_erc": {
+      const netlistData = await fetchParsedNetlist(timeoutMs);
+      const report = runNetlistErc(netlistData);
+      const listed = args.includeOk === true ? report.checks : report.checks.filter((check) => check.status !== "pass");
+      return {
+        ok: report.ok,
+        counts: report.counts,
+        componentCount: report.componentCount,
+        netCount: report.netCount,
+        checks: listed,
+        hint: report.ok ? "No electrical failure found. This is a smoke test, not a simulation: run eda_run_drc and review the schematic as well." : "Fix the failing checks before routing; eda_run_drc on this build only returns aggregated counts, so this list is the actionable signal."
+      };
+    }
+    case "eda_pcb_canvas_origin": {
+      const setTo = args.align === true ? [0, 0] : args.offsetX === void 0 && args.offsetY === void 0 ? null : [Number(args.offsetX ?? 0), Number(args.offsetY ?? 0)];
+      let aligned = null;
+      if (setTo !== null) aligned = await callExtension("pcb_Document.setCanvasOrigin", setTo, timeoutMs);
+      const origin = await callExtension("pcb_Document.getCanvasOrigin", [], timeoutMs);
+      const out = {
+        canvasOrigin: origin,
+        aligned,
+        note: "JLCEDA displays canvas coordinates; APIs use data coordinates. align:true sets the offset to zero so both agree."
+      };
+      const point = args.point;
+      if (point !== null && typeof point === "object") {
+        const px = Number(point.x);
+        const py = Number(point.y);
+        if (Number.isFinite(px) && Number.isFinite(py)) {
+          out.point = {
+            input: { x: px, y: py },
+            canvasToData: await callExtension("pcb_Document.convertCanvasOriginToDataOrigin", [px, py], timeoutMs),
+            dataToCanvas: await callExtension("pcb_Document.convertDataOriginToCanvasOrigin", [px, py], timeoutMs)
+          };
+        }
+      }
+      return out;
+    }
+    case "eda_capture": {
+      if (args.cleanup === true) {
+        const removed = [];
+        const failed = [];
+        for (const file of capturedFiles.splice(0, capturedFiles.length)) {
+          try {
+            await unlink(file);
+            removed.push(file);
+          } catch {
+            failed.push(file);
+          }
+        }
+        return { ok: failed.length === 0, removed, failed, hint: "Capture files are scratch: delete them as soon as you have looked at the image." };
+      }
+      const captured = await callExtension("dmt_EditorControl.getCurrentRenderedAreaImage", [], toolTimeout(args, timeoutMs));
+      const dataUrl = typeof captured === "string" ? captured : captured !== null && typeof captured === "object" && typeof captured.dataUrl === "string" ? captured.dataUrl : "";
+      if (dataUrl === "") throw new Error("eda_capture: the app returned no image (is a document tab active?)");
+      const base64 = dataUrl.includes(",") ? dataUrl.slice(dataUrl.indexOf(",") + 1) : dataUrl;
+      const pngBytes = Buffer.from(base64, "base64");
+      const capturePath = args.outPath === void 0 ? "" : String(args.outPath).trim();
+      if (capturePath !== "") {
+        await writeFile(capturePath, pngBytes);
+        capturedFiles.push(capturePath);
+        return {
+          ok: true,
+          written: capturePath,
+          bytes: pngBytes.length,
+          hint: "Read the file with the image reader, then call eda_capture({cleanup:true}) so the scratch PNG does not linger."
+        };
+      }
+      if (args.inline === true) return { ok: true, bytes: pngBytes.length, dataUrl };
+      return { ok: true, bytes: pngBytes.length, dataUrlPrefix: dataUrl.slice(0, 32), hint: "Pass outPath to save a PNG, or inline:true to receive the data URL." };
+    }
     case "eda_workflow_guide":
       return { summary: WORKFLOW_SUMMARY, guide: WORKFLOW_GUIDE, autoLayoutAllowed: ALLOW_AUTO_LAYOUT };
     case "eda_create_board":
@@ -2368,10 +3319,15 @@ async function executeTool(name, rawArgs, timeoutMs) {
     case "eda_api_call": {
       if (!ALLOW_RAW_API) throw new Error("eda_api_call is disabled by settings (allowRawApi=false)");
       const method = String(args.method ?? "");
-      if (!ALLOWED_API.has(method)) {
-        throw new Error("API method not allowed: " + method + ". The extension only accepts its allow-list (" + ALLOWED_API.size + " methods): call eda_list_api_methods to get it. Common schematic helpers such as sch_PrimitiveComponent.getAllPinsByPrimitiveId and sch_PrimitivePin.get are already wrapped by eda_get_pins.");
+      try {
+        return await callExtension(method, Array.isArray(args.args) ? args.args : [], timeoutMs);
+      } catch (failure) {
+        const message = failure instanceof Error ? failure.message : String(failure);
+        if (!/not allowed/i.test(message)) throw failure;
+        const live = await extensionApiMethods(timeoutMs, true);
+        const hint = live === void 0 ? "The connected extension rejected it and does not expose its list (older zip); eda_list_api_methods then shows the bridge copy, which may be narrower than reality." : "The extension enforces " + live.all.length + ' methods right now (eda_list_api_methods source:"extension").';
+        throw new Error("API method not allowed: " + method + ". " + hint + " Wrapped helpers usually exist: eda_get_pins (pins), eda_place_net_labels (labels), eda_pcb_* (PCB primitives).");
       }
-      return await callExtension(method, Array.isArray(args.args) ? args.args : [], timeoutMs);
     }
     case "pcb_get_components": {
       const layer = resolvePcbLayer(args.layer);
@@ -2698,23 +3654,44 @@ async function executeTool(name, rawArgs, timeoutMs) {
       assertNetName(String(args.net), "eda_pcb_create_pour");
       const fill = args.pourFillMethod === void 0 ? void 0 : String(args.pourFillMethod);
       if (fill !== void 0 && fill !== "45grid" && fill !== "90grid" && fill !== "solid") throw new Error("eda_pcb_create_pour: pourFillMethod must be 45grid, 90grid or solid");
-      const raw = await callExtension("dsh.internal.pourCreate", [
+      let polygonOk = false;
+      try {
+        const probe = await callExtension("pcb_MathPolygon.createPolygon", [buildPolygonSource(points)], timeoutMs);
+        polygonOk = probe !== void 0 && probe !== null;
+      } catch {
+        polygonOk = false;
+      }
+      const attempt = async (fillMethod, preserveSilos) => callExtension("dsh.internal.pourCreate", [
         String(args.net),
         layer,
         buildPolygonSource(points),
-        fill,
-        args.preserveSilos === void 0 ? void 0 : Boolean(args.preserveSilos),
+        fillMethod,
+        preserveSilos,
         args.pourName === void 0 ? void 0 : String(args.pourName),
         args.pourPriority === void 0 ? void 0 : Number(args.pourPriority),
         args.lineWidth === void 0 ? void 0 : Number(args.lineWidth),
         args.locked === void 0 ? void 0 : Boolean(args.locked)
       ], timeoutMs);
+      let raw;
+      let retried = false;
+      try {
+        raw = await attempt(fill, args.preserveSilos === void 0 ? void 0 : Boolean(args.preserveSilos));
+      } catch (firstFailure) {
+        retried = true;
+        try {
+          raw = await attempt("solid", false);
+        } catch (secondFailure) {
+          const detail = secondFailure instanceof Error ? secondFailure.message : String(secondFailure);
+          throw new Error("eda_pcb_create_pour failed twice (first: " + (firstFailure instanceof Error ? firstFailure.message : String(firstFailure)) + "; retry: " + detail + "). polygonStage=" + (polygonOk ? "ok" : "failed") + ": " + (polygonOk ? "the app accepted the outline but refused the pour itself, so this is an application limit, not a coordinate problem. Pour by hand in the PCB editor (\u8986\u94DC \u2192 select GND \u2192 top + bottom); eda_design_audit reports it as a warn until then." : "the outline polygon was rejected too: check that every point is inside the board outline and flat [x1,y1,...].") + " retried=" + retried);
+        }
+      }
       return {
         net: String(args.net),
         layer,
         layerId: layer,
         pointCount: points.length / 2,
         pour: summarizePrimitive(raw),
+        retried,
         rules: {
           clearanceMil: { required: POUR_CLEARANCE_MIN_MIL, recommended: POUR_CLEARANCE_RECOMMENDED_MIL },
           note: "The pour/clearance value lives in the board design rules, not in this call: set it in \u8BBE\u8BA1 \u2192 \u8BBE\u8BA1\u89C4\u5219 (recommended " + POUR_CLEARANCE_RECOMMENDED_MIL + " mil) and remove islands before exporting."