opentakeoff-mcp 0.9.18 → 0.9.20

package/README.md

@@ -109,12 +109,13 @@ includes document text, shape vertices, or result payload content.
 | `sheet_info` | One sheet's dims, vector segment count, scale status, detected suggestion, committed shape count. |
 | `set_scale` | Set a sheet's scale — exactly one of `label`, `upp`, `calibrate {p1, p2, feet}`, `use_detected`. |
 | `one_click` | One-Click Area at (x, y): flood fill bounded by the plan linework, traced, vertices snapped. Pass `condition` to commit; `role: "deduct"` subtracts. |
-| `detect_rooms` | Batch One-Click: reads every room-number label off the sheet's text layer and floods each — one call instead of `read_sheet_text` + reasoning + N `one_click` calls. Only cleanly-traced rooms come back; everything skipped is counted and reasoned in `withheld` (degenerate / duplicate / implausible), never dropped silently. Pass `condition` to commit every detected room. |
+| `detect_rooms` | Batch One-Click: reads every room-number label off the sheet's text layer and floods each — one call instead of `read_sheet_text` + reasoning + N `one_click` calls. Only cleanly-traced rooms come back; everything skipped is counted and reasoned in `withheld` (degenerate / duplicate / implausible / unresolved), never dropped silently. To commit: `assign_from_schedule: true` routes each room through its OWN room-finish schedule row and commits under the FLOOR finish that row states (rooms the schedule can't answer for return in `unresolved[]` with reasons and re-seedable coordinates); or pass `condition` to commit every room under one stated tag. |
 | `measure_polygon` | Area + perimeter of a polygon you supply (min 3 verts). Requires scale. |
 | `measure_line` | Length of an open polyline (min 2 points). Requires scale. |
 | `derive_base` | **Base LF from committed rooms**: for every floor shape of a source condition, commits a linear base run tracing that room's boundary, quantified net of the door openings YOU state per room (`{shape_id, lf}` — your claim, recorded on `origin.derived`; the tool never guesses). All-or-nothing; one undo step. |
 | `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. |
@@ -123,10 +124,10 @@ includes document text, shape vertices, or result payload content.
 | `edit_condition` | Set a condition's **waste %**, **×N multiplier**, **height_ft** (the H knob `measure_surface` quantifies against), and **roll_setup** (the roll-goods opt-in: seams figured, cuts packed, the reply echoes the order — cuts, `order_lf`, rolls, `order_qty` — and `export_report`'s `roll_goods` block carries the same rows; `null` opts out) — the knobs that turn measured quantities into order quantities. Resolves an **existing** finish tag or errors — a typo must not mint an empty condition. No review gate; one `undo_last` step restores the knobs verbatim. |
 | `export_report` | The **computed Report document** — `opentakeoff.report.v1`, the same JSON the canvas Report exports: gross + waste-adjusted quantities, the computed materials **buy list** per condition plus the project-wide roll-up, per-sheet base subtotals, and scale provenance. The contract for pricing consumers — `export_takeoff` carries materials as config rows, `takeoff_summary` strips them. Inline, and to disk with `path`. |
 | `import_takeoff` | **The way back in**: load a `takeoff_canvas.v1` file (a prior `export_takeoff`, or the app's own save) through the SAME merge rules as the app's Sheet-menu import — finish-tag identity joins conditions (this session's knobs win), new ids append, duplicates skip (idempotent re-import), this session's calibration wins per sheet. Resume, extend, or audit. |
-| `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. 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, and review state 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. |
+| `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 || {};
@@ -2292,6 +2536,12 @@ var Session = class _Session {
   conditions = [];
   markups = [];
   shapes = [];
+  /** The last assign-from-schedule run's unresolved rooms (0.9.18) — what the
+   * marked-set cover discloses as withheld. Replaced per assign run, cleared
+   * with the rest of the session on a non-merge load_plan. Seeds ride
+   * normalized so the export-time staleness drop can test them against
+   * committed rings in verts_norm space. */
+  scheduleWithheld = [];
   /** Newest-last. Capped at UNDO_CAP; the oldest entry falls off the front. */
   journal = [];
   seq = 0;
@@ -2331,6 +2581,7 @@ var Session = class _Session {
       this.file = null;
       this.filePath = null;
       this.nextOrd = 1;
+      this.scheduleWithheld = [];
       this.journal = [];
       this.pendingCommits = [];
     } else if (this.docs.has(base)) {
@@ -2734,6 +2985,7 @@ var Session = class _Session {
     return c;
   }
   commit(s, tag, role, vertsPx, computed, origin) {
+    if (origin?.actor === "agent" && !origin.assignment) origin = { ...origin, assignment: { source: "asserted" } };
     const c = this.conditionFor(tag);
     const shape = {
       id: uid("shp"),
@@ -2830,6 +3082,16 @@ var Session = class _Session {
    *       judge and nothing commits anyway. */
   async detectRooms(name, opts) {
     const s = this.sheet(name);
+    const assign = !!opts.assignFromSchedule;
+    let graph = null;
+    if (assign) {
+      if (s.upp == null) throw new UserError(this.scaleGate(s));
+      graph = await this.ensureGraph();
+      if (!graph.available) throw new UserError("This set has no text layer (a scan) \u2014 the sheet graph is unavailable, not empty.");
+      if (!graph.tables.some((t) => t.kind === "room-finish")) {
+        throw new UserError("No room-finish schedule in the working set \u2014 load_plan the schedule sheet with merge: true, or pass condition to commit every room under one tag.");
+      }
+    }
     const mask = await this.maskWithLayers(name, opts.layers);
     if (!mask) throw new UserError("This sheet has no vector linework (likely a scan); raster fallback not yet available in the MCP server.");
     const minAreaSf = opts.minAreaSf ?? 5;
@@ -2839,7 +3101,8 @@ var Session = class _Session {
       const num2 = (sp.str || "").trim().split(/\s+/).find((tok) => ROOM_LABEL_RE.test(tok));
       if (num2) labels.push({ str: num2, bbox: sp });
     }
-    const withheld = { degenerate: 0, duplicate: 0, bubble: 0, implausible: 0 };
+    const withheld = { degenerate: 0, duplicate: 0, bubble: 0, implausible: 0, unresolved: 0 };
+    const unresolved = [];
     const byRing = /* @__PURE__ */ new Map();
     const order = [];
     for (const lb of labels) {
@@ -2907,21 +3170,42 @@ var Session = class _Session {
         return null;
       }
       const perimeter_lf = round2(c.perimPx * upp);
+      let tag = opts.condition;
+      let assignment;
+      if (assign) {
+        const hit = this.floorTagFor(graph, c.label);
+        if ("reason" in hit) {
+          withheld.unresolved++;
+          unresolved.push({ label: c.label, reason: hit.reason, area_sf, perimeter_lf, seed: [round1(c.seed[0]), round1(c.seed[1])] });
+          return null;
+        }
+        tag = hit.tag;
+        assignment = { source: "schedule", room_tag: c.label, surface: "FLOOR", schedule_sheet: hit.sheet };
+      }
       let shape_id;
-      if (opts.condition) {
-        shape_id = this.commit(s, opts.condition, opts.role, c.ring, { area_sf, perimeter_lf }, {
+      if (tag) {
+        shape_id = this.commit(s, tag, opts.role, c.ring, { area_sf, perimeter_lf }, {
           method: "one_click_v1",
           actor: "agent",
           seed_norm: [c.seed[0] / s.widthPx, c.seed[1] / s.heightPx],
           reviewed: false,
           ...c.hatch ? { hatch_filtered: true } : {},
-          ...c.gap ? { gap_bridged_px: c.gap } : {}
+          ...c.gap ? { gap_bridged_px: c.gap } : {},
+          ...assignment ? { assignment } : {}
         }).id;
       }
-      return { ...common, area_sf, perimeter_lf, ...shape_id ? { shape_id } : {} };
+      return { ...common, area_sf, perimeter_lf, ...shape_id ? { shape_id, condition: tag } : {} };
     }).filter((r) => r !== null);
     this.flushCommits("detect_rooms");
-    const withheldTotal = withheld.degenerate + withheld.duplicate + withheld.bubble + withheld.implausible;
+    if (assign) {
+      this.scheduleWithheld = unresolved.map((u) => ({
+        sheet_id: s.key,
+        label: u.label,
+        reason: u.reason,
+        seed_norm: [u.seed[0] / s.widthPx, u.seed[1] / s.heightPx]
+      }));
+    }
+    const withheldTotal = withheld.degenerate + withheld.duplicate + withheld.bubble + withheld.implausible + withheld.unresolved;
     return {
       detected: rooms.length,
       rooms,
@@ -2930,8 +3214,11 @@ var Session = class _Session {
         ...withheld,
         ...upp != null ? { min_area_sf: minAreaSf } : {}
       },
+      // assign mode always states the answer, empty array included: [] is the
+      // positive claim "every detected room resolved against its own row"
+      ...assign ? { unresolved } : {},
       ...s.detected?.multi ? { multiple_scales: true } : {},
-      ...withheldTotal ? { note: `${withheldTotal} seed(s) withheld \u2014 ${withheld.duplicate} duplicate region(s), ${withheld.bubble} label-bubble(s), ${withheld.implausible} under ${minAreaSf} SF, ${withheld.degenerate} untraceable.` } : {},
+      ...withheldTotal ? { note: `${withheldTotal} seed(s) withheld \u2014 ${withheld.duplicate} duplicate region(s), ${withheld.bubble} label-bubble(s), ${withheld.implausible} under ${minAreaSf} SF, ${withheld.degenerate} untraceable${assign ? `, ${withheld.unresolved} unresolved against the schedule (see unresolved[])` : ""}.` } : {},
       ...s.upp == null ? { warning: `No scale set for ${s.key} \u2014 quantities unavailable. Call set_scale${s.detected ? ` (detected: ${s.detected.label})` : ""}.` } : {}
     };
   }
@@ -3047,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
@@ -3085,6 +3456,7 @@ var Session = class _Session {
         ...x.height_ft !== void 0 ? { height_ft: x.height_ft } : {},
         nverts: x.verts_norm.length,
         reviewed: x.origin?.reviewed === true,
+        ...x.origin?.assignment ? { assignment: x.origin.assignment.source } : {},
         ...x.origin?.agent_edits ? { agent_edits: x.origin.agent_edits } : {}
       })),
       count: rows.length
@@ -3164,7 +3536,13 @@ var Session = class _Session {
       verts_norm: vertsPx.map(([x, y]) => [x / s.widthPx, y / s.heightPx]),
       computed,
       ...role === "surface_area" ? { height_ft: Number(cur.height_ft) || heightFor() } : {},
-      ...cur.origin ? { origin: { ...cur.origin, agent_edits: (cur.origin.agent_edits ?? 0) + 1 } } : {}
+      ...cur.origin ? { origin: {
+        ...cur.origin,
+        agent_edits: (cur.origin.agent_edits ?? 0) + 1,
+        // a reassign onto a different tag is the agent choosing the finish —
+        // keeping "schedule" (and its citation) past that point would be a lie
+        ...patch.condition !== void 0 && cur.origin.assignment?.source === "schedule" ? { assignment: { source: "asserted" } } : {}
+      } } : {}
     };
     this.record({ op: "edit", tool: "edit_shape", before });
     const changed = [
@@ -3368,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"),
@@ -3385,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 {
@@ -3395,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."
     };
   }
@@ -3432,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
@@ -3534,6 +3924,24 @@ var Session = class _Session {
       counts: { rooms: g.rooms.length, schedules: g.tables.length, callouts: g.callouts.length }
     };
   }
+  /** The FLOOR finish a room's own schedule row states — assign-from-schedule's
+   * per-room resolver (0.9.18): resolveTag's chain narrowed to the one surface
+   * a floor takeoff commits. Refusal over guessing, per room: an unresolved
+   * tag returns resolveTag's own reason; a resolved row with no FLOOR cell
+   * says so; a compound cell ("CPT-1/VCT-1") is ambiguous — committing the
+   * whole room's SF under a two-finish literal would assert an area split the
+   * schedule never stated. Compound detection is narrow ("/", ",", " OR "),
+   * so a hyphenated code never trips it. BASE/WALL are deliberately ignored:
+   * those are derive_base's and measure_surface's measures. */
+  floorTagFor(g, tag) {
+    const res = resolveTag(g, tag);
+    if (res.status !== "resolved") return { reason: res.reason };
+    const floor = res.finishes.find((f) => f.surface === "FLOOR");
+    const code = floor?.code.trim();
+    if (!floor || !code) return { reason: `schedule row ${res.tag} states no FLOOR finish` };
+    if (/[/,]|\bOR\b/i.test(code)) return { reason: `ambiguous: floor cell "${code}" names more than one finish with no stated split` };
+    return { tag: code, sheet: floor.source.sheet };
+  }
   async resolveRoomTag(tag) {
     if (!tag || !tag.trim()) throw new UserError('Pass a room tag, e.g. resolve_tag { tag: "134" }.');
     const g = await this.ensureGraph();
@@ -3695,6 +4103,7 @@ var detectedRoom = z.object({
   area_sf: z.number().optional().describe("Scaled mode: traced area in SF"),
   perimeter_lf: z.number().optional().describe("Scaled mode: traced perimeter in LF"),
   shape_id: z.string().optional().describe("Scaled mode: id of the committed shape, when condition was passed"),
+  condition: z.string().optional().describe("The finish tag this room committed under \u2014 the passed condition, or in assign mode the FLOOR finish its own schedule row states. Present exactly when shape_id is"),
   area_px2: z.number().optional().describe("Preview mode (no scale): raw area in px\xB2"),
   perimeter_px: z.number().optional().describe("Preview mode (no scale): raw perimeter in px")
 });
@@ -3707,8 +4116,16 @@ var detectRoomsOutput = {
     duplicate: z.number().int().describe("Flooded to a region another label already claimed \u2014 counted once, never twice"),
     bubble: z.number().int().describe("Labels whose every clean flood was their own label BUBBLE (ring bbox \u2248 label bbox \u2014 plans box their room numbers). Scale-free, so it guards unscaled previews too"),
     implausible: z.number().int().describe("Enclosed, clean, non-bubble, but smaller than min_area_sf \u2014 a door swing or wall cavity rather than a room"),
+    unresolved: z.number().int().describe("Assign mode: rooms the schedule could not answer for (no row, no FLOOR cell, or a compound cell) \u2014 withheld into unresolved[], never committed under a guess. Always present; 0 outside assign mode"),
     min_area_sf: z.number().optional().describe("The plausibility floor applied (scaled mode only)")
   }).describe("What detection skipped and why \u2014 a withheld room is a question the caller can ask; a silently dropped one is a hole in a bid"),
+  unresolved: z.array(z.object({
+    label: z.string().describe("The room tag as drawn"),
+    reason: z.string().describe(`WHY the schedule could not answer \u2014 resolveTag's own reason, "states no FLOOR finish", or "ambiguous: \u2026" for a compound cell`),
+    area_sf: z.number().describe("The room's real traced area \u2014 withheld from committing, not from reporting"),
+    perimeter_lf: z.number(),
+    seed: z.tuple([z.number(), z.number()]).describe("The flood seed (image px) \u2014 once the estimator answers, one_click here with the stated condition commits it")
+  })).optional().describe("Assign mode only, empty array included: [] is the positive claim that every detected room resolved against its own schedule row"),
   note: z.string().optional().describe("Human-readable summary of what was withheld, when anything was"),
   multiple_scales: z.literal(true).optional().describe("Several DISTINCT scale notes on this sheet (#153) \u2014 rooms inside an enlarged viewport may be figured at the wrong scale"),
   warning: z.string().optional().describe("Preview mode (no scale): why quantities are unavailable and what to do")
