opentakeoff-mcp 0.9.21 → 0.9.26

package/dist/server-core.js

@@ -267,7 +267,21 @@ function textSpans(ph) {
     const x = t[4], y = t[5];
     const w = (it.width || 0) * RENDER_SCALE;
     const h = (it.height || 0) * RENDER_SCALE || Math.hypot(t[2], t[3]);
-    out.push({ str, x0: +x.toFixed(1), y0: +(y - h).toFixed(1), x1: +(x + w).toFixed(1), y1: +y.toFixed(1) });
+    const dn = Math.hypot(t[0], t[1]) || 1;
+    const un = Math.hypot(t[2], t[3]) || 1;
+    const dx = t[0] / dn, dy = t[1] / dn;
+    const ux = t[2] / un, uy = t[3] / un;
+    const xs = [x, x + w * dx, x + h * ux, x + w * dx + h * ux];
+    const ys = [y, y + w * dy, y + h * uy, y + w * dy + h * uy];
+    const rot = (Math.round(Math.atan2(dy, dx) * 180 / Math.PI) % 360 + 360) % 360;
+    out.push({
+      str,
+      x0: +Math.min(...xs).toFixed(1),
+      y0: +Math.min(...ys).toFixed(1),
+      x1: +Math.max(...xs).toFixed(1),
+      y1: +Math.max(...ys).toFixed(1),
+      ...rot ? { rot } : {}
+    });
   }
   return out;
 }
@@ -408,27 +422,194 @@ function segRoles(layerOf, codes) {
   return any ? out : null;
 }
 
+// ../web/src/lib/geometry.js
+function starPath(cx, cy, R, points = 4, innerRatio = 0.38) {
+  const r = R * innerRatio;
+  let d = "";
+  for (let i = 0; i < points * 2; i++) {
+    const a = Math.PI * i / points - Math.PI / 2, rad = i % 2 === 0 ? R : r;
+    d += `${i === 0 ? "M" : "L"}${cx + rad * Math.cos(a)},${cy + rad * Math.sin(a)} `;
+  }
+  return d + "Z";
+}
+function arrowheadPath(fromX, fromY, tipX, tipY, size = 6) {
+  let dx = tipX - fromX, dy = tipY - fromY;
+  const len = Math.hypot(dx, dy);
+  if (len < 1e-6) {
+    dx = 0;
+    dy = 1;
+  } else {
+    dx /= len;
+    dy /= len;
+  }
+  const bx = tipX - dx * size, by = tipY - dy * size;
+  const nx = -dy, ny = dx, half = size * 0.5;
+  return `M${tipX},${tipY} L${bx + nx * half},${by + ny * half} L${bx - nx * half},${by - ny * half} Z`;
+}
+function arcToBezier(x0, y0, x1, y1, r, laf, sf) {
+  const dx = (x0 - x1) / 2, dy = (y0 - y1) / 2;
+  let rr = Math.abs(r) || 1;
+  const lambda = (dx * dx + dy * dy) / (rr * rr);
+  if (lambda > 1) rr *= Math.sqrt(lambda);
+  const sign = laf !== sf ? 1 : -1;
+  const num2 = rr * rr * rr * rr - rr * rr * dy * dy - rr * rr * dx * dx;
+  const den = rr * rr * dy * dy + rr * rr * dx * dx;
+  const coef = sign * Math.sqrt(Math.max(0, den === 0 ? 0 : num2 / den));
+  const cxp = coef * dy, cyp = -coef * dx;
+  const ang = (ux, uy, vx, vy) => {
+    const dot = ux * vx + uy * vy, len = Math.hypot(ux, uy) * Math.hypot(vx, vy) || 1;
+    let a = Math.acos(Math.max(-1, Math.min(1, dot / len)));
+    if (ux * vy - uy * vx < 0) a = -a;
+    return a;
+  };
+  const th1 = ang(1, 0, (dx - cxp) / rr, (dy - cyp) / rr);
+  let dth = ang((dx - cxp) / rr, (dy - cyp) / rr, (-dx - cxp) / rr, (-dy - cyp) / rr);
+  if (!sf && dth > 0) dth -= 2 * Math.PI;
+  if (sf && dth < 0) dth += 2 * Math.PI;
+  const th2 = th1 + dth;
+  const alpha = 4 / 3 * Math.tan(dth / 4);
+  return [
+    x0 - alpha * rr * Math.sin(th1),
+    y0 + alpha * rr * Math.cos(th1),
+    x1 + alpha * rr * Math.sin(th2),
+    y1 - alpha * rr * Math.cos(th2)
+  ];
+}
+function cloudBezier(x0, y0, x1, y1) {
+  const ax0 = Math.min(x0, x1), ay0 = Math.min(y0, y1), ax1 = Math.max(x0, x1), ay1 = Math.max(y0, y1);
+  const r = Math.max(6, Math.min(22, (ax1 - ax0 + ay1 - ay0) / 22));
+  const arc = (len) => Math.max(1, Math.round(len / (r * 1.6)));
+  const segments = [];
+  let px = ax0, py = ay0;
+  const edge = (fromX, fromY, toX, toY) => {
+    const n = arc(Math.hypot(toX - fromX, toY - fromY));
+    for (let i = 1; i <= n; i++) {
+      const qx = fromX + (toX - fromX) * (i / n), qy = fromY + (toY - fromY) * (i / n);
+      const [c1x, c1y, c2x, c2y] = arcToBezier(px, py, qx, qy, r, 0, 1);
+      segments.push([[c1x, c1y], [c2x, c2y], [qx, qy]]);
+      px = qx;
+      py = qy;
+    }
+  };
+  edge(ax0, ay0, ax1, ay0);
+  edge(ax1, ay0, ax1, ay1);
+  edge(ax1, ay1, ax0, ay1);
+  edge(ax0, ay1, ax0, ay0);
+  return { start: [ax0, ay0], segments };
+}
+function buildSnapGrid(points, cell) {
+  const map = /* @__PURE__ */ new Map();
+  for (const p of points) {
+    const k = `${Math.floor(p[0] / cell)},${Math.floor(p[1] / cell)}`;
+    let a = map.get(k);
+    if (!a) {
+      a = [];
+      map.set(k, a);
+    }
+    if (a.length < 40) a.push(p);
+  }
+  return { cell, map };
+}
+function nearestSnap(grid, x, y, maxDist) {
+  if (!grid) return null;
+  const { cell, map } = grid, cx = Math.floor(x / cell), cy = Math.floor(y / cell);
+  let best = null, bestD = maxDist * maxDist;
+  for (let gx = cx - 1; gx <= cx + 1; gx++) for (let gy = cy - 1; gy <= cy + 1; gy++) {
+    const a = map.get(`${gx},${gy}`);
+    if (!a) continue;
+    for (const p of a) {
+      const dx = p[0] - x, dy = p[1] - y, d = dx * dx + dy * dy;
+      if (d < bestD) {
+        bestD = d;
+        best = p;
+      }
+    }
+  }
+  return best;
+}
+function closedMetrics(pts) {
+  const n = pts.length;
+  if (n < 3) {
+    let perim2 = 0;
+    for (let i = 1; i < n; i++) perim2 += Math.hypot(pts[i][0] - pts[i - 1][0], pts[i][1] - pts[i - 1][1]);
+    return { area: 0, perim: perim2 };
+  }
+  let area = 0, perim = 0;
+  for (let i = 0; i < n; i++) {
+    const [x1, y1] = pts[i], [x2, y2] = pts[(i + 1) % n];
+    area += x1 * y2 - x2 * y1;
+    perim += Math.hypot(x2 - x1, y2 - y1);
+  }
+  return { area: Math.abs(area) / 2, perim };
+}
+function openLen(pts) {
+  let L = 0;
+  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 pointInPoly(x, y, pts) {
+  let inside = 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;
+  }
+  return inside;
+}
+function chiselRibbon(pts, w, nibDeg = 45) {
+  const a = nibDeg * Math.PI / 180, vx = Math.cos(a) * w / 2, vy = -(Math.sin(a) * w) / 2;
+  return [...pts.map(([x, y]) => [x + vx, y + vy]), ...[...pts].reverse().map(([x, y]) => [x - vx, y - vy])];
+}
+
 // ../web/src/lib/oneclick.ts
 var MASK_MAX_DIM = 3e3;
+function baselineImgDims(pageW, pageH, baseScale) {
+  const bs = Number.isFinite(baseScale) && baseScale > 0 ? baseScale : 1;
+  const w = Number.isFinite(pageW) && pageW > 0 ? pageW : 1;
+  const h = Number.isFinite(pageH) && pageH > 0 ? pageH : 1;
+  return { w: Math.max(1, Math.ceil(w * bs)), h: Math.max(1, Math.ceil(h * bs)) };
+}
 var LEAK_FRACTION = 0.3;
-var TINY_PX = 30;
-var MIN_THICK = 4;
 var CURVE_STEPS = 8;
 var GAP_BRIDGE_MAX = 2;
+var CAL_MPPF = 18;
+var TINY_PX = 30;
+var TINY_SF = TINY_PX / (CAL_MPPF * CAL_MPPF);
+var TINY_PX_FLOOR = 8;
+var MIN_THICK = 4;
+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;
+var SEG_POLYARC = 8;
+var ARC_MIN_CHORDS = 4;
+var ARC_MIN_TOTAL_TURN = 30;
+var ARC_CHORD_TURN_MIN = 2;
+var ARC_CHORD_TURN_MAX = 45;
+var ARC_FIT_TOL_FRAC = 0.03;
+var ARC_CLOSED_TURN = 300;
+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_MIN_RUN = 10;
 var HATCH_MAX_PITCH = 24;
-var HATCH_PITCH_TOL = 0.35;
-var HATCH_MIN_REGULAR = 0.7;
-var HATCH_OVERLAP_FRAC = 0.5;
-var ROW_EPS = 1.5;
-var WIDE_PROTECT_RATIO = 2;
-var SPAN_PROTECT_RATIO = 3;
+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.35;
+var HATCH_ESCALATE_FRAC = 0.02;
 var HATCH_GROWTH_MAX = 2.5;
 var SENS_STRICT = 0;
 var SENS_BALANCED = 0.5;
@@ -438,8 +619,8 @@ var SENS_ANCHORS = [
   // moderate band empties (escalateFrac == HATCH_BOUND_FRAC) ⇒ pre-#32
   [SENS_BALANCED, HATCH_ESCALATE_FRAC, HATCH_GROWTH_MAX],
   // calibrated on the sample plan (issue #32)
-  [SENS_AGGRESSIVE, 0.2, 4]
-  // cross more hatch, tolerate more growth
+  [SENS_AGGRESSIVE, 0, 4]
+  // cross any hatch, tolerate more growth
 ];
 function escalationParams(sensitivity) {
   const s = Math.max(0, Math.min(1, Number.isFinite(sensitivity) ? sensitivity : SENS_BALANCED));
@@ -636,8 +817,349 @@ function extractVectorGeometry(opList, transform, OPS3) {
       }
     }
   }
-  return { points, segs, meta: Uint8Array.from(metaArr), imageArea, layerOf: Int32Array.from(layerOfArr), layerIds };
+  const meta = Uint8Array.from(metaArr);
+  markPolylineArcs(segs, meta);
+  return { points, segs, meta, imageArea, layerOf: Int32Array.from(layerOfArr), layerIds };
+}
+function markPolylineArcs(segs, meta) {
+  const n = segs.length >> 2;
+  if (!meta || n < ARC_MIN_CHORDS) return 0;
+  let marked = 0;
+  const len = (i) => Math.hypot(segs[i * 4 + 2] - segs[i * 4], segs[i * 4 + 3] - segs[i * 4 + 1]);
+  let chain = [];
+  const flush = () => {
+    if (chain.length >= ARC_MIN_CHORDS) marked += scanChainForArcs(segs, meta, chain);
+    chain = [];
+  };
+  for (let i = 0; i < n; i++) {
+    if (meta[i] & (SEG_CURVE | SEG_CLIP)) {
+      flush();
+      continue;
+    }
+    if (len(i) < 0.5) continue;
+    if (chain.length) {
+      const p = chain[chain.length - 1];
+      const gap = Math.hypot(segs[i * 4] - segs[p * 4 + 2], segs[i * 4 + 1] - segs[p * 4 + 3]);
+      if (meta[i] !== meta[p] || gap > Math.max(len(i), len(p))) flush();
+    }
+    chain.push(i);
+  }
+  flush();
+  return marked;
+}
+function scanChainForArcs(segs, meta, chain) {
+  let marked = 0;
+  for (const w of scanChainWindows(segs, chain)) {
+    const cm = meta[chain[w.c0]];
+    for (let j = chain[w.c0]; j <= chain[w.c1]; j++) if (meta[j] === cm) meta[j] |= SEG_CURVE | SEG_POLYARC;
+    marked += w.c1 - w.c0 + 1;
+  }
+  return marked;
+}
+function scanChainWindows(segs, chain) {
+  const m = chain.length;
+  const dirs = [], lens = [];
+  for (const i of chain) {
+    const dx = segs[i * 4 + 2] - segs[i * 4], dy = segs[i * 4 + 3] - segs[i * 4 + 1];
+    dirs.push(Math.atan2(dy, dx) * 180 / Math.PI);
+    lens.push(Math.hypot(dx, dy));
+  }
+  const turn = [0];
+  for (let k = 1; k < m; k++) {
+    let t = dirs[k] - dirs[k - 1];
+    if (t > 180) t -= 360;
+    if (t <= -180) t += 360;
+    turn.push(t);
+  }
+  const ratioOk = (k) => {
+    const r = Math.max(lens[k], lens[k - 1]) / Math.max(1e-9, Math.min(lens[k], lens[k - 1]));
+    return r <= 3;
+  };
+  const signedTurn = (k) => Math.abs(turn[k]) >= ARC_CHORD_TURN_MIN && Math.abs(turn[k]) <= ARC_CHORD_TURN_MAX && ratioOk(k);
+  const neutral = (k) => Math.abs(turn[k]) < ARC_CHORD_TURN_MIN && ratioOk(k);
+  const out = [];
+  let s = 1;
+  while (s < m) {
+    if (!signedTurn(s)) {
+      s++;
+      continue;
+    }
+    const sgn = Math.sign(turn[s]);
+    let e = s, bridged = false;
+    for (let k = s + 1; k < m; k++) {
+      if (signedTurn(k) && Math.sign(turn[k]) === sgn) {
+        e = k;
+        bridged = false;
+        continue;
+      }
+      if (neutral(k) && !bridged) {
+        bridged = true;
+        continue;
+      }
+      break;
+    }
+    if (e - s + 2 >= ARC_MIN_CHORDS) {
+      let total = 0;
+      for (let j = s; j <= e; j++) total += Math.abs(turn[j]);
+      if (total >= ARC_MIN_TOTAL_TURN) {
+        for (const [c0, c1] of [[s - 1, e], [s, e], [s - 1, e - 1], [s, e - 1]]) {
+          if (c1 - c0 + 1 < ARC_MIN_CHORDS) continue;
+          let t = 0, signed = 0;
+          for (let j = c0 + 1; j <= c1; j++) {
+            t += Math.abs(turn[j]);
+            signed += turn[j];
+          }
+          const fit = t < ARC_MIN_TOTAL_TURN ? null : circleFitOk(segs, chain, c0, c1);
+          if (!fit) continue;
+          out.push({ c0, c1, turn: signed, r: fit.r });
+          break;
+        }
+      }
+    }
+    s = e + 1;
+  }
+  return out;
 }
+function flagNonDoorArcs(segs, meta) {
+  const n = segs.length >> 2;
+  const veto = new Uint8Array(n);
+  if (!meta || n < ARC_MIN_CHORDS) return veto;
+  const len = (i) => Math.hypot(segs[i * 4 + 2] - segs[i * 4], segs[i * 4 + 3] - segs[i * 4 + 1]);
+  let chain = [];
+  const flush = () => {
+    if (chain.length >= ARC_MIN_CHORDS) judgeChain(segs, chain, veto);
+    chain = [];
+  };
+  for (let i = 0; i < n; i++) {
+    if (len(i) < 0.5) continue;
+    if (!(meta[i] & SEG_CURVE) || meta[i] & SEG_CLIP) {
+      flush();
+      continue;
+    }
+    if (chain.length) {
+      const p = chain[chain.length - 1];
+      const gap = Math.hypot(segs[i * 4] - segs[p * 4 + 2], segs[i * 4 + 1] - segs[p * 4 + 3]);
+      if (meta[i] !== meta[p] || gap > Math.max(len(i), len(p))) flush();
+    }
+    chain.push(i);
+  }
+  flush();
+  return veto;
+}
+function judgeChain(segs, chain, veto) {
+  const wins = scanChainWindows(segs, chain);
+  if (!wins.length) return;
+  const stamp = (w) => {
+    for (let j = chain[w.c0]; j <= chain[w.c1]; j++) veto[j] = 1;
+  };
+  let closed = false;
+  for (const w of wins) if (Math.abs(w.turn) >= ARC_CLOSED_TURN) {
+    stamp(w);
+    closed = true;
+  }
+  if (closed) return;
+  if (wins.length <= ARC_CUSP_MIN) return;
+  let run2 = 1, best = 1;
+  for (let k = 1; k < wins.length; k++) {
+    if (wins[k].c0 - wins[k - 1].c1 <= 2 && Math.sign(wins[k].turn) === Math.sign(wins[k - 1].turn)) run2++;
+    else run2 = 1;
+    if (run2 > best) best = run2;
+  }
+  if (best <= ARC_CUSP_MIN) return;
+  let rmin = Infinity, rmax = 0, span = 0;
+  for (const w of wins) {
+    if (w.r < rmin) rmin = w.r;
+    if (w.r > rmax) rmax = w.r;
+  }
+  for (const i of chain) span += Math.hypot(segs[i * 4 + 2] - segs[i * 4], segs[i * 4 + 3] - segs[i * 4 + 1]);
+  if (!(rmin > 0) || rmax > rmin * ARC_CUSP_R_RATIO) return;
+  if (rmax * ARC_CUSP_SPAN_MULT > span) return;
+  for (const w of wins) stamp(w);
+}
+function circleFitOk(segs, chain, c0, c1) {
+  const xs = [], ys = [];
+  xs.push(segs[chain[c0] * 4]);
+  ys.push(segs[chain[c0] * 4 + 1]);
+  for (let k = c0; k <= c1; k++) {
+    const i = chain[k];
+    xs.push(segs[i * 4 + 2]);
+    ys.push(segs[i * 4 + 3]);
+  }
+  const m = xs.length;
+  let mx = 0, my = 0;
+  for (let i = 0; i < m; i++) {
+    mx += xs[i];
+    my += ys[i];
+  }
+  mx /= m;
+  my /= m;
+  let sxx = 0, sxy = 0, syy = 0, sxz = 0, syz = 0;
+  for (let i = 0; i < m; i++) {
+    const x = xs[i] - mx, y = ys[i] - my, z3 = x * x + y * y;
+    sxx += x * x;
+    sxy += x * y;
+    syy += y * y;
+    sxz += x * z3;
+    syz += y * z3;
+  }
+  const det = sxx * syy - sxy * sxy;
+  if (Math.abs(det) < 1e-9) return null;
+  const cx = (sxz * syy - syz * sxy) / (2 * det);
+  const cy = (syz * sxx - sxz * sxy) / (2 * det);
+  let r = 0;
+  for (let i = 0; i < m; i++) r += Math.hypot(xs[i] - mx - cx, ys[i] - my - cy);
+  r /= m;
+  if (!(r > 0)) return null;
+  const tol = Math.max(0.75, r * ARC_FIT_TOL_FRAC);
+  for (let i = 0; i < m; i++) {
+    if (Math.abs(Math.hypot(xs[i] - mx - cx, ys[i] - my - cy) - r) > tol) return null;
+  }
+  return { cx: cx + mx, cy: cy + my, r };
+}
+function classifyHatchSegs(segs, meta, ws, pitchCapPx = HATCH_MAX_PITCH) {
+  const n = segs.length >> 2;
+  const soft = new Uint8Array(n);
+  if (!meta || !n) return soft;
+  const HALF_CELL = 0.5;
+  const cand = [];
+  for (let i = 0; i < n; i++) {
+    const mt = meta[i];
+    if (mt & SEG_CURVE) continue;
+    if (mt & SEG_CLIP) {
+      soft[i] = 1;
+      continue;
+    }
+    if (mt & SEG_FILLONLY) continue;
+    const x1 = segs[i * 4] * ws, y1 = segs[i * 4 + 1] * ws, x2 = segs[i * 4 + 2] * ws, y2 = segs[i * 4 + 3] * ws;
+    const dx = x2 - x1, dy = y2 - y1;
+    const len = Math.hypot(dx, dy);
+    if (len < 0.75) continue;
+    let ang = Math.atan2(dy, dx) * 180 / Math.PI;
+    if (ang < 0) ang += 180;
+    if (ang >= 180) ang -= 180;
+    cand.push({ i, ang, x1, y1, x2, y2, w: meta[i] >> 4 });
+  }
+  if (cand.length < 5) return soft;
+  cand.sort((a, b) => a.ang - b.ang);
+  const clusters = [];
+  let cl = [cand[0]];
+  for (let k = 1; k < cand.length; k++) {
+    if (cand[k].ang - cand[k - 1].ang <= HATCH_ANGLE_TOL) cl.push(cand[k]);
+    else {
+      clusters.push(cl);
+      cl = [cand[k]];
+    }
+  }
+  clusters.push(cl);
+  if (clusters.length > 1) {
+    const first = clusters[0], last = clusters[clusters.length - 1];
+    if (first[0].ang < HATCH_ANGLE_TOL && last[last.length - 1].ang > 180 - HATCH_ANGLE_TOL) {
+      for (const s of last) s.ang -= 180;
+      clusters[0] = last.concat(first);
+      clusters.pop();
+    }
+  }
+  for (const members of clusters) {
+    if (members.length < 5) continue;
+    let sum = 0;
+    for (const s of members) sum += s.ang;
+    const th = sum / members.length * Math.PI / 180;
+    const dxu = Math.cos(th), dyu = Math.sin(th);
+    const nxu = -dyu, nyu = dxu;
+    const pieces = members.map((s) => ({
+      i: s.i,
+      d: (s.x1 + s.x2) / 2 * nxu + (s.y1 + s.y2) / 2 * nyu,
+      t0: Math.min(s.x1 * dxu + s.y1 * dyu, s.x2 * dxu + s.y2 * dyu),
+      t1: Math.max(s.x1 * dxu + s.y1 * dyu, s.x2 * dxu + s.y2 * dyu),
+      w: s.w
+    })).sort((a, b) => a.d - b.d);
+    const rowOf = new Int32Array(pieces.length);
+    const rowD = [];
+    const rowPieces = [];
+    for (let k = 0; k < pieces.length; k++) {
+      if (rowD.length && pieces[k].d - rowD[rowD.length - 1] <= HALF_CELL) {
+        rowOf[k] = rowD.length - 1;
+        rowPieces[rowPieces.length - 1].push(pieces[k]);
+      } else {
+        rowOf[k] = rowD.length;
+        rowD.push(pieces[k].d);
+        rowPieces.push([pieces[k]]);
+      }
+    }
+    for (const rp of rowPieces) rp.sort((a, b) => a.t0 - b.t0);
+    const rowMaxT1 = rowPieces.map((rp) => {
+      const m = new Array(rp.length);
+      let mx = -Infinity;
+      for (let i = 0; i < rp.length; i++) {
+        mx = Math.max(mx, rp[i].t1);
+        m[i] = mx;
+      }
+      return m;
+    });
+    const rowHas = (j, w, t0, t1) => {
+      const P = rowPieces[j], M = rowMaxT1[j];
+      let lo = 0, hi = P.length - 1, last = -1;
+      while (lo <= hi) {
+        const mid = lo + hi >> 1;
+        if (P[mid].t0 <= t1 - HALF_CELL) {
+          last = mid;
+          lo = mid + 1;
+        } else hi = mid - 1;
+      }
+      for (let i = last; i >= 0; i--) {
+        if (M[i] < t0 + HALF_CELL) break;
+        const p = P[i];
+        if (p.w === w && Math.min(p.t1, t1) - Math.max(p.t0, t0) >= HALF_CELL) return true;
+      }
+      return false;
+    };
+    const nearestRow = (j, dir, w, t0, t1) => {
+      for (let r = j + dir; r >= 0 && r < rowD.length; r += dir) {
+        if (Math.abs(rowD[r] - rowD[j]) > pitchCapPx + HALF_CELL) break;
+        if (rowHas(r, w, t0, t1)) return r;
+      }
+      return -1;
+    };
+    const rowAt = (target, w, t0, t1) => {
+      let lo = 0, hi = rowD.length - 1;
+      while (lo < hi) {
+        const mid = lo + hi >> 1;
+        if (rowD[mid] < target - HALF_CELL) lo = mid + 1;
+        else hi = mid;
+      }
+      for (let r = lo; r < rowD.length && rowD[r] <= target + HALF_CELL; r++) {
+        if (rowD[r] >= target - HALF_CELL && rowHas(r, w, t0, t1)) return true;
+      }
+      return false;
+    };
+    for (let k = 0; k < pieces.length; k++) {
+      const c = pieces[k];
+      const j = rowOf[k];
+      const up = nearestRow(j, 1, c.w, c.t0, c.t1);
+      const dn = nearestRow(j, -1, c.w, c.t0, c.t1);
+      if (up < 0 || dn < 0) continue;
+      const pUp = rowD[up] - rowD[j], pDn = rowD[j] - rowD[dn];
+      const at = (mult, p) => rowAt(rowD[j] + mult * p, c.w, c.t0, c.t1);
+      for (const p of pUp === pDn ? [pUp] : [pUp, pDn]) {
+        if (p < HALF_CELL || p > pitchCapPx + HALF_CELL) continue;
+        const interior = at(1, p) && at(-1, p) && (at(2, p) || at(-2, p));
+        const clipped = at(1, p) && at(2, p) && at(3, p) && pDn <= p + HALF_CELL || at(-1, p) && at(-2, p) && at(-3, p) && pUp <= p + HALF_CELL;
+        if (interior || clipped) {
+          soft[c.i] = 1;
+          break;
+        }
+      }
+    }
+  }
+  return soft;
+}
+var HATCH_MIN_RUN = 10;
+var HATCH_PITCH_TOL = 0.35;
+var HATCH_MIN_REGULAR = 0.7;
+var HATCH_OVERLAP_FRAC = 0.5;
+var ROW_EPS = 1.5;
+var WIDE_PROTECT_RATIO = 2;
+var SPAN_PROTECT_RATIO = 3;
 function sweepHatchRuns(segs, meta, ws) {
   const n = segs.length >> 2;
   const clipSoft = [];
@@ -770,13 +1292,6 @@ function sweepHatchRuns(segs, meta, ws) {
   }
   return { clipSoft, runs };
 }
