opentakeoff-mcp 0.9.43 → 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
@@ -7524,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;
   }
@@ -7542,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 {
@@ -7561,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 }
     };
@@ -7591,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",
@@ -7612,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) {
@@ -7635,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) })) } : {}
       }))
     };
@@ -8195,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"),
@@ -8222,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() })
 };
@@ -8237,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(),
@@ -8255,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")
   }))
 };
@@ -10358,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)));
@@ -10649,7 +10848,7 @@ function applyStagedTools(server, registered) {
 // package.json
 var package_default = {
   name: "opentakeoff-mcp",
-  version: "0.9.43",
+  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.43",
+  "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.",