@@ -3734,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(),
@@ -3791,7 +4235,7 @@ var exportTakeoffOutput = {
     measure_role: z.enum(["floor_area", "deduct", "linear", "surface_area", "count"]),
     verts_norm: z.array(point).describe("Vertices normalized to sheet dims (0\u20131)"),
     computed: z.object({ area_sf: z.number().optional(), perimeter_lf: z.number().optional(), count: z.number().optional() }).passthrough().describe("count shapes carry {count} alone; every other role carries area_sf + perimeter_lf"),
-    origin: z.object({}).passthrough().optional().describe("Provenance: method (manual|one_click_v1), actor (omitted=human, 'agent'=MCP/automation), reviewed (human affirmed at an explicit gate), and correction fields (edited, edited_before_create, copied, proposed_verts_norm, edits)")
+    origin: z.object({}).passthrough().optional().describe("Provenance: method (manual|one_click_v1), actor (omitted=human, 'agent'=MCP/automation), reviewed (human affirmed at an explicit gate), assignment (where the finish tag came from \u2014 {source: 'schedule', room_tag, surface, schedule_sheet} when the room's own schedule row decided it, {source: 'asserted'} when the agent chose; stamped on every agent commit), and correction fields (edited, edited_before_create, copied, proposed_verts_norm, edits)")
   }).passthrough()),
   markups: z.array(z.unknown()),
   sheet_group: z.array(z.unknown()),
