opentakeoff-mcp 0.9.27 → 0.9.30

package/README.md

@@ -113,6 +113,7 @@ includes document text, shape vertices, or result payload content.
 | `measure_polygon` | Area + perimeter of a polygon you supply (min 3 verts). Requires scale. |
 | `measure_line` | Length of an open polyline (min 2 points). Requires scale. |
 | `derive_base` | **Base LF from committed rooms**: for every floor shape of a source condition, commits a linear base run tracing that room's boundary, quantified net of the door openings YOU state per room (`{shape_id, lf}` — your claim, recorded on `origin.derived`; the tool never guesses). All-or-nothing; one undo step. |
+| `derive_transitions` | **The transition where two finishes meet**: pass two finish tags and the tag to commit under, and every committed room of each is compared against every room of the other. The catch this is built around — flood-traced rooms **do not share edges**, a partition puts 4–8″ between them — so proximity comes in two flavours and they are never conflated. A **butt joint** (rings running together inside one open space, within an inch) *is* the transition and commits as a linear shape, `origin.derived` naming both parents, the tags, and the measured gap. A **wall-separated** run means the rooms are adjacent across a partition, where the transition is a threshold in a doorway that nothing in the trace record locates (the flood engine reports how *much* boundary it sealed, never where) — those return in `withheld` with length, gap in inches, and an `at` point to `view_sheet`, as questions rather than a confident wrong number. `max_gap_in` (default 12) only ever turns more of the plan into questions, never into committed LF. All-or-nothing; one undo step. |
 | `measure_surface` | **Wall SF**: an open run traced along the wall, quantified as traced LF × the condition's height (the canvas's H knob — pass `height_ft` to set it, or set it once with `edit_condition`). Wall tile, wainscot, wall systems. Refuses without a height, minting nothing. |
 | `place_count` | **EA markers**: one point, one each — thresholds, stair nosings, floor boxes. No scale required (EA is scale-free). One shape per point; the whole call is one undo step. |
 | `symbol_sweep` | **Every instance of a repeated plan symbol, from ONE example**: marquee a tight `seed_rect` around a single drain/threshold/fixture symbol and the vector linework is searched deterministically for every other placement — translation plus 0/90/180/270 rotation and mirroring (both on by default). Score = length-weighted fraction of the seed's segments matched within `tolerance_px`; ≥ 0.92 is a match, the 0.75–0.92 band returns in `withheld` with reasons (never committed, never dropped silently), and the work cap is disclosed when it bites. **`scope: "set"` sweeps the whole working set, counting on PLAN-role sheets only** (the sheet graph decides; every excluded sheet disclosed in `skipped` with role and reason) — and the seed rect may sit on a detail or legend sheet, which then serves as the fingerprint SOURCE while staying excluded from counting: the estimator's "click the assembly in the detail, count it on the plans" gesture. Per-sheet results carry their own match/withheld lists, per-sheet cap accounting, and wall-clock `elapsed_ms`. `commit: true` + `condition` commits every match center as an EA count marker — the whole sweep (set-wide included) is one undo step, `origin.method "symbol_sweep"` with per-marker score, transform, and seed source (`origin.symbol.seed`). No scale required. |

package/dist/server-core.js

@@ -479,14 +479,14 @@ 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 = [];
+  const segments2 = [];
   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]]);
+      segments2.push([[c1x, c1y], [c2x, c2y], [qx, qy]]);
       px = qx;
       py = qy;
     }
@@ -495,7 +495,7 @@ function cloudBezier(x0, y0, x1, y1) {
   edge(ax1, ay0, ax1, ay1);
   edge(ax1, ay1, ax0, ay1);
   edge(ax0, ay1, ax0, ay0);
-  return { start: [ax0, ay0], segments };
+  return { start: [ax0, ay0], segments: segments2 };
 }
 function buildSnapGrid(points, cell) {
   const map = /* @__PURE__ */ new Map();
@@ -1203,7 +1203,7 @@ function sweepHatchRuns(segs, meta, ws) {
       clusters.pop();
     }
   }
