opentakeoff-mcp 0.9.26 → 0.9.29

package/dist/server-core.js

@@ -1292,6 +1292,76 @@ function sweepHatchRuns(segs, meta, ws) {
   }
   return { clipSoft, runs };
 }
+var ANNOT_OFFSET_MAX_FT = 2;
+var ANNOT_OFFSET_MIN_FT = 0.25;
+var ANNOT_MIN_LEN_FT = 4;
+var ANNOT_OVERLAP_FRAC = 0.6;
+var ANNOT_MIN_PEN_STEP = 1;
+var ANNOT_MAX_SCAN = 64;
+function classifyOffsetAnnotationSegs(segs, meta, ws, maxOffsetPx, minOffsetPx, minLenPx) {
+  const n = segs.length >> 2;
+  const soft = new Uint8Array(n);
+  if (!meta || !n || !(maxOffsetPx > 0) || !(minLenPx > 0)) return soft;
+  const cand = [];
+  for (let i = 0; i < n; i++) {
+    const mt = meta[i];
+    if (mt & (SEG_CURVE | SEG_CLIP | 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;
+    if (Math.hypot(dx, dy) < minLenPx) 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 < 2) return soft;
+  const BIN = HATCH_ANGLE_TOL, NBINS = Math.max(1, Math.round(180 / BIN));
+  for (const shift of [0, BIN / 2]) {
+    const bins = /* @__PURE__ */ new Map();
+    for (const c of cand) {
+      let b = Math.floor((c.ang + shift) / BIN);
+      if (b >= NBINS) b -= NBINS;
+      const th = c.ang * Math.PI / 180;
+      const dxu = Math.cos(th), dyu = Math.sin(th);
+      const nxu = -dyu, nyu = dxu;
+      const r = {
+        i: c.i,
+        ang: c.ang,
+        d: (c.x1 + c.x2) / 2 * nxu + (c.y1 + c.y2) / 2 * nyu,
+        t0: Math.min(c.x1 * dxu + c.y1 * dyu, c.x2 * dxu + c.y2 * dyu),
+        t1: Math.max(c.x1 * dxu + c.y1 * dyu, c.x2 * dxu + c.y2 * dyu),
+        w: c.w
+      };
+      const arr2 = bins.get(b);
+      if (arr2) arr2.push(r);
+      else bins.set(b, [r]);
+    }
+    for (const runs of bins.values()) {
+      if (runs.length < 2) continue;
+      runs.sort((a, b) => a.d - b.d);
+      for (let k = 0; k < runs.length; k++) {
+        const c = runs[k];
+        if (soft[c.i]) continue;
+        const need = ANNOT_OVERLAP_FRAC * (c.t1 - c.t0);
+        const alongside = (dir) => {
+          for (let step = 1, j = k + dir; step <= ANNOT_MAX_SCAN && j >= 0 && j < runs.length; step++, j += dir) {
+            const o = runs[j];
+            const gap = Math.abs(o.d - c.d);
+            if (gap > maxOffsetPx) break;
+            if (gap < minOffsetPx) continue;
+            if (Math.min(o.t1, c.t1) - Math.max(o.t0, c.t0) < need) continue;
+            return o;
+          }
+          return null;
+        };
+        const up = alongside(1), dn = alongside(-1);
+        const heavier = (o, other) => !!o && !other && o.w >= c.w + ANNOT_MIN_PEN_STEP;
+        if (heavier(up, dn) || heavier(dn, up)) soft[c.i] = 1;
+      }
+    }
+  }
+  return soft;
+}
 var HATCH_ID_ANGLE_Q = 0.5;
 var HATCH_ID_PITCH_Q = 0.1;
 function hatchFamilies(segs, meta) {
@@ -1335,6 +1405,10 @@ function buildMask(segs, imgW, imgH, maxDim = MASK_MAX_DIM, meta = null, pxPerFt
   const mask = new Uint8Array(mw * mh);
   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 annot = meta && mppf > 0 ? classifyOffsetAnnotationSegs(segs, meta, ws, ANNOT_OFFSET_MAX_FT * mppf, ANNOT_OFFSET_MIN_FT * mppf, ANNOT_MIN_LEN_FT * mppf) : null;
+  if (soft && annot) {
+    for (let i = 0; i < soft.length; i++) if (annot[i]) soft[i] = 1;
+  }
   const noDoor = meta ? flagNonDoorArcs(segs, meta) : null;
   let softCount = 0;
   for (let i = 0, si = 0; i + 3 < segs.length; i += 4, si++) {
@@ -1779,6 +1853,123 @@ function boundaryCurveClusters(mo, region) {
   }
   return clusters;
 }
+var SPLIT_GAP = 1;
+var SPLIT_MIN_SEED = 8;
+var SAME_ARC_CENTRE_FT = 0.5;
+var SAME_ARC_RADIUS_FRAC = 0.15;
+function splitMergedArcs(cl, mw, mask, mppf) {
+  if (cl.length < 2 * SPLIT_MIN_SEED) return [cl];
+  if (arcClusterFit(cl, mw, mask).good) return [cl];
+  const set = new Set(cl);
+  const seen = /* @__PURE__ */ new Set();
+  const parts = [];
+  for (const start of cl) {
+    if (seen.has(start)) continue;
+    seen.add(start);
+    const comp = [start];
+    const stack = [start];
+    while (stack.length) {
+      const i = stack.pop();
+      const y = i / mw | 0, x = i - y * mw;
+      for (let dy = -SPLIT_GAP; dy <= SPLIT_GAP; dy++) {
+        for (let dx = -SPLIT_GAP; dx <= SPLIT_GAP; dx++) {
+          if (!dx && !dy) continue;
+          const j = (y + dy) * mw + (x + dx);
+          if (set.has(j) && !seen.has(j)) {
+            seen.add(j);
+            comp.push(j);
+            stack.push(j);
+          }
+        }
+      }
+    }
+    parts.push(comp);
+  }
+  if (parts.length < 2) return [cl];
+  const centreTol = mppf > 0 ? Math.max(2, SAME_ARC_CENTRE_FT * mppf) : 4;
+  const groups = [];
+  const orphans = [];
+  for (const p of parts.slice().sort((a, b) => b.length - a.length)) {
+    const f = p.length >= SPLIT_MIN_SEED ? arcClusterFit(p, mw, mask) : null;
+    const claim = f && f.good ? groups.find((gp) => Math.hypot(gp.cx - f.cx, gp.cy - f.cy) <= centreTol && Math.abs(gp.r - f.r) <= SAME_ARC_RADIUS_FRAC * Math.max(gp.r, f.r)) : void 0;
+    if (claim) {
+      claim.cells.push(...p);
+      continue;
+    }
+    if (f && f.good) {
+      groups.push({ cx: f.cx, cy: f.cy, r: f.r, cells: p.slice() });
+      continue;
+    }
+    orphans.push(...p);
+  }
+  if (groups.length < 2) return [cl];
+  const out = groups.map((gp) => gp.cells);
+  if (orphans.length) out.push(orphans);
+  return out;
+}
+var LEAF_MIN_SECTOR_FRAC = 0.15;
+var LEAF_MIN_COVER = 0.55;
+var LEAF_HALF_FT = 0.3;
+var LEAF_HALF_FLOOR_PX = 1.5;
+var LEAF_T0 = 0.2;
+var LEAF_T1 = 0.95;
+function doorLeafCells(fit, cl, mw, mh, mask, mppf = 0) {
+  if (!fit.good || !(fit.r > 2)) return null;
+  const LEAF_HALF_W = mppf > 0 ? Math.max(LEAF_HALF_FLOOR_PX, LEAF_HALF_FT * mppf) : LEAF_HALF_FLOOR_PX;
+  const angs = cl.map((i) => Math.atan2((i / mw | 0) - fit.cy, i % mw - fit.cx)).sort((a, b) => a - b);
+  if (angs.length < 2) return null;
+  let gapAt = -1, gapMax = angs[0] + 2 * Math.PI - angs[angs.length - 1];
+  for (let k = 1; k < angs.length; k++) {
+    const gp = angs[k] - angs[k - 1];
+    if (gp > gapMax) {
+      gapMax = gp;
+      gapAt = k;
+    }
+  }
+  const ends = gapAt < 0 ? [angs[0], angs[angs.length - 1]] : [angs[gapAt], angs[gapAt - 1]];
+  let best = null, bestCover = LEAF_MIN_COVER;
+  for (const th of ends) {
+    const ux = Math.cos(th), uy = Math.sin(th);
+    const ax = fit.cx + ux * fit.r * LEAF_T0, ay = fit.cy + uy * fit.r * LEAF_T0;
+    const bx = fit.cx + ux * fit.r * LEAF_T1, by = fit.cy + uy * fit.r * LEAF_T1;
+    const x0 = Math.max(0, Math.floor(Math.min(ax, bx) - LEAF_HALF_W - 1));
+    const x1 = Math.min(mw - 1, Math.ceil(Math.max(ax, bx) + LEAF_HALF_W + 1));
+    const y0 = Math.max(0, Math.floor(Math.min(ay, by) - LEAF_HALF_W - 1));
+    const y1 = Math.min(mh - 1, Math.ceil(Math.max(ay, by) + LEAF_HALF_W + 1));
+    const dx = bx - ax, dy = by - ay, L2 = dx * dx + dy * dy;
+    if (!(L2 > 0)) continue;
+    const cells = [];
+    for (let y = y0; y <= y1; y++) {
+      for (let x = x0; x <= x1; x++) {
+        let t = ((x - ax) * dx + (y - ay) * dy) / L2;
+        t = t < 0 ? 0 : t > 1 ? 1 : t;
+        const ex = ax + t * dx - x, ey = ay + t * dy - y;
+        if (ex * ex + ey * ey > LEAF_HALF_W * LEAF_HALF_W) continue;
+        const i = y * mw + x;
+        if (mask[i] & 1 && !(mask[i] & MASK_CURVE_BIT)) cells.push(i);
+      }
+    }
+    let hit = 0, tries = 0;
+    for (let t = 0; t <= 1; t += 0.02) {
+      tries++;
+      const px = ax + t * dx, py = ay + t * dy;
+      let inked = false;
+      for (let o = -LEAF_HALF_W; o <= LEAF_HALF_W && !inked; o += 0.5) {
+        const x = Math.round(px - dy / Math.sqrt(L2) * o), y = Math.round(py + dx / Math.sqrt(L2) * o);
+        if (x < 0 || y < 0 || x >= mw || y >= mh) continue;
+        const i = y * mw + x;
+        if (mask[i] & 1 && !(mask[i] & MASK_CURVE_BIT)) inked = true;
+      }
+      if (inked) hit++;
+    }
+    const cover = tries ? hit / tries : 0;
+    if (cover > bestCover && cells.length) {
+      bestCover = cover;
+      best = cells;
+    }
+  }
+  return best && best.length ? best : null;
+}
 function arcClusterFit(cl, mw, mask) {
   const m = cl.length;
   const X = (i) => i % mw, Y = (i) => i / mw | 0;
@@ -2009,10 +2200,33 @@ function floodRegionSealedInner(mo, ix, iy, sensitivity, radii, wedgeCapPx, minP
   let hatchTier = r1.hatchTier;
   let sealedPx = r1.sealedPx, virtualFrac = r1.virtualFrac;
   let minPassPxOut = r1.minPassPx, minPassDelta = r1.minPassDelta;
-  const ranked = clusters.map((cl) => {
+  const entry = (cl, pass, fit) => {
+    const f = fit ?? arcClusterFit(cl, mw, mo.mask);
+    const ideal = 0.5 * f.r * f.r * f.sweep;
+    return {
+      cl,
+      fit: f,
+      allow: wedgeAllowance(f, mo.mppf || 0, wedgeCapPx),
+      rank: doorLikeness(f, mo.mppf || 0),
+      at: cl[0],
+      pass,
+      minGrow: pass === 2 ? Math.max(1, Math.round(LEAF_MIN_SECTOR_FRAC * ideal)) : 0
+    };
+  };
+  const ranked = [];
+  for (const cl of clusters) {
     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);
+    ranked.push(entry(cl, 0, fit));
+    const parts = splitMergedArcs(cl, mw, mo.mask, mo.mppf || 0);
+    const pieces = parts.length > 1 ? parts : [cl];
+    if (parts.length > 1) for (const p of parts) ranked.push(entry(p, 1));
+    for (const p of pieces) {
+      const pf = p === cl ? fit : arcClusterFit(p, mw, mo.mask);
+      const leaf = doorLeafCells(pf, p, mw, mh, mo.mask, mo.mppf || 0);
+      if (leaf) ranked.push({ ...entry(leaf, 2, pf), cl: leaf });
+    }
+  }
+  ranked.splice(0, ranked.length, ...ranked.filter((c) => c.allow >= 1).sort((a, b) => a.pass - b.pass || 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);
@@ -2022,7 +2236,7 @@ function floodRegionSealedInner(mo, ix, iy, sensitivity, radii, wedgeCapPx, minP
     sealCache.set(mo.mask, base);
   }
   const baseDT = base.dt;
-  for (const { cl, fit, allow: clusterAllowance } of ranked.slice(0, WEDGE_MAX_DOORS)) {
+  for (const { cl, fit, allow: clusterAllowance, minGrow } of ranked.slice(0, 2 * WEDGE_MAX_DOORS)) {
     if (!m2mask) {
       m2mask = mo.mask.slice();
       m2dt = baseDT.slice();
@@ -2056,6 +2270,7 @@ function floodRegionSealedInner(mo, ix, iy, sensitivity, radii, wedgeCapPx, minP
     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 < minGrow) continue;
     if (growth > clusterAllowance) continue;
     if (count - r1.count + growth > globalAllowance) continue;
     if (!region) {
@@ -3019,6 +3234,9 @@ var SWEEP_MAX_CANDIDATES = 2e4;
 var ANCHOR_COUNT = 3;
 var MIN_SEG_LEN = 0.5;
 var MAX_SEED_SEGS = 2e3;
+var SWEEP_MIN_SCALE = 1 / 64;
+var SWEEP_MAX_SCALE = 64;
+var MIN_FOOTPRINT_TOLS = 6;
 function transformsFor(rotations, mirror) {
   const rots = [
     [0, [1, 0, 0, 1]],
@@ -3068,6 +3286,38 @@ 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 scaleFingerprint(fp, k) {
+  if (!Number.isFinite(k) || !(k > 0)) {
+    throw new Error(`Size ratio must be a positive, finite number (seed-sheet px per target-sheet px) \u2014 got ${k}.`);
+  }
+  if (k === 1) return fp;
+  if (k < SWEEP_MIN_SCALE || k > SWEEP_MAX_SCALE) {
+    throw new Error(`Size ratio ${k.toFixed(4)} is outside the sane band (${SWEEP_MIN_SCALE} \u2013 ${SWEEP_MAX_SCALE}) \u2014 that is a larger disagreement than any real sheet pair, so the likelier cause is a wrong scale on one of the two sheets. Check set_scale on both before sweeping across them.`);
+  }
+  const rel = [];
+  let totalLen = 0;
+  let subPixelDropped = 0;
+  for (const r of fp.rel) {
+    const len = r[4] * k;
+    if (len < MIN_SEG_LEN) {
+      subPixelDropped++;
+      continue;
+    }
+    rel.push([r[0] * k, r[1] * k, r[2] * k, r[3] * k, len]);
+    totalLen += len;
+  }
+  if (!rel.length) {
+    throw new Error(`At a ${k.toFixed(4)} size ratio every segment of this symbol falls below ${MIN_SEG_LEN} px on the target sheet \u2014 there is no linework left to match. Marquee an instance drawn on the target sheet itself.`);
+  }
+  return {
+    rel,
+    totalLen,
+    segments: rel.length,
+    center: fp.center,
+    footprint: fp.footprint * k,
+    ...subPixelDropped ? { subPixelDropped } : {}
+  };
+}
 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]);
@@ -3116,13 +3366,21 @@ function fingerprintSymbol(segs, seedRect) {
   };
 }
 function matchSymbol(fp, segs, opts = {}) {
-  const tol = opts.tolPx ?? SWEEP_TOL_PX;
+  const scale = opts.scale ?? 1;
+  const tol = (opts.tolPx ?? SWEEP_TOL_PX) * Math.max(1, scale);
   const scoreHigh = opts.scoreHigh ?? SWEEP_SCORE_HIGH;
   const scoreLow = opts.scoreLow ?? SWEEP_SCORE_LOW;
   const maxCandidates = opts.maxCandidates ?? SWEEP_MAX_CANDIDATES;
   const xforms = transformsFor(opts.rotations ?? true, opts.mirror ?? true);
   const n = segs.length >> 2;
-  const { rel, totalLen } = fp;
+  if (scale !== 1 && opts.excludeCenter) {
+    throw new Error("excludeCenter is a point on the SEED sheet and means nothing on a target sheet at a different scale \u2014 omit it when sweeping across sheets (there is no seed there to shadow).");
+  }
+  const fpS = scale === 1 ? fp : scaleFingerprint(fp, scale);
+  if (scale !== 1 && fpS.footprint < MIN_FOOTPRINT_TOLS * tol) {
+    throw new Error(`At a ${scale.toFixed(4)} size ratio this symbol is ${fpS.footprint.toFixed(1)} px across on the target sheet \u2014 inside the ${tol.toFixed(1)} px matching tolerance, where every placement scores alike and a "match" means nothing. The seed is drawn too large relative to the target for its linework to survive the trip: marquee an instance on the target sheet itself, or count the tag text with sweep_schedule_row.`);
+  }
+  const { rel, totalLen } = fpS;
   const lenBucket = /* @__PURE__ */ new Map();
   for (let i = 0; i < n; i++) {
     const b = Math.round(segLen(segs, i));
@@ -3219,7 +3477,7 @@ function matchSymbol(fp, segs, opts = {}) {
       twin.xf = s.xf;
     }
   }
-  const suppressR = Math.max(mergeR, fp.footprint / 2);
+  const suppressR = Math.max(mergeR, fpS.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 = [];
@@ -3240,7 +3498,20 @@ function matchSymbol(fp, segs, opts = {}) {
   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 } };
+  return {
+    matches,
+    withheld,
+    candidates: { considered, dropped },
+    ...scale === 1 ? {} : {
+      scaled: {
+        ratio: Math.round(scale * 1e6) / 1e6,
+        segments: fpS.segments,
+        sub_pixel_dropped: fpS.subPixelDropped ?? 0,
+        footprint_px: Math.round(fpS.footprint * 10) / 10,
+        tol_px: Math.round(tol * 100) / 100
+      }
+    }
+  };
 }
 
 // ../web/src/lib/provenance.js
@@ -5150,6 +5421,37 @@ var Session = class _Session {
     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);
     return { committed: ids.length, shape_ids: ids, condition: c.finish_tag, ea_total };
   }
+  /** The seed→target size ratio for a cross-sheet sweep (#186): seed-sheet
+   * image px per target-sheet image px, which is exactly `upp_seed /
+   * upp_target` — both sheets' own committed scales, no search and no guess.
+   *
+   * `known: false` means at least one of the two sheets has no scale set. The
+   * sweep can still run at 1.0 (same-size drafting is the norm across the plan
+   * sheets of one set) but the caller MUST disclose the assumption, because an
+   * unknown ratio and a zero count together are indistinguishable from "the
+   * symbol isn't there" — the exact silent wrong answer #186 exists to kill. */
+  sweepRatio(seed, target) {
+    if (seed.key === target.key) return { scale: 1, known: true };
+    if (seed.upp && target.upp) return { scale: seed.upp / target.upp, known: true };
+    return { scale: 1, known: false };
+  }
+  /** The refusal that has to fire before a detail-seeded sweep runs blind. A
+   * detail, legend, or schedule sheet is drawn at ITS own enlarged scale — a
+   * 1-1/2" = 1'-0" detail against a 1/8" plan is 12× — so sweeping it against
+   * the plans without the ratio searches for a symbol twelve times too large
+   * and reports a confident zero. Plan-to-plan is different and stays
+   * permissive: one set's plan sheets are drawn at one scale nearly always,
+   * and requiring set_scale there would break sweeps that work today. */
+  requireCrossScale(seed, seedRole, targets) {
+    if (seedRole === "plan") return;
+    const seen = /* @__PURE__ */ new Set();
+    const missing = [seed, ...targets].filter((sh) => !sh.upp && !seen.has(sh.key) && (seen.add(sh.key), true));
+    if (!missing.length) return;
+    const names = missing.map((sh) => sh.key);
+    throw new UserError(
+      `The seed sits on a ${seedRole} sheet (${seed.key}), which is drawn at its own enlarged scale \u2014 matching it against the plans needs BOTH scales stated, and ${names.length === 1 ? `${names[0]} has none` : `these have none: ${names.join(", ")}`}. Sweeping without the ratio would search the plans for a symbol several times too large and report a confident zero, so it refuses instead. Run set_scale on ${names.join(", ")} first${missing.some((sh) => sh.detected) ? ` (detected: ${missing.filter((sh) => sh.detected).map((sh) => `${sh.key} \u2192 ${sh.detected.label}`).join(", ")})` : ""}, or marquee an instance drawn on a plan sheet itself and sweep with scope 'sheet'.`
+    );
+  }
   /** symbol_sweep — every placement of ONE example symbol, from the linework.
    * The engine is pure (web/src/lib/symbolsweep.ts): fingerprint the seed
    * rect's segments, propose placements by constellation anchoring under the
@@ -5247,6 +5549,7 @@ var Session = class _Session {
     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";
+    this.requireCrossScale(s, seedRole, this.sheetList().filter((sh) => (roleOf.get(sh.key) ?? "unknown") === "plan"));
     const perSheet = [];
     const skipped = [];
     for (const sh of this.sheetList()) {
@@ -5264,10 +5567,21 @@ var Session = class _Session {
         skipped.push({ sheet: sh.key, role, reason: "no vector linework (likely a scan) \u2014 symbol matching reads the drawn segments" });
         continue;
       }
+      const ratio = this.sweepRatio(s, sh);
       const t0 = process.hrtime.bigint();
-      const res = matchSymbol(fp, g2.segs, { ...sweepOpts, ...sh.key === s.key ? { excludeCenter: fp.center } : {} });
+      let res;
+      try {
+        res = matchSymbol(fp, g2.segs, {
+          ...sweepOpts,
+          ...ratio.scale === 1 ? {} : { scale: ratio.scale },
+          ...sh.key === s.key ? { excludeCenter: fp.center } : {}
+        });
+      } catch (e) {
+        skipped.push({ sheet: sh.key, role, reason: e instanceof Error ? e.message : String(e) });
+        continue;
+      }
       const elapsed_ms = Math.round(Number(process.hrtime.bigint() - t0) / 1e4) / 100;
-      perSheet.push({ state: sh, ...res, elapsed_ms });
+      perSheet.push({ state: sh, ...res, elapsed_ms, scale: ratio });
     }
     const found = perSheet.reduce((n, p) => n + p.matches.length, 0);
     let committed;
@@ -5292,6 +5606,21 @@ var Session = class _Session {
     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.");
+    const rescaled = perSheet.filter((p) => p.scaled);
+    const assumed = perSheet.filter((p) => !p.scale.known);
+    if (rescaled.length) {
+      notes.push(`Size ratio applied from the sheets' own scales: ${rescaled.map((p) => `${p.state.key} \xD7${p.scaled.ratio}`).join(", ")} \u2014 the seed was resized to each target sheet before matching, never scale-searched.`);
+      const thinned = rescaled.filter((p) => p.scaled.sub_pixel_dropped > 0);
+      if (thinned.length) {
+        notes.push(`Scaling down cost detail: ${thinned.map((p) => `${p.state.key} dropped ${p.scaled.sub_pixel_dropped} sub-pixel segment(s)`).join(", ")} \u2014 scores there are a fraction of the linework that survived the trip, not of the whole seed.`);
+      }
+    }
+    if (assumed.length) {
+      const empty = assumed.filter((p) => !p.matches.length).map((p) => p.state.key);
+      notes.push(
+        `Swept at 1:1 on ${assumed.map((p) => p.state.key).join(", ")} \u2014 no scale is set on the seed sheet or on those, so the true size ratio is unknown and same-size drafting was assumed.` + (empty.length ? ` ${empty.join(", ")} found nothing, and an unstated ratio is a live explanation for that: if any of those sheets is drawn at a different scale than ${s.key}, the search was for a wrong-sized symbol. set_scale on both ends turns this from an assumption into arithmetic.` : "")
+      );
+    }
     return {
       scope,
       found,
@@ -5302,7 +5631,9 @@ var Session = class _Session {
         matches: p.matches.map((m) => ({ at: [round1(m.at[0]), round1(m.at[1])], score: m.score, rotation: m.rotation, mirrored: m.mirrored })),
         withheld: p.withheld.map((w) => ({ at: [round1(w.at[0]), round1(w.at[1])], score: w.score, rotation: w.rotation, mirrored: w.mirrored, reason: w.reason })),
         candidates: p.candidates,
-        elapsed_ms: p.elapsed_ms
+        elapsed_ms: p.elapsed_ms,
+        ...p.scaled ? { scaled: p.scaled } : {},
+        ...p.scale.known ? {} : { scale_assumed: "no scale set on the seed sheet or this one \u2014 swept at 1:1" }
       })),
       skipped,
       ...committed ?? {},
@@ -5389,8 +5720,8 @@ var Session = class _Session {
       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 };
+    if (withOcc[0].occ.length > 1) corro = { sh: anchorSheet, segs: anchorGeo.segs, occ: withOcc[0].occ.slice(1) };
+    else if (withOcc.length > 1) corro = { sh: withOcc[1].sh, 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;
@@ -5414,8 +5745,14 @@ var Session = class _Session {
         anchorRect = rect;
         break;
       }
-      const probe = matchSymbol(cand, corro.segs, sweepOpts);
-      const pr = cand.footprint / 2 + anchor.h;
+      const cr = this.sweepRatio(anchorSheet, corro.sh);
+      let probe;
+      try {
+        probe = matchSymbol(cand, corro.segs, { ...sweepOpts, ...cr.scale === 1 ? {} : { scale: cr.scale } });
+      } catch {
+        continue;
+      }
+      const pr = (probe.scaled ? probe.scaled.footprint_px : 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;
@@ -5426,7 +5763,7 @@ var Session = class _Session {
     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 radiusFor = (sc) => (sc ? sc.footprint_px : 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) {
@@ -5435,8 +5772,16 @@ var Session = class _Session {
         skipped.push({ sheet: sh.key, role: "plan", reason: "no vector linework (likely a scan) \u2014 symbol matching reads the drawn segments" });
         continue;
       }
+      const ratio = this.sweepRatio(anchorSheet, sh);
       const t0 = process.hrtime.bigint();
-      const res = matchSymbol(fp, g2.segs, sweepOpts);
+      let res;
+      try {
+        res = matchSymbol(fp, g2.segs, { ...sweepOpts, ...ratio.scale === 1 ? {} : { scale: ratio.scale } });
+      } catch (e) {
+        skipped.push({ sheet: sh.key, role: "plan", reason: e instanceof Error ? e.message : String(e) });
+        continue;
+      }
+      const R = radiusFor(res.scaled);
       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 });
@@ -5472,7 +5817,7 @@ var Session = class _Session {
       excluded.sort(byPos);
       withheld.sort(byPos);
       const text_only = occ.filter((o, k) => !matchedOcc.has(k) && !res.withheld.some((w) => Math.hypot(w.at[0] - o.cx, w.at[1] - o.cy) <= R)).map((o) => ({ at: [round1(o.cx), round1(o.cy)] }));
-      perSheet.push({ state: sh, matches, withheld, excluded, text_only, candidates: res.candidates, elapsed_ms });
+      perSheet.push({ state: sh, matches, withheld, excluded, text_only, candidates: res.candidates, elapsed_ms, scale: ratio, ...res.scaled ? { scaled: res.scaled } : {} });
     }
     const found = perSheet.reduce((n, p) => n + p.matches.length, 0);
     let committed;
@@ -5506,6 +5851,14 @@ var Session = class _Session {
     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.");
+    const rowRescaled = perSheet.filter((p) => p.scaled);
+    if (rowRescaled.length) {
+      notes.push(`Size ratio applied from the sheets' own scales: ${rowRescaled.map((p) => `${p.state.key} \xD7${p.scaled.ratio}`).join(", ")} \u2014 the marker was resized from ${anchorSheet.key} before matching.`);
+    }
+    const rowAssumed = perSheet.filter((p) => !p.scale.known && !p.matches.length);
+    if (rowAssumed.length) {
+      notes.push(`${rowAssumed.map((p) => p.state.key).join(", ")} found nothing and were swept at 1:1 \u2014 no scale is set on ${anchorSheet.key} or on them, so a different drawn scale there is a live explanation for the zero. set_scale on both ends to rule it out.`);
+    }
     return {
       tag: t,
       row: {
@@ -5533,7 +5886,9 @@ var Session = class _Session {
         excluded: p.excluded.map((e) => ({ at: [round1(e.at[0]), round1(e.at[1])], tag: e.tag })),
         text_only: p.text_only,
         candidates: p.candidates,
-        elapsed_ms: p.elapsed_ms
+        elapsed_ms: p.elapsed_ms,
+        ...p.scaled ? { scaled: p.scaled } : {},
+        ...p.scale.known ? {} : { scale_assumed: `no scale set on ${anchorSheet.key} or this sheet \u2014 swept at 1:1` }
       })),
       skipped,
       ...committed ?? {},
@@ -6457,13 +6812,23 @@ 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 sweepScaled = z.object({
+  ratio: z.number().describe("Seed-sheet px per target-sheet px, computed from the two sheets' own committed scales (upp_seed / upp_target) \u2014 stated, never scale-searched"),
+  segments: z.number().int().describe("Fingerprint segments that survived the resize and were actually searched for"),
+  sub_pixel_dropped: z.number().int().describe("Seed segments that fell below matchable length when scaled down \u2014 excluded from the score rather than depressing it, so a score here is a fraction of what survived, not of the whole seed"),
+  footprint_px: z.number().describe("The symbol's size on THIS sheet after the resize"),
+  tol_px: z.number().describe("The endpoint tolerance actually applied \u2014 it rides the ratio up when the seed is magnified (its drawn jitter magnifies too) and never down")
+}).describe("#186: present only when the seed was resized for this sheet");
+var sweepScaleAssumed = z.string().describe("#186: present when the true ratio is UNKNOWN (a scale is missing on the seed sheet or this one) and the sweep ran at 1:1 \u2014 an unstated ratio plus a zero count is not evidence of absence");
 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")
+  elapsed_ms: z.number().describe("Wall-clock for this sheet's sweep"),
+  scaled: sweepScaled.optional(),
+  scale_assumed: sweepScaleAssumed.optional()
 });
 var sweepSkipped = z.array(z.object({
   sheet: z.string(),
@@ -6827,7 +7192,9 @@ var sweepScheduleRowOutput = {
     excluded: z.array(z.object({ at: z.tuple([z.number(), z.number()]), tag: z.string() })).describe("Markers matching the geometry but labeled with a SIBLING row's tag \u2014 the bubble shape is shared across marks, so these belong to that row, not this one"),
     text_only: z.array(z.object({ at: z.tuple([z.number(), z.number()]) })).describe("The tag drawn with NO matching marker geometry nearby \u2014 a note reference or a variant marker; a question, never a count"),
     candidates: z.object({ considered: z.number().int(), dropped: z.number().int() }),
-    elapsed_ms: z.number().describe("Wall-clock for this sheet's sweep")
+    elapsed_ms: z.number().describe("Wall-clock for this sheet's sweep"),
+    scaled: sweepScaled.optional(),
+    scale_assumed: sweepScaleAssumed.optional()
   })).describe("One entry per swept PLAN-role sheet, load order"),
   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"),
@@ -8420,7 +8787,7 @@ 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 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}`,
+    description: `Find EVERY instance of a repeated plan symbol from ONE example \u2014 drains, thresholds, fixtures, transition markers: marquee a tight seed_rect around a single instance and the vector linework is searched for every other placement of that same segment cluster. Deterministic geometry, not vision: each placement scores as the length-weighted fraction of the seed's segments reproduced within tolerance_px, under translation plus 0/90/180/270 rotation and mirroring (symbols rotate on plans \u2014 both ON by default; turn them off to pin orientation). Score \u2265 0.92 is a match; the 0.75\u20130.92 band comes back in \`withheld\` with a reason \u2014 a near-match is a question you answer by LOOKING (view_sheet at its \`at\`), never a silent commit and never a silent drop. The seed's own location is reported in \`seed\` and never double-committed. Work is capped and the cap is disclosed: a reply with candidates.dropped > 0 says exactly that some placements were never scored \u2014 tighten the seed rect around more distinctive geometry rather than trusting a truncated count. Marquee discipline: the rect must hug ONE instance \u2014 only segments FULLY inside it define the symbol, so a loose rect that swallows wall linework fingerprints the wall, not the symbol. scope "set" sweeps the WHOLE working set, counting on PLAN-role sheets only (the sheet graph decides): a symbol drawn in a detail, legend, or schedule is a reference drawing and never counts itself \u2014 which is also how you seed from one: marquee the assembly on the detail sheet and its plan-sheet occurrences are counted while the detail stays excluded (the exclusion disclosed in \`skipped\`, per-sheet results with per-sheet caps and wall-clock in \`sheets\`). Scale across sheets: the fingerprint is size-true and is never scale-SEARCHED, so a detail drawn at 1-1/2" = 1'-0" is 12\xD7 the size of the same mark on a 1/8" plan \u2014 when BOTH sheets have a scale set, the exact ratio is computed from them and the seed is resized before matching (reported per sheet as \`scaled\`); when a scale is missing, the sweep runs at 1:1 and SAYS so (\`scale_assumed\`), because an unknown ratio plus a zero count is not evidence of absence. Seeding from a detail/legend/schedule sheet REFUSES outright until both scales are set \u2014 that is the case where an unstated ratio silently finds nothing. commit: true (requires condition) commits every match center as an EA count marker through the same path as place_count \u2014 the whole sweep (set-wide included) is ONE undo step, each marker carries origin.method "symbol_sweep" with its score, transform, and seed source, and withheld placements are NEVER committed. The COUNT is scale-free (EA), but matching across sheets of different scales is not \u2014 set_scale on the sheets involved is what turns the ratio from an assumption into arithmetic. After any batch commit, LOOK at what landed \u2014 view_sheet {overlay: true} over the swept area \u2014 and audit the markers against the drawing before trusting the EA total. ${COORDS}`,
     inputSchema: {
       sheet: z2.string().describe("The sheet the seed rect sits on \u2014 in scope 'set' it may be ANY sheet (a detail/legend seed sheet is fingerprint source only, never counted)"),
       seed_rect: z2.tuple([pointSchema, pointSchema]).describe("Marquee around ONE example instance, [[x0,y0],[x1,y1]] in image px \u2014 tight: segments fully inside define the symbol"),
@@ -8442,7 +8809,7 @@ function registerTools(server, session) {
     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}`,
+    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. The COUNT is scale-free (EA), but matching is not: where the anchor sheet and a target sheet both carry a scale, the marker is resized by their exact ratio before matching (\`scaled\` per sheet), and where one does not, the sweep runs at 1:1 and discloses it (\`scale_assumed\`) rather than reporting a confident zero. 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)"),
@@ -8793,7 +9160,7 @@ function registerResources(server, session) {
 // package.json
 var package_default = {
   name: "opentakeoff-mcp",
-  version: "0.9.26",
+  version: "0.9.29",
   mcpName: "io.github.Kentucky-ai/opentakeoff",
   type: "module",
   description: "OpenTakeoff MCP server \u2014 drive the takeoff engine from your MCP client over stdio.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opentakeoff-mcp",
-  "version": "0.9.26",
+  "version": "0.9.29",
   "mcpName": "io.github.Kentucky-ai/opentakeoff",
   "type": "module",
   "description": "OpenTakeoff MCP server — drive the takeoff engine from your MCP client over stdio.",