opentakeoff-mcp 0.9.61 → 0.9.63

package/README.md

@@ -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

@@ -4638,6 +4638,64 @@ function sharedRuns(ringA, ringB, opts) {
   }
   return runs;
 }
+var TRANSITION_DEFAULTS = { max_gap_in: 12, min_run_in: 12 };
+var round22 = (n) => +n.toFixed(2);
+var round12 = (n) => +n.toFixed(1);
+function dropCollinear(path5, tol = 1e-6) {
+  if (path5.length < 3) return path5.map((p) => [p[0], p[1]]);
+  const out = [[path5[0][0], path5[0][1]]];
+  for (let i = 1; i < path5.length - 1; i++) {
+    const a = out[out.length - 1], b = path5[i], c = path5[i + 1];
+    const abx = b[0] - a[0], aby = b[1] - a[1];
+    const acx = c[0] - a[0], acy = c[1] - a[1];
+    const len = Math.hypot(acx, acy);
+    const off = len > 0 ? Math.abs(abx * acy - aby * acx) / len : Infinity;
+    if (off > tol) out.push([b[0], b[1]]);
+  }
+  out.push([path5[path5.length - 1][0], path5[path5.length - 1][1]]);
+  return out;
+}
+function deriveTransitionRuns(a, b, sheets, opts = {}) {
+  const maxGapIn = opts.max_gap_in ?? TRANSITION_DEFAULTS.max_gap_in;
+  const minRunIn = opts.min_run_in ?? TRANSITION_DEFAULTS.min_run_in;
+  const runs = [], withheld = [];
+  if (!(maxGapIn > 0) || !(minRunIn > 0)) return { runs, withheld };
+  for (const [key, frame] of sheets) {
+    if (!(frame.upp > 0) || !(frame.widthPx > 0) || !(frame.heightPx > 0)) continue;
+    const onA = a.shapes.filter((s) => s.sheet_id === key);
+    const onB = b.shapes.filter((s) => s.sheet_id === key);
+    if (!onA.length || !onB.length) continue;
+    const pxPerFt = 1 / frame.upp;
+    const toPx = (s) => s.verts_norm.map(([x, y]) => [x * frame.widthPx, y * frame.heightPx]);
+    const runOpts = {
+      step_px: Math.max(1, pxPerFt * 0.25),
+      // a quarter-foot walk — finer than any transition matters
+      touch_px: pxPerFt * (1 / 12),
+      // within an inch: one open space, not two rooms
+      max_gap_px: pxPerFt * (maxGapIn / 12),
+      min_len_px: pxPerFt * (minRunIn / 12)
+    };
+    for (const ra of onA) {
+      for (const rb of onB) {
+        if (ra.id === rb.id) continue;
+        for (const r of sharedRuns(toPx(ra), toPx(rb), runOpts)) {
+          const row = {
+            sheet_id: key,
+            between_shape_ids: [ra.id, rb.id],
+            between: [a.tag, b.tag],
+            length_lf: round22(r.length_px * frame.upp),
+            gap_in: round12(r.gap_px * frame.upp * 12),
+            at: [Math.round(r.at[0]), Math.round(r.at[1])],
+            verts_norm: dropCollinear(r.path).map(([x, y]) => [x / frame.widthPx, y / frame.heightPx])
+          };
+          if (r.kind === "wall") withheld.push({ ...row, reason: "wall_separated" });
+          else runs.push(row);
+        }
+      }
+    }
+  }
+  return { runs, withheld };
+}
 
 // ../web/src/lib/cutout.js
 import { polygon as turfPolygon, featureCollection } from "@turf/helpers";
@@ -4950,7 +5008,7 @@ function applyApprovalCommand(approvals, cmd) {
 }
 
 // ../web/src/lib/num.js
-var round22 = (n) => Math.round((n + Number.EPSILON) * 100) / 100;
+var round23 = (n) => Math.round((n + Number.EPSILON) * 100) / 100;
 
 // ../web/src/lib/conditionColumns.js
 var visible = (v) => typeof v === "string" && v.trim() ? v : "";
