opentakeoff-mcp 0.9.25 → 0.9.26

package/README.md

@@ -108,8 +108,8 @@ includes document text, shape vertices, or result payload content.
 | `load_plan` | Open a plan PDF from disk. Default replaces the whole session; **`merge: true` ADDS the document to the working set** (#152) — plans + schedule + addenda as one takeoff, sheet graph spanning the whole set, marked set covering every worked sheet. Returns per-sheet dims, title-block `sheet_number`, and the detected drawn scale where present. |
 | `sheet_info` | One sheet's dims, vector segment count, scale status, detected suggestion, committed shape count. |
 | `set_scale` | Set a sheet's scale — exactly one of `label`, `upp`, `calibrate {p1, p2, feet}`, `use_detected`. |
-| `one_click` | One-Click Area at (x, y): flood fill bounded by the plan linework, traced, vertices snapped. 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; `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. 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. |
+| `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. |
 | `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. |

package/dist/server-core.js

@@ -580,6 +580,12 @@ var MIN_THICK_FT = MIN_THICK / CAL_MPPF;
 var MIN_THICK_FLOOR = 2;
 var NUDGE_PX = 3;
 var NUDGE_FT = NUDGE_PX / CAL_MPPF;
+var MIN_PASS_FT = 0.5;
+function minPassRadiusFor(maskPxPerFt) {
+  if (!Number.isFinite(maskPxPerFt) || maskPxPerFt <= 0) return 0;
+  return Math.min(SEAL_R_MAX, Math.round(MIN_PASS_FT * maskPxPerFt / 2));
+}
+var DETERMINISM_MIN_MPPF = 8;
 var SEG_CURVE = 1;
 var SEG_CLIP = 2;
 var SEG_FILLONLY = 4;
@@ -594,9 +600,14 @@ var ARC_CUSP_MIN = 3;
 var ARC_CUSP_R_RATIO = 1.5;
 var ARC_CUSP_SPAN_MULT = 8;
 var MASK_NODOOR_BIT = 8;
+var DOOR_R_MIN_FT = 1.5;
+var DOOR_R_MAX_FT = 4.5;
+var CLUSTER_FIT_TOL_FRAC = 0.05;
+var CLUSTER_FIT_TOL_PX = 1.5;
 var HATCH_ANGLE_TOL = 2;
 var HATCH_MAX_PITCH = 24;
 var HATCH_MAX_PITCH_FT = HATCH_MAX_PITCH / 18;
+var HATCH_TIER_RISK = { bounded: 0, trapped: 1, override: 2 };
 var HATCH_BOUND_FRAC = 0.7;
 var HATCH_ESCALATE_FRAC = 0.02;
 var HATCH_GROWTH_MAX = 2.5;
@@ -1550,18 +1561,6 @@ function bridgedMask(mo, r) {
   }
   return { mask: m, mw: mo.mw, mh: mo.mh, ws: mo.ws, softCount: mo.softCount, mppf: mo.mppf };
 }
-function floodRegion(maskObj, ix, iy, sensitivity = SENS_BALANCED) {
-  const r = floodRegionLadder(maskObj, ix, iy, sensitivity);
-  if (r.status !== "leak") return r;
-  for (let br = 1; br <= GAP_BRIDGE_MAX; br++) {
-    const rb = floodRegionLadder(bridgedMask(maskObj, br), ix, iy, sensitivity);
-    if (rb.status === "ok") {
-      rb.gapBridged = br;
-      return rb;
-    }
-  }
-  return r;
-}
 function floodRegionLadder(maskObj, ix, iy, sensitivity) {
   const r1 = floodPass(maskObj, ix, iy, 3);
   if (!maskObj.softCount) return r1;
@@ -1582,7 +1581,591 @@ function floodRegionLadder(maskObj, ix, iy, sensitivity) {
   }
   return r1;
 }
+var SEAL_RADII = [1, 2, 4];
+var DOOR_SEAL_MAX_FT = 5;
+var SEAL_R_MAX = 128;
+var SEAL_VIRTUAL_MAX = 0.25;
+var SEAL_MAX_SHEET_FRAC = 0.3;
+var VIRTUAL_HUG_PX = 3;
+function sealRadiiFor(maskPxPerFt) {
+  if (!Number.isFinite(maskPxPerFt) || maskPxPerFt <= 0) return SEAL_RADII;
+  const maxR = Math.min(SEAL_R_MAX, Math.ceil(DOOR_SEAL_MAX_FT * maskPxPerFt / 2));
+  const radii = [];
+  for (let r = 1; r < maxR; r *= 2) radii.push(r);
+  radii.push(maxR);
+  return radii;
+}
+var sealCache = /* @__PURE__ */ new WeakMap();
+function hardDT(mask, mw, mh, out) {
+  const dt = out || new Uint8Array(mw * mh).fill(255);
+  for (let y = 0; y < mh; y++) {
+    const row = y * mw;
+    for (let x = 0; x < mw; x++) {
+      const i = row + x;
+      if (mask[i] & 1) {
+        dt[i] = 0;
+        continue;
+      }
+      let d = 255;
+      if (x > 0) d = Math.min(d, dt[i - 1] + 1);
+      if (y > 0) d = Math.min(d, dt[i - mw] + 1);
+      dt[i] = Math.min(255, d);
+    }
+  }
+  for (let y = mh - 1; y >= 0; y--) {
+    const row = y * mw;
+    for (let x = mw - 1; x >= 0; x--) {
+      const i = row + x;
+      let d = dt[i];
+      if (x < mw - 1) d = Math.min(d, dt[i + 1] + 1);
+      if (y < mh - 1) d = Math.min(d, dt[i + mw] + 1);
+      dt[i] = Math.min(255, d);
+    }
+  }
+  return dt;
+}
+function l1ToBox(x, y, bx0, by0, bx1, by1) {
+  const dx = x < bx0 ? bx0 - x : x > bx1 ? x - bx1 : 0;
+  const dy = y < by0 ? by0 - y : y > by1 ? y - by1 : 0;
+  return dx + dy;
+}
+function dtDirtyWindow(cl, mw, mh, dt) {
+  let cx0 = mw, cy0 = mh, cx1 = -1, cy1 = -1;
+  for (const i of cl) {
+    const y = i / mw | 0, x = i - y * mw;
+    if (x < cx0) cx0 = x;
+    if (x > cx1) cx1 = x;
+    if (y < cy0) cy0 = y;
+    if (y > cy1) cy1 = y;
+  }
+  if (cx1 < 0) return null;
+  for (let w = 16; ; w *= 2) {
+    const x0 = cx0 - w, y0 = cy0 - w, x1 = cx1 + w, y1 = cy1 + w;
+    if (x0 <= 0 && y0 <= 0 && x1 >= mw - 1 && y1 >= mh - 1) return null;
+    const clear = (x, y) => x < 0 || y < 0 || x >= mw || y >= mh || dt[y * mw + x] < l1ToBox(x, y, cx0, cy0, cx1, cy1);
+    let ok2 = true;
+    for (let x = x0 - 1; x <= x1 + 1 && ok2; x++) ok2 = clear(x, y0 - 1) && clear(x, y1 + 1);
+    for (let y = y0; y <= y1 && ok2; y++) ok2 = clear(x0 - 1, y) && clear(x1 + 1, y);
+    if (ok2) return { x0: Math.max(0, x0), y0: Math.max(0, y0), x1: Math.min(mw - 1, x1), y1: Math.min(mh - 1, y1) };
+  }
+}
+function hardDTWindow(mask, mw, mh, dt, b) {
+  for (let y = b.y0; y <= b.y1; y++) {
+    const row = y * mw;
+    for (let x = b.x0; x <= b.x1; x++) {
+      const i = row + x;
+      if (mask[i] & 1) {
+        dt[i] = 0;
+        continue;
+      }
+      let d = 255;
+      if (x > 0) d = Math.min(d, dt[i - 1] + 1);
+      if (y > 0) d = Math.min(d, dt[i - mw] + 1);
+      dt[i] = Math.min(255, d);
+    }
+  }
+  for (let y = b.y1; y >= b.y0; y--) {
+    const row = y * mw;
+    for (let x = b.x1; x >= b.x0; x--) {
+      const i = row + x;
+      let d = dt[i];
+      if (x < mw - 1) d = Math.min(d, dt[i + 1] + 1);
+      if (y < mh - 1) d = Math.min(d, dt[i + mw] + 1);
+      dt[i] = Math.min(255, d);
+    }
+  }
+}
+function dilatedView(mo, r, dt) {
+  return { mask: mo.mask, mw: mo.mw, mh: mo.mh, ws: mo.ws, softCount: mo.softCount, mppf: mo.mppf, dilDT: dt, dilR: r };
+}
+function growRegionBack(f, orig, r, barrier, dt) {
+  const { region, mw, mh } = f;
+  const mask = orig.mask;
+  const b = boxOf(region, mw, mh);
+  regionBox.set(region, b);
+  let frontier = [];
+  for (let y = b.y0; y <= b.y1; y++) {
+    const row = y * mw;
+    for (let x = b.x0; x <= b.x1; x++) {
+      const i = row + x;
+      if (!region[i]) continue;
+      if (x > 0 && !region[i - 1] || x < mw - 1 && !region[i + 1] || y > 0 && !region[i - mw] || y < mh - 1 && !region[i + mw]) frontier.push(i);
+    }
+  }
+  const tryGrow = (from, to, next) => {
+    if (!region[to] && !(mask[to] & barrier) && dt[to] <= r && dt[to] <= dt[from]) {
+      region[to] = 1;
+      f.count++;
+      next.push(to);
+      const y = to / mw | 0, x = to - y * mw;
+      if (x < b.x0) b.x0 = x;
+      if (x > b.x1) b.x1 = x;
+      if (y < b.y0) b.y0 = y;
+      if (y > b.y1) b.y1 = y;
+    }
+  };
+  while (frontier.length) {
+    const next = [];
+    for (const i of frontier) {
+      const x = i % mw, y = i / mw | 0;
+      if (x > 0) tryGrow(i, i - 1, next);
+      if (x < mw - 1) tryGrow(i, i + 1, next);
+      if (y > 0) tryGrow(i, i - mw, next);
+      if (y < mh - 1) tryGrow(i, i + mw, next);
+    }
+    frontier = next;
+  }
+}
+var WEDGE_SLACK = 1.3;
+var WEDGE_GROWTH_FRAC = 0.3;
+var WEDGE_MAX_DOORS = 12;
+function doorWedgeCapPx(maskPxPerFt) {
+  if (!Number.isFinite(maskPxPerFt) || maskPxPerFt <= 0) return 0;
+  return Math.round(Math.PI / 4 * (DOOR_SEAL_MAX_FT * maskPxPerFt) ** 2 * WEDGE_SLACK);
+}
+function boundaryCurveClusters(mo, region) {
+  const { mw, mh } = mo;
+  const src = mo.mask;
+  const near = [];
+  const b = boxOf(region, mw, mh);
+  const y0 = Math.max(0, b.y0 - 3), y1 = Math.min(mh - 1, b.y1 + 3);
+  const x0 = Math.max(0, b.x0 - 3), x1 = Math.min(mw - 1, b.x1 + 3);
+  for (let y = y0; y <= y1; y++) {
+    const row = y * mw;
+    for (let x = x0; x <= x1; x++) {
+      const i = row + x;
+      if (!(src[i] & MASK_CURVE_BIT)) continue;
+      let n = false;
+      for (let dy = -3; dy <= 3 && !n; dy++) {
+        const ny = y + dy;
+        if (ny < 0 || ny >= mh) continue;
+        for (let dx = -3; dx <= 3; dx++) {
+          const nx = x + dx;
+          if (nx >= 0 && nx < mw && region[ny * mw + nx]) {
+            n = true;
+            break;
+          }
+        }
+      }
+      if (n) near.push(i);
+    }
+  }
+  const clusters = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const s of near) {
+    if (seen.has(s)) continue;
+    const cl = [];
+    const stack = [s];
+    seen.add(s);
+    while (stack.length) {
+      const i = stack.pop();
+      cl.push(i);
+      const x = i % mw, y = i / mw | 0;
+      for (let dy = -3; dy <= 3; dy++) {
+        const ny = y + dy;
+        if (ny < 0 || ny >= mh) continue;
+        for (let dx = -3; dx <= 3; dx++) {
+          const nx = x + dx;
+          if (nx < 0 || nx >= mw) continue;
+          const j = ny * mw + nx;
+          if (!seen.has(j) && src[j] & MASK_CURVE_BIT) {
+            seen.add(j);
+            stack.push(j);
+          }
+        }
+      }
+    }
+    clusters.push(cl);
+  }
+  return clusters;
+}
+function arcClusterFit(cl, mw, mask) {
+  const m = cl.length;
+  const X = (i) => i % mw, Y = (i) => i / mw | 0;
+  let mx = 0, my = 0, noDoor = 0;
+  for (const i of cl) {
+    mx += X(i);
+    my += Y(i);
+    if (mask[i] & MASK_NODOOR_BIT) noDoor++;
+  }
+  mx /= m;
+  my /= m;
+  let sxx = 0, sxy = 0, syy = 0, sxz = 0, syz = 0;
+  for (const i of cl) {
+    const x = X(i) - mx, y = Y(i) - my, z3 = x * x + y * y;
+    sxx += x * x;
+    sxy += x * y;
+    syy += y * y;
+    sxz += x * z3;
+    syz += y * z3;
+  }
+  const tr = sxx + syy, dsc = Math.sqrt(Math.max(0, ((sxx - syy) / 2) ** 2 + sxy * sxy));
+  const l1 = tr / 2 + dsc;
+  let ux = sxy, uy = l1 - sxx;
+  if (Math.hypot(ux, uy) < 1e-9) {
+    ux = 1;
+    uy = 0;
+  } else {
+    const L = Math.hypot(ux, uy);
+    ux /= L;
+    uy /= L;
+  }
+  let u0 = Infinity, u1 = -Infinity, n0 = Infinity, n1 = -Infinity;
+  for (const i of cl) {
+    const x = X(i) - mx, y = Y(i) - my;
+    const a = x * ux + y * uy, b = -x * uy + y * ux;
+    if (a < u0) u0 = a;
+    if (a > u1) u1 = a;
+    if (b < n0) n0 = b;
+    if (b > n1) n1 = b;
+  }
+  const bu = u1 - u0 + 1, bn = n1 - n0 + 1;
+  const base = { cx: mx, cy: my, r: 0, rms: Infinity, good: false, sweep: 0, noDoorFrac: noDoor / m, bu, bn, buH: bu, bnH: bn };
+  const det = sxx * syy - sxy * sxy;
+  if (m < ARC_MIN_CHORDS || Math.abs(det) < 1e-9) return base;
+  const cx = (sxz * syy - syz * sxy) / (2 * det), cy = (syz * sxx - sxz * sxy) / (2 * det);
+  let r = 0;
+  for (const i of cl) r += Math.hypot(X(i) - mx - cx, Y(i) - my - cy);
+  r /= m;
+  if (!(r > 0)) return base;
+  let s2 = 0;
+  const angs = [];
+  for (const i of cl) {
+    const dx = X(i) - mx - cx, dy = Y(i) - my - cy;
+    const d = Math.hypot(dx, dy) - r;
+    s2 += d * d;
+    angs.push(Math.atan2(dy, dx));
+  }
+  const rms = Math.sqrt(s2 / m);
+  angs.sort((a, b) => a - b);
+  let gap = angs[0] + 2 * Math.PI - angs[angs.length - 1];
+  for (let k = 1; k < angs.length; k++) if (angs[k] - angs[k - 1] > gap) gap = angs[k] - angs[k - 1];
+  const hu = cx * ux + cy * uy, hn = -cx * uy + cy * ux;
+  return {
+    ...base,
+    cx: cx + mx,
+    cy: cy + my,
+    r,
+    rms,
+    good: rms <= Math.max(CLUSTER_FIT_TOL_PX, CLUSTER_FIT_TOL_FRAC * r),
+    sweep: Math.max(0, 2 * Math.PI - gap),
+    buH: Math.max(u1, hu) - Math.min(u0, hu) + 1,
+    bnH: Math.max(n1, hn) - Math.min(n0, hn) + 1
+  };
+}
 var WEDGE_RIM_FT = 3 / CAL_MPPF;
+function wedgeRimPx(maskPxPerFt) {
+  if (!Number.isFinite(maskPxPerFt) || maskPxPerFt <= 0) return 3;
+  return Math.max(3, Math.round(WEDGE_RIM_FT * maskPxPerFt));
+}
+function wedgeAllowance(fit, mppf, wedgeCapPx) {
+  if (fit.noDoorFrac > 0.5 && !fit.good) return 0;
+  if (fit.good && mppf > 0 && fit.r / mppf > DOOR_R_MAX_FT) return 0;
+  const rim = wedgeRimPx(mppf);
+  const bu = fit.good ? fit.buH : fit.bu, bn = fit.good ? fit.bnH : fit.bn;
+  let area = bu * bn;
+  if (fit.good) area = Math.min(area, 0.5 * fit.sweep * fit.r * fit.r);
+  area += 2 * rim * (bu + bn) + 4 * rim * rim;
+  return Math.min(2 * wedgeCapPx, Math.round(area * WEDGE_SLACK));
+}
+function doorLikeness(fit, mppf) {
+  let s = 1 - fit.noDoorFrac;
+  const swDeg = fit.sweep * 180 / Math.PI;
+  if (fit.good) {
+    s += 1;
+    if (mppf > 0 && fit.r / mppf >= DOOR_R_MIN_FT && fit.r / mppf <= DOOR_R_MAX_FT) s += 4;
+    if (swDeg >= 45 && swDeg <= 190) s += 2;
+  }
+  return s;
+}
+function ascendSeed(dt, mw, mh, ws, ix, iy, r) {
+  let cx = Math.max(0, Math.min(mw - 1, Math.round(ix * ws)));
+  let cy = Math.max(0, Math.min(mh - 1, Math.round(iy * ws)));
+  for (let step = 0; step < 2 * r && dt[cy * mw + cx] <= r; step++) {
+    let bx = cx, by = cy, bd = dt[cy * mw + cx];
+    if (cx > 0 && dt[cy * mw + cx - 1] > bd) {
+      bd = dt[cy * mw + cx - 1];
+      bx = cx - 1;
+      by = cy;
+    }
+    if (cx < mw - 1 && dt[cy * mw + cx + 1] > bd) {
+      bd = dt[cy * mw + cx + 1];
+      bx = cx + 1;
+      by = cy;
+    }
+    if (cy > 0 && dt[(cy - 1) * mw + cx] > bd) {
+      bd = dt[(cy - 1) * mw + cx];
+      bx = cx;
+      by = cy - 1;
+    }
+    if (cy < mh - 1 && dt[(cy + 1) * mw + cx] > bd) {
+      bd = dt[(cy + 1) * mw + cx];
+      bx = cx;
+      by = cy + 1;
+    }
+    if (bx === cx && by === cy) break;
+    cx = bx;
+    cy = by;
+  }
+  return [cx / ws, cy / ws];
+}
+function sealAttempt(mo, ix, iy, sensitivity, radii, minPassPx = 0, given) {
+  const scratch = () => {
+    if (given) return given;
+    let s = sealCache.get(mo.mask);
+    if (!s) {
+      s = { dt: hardDT(mo.mask, mo.mw, mo.mh) };
+      sealCache.set(mo.mask, s);
+    }
+    return s;
+  };
+  let raw = null;
+  const rawFlood = () => raw ??= floodRegionLadder(mo, ix, iy, sensitivity);
+  let leakedR = 0;
+  const cx = Math.max(0, Math.min(mo.mw - 1, Math.round(ix * mo.ws)));
+  const cy = Math.max(0, Math.min(mo.mh - 1, Math.round(iy * mo.ws)));
+  const cSoft = (mo.mask[cy * mo.mw + cx] & 2) !== 0;
+  const cdt = (s) => cSoft ? 0 : s.dt[cy * mo.mw + cx];
+  if (minPassPx > 0) {
+    const s = scratch();
+    const dm = dilatedView(mo, minPassPx, s.dt);
+    const [ax, ay] = ascendSeed(s.dt, mo.mw, mo.mh, mo.ws, ix, iy, minPassPx);
+    const f = floodRegionLadder(dm, ax, ay, sensitivity);
+    if (f.status === "leak" && minPassPx > leakedR && cdt(s) > minPassPx) leakedR = minPassPx;
+    if (f.status === "ok") {
+      growRegionBack(f, mo, minPassPx, f.hatchFiltered ? 1 : 3, s.dt);
+      const r0 = rawFlood();
+      if (r0.status === "ok" && r0.count > 0) {
+        const d = +(1 - f.count / r0.count).toFixed(4);
+        if (d > 0) {
+          f.minPassPx = minPassPx;
+          f.minPassDelta = d;
+        }
+        return f;
+      }
+      const vf = f.count > f.mw * f.mh * SEAL_MAX_SHEET_FRAC ? 1 : virtualBoundaryFrac(f, s.dt);
+      if (vf <= SEAL_VIRTUAL_MAX) {
+        f.minPassPx = minPassPx;
+        f.minPassDelta = 1;
+        f.sealedPx = minPassPx;
+        f.virtualFrac = +vf.toFixed(3);
+        return f;
+      }
+    }
+  }
+  const base = rawFlood();
+  if (base.status === "ok") return base;
+  const sc = scratch();
+  for (const r of radii) {
+    if (r <= minPassPx) continue;
+    const dm = dilatedView(mo, r, sc.dt);
+    const [ax, ay] = ascendSeed(sc.dt, mo.mw, mo.mh, mo.ws, ix, iy, r);
+    const f = floodRegionLadder(dm, ax, ay, sensitivity);
+    if (f.status !== "ok") {
+      if (f.status === "leak" && r > leakedR && cdt(sc) > r) leakedR = r;
+      continue;
+    }
+    growRegionBack(f, mo, r, f.hatchFiltered ? 1 : 3, sc.dt);
+    if (f.count > f.mw * f.mh * SEAL_MAX_SHEET_FRAC) continue;
+    const vf = virtualBoundaryFrac(f, sc.dt);
+    if (vf > SEAL_VIRTUAL_MAX) continue;
+    f.sealedPx = r;
+    f.virtualFrac = +vf.toFixed(3);
+    return f;
+  }
+  if (base.status === "leak" && leakedR > 0) base.leakedDilationPx = leakedR;
+  return base;
+}
+function floodRegionSealed(mo, ix, iy, sensitivity = SENS_BALANCED, radii = SEAL_RADII, wedgeCapPx = 0, minPassPx = 0) {
+  const out = floodRegionSealedInner(mo, ix, iy, sensitivity, radii, wedgeCapPx, minPassPx);
+  if (out.status === "ok") {
+    const cf = curveBoundaryFrac(out, mo);
+    if (cf > 0) out.curveFrac = +cf.toFixed(3);
+  }
+  return out;
+}
+function floodRegionSealedInner(mo, ix, iy, sensitivity, radii, wedgeCapPx, minPassPx) {
+  const r1 = sealAttempt(mo, ix, iy, sensitivity, radii, minPassPx);
+  if (r1.status === "leak") {
+    const futileBelowPx = (r1.leakedDilationPx ?? 0) >> 1;
+    for (let br = 1; br <= GAP_BRIDGE_MAX; br++) {
+      if (br <= futileBelowPx) continue;
+      const rb = floodRegionLadder(bridgedMask(mo, br), ix, iy, sensitivity);
+      if (rb.status === "ok") {
+        rb.gapBridged = br;
+        return rb;
+      }
+    }
+  }
+  if (!wedgeCapPx || r1.status !== "ok") return r1;
+  const clusters = boundaryCurveClusters(mo, r1.region);
+  if (!clusters.length) return r1;
+  const globalAllowance = Math.max(wedgeCapPx, Math.min(Math.round(r1.count * WEDGE_GROWTH_FRAC), WEDGE_MAX_DOORS * wedgeCapPx));
+  const { mw, mh } = mo;
+  let region = null;
+  let count = r1.count;
+  let wedges = 0, ringWedges = 0;
+  let hatchFiltered = !!r1.hatchFiltered;
+  let hatchTier = r1.hatchTier;
+  let sealedPx = r1.sealedPx, virtualFrac = r1.virtualFrac;
+  let minPassPxOut = r1.minPassPx, minPassDelta = r1.minPassDelta;
+  const ranked = clusters.map((cl) => {
+    const fit = arcClusterFit(cl, mw, mo.mask);
+    return { cl, fit, allow: wedgeAllowance(fit, mo.mppf || 0, wedgeCapPx), rank: doorLikeness(fit, mo.mppf || 0), at: cl[0] };
+  }).filter((c) => c.allow >= 1).sort((a, b) => b.rank - a.rank || a.at - b.at);
+  let m2mask = null, m2dt = null;
+  let openedCl = null, dirty = null;
+  const rb1 = boxOf(r1.region, mw, mh);
+  let base = sealCache.get(mo.mask);
+  if (!base) {
+    base = { dt: hardDT(mo.mask, mw, mh) };
+    sealCache.set(mo.mask, base);
+  }
+  const baseDT = base.dt;
+  for (const { cl, fit, allow: clusterAllowance } of ranked.slice(0, WEDGE_MAX_DOORS)) {
+    if (!m2mask) {
+      m2mask = mo.mask.slice();
+      m2dt = baseDT.slice();
+    } else {
+      if (openedCl) for (const i of openedCl) m2mask[i] = mo.mask[i];
+      if (dirty) for (let y = dirty.y0; y <= dirty.y1; y++) {
+        const r = y * mw;
+        m2dt.set(baseDT.subarray(r + dirty.x0, r + dirty.x1 + 1), r + dirty.x0);
+      }
+      else m2dt.set(baseDT);
+    }
+    for (const i of cl) m2mask[i] = m2mask[i] & ~1;
+    openedCl = cl;
+    const m2 = { mask: m2mask, mw, mh, ws: mo.ws, softCount: mo.softCount, mppf: mo.mppf };
+    dirty = dtDirtyWindow(cl, mw, mh, baseDT);
+    if (dirty) hardDTWindow(m2mask, mw, mh, m2dt, dirty);
+    else hardDT(m2mask, mw, mh, m2dt);
+    const sc2 = { dt: m2dt };
+    let bi = -1, bd = -1;
+    for (let y = rb1.y0; y <= rb1.y1; y++) {
+      const row = y * mw;
+      for (let x = rb1.x0; x <= rb1.x1; x++) {
+        const i = row + x;
+        if (r1.region[i] && sc2.dt[i] > bd) {
+          bd = sc2.dt[i];
+          bi = i;
+        }
+      }
+    }
+    const sx = bi < 0 ? ix : bi % mw / mo.ws, sy = bi < 0 ? iy : Math.floor(bi / mw) / mo.ws;
+    const r2 = sealAttempt(m2, sx, sy, sensitivity, radii, minPassPx, sc2);
+    if (r2.status !== "ok" || r2.count <= r1.count) continue;
+    const growth = r2.count - r1.count;
+    if (growth > clusterAllowance) continue;
+    if (count - r1.count + growth > globalAllowance) continue;
+    if (!region) {
+      region = r1.region.slice();
+      regionBox.set(region, { ...rb1 });
+    }
+    const rb = regionBox.get(region), b2 = boxOf(r2.region, mw, mh);
+    for (let y = b2.y0; y <= b2.y1; y++) {
+      const row = y * mw;
+      for (let x = b2.x0; x <= b2.x1; x++) {
+        const i = row + x;
+        if (r2.region[i] && !region[i]) {
+          region[i] = 1;
+          count++;
+          if (x < rb.x0) rb.x0 = x;
+          if (x > rb.x1) rb.x1 = x;
+          if (y < rb.y0) rb.y0 = y;
+          if (y > rb.y1) rb.y1 = y;
+        }
+      }
+    }
+    wedges++;
+    if (fit.noDoorFrac > 0.5 && fit.good) ringWedges++;
+    if (r2.hatchFiltered) hatchFiltered = true;
+    if (r2.hatchTier && HATCH_TIER_RISK[r2.hatchTier] > (hatchTier ? HATCH_TIER_RISK[hatchTier] : -1)) hatchTier = r2.hatchTier;
+    if (r2.sealedPx && (!sealedPx || r2.sealedPx > sealedPx)) sealedPx = r2.sealedPx;
+    if (r2.virtualFrac != null && (virtualFrac == null || r2.virtualFrac > virtualFrac)) virtualFrac = r2.virtualFrac;
+    if (r2.minPassPx && (!minPassPxOut || r2.minPassPx > minPassPxOut)) minPassPxOut = r2.minPassPx;
+    if (r2.minPassDelta != null && (minPassDelta == null || r2.minPassDelta > minPassDelta)) minPassDelta = r2.minPassDelta;
+  }
+  if (!wedges || !region) return r1;
+  const out = {
+    status: "ok",
+    region,
+    count,
+    mw,
+    mh,
+    ws: r1.ws,
+    mppf: r1.mppf,
+    hardHits: r1.hardHits,
+    softHits: r1.softHits,
+    hatchFiltered: hatchFiltered || void 0,
+    hatchTier,
+    sealedPx,
+    virtualFrac,
+    minPassPx: minPassPxOut,
+    minPassDelta,
+    ...ringWedges ? { ringWedges } : {}
+  };
+  const reg = region, reg1 = r1.region, mask = mo.mask;
+  const isDelta = (i) => reg[i] && !reg1[i];
+  const rbA = boxOf(reg, mw, mh);
+  const ay0 = Math.max(1, rbA.y0), ay1 = Math.min(mh - 2, rbA.y1);
+  const ax0 = Math.max(1, rbA.x0), ax1 = Math.min(mw - 2, rbA.x1);
+  for (let pass = 0; pass < 2; pass++) {
+    for (let y = ay0; y <= ay1; y++) {
+      const row = y * mw;
+      for (let x = ax0; x <= ax1; x++) {
+        const i = row + x;
+        if (reg[i] || !(mask[i] & 1)) continue;
+        const pinchH = reg[i - 1] && reg[i + 1], pinchV = reg[i - mw] && reg[i + mw];
+        if (pinchH && (isDelta(i - 1) || isDelta(i + 1)) || pinchV && (isDelta(i - mw) || isDelta(i + mw))) {
+          reg[i] = 1;
+          out.count++;
+        }
+      }
+    }
+  }
+  out.wedges = wedges;
+  out.wedgeGrowth = +(out.count / r1.count).toFixed(3);
+  return out;
+}
+function virtualBoundaryFrac(f, dt) {
+  const { region, mw, mh } = f;
+  const b = boxOf(region, mw, mh);
+  let boundary = 0, virtual = 0;
+  for (let y = b.y0; y <= b.y1; y++) {
+    const row = y * mw;
+    for (let x = b.x0; x <= b.x1; x++) {
+      const i = row + x;
+      if (!region[i]) continue;
+      if (x > 0 && !region[i - 1] || x < mw - 1 && !region[i + 1] || y > 0 && !region[i - mw] || y < mh - 1 && !region[i + mw]) {
+        boundary++;
+        if (dt[i] > VIRTUAL_HUG_PX) virtual++;
+      }
+    }
+  }
+  return boundary ? virtual / boundary : 1;
+}
+function curveBoundaryFrac(f, mo) {
+  const { region, mw, mh } = f;
+  const mask = mo.mask;
+  const b = boxOf(region, mw, mh);
+  let boundary = 0, curved = 0;
+  for (let y = b.y0; y <= b.y1; y++) {
+    const row = y * mw;
+    for (let x = b.x0; x <= b.x1; x++) {
+      const i = row + x;
+      if (!region[i]) continue;
+      const w = x > 0 ? i - 1 : -1, e = x < mw - 1 ? i + 1 : -1, n = y > 0 ? i - mw : -1, s = y < mh - 1 ? i + mw : -1;
+      if (!(w >= 0 && !region[w] || e >= 0 && !region[e] || n >= 0 && !region[n] || s >= 0 && !region[s])) continue;
+      boundary++;
+      for (const j of [w, e, n, s]) if (j >= 0 && !region[j] && mask[j] & MASK_CURVE_BIT) {
+        curved++;
+        break;
+      }
+    }
+  }
+  return boundary ? curved / boundary : 0;
+}
 function traceRegion(reg, epsMaskPx = 1.5) {
   const { region, mw, mh, ws } = reg;
   let s = -1;
@@ -1682,6 +2265,20 @@ function ringArea(pts) {
 
 // ../web/src/lib/detectRooms.ts
 var ROOM_LABEL_RE = /^\d{2,3}[A-Z]?$/;
+function oneClickArgs(maskPxPerFt) {
+  const mppf = Number.isFinite(maskPxPerFt) && maskPxPerFt > 0 ? maskPxPerFt : 0;
+  return {
+    mppf,
+    scaleBlind: mppf <= 0,
+    radii: sealRadiiFor(mppf),
+    wedgeCapPx: doorWedgeCapPx(mppf),
+    minPassPx: minPassRadiusFor(mppf)
+  };
+}
+function floodAtSeed(maskObj, ix, iy, sensitivity = SENS_BALANCED, maskPxPerFt = maskObj.mppf || 0) {
+  const a = oneClickArgs(maskPxPerFt);
+  return floodRegionSealed(maskObj, ix, iy, sensitivity, a.radii, a.wedgeCapPx, a.minPassPx);
+}
 var BUBBLE_RATIO = 2.5;
 function seedLadderPx(b, first = "anchor") {
   const cx = (b.x0 + b.x1) / 2, cy = (b.y0 + b.y1) / 2;
@@ -2231,6 +2828,82 @@ var fail = (err) => ({
 var round2 = (n) => +n.toFixed(2);
 var round1 = (n) => +n.toFixed(1);
 
+// ../web/src/lib/confidence.ts
+var CONF_RASTER = 0.9;
+var CONF_HATCH = 0.95;
+var CONF_HATCH_TIER = { bounded: CONF_HATCH, trapped: 0.93, override: 0.85 };
+var CONF_WEDGE = 0.97;
+var WEDGE_ANNEX_REF = 0.1;
+var CONF_COARSE = 0.9;
+var CONF_MINPASS = 0.99;
+var CONF_MINPASS_SOLE = 0.85;
+var CONF_CURVE_K = 0.5;
+var ROOM_PLAUSIBLE_SF = 5e3;
+var ROOM_ABSURD_SF = 5e4;
+var CONF_OVERSIZE_MAX = 0.35;
+var SEAL_VIRTUAL_DEFAULT = 0.1;
+var clamp = (v, lo, hi) => Math.min(Math.max(v, lo), hi);
+function floodSignals(f, opts = {}) {
+  return {
+    raster: opts.raster,
+    hatchFiltered: f.hatchFiltered,
+    hatchTier: f.hatchTier,
+    sealedPx: f.sealedPx,
+    virtualFrac: f.virtualFrac,
+    wedges: f.wedges,
+    wedgeGrowth: f.wedgeGrowth,
+    curveFrac: f.curveFrac,
+    minPassPx: f.minPassPx,
+    minPassDelta: f.minPassDelta,
+    areaSF: opts.areaSF,
+    mppf: f.mppf ?? opts.mppf
+  };
+}
+function traceConfidence(s) {
+  let score = 1;
+  const factors = [];
+  if (s.raster) {
+    score *= CONF_RASTER;
+    factors.push("raster-traced");
+  }
+  if (s.hatchFiltered) {
+    const tier = s.hatchTier ?? "bounded";
+    score *= CONF_HATCH_TIER[tier];
+    factors.push(`hatch-filtered(${tier})`);
+  }
+  if (s.sealedPx) {
+    const vf = typeof s.virtualFrac === "number" ? clamp(s.virtualFrac, 0, 0.25) : SEAL_VIRTUAL_DEFAULT;
+    score *= 1 - vf;
+    factors.push(`sealed-opening(${Math.round(vf * 100)}% synthetic boundary)`);
+  }
+  if (s.minPassDelta) {
+    const sole = s.minPassDelta >= 1;
+    score *= sole ? CONF_MINPASS_SOLE : CONF_MINPASS;
+    factors.push(sole ? "undecidable-passage(the drawn linework does not enclose this space)" : `min-passage-rule(${(s.minPassDelta * 100).toFixed(1)}% of the verbatim flood removed)`);
+  }
+  if (s.wedges) {
+    const annex = typeof s.wedgeGrowth === "number" && s.wedgeGrowth > 1 ? (s.wedgeGrowth - 1) / s.wedgeGrowth : void 0;
+    const w = annex === void 0 ? 1 : clamp(annex / WEDGE_ANNEX_REF, 0, 1);
+    score *= 1 - (1 - CONF_WEDGE) * w;
+    factors.push(annex === void 0 ? "door-swing-crossed" : `door-swing-crossed(${(annex * 100).toFixed(1)}% annexed swing)`);
+  }
+  if (s.curveFrac) {
+    const cf = clamp(s.curveFrac, 0, 1);
+    score *= 1 - CONF_CURVE_K * cf;
+    factors.push(`curve-bounded(${Math.round(cf * 100)}% of the boundary)`);
+  }
+  if (typeof s.areaSF === "number" && s.areaSF > ROOM_PLAUSIBLE_SF) {
+    const over = clamp((s.areaSF - ROOM_PLAUSIBLE_SF) / (ROOM_ABSURD_SF - ROOM_PLAUSIBLE_SF), 0, 1);
+    score *= 1 - CONF_OVERSIZE_MAX * over;
+    factors.push(`oversize-for-one-room(${Math.round(s.areaSF).toLocaleString("en-US")} SF)`);
+  }
+  if (typeof s.mppf === "number" && s.mppf > 0 && s.mppf < DETERMINISM_MIN_MPPF) {
+    score *= CONF_COARSE;
+    factors.push("coarse-mask");
+  }
+  return { score: +score.toFixed(2), factors };
+}
+
 // ../web/src/lib/rastermask.ts
 var RASTER_MIN_IMG_FRAC = 0.1;
 var RASTER_MIN_SEGS = 500;
@@ -3844,15 +4517,41 @@ var Session = class _Session {
     }
     return segRoles(geo.layerOf, layerRoleCodes(geo.layerIds, infoById));
   }
+  /** The vector mask, built through buildMask's FULL scale-pinned signature
+   * (RFC #60 / PR #179 — the canvas's ensureMask, verbatim in intent):
+   * `pxPerFt` (the sheet scale as image px per foot) rides INTO the mask, so
+   * the hatch pitch cap, the seal radii, door-wedge caps and the minimum-
+   * passage rule are all feet-true through `mask.mppf` instead of guessing in
+   * raster px; the `page` pin (audit A1/F3) makes the working grid a property
+   * of the SHEET in points, never of a render. This server renders at the
+   * canvas BASELINE (RENDER_SCALE) always, so renderScale === baseScale and
+   * basePxPerFt === pxPerFt — the one degenerate case where the pin and the
+   * legacy reconstruction agree bit-for-bit. */
+  buildVectorMask(s, geo, layersOpt) {
+    if (!geo.segs.length) return null;
+    const pxPerFt = s.upp ? 1 / s.upp : 0;
+    return buildMask(
+      geo.segs,
+      s.widthPx,
+      s.heightPx,
+      MASK_MAX_DIM,
+      geo.meta,
+      pxPerFt,
+      pxPerFt,
+      { pageW: s.widthPt, pageH: s.heightPt, renderScale: RENDER_SCALE, baseScale: RENDER_SCALE },
+      this.rolesFor(s, geo, layersOpt)
+    );
+  }
   /** v1 masks come from the sheet's vector linework only; a scanned sheet
    * (zero segments) is null here and the measuring tools fall back to
    * ensureRasterMask (#154). Layer roles (#85) ride in as the stated
-   * short-circuit; an unlayered sheet builds the identical pre-#85 mask. */
+   * short-circuit; an unlayered sheet builds the identical pre-#85 mask.
+   * The cached mask BAKES THE SCALE IN (mppf) — set_scale evicts it. */
   async ensureMask(name) {
     const s = this.sheet(name);
     if (s.mask === void 0) {
       const geo = await this.ensureGeometry(s);
-      s.mask = geo.segs.length ? buildMask(geo.segs, s.widthPx, s.heightPx, MASK_MAX_DIM, geo.meta, this.rolesFor(s, geo)) : null;
+      s.mask = this.buildVectorMask(s, geo);
     }
     return s.mask;
   }
@@ -3863,16 +4562,18 @@ var Session = class _Session {
     if (!layersOpt || !layersOpt.include?.length && !layersOpt.exclude?.length) return this.ensureMask(name);
     const s = this.sheet(name);
     const geo = await this.ensureGeometry(s);
-    if (!geo.segs.length) return null;
-    return buildMask(geo.segs, s.widthPx, s.heightPx, MASK_MAX_DIM, geo.meta, this.rolesFor(s, geo, layersOpt));
+    return this.buildVectorMask(s, geo, layersOpt);
   }
   /** The raster-fallback mask (#154): a dedicated render of the sheet at mask
    * scale (the view_sheet machinery — pdf.ts + @napi-rs/canvas), thresholded
    * by the canvas's own rastermask engine into the same MaskObj shape
-   * buildMask emits, so floodRegion/traceRegion run unchanged on scans.
-   * Cached per sheet like geo/mask; where the optional native canvas never
-   * installed, renderRgba throws its plain install-hint Error and the tool
-   * reply carries it — a stated inability, never a guessed polygon. */
+   * buildMask emits, so the sealed flood (floodAtSeed) and traceRegion run
+   * unchanged on scans. It carries NO mppf of its own (pixels cannot know
+   * the sheet scale), so flood call sites pass mask px per foot explicitly —
+   * ws / upp, the canvas's own raster-path convention — and set_scale evicts
+   * this cache alongside the vector mask. Where the optional native canvas
+   * never installed, renderRgba throws its plain install-hint Error and the
+   * tool reply carries it — a stated inability, never a guessed polygon. */
   async ensureRasterMask(s) {
     if (!s.rmask) {
       const ws = Math.min(1, MASK_MAX_DIM / Math.max(s.widthPx, s.heightPx, 1));
@@ -3955,6 +4656,10 @@ var Session = class _Session {
     } else {
       throw new UserError("Provide exactly one of: label, upp, calibrate, use_detected.");
     }
+    if (s.upp !== upp) {
+      s.mask = void 0;
+      s.rmask = void 0;
+    }
     s.upp = upp;
     s.scaleSource = source === "label" ? "standard" : source === "calibrate" ? "calibrated" : source;
     return {
@@ -4003,7 +4708,43 @@ var Session = class _Session {
     }
     return c;
   }
-  commit(s, tag, role, vertsPx, computed, origin) {
+  /** Slim flood evidence — the engine result's SCALAR signals, harvested the
+   * moment the flood returns so a batch sweep never pins N mask-sized region
+   * bitmaps just to score confidence at commit time. `signals` goes through
+   * floodSignals, THE adapter (audit A2: hand-listed signal fields are how an
+   * engine emission goes silently inert); gapBridged/ringWedges ride beside
+   * it because they are provenance the adapter does not carry. */
+  static floodEvidence(f, raster, mppf) {
+    return {
+      signals: floodSignals(f, { raster, mppf }),
+      raster,
+      ...f.gapBridged ? { gapBridged: f.gapBridged } : {},
+      ...f.ringWedges ? { ringWedges: f.ringWedges } : {}
+    };
+  }
+  /** THE flood → provenance mapping (the canvas Create gate's field set,
+   * TakeoffCanvas commitOneClickRegions). One function, spread into the
+   * committed origin by commit() and into the tool reply by the flood call
+   * sites, so the two surfaces cannot drift and no site hand-lists fields. */
+  static floodStamp(ev, areaSF) {
+    const conf = traceConfidence({ ...ev.signals, areaSF });
+    const sig = ev.signals;
+    return {
+      confidence: conf.score,
+      ...conf.factors.length ? { confidence_factors: conf.factors } : {},
+      ...sig.hatchFiltered ? { hatch_filtered: true } : {},
+      ...sig.sealedPx ? { gap_sealed_px: sig.sealedPx } : {},
+      ...ev.gapBridged ? { gap_bridged_px: ev.gapBridged } : {},
+      // min-pass fields ride only when the rule CHANGED the answer — the
+      // canvas convention (minPassDelta gates minPassPx)
+      ...sig.minPassDelta ? { min_pass_px: sig.minPassPx || 0, min_pass_delta: sig.minPassDelta } : {},
+      ...sig.wedges ? { door_wedges: sig.wedges } : {},
+      ...ev.ringWedges ? { ring_interiors: ev.ringWedges } : {},
+      ...ev.raster ? { raster_traced: true } : {}
+    };
+  }
+  commit(s, tag, role, vertsPx, computed, origin, flood) {
+    if (origin && flood) origin = { ...origin, ..._Session.floodStamp(flood, computed.area_sf) };
     if (origin?.actor === "agent" && !origin.assignment) origin = { ...origin, assignment: { source: "asserted" } };
     const c = this.conditionFor(tag);
     const shape = {
@@ -4028,7 +4769,7 @@ var Session = class _Session {
       const mask = await this.maskWithLayers(name, opts.layers);
       if (!mask && !rasterEligible) throw new UserError("This sheet has no vector linework and no scan image to flood \u2014 nothing here bounds a region. Trace the space with measure_polygon instead.");
       if (mask) {
-        const r = floodRegion(mask, x, y, opts.sensitivity ?? SENS_BALANCED);
+        const r = floodAtSeed(mask, x, y, opts.sensitivity ?? SENS_BALANCED);
         if (r.status === "ok") f = r;
         else if (!rasterEligible) {
           if (r.status === "leak") throw new UserError("That space isn't enclosed on the plan linework \u2014 the fill spilled through a gap or opening.");
@@ -4039,29 +4780,23 @@ var Session = class _Session {
     if (!f) {
       this.refuseLayersOnRaster(opts.layers);
       const rmask = await this.ensureRasterMask(s);
-      const r = floodRegion(rmask, x, y);
+      const r = floodAtSeed(rmask, x, y, SENS_BALANCED, s.upp ? rmask.ws / s.upp : 0);
       if (r.status === "leak") throw new UserError("That space isn't enclosed on the scan \u2014 the fill escaped through a gap (faded line or open doorway). Seed a more enclosed spot, or trace it with measure_polygon.");
       if (r.status !== "ok") throw new UserError("Landed on dense scan ink (text or hatching). Seed an open spot inside the room.");
       f = r;
       raster = true;
     }
+    const ev = _Session.floodEvidence(f, raster, s.upp ? f.ws / s.upp : 0);
     const ring = raster ? traceRegion(f, RASTER_RDP_EPS) : snapVertices(traceRegion(f), (px, py, d) => s.snap ? nearestSnap(s.snap, px, py, d) : null, SNAP_TOL);
     if (ring.length < 3) throw new UserError("Couldn't trace that space into a polygon.");
     const areaPx2 = ringArea(ring);
     const perimPx = closedMetrics(ring).perim;
-    const common = {
-      status: "ok",
-      nverts: ring.length,
-      ...f.hatchFiltered ? { hatch_filtered: true } : {},
-      ...f.gapBridged ? { gap_bridged_px: f.gapBridged } : {},
-      // which path ran, disclosed both ways (#154): present = pixels bounded
-      // this trace, absent = the vector linework did
-      ...raster ? { raster_traced: true } : {},
-      ...opts.returnVerts ? { verts: ring.map(([vx, vy]) => [round1(vx), round1(vy)]) } : {}
-    };
     if (s.upp == null) {
       return {
-        ...common,
+        status: "ok",
+        nverts: ring.length,
+        ..._Session.floodStamp(ev),
+        ...opts.returnVerts ? { verts: ring.map(([vx, vy]) => [round1(vx), round1(vy)]) } : {},
         area_px2: round1(areaPx2),
         perimeter_px: round1(perimPx),
         warning: `No scale set for ${s.key} \u2014 quantities unavailable. Call set_scale${s.detected ? ` (detected: ${s.detected.label})` : ""}.`
@@ -4070,6 +4805,12 @@ var Session = class _Session {
     const upp = s.upp;
     const area_sf = round2(areaPx2 * upp * upp);
     const perimeter_lf = round2(perimPx * upp);
+    const common = {
+      status: "ok",
+      nverts: ring.length,
+      ..._Session.floodStamp(ev, area_sf),
+      ...opts.returnVerts ? { verts: ring.map(([vx, vy]) => [round1(vx), round1(vy)]) } : {}
+    };
     let shape_id;
     if (opts.condition) {
       shape_id = this.commit(s, opts.condition, opts.role, ring, { area_sf, perimeter_lf }, {
@@ -4077,12 +4818,6 @@ var Session = class _Session {
         actor: "agent",
         seed_norm: [x / s.widthPx, y / s.heightPx],
         reviewed: false,
-        ...f.hatchFiltered ? { hatch_filtered: true } : {},
-        ...f.gapBridged ? { gap_bridged_px: f.gapBridged } : {},
-        // #154 — a trace whose boundary was scan PIXELS is a different claim
-        // than one bounded by vector linework; the record says which (the
-        // canvas's raster_traced vocabulary, contribution.v2)
-        ...raster ? { raster_traced: true } : {},
         // #85 — a trace bounded by DECLARED boundary layers is categorically
         // stronger evidence than one bounded by a pitch heuristic (vector
         // path only: the raster mask never saw the layer table)
@@ -4091,7 +4826,7 @@ var Session = class _Session {
         // how the shape was made (ShapeOrigin.fill_sensitivity) — vector path
         // only; the knob is inert on a single-tier raster mask
         ...!raster && opts.sensitivity !== void 0 && opts.sensitivity !== SENS_BALANCED ? { fill_sensitivity: opts.sensitivity } : {}
-      }).id;
+      }, ev).id;
     }
     this.flushCommits("one_click");
     const mixed = this.scaleWarningFor(s, ring);
@@ -4161,11 +4896,12 @@ var Session = class _Session {
     const unresolved = [];
     const byRing = /* @__PURE__ */ new Map();
     const order = [];
+    const sweepMppf = raster ? s.upp ? mask.ws / s.upp : 0 : mask.mppf || 0;
     for (const lb of labels) {
-      let ring = null, hatch = false, gap = 0, seed = null;
+      let ring = null, ev = null, seed = null;
       let sawBubble = false, sawDegenerate = false;
       for (const probe of seedLadderPx(lb.bbox)) {
-        const f = floodRegion(mask, probe[0], probe[1], opts.sensitivity ?? SENS_BALANCED);
+        const f = floodAtSeed(mask, probe[0], probe[1], opts.sensitivity ?? SENS_BALANCED, sweepMppf);
         if (f.status !== "ok") continue;
         const r = raster ? traceRegion(f, RASTER_RDP_EPS) : snapVertices(traceRegion(f), (px, py, d) => s.snap ? nearestSnap(s.snap, px, py, d) : null, SNAP_TOL);
         if (r.length < 3) {
@@ -4177,12 +4913,11 @@ var Session = class _Session {
           continue;
         }
         ring = r;
-        hatch = !!f.hatchFiltered;
-        gap = f.gapBridged || 0;
+        ev = _Session.floodEvidence(f, raster, sweepMppf);
         seed = probe;
         break;
       }
-      if (!ring || !seed) {
+      if (!ring || !ev || !seed) {
         if (sawBubble) withheld.bubble++;
         else if (sawDegenerate) withheld.degenerate++;
         continue;
@@ -4200,8 +4935,7 @@ var Session = class _Session {
         areaPx2: ringArea(ring),
         perimPx: closedMetrics(ring).perim,
         seed,
-        hatch,
-        gap,
+        ev,
         merged: []
       };
       byRing.set(key, cand);
@@ -4209,17 +4943,16 @@ var Session = class _Session {
     }
     const upp = s.upp;
     const rooms = order.map((c) => {
-      const common = {
-        label: c.label,
-        nverts: c.ring.length,
-        ...c.merged.length ? { merged_labels: c.merged } : {},
-        ...c.hatch ? { hatch_filtered: true } : {},
-        ...c.gap ? { gap_bridged_px: c.gap } : {},
-        ...raster ? { raster_traced: true } : {},
-        ...opts.returnVerts ? { verts: c.ring.map(([vx, vy]) => [round1(vx), round1(vy)]) } : {}
-      };
       if (upp == null) {
-        return { ...common, area_px2: round1(c.areaPx2), perimeter_px: round1(c.perimPx) };
+        return {
+          label: c.label,
+          nverts: c.ring.length,
+          ...c.merged.length ? { merged_labels: c.merged } : {},
+          ..._Session.floodStamp(c.ev),
+          ...opts.returnVerts ? { verts: c.ring.map(([vx, vy]) => [round1(vx), round1(vy)]) } : {},
+          area_px2: round1(c.areaPx2),
+          perimeter_px: round1(c.perimPx)
+        };
       }
       const area_sf = round2(c.areaPx2 * upp * upp);
       if (area_sf < minAreaSf) {
@@ -4227,6 +4960,13 @@ var Session = class _Session {
         return null;
       }
       const perimeter_lf = round2(c.perimPx * upp);
+      const common = {
+        label: c.label,
+        nverts: c.ring.length,
+        ...c.merged.length ? { merged_labels: c.merged } : {},
+        ..._Session.floodStamp(c.ev, area_sf),
+        ...opts.returnVerts ? { verts: c.ring.map(([vx, vy]) => [round1(vx), round1(vy)]) } : {}
+      };
       let tag = opts.condition;
       let assignment;
       if (assign) {
@@ -4246,11 +4986,8 @@ var Session = class _Session {
           actor: "agent",
           seed_norm: [c.seed[0] / s.widthPx, c.seed[1] / s.heightPx],
           reviewed: false,
-          ...c.hatch ? { hatch_filtered: true } : {},
-          ...c.gap ? { gap_bridged_px: c.gap } : {},
-          ...raster ? { raster_traced: true } : {},
           ...assignment ? { assignment } : {}
-        }).id;
+        }, c.ev).id;
       }
       return { ...common, area_sf, perimeter_lf, ...shape_id ? { shape_id, condition: tag } : {} };
     }).filter((r) => r !== null);
@@ -5585,6 +6322,15 @@ function traceToolCall(tool, args, startedAt, reply) {
 // src/outputs.ts
 import { z } from "zod";
 var point = z.tuple([z.number(), z.number()]);
+var traceProvenance = {
+  confidence: z.number().optional().describe("0..1 \u2014 the trace scored from the engine's own signals (sealed openings, door wedges, min-passage rule, hatch tier, raster boundary, mask coarseness, implausible size). A review PRIORITIZER, not a verification: 1.0 means every signal came back clean, never that the trace is right. A low score is a view_sheet {overlay:true} audit prompt, not a fact to bid from"),
+  confidence_factors: z.array(z.string()).optional().describe('The named factors behind a sub-1.0 confidence (e.g. "sealed-opening(10% synthetic boundary)") \u2014 each names the edge worth putting eyes on; absent when every signal ran clean'),
+  gap_sealed_px: z.number().optional().describe("Present when the seal ladder closed a genuine OPENING this many mask px wide (doorway-scale \u2014 scaled by the sheet's feet, distinct from gap_bridged_px's drafting-pinhole rescue). Part of the boundary is synthetic, and confidence deducts by that share; rides origin.gap_sealed_px on the committed shape"),
+  min_pass_px: z.number().optional().describe("The feet-true minimum-passage rule (openings under ~0.5 ft never connect two spaces) ran at this dilation radius AND changed the answer \u2014 present only with min_pass_delta"),
+  min_pass_delta: z.number().optional().describe("Fraction of the verbatim flood the minimum-passage rule removed; 1 means the drawn linework bounds nothing here and the rule is the only reason there is a measurement \u2014 audit before trusting"),
+  door_wedges: z.number().int().optional().describe("Door-swing wedges annexed into the region under grow-but-verify \u2014 how many doorways' swings were included, the canvas's own door handling; rides origin.door_wedges"),
+  ring_interiors: z.number().int().optional().describe("Of those wedges, how many were a CLOSED ring's interior (round column, callout bubble) rather than a door swing \u2014 annexed floor you may want as a deduct instead")
+};
 var sheetSummary2 = {
   sheet: z.string().describe('Sheet key: page 1 is the bare file name ("plan.pdf"), pages 2+ are "plan.pdf#2"'),
   page: z.number().int().describe("1-based page number"),
@@ -5629,6 +6375,7 @@ var setScaleOutput = {
 var oneClickOutput = {
   status: z.literal("ok"),
   nverts: z.number().int().describe("Vertex count of the traced polygon"),
+  ...traceProvenance,
   hatch_filtered: z.literal(true).optional().describe("Present when hatch/pattern linework was classified out of the boundary"),
   gap_bridged_px: z.number().optional().describe("Present when the seal ladder bridged a drafting pinhole this many px wide to close the region \u2014 the rescue rides provenance (origin.gap_bridged_px) rather than passing as a clean fill"),
   raster_traced: z.literal(true).optional().describe("Present when the region was bounded by the sheet's RENDERED PIXELS (the scanned-sheet raster fallback, #154) rather than vector linework \u2014 absent means the vector path ran. Rides origin.raster_traced on the committed shape; a raster ring's corners are unsnapped (a scan has no true endpoints), so audit it with view_sheet overlay before trusting the total"),
@@ -5644,6 +6391,7 @@ var detectedRoom = z.object({
   label: z.string().describe('The room-number text the seed was read from (e.g. "104", "139A")'),
   nverts: z.number().int().describe("Vertex count of the traced polygon"),
   merged_labels: z.array(z.string()).optional().describe("Other labels that flooded to this same region \u2014 the area is counted once, under `label`"),
+  ...traceProvenance,
   hatch_filtered: z.literal(true).optional().describe("Present when hatch/pattern linework was classified out of the boundary"),
   gap_bridged_px: z.number().optional().describe("Present when the seal ladder bridged a drafting pinhole this many px wide to close the region"),
   raster_traced: z.literal(true).optional().describe("Present when the room was bounded by rendered pixels (scanned-sheet raster fallback, #154) rather than vector linework \u2014 sheet-wide per sweep, and it rides origin.raster_traced on the committed shape"),
@@ -7601,7 +8349,7 @@ function registerTools(server, session) {
     return session.setScale(a.sheet, a);
   }));
   server.registerTool("one_click", {
-    description: `One-Click Area: click inside a room (image px) and the plan's vector linework bounds it \u2014 flood fill, contour trace, vertices snapped to true PDF endpoints. SCANNED sheets work too (#154): where vectors can't bound the room (an image-only scan, or a scan wrapper whose only linework is the title block), the flood falls back automatically to the sheet's rendered pixels \u2014 same engine the canvas uses \u2014 and the reply plus the committed shape's origin carry raster_traced: true so a pixel-bounded ring is never mistaken for a vector-snapped one. Vector always wins where it works; a raster ring's corners are unsnapped, so audit it with view_sheet {overlay: true} before trusting the total. With the sheet's scale set, returns area_sf / perimeter_lf; pass condition (a finish tag, e.g. "CPT-1") to commit the traced shape to the takeoff. Without a scale it returns px-only quantities with a warning and commits nothing. role "deduct" makes the committed shape subtract. After committing, LOOK at what landed \u2014 view_sheet {overlay: true} \u2014 and fix an overshot ring with edit_shape before trusting any total. ${COORDS}`,
+    description: `One-Click Area: click inside a room (image px) and the plan's vector linework bounds it \u2014 the sealed flood engine (RFC #60), contour trace, vertices snapped to true PDF endpoints. The engine's arguments are FEET-TRUE through the sheet's scale, exactly the canvas's: gap sealing bridges up to a door-width opening (disclosed as gap_sealed_px \u2014 that much boundary is synthetic), door-swing wedges annex the swing a doorway sweeps (door_wedges), and the minimum-passage rule keeps sub-half-foot slits from conjoining two rooms (min_pass_px/min_pass_delta). Every trace carries the engine's own account of itself: confidence (0..1, with confidence_factors naming what deducted) \u2014 a review PRIORITIZER, never a verification. 1.0 means every signal ran clean, not that the trace is right; a LOW confidence is a view_sheet {overlay: true} audit prompt, not a fact to bid from \u2014 put eyes on the flagged edge before the total means anything. SCANNED sheets work too (#154): where vectors can't bound the room (an image-only scan, or a scan wrapper whose only linework is the title block), the flood falls back automatically to the sheet's rendered pixels \u2014 same engine the canvas uses \u2014 and the reply plus the committed shape's origin carry raster_traced: true so a pixel-bounded ring is never mistaken for a vector-snapped one. Vector always wins where it works; a raster ring's corners are unsnapped, so audit it with view_sheet {overlay: true} before trusting the total. With the sheet's scale set, returns area_sf / perimeter_lf; pass condition (a finish tag, e.g. "CPT-1") to commit the traced shape to the takeoff \u2014 the full engine account rides the committed shape's origin, so the export tells the truth about how each shape was made. Without a scale it returns px-only quantities with a warning and commits nothing (the engine also degrades to its scale-blind fallbacks \u2014 a weaker measurement, one more reason set_scale comes first). role "deduct" makes the committed shape subtract. After committing, LOOK at what landed \u2014 view_sheet {overlay: true} \u2014 and fix an overshot ring with edit_shape before trusting any total. ${COORDS}`,
     inputSchema: {
       sheet: z2.string(),
       x: z2.number(),
@@ -7615,7 +8363,7 @@ function registerTools(server, session) {
     outputSchema: oneClickOutput
   }, run("one_click", (a) => session.oneClick(a.sheet, a.x, a.y, { condition: a.condition, role: a.role, returnVerts: a.return_verts, sensitivity: a.sensitivity, layers: a.layers })));
   server.registerTool("detect_rooms", {
-    description: `Batch room detection: reads every room-number label off the sheet's text layer (e.g. "134", "OFFICE 101") and runs One-Click at each \u2014 one call instead of read_sheet_text + reasoning + N one_click calls. An OCR'd scan (text layer, no vector linework) floods the rendered pixels instead (#154), disclosed per room and on origin as raster_traced. A seed is only reported as a room once it survives three gates, and everything skipped is counted and reasoned in \`withheld\` \u2014 never dropped silently, because a room the tool tells you it skipped is a question you can ask, while one it hides is a hole in a bid. The gates: a flood that leaked or landed in dense linework never becomes a region; two labels flooding the SAME region commit once (the extra labels ride on \`merged_labels\` \u2014 double-counting an area is the worst failure an estimating tool has); and a flood that is enclosed and clean but smaller than min_area_sf is a room-number bubble, a door swing, or a wall cavity rather than a room. With the sheet's scale set, returns area_sf/perimeter_lf per room. TO COMMIT, choose the honest source of the finish tag: assign_from_schedule: true routes every room through its OWN room-finish schedule row and commits each under the FLOOR finish that row states \u2014 when a schedule exists in the set, THIS is the default move, because one agent-chosen tag across N rooms flattens real finish variety into a wrong bid; condition commits every room under that one stated tag (only right when the rooms genuinely share it; role "deduct" makes them subtract). Without a scale, returns px-only quantities per room and commits nothing \u2014 the plausibility floor needs real units, so it only applies once a scale is set. A batch commit is NOT finished until you have LOOKED at it: view_sheet {overlay: true}, audit every ring against the walls, fix misses with edit_shape / delete_shape \u2014 before the totals mean anything. ${COORDS}`,
+    description: `Batch room detection: reads every room-number label off the sheet's text layer (e.g. "134", "OFFICE 101") and runs One-Click at each \u2014 one call instead of read_sheet_text + reasoning + N one_click calls. An OCR'd scan (text layer, no vector linework) floods the rendered pixels instead (#154), disclosed per room and on origin as raster_traced. A seed is only reported as a room once it survives three gates, and everything skipped is counted and reasoned in \`withheld\` \u2014 never dropped silently, because a room the tool tells you it skipped is a question you can ask, while one it hides is a hole in a bid. The gates: a flood that leaked or landed in dense linework never becomes a region; two labels flooding the SAME region commit once (the extra labels ride on \`merged_labels\` \u2014 double-counting an area is the worst failure an estimating tool has); and a flood that is enclosed and clean but smaller than min_area_sf is a room-number bubble, a door swing, or a wall cavity rather than a room. Every room floods through the SAME sealed engine a single one_click runs (RFC #60 \u2014 feet-true gap sealing, door-swing wedges, the minimum-passage rule), so a batch detection and a click at the same seed measure the same square footage; each room carries the engine's account of its own trace (confidence + confidence_factors, gap_sealed_px, door_wedges, min_pass_px/min_pass_delta), and the same account rides origin on everything committed. Confidence is a review prioritizer, never a verification \u2014 a low-confidence room is a view_sheet {overlay: true} audit prompt, not a fact to bid from. With the sheet's scale set, returns area_sf/perimeter_lf per room. TO COMMIT, choose the honest source of the finish tag: assign_from_schedule: true routes every room through its OWN room-finish schedule row and commits each under the FLOOR finish that row states \u2014 when a schedule exists in the set, THIS is the default move, because one agent-chosen tag across N rooms flattens real finish variety into a wrong bid; condition commits every room under that one stated tag (only right when the rooms genuinely share it; role "deduct" makes them subtract). Without a scale, returns px-only quantities per room and commits nothing \u2014 the plausibility floor needs real units, so it only applies once a scale is set. A batch commit is NOT finished until you have LOOKED at it: view_sheet {overlay: true}, audit every ring against the walls, fix misses with edit_shape / delete_shape \u2014 before the totals mean anything. ${COORDS}`,
     inputSchema: {
       sheet: z2.string(),
       condition: z2.string().optional().describe("Finish tag to commit every detected room under (minted on first use). Mutually exclusive with assign_from_schedule"),
@@ -8045,7 +8793,7 @@ function registerResources(server, session) {
 // package.json
 var package_default = {
   name: "opentakeoff-mcp",
-  version: "0.9.25",
+  version: "0.9.26",
   mcpName: "io.github.Kentucky-ai/opentakeoff",
   type: "module",
   description: "OpenTakeoff MCP server \u2014 drive the takeoff engine from your MCP client over stdio.",
@@ -8061,7 +8809,7 @@ var package_default = {
     mcpb: "npm run build && node scripts/build-mcpb.mjs",
     prepublishOnly: "npm run typecheck && npm test && npm run build",
     typecheck: "tsc --noEmit",
-    test: "node --import tsx --test test/conformance.test.ts test/context.test.ts test/e2e.test.ts test/raster.test.ts test/resources.test.ts test/scalewarn.test.ts test/session.test.ts test/tools.test.ts test/view.test.ts"
+    test: "node --import tsx --test test/conformance.test.ts test/context.test.ts test/e2e.test.ts test/parity.test.ts test/raster.test.ts test/resources.test.ts test/scalewarn.test.ts test/session.test.ts test/tools.test.ts test/view.test.ts"
   },
   dependencies: {
     "@modelcontextprotocol/sdk": "^1.12.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opentakeoff-mcp",
-  "version": "0.9.25",
+  "version": "0.9.26",
   "mcpName": "io.github.Kentucky-ai/opentakeoff",
   "type": "module",
   "description": "OpenTakeoff MCP server — drive the takeoff engine from your MCP client over stdio.",
@@ -16,7 +16,7 @@
     "mcpb": "npm run build && node scripts/build-mcpb.mjs",
     "prepublishOnly": "npm run typecheck && npm test && npm run build",
     "typecheck": "tsc --noEmit",
-    "test": "node --import tsx --test test/conformance.test.ts test/context.test.ts test/e2e.test.ts test/raster.test.ts test/resources.test.ts test/scalewarn.test.ts test/session.test.ts test/tools.test.ts test/view.test.ts"
+    "test": "node --import tsx --test test/conformance.test.ts test/context.test.ts test/e2e.test.ts test/parity.test.ts test/raster.test.ts test/resources.test.ts test/scalewarn.test.ts test/session.test.ts test/tools.test.ts test/view.test.ts"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.0",