opentakeoff-mcp 0.9.42 → 0.9.44

package/README.md

@@ -162,9 +162,9 @@ reads the tool list once. ([#230](https://github.com/Kentucky-ai/opentakeoff/iss
 | `delete_verdict` | Lift an agent verdict mark by id. Agent marks only — the estimator's seal is human ink and is refused, the same line `edit_shape` holds on reviewed shapes. `undo_last` re-seats a lifted mark exactly where it was. |
 | `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_graph` | The plan-set INDEX (#87): every sheet's role with evidence, the schedule tables found, every room tag with its stacked name, the detail callouts — how an agent decides WHAT to measure without a human enumerating rooms. |
-| `resolve_tag` | ONE room tag → its room-finish schedule row → each code's finish/material definition, every edge cited (sheet + literal text + bbox). Refusal over guessing: `unresolved` comes back with a reason, never as silence. |
-| `find_schedule` | Locate a schedule table by kind ("room finish", "material") — sheet, title, headers, row count, and a `view_sheet`-ready region. |
+| `sheet_graph` | The plan-set INDEX (#87): every sheet's role with evidence, the schedule tables found, every room tag with its stacked name, the detail callouts, and every revision marker (text `Δ2`/`REV 2` tags AND drawn deltas — a bare digit inside a triangle of linework, proven from the sheet's vector geometry — in `revisions`) — how an agent decides WHAT to measure without a human enumerating rooms. |
+| `resolve_tag` | ONE room tag → its room-finish schedule row → each code's finish/material definition, every edge cited (sheet + literal text + bbox). Refusal over guessing: `unresolved` comes back with a reason, never as silence. A delta/REV marker on the answering row rides the result as `revisions` — the codes are the post-revision answer, and you're told the ink changed. |
+| `find_schedule` | Locate a schedule table by kind ("room finish", "material") — sheet, title, headers, row count, a `view_sheet`-ready region, and `revised_rows` when delta/REV-marked rows exist. |
 | `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. |
 | `view_sheet` | The agent's eyes: render the sheet (or an image-px crop) to PNG. `overlay` burns committed shapes in (solid = human-affirmed, dashed = unreviewed) to verify geometry landed; `grid` burns in a calibrated 1-ft/5-ft measuring grid with foot labels (`"auto"` from the set scale, or the drawing scale like `"1/4"`) so dimensions are counted off cells, not guessed. |
 

package/dist/server-core.js

@@ -181,6 +181,12 @@ async function openPdf(filePath) {
         viewport: { width: vp.width, height: vp.height, transform: vp.transform },
         textContent,
         operatorList: async () => await page.getOperatorList(),
+        cleanup: () => {
+          try {
+            page.cleanup();
+          } catch {
+          }
+        },
         async renderPng(scale) {
           await ensureCanvasGlobals();
           const rvp = page.getViewport({ scale });
@@ -2580,6 +2586,79 @@ function sheetBuilding(sheet) {
   const [building, span] = [...seen.entries()][0];
   return { building, evidence: { sheet: sheet.key, text: span.str.trim(), bbox: bboxOf(span) } };
 }
+var DELTA_MARK_RE = /^[Δ∆△▲]\s*(\d{1,2}[A-Z]?)$|^(\d{1,2}[A-Z]?)\s*[Δ∆△▲]$/;
+var REV_MARK_RE = /^REV(?:ISION)?\.?\s*#?\s*(\d{1,2}[A-Z]?)$/;
+var revisionOf = (s) => {
+  const t = norm(s);
+  if (!t || t.length > 12) return null;
+  const d = t.match(DELTA_MARK_RE);
+  if (d) return d[1] ?? d[2];
+  const r = t.match(REV_MARK_RE);
+  return r ? r[1] : null;
+};
+var BARE_DIGIT_RE = /^\d{1,2}$/;
+function drawnDeltaMarkers(spans, segs) {
+  const cands = spans.filter((s) => BARE_DIGIT_RE.test((s.str || "").trim()));
+  if (!cands.length || !segs.length) return [];
+  const CELL = 64;
+  const grid = /* @__PURE__ */ new Map();
+  const nSeg = Math.floor(segs.length / 4);
+  for (let i = 0; i < nSeg; i++) {
+    const dx = segs[i * 4 + 2] - segs[i * 4], dy = segs[i * 4 + 3] - segs[i * 4 + 1];
+    const len = Math.hypot(dx, dy);
+    if (len < 4 || len > 400) continue;
+    const mx = (segs[i * 4] + segs[i * 4 + 2]) / 2, my = (segs[i * 4 + 1] + segs[i * 4 + 3]) / 2;
+    const k = `${Math.floor(mx / CELL)},${Math.floor(my / CELL)}`;
+    let cell = grid.get(k);
+    if (!cell) grid.set(k, cell = []);
+    cell.push(i);
+  }
+  const out = [];
+  for (const sp of cands) {
+    const h = Math.max(sp.h || 8, 6);
+    const cx = sp.x + (sp.w || 0) / 2, cy = sp.y + h / 2;
+    const R = h * 5;
+    const near = [];
+    for (let gx = Math.floor((cx - R) / CELL); gx <= Math.floor((cx + R) / CELL); gx++) {
+      for (let gy = Math.floor((cy - R) / CELL); gy <= Math.floor((cy + R) / CELL); gy++) {
+        for (const i of grid.get(`${gx},${gy}`) || []) {
+          const mx = (segs[i * 4] + segs[i * 4 + 2]) / 2, my = (segs[i * 4 + 1] + segs[i * 4 + 3]) / 2;
+          const len = Math.hypot(segs[i * 4 + 2] - segs[i * 4], segs[i * 4 + 3] - segs[i * 4 + 1]);
+          if (Math.hypot(mx - cx, my - cy) <= R && len >= h * 1.2 && len <= h * 8) near.push(i);
+        }
+      }
+    }
+    if (near.length < 3 || near.length > 60) continue;
+    const tol = Math.max(2, h * 0.35);
+    let best = null;
+    let bestArea = Infinity;
+    const P = (i, end) => [segs[i * 4 + end * 2], segs[i * 4 + 1 + end * 2]];
+    const close = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1]) <= tol;
+    for (let a = 0; a < near.length; a++) for (let b = a + 1; b < near.length; b++) for (let c = b + 1; c < near.length; c++) {
+      for (const fa of [0, 1]) for (const fb of [0, 1]) for (const fc of [0, 1]) {
+        const [a0, a1] = [P(near[a], fa), P(near[a], 1 - fa)];
+        const [b0, b1] = [P(near[b], fb), P(near[b], 1 - fb)];
+        const [c0, c1] = [P(near[c], fc), P(near[c], 1 - fc)];
+        if (!close(a1, b0) || !close(b1, c0) || !close(c1, a0)) continue;
+        const v = [a0, b0, c0];
+        const side = (p, q) => Math.hypot(p[0] - q[0], p[1] - q[1]);
+        const s01 = side(v[0], v[1]), s12 = side(v[1], v[2]), s20 = side(v[2], v[0]);
+        const mx = Math.max(s01, s12, s20), mn = Math.min(s01, s12, s20);
+        if (mn < h * 1.2 || mx > h * 8 || mx / mn > 2.5) continue;
+        const cross = (p, q) => (q[0] - p[0]) * (cy - p[1]) - (q[1] - p[1]) * (cx - p[0]);
+        const d0 = cross(v[0], v[1]), d1 = cross(v[1], v[2]), d2 = cross(v[2], v[0]);
+        if (!(d0 > 0 && d1 > 0 && d2 > 0 || d0 < 0 && d1 < 0 && d2 < 0)) continue;
+        const area = Math.abs((v[1][0] - v[0][0]) * (v[2][1] - v[0][1]) - (v[2][0] - v[0][0]) * (v[1][1] - v[0][1])) / 2;
+        if (area < bestArea) {
+          bestArea = area;
+          best = [Math.min(v[0][0], v[1][0], v[2][0]), Math.min(v[0][1], v[1][1], v[2][1]), Math.max(v[0][0], v[1][0], v[2][0]), Math.max(v[0][1], v[1][1], v[2][1])];
+        }
+      }
+    }
+    if (best) out.push({ span: sp, tri: best });
+  }
+  return out;
+}
 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 = [];
@@ -2612,7 +2691,7 @@ function findHeaderRow(rows, vocab, required, minHits) {
       const w = headerLabel(t.str, vocab);
       if (w && !seen.has(w)) {
         seen.add(w);
-        anchors.push({ label: w, x: t.x });
+        anchors.push({ label: w, x: t.x + (t.w || 0) / 2 });
       }
     }
     if (anchors.length < minHits || !required.some((r) => seen.has(r))) continue;
@@ -2675,6 +2754,80 @@ function rowKeyOf(raw, kind, buildings) {
   return null;
 }
 var numOf = (key) => key.match(QUALIFIED_KEY_RE)?.[2] ?? key;
+var centerX = (t) => t.x + (t.w || 0) / 2;
+function bandDataRows(rows, anchors, kind, sheetKey, buildings, cfg) {
+  const { x0, x1, medGap } = bandLimits(anchors);
+  const out = [];
+  const outY = [];
+  let region = null;
+  const add = (row, toks) => {
+    for (const t of toks) {
+      const label = nearestAnchor(centerX(t), anchors);
+      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)) };
+      region = region ? merge(region, bboxOf(t)) : bboxOf(t);
+    }
+  };
+  const orphans = [];
+  const markers = [];
+  for (let i = Math.max(cfg.fromIdx, 0); i < rows.length; i++) {
+    if (rowY(rows[i]) <= cfg.belowY) continue;
+    const banded = [];
+    for (const t of rows[i]) {
+      const tri = cfg.deltas?.get(t);
+      const rev = tri ? norm(t.str) : revisionOf(t.str);
+      if (rev != null) {
+        if (centerX(t) >= x0 - 2.5 * medGap && centerX(t) <= x1 + medGap) markers.push({ rev, span: t, ...tri ? { drawn: true, tri } : {} });
+        continue;
+      }
+      if (t.x >= x0 && t.x <= x1) banded.push(t);
+    }
+    if (!banded.length) continue;
+    const keyed = rowKeyOf(banded[0].str, kind, buildings);
+    if (!keyed) {
+      orphans.push({ toks: banded, y: rowY(rows[i]) });
+      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;
+    add(row, banded);
+    out.push(row);
+    outY.push(rowY(rows[i]));
+  }
+  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) => {
+    let bi = -1, bd = Infinity;
+    outY.forEach((ry, i) => {
+      const d = Math.abs(y - ry);
+      if (d < bd) {
+        bd = d;
+        bi = i;
+      }
+    });
+    return { i: bi, d: bd };
+  };
+  const radius = (h) => pitch ? pitch * 0.6 : Math.max(h, 8) * 1.6;
+  for (const o of orphans) {
+    const { i, d } = nearest(o.y);
+    if (i < 0 || d > radius(Math.max(...o.toks.map((t) => t.h || 8)))) continue;
+    add(out[i], o.toks);
+  }
+  for (const m of markers) {
+    const { i, d } = nearest(m.span.y);
+    if (i < 0 || d > radius(m.span.h || 8) || out[i].revision) continue;
+    const ebox = m.tri ? merge(bboxOf(m.span), m.tri) : bboxOf(m.span);
+    out[i].revision = { rev: m.rev, source: { sheet: sheetKey, text: m.span.str.trim(), bbox: ebox }, ...m.drawn ? { drawn: true } : {} };
+  }
+  for (const row of out) {
+    if (row.building) continue;
+    const cellB = norm(row.cells.BLDG?.text || row.cells.BUILDING?.text || "");
+    if (DESIGNATOR_RE.test(cellB)) row.building = cellB;
+  }
+  return { out, region };
+}
 function extractTable(sheet, kind, opts = {}) {
   const horiz = sheet.spans.filter((s) => !isVertical(s));
   const vert = sheet.spans.filter(isVertical);
@@ -2705,33 +2858,13 @@ function extractTable(sheet, kind, opts = {}) {
     titleFrom = rows.findIndex((r) => rowY(r) >= rot.top) - 1;
     if (titleFrom < -1) titleFrom = rows.length - 1;
   }
-  const out = [];
   let region = null;
   for (const t of headerSpans) region = region ? merge(region, bboxOf(t)) : bboxOf(t);
-  const { x0, x1 } = bandLimits(anchors);
-  for (let i = Math.max(dataFrom, 0); i < rows.length; i++) {
-    if (rotated && rowY(rows[i]) <= dataBelowY) continue;
-    const inBand = rows[i].filter((t) => t.x >= x0 && t.x <= x1);
-    if (!inBand.length) continue;
-    const keyed = rowKeyOf(inBand[0].str, kind, opts.buildings);
-    if (!keyed) 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);
-    }
-    const row = { key: keyed.key, sheet: sheet.key, cells };
-    const cellB = norm(cells.BLDG?.text || cells.BUILDING?.text || "");
-    const b = keyed.building ?? (DESIGNATOR_RE.test(cellB) ? cellB : void 0);
-    if (b) row.building = b;
-    out.push(row);
-  }
+  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;
   if (!out.length) return null;
+  const { x0, x1 } = bandLimits(anchors);
   let title = null;
   for (let i = titleFrom; i >= 0 && i >= titleFrom - 5 && !title; i--) {
     const hit = rows[i].find((t) => /SCHEDULE/.test(norm(t.str)) && t.x >= x0 && t.x <= x1);
@@ -2763,40 +2896,25 @@ function mergeContinuation(base, frag) {
   base.parts.push({ sheet: frag.sheet, title: frag.title?.text || "", rows: frag.rows.length, region: frag.region, ...frag.rotated_headers ? { rotated_headers: true } : {} });
   base.rows.push(...frag.rows);
 }
-function adoptContinuationRows(sheet, titleSpan, base, buildings) {
+function adoptContinuationRows(sheet, titleSpan, base, buildings, deltas) {
   if (!base.anchors?.length || base.kind === "unknown") return null;
   const rows = clusterRows(sheet.spans.filter((s) => !isVertical(s)));
-  const { x0, x1, medGap } = bandLimits(base.anchors);
+  const { medGap } = bandLimits(base.anchors);
   const keyTol = Math.max(40, medGap / 2);
-  const out = [];
-  let region = bboxOf(titleSpan);
-  for (const row of rows) {
-    if (rowY(row) <= titleSpan.y) continue;
-    const inBand = row.filter((t) => t.x >= x0 && t.x <= x1);
-    if (!inBand.length) continue;
-    const keyed = rowKeyOf(inBand[0].str, base.kind, buildings);
-    if (!keyed || Math.abs(inBand[0].x - base.anchors[0].x) > keyTol) continue;
-    const cells = {};
-    for (const t of inBand) {
-      const label = nearestAnchor(t.x, base.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 = merge(region, bboxOf(t));
-    }
-    const r = { key: keyed.key, sheet: sheet.key, cells };
-    if (keyed.building) r.building = keyed.building;
-    out.push(r);
-  }
-  if (!out.length) return null;
+  const banded = bandDataRows(rows, base.anchors, base.kind, sheet.key, buildings, {
+    fromIdx: 0,
+    belowY: titleSpan.y,
+    keyAlign: { x: base.anchors[0].x, tol: keyTol },
+    deltas
+  });
+  if (!banded.out.length) return null;
+  const region = banded.region ? merge(bboxOf(titleSpan), banded.region) : bboxOf(titleSpan);
   return {
     kind: base.kind,
     sheet: sheet.key,
     title: { sheet: sheet.key, text: titleSpan.str.trim(), bbox: bboxOf(titleSpan) },
     headers: base.headers,
-    rows: out,
+    rows: banded.out,
     region
   };
 }
@@ -2811,6 +2929,7 @@ function roomTags(sheet, opts = {}) {
     return { ok: false };
   };
   for (const sp of spans) {
+    if (opts.deltas?.has(sp)) continue;
     const t = sp.str.trim();
     const a = accept(t);
     if (!a.ok) continue;
@@ -2834,6 +2953,30 @@ function roomTags(sheet, opts = {}) {
     if (a.building) tag.building = a.building;
     out.push(tag);
   }
+  const markers = [];
+  for (const c of spans) {
+    const tri = opts.deltas?.get(c);
+    if (tri) markers.push({ rev: norm(c.str), span: c, box: merge(bboxOf(c), tri), drawn: true });
+    else {
+      const rev = revisionOf(c.str);
+      if (rev != null) markers.push({ rev, span: c, box: bboxOf(c) });
+    }
+  }
+  for (const tag of out) {
+    const hgt = Math.max(tag.bbox[3] - tag.bbox[1], 6);
+    let bestM = null;
+    let bd = Infinity;
+    for (const m of markers) {
+      const dx = Math.max(tag.bbox[0] - m.box[2], m.box[0] - tag.bbox[2], 0);
+      const dy = Math.max(tag.bbox[1] - m.box[3], m.box[1] - tag.bbox[3], 0);
+      const d = Math.hypot(dx, dy);
+      if (d <= hgt * 2.5 && d < bd) {
+        bd = d;
+        bestM = m;
+      }
+    }
+    if (bestM) tag.revision = { rev: bestM.rev, source: { sheet: sheet.key, text: bestM.span.str.trim(), bbox: bestM.box }, ...bestM.drawn ? { drawn: true } : {} };
+  }
   return out;
 }
 var CALLOUT_RE = /^(\d{1,2})\s*\/\s*([A-Z]{1,2}-?\d{1,3}(?:\.\d+)?)$/;
@@ -2847,8 +2990,23 @@ 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: [], notes: [] };
+  if (!withText.length) return { available: false, sheets: [], rooms: [], tables: [], callouts: [], buildings: [], revisions: [], notes: [] };
   const notes = [];
+  const deltasBySheet = /* @__PURE__ */ new Map();
+  const revisions = [];
+  for (const s of withText) {
+    const deltas = /* @__PURE__ */ new Map();
+    if (s.segs?.length) for (const d of drawnDeltaMarkers(s.spans, s.segs)) deltas.set(d.span, d.tri);
+    if (deltas.size) deltasBySheet.set(s.key, deltas);
+    for (const sp of s.spans) {
+      const tri = deltas.get(sp);
+      if (tri) revisions.push({ rev: norm(sp.str), sheet: s.key, bbox: merge(bboxOf(sp), tri), drawn: true });
+      else {
+        const rev = revisionOf(sp.str);
+        if (rev != null) revisions.push({ rev, sheet: s.key, bbox: bboxOf(sp) });
+      }
+    }
+  }
   const ctxBySheet = /* @__PURE__ */ new Map();
   const buildings = /* @__PURE__ */ new Set();
   for (const s of withText) {
@@ -2862,7 +3020,7 @@ function buildSheetGraph(sheets) {
   for (const s of withText) {
     roles.set(s.key, classifySheetRole(s));
     for (const kind of ["room-finish", "finish"]) {
-      const t = extractTable(s, kind, { buildings });
+      const t = extractTable(s, kind, { buildings, deltas: deltasBySheet.get(s.key) });
       if (!t) continue;
       const titleB = t.title ? buildingMentions(t.title.text) : [];
       const b = titleB.length === 1 ? titleB[0] : ctxBySheet.get(s.key);
@@ -2891,7 +3049,7 @@ function buildSheetGraph(sheets) {
       const fragBase = baseTitleOf(text);
       const base = [...tables].reverse().find((t) => t.kind !== "unknown" && t.title && baseTitleOf(t.title.text) === fragBase && t.sheet !== s.key && !t.parts?.some((p) => p.sheet === s.key));
       if (!base || fragmentKinds.get(s.key)?.has(base.kind)) continue;
-      const adopted = adoptContinuationRows(s, sp, base, buildings);
+      const adopted = adoptContinuationRows(s, sp, base, buildings, deltasBySheet.get(s.key));
       if (adopted) {
         if (adopted.building == null && ctxBySheet.get(s.key)) adopted.building = ctxBySheet.get(s.key);
         mergeContinuation(base, adopted);
@@ -2912,7 +3070,7 @@ function buildSheetGraph(sheets) {
     const role = roles.get(s.key);
     if (role.role === "plan" || role.role === "unknown" || role.role === "demolition") {
       const ctxB = ctxBySheet.get(s.key);
-      for (const r of roomTags(s, { buildings, exclude: sheetNumbers })) {
+      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);
       }
@@ -2942,7 +3100,7 @@ function buildSheetGraph(sheets) {
     if (b) entry.building = b;
     return entry;
   });
-  return { available: true, sheets: outSheets, rooms, tables, callouts, buildings: [...buildings].sort(), notes };
+  return { available: true, sheets: outSheets, rooms, tables, callouts, buildings: [...buildings].sort(), revisions, notes };
 }
 var SURFACE_HEADERS = ["FLOOR", "BASE", "WALL", "WALLS", "NORTH", "SOUTH", "EAST", "WEST", "CEILING", "WAINSCOT"];
 function resolveTag(graph, tag) {
@@ -3030,7 +3188,10 @@ function resolveTag(graph, tag) {
     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, ...chosen.building ? { building: chosen.building } : {}, finishes, sources };
+  const revs = [];
+  if (r.revision) revs.push(r.revision);
+  if (room?.revision && !revs.some((v) => v.rev === room.revision.rev)) revs.push(room.revision);
+  return { status: "resolved", tag: t, room, ...chosen.building ? { building: chosen.building } : {}, finishes, sources, ...revs.length ? { revisions: revs } : {} };
 }
 
 // src/format.ts
@@ -3370,7 +3531,7 @@ function buildRasterMask(rgba, mw, mh, ws = 1, opts = {}) {
 var SWEEP_TOL_PX = 2;
 var SWEEP_SCORE_HIGH = 0.92;
 var SWEEP_SCORE_LOW = 0.75;
-var SWEEP_MAX_CANDIDATES = 2e4;
+var SWEEP_CANDIDATE_CEILING = 25e4;
 var ANCHOR_COUNT = 3;
 var MIN_SEG_LEN = 0.5;
 var MAX_SEED_SEGS = 2e3;
@@ -3510,7 +3671,7 @@ function matchSymbol(fp, segs, opts = {}) {
   const tol = (opts.tolPx ?? SWEEP_TOL_PX) * Math.max(1, scale);
   const scoreHigh = opts.scoreHigh ?? SWEEP_SCORE_HIGH;
   const scoreLow = opts.scoreLow ?? SWEEP_SCORE_LOW;
-  const maxCandidates = opts.maxCandidates ?? SWEEP_MAX_CANDIDATES;
+  const maxCandidates = opts.maxCandidates ?? SWEEP_CANDIDATE_CEILING;
   const xforms = transformsFor(opts.rotations ?? true, opts.mirror ?? true);
   const n = segs.length >> 2;
   if (scale !== 1 && opts.excludeCenter) {
@@ -3642,6 +3803,7 @@ function matchSymbol(fp, segs, opts = {}) {
     matches,
     withheld,
     candidates: { considered, dropped },
+    complete: dropped === 0,
     ...scale === 1 ? {} : {
       scaled: {
         ratio: Math.round(scale * 1e6) / 1e6,
@@ -6282,6 +6444,7 @@ var Session = class _Session {
         withheld: res.withheld.map((w) => ({ at: [round1(w.at[0]), round1(w.at[1])], score: w.score, rotation: w.rotation, mirrored: w.mirrored, reason: w.reason })),
         seed: seedOut,
         candidates: res.candidates,
+        complete: res.complete,
         ...committed2 ? {
           committed: committed2.committed,
           shape_ids: committed2.shape_ids,
@@ -6289,7 +6452,7 @@ var Session = class _Session {
           ea_total: committed2.ea_total
         } : {},
         ...opts.commit && !res.matches.length ? { note: "commit requested but nothing cleared the bar \u2014 no shapes were committed." } : {},
-        ...res.candidates.dropped > 0 ? { warning: `Work cap: ${res.candidates.dropped} candidate placement(s) were never scored \u2014 the seed's linework is too common on this sheet for an exhaustive sweep. Tighten the seed rect around more distinctive geometry, or sweep a region at a time and reconcile the counts.` } : {}
+        ...res.candidates.dropped > 0 ? { warning: `Work ceiling: ${res.candidates.dropped} candidate placement(s) were never scored \u2014 this count is a FLOOR, not a total. The seed's linework is too common on this sheet for an exhaustive sweep; tighten the seed rect around more distinctive geometry, or sweep a region at a time and reconcile the counts.` } : {}
       };
     }
     const graph = await this.ensureGraph();
@@ -6381,14 +6544,16 @@ var Session = class _Session {
         matches: p.matches.map((m) => ({ at: [round1(m.at[0]), round1(m.at[1])], score: m.score, rotation: m.rotation, mirrored: m.mirrored })),
         withheld: p.withheld.map((w) => ({ at: [round1(w.at[0]), round1(w.at[1])], score: w.score, rotation: w.rotation, mirrored: w.mirrored, reason: w.reason })),
         candidates: p.candidates,
+        complete: p.complete,
         elapsed_ms: p.elapsed_ms,
         ...p.scaled ? { scaled: p.scaled } : {},
         ...p.scale.known ? {} : { scale_assumed: "no scale set on the seed sheet or this one \u2014 swept at 1:1" }
       })),
