opentakeoff-mcp 0.9.19 → 0.9.20

package/README.md

@@ -115,6 +115,7 @@ includes document text, shape vertices, or result payload content.
 | `derive_base` | **Base LF from committed rooms**: for every floor shape of a source condition, commits a linear base run tracing that room's boundary, quantified net of the door openings YOU state per room (`{shape_id, lf}` — your claim, recorded on `origin.derived`; the tool never guesses). All-or-nothing; one undo step. |
 | `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 sheet's 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. `commit: true` + `condition` commits every match center as an EA count marker through the `place_count` path — one undo step, `origin.method "symbol_sweep"` with per-marker score and transform. 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`. |
 | `delete_shape` | Remove a committed shape by id. |
@@ -126,7 +127,7 @@ includes document text, shape vertices, or result payload content.
 | `export_marked_pdf` | The **marked-up planset** — the deliverable. Writes a distribution-ready PDF: a legend cover (per-condition totals, swatches, by-sheet breakdown) plus every sheet that carries work, vector-copied from the source with shapes, hatches, per-shape quantity chips, and annotations burned in — built by the same module as the canvas's MARKED SET button. Machine-traced shapes are disclosed as pending human review on the document itself, and the cover states where the finish tags came from (`Finish assignment: N schedule-resolved · N agent-asserted · …`, plus any rooms the last assign run withheld). Default path: `<plan> - marked set.pdf` next to the plan. Works without `@napi-rs/canvas`. |
 | `list_shapes` | The **mid-session inventory**: every committed shape's id, sheet, condition, role, quantities, review state, and assignment verdict (`schedule` \| `asserted` — where its finish tag came from) in one compact read — the ids `edit_shape`/`delete_shape` assume you have, without pulling the whole `export_takeoff` payload. Filters by sheet/condition narrow; empty is a result, not an error. |
 | `undo_last` | Step back over your own last `n` mutations, newest first. Exact inverses: a commit is removed, an edit restored verbatim, a delete re-inserted where it was, a materials edit's whole array restored, a condition edit's waste/multiplier pair restored. A whole `detect_rooms` sweep is **one** step. |
