opentakeoff-mcp 0.9.59 → 0.9.61

package/README.md

@@ -145,7 +145,7 @@ reads the tool list once. ([#230](https://github.com/Kentucky-ai/opentakeoff/iss
 | `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. **Counter-examples** (`exclude`, #259): rects around instances you do NOT mean, marqueed like the seed—the rect's own contents decide whether it rejects by extra contained linework or by the background line running THROUGH it that a real instance would break; every rejection disclosed in `rejected[]`, reinstatable with `place_count`, dead negatives refused with instructions. **Stroke-luminance gate** (`luminance_tolerance`, #260): for flattened exports where layers and pen weights are stripped but the file still states stroke color—a stated tolerance holds candidates to the seed's own pen, opt-in both ways, with `lum_gate` naming every placement the pen pulled under the bar. |
+| `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. **Counter-examples** (`exclude`, #259): rects around instances you do NOT mean, marqueed like the seed—the rect's own contents decide whether it rejects by extra contained linework or by the background line running THROUGH it that a real instance would break; every rejection disclosed in `rejected[]`, reinstatable with `place_count`, dead negatives refused with instructions. **Stroke-luminance gate** (`luminance_tolerance`, #260): for flattened exports where layers and pen weights are stripped but the file still states stroke color—a stated tolerance holds candidates to the seed's own pen, opt-in both ways, with `lum_gate` naming every placement the pen pulled under the bar. **Labels** (#308): for labeled families the sweep reads the drawing's own names—a fixture token written beside a placement or connected by its drawn leader (leader-following arms only on multi-pen sheets)—as `label`/`label_via` on every row plus `seed.label`; the reply flags shape-only matches in a labeled family, withheld rows carrying the seed's own tag, and matches the drawing names differently. Disclosure, never a recount. |
 | `sweep_schedule_row` | **Take off a schedule row's mark from the row itself**: pass the row's key (for example, `T1`) and the tool reads the row from the set's schedule tables (the row is the condition's cited source), anchors a 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—`anchor.corroborated`—before it is trusted), and sweeps every plan-role sheet. **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 key is `excluded` and says whose it is, an unlabeled match is `withheld` as a question, a tag drawn with no matching marker is `text_only`. Refusal over guessing, each with the reason and the fix: no such row, an ambiguous key, a tag drawn on no plan sheet, no repeatable marker linework—a fingerprint is never guessed from text alone. `commit: true` commits the counted matches under the row's own key—one undo step, `origin.assignment {source: "schedule"}` plus the anchor and row citation on `origin.symbol.seed`. No scale required. |
 | `takeoff_summary` | Per-condition totals + grand totals, computed by the Report's rules. |
 | `export_takeoff` | The full `opentakeoff.takeoff_canvas.v1` payload—exactly what the app autosaves. Inline, and to disk with `path` (see **Writing to disk** below). |

package/dist/server-core.js

@@ -4154,6 +4154,30 @@ function buildNegative(fp, segs, rect, opts = {}) {
     center: [Math.round(best.at[0] * 10) / 10, Math.round(best.at[1] * 10) / 10]
   };
 }
