opentakeoff-mcp 0.9.3 → 0.9.7

package/README.md

@@ -117,7 +117,9 @@ includes document text, shape vertices, or result payload content.
 | `delete_shape` | Remove a committed shape by id. |
 | `edit_shape` | **Revise** a committed shape instead of redoing it: new `verts`, a different `condition`, a different `role`, or any combination — quantities recomputed from the result. Refuses shapes a human affirmed. |
 | `edit_materials` | Add/remove/patch supporting-materials rows on a condition — the coverage-rate lines (adhesive at N sf/gal, grout at N lf/bag, …) that turn a measured quantity into an order quantity, matching the canvas's Supporting Materials panel. `condition` mints on first touch, like `one_click`/`measure_polygon`. No review gate (materials rows are quantity config, not traced geometry) — edits directly, reversible with `undo_last`. |
-| `undo_last` | Step back over your own last `n` mutations, newest first. Exact inverses: a commit is removed, an edit restored verbatim, a delete re-inserted where it was, a materials edit's whole array restored. A whole `detect_rooms` sweep is **one** step. |
+| `edit_condition` | Set a condition's **waste %** and **×N multiplier** — the knobs that turn measured quantities into order quantities (`takeoff_summary`'s `*_net`); without them an agent takeoff always ships net === gross. Resolves an **existing** finish tag or errors — a typo must not mint an empty condition. No review gate; one `undo_last` step restores both knobs verbatim. |
+| `export_report` | The **computed Report document** — `opentakeoff.report.v1`, the same JSON the canvas Report exports: gross + waste-adjusted quantities, the computed materials **buy list** per condition plus the project-wide roll-up, per-sheet base subtotals, and scale provenance. The contract for pricing consumers — `export_takeoff` carries materials as config rows, `takeoff_summary` strips them. Inline, and to disk with `path`. |
+| `undo_last` | Step back over your own last `n` mutations, newest first. Exact inverses: a commit is removed, an edit restored verbatim, a delete re-inserted where it was, a materials edit's whole array restored, a condition edit's waste/multiplier pair restored. A whole `detect_rooms` sweep is **one** step. |
 | `read_sheet_text` | Positioned page text (image px), optionally restricted to a region — title blocks, room labels, finish schedules. |
 | `find_text` | **Locate** a known string — the complement to `read_sheet_text` (which returns what a region *says*; this finds *where* a string sits). Case-insensitive substring match per pdf.js text run; each hit's center feeds straight into `one_click`'s seed. |
 | `sheet_context` | The region's STRUCTURE in one frame: classified vector segments (endpoints as drawn, meta byte per segment), text spans with bboxes, and hatch-family instances with content-derived ids — same pattern spec ⇒ same id anywhere on the sheet, so plan↔legend matching is `id === id`. Decimation is declared and counted on every reply: `kept + dropped === total_in_region`, cap applies longest-first so walls survive. |

package/dist/server-core.js

@@ -216,6 +216,12 @@ async function openPdf(filePath) {
         }
       };
     },
+    async layers() {
+      const cfg = await doc.getOptionalContentConfig();
+      const groups = cfg ? cfg.getGroups() : null;
+      if (!groups) return [];
+      return Object.entries(groups).map(([id, g]) => ({ id, name: String(g?.name ?? ""), visible: g?.visible !== false }));
+    },
     destroy: () => doc.destroy().then(() => void 0)
   };
 }
@@ -243,25 +249,120 @@ function textSpans(ph) {
   return out;
 }
 
