opentakeoff-mcp 0.9.35 → 0.9.38

package/README.md

@@ -111,6 +111,7 @@ includes document text, shape vertices, or result payload content.
 | `one_click` | One-Click Area at (x, y): the sealed flood engine bounded by the plan linework, traced, vertices snapped — the SAME feet-true arguments the canvas passes at a click (gap sealing up to a door width, door-swing wedge inclusion, the half-foot minimum-passage rule), so an MCP trace and a canvas click at one seed measure the same square footage (pinned against the bench corpus goldens in `test/parity.test.ts`). Every trace carries the engine's account of itself: `confidence` 0–1 with `confidence_factors` naming each deduction (`gap_sealed_px`, `door_wedges`, `min_pass_delta`, …) — a review prioritizer, never a verification; a low score is a `view_sheet {overlay: true}` audit prompt, not a fact. On a SCANNED sheet (no usable linework) the flood falls back automatically to the rendered pixels — same engine as the canvas — with `raster_traced` disclosed on the reply and on the shape's origin (#154). Pass `condition` to commit (the full account stamps `origin` centrally at the commit); `role: "deduct"` subtracts. |
 | `detect_rooms` | Batch One-Click: reads every room-number label off the sheet's text layer and floods each — one call instead of `read_sheet_text` + reasoning + N `one_click` calls, through the SAME sealed engine per room (confidence + the engine account ride each room and its committed origin). Only cleanly-traced rooms come back; everything skipped is counted and reasoned in `withheld` (degenerate / duplicate / implausible / unresolved), never dropped silently. To commit: `assign_from_schedule: true` routes each room through its OWN room-finish schedule row and commits under the FLOOR finish that row states (rooms the schedule can't answer for return in `unresolved[]` with reasons and re-seedable coordinates); or pass `condition` to commit every room under one stated tag. |
 | `measure_polygon` | Area + perimeter of a polygon you supply (min 3 verts). Requires scale. |
+| `cut_out` | **A real hole in a committed floor shape** (#206), reconciled the way the canvas cuts one (#137) — the same `lib/cutout.js` boolean subtract, one module, so a headless session and the app can never disagree about what a hole holds. The parent keeps its outer ring + `verts_norm_holes`, its `computed` nets for real (N cuts compose, overlap never double-deducts, a hole ADDS perimeter), and the deduct carries `cuts_shape_id` so report/legend read the reconciled number. Refuses a ring not FULLY inside the parent (the canvas's edge-clip is a canvas affordance; over the wire it's refusal-over-guessing) and a cut that would erase or split the parent. One undo step restores parent and hole together; `delete_shape` on the deduct reverts the cut too (multi-cut parents rebuild from the chain's pristine snapshot minus survivors — the canvas's own delete semantics, ported as the spec). |
 | `measure_line` | Length of an open polyline (min 2 points). Requires scale. |
 | `derive_base` | **Base LF from committed rooms**: for every floor shape of a source condition, commits a linear base run tracing that room's boundary, quantified net of the door openings YOU state per room (`{shape_id, lf}` — your claim, recorded on `origin.derived`; the tool never guesses). All-or-nothing; one undo step. |
 | `derive_transitions` | **The transition where two finishes meet**: pass two finish tags and the tag to commit under, and every committed room of each is compared against every room of the other. The catch this is built around — flood-traced rooms **do not share edges**, a partition puts 4–8″ between them — so proximity comes in two flavours and they are never conflated. A **butt joint** (rings running together inside one open space, within an inch) *is* the transition and commits as a linear shape, `origin.derived` naming both parents, the tags, and the measured gap. A **wall-separated** run means the rooms are adjacent across a partition, where the transition is a threshold in a doorway that nothing in the trace record locates (the flood engine reports how *much* boundary it sealed, never where) — those return in `withheld` with length, gap in inches, and an `at` point to `view_sheet`, as questions rather than a confident wrong number. `max_gap_in` (default 12) only ever turns more of the plan into questions, never into committed LF. All-or-nothing; one undo step. |
@@ -124,8 +125,11 @@ includes document text, shape vertices, or result payload content.
 | `edit_shape` | **Revise** a committed shape instead of redoing it: new `verts`, a different `condition`, a different `role`, a `label` (the room it belongs to — what per-room reporting groups by; `""` clears it), or any combination — quantities recomputed from the result. Refuses shapes a human affirmed. |
 | `edit_materials` | Add/remove/patch supporting-materials rows on a condition — the coverage-rate lines (adhesive at N sf/gal, grout at N lf/bag, …) that turn a measured quantity into an order quantity, matching the canvas's Supporting Materials panel. `basis` is `area` \| `linear` \| `count` \| **`seam_lf`** — the last is the *figured* roll-layout seam length a weld rod or seam tape is bought by (set `roll_setup` on the condition first; without one it reads 0, because nothing has decided how that floor gets cut). `condition` mints on first touch, like `one_click`/`measure_polygon`. No review gate (materials rows are quantity config, not traced geometry) — edits directly, reversible with `undo_last`. |
 | `edit_condition` | Set a condition's **waste %**, **×N multiplier**, **height_ft** (the H knob `measure_surface` quantifies against), and **roll_setup** (the roll-goods opt-in: seams figured, cuts packed, the reply echoes the order — cuts, `order_lf`, rolls, `order_qty` — and `export_report`'s `roll_goods` block carries the same rows; `null` opts out) — the knobs that turn measured quantities into order quantities. Resolves an **existing** finish tag or errors — a typo must not mint an empty condition. No review gate; one `undo_last` step restores the knobs verbatim. |
+| `duplicate_condition` | **Twin a condition** — the same finish measured somewhere else, with its own supporting materials. One finish in two areas is neither two conditions nor one: the same sheet goods over a slab and over a raised deck take the same field material and different preparation underneath. The twin arrives carrying the original's whole materials list and keeps **following** it — fix a coverage rate on the original and every twin that hasn't touched that row gets it; edit a row on the twin and only THAT row stops following. `label` is required and becomes the tag suffix (`CPT-1` + `Level 2` → `CPT-1 – Level 2`). Reversible with `undo_last`. |
+| `split_condition` | **Cut a twin loose** from its family: every following material row freezes at its current values and edits to the original stop reaching it. It keeps its finish tag and still groups with its siblings — only the inheritance ends. For when two variants have diverged far enough that following each other is wrong. A condition that already owns its materials returns `split: false` rather than erroring. Reversible with `undo_last`. |
 | `export_report` | The **computed Report document** — `opentakeoff.report.v1`, the same JSON the canvas Report exports: gross + waste-adjusted quantities, the computed materials **buy list** per condition plus the project-wide roll-up, per-sheet base subtotals, and scale provenance. The contract for pricing consumers — `export_takeoff` carries materials as config rows, `takeoff_summary` strips them. Inline, and to disk with `path` (see **Writing to disk** below). |