+function mergeProposals(scored, mergeR) {
+  const kept = [];
+  for (const s of scored) {
+    const twin = kept.find((k) => Math.hypot(k.at[0] - s.at[0], k.at[1] - s.at[1]) <= mergeR);
+    if (!twin) {
+      kept.push({ ...s });
+      continue;
+    }
+    if (s.score > twin.score || s.score === twin.score && s.xf < twin.xf) {
+      twin.at = s.at;
+      twin.score = s.score;
+      twin.rotation = s.rotation;
+      twin.mirrored = s.mirrored;
+      twin.xf = s.xf;
+    }
+  }
+  const byBest = [...kept].sort((a, b) => b.score - a.score || a.xf - b.xf || a.at[1] - b.at[1] || a.at[0] - b.at[0]);
+  const out = [];
+  for (const s of byBest) {
+    if (out.some((k) => Math.hypot(k.at[0] - s.at[0], k.at[1] - s.at[1]) <= mergeR)) continue;
+    out.push(s);
+  }
+  return out;
+}
 function matchSymbol(fp, segs, opts = {}) {
   const scale = opts.scale ?? 1;
   const tol = (opts.tolPx ?? SWEEP_TOL_PX) * Math.max(1, scale);
@@ -4264,21 +4288,7 @@ function matchSymbol(fp, segs, opts = {}) {
     scored.push({ at: [c.tx, c.ty], score, rotation: xforms[c.xf].rotation, mirrored: xforms[c.xf].mirrored, xf: c.xf });
   }
   const mergeR = Math.max(2 * tol, 4);
-  const kept = [];
-  for (const s of scored) {
-    const twin = kept.find((k) => Math.hypot(k.at[0] - s.at[0], k.at[1] - s.at[1]) <= mergeR);
-    if (!twin) {
-      kept.push(s);
-      continue;
-    }
-    if (s.score > twin.score || s.score === twin.score && s.xf < twin.xf) {
-      twin.at = s.at;
-      twin.score = s.score;
-      twin.rotation = s.rotation;
-      twin.mirrored = s.mirrored;
-      twin.xf = s.xf;
-    }
-  }
+  const kept = mergeProposals(scored, mergeR);
   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;
@@ -4419,6 +4429,116 @@ function matchSymbol(fp, segs, opts = {}) {
   };
 }
 