@@ -5025,8 +5083,8 @@ function conditionTotals(conditions, shapes, ctx = null) {
       const per = Math.max(0, Number(m.per) || 0);
       const basisVal = m.basis === "linear" ? lf : m.basis === "count" ? ea : m.basis === "seam_lf" ? seam : total;
       let qty = per > 0 ? basisVal / per : 0;
-      qty = m.round === false ? round22(qty) : Math.ceil(qty - 1e-9);
-      return { name: m.name, unit: m.unit || "", per, basis: m.basis || "area", round: m.round !== false, note: m.note || "", basis_qty: round22(basisVal), qty };
+      qty = m.round === false ? round23(qty) : Math.ceil(qty - 1e-9);
+      return { name: m.name, unit: m.unit || "", per, basis: m.basis || "area", round: m.round !== false, note: m.note || "", basis_qty: round23(basisVal), qty };
     });
     return {
       id: c.id,
@@ -5037,19 +5095,19 @@ function conditionTotals(conditions, shapes, ctx = null) {
       multiplier: mult,
       waste_pct: waste,
       shape_count: cs.length,
-      floor_sf: round22(floor),
-      wall_sf: round22(wall),
-      border_sf: round22(border),
-      lf: round22(lf),
+      floor_sf: round23(floor),
+      wall_sf: round23(wall),
+      border_sf: round23(border),
+      lf: round23(lf),
       ea,
-      total_sf: round22(total),
+      total_sf: round23(total),
       // waste-adjusted (order quantities)
-      floor_sf_net: round22(floor * w),
-      wall_sf_net: round22(wall * w),
-      border_sf_net: round22(border * w),
-      lf_net: round22(lf * w),
-      total_sf_net: round22(total * w),
-      sy_net: round22(total * w / 9),
+      floor_sf_net: round23(floor * w),
+      wall_sf_net: round23(wall * w),
+      border_sf_net: round23(border * w),
+      lf_net: round23(lf * w),
+      total_sf_net: round23(total * w),
+      sy_net: round23(total * w / 9),
       materials
     };
   });
@@ -5098,11 +5156,11 @@ function hasMultipliers(bySheet) {
 function roundSheetRow(r) {
   return {
     ...r,
-    floor_sf: round22(r.floor_sf),
-    wall_sf: round22(r.wall_sf),
-    border_sf: round22(r.border_sf),
-    lf: round22(r.lf),
-    ea: round22(r.ea)
+    floor_sf: round23(r.floor_sf),
+    wall_sf: round23(r.wall_sf),
+    border_sf: round23(r.border_sf),
+    lf: round23(r.lf),
+    ea: round23(r.ea)
   };
 }
 function materialsSummary(rows) {
@@ -5113,17 +5171,17 @@ function materialsSummary(rows) {
     cur.qty += m.qty;
     map.set(key, cur);
   }
-  return [...map.values()].map((x) => ({ ...x, qty: round22(x.qty) }));
+  return [...map.values()].map((x) => ({ ...x, qty: round23(x.qty) }));
 }
 function grandTotals(rows) {
   const sum = (k) => rows.reduce((n, r) => n + (r[k] || 0), 0);
   return {
-    total_sf: round22(sum("total_sf")),
-    total_sf_net: round22(sum("total_sf_net")),
-    lf: round22(sum("lf")),
-    lf_net: round22(sum("lf_net")),
+    total_sf: round23(sum("total_sf")),
+    total_sf_net: round23(sum("total_sf_net")),
+    lf: round23(sum("lf")),
+    lf_net: round23(sum("lf_net")),
     ea: sum("ea"),
-    sy_net: round22(sum("sy_net"))
+    sy_net: round23(sum("sy_net"))
   };
 }
 function reportJson({ projectName = "", rows = [], bySheet = [], scaleInfo = [], markups = [], rfis = [], sheetLabel = null, conditionColumns = [], attrsByCond = null, shapeLabels = [], byLabel = [], displayUnits = "imperial", rollGoods = [] }) {
@@ -5621,7 +5679,7 @@ function computeRollTakeoff(conditions, shapes, dimsFor, uppFor) {
       orderFt,
       rollCount: rollLayoutRollCount(layout.strips),
       oversize: layout.strips.some((s) => s.overRoll),
-      qty: round22(rollQtyForUnit(orderFt, config.rollWidthFt, unit)),
+      qty: round23(rollQtyForUnit(orderFt, config.rollWidthFt, unit)),
       unit,
       cutCount: layout.strips.length,
       seamLf: seamLfForStrips(layout.strips),
@@ -5674,16 +5732,16 @@ function rollReportRows(rollByCond, rows) {
       roll_length_ft: ri.config.rollLengthFt,
       direction: ri.direction,
       cuts: ri.cutCount,
-      order_lf: round22(ri.orderFt * mult),
+      order_lf: round23(ri.orderFt * mult),
       rolls: ri.rollCount * mult,
-      order_qty: round22(ri.qty * mult),
+      order_qty: round23(ri.qty * mult),
       order_unit: ri.unit,
       oversize: ri.oversize,
       // seam_lf APPENDS last (the additive-only convention the roll_goods
       // block already follows): the figured weld-rod / seam-tape length, ×N
       // like every other reported quantity. 0 is a real answer — a layout
       // whose rooms each fit one strip has no seams to weld.
-      seam_lf: round22((ri.seamLf || 0) * mult)
+      seam_lf: round23((ri.seamLf || 0) * mult)
     });
   }
   return out;
@@ -5790,6 +5848,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;
@@ -6035,9 +6146,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,
@@ -6050,6 +6163,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
       }
     };