-| `import_takeoff` | **The way back in**: load a `takeoff_canvas.v1` file (a prior `export_takeoff`, or the app's own save) through the SAME merge rules as the app's Sheet-menu import — finish-tag identity joins conditions (this session's knobs win), new ids append, duplicates skip (idempotent re-import), this session's calibration wins per sheet. Resume, extend, or audit. |
+| `import_takeoff` | **The way back in**: load a `takeoff_canvas.v1` file (a prior `export_takeoff`, or the app's own save) through the SAME merge rules as the app's Sheet-menu import — finish-tag identity joins conditions (this session's knobs win), new ids append, duplicates skip (idempotent re-import), this session's calibration wins per sheet. Resume, extend, or audit. Correction rules (#88) ride the file too — `apply_rules` re-runs them. |
+| `apply_rules` | **Re-run the correction rules the takeoff arrived with** (#207) — the lessons an estimator TAUGHT the canvas (#88), e.g. "every room like this loses the mechanical chase". Same pure `rules.ts` engine the canvas Preview runs; committed as the ONE batch its Apply makes (`reviewed: false`, one undo step, `origin {method rule_v1, actor rule}` with the rule/seed/room citation). The reply's per-rule disclosure — produced, skipped, ids — IS the preview an agent gets. Idempotent by construction: anything an existing deduct covers is dropped by the engine, so re-running after new rooms commit is the intended workflow. Rules arrive ONLY via `import_takeoff`; minting one is an estimator's correction and stays behind the canvas's human Preview→Apply gate. |
 | `export_marked_pdf` | The **marked-up planset** — the deliverable. Writes a distribution-ready PDF: a legend cover (per-condition totals, swatches, by-sheet breakdown) plus every sheet that carries work, vector-copied from the source with shapes, hatches, per-shape quantity chips, and annotations burned in — built by the same module as the canvas's MARKED SET button. Machine-traced shapes are disclosed as pending human review on the document itself, and the cover states where the finish tags came from (`Finish assignment: N schedule-resolved · N agent-asserted · …`, plus any rooms the last assign run withheld). Default path: `<plan> - marked set.pdf` next to the plan (see **Writing to disk** below). Works without `@napi-rs/canvas`. |
 | `list_shapes` | The **mid-session inventory**: every committed shape's id, sheet, condition, role, quantities, room `label`, review state, and assignment verdict (`schedule` \| `asserted` — where its finish tag came from) in one compact read — the ids `edit_shape`/`delete_shape` assume you have, without pulling the whole `export_takeoff` payload. Filters by sheet/condition narrow; empty is a result, not an error. |
 | `undo_last` | Step back over your own last `n` mutations, newest first. Exact inverses: a commit is removed, an edit restored verbatim, a delete re-inserted where it was, a materials edit's whole array restored, a condition edit's waste/multiplier pair restored. A whole `detect_rooms` sweep is **one** step. |

package/dist/server-core.js

@@ -547,13 +547,23 @@ function openLen(pts) {
   for (let i = 1; i < pts.length; i++) L += Math.hypot(pts[i][0] - pts[i - 1][0], pts[i][1] - pts[i - 1][1]);
   return L;
 }
+function polyWithHolesMetrics(outerPts, holesPts = []) {
+  const outer = closedMetrics(outerPts);
+  let area = outer.area, perim = outer.perim;
+  for (const h of holesPts) {
+    const hm = closedMetrics(h);
+    area -= hm.area;
+    perim += hm.perim;
+  }
+  return { area: Math.max(0, area), perim };
+}
 function pointInPoly(x, y, pts) {
-  let inside = false;
+  let inside2 = false;
   for (let i = 0, j = pts.length - 1; i < pts.length; j = i++) {
     const [xi, yi] = pts[i], [xj, yj] = pts[j];
-    if (yi > y !== yj > y && x < (xj - xi) * (y - yi) / (yj - yi) + xi) inside = !inside;
+    if (yi > y !== yj > y && x < (xj - xi) * (y - yi) / (yj - yi) + xi) inside2 = !inside2;
   }
-  return inside;
+  return inside2;
 }
 function chiselRibbon(pts, w, nibDeg = 45) {
   const a = nibDeg * Math.PI / 180, vx = Math.cos(a) * w / 2, vy = -(Math.sin(a) * w) / 2;
@@ -3452,10 +3462,10 @@ function fingerprintSymbol(segs, seedRect) {
   const n = segs.length >> 2;
   const rx0 = Math.min(seedRect[0][0], seedRect[1][0]), rx1 = Math.max(seedRect[0][0], seedRect[1][0]);
   const ry0 = Math.min(seedRect[0][1], seedRect[1][1]), ry1 = Math.max(seedRect[0][1], seedRect[1][1]);
-  const inside = (x, y) => x >= rx0 && x <= rx1 && y >= ry0 && y <= ry1;
+  const inside2 = (x, y) => x >= rx0 && x <= rx1 && y >= ry0 && y <= ry1;
   const seedIdx = [];
   for (let i = 0; i < n; i++) {
-    if (inside(segs[i * 4], segs[i * 4 + 1]) && inside(segs[i * 4 + 2], segs[i * 4 + 3]) && segLen(segs, i) >= MIN_SEG_LEN) {
+    if (inside2(segs[i * 4], segs[i * 4 + 1]) && inside2(segs[i * 4 + 2], segs[i * 4 + 3]) && segLen(segs, i) >= MIN_SEG_LEN) {
       seedIdx.push(i);
     }
   }
@@ -3744,6 +3754,180 @@ function sharedRuns(ringA, ringB, opts) {
   return runs;
 }
 
+// ../web/src/lib/cutout.js
+import { polygon as turfPolygon, featureCollection } from "@turf/helpers";
+import turfDifference from "@turf/difference";
+import booleanOverlap from "@turf/boolean-overlap";
+import booleanContains from "@turf/boolean-contains";
+var closeRing = (pts) => {
+  if (!pts.length) return pts;
+  const [x0, y0] = pts[0], [xn, yn] = pts[pts.length - 1];
+  return x0 === xn && y0 === yn ? pts : [...pts, [x0, y0]];
+};
+var openRing = (pts) => {
+  if (pts.length > 1) {
+    const [x0, y0] = pts[0], [xn, yn] = pts[pts.length - 1];
+    if (x0 === xn && y0 === yn) return pts.slice(0, -1);
+  }
+  return pts;
+};
+function ringFullyInside(outerRingPx, innerRingPx) {
+  if (outerRingPx.length < 3 || innerRingPx.length < 3) return false;
+  try {
+    return booleanContains(turfPolygon([closeRing(outerRingPx)]), turfPolygon([closeRing(innerRingPx)]));
+  } catch {
+    return false;
+  }
+}
+function subtractCutout(outerRingPx, holeRingsPx, deductRingPx) {
+  let result;
+  try {
+    const parentPoly = turfPolygon([closeRing(outerRingPx), ...holeRingsPx.map(closeRing)]);
+    const deductPoly = turfPolygon([closeRing(deductRingPx)]);
+    result = turfDifference(featureCollection([parentPoly, deductPoly]));
+  } catch {
+    return null;
+  }
+  if (!result || result.geometry?.type !== "Polygon") return null;
+  const [outer, ...holes] = result.geometry.coordinates.map(openRing);
+  if (outer.length < 3) return null;
+  const metrics = polyWithHolesMetrics(outer, holes);
+  return { outer, holes, area: metrics.area, perim: metrics.perim };
+}
+function recomposeCutouts(baseOuterPx, baseHolesPx, deductRingsPx) {
+  let outer = baseOuterPx, holes = baseHolesPx;
+  for (const ring of deductRingsPx) {
+    const r = subtractCutout(outer, holes, ring);
+    if (!r) return null;
+    outer = r.outer;
+    holes = r.holes;
+  }
+  const metrics = polyWithHolesMetrics(outer, holes);
+  return { outer, holes, area: metrics.area, perim: metrics.perim };
+}
+
+// ../web/src/lib/rules.ts
+var ringCentroid = (pts) => {
+  let x = 0, y = 0;
+  for (const p of pts) {
+    x += p[0];
+    y += p[1];
+  }
+  return [x / pts.length, y / pts.length];
+};
+var inside = (p, ring) => pointInPoly(p[0], p[1], ring);
+function findEnclosedRegions(mask, ringImgPx, maxCells, minCells = 4) {
+  const { mask: m, mw, mh, ws } = mask;
+  if (ringImgPx.length < 3 || maxCells < minCells) return [];
+  const ringMask = ringImgPx.map(([x, y]) => [x * ws, y * ws]);
+  let bx0 = Infinity, by0 = Infinity, bx1 = -Infinity, by1 = -Infinity;
+  for (const [x, y] of ringMask) {
+    if (x < bx0) bx0 = x;
+    if (x > bx1) bx1 = x;
+    if (y < by0) by0 = y;
+    if (y > by1) by1 = y;
+  }
+  const x0 = Math.max(0, Math.floor(bx0)), y0 = Math.max(0, Math.floor(by0));
+  const x1 = Math.min(mw - 1, Math.ceil(bx1)), y1 = Math.min(mh - 1, Math.ceil(by1));
+  if (x1 <= x0 || y1 <= y0) return [];
+  const bw = x1 - x0 + 1, bh = y1 - y0 + 1;
+  const seen = new Uint8Array(bw * bh);
+  const isFree = (gx, gy) => !(m[gy * mw + gx] & 1) && inside([gx + 0.5, gy + 0.5], ringMask);
+  const out = [];
+  for (let gy = y0; gy <= y1; gy++) {
+    for (let gx = x0; gx <= x1; gx++) {
+      const li = (gy - y0) * bw + (gx - x0);
+      if (seen[li] || !isFree(gx, gy)) {
+        seen[li] = 1;
+        continue;
+      }
+      const cells = [];
+      const stack = [gx, gy];
+      seen[li] = 1;
+      let over = false;
+      let cx0 = gx, cx1 = gx, cy0 = gy, cy1 = gy;
+      while (stack.length) {
+        const cy = stack.pop(), cx = stack.pop();
+        cells.push(cx, cy);
+        if (cx < cx0) cx0 = cx;
+        if (cx > cx1) cx1 = cx;
+        if (cy < cy0) cy0 = cy;
+        if (cy > cy1) cy1 = cy;
+        if (!over && cells.length / 2 > maxCells) over = true;
+        const nbrs = [cx - 1, cy, cx + 1, cy, cx, cy - 1, cx, cy + 1];
+        for (let k = 0; k < 8; k += 2) {
+          const nx = nbrs[k], ny = nbrs[k + 1];
+          if (nx < x0 || ny < y0 || nx > x1 || ny > y1) continue;
+          const nli = (ny - y0) * bw + (nx - x0);
+          if (seen[nli]) continue;
+          seen[nli] = 1;
+          if (isFree(nx, ny)) {
+            stack.push(nx, ny);
+          }
+        }
+      }
+      const n = cells.length / 2;
+      if (over || n > maxCells || n < minCells) continue;
+      if (cx1 - cx0 + 1 < 2 || cy1 - cy0 + 1 < 2) continue;
+      const cw = cx1 - cx0 + 1, ch = cy1 - cy0 + 1;
+      const region = new Uint8Array(cw * ch);
+      for (let k = 0; k < cells.length; k += 2) region[(cells[k + 1] - cy0) * cw + (cells[k] - cx0)] = 1;
+      const ring = traceRegion({ region, mw: cw, mh: ch, ws }).map(([px, py]) => [px + cx0 / ws, py + cy0 / ws]);
+      if (ring.length >= 3) out.push(ring);
+    }
+  }
+  return out;
+}
+function applyRuleToProject(rule, shapes, sheetData) {
+  if (!rule.active || rule.predicate.kind !== "enclosed_subpolygon_deduct") return [];
+  const rooms = shapes.filter((s) => s.measure_role === "floor_area" && s.condition_id === rule.seed_condition_id && s.verts_norm.length >= 3 && sheetData.has(s.sheet_id));
+  const deductsBySheet = /* @__PURE__ */ new Map();
+  for (const s of shapes) {
+    if (s.measure_role !== "deduct" || s.verts_norm.length < 3) continue;
+    const d = sheetData.get(s.sheet_id);
+    if (!d) continue;
+    const ring = s.verts_norm.map(([nx, ny]) => [nx * d.imgW, ny * d.imgH]);
+    let arr2 = deductsBySheet.get(s.sheet_id);
+    if (!arr2) {
+      arr2 = [];
+      deductsBySheet.set(s.sheet_id, arr2);
+    }
+    arr2.push(ring);
+  }
+  const out = [];
+  const acceptedBySheet = /* @__PURE__ */ new Map();
+  for (const room of rooms) {
+    const d = sheetData.get(room.sheet_id);
+    if (!(d.upp > 0)) continue;
+    const ringImg = room.verts_norm.map(([nx, ny]) => [nx * d.imgW, ny * d.imgH]);
+    const cellSf = (d.upp / d.mask.ws) ** 2;
+    const maxCells = Math.floor(rule.predicate.max_area_sf / cellSf);
+    const found = findEnclosedRegions(d.mask, ringImg, maxCells);
+    for (const ring of found) {
+      const areaSf = ringArea(ring) * d.upp * d.upp;
+      if (!(areaSf > 0) || areaSf > rule.predicate.max_area_sf) continue;
+      const c = ringCentroid(ring);
+      const existing = deductsBySheet.get(room.sheet_id) || [];
+      const taken = acceptedBySheet.get(room.sheet_id) || [];
+      const covered = (rings) => rings.some((r) => inside(c, r) || inside(ringCentroid(r), ring));
+      if (covered(existing) || covered(taken)) continue;
+      out.push({
+        sheet_id: room.sheet_id,
+        container_shape_id: room.id,
+        verts_norm: ring.map(([x, y]) => [x / d.imgW, y / d.imgH]),
+        area_sf: +areaSf.toFixed(2)
+      });
+      let arr2 = acceptedBySheet.get(room.sheet_id);
+      if (!arr2) {
+        arr2 = [];
+        acceptedBySheet.set(room.sheet_id, arr2);
+      }
+      arr2.push(ring);
+    }
+  }
+  return out;
+}
+
 // ../web/src/lib/provenance.js
 var mintUuid = () => {
   const c = globalThis.crypto;
@@ -4740,6 +4924,11 @@ var Session = class _Session {
    * normalized so the export-time staleness drop can test them against
    * committed rings in verts_norm space. */
   scheduleWithheld = [];
+  /** Correction rules (#207) — imported from a canvas takeoff file, never
+   * minted here (a rule IS an estimator's correction by definition; minting
+   * stays behind the canvas's human Preview→Apply gate). apply_rules re-runs
+   * them; applied_to mirrors the canvas's audit-trail semantics. */
+  rules = [];
   /** Newest-last. Capped at UNDO_CAP; the oldest entry falls off the front. */
   journal = [];
   seq = 0;
@@ -4781,6 +4970,7 @@ var Session = class _Session {
       this.filePath = null;
       this.nextOrd = 1;
       this.scheduleWithheld = [];
+      this.rules = [];
       this.journal = [];
       this.pendingCommits = [];
     } else if (this.docs.has(base)) {
@@ -5674,6 +5864,188 @@ var Session = class _Session {
       note: "Base runs trace each room's boundary; openings are your stated claim, recorded on origin.derived. Verify with view_sheet overlay:true."
     };
   }
+  /** apply_rules (#207): re-run the correction rules an estimator taught the
+   * canvas (#88). Rules arrive with import_takeoff — they are never minted
+   * here, because a rule IS an estimator's correction by definition and the
+   * v1 predicate's known label-box false-positive stays safe behind the
+   * canvas's human Preview→Apply gate. Evaluation is the same pure rules.ts
+   * engine the canvas Preview runs; the commit is the one batch the canvas's
+   * Apply makes (ONE journal entry, undo_last takes it all back). Everything
+   * lands reviewed: false — this server has no review gate — and the reply's
+   * per-rule disclosure IS the preview an agent gets. Idempotent by
+   * construction: the engine drops any candidate an existing deduct already
+   * covers, and rule N's mints are rule N+1's dedup targets, exactly like
+   * consecutive Applies on the canvas. */
+  async applyRules(opts = {}) {
+    if (!this.rules.length) {
+      throw new UserError("No rules in this session \u2014 rules ride import_takeoff from a canvas file (an estimator's taught corrections, #88). Minting new rules is the canvas's job; this verb only re-runs what a human already taught.");
+    }
+    const activeCondIds = new Set(this.rules.filter((r) => r.active).map((r) => r.seed_condition_id));
+    const sheetKeys = opts.sheet ? [this.sheet(opts.sheet).key] : [...new Set(this.shapes.filter((x) => x.measure_role === "floor_area" && activeCondIds.has(x.condition_id)).map((x) => x.sheet_id))];
+    const skipped_sheets = [];
+    const sheetData = /* @__PURE__ */ new Map();
+    for (const key of sheetKeys) {
+      const s = this.sheet(key);
+      if (!(s.upp && s.upp > 0)) {
+        skipped_sheets.push({ sheet_id: key, reason: "no_scale" });
+        continue;
+      }
+      const mask = await this.ensureMask(key);
+      if (!mask) {
+        skipped_sheets.push({ sheet_id: key, reason: "no_vector_mask" });
+        continue;
+      }
+      sheetData.set(key, { mask, upp: s.upp, imgW: s.widthPx, imgH: s.heightPx });
+    }
+    const rulesOut = [];
+    const skipped_rules = [];
+    for (const rule of this.rules) {
+      if (!rule.active) {
+        skipped_rules.push({ rule_id: rule.id, label: rule.label, reason: "inactive" });
+        continue;
+      }
+      const cond = this.conditions.find((c) => c.id === rule.seed_condition_id);
+      if (!cond) {
+        skipped_rules.push({ rule_id: rule.id, label: rule.label, reason: "condition_not_in_session" });
+        continue;
+      }
+      const candidates = applyRuleToProject(rule, this.shapes, sheetData);
+      const ids = [];
+      let sf = 0;
+      for (const cand of candidates) {
+        const d = sheetData.get(cand.sheet_id);
+        const vertsPx = cand.verts_norm.map(([nx, ny]) => [nx * d.imgW, ny * d.imgH]);
+        const shape = this.commit(
+          this.sheet(cand.sheet_id),
+          cond.finish_tag,
+          "deduct",
+          vertsPx,
+          { area_sf: cand.area_sf, perimeter_lf: round2(closedMetrics(vertsPx).perim * d.upp) },
+          {
+            method: "rule_v1",
+            actor: "rule",
+            reviewed: false,
+            rule_id: rule.id,
+            seed_shape_id: rule.seed_shape_id,
+            container_shape_id: cand.container_shape_id
+          }
+        );
+        ids.push(shape.id);
+        sf += cand.area_sf;
+      }
+      if (ids.length) rule.applied_to = ids;
+      rulesOut.push({ rule_id: rule.id, label: rule.label, condition: cond.finish_tag, produced: ids.length, shape_ids: ids, deduct_sf: round2(sf) });
+    }
+    this.flushCommits("apply_rules");
+    const committed = rulesOut.reduce((n, r) => n + r.produced, 0);
+    return {
+      rules: rulesOut,
+      committed,
+      total_deduct_sf: round2(rulesOut.reduce((n, r) => n + r.deduct_sf, 0)),
+      skipped_rules,
+      skipped_sheets,
+      note: committed ? "One batch, one undo step, everything reviewed: false \u2014 this disclosure is your preview; verify with view_sheet overlay:true. Re-running is idempotent: anything a deduct already covers is dropped by the engine." : "No new candidates \u2014 every match is already covered by an existing deduct (re-running is idempotent by construction), or the rules' rooms are not on the evaluated sheets."
+    };
+  }
+  /** cut_out (#206): a REAL hole, reconciled the way the canvas cuts one
+   * (#137) — the same lib/cutout.js boolean subtract, so a headless session
+   * and the app can never disagree about what a hole holds. The parent's
+   * outer ring + existing holes minus the new ring lands back on the parent
+   * (verts_norm_holes + netted computed); the deduct commits carrying
+   * cuts_shape_id, so totals.js skips it (set subtraction — N cuts compose,
+   * overlap never double-deducts). One journal entry: undo_last restores
+   * parent and hole together. Refusal over guessing: a cut not FULLY inside
+   * the parent refuses (the canvas's edge-clip is a canvas affordance), and
+   * a subtract that erases or splits the parent refuses whole. */
+  cutOut(opts) {
+    const parent = this.shapes.find((x) => x.id === opts.parent_shape_id);
+    if (!parent) throw new UserError(`No shape with id ${JSON.stringify(opts.parent_shape_id)} \u2014 list_shapes for real ids.`);
+    if (parent.measure_role !== "floor_area") {
+      throw new UserError(`cut_out subtracts from a floor_area shape \u2014 ${parent.id} is ${parent.measure_role}. An opening in a linear run is derive_base's openings claim; a count marker has no area to cut.`);
+    }
+    if (parent.origin?.reviewed === true) {
+      throw new UserError(`Shape ${parent.id} was affirmed by a human \u2014 reviewed work is ink, and cutting a hole in it would mutate what the estimator signed. Commit an independent deduct with measure_polygon instead.`);
+    }
+    const s = this.sheet(parent.sheet_id);
+    if (s.upp == null) throw new UserError(this.scaleGate(s));
+    if (opts.verts.length < 3) throw new UserError(`A cut needs at least 3 vertices \u2014 got ${opts.verts.length}.`);
+    const upp = s.upp;
+    const toPx = (ring) => ring.map(([nx, ny]) => [nx * s.widthPx, ny * s.heightPx]);
+    const toNorm = (ring) => ring.map(([x, y]) => [x / s.widthPx, y / s.heightPx]);
+    const outerPx = toPx(parent.verts_norm);
+    if (!ringFullyInside(outerPx, opts.verts)) {
+      throw new UserError("The cut is not fully inside the parent's outer ring. The canvas resolves an edge-crossing cut as a boundary clip; over the wire the rule is refusal-over-guessing \u2014 reshape the parent with edit_shape, or commit an independent deduct with measure_polygon.");
+    }
+    const holesPx = (parent.verts_norm_holes ?? []).map(toPx);
+    const r = subtractCutout(outerPx, holesPx, opts.verts);
+    if (!r) {
+      throw new UserError("The subtract degenerates \u2014 this cut would erase the parent or split it into disjoint pieces. That is a re-trace decision, not a hole: measure_polygon the pieces as their own rooms.");
+    }
+    const parentPrev = {
+      verts_norm: parent.verts_norm.map((v) => [...v]),
+      ...parent.verts_norm_holes ? { verts_norm_holes: parent.verts_norm_holes.map((h) => h.map((v) => [...v])) } : {},
+      ...parent.computed ? { computed: { ...parent.computed } } : {}
+    };
+    const met = closedMetrics(opts.verts);
+    const deduct = {
+      id: uid("shp"),
+      sheet_id: s.key,
+      condition_id: parent.condition_id,
+      measure_role: "deduct",
+      verts_norm: opts.verts.map(([x, y]) => [x / s.widthPx, y / s.heightPx]),
+      // face value for the hover label — totals skip it, the parent nets it
+      computed: { area_sf: round2(met.area * upp * upp), perimeter_lf: round2(met.perim * upp) },
+      cuts_shape_id: parent.id,
+      origin: { method: "cutout_v1", actor: "agent", reviewed: false, cuts_shape_id: parent.id, parent_prev: parentPrev }
+    };
+    const prevNet = parentPrev.computed?.area_sf ?? 0;
+    parent.verts_norm = toNorm(r.outer);
+    parent.verts_norm_holes = r.holes.map(toNorm);
+    parent.computed = { area_sf: round2(r.area * upp * upp), perimeter_lf: round2(r.perim * upp) };
+    this.shapes.push(deduct);
+    this.record({ op: "cutout", tool: "cut_out", deduct_id: deduct.id, parent_id: parent.id, parent_prev: parentPrev });
+    return {
+      deduct_shape_id: deduct.id,
+      parent_shape_id: parent.id,
+      hole_sf: round2(Math.max(0, prevNet - (parent.computed.area_sf ?? 0))),
+      parent_net: { area_sf: parent.computed.area_sf ?? 0, perimeter_lf: parent.computed.perimeter_lf ?? 0 },
+      holes: parent.verts_norm_holes.length,
+      note: "The parent's computed nets the hole for real (boolean subtract, not arithmetic) \u2014 overlap with an earlier cut never double-deducts. One undo step restores parent and hole together; deleting the deduct later reverts the cut too."
+    };
+  }
+  /** The canvas's cutoutParentPrevSans, ported verbatim in spirit (#206 —
+   * "the canvas's answer is the spec"): rebuilding a multi-cut parent after
+   * ONE cut is deleted starts from the chain's EARLIEST pristine snapshot and
+   * re-subtracts every survivor in commit order. Null when the rebuild can't
+   * be trusted — the caller falls back to a plain delete that leaves the cut
+   * baked in, never reverts over survivors. */
+  cutoutParentPrevSans(doomed) {
+    const chain = this.shapes.filter((x) => x.cuts_shape_id === doomed.cuts_shape_id && x.origin?.parent_prev);
+    const rest = chain.filter((x) => x.id !== doomed.id);
+    if (!rest.length) return doomed.origin.parent_prev;
+    const parent = this.shapes.find((x) => x.id === doomed.cuts_shape_id);
+    const s = this.sheet(parent.sheet_id);
+    if (s.upp == null) return null;
+    const upp = s.upp;
+    const px = (ring) => ring.map(([nx, ny]) => [nx * s.widthPx, ny * s.heightPx]);
+    const base = chain[0].origin.parent_prev;
+    const r = recomposeCutouts(px(base.verts_norm), (base.verts_norm_holes ?? []).map(px), rest.map((x) => px(x.verts_norm)));
+    if (!r) return null;
+    const norm2 = (ring) => ring.map(([x, y]) => [x / s.widthPx, y / s.heightPx]);
+    return {
+      verts_norm: norm2(r.outer),
+      ...r.holes.length ? { verts_norm_holes: r.holes.map(norm2) } : {},
+      computed: { area_sf: round2(r.area * upp * upp), perimeter_lf: round2(r.perim * upp) }
+    };
+  }
+  /** Write a cutout snapshot back onto a parent — the one place the restore
+   * shape is defined, used by undo and by delete's revert. */
+  static restoreCutoutSnapshot(p, snap) {
+    p.verts_norm = snap.verts_norm.map((v) => [...v]);
+    if (snap.verts_norm_holes) p.verts_norm_holes = snap.verts_norm_holes.map((h) => h.map((v) => [...v]));
+    else delete p.verts_norm_holes;
+    if (snap.computed) p.computed = { ...snap.computed };
+  }
   /** Mint the transition where two finishes meet (#202) — the derivation that
    * follows derive_base, and the one an estimator draws by hand on every job.
    *
@@ -6312,9 +6684,43 @@ var Session = class _Session {
   deleteShape(id) {
     const i = this.shapes.findIndex((x) => x.id === id);
     if (i < 0) throw new UserError(`No shape with id ${JSON.stringify(id)}.`);
-    const [shape] = this.shapes.splice(i, 1);
+    const shape = this.shapes[i];
+    if (shape.cuts_shape_id && shape.origin?.parent_prev) {
+      const parent = this.shapes.find((x) => x.id === shape.cuts_shape_id);
+      if (parent) {
+        const parentPrev = this.cutoutParentPrevSans(shape);
+        if (parentPrev) {
+          const parentAfter = {
+            verts_norm: parent.verts_norm.map((v) => [...v]),
+            ...parent.verts_norm_holes ? { verts_norm_holes: parent.verts_norm_holes.map((h) => h.map((v) => [...v])) } : {},
+            computed: { ...parent.computed }
+          };
+          this.shapes.splice(i, 1);
+          _Session.restoreCutoutSnapshot(parent, parentPrev);
+          this.record({ op: "cutout_restore", tool: "delete_shape", removed: { shape, index: i }, parent_id: parent.id, parent_after: parentAfter });
+          return {
+            deleted: id,
+            shape_count: this.shapes.length,
+            note: `Reconciled cutout: the cut was reverted out of parent ${parent.id} too (its net is back to ${parent.computed.area_sf} SF).`
+          };
+        }
+        this.shapes.splice(i, 1);
+        this.record({ op: "delete", tool: "delete_shape", removed: [{ shape, index: i }] });
+        return {
+          deleted: id,
+          shape_count: this.shapes.length,
+          note: `The cut could not be rebuilt out of parent ${parent.id} (a re-subtract degenerates) \u2014 the deduct is gone but its hole stays baked into the parent's geometry, the canvas's own fallback.`
+        };
+      }
+    }
+    this.shapes.splice(i, 1);
     this.record({ op: "delete", tool: "delete_shape", removed: [{ shape, index: i }] });
-    return { deleted: id, shape_count: this.shapes.length };
+    const orphans = this.shapes.filter((x) => x.cuts_shape_id === id).length;
+    return {
+      deleted: id,
+      shape_count: this.shapes.length,
+      ...orphans ? { note: `${orphans} reconciled deduct(s) pointed at this shape and are now orphaned (their holes died with the parent; totals ignore them) \u2014 the canvas behaves the same. delete_shape them too, or undo_last.` } : {}
+    };
   }
   /** Revise a committed shape in place: new geometry, a different condition, a
    * different role, or any combination. This is the verb that turns the agent
@@ -6351,6 +6757,12 @@ var Session = class _Session {
     if (patch.verts === void 0 && patch.condition === void 0 && patch.role === void 0 && patch.label === void 0) {
       throw new UserError("Nothing to change \u2014 pass at least one of verts, condition, role, label.");
     }
+    if (cur.cuts_shape_id && (patch.verts !== void 0 || patch.role !== void 0 || patch.condition !== void 0)) {
+      throw new UserError(`Shape ${JSON.stringify(id)} is a reconciled cutout \u2014 its ring IS the hole in ${cur.cuts_shape_id}. delete_shape it (the parent's geometry is restored) and cut_out again where you mean it.`);
+    }
+    if (cur.verts_norm_holes?.length && (patch.verts !== void 0 || patch.role !== void 0)) {
+      throw new UserError(`Shape ${JSON.stringify(id)} carries ${cur.verts_norm_holes.length} reconciled hole(s) \u2014 reshaping its outer ring would strand them. delete_shape the cutout deduct(s) first (each restores the parent), reshape, then cut_out again.`);
+    }
     const s = this.sheet(cur.sheet_id);
     const role = patch.role ?? cur.measure_role;
     if (role !== "count" && s.upp == null) throw new UserError(this.scaleGate(s));
@@ -6760,6 +7172,16 @@ var Session = class _Session {
           else c.materials_dropped = structuredClone(e.before.materials_dropped);
         }
         undone.push({ seq: e.seq, op: e.op, tool: e.tool, shapes: 0 });
+      } else if (e.op === "cutout") {
+        this.shapes = this.shapes.filter((x) => x.id !== e.deduct_id);
+        const p = this.shapes.find((x) => x.id === e.parent_id);
+        if (p) _Session.restoreCutoutSnapshot(p, e.parent_prev);
+        undone.push({ seq: e.seq, op: e.op, tool: e.tool, shapes: 1 });
+      } else if (e.op === "cutout_restore") {
+        this.shapes.splice(Math.min(e.removed.index, this.shapes.length), 0, e.removed.shape);
+        const p = this.shapes.find((x) => x.id === e.parent_id);
+        if (p) _Session.restoreCutoutSnapshot(p, e.parent_after);
+        undone.push({ seq: e.seq, op: e.op, tool: e.tool, shapes: 1 });
       } else if (e.op === "approval") {
         this.approvals = applyApprovalCommand2(this.approvals, e.inverse).approvals;
         undone.push({ seq: e.seq, op: e.op, tool: e.tool, shapes: 0 });
@@ -7508,9 +7930,43 @@ var importTakeoffOutput = {
   conditions_added: z.number().int(),
   scales_adopted: z.number().int().describe("Sheets whose calibration came from the file (this session's own always wins)"),
   unknown_files: z.array(z.string()).describe("Files referenced by imported shapes that this document doesn't have \u2014 they count in totals but can't be viewed here"),
+  rules_imported: z.number().int().describe("Correction rules (#88) that arrived with the file \u2014 apply_rules re-runs them"),
   shapes_total: z.number().int(),
   note: z.string()
 };
+var cutOutOutput = {
+  deduct_shape_id: z.string().describe("The reconciled deduct \u2014 carries cuts_shape_id; totals skip it (the parent nets the hole)"),
+  parent_shape_id: z.string(),
+  hole_sf: z.number().describe("What this cut actually removed from the parent's net \u2014 0 when the ring fell entirely inside an existing hole"),
+  parent_net: z.object({
+    area_sf: z.number().describe("The parent's recomputed net after the subtract"),
+    perimeter_lf: z.number().describe("Outer ring + hole boundaries \u2014 a hole ADDS perimeter")
+  }),
+  holes: z.number().int().describe("Holes the parent now carries"),
+  note: z.string()
+};
+var applyRulesOutput = {
+  rules: z.array(z.object({
+    rule_id: z.string(),
+    label: z.string().describe("The rule's own plain-language statement, minted at creation"),
+    condition: z.string().describe("The finish tag whose rooms were scanned"),
+    produced: z.number().int(),
+    shape_ids: z.array(z.string()).describe("The committed deducts \u2014 reviewed: false, one batch"),
+    deduct_sf: z.number()
+  })),
+  committed: z.number().int().describe("Deducts committed across all rules \u2014 0 is a result (idempotence)"),
+  total_deduct_sf: z.number(),
+  skipped_rules: z.array(z.object({
+    rule_id: z.string(),
+    label: z.string(),
+    reason: z.enum(["inactive", "condition_not_in_session"])
+  })).describe("Rules not evaluated, named \u2014 never silently dropped"),
+  skipped_sheets: z.array(z.object({
+    sheet_id: z.string(),
+    reason: z.enum(["no_scale", "no_vector_mask"])
+  })).describe("Sheets that could not be scanned (uncalibrated, or scanned raster with no linework mask)"),
+  note: z.string()
+};
 var deriveBaseOutput = {
   condition: z.string().describe("The tag the base committed under"),
   source_condition: z.string(),
@@ -7567,7 +8023,8 @@ var listShapesOutput = {
 };
 var deleteShapeOutput = {
   deleted: z.string().describe("The removed shape's id"),
-  shape_count: z.number().int().describe("Committed shapes remaining")
+  shape_count: z.number().int().describe("Committed shapes remaining"),
+  note: z.string().optional().describe("Cutout interplay (#206), when it applies: the parent's cut was reverted, could not be rebuilt, or reconciled deducts were orphaned by a parent delete")
 };
 var editShapeOutput = {
   shape_id: z.string(),
@@ -7584,7 +8041,7 @@ var undoLastOutput = {
   undone: z.number().int().describe("Steps actually reversed"),
   steps: z.array(z.object({
     seq: z.number().int(),
-    op: z.enum(["commit", "edit", "delete", "materials", "condition", "approval", "duplicate_condition", "split_condition"]),
+    op: z.enum(["commit", "edit", "delete", "materials", "condition", "approval", "duplicate_condition", "split_condition", "cutout", "cutout_restore"]),
     tool: z.string().describe("The tool call this step came from"),
     shapes: z.number().int().describe("Shapes affected by reversing this step \u2014 0 for a materials step (it restores a condition's supporting-materials rows, not shapes), for a condition step (it restores the waste/multiplier pair), and for an approval step (it re-seats or removes a verdict mark)")
   })).describe("Newest first"),
@@ -9337,13 +9794,28 @@ async function importTakeoff(session, filePath) {
       s.scaleSource = row.scale_source ?? "upp";
     }
   }
+  const tagKey2 = (t) => String(t || "").trim().toUpperCase();
+  const importedConds = Array.isArray(imported.conditions) ? imported.conditions : [];
+  const tagById = new Map(importedConds.map((c) => [c.id, tagKey2(c.finish_tag)]));
+  const sessionByTag = new Map(session.conditions.map((c) => [tagKey2(c.finish_tag), c.id]));
+  const knownRuleIds = new Set(session.rules.map((r) => r.id));
+  let rulesImported = 0;
+  for (const raw of Array.isArray(imported.rules) ? imported.rules : []) {
+    if (!raw || typeof raw !== "object" || !raw.id || knownRuleIds.has(raw.id)) continue;
+    if (raw.predicate?.kind !== "enclosed_subpolygon_deduct" || !(raw.predicate.max_area_sf > 0)) continue;
+    const mapped = sessionByTag.get(tagById.get(raw.seed_condition_id) ?? "");
+    session.rules.push({ ...raw, applied_to: [...raw.applied_to ?? []], seed_condition_id: mapped ?? raw.seed_condition_id });
+    knownRuleIds.add(raw.id);
+    rulesImported++;
+  }
   const addedIds = session.shapes.filter((s) => !prevShapeIds.has(s.id)).map((s) => s.id);
   if (addedIds.length) session.journalCommit("import_takeoff", addedIds);
   return {
     file: path4.basename(filePath),
     ...note,
+    rules_imported: rulesImported,
     shapes_total: session.shapes.length,
-    note: note.replaced ? "Empty session \u2014 the import IS the takeoff now. Unreviewed machine shapes stay pencil; verify with view_sheet overlay:true." : "Merged: same finish tags joined your conditions, new ids appended, duplicates skipped (re-import is idempotent), this session's calibration won per sheet."
+    note: (note.replaced ? "Empty session \u2014 the import IS the takeoff now. Unreviewed machine shapes stay pencil; verify with view_sheet overlay:true." : "Merged: same finish tags joined your conditions, new ids appended, duplicates skipped (re-import is idempotent), this session's calibration won per sheet.") + (rulesImported ? ` ${rulesImported} correction rule(s) arrived \u2014 apply_rules re-runs them.` : "")
   };
 }
 
@@ -9442,6 +9914,14 @@ function registerTools(server, session) {
     },
     outputSchema: measurePolygonOutput
   }, run("measure_polygon", (a) => session.measurePolygon(a.sheet, a.verts, { condition: a.condition, role: a.role })));
+  server.registerTool("cut_out", {
+    description: `Cut a REAL hole in a committed floor_area shape (#206) \u2014 the way the canvas cuts one (#137): the same lib/cutout.js boolean subtract, so the two surfaces can never disagree about what a hole holds. The parent keeps its outer ring plus the reconciled hole(s) (verts_norm_holes), its computed nets for real \u2014 N cuts compose, overlap between cuts never double-deducts (set subtraction), a hole ADDS perimeter \u2014 and the deduct commits carrying cuts_shape_id so the report and legend read the reconciled number, never a second arithmetic pass. This is the verb for a column, a floor drain, an island of casework INSIDE a room; an independent measure_polygon role:"deduct" stays the tool for a deduction that isn't a hole in one parent. Refusal over guessing: the ring must sit FULLY inside the parent's outer ring (an edge-crossing cut is a boundary correction \u2014 edit_shape the parent instead), and a cut that would erase the parent or split it in two refuses whole (trace the pieces as rooms). One journal entry \u2014 undo_last restores parent and hole together; delete_shape on the deduct later reverts the cut too (a multi-cut parent rebuilds from the chain's pristine snapshot minus the survivors). ${COORDS}`,
+    inputSchema: {
+      parent_shape_id: z2.string().describe("A committed floor_area shape id (list_shapes)"),
+      verts: z2.array(pointSchema).min(3).describe("The hole's ring, image px, fully inside the parent")
+    },
+    outputSchema: cutOutOutput
+  }, run("cut_out", (a) => session.cutOut(a)));
   server.registerTool("measure_line", {
     description: `Measure an open polyline (min 2 points, image px): length_lf at the sheet's scale. Requires the scale to be set. Pass condition to commit it as a linear shape (base, transitions, feature strips). ${COORDS}`,
     inputSchema: {
@@ -9586,6 +10066,13 @@ All-or-nothing, like derive_base: an unknown tag, a transition landing on either
     },
     outputSchema: importTakeoffOutput
   }, run("import_takeoff", (a) => importTakeoff(session, a.path)));
+  server.registerTool("apply_rules", {
+    description: `Re-run the correction rules the takeoff arrived with (#207) \u2014 the lessons an estimator TAUGHT the canvas (#88): "every room like this loses the mechanical chase." A rule is a deterministic predicate (enclosed linework islands under a size cap, inside the rule's condition's rooms), never a re-prompt. Evaluation is the same pure rules.ts engine the canvas Preview runs; the commit is the one batch the canvas's Apply makes \u2014 ONE journal entry, undo_last takes the whole batch back. Everything lands reviewed: false (this server has no review gate), and the reply's per-rule disclosure \u2014 what each rule produced, what was skipped, with ids \u2014 IS your preview: read it, then view_sheet overlay:true. Idempotent by construction: any candidate an existing deduct already covers is dropped by the engine, so re-running after new rooms commit is the intended workflow and never double-deducts. Rules arrive ONLY via import_takeoff (minting a new rule is an estimator's correction and stays behind the canvas's human Preview\u2192Apply gate); with none imported this refuses. Pass sheet to scan one sheet; omit it to scan every sheet holding the rules' rooms. Uncalibrated and scanned-raster sheets come back in skipped_sheets, named.`,
+    inputSchema: {
+      sheet: z2.string().optional().describe("Scan only this sheet (default: every sheet holding the rules' conditions' rooms)")
+    },
+    outputSchema: applyRulesOutput
+  }, run("apply_rules", (a) => session.applyRules(a)));
   server.registerTool("export_marked_pdf", {
     description: `The MARKED-UP PLANSET \u2014 the deliverable of every takeoff. Writes a distribution-ready PDF to disk: a legend cover (per-condition totals, swatches, a by-sheet breakdown) followed by every sheet that carries takeoff shapes or annotations, vector-copied from the source plan with the work burned in as drawn \u2014 condition colors and hatches, a quantity chip on every shape, annotation clouds/callouts/highlights, and approval marks (the estimator's APPROVED rings, the agent's AGENT diamonds \u2014 the cover tallies the split). Built by the same module as the canvas's MARKED SET button, so agent output and app output are one implementation. A construction takeoff is no good without markup: finish EVERY takeoff by writing this file and giving the user its path (export_report carries the numbers for pricing; this carries the evidence). When the shapes were machine-traced and unreviewed, the document says so on its last page \u2014 the review path is importing the export_takeoff payload into the app, where agent shapes arrive as pencil proposals. Default path: next to the loaded plan as "<plan> - marked set.pdf". Needs no native canvas \u2014 pure vector copy, so it works even where view_sheet cannot render.`,
     inputSchema: {
@@ -9888,7 +10375,7 @@ function registerResources(server, session) {
 // package.json
 var package_default = {
   name: "opentakeoff-mcp",
-  version: "0.9.35",
+  version: "0.9.38",
   mcpName: "io.github.Kentucky-ai/opentakeoff",
   type: "module",
   description: "OpenTakeoff MCP server \u2014 drive the takeoff engine from your MCP client over stdio.",
@@ -9908,6 +10395,10 @@ var package_default = {
   },
   dependencies: {
     "@modelcontextprotocol/sdk": "^1.12.0",
+    "@turf/boolean-contains": "^7.4.0",
+    "@turf/boolean-overlap": "^7.4.0",
+    "@turf/difference": "^7.4.0",
+    "@turf/helpers": "^7.4.0",
     "pdf-lib": "^1.17.1",
     "pdfjs-dist": "^4.10.38",
     zod: "^3.24.1"
@@ -9917,9 +10408,9 @@ var package_default = {
   },
   devDependencies: {
     "@types/node": "^22.19.21",
-    typescript: "^5.7.2",
+    esbuild: "^0.25.0",
     tsx: "^4.19.2",
-    esbuild: "^0.25.0"
+    typescript: "^5.7.2"
   },
   bin: {
     "opentakeoff-mcp": "dist/server.js"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opentakeoff-mcp",
-  "version": "0.9.35",
+  "version": "0.9.38",
   "mcpName": "io.github.Kentucky-ai/opentakeoff",
   "type": "module",
   "description": "OpenTakeoff MCP server — drive the takeoff engine from your MCP client over stdio.",
@@ -20,6 +20,10 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.0",
+    "@turf/boolean-contains": "^7.4.0",
+    "@turf/boolean-overlap": "^7.4.0",
+    "@turf/difference": "^7.4.0",
+    "@turf/helpers": "^7.4.0",
     "pdf-lib": "^1.17.1",
     "pdfjs-dist": "^4.10.38",
     "zod": "^3.24.1"
@@ -29,9 +33,9 @@
   },
   "devDependencies": {
     "@types/node": "^22.19.21",
-    "typescript": "^5.7.2",
+    "esbuild": "^0.25.0",
     "tsx": "^4.19.2",
-    "esbuild": "^0.25.0"
+    "typescript": "^5.7.2"
   },
   "bin": {
     "opentakeoff-mcp": "dist/server.js"