@@ -3838,6 +4282,7 @@ var listShapesOutput = {
     height_ft: z.number().optional().describe("surface_area shapes \u2014 the height they were quantified at"),
     nverts: z.number().int(),
     reviewed: z.boolean().describe("true = human-affirmed ink, refused by every agent mutation"),
+    assignment: z.enum(["schedule", "asserted"]).optional().describe(`Where the finish tag came from: "schedule" = resolved from the room's own schedule row, "asserted" = the agent chose it. origin.assignment in export_takeoff carries the citation. Absent on human canvas shapes`),
     agent_edits: z.number().int().optional().describe("Present when the agent has revised this shape")
   })),
   count: z.number().int()
@@ -4051,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(),
@@ -4062,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 = {
@@ -4080,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 === ",";
@@ -4735,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, 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;
@@ -4752,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();
@@ -4825,6 +5290,15 @@ async function buildMarkedSetPdf({ projectName, dark, sheets, shapes, markups, r
       }
     }
     draw(`${marked.length} marked sheet${marked.length === 1 ? "" : "s"} \xB7 ${markedShapes.length} takeoff item${markedShapes.length === 1 ? "" : "s"} \xB7 quantities net of deducts, waste-adjusted where noted`, { x: 52, y: metaY, size: 9.5, font, color: muted });
+    if (provenance) {
+      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 });
@@ -4853,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;
@@ -5095,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);
@@ -5131,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();
@@ -5146,6 +5655,20 @@ async function buildMarkedSetPdf({ projectName, dark, sheets, shapes, markups, r
 }
 
 // src/marked.ts
+function assignmentDisclosure(shapes, withheld = []) {
+  const agent = shapes.filter((s) => s.origin?.actor === "agent");
+  const live = withheld.filter((w) => !shapes.some((s) => s.sheet_id === w.sheet_id && (s.measure_role === "floor_area" || s.measure_role === "deduct") && s.verts_norm.length >= 3 && pointInPoly(w.seed_norm[0], w.seed_norm[1], s.verts_norm)));
+  if (!agent.length && !live.length) return null;
+  const schedule = agent.filter((s) => s.origin?.assignment?.source === "schedule").length;
+  const asserted = agent.filter((s) => s.origin?.assignment?.source === "asserted").length;
+  const pending = agent.filter((s) => s.origin?.reviewed !== true).length;
+  const parts = [];
+  if (schedule) parts.push(`${schedule} schedule-resolved`);
+  if (asserted) parts.push(`${asserted} agent-asserted`);
+  if (pending) parts.push(`${pending} pending human review`);
+  if (live.length) parts.push(`${live.length} room${live.length === 1 ? "" : "s"} withheld, unresolved against the schedule`);
+  return parts.length ? `Finish assignment: ${parts.join(" \xB7 ")}` : null;
+}
 var buildMarkedSetPdf2 = buildMarkedSetPdf;
 async function exportMarkedPdf(session, opts) {
   const { file, filePath } = session;
@@ -5199,6 +5722,7 @@ async function exportMarkedPdf(session, opts) {
     getPage,
     loadPdfData,
     credit,
+    provenance: assignmentDisclosure(session.shapes, session.scheduleWithheld),
     coverTitle: "OpenTakeoff \xB7 Marked Set"
   });
   const outPath = path3.resolve(opts.path ?? path3.join(path3.dirname(filePath), `${base} - marked set.pdf`));
@@ -5421,7 +5945,7 @@ function registerTools(server, session) {
     return session.setScale(a.sheet, a);
   }));
   server.registerTool("one_click", {
-    description: `One-Click Area: click inside a room (image px) and the plan's vector linework bounds it \u2014 flood fill, contour trace, vertices snapped to true PDF endpoints. With the sheet's scale set, returns area_sf / perimeter_lf; pass condition (a finish tag, e.g. "CPT-1") to commit the traced shape to the takeoff. Without a scale it returns px-only quantities with a warning and commits nothing. role "deduct" makes the committed shape subtract. ${COORDS}`,
+    description: `One-Click Area: click inside a room (image px) and the plan's vector linework bounds it \u2014 flood fill, contour trace, vertices snapped to true PDF endpoints. With the sheet's scale set, returns area_sf / perimeter_lf; pass condition (a finish tag, e.g. "CPT-1") to commit the traced shape to the takeoff. Without a scale it returns px-only quantities with a warning and commits nothing. role "deduct" makes the committed shape subtract. After committing, LOOK at what landed \u2014 view_sheet {overlay: true} \u2014 and fix an overshot ring with edit_shape before trusting any total. ${COORDS}`,
     inputSchema: {
       sheet: z2.string(),
       x: z2.number(),
@@ -5435,10 +5959,11 @@ function registerTools(server, session) {
     outputSchema: oneClickOutput
   }, run("one_click", (a) => session.oneClick(a.sheet, a.x, a.y, { condition: a.condition, role: a.role, returnVerts: a.return_verts, sensitivity: a.sensitivity, layers: a.layers })));
   server.registerTool("detect_rooms", {
-    description: `Batch room detection: reads every room-number label off the sheet's text layer (e.g. "134", "OFFICE 101") and runs One-Click at each \u2014 one call instead of read_sheet_text + reasoning + N one_click calls. A seed is only reported as a room once it survives three gates, and everything skipped is counted and reasoned in \`withheld\` \u2014 never dropped silently, because a room the tool tells you it skipped is a question you can ask, while one it hides is a hole in a bid. The gates: a flood that leaked or landed in dense linework never becomes a region; two labels flooding the SAME region commit once (the extra labels ride on \`merged_labels\` \u2014 double-counting an area is the worst failure an estimating tool has); and a flood that is enclosed and clean but smaller than min_area_sf is a room-number bubble, a door swing, or a wall cavity rather than a room. With the sheet's scale set, returns area_sf/perimeter_lf per room; pass condition to commit every detected room under that finish tag (role "deduct" makes them subtract). Without a scale, returns px-only quantities per room and commits nothing \u2014 the plausibility floor needs real units, so it only applies once a scale is set. ${COORDS}`,
+    description: `Batch room detection: reads every room-number label off the sheet's text layer (e.g. "134", "OFFICE 101") and runs One-Click at each \u2014 one call instead of read_sheet_text + reasoning + N one_click calls. A seed is only reported as a room once it survives three gates, and everything skipped is counted and reasoned in \`withheld\` \u2014 never dropped silently, because a room the tool tells you it skipped is a question you can ask, while one it hides is a hole in a bid. The gates: a flood that leaked or landed in dense linework never becomes a region; two labels flooding the SAME region commit once (the extra labels ride on \`merged_labels\` \u2014 double-counting an area is the worst failure an estimating tool has); and a flood that is enclosed and clean but smaller than min_area_sf is a room-number bubble, a door swing, or a wall cavity rather than a room. With the sheet's scale set, returns area_sf/perimeter_lf per room. TO COMMIT, choose the honest source of the finish tag: assign_from_schedule: true routes every room through its OWN room-finish schedule row and commits each under the FLOOR finish that row states \u2014 when a schedule exists in the set, THIS is the default move, because one agent-chosen tag across N rooms flattens real finish variety into a wrong bid; condition commits every room under that one stated tag (only right when the rooms genuinely share it; role "deduct" makes them subtract). Without a scale, returns px-only quantities per room and commits nothing \u2014 the plausibility floor needs real units, so it only applies once a scale is set. A batch commit is NOT finished until you have LOOKED at it: view_sheet {overlay: true}, audit every ring against the walls, fix misses with edit_shape / delete_shape \u2014 before the totals mean anything. ${COORDS}`,
     inputSchema: {
       sheet: z2.string(),
-      condition: z2.string().optional().describe("Finish tag to commit every detected room under (minted on first use)"),
+      condition: z2.string().optional().describe("Finish tag to commit every detected room under (minted on first use). Mutually exclusive with assign_from_schedule"),
+      assign_from_schedule: z2.boolean().default(false).describe(`Commit each room under the FLOOR finish its OWN room-finish schedule row states (resolve_tag's chain, per room): the citation rides origin.assignment, and rooms the schedule cannot answer for \u2014 no row, no FLOOR cell, a compound cell like "CPT-1/VCT-1" \u2014 are returned in unresolved[] with reasons and seeds instead of committed under a guess. Needs the sheet's scale and a room-finish schedule in the working set (merge the schedule sheet in with load_plan first). Mutually exclusive with condition`),
       role: roleSchema,
       return_verts: z2.boolean().default(false).describe("Include each traced polygon's vertices (image px)"),
       min_area_sf: z2.number().positive().default(5).describe("Plausibility floor: enclosed non-bubble regions smaller than this are withheld as cavities, not rooms. Default 5 SF \u2014 below any real finished space (a broom closet is ~10 SF). Lower it to inspect what was skipped."),
@@ -5446,7 +5971,12 @@ function registerTools(server, session) {
       layers: layersFilterSchema
     },
     outputSchema: detectRoomsOutput
-  }, run("detect_rooms", (a) => session.detectRooms(a.sheet, { condition: a.condition, role: a.role, returnVerts: a.return_verts, minAreaSf: a.min_area_sf, sensitivity: a.sensitivity, layers: a.layers })));
+  }, run("detect_rooms", (a) => {
+    if (a.assign_from_schedule && a.condition !== void 0) {
+      throw new UserError("Provide at most one of: condition (every room under one stated tag) or assign_from_schedule (each room's own schedule row decides).");
+    }
+    return session.detectRooms(a.sheet, { condition: a.condition, role: a.role, returnVerts: a.return_verts, minAreaSf: a.min_area_sf, sensitivity: a.sensitivity, layers: a.layers, assignFromSchedule: a.assign_from_schedule });
+  }));
   server.registerTool("measure_polygon", {
     description: `Measure a closed polygon you supply (min 3 vertices, image px): area_sf and perimeter_lf at the sheet's scale. Requires the scale to be set. Pass condition to commit it; role "deduct" subtracts. ${COORDS}`,
     inputSchema: {
@@ -5485,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: {
@@ -5661,7 +6211,7 @@ function registerTools(server, session) {
     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: full-sheet overview first, then tight crops at higher px until dimension strings and room labels read cleanly. 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". 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"),
@@ -5682,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
@@ -5798,7 +6348,7 @@ function registerResources(server, session) {
 // package.json
 var package_default = {
   name: "opentakeoff-mcp",
-  version: "0.9.18",
+  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.",
@@ -5875,8 +6425,8 @@ function buildServer(session = new Session()) {
       "OpenTakeoff: quantity takeoff on construction plan PDFs.",
       "A takeoff's deliverable is the marked-up planset, not a numbers report. Standard finish for ANY takeoff:",
       "1. load_plan, then set_scale on each sheet you measure (quantities are px-only until the scale is set).",
-      "2. Commit shapes under finish-tag conditions (one_click / detect_rooms / measure_polygon / measure_line with `condition`).",
-      "3. LOOK at what landed with view_sheet overlay:true and fix misses with edit_shape before trusting totals.",
+      "2. Commit shapes under finish-tag conditions (one_click / detect_rooms / measure_polygon / measure_line with `condition`; when the set carries a room-finish schedule, prefer detect_rooms assign_from_schedule so each room commits under its OWN row).",
+      "3. LOOK at what landed with view_sheet overlay:true and fix misses with edit_shape before trusting totals \u2014 crop the work region tight (full-sheet renders downsample too far to audit a ring).",
       "4. Finish by writing the marked-up planset with export_marked_pdf and give the user its file path, alongside export_report for the numbers. Never end a takeoff with numbers alone."
     ].join("\n")
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opentakeoff-mcp",
-  "version": "0.9.18",
+  "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.",