@@ -7097,26 +7211,40 @@ var Session = class _Session {
       const s = this.sheet(key);
       if (s.upp == null) throw new UserError(`${key} has no scale \u2014 a transition is a real length, so set_scale first (${this.scaleGate(s)})`);
     }
-    const committed = [], withheld = [];
+    const frames = /* @__PURE__ */ new Map();
     for (const key of sheetsInPlay) {
       const s = this.sheet(key);
-      const upp = s.upp;
-      const pxPerFt = 1 / upp;
-      const toPx = (sh) => sh.verts_norm.map(([x, y]) => [x * s.widthPx, y * s.heightPx]);
-      const onSheetA = fa.filter((x) => x.sheet_id === key), onSheetB = fb.filter((x) => x.sheet_id === key);
-      for (const ra of onSheetA) {
-        for (const rb of onSheetB) {
-          const runs = sharedRuns(toPx(ra), toPx(rb), {
-            step_px: Math.max(1, pxPerFt * 0.25),
-            // a quarter-foot walk — finer than any transition matters
-            touch_px: pxPerFt * (1 / 12),
-            // within an inch: one open space, not two rooms
-            max_gap_px: pxPerFt * (maxGapIn / 12),
-            min_len_px: pxPerFt * (minRunIn / 12)
-          });
-          for (const r of runs) this.recordRun(s, r, upp, opts.condition, ra.id, rb.id, a.finish_tag, b.finish_tag, committed, withheld);
-        }
-      }
+      frames.set(key, { widthPx: s.widthPx, heightPx: s.heightPx, upp: s.upp });
+    }
+    const src = (sh) => ({ id: sh.id, sheet_id: sh.sheet_id, verts_norm: sh.verts_norm });
+    const derived = deriveTransitionRuns(
+      { tag: a.finish_tag, shapes: fa.map(src) },
+      { tag: b.finish_tag, shapes: fb.map(src) },
+      frames,
+      { max_gap_in: maxGapIn, min_run_in: minRunIn }
+    );
+    const committed = [], withheld = [];
+    for (const w of derived.withheld) {
+      withheld.push({
+        sheet: w.sheet_id,
+        between_shape_ids: w.between_shape_ids,
+        length_lf: w.length_lf,
+        gap_in: w.gap_in,
+        at: w.at,
+        reason: "wall_separated",
+        detail: `${a.finish_tag} and ${b.finish_tag} run ${w.length_lf} LF apart across ${w.gap_in}" of wall \u2014 adjacent rooms, not a butt joint. If a door opens here the transition is a threshold at the door, which this cannot see.`
+      });
+    }
+    for (const r of derived.runs) {
+      const s = this.sheet(r.sheet_id);
+      const pathPx = r.verts_norm.map(([x, y]) => [x * s.widthPx, y * s.heightPx]);
+      const shape = this.commit(s, opts.condition, "linear", pathPx, { area_sf: 0, perimeter_lf: r.length_lf }, {
+        method: "agent_v1",
+        actor: "agent",
+        reviewed: false,
+        derived: { between_shape_ids: r.between_shape_ids, between: [a.finish_tag, b.finish_tag], case: "butt", gap_in: r.gap_in }
+      });
+      committed.push({ sheet: r.sheet_id, between_shape_ids: r.between_shape_ids, length_lf: r.length_lf, gap_in: r.gap_in, at: r.at, shape_id: shape.id });
     }
     if (committed.length) this.flushCommits("derive_transitions");
     return {
@@ -7130,23 +7258,6 @@ var Session = class _Session {
       note: withheld.length ? `${withheld.length} run(s) are adjacency ACROSS A WALL, not a butt joint \u2014 the transition there is a threshold in the doorway, and the trace record does not say where the doorway is. view_sheet each \`at\` and place them with measure_line / place_count.` : "Every run was a butt joint inside one open space. Verify with view_sheet overlay:true before trusting the total."
     };
   }
