opentakeoff-mcp 0.9.60 → 0.9.62

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). |
@@ -172,7 +172,7 @@ reads the tool list once. ([#230](https://github.com/Kentucky-ai/opentakeoff/iss
 | `resolve_tag` | ONE room tag → its room-finish schedule row → each code's finish/material definition, every edge cited (sheet + literal text + bbox). Refusal over guessing: `unresolved` comes back with a reason, never as silence. A delta/REV marker on the answering row rides the result as `revisions`—the codes are the post-revision answer, and you're told the ink changed. |
 | `find_schedule` | Locate a schedule table by kind ("room finish", "material")—sheet, title, headers, row count, a `view_sheet`-ready region, and `revised_rows` when delta/REV-marked rows exist. |
 | `sheet_context` | The region's STRUCTURE in one frame: classified vector segments (endpoints as drawn, meta byte per segment), text spans with bboxes, and hatch-family instances with content-derived ids—same pattern spec ⇒ same id anywhere on the sheet, so plan↔legend matching is `id === id`. Decimation is declared and counted on every reply: `kept + dropped === total_in_region`, cap applies longest-first so walls survive. |
-| `view_sheet` | The agent's eyes: render the sheet (or an image-px crop) to PNG. `overlay` burns committed shapes in (solid = human-affirmed, dashed = unreviewed) to verify geometry landed; `grid` burns in a calibrated 1-ft/5-ft measuring grid with foot labels (`"auto"` from the set scale, or the drawing scale like `"1/4"`) so dimensions are counted off cells, not guessed. |
+| `view_sheet` | The agent's eyes: render the sheet (or an image-px crop) to PNG. `overlay` burns committed shapes in (solid = human-affirmed, dashed = unreviewed) to verify geometry landed; `grid` burns in a calibrated 1-ft/5-ft measuring grid with foot labels (`"auto"` from the set scale, or the drawing scale like `"1/4"`) so dimensions are counted off cells, not guessed; `marks` (#297) burns disclosure layers in — `question` (withheld placements, orange ?-circle), `struck` (rejections, magenta struck ×), `ring` (the sweep's seed, violet double ring) — in colors off the common CAD pens, so what a reply names, the picture shows. |
 
 ### The agent revises its own work
 

package/dist/server-core.js

@@ -4429,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) {
@@ -5680,6 +5790,59 @@ function drawShapes(ctx, toCanvas, shapes, sheetW, sheetH, longEdge) {
   }
   ctx.setLineDash([]);
 }
+var MARK_QUESTION = "#ff8c00";
+var MARK_STRUCK = "#e10ee1";
+var MARK_RING = "#7a00e6";
+function polyCircle(ctx, x, y, r) {
+  ctx.beginPath();
+  for (let i = 0; i <= 16; i++) {
+    const a = i / 16 * 2 * Math.PI;
+    const px = x + r * Math.cos(a), py = y + r * Math.sin(a);
+    if (i === 0) ctx.moveTo(px, py);
+    else ctx.lineTo(px, py);
+  }
+  ctx.stroke();
+}
+function drawMarks(ctx, toCanvas, marks, longEdge) {
+  const r = Math.max(7, longEdge / 110);
+  const w = Math.max(1.6, longEdge / 600);
+  ctx.setLineDash([]);
+  ctx.lineWidth = w;
+  let drawn = 0;
+  for (const [mx, my] of marks.question ?? []) {
+    const [x, y] = toCanvas(mx, my);
+    ctx.strokeStyle = MARK_QUESTION;
+    polyCircle(ctx, x, y, r);
+    ctx.fillStyle = MARK_QUESTION;
+    ctx.font = `bold ${Math.round(r * 1.4)}px sans-serif`;
+    ctx.fillText("?", x - r * 0.35, y + r * 0.5);
+    drawn++;
+  }
+  for (const [mx, my] of marks.struck ?? []) {
+    const [x, y] = toCanvas(mx, my);
+    ctx.strokeStyle = MARK_STRUCK;
+    const m = r * 0.8;
+    ctx.beginPath();
+    ctx.moveTo(x - m, y - m);
+    ctx.lineTo(x + m, y + m);
+    ctx.moveTo(x - m, y + m);
+    ctx.lineTo(x + m, y - m);
+    ctx.stroke();
+    ctx.beginPath();
+    ctx.moveTo(x - r * 1.2, y);
+    ctx.lineTo(x + r * 1.2, y);
+    ctx.stroke();
+    drawn++;
+  }
+  for (const [mx, my] of marks.ring ?? []) {
+    const [x, y] = toCanvas(mx, my);
+    ctx.strokeStyle = MARK_RING;
+    polyCircle(ctx, x, y, r);
+    polyCircle(ctx, x, y, r * 0.6);
+    drawn++;
+  }
+  return drawn;
+}
 
 // src/session.ts
 var SNAP_CELL = 24;