-// src/format.ts
-var UserError = class extends Error {
+// ../web/src/lib/layers.ts
+var ROLE_CODE = {
+  unknown: 0,
+  boundary: 1,
+  "finish-pattern": 2,
+  annotation: 3,
+  structure: 4,
+  demolition: 5
 };
-var ok = (payload) => ({
-  structuredContent: payload,
-  content: [{ type: "text", text: JSON.stringify(payload) }]
-});
-var okImage = (png, meta) => ({
-  content: [
-    { type: "image", data: Buffer.from(png.buffer, png.byteOffset, png.byteLength).toString("base64"), mimeType: "image/png" },
-    { type: "text", text: JSON.stringify(meta) }
-  ]
-});
-var fail = (err) => ({
-  isError: true,
-  content: [{ type: "text", text: JSON.stringify({ error: err instanceof Error ? err.message : String(err) }) }]
-});
-var round2 = (n) => +n.toFixed(2);
-var round1 = (n) => +n.toFixed(1);
+var ROLE_HIDDEN = 6;
+var DEMOLITION = /* @__PURE__ */ new Set(["DEMO", "DEMOL", "DEMOLITION", "REMV", "REMOVE"]);
+var PATTERN = /* @__PURE__ */ new Set(["PATT", "PATTERN", "PATTERNS", "HATCH", "HATCHING", "POCHE"]);
+var ANNOTATION = /* @__PURE__ */ new Set([
+  "ANNO",
+  "TEXT",
+  "DIM",
+  "DIMS",
+  "NOTE",
+  "NOTES",
+  "SYMB",
+  "SYMBOL",
+  "IDEN",
+  "TAG",
+  "TAGS",
+  "TTLB",
+  "TITLEBLOCK",
+  "LEGN",
+  "LEGEND",
+  "SHBD",
+  "NPLT",
+  "PLOT",
+  "GRID",
+  "GRIDS",
+  "LEVL",
+  "REVS",
+  "REV"
+]);
+var FIXTURES = /* @__PURE__ */ new Set(["FURN", "FURNITURE", "EQPM", "EQUIP", "EQUIPMENT", "CASE", "CASW", "CASEWORK", "MILL", "MILLWORK", "PLMB", "PFIX", "APPL", "SPCL", "SEAT", "SEATING"]);
+var STRUCTURE = /* @__PURE__ */ new Set(["COLS", "COL", "COLUMN", "COLUMNS", "BEAM", "BEAMS", "BRACE", "FNDN", "FOUNDATION", "JOIS", "JOIST", "SLAB"]);
+var BOUNDARY = /* @__PURE__ */ new Set([
+  "WALL",
+  "WALLS",
+  "PRHT",
+  "FULL",
+  "PART",
+  "PARTN",
+  "PARTITION",
+  "PARTITIONS",
+  "GLAZ",
+  "GLAZING",
+  "STOR",
+  "STOREFRONT",
+  "CWMG",
+  "OTLN",
+  "OUTLINE",
+  "OUTLINES",
+  "RM",
+  "ROOM",
+  "ROOMS",
+  "AREA",
+  "AREAS",
+  "DOOR",
+  "DOORS",
+  "DR",
+  "WNDW",
+  "WIND",
+  "WINDOW",
+  "WINDOWS"
+]);
+var DISCIPLINES = /* @__PURE__ */ new Set(["A", "S", "M", "E", "P", "F", "C", "L", "T", "I", "Q", "G", "H", "V", "W", "X", "Z"]);
+function layerNameTokens(raw) {
+  const base = String(raw || "").split("|").pop() || "";
+  return base.replace(/\$\d+\$/g, "-").toUpperCase().split(/[^A-Z0-9]+/).filter(Boolean);
+}
+function classifyLayerName(raw) {
+  const s = String(raw || "").trim();
+  if (!s || /^0$/.test(s) || /^layer\s*\d*$/i.test(s)) return { role: "unknown", confidence: 0 };
+  const toks = layerNameTokens(s);
+  if (!toks.length) return { role: "unknown", confidence: 0 };
+  const conforming = DISCIPLINES.has(toks[0]) && toks.length > 1;
+  const grade = (base) => conforming ? base : Math.max(0.5, base - 0.2);
+  const has = (table) => toks.some((t) => table.has(t));
+  if (has(DEMOLITION)) return { role: "demolition", confidence: grade(0.95) };
+  if (has(PATTERN)) return { role: "finish-pattern", confidence: grade(0.9) };
+  if (has(ANNOTATION)) return { role: "annotation", confidence: grade(0.85) };
+  if (toks[0] === "S" && toks.length > 1) return { role: "structure", confidence: 0.85 };
+  if (has(STRUCTURE)) return { role: "structure", confidence: grade(0.8) };
+  if (has(BOUNDARY)) return { role: "boundary", confidence: grade(0.9) };
+  if (has(FIXTURES)) return { role: "annotation", confidence: grade(0.65) };
+  return { role: "unknown", confidence: 0.2 };
+}
+function layerRoleCodes(layerIds, infoById) {
+  const codes = new Uint8Array(layerIds.length);
+  layerIds.forEach((id, k) => {
+    const info = infoById.get(id);
+    if (!info) return;
+    codes[k] = info.visible === false ? ROLE_HIDDEN : ROLE_CODE[info.role];
+  });
+  return codes;
+}
+function segRoles(layerOf, codes) {
+  if (!layerOf || !codes.length) return null;
+  const n = layerOf.length;
+  const out = new Uint8Array(n);
+  let any = false;
+  for (let i = 0; i < n; i++) {
+    const li = layerOf[i];
+    if (li >= 0 && li < codes.length && codes[li]) {
+      out[i] = codes[li];
+      any = true;
+    }
+  }
+  return any ? out : null;
+}
 
 // ../web/src/lib/oneclick.ts
 var MASK_MAX_DIM = 3e3;
@@ -317,6 +418,20 @@ function extractVectorGeometry(opList, transform, OPS3) {
   let m = transform.slice();
   let lw = 1;
   const stack = [];
+  const layerIds = [];
+  const layerIdxById = /* @__PURE__ */ new Map();
+  const layerOfArr = [];
+  const mcStack = [];
+  let curLayer = -1;
+  const layerIdxFor = (id) => {
+    let k = layerIdxById.get(id);
+    if (k === void 0) {
+      k = layerIds.length;
+      layerIds.push(id);
+      layerIdxById.set(id, k);
+    }
+    return k;
+  };
   const mul = (a, b) => [a[0] * b[0] + a[2] * b[1], a[1] * b[0] + a[3] * b[1], a[0] * b[2] + a[2] * b[3], a[1] * b[2] + a[3] * b[3], a[0] * b[4] + a[2] * b[5] + a[4], a[1] * b[4] + a[3] * b[5] + a[5]];
   const tx = (x, y) => [m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]];
   const fns = opList.fnArray, A = opList.argsArray;
@@ -352,6 +467,26 @@ function extractVectorGeometry(opList, transform, OPS3) {
         m = p[0];
         lw = p[1];
       }
+    } else if (fn === OPS3.beginMarkedContent) {
+      mcStack.push(-1);
+    } else if (fn === OPS3.beginMarkedContentProps) {
+      const data = args && args[0] === "OC" ? args[1] : null;
+      let li = -1;
+      if (data && typeof data === "object") {
+        if (typeof data.id === "string" && data.id) li = layerIdxFor(data.id);
+        else if (Array.isArray(data.ids) && data.ids.length === 1 && typeof data.ids[0] === "string" && data.ids[0]) li = layerIdxFor(data.ids[0]);
+      }
+      mcStack.push(li);
+      if (li >= 0) curLayer = li;
+    } else if (fn === OPS3.endMarkedContent) {
+      if (mcStack.length) {
+        mcStack.pop();
+        curLayer = -1;
+        for (let k = mcStack.length - 1; k >= 0; k--) if (mcStack[k] >= 0) {
+          curLayer = mcStack[k];
+          break;
+        }
+      }
     } else if (fn === OPS3.paintImageXObject || fn === OPS3.paintInlineImageXObject || fn === OPS3.paintImageMaskXObject) {
       imageArea += Math.abs(m[0] * m[3] - m[1] * m[2]);
     } else if (fn === OPS3.paintImageXObjectRepeat) {
@@ -379,6 +514,7 @@ function extractVectorGeometry(opList, transform, OPS3) {
       const flags = paintFlags(i) | devW << 4;
       const ops = args[0], co = args[1];
       let c = 0, cur = null, start = null;
+      const pathLayer = curLayer;
       const visit = (p) => {
         points.push(p);
       };
@@ -386,6 +522,7 @@ function extractVectorGeometry(opList, transform, OPS3) {
         if (cur) {
           segs.push(cur[0], cur[1], p[0], p[1]);
           metaArr.push(flags);
+          layerOfArr.push(pathLayer);
         }
         cur = p;
         visit(p);
@@ -426,6 +563,7 @@ function extractVectorGeometry(opList, transform, OPS3) {
             if (cur) {
               segs.push(cur[0], cur[1], q[0], q[1]);
               metaArr.push(flags | SEG_CURVE);
+              layerOfArr.push(pathLayer);
             }
             cur = q;
           }
@@ -434,6 +572,7 @@ function extractVectorGeometry(opList, transform, OPS3) {
           if (cur && start) {
             segs.push(cur[0], cur[1], start[0], start[1]);
             metaArr.push(flags);
+            layerOfArr.push(pathLayer);
             cur = start;
           }
         } else if (op === OPS3.rectangle) {
@@ -444,6 +583,7 @@ function extractVectorGeometry(opList, transform, OPS3) {
             const a = q[k], b = q[(k + 1) % 4];
             segs.push(a[0], a[1], b[0], b[1]);
             metaArr.push(flags);
+            layerOfArr.push(pathLayer);
             visit(a);
           }
           cur = q[0];
@@ -452,7 +592,7 @@ function extractVectorGeometry(opList, transform, OPS3) {
       }
     }
   }
-  return { points, segs, meta: Uint8Array.from(metaArr), imageArea };
+  return { points, segs, meta: Uint8Array.from(metaArr), imageArea, layerOf: Int32Array.from(layerOfArr), layerIds };
 }
 function sweepHatchRuns(segs, meta, ws) {
   const n = segs.length >> 2;
@@ -612,14 +752,16 @@ function hatchFamilies(segs, meta) {
     };
   });
 }