-  const median = (arr2) => {
+  const median2 = (arr2) => {
     const a = arr2.slice().sort((x, y) => x - y);
     return a[a.length >> 1];
   };
@@ -1240,17 +1240,17 @@ function sweepHatchRuns(segs, meta, ws) {
       if (count < HATCH_MIN_RUN) return;
       const gaps = [];
       for (let k = a + 1; k <= b; k++) gaps.push(rows[k].d - rows[k - 1].d);
-      const med = median(gaps);
+      const med = median2(gaps);
       if (!med) return;
       let reg = 0;
       for (const g of gaps) if (Math.abs(g - med) <= med * HATCH_PITCH_TOL) reg++;
       if (reg / gaps.length < HATCH_MIN_REGULAR) return;
       const widths = [];
       for (let k = a; k <= b; k++) for (const s of rows[k].segs) widths.push(s.w);
-      const modalW = Math.max(1, median(widths));
+      const modalW = Math.max(1, median2(widths));
       const spans = [];
       for (let k = a; k <= b; k++) spans.push(rows[k].t1 - rows[k].t0);
-      const medSpan = Math.max(1, median(spans));
+      const medSpan = Math.max(1, median2(spans));
       const memberIdx = [];
       const softIdx = [];
       let bx0 = Infinity, by0 = Infinity, bx1 = -Infinity, by1 = -Infinity;
@@ -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) {
@@ -3299,6 +3514,106 @@ function matchSymbol(fp, segs, opts = {}) {
   };
 }
 
+// ../web/src/lib/transitions.ts
+var COINCIDENT_PX = 1e-9;
+function segments(ring) {
+  const out = [];
+  for (let i = 0; i < ring.length; i++) out.push([ring[i], ring[(i + 1) % ring.length]]);
+  return out;
+}
+function nearestOnSeg(p, a, b) {
+  const vx = b[0] - a[0], vy = b[1] - a[1];
+  const len2 = vx * vx + vy * vy;
+  const t = len2 > 0 ? Math.max(0, Math.min(1, ((p[0] - a[0]) * vx + (p[1] - a[1]) * vy) / len2)) : 0;
+  const at = [a[0] + vx * t, a[1] + vy * t];
+  return { d: Math.hypot(p[0] - at[0], p[1] - at[1]), at };
+}
+function nearestOnRing(p, ring) {
+  let best = { d: Infinity, at: p };
+  for (const [a, b] of segments(ring)) {
+    const hit = nearestOnSeg(p, a, b);
+    if (hit.d < best.d) best = hit;
+  }
+  return best;
+}
+function sampleRing(ring, step) {
+  const out = [];
+  for (const [a, b] of segments(ring)) {
+    const len = Math.hypot(b[0] - a[0], b[1] - a[1]);
+    if (!(len > 0)) continue;
+    const n = Math.max(1, Math.ceil(len / step));
+    for (let k = 0; k < n; k++) {
+      const t = k / n;
+      out.push([a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t]);
+    }
+  }
+  return out;
+}
+function median(xs) {
+  if (!xs.length) return Infinity;
+  const s = [...xs].sort((p, q) => p - q);
+  const m = s.length >> 1;
+  return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2;
+}
+function sharedRuns(ringA, ringB, opts) {
+  if (ringA.length < 3 || ringB.length < 3) return [];
+  const { step_px, touch_px, max_gap_px, min_len_px } = opts;
+  const samples = sampleRing(ringA, step_px);
+  if (samples.length < 2) return [];
+  const near = samples.map((p) => nearestOnRing(p, ringB));
+  const dists = near.map((h) => h.d);
+  const alongside = samples.map((p, i) => {
+    if (dists[i] > max_gap_px) return false;
+    const prev = samples[(i - 1 + samples.length) % samples.length];
+    const next = samples[(i + 1) % samples.length];
+    const tx = next[0] - prev[0], ty = next[1] - prev[1];
+    const tl = Math.hypot(tx, ty);
+    const dx = near[i].at[0] - p[0], dy = near[i].at[1] - p[1];
+    const dl = Math.hypot(dx, dy);
+    if (tl === 0) return false;
+    if (dl < COINCIDENT_PX) return true;
+    return Math.abs((tx * dx + ty * dy) / (tl * dl)) <= 0.5;
+  });
+  const raw = [];
+  let start = -1;
+  for (let i = 0; i < samples.length; i++) {
+    if (alongside[i] && start < 0) start = i;
+    if (!alongside[i] && start >= 0) {
+      raw.push({ from: start, to: i - 1 });
+      start = -1;
+    }
+  }
+  if (start >= 0) raw.push({ from: start, to: samples.length - 1 });
+  if (raw.length > 1) {
+    const first = raw[0], last = raw[raw.length - 1];
+    if (first.from === 0 && last.to === samples.length - 1) {
+      raw.pop();
+      raw[0] = { from: last.from, to: first.to + samples.length };
+    }
+  }
+  const runs = [];
+  for (const r of raw) {
+    const idx = [];
+    for (let i = r.from; i <= r.to; i++) idx.push(i % samples.length);
+    const path5 = idx.map((i) => samples[i]);
+    let length_px = 0;
+    for (let i = 1; i < path5.length; i++) {
+      length_px += Math.hypot(path5[i][0] - path5[i - 1][0], path5[i][1] - path5[i - 1][1]);
+    }
+    if (length_px < min_len_px) continue;
+    const gap_px = median(idx.map((i) => dists[i]));
+    const mid = path5[path5.length >> 1];
+    runs.push({
+      kind: gap_px <= touch_px ? "butt" : "wall",
+      path: path5,
+      length_px,
+      gap_px,
+      at: [mid[0], mid[1]]
+    });
+  }
+  return runs;
+}
+
 // ../web/src/lib/provenance.js
 var mintUuid = () => {
   const c = globalThis.crypto;
@@ -4478,9 +4793,9 @@ var Session = class _Session {
       kept = visible2.slice().sort((a, b) => b.len - a.len).slice(0, cap);
       droppedCap = visible2.length - cap;
     }
-    const segments = [], metaOut = [], family = [];
+    const segments2 = [], metaOut = [], family = [];
     for (const { i } of kept) {
-      segments.push([
+      segments2.push([
         round1(geo.segs[i * 4]),
         round1(geo.segs[i * 4 + 1]),
         round1(geo.segs[i * 4 + 2]),
@@ -4502,7 +4817,7 @@ var Session = class _Session {
       region: [round1(r.x0), round1(r.y0), round1(r.x1), round1(r.y1)],
       has_vector_linework: hasVectors,
       vectors: {
-        segments,
+        segments: segments2,
         meta: metaOut,
         family,
         kept: kept.length,
@@ -5181,6 +5496,100 @@ var Session = class _Session {
       note: "Base runs trace each room's boundary; openings are your stated claim, recorded on origin.derived. Verify with view_sheet overlay:true."
     };
   }
+  /** Mint the transition where two finishes meet (#202) — the derivation that
+   * follows derive_base, and the one an estimator draws by hand on every job.
+   *
+   * The geometry lives in web/src/lib/transitions.ts, and its headline is that
+   * flood-traced rooms DO NOT SHARE EDGES: a partition puts four to eight
+   * inches between two rings, so what is actually there is proximity, in two
+   * flavours that mean different things. A BUTT JOINT (the rings run together
+   * inside one open space) is the transition, and commits. A WALL-SEPARATED run
+   * means the rooms are adjacent across a partition — the transition there is a
+   * threshold in the DOORWAY, and nothing in the trace record says where the
+   * doorway is: the flood engine seals openings and reports only how much
+   * boundary it synthesised, never where. Committing thirty-four feet of
+   * threshold because two rooms share thirty-four feet of wall would be a wrong
+   * bid with a machine's confidence behind it, so those come back in
+   * `withheld` — length, gap, and a point to look at — as questions.
+   *
+   * All-or-nothing like derive_base: unknown tags, a transition landing on
+   * either source tag, or an unscaled sheet refuses the whole call before
+   * anything commits. The sweep is ONE journal gesture. */
+  deriveTransitions(opts) {
+    const findCond = (tag) => {
+      const c = this.conditions.find((x) => x.finish_tag === tag);
+      if (!c) throw new UserError(`No condition ${JSON.stringify(tag)} \u2014 tags: ${this.conditions.map((x) => x.finish_tag).join(", ") || "(none)"}.`);
+      return c;
+    };
+    const a = findCond(opts.condition_a), b = findCond(opts.condition_b);
+    if (a.id === b.id) throw new UserError("condition_a and condition_b must be different finishes \u2014 a tag does not transition to itself.");
+    if (opts.condition === a.finish_tag || opts.condition === b.finish_tag) {
+      throw new UserError(`The transition must land on its OWN tag (e.g. 'T-1') \u2014 committing onto ${opts.condition} would add its LF to one of the finishes it separates.`);
+    }
+    const maxGapIn = opts.max_gap_in ?? 12;
+    const minRunIn = opts.min_run_in ?? 12;
+    if (!(maxGapIn > 0)) throw new UserError("max_gap_in must be > 0.");
+    if (!(minRunIn > 0)) throw new UserError("min_run_in must be > 0.");
+    const floors = (c) => this.shapes.filter((x) => x.condition_id === c.id && x.measure_role === "floor_area");
+    const fa = floors(a), fb = floors(b);
+    for (const [tag, list] of [[a.finish_tag, fa], [b.finish_tag, fb]]) {
+      if (!list.length) throw new UserError(`${tag} has no floor_area shapes to derive from \u2014 commit rooms first (one_click / detect_rooms).`);
+    }
+    const sheetsInPlay = [...new Set([...fa, ...fb].map((s) => s.sheet_id))];
+    for (const key of sheetsInPlay) {
+      const s = this.sheet(key);
+      if (s.upp == null) throw new UserError(`${key} has no scale \u2014 a transition is a real length, so set_scale first (${this.scaleGate(s)})`);
+    }
+    const committed = [], withheld = [];
+    for (const key of sheetsInPlay) {
+      const s = this.sheet(key);
+      const upp = s.upp;
+      const pxPerFt = 1 / upp;
+      const toPx = (sh) => sh.verts_norm.map(([x, y]) => [x * s.widthPx, y * s.heightPx]);
+      const onSheetA = fa.filter((x) => x.sheet_id === key), onSheetB = fb.filter((x) => x.sheet_id === key);
+      for (const ra of onSheetA) {
+        for (const rb of onSheetB) {
+          const runs = sharedRuns(toPx(ra), toPx(rb), {
+            step_px: Math.max(1, pxPerFt * 0.25),
+            // a quarter-foot walk — finer than any transition matters
+            touch_px: pxPerFt * (1 / 12),
+            // within an inch: one open space, not two rooms
+            max_gap_px: pxPerFt * (maxGapIn / 12),
+            min_len_px: pxPerFt * (minRunIn / 12)
+          });
+          for (const r of runs) this.recordRun(s, r, upp, opts.condition, ra.id, rb.id, a.finish_tag, b.finish_tag, committed, withheld);
+        }
+      }
+    }
+    if (committed.length) this.flushCommits("derive_transitions");
+    return {
+      condition: opts.condition,
+      between: [a.finish_tag, b.finish_tag],
+      committed: committed.length,
+      total_lf: round2(committed.reduce((n, r) => n + r.length_lf, 0)),
+      runs: committed,
+      withheld,
+      withheld_lf: round2(withheld.reduce((n, r) => n + r.length_lf, 0)),
+      note: withheld.length ? `${withheld.length} run(s) are adjacency ACROSS A WALL, not a butt joint \u2014 the transition there is a threshold in the doorway, and the trace record does not say where the doorway is. view_sheet each \`at\` and place them with measure_line / place_count.` : "Every run was a butt joint inside one open space. Verify with view_sheet overlay:true before trusting the total."
+    };
+  }
+  /** One shared run → committed transition, or a disclosed question. */
+  recordRun(s, r, upp, condition, aId, bId, aTag, bTag, committed, withheld) {
+    const length_lf = round2(r.length_px * upp);
+    const gap_in = round1(r.gap_px * upp * 12);
+    const row = { sheet: s.key, between_shape_ids: [aId, bId], length_lf, gap_in, at: [Math.round(r.at[0]), Math.round(r.at[1])] };
+    if (r.kind === "wall") {
+      withheld.push({ ...row, reason: "wall_separated", detail: `${aTag} and ${bTag} run ${length_lf} LF apart across ${gap_in}" of wall \u2014 adjacent rooms, not a butt joint. If a door opens here the transition is a threshold at the door, which this cannot see.` });
+      return;
+    }
+    const shape = this.commit(s, condition, "linear", r.path, { area_sf: 0, perimeter_lf: length_lf }, {
+      method: "agent_v1",
+      actor: "agent",
+      reviewed: false,
+      derived: { between_shape_ids: [aId, bId], between: [aTag, bTag], case: "butt", gap_in }
+    });
+    committed.push({ ...row, shape_id: shape.id });
+  }
   /** Count markers — the canvas's Count tool (commitCount): one point, one EA,
    * computed {count: 1}, NO scale required (EA is scale-free; the canvas's
    * recompute skips count shapes for the same reason). One shape per point,
@@ -6736,6 +7145,27 @@ var deriveBaseOutput = {
   total_lf: z.number().describe("Sum of net_lf across rooms"),
   note: z.string()
 };
+var transitionRun = {
+  sheet: z.string(),
+  between_shape_ids: z.array(z.string()).describe("The two floor_area shapes this run separates"),
+  length_lf: z.number().describe("Run length along the first shape's boundary"),
+  gap_in: z.number().describe("Median distance between the two rings across the run, in inches \u2014 0-ish is one open space, 4-8 is a partition"),
+  at: z.array(z.number()).describe("Run midpoint (image px) \u2014 pass to view_sheet to look at it")
+};
+var deriveTransitionsOutput = {
+  condition: z.string().describe("The tag the transitions committed under"),
+  between: z.array(z.string()).describe("The two finish tags"),
+  committed: z.number().int(),
+  total_lf: z.number().describe("Sum of committed run lengths \u2014 butt joints only"),
+  runs: z.array(z.object({ ...transitionRun, shape_id: z.string() })),
+  withheld: z.array(z.object({
+    ...transitionRun,
+    reason: z.literal("wall_separated"),
+    detail: z.string()
+  })).describe("Adjacency across a wall: real, measured, and NOT committed \u2014 the transition there is a threshold at a doorway this cannot locate"),
+  withheld_lf: z.number().describe("Shared-wall length held back \u2014 never part of total_lf"),
+  note: z.string()
+};
 var listShapesOutput = {
   shapes: z.array(z.object({
     id: z.string(),
@@ -8621,6 +9051,27 @@ function registerTools(server, session) {
     },
     outputSchema: deriveBaseOutput
   }, run("derive_base", (a) => session.deriveBase(a)));
+  server.registerTool("derive_transitions", {
+    description: `Mint the transition where two finishes MEET (#202) \u2014 the derivation that follows derive_base, and the line an estimator draws by hand on every job. Pass the two finish tags and the tag the transition commits under (e.g. condition_a 'CPT-1', condition_b 'PT-1', condition 'T-1'), and every committed room of each is compared against every committed room of the other.
+
+WHAT THE GEOMETRY ACTUALLY IS, because it decides what you get back: flood-traced rooms DO NOT SHARE EDGES. A trace fills to the wall linework, so two rooms across a partition are separated by four to eight inches of nothing \u2014 testing for a shared edge finds zero transitions on a real planset. What is there is proximity, in two flavours that mean completely different things:
+
+\u2022 BUTT JOINT \u2014 the two rings run together inside ONE open space (a lobby that changes from carpet to tile with no wall between). The transition IS that run, and it commits as a linear shape under your tag, origin.derived naming both parent shapes and the measured gap.
+
+\u2022 WALL-SEPARATED \u2014 the rings run parallel across a partition. The rooms are adjacent, but the transition is NOT the shared wall: it is a threshold, in the doorway, and NOTHING in the trace record says where the doorway is (the flood engine seals openings and reports how MUCH boundary it synthesised, never where). Committing 34 LF of threshold because two rooms share 34 LF of wall would be a wrong bid with a machine's confidence behind it. These come back in \`withheld\` \u2014 measured, with their length, their gap in inches, and an \`at\` point \u2014 as questions you answer by LOOKING (view_sheet at \`at\`, then measure_line or place_count the threshold yourself). The symbol_sweep doctrine: a near-match is never a silent commit and never a silent drop.
+
+Tuning: max_gap_in (default 12) is how far apart two rings can be and still count as adjacent at all \u2014 raise it for thick walls, and every extra inch turns more of the plan into wall_separated questions, never into committed LF. min_run_in (default 12) drops corner artifacts. The butt-joint threshold is fixed at one inch and is not a knob: "these two finishes touch" is not a judgement call.
+
+All-or-nothing, like derive_base: an unknown tag, a transition landing on either source tag, the same tag twice, or a sheet without a scale refuses the whole call before anything commits. The whole sweep is ONE undo step. After it, LOOK \u2014 view_sheet {overlay: true} over each run \u2014 before trusting total_lf. ${COORDS}`,
+    inputSchema: {
+      condition_a: z2.string().describe("First finish tag, e.g. 'CPT-1' \u2014 its committed rooms are walked, and runs are traced along their boundaries"),
+      condition_b: z2.string().describe("Second finish tag, e.g. 'PT-1'"),
+      condition: z2.string().describe("Finish tag the transitions commit under (minted on first use), e.g. 'T-1'. Must differ from both sources"),
+      max_gap_in: z2.number().positive().optional().describe("How far apart two rings can be and still count as adjacent, in inches (default 12 \u2014 a thick partition). Wider only produces more wall_separated QUESTIONS, never more committed LF"),
+      min_run_in: z2.number().positive().optional().describe("Shortest run worth reporting, in inches (default 12) \u2014 below this is a corner where two rooms clip, not a transition")
+    },
+    outputSchema: deriveTransitionsOutput
+  }, run("derive_transitions", (a) => session.deriveTransitions(a)));
   server.registerTool("takeoff_summary", {
     description: `Per-condition totals (floor/wall/border SF, LF, EA, SY, with and without waste) plus grand totals \u2014 the Report's numbers, computed by the same rules. Numbers only: the deliverable that SHOWS the work on the drawings is export_marked_pdf. ${COORDS}`,
     inputSchema: {},
@@ -8945,7 +9396,7 @@ function registerResources(server, session) {
 // package.json
 var package_default = {
   name: "opentakeoff-mcp",
-  version: "0.9.27",
+  version: "0.9.30",
   mcpName: "io.github.Kentucky-ai/opentakeoff",
   type: "module",
   description: "OpenTakeoff MCP server \u2014 drive the takeoff engine from your MCP client over stdio.",
@@ -8961,7 +9412,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/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"
+    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/transitions.test.ts test/view.test.ts"
   },
   dependencies: {
     "@modelcontextprotocol/sdk": "^1.12.0",
@@ -9023,8 +9474,10 @@ function buildServer(session = new Session()) {
       "A takeoff's deliverable is the marked-up planset, not a numbers report. Standard finish for ANY takeoff:",
       "1. load_plan, then set_scale on each sheet you measure (quantities are px-only until the scale is set).",
       "2. Commit shapes under finish-tag conditions (one_click / detect_rooms / measure_polygon / measure_line with `condition`; when the set carries a room-finish schedule, prefer detect_rooms assign_from_schedule so each room commits under its OWN row).",
-      "3. LOOK at what landed with view_sheet overlay:true and fix misses with edit_shape before trusting totals \u2014 crop the work region tight (full-sheet renders downsample too far to audit a ring).",
-      "4. Finish by writing the marked-up planset with export_marked_pdf and give the user its file path, alongside export_report for the numbers. Never end a takeoff with numbers alone."
+      "3. DERIVE what follows from the rooms instead of re-measuring it: derive_base for base LF (perimeter \u2212 the door openings YOU state), derive_transitions for the line where two finishes meet. Both read committed floor shapes, so they come after step 2 and their output is audited in step 4 like anything else.",
+      "4. LOOK at what landed with view_sheet overlay:true and fix misses with edit_shape before trusting totals \u2014 crop the work region tight (full-sheet renders downsample too far to audit a ring).",
+      "5. Finish by writing the marked-up planset with export_marked_pdf and give the user its file path, alongside export_report for the numbers. Never end a takeoff with numbers alone.",
+      "WITHHELD IS NOT A FAILURE \u2014 IT IS THE ANSWER. detect_rooms, symbol_sweep, sweep_schedule_row and derive_transitions all measure things they then decline to commit, and say why: a near-match in the score band, a room the schedule cannot answer for, adjacency across a WALL rather than a butt joint. Read those arrays, view_sheet the coordinates they hand you, and resolve them or report them. A withheld item you ignore is a hole in the bid; one you never mention is worse."
     ].join("\n")
   });
   registerTools(server, session);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opentakeoff-mcp",
-  "version": "0.9.27",
+  "version": "0.9.30",
   "mcpName": "io.github.Kentucky-ai/opentakeoff",
   "type": "module",
   "description": "OpenTakeoff MCP server — drive the takeoff engine from your MCP client over stdio.",
@@ -16,7 +16,7 @@
     "mcpb": "npm run build && node scripts/build-mcpb.mjs",
     "prepublishOnly": "npm run typecheck && npm test && npm run build",
     "typecheck": "tsc --noEmit",
-    "test": "node --import tsx --test test/conformance.test.ts test/context.test.ts test/e2e.test.ts test/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"
+    "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/transitions.test.ts test/view.test.ts"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.0",