-function classifyHatchSegs(segs, meta, ws) {
-  const soft = new Uint8Array(segs.length >> 2);
-  const { clipSoft, runs } = sweepHatchRuns(segs, meta, ws);
-  for (const i of clipSoft) soft[i] = 1;
-  for (const r of runs) for (const i of r.softIdx) soft[i] = 1;
-  return soft;
-}
 var HATCH_ID_ANGLE_Q = 0.5;
 var HATCH_ID_PITCH_Q = 0.1;
 function hatchFamilies(segs, meta) {
@@ -796,16 +1311,38 @@ function hatchFamilies(segs, meta) {
     };
   });
 }
-function buildMask(segs, imgW, imgH, maxDim = MASK_MAX_DIM, meta = null, roles = null) {
-  const ws = Math.min(1, maxDim / Math.max(imgW, imgH, 1));
-  const mw = Math.max(2, Math.ceil(imgW * ws)), mh = Math.max(2, Math.ceil(imgH * ws));
+var MASK_CURVE_BIT = 4;
+function buildMask(segs, imgW, imgH, maxDim = MASK_MAX_DIM, meta = null, pxPerFt = 0, basePxPerFt = 0, page = null, roles = null) {
+  if (pxPerFt instanceof Uint8Array || pxPerFt === null) {
+    if (!roles) roles = pxPerFt;
+    pxPerFt = 0;
+  }
+  const pg = page && Number.isFinite(page.pageW) && page.pageW > 0 && Number.isFinite(page.pageH) && page.pageH > 0 && Number.isFinite(page.baseScale) && page.baseScale > 0 && Number.isFinite(page.renderScale) && page.renderScale > 0 ? page : null;
+  let k, bW, bH;
+  if (pg) {
+    k = pg.baseScale / pg.renderScale;
+    const bd = baselineImgDims(pg.pageW, pg.pageH, pg.baseScale);
+    bW = bd.w;
+    bH = bd.h;
+  } else {
+    k = Number.isFinite(basePxPerFt) && basePxPerFt > 0 && Number.isFinite(pxPerFt) && pxPerFt > 0 ? basePxPerFt / pxPerFt : 1;
+    bW = imgW * k;
+    bH = imgH * k;
+  }
+  const wsB = Math.min(1, maxDim / Math.max(bW, bH, 1));
+  const mw = Math.max(2, Math.ceil(bW * wsB)), mh = Math.max(2, Math.ceil(bH * wsB));
+  const ws = k * wsB;
   const mask = new Uint8Array(mw * mh);
-  const soft = meta ? classifyHatchSegs(segs, meta, ws) : null;
+  const mppf = Number.isFinite(pxPerFt) && pxPerFt > 0 ? pxPerFt * ws : 0;
+  const soft = meta ? classifyHatchSegs(segs, meta, ws, mppf > 0 ? HATCH_MAX_PITCH_FT * mppf : HATCH_MAX_PITCH) : null;
+  const noDoor = meta ? flagNonDoorArcs(segs, meta) : null;
   let softCount = 0;
   for (let i = 0, si = 0; i + 3 < segs.length; i += 4, si++) {
     const role = roles ? roles[si] : 0;
     if (role === 2 || role === 3 || role === 5 || role === 6) continue;
-    const v = role === 1 || role === 4 ? 1 : soft && soft[si] ? 2 : 1;
+    let v = role === 1 || role === 4 ? 1 : soft && soft[si] ? 2 : 1;
+    if (v === 1 && meta && meta[si] & SEG_CURVE) v = 1 | MASK_CURVE_BIT;
+    if (v & MASK_CURVE_BIT && noDoor && noDoor[si]) v |= MASK_NODOOR_BIT;
     if (v === 2) softCount++;
     let x0 = Math.round(segs[i] * ws), y0 = Math.round(segs[i + 1] * ws);
     const x1 = Math.round(segs[i + 2] * ws), y1 = Math.round(segs[i + 3] * ws);
@@ -826,18 +1363,44 @@ function buildMask(segs, imgW, imgH, maxDim = MASK_MAX_DIM, meta = null, roles =
       }
     }
   }
-  return { mask, mw, mh, ws, softCount };
+  return { mask, mw, mh, ws, softCount, mppf };
+}
+var regionBox = /* @__PURE__ */ new WeakMap();
+function boxOf(region, mw, mh) {
+  return regionBox.get(region) || { x0: 0, y0: 0, x1: mw - 1, y1: mh - 1 };
+}
+var REGION_POOL_MAX = 2;
+var regionPool = [];
+function takeRegion(n) {
+  for (let k = regionPool.length - 1; k >= 0; k--) {
+    if (regionPool[k].length === n) {
+      const b = regionPool.splice(k, 1)[0];
+      b.fill(0);
+      return b;
+    }
+  }
+  return new Uint8Array(n);
+}
+function dropRegion(b) {
+  if (regionPool.length < REGION_POOL_MAX) regionPool.push(b);
 }
 function floodPass(maskObj, ix, iy, barrier) {
   const { mask, mw, mh, ws } = maskObj;
+  const dilDT = maskObj.dilDT;
+  const dilR = dilDT ? maskObj.dilR : -1;
+  const bits = (i) => dilDT === void 0 ? mask[i] : (dilDT[i] <= dilR ? 1 : 0) | mask[i] & 2;
+  const mppf = maskObj.mppf || 0;
+  const tinyPx = mppf > 0 ? Math.max(TINY_PX_FLOOR, Math.round(TINY_SF * mppf * mppf)) : TINY_PX;
+  const minThick = mppf > 0 ? Math.max(MIN_THICK_FLOOR, Math.round(MIN_THICK_FT * mppf)) : MIN_THICK;
+  const nudge = mppf > 0 ? Math.max(NUDGE_PX, Math.round(NUDGE_FT * mppf)) : NUDGE_PX;
   let sx = Math.round(ix * ws), sy = Math.round(iy * ws);
   if (sx < 0 || sy < 0 || sx >= mw || sy >= mh) return { status: "boundary" };
-  if (mask[sy * mw + sx] & barrier) {
+  if (bits(sy * mw + sx) & barrier) {
     let found = null;
-    for (let r = 1; r <= 3 && !found; r++) {
+    for (let r = 1; r <= nudge && !found; r++) {
       for (let dy = -r; dy <= r && !found; dy++) for (let dx = -r; dx <= r; dx++) {
         const nx = sx + dx, ny = sy + dy;
-        if (nx >= 0 && ny >= 0 && nx < mw && ny < mh && !(mask[ny * mw + nx] & barrier)) {
+        if (nx >= 0 && ny >= 0 && nx < mw && ny < mh && !(bits(ny * mw + nx) & barrier)) {
           found = [nx, ny];
           break;
         }
@@ -847,34 +1410,68 @@ function floodPass(maskObj, ix, iy, barrier) {
     sx = found[0];
     sy = found[1];
   }
-  const region = new Uint8Array(mw * mh);
+  const region = takeRegion(mw * mh);
   const cap = Math.floor(mw * mh * LEAK_FRACTION);
-  let count = 0, leaked = false, hardHits = 0, softHits = 0;
+  let count = 0, hardHits = 0, softHits = 0;
   let bx0 = sx, bx1 = sx, by0 = sy, by1 = sy;
-  const stack = [[sx, sy]];
-  while (stack.length) {
-    const popped = stack.pop();
-    const px = popped[0], py = popped[1];
+  let stack = new Int32Array(1024);
+  let sp = 0;
+  const push = (x, y) => {
+    if (sp === stack.length) {
+      const g = new Int32Array(sp * 2);
+      g.set(stack);
+      stack = g;
+    }
+    stack[sp++] = y * mw + x;
+  };
+  const dil = dilDT !== void 0;
+  const dtA = dilDT;
+  push(sx, sy);
+  while (sp > 0) {
+    const cell = stack[--sp];
+    const py = cell / mw | 0, px = cell - py * mw;
+    const row = py * mw;
     let x0 = px;
-    while (x0 > 0 && !(mask[py * mw + x0 - 1] & barrier) && !region[py * mw + x0 - 1]) x0--;
-    if (x0 > 0 && mask[py * mw + x0 - 1] & barrier) {
-      if (mask[py * mw + x0 - 1] & 1) hardHits++;
-      else softHits++;
+    for (; ; ) {
+      if (x0 === 0) break;
+      const j = row + x0 - 1;
+      if ((dil ? (dtA[j] <= dilR ? 1 : 0) | mask[j] & 2 : mask[j]) & barrier) break;
+      if (region[j]) break;
+      x0--;
+    }
+    if (x0 > 0) {
+      const j = row + x0 - 1, b = dil ? (dtA[j] <= dilR ? 1 : 0) | mask[j] & 2 : mask[j];
+      if (b & barrier) {
+        if (b & 1) hardHits++;
+        else softHits++;
+      }
     }
     let x1 = px;
-    while (x1 < mw - 1 && !(mask[py * mw + x1 + 1] & barrier) && !region[py * mw + x1 + 1]) x1++;
-    if (x1 < mw - 1 && mask[py * mw + x1 + 1] & barrier) {
-      if (mask[py * mw + x1 + 1] & 1) hardHits++;
-      else softHits++;
+    for (; ; ) {
+      if (x1 >= mw - 1) break;
+      const j = row + x1 + 1;
+      if ((dil ? (dtA[j] <= dilR ? 1 : 0) | mask[j] & 2 : mask[j]) & barrier) break;
+      if (region[j]) break;
+      x1++;
+    }
+    if (x1 < mw - 1) {
+      const j = row + x1 + 1, b = dil ? (dtA[j] <= dilR ? 1 : 0) | mask[j] & 2 : mask[j];
+      if (b & barrier) {
+        if (b & 1) hardHits++;
+        else softHits++;
+      }
+    }
+    if (x0 === 0 || x1 === mw - 1 || py === 0 || py === mh - 1) {
+      dropRegion(region);
+      return { status: "leak" };
     }
-    if (x0 === 0 || x1 === mw - 1 || py === 0 || py === mh - 1) leaked = true;
     if (x0 < bx0) bx0 = x0;
     if (x1 > bx1) bx1 = x1;
     if (py < by0) by0 = py;
     if (py > by1) by1 = py;
     let upOpen = false, downOpen = false;
     for (let x = x0; x <= x1; x++) {
-      const idx = py * mw + x;
+      const idx = row + x;
       if (region[idx]) {
         upOpen = downOpen = false;
         continue;
@@ -883,14 +1480,15 @@ function floodPass(maskObj, ix, iy, barrier) {
       count++;
       if (py > 0) {
         const u = idx - mw;
-        if (!(mask[u] & barrier) && !region[u]) {
+        const ub = dil ? (dtA[u] <= dilR ? 1 : 0) | mask[u] & 2 : mask[u];
+        if (!(ub & barrier) && !region[u]) {
           if (!upOpen) {
-            stack.push([x, py - 1]);
+            push(x, py - 1);
             upOpen = true;
           }
         } else {
-          if (mask[u] & barrier) {
-            if (mask[u] & 1) hardHits++;
+          if (ub & barrier) {
+            if (ub & 1) hardHits++;
             else softHits++;
           }
           upOpen = false;
@@ -898,87 +1496,686 @@ function floodPass(maskObj, ix, iy, barrier) {
       }
       if (py < mh - 1) {
         const d = idx + mw;
-        if (!(mask[d] & barrier) && !region[d]) {
+        const db = dil ? (dtA[d] <= dilR ? 1 : 0) | mask[d] & 2 : mask[d];
+        if (!(db & barrier) && !region[d]) {
           if (!downOpen) {
-            stack.push([x, py + 1]);
+            push(x, py + 1);
             downOpen = true;
           }
         } else {
-          if (mask[d] & barrier) {
-            if (mask[d] & 1) hardHits++;
+          if (db & barrier) {
+            if (db & 1) hardHits++;
             else softHits++;
           }
           downOpen = false;
         }
       }
     }
-    if (count > cap) return { status: "leak" };
-  }
-  if (leaked) return { status: "leak" };
-  if (count < TINY_PX || bx1 - bx0 + 1 < MIN_THICK || by1 - by0 + 1 < MIN_THICK) return { status: "tiny", count };
-  return { status: "ok", region, count, mw, mh, ws, hardHits, softHits };
-}
-function dilateHard(maskObj, r) {
-  const { mask, mw, mh, ws, softCount } = maskObj;
-  const horiz = new Uint8Array(mask);
-  for (let y = 0; y < mh; y++) {
-    const row = y * mw;
-    for (let x = 0; x < mw; x++) {
-      if (mask[row + x] & 1) {
-        const x1 = Math.min(mw - 1, x + r);
-        for (let i = Math.max(0, x - r); i <= x1; i++) horiz[row + i] |= 1;
+    if (count > cap) {
+      dropRegion(region);
+      return { status: "leak" };
+    }
+  }
+  if (count < tinyPx || bx1 - bx0 + 1 < minThick || by1 - by0 + 1 < minThick) {
+    dropRegion(region);
+    return { status: "tiny", count };
+  }
+  regionBox.set(region, { x0: bx0, y0: by0, x1: bx1, y1: by1 });
+  return { status: "ok", region, count, mw, mh, ws, mppf: mppf || void 0, hardHits, softHits };
+}
+function dilateHard(maskObj, r) {
+  const { mask, mw, mh, ws, softCount, mppf } = maskObj;
+  const horiz = new Uint8Array(mask);
+  for (let y = 0; y < mh; y++) {
+    const row = y * mw;
+    for (let x = 0; x < mw; x++) {
+      if (mask[row + x] & 1) {
+        const x1 = Math.min(mw - 1, x + r);
+        for (let i = Math.max(0, x - r); i <= x1; i++) horiz[row + i] |= 1;
+      }
+    }
+  }
+  const out = new Uint8Array(horiz);
+  for (let y = 0; y < mh; y++) {
+    const row = y * mw;
+    for (let x = 0; x < mw; x++) {
+      if (horiz[row + x] & 1) {
+        const y1 = Math.min(mh - 1, y + r);
+        for (let j = Math.max(0, y - r); j <= y1; j++) out[j * mw + x] |= 1;
+      }
+    }
+  }
+  return { mask: out, mw, mh, ws, softCount, mppf };
+}
+var bridgeCache = /* @__PURE__ */ new WeakMap();
+function bridgedMask(mo, r) {
+  let per = bridgeCache.get(mo.mask);
+  if (!per) {
+    per = [];
+    bridgeCache.set(mo.mask, per);
+  }
+  let m = per[r];
+  if (!m) {
+    m = dilateHard(mo, r).mask;
+    per[r] = m;
+  }
+  return { mask: m, mw: mo.mw, mh: mo.mh, ws: mo.ws, softCount: mo.softCount, mppf: mo.mppf };
+}
+function floodRegionLadder(maskObj, ix, iy, sensitivity) {
+  const r1 = floodPass(maskObj, ix, iy, 3);
+  if (!maskObj.softCount) return r1;
+  if (r1.status === "leak") return r1;
+  const { escalateFrac, growthMax } = escalationParams(sensitivity);
+  let growthCap = Infinity;
+  if (r1.status === "ok") {
+    const blocks = (r1.hardHits || 0) + (r1.softHits || 0);
+    const softFrac = blocks ? (r1.softHits || 0) / blocks : 0;
+    if (softFrac < escalateFrac) return r1;
+    if (softFrac < HATCH_BOUND_FRAC) growthCap = growthMax;
+  }
+  const r2 = floodPass(maskObj, ix, iy, 1);
+  if (r2.status === "ok" && (r1.status !== "ok" || r2.count > r1.count && r2.count <= r1.count * growthCap)) {
+    r2.hatchFiltered = true;
+    r2.hatchTier = growthCap !== Infinity ? "bounded" : r1.status === "ok" ? "override" : "trapped";
+    return r2;
+  }
+  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++;
+        }
       }
     }
   }
-  const out = new Uint8Array(horiz);
-  for (let y = 0; y < mh; y++) {
+  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 = 0; x < mw; x++) {
-      if (horiz[row + x] & 1) {
-        const y1 = Math.min(mh - 1, y + r);
-        for (let j = Math.max(0, y - r); j <= y1; j++) out[j * mw + x] |= 1;
+    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 { mask: out, mw, mh, ws, softCount };
+  return boundary ? virtual / boundary : 1;
 }
-function floodRegion(maskObj, ix, iy, sensitivity = SENS_BALANCED) {
-  const attempt = (m) => {
-    const r1 = floodPass(m, ix, iy, 3);
-    if (!m.softCount) return r1;
-    if (r1.status === "leak") return r1;
-    const { escalateFrac, growthMax } = escalationParams(sensitivity);
-    let growthCap = Infinity;
-    if (r1.status === "ok") {
-      const blocks = (r1.hardHits || 0) + (r1.softHits || 0);
-      const softFrac = blocks ? (r1.softHits || 0) / blocks : 0;
-      if (softFrac < escalateFrac) return r1;
-      if (softFrac < HATCH_BOUND_FRAC) growthCap = growthMax;
-    }
-    const r2 = floodPass(m, ix, iy, 1);
-    if (r2.status === "ok" && (r1.status !== "ok" || r2.count <= r1.count * growthCap)) {
-      r2.hatchFiltered = true;
-      return r2;
-    }
-    return r1;
-  };
-  const r = attempt(maskObj);
-  if (r.status !== "leak") return r;
-  for (let br = 1; br <= GAP_BRIDGE_MAX; br++) {
-    const rb = attempt(dilateHard(maskObj, br));
-    if (rb.status === "ok") {
-      rb.gapBridged = br;
-      return rb;
+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 r;
+  return boundary ? curved / boundary : 0;
 }
 function traceRegion(reg, epsMaskPx = 1.5) {
   const { region, mw, mh, ws } = reg;
   let s = -1;
-  for (let i = 0; i < region.length; i++) if (region[i]) {
-    s = i;
-    break;
+  const b = boxOf(region, mw, mh);
+  for (let y = b.y0; y <= b.y1 && s < 0; y++) {
+    const row = y * mw;
+    for (let x = b.x0; x <= b.x1; x++) if (region[row + x]) {
+      s = row + x;
+      break;
+    }
   }
   if (s < 0) return [];
   const sx = s % mw, sy = s / mw | 0;
@@ -1068,11 +2265,27 @@ 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) {
+function seedLadderPx(b, first = "anchor") {
   const cx = (b.x0 + b.x1) / 2, cy = (b.y0 + b.y1) / 2;
   const h = Math.max(b.y1 - b.y0, 1);
-  return [[cx, cy], [cx, cy + 2 * h], [cx, cy - 2 * h], [cx, cy + 3.5 * h]];
+  const center = [cx, cy], below = [cx, cy + 2 * h];
+  const rest = [[cx, cy - 2 * h], [cx, cy + 3.5 * h]];
+  return first === "below-box" ? [below, center, ...rest] : [center, below, ...rest];
 }
 function isLabelBubblePx(ring, b) {
   let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
@@ -1090,7 +2303,8 @@ function isLabelBubblePx(ring, b) {
 var bboxOf = (s) => [s.x, s.y, s.x + (s.w || 0), s.y + (s.h || 0)];
 var merge = (a, b) => [Math.min(a[0], b[0]), Math.min(a[1], b[1]), Math.max(a[2], b[2]), Math.max(a[3], b[3])];
 var norm = (s) => (s || "").trim().toUpperCase();
-var SCHEDULE_TITLE_RE = /^[A-Z][A-Z ()/&.-]* SCHEDULE( *[-–] *[A-Z0-9 ()/&.-]+)?$/;
+var isVertical = (s) => s.rot != null ? Math.abs(s.rot % 180) === 90 : (s.str || "").trim().length >= 4 && (s.w || 0) > 0 && (s.h || 0) > 2 * s.w;
+var SCHEDULE_TITLE_RE = /^[A-Z][A-Z ()/&.'’-]* SCHEDULE( *[-–] *[A-Z0-9 ()/&.'’-]+)?( *\(?(?:CONTINUATION|CONTINUED|CONT['’]?D?)\.?\)?)?$/;
 var ROLE_SIGNALS = [
   { re: /DEMOLITION\s+PLAN|DEMO\s+PLAN/, role: "demolition", conf: 0.9 },
   { re: /FINISH\s+PLAN|FLOOR\s+PLAN|FURNITURE\s+PLAN|CEILING\s+PLAN/, role: "plan", conf: 0.85 },
@@ -1125,6 +2339,22 @@ function classifySheetRole(sheet) {
     evidence: { sheet: sheet.key, text: best.span.str.trim(), bbox: bboxOf(best.span) }
   };
 }
+var BUILDING_RE = /\b(?:BUILDING|BLDG\.?)\s+([A-Z]\d?|\d{1,2})\b/g;
+var DESIGNATOR_RE = /^([A-Z]\d?|\d{1,2}|[A-Z]{2})$/;
+function buildingMentions(text) {
+  const u = norm(text);
+  if (u.length > 80 || REFERENCE_RE.test(u)) return [];
+  return [...u.matchAll(BUILDING_RE)].map((m) => m[1]);
+}
+function sheetBuilding(sheet) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const sp of sheet.spans) {
+    for (const b of buildingMentions(sp.str)) if (!seen.has(b)) seen.set(b, sp);
+  }
+  if (seen.size !== 1) return null;
+  const [building, span] = [...seen.entries()][0];
+  return { building, evidence: { sheet: sheet.key, text: span.str.trim(), bbox: bboxOf(span) } };
+}
 function clusterRows(spans) {
   const toks = spans.filter((t) => t.str && t.str.trim()).sort((a, b) => a.y - b.y || a.x - b.x);
   const rows = [];
@@ -1142,7 +2372,8 @@ function clusterRows(spans) {
   if (cur.length) rows.push(cur);
   return rows.map((r) => r.sort((a, b) => a.x - b.x));
 }
-var ROOM_HEADERS = ["ROOM", "NO", "NUMBER", "NAME", "FLOOR", "BASE", "WALL", "WALLS", "NORTH", "SOUTH", "EAST", "WEST", "CEILING", "WAINSCOT", "REMARKS", "CLG", "HT"];
+var rowY = (r) => r.reduce((s, t) => s + t.y, 0) / r.length;
+var ROOM_HEADERS = ["ROOM", "NO", "NUMBER", "NAME", "FLOOR", "BASE", "WALL", "WALLS", "NORTH", "SOUTH", "EAST", "WEST", "CEILING", "WAINSCOT", "REMARKS", "CLG", "HT", "BLDG", "BUILDING"];
 var FINISH_HEADERS = ["CODE", "MARK", "MATERIAL", "MANUFACTURER", "PRODUCT", "STYLE", "COLOR", "SIZE", "REMARKS", "DESCRIPTION", "PATTERN"];
 var headerLabel = (s, vocab) => {
   for (const w of norm(s).split(/[^A-Z]+/)) if (w && vocab.includes(w)) return w;
@@ -1164,33 +2395,101 @@ function findHeaderRow(rows, vocab, required, minHits) {
   }
   return null;
 }
+function findRotatedHeader(vert, vocab, required, minHits) {
+  const cands = vert.map((sp) => ({ sp, label: headerLabel(sp.str, vocab) })).filter((c) => !!c.label).sort((a, b) => a.sp.x - b.sp.x);
+  let band = [];
+  let y0 = 0, y1 = 0;
+  const flush = () => {
+    const seen = new Set(band.map((c) => c.label));
+    if (band.length < minHits || seen.size < minHits || !required.some((r) => seen.has(r))) return null;
+    const anchors = [];
+    const used = /* @__PURE__ */ new Set();
+    for (const c of band) if (!used.has(c.label)) {
+      used.add(c.label);
+      anchors.push({ label: c.label, x: c.sp.x + (c.sp.w || 0) / 2 });
+    }
+    return { anchors: anchors.sort((a, b) => a.x - b.x), top: y0, bottom: y1, spans: band.map((c) => c.sp) };
+  };
+  for (const c of cands) {
+    const cy0 = c.sp.y, cy1 = c.sp.y + (c.sp.h || 0);
+    if (band.length && (cy0 > y1 || cy1 < y0)) {
+      const done = flush();
+      if (done) return done;
+      band = [];
+    }
+    if (!band.length) {
+      y0 = cy0;
+      y1 = cy1;
+    } else {
+      y0 = Math.min(y0, cy0);
+      y1 = Math.max(y1, cy1);
+    }
+    band.push(c);
+  }
+  return band.length ? flush() : null;
+}
 var nearestAnchor = (x, anchors) => {
   let best = anchors[0];
   for (const a of anchors) if (Math.abs(a.x - x) < Math.abs(best.x - x)) best = a;
   return best.label;
 };
+function bandLimits(anchors) {
+  const gaps = anchors.slice(1).map((a, i) => a.x - anchors[i].x).sort((a, b) => a - b);
+  const medGap = gaps.length ? gaps[gaps.length >> 1] : 150;
+  return { x0: anchors[0].x - Math.max(80, medGap / 2), x1: anchors[anchors.length - 1].x + Math.max(300, medGap * 3), medGap };
+}
 var CODE_RE = /^[A-Z]{1,4}(-?[A-Z0-9]{1,4})?$/;
 var ROW_KEY_RE = /^\d{1,3}[A-Z]{0,2}$/;
-function extractTable(sheet, kind) {
-  const rows = clusterRows(sheet.spans);
-  const found = kind === "room-finish" ? findHeaderRow(rows, ROOM_HEADERS, ["FLOOR", "BASE"], 4) : findHeaderRow(rows, FINISH_HEADERS, ["CODE", "MARK"], 3);
-  if (!found) return null;
-  const { anchors, rowIndex } = found;
-  const keyRe = kind === "room-finish" ? ROW_KEY_RE : CODE_RE;
+var QUALIFIED_KEY_RE = /^([A-Z]{1,2})-(\d{1,3}[A-Z]{0,2})$/;
+function rowKeyOf(raw, kind, buildings) {
+  const key = norm(raw).replace(/[^A-Z0-9-]/g, "");
+  if (kind === "finish") return CODE_RE.test(key) ? { key } : null;
+  if (ROW_KEY_RE.test(key)) return { key };
+  const q = key.match(QUALIFIED_KEY_RE);
+  if (q && buildings?.has(q[1])) return { key, building: q[1] };
+  return null;
+}
+var numOf = (key) => key.match(QUALIFIED_KEY_RE)?.[2] ?? key;
+function extractTable(sheet, kind, opts = {}) {
+  const horiz = sheet.spans.filter((s) => !isVertical(s));
+  const vert = sheet.spans.filter(isVertical);
+  const rows = clusterRows(horiz);
+  const vocab = kind === "room-finish" ? ROOM_HEADERS : FINISH_HEADERS;
+  const required = kind === "room-finish" ? ["FLOOR", "BASE"] : ["CODE", "MARK"];
+  const minHits = kind === "room-finish" ? 4 : 3;
+  let anchors;
+  let headerSpans;
+  let dataFrom;
+  let dataBelowY = -Infinity;
+  let titleFrom;
+  let rotated = false;
+  const flat = findHeaderRow(rows, vocab, required, minHits);
+  if (flat) {
+    anchors = flat.anchors;
+    headerSpans = rows[flat.rowIndex];
+    dataFrom = flat.rowIndex + 1;
+    titleFrom = flat.rowIndex - 1;
+  } else {
+    const rot = findRotatedHeader(vert, vocab, required, minHits);
+    if (!rot) return null;
+    rotated = true;
+    anchors = rot.anchors;
+    headerSpans = rot.spans;
+    dataBelowY = rot.bottom - 2;
+    dataFrom = 0;
+    titleFrom = rows.findIndex((r) => rowY(r) >= rot.top) - 1;
+    if (titleFrom < -1) titleFrom = rows.length - 1;
+  }
   const out = [];
   let region = null;
-  const headerRow = rows[rowIndex];
-  for (const t of headerRow) region = region ? merge(region, bboxOf(t)) : bboxOf(t);
-  const gaps = anchors.slice(1).map((a, i) => a.x - anchors[i].x).sort((a, b) => a - b);
-  const medGap = gaps.length ? gaps[gaps.length >> 1] : 150;
-  const x0 = anchors[0].x - Math.max(80, medGap / 2);
-  const x1 = anchors[anchors.length - 1].x + Math.max(300, medGap * 3);
-  for (let i = rowIndex + 1; i < rows.length; i++) {
+  for (const t of headerSpans) region = region ? merge(region, bboxOf(t)) : bboxOf(t);
+  const { x0, x1 } = bandLimits(anchors);
+  for (let i = Math.max(dataFrom, 0); i < rows.length; i++) {
+    if (rotated && rowY(rows[i]) <= dataBelowY) continue;
     const inBand = rows[i].filter((t) => t.x >= x0 && t.x <= x1);
     if (!inBand.length) continue;
-    const keyTok = inBand[0];
-    const key = norm(keyTok.str).replace(/[^A-Z0-9-]/g, "");
-    if (!keyRe.test(key)) continue;
+    const keyed = rowKeyOf(inBand[0].str, kind, opts.buildings);
+    if (!keyed) continue;
     const cells = {};
     for (const t of inBand) {
       const label = nearestAnchor(t.x, anchors);
@@ -1201,28 +2500,101 @@ function extractTable(sheet, kind) {
       }
       region = region ? merge(region, bboxOf(t)) : bboxOf(t);
     }
-    out.push({ key, cells });
+    const row = { key: keyed.key, sheet: sheet.key, cells };
+    const cellB = norm(cells.BLDG?.text || cells.BUILDING?.text || "");
+    const b = keyed.building ?? (DESIGNATOR_RE.test(cellB) ? cellB : void 0);
+    if (b) row.building = b;
+    out.push(row);
   }
   if (!out.length) return null;
   let title = null;
-  for (let i = rowIndex - 1; i >= 0 && i >= rowIndex - 6 && !title; i--) {
+  for (let i = titleFrom; i >= 0 && i >= titleFrom - 5 && !title; i--) {
     const hit = rows[i].find((t) => /SCHEDULE/.test(norm(t.str)) && t.x >= x0 && t.x <= x1);
     if (hit) title = { sheet: sheet.key, text: hit.str.trim(), bbox: bboxOf(hit) };
   }
-  return { kind, sheet: sheet.key, title, headers: anchors.map((a) => a.label), rows: out, region };
+  const table = { kind, sheet: sheet.key, title, headers: anchors.map((a) => a.label), rows: out, region, anchors };
+  if (rotated) table.rotated_headers = true;
+  return table;
+}
+var CONT_TAIL_RE = /[\s\-–—:.,(]*(?:CONTINUATION|CONTINUED|CONT['’]?D?)[\s.)]*$/;
+var isContinuationTitle = (text) => {
+  const u = norm(text);
+  return /SCHEDULE/.test(u) && CONT_TAIL_RE.test(u);
+};
+var baseTitleOf = (text) => norm(text).replace(CONT_TAIL_RE, "").replace(/[\s\-–—:.,()]+$/, "").trim();
+function findContinuationBase(logical, frag) {
+  const sameKind = logical.filter((t) => t.kind === frag.kind && (frag.building == null || t.building == null || t.building === frag.building));
+  if (!sameKind.length) return null;
+  const fragBase = baseTitleOf(frag.title.text);
+  const titled = sameKind.filter((t) => t.title && baseTitleOf(t.title.text) === fragBase);
+  const pool = titled.length ? titled : sameKind;
+  return pool[pool.length - 1];
+}
+function mergeContinuation(base, frag) {
+  if (!base.parts) {
+    base.parts = [{ sheet: base.sheet, title: base.title?.text || "", rows: base.rows.length, region: base.region, ...base.rotated_headers ? { rotated_headers: true } : {} }];
+  }
+  for (const r of frag.rows) if (r.building == null && frag.building != null) r.building = frag.building;
+  base.parts.push({ sheet: frag.sheet, title: frag.title?.text || "", rows: frag.rows.length, region: frag.region, ...frag.rotated_headers ? { rotated_headers: true } : {} });
+  base.rows.push(...frag.rows);
+}
+function adoptContinuationRows(sheet, titleSpan, base, buildings) {
+  if (!base.anchors?.length || base.kind === "unknown") return null;
+  const rows = clusterRows(sheet.spans.filter((s) => !isVertical(s)));
+  const { x0, x1, medGap } = bandLimits(base.anchors);
+  const keyTol = Math.max(40, medGap / 2);
+  const out = [];
+  let region = bboxOf(titleSpan);
+  for (const row of rows) {
+    if (rowY(row) <= titleSpan.y) continue;
+    const inBand = row.filter((t) => t.x >= x0 && t.x <= x1);
+    if (!inBand.length) continue;
+    const keyed = rowKeyOf(inBand[0].str, base.kind, buildings);
+    if (!keyed || Math.abs(inBand[0].x - base.anchors[0].x) > keyTol) continue;
+    const cells = {};
+    for (const t of inBand) {
+      const label = nearestAnchor(t.x, base.anchors);
+      const text = t.str.trim();
+      if (!cells[label]) cells[label] = { text, bbox: bboxOf(t) };
+      else {
+        cells[label] = { text: `${cells[label].text} ${text}`, bbox: merge(cells[label].bbox, bboxOf(t)) };
+      }
+      region = merge(region, bboxOf(t));
+    }
+    const r = { key: keyed.key, sheet: sheet.key, cells };
+    if (keyed.building) r.building = keyed.building;
+    out.push(r);
+  }
+  if (!out.length) return null;
+  return {
+    kind: base.kind,
+    sheet: sheet.key,
+    title: { sheet: sheet.key, text: titleSpan.str.trim(), bbox: bboxOf(titleSpan) },
+    headers: base.headers,
+    rows: out,
+    region
+  };
 }
-function roomTags(sheet) {
+var QUALIFIED_TAG_RE = /^([A-Z]{1,2})-(\d{2,3}[A-Z]?)$/;
+function roomTags(sheet, opts = {}) {
   const out = [];
   const spans = sheet.spans;
+  const accept = (t) => {
+    if (ROOM_LABEL_RE.test(t)) return { ok: true };
+    const q = norm(t).match(QUALIFIED_TAG_RE);
+    if (q && opts.buildings?.has(q[1]) && !opts.exclude?.has(norm(t).replace(/[^A-Z0-9]/g, ""))) return { ok: true, building: q[1] };
+    return { ok: false };
+  };
   for (const sp of spans) {
     const t = sp.str.trim();
-    if (!ROOM_LABEL_RE.test(t)) continue;
+    const a = accept(t);
+    if (!a.ok) continue;
     const b = bboxOf(sp);
     const hgt = Math.max(sp.h || 8, 6);
     let name = "";
     let best = Infinity;
     for (const cand of spans) {
-      if (cand === sp || ROOM_LABEL_RE.test(cand.str.trim())) continue;
+      if (cand === sp || accept(cand.str.trim()).ok) continue;
       const cb = bboxOf(cand);
       const dy = b[1] - cb[3];
       if (dy < -hgt * 0.2 || dy > hgt * 2.2) continue;
@@ -1233,7 +2605,9 @@ function roomTags(sheet) {
         name = cand.str.trim();
       }
     }
-    out.push({ tag: t, name, sheet: sheet.key, bbox: b });
+    const tag = { tag: t, name, sheet: sheet.key, bbox: b };
+    if (a.building) tag.building = a.building;
+    out.push(tag);
   }
   return out;
 }
@@ -1248,65 +2622,190 @@ function detailCallouts(sheet) {
 }
 function buildSheetGraph(sheets) {
   const withText = sheets.filter((s) => s.spans.length > 0);
-  if (!withText.length) return { available: false, sheets: [], rooms: [], tables: [], callouts: [] };
+  if (!withText.length) return { available: false, sheets: [], rooms: [], tables: [], callouts: [], buildings: [], notes: [] };
+  const notes = [];
+  const ctxBySheet = /* @__PURE__ */ new Map();
+  const buildings = /* @__PURE__ */ new Set();
+  for (const s of withText) {
+    for (const sp of s.spans) for (const b of buildingMentions(sp.str)) buildings.add(b);
+    const ctx = sheetBuilding(s);
+    if (ctx) ctxBySheet.set(s.key, ctx.building);
+  }
+  const roles = /* @__PURE__ */ new Map();
+  const fragments = [];
+  const fragmentKinds = /* @__PURE__ */ new Map();
+  for (const s of withText) {
+    roles.set(s.key, classifySheetRole(s));
+    for (const kind of ["room-finish", "finish"]) {
+      const t = extractTable(s, kind, { buildings });
+      if (!t) continue;
+      const titleB = t.title ? buildingMentions(t.title.text) : [];
+      const b = titleB.length === 1 ? titleB[0] : ctxBySheet.get(s.key);
+      if (b) t.building = b;
+      for (const r of t.rows) if (r.building) buildings.add(r.building);
+      fragments.push(t);
+      if (!fragmentKinds.has(s.key)) fragmentKinds.set(s.key, /* @__PURE__ */ new Set());
+      fragmentKinds.get(s.key).add(kind);
+    }
+  }
   const tables = [];
+  for (const f of fragments) {
+    const base = f.title && isContinuationTitle(f.title.text) ? findContinuationBase(tables, f) : null;
+    if (base) mergeContinuation(base, f);
+    else {
+      if (f.title && isContinuationTitle(f.title.text)) {
+        notes.push(`${f.sheet}: "${f.title.text}" reads as a continuation but no earlier ${f.kind} table matches \u2014 kept as a standalone table`);
+      }
+      tables.push(f);
+    }
+  }
+  for (const s of withText) {
+    for (const sp of s.spans) {
+      const text = sp.str.trim();
+      if (!isContinuationTitle(text)) continue;
+      const fragBase = baseTitleOf(text);
+      const base = [...tables].reverse().find((t) => t.kind !== "unknown" && t.title && baseTitleOf(t.title.text) === fragBase && t.sheet !== s.key && !t.parts?.some((p) => p.sheet === s.key));
+      if (!base || fragmentKinds.get(s.key)?.has(base.kind)) continue;
+      const adopted = adoptContinuationRows(s, sp, base, buildings);
+      if (adopted) {
+        if (adopted.building == null && ctxBySheet.get(s.key)) adopted.building = ctxBySheet.get(s.key);
+        mergeContinuation(base, adopted);
+        for (const r of adopted.rows) if (r.building) buildings.add(r.building);
+      } else {
+        notes.push(`${s.key}: "${text}" reads as a continuation of ${base.sheet} but no rows aligned to that table's columns \u2014 rows there are NOT indexed`);
+      }
+    }
+  }
+  const sheetNumbers = /* @__PURE__ */ new Set();
+  for (const s of sheets) {
+    const n = norm(s.sheet_number || "").replace(/[^A-Z0-9]/g, "");
+    if (n) sheetNumbers.add(n);
+  }
   const rooms = [];
   const callouts = [];
-  const outSheets = [];
   for (const s of withText) {
-    const role = classifySheetRole(s);
-    const found = [];
-    for (const kind of ["room-finish", "finish"]) {
-      const t = extractTable(s, kind);
-      if (t) {
-        found.push(t);
-        tables.push(t);
+    const role = roles.get(s.key);
+    if (role.role === "plan" || role.role === "unknown" || role.role === "demolition") {
+      const ctxB = ctxBySheet.get(s.key);
+      for (const r of roomTags(s, { buildings, exclude: sheetNumbers })) {
+        if (r.building == null && ctxB) r.building = ctxB;
+        rooms.push(r);
       }
     }
-    if (role.role === "plan" || role.role === "unknown" || role.role === "demolition") rooms.push(...roomTags(s));
     callouts.push(...detailCallouts(s));
-    outSheets.push({
-      key: s.key,
-      role: role.role,
-      confidence: role.confidence,
-      evidence: role.evidence,
-      schedules: found.map((t) => ({ kind: t.kind, title: t.title?.text || "", rows: t.rows.length, region: t.region }))
-    });
   }
-  return { available: true, sheets: outSheets, rooms, tables, callouts };
+  const outSheets = withText.map((s) => {
+    const role = roles.get(s.key);
+    const schedules = [];
+    for (const t of tables) {
+      const parts = t.parts ?? [{ sheet: t.sheet, title: t.title?.text || "", rows: t.rows.length, region: t.region, ...t.rotated_headers ? { rotated_headers: true } : {} }];
+      for (let i = 0; i < parts.length; i++) {
+        const p = parts[i];
+        if (p.sheet !== s.key) continue;
+        schedules.push({
+          kind: t.kind,
+          title: p.title || t.title?.text || "",
+          rows: p.rows,
+          region: p.region,
+          ...i > 0 ? { continues: t.sheet } : {},
+          ...p.rotated_headers ? { rotated_headers: true } : {}
+        });
+      }
+    }
+    const entry = { key: s.key, role: role.role, confidence: role.confidence, evidence: role.evidence, schedules };
+    const b = ctxBySheet.get(s.key);
+    if (b) entry.building = b;
+    return entry;
+  });
+  return { available: true, sheets: outSheets, rooms, tables, callouts, buildings: [...buildings].sort(), notes };
 }
 var SURFACE_HEADERS = ["FLOOR", "BASE", "WALL", "WALLS", "NORTH", "SOUTH", "EAST", "WEST", "CEILING", "WAINSCOT"];
 function resolveTag(graph, tag) {
-  const t = norm(tag);
-  const room = graph.rooms.find((r2) => norm(r2.tag) === t) || null;
+  const t = norm(tag).replace(/\s+/g, "");
+  const q = t.match(QUALIFIED_KEY_RE);
+  const wantB = q ? q[1] : null;
+  const num2 = q ? q[2] : t;
+  const rooms = graph.rooms.filter((r2) => {
+    const rt = norm(r2.tag).replace(/\s+/g, "");
+    return rt === t || numOf(rt) === num2;
+  });
+  const pickRoom = (b) => {
+    if (b) return rooms.find((r2) => r2.building === b) ?? rooms.find((r2) => !r2.building) ?? null;
+    const distinct = new Set(rooms.map((r2) => r2.building || ""));
+    return distinct.size > 1 ? null : rooms[0] ?? null;
+  };
   const roomTables = graph.tables.filter((x) => x.kind === "room-finish");
-  if (!roomTables.length) return { status: "unresolved", tag: t, room, reason: "no room-finish schedule found in the set" };
-  const matches = roomTables.flatMap((tab2) => tab2.rows.filter((r2) => norm(r2.key) === t).map((r2) => ({ tab: tab2, r: r2 })));
-  if (!matches.length) return { status: "unresolved", tag: t, room, reason: `no schedule row for ${t} \u2014 the plan shows the room but no room-finish table lists it` };
-  if (matches.length > 1) return { status: "unresolved", tag: t, room, reason: `ambiguous: ${matches.length} schedule rows match ${t} (room numbers reused across the set?)` };
-  const { tab, r } = matches[0];
+  if (!roomTables.length) return { status: "unresolved", tag: t, room: pickRoom(wantB), reason: "no room-finish schedule found in the set" };
+  const cands = [];
+  for (const tab2 of roomTables) {
+    for (const r2 of tab2.rows) {
+      if (numOf(norm(r2.key)) !== num2) continue;
+      const b = r2.building ?? tab2.building;
+      cands.push({ tab: tab2, r: r2, ...b ? { building: b } : {} });
+    }
+  }
+  const describe = (c) => `${c.building ? `building ${c.building}` : "no building"} (${c.r.sheet})`;
+  const wire = (c) => ({ key: c.r.key, ...c.building ? { building: c.building } : {}, sheet: c.r.sheet, table: c.tab.title?.text || `${c.tab.kind} schedule` });
+  let chosen;
+  if (wantB) {
+    const filtered = cands.filter((c) => c.building === wantB);
+    if (!filtered.length) {
+      if (!graph.buildings.length) {
+        return { status: "unresolved", tag: t, room: pickRoom(wantB), reason: `the set names no buildings \u2014 no BUILDING/BLDG text or qualified schedule keys anywhere; try resolve_tag "${num2}"`, ...cands.length ? { candidates: cands.map(wire) } : {} };
+      }
+      if (!graph.buildings.includes(wantB)) {
+        return { status: "unresolved", tag: t, room: pickRoom(wantB), reason: `the set names no building "${wantB}" (buildings found: ${graph.buildings.join(", ")})`, ...cands.length ? { candidates: cands.map(wire) } : {} };
+      }
+      if (cands.length) {
+        return { status: "unresolved", tag: t, room: pickRoom(wantB), reason: `no building-${wantB} schedule row for ${num2} \u2014 ${num2} is listed under ${cands.map(describe).join(", ")}`, candidates: cands.map(wire) };
+      }
+      return { status: "unresolved", tag: t, room: pickRoom(wantB), reason: `no schedule row for ${t} \u2014 the plan shows the room but no room-finish table lists it` };
+    }
+    if (filtered.length > 1) {
+      return { status: "unresolved", tag: t, room: pickRoom(wantB), reason: `ambiguous: ${filtered.length} schedule rows match ${t} (${filtered.map((c) => c.r.sheet).join(", ")})`, candidates: filtered.map(wire) };
+    }
+    chosen = filtered[0];
+  } else {
+    if (!cands.length) return { status: "unresolved", tag: t, room: pickRoom(null), reason: `no schedule row for ${t} \u2014 the plan shows the room but no room-finish table lists it` };
+    if (cands.length > 1) {
+      const distinctB = [...new Set(cands.filter((c) => c.building).map((c) => c.building))];
+      if (distinctB.length > 1) {
+        return {
+          status: "unresolved",
+          tag: t,
+          room: null,
+          reason: `ambiguous: room ${num2} appears in ${distinctB.length} buildings \u2014 ${cands.map(describe).join(", ")} \u2014 qualify the tag, e.g. "${distinctB[0]}-${num2}"`,
+          candidates: cands.map(wire)
+        };
+      }
+      return { status: "unresolved", tag: t, room: pickRoom(null), reason: `ambiguous: ${cands.length} schedule rows match ${t} (room numbers reused across the set?)`, candidates: cands.map(wire) };
+    }
+    chosen = cands[0];
+  }
+  const { tab, r } = chosen;
+  const room = pickRoom(chosen.building ?? null);
   const finTables = graph.tables.filter((x) => x.kind === "finish");
   const finishes = [];
-  const sources = [{ sheet: tab.sheet, text: `${tab.title?.text || "room-finish schedule"} row ${r.key}`, bbox: r.cells[Object.keys(r.cells)[0]]?.bbox || tab.region }];
+  const sources = [{ sheet: r.sheet, text: `${tab.title?.text || "room-finish schedule"} row ${r.key}`, bbox: r.cells[Object.keys(r.cells)[0]]?.bbox || tab.region }];
   if (room) sources.unshift({ sheet: room.sheet, text: `${room.name ? room.name + " " : ""}${room.tag}`.trim(), bbox: room.bbox });
   for (const surface of SURFACE_HEADERS) {
     const cell = r.cells[surface];
     if (!cell || !cell.text.trim()) continue;
     const code = norm(cell.text).replace(/[^A-Z0-9-]/g, "");
-    const fin = { surface, code: cell.text.trim(), source: { sheet: tab.sheet, text: cell.text.trim(), bbox: cell.bbox } };
+    const fin = { surface, code: cell.text.trim(), source: { sheet: r.sheet, text: cell.text.trim(), bbox: cell.bbox } };
     for (const ft of finTables) {
       const def = ft.rows.find((fr) => norm(fr.key) === code);
       if (def) {
         const cells = {};
         for (const [k, v] of Object.entries(def.cells)) cells[k] = v.text;
-        fin.definition = { cells, source: { sheet: ft.sheet, text: `${ft.title?.text || "finish schedule"} row ${def.key}`, bbox: def.cells[Object.keys(def.cells)[0]]?.bbox || ft.region } };
+        fin.definition = { cells, source: { sheet: def.sheet, text: `${ft.title?.text || "finish schedule"} row ${def.key}`, bbox: def.cells[Object.keys(def.cells)[0]]?.bbox || ft.region } };
         break;
       }
     }
     finishes.push(fin);
   }
   if (!finishes.length) return { status: "unresolved", tag: t, room, reason: `schedule row ${t} exists but carries no finish cells the extractor could band` };
-  return { status: "resolved", tag: t, room, finishes, sources };
+  return { status: "resolved", tag: t, room, ...chosen.building ? { building: chosen.building } : {}, finishes, sources };
 }
 
 // src/format.ts
@@ -1329,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;
@@ -1425,7 +3000,15 @@ function buildRasterMask(rgba, mw, mh, ws = 1, opts = {}) {
   if (polarityMean < INVERT_MEAN) for (let i = 0; i < n; i++) gray[i] = 255 - gray[i];
   let mask = adaptiveThreshold(gray, mw, mh, opts.t, opts.absInk);
   if (opts.bridge !== false) mask = closeMask(mask, mw, mh);
-  return { mask, mw, mh, ws, softCount: 0 };
+  return {
+    mask,
+    mw,
+    mh,
+    ws,
+    softCount: 0,
+    ...opts.dpiLimited ? { dpiLimited: true } : {},
+    ...opts.scanDpi ? { scanDpi: opts.scanDpi } : {}
+  };
 }
 
 // ../web/src/lib/symbolsweep.ts
@@ -1485,12 +3068,7 @@ var EndpointGrid = class {
   }
 };
 var segLen = (segs, i) => Math.hypot(segs[i * 4 + 2] - segs[i * 4], segs[i * 4 + 3] - segs[i * 4 + 1]);
-function sweepSymbols(segs, seedRect, opts = {}) {
-  const tol = opts.tolPx ?? SWEEP_TOL_PX;
-  const scoreHigh = opts.scoreHigh ?? SWEEP_SCORE_HIGH;
-  const scoreLow = opts.scoreLow ?? SWEEP_SCORE_LOW;
-  const maxCandidates = opts.maxCandidates ?? SWEEP_MAX_CANDIDATES;
-  const xforms = transformsFor(opts.rotations ?? true, opts.mirror ?? true);
+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]);
@@ -1529,6 +3107,22 @@ function sweepSymbols(segs, seedRect, opts = {}) {
     sbx1 = Math.max(sbx1, segs[i * 4], segs[i * 4 + 2]);
     sby1 = Math.max(sby1, segs[i * 4 + 1], segs[i * 4 + 3]);
   }
+  return {
+    rel,
+    totalLen,
+    segments: seedIdx.length,
+    center: [seedCx, seedCy],
+    footprint: Math.hypot(sbx1 - sbx0, sby1 - sby0)
+  };
+}
+function matchSymbol(fp, segs, opts = {}) {
+  const tol = opts.tolPx ?? SWEEP_TOL_PX;
+  const scoreHigh = opts.scoreHigh ?? SWEEP_SCORE_HIGH;
+  const scoreLow = opts.scoreLow ?? SWEEP_SCORE_LOW;
+  const maxCandidates = opts.maxCandidates ?? SWEEP_MAX_CANDIDATES;
+  const xforms = transformsFor(opts.rotations ?? true, opts.mirror ?? true);
+  const n = segs.length >> 2;
+  const { rel, totalLen } = fp;
   const lenBucket = /* @__PURE__ */ new Map();
   for (let i = 0; i < n; i++) {
     const b = Math.round(segLen(segs, i));
@@ -1625,174 +3219,114 @@ function sweepSymbols(segs, seedRect, opts = {}) {
       twin.xf = s.xf;
     }
   }
-  const suppressR = Math.max(mergeR, Math.hypot(sbx1 - sbx0, sby1 - sby0) / 2);
-  const away = kept.filter((s) => Math.hypot(s.at[0] - seedCx, s.at[1] - seedCy) > suppressR);
-  const matches = [];
-  const withheld = [];
-  const pct = (v) => Math.round(v * 1e3) / 1e3;
-  const row = (s) => ({
-    at: [Math.round(s.at[0] * 10) / 10, Math.round(s.at[1] * 10) / 10],
-    score: pct(s.score),
-    rotation: s.rotation,
-    mirrored: s.mirrored
-  });
-  for (const s of away) if (s.score >= scoreHigh) matches.push(row(s));
-  for (const s of away) {
-    if (s.score >= scoreHigh) continue;
-    if (matches.some((m) => Math.hypot(m.at[0] - s.at[0], m.at[1] - s.at[1]) <= suppressR)) continue;
-    withheld.push({ ...row(s), reason: `matched ${Math.round(s.score * 100)}% of the seed's linework (commit bar ${Math.round(scoreHigh * 100)}%) \u2014 likely a variant or an overlapped instance; look before counting it` });
-  }
-  const order = (a, b) => a.at[1] - b.at[1] || a.at[0] - b.at[0] || a.rotation - b.rotation || Number(a.mirrored) - Number(b.mirrored);
-  matches.sort(order);
-  withheld.sort(order);
-  return {
-    seed: {
-      segments: seedIdx.length,
-      center: [Math.round(seedCx * 10) / 10, Math.round(seedCy * 10) / 10],
-      length_px: Math.round(totalLen * 10) / 10
-    },
-    matches,
-    withheld,
-    candidates: { considered, dropped }
-  };
-}
-
-// ../web/src/lib/geometry.js
-function starPath(cx, cy, R, points = 4, innerRatio = 0.38) {
-  const r = R * innerRatio;
-  let d = "";
-  for (let i = 0; i < points * 2; i++) {
-    const a = Math.PI * i / points - Math.PI / 2, rad = i % 2 === 0 ? R : r;
-    d += `${i === 0 ? "M" : "L"}${cx + rad * Math.cos(a)},${cy + rad * Math.sin(a)} `;
-  }
-  return d + "Z";
-}
-function arrowheadPath(fromX, fromY, tipX, tipY, size = 6) {
-  let dx = tipX - fromX, dy = tipY - fromY;
-  const len = Math.hypot(dx, dy);
-  if (len < 1e-6) {
-    dx = 0;
-    dy = 1;
-  } else {
-    dx /= len;
-    dy /= len;
-  }
-  const bx = tipX - dx * size, by = tipY - dy * size;
-  const nx = -dy, ny = dx, half = size * 0.5;
-  return `M${tipX},${tipY} L${bx + nx * half},${by + ny * half} L${bx - nx * half},${by - ny * half} Z`;
-}
-function arcToBezier(x0, y0, x1, y1, r, laf, sf) {
-  const dx = (x0 - x1) / 2, dy = (y0 - y1) / 2;
-  let rr = Math.abs(r) || 1;
-  const lambda = (dx * dx + dy * dy) / (rr * rr);
-  if (lambda > 1) rr *= Math.sqrt(lambda);
-  const sign = laf !== sf ? 1 : -1;
-  const num2 = rr * rr * rr * rr - rr * rr * dy * dy - rr * rr * dx * dx;
-  const den = rr * rr * dy * dy + rr * rr * dx * dx;
-  const coef = sign * Math.sqrt(Math.max(0, den === 0 ? 0 : num2 / den));
-  const cxp = coef * dy, cyp = -coef * dx;
-  const ang = (ux, uy, vx, vy) => {
-    const dot = ux * vx + uy * vy, len = Math.hypot(ux, uy) * Math.hypot(vx, vy) || 1;
-    let a = Math.acos(Math.max(-1, Math.min(1, dot / len)));
-    if (ux * vy - uy * vx < 0) a = -a;
-    return a;
-  };
-  const th1 = ang(1, 0, (dx - cxp) / rr, (dy - cyp) / rr);
-  let dth = ang((dx - cxp) / rr, (dy - cyp) / rr, (-dx - cxp) / rr, (-dy - cyp) / rr);
-  if (!sf && dth > 0) dth -= 2 * Math.PI;
-  if (sf && dth < 0) dth += 2 * Math.PI;
-  const th2 = th1 + dth;
-  const alpha = 4 / 3 * Math.tan(dth / 4);
-  return [
-    x0 - alpha * rr * Math.sin(th1),
-    y0 + alpha * rr * Math.cos(th1),
-    x1 + alpha * rr * Math.sin(th2),
-    y1 - alpha * rr * Math.cos(th2)
-  ];
-}
-function cloudBezier(x0, y0, x1, y1) {
-  const ax0 = Math.min(x0, x1), ay0 = Math.min(y0, y1), ax1 = Math.max(x0, x1), ay1 = Math.max(y0, y1);
-  const r = Math.max(6, Math.min(22, (ax1 - ax0 + ay1 - ay0) / 22));
-  const arc = (len) => Math.max(1, Math.round(len / (r * 1.6)));
-  const segments = [];
-  let px = ax0, py = ay0;
-  const edge = (fromX, fromY, toX, toY) => {
-    const n = arc(Math.hypot(toX - fromX, toY - fromY));
-    for (let i = 1; i <= n; i++) {
-      const qx = fromX + (toX - fromX) * (i / n), qy = fromY + (toY - fromY) * (i / n);
-      const [c1x, c1y, c2x, c2y] = arcToBezier(px, py, qx, qy, r, 0, 1);
-      segments.push([[c1x, c1y], [c2x, c2y], [qx, qy]]);
-      px = qx;
-      py = qy;
-    }
-  };
-  edge(ax0, ay0, ax1, ay0);
-  edge(ax1, ay0, ax1, ay1);
-  edge(ax1, ay1, ax0, ay1);
-  edge(ax0, ay1, ax0, ay0);
-  return { start: [ax0, ay0], segments };
-}
-function buildSnapGrid(points, cell) {
-  const map = /* @__PURE__ */ new Map();
-  for (const p of points) {
-    const k = `${Math.floor(p[0] / cell)},${Math.floor(p[1] / cell)}`;
-    let a = map.get(k);
-    if (!a) {
-      a = [];
-      map.set(k, a);
-    }
-    if (a.length < 40) a.push(p);
-  }
-  return { cell, map };
-}
-function nearestSnap(grid, x, y, maxDist) {
-  if (!grid) return null;
-  const { cell, map } = grid, cx = Math.floor(x / cell), cy = Math.floor(y / cell);
-  let best = null, bestD = maxDist * maxDist;
-  for (let gx = cx - 1; gx <= cx + 1; gx++) for (let gy = cy - 1; gy <= cy + 1; gy++) {
-    const a = map.get(`${gx},${gy}`);
-    if (!a) continue;
-    for (const p of a) {
-      const dx = p[0] - x, dy = p[1] - y, d = dx * dx + dy * dy;
-      if (d < bestD) {
-        bestD = d;
-        best = p;
-      }
-    }
-  }
-  return best;
-}
-function closedMetrics(pts) {
-  const n = pts.length;
-  if (n < 3) {
-    let perim2 = 0;
-    for (let i = 1; i < n; i++) perim2 += Math.hypot(pts[i][0] - pts[i - 1][0], pts[i][1] - pts[i - 1][1]);
-    return { area: 0, perim: perim2 };
-  }
-  let area = 0, perim = 0;
-  for (let i = 0; i < n; i++) {
-    const [x1, y1] = pts[i], [x2, y2] = pts[(i + 1) % n];
-    area += x1 * y2 - x2 * y1;
-    perim += Math.hypot(x2 - x1, y2 - y1);
+  const suppressR = Math.max(mergeR, fp.footprint / 2);
+  const ex = opts.excludeCenter;
+  const away = ex ? kept.filter((s) => Math.hypot(s.at[0] - ex[0], s.at[1] - ex[1]) > suppressR) : kept;
+  const matches = [];
+  const withheld = [];
+  const pct = (v) => Math.round(v * 1e3) / 1e3;
+  const row = (s) => ({
+    at: [Math.round(s.at[0] * 10) / 10, Math.round(s.at[1] * 10) / 10],
+    score: pct(s.score),
+    rotation: s.rotation,
+    mirrored: s.mirrored
+  });
+  for (const s of away) if (s.score >= scoreHigh) matches.push(row(s));
+  for (const s of away) {
+    if (s.score >= scoreHigh) continue;
+    if (matches.some((m) => Math.hypot(m.at[0] - s.at[0], m.at[1] - s.at[1]) <= suppressR)) continue;
+    withheld.push({ ...row(s), reason: `matched ${Math.round(s.score * 100)}% of the seed's linework (commit bar ${Math.round(scoreHigh * 100)}%) \u2014 likely a variant or an overlapped instance; look before counting it` });
   }
-  return { area: Math.abs(area) / 2, perim };
+  const order = (a, b) => a.at[1] - b.at[1] || a.at[0] - b.at[0] || a.rotation - b.rotation || Number(a.mirrored) - Number(b.mirrored);
+  matches.sort(order);
+  withheld.sort(order);
+  return { matches, withheld, candidates: { considered, dropped } };
 }
-function openLen(pts) {
-  let L = 0;
-  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;
+
+// ../web/src/lib/provenance.js
+var mintUuid = () => {
+  const c = globalThis.crypto;
+  if (c && typeof c.randomUUID === "function") return c.randomUUID();
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+};
+var nowIso = () => (/* @__PURE__ */ new Date()).toISOString();
+
+// ../web/src/lib/approvals.js
+var APPROVAL_POLICY = {
+  add: "mints id (apr- + uuid) + ts per record; restore: true re-adds VERBATIM at the recorded indices (undo of a lift)",
+  delete: "no stamp; inverse re-adds the removed records verbatim, original order included",
+  replace: "whole-array non-edit (hydrate) \u2014 nothing mints, inverse null (never recorded)"
+};
+var APPROVAL_ACTORS = ["estimator", "agent"];
+var APPROVAL_R = 0.022;
+var APPROVAL_INK = {
+  estimator: { light: "#1f6b4a", dark: "#55b083" },
+  agent: { light: "#6c6a5e", dark: "#9d9a8c" }
+};
+function approvalInk(actor, dark = false) {
+  const c = APPROVAL_INK[actor] || APPROVAL_INK.agent;
+  return dark ? c.dark : c.light;
 }
-function pointInPoly(x, y, pts) {
-  let inside = 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;
+var isPair = (p) => Array.isArray(p) && p.length === 2 && Number.isFinite(p[0]) && Number.isFinite(p[1]);
+function sanitizeApprovals(raw) {
+  const seen = /* @__PURE__ */ new Set();
+  return (Array.isArray(raw) ? raw : []).filter((a) => {
+    if (!a || typeof a !== "object" || Array.isArray(a)) return false;
+    if (!(typeof a.id === "string" && a.id)) return false;
+    if (!APPROVAL_ACTORS.includes(a.actor)) return false;
+    if (!(typeof a.sheet_id === "string" && a.sheet_id)) return false;
+    if (!isPair(a.at)) return false;
+    if (seen.has(a.id)) return false;
+    seen.add(a.id);
+    return true;
+  });
+}
+function approvalTally(approvals) {
+  const t = { estimator: 0, agent: 0 };
+  for (const a of Array.isArray(approvals) ? approvals : []) {
+    if (a && a.actor in t) t[a.actor] += 1;
   }
-  return inside;
+  return t;
 }
-function chiselRibbon(pts, w, nibDeg = 45) {
-  const a = nibDeg * Math.PI / 180, vx = Math.cos(a) * w / 2, vy = -(Math.sin(a) * w) / 2;
-  return [...pts.map(([x, y]) => [x + vx, y + vy]), ...[...pts].reverse().map(([x, y]) => [x - vx, y - vy])];
+function applyApprovalCommand(approvals, cmd) {
+  if (!cmd || !(cmd.type in APPROVAL_POLICY)) {
+    throw new Error(`Unknown approval command type: ${cmd && cmd.type} \u2014 add it to APPROVAL_POLICY (and decide what it mints) first.`);
+  }
+  switch (cmd.type) {
+    case "add": {
+      const minted = cmd.restore ? cmd.approvals : cmd.approvals.map((a) => {
+        const { id, ts, ...rest } = a;
+        if (!APPROVAL_ACTORS.includes(rest.actor)) {
+          throw new Error(`Unknown approval actor: ${rest.actor} \u2014 must be one of ${APPROVAL_ACTORS.join(", ")}.`);
+        }
+        return { id: id || `apr-${mintUuid()}`, ts: ts || nowIso(), ...rest };
+      });
+      let next;
+      if (cmd.restore && Array.isArray(cmd.at) && cmd.at.length === minted.length) {
+        next = approvals.slice();
+        minted.forEach((a, k) => next.splice(Math.min(cmd.at[k], next.length), 0, a));
+      } else {
+        next = [...approvals, ...minted];
+      }
+      return { approvals: next, inverse: { type: "delete", ids: minted.map((a) => a.id) } };
+    }
+    case "delete": {
+      const idSet = new Set(cmd.ids);
+      const removed = [], at = [];
+      approvals.forEach((a, i) => {
+        if (idSet.has(a.id)) {
+          removed.push(a);
+          at.push(i);
+        }
+      });
+      return {
+        approvals: approvals.filter((a) => !idSet.has(a.id)),
+        inverse: { type: "add", approvals: removed, restore: true, at }
+      };
+    }
+    case "replace":
+      return { approvals: Array.isArray(cmd.approvals) ? cmd.approvals : [], inverse: null };
+  }
 }
 
 // ../web/src/lib/num.js
@@ -2593,9 +4127,11 @@ var SNAP_CELL = 24;
 var SNAP_TOL = 7;
 var PALETTE = ["#c96442", "#2f7d54", "#2563eb", "#9333ea", "#b8860b", "#0d9488", "#be185d", "#1f2937", "#dc2626", "#0891b2"];
 var HATCH_IDS = ["solid", "diag", "diag2", "cross", "diagdense", "horiz", "vert", "grid", "brick", "plank", "herring", "basket", "checker", "wave", "dots", "speckle", "iso", "honeycomb", "scan", "plus", "circuit", "topo"];
-var mintUuid = () => globalThis.crypto && typeof globalThis.crypto.randomUUID === "function" ? globalThis.crypto.randomUUID() : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
-var uid = (p) => `${p}-${mintUuid()}`;
+var mintUuid2 = () => globalThis.crypto && typeof globalThis.crypto.randomUUID === "function" ? globalThis.crypto.randomUUID() : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+var uid = (p) => `${p}-${mintUuid2()}`;
 var ANN_SCHEMA = "opentakeoff.takeoff_canvas.v1";
+var sanitizeApprovals2 = sanitizeApprovals;
+var applyApprovalCommand2 = applyApprovalCommand;
 var CONTEXT_MIN_LEN_PX = 2;
 var CONTEXT_MAX_SEGMENTS = 4e3;
 var CONTEXT_MAX_SEGMENTS_CEIL = 2e4;
@@ -2648,6 +4184,9 @@ var Session = class _Session {
   conditions = [];
   markups = [];
   shapes = [];
+  /** Approval-family records (#176) — estimator seals arrive only by import;
+   * agent verdicts mint through markVerdict and nothing else. */
+  approvals = [];
   /** The last assign-from-schedule run's unresolved rooms (0.9.18) — what the
    * marked-set cover discloses as withheld. Replaced per assign run, cleared
    * with the rest of the session on a non-merge load_plan. Seeds ride
@@ -2690,6 +4229,7 @@ var Session = class _Session {
       this.conditions = [];
       this.shapes = [];
       this.markups = [];
+      this.approvals = [];
       this.file = null;
       this.filePath = null;
       this.nextOrd = 1;
@@ -2977,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;
   }
@@ -2996,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));
@@ -3088,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 {
@@ -3136,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 = {
@@ -3161,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.");
@@ -3172,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})` : ""}.`
@@ -3203,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 }, {
@@ -3210,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)
@@ -3224,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);
@@ -3294,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) {
@@ -3310,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;
@@ -3333,8 +4935,7 @@ var Session = class _Session {
         areaPx2: ringArea(ring),
         perimPx: closedMetrics(ring).perim,
         seed,
-        hatch,
-        gap,
+        ev,
         merged: []
       };
       byRing.set(key, cand);
@@ -3342,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) {
@@ -3360,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) {
@@ -3379,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);
@@ -3552,11 +5156,24 @@ var Session = class _Session {
    * square symmetry group, score each as the length-weighted fraction of seed
    * segments reproduced within tolerance. This method is the plumbing plus
    * the wire shapes: rect clamping, the scan refusal, and the commit path —
-   * match centers through placeCount (ONE undo step, EA scale-free), origins
-   * telling the truth (`method: "symbol_sweep"`, per-match score/transform),
-   * withheld placements NEVER committed. */
+   * match centers through the placeCount path (ONE undo step, EA scale-free),
+   * origins telling the truth (`method: "symbol_sweep"`, per-match
+   * score/transform), withheld placements NEVER committed.
+   *
+   * scope "set" (phase 2) sweeps the whole working set, restricted to
+   * PLAN-role sheets by the sheet graph: a symbol instance drawn in a detail,
+   * legend, or schedule is a reference drawing, not installed work, and must
+   * never count itself. The seed rect may sit on ANY sheet — marqueeing the
+   * assembly on a detail sheet is the estimator's own gesture — and a
+   * non-plan seed sheet serves as the fingerprint SOURCE while staying
+   * excluded from counting. Every excluded sheet is disclosed in `skipped`
+   * with its role and reason; per-sheet results carry their own match /
+   * withheld / cap accounting plus wall-clock elapsed_ms. The whole set-wide
+   * commit is ONE undo step: the gesture the agent made was "sweep the set",
+   * and taking it back should not require one undo per sheet. */
   async symbolSweep(name, opts) {
     const s = this.sheet(name);
+    const scope = opts.scope ?? "sheet";
     if (opts.commit && !opts.condition) {
       throw new UserError("commit: true needs a condition \u2014 the finish tag the match markers count under (e.g. 'FD-1').");
     }
@@ -3578,44 +5195,350 @@ var Session = class _Session {
       mirror: opts.mirror ?? true,
       tolPx: opts.tolerancePx ?? SWEEP_TOL_PX
     };
-    let res;
+    let fp;
     try {
-      res = sweepSymbols(geo.segs, rect, sweepOpts);
+      fp = fingerprintSymbol(geo.segs, rect);
     } catch (e) {
       throw new UserError(e instanceof Error ? e.message : String(e));
     }
+    const seedOut = {
+      sheet: s.key,
+      segments: fp.segments,
+      center: [round1(fp.center[0]), round1(fp.center[1])],
+      rect: [round1(rect[0][0]), round1(rect[0][1]), round1(rect[1][0]), round1(rect[1][1])],
+      length_px: round1(fp.totalLen)
+    };
+    if (scope === "sheet") {
+      const res = matchSymbol(fp, geo.segs, { ...sweepOpts, excludeCenter: fp.center });
+      let committed2;
+      if (opts.commit && res.matches.length) {
+        committed2 = this.placeCount(name, res.matches.map((m) => m.at), {
+          condition: opts.condition,
+          tool: "symbol_sweep",
+          origins: res.matches.map((m) => ({
+            method: "symbol_sweep",
+            actor: "agent",
+            reviewed: false,
+            symbol: { score: m.score, rotation: m.rotation, mirrored: m.mirrored, seed: { source: "instance", sheet: s.key } }
+          }))
+        });
+      }
+      return {
+        scope,
+        found: res.matches.length,
+        matches: res.matches.map((m) => ({ at: [round1(m.at[0]), round1(m.at[1])], score: m.score, rotation: m.rotation, mirrored: m.mirrored })),
+        withheld: res.withheld.map((w) => ({ at: [round1(w.at[0]), round1(w.at[1])], score: w.score, rotation: w.rotation, mirrored: w.mirrored, reason: w.reason })),
+        seed: seedOut,
+        candidates: res.candidates,
+        ...committed2 ? {
+          committed: committed2.committed,
+          shape_ids: committed2.shape_ids,
+          condition: committed2.condition,
+          ea_total: committed2.ea_total
+        } : {},
+        ...opts.commit && !res.matches.length ? { note: "commit requested but nothing cleared the bar \u2014 no shapes were committed." } : {},
+        ...res.candidates.dropped > 0 ? { warning: `Work cap: ${res.candidates.dropped} candidate placement(s) were never scored \u2014 the seed's linework is too common on this sheet for an exhaustive sweep. Tighten the seed rect around more distinctive geometry, or sweep a region at a time and reconcile the counts.` } : {}
+      };
+    }
+    const graph = await this.ensureGraph();
+    if (!graph.available) {
+      throw new UserError("This set has no text layer, so sheet ROLES are unknown \u2014 a set-wide sweep counts PLAN sheets only, and it will not guess which sheets those are. Sweep each sheet explicitly with scope 'sheet'.");
+    }
+    const roleOf = new Map(graph.sheets.map((g) => [g.key, g.role]));
+    const seedRole = roleOf.get(s.key) ?? "unknown";
+    const seedSource = seedRole === "plan" ? "instance" : "detail_sheet";
+    const perSheet = [];
+    const skipped = [];
+    for (const sh of this.sheetList()) {
+      const role = roleOf.get(sh.key) ?? "unknown";
+      if (role !== "plan") {
+        skipped.push({
+          sheet: sh.key,
+          role,
+          reason: sh.key === s.key ? `the seed source \u2014 a symbol drawn on a ${role} sheet defines the fingerprint but is a reference drawing, never installed work` : role === "unknown" ? "role unknown (no classifiable title text) \u2014 sweep it explicitly with scope 'sheet' if it is a plan" : `a ${role} sheet \u2014 symbol instances here are reference drawings, not installed work`
+        });
+        continue;
+      }
+      const g2 = await this.ensureGeometry(sh);
+      if (!g2.segs.length) {
+        skipped.push({ sheet: sh.key, role, reason: "no vector linework (likely a scan) \u2014 symbol matching reads the drawn segments" });
+        continue;
+      }
+      const t0 = process.hrtime.bigint();
+      const res = matchSymbol(fp, g2.segs, { ...sweepOpts, ...sh.key === s.key ? { excludeCenter: fp.center } : {} });
+      const elapsed_ms = Math.round(Number(process.hrtime.bigint() - t0) / 1e4) / 100;
+      perSheet.push({ state: sh, ...res, elapsed_ms });
+    }
+    const found = perSheet.reduce((n, p) => n + p.matches.length, 0);
     let committed;
-    if (opts.commit && res.matches.length) {
-      committed = this.placeCount(name, res.matches.map((m) => m.at), {
-        condition: opts.condition,
-        tool: "symbol_sweep",
-        origins: res.matches.map((m) => ({
-          method: "symbol_sweep",
-          actor: "agent",
-          reviewed: false,
-          symbol: { score: m.score, rotation: m.rotation, mirrored: m.mirrored }
-        }))
-      });
+    if (opts.commit && found) {
+      const ids = [];
+      for (const ps of perSheet) {
+        for (const m of ps.matches) {
+          ids.push(this.commit(ps.state, opts.condition, "count", [m.at], { count: 1 }, {
+            method: "symbol_sweep",
+            actor: "agent",
+            reviewed: false,
+            symbol: { score: m.score, rotation: m.rotation, mirrored: m.mirrored, seed: { source: seedSource, sheet: s.key, role: seedRole } }
+          }).id);
+        }
+      }
+      this.flushCommits("symbol_sweep");
+      const c = this.conditions.find((x) => x.finish_tag === opts.condition);
+      const ea_total = this.shapes.filter((x) => x.condition_id === c.id && x.measure_role === "count").reduce((n, x) => n + (x.computed.count || 1), 0);
+      committed = { committed: ids.length, shape_ids: ids, condition: c.finish_tag, ea_total };
+    }
+    const capped = perSheet.filter((p) => p.candidates.dropped > 0);
+    const notes = [];
+    if (!perSheet.length) notes.push("No plan-role sheet in the set was sweepable \u2014 nothing was counted; skipped[] says why, sheet by sheet.");
+    if (opts.commit && !found) notes.push("commit requested but nothing cleared the bar on any plan sheet \u2014 no shapes were committed.");
+    return {
+      scope,
+      found,
+      seed: { ...seedOut, role: seedRole },
+      sheets: perSheet.map((p) => ({
+        sheet: p.state.key,
+        found: p.matches.length,
+        matches: p.matches.map((m) => ({ at: [round1(m.at[0]), round1(m.at[1])], score: m.score, rotation: m.rotation, mirrored: m.mirrored })),
+        withheld: p.withheld.map((w) => ({ at: [round1(w.at[0]), round1(w.at[1])], score: w.score, rotation: w.rotation, mirrored: w.mirrored, reason: w.reason })),
+        candidates: p.candidates,
+        elapsed_ms: p.elapsed_ms
+      })),
+      skipped,
+      ...committed ?? {},
+      ...notes.length ? { note: notes.join(" ") } : {},
+      ...capped.length ? { warning: `Work cap: candidate placements were dropped un-scored on ${capped.map((p) => p.state.key).join(", ")} \u2014 the seed's linework is too common there for an exhaustive sweep. Tighten the seed rect around more distinctive geometry, or sweep those sheets singly and reconcile the counts.` } : {}
+    };
+  }
+  /** sweep_schedule_row (phase 2) — the estimator's story, honored: a
+   * transition type sometimes exists only as a schedule row plus tag markers
+   * scattered across the plan sheets. Given the ROW's key, this mints the
+   * condition FROM the row (the assign-from-schedule vocabulary: the tag is
+   * the schedule's claim, `origin.assignment {source: "schedule"}` with the
+   * citation) and sweeps every plan sheet for the marker the tag is drawn as.
+   *
+   * THE CONTRACT, stated precisely — refusal-honest, never text-to-geometry
+   * guessing:
+   *   1. The row must exist in a schedule table the sheet graph extracted
+   *      (one row — a key defined twice across tables is ambiguous, refused).
+   *   2. The tag must be DRAWN on at least one plan-role sheet. A row whose
+   *      tag appears nowhere on the plans cannot be geometrically anchored,
+   *      and a fingerprint is NEVER guessed from text alone — refused, with
+   *      the fix (marquee an instance with symbol_sweep).
+   *   3. The fingerprint is the linework around the tag's own drawn
+   *      occurrence (a deterministic pad ladder around the text bbox), and
+   *      where the tag occurs more than once it must CORROBORATE — recur at
+   *      a second occurrence — before it is trusted. No repeatable marker
+   *      geometry → refused.
+   *   4. A geometric match COUNTS only when the row's own tag text sits
+   *      within the marker's footprint — drafting reuses one bubble shape
+   *      across many tags, so geometry alone is not identity. A match
+   *      carrying a SIBLING row's tag is excluded (disclosed with the tag it
+   *      carries); a match carrying no tag is withheld as a question; a tag
+   *      occurrence with no matching geometry is disclosed as text_only.
+   * Commit is ONE undo step for the whole set-wide sweep. */
+  async sweepScheduleRow(tag, opts = {}) {
+    const t = (tag || "").trim().toUpperCase().replace(/\s+/g, "");
+    if (!t) throw new UserError('Pass a schedule-row tag as drawn, e.g. sweep_schedule_row { tag: "T1" }.');
+    const graph = await this.ensureGraph();
+    if (!graph.available) throw new UserError("This set has no text layer (a scan) \u2014 the sheet graph is unavailable, so schedule rows cannot be read.");
+    const rowHits = graph.tables.flatMap((tb2) => tb2.rows.filter((r2) => r2.key === t).map((r2) => ({ tb: tb2, r: r2 })));
+    if (!rowHits.length) {
+      const found2 = graph.tables.map((x) => `${x.kind} on ${x.sheet} (${x.rows.length} rows)`).join(" | ");
+      throw new UserError(`No schedule row "${t}" in the set \u2014 tables found: ${found2 || "none"}. Check the tag as drawn (find_schedule shows each table's region), or merge the schedule sheet in with load_plan.`);
+    }
+    if (rowHits.length > 1) {
+      throw new UserError(`Ambiguous: ${rowHits.length} schedule rows carry the key "${t}" \u2014 the same mark defined twice cannot seed one sweep. Marquee the marker yourself with symbol_sweep.`);
+    }
+    const { tb, r } = rowHits[0];
+    const siblings = [...new Set(graph.tables.flatMap((x) => x.rows.map((row) => row.key)))].filter((k) => k !== t).sort();
+    const table = tb.title?.text || `${tb.kind} schedule`;
+    const roleOf = new Map(graph.sheets.map((g) => [g.key, g.role]));
+    const skipped = [];
+    const planSheets = [];
+    for (const sh of this.sheetList()) {
+      const role = roleOf.get(sh.key) ?? "unknown";
+      if (role === "plan") planSheets.push(sh);
+      else {
+        skipped.push({
+          sheet: sh.key,
+          role,
+          reason: role === "unknown" ? "role unknown (no classifiable title text) \u2014 instances here are not counted" : `a ${role} sheet \u2014 the tag's instances here are reference drawings, never installed work`
+        });
+      }
+    }
+    const occOf = (sh, key) => {
+      if (!sh.spans) sh.spans = textSpans(sh.page);
+      return sh.spans.filter((sp) => sp.str.trim().toUpperCase() === key).map((sp) => ({ cx: (sp.x0 + sp.x1) / 2, cy: (sp.y0 + sp.y1) / 2, h: Math.max(sp.y1 - sp.y0, 6), bbox: [sp.x0, sp.y0, sp.x1, sp.y1] })).sort((a, b) => a.cy - b.cy || a.cx - b.cx);
+    };
+    const occBySheet = planSheets.map((sh) => ({ sh, occ: occOf(sh, t) }));
+    const totalOcc = occBySheet.reduce((n, e) => n + e.occ.length, 0);
+    if (!totalOcc) {
+      throw new UserError(`Schedule row "${t}" (${table} on ${tb.sheet}) cannot be geometrically anchored \u2014 its tag is not drawn on any plan sheet, and a fingerprint is never guessed from text alone. If the marker is drawn untagged, marquee one instance with symbol_sweep {scope: "set"}.`);
+    }
+    const withOcc = occBySheet.filter((e) => e.occ.length > 0).sort((a, b) => b.occ.length - a.occ.length || a.sh.ord - b.sh.ord);
+    const anchorSheet = withOcc[0].sh;
+    const anchor = withOcc[0].occ[0];
+    const anchorGeo = await this.ensureGeometry(anchorSheet);
+    if (!anchorGeo.segs.length) {
+      throw new UserError(`${anchorSheet.key} carries the tag "${t}" but no vector linework \u2014 the marker cannot be fingerprinted on a scan.`);
+    }
+    const sweepOpts = {
+      rotations: opts.rotations ?? true,
+      mirror: opts.mirror ?? true,
+      tolPx: opts.tolerancePx ?? SWEEP_TOL_PX
+    };
+    let corro = null;
+    if (withOcc[0].occ.length > 1) corro = { segs: anchorGeo.segs, occ: withOcc[0].occ.slice(1) };
+    else if (withOcc.length > 1) corro = { segs: (await this.ensureGeometry(withOcc[1].sh)).segs, occ: withOcc[1].occ };
+    const cX = (v) => Math.max(0, Math.min(v, anchorSheet.widthPx));
+    const cY = (v) => Math.max(0, Math.min(v, anchorSheet.heightPx));
+    let fp = null;
+    let anchorRect = null;
+    let corroborated = false;
+    for (const padK of [1, 2, 3]) {
+      const pad = padK * anchor.h;
+      const rect = [
+        [cX(anchor.bbox[0] - pad), cY(anchor.bbox[1] - pad)],
+        [cX(anchor.bbox[2] + pad), cY(anchor.bbox[3] + pad)]
+      ];
+      let cand;
+      try {
+        cand = fingerprintSymbol(anchorGeo.segs, rect);
+      } catch (e) {
+        if (e instanceof Error && /region, not one symbol/.test(e.message)) break;
+        continue;
+      }
+      if (!corro) {
+        fp = cand;
+        anchorRect = rect;
+        break;
+      }
+      const probe = matchSymbol(cand, corro.segs, sweepOpts);
+      const pr = cand.footprint / 2 + anchor.h;
+      if (corro.occ.some((o) => probe.matches.some((m) => Math.hypot(m.at[0] - o.cx, m.at[1] - o.cy) <= pr))) {
+        fp = cand;
+        anchorRect = rect;
+        corroborated = true;
+        break;
+      }
+    }
+    if (!fp || !anchorRect) {
+      throw new UserError(corro ? `Schedule row "${t}" cannot be anchored: the linework around its drawn tag on ${anchorSheet.key} does not recur at the tag's other occurrences \u2014 no repeatable marker geometry to fingerprint. Marquee one instance with symbol_sweep instead.` : `Schedule row "${t}" cannot be anchored: no fingerprintable marker linework sits around its drawn tag on ${anchorSheet.key}. Marquee one instance with symbol_sweep instead.`);
+    }
+    const R = fp.footprint / 2 + anchor.h;
+    const byPos = (a, b) => a.at[1] - b.at[1] || a.at[0] - b.at[0];
+    const perSheet = [];
+    for (const { sh, occ } of occBySheet) {
+      const g2 = await this.ensureGeometry(sh);
+      if (!g2.segs.length) {
+        skipped.push({ sheet: sh.key, role: "plan", reason: "no vector linework (likely a scan) \u2014 symbol matching reads the drawn segments" });
+        continue;
+      }
+      const t0 = process.hrtime.bigint();
+      const res = matchSymbol(fp, g2.segs, sweepOpts);
+      const elapsed_ms = Math.round(Number(process.hrtime.bigint() - t0) / 1e4) / 100;
+      const sibSpans = [];
+      for (const k of siblings) for (const o of occOf(sh, k)) sibSpans.push({ key: k, cx: o.cx, cy: o.cy });
+      const matches = [];
+      const excluded = [];
+      const withheld = [];
+      const matchedOcc = /* @__PURE__ */ new Set();
+      for (const m of res.matches) {
+        let oi = -1;
+        for (let k = 0; k < occ.length; k++) {
+          if (Math.hypot(m.at[0] - occ[k].cx, m.at[1] - occ[k].cy) <= R) {
+            oi = k;
+            break;
+          }
+        }
+        if (oi >= 0) {
+          matchedOcc.add(oi);
+          matches.push({ ...m, tag_at: occ[oi].bbox });
+          continue;
+        }
+        const sib = sibSpans.find((sp) => Math.hypot(m.at[0] - sp.cx, m.at[1] - sp.cy) <= R);
+        if (sib) {
+          excluded.push({ at: m.at, tag: sib.key });
+          continue;
+        }
+        withheld.push({ ...m, reason: `the marker geometry matches but carries no "${t}" tag within its footprint \u2014 an unlabeled instance or a shared marker shape; look before counting it` });
+      }
+      for (const w of res.withheld) {
+        const near = occ.some((o) => Math.hypot(w.at[0] - o.cx, w.at[1] - o.cy) <= R);
+        withheld.push(near ? { ...w, reason: `${w.reason} \u2014 and the "${t}" tag is drawn beside it` } : w);
+      }
+      matches.sort(byPos);
+      excluded.sort(byPos);
+      withheld.sort(byPos);
+      const text_only = occ.filter((o, k) => !matchedOcc.has(k) && !res.withheld.some((w) => Math.hypot(w.at[0] - o.cx, w.at[1] - o.cy) <= R)).map((o) => ({ at: [round1(o.cx), round1(o.cy)] }));
+      perSheet.push({ state: sh, matches, withheld, excluded, text_only, candidates: res.candidates, elapsed_ms });
+    }
+    const found = perSheet.reduce((n, p) => n + p.matches.length, 0);
+    let committed;
+    if (opts.commit && found) {
+      const ids = [];
+      for (const ps of perSheet) {
+        for (const m of ps.matches) {
+          ids.push(this.commit(ps.state, t, "count", [m.at], { count: 1 }, {
+            method: "symbol_sweep",
+            actor: "agent",
+            reviewed: false,
+            assignment: { source: "schedule", schedule_sheet: tb.sheet },
+            symbol: {
+              score: m.score,
+              rotation: m.rotation,
+              mirrored: m.mirrored,
+              seed: { source: "schedule_row", sheet: anchorSheet.key, row: { sheet: tb.sheet, key: t, table } }
+            }
+          }).id);
+        }
+      }
+      this.flushCommits("sweep_schedule_row");
+      const c = this.conditions.find((x) => x.finish_tag === t);
+      const ea_total = this.shapes.filter((x) => x.condition_id === c.id && x.measure_role === "count").reduce((n, x) => n + (x.computed.count || 1), 0);
+      committed = { committed: ids.length, shape_ids: ids, condition: c.finish_tag, ea_total };
     }
+    const cells = {};
+    for (const [k, v] of Object.entries(r.cells)) cells[k] = v.text;
+    const firstCell = r.cells[Object.keys(r.cells)[0]];
+    const capped = perSheet.filter((p) => p.candidates.dropped > 0);
+    const notes = [];
+    if (!corroborated) notes.push(`The tag "${t}" is drawn ${totalOcc === 1 ? "exactly once" : "too sparsely to cross-check"} \u2014 the fingerprint could not corroborate at a second occurrence; audit the matches with view_sheet before trusting the count.`);
+    if (opts.commit && !found) notes.push("commit requested but nothing cleared the bar \u2014 no shapes were committed.");
     return {
-      found: res.matches.length,
-      matches: res.matches.map((m) => ({ at: [round1(m.at[0]), round1(m.at[1])], score: m.score, rotation: m.rotation, mirrored: m.mirrored })),
-      withheld: res.withheld.map((w) => ({ at: [round1(w.at[0]), round1(w.at[1])], score: w.score, rotation: w.rotation, mirrored: w.mirrored, reason: w.reason })),
-      seed: {
-        segments: res.seed.segments,
-        center: [round1(res.seed.center[0]), round1(res.seed.center[1])],
-        rect: [round1(rect[0][0]), round1(rect[0][1]), round1(rect[1][0]), round1(rect[1][1])],
-        length_px: res.seed.length_px
+      tag: t,
+      row: {
+        sheet: tb.sheet,
+        table,
+        key: t,
+        cells,
+        citation: { sheet: tb.sheet, text: `${table} row ${t}`, bbox: _Session.wireBox(firstCell?.bbox || tb.region) }
       },
-      candidates: res.candidates,
-      ...committed ? {
-        committed: committed.committed,
-        shape_ids: committed.shape_ids,
-        condition: committed.condition,
-        ea_total: committed.ea_total
-      } : {},
-      ...opts.commit && !res.matches.length ? { note: "commit requested but nothing cleared the bar \u2014 no shapes were committed." } : {},
-      ...res.candidates.dropped > 0 ? { warning: `Work cap: ${res.candidates.dropped} candidate placement(s) were never scored \u2014 the seed's linework is too common on this sheet for an exhaustive sweep. Tighten the seed rect around more distinctive geometry, or sweep a region at a time and reconcile the counts.` } : {}
+      anchor: {
+        sheet: anchorSheet.key,
+        at: [round1(anchor.cx), round1(anchor.cy)],
+        rect: [round1(anchorRect[0][0]), round1(anchorRect[0][1]), round1(anchorRect[1][0]), round1(anchorRect[1][1])],
+        segments: fp.segments,
+        length_px: round1(fp.totalLen),
+        corroborated,
+        occurrences: totalOcc
+      },
+      found,
+      sheets: perSheet.map((p) => ({
+        sheet: p.state.key,
+        found: p.matches.length,
+        matches: p.matches.map((m) => ({ at: [round1(m.at[0]), round1(m.at[1])], score: m.score, rotation: m.rotation, mirrored: m.mirrored, tag_at: _Session.wireBox(m.tag_at) })),
+        withheld: p.withheld.map((w) => ({ at: [round1(w.at[0]), round1(w.at[1])], score: w.score, rotation: w.rotation, mirrored: w.mirrored, reason: w.reason })),
+        excluded: p.excluded.map((e) => ({ at: [round1(e.at[0]), round1(e.at[1])], tag: e.tag })),
+        text_only: p.text_only,
+        candidates: p.candidates,
+        elapsed_ms: p.elapsed_ms
+      })),
+      skipped,
+      ...committed ?? {},
+      ...notes.length ? { note: notes.join(" ") } : {},
+      ...capped.length ? { warning: `Work cap: candidate placements were dropped un-scored on ${capped.map((p) => p.state.key).join(", ")} \u2014 sweep those sheets singly with symbol_sweep and reconcile the counts.` } : {}
     };
   }
   /** The mid-session shape inventory (#149): every committed shape's id,
@@ -3907,6 +5830,9 @@ var Session = class _Session {
           else c.roll_setup = e.before.roll_setup;
         }
         undone.push({ seq: e.seq, op: e.op, tool: e.tool, shapes: 0 });
+      } 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 });
       } else {
         for (const { shape, index } of e.removed) {
           this.shapes.splice(Math.min(index, this.shapes.length), 0, shape);
@@ -3980,18 +5906,28 @@ var Session = class _Session {
   }
   /** Read annotations, optionally narrowed to a sheet and/or a condition.
    *  Resolves condition_id to its finish tag so a caller can act on the reply
-   *  without joining against the conditions array. */
+   *  without joining against the conditions array.
+   *
+   *  Verdict marks (#176) ride the same inventory as their own block: the
+   *  sheet filter applies directly (a record renders on its sheet), and a
+   *  condition filter reaches a verdict THROUGH its target shape — a verdict
+   *  on a CPT-1 shape is about CPT-1 work, while a sheet-point mark carries
+   *  no scope and drops out of any condition filter. */
   listAnnotations(f = {}) {
     const tagById = new Map(this.conditions.map((c) => [c.id, c.finish_tag]));
     let rows = this.markups;
+    let seals = this.approvals;
     if (f.sheet) {
       const s = this.sheet(f.sheet);
       rows = rows.filter((m) => m.sheet_id === s.key);
+      seals = seals.filter((a) => a.sheet_id === s.key);
     }
+    const shapeById = new Map(this.shapes.map((x) => [x.id, x]));
     if (f.condition) {
       const c = this.conditions.find((x) => x.finish_tag === f.condition);
       if (!c) throw new UserError(`no condition "${f.condition}" \u2014 tags: ${this.conditions.map((x) => x.finish_tag).join(", ") || "(none)"}`);
       rows = rows.filter((m) => m.condition_id === c.id);
+      seals = seals.filter((a) => a.shape_id !== void 0 && shapeById.get(a.shape_id)?.condition_id === c.id);
     }
     const s0 = this.sheets;
     const px = (m, p) => {
@@ -4016,7 +5952,22 @@ var Session = class _Session {
         ...m.len_ft != null ? { length_lf: m.len_ft } : {}
       })),
       count: rows.length,
-      unattached: rows.filter((m) => !m.condition_id).length
+      unattached: rows.filter((m) => !m.condition_id).length,
+      verdicts: seals.map((a) => {
+        const sh = s0.get(a.sheet_id);
+        const target = a.shape_id !== void 0 ? shapeById.get(a.shape_id) : void 0;
+        return {
+          id: a.id,
+          actor: a.actor,
+          sheet: a.sheet_id,
+          ...sh ? { at: [round1(a.at[0] * sh.widthPx), round1(a.at[1] * sh.heightPx)] } : {},
+          ...a.ts ? { ts: a.ts } : {},
+          ...a.shape_id !== void 0 ? { shape_id: a.shape_id } : {},
+          condition: target ? tagById.get(target.condition_id) ?? "" : "",
+          ...typeof a.text === "string" && a.text ? { text: a.text } : {}
+        };
+      }),
+      verdict_count: seals.length
     };
   }
   /** Attach an existing annotation to a condition, or detach it with "". The
@@ -4032,6 +5983,121 @@ var Session = class _Session {
     m.condition_id = c.id;
     return { id: m.id, condition: c.finish_tag, condition_id: c.id, note: `Attached to ${c.finish_tag}.` };
   }
+  // ── verdict marks (#176) — the agent half of the approval family ───────────
+  /** Where a shape-targeted verdict draws, in the space of the verts given.
+   * The anchor is a render decision, not a measurement: a closed room anchors
+   * at its area centroid, an open run at its on-path midpoint (a bent run's
+   * centroid can sit off the work; the midpoint never does), a count marker
+   * at the marker itself. Callers pass SHEET-PX verts so the midpoint is the
+   * drawn run's true midpoint — arc length does not commute with the
+   * non-uniform norm↔px map (centroids do, so they'd be safe either way).
+   * Degenerate geometry falls back to the vertex mean. */
+  static verdictAnchor(v, role) {
+    if (v.length === 1) return [v[0][0], v[0][1]];
+    const closed = role === "floor_area" || role === "deduct";
+    if (closed && v.length >= 3) {
+      let a = 0, cx = 0, cy = 0;
+      for (let i = 0; i < v.length; i++) {
+        const [x1, y1] = v[i], [x2, y2] = v[(i + 1) % v.length];
+        const w = x1 * y2 - x2 * y1;
+        a += w;
+        cx += (x1 + x2) * w;
+        cy += (y1 + y2) * w;
+      }
+      if (Math.abs(a) > 1e-12) return [cx / (3 * a), cy / (3 * a)];
+    } else if (!closed && v.length >= 2) {
+      const lens = [];
+      let total = 0;
+      for (let i = 1; i < v.length; i++) {
+        const l = Math.hypot(v[i][0] - v[i - 1][0], v[i][1] - v[i - 1][1]);
+        lens.push(l);
+        total += l;
+      }
+      let walk = total / 2;
+      for (let i = 0; i < lens.length; i++) {
+        if (walk <= lens[i] && lens[i] > 0) {
+          const t = walk / lens[i];
+          return [v[i][0] + (v[i + 1][0] - v[i][0]) * t, v[i][1] + (v[i + 1][1] - v[i][1]) * t];
+        }
+        walk -= lens[i];
+      }
+    }
+    const n = v.length || 1;
+    return [v.reduce((s, p) => s + p[0], 0) / n, v.reduce((s, p) => s + p[1], 0) / n];
+  }
+  /** Mint the agent's verdict mark. actor is the string literal "agent" on
+   * the one line that writes the record — there is no actor parameter on this
+   * method, on the tool, or anywhere between, so no MCP path can produce the
+   * estimator's APPROVED seal (that ink stays behind the canvas's human-only
+   * Approve tool). The mutation and its exact-restore inverse both come from
+   * the canvas's pure apply, so a mark here undoes and hydrates exactly like
+   * a mark made in the app. Touches no quantity. */
+  markVerdict(a) {
+    let sheetId;
+    let atNorm;
+    let shape;
+    if (a.shape_id !== void 0) {
+      shape = this.shapes.find((x) => x.id === a.shape_id);
+      if (!shape) throw new UserError(`No shape with id ${JSON.stringify(a.shape_id)} \u2014 list_shapes has the real ids.`);
+      const dup = this.approvals.find((x) => x.actor === "agent" && x.shape_id === shape.id);
+      if (dup) throw new UserError(`Shape ${shape.id} already carries an agent verdict (${dup.id}) \u2014 one mark per shape. delete_verdict it first to re-mark.`);
+      sheetId = shape.sheet_id;
+      const dims = this.sheets.get(sheetId);
+      if (dims) {
+        const px = shape.verts_norm.map(([nx, ny]) => [nx * dims.widthPx, ny * dims.heightPx]);
+        const [ax, ay] = _Session.verdictAnchor(px, shape.measure_role);
+        atNorm = [ax / dims.widthPx, ay / dims.heightPx];
+      } else {
+        atNorm = _Session.verdictAnchor(shape.verts_norm, shape.measure_role);
+      }
+    } else {
+      const s = this.sheet(a.sheet);
+      sheetId = s.key;
+      atNorm = [a.at[0] / s.widthPx, a.at[1] / s.heightPx];
+    }
+    const text = (a.text ?? "").trim();
+    const { approvals, inverse } = applyApprovalCommand2(this.approvals, {
+      type: "add",
+      approvals: [{
+        actor: "agent",
+        // hardcoded — the structural impossibility, not a default
+        sheet_id: sheetId,
+        at: atNorm,
+        ...shape ? { shape_id: shape.id } : {},
+        ...text ? { text } : {}
+      }]
+    });
+    this.approvals = approvals;
+    this.record({ op: "approval", tool: "mark_verdict", inverse });
+    const minted = this.approvals[this.approvals.length - 1];
+    const sh = this.sheets.get(sheetId);
+    const tag = shape ? this.conditions.find((c) => c.id === shape.condition_id)?.finish_tag ?? "" : void 0;
+    return {
+      id: minted.id,
+      actor: "agent",
+      sheet: sheetId,
+      ...sh ? { at: [round1(atNorm[0] * sh.widthPx), round1(atNorm[1] * sh.heightPx)] } : {},
+      ts: minted.ts,
+      ...shape ? { shape_id: shape.id } : {},
+      ...tag !== void 0 ? { condition: tag } : {},
+      ...text ? { text } : {},
+      note: shape ? `AGENT diamond anchored on ${shape.id} \u2014 the agent's pencil-signature on its own work, beside the estimator's ink, never in its place. It touches no quantity.` : "AGENT diamond at the sheet point \u2014 the agent's pencil-signature, beside the estimator's ink, never in its place. It touches no quantity."
+    };
+  }
+  /** Lift an agent verdict mark. The estimator's seal is human ink and is
+   * refused — the same line editShape holds on reviewed shapes: an agent
+   * retracts only its own marks. */
+  deleteVerdict(id) {
+    const a = this.approvals.find((x) => x.id === id);
+    if (!a) throw new UserError(`No verdict ${JSON.stringify(id)} \u2014 list_annotations returns the real ids in verdicts[].`);
+    if (a.actor !== "agent") {
+      throw new UserError(`${id} is the estimator's APPROVED seal \u2014 human ink, refused. An agent lifts only its own marks (actor "agent").`);
+    }
+    const { approvals, inverse } = applyApprovalCommand2(this.approvals, { type: "delete", ids: [id] });
+    this.approvals = approvals;
+    this.record({ op: "approval", tool: "delete_verdict", inverse });
+    return { deleted: id, verdicts_remaining: this.approvals.length };
+  }
   /** The exact browser save payload (TakeoffCanvas.jsx autosave + the schema key
    * store.saveAnnotations stamps) — importable by the app. */
   exportPayload() {
@@ -4044,6 +6110,10 @@ var Session = class _Session {
       conditions: this.conditions,
       shapes: this.shapes,
       markups: this.markups,
+      // approvals ride the payload additively (#176) — present only when any
+      // exist, exactly the canvas buildPayload's convention, so a verdict-free
+      // export stays byte-identical to a pre-#176 one
+      ...this.approvals.length ? { approvals: this.approvals } : {},
       sheet_group: [],
       last_group: [],
       sheet_tabs: [],
@@ -4086,7 +6156,7 @@ var Session = class _Session {
         inputs.push({
           key: s.key,
           sheet_number: s.sheetNumber,
-          spans: s.spans.map((t) => ({ str: t.str, x: t.x0, y: t.y0, w: t.x1 - t.x0, h: t.y1 - t.y0 }))
+          spans: s.spans.map((t) => ({ str: t.str, x: t.x0, y: t.y0, w: t.x1 - t.x0, h: t.y1 - t.y0, ...t.rot ? { rot: t.rot } : {} }))
         });
       }
       this.graph = buildSheetGraph(inputs);
@@ -4108,10 +6178,20 @@ var Session = class _Session {
         role: s.role,
         confidence: s.confidence,
         ...s.evidence ? { evidence: _Session.wireEvidence(s.evidence) } : {},
-        schedules: s.schedules.map((t) => ({ kind: t.kind, title: t.title, rows: t.rows, region: _Session.wireBox(t.region) }))
+        ...s.building ? { building: s.building } : {},
+        schedules: s.schedules.map((t) => ({
+          kind: t.kind,
+          title: t.title,
+          rows: t.rows,
+          region: _Session.wireBox(t.region),
+          ...t.continues ? { continues: t.continues } : {},
+          ...t.rotated_headers ? { rotated_headers: true } : {}
+        }))
       })),
-      rooms: g.rooms.map((r) => ({ tag: r.tag, name: r.name, sheet: r.sheet, bbox: _Session.wireBox(r.bbox) })),
+      rooms: g.rooms.map((r) => ({ tag: r.tag, name: r.name, sheet: r.sheet, bbox: _Session.wireBox(r.bbox), ...r.building ? { building: r.building } : {} })),
       callouts: g.callouts.map((c) => ({ detail: c.detail, target_sheet: c.target_sheet, sheet: c.sheet, bbox: _Session.wireBox(c.bbox) })),
+      ...g.buildings.length ? { buildings: g.buildings } : {},
+      ...g.notes.length ? { notes: g.notes } : {},
       counts: { rooms: g.rooms.length, schedules: g.tables.length, callouts: g.callouts.length }
     };
   }
@@ -4138,12 +6218,21 @@ var Session = class _Session {
     const g = await this.ensureGraph();
     if (!g.available) throw new UserError("This set has no text layer (a scan) \u2014 the sheet graph is unavailable, not empty.");
     const res = resolveTag(g, tag);
-    const room = res.room ? { tag: res.room.tag, name: res.room.name, sheet: res.room.sheet, bbox: _Session.wireBox(res.room.bbox) } : null;
-    if (res.status === "unresolved") return { status: "unresolved", tag: res.tag, room, reason: res.reason };
+    const room = res.room ? { tag: res.room.tag, name: res.room.name, sheet: res.room.sheet, bbox: _Session.wireBox(res.room.bbox), ...res.room.building ? { building: res.room.building } : {} } : null;
+    if (res.status === "unresolved") {
+      return {
+        status: "unresolved",
+        tag: res.tag,
+        room,
+        reason: res.reason,
+        ...res.candidates?.length ? { candidates: res.candidates } : {}
+      };
+    }
     return {
       status: "resolved",
       tag: res.tag,
       room,
+      ...res.building ? { building: res.building } : {},
       finishes: res.finishes.map((f) => ({
         surface: f.surface,
         code: f.code,
@@ -4170,7 +6259,10 @@ var Session = class _Session {
         title: t.title?.text || "",
         rows: t.rows.length,
         headers: t.headers,
-        region: _Session.wireBox(t.region)
+        region: _Session.wireBox(t.region),
+        ...t.building ? { building: t.building } : {},
+        ...t.rotated_headers ? { rotated_headers: true } : {},
+        ...t.parts ? { parts: t.parts.map((p) => ({ sheet: p.sheet, title: p.title, rows: p.rows, region: _Session.wireBox(p.region) })) } : {}
       }))
     };
   }
@@ -4230,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"),
@@ -4274,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"),
@@ -4289,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"),
@@ -4350,20 +6453,39 @@ var sweepPlacement = {
   rotation: z.number().describe("Detected rotation in degrees (0 | 90 | 180 | 270)"),
   mirrored: z.boolean()
 };
+var sweepCandidates = z.object({
+  considered: z.number().int(),
+  dropped: z.number().int().describe("Placements never scored because the work cap bit \u2014 always disclosed, never silent")
+});
+var sweepSheetBlock = z.object({
+  sheet: z.string(),
+  found: z.number().int(),
+  matches: z.array(z.object(sweepPlacement)),
+  withheld: z.array(z.object({ ...sweepPlacement, reason: z.string() })),
+  candidates: sweepCandidates.describe("The work cap applies PER SHEET; dropped > 0 here names exactly where the count is incomplete"),
+  elapsed_ms: z.number().describe("Wall-clock for this sheet's sweep")
+});
+var sweepSkipped = z.array(z.object({
+  sheet: z.string(),
+  role: z.string().describe("The sheet's graph role (plan / schedule / legend / detail / \u2026)"),
+  reason: z.string()
+}));
 var symbolSweepOutput = {
-  found: z.number().int().describe("Placements that cleared the commit bar \u2014 matches.length"),
-  matches: z.array(z.object(sweepPlacement)).describe("Deterministic reading order (y, then x). The seed's own location is never listed here"),
-  withheld: z.array(z.object({ ...sweepPlacement, reason: z.string() })).describe("Near-matches in the [0.75, 0.92) band \u2014 reported with a reason, NEVER committed. A withheld placement is a question you can answer with view_sheet; a hidden one is a miscount"),
+  scope: z.enum(["sheet", "set"]).describe('"sheet" = the swept sheet alone (matches/withheld/candidates at top level); "set" = every PLAN-role sheet in the working set (per-sheet results in sheets[], exclusions in skipped[])'),
+  found: z.number().int().describe("Placements that cleared the commit bar \u2014 across every swept sheet in set scope"),
+  matches: z.array(z.object(sweepPlacement)).optional().describe("Sheet scope only. Deterministic reading order (y, then x). The seed's own location is never listed here"),
+  withheld: z.array(z.object({ ...sweepPlacement, reason: z.string() })).optional().describe("Sheet scope only. Near-matches in the [0.75, 0.92) band \u2014 reported with a reason, NEVER committed. A withheld placement is a question you can answer with view_sheet; a hidden one is a miscount"),
   seed: z.object({
+    sheet: z.string().describe("The sheet the seed rect was marqueed on"),
+    role: z.string().optional().describe("Set scope: the seed sheet's graph role \u2014 a non-plan seed sheet is the fingerprint SOURCE and is excluded from counting"),
     segments: z.number().int().describe("Vector segments fully inside the seed rect \u2014 the fingerprint"),
     center: z.tuple([z.number(), z.number()]).describe("The seed instance's own centroid (image px) \u2014 reported here, never double-committed as a match"),
     rect: z.array(z.number()).length(4).describe("The seed rect actually used, post-clamp [x0, y0, x1, y1]"),
     length_px: z.number().describe("Total seed linework length, image px")
   }),
-  candidates: z.object({
-    considered: z.number().int(),
-    dropped: z.number().int().describe("Placements never scored because the work cap bit \u2014 always disclosed, never silent")
-  }),
+  candidates: sweepCandidates.optional().describe("Sheet scope only \u2014 set scope accounts per sheet in sheets[]"),
+  sheets: z.array(sweepSheetBlock).optional().describe("Set scope only: one entry per swept PLAN-role sheet, load order"),
+  skipped: sweepSkipped.optional().describe("Set scope only: every sheet excluded from counting, with role and reason \u2014 including the seed's own sheet when it is not a plan"),
   committed: z.number().int().optional().describe("commit mode: count shapes committed \u2014 one per match"),
   shape_ids: z.array(z.string()).optional(),
   condition: z.string().optional().describe("commit mode: the finish tag the markers counted under"),
@@ -4431,6 +6553,7 @@ var exportTakeoffOutput = {
     origin: z.object({}).passthrough().optional().describe("Provenance: method (manual|one_click_v1), actor (omitted=human, 'agent'=MCP/automation), reviewed (human affirmed at an explicit gate), assignment (where the finish tag came from \u2014 {source: 'schedule', room_tag, surface, schedule_sheet} when the room's own schedule row decided it, {source: 'asserted'} when the agent chose; stamped on every agent commit), and correction fields (edited, edited_before_create, copied, proposed_verts_norm, edits)")
   }).passthrough()),
   markups: z.array(z.unknown()),
+  approvals: z.array(z.unknown()).optional().describe("Approval-family records (#176) \u2014 the estimator's APPROVED seals and the agent's verdict marks {id, actor, ts, sheet_id, at:[nx,ny], shape_id?, text?}. Present only when any exist (the canvas payload's own convention), so a verdict-free export stays byte-identical"),
   sheet_group: z.array(z.unknown()),
   last_group: z.array(z.unknown()),
   sheet_tabs: z.array(z.unknown()),
@@ -4498,9 +6621,9 @@ 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"]),
+    op: z.enum(["commit", "edit", "delete", "materials", "condition", "approval"]),
     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) and for a condition step (it restores the waste/multiplier pair)")
+    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"),
   shape_count: z.number().int().describe("Committed shapes after the undo"),
   remaining: z.number().int().describe("Steps still available to undo"),
@@ -4573,9 +6696,10 @@ var exportReportOutput = {
 var exportMarkedPdfOutput = {
   path: z.string().describe("Absolute path of the written marked-set PDF \u2014 hand this to the user"),
   pages: z.number().int().describe("Legend cover + one page per marked sheet"),
-  sheets_marked: z.number().int().describe("Sheets carrying shapes or annotations \u2014 unmarked sheets are omitted"),
+  sheets_marked: z.number().int().describe("Sheets carrying shapes, annotations, or approval marks \u2014 unmarked sheets are omitted"),
   shapes_drawn: z.number().int(),
   annotations_drawn: z.number().int(),
+  approvals_drawn: z.number().int().describe("Approval-family glyphs burned in (#176) \u2014 estimator APPROVED rings + agent AGENT diamonds; the cover tallies the split when any exist"),
   note: z.string()
 };
 var editConditionOutput = {
@@ -4607,7 +6731,13 @@ var readSheetTextOutput = {
 };
 var wireBox = z.object({ x0: z.number(), y0: z.number(), x1: z.number(), y1: z.number() });
 var wireEvidence = z.object({ sheet: z.string(), text: z.string(), bbox: wireBox }).describe("An evidence pointer \u2014 the sheet, the literal text, and where it sits (image px). Every edge in the graph carries one; pass the bbox to view_sheet to LOOK at the source.");
-var graphRoom = z.object({ tag: z.string(), name: z.string().describe("The name span stacked over the tag ('' when none)"), sheet: z.string(), bbox: wireBox });
+var graphRoom = z.object({
+  tag: z.string(),
+  name: z.string().describe("The name span stacked over the tag ('' when none)"),
+  sheet: z.string(),
+  bbox: wireBox,
+  building: z.string().optional().describe("The building the room belongs to, when the set names one \u2014 its plan sheet's BUILDING/BLDG context, or the tag's own qualifier ('A-134')")
+});
 var sheetGraphOutput = {
   available: z.boolean().describe("false = the set has no text layer (a scan) \u2014 the graph degrades to unavailable, never half-populates"),
   sheets: z.array(z.object({
@@ -4615,35 +6745,98 @@ var sheetGraphOutput = {
     role: z.enum(["plan", "schedule", "legend", "detail", "elevation", "demolition", "unknown"]),
     confidence: z.number().describe("0..1; mixed title signals halve it, a bare sheet-number convention stays under 0.5"),
     evidence: wireEvidence.optional(),
-    schedules: z.array(z.object({ kind: z.string(), title: z.string(), rows: z.number().int(), region: wireBox }))
+    building: z.string().optional().describe("The sheet's building context, when it names exactly one (BUILDING A / BLDG 2)"),
+    schedules: z.array(z.object({
+      kind: z.string(),
+      title: z.string(),
+      rows: z.number().int(),
+      region: wireBox,
+      continues: z.string().optional().describe("Present on a continuation fragment ('\u2026 SCHEDULE \u2014 CONT'D'): the sheet carrying the table's base fragment. The fragments read as ONE table \u2014 resolve_tag and find_schedule already see the union"),
+      rotated_headers: z.boolean().optional().describe("true when the column headers were read at a quarter-turn")
+    }))
   })),
   rooms: z.array(graphRoom).describe("Room tags read off plan-role sheets \u2014 schedule sheets contribute rows, never phantom rooms"),
   callouts: z.array(z.object({ detail: z.string(), target_sheet: z.string(), sheet: z.string(), bbox: wireBox })).describe("Detail callouts (3/A-601) \u2014 edges to their target sheets"),
-  counts: z.object({ rooms: z.number().int(), schedules: z.number().int(), callouts: z.number().int() })
+  buildings: z.array(z.string()).optional().describe("Every building designator the set names (sorted) \u2014 present only on multi-building-aware sets. Room numbers reused across these need qualified tags ('A-134')"),
+  notes: z.array(z.string()).optional().describe("Named gaps found while indexing (e.g. a continuation whose rows could not be aligned) \u2014 the graph refuses silently dropping anything"),
+  counts: z.object({ rooms: z.number().int(), schedules: z.number().int().describe("LOGICAL tables \u2014 a schedule continued across sheets counts once"), callouts: z.number().int() })
 };
 var resolveTagOutput = {
   status: z.enum(["resolved", "unresolved"]),
   tag: z.string(),
-  room: graphRoom.nullable().describe("The plan tag, when the room appears on a plan sheet \u2014 cited even when resolution fails"),
+  room: graphRoom.nullable().describe("The plan tag, when the room appears on a plan sheet \u2014 cited even when resolution fails. null on a multi-building ambiguity: citing one building's tag would be quietly wrong"),
+  building: z.string().optional().describe("resolved only \u2014 the building whose schedule row answered, when the set names buildings"),
   finishes: z.array(z.object({
     surface: z.string().describe("The schedule column: FLOOR / BASE / WALL / \u2026"),
     code: z.string(),
     source: wireEvidence,
     definition: z.object({ cells: z.record(z.string()), source: wireEvidence }).optional().describe("The finish/material-schedule row this code chains to, when one exists")
   })).optional(),
-  sources: z.array(wireEvidence).optional().describe("The chain: plan tag \u2192 schedule row"),
-  reason: z.string().optional().describe("unresolved only \u2014 WHY (no schedule row / ambiguous / no schedule found). A room that appears on the plan with no row comes back here, never as a silent omission")
+  sources: z.array(wireEvidence).optional().describe("The chain: plan tag \u2192 schedule row (the row cites the sheet that CARRIES it \u2014 under a continuation that is the CONT'D sheet)"),
+  reason: z.string().optional().describe("unresolved only \u2014 WHY (no schedule row / ambiguous / no schedule found). A room that appears on the plan with no row comes back here, never as a silent omission"),
+  candidates: z.array(z.object({
+    key: z.string(),
+    building: z.string().optional(),
+    sheet: z.string(),
+    table: z.string()
+  })).optional().describe('unresolved only \u2014 every schedule row that COULD have answered (an ambiguous multi-building tag lists one per building; qualify the tag, e.g. "A-134", to pick)')
 };
 var findScheduleOutput = {
   matches: z.array(z.object({
     sheet: z.string(),
     kind: z.string(),
     title: z.string(),
-    rows: z.number().int(),
+    rows: z.number().int().describe("Total data rows \u2014 a continued schedule counts every fragment's rows"),
     headers: z.array(z.string()),
-    region: wireBox.describe("Pass to view_sheet to look at the table")
+    region: wireBox.describe("Pass to view_sheet to look at the table (the BASE fragment's region when the table continues)"),
+    building: z.string().optional().describe("The building this table answers for, when its title or sheet names one"),
+    rotated_headers: z.boolean().optional().describe("true when the column headers were read at a quarter-turn"),
+    parts: z.array(z.object({ sheet: z.string(), title: z.string(), rows: z.number().int(), region: wireBox })).optional().describe("Present when the table CONTINUES across sheets ('\u2026 SCHEDULE \u2014 CONT'D'): every fragment, base first, each with its own viewable region")
   }))
 };
+var rowSweepPlacement = {
+  at: z.tuple([z.number(), z.number()]).describe("The matched marker's centroid (image px)"),
+  score: z.number().describe("Length-weighted fraction of the anchor's segments matched within tolerance, 0..1"),
+  rotation: z.number().describe("Detected rotation in degrees (0 | 90 | 180 | 270)"),
+  mirrored: z.boolean()
+};
+var sweepScheduleRowOutput = {
+  tag: z.string().describe("The row key as normalized (the tag as drawn)"),
+  row: z.object({
+    sheet: z.string(),
+    table: z.string().describe("The table's title (or kind, when untitled)"),
+    key: z.string(),
+    cells: z.record(z.string()).describe("The row's cells, header \u2192 text \u2014 what the schedule SAYS this mark is"),
+    citation: wireEvidence
+  }).describe("The schedule row the sweep was seeded from \u2014 the condition's source"),
+  anchor: z.object({
+    sheet: z.string().describe("The plan sheet the fingerprint was anchored on"),
+    at: z.tuple([z.number(), z.number()]).describe("The anchoring tag occurrence's center (image px)"),
+    rect: z.array(z.number()).length(4).describe("The fingerprint rect actually used [x0, y0, x1, y1] \u2014 the pad ladder's winning step"),
+    segments: z.number().int().describe("Vector segments in the marker fingerprint"),
+    length_px: z.number(),
+    corroborated: z.boolean().describe("true = the fingerprint recurred at a second tag occurrence before being trusted; false = the tag is drawn too sparsely to cross-check (see note)"),
+    occurrences: z.number().int().describe("Drawn occurrences of the tag across all plan sheets")
+  }),
+  found: z.number().int().describe("Matches carrying the row's own tag \u2014 the honest count, across every plan sheet"),
+  sheets: z.array(z.object({
+    sheet: z.string(),
+    found: z.number().int(),
+    matches: z.array(z.object({ ...rowSweepPlacement, tag_at: wireBox.describe("The corroborating tag text's bbox \u2014 the evidence that this marker is THIS row's") })),
+    withheld: z.array(z.object({ ...rowSweepPlacement, reason: z.string() })).describe("Questions, never counts: markers matching the geometry but carrying no tag (an unlabeled instance or a shared bubble shape), and near-miss scores in the [0.75, 0.92) band"),
+    excluded: z.array(z.object({ at: z.tuple([z.number(), z.number()]), tag: z.string() })).describe("Markers matching the geometry but labeled with a SIBLING row's tag \u2014 the bubble shape is shared across marks, so these belong to that row, not this one"),
+    text_only: z.array(z.object({ at: z.tuple([z.number(), z.number()]) })).describe("The tag drawn with NO matching marker geometry nearby \u2014 a note reference or a variant marker; a question, never a count"),
+    candidates: z.object({ considered: z.number().int(), dropped: z.number().int() }),
+    elapsed_ms: z.number().describe("Wall-clock for this sheet's sweep")
+  })).describe("One entry per swept PLAN-role sheet, load order"),
+  skipped: z.array(z.object({ sheet: z.string(), role: z.string(), reason: z.string() })).describe("Sheets excluded from counting (schedule/detail/legend/unknown), each with its reason"),
+  committed: z.number().int().optional().describe("commit mode: count shapes committed \u2014 one per counted match, the whole sweep ONE undo step"),
+  shape_ids: z.array(z.string()).optional(),
+  condition: z.string().optional().describe("commit mode: the condition minted FROM the row \u2014 its key is the tag"),
+  ea_total: z.number().optional(),
+  note: z.string().optional(),
+  warning: z.string().optional().describe("Present when the per-sheet work cap dropped candidates")
+};
 var hatchFamilyRow = z.object({
   id: z.string().describe("Content hash of the quantized (angle, pitch, pen-width) signature \u2014 the SAME id for the same pattern spec anywhere on the sheet, so legend\u2194plan matching is id === id. Identifies a pattern, not a material; the legend maps pattern \u2192 material."),
   angle_deg: z.number().describe("Raw mean angle [0, 180) \u2014 rides beside the id for tolerance matching at bucket boundaries"),
@@ -4674,7 +6867,7 @@ var sheetContextOutput = {
     note: z.string().optional()
   }),
   text: z.object({
-    spans: z.array(z.object({ str: z.string(), x0: z.number(), y0: z.number(), x1: z.number(), y1: z.number() })).describe("Text with bboxes, image px, same frame as the vectors"),
+    spans: z.array(z.object({ str: z.string(), x0: z.number(), y0: z.number(), x1: z.number(), y1: z.number(), rot: z.number().optional().describe("Run direction in degrees, clockwise, y down \u2014 present only when rotated (90/270 = a quarter-turn, e.g. rotated schedule headers)") })).describe("Text with bboxes, image px, same frame as the vectors"),
     count: z.number().int()
   }),
   hatch: z.object({ families: z.array(hatchFamilyRow), count: z.number().int() })
@@ -4704,10 +6897,37 @@ var annotateOutput = {
   length_lf: z.number().optional().describe("Dimension only: the measured length (real feet) the annotation will label itself with"),
   note: z.string()
 };
+var verdictRow = z.object({
+  id: z.string(),
+  actor: z.enum(["estimator", "agent"]).describe('"estimator" = the human APPROVED ring (ink \u2014 import-borne here, never minted over MCP), "agent" = the AGENT diamond'),
+  sheet: z.string(),
+  at: z.tuple([z.number(), z.number()]).optional().describe("Render anchor (image px) \u2014 absent only when the record rides a sheet from a file this session hasn't loaded (#152)"),
+  ts: z.string().optional().describe("ISO-8601 mint time"),
+  shape_id: z.string().optional().describe("Present when the verdict targets a committed shape \u2014 WHAT was marked, not where it draws"),
+  condition: z.string().describe("The targeted shape's finish tag, resolved \u2014 '' for sheet-point marks"),
+  text: z.string().optional().describe("The optional short note riding the record")
+});
+var markVerdictOutput = {
+  id: z.string().describe('The minted record id ("apr-\u2026")'),
+  actor: z.literal("agent").describe("Always agent \u2014 this tool is structurally incapable of minting the estimator's seal"),
+  sheet: z.string(),
+  at: z.tuple([z.number(), z.number()]).optional().describe("Where the AGENT diamond renders (image px) \u2014 absent only when the marked shape rides a sheet from a file this session hasn't loaded (#152)"),
+  ts: z.string().describe("ISO-8601 mint time"),
+  shape_id: z.string().optional().describe("Shape mode: the committed shape this verdict is about"),
+  condition: z.string().optional().describe("Shape mode: the marked shape's finish tag, resolved"),
+  text: z.string().optional(),
+  note: z.string()
+};
+var deleteVerdictOutput = {
+  deleted: z.string().describe("The lifted record's id"),
+  verdicts_remaining: z.number().int().describe("Approval-family records still on the takeoff (both actors)")
+};
 var listAnnotationsOutput = {
   annotations: z.array(annotationRow),
   count: z.number().int(),
-  unattached: z.number().int().describe("How many carry no condition \u2014 candidates for link_annotation")
+  unattached: z.number().int().describe("How many carry no condition \u2014 candidates for link_annotation"),
+  verdicts: z.array(verdictRow).describe("Approval-family records (#176) under the same filters: sheet applies directly; a condition filter reaches a verdict THROUGH its target shape (a sheet-point mark carries no scope and drops out)"),
+  verdict_count: z.number().int()
 };
 var linkAnnotationOutput = {
   id: z.string(),
@@ -4720,24 +6940,6 @@ var linkAnnotationOutput = {
 import path3 from "node:path";
 import { readFile as readFile2, writeFile } from "node:fs/promises";
 
-// ../web/src/lib/approvals.js
-var APPROVAL_R = 0.022;
-var APPROVAL_INK = {
-  estimator: { light: "#1f6b4a", dark: "#55b083" },
-  agent: { light: "#6c6a5e", dark: "#9d9a8c" }
-};
-function approvalInk(actor, dark = false) {
-  const c = APPROVAL_INK[actor] || APPROVAL_INK.agent;
-  return dark ? c.dark : c.light;
-}
-function approvalTally(approvals) {
-  const t = { estimator: 0, agent: 0 };
-  for (const a of Array.isArray(approvals) ? approvals : []) {
-    if (a && a.actor in t) t[a.actor] += 1;
-  }
-  return t;
-}
-
 // ../web/src/lib/svgpath.js
 function isSep(c) {
   return c === " " || c === "	" || c === "\n" || c === "\r" || c === "\f" || c === ",";
@@ -5866,7 +8068,7 @@ var buildMarkedSetPdf2 = buildMarkedSetPdf;
 async function exportMarkedPdf(session, opts) {
   const { file, filePath } = session;
   if (!file || !filePath) throw new UserError("No plan loaded \u2014 call load_plan first.");
-  if (!session.shapes.length && !session.markups.length) {
+  if (!session.shapes.length && !session.markups.length && !session.approvals.length) {
     throw new UserError("Nothing to mark yet \u2014 commit shapes (one_click / detect_rooms / measure_polygon / measure_line with a condition) or annotate before exporting the marked set.");
   }
   const sheetStates = session.sheetList();
@@ -5910,6 +8112,10 @@ async function exportMarkedPdf(session, opts) {
     sheets,
     shapes: session.shapes,
     markups: session.markups,
+    // approval marks (#176): the estimator's APPROVED rings and the agent's
+    // AGENT diamonds burn in above the markups, and the cover tallies the
+    // ink/pencil split — the same builder path the canvas's MARKED SET uses
+    approvals: session.approvals,
     rfis: [],
     conditions: session.conditions,
     getPage,
@@ -5920,13 +8126,14 @@ async function exportMarkedPdf(session, opts) {
   });
   const outPath = path3.resolve(opts.path ?? path3.join(path3.dirname(filePath), `${base} - marked set.pdf`));
   await writeFile(outPath, bytes);
-  const markedKeys = /* @__PURE__ */ new Set([...session.shapes.map((s) => s.sheet_id), ...session.markups.map((m) => m.sheet_id)]);
+  const markedKeys = /* @__PURE__ */ new Set([...session.shapes.map((s) => s.sheet_id), ...session.markups.map((m) => m.sheet_id), ...session.approvals.map((a) => a.sheet_id)]);
   return {
     path: outPath,
     pages: 1 + markedKeys.size,
     sheets_marked: markedKeys.size,
     shapes_drawn: session.shapes.length,
     annotations_drawn: session.markups.length,
+    approvals_drawn: session.approvals.length,
     note: "The takeoff burned into the plan sheets, with a legend cover \u2014 hand this to the user to review. To revise in the app, import the export_takeoff payload; agent shapes arrive as pencil proposals there until accepted."
   };
 }
@@ -5984,7 +8191,7 @@ function mergeTakeoffImport(current, imported, knownFiles = null) {
     return [...new Set(added.map((s) => String(s.sheet_id).split("#")[0]).filter((f) => !known.has(f)))];
   };
   const pendingCount = (shapes) => shapes.filter((s) => s.origin?.reviewed === false).length;
-  if (!arr(cur.shapes).length && !arr(cur.markups).length) {
+  if (!arr(cur.shapes).length && !arr(cur.markups).length && !arr(cur.approvals).length) {
     const payload2 = {
       ...imported,
       ...arr(imported.sheet_tabs).length ? {} : { sheet_tabs: arr(cur.sheet_tabs) },
@@ -6022,6 +8229,8 @@ function mergeTakeoffImport(current, imported, knownFiles = null) {
   const addedMarkups = arr(imported.markups).filter((m) => m && typeof m === "object" && (!m.id || !markupIds.has(m.id)));
   const rfiIds = new Set(arr(cur.rfis).map((r) => r?.id).filter(Boolean));
   const addedRfis = arr(imported.rfis).filter((r) => r && typeof r === "object" && r.id && !rfiIds.has(r.id));
+  const approvalIds = new Set(arr(cur.approvals).map((a) => a?.id).filter(Boolean));
+  const addedApprovals = sanitizeApprovals(imported.approvals).filter((a) => !approvalIds.has(a.id));
   const sheets = [...arr(cur.sheets)];
   const scaled = new Set(sheets.map((s) => s?.sheet_id));
   let scalesAdopted = 0;
@@ -6038,6 +8247,7 @@ function mergeTakeoffImport(current, imported, knownFiles = null) {
     shapes: [...arr(cur.shapes), ...addedShapes],
     markups: [...arr(cur.markups), ...addedMarkups],
     ...addedRfis.length ? { rfis: [...arr(cur.rfis), ...addedRfis] } : {},
+    ...addedApprovals.length ? { approvals: [...arr(cur.approvals), ...addedApprovals] } : {},
     sheets
   };
   return {
@@ -6068,6 +8278,7 @@ async function importTakeoff(session, filePath) {
   session.conditions = payload.conditions ?? [];
   session.shapes = payload.shapes ?? [];
   session.markups = payload.markups ?? [];
+  session.approvals = sanitizeApprovals2(payload.approvals);
   for (const row of payload.sheets ?? []) {
     const s = session.sheetOrNull(row.sheet_id);
     if (s && s.upp == null && row.units_per_px > 0) {
@@ -6138,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(),
@@ -6152,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"),
@@ -6209,12 +8420,13 @@ function registerTools(server, session) {
     outputSchema: placeCountOutput
   }, run("place_count", (a) => session.placeCount(a.sheet, a.points, { condition: a.condition })));
   server.registerTool("symbol_sweep", {
-    description: `Find EVERY instance of a repeated plan symbol from ONE example \u2014 drains, thresholds, fixtures, transition markers: marquee a tight seed_rect around a single instance and the sheet's vector linework is searched for every other placement of that same segment cluster. Deterministic geometry, not vision: each placement scores as the length-weighted fraction of the seed's segments reproduced within tolerance_px, under translation plus 0/90/180/270 rotation and mirroring (symbols rotate on plans \u2014 both ON by default; turn them off to pin orientation). Score \u2265 0.92 is a match; the 0.75\u20130.92 band comes back in \`withheld\` with a reason \u2014 a near-match is a question you answer by LOOKING (view_sheet at its \`at\`), never a silent commit and never a silent drop. The seed's own location is reported in \`seed\` and never double-committed. Work is capped and the cap is disclosed: a reply with candidates.dropped > 0 says exactly that some placements were never scored \u2014 tighten the seed rect around more distinctive geometry rather than trusting a truncated count. Marquee discipline: the rect must hug ONE instance \u2014 only segments FULLY inside it define the symbol, so a loose rect that swallows wall linework fingerprints the wall, not the symbol. commit: true (requires condition) commits every match center as an EA count marker through the same path as place_count \u2014 the whole sweep is ONE undo step, each marker carries origin.method "symbol_sweep" with its score and transform, and withheld placements are NEVER committed. No scale needed: EA is scale-free. After any batch commit, LOOK at what landed \u2014 view_sheet {overlay: true} over the swept area \u2014 and audit the markers against the drawing before trusting the EA total. ${COORDS}`,
+    description: `Find EVERY instance of a repeated plan symbol from ONE example \u2014 drains, thresholds, fixtures, transition markers: marquee a tight seed_rect around a single instance and the vector linework is searched for every other placement of that same segment cluster. Deterministic geometry, not vision: each placement scores as the length-weighted fraction of the seed's segments reproduced within tolerance_px, under translation plus 0/90/180/270 rotation and mirroring (symbols rotate on plans \u2014 both ON by default; turn them off to pin orientation). Score \u2265 0.92 is a match; the 0.75\u20130.92 band comes back in \`withheld\` with a reason \u2014 a near-match is a question you answer by LOOKING (view_sheet at its \`at\`), never a silent commit and never a silent drop. The seed's own location is reported in \`seed\` and never double-committed. Work is capped and the cap is disclosed: a reply with candidates.dropped > 0 says exactly that some placements were never scored \u2014 tighten the seed rect around more distinctive geometry rather than trusting a truncated count. Marquee discipline: the rect must hug ONE instance \u2014 only segments FULLY inside it define the symbol, so a loose rect that swallows wall linework fingerprints the wall, not the symbol. scope "set" sweeps the WHOLE working set, counting on PLAN-role sheets only (the sheet graph decides): a symbol drawn in a detail, legend, or schedule is a reference drawing and never counts itself \u2014 which is also how you seed from one: marquee the assembly on the detail sheet and its plan-sheet occurrences are counted while the detail stays excluded (the exclusion disclosed in \`skipped\`, per-sheet results with per-sheet caps and wall-clock in \`sheets\`; the fingerprint is size-true, so a detail drawn at an enlarged scale will not match plan-size instances). commit: true (requires condition) commits every match center as an EA count marker through the same path as place_count \u2014 the whole sweep (set-wide included) is ONE undo step, each marker carries origin.method "symbol_sweep" with its score, transform, and seed source, and withheld placements are NEVER committed. No scale needed: EA is scale-free. After any batch commit, LOOK at what landed \u2014 view_sheet {overlay: true} over the swept area \u2014 and audit the markers against the drawing before trusting the EA total. ${COORDS}`,
     inputSchema: {
-      sheet: z2.string(),
+      sheet: z2.string().describe("The sheet the seed rect sits on \u2014 in scope 'set' it may be ANY sheet (a detail/legend seed sheet is fingerprint source only, never counted)"),
       seed_rect: z2.tuple([pointSchema, pointSchema]).describe("Marquee around ONE example instance, [[x0,y0],[x1,y1]] in image px \u2014 tight: segments fully inside define the symbol"),
       condition: z2.string().optional().describe("Finish tag to commit match markers under (minted on first use), e.g. 'FD-1'. Required when commit is true"),
       commit: z2.boolean().default(false).describe("Commit every MATCH center as one EA count marker (withheld placements never commit)"),
+      scope: z2.enum(["sheet", "set"]).default("sheet").describe('"sheet" = this sheet only; "set" = every PLAN-role sheet in the working set (needs a text layer for the sheet graph; non-plan sheets are excluded and disclosed)'),
       rotations: z2.boolean().default(true).describe("Also match 90/180/270-rotated placements"),
       mirror: z2.boolean().default(true).describe("Also match mirrored placements"),
       tolerance_px: z2.number().positive().max(20).default(2).describe("Endpoint match tolerance in image px (default 2 \u2014 CAD jitter, not drift)")
@@ -6223,6 +8435,23 @@ function registerTools(server, session) {
   }, run("symbol_sweep", (a) => session.symbolSweep(a.sheet, {
     seedRect: a.seed_rect,
     condition: a.condition,
+    commit: a.commit,
+    scope: a.scope,
+    rotations: a.rotations,
+    mirror: a.mirror,
+    tolerancePx: a.tolerance_px
+  })));
+  server.registerTool("sweep_schedule_row", {
+    description: `Take off a schedule row's mark from the row itself \u2014 the estimator's own gesture: a transition type sometimes exists only as a schedule row plus tag markers scattered across the plan sheets, and this tool mints the condition FROM the row and finds every occurrence. Pass the row's key (e.g. 'T1') and the tool (1) reads the row from the set's schedule tables (the sheet_graph/find_schedule machinery \u2014 the row is the condition's cited source), (2) anchors a geometric fingerprint on the marker the tag is DRAWN as on a plan sheet (a deterministic pad ladder around the tag text; where the tag occurs more than once the fingerprint must recur at a second occurrence before it is trusted \u2014 \`anchor.corroborated\`), and (3) sweeps every PLAN-role sheet for it. The count is geometry AND text agreeing: drafting reuses one bubble shape across many marks, so a match counts ONLY when the row's own tag sits within the marker footprint (its bbox rides the match as \`tag_at\` evidence); a match labeled with a SIBLING row's tag is excluded and says whose it is, an unlabeled match is withheld as a question, and a tag drawn with no matching marker is disclosed as text_only. REFUSAL over guessing, with the reason and the fix: no such row; the same key in two tables (ambiguous); a tag drawn on no plan sheet; no repeatable marker linework around the tag \u2014 a fingerprint is never guessed from text alone (the fallback is always: marquee one instance with symbol_sweep). commit: true commits the counted matches as EA markers under the row's own key \u2014 one undo step for the whole set-wide sweep, every marker carrying origin.assignment {source: "schedule"} plus the anchor and row citation on origin.symbol.seed. No scale needed: EA is scale-free. After committing, LOOK: view_sheet {overlay: true} over each swept sheet. ${COORDS}`,
+    inputSchema: {
+      tag: z2.string().min(1).describe("The schedule row's key exactly as drawn, e.g. 'T1', 'TR-2' \u2014 it becomes the condition tag on commit"),
+      commit: z2.boolean().default(false).describe("Commit every counted match as one EA count marker (excluded/withheld/text_only never commit)"),
+      rotations: z2.boolean().default(true).describe("Also match 90/180/270-rotated markers"),
+      mirror: z2.boolean().default(true).describe("Also match mirrored markers"),
+      tolerance_px: z2.number().positive().max(20).default(2).describe("Endpoint match tolerance in image px (default 2 \u2014 CAD jitter, not drift)")
+    },
+    outputSchema: sweepScheduleRowOutput
+  }, run("sweep_schedule_row", (a) => session.sweepScheduleRow(a.tag, {
     commit: a.commit,
     rotations: a.rotations,
     mirror: a.mirror,
@@ -6273,14 +8502,14 @@ function registerTools(server, session) {
     return doc;
   }));
   server.registerTool("import_takeoff", {
-    description: `The way BACK IN (#151): load an "opentakeoff.takeoff_canvas.v1" file \u2014 a prior export_takeoff, or the app's own save \u2014 into this session, through the SAME tested merge rules as the app's Sheet-menu import: finish-tag identity joins imported conditions onto this session's own (their knobs win), new ids append, duplicate ids skip (re-import is idempotent), and THIS session's calibration wins per sheet. An empty session adopts the file wholesale. Resume yesterday's work, extend a takeoff a human already reviewed (their ink stays ink \u2014 reviewed shapes arrive untouchable by agent verbs), or audit someone else's export with list_shapes/takeoff_summary. Requires a loaded plan; shapes referencing OTHER files ride along and count in totals but can't be viewed against this document \u2014 the reply's unknown_files names them. undo_last removes the imported SHAPES as one step; adopted conditions, scales, and annotations stay.`,
+    description: `The way BACK IN (#151): load an "opentakeoff.takeoff_canvas.v1" file \u2014 a prior export_takeoff, or the app's own save \u2014 into this session, through the SAME tested merge rules as the app's Sheet-menu import: finish-tag identity joins imported conditions onto this session's own (their knobs win), new ids append, duplicate ids skip (re-import is idempotent), and THIS session's calibration wins per sheet. An empty session adopts the file wholesale. Resume yesterday's work, extend a takeoff a human already reviewed (their ink stays ink \u2014 reviewed shapes arrive untouchable by agent verbs), or audit someone else's export with list_shapes/takeoff_summary. Requires a loaded plan; shapes referencing OTHER files ride along and count in totals but can't be viewed against this document \u2014 the reply's unknown_files names them. Approval marks ride the file too \u2014 transport, not minting: an estimator seal arriving by import stays estimator ink, listable but untouchable here. undo_last removes the imported SHAPES as one step; adopted conditions, scales, annotations, and approval marks stay.`,
     inputSchema: {
       path: z2.string().describe("Path to a takeoff_canvas.v1 JSON file on disk")
     },
     outputSchema: importTakeoffOutput
   }, run("import_takeoff", (a) => importTakeoff(session, a.path)));
   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. 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.`,
+    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: {
       path: z2.string().optional().describe('Where to write the PDF (default: "<plan dir>/<plan> - marked set.pdf")'),
       project_name: z2.string().optional().describe("Cover-page project name (default: the plan file's name)")
@@ -6371,17 +8600,17 @@ function registerTools(server, session) {
     outputSchema: undoLastOutput
   }, run("undo_last", ({ n }) => session.undoLast(n)));
   server.registerTool("sheet_graph", {
-    description: `The plan-set INDEX (#87): every sheet's role (plan / schedule / legend / \u2026, with confidence and the title evidence), the schedule tables found (kind, row count, region), every room tag on the plan sheets (with the stacked room NAME when one exists), and the detail callouts (3/A-601 \u2192 sheet edges). Built once per document from the text layer and cached. This is how an agent decides WHAT to measure without a human enumerating the rooms: list the rooms here, resolve each with resolve_tag, then measure with one_click/detect_rooms. A scanned set (no text layer) returns available: false \u2014 unavailable, never half-populated. ${COORDS}`,
+    description: `The plan-set INDEX (#87): every sheet's role (plan / schedule / legend / \u2026, with confidence and the title evidence), the schedule tables found (kind, row count, region \u2014 a schedule CONTINUED across sheets ("\u2026 SCHEDULE \u2014 CONT'D") reads as ONE table, the continuation fragment naming its base in "continues"; rotated column headers are read at their quarter-turn and flagged), every room tag on the plan sheets (with the stacked room NAME when one exists, and the room's BUILDING on multi-building sets), the detail callouts (3/A-601 \u2192 sheet edges), the set's building designators, and named indexing gaps in "notes". Built once per document from the text layer and cached. This is how an agent decides WHAT to measure without a human enumerating the rooms: list the rooms here, resolve each with resolve_tag, then measure with one_click/detect_rooms. A scanned set (no text layer) returns available: false \u2014 unavailable, never half-populated. ${COORDS}`,
     inputSchema: {},
     outputSchema: sheetGraphOutput
   }, run("sheet_graph", () => session.sheetGraph()));
   server.registerTool("resolve_tag", {
-    description: `Resolve ONE room tag across the set (#87): the plan tag \u2192 its room-finish schedule row \u2192 each finish code's definition in the finish/material schedule, EVERY edge carrying an evidence pointer (sheet + literal text + bbox \u2014 pass a bbox to view_sheet to look at the source). The doctrine is refusal over guessing: a room that appears on the plan with no schedule row returns status "unresolved" with the reason (and still cites the plan tag); reused room numbers across the set return "ambiguous" rather than picking one. This is the answer to "what finish is specified in room 134, and how do you know". ${COORDS}`,
-    inputSchema: { tag: z2.string().describe('The room tag as drawn, e.g. "134" or "139A"') },
+    description: `Resolve ONE room tag across the set (#87): the plan tag \u2192 its room-finish schedule row \u2192 each finish code's definition in the finish/material schedule, EVERY edge carrying an evidence pointer (sheet + literal text + bbox \u2014 pass a bbox to view_sheet to look at the source). Rows carried by a continuation sheet ("\u2026 SCHEDULE \u2014 CONT'D") resolve exactly like base-sheet rows, citing the sheet the ink is on. The doctrine is refusal over guessing: a room that appears on the plan with no schedule row returns status "unresolved" with the reason (and still cites the plan tag); reused room numbers return "ambiguous" rather than picking one \u2014 on a multi-building set the refusal LISTS the candidate rows per building, and a building-qualified tag ("A-134") picks the building the set names. ${COORDS}`,
+    inputSchema: { tag: z2.string().describe('The room tag as drawn, e.g. "134" or "139A" \u2014 or building-qualified on a multi-building set, e.g. "A-134" (building A, room 134)') },
     outputSchema: resolveTagOutput
   }, run("resolve_tag", ({ tag }) => session.resolveRoomTag(tag)));
   server.registerTool("find_schedule", {
-    description: `Locate a schedule table in the set (#87): pass a kind ("room finish", "material"/"finish") and get every matching table's sheet, title, headers, row count, and REGION \u2014 sized for a view_sheet look or a read_sheet_text pull of exactly the table. Errors with what WAS found when the asked-for kind isn't in the set. ${COORDS}`,
+    description: `Locate a schedule table in the set (#87): pass a kind ("room finish", "material"/"finish") and get every matching table's sheet, title, headers, TOTAL row count, and REGION \u2014 sized for a view_sheet look or a read_sheet_text pull of exactly the table. A schedule continued across sheets is ONE match whose "parts" list every fragment (base first) with its own viewable region; tables read through rotated headers say so; a table answering for one building carries "building". Errors with what WAS found when the asked-for kind isn't in the set. ${COORDS}`,
     inputSchema: { kind: z2.string().describe('"room finish" (rooms \u2192 surface finishes) or "finish"/"material" (codes \u2192 products)') },
     outputSchema: findScheduleOutput
   }, run("find_schedule", ({ kind }) => session.findSchedule(kind)));
@@ -6445,7 +8674,7 @@ No review gate: the pencil-not-ink rule exists to stop an agent inventing geomet
     outputSchema: annotateOutput
   }, run("annotate", (a) => session.annotate(a)));
   server.registerTool("list_annotations", {
-    description: `Every annotation on the takeoff, with condition_id RESOLVED to its finish tag so you can act on the reply without joining against conditions[]. Filter by sheet, by condition, or both. Coordinates come back in image px (the same frame you passed in), not the normalized form they're stored as. \`unattached\` counts the notes carrying no condition \u2014 the candidates for link_annotation. ${COORDS}`,
+    description: `Every annotation on the takeoff, with condition_id RESOLVED to its finish tag so you can act on the reply without joining against conditions[]. Filter by sheet, by condition, or both. Coordinates come back in image px (the same frame you passed in), not the normalized form they're stored as. \`unattached\` counts the notes carrying no condition \u2014 the candidates for link_annotation. \`verdicts\` is the approval family's inventory (mark_verdict/delete_verdict): every mark with its actor stated \u2014 the estimator's APPROVED ring or the agent's AGENT diamond \u2014 under the same filters, a condition filter reaching a verdict through its target shape. ${COORDS}`,
     inputSchema: {
       sheet: z2.string().optional().describe("Only annotations on this sheet"),
       condition: z2.string().optional().describe("Only annotations attached to this finish tag")
@@ -6460,6 +8689,29 @@ No review gate: the pencil-not-ink rule exists to stop an agent inventing geomet
     },
     outputSchema: linkAnnotationOutput
   }, run("link_annotation", (a) => session.linkAnnotation(a.annotation_id, a.condition)));
+  server.registerTool("mark_verdict", {
+    description: `Mark the agent's VERDICT on work \u2014 the pencil half of the approval family, and the only half an agent can mint. Two actors exist on the record: the estimator's APPROVED ring is ink, minted solely by a human's click at the canvas's Approve tool; this tool mints the AGENT diamond and structurally nothing else \u2014 it takes no actor input to misuse. Target the work either way: shape_id anchors the mark ON a committed shape (a room at its area centroid, a run at its on-path midpoint, a count marker at its point) and records WHAT was marked \u2014 the shape_id stays on the record as provenance, and the glyph keeps its own anchor even if the shape is later deleted; or sheet + at drops the mark at a sheet point (image px). Exactly one target. Optional text rides the record through every export; the glyph itself always reads AGENT. A verdict touches no quantity and gates nothing: it is the agent's signed claim that it checked this work \u2014 pencil beside the estimator's ink, never in its place. The mark renders as the graphite AGENT diamond on the canvas and in the marked set, the marked-set cover tallies the split ("Approval stamps: N estimator-approved \xB7 M agent-marked"), and the record rides the annotations payload through export_takeoff / import_takeoff and the app's own saves. One mark per shape (re-mark = delete_verdict, then mark again); list_annotations returns the inventory in verdicts[]; undo_last steps over a mark exactly like any other mutation. ${COORDS}`,
+    inputSchema: {
+      shape_id: z2.string().optional().describe("Mark a committed shape (list_shapes has the ids) \u2014 anchored on the shape, recorded as provenance. Exactly one target: this OR sheet + at"),
+      sheet: z2.string().optional().describe("Sheet-point mode: the sheet, together with at"),
+      at: pointSchema.optional().describe("Sheet-point mode: where the AGENT diamond renders (image px)"),
+      text: z2.string().optional().describe("Optional short note riding the record and every export \u2014 the glyph always reads AGENT")
+    },
+    outputSchema: markVerdictOutput
+  }, run("mark_verdict", (a) => {
+    const byShape = a.shape_id !== void 0;
+    const byPoint = a.sheet !== void 0 || a.at !== void 0;
+    if (byShape === byPoint) throw new UserError("Provide exactly one target: shape_id (mark a committed shape), or sheet + at (mark a sheet point).");
+    if (byPoint && (a.sheet === void 0 || a.at === void 0)) throw new UserError("A sheet-point verdict needs BOTH sheet and at: [x, y] (image px).");
+    return session.markVerdict({ shape_id: a.shape_id, sheet: a.sheet, at: a.at, text: a.text });
+  }));
+  server.registerTool("delete_verdict", {
+    description: `Lift an agent verdict mark by id (mark_verdict's reply, or list_annotations verdicts[]). Agent marks only: the estimator's APPROVED seal is human ink and is refused \u2014 the same line edit_shape holds on reviewed shapes. Journaled like every mutation, so undo_last re-seats a lifted mark exactly where it was.`,
+    inputSchema: {
+      verdict_id: z2.string().describe("Record id from mark_verdict or list_annotations verdicts[]")
+    },
+    outputSchema: deleteVerdictOutput
+  }, run("delete_verdict", ({ verdict_id }) => session.deleteVerdict(verdict_id)));
 }
 
 // src/resources.ts
@@ -6541,7 +8793,7 @@ function registerResources(server, session) {
 // package.json
 var package_default = {
   name: "opentakeoff-mcp",
-  version: "0.9.21",
+  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.",
@@ -6557,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",