opentakeoff-mcp 0.9.45 → 0.9.47

package/dist/server-core.js

@@ -2677,34 +2677,98 @@ function clusterRows(spans) {
   return rows.map((r) => r.sort((a, b) => a.x - b.x));
 }
 var rowY = (r) => r.reduce((s, t) => s + t.y, 0) / r.length;
-var ROOM_HEADERS = ["ROOM", "NO", "NUMBER", "NAME", "FLOOR", "BASE", "WALL", "WALLS", "NORTH", "SOUTH", "EAST", "WEST", "CEILING", "WAINSCOT", "REMARKS", "CLG", "HT", "BLDG", "BUILDING"];
+var SURFACE_WORDS = /* @__PURE__ */ new Set(["FLOOR", "BASE", "WALL", "WALLS", "CEILING", "NORTH", "SOUTH", "EAST", "WEST", "WAINSCOT"]);
+var ROOM_HEADERS = ["ROOM", "NO", "NUMBER", "NAME", "MARK", "LOCATION", "FLOOR", "BASE", "WALL", "WALLS", "NORTH", "SOUTH", "EAST", "WEST", "CEILING", "WAINSCOT", "REMARKS", "CLG", "HT", "HEIGHT", "FINISH", "CASEWORK", "CABINET", "COUNTER", "COUNTERTOP", "BLDG", "BUILDING"];
 var FINISH_HEADERS = ["CODE", "MARK", "SYMBOL", "MATERIAL", "MANUFACTURER", "PRODUCT", "STYLE", "COLOR", "SIZE", "REMARKS", "DESCRIPTION", "PATTERN", "COMMENTS"];
-var headerLabel = (s, vocab) => {
-  for (const w of norm(s).split(/[^A-Z]+/)) if (w && vocab.includes(w)) return w;
-  return null;
+var headerLabel = (s, vocab) => headerLabels(s, vocab)[0] ?? null;
+var headerLabels = (s, vocab) => {
+  const out = [];
+  for (const w of norm(s).split(/[^A-Z]+/)) if (w && vocab.includes(w) && !out.includes(w)) out.push(w);
+  return out;
+};
+function headerHits(row, vocab) {
+  const out = [];
+  for (const t of row) {
+    const w = headerLabel(t.str, vocab);
+    if (w) out.push({ label: w, span: t });
+  }
+  return out.sort((a, b) => a.span.x - b.span.x);
+}
+var qualifies = (hits, required, minHits) => {
+  const seen = new Set(hits.map((h) => h.label));
+  return seen.size >= minHits && required.some((r) => seen.has(r));
 };
 function findHeaderRow(rows, vocab, required, minHits) {
   for (let i = 0; i < rows.length; i++) {
+    let hits = headerHits(rows[i], vocab);
+    if (!qualifies(hits, required, minHits)) continue;
+    let idx = i;
+    for (; ; ) {
+      let next = -1;
+      for (let j = idx + 1; j < Math.min(idx + 4, rows.length); j++) {
+        const h = headerHits(rows[j], vocab);
+        const ratio = h.length / Math.max(1, rows[j].length);
+        if (qualifies(h, required, minHits) && h.length > hits.length && ratio >= 0.6) {
+          next = j;
+          break;
+        }
+      }
+      if (next < 0) break;
+      idx = next;
+      hits = headerHits(rows[idx], vocab);
+    }
+    const dup = /* @__PURE__ */ new Set();
+    const once = /* @__PURE__ */ new Set();
+    for (const h of hits) (once.has(h.label) ? dup : once).add(h.label);
     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 + (t.w || 0) / 2 });
+    const used = /* @__PURE__ */ new Set();
+    for (let j = 0; j < hits.length; j++) {
+      const h = hits[j];
+      let label = h.label;
+      if (dup.has(h.label) && !SURFACE_WORDS.has(h.label)) {
+        const hi = j + 1 < hits.length ? hits[j + 1].span.x : Infinity;
+        const parent = parentLabelOver(rows, idx, i, h.span.x, hi, vocab);
+        if (parent && parent !== h.label) label = `${parent} ${h.label}`;
+      }
+      if (used.has(label)) {
+        const alt = headerLabels(h.span.str, vocab).find((w) => !used.has(w));
+        if (alt) label = alt;
+      }
+      if (used.has(label)) continue;
+      used.add(label);
+      anchors.push({ label, x: h.span.x + (h.span.w || 0) / 2 });
+    }
+    if (anchors.length < minHits) continue;
+    if (idx > i) {
+      const lo = Math.min(...anchors.map((a) => a.x)), hi = Math.max(...anchors.map((a) => a.x));
+      for (let j = i; j < idx; j++) {
+        for (const h of headerHits(rows[j], vocab)) {
+          const cx = h.span.x + (h.span.w || 0) / 2;
+          if (cx >= lo && cx <= hi) continue;
+          if (used.has(h.label)) continue;
+          used.add(h.label);
+          anchors.push({ label: h.label, x: cx });
+        }
       }
     }
-    if (anchors.length < minHits || !required.some((r) => seen.has(r))) continue;
-    return { anchors: subTierAnchors(rows, i, anchors.sort((a, b) => a.x - b.x), vocab), rowIndex: i };
+    return { anchors: subTierAnchors(rows, idx, anchors.sort((a, b) => a.x - b.x), vocab), rowIndex: idx };
   }
   return null;
 }
 var SUB_LABEL_RE = /^[A-Z0-9][A-Z0-9.\/-]{0,5}$/;