+// ../web/src/lib/symbollabels.ts
+var LABEL_TOKEN_RE = /^[A-Z]{1,4}-?\d{0,3}[A-Z]?$/;
+function labelTokens(spans) {
+  return spans.filter((s) => {
+    const t = s.str.trim();
+    return t.length <= 6 && LABEL_TOKEN_RE.test(t) && /[A-Z]/.test(t);
+  });
+}
+var LABEL_ADJACENT_K = 2.2;
+var LEADER_MAX_DARK_SHARE = 0.9;
+var LEADER_DARK_LUM = 60;
+var LEADER_HOP_PX = 14;
+var LEADER_HOPS = 4;
+var LEADER_HIT_PX = 30;
+function buildDarkIndex(segs, lum) {
+  const dark = [];
+  const n = segs.length >> 2;
+  for (let i = 0; i < n; i++) {
+    if (lum[i] < LEADER_DARK_LUM) dark.push([segs[i * 4], segs[i * 4 + 1], segs[i * 4 + 2], segs[i * 4 + 3]]);
+  }
+  const cell = LEADER_HOP_PX * 2;
+  const key = (x, y) => Math.floor(x / cell) * 73856093 ^ Math.floor(y / cell) * 19349663;
+  const cells = /* @__PURE__ */ new Map();
+  dark.forEach((s, i) => {
+    for (const [x, y] of [[s[0], s[1]], [s[2], s[3]]]) {
+      const k = key(x, y);
+      const a = cells.get(k);
+      if (a) a.push(i);
+      else cells.set(k, [i]);
+    }
+  });
+  return { segs: dark, cells, cell };
+}
+function nearDark(idx, x, y) {
+  const out = [];
+  const cx = Math.floor(x / idx.cell), cy = Math.floor(y / idx.cell);
+  for (let dx = -1; dx <= 1; dx++) for (let dy = -1; dy <= 1; dy++) {
+    const a = idx.cells.get((cx + dx) * 73856093 ^ (cy + dy) * 19349663);
+    if (a) {
+      for (const i of a) if (!out.includes(i)) out.push(i);
+    }
+  }
+  return out;
+}
+function chase(idx, start) {
+  let frontier = [start];
+  const seen = /* @__PURE__ */ new Set();
+  const reached = [start];
+  for (let hop = 0; hop < LEADER_HOPS; hop++) {
+    const next = [];
+    for (const p of frontier) {
+      for (const i of nearDark(idx, p[0], p[1])) {
+        const s = idx.segs[i];
+        const ends = [[s[0], s[1]], [s[2], s[3]]];
+        for (let e = 0; e < 2; e++) {
+          if (Math.hypot(ends[e][0] - p[0], ends[e][1] - p[1]) > LEADER_HOP_PX) continue;
+          const other = ends[1 - e];
+          const k = `${i}:${1 - e}`;
+          if (seen.has(k)) continue;
+          seen.add(k);
+          next.push(other);
+          reached.push(other);
+        }
+      }
+    }
+    if (!next.length) break;
+    frontier = next;
+  }
+  return reached;
+}
+function labelPlacements(placements, spans, segs, lum) {
+  const tokens = labelTokens(spans);
+  if (!tokens.length || !placements.length) return placements.map(() => null);
+  const out = placements.map(() => null);
+  for (let p = 0; p < placements.length; p++) {
+    const [px, py] = placements[p];
+    let best = null;
+    for (const t of tokens) {
+      const h = Math.max(t.y1 - t.y0, 8);
+      const d = Math.hypot((t.x0 + t.x1) / 2 - px, (t.y0 + t.y1) / 2 - py);
+      if (d <= LABEL_ADJACENT_K * h && (!best || d < best.d)) best = { tag: t.str.trim(), d };
+    }
+    if (best) out[p] = { label: best.tag, via: "adjacent", distance_px: Math.round(best.d) };
+  }
+  if (lum && lum.length) {
+    let darkLen = 0, totalLen = 0;
+    const n = segs.length >> 2;
+    for (let i = 0; i < n; i++) {
+      const L = Math.hypot(segs[i * 4 + 2] - segs[i * 4], segs[i * 4 + 3] - segs[i * 4 + 1]);
+      totalLen += L;
+      if (lum[i] < LEADER_DARK_LUM) darkLen += L;
+    }
+    if (totalLen > 0 && darkLen / totalLen <= LEADER_MAX_DARK_SHARE) {
+      const idx = buildDarkIndex(segs, lum);
+      for (const t of tokens) {
+        const cy = (t.y0 + t.y1) / 2;
+        for (const start of [[t.x0 - 4, cy], [t.x1 + 4, cy]]) {
+          const reach = chase(idx, start);
+          for (let p = 0; p < placements.length; p++) {
+            if (out[p]) continue;
+            const hit = reach.reduce((m, q) => Math.min(m, Math.hypot(q[0] - placements[p][0], q[1] - placements[p][1])), Infinity);
+            if (hit <= LEADER_HIT_PX) out[p] = { label: t.str.trim(), via: "leader", distance_px: Math.round(hit) };
+          }
+        }
+      }
+    }
+  }
+  return out;
+}
+
 // ../web/src/lib/transitions.ts
 var COINCIDENT_PX = 1e-9;
 function segments(ring) {
@@ -7189,6 +7309,45 @@ var Session = class _Session {
       complete: true
     };
   }