-  /** One shared run → committed transition, or a disclosed question. */
-  recordRun(s, r, upp, condition, aId, bId, aTag, bTag, committed, withheld) {
-    const length_lf = round2(r.length_px * upp);
-    const gap_in = round1(r.gap_px * upp * 12);
-    const row = { sheet: s.key, between_shape_ids: [aId, bId], length_lf, gap_in, at: [Math.round(r.at[0]), Math.round(r.at[1])] };
-    if (r.kind === "wall") {
-      withheld.push({ ...row, reason: "wall_separated", detail: `${aTag} and ${bTag} run ${length_lf} LF apart across ${gap_in}" of wall \u2014 adjacent rooms, not a butt joint. If a door opens here the transition is a threshold at the door, which this cannot see.` });
-      return;
-    }
-    const shape = this.commit(s, condition, "linear", r.path, { area_sf: 0, perimeter_lf: length_lf }, {
-      method: "agent_v1",
-      actor: "agent",
-      reviewed: false,
-      derived: { between_shape_ids: [aId, bId], between: [aTag, bTag], case: "butt", gap_in }
-    });
-    committed.push({ ...row, shape_id: shape.id });
-  }
   /** Count markers — the canvas's Count tool (commitCount): one point, one EA,
    * computed {count: 1}, NO scale required (EA is scale-free; the canvas's
    * recompute skips count shapes for the same reason). One shape per point,
@@ -7421,6 +7532,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.");
@@ -7473,16 +7590,23 @@ var Session = class _Session {
       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);
@@ -7501,11 +7625,13 @@ 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 } : {}
         } : {},
         ...(() => {
           const parts = [];
-          if (opts.commit && !res.matches.length) parts.push("commit requested but nothing cleared the bar \u2014 no shapes were committed.");
+          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(" ") } : {};
         })(),
@@ -9188,6 +9314,7 @@ var symbolSweepOutput = {
   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)"),
@@ -11503,12 +11630,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. 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}`,
+    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"),
@@ -11526,7 +11654,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}`,
@@ -11779,19 +11908,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);
@@ -12077,7 +12211,7 @@ function nameTheStageInRefusals(server) {
 // package.json
 var package_default = {
   name: "opentakeoff-mcp",
-  version: "0.9.61",
+  version: "0.9.63",
   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.61",
+  "version": "0.9.63",
   "mcpName": "io.github.Kentucky-ai/opentakeoff",
   "type": "module",
   "description": "OpenTakeoff MCP server — drive the takeoff engine from your MCP client over stdio.",