+      complete: perSheet.every((p) => p.complete),
       skipped,
       ...committed ?? {},
       ...notes.length ? { note: notes.join(" ") } : {},
-      ...capped.length ? { warning: `Work cap: candidate placements were dropped un-scored on ${capped.map((p) => p.state.key).join(", ")} \u2014 the seed's linework is too common there for an exhaustive sweep. Tighten the seed rect around more distinctive geometry, or sweep those sheets singly and reconcile the counts.` } : {}
+      ...capped.length ? { warning: `Work ceiling: candidate placements were dropped un-scored on ${capped.map((p) => p.state.key).join(", ")} \u2014 counts there are FLOORS, not totals. The seed's linework is too common there for an exhaustive sweep; tighten the seed rect around more distinctive geometry, or sweep those sheets singly and reconcile the counts.` } : {}
     };
   }
   /** sweep_schedule_row (phase 2) — the estimator's story, honored: a
@@ -6567,7 +6732,7 @@ var Session = class _Session {
       excluded.sort(byPos);
       withheld.sort(byPos);
       const text_only = occ.filter((o, k) => !matchedOcc.has(k) && !res.withheld.some((w) => Math.hypot(w.at[0] - o.cx, w.at[1] - o.cy) <= R)).map((o) => ({ at: [round1(o.cx), round1(o.cy)] }));
-      perSheet.push({ state: sh, matches, withheld, excluded, text_only, candidates: res.candidates, elapsed_ms, scale: ratio, ...res.scaled ? { scaled: res.scaled } : {} });
+      perSheet.push({ state: sh, matches, withheld, excluded, text_only, candidates: res.candidates, complete: res.complete, elapsed_ms, scale: ratio, ...res.scaled ? { scaled: res.scaled } : {} });
     }
     const found = perSheet.reduce((n, p) => n + p.matches.length, 0);
     let committed;
@@ -6636,10 +6801,12 @@ var Session = class _Session {
         excluded: p.excluded.map((e) => ({ at: [round1(e.at[0]), round1(e.at[1])], tag: e.tag })),
         text_only: p.text_only,
         candidates: p.candidates,
+        complete: p.complete,
         elapsed_ms: p.elapsed_ms,
         ...p.scaled ? { scaled: p.scaled } : {},
         ...p.scale.known ? {} : { scale_assumed: `no scale set on ${anchorSheet.key} or this sheet \u2014 swept at 1:1` }
       })),
+      complete: perSheet.every((p) => p.complete),
       skipped,
       ...committed ?? {},
       ...notes.length ? { note: notes.join(" ") } : {},
@@ -7518,15 +7685,31 @@ var Session = class _Session {
     if (!this.docs.size) throw new UserError("No plan loaded \u2014 call load_plan first.");
     if (!this.graph) {
       const inputs = [];
+      let vecBudget = 3e7;
+      let skippedHeavy = 0;
       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, ...t.rot ? { rot: t.rot } : {} }))
-        });
+        const spans = s.spans.map((t) => ({ str: t.str, x: t.x0, y: t.y0, w: t.x1 - t.x0, h: t.y1 - t.y0, ...t.rot ? { rot: t.rot } : {} }));
+        let segs;
+        if (spans.some((t) => /^\d{1,2}$/.test(t.str.trim()))) {
+          const role = classifySheetRole({ key: s.key, sheet_number: s.sheetNumber, spans }).role;
+          if (role === "plan" || role === "schedule" || role === "demolition" || role === "unknown") {
+            if (vecBudget <= 0) skippedHeavy++;
+            else if (s.geo) {
+              segs = s.geo.segs;
+              vecBudget -= segs.length / 4;
+            } else {
+              const opList = await s.page.operatorList();
+              segs = extractVectorGeometry(opList, s.page.viewport.transform, OPS2).segs;
+              vecBudget -= segs.length / 4;
+              s.page.cleanup();
+            }
+          }
+        }
+        inputs.push({ key: s.key, sheet_number: s.sheetNumber, spans, ...segs?.length ? { segs } : {} });
       }
       this.graph = buildSheetGraph(inputs);
+      if (skippedHeavy) this.graph.notes.push(`drawn-delta hunt skipped on ${skippedHeavy} sheet(s) \u2014 the set's linework exceeded the vector budget; text revision markers (\u03942 / REV 2) were still read everywhere`);
     }
     return this.graph;
   }
@@ -7536,6 +7719,16 @@ var Session = class _Session {
   static wireEvidence(e) {
     return { sheet: e.sheet, text: e.text, bbox: _Session.wireBox(e.bbox) };
   }
+  static wireRoom(r) {
+    return {
+      tag: r.tag,
+      name: r.name,
+      sheet: r.sheet,
+      bbox: _Session.wireBox(r.bbox),
+      ...r.building ? { building: r.building } : {},
+      ...r.revision ? { revision: { rev: r.revision.rev, source: _Session.wireEvidence(r.revision.source), ...r.revision.drawn ? { drawn: true } : {} } } : {}
+    };
+  }
   async sheetGraph() {
     const g = await this.ensureGraph();
     return {
@@ -7555,9 +7748,10 @@ var Session = class _Session {
           ...t.rotated_headers ? { rotated_headers: true } : {}
         }))
       })),
-      rooms: g.rooms.map((r) => ({ tag: r.tag, name: r.name, sheet: r.sheet, bbox: _Session.wireBox(r.bbox), ...r.building ? { building: r.building } : {} })),
+      rooms: g.rooms.map(_Session.wireRoom),
       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 }
     };
@@ -7585,7 +7779,7 @@ var Session = class _Session {
     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), ...res.room.building ? { building: res.room.building } : {} } : null;
+    const room = res.room ? _Session.wireRoom(res.room) : null;
     if (res.status === "unresolved") {
       return {
         status: "unresolved",
@@ -7606,7 +7800,8 @@ var Session = class _Session {
         source: _Session.wireEvidence(f.source),
         ...f.definition ? { definition: { cells: f.definition.cells, source: _Session.wireEvidence(f.definition.source) } } : {}
       })),
-      sources: res.sources.map(_Session.wireEvidence)
+      sources: res.sources.map(_Session.wireEvidence),
+      ...res.revisions?.length ? { revisions: res.revisions.map((v) => ({ rev: v.rev, source: _Session.wireEvidence(v.source), ...v.drawn ? { drawn: true } : {} })) } : {}
     };
   }
   async findSchedule(kind) {
@@ -7629,6 +7824,7 @@ var Session = class _Session {
         region: _Session.wireBox(t.region),
         ...t.building ? { building: t.building } : {},
         ...t.rotated_headers ? { rotated_headers: true } : {},
+        ...t.rows.some((r) => r.revision) ? { revised_rows: t.rows.filter((r) => r.revision).length } : {},
         ...t.parts ? { parts: t.parts.map((p) => ({ sheet: p.sheet, title: p.title, rows: p.rows, region: _Session.wireBox(p.region) })) } : {}
       }))
     };
@@ -7838,7 +8034,8 @@ var sweepSheetBlock = z.object({
   found: z.number().int(),
   matches: z.array(z.object(sweepPlacement)),
   withheld: z.array(z.object({ ...sweepPlacement, reason: z.string() })),
-  candidates: sweepCandidates.describe("The work cap applies PER SHEET; dropped > 0 here names exactly where the count is incomplete"),
+  candidates: sweepCandidates.describe("The work ceiling applies PER SHEET; dropped > 0 here names exactly where the count is incomplete"),
+  complete: z.boolean().describe("True when every proposed placement on this sheet was scored \u2014 false means this sheet's count is a FLOOR, not a total (#261)"),
   elapsed_ms: z.number().describe("Wall-clock for this sheet's sweep"),
   scaled: sweepScaled.optional(),
   scale_assumed: sweepScaleAssumed.optional()
@@ -7862,6 +8059,7 @@ var symbolSweepOutput = {
     length_px: z.number().describe("Total seed linework length, image px")
   }),
   candidates: sweepCandidates.optional().describe("Sheet scope only \u2014 set scope accounts per sheet in sheets[]"),
+  complete: z.boolean().describe("True when every proposed placement was scored (every swept sheet, in set scope) and the count is a total. FALSE MEANS THE COUNT IS A FLOOR \u2014 acknowledge it before trusting found (#261)"),
   sheets: z.array(sweepSheetBlock).optional().describe("Set scope only: one entry per swept PLAN-role sheet, load order"),
   skipped: sweepSkipped.optional().describe("Set scope only: every sheet excluded from counting, with role and reason \u2014 including the seed's own sheet when it is not a plan"),
   committed: z.number().int().optional().describe("commit mode: count shapes committed \u2014 one per match"),
@@ -8187,12 +8385,18 @@ var readSheetTextOutput = {
 };
 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 wireRevision = z.object({
+  rev: z.string(),
+  source: wireEvidence,
+  drawn: z.boolean().optional().describe("true = a DRAWN delta: a bare digit inside a triangle of linework (the common CAD convention \u2014 the text layer carries only the digit; the geometry proved the triangle). The evidence bbox spans digit and triangle")
+}).describe("A revision marker (delta triangle / 'REV 2' tag) attached to this item: the ink CHANGED under that revision. The value read is the post-revision answer \u2014 view_sheet the marker's bbox and check the addendum before pricing");
 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,
-  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')")
+  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()
 });
 var sheetGraphOutput = {
   available: z.boolean().describe("false = the set has no text layer (a scan) \u2014 the graph degrades to unavailable, never half-populates"),
@@ -8214,6 +8418,7 @@ var sheetGraphOutput = {
   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"),
   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() })
 };
@@ -8229,6 +8434,7 @@ var resolveTagOutput = {
     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 (the row cites the sheet that CARRIES it \u2014 under a continuation that is the CONT'D sheet)"),
+  revisions: z.array(wireRevision).optional().describe("resolved only \u2014 delta/REV markers on the answering schedule row or the plan bubble. The finishes above are the POST-revision answer, but the ink changed: check the marker (view_sheet its bbox) and the addendum before pricing"),
   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"),
   candidates: z.array(z.object({
     key: z.string(),
@@ -8247,6 +8453,7 @@ var findScheduleOutput = {
     region: wireBox.describe("Pass to view_sheet to look at the table (the BASE fragment's region when the table continues)"),
     building: z.string().optional().describe("The building this table answers for, when its title or sheet names one"),
     rotated_headers: z.boolean().optional().describe("true when the column headers were read at a quarter-turn"),
+    revised_rows: z.number().int().optional().describe("Rows carrying a delta/REV marker \u2014 the ink changed there; resolve those tags to see which"),
     parts: z.array(z.object({ sheet: z.string(), title: z.string(), rows: z.number().int(), region: wireBox })).optional().describe("Present when the table CONTINUES across sheets ('\u2026 SCHEDULE \u2014 CONT'D'): every fragment, base first, each with its own viewable region")
   }))
 };
@@ -8283,10 +8490,12 @@ var sweepScheduleRowOutput = {
     excluded: z.array(z.object({ at: z.tuple([z.number(), z.number()]), tag: z.string() })).describe("Markers matching the geometry but labeled with a SIBLING row's tag \u2014 the bubble shape is shared across marks, so these belong to that row, not this one"),
     text_only: z.array(z.object({ at: z.tuple([z.number(), z.number()]) })).describe("The tag drawn with NO matching marker geometry nearby \u2014 a note reference or a variant marker; a question, never a count"),
     candidates: z.object({ considered: z.number().int(), dropped: z.number().int() }),
+    complete: z.boolean().describe("True when every proposed placement on this sheet was scored \u2014 false means this sheet's count is a FLOOR, not a total (#261)"),
     elapsed_ms: z.number().describe("Wall-clock for this sheet's sweep"),
     scaled: sweepScaled.optional(),
     scale_assumed: sweepScaleAssumed.optional()
   })).describe("One entry per swept PLAN-role sheet, load order"),
+  complete: z.boolean().describe("True when every proposed placement was scored on every swept sheet \u2014 false means at least one sheet's count is a FLOOR, not a total (#261)"),
   skipped: z.array(z.object({ sheet: z.string(), role: z.string(), reason: z.string() })).describe("Sheets excluded from counting (schedule/detail/legend/unknown), each with its reason"),
   committed: z.number().int().optional().describe("commit mode: count shapes committed \u2014 one per counted match, the whole sweep ONE undo step"),
   shape_ids: z.array(z.string()).optional(),
@@ -10117,7 +10326,7 @@ function registerTools(realServer, session) {
     outputSchema: placeCountOutput
   }, run("place_count", (a) => session.placeCount(a.sheet, a.points, { condition: a.condition })));
   server.registerTool("symbol_sweep", {
-    description: `Find EVERY instance of a repeated plan symbol from ONE example \u2014 drains, thresholds, fixtures, transition markers: marquee a tight seed_rect around a single instance and the vector linework is searched for every other placement of that same segment cluster. Deterministic geometry, not vision: each placement scores as the length-weighted fraction of the seed's segments reproduced within tolerance_px, under translation plus 0/90/180/270 rotation and mirroring (symbols rotate on plans \u2014 both ON by default; turn them off to pin orientation). Score \u2265 0.92 is a match; the 0.75\u20130.92 band comes back in \`withheld\` with a reason \u2014 a near-match is a question you answer by LOOKING (view_sheet at its \`at\`), never a silent commit and never a silent drop. The seed's own location is reported in \`seed\` and never double-committed. Work is capped and the cap is disclosed: a reply with candidates.dropped > 0 says exactly that some placements were never scored \u2014 tighten the seed rect around more distinctive geometry rather than trusting a truncated count. Marquee discipline: the rect must hug ONE instance \u2014 only segments FULLY inside it define the symbol, so a loose rect that swallows wall linework fingerprints the wall, not the symbol. scope "set" sweeps the WHOLE working set, counting on PLAN-role sheets only (the sheet graph decides): a symbol drawn in a detail, legend, or schedule is a reference drawing and never counts itself \u2014 which is also how you seed from one: marquee the assembly on the detail sheet and its plan-sheet occurrences are counted while the detail stays excluded (the exclusion disclosed in \`skipped\`, per-sheet results with per-sheet caps and wall-clock in \`sheets\`). Scale across sheets: the fingerprint is size-true and is never scale-SEARCHED, so a detail drawn at 1-1/2" = 1'-0" is 12\xD7 the size of the same mark on a 1/8" plan \u2014 when BOTH sheets have a scale set, the exact ratio is computed from them and the seed is resized before matching (reported per sheet as \`scaled\`); when a scale is missing, the sweep runs at 1:1 and SAYS so (\`scale_assumed\`), because an unknown ratio plus a zero count is not evidence of absence. Seeding from a detail/legend/schedule sheet REFUSES outright until both scales are set \u2014 that is the case where an unstated ratio silently finds nothing. commit: true (requires condition) commits every match center as an EA count marker through the same path as place_count \u2014 the whole sweep (set-wide included) is ONE undo step, each marker carries origin.method "symbol_sweep" with its score, transform, and seed source, and withheld placements are NEVER committed. The COUNT is scale-free (EA), but matching across sheets of different scales is not \u2014 set_scale on the sheets involved is what turns the ratio from an assumption into arithmetic. After any batch commit, LOOK at what landed \u2014 view_sheet {overlay: true} over the swept area \u2014 and audit the markers against the drawing before trusting the EA total. ${COORDS}`,
+    description: `Find EVERY instance of a repeated plan symbol from ONE example \u2014 drains, thresholds, fixtures, transition markers: marquee a tight seed_rect around a single instance and the vector linework is searched for every other placement of that same segment cluster. Deterministic geometry, not vision: each placement scores as the length-weighted fraction of the seed's segments reproduced within tolerance_px, under translation plus 0/90/180/270 rotation and mirroring (symbols rotate on plans \u2014 both ON by default; turn them off to pin orientation). Score \u2265 0.92 is a match; the 0.75\u20130.92 band comes back in \`withheld\` with a reason \u2014 a near-match is a question you answer by LOOKING (view_sheet at its \`at\`), never a silent commit and never a silent drop. The seed's own location is reported in \`seed\` and never double-committed. Every proposed placement is scored up to a hard work ceiling sized for pathological sheets, and the reply says which it was: complete true means the count is a total; complete false (with candidates.dropped > 0) means the count is a FLOOR \u2014 some placements were never scored \u2014 so tighten the seed rect around more distinctive geometry rather than trusting it as a total. Marquee discipline: the rect must hug ONE instance \u2014 only segments FULLY inside it define the symbol, so a loose rect that swallows wall linework fingerprints the wall, not the symbol. scope "set" sweeps the WHOLE working set, counting on PLAN-role sheets only (the sheet graph decides): a symbol drawn in a detail, legend, or schedule is a reference drawing and never counts itself \u2014 which is also how you seed from one: marquee the assembly on the detail sheet and its plan-sheet occurrences are counted while the detail stays excluded (the exclusion disclosed in \`skipped\`, per-sheet results with per-sheet caps and wall-clock in \`sheets\`). Scale across sheets: the fingerprint is size-true and is never scale-SEARCHED, so a detail drawn at 1-1/2" = 1'-0" is 12\xD7 the size of the same mark on a 1/8" plan \u2014 when BOTH sheets have a scale set, the exact ratio is computed from them and the seed is resized before matching (reported per sheet as \`scaled\`); when a scale is missing, the sweep runs at 1:1 and SAYS so (\`scale_assumed\`), because an unknown ratio plus a zero count is not evidence of absence. Seeding from a detail/legend/schedule sheet REFUSES outright until both scales are set \u2014 that is the case where an unstated ratio silently finds nothing. commit: true (requires condition) commits every match center as an EA count marker through the same path as place_count \u2014 the whole sweep (set-wide included) is ONE undo step, each marker carries origin.method "symbol_sweep" with its score, transform, and seed source, and withheld placements are NEVER committed. The COUNT is scale-free (EA), but matching across sheets of different scales is not \u2014 set_scale on the sheets involved is what turns the ratio from an assumption into arithmetic. After any batch commit, LOOK at what landed \u2014 view_sheet {overlay: true} over the swept area \u2014 and audit the markers against the drawing before trusting the EA total. ${COORDS}`,
     inputSchema: {
       sheet: z2.string().describe("The sheet the seed rect sits on \u2014 in scope 'set' it may be ANY sheet (a detail/legend seed sheet is fingerprint source only, never counted)"),
       seed_rect: z2.tuple([pointSchema, pointSchema]).describe("Marquee around ONE example instance, [[x0,y0],[x1,y1]] in image px \u2014 tight: segments fully inside define the symbol"),
@@ -10348,17 +10557,17 @@ 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, 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 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}`,
     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). Rows carried by a continuation sheet ("\u2026 SCHEDULE \u2014 CONT'D") resolve exactly like base-sheet rows, citing the sheet the ink is on. 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 return "ambiguous" rather than picking one \u2014 on a multi-building set the refusal LISTS the candidate rows per building, and a building-qualified tag ("A-134") picks the building the set names. ${COORDS}`,
+    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). Rows carried by a continuation sheet ("\u2026 SCHEDULE \u2014 CONT'D") resolve exactly like base-sheet rows, citing the sheet the ink is on. 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 return "ambiguous" rather than picking one \u2014 on a multi-building set the refusal LISTS the candidate rows per building, and a building-qualified tag ("A-134") picks the building the set names. A delta triangle or REV tag on the answering row (or the plan bubble) rides the result as "revisions": the codes returned are the POST-revision answer, but the ink changed under that delta \u2014 view_sheet the marker's bbox and check the addendum before pricing. ${COORDS}`,
     inputSchema: { tag: z2.string().describe('The room tag as drawn, e.g. "134" or "139A" \u2014 or building-qualified on a multi-building set, e.g. "A-134" (building A, room 134)') },
     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, TOTAL row count, and REGION \u2014 sized for a view_sheet look or a read_sheet_text pull of exactly the table. A schedule continued across sheets is ONE match whose "parts" list every fragment (base first) with its own viewable region; tables read through rotated headers say so; a table answering for one building carries "building". Errors with what WAS found when the asked-for kind isn't in the set. ${COORDS}`,
+    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, TOTAL row count, and REGION \u2014 sized for a view_sheet look or a read_sheet_text pull of exactly the table. A schedule continued across sheets is ONE match whose "parts" list every fragment (base first) with its own viewable region; tables read through rotated headers say so; a table answering for one building carries "building"; a table with delta/REV-marked rows says how many in "revised_rows". 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)));
@@ -10639,7 +10848,7 @@ function applyStagedTools(server, registered) {
 // package.json
 var package_default = {
   name: "opentakeoff-mcp",
-  version: "0.9.42",
+  version: "0.9.44",
   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.42",
+  "version": "0.9.44",
   "mcpName": "io.github.Kentucky-ai/opentakeoff",
   "type": "module",
   "description": "OpenTakeoff MCP server — drive the takeoff engine from your MCP client over stdio.",