+  /** #308 — resolve the drawing's own tag for a sweep's placements. Pure
+   * resolution lives in web/src/lib/symbollabels.ts (shared with the canvas
+   * Symbol tool, #264); this just lines the answers back up with the rows
+   * they belong to. */
+  sweepLabels(spans, geo, seedCenter, matches, withheld) {
+    const centers = [...seedCenter ? [seedCenter] : [], ...matches.map((m) => m.at), ...withheld.map((w) => w.at)];
+    const named = labelPlacements(centers, spans, geo.segs, geo.lum);
+    const off = seedCenter ? 1 : 0;
+    return {
+      seed: seedCenter ? named[0] : null,
+      matches: named.slice(off, off + matches.length),
+      withheld: named.slice(off + matches.length)
+    };
+  }
+  static labelFields(l) {
+    return l ? { label: l.label, label_via: l.via } : {};
+  }
+  /** The label findings worth a sentence, in both directions (#308): a match
+   * with no label in a labeled family is a shape-only count to look at; a
+   * withheld row carrying the seed's own tag is the drawing vouching for it;
+   * a withheld row carrying a different tag is a sibling fixture, answered. */
+  static sweepLabelNote(lbl) {
+    const parts = [];
+    const seedTag = lbl.seed?.label;
+    const anyLabeled = !!seedTag || lbl.matches.some(Boolean);
+    const unlabeledMatches = lbl.matches.filter((l) => !l).length;
+    if (anyLabeled && unlabeledMatches) {
+      parts.push(`${unlabeledMatches} committed match(es) carry NO label while this family is labeled${seedTag ? ` (the seed reads "${seedTag}")` : ""} \u2014 counted on shape alone; view_sheet them before trusting the total.`);
+    }
+    if (seedTag) {
+      const diffMatches = [...new Set(lbl.matches.filter((l) => !!l && l.label !== seedTag).map((l) => l.label))];
+      if (diffMatches.length) parts.push(`Committed match(es) the drawing names differently (${diffMatches.join(", ")}) \u2014 the geometry matched but the tag disagrees; check they belong in this count, or exclude one as a counter-example.`);
+      const same = lbl.withheld.filter((l) => l && l.label === seedTag).length;
+      const others = [...new Set(lbl.withheld.filter((l) => !!l && l.label !== seedTag).map((l) => l.label))];
+      if (same) parts.push(`${same} withheld placement(s) carry the seed's own tag "${seedTag}" \u2014 the drawing says they are real; look, then place_count.`);
+      if (others.length) parts.push(`Withheld placements the drawing names differently (${others.join(", ")}) are sibling fixtures, not missed counts.`);
+    }
+    return parts.length ? parts.join(" ") : null;
+  }
   placeCount(name, points, opts) {
     const s = this.sheet(name);
     const ids = points.map(([x, y], i) => this.commit(
@@ -7311,6 +7470,8 @@ var Session = class _Session {
     };
     if (scope === "sheet") {
       const res = matchSymbol(fp, geo.segs, { ...sweepOpts, lum: geo.lum, excludeCenter: fp.center, ...negatives.length ? { negatives } : {} });
+      if (!s.spans) s.spans = textSpans(s.page);
+      const lbl = this.sweepLabels(s.spans, geo, fp.center, res.matches, res.withheld);
       let committed2;
       if (opts.commit && res.matches.length) {
         committed2 = this.placeCount(name, res.matches.map((m) => m.at), {
@@ -7324,12 +7485,13 @@ var Session = class _Session {
           }))
         });
       }
+      const labelNote2 = _Session.sweepLabelNote(lbl);
       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,
+        matches: res.matches.map((m, i) => ({ at: [round1(m.at[0]), round1(m.at[1])], score: m.score, rotation: m.rotation, mirrored: m.mirrored, ..._Session.labelFields(lbl.matches[i]) })),
+        withheld: res.withheld.map((w, i) => ({ at: [round1(w.at[0]), round1(w.at[1])], score: w.score, rotation: w.rotation, mirrored: w.mirrored, ..._Session.labelFields(lbl.withheld[i]), reason: w.reason })),
+        seed: { ...seedOut, ..._Session.labelFields(lbl.seed) },
         ...res.rejected.length ? { rejected: res.rejected.map((r) => ({ at: [round1(r.at[0]), round1(r.at[1])], score: r.score, rotation: r.rotation, mirrored: r.mirrored, by: r.by + 1, mode: r.mode, evidence: r.evidence, reason: r.reason })) } : {},
         ...res.negatives ? { negatives: res.negatives.filter((n) => !!n).map((n) => ({ mode: n.mode, segments: n.segments, center: [round1(n.center[0]), round1(n.center[1])] })) } : {},
         ...res.lum_gate ? { lum_gate: res.lum_gate } : {},
@@ -7341,7 +7503,12 @@ var Session = class _Session {
           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." } : {},
+        ...(() => {
+          const parts = [];
+          if (opts.commit && !res.matches.length) parts.push("commit requested but nothing cleared the bar \u2014 no shapes were committed.");
+          if (labelNote2) parts.push(labelNote2);
+          return parts.length ? { note: parts.join(" ") } : {};
+        })(),
         ...res.candidates.dropped > 0 ? { warning: `Work ceiling: ${res.candidates.dropped} candidate placement(s) were never scored \u2014 this count is a FLOOR, not a total. 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.` } : {}
       };
     }
@@ -7386,7 +7553,9 @@ var Session = class _Session {
         continue;
       }
       const elapsed_ms = Math.round(Number(process.hrtime.bigint() - t0) / 1e4) / 100;
-      perSheet.push({ state: sh, ...res, elapsed_ms, scale: ratio });
+      if (!sh.spans) sh.spans = textSpans(sh.page);
+      const labels = this.sweepLabels(sh.spans, g2, null, res.matches, res.withheld);
+      perSheet.push({ state: sh, ...res, elapsed_ms, scale: ratio, labels });
     }
     const found = perSheet.reduce((n, p) => n + p.matches.length, 0);
     let committed;