-| `annotate` | Place a note ABOUT the work — cloud/highlight (`rect`), text (`at`), callout (`at` + `target`), **arrow** (`from` + `to` — plank/seam direction), **bubble** (`at` + optional `r` — keynote circle, centered text). Attach to a condition and it wears that scope's colour on the canvas and in the marked set. No review gate: notes are not geometry. |
+| `annotate` | Place a note ABOUT the work — cloud/highlight (`rect`), text (`at`), callout (`at` + `target`), **arrow** (`from` + `to` — plank/seam direction), **bubble** (`at` + optional `r` — keynote circle, centered text), **dimension** (`from` + `to` — a dimension line with end ticks, labelled with the measured length at the sheet's scale; the one annotation the scale gate applies to — an unscaled sheet refuses like the measure tools). Attach to a condition and it wears that scope's colour on the canvas and in the marked set. No review gate: notes are not geometry. |
 | `list_annotations` | Every annotation with its condition RESOLVED to a finish tag, coordinates back in image px; filter by sheet/condition. `unattached` counts the link_annotation candidates. |
 | `link_annotation` | Attach an existing annotation to a condition (or detach with an empty tag) — the canvas's Attach/Detach control, reachable by an agent. |
 | `read_sheet_text` | Positioned page text (image px), optionally restricted to a region — title blocks, room labels, finish schedules. |

package/dist/server-core.js

@@ -1316,6 +1316,235 @@ var fail = (err) => ({
 var round2 = (n) => +n.toFixed(2);
 var round1 = (n) => +n.toFixed(1);
 
+// ../web/src/lib/symbolsweep.ts
+var SWEEP_TOL_PX = 2;
+var SWEEP_SCORE_HIGH = 0.92;
+var SWEEP_SCORE_LOW = 0.75;
+var SWEEP_MAX_CANDIDATES = 2e4;
+var ANCHOR_COUNT = 3;
+var MIN_SEG_LEN = 0.5;
+var MAX_SEED_SEGS = 2e3;
+function transformsFor(rotations, mirror) {
+  const rots = [
+    [0, [1, 0, 0, 1]],
+    [90, [0, -1, 1, 0]],
+    [180, [-1, 0, 0, -1]],
+    [270, [0, 1, -1, 0]]
+  ];
+  const use = rotations ? rots : rots.slice(0, 1);
+  const out = use.map(([rotation, m]) => ({ rotation, mirrored: false, m }));
+  if (mirror) {
+    for (const [rotation, m] of use) out.push({ rotation, mirrored: true, m: [-m[0], m[1], -m[2], m[3]] });
+  }
+  return out;
+}
+var apply = (m, x, y) => [m[0] * x + m[1] * y, m[2] * x + m[3] * y];
+var EndpointGrid = class {
+  constructor(segs, tol) {
+    this.segs = segs;
+    this.cell = Math.max(2 * tol, 4);
+    const n = segs.length >> 2;
+    for (let i = 0; i < n; i++) {
+      this.add(segs[i * 4], segs[i * 4 + 1], i);
+      this.add(segs[i * 4 + 2], segs[i * 4 + 3], i);
+    }
+  }
+  cells = /* @__PURE__ */ new Map();
+  cell;
+  key(cx, cy) {
+    return cx * 73856093 ^ cy * 19349663;
+  }
+  add(x, y, i) {
+    const k = this.key(Math.floor(x / this.cell), Math.floor(y / this.cell));
+    const a = this.cells.get(k);
+    if (a) {
+      if (a[a.length - 1] !== i) a.push(i);
+    } else this.cells.set(k, [i]);
+  }
+  /** Indices of segments with an endpoint within one cell of (x, y). */
+  near(x, y, out) {
+    out.length = 0;
+    const cx = Math.floor(x / this.cell), cy = Math.floor(y / this.cell);
+    for (let dy = -1; dy <= 1; dy++) for (let dx = -1; dx <= 1; dx++) {
+      const a = this.cells.get(this.key(cx + dx, cy + dy));
+      if (a) for (const i of a) out.push(i);
+    }
+    return out;
+  }
+};
+var segLen = (segs, i) => Math.hypot(segs[i * 4 + 2] - segs[i * 4], segs[i * 4 + 3] - segs[i * 4 + 1]);
+function sweepSymbols(segs, seedRect, opts = {}) {
+  const tol = opts.tolPx ?? SWEEP_TOL_PX;
+  const scoreHigh = opts.scoreHigh ?? SWEEP_SCORE_HIGH;
+  const scoreLow = opts.scoreLow ?? SWEEP_SCORE_LOW;
+  const maxCandidates = opts.maxCandidates ?? SWEEP_MAX_CANDIDATES;
+  const xforms = transformsFor(opts.rotations ?? true, opts.mirror ?? true);
+  const n = segs.length >> 2;
+  const rx0 = Math.min(seedRect[0][0], seedRect[1][0]), rx1 = Math.max(seedRect[0][0], seedRect[1][0]);
+  const ry0 = Math.min(seedRect[0][1], seedRect[1][1]), ry1 = Math.max(seedRect[0][1], seedRect[1][1]);
+  const inside = (x, y) => x >= rx0 && x <= rx1 && y >= ry0 && y <= ry1;
+  const seedIdx = [];
+  for (let i = 0; i < n; i++) {
+    if (inside(segs[i * 4], segs[i * 4 + 1]) && inside(segs[i * 4 + 2], segs[i * 4 + 3]) && segLen(segs, i) >= MIN_SEG_LEN) {
+      seedIdx.push(i);
+    }
+  }
+  if (!seedIdx.length) {
+    throw new Error("No vector segments sit fully inside the seed rect \u2014 marquee tightly around one whole symbol instance (segments crossing the rect edge don't count as the symbol).");
+  }
+  if (seedIdx.length > MAX_SEED_SEGS) {
+    throw new Error(`The seed rect holds ${seedIdx.length} segments \u2014 that is a region, not one symbol instance. Marquee a single symbol.`);
+  }
+  let totalLen = 0, cxw = 0, cyw = 0;
+  for (const i of seedIdx) {
+    const L = segLen(segs, i);
+    totalLen += L;
+    cxw += (segs[i * 4] + segs[i * 4 + 2]) / 2 * L;
+    cyw += (segs[i * 4 + 1] + segs[i * 4 + 3]) / 2 * L;
+  }
+  const seedCx = cxw / totalLen, seedCy = cyw / totalLen;
+  const rel = seedIdx.map((i) => [
+    segs[i * 4] - seedCx,
+    segs[i * 4 + 1] - seedCy,
+    segs[i * 4 + 2] - seedCx,
+    segs[i * 4 + 3] - seedCy,
+    segLen(segs, i)
+  ]);
+  let sbx0 = Infinity, sby0 = Infinity, sbx1 = -Infinity, sby1 = -Infinity;
+  for (const i of seedIdx) {
+    sbx0 = Math.min(sbx0, segs[i * 4], segs[i * 4 + 2]);
+    sby0 = Math.min(sby0, segs[i * 4 + 1], segs[i * 4 + 3]);
+    sbx1 = Math.max(sbx1, segs[i * 4], segs[i * 4 + 2]);
+    sby1 = Math.max(sby1, segs[i * 4 + 1], segs[i * 4 + 3]);
+  }
+  const lenBucket = /* @__PURE__ */ new Map();
+  for (let i = 0; i < n; i++) {
+    const b = Math.round(segLen(segs, i));
+    const a = lenBucket.get(b);
+    if (a) a.push(i);
+    else lenBucket.set(b, [i]);
+  }
+  const bucketBand = (L) => {
+    const out = [];
+    for (let b = Math.floor(L - 2 * tol); b <= Math.ceil(L + 2 * tol); b++) {
+      const a = lenBucket.get(b);
+      if (a) {
+        for (const i of a) if (Math.abs(segLen(segs, i) - L) <= 2 * tol) out.push(i);
+      }
+    }
+    return out;
+  };
+  const byLenQ = /* @__PURE__ */ new Map();
+  for (let k = 0; k < rel.length; k++) {
+    const L = rel[k][4];
+    const q = Math.round(L);
+    if (!byLenQ.has(q)) byLenQ.set(q, { relIdx: k, len: L, rarity: bucketBand(L).length });
+  }
+  const anchors = [...byLenQ.values()].sort((a, b) => a.rarity - b.rarity || b.len - a.len || a.relIdx - b.relIdx).slice(0, ANCHOR_COUNT);
+  const proposals = [];
+  const seen = /* @__PURE__ */ new Set();
+  const quant = Math.max(tol, 1);
+  for (let xi = 0; xi < xforms.length; xi++) {
+    const { m } = xforms[xi];
+    for (const anc of anchors) {
+      const r = rel[anc.relIdx];
+      const A = apply(m, r[0], r[1]);
+      const B = apply(m, r[2], r[3]);
+      for (const j of bucketBand(anc.len)) {
+        const px = segs[j * 4], py = segs[j * 4 + 1], qx = segs[j * 4 + 2], qy = segs[j * 4 + 3];
+        for (const [ax, ay, bx, by] of [[A[0], A[1], B[0], B[1]], [B[0], B[1], A[0], A[1]]]) {
+          const c1x = px - ax, c1y = py - ay;
+          const c2x = qx - bx, c2y = qy - by;
+          if (Math.abs(c1x - c2x) > 2 * tol || Math.abs(c1y - c2y) > 2 * tol) continue;
+          const tx = (c1x + c2x) / 2, ty = (c1y + c2y) / 2;
+          const key = `${xi}:${Math.round(tx / quant)}:${Math.round(ty / quant)}`;
+          if (seen.has(key)) continue;
+          seen.add(key);
+          proposals.push({ tx, ty, xf: xi });
+        }
+      }
+    }
+  }
+  proposals.sort((a, b) => a.ty - b.ty || a.tx - b.tx || a.xf - b.xf);
+  const considered = Math.min(proposals.length, maxCandidates);
+  const dropped = proposals.length - considered;
+  const grid = new EndpointGrid(segs, tol);
+  const scratch = [];
+  const tol2 = tol * tol;
+  const near = (x1, y1, x2, y2) => (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) <= tol2;
+  const scoreAt = (m, tx, ty) => {
+    let matched = 0;
+    for (const r of rel) {
+      const a = apply(m, r[0], r[1]);
+      const b = apply(m, r[2], r[3]);
+      const ax = a[0] + tx, ay = a[1] + ty, bx = b[0] + tx, by = b[1] + ty;
+      let hit = false;
+      for (const j of grid.near(ax, ay, scratch)) {
+        const px = segs[j * 4], py = segs[j * 4 + 1], qx = segs[j * 4 + 2], qy = segs[j * 4 + 3];
+        if (near(px, py, ax, ay) && near(qx, qy, bx, by) || near(qx, qy, ax, ay) && near(px, py, bx, by)) {
+          hit = true;
+          break;
+        }
+      }
+      if (hit) matched += r[4];
+    }
+    return matched / totalLen;
+  };
+  const scored = [];
+  for (let k = 0; k < considered; k++) {
+    const c = proposals[k];
+    const score = scoreAt(xforms[c.xf].m, c.tx, c.ty);
+    if (score < scoreLow) continue;
+    scored.push({ at: [c.tx, c.ty], score, rotation: xforms[c.xf].rotation, mirrored: xforms[c.xf].mirrored, xf: c.xf });
+  }
+  const mergeR = Math.max(2 * tol, 4);
+  const kept = [];
+  for (const s of scored) {
+    const twin = kept.find((k) => Math.hypot(k.at[0] - s.at[0], k.at[1] - s.at[1]) <= mergeR);
+    if (!twin) {
+      kept.push(s);
+      continue;
+    }
+    if (s.score > twin.score || s.score === twin.score && s.xf < twin.xf) {
+      twin.at = s.at;
+      twin.score = s.score;
+      twin.rotation = s.rotation;
+      twin.mirrored = s.mirrored;
+      twin.xf = s.xf;
+    }
+  }
+  const suppressR = Math.max(mergeR, Math.hypot(sbx1 - sbx0, sby1 - sby0) / 2);
+  const away = kept.filter((s) => Math.hypot(s.at[0] - seedCx, s.at[1] - seedCy) > suppressR);
+  const matches = [];
+  const withheld = [];
+  const pct = (v) => Math.round(v * 1e3) / 1e3;
+  const row = (s) => ({
+    at: [Math.round(s.at[0] * 10) / 10, Math.round(s.at[1] * 10) / 10],
+    score: pct(s.score),
+    rotation: s.rotation,
+    mirrored: s.mirrored
+  });
+  for (const s of away) if (s.score >= scoreHigh) matches.push(row(s));
+  for (const s of away) {
+    if (s.score >= scoreHigh) continue;
+    if (matches.some((m) => Math.hypot(m.at[0] - s.at[0], m.at[1] - s.at[1]) <= suppressR)) continue;
+    withheld.push({ ...row(s), reason: `matched ${Math.round(s.score * 100)}% of the seed's linework (commit bar ${Math.round(scoreHigh * 100)}%) \u2014 likely a variant or an overlapped instance; look before counting it` });
+  }
+  const order = (a, b) => a.at[1] - b.at[1] || a.at[0] - b.at[0] || a.rotation - b.rotation || Number(a.mirrored) - Number(b.mirrored);
+  matches.sort(order);
+  withheld.sort(order);
+  return {
+    seed: {
+      segments: seedIdx.length,
+      center: [Math.round(seedCx * 10) / 10, Math.round(seedCy * 10) / 10],
+      length_px: Math.round(totalLen * 10) / 10
+    },
+    matches,
+    withheld,
+    candidates: { considered, dropped }
+  };
+}
+
 // ../web/src/lib/geometry.js
 function starPath(cx, cy, R, points = 4, innerRatio = 0.38) {
   const r = R * innerRatio;
@@ -1463,6 +1692,21 @@ function attrValue(attrs, colId) {
   return visible(attrs?.[colId]);
 }
 
+// ../web/src/lib/units.ts
+var M_PER_FT = 0.3048;
+function dimLabel(feet, units = "imperial") {
+  if (!Number.isFinite(feet)) return "";
+  if (units === "metric") return `${(feet * M_PER_FT).toFixed(2)} m`;
+  const sign = feet < 0 ? "-" : "";
+  let ft = Math.floor(Math.abs(feet) + 1e-9);
+  let inch = Math.round((Math.abs(feet) - ft) * 12);
+  if (inch === 12) {
+    ft += 1;
+    inch = 0;
+  }
+  return `${sign}${ft}'-${inch}"`;
+}
+
 // ../web/src/lib/totals.js
 function accumulateRole(acc, s) {
   const cp = s.computed || {};
@@ -3090,15 +3334,99 @@ var Session = class _Session {
    * 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,
    * the whole call one journal gesture — undoing a placement sweep is one step,
-   * matching detect_rooms. */
+   * matching detect_rooms.
+   *
+   * `origins` (optional, aligned with points) lets a derived tool commit
+   * through this same path while telling the truth about the method —
+   * symbol_sweep stamps `{method: "symbol_sweep", …, symbol: {score, …}}` per
+   * marker; a bare place_count stays exactly the manual agent gesture it is. */
   placeCount(name, points, opts) {
     const s = this.sheet(name);
-    const ids = points.map(([x, y]) => this.commit(s, opts.condition, "count", [[x, y]], { count: 1 }, { method: "manual", actor: "agent" }).id);
-    this.flushCommits("place_count");
+    const ids = points.map(([x, y], i) => this.commit(
+      s,
+      opts.condition,
+      "count",
+      [[x, y]],
+      { count: 1 },
+      opts.origins?.[i] ? { ...opts.origins[i] } : { method: "manual", actor: "agent" }
+    ).id);
+    this.flushCommits(opts.tool ?? "place_count");
     const c = this.conditions.find((x) => x.finish_tag === opts.condition);
     const ea_total = this.shapes.filter((x) => x.condition_id === c.id && x.measure_role === "count").reduce((n, x) => n + (x.computed.count || 1), 0);
     return { committed: ids.length, shape_ids: ids, condition: c.finish_tag, ea_total };
   }
+  /** symbol_sweep — every placement of ONE example symbol, from the linework.
+   * The engine is pure (web/src/lib/symbolsweep.ts): fingerprint the seed
+   * rect's segments, propose placements by constellation anchoring under the
+   * square symmetry group, score each as the length-weighted fraction of seed
+   * segments reproduced within tolerance. This method is the plumbing plus
+   * the wire shapes: rect clamping, the scan refusal, and the commit path —
+   * match centers through placeCount (ONE undo step, EA scale-free), origins
+   * telling the truth (`method: "symbol_sweep"`, per-match score/transform),
+   * withheld placements NEVER committed. */
+  async symbolSweep(name, opts) {
+    const s = this.sheet(name);
+    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').");
+    }
+    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.");
+    }
+    const clampX = (v) => Math.max(0, Math.min(v, s.widthPx));
+    const clampY = (v) => Math.max(0, Math.min(v, s.heightPx));
+    const rect = [
+      [clampX(opts.seedRect[0][0]), clampY(opts.seedRect[0][1])],
+      [clampX(opts.seedRect[1][0]), clampY(opts.seedRect[1][1])]
+    ];
+    if (!(Math.abs(rect[1][0] - rect[0][0]) >= 1 && Math.abs(rect[1][1] - rect[0][1]) >= 1)) {
+      throw new UserError(`Empty seed rect \u2014 need two distinct corners in image px inside the sheet (${s.widthPx} \xD7 ${s.heightPx}).`);
+    }
+    const sweepOpts = {
+      rotations: opts.rotations ?? true,
+      mirror: opts.mirror ?? true,
+      tolPx: opts.tolerancePx ?? SWEEP_TOL_PX
+    };
+    let res;
+    try {
+      res = sweepSymbols(geo.segs, rect, sweepOpts);
+    } catch (e) {
+      throw new UserError(e instanceof Error ? e.message : String(e));
+    }
+    let committed;
+    if (opts.commit && res.matches.length) {
+      committed = this.placeCount(name, res.matches.map((m) => m.at), {
+        condition: opts.condition,
+        tool: "symbol_sweep",
+        origins: res.matches.map((m) => ({
+          method: "symbol_sweep",
+          actor: "agent",
+          reviewed: false,
+          symbol: { score: m.score, rotation: m.rotation, mirrored: m.mirrored }
+        }))
+      });
+    }
+    return {
+      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: {
+        segments: res.seed.segments,
+        center: [round1(res.seed.center[0]), round1(res.seed.center[1])],
+        rect: [round1(rect[0][0]), round1(rect[0][1]), round1(rect[1][0]), round1(rect[1][1])],
+        length_px: res.seed.length_px
+      },
+      candidates: res.candidates,
+      ...committed ? {
+        committed: committed.committed,
+        shape_ids: committed.shape_ids,
+        condition: committed.condition,
+        ea_total: committed.ea_total
+      } : {},
+      ...opts.commit && !res.matches.length ? { note: "commit requested but nothing cleared the bar \u2014 no shapes were committed." } : {},
+      ...res.candidates.dropped > 0 ? { warning: `Work cap: ${res.candidates.dropped} candidate placement(s) were never scored \u2014 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.` } : {}
+    };
+  }
   /** The mid-session shape inventory (#149): every committed shape's id,
    * home, role, and quantities in one compact read — the ids edit_shape /
    * delete_shape assume you have, without pulling the whole export_takeoff
@@ -3418,7 +3746,14 @@ var Session = class _Session {
     if ((a.type === "cloud" || a.type === "highlight") && !a.rect) throw new UserError(`a ${a.type} needs rect: [[x0,y0],[x1,y1]] in image px`);
     if ((a.type === "text" || a.type === "callout" || a.type === "bubble") && !a.at) throw new UserError(`a ${a.type} needs at: [x,y] in image px`);
     if (a.type === "callout" && !a.target) throw new UserError("a callout needs target: [x,y] \u2014 the point the leader line aims at");
-    if (a.type === "arrow" && (!a.from || !a.to)) throw new UserError("an arrow needs from: [x,y] and to: [x,y] \u2014 tail and head, in image px");
+    if ((a.type === "arrow" || a.type === "dimension") && (!a.from || !a.to)) {
+      throw new UserError(a.type === "arrow" ? "an arrow needs from: [x,y] and to: [x,y] \u2014 tail and head, in image px" : "a dimension needs from: [x,y] and to: [x,y] \u2014 its two measured endpoints, in image px");
+    }
+    let len_ft;
+    if (a.type === "dimension") {
+      if (s.upp == null) throw new UserError(this.scaleGate(s));
+      len_ft = round2(Math.hypot(a.to[0] - a.from[0], a.to[1] - a.from[1]) * s.upp);
+    }
     const cond = a.condition ? this.conditionFor(a.condition) : null;
     const m = {
       id: uid("mk"),
@@ -3435,7 +3770,10 @@ var Session = class _Session {
       ...a.to ? { to: n(a.to) } : {},
       // bubble radius: px → fraction of sheet WIDTH (marked-set frame); the
       // canvas default is 0.02 when unset — stored explicitly so exports agree
-      ...a.type === "bubble" ? { r: a.r != null ? a.r / s.widthPx : 0.02 } : {}
+      ...a.type === "bubble" ? { r: a.r != null ? a.r / s.widthPx : 0.02 } : {},
+      // dimension: the measured length rides the markup so the renderers
+      // (canvas, marked set) draw the label without scale plumbing
+      ...len_ft !== void 0 ? { len_ft } : {}
     };
     this.markups.push(m);
     return {
@@ -3445,6 +3783,7 @@ var Session = class _Session {
       text: m.text,
       condition: cond?.finish_tag ?? "",
       condition_id: m.condition_id,
+      ...len_ft !== void 0 ? { length_lf: len_ft } : {},
       note: cond ? `Attached to ${cond.finish_tag} \u2014 it wears that condition's colour on the canvas and in the marked set.` : "Unattached \u2014 a note about the sheet. Pass condition to tie it to a scope."
     };
   }
@@ -3482,7 +3821,8 @@ var Session = class _Session {
         ...m.rect ? { rect: [px(m, m.rect[0]), px(m, m.rect[1])] } : {},
         ...m.from ? { from: px(m, m.from) } : {},
         ...m.to ? { to: px(m, m.to) } : {},
-        ...m.r != null ? { r: round1(m.r * (s0.get(m.sheet_id)?.widthPx ?? 0)) } : {}
+        ...m.r != null ? { r: round1(m.r * (s0.get(m.sheet_id)?.widthPx ?? 0)) } : {},
+        ...m.len_ft != null ? { length_lf: m.len_ft } : {}
       })),
       count: rows.length,
       unattached: rows.filter((m) => !m.condition_id).length
@@ -3811,6 +4151,33 @@ var placeCountOutput = {
   condition: z.string(),
   ea_total: z.number().describe("The condition's total EA after this call")
 };
+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()
+};
+var symbolSweepOutput = {
+  found: z.number().int().describe("Placements that cleared the commit bar \u2014 matches.length"),
+  matches: z.array(z.object(sweepPlacement)).describe("Deterministic reading order (y, then x). The seed's own location is never listed here"),
+  withheld: z.array(z.object({ ...sweepPlacement, reason: z.string() })).describe("Near-matches in the [0.75, 0.92) band \u2014 reported with a reason, NEVER committed. A withheld placement is a question you can answer with view_sheet; a hidden one is a miscount"),
+  seed: z.object({
+    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")
+  }),
+  candidates: z.object({
+    considered: z.number().int(),
+    dropped: z.number().int().describe("Placements never scored because the work cap bit \u2014 always disclosed, never silent")
+  }),
+  committed: z.number().int().optional().describe("commit mode: count shapes committed \u2014 one per match"),
+  shape_ids: z.array(z.string()).optional(),
+  condition: z.string().optional().describe("commit mode: the finish tag the markers counted under"),
+  ea_total: z.number().optional().describe("commit mode: the condition's total EA after this call"),
+  note: z.string().optional(),
+  warning: z.string().optional().describe("Present when the work cap dropped candidates \u2014 what a tighter seed rect would recover")
+};
 var measureLineOutput = {
   length_lf: z.number(),
   npts: z.number().int(),
@@ -4129,9 +4496,10 @@ var annotationRow = z.object({
   at: z.tuple([z.number(), z.number()]).optional(),
   target: z.tuple([z.number(), z.number()]).optional(),
   rect: z.array(z.tuple([z.number(), z.number()]).optional()).optional(),
-  from: z.tuple([z.number(), z.number()]).optional().describe("Arrow tail (image px)"),
-  to: z.tuple([z.number(), z.number()]).optional().describe("Arrow head (image px)"),
-  r: z.number().optional().describe("Bubble radius (image px)")
+  from: z.tuple([z.number(), z.number()]).optional().describe("Arrow tail / dimension start (image px)"),
+  to: z.tuple([z.number(), z.number()]).optional().describe("Arrow head / dimension end (image px)"),
+  r: z.number().optional().describe("Bubble radius (image px)"),
+  length_lf: z.number().optional().describe("Dimension only: the measured length in real feet, snapshotted at annotate time from the sheet scale")
 });
 var annotateOutput = {
   id: z.string(),
@@ -4140,6 +4508,7 @@ var annotateOutput = {
   text: z.string(),
   condition: z.string(),
   condition_id: z.string(),
+  length_lf: z.number().optional().describe("Dimension only: the measured length (real feet) the annotation will label itself with"),
   note: z.string()
 };
 var listAnnotationsOutput = {
@@ -4158,6 +4527,24 @@ var linkAnnotationOutput = {
 import path3 from "node:path";
 import { readFile as readFile2, writeFile } from "node:fs/promises";
 
+// ../web/src/lib/approvals.js
+var APPROVAL_R = 0.022;
+var APPROVAL_INK = {
+  estimator: { light: "#1f6b4a", dark: "#55b083" },
+  agent: { light: "#6c6a5e", dark: "#9d9a8c" }
+};
+function approvalInk(actor, dark = false) {
+  const c = APPROVAL_INK[actor] || APPROVAL_INK.agent;
+  return dark ? c.dark : c.light;
+}
+function approvalTally(approvals) {
+  const t = { estimator: 0, agent: 0 };
+  for (const a of Array.isArray(approvals) ? approvals : []) {
+    if (a && a.actor in t) t[a.actor] += 1;
+  }
+  return t;
+}
+
 // ../web/src/lib/svgpath.js
 function isSep(c) {
   return c === " " || c === "	" || c === "\n" || c === "\r" || c === "\f" || c === ",";
@@ -4813,7 +5200,7 @@ function invertPixels(cv) {
   ctx.fillRect(0, 0, cv.width, cv.height);
   ctx.restore();
 }
-async function buildMarkedSetPdf({ projectName, dark, sheets, shapes, markups, rfis = [], conditions, getPage, loadPdfData, company, clientInfo, credit = null, provenance = null, coverTitle = "Marked Set", units = "imperial" }) {
+async function buildMarkedSetPdf({ projectName, dark, sheets, shapes, markups, approvals = [], rfis = [], conditions, getPage, loadPdfData, company, clientInfo, credit = null, provenance = null, coverTitle = "Marked Set", units = "imperial" }) {
   const M = units === "metric";
   const uA = (sf) => M ? sf * 0.09290304 : sf;
   const uL = (lf) => M ? lf * 0.3048 : lf;
@@ -4830,8 +5217,8 @@ async function buildMarkedSetPdf({ projectName, dark, sheets, shapes, markups, r
     }
     return m;
   };
-  const shapesBy = byKey(shapes), marksBy = byKey(markups);
-  const marked = sheets.filter((sh) => (shapesBy.get(sh.key) || []).length || (marksBy.get(sh.key) || []).length);
+  const shapesBy = byKey(shapes), marksBy = byKey(markups), apBy = byKey(approvals);
+  const marked = sheets.filter((sh) => (shapesBy.get(sh.key) || []).length || (marksBy.get(sh.key) || []).length || (apBy.get(sh.key) || []).length);
   if (!marked.length && !rfis?.length) throw new Error("Nothing to export \u2014 no sheet carries takeoffs or markups.");
   const markedShapes = marked.flatMap((sh) => shapesBy.get(sh.key) || []);
   const doc = await PDFDocument.create();
@@ -4907,6 +5294,11 @@ async function buildMarkedSetPdf({ projectName, dark, sheets, shapes, markups, r
       metaY -= 12;
       draw(provenance, { x: 52, y: metaY, size: 9.5, font, color: muted });
     }
+    const apCount = approvalTally(marked.flatMap((sh) => apBy.get(sh.key) || []));
+    if (apCount.estimator || apCount.agent) {
+      metaY -= 12;
+      draw(`Approval stamps: ${apCount.estimator} estimator-approved \xB7 ${apCount.agent} agent-marked`, { x: 52, y: metaY, size: 9.5, font, color: muted });
+    }
     let y = metaY - 34;
     const rows = conditionTotals(conditions, markedShapes).filter((r) => r.shape_count > 0);
     draw("CONDITIONS", { x: 52, y, size: 9, font: bold, color: muted });
@@ -4935,7 +5327,7 @@ async function buildMarkedSetPdf({ projectName, dark, sheets, shapes, markups, r
     for (const sh of marked) {
       if (y < 90) break;
       const items = shapesBy.get(sh.key) || [];
-      draw(`${sh.label} \xB7 page ${sh.page} \xB7 ${items.length + (marksBy.get(sh.key) || []).length} item(s)`, { x: 52, y, size: 9.5, font: bold, color: ink });
+      draw(`${sh.label} \xB7 page ${sh.page} \xB7 ${items.length + (marksBy.get(sh.key) || []).length + (apBy.get(sh.key) || []).length} item(s)`, { x: 52, y, size: 9.5, font: bold, color: ink });
       y -= 13;
       for (const r of bySheetId.get(sh.key)?.rows || []) {
         if (y < 92) break;
@@ -5177,6 +5569,21 @@ async function buildMarkedSetPdf({ projectName, dark, sheets, shapes, markups, r
         pg.drawSvgPath(arrowheadPath(pfx, -pfy, ptx, -pty, 6 * mw), { x: 0, y: 0, color: mcol, opacity: 0.95 });
         const t = lbl(m.text);
         if (t) text(t, (m.from[0] + m.to[0]) / 2 * W, (m.from[1] + m.to[1]) / 2 * H - 6 / ptScale, 8, mcol, bold);
+      } else if (m.type === "dimension" && m.from && m.to) {
+        const fx = m.from[0] * W, fy = m.from[1] * H, dxq = m.to[0] * W, dyq = m.to[1] * H;
+        line(fx, fy, dxq, dyq, mcol, 1.1 * mw, 0.95, mdash);
+        const dl = Math.hypot(dxq - fx, dyq - fy) || 1;
+        const dnx = -(dyq - fy) / dl, dny = (dxq - fx) / dl;
+        const tk = 5 / ptScale;
+        line(fx - dnx * tk, fy - dny * tk, fx + dnx * tk, fy + dny * tk, mcol, 1.1 * mw, 0.95);
+        line(dxq - dnx * tk, dyq - dny * tk, dxq + dnx * tk, dyq + dny * tk, mcol, 1.1 * mw, 0.95);
+        const t = lbl([Number(m.len_ft) > 0 ? dimLabel(m.len_ft, M ? "metric" : "imperial") : "", m.text].filter(Boolean).join(" \xB7 "));
+        if (t) {
+          const size = 8;
+          const tw = bold.widthOfTextAtSize(winAnsiSafe(t), size);
+          const [pmx, pmy] = toPage((fx + dxq) / 2 + dnx * (14 / ptScale), (fy + dyq) / 2 + dny * (14 / ptScale));
+          pg.drawText(winAnsiSafe(t), { x: pmx - tw / 2, y: pmy - size / 2.7, size, font: bold, color: mcol, rotate: chipRot });
+        }
       } else if (m.type === "bubble" && m.at) {
         const cxImg = m.at[0] * W, cyImg = m.at[1] * H;
         const [pcx, pcy] = toPage(cxImg, cyImg);
@@ -5213,6 +5620,26 @@ async function buildMarkedSetPdf({ projectName, dark, sheets, shapes, markups, r
         text(lbl(m.text), m.at[0] * W, m.at[1] * H, 8.5, mcol, bold);
       }
     }
+    for (const a of apBy.get(sh.key) || []) {
+      const isAgent = a.actor === "agent";
+      const acol = rgb(...hex(approvalInk(a.actor, dark)));
+      const cxImg = a.at[0] * W, cyImg = a.at[1] * H;
+      const rImg = APPROVAL_R * W, rPt = rImg * ptScale;
+      const [pcx, pcy] = toPage(cxImg, cyImg);
+      const backing = dark ? rgb(0.08, 0.1, 0.12) : rgb(1, 1, 1);
+      if (isAgent) {
+        const dia = (k) => [[cxImg, cyImg - rImg * k], [cxImg + rImg * k, cyImg], [cxImg, cyImg + rImg * k], [cxImg - rImg * k, cyImg]];
+        pg.drawSvgPath(svgPath(dia(1)), { x: 0, y: 0, color: backing, opacity: 0.72, borderColor: acol, borderWidth: rPt * 0.07 });
+        pg.drawSvgPath(svgPath(dia(0.72)), { x: 0, y: 0, borderColor: acol, borderWidth: rPt * 0.035 });
+      } else {
+        pg.drawEllipse({ x: pcx, y: pcy, xScale: rPt, yScale: rPt, color: backing, opacity: 0.72, borderColor: acol, borderWidth: rPt * 0.07 });
+        pg.drawEllipse({ x: pcx, y: pcy, xScale: rPt * 0.78, yScale: rPt * 0.78, borderColor: acol, borderWidth: rPt * 0.035 });
+      }
+      const label = isAgent ? "AGENT" : "APPROVED";
+      const size = rPt * (isAgent ? 0.3 : 0.26);
+      const tw = bold.widthOfTextAtSize(label, size);
+      pg.drawText(label, { x: pcx - tw / 2, y: pcy - size / 2.7, size, font: bold, color: acol, rotate: chipRot });
+    }
     text(`${sh.label} \xB7 marked set`, 14, 20, 8, muted);
   }
   const allPages = doc.getPages();
@@ -5588,6 +6015,26 @@ function registerTools(server, session) {
     },
     outputSchema: placeCountOutput
   }, run("place_count", (a) => session.placeCount(a.sheet, a.points, { condition: a.condition })));
+  server.registerTool("symbol_sweep", {
+    description: `Find EVERY instance of a repeated plan symbol from ONE example \u2014 drains, thresholds, fixtures, transition markers: marquee a tight seed_rect around a single instance and the sheet's vector linework is searched for every other placement of that same segment cluster. Deterministic geometry, not vision: each placement scores as the length-weighted fraction of the seed's segments reproduced within tolerance_px, under translation plus 0/90/180/270 rotation and mirroring (symbols rotate on plans \u2014 both ON by default; turn them off to pin orientation). Score \u2265 0.92 is a match; the 0.75\u20130.92 band comes back in \`withheld\` with a reason \u2014 a near-match is a question you answer by LOOKING (view_sheet at its \`at\`), never a silent commit and never a silent drop. The seed's own location is reported in \`seed\` and never double-committed. Work is capped and the cap is disclosed: a reply with candidates.dropped > 0 says exactly that some placements were never scored \u2014 tighten the seed rect around more distinctive geometry rather than trusting a truncated count. Marquee discipline: the rect must hug ONE instance \u2014 only segments FULLY inside it define the symbol, so a loose rect that swallows wall linework fingerprints the wall, not the symbol. commit: true (requires condition) commits every match center as an EA count marker through the same path as place_count \u2014 the whole sweep is ONE undo step, each marker carries origin.method "symbol_sweep" with its score and transform, and withheld placements are NEVER committed. No scale needed: EA is scale-free. After any batch commit, LOOK at what landed \u2014 view_sheet {overlay: true} over the swept area \u2014 and audit the markers against the drawing before trusting the EA total. ${COORDS}`,
+    inputSchema: {
+      sheet: z2.string(),
+      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)"),
+      rotations: z2.boolean().default(true).describe("Also match 90/180/270-rotated placements"),
+      mirror: z2.boolean().default(true).describe("Also match mirrored placements"),
+      tolerance_px: z2.number().positive().max(20).default(2).describe("Endpoint match tolerance in image px (default 2 \u2014 CAD jitter, not drift)")
+    },
+    outputSchema: symbolSweepOutput
+  }, run("symbol_sweep", (a) => session.symbolSweep(a.sheet, {
+    seedRect: a.seed_rect,
+    condition: a.condition,
+    commit: a.commit,
+    rotations: a.rotations,
+    mirror: a.mirror,
+    tolerancePx: a.tolerance_px
+  })));
   server.registerTool("derive_base", {
     description: `Mint the wall base from committed rooms (#148) \u2014 the estimator's most mechanical derivation: base LF = room perimeter \u2212 stated door openings. For every floor_area shape of source_condition, commits ONE linear shape under condition (e.g. 'RB-1') tracing that room's boundary, quantified NET of the openings you state per room. The openings are YOUR claim to make \u2014 look at the doors with view_sheet, state {shape_id, lf} per room (repeat a shape_id to stack openings); the tool never guesses, and your claim is recorded on origin.derived (from_shape_id, gross_lf, openings_lf). All-or-nothing: an unknown shape_id, a negative lf, or openings meeting a room's whole perimeter refuses the call before anything commits. The whole derivation is ONE undo step. Deriving onto the source condition is refused \u2014 base lands on its own tag.`,
     inputSchema: {
@@ -5785,21 +6232,21 @@ function registerTools(server, session) {
     return reply;
   });
   server.registerTool("annotate", {
-    description: `Place an annotation on a sheet \u2014 a note ABOUT the work, never a measurement of it. Types: cloud and highlight take rect:[[x0,y0],[x1,y1]] (a revision cloud around an area, a highlight box over it), text takes at:[x,y], callout takes at:[x,y] plus target:[x,y] (the point its leader aims at), arrow takes from:[x,y] and to:[x,y] (tail and head \u2014 plank/seam direction, the markup flooring drawings use most; #150), bubble takes at:[x,y] plus optional r (a keynote/detail circle carrying centered text). 
+    description: `Place an annotation on a sheet \u2014 a note ABOUT the work, never a measurement of it. Types: cloud and highlight take rect:[[x0,y0],[x1,y1]] (a revision cloud around an area, a highlight box over it), text takes at:[x,y], callout takes at:[x,y] plus target:[x,y] (the point its leader aims at), arrow takes from:[x,y] and to:[x,y] (tail and head \u2014 plank/seam direction, the markup flooring drawings use most; #150), bubble takes at:[x,y] plus optional r (a keynote/detail circle carrying centered text), dimension takes from:[x,y] and to:[x,y] (its two measured endpoints) and labels itself with the length between them at the sheet's scale \u2014 drawn as a dimension line with end ticks and the measurement centered. A dimension states a REAL length, so it is the one annotation the scale gate applies to: on an unscaled sheet it refuses exactly like the measure tools (set_scale first) rather than dressing a px figure up as feet. It still touches no quantity \u2014 a dimension is a note about a distance, not a takeoff line item.
 
 Pass condition to attach the note to a finish tag, which is what makes it part of that SCOPE rather than a floating remark: it then wears the condition's colour on the canvas and in the marked-set PDF, and travels with it into the report. The tag is minted on first touch like one_click/measure_polygon, so you can annotate CPT-1 before anything is traced for it. Omit condition for a note about the sheet itself. 
 
 No review gate: the pencil-not-ink rule exists to stop an agent inventing geometry, and a cloud reading "verify substrate" is not geometry. It touches no quantity. ${COORDS}`,
     inputSchema: {
       sheet: z2.string().describe("Sheet name or number, as sheet_info reports it"),
-      type: z2.enum(["cloud", "text", "callout", "highlight", "arrow", "bubble"]).describe("cloud/highlight need rect; text/callout/bubble need at; callout also needs target; arrow needs from + to"),
-      text: z2.string().default("").describe("The note. A cloud with no text still reads as 'look here'; a bubble's text draws centered in the circle"),
+      type: z2.enum(["cloud", "text", "callout", "highlight", "arrow", "bubble", "dimension"]).describe("cloud/highlight need rect; text/callout/bubble need at; callout also needs target; arrow and dimension need from + to"),
+      text: z2.string().default("").describe("The note. A cloud with no text still reads as 'look here'; a bubble's text draws centered in the circle; a dimension appends it after the measured length"),
       condition: z2.string().optional().describe("Finish tag to attach this note to, e.g. 'CPT-1' (minted on first use). Omit for an unattached sheet note"),
       at: pointSchema.optional().describe("Anchor point (image px) \u2014 text, callout, and bubble (the circle's center)"),
       target: pointSchema.optional().describe("What a callout's leader line points at (image px)"),
       rect: z2.tuple([pointSchema, pointSchema]).optional().describe("Corners (image px) \u2014 cloud and highlight"),
-      from: pointSchema.optional().describe("Arrow tail (image px)"),
-      to: pointSchema.optional().describe("Arrow head \u2014 what it points at (image px)"),
+      from: pointSchema.optional().describe("Arrow tail / dimension start (image px)"),
+      to: pointSchema.optional().describe("Arrow head / dimension end (image px)"),
       r: z2.number().positive().optional().describe("Bubble radius (image px); omitted \u2192 the canvas default (2% of sheet width)")
     },
     outputSchema: annotateOutput
@@ -5901,7 +6348,7 @@ function registerResources(server, session) {
 // package.json
 var package_default = {
   name: "opentakeoff-mcp",
-  version: "0.9.19",
+  version: "0.9.20",
   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.19",
+  "version": "0.9.20",
   "mcpName": "io.github.Kentucky-ai/opentakeoff",
   "type": "module",
   "description": "OpenTakeoff MCP server — drive the takeoff engine from your MCP client over stdio.",