-function parentLabelOver(rows, hdrIdx, gx0, gx1, vocab) {
-  const width = Math.max(gx1 - gx0, 1);
-  for (let j = hdrIdx - 1; j >= 0 && j >= hdrIdx - 2; j--) {
+function parentLabelOver(rows, hdrIdx, topIdx, gx0, gx1, vocab) {
+  const width = Math.max(Math.min(gx1, gx0 + 4e3) - gx0, 1);
+  const hs = rows[hdrIdx].map((t) => t.h || 8).sort((a, b) => a - b);
+  const near = Math.max(24, (hs[hs.length >> 1] || 8) * 4);
+  const hy = rowY(rows[hdrIdx]);
+  const floorIdx = Math.max(0, Math.min(topIdx, hdrIdx - 8));
+  for (let j = hdrIdx - 1; j >= floorIdx; j--) {
+    if (hy - rowY(rows[j]) > near) break;
     for (const t of rows[j]) {
-      if (Math.min(t.x + (t.w || 0), gx1) - Math.max(t.x, gx0) <= width * 0.3) continue;
+      const cx = t.x + (t.w || 0) / 2;
+      const inInterval = cx >= gx0 && cx < gx1;
+      const overlaps = Math.min(t.x + (t.w || 0), gx1) - Math.max(t.x, gx0) > width * 0.3;
+      if (!inInterval && !overlaps) continue;
       const lbl = headerLabel(t.str, vocab);
       if (lbl) return lbl;
     }
@@ -2733,7 +2797,7 @@ function subTierAnchors(rows, hdrIdx, anchors, vocab) {
   for (const r of runs) {
     if (r.length < 2) continue;
     const last = r[r.length - 1];
-    const parent = parentLabelOver(rows, hdrIdx, r[0].x, last.x + (last.w || 0), vocab);
+    const parent = parentLabelOver(rows, hdrIdx, hdrIdx - 2, r[0].x, last.x + (last.w || 0), vocab);
     if (!parent) continue;
     const pitch = r.length > 1 ? r.slice(1).map((t, i) => mid(t) - mid(r[i])).sort((a, b) => a - b)[r.length - 1 >> 1] : 0;
     for (const t of r) {
@@ -2819,14 +2883,78 @@ function rowKeyOf(raw, kind, buildings) {
 }
 var numOf = (key) => key.match(QUALIFIED_KEY_RE)?.[2] ?? key;
 var centerX = (t) => t.x + (t.w || 0) / 2;
+function columnMapFor(rows, anchors, cfg, x0, x1, coord) {
+  const at = (t) => coord === "left" ? t.x : t.x + (t.w || 0) / 2;
+  const xs = [];
+  const hs = [];
+  for (let i = Math.max(cfg.fromIdx, 0); i < rows.length; i++) {
+    if (rowY(rows[i]) <= cfg.belowY) continue;
+    for (const t of rows[i]) {
+      if (t.x < x0 || t.x > x1 || revisionOf(t.str) != null) continue;
+      xs.push(at(t));
+      hs.push(t.h || 8);
+    }
+  }
+  if (xs.length < anchors.length * 2) return null;
+  hs.sort((a, b) => a - b);
+  const tol = Math.max(4, hs[hs.length >> 1] * 0.5);
+  xs.sort((a, b) => a - b);
+  const clusters = [];
+  for (const x of xs) {
+    const last = clusters[clusters.length - 1];
+    if (last && x - last.start <= tol) {
+      last.n++;
+      continue;
+    }
+    clusters.push({ start: x, n: 1 });
+  }
+  const maxN = Math.max(...clusters.map((c) => c.n));
+  const kept = clusters.filter((c) => c.n >= Math.max(2, maxN * 0.25));
+  if (kept.length < anchors.length) return null;
+  const byLabel = /* @__PURE__ */ new Map();
+  for (const c of kept) {
+    const own = anchors.find((a) => a.x >= c.start);
+    if (!own) continue;
+    const cur = byLabel.get(own.label);
+    if (cur == null || c.start < cur) byLabel.set(own.label, c.start);
+  }
+  if (byLabel.size !== anchors.length) return null;
+  const cols = [...byLabel.entries()].map(([label, start]) => ({ label, start })).sort((a, b) => a.start - b.start);
+  if (cols.map((c) => c.label).join("|") !== anchors.map((a) => a.label).join("|")) return null;
+  const starts = kept.map((c) => c.start);
+  let on = 0;
+  for (const x of xs) if (starts.some((st) => Math.abs(x - st) <= tol)) on++;
+  return { coord, cols, score: on / xs.length };
+}
+function columnStarts(rows, anchors, cfg, x0, x1) {
+  const FIT_FLOOR = 0.7;
+  const fits = (m) => m && m.score >= FIT_FLOOR ? m : null;
+  const left = fits(columnMapFor(rows, anchors, cfg, x0, x1, "left"));
+  const center = fits(columnMapFor(rows, anchors, cfg, x0, x1, "center"));
+  if (!left) return center;
+  if (!center) return left;
+  return center.score > left.score + 0.05 ? center : left;
+}
 function bandDataRows(rows, anchors, kind, sheetKey, buildings, cfg) {
   const { x0, x1, medGap } = bandLimits(anchors);
+  const cols = columnStarts(rows, anchors, cfg, x0, x1);
+  const keyTol = cols && cols.cols.length > 1 ? Math.max(8, (cols.cols[1].start - cols.cols[0].start) * 0.5) : 40;
   const out = [];
   const outY = [];
   let region = null;
+  const columnOf = (t) => {
+    if (!cols) return nearestAnchor(centerX(t), anchors);
+    const at = cols.coord === "left" ? t.x : centerX(t);
+    let label = cols.cols[0].label;
+    for (const c of cols.cols) {
+      if (at + 1 >= c.start) label = c.label;
+      else break;
+    }
+    return label;
+  };
   const add = (row, toks) => {
     for (const t of toks) {
-      const label = nearestAnchor(centerX(t), anchors);
+      const label = columnOf(t);
       const text = t.str.trim();
       if (!row.cells[label]) row.cells[label] = { text, bbox: bboxOf(t) };
       else row.cells[label] = { text: `${row.cells[label].text} ${text}`, bbox: merge(row.cells[label].bbox, bboxOf(t)) };
@@ -2853,6 +2981,7 @@ function bandDataRows(rows, anchors, kind, sheetKey, buildings, cfg) {
       orphans.push({ toks: banded, y: rowY(rows[i]) });
       continue;
     }
+    if (cols && Math.abs((cols.coord === "left" ? banded[0].x : centerX(banded[0])) - cols.cols[0].start) > keyTol) continue;
     if (cfg.keyAlign && Math.abs(centerX(banded[0]) - cfg.keyAlign.x) > cfg.keyAlign.tol) continue;
     const row = { key: keyed.key, sheet: sheetKey, cells: {} };
     if (keyed.building) row.building = keyed.building;
@@ -2860,6 +2989,21 @@ function bandDataRows(rows, anchors, kind, sheetKey, buildings, cfg) {
     out.push(row);
     outY.push(rowY(rows[i]));
   }
+  if (out.length > 2) {
+    const d = outY.slice(1).map((y, i) => y - outY[i]).filter((g) => g > 0).sort((a, b) => a - b);
+    const pitch0 = d.length ? d[d.length >> 1] : 0;
+    if (pitch0 > 0) {
+      let end = out.length;
+      for (let i = 1; i < outY.length; i++) if (outY[i] - outY[i - 1] > pitch0 * 8) {
+        end = i;
+        break;
+      }
+      if (end < out.length) {
+        out.length = end;
+        outY.length = end;
+      }
+    }
+  }
   const gaps = outY.slice(1).map((y, i) => y - outY[i]).filter((d) => d > 0).sort((a, b) => a - b);
   const pitch = gaps.length ? gaps[gaps.length >> 1] : 0;
   const nearest = (y) => {
@@ -2922,8 +3066,12 @@ function extractTable(sheet, kind, opts = {}) {
     titleFrom = rows.findIndex((r) => rowY(r) >= rot.top) - 1;
     if (titleFrom < -1) titleFrom = rows.length - 1;
   }
+  const hdrBand = bandLimits(anchors);
   let region = null;
-  for (const t of headerSpans) region = region ? merge(region, bboxOf(t)) : bboxOf(t);
+  for (const t of headerSpans) {
+    if (centerX(t) < hdrBand.x0 || centerX(t) > hdrBand.x1) continue;
+    region = region ? merge(region, bboxOf(t)) : bboxOf(t);
+  }
   const banded = bandDataRows(rows, anchors, kind, sheet.key, opts.buildings, { fromIdx: dataFrom, belowY: dataBelowY, deltas: opts.deltas });
   const out = banded.out;
   if (banded.region) region = region ? merge(region, banded.region) : banded.region;
@@ -2983,6 +3131,7 @@ function adoptContinuationRows(sheet, titleSpan, base, buildings, deltas) {
   };
 }
 var QUALIFIED_TAG_RE = /^([A-Z]{1,2})-(\d{2,3}[A-Z]?)$/;
+var NON_ROOM_NAME = /* @__PURE__ */ new Set(["NUMBER", "NO", "NAME", "MARK", "SYMBOL", "CODE", "TYPE", "QTY", "SIZE", "TOTAL", "SHEET", "DATE", "SCALE", "REV", "REVISION", "DESCRIPTION", "REMARKS", "COMMENTS", "DETAIL", "ROOM"]);
 function roomTags(sheet, opts = {}) {
   const out = [];
   const spans = sheet.spans;
@@ -3007,7 +3156,10 @@ function roomTags(sheet, opts = {}) {
       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;
+      const raw = cand.str.trim();
+      if (/[a-z]/.test(raw)) continue;
+      if (!/^[A-Z][A-Z .'’\/&-]{1,}$/.test(norm(raw))) continue;
+      if (NON_ROOM_NAME.has(norm(raw))) continue;
       if (dy < best) {
         best = dy;
         name = cand.str.trim();
@@ -3054,7 +3206,7 @@ function detailCallouts(sheet) {
 }
 function buildSheetGraph(sheets) {
   const withText = sheets.filter((s) => s.spans.length > 0);
-  if (!withText.length) return { available: false, sheets: [], rooms: [], tables: [], callouts: [], buildings: [], revisions: [], notes: [] };
+  if (!withText.length) return { available: false, sheets: [], rooms: [], unmatched_tags: [], tables: [], callouts: [], buildings: [], revisions: [], notes: [] };
   const notes = [];
   const deltasBySheet = /* @__PURE__ */ new Map();
   const revisions = [];
@@ -3132,19 +3284,46 @@ function buildSheetGraph(sheets) {
     const n = norm(s.sheet_number || "").replace(/[^A-Z0-9]/g, "");
     if (n) sheetNumbers.add(n);
   }
-  const rooms = [];
+  const found = [];
   const callouts = [];
   for (const s of withText) {
     const role = roles.get(s.key);
-    if (role.role === "plan" || role.role === "unknown" || role.role === "demolition") {
+    const suppresses = (role.role === "schedule" || role.role === "legend" || role.role === "elevation" || role.role === "detail") && role.confidence >= 0.6;
+    if (!suppresses) {
       const ctxB = ctxBySheet.get(s.key);
       for (const r of roomTags(s, { buildings, exclude: sheetNumbers, deltas: deltasBySheet.get(s.key) })) {
         if (r.building == null && ctxB) r.building = ctxB;
-        rooms.push(r);
+        found.push(r);
       }
     }
     callouts.push(...detailCallouts(s));
   }
+  const roomRows = tables.filter((t) => t.kind === "room-finish");
+  const scheduleNums = /* @__PURE__ */ new Set();
+  for (const t of roomRows) for (const r of t.rows) scheduleNums.add(numOf(norm(r.key)));
+  const rooms = [];
+  const unmatched = [];
+  for (const r of found) {
+    const num2 = numOf(norm(r.tag).replace(/\s+/g, ""));
+    const byName = !!r.name.trim();
+    const bySchedule = scheduleNums.has(num2);
+    if (bySchedule || byName && !roomRows.length) {
+      r.corroboration = bySchedule ? byName ? "name+schedule" : "schedule" : "name";
+      rooms.push(r);
+    } else {
+      unmatched.push({
+        tag: r.tag,
+        sheet: r.sheet,
+        bbox: r.bbox,
+        ...r.building ? { building: r.building } : {},
+        ...byName ? { name: r.name } : {},
+        reason: !roomRows.length ? "no room name drawn with it, and the set carries no room-finish schedule to check it against" : byName ? `"${r.name}" is drawn with it but no room-finish row answers for it \u2014 either a room the schedule omits, or a keynote/legend row; LOOK before pricing it` : "no room name drawn with it and no room-finish row answers for it \u2014 reads as a keynote, detail marker or dimension fragment rather than a room"
+      });
+    }
+  }
+  if (unmatched.length) {
+    notes.push(`${unmatched.length} numbered tag(s) on plan sheets are NOT counted as rooms \u2014 no name drawn with them and no schedule row answers for them; see unmatched_tags (they are listed, never dropped)`);
+  }
   const outSheets = withText.map((s) => {
     const role = roles.get(s.key);
     const schedules = [];
@@ -3168,7 +3347,7 @@ function buildSheetGraph(sheets) {
     if (b) entry.building = b;
     return entry;
   });
-  return { available: true, sheets: outSheets, rooms, tables, callouts, buildings: [...buildings].sort(), revisions, notes };
+  return { available: true, sheets: outSheets, rooms, unmatched_tags: unmatched, tables, callouts, buildings: [...buildings].sort(), revisions, notes };
 }
 var SURFACE_HEADERS = ["FLOOR", "BASE", "WALL", "WALLS", "NORTH", "SOUTH", "EAST", "WEST", "CEILING", "WAINSCOT"];
 var surfaceRank = (label) => SURFACE_HEADERS.indexOf(label.split(" ")[0]);
@@ -3177,7 +3356,9 @@ function resolveTag(graph, tag) {
   const q = t.match(QUALIFIED_KEY_RE);
   const wantB = q ? q[1] : null;
   const num2 = q ? q[2] : t;
-  const rooms = graph.rooms.filter((r2) => {
+  const asRoom = (u) => ({ tag: u.tag, name: u.name ?? "", sheet: u.sheet, bbox: u.bbox, ...u.building ? { building: u.building } : {} });
+  const candidates = [...graph.rooms, ...graph.unmatched_tags.map(asRoom)];
+  const rooms = candidates.filter((r2) => {
     const rt = norm(r2.tag).replace(/\s+/g, "");
     return rt === t || numOf(rt) === num2;
   });
@@ -7796,6 +7977,7 @@ var Session = class _Session {
       sheet: r.sheet,
       bbox: _Session.wireBox(r.bbox),
       ...r.building ? { building: r.building } : {},
+      ...r.corroboration ? { corroboration: r.corroboration } : {},
       ...r.revision ? { revision: { rev: r.revision.rev, source: _Session.wireEvidence(r.revision.source), ...r.revision.drawn ? { drawn: true } : {} } } : {}
     };
   }
@@ -7819,11 +8001,21 @@ var Session = class _Session {
         }))
       })),
       rooms: g.rooms.map(_Session.wireRoom),
+      ...g.unmatched_tags.length ? {
+        unmatched_tags: g.unmatched_tags.map((u) => ({
+          tag: u.tag,
+          sheet: u.sheet,
+          bbox: _Session.wireBox(u.bbox),
+          ...u.building ? { building: u.building } : {},
+          ...u.name ? { name: u.name } : {},
+          reason: u.reason
+        }))
+      } : {},
       callouts: g.callouts.map((c) => ({ detail: c.detail, target_sheet: c.target_sheet, sheet: c.sheet, bbox: _Session.wireBox(c.bbox) })),
       ...g.buildings.length ? { buildings: g.buildings } : {},
       ...g.revisions.length ? { revisions: g.revisions.map((r) => ({ rev: r.rev, sheet: r.sheet, bbox: _Session.wireBox(r.bbox), ...r.drawn ? { drawn: true } : {} })) } : {},
       ...g.notes.length ? { notes: g.notes } : {},
-      counts: { rooms: g.rooms.length, schedules: g.tables.length, callouts: g.callouts.length }
+      counts: { rooms: g.rooms.length, unmatched_tags: g.unmatched_tags.length, schedules: g.tables.length, callouts: g.callouts.length }
     };
   }
   /** The FLOOR finish a room's own schedule row states — assign-from-schedule's
@@ -8466,7 +8658,8 @@ var graphRoom = z.object({
   sheet: z.string(),
   bbox: wireBox,
   building: z.string().optional().describe("The building the room belongs to, when the set names one \u2014 its plan sheet's BUILDING/BLDG context, or the tag's own qualifier ('A-134')"),
-  revision: wireRevision.optional()
+  revision: wireRevision.optional(),
+  corroboration: z.string().optional().describe('Why this number is believed to be a room: "schedule" (a room-finish row answers for it), "name" (a name is drawn with it and the set has no room-finish schedule), or "name+schedule"')
 });
 var sheetGraphOutput = {
   available: z.boolean().describe("false = the set has no text layer (a scan) \u2014 the graph degrades to unavailable, never half-populates"),
@@ -8485,12 +8678,20 @@ var sheetGraphOutput = {
       rotated_headers: z.boolean().optional().describe("true when the column headers were read at a quarter-turn")
     }))
   })),
-  rooms: z.array(graphRoom).describe("Room tags read off plan-role sheets \u2014 schedule sheets contribute rows, never phantom rooms"),
+  rooms: z.array(graphRoom).describe("Numbers CORROBORATED as rooms \u2014 a room-finish row answers for them, or (where the set carries no room-finish schedule) a room name is drawn with them. Each says which in `corroboration`. Schedule sheets contribute rows, never phantom rooms"),
+  unmatched_tags: z.array(z.object({
+    tag: z.string(),
+    sheet: z.string(),
+    bbox: wireBox,
+    building: z.string().optional(),
+    name: z.string().optional().describe("Text drawn with the number, when there is any \u2014 on a keynote legend this is the accessory description, not a room name"),
+    reason: z.string().describe("WHY this number is not counted as a room. Read these: one of them may be a room the schedule left out, which is a hole in the bid")
+  })).optional().describe('Numbered tags on plan sheets that are NOT counted as rooms \u2014 keynote hexagons, detail markers, dimension fragments, legend rows. Listed with a reason, never dropped. A real finish plan is covered in 2\u20133 digit numbers that are not rooms; counting them as rooms makes every one come back "no schedule row", which reads exactly like the lost-bid case and buries it'),
   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"),
   buildings: z.array(z.string()).optional().describe("Every building designator the set names (sorted) \u2014 present only on multi-building-aware sets. Room numbers reused across these need qualified tags ('A-134')"),
   revisions: z.array(z.object({ rev: z.string(), sheet: z.string(), bbox: wireBox, drawn: z.boolean().optional() })).optional().describe("Every delta-triangle / REV-tag marker the set carries \u2014 text markers ('\u03942', 'REV 2') and DRAWN deltas (a bare digit inside a triangle of linework, drawn: true) \u2014 where one sits, the ink changed under that revision. Markers on a schedule row or room bubble also attach there (and ride resolve_tag). A revision CLOUD is arc-chain linework these detectors do not read \u2014 absence here is not absence of revisions"),
   notes: z.array(z.string()).optional().describe("Named gaps found while indexing (e.g. a continuation whose rows could not be aligned) \u2014 the graph refuses silently dropping anything"),
-  counts: z.object({ rooms: z.number().int(), schedules: z.number().int().describe("LOGICAL tables \u2014 a schedule continued across sheets counts once"), callouts: z.number().int() })
+  counts: z.object({ rooms: z.number().int(), unmatched_tags: z.number().int().optional(), schedules: z.number().int().describe("LOGICAL tables \u2014 a schedule continued across sheets counts once"), callouts: z.number().int() })
 };
 var resolveTagOutput = {
   status: z.enum(["resolved", "unresolved"]),
@@ -10627,7 +10828,7 @@ All-or-nothing, like derive_base: an unknown tag, a transition landing on either
     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 \u2014 a schedule CONTINUED across sheets ("\u2026 SCHEDULE \u2014 CONT'D") reads as ONE table, the continuation fragment naming its base in "continues"; rotated column headers are read at their quarter-turn and flagged), every room tag on the plan sheets (with the stacked room NAME when one exists, and the room's BUILDING on multi-building sets), the detail callouts (3/A-601 \u2192 sheet edges), the set's building designators, every REVISION marker the set carries (text markers "\u03942"/"REV 2" AND drawn deltas \u2014 a bare digit inside a triangle of linework, proven from vector geometry and flagged drawn \u2014 in "revisions", and attached to the schedule row / room tag they sit on), and named indexing gaps in "notes". 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}`,
+    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 \u2014 a schedule CONTINUED across sheets ("\u2026 SCHEDULE \u2014 CONT'D") reads as ONE table, the continuation fragment naming its base in "continues"; rotated column headers are read at their quarter-turn and flagged), every number CORROBORATED as a room (with the stacked room NAME when one exists, the room's BUILDING on multi-building sets, and "corroboration" saying why it counts as a room) plus "unmatched_tags" \u2014 the numbers that are NOT rooms (keynote hexagons, detail markers, dimension fragments, legend rows), each with a reason, listed and never dropped; READ those reasons, one of them may be a room the schedule left out, the detail callouts (3/A-601 \u2192 sheet edges), the set's building designators, every REVISION marker the set carries (text markers "\u03942"/"REV 2" AND drawn deltas \u2014 a bare digit inside a triangle of linework, proven from vector geometry and flagged drawn \u2014 in "revisions", and attached to the schedule row / room tag they sit on), and named indexing gaps in "notes". 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()));
@@ -10918,7 +11119,7 @@ function applyStagedTools(server, registered) {
 // package.json
 var package_default = {
   name: "opentakeoff-mcp",
-  version: "0.9.45",
+  version: "0.9.47",
   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.45",
+  "version": "0.9.47",
   "mcpName": "io.github.Kentucky-ai/opentakeoff",
   "type": "module",
   "description": "OpenTakeoff MCP server — drive the takeoff engine from your MCP client over stdio.",