@@ -7434,17 +7603,25 @@ var Session = class _Session {
     if (lumRejectedTotal) {
       notes.push(`${lumRejectedTotal} placement(s) the geometry would have committed were pulled under the bar by your stated luminance tolerance \u2014 each is named per sheet in lum_gate.at. Look before trusting the gate: a symbol somebody redrew in a different pen fails it honestly.`);
     }
+    if (!s.spans) s.spans = textSpans(s.page);
+    const seedLbl = this.sweepLabels(s.spans, geo, fp.center, [], []).seed;
+    const labelNote = _Session.sweepLabelNote({
+      seed: seedLbl,
+      matches: perSheet.flatMap((p) => p.labels.matches),
+      withheld: perSheet.flatMap((p) => p.labels.withheld)
+    });
+    if (labelNote) notes.push(labelNote);
     return {
       scope,
       found,
-      seed: { ...seedOut, role: seedRole },
+      seed: { ...seedOut, role: seedRole, ..._Session.labelFields(seedLbl) },
       ...rejectedTotal ? { rejected_total: rejectedTotal } : {},
       ...negatives.length ? { negatives: negatives.map((n) => ({ mode: n.mode, segments: n.rel.length, center: [round1(n.center[0]), round1(n.center[1])] })) } : {},
       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 })),
+        matches: p.matches.map((m, i) => ({ at: [round1(m.at[0]), round1(m.at[1])], score: m.score, rotation: m.rotation, mirrored: m.mirrored, ..._Session.labelFields(p.labels.matches[i]) })),
+        withheld: p.withheld.map((w, i) => ({ at: [round1(w.at[0]), round1(w.at[1])], score: w.score, rotation: w.rotation, mirrored: w.mirrored, ..._Session.labelFields(p.labels.withheld[i]), reason: w.reason })),
         ...p.rejected.length ? { rejected: p.rejected.map((r) => ({ at: [round1(r.at[0]), round1(r.at[1])], score: r.score, rotation: r.rotation, mirrored: r.mirrored, by: r.by + 1, mode: r.mode, evidence: r.evidence, reason: r.reason })) } : {},
         ...p.lum_gate ? { lum_gate: p.lum_gate } : {},
         candidates: p.candidates,