@@ -5925,9 +6088,11 @@ var Session = class _Session {
     }
     const ppf = gridPxPerFoot(opts.grid, s.upp);
     const sheetShapes = this.shapes.filter((x) => x.sheet_id === s.key);
+    let marksDrawn = 0;
     const { png, width, height, zoom } = await s.page.renderRegionPng(r, px, (ctx, toCanvas) => {
       if (ppf) drawGrid(ctx, toCanvas, r, ppf);
       if (opts.overlay) drawShapes(ctx, toCanvas, sheetShapes, s.widthPx, s.heightPx, px);
+      if (opts.marks) marksDrawn = drawMarks(ctx, toCanvas, opts.marks, px);
     });
     return {
       png,
@@ -5940,6 +6105,7 @@ var Session = class _Session {
         zoom: +zoom.toFixed(4),
         overlay: !!opts.overlay,
         ...opts.overlay ? { shapes_drawn: sheetShapes.length } : {},
+        ...opts.marks ? { marks_drawn: marksDrawn } : {},
         grid_px_per_foot: ppf ? round2(ppf) : 0
       }
     };
@@ -7199,6 +7365,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(
@@ -7272,6 +7477,12 @@ var Session = class _Session {
     if (opts.commit && !opts.condition) {
       throw new UserError("commit: true needs a condition \u2014 the finish tag the match markers count under (e.g. 'FD-1').");
     }
+    if (opts.commitSeed && !opts.commit) {
+      throw new UserError("commit_seed: true needs commit: true \u2014 the seed joins the same one-undo-step batch as the matches.");
+    }
+    if (opts.commitSeed && scope === "set") {
+      throw new UserError("commit_seed applies to sheet scope only \u2014 in a set-wide sweep the seed may sit on a detail or legend sheet, where it is a reference drawing. If the seed instance is installed work, place_count it on its sheet explicitly.");
+    }
     const geo = await this.ensureGeometry(s);
     if (!geo.segs.length) {
       throw new UserError("This sheet has no vector linework (likely a scan) \u2014 symbol matching reads the drawn segments; raster fallback not yet available in the MCP server.");
@@ -7321,25 +7532,35 @@ 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), {
+      if (opts.commit && (res.matches.length || opts.commitSeed)) {
+        const points = [...opts.commitSeed ? [fp.center] : [], ...res.matches.map((m) => m.at)];
+        const seedOrigin = {
+          method: "symbol_sweep",
+          actor: "agent",
+          reviewed: false,
+          symbol: { score: 1, rotation: 0, mirrored: false, seed: { source: "instance", sheet: s.key } }
+        };
+        committed2 = this.placeCount(name, points, {
           condition: opts.condition,
           tool: "symbol_sweep",
-          origins: res.matches.map((m) => ({
+          origins: [...opts.commitSeed ? [seedOrigin] : [], ...res.matches.map((m) => ({
             method: "symbol_sweep",
             actor: "agent",
             reviewed: false,
             symbol: { score: m.score, rotation: m.rotation, mirrored: m.mirrored, seed: { source: "instance", sheet: s.key } }
-          }))
+          }))]
         });
       }
+      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 } : {},
@@ -7349,9 +7570,16 @@ var Session = class _Session {
           committed: committed2.committed,
           shape_ids: committed2.shape_ids,
           condition: committed2.condition,
-          ea_total: committed2.ea_total
+          ea_total: committed2.ea_total,
+          ...opts.commitSeed ? { seed_committed: true } : {}
         } : {},
-        ...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 && !opts.commitSeed) parts.push("commit requested but nothing cleared the bar \u2014 no shapes were committed.");
+          if (committed2 && !opts.commitSeed) parts.push(`The seed instance at (${round1(fp.center[0])}, ${round1(fp.center[1])}) is NOT in this count \u2014 if it is installed work, re-run with commit_seed: true or place_count it.`);
+          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.` } : {}
       };
     }
@@ -7396,7 +7624,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;
@@ -7444,17 +7674,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,
@@ -8951,7 +9189,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,
@@ -9012,11 +9252,14 @@ 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)"),
   rejected_total: z.number().int().optional().describe("Set scope: placements counter-examples rejected across every swept sheet"),
+  seed_committed: z.boolean().optional().describe("Present when commit_seed: true minted the seed instance into the batch (#296) \u2014 ea_total then includes it"),
   lum_gate: sweepLumGate.optional().describe("Sheet scope only. The stated stroke-luminance gate's accounting (#260): the tolerance, the seed's own luminance band, and every placement the geometry would have committed that the pen pulled under the bar \u2014 NEVER counted in found, never silent. Set scope accounts per sheet in sheets[]"),
   candidates: sweepCandidates.optional().describe("Sheet scope only \u2014 set scope accounts per sheet in sheets[]"),
   complete: z.boolean().describe("True when every proposed placement was scored (every swept sheet, in set scope) and the count is a total. FALSE MEANS THE COUNT IS A FLOOR \u2014 acknowledge it before trusting found (#261)"),
@@ -11332,12 +11575,13 @@ 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 SEED instance is not in that count (#296) \u2014 in sheet scope it is almost always installed work, so pass commit_seed: true to mint it into the same batch (the reply reminds you whenever a sheet-scope commit leaves it out; ea_total one short of the hand tally is exactly this). 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"),
       condition: z2.string().optional().describe("Finish tag to commit match markers under (minted on first use), e.g. 'FD-1'. Required when commit is true"),
       commit: z2.boolean().default(false).describe("Commit every MATCH center as one EA count marker (withheld placements never commit)"),
+      commit_seed: z2.boolean().default(false).describe("Sheet scope + commit only (#296): also commit the SEED instance \u2014 in sheet scope the seed is almost always installed work, and a count that excludes it bids one short. Joins the same one-undo-step batch, origin score 1. Refused in set scope, where a detail/legend seed is a reference drawing"),
       scope: z2.enum(["sheet", "set"]).default("sheet").describe('"sheet" = this sheet only; "set" = every PLAN-role sheet in the working set (needs a text layer for the sheet graph; non-plan sheets are excluded and disclosed)'),
       rotations: z2.boolean().default(true).describe("Also match 90/180/270-rotated placements"),
       mirror: z2.boolean().default(true).describe("Also match mirrored placements"),
@@ -11355,7 +11599,8 @@ function registerTools(realServer, session) {
     mirror: a.mirror,
     tolerancePx: a.tolerance_px,
     exclude: a.exclude,
-    luminanceTolerance: a.luminance_tolerance
+    luminanceTolerance: a.luminance_tolerance,
+    commitSeed: a.commit_seed
   })));
   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. 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}`,
@@ -11608,19 +11853,24 @@ All-or-nothing, like derive_base: an unknown tag, a transition landing on either
     outputSchema: findTextOutput
   }, run("find_text", (a) => session.findText(a.sheet, a.q, { region: a.region, limit: a.limit })));
   server.registerTool("view_sheet", {
-    description: `SEE the sheet \u2014 render the page (or a crop of it) to a PNG image. This is your eyes on the plan, so CROP, DON'T SQUINT: the render downsamples to the px budget (\u22642000 long side), which on an E-size sheet is ~4 sheet pixels per returned pixel \u2014 a full-sheet render finds WHERE things are, and only a tight region crop can tell you what the linework and labels actually say. Never audit a trace or read a dimension off a full-sheet render. region is in image px \u2014 the same space as every other tool \u2014 so a feature at pixel (ix, iy) of the returned image sits at x = region_x0 + ix \xD7 (region_x1 \u2212 region_x0) / img_w (same for y), and those coordinates go straight into one_click, measure_polygon, or read_sheet_text. overlay:true burns the session's committed shapes into the render (human-affirmed ink solid red, unreviewed machine shapes dashed blue) \u2014 render again after committing to verify your geometry landed where you intended, and sanity-check what you see: a fixture-sized ring where a room should be means the seed landed inside a stall or casework; an outsized ring means the flood escaped through an opening. To MEASURE rather than guess, pass grid: a calibrated measuring grid is burned in \u2014 thin lines every 1 ft, heavy blue every 5 ft, foot labels along the crop edges, feet counted from the crop's top-left corner. Count grid cells between walls exactly like an estimator scaling a plan; never derive a dimension by eye when the grid can give it to you. grid "auto" uses the sheet's set scale; before set_scale, pass the drawing scale read off the title block as inches-per-foot \u2014 "1/4" for a 1/4" = 1'-0" plan, "3/16", "0.25". Rendering needs the optional native canvas (@napi-rs/canvas); where it isn't installed this tool errors cleanly and every other tool still works. ${COORDS}`,
+    description: `SEE the sheet \u2014 render the page (or a crop of it) to a PNG image. This is your eyes on the plan, so CROP, DON'T SQUINT: the render downsamples to the px budget (\u22642000 long side), which on an E-size sheet is ~4 sheet pixels per returned pixel \u2014 a full-sheet render finds WHERE things are, and only a tight region crop can tell you what the linework and labels actually say. Never audit a trace or read a dimension off a full-sheet render. region is in image px \u2014 the same space as every other tool \u2014 so a feature at pixel (ix, iy) of the returned image sits at x = region_x0 + ix \xD7 (region_x1 \u2212 region_x0) / img_w (same for y), and those coordinates go straight into one_click, measure_polygon, or read_sheet_text. overlay:true burns the session's committed shapes into the render (human-affirmed ink solid red, unreviewed machine shapes dashed blue) \u2014 render again after committing to verify your geometry landed where you intended, and sanity-check what you see: a fixture-sized ring where a room should be means the seed landed inside a stall or casework; an outsized ring means the flood escaped through an opening. To MEASURE rather than guess, pass grid: a calibrated measuring grid is burned in \u2014 thin lines every 1 ft, heavy blue every 5 ft, foot labels along the crop edges, feet counted from the crop's top-left corner. Count grid cells between walls exactly like an estimator scaling a plan; never derive a dimension by eye when the grid can give it to you. grid "auto" uses the sheet's set scale; before set_scale, pass the drawing scale read off the title block as inches-per-foot \u2014 "1/4" for a 1/4" = 1'-0" plan, "3/16", "0.25". marks (#297) burns DISCLOSURE layers into the render, so what a reply names, the picture shows: pass the coordinate lists a tool disclosed \u2014 question: withheld placements (orange ?-circles), struck: rejections a counter-example or luminance gate refused (magenta struck \xD7), ring: reference points like the sweep's own seed (violet double ring). The colors sit deliberately off the common CAD pens so they cannot vanish into color-plotted work. An overlay audit without marks shows only committed ink \u2014 the validation trap where 37 disclosed near-misses read as "it missed them". Rendering needs the optional native canvas (@napi-rs/canvas); where it isn't installed this tool errors cleanly and every other tool still works. ${COORDS}`,
     inputSchema: {
       sheet: z2.string(),
       region: z2.object({ x0: z2.number(), y0: z2.number(), x1: z2.number(), y1: z2.number() }).optional().describe("Crop rect in image px (origin top-left, y down); omit for the full sheet"),
       px: z2.number().int().min(200).max(2e3).optional().describe("Long-side pixel budget of the returned image (default 1400) \u2014 small region + high px = readable dimension strings"),
       overlay: z2.boolean().optional().describe("Burn committed shapes into the render (solid = human-affirmed, dashed = unreviewed)"),
-      grid: z2.string().optional().describe(`Burn in a calibrated 1-ft/5-ft measuring grid: "auto" = the sheet's set scale; otherwise the drawing scale as inches-per-foot, e.g. "1/4", "3/16", "0.25"`)
+      grid: z2.string().optional().describe(`Burn in a calibrated 1-ft/5-ft measuring grid: "auto" = the sheet's set scale; otherwise the drawing scale as inches-per-foot, e.g. "1/4", "3/16", "0.25"`),
+      marks: z2.object({
+        question: z2.array(pointSchema).optional().describe("Open questions \u2014 withheld placements, spots to look at. Orange ?-in-circle"),
+        struck: z2.array(pointSchema).optional().describe("Refusals \u2014 rejected[] placements, lum_gate.at. Magenta struck \xD7"),
+        ring: z2.array(pointSchema).optional().describe("Reference points \u2014 the sweep's seed.center, an anchor. Violet double ring")
+      }).optional().describe("Disclosure marks to burn into the render (#297): what the reply names, the picture shows. Coordinates in image px")
     }
   }, async (a) => {
     const startedAt = process.hrtime.bigint();
     let reply;
     try {
-      const { png, meta } = await session.viewSheet(a.sheet, { region: a.region, px: a.px, overlay: a.overlay, grid: a.grid });
+      const { png, meta } = await session.viewSheet(a.sheet, { region: a.region, px: a.px, overlay: a.overlay, grid: a.grid, marks: a.marks });
       reply = okImage(png, meta);
     } catch (e) {
       reply = fail(e);
@@ -11906,7 +12156,7 @@ function nameTheStageInRefusals(server) {
 // package.json
 var package_default = {
   name: "opentakeoff-mcp",
-  version: "0.9.60",
+  version: "0.9.62",
   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.60",
+  "version": "0.9.62",
   "mcpName": "io.github.Kentucky-ai/opentakeoff",
   "type": "module",
   "description": "OpenTakeoff MCP server — drive the takeoff engine from your MCP client over stdio.",