-function buildMask(segs, imgW, imgH, maxDim = MASK_MAX_DIM, meta = null) {
+function buildMask(segs, imgW, imgH, maxDim = MASK_MAX_DIM, meta = null, roles = null) {
   const ws = Math.min(1, maxDim / Math.max(imgW, imgH, 1));
   const mw = Math.max(2, Math.ceil(imgW * ws)), mh = Math.max(2, Math.ceil(imgH * ws));
   const mask = new Uint8Array(mw * mh);
   const soft = meta ? classifyHatchSegs(segs, meta, ws) : null;
   let softCount = 0;
   for (let i = 0, si = 0; i + 3 < segs.length; i += 4, si++) {
-    const v = soft && soft[si] ? 2 : 1;
+    const role = roles ? roles[si] : 0;
+    if (role === 2 || role === 3 || role === 5 || role === 6) continue;
+    const v = role === 1 || role === 4 ? 1 : soft && soft[si] ? 2 : 1;
     if (v === 2) softCount++;
     let x0 = Math.round(segs[i] * ws), y0 = Math.round(segs[i + 1] * ws);
     const x1 = Math.round(segs[i + 2] * ws), y1 = Math.round(segs[i + 3] * ws);
@@ -900,6 +1042,249 @@ function isLabelBubblePx(ring, b) {
   return x1 - x0 <= BUBBLE_RATIO * lw && y1 - y0 <= BUBBLE_RATIO * lh;
 }
 
+// ../web/src/lib/sheetgraph.ts
+var bboxOf = (s) => [s.x, s.y, s.x + (s.w || 0), s.y + (s.h || 0)];
+var merge = (a, b) => [Math.min(a[0], b[0]), Math.min(a[1], b[1]), Math.max(a[2], b[2]), Math.max(a[3], b[3])];
+var norm = (s) => (s || "").trim().toUpperCase();
+var SCHEDULE_TITLE_RE = /^[A-Z][A-Z ()/&.-]* SCHEDULE( *[-–] *[A-Z0-9 ()/&.-]+)?$/;
+var ROLE_SIGNALS = [
+  { re: /DEMOLITION\s+PLAN|DEMO\s+PLAN/, role: "demolition", conf: 0.9 },
+  { re: /FINISH\s+PLAN|FLOOR\s+PLAN|FURNITURE\s+PLAN|CEILING\s+PLAN/, role: "plan", conf: 0.85 },
+  { re: SCHEDULE_TITLE_RE, role: "schedule", conf: 0.85 },
+  { re: /SCHEDULE/, role: "schedule", conf: 0.5 },
+  { re: /LEGEND/, role: "legend", conf: 0.5 },
+  { re: /ELEVATIONS?\b/, role: "elevation", conf: 0.7 },
+  { re: /DETAILS?\b|SECTIONS?\b/, role: "detail", conf: 0.6 }
+];
+var REFERENCE_RE = /^(SEE|REFER|PER|NOTED|AS SHOWN)\b|REFER TO/;
+function classifySheetRole(sheet) {
+  const hits = [];
+  for (const sp of sheet.spans) {
+    const u = norm(sp.str);
+    if (u.length < 4 || u.length > 60 || REFERENCE_RE.test(u)) continue;
+    for (const sig of ROLE_SIGNALS) if (sig.re.test(u)) {
+      hits.push({ role: sig.role, conf: sig.conf, span: sp });
+      break;
+    }
+  }
+  if (!hits.length) {
+    const n = norm(sheet.sheet_number || "");
+    if (/^A-?1\d\d/.test(n)) return { role: "plan", confidence: 0.4, evidence: null };
+    return { role: "unknown", confidence: 0, evidence: null };
+  }
+  hits.sort((a, b) => b.conf - a.conf);
+  const best = hits[0];
+  const dissent = hits.some((h) => h.role !== best.role && h.conf >= best.conf - 0.1);
+  return {
+    role: best.role,
+    confidence: dissent ? best.conf / 2 : best.conf,
+    evidence: { sheet: sheet.key, text: best.span.str.trim(), bbox: bboxOf(best.span) }
+  };
+}
+function clusterRows(spans) {
+  const toks = spans.filter((t) => t.str && t.str.trim()).sort((a, b) => a.y - b.y || a.x - b.x);
+  const rows = [];
+  let cur = [];
+  let cy = 0;
+  for (const t of toks) {
+    const tol = Math.max((t.h || 8) * 0.35, 3);
+    if (cur.length && Math.abs(t.y - cy) > tol) {
+      rows.push(cur);
+      cur = [];
+    }
+    cur.push(t);
+    cy = cur.reduce((s, w) => s + w.y, 0) / cur.length;
+  }
+  if (cur.length) rows.push(cur);
+  return rows.map((r) => r.sort((a, b) => a.x - b.x));
+}
+var ROOM_HEADERS = ["ROOM", "NO", "NUMBER", "NAME", "FLOOR", "BASE", "WALL", "WALLS", "NORTH", "SOUTH", "EAST", "WEST", "CEILING", "WAINSCOT", "REMARKS", "CLG", "HT"];
+var FINISH_HEADERS = ["CODE", "MARK", "MATERIAL", "MANUFACTURER", "PRODUCT", "STYLE", "COLOR", "SIZE", "REMARKS", "DESCRIPTION", "PATTERN"];
+var headerLabel = (s, vocab) => {
+  for (const w of norm(s).split(/[^A-Z]+/)) if (w && vocab.includes(w)) return w;
+  return null;
+};
+function findHeaderRow(rows, vocab, required, minHits) {
+  for (let i = 0; i < rows.length; i++) {
+    const anchors = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const t of rows[i]) {
+      const w = headerLabel(t.str, vocab);
+      if (w && !seen.has(w)) {
+        seen.add(w);
+        anchors.push({ label: w, x: t.x });
+      }
+    }
+    if (anchors.length < minHits || !required.some((r) => seen.has(r))) continue;
+    return { anchors: anchors.sort((a, b) => a.x - b.x), rowIndex: i };
+  }
+  return null;
+}
+var nearestAnchor = (x, anchors) => {
+  let best = anchors[0];
+  for (const a of anchors) if (Math.abs(a.x - x) < Math.abs(best.x - x)) best = a;
+  return best.label;
+};
+var CODE_RE = /^[A-Z]{1,4}(-?[A-Z0-9]{1,4})?$/;
+var ROW_KEY_RE = /^\d{1,3}[A-Z]{0,2}$/;
+function extractTable(sheet, kind) {
+  const rows = clusterRows(sheet.spans);
+  const found = kind === "room-finish" ? findHeaderRow(rows, ROOM_HEADERS, ["FLOOR", "BASE"], 4) : findHeaderRow(rows, FINISH_HEADERS, ["CODE", "MARK"], 3);
+  if (!found) return null;
+  const { anchors, rowIndex } = found;
+  const keyRe = kind === "room-finish" ? ROW_KEY_RE : CODE_RE;
+  const out = [];
+  let region = null;
+  const headerRow = rows[rowIndex];
+  for (const t of headerRow) region = region ? merge(region, bboxOf(t)) : bboxOf(t);
+  const gaps = anchors.slice(1).map((a, i) => a.x - anchors[i].x).sort((a, b) => a - b);
+  const medGap = gaps.length ? gaps[gaps.length >> 1] : 150;
+  const x0 = anchors[0].x - Math.max(80, medGap / 2);
+  const x1 = anchors[anchors.length - 1].x + Math.max(300, medGap * 3);
+  for (let i = rowIndex + 1; i < rows.length; i++) {
+    const inBand = rows[i].filter((t) => t.x >= x0 && t.x <= x1);
+    if (!inBand.length) continue;
+    const keyTok = inBand[0];
+    const key = norm(keyTok.str).replace(/[^A-Z0-9-]/g, "");
+    if (!keyRe.test(key)) continue;
+    const cells = {};
+    for (const t of inBand) {
+      const label = nearestAnchor(t.x, anchors);
+      const text = t.str.trim();
+      if (!cells[label]) cells[label] = { text, bbox: bboxOf(t) };
+      else {
+        cells[label] = { text: `${cells[label].text} ${text}`, bbox: merge(cells[label].bbox, bboxOf(t)) };
+      }
+      region = region ? merge(region, bboxOf(t)) : bboxOf(t);
+    }
+    out.push({ key, cells });
+  }
+  if (!out.length) return null;
+  let title = null;
+  for (let i = rowIndex - 1; i >= 0 && i >= rowIndex - 6 && !title; i--) {
+    const hit = rows[i].find((t) => /SCHEDULE/.test(norm(t.str)) && t.x >= x0 && t.x <= x1);
+    if (hit) title = { sheet: sheet.key, text: hit.str.trim(), bbox: bboxOf(hit) };
+  }
+  return { kind, sheet: sheet.key, title, headers: anchors.map((a) => a.label), rows: out, region };
+}
+function roomTags(sheet) {
+  const out = [];
+  const spans = sheet.spans;
+  for (const sp of spans) {
+    const t = sp.str.trim();
+    if (!ROOM_LABEL_RE.test(t)) continue;
+    const b = bboxOf(sp);
+    const hgt = Math.max(sp.h || 8, 6);
+    let name = "";
+    let best = Infinity;
+    for (const cand of spans) {
+      if (cand === sp || ROOM_LABEL_RE.test(cand.str.trim())) continue;
+      const cb = bboxOf(cand);
+      const dy = b[1] - cb[3];
+      if (dy < -hgt * 0.2 || dy > hgt * 2.2) continue;
+      if (cb[2] < b[0] - hgt || cb[0] > b[2] + hgt) continue;
+      if (!/^[A-Z][A-Z .\/&-]{2,}$/.test(norm(cand.str))) continue;
+      if (dy < best) {
+        best = dy;
+        name = cand.str.trim();
+      }
+    }
+    out.push({ tag: t, name, sheet: sheet.key, bbox: b });
+  }
+  return out;
+}
+var CALLOUT_RE = /^(\d{1,2})\s*\/\s*([A-Z]{1,2}-?\d{1,3}(?:\.\d+)?)$/;
+function detailCallouts(sheet) {
+  const out = [];
+  for (const sp of sheet.spans) {
+    const m = sp.str.trim().match(CALLOUT_RE);
+    if (m) out.push({ detail: m[1], target_sheet: m[2], sheet: sheet.key, bbox: bboxOf(sp) });
+  }
+  return out;
+}
+function buildSheetGraph(sheets) {
+  const withText = sheets.filter((s) => s.spans.length > 0);
+  if (!withText.length) return { available: false, sheets: [], rooms: [], tables: [], callouts: [] };
+  const tables = [];
+  const rooms = [];
+  const callouts = [];
+  const outSheets = [];
+  for (const s of withText) {
+    const role = classifySheetRole(s);
+    const found = [];
+    for (const kind of ["room-finish", "finish"]) {
+      const t = extractTable(s, kind);
+      if (t) {
+        found.push(t);
+        tables.push(t);
+      }
+    }
+    if (role.role === "plan" || role.role === "unknown" || role.role === "demolition") rooms.push(...roomTags(s));
+    callouts.push(...detailCallouts(s));
+    outSheets.push({
+      key: s.key,
+      role: role.role,
+      confidence: role.confidence,
+      evidence: role.evidence,
+      schedules: found.map((t) => ({ kind: t.kind, title: t.title?.text || "", rows: t.rows.length, region: t.region }))
+    });
+  }
+  return { available: true, sheets: outSheets, rooms, tables, callouts };
+}
+var SURFACE_HEADERS = ["FLOOR", "BASE", "WALL", "WALLS", "NORTH", "SOUTH", "EAST", "WEST", "CEILING", "WAINSCOT"];
+function resolveTag(graph, tag) {
+  const t = norm(tag);
+  const room = graph.rooms.find((r2) => norm(r2.tag) === t) || null;
+  const roomTables = graph.tables.filter((x) => x.kind === "room-finish");
+  if (!roomTables.length) return { status: "unresolved", tag: t, room, reason: "no room-finish schedule found in the set" };
+  const matches = roomTables.flatMap((tab2) => tab2.rows.filter((r2) => norm(r2.key) === t).map((r2) => ({ tab: tab2, r: r2 })));
+  if (!matches.length) return { status: "unresolved", tag: t, room, reason: `no schedule row for ${t} \u2014 the plan shows the room but no room-finish table lists it` };
+  if (matches.length > 1) return { status: "unresolved", tag: t, room, reason: `ambiguous: ${matches.length} schedule rows match ${t} (room numbers reused across the set?)` };
+  const { tab, r } = matches[0];
+  const finTables = graph.tables.filter((x) => x.kind === "finish");
+  const finishes = [];
+  const sources = [{ sheet: tab.sheet, text: `${tab.title?.text || "room-finish schedule"} row ${r.key}`, bbox: r.cells[Object.keys(r.cells)[0]]?.bbox || tab.region }];
+  if (room) sources.unshift({ sheet: room.sheet, text: `${room.name ? room.name + " " : ""}${room.tag}`.trim(), bbox: room.bbox });
+  for (const surface of SURFACE_HEADERS) {
+    const cell = r.cells[surface];
+    if (!cell || !cell.text.trim()) continue;
+    const code = norm(cell.text).replace(/[^A-Z0-9-]/g, "");
+    const fin = { surface, code: cell.text.trim(), source: { sheet: tab.sheet, text: cell.text.trim(), bbox: cell.bbox } };
+    for (const ft of finTables) {
+      const def = ft.rows.find((fr) => norm(fr.key) === code);
+      if (def) {
+        const cells = {};
+        for (const [k, v] of Object.entries(def.cells)) cells[k] = v.text;
+        fin.definition = { cells, source: { sheet: ft.sheet, text: `${ft.title?.text || "finish schedule"} row ${def.key}`, bbox: def.cells[Object.keys(def.cells)[0]]?.bbox || ft.region } };
+        break;
+      }
+    }
+    finishes.push(fin);
+  }
+  if (!finishes.length) return { status: "unresolved", tag: t, room, reason: `schedule row ${t} exists but carries no finish cells the extractor could band` };
+  return { status: "resolved", tag: t, room, finishes, sources };
+}
+
+// src/format.ts
+var UserError = class extends Error {
+};
+var ok = (payload) => ({
+  structuredContent: payload,
+  content: [{ type: "text", text: JSON.stringify(payload) }]
+});
+var okImage = (png, meta) => ({
+  content: [
+    { type: "image", data: Buffer.from(png.buffer, png.byteOffset, png.byteLength).toString("base64"), mimeType: "image/png" },
+    { type: "text", text: JSON.stringify(meta) }
+  ]
+});
+var fail = (err) => ({
+  isError: true,
+  content: [{ type: "text", text: JSON.stringify({ error: err instanceof Error ? err.message : String(err) }) }]
+});
+var round2 = (n) => +n.toFixed(2);
+var round1 = (n) => +n.toFixed(1);
+
 // ../web/src/lib/geometry.js
 function buildSnapGrid(points, cell) {
   const map = /* @__PURE__ */ new Map();
@@ -965,8 +1350,14 @@ function attrValue(attrs, colId) {
 function accumulateRole(acc, s) {
   const cp = s.computed || {};
   switch (s.measure_role) {
+    // #137 — a deduct carrying cuts_shape_id was reconciled at commit time
+    // into a REAL polygon boolean subtract against its parent (lib/cutout.js):
+    // the parent's own computed.area_sf already nets the hole out, so
+    // counting the deduct's own area again here would double-subtract the
+    // same cut. Its area_sf stays at face value on the shape (hover label);
+    // this is the ONE place that decides whether it counts toward aggregates.
     case "deduct":
-      acc.floor -= cp.area_sf || 0;
+      if (!s.cuts_shape_id) acc.floor -= cp.area_sf || 0;
       break;
     case "floor_area":
       acc.floor += cp.area_sf || 0;
@@ -1101,7 +1492,7 @@ function grandTotals(rows) {
     sy_net: round22(sum("sy_net"))
   };
 }
-function reportJson({ projectName = "", rows = [], bySheet = [], scaleInfo = [], markups = [], rfis = [], sheetLabel = null, conditionColumns = [], attrsByCond = null, shapeLabels = [], byLabel = [], displayUnits = "imperial" }) {
+function reportJson({ projectName = "", rows = [], bySheet = [], scaleInfo = [], markups = [], rfis = [], sheetLabel = null, conditionColumns = [], attrsByCond = null, shapeLabels = [], byLabel = [], displayUnits = "imperial", rollGoods = [] }) {
   const label = (id) => sheetLabel ? sheetLabel(id) : id;
   const colDefs = (Array.isArray(conditionColumns) ? conditionColumns : []).filter((cc) => cc && typeof cc === "object" && typeof cc.id === "string");
   const attrs = attrsByCond instanceof Map ? attrsByCond : /* @__PURE__ */ new Map();
@@ -1182,7 +1573,14 @@ function reportJson({ projectName = "", rows = [], bySheet = [], scaleInfo = [],
     // the display system the exporting user was reading — the units port's
     // "JSON stays raw, but says so" contract.
     units: "imperial (SF/LF \u2014 raw internal values)",
-    display_units: displayUnits === "metric" ? "metric" : "imperial"
+    display_units: displayUnits === "metric" ? "metric" : "imperial",
+    // roll_goods APPENDS last (additive-only v1, #136): one row per roll-goods
+    // condition — the figured order (order_lf / rolls / order_qty in the
+    // condition's sell unit, ×N applied like every reported quantity) beside
+    // the measured quantities the conditions[] rows already carry. Always
+    // emitted; empty for projects with no roll-goods conditions, so every
+    // pre-#136 export round-trips byte-identically except this one key.
+    roll_goods: Array.isArray(rollGoods) ? rollGoods : []
   };
 }
 
@@ -1313,7 +1711,7 @@ var sheetSummary = (s) => ({
   ...s.sheetNumber ? { sheet_number: s.sheetNumber } : {},
   ...s.detected ? { detected_scale: s.detected.label } : {}
 });
-var Session = class {
+var Session = class _Session {
   file = null;
   doc = null;
   sheets = /* @__PURE__ */ new Map();
@@ -1350,6 +1748,7 @@ var Session = class {
     this.file = null;
     this.journal = [];
     this.pendingCommits = [];
+    this.graph = null;
     const doc = await openPdf(filePath);
     this.doc = doc;
     this.file = path2.basename(filePath);
@@ -1539,20 +1938,80 @@ var Session = class {
       const opList = await s.page.operatorList();
       s.geo = extractVectorGeometry(opList, s.page.viewport.transform, OPS2);
       s.snap = buildSnapGrid(s.geo.points, SNAP_CELL);
+      const layerIds = s.geo.layerIds || [];
+      if (layerIds.length && this.doc) {
+        const byId = new Map((await this.doc.layers()).map((g) => [g.id, g]));
+        const counts = /* @__PURE__ */ new Map();
+        const lo = s.geo.layerOf;
+        if (lo) {
+          for (let i = 0; i < lo.length; i++) if (lo[i] >= 0) counts.set(lo[i], (counts.get(lo[i]) || 0) + 1);
+        }
+        s.layers = layerIds.map((id, k) => {
+          const g = byId.get(id);
+          const name = g?.name || "";
+          const { role, confidence } = classifyLayerName(name);
+          return { id, name, role, confidence, visible: g ? g.visible : true, seg_count: counts.get(k) || 0 };
+        });
+      } else {
+        s.layers = [];
+      }
     }
     return s.geo;
   }
+  /** Per-layer role codes for buildMask (#85), with optional include/exclude
+   * OVERRIDES (by layer name or id, case-insensitive): include forces hard
+   * boundary, exclude drops the layer outright — the agent's judgment beats
+   * the table's. Unknown names error with the sheet's actual layer list
+   * (resolve-or-error, never a silent no-op). */
+  rolesFor(s, geo, layersOpt) {
+    const infos = s.layers || [];
+    if (!infos.length || !geo.layerIds?.length) {
+      if (layersOpt && (layersOpt.include?.length || layersOpt.exclude?.length)) {
+        throw new UserError(`${s.key} has no PDF layers (no Optional Content survived export) \u2014 layers.include/exclude can't apply here.`);
+      }
+      return null;
+    }
+    const infoById = new Map(infos.map((l) => [l.id, { role: l.role, visible: l.visible }]));
+    if (layersOpt) {
+      const resolve = (ref) => {
+        const needle = ref.trim().toLowerCase();
+        const hit = infos.find((l) => l.id.toLowerCase() === needle || l.name.toLowerCase() === needle);
+        if (!hit) throw new UserError(`No layer ${JSON.stringify(ref)} on ${s.key}. Layers: ${infos.map((l) => l.name || l.id).join(" | ")}`);
+        return hit;
+      };
+      for (const ref of layersOpt.include || []) {
+        const l = resolve(ref);
+        infoById.set(l.id, { role: "boundary", visible: true });
+      }
+      for (const ref of layersOpt.exclude || []) {
+        const l = resolve(ref);
+        infoById.set(l.id, { role: l.role, visible: false });
+      }
+    }
+    return segRoles(geo.layerOf, layerRoleCodes(geo.layerIds, infoById));
+  }
   /** v1 masks come from the sheet's vector linework only. Raster seam: a scanned
    * sheet would render via a node canvas into a future rastermask module that
-   * returns this same MaskObj shape. */
+   * returns this same MaskObj shape. Layer roles (#85) ride in as the stated
+   * short-circuit; an unlayered sheet builds the identical pre-#85 mask. */
   async ensureMask(name) {
     const s = this.sheet(name);
     if (s.mask === void 0) {
       const geo = await this.ensureGeometry(s);
-      s.mask = geo.segs.length ? buildMask(geo.segs, s.widthPx, s.heightPx, MASK_MAX_DIM, geo.meta) : null;
+      s.mask = geo.segs.length ? buildMask(geo.segs, s.widthPx, s.heightPx, MASK_MAX_DIM, geo.meta, this.rolesFor(s, geo)) : null;
     }
     return s.mask;
   }
+  /** The mask honoring per-call layer overrides — a fresh build when overrides
+   * are given (never cached: the default mask stays authoritative), the cached
+   * default otherwise. */
+  async maskWithLayers(name, layersOpt) {
+    if (!layersOpt || !layersOpt.include?.length && !layersOpt.exclude?.length) return this.ensureMask(name);
+    const s = this.sheet(name);
+    const geo = await this.ensureGeometry(s);
+    if (!geo.segs.length) return null;
+    return buildMask(geo.segs, s.widthPx, s.heightPx, MASK_MAX_DIM, geo.meta, this.rolesFor(s, geo, layersOpt));
+  }
   async sheetInfo(name) {
     const s = this.sheet(name);
     const geo = await this.ensureGeometry(s);
@@ -1562,7 +2021,10 @@ var Session = class {
       has_vector_linework: geo.segs.length > 0,
       scale_set: s.upp != null,
       ...s.upp != null ? { upp: s.upp } : {},
-      shape_count: this.shapes.filter((x) => x.sheet_id === s.key).length
+      shape_count: this.shapes.filter((x) => x.sheet_id === s.key).length,
+      // the sheet's PDF layer table (#85) — always emitted; [] = no Optional
+      // Content survived export and every engine path runs the heuristics
+      layers: (s.layers || []).map((l) => ({ id: l.id, name: l.name, role: l.role, confidence: l.confidence, visible: l.visible, seg_count: l.seg_count }))
     };
   }
   scaleGate(s) {
@@ -1637,7 +2099,7 @@ var Session = class {
   }
   async oneClick(name, x, y, opts) {
     const s = this.sheet(name);
-    const mask = await this.ensureMask(name);
+    const mask = await this.maskWithLayers(name, opts.layers);
     if (!mask) throw new UserError("This sheet has no vector linework (likely a scan); raster fallback not yet available in the MCP server.");
     const f = floodRegion(mask, x, y, opts.sensitivity ?? SENS_BALANCED);
     if (f.status === "leak") throw new UserError("That space isn't enclosed on the plan linework \u2014 the fill spilled through a gap or opening.");
@@ -1673,6 +2135,9 @@ var Session = class {
         reviewed: false,
         ...f.hatchFiltered ? { hatch_filtered: true } : {},
         ...f.gapBridged ? { gap_bridged_px: f.gapBridged } : {},
+        // #85 — a trace bounded by DECLARED boundary layers is categorically
+        // stronger evidence than one bounded by a pitch heuristic
+        ...(s.layers || []).some((l) => l.visible && (l.role === "boundary" || l.role === "structure")) ? { layer_bounded: true } : {},
         // canvas-parity provenance: a non-default fill sensitivity is part of
         // how the shape was made (ShapeOrigin.fill_sensitivity)
         ...opts.sensitivity !== void 0 && opts.sensitivity !== SENS_BALANCED ? { fill_sensitivity: opts.sensitivity } : {}
@@ -1713,7 +2178,7 @@ var Session = class {
    *       judge and nothing commits anyway. */
   async detectRooms(name, opts) {
     const s = this.sheet(name);
-    const mask = await this.ensureMask(name);
+    const mask = await this.maskWithLayers(name, opts.layers);
     if (!mask) throw new UserError("This sheet has no vector linework (likely a scan); raster fallback not yet available in the MCP server.");
     const minAreaSf = opts.minAreaSf ?? 5;
     if (!s.spans) s.spans = textSpans(s.page);
@@ -2156,11 +2621,11 @@ var Session = class {
    * the contract a pricing consumer reads (#130) — export_takeoff carries
    * materials as CONFIG rows and takeoff_summary strips them; only this
    * document carries the computed order quantities. */
-  exportReport() {
+  exportReport(projectName = "") {
     if (!this.doc) throw new UserError("No plan loaded \u2014 call load_plan first.");
     const rows = conditionTotals(this.conditions, this.shapes).filter((r) => r.shape_count > 0);
     return reportJson({
-      projectName: "",
+      projectName,
       rows,
       bySheet: sheetTotals(this.conditions, this.shapes),
       scaleInfo: [...this.sheets.values()].filter((s) => s.upp != null).map((s) => ({ sheet_id: s.key, scale_source: s.scaleSource ?? "unknown" })),
@@ -2168,6 +2633,90 @@ var Session = class {
       rfis: []
     });
   }
+  // ── the sheet graph (#87) ─────────────────────────────────────────────────
+  // Built lazily from every sheet's text spans, cached per document (loadPlan
+  // clears it). The engine is pure (web/src/lib/sheetgraph.ts); this is the
+  // span plumbing plus the wire shapes.
+  graph = null;
+  async ensureGraph() {
+    if (!this.doc) throw new UserError("No plan loaded \u2014 call load_plan first.");
+    if (!this.graph) {
+      const inputs = [];
+      for (const s of this.sheets.values()) {
+        if (!s.spans) s.spans = textSpans(s.page);
+        inputs.push({
+          key: s.key,
+          sheet_number: s.sheetNumber,
+          spans: s.spans.map((t) => ({ str: t.str, x: t.x0, y: t.y0, w: t.x1 - t.x0, h: t.y1 - t.y0 }))
+        });
+      }
+      this.graph = buildSheetGraph(inputs);
+    }
+    return this.graph;
+  }
+  static wireBox(b) {
+    return { x0: round1(b[0]), y0: round1(b[1]), x1: round1(b[2]), y1: round1(b[3]) };
+  }
+  static wireEvidence(e) {
+    return { sheet: e.sheet, text: e.text, bbox: _Session.wireBox(e.bbox) };
+  }
+  async sheetGraph() {
+    const g = await this.ensureGraph();
+    return {
+      available: g.available,
+      sheets: g.sheets.map((s) => ({
+        sheet: s.key,
+        role: s.role,
+        confidence: s.confidence,
+        ...s.evidence ? { evidence: _Session.wireEvidence(s.evidence) } : {},
+        schedules: s.schedules.map((t) => ({ kind: t.kind, title: t.title, rows: t.rows, region: _Session.wireBox(t.region) }))
+      })),
+      rooms: g.rooms.map((r) => ({ tag: r.tag, name: r.name, sheet: r.sheet, bbox: _Session.wireBox(r.bbox) })),
+      callouts: g.callouts.map((c) => ({ detail: c.detail, target_sheet: c.target_sheet, sheet: c.sheet, bbox: _Session.wireBox(c.bbox) })),
+      counts: { rooms: g.rooms.length, schedules: g.tables.length, callouts: g.callouts.length }
+    };
+  }
+  async resolveRoomTag(tag) {
+    if (!tag || !tag.trim()) throw new UserError('Pass a room tag, e.g. resolve_tag { tag: "134" }.');
+    const g = await this.ensureGraph();
+    if (!g.available) throw new UserError("This set has no text layer (a scan) \u2014 the sheet graph is unavailable, not empty.");
+    const res = resolveTag(g, tag);
+    const room = res.room ? { tag: res.room.tag, name: res.room.name, sheet: res.room.sheet, bbox: _Session.wireBox(res.room.bbox) } : null;
+    if (res.status === "unresolved") return { status: "unresolved", tag: res.tag, room, reason: res.reason };
+    return {
+      status: "resolved",
+      tag: res.tag,
+      room,
+      finishes: res.finishes.map((f) => ({
+        surface: f.surface,
+        code: f.code,
+        source: _Session.wireEvidence(f.source),
+        ...f.definition ? { definition: { cells: f.definition.cells, source: _Session.wireEvidence(f.definition.source) } } : {}
+      })),
+      sources: res.sources.map(_Session.wireEvidence)
+    };
+  }
+  async findSchedule(kind) {
+    const g = await this.ensureGraph();
+    if (!g.available) throw new UserError("This set has no text layer (a scan) \u2014 the sheet graph is unavailable.");
+    const k = (kind || "").toLowerCase();
+    const want = /room/.test(k) ? "room-finish" : /finish|material|product|code|mark/.test(k) ? "finish" : k;
+    const hits = g.tables.filter((t) => t.kind === want);
+    if (!hits.length) {
+      const found = g.tables.map((t) => `${t.kind} on ${t.sheet}`).join(" | ");
+      throw new UserError(`No ${JSON.stringify(kind)} schedule found in the set. Found: ${found || "no schedules at all"}.`);
+    }
+    return {
+      matches: hits.map((t) => ({
+        sheet: t.sheet,
+        kind: t.kind,
+        title: t.title?.text || "",
+        rows: t.rows.length,
+        headers: t.headers,
+        region: _Session.wireBox(t.region)
+      }))
+    };
+  }
   readSheetText(name, region) {
     const s = this.sheet(name);
     const items = region ? s.text.filter((t) => t.x >= region.x0 && t.x <= region.x1 && t.y >= region.y0 && t.y <= region.y1) : s.text;
@@ -2246,7 +2795,15 @@ var sheetInfoOutput = {
   has_vector_linework: z.boolean().describe("one_click needs vector linework"),
   scale_set: z.boolean(),
   upp: z.number().optional().describe("Real feet per image px at render scale 2.0 \u2014 present once the scale is set"),
-  shape_count: z.number().int().describe("Committed shapes on this sheet")
+  shape_count: z.number().int().describe("Committed shapes on this sheet"),
+  layers: z.array(z.object({
+    id: z.string().describe("Optional Content Group id \u2014 pass to one_click/detect_rooms layers.include/exclude"),
+    name: z.string().describe("The CAD layer name as exported (e.g. A-WALL-FULL)"),
+    role: z.enum(["boundary", "finish-pattern", "annotation", "structure", "demolition", "unknown"]).describe("What this layer's linework IS to a takeoff (lib/layers.ts) \u2014 boundary/structure plot hard, pattern/annotation/demolition are excluded, unknown falls back to the hatch heuristics"),
+    confidence: z.number().describe("0..1 \u2014 how sure the name classifier is"),
+    visible: z.boolean().describe("Default-config visibility \u2014 a hidden layer's ink is excluded outright (or you trace demolition)"),
+    seg_count: z.number().int().describe("Segments this layer owns on this sheet")
+  })).describe("The sheet's PDF layer table (#85) \u2014 [] when no Optional Content survived export (every engine path then runs the heuristics unchanged)")
 };
 var setScaleOutput = {
   sheet: z.string(),
@@ -2451,7 +3008,8 @@ var exportReportOutput = {
   shape_labels: z.array(z.string()),
   by_label: z.array(z.record(z.unknown())),
   units: z.string(),
-  display_units: z.string()
+  display_units: z.string(),
+  roll_goods: z.array(z.record(z.unknown())).describe("Roll-goods order rows (#136) \u2014 order_lf / rolls / order_qty per roll-goods condition, \xD7N applied; empty when no condition carries a roll_setup (always the case for a headless session today)")
 };
 var editConditionOutput = {
   condition: z.string().describe("The finish tag passed in"),
@@ -2464,6 +3022,45 @@ var readSheetTextOutput = {
   items: z.array(z.object({ str: z.string(), x: z.number(), y: z.number() })).describe("Positioned text items (image px)"),
   text: z.string().describe("The items joined with spaces")
 };
+var wireBox = z.object({ x0: z.number(), y0: z.number(), x1: z.number(), y1: z.number() });
+var wireEvidence = z.object({ sheet: z.string(), text: z.string(), bbox: wireBox }).describe("An evidence pointer \u2014 the sheet, the literal text, and where it sits (image px). Every edge in the graph carries one; pass the bbox to view_sheet to LOOK at the source.");
+var graphRoom = z.object({ tag: z.string(), name: z.string().describe("The name span stacked over the tag ('' when none)"), sheet: z.string(), bbox: wireBox });
+var sheetGraphOutput = {
+  available: z.boolean().describe("false = the set has no text layer (a scan) \u2014 the graph degrades to unavailable, never half-populates"),
+  sheets: z.array(z.object({
+    sheet: z.string(),
+    role: z.enum(["plan", "schedule", "legend", "detail", "elevation", "demolition", "unknown"]),
+    confidence: z.number().describe("0..1; mixed title signals halve it, a bare sheet-number convention stays under 0.5"),
+    evidence: wireEvidence.optional(),
+    schedules: z.array(z.object({ kind: z.string(), title: z.string(), rows: z.number().int(), region: wireBox }))
+  })),
+  rooms: z.array(graphRoom).describe("Room tags read off plan-role sheets \u2014 schedule sheets contribute rows, never phantom rooms"),
+  callouts: z.array(z.object({ detail: z.string(), target_sheet: z.string(), sheet: z.string(), bbox: wireBox })).describe("Detail callouts (3/A-601) \u2014 edges to their target sheets"),
+  counts: z.object({ rooms: z.number().int(), schedules: z.number().int(), callouts: z.number().int() })
+};
+var resolveTagOutput = {
+  status: z.enum(["resolved", "unresolved"]),
+  tag: z.string(),
+  room: graphRoom.nullable().describe("The plan tag, when the room appears on a plan sheet \u2014 cited even when resolution fails"),
+  finishes: z.array(z.object({
+    surface: z.string().describe("The schedule column: FLOOR / BASE / WALL / \u2026"),
+    code: z.string(),
+    source: wireEvidence,
+    definition: z.object({ cells: z.record(z.string()), source: wireEvidence }).optional().describe("The finish/material-schedule row this code chains to, when one exists")
+  })).optional(),
+  sources: z.array(wireEvidence).optional().describe("The chain: plan tag \u2192 schedule row"),
+  reason: z.string().optional().describe("unresolved only \u2014 WHY (no schedule row / ambiguous / no schedule found). A room that appears on the plan with no row comes back here, never as a silent omission")
+};
+var findScheduleOutput = {
+  matches: z.array(z.object({
+    sheet: z.string(),
+    kind: z.string(),
+    title: z.string(),
+    rows: z.number().int(),
+    headers: z.array(z.string()),
+    region: wireBox.describe("Pass to view_sheet to look at the table")
+  }))
+};
 var hatchFamilyRow = z.object({
   id: z.string().describe("Content hash of the quantized (angle, pitch, pen-width) signature \u2014 the SAME id for the same pattern spec anywhere on the sheet, so legend\u2194plan matching is id === id. Identifies a pattern, not a material; the legend maps pattern \u2192 material."),
   angle_deg: z.number().describe("Raw mean angle [0, 180) \u2014 rides beside the id for tolerance matching at bucket boundaries"),
@@ -2535,6 +3132,10 @@ var linkAnnotationOutput = {
 var COORDS = "Coordinates are image px at render scale 2.0: PDF pt \xD7 2, origin top-left, y down (the browser canvas's native space). Sheet payloads carry dims in both px and pt.";
 var pointSchema = z2.tuple([z2.number(), z2.number()]);
 var roleSchema = z2.enum(["floor_area", "deduct"]).default("floor_area");
+var layersFilterSchema = z2.object({
+  include: z2.array(z2.string()).optional().describe("Layer names or ids whose ink must plot as HARD boundary"),
+  exclude: z2.array(z2.string()).optional().describe("Layer names or ids whose ink must not block the flood at all")
+}).optional().describe("Override the sheet's classified layer roles for THIS call (see sheet_info.layers)");
 var run = (tool, fn) => async (args) => {
   const startedAt = process.hrtime.bigint();
   let reply;
@@ -2585,10 +3186,11 @@ function registerTools(server, session) {
       condition: z2.string().optional().describe("Finish tag to commit under (minted on first use)"),
       role: roleSchema,
       return_verts: z2.boolean().default(false).describe("Include the traced polygon's vertices (image px)"),
-      sensitivity: z2.number().min(0).max(1).optional().describe("Fill sensitivity, the same knob the canvas has: 0 strict (hatch/light linework always blocks), 0.5 balanced (default), 1 aggressive (crosses more hatch, tolerates more growth). Raise it when a flood stops short at hatching INSIDE the room; verify the grown ring with view_sheet overlay before committing")
+      sensitivity: z2.number().min(0).max(1).optional().describe("Fill sensitivity, the same knob the canvas has: 0 strict (hatch/light linework always blocks), 0.5 balanced (default), 1 aggressive (crosses more hatch, tolerates more growth). Raise it when a flood stops short at hatching INSIDE the room; verify the grown ring with view_sheet overlay before committing"),
+      layers: layersFilterSchema
     },
     outputSchema: oneClickOutput
-  }, run("one_click", (a) => session.oneClick(a.sheet, a.x, a.y, { condition: a.condition, role: a.role, returnVerts: a.return_verts, sensitivity: a.sensitivity })));
+  }, run("one_click", (a) => session.oneClick(a.sheet, a.x, a.y, { condition: a.condition, role: a.role, returnVerts: a.return_verts, sensitivity: a.sensitivity, layers: a.layers })));
   server.registerTool("detect_rooms", {
     description: `Batch room detection: reads every room-number label off the sheet's text layer (e.g. "134", "OFFICE 101") and runs One-Click at each \u2014 one call instead of read_sheet_text + reasoning + N one_click calls. A seed is only reported as a room once it survives three gates, and everything skipped is counted and reasoned in \`withheld\` \u2014 never dropped silently, because a room the tool tells you it skipped is a question you can ask, while one it hides is a hole in a bid. The gates: a flood that leaked or landed in dense linework never becomes a region; two labels flooding the SAME region commit once (the extra labels ride on \`merged_labels\` \u2014 double-counting an area is the worst failure an estimating tool has); and a flood that is enclosed and clean but smaller than min_area_sf is a room-number bubble, a door swing, or a wall cavity rather than a room. With the sheet's scale set, returns area_sf/perimeter_lf per room; pass condition to commit every detected room under that finish tag (role "deduct" makes them subtract). Without a scale, returns px-only quantities per room and commits nothing \u2014 the plausibility floor needs real units, so it only applies once a scale is set. ${COORDS}`,
     inputSchema: {
@@ -2597,10 +3199,11 @@ function registerTools(server, session) {
       role: roleSchema,
       return_verts: z2.boolean().default(false).describe("Include each traced polygon's vertices (image px)"),
       min_area_sf: z2.number().positive().default(5).describe("Plausibility floor: enclosed non-bubble regions smaller than this are withheld as cavities, not rooms. Default 5 SF \u2014 below any real finished space (a broom closet is ~10 SF). Lower it to inspect what was skipped."),
-      sensitivity: z2.number().min(0).max(1).optional().describe("Fill sensitivity, the same knob the canvas has: 0 strict (hatch/light linework always blocks), 0.5 balanced (default), 1 aggressive (crosses more hatch, tolerates more growth). Raise it when a flood stops short at hatching INSIDE the room; verify the grown ring with view_sheet overlay before committing")
+      sensitivity: z2.number().min(0).max(1).optional().describe("Fill sensitivity, the same knob the canvas has: 0 strict (hatch/light linework always blocks), 0.5 balanced (default), 1 aggressive (crosses more hatch, tolerates more growth). Raise it when a flood stops short at hatching INSIDE the room; verify the grown ring with view_sheet overlay before committing"),
+      layers: layersFilterSchema
     },
     outputSchema: detectRoomsOutput
-  }, run("detect_rooms", (a) => session.detectRooms(a.sheet, { condition: a.condition, role: a.role, returnVerts: a.return_verts, minAreaSf: a.min_area_sf, sensitivity: a.sensitivity })));
+  }, run("detect_rooms", (a) => session.detectRooms(a.sheet, { condition: a.condition, role: a.role, returnVerts: a.return_verts, minAreaSf: a.min_area_sf, sensitivity: a.sensitivity, layers: a.layers })));
   server.registerTool("measure_polygon", {
     description: `Measure a closed polygon you supply (min 3 vertices, image px): area_sf and perimeter_lf at the sheet's scale. Requires the scale to be set. Pass condition to commit it; role "deduct" subtracts. ${COORDS}`,
     inputSchema: {
@@ -2639,10 +3242,13 @@ function registerTools(server, session) {
   }));
   server.registerTool("export_report", {
     description: `The computed Report document \u2014 "opentakeoff.report.v1", the same schema the canvas Report's JSON export writes. Everything a pricing consumer needs without re-implementing the app's math: per-condition quantities with waste and multiplier applied (gross and *_net), the computed materials BUY LIST per condition (order quantity = basis \xF7 coverage rate, rounded up to whole purchase units) plus the project-wide roll-up summed by (name, unit), per-sheet BASE subtotals, scale provenance per sheet, and annotations. Contrast: export_takeoff is the raw canvas payload (materials as CONFIG rows, no computed quantities) and takeoff_summary strips materials for a compact reply \u2014 when the numbers are leaving for pricing, consume this. Returned inline; pass path to also write it to disk as JSON.`,
-    inputSchema: { path: z2.string().optional().describe("File path to write the document to") },
+    inputSchema: {
+      path: z2.string().optional().describe("File path to write the document to"),
+      project_name: z2.string().optional().describe("Label for the document's project_name field (a headless session has no project of its own; omitted \u2192 null)")
+    },
     outputSchema: exportReportOutput
-  }, run("export_report", async ({ path: outPath }) => {
-    const doc = session.exportReport();
+  }, run("export_report", async ({ path: outPath, project_name: projectName }) => {
+    const doc = session.exportReport(projectName);
     if (outPath) {
       const { writeFile } = await import("node:fs/promises");
       await writeFile(outPath, JSON.stringify(doc));
@@ -2710,6 +3316,21 @@ function registerTools(server, session) {
     },
     outputSchema: undoLastOutput
   }, run("undo_last", ({ n }) => session.undoLast(n)));
+  server.registerTool("sheet_graph", {
+    description: `The plan-set INDEX (#87): every sheet's role (plan / schedule / legend / \u2026, with confidence and the title evidence), the schedule tables found (kind, row count, region), every room tag on the plan sheets (with the stacked room NAME when one exists), and the detail callouts (3/A-601 \u2192 sheet edges). Built once per document from the text layer and cached. This is how an agent decides WHAT to measure without a human enumerating the rooms: list the rooms here, resolve each with resolve_tag, then measure with one_click/detect_rooms. A scanned set (no text layer) returns available: false \u2014 unavailable, never half-populated. ${COORDS}`,
+    inputSchema: {},
+    outputSchema: sheetGraphOutput
+  }, run("sheet_graph", () => session.sheetGraph()));
+  server.registerTool("resolve_tag", {
+    description: `Resolve ONE room tag across the set (#87): the plan tag \u2192 its room-finish schedule row \u2192 each finish code's definition in the finish/material schedule, EVERY edge carrying an evidence pointer (sheet + literal text + bbox \u2014 pass a bbox to view_sheet to look at the source). The doctrine is refusal over guessing: a room that appears on the plan with no schedule row returns status "unresolved" with the reason (and still cites the plan tag); reused room numbers across the set return "ambiguous" rather than picking one. This is the answer to "what finish is specified in room 134, and how do you know". ${COORDS}`,
+    inputSchema: { tag: z2.string().describe('The room tag as drawn, e.g. "134" or "139A"') },
+    outputSchema: resolveTagOutput
+  }, run("resolve_tag", ({ tag }) => session.resolveRoomTag(tag)));
+  server.registerTool("find_schedule", {
+    description: `Locate a schedule table in the set (#87): pass a kind ("room finish", "material"/"finish") and get every matching table's sheet, title, headers, row count, and REGION \u2014 sized for a view_sheet look or a read_sheet_text pull of exactly the table. Errors with what WAS found when the asked-for kind isn't in the set. ${COORDS}`,
+    inputSchema: { kind: z2.string().describe('"room finish" (rooms \u2192 surface finishes) or "finish"/"material" (codes \u2192 products)') },
+    outputSchema: findScheduleOutput
+  }, run("find_schedule", ({ kind }) => session.findSchedule(kind)));
   server.registerTool("read_sheet_text", {
     description: `The sheet's text with positions \u2014 items [{str, x, y}] in image px plus the joined text. Optionally restrict to a region {x0, y0, x1, y1}. Use it to read title blocks, room labels, finish schedules, and scale notes. ${COORDS}`,
     inputSchema: {
@@ -2863,7 +3484,7 @@ function registerResources(server, session) {
 // package.json
 var package_default = {
   name: "opentakeoff-mcp",
-  version: "0.9.3",
+  version: "0.9.7",
   mcpName: "io.github.Kentucky-ai/opentakeoff",
   type: "module",
   description: "OpenTakeoff MCP server \u2014 drive the takeoff engine from your MCP client over stdio.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opentakeoff-mcp",
-  "version": "0.9.3",
+  "version": "0.9.7",
   "mcpName": "io.github.Kentucky-ai/opentakeoff",
   "type": "module",
   "description": "OpenTakeoff MCP server \u2014 drive the takeoff engine from your MCP client over stdio.",