@@ -8941,7 +9118,9 @@ var sweepPlacement = {
   at: z.tuple([z.number(), z.number()]).describe("The placed symbol's centroid (image px) \u2014 the point a commit places its count marker at"),
   score: z.number().describe("Length-weighted fraction of the seed's segments matched within tolerance, 0..1"),
   rotation: z.number().describe("Detected rotation in degrees (0 | 90 | 180 | 270)"),
-  mirrored: z.boolean()
+  mirrored: z.boolean(),
+  label: z.string().optional().describe(`The drawing's own tag for this placement (#308) \u2014 a fixture token written beside it or connected by a drawn leader (e.g. "P-7", "FD1"). Disclosure, never a recount: a match with NO label in a labeled family was counted on shape alone (look before trusting), and a withheld row carrying the seed's own tag is the drawing vouching for it`),
+  label_via: z.enum(["adjacent", "leader"]).optional().describe("How the tag reached this placement: written beside it, or followed along a drawn leader line (leader-following arms only on multi-pen sheets, where the annotation pen separates from the work)")
 };
 var sweepRejected = z.object({
   ...sweepPlacement,
@@ -9002,7 +9181,9 @@ var symbolSweepOutput = {
     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")
+    length_px: z.number().describe("Total seed linework length, image px"),
+    label: z.string().optional().describe(`The drawing's own tag for the seed instance (#308) \u2014 the family's identity, e.g. seeding a drain the sheet labels "P-7"`),
+    label_via: z.enum(["adjacent", "leader"]).optional()
   }),
   rejected: z.array(sweepRejected).optional().describe("Sheet scope only. Placements the geometry accepted and a counter-example refused (#259) \u2014 NEVER counted in found, and never silent: each says which negative did it and what it saw. Reinstate one by hand with place_count at its `at` if you disagree"),
   negatives: sweepNegatives.optional().describe("What each `exclude` rect was read as, in the order you passed them (#259)"),
@@ -11322,7 +11503,7 @@ function registerTools(realServer, 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. Every proposed placement is scored up to a hard work ceiling sized for pathological sheets, and the reply says which it was: complete true means the count is a total; complete false (with candidates.dropped > 0) means the count is a FLOOR \u2014 some placements were never scored \u2014 so tighten the seed rect around more distinctive geometry rather than trusting it as a total. 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. Counter-examples (#259): drafting reuses one generic shape for different devices \u2014 a wall-mounted data outlet drawn as a plain triangle, the flush-floor variant the SAME triangle inside a square, keynote callouts a triangle with a letter in it \u2014 so the seed legitimately matches things you do not mean, and seeding more geometry only works where the drawing offers more to capture. \`exclude\` takes rects around instances you do NOT mean, marqueed exactly like the seed. You never choose a mechanism; the rect's contents decide, because both are the same gesture: a rect holding EXTRA linework beyond the seed rejects placements where that extra linework is present too (the box, the letter), and a rect holding no extra linework of its own is read as the line running THROUGH it \u2014 a bare ceiling-grid tile whose grid line a real fixture, drawn over it, would BREAK. That second mechanic is not expressible as a seed: only segments fully INSIDE a rect define a symbol, and background structure is long by nature. Every rejection is disclosed in rejected[] \u2014 which negative, what fraction of its evidence was found, and the placement \u2014 and NEVER counted in found: an exclusion is a judgement, so look at it and reinstate any you disagree with using place_count at its \`at\`. A counter-example that holds no instance of the seed, or holds the seed with nothing extra, is REFUSED rather than silently doing nothing. Stroke luminance (#260): a flattened export strips the layer tree and flattens every pen, but the file still STATES stroke color \u2014 a black fixture outline over a grey ceiling grid is unambiguous there even when the geometry is identical (two empty 2 ft grid tiles reproduce a 2\xD74 fixture's outline exactly). luminance_tolerance (0\u2013254) gates on it: a sheet segment only answers for a seed segment when their stroke luminances are within the stated tolerance (Rec. 709, 0 = black, 255 = white; 32\u201364 separates black from grey without touching anti-aliasing wobble). OPT-IN and disclosed, in the spirit of tolerance_px \u2014 omitted, sweeps score exactly as before; stated, the reply's lum_gate says the seed's own luminance band and names every placement the geometry would have committed and the pen did not, so you can LOOK at what a stated gate cost. Prefer geometry (a counter-example, a tighter seed) where the drawing offers it \u2014 color is the fallback for exports where nothing else survived. 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. Every proposed placement is scored up to a hard work ceiling sized for pathological sheets, and the reply says which it was: complete true means the count is a total; complete false (with candidates.dropped > 0) means the count is a FLOOR \u2014 some placements were never scored \u2014 so tighten the seed rect around more distinctive geometry rather than trusting it as a total. 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. Counter-examples (#259): drafting reuses one generic shape for different devices \u2014 a wall-mounted data outlet drawn as a plain triangle, the flush-floor variant the SAME triangle inside a square, keynote callouts a triangle with a letter in it \u2014 so the seed legitimately matches things you do not mean, and seeding more geometry only works where the drawing offers more to capture. \`exclude\` takes rects around instances you do NOT mean, marqueed exactly like the seed. You never choose a mechanism; the rect's contents decide, because both are the same gesture: a rect holding EXTRA linework beyond the seed rejects placements where that extra linework is present too (the box, the letter), and a rect holding no extra linework of its own is read as the line running THROUGH it \u2014 a bare ceiling-grid tile whose grid line a real fixture, drawn over it, would BREAK. That second mechanic is not expressible as a seed: only segments fully INSIDE a rect define a symbol, and background structure is long by nature. Every rejection is disclosed in rejected[] \u2014 which negative, what fraction of its evidence was found, and the placement \u2014 and NEVER counted in found: an exclusion is a judgement, so look at it and reinstate any you disagree with using place_count at its \`at\`. A counter-example that holds no instance of the seed, or holds the seed with nothing extra, is REFUSED rather than silently doing nothing. Stroke luminance (#260): a flattened export strips the layer tree and flattens every pen, but the file still STATES stroke color \u2014 a black fixture outline over a grey ceiling grid is unambiguous there even when the geometry is identical (two empty 2 ft grid tiles reproduce a 2\xD74 fixture's outline exactly). luminance_tolerance (0\u2013254) gates on it: a sheet segment only answers for a seed segment when their stroke luminances are within the stated tolerance (Rec. 709, 0 = black, 255 = white; 32\u201364 separates black from grey without touching anti-aliasing wobble). OPT-IN and disclosed, in the spirit of tolerance_px \u2014 omitted, sweeps score exactly as before; stated, the reply's lum_gate says the seed's own luminance band and names every placement the geometry would have committed and the pen did not, so you can LOOK at what a stated gate cost. Prefer geometry (a counter-example, a tighter seed) where the drawing offers it \u2014 color is the fallback for exports where nothing else survived. Labels (#308): for a LABELED family \u2014 fixtures, tagged equipment, keyed devices \u2014 the drawing already names every instance, and the sweep reads those names: a fixture token written beside a placement, or connected to it by a drawn leader line (leader-following arms only on multi-pen sheets, where the annotation pen separates from the work), comes back as \`label\` + \`label_via\` on the row, and the seed's own tag rides \`seed.label\`. Disclosure in both directions, never a recount: a committed match with NO label while the family is labeled was counted on shape alone (measured case: two 0.97 matches that were valve internals, not drains \u2014 LOOK at those first), a withheld row carrying the seed's own tag is the drawing vouching for a near-miss (look, then place_count), and a withheld row named a DIFFERENT tag is a sibling fixture answered, not a missed count. 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"),
@@ -11896,7 +12077,7 @@ function nameTheStageInRefusals(server) {
 // package.json
 var package_default = {
   name: "opentakeoff-mcp",
-  version: "0.9.59",
+  version: "0.9.61",
   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.59",
+  "version": "0.9.61",
   "mcpName": "io.github.Kentucky-ai/opentakeoff",
   "type": "module",
   "description": "OpenTakeoff MCP server — drive the takeoff engine from your MCP client over stdio.",