opentakeoff-mcp 0.9.8 → 0.9.12

package/README.md

@@ -112,14 +112,17 @@ includes document text, shape vertices, or result payload content.
 | `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. |
 | `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. |
+| `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. |
 | `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. |
 | `edit_shape` | **Revise** a committed shape instead of redoing it: new `verts`, a different `condition`, a different `role`, or any combination — quantities recomputed from the result. Refuses shapes a human affirmed. |
 | `edit_materials` | Add/remove/patch supporting-materials rows on a condition — the coverage-rate lines (adhesive at N sf/gal, grout at N lf/bag, …) that turn a measured quantity into an order quantity, matching the canvas's Supporting Materials panel. `condition` mints on first touch, like `one_click`/`measure_polygon`. No review gate (materials rows are quantity config, not traced geometry) — edits directly, reversible with `undo_last`. |
-| `edit_condition` | Set a condition's **waste %** and **×N multiplier** — the knobs that turn measured quantities into order quantities (`takeoff_summary`'s `*_net`); without them an agent takeoff always ships net === gross. Resolves an **existing** finish tag or errors — a typo must not mint an empty condition. No review gate; one `undo_last` step restores both knobs verbatim. |
+| `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`. |
 | `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. |
 | `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. |
 | `read_sheet_text` | Positioned page text (image px), optionally restricted to a region — title blocks, room labels, finish schedules. |
 | `find_text` | **Locate** a known string — the complement to `read_sheet_text` (which returns what a region *says*; this finds *where* a string sits). Case-insensitive substring match per pdf.js text run; each hit's center feeds straight into `one_click`'s seed. |

package/dist/server-core.js

@@ -1675,6 +1675,440 @@ function reportJson({ projectName = "", rows = [], bySheet = [], scaleInfo = [],
   };
 }
 
+// ../web/src/lib/rollgoods.js
+var ROLL_FLOORING_TYPES = ["carpet", "sheet_vinyl", "rubber"];
+function isRollType(ft) {
+  return ROLL_FLOORING_TYPES.includes(ft);
+}
+function defaultRollSetup(ft) {
+  return { roll_width_ft: 12, roll_length_ft: 0, seam_allowance_in: 2, wall_overage_in: 3, doorway_overage_in: 1, direction: "auto", price_unit: ft === "carpet" ? "sy" : "sf" };
+}
+function rollQtyForUnit(orderFt, rollWidthFt, unit) {
+  const w = rollWidthFt || 12;
+  if (unit === "lf") return orderFt;
+  if (unit === "sf") return orderFt * w;
+  return orderFt * w / 9;
+}
+function laneCapacityIn(n, i, rollWidthIn, seamIn, wallIn) {
+  if (n === 1) return rollWidthIn - 2 * wallIn;
+  const isEdge = i === 0 || i === n - 1;
+  return isEdge ? rollWidthIn - seamIn - wallIn : rollWidthIn - 2 * seamIn;
+}
+function totalCapacityIn(n, rollWidthIn, seamIn, wallIn) {
+  let sum = 0;
+  for (let i = 0; i < n; i++) sum += laneCapacityIn(n, i, rollWidthIn, seamIn, wallIn);
+  return sum;
+}
+function computeLaneCount(widthIn, rollWidthIn, seamIn, wallIn) {
+  for (let n = 1; n <= 40; n++) if (totalCapacityIn(n, rollWidthIn, seamIn, wallIn) >= widthIn - 1e-6) return n;
+  return 40;
+}
+function scanlineCrossings(ring, laneAxis, runAxis, v) {
+  const n = ring.length, vals = [];
+  for (let i = 0; i < n; i++) {
+    const a = ring[i], b = ring[(i + 1) % n];
+    const av = a[laneAxis], bv = b[laneAxis];
+    if (av <= v && bv > v || bv <= v && av > v) {
+      const t = (v - av) / (bv - av);
+      vals.push({ val: a[runAxis] + t * (b[runAxis] - a[runAxis]), edgeIndex: i });
+    }
+  }
+  vals.sort((p, q) => p.val - q.val);
+  return vals;
+}
+function laneSampleAxisValues(ring, laneAxis, lo, hi) {
+  const eps = 1e-6;
+  const vs = [Math.min(lo + eps, hi), Math.max(hi - eps, lo)];
+  ring.forEach((p) => {
+    if (p[laneAxis] > lo + eps && p[laneAxis] < hi - eps) vs.push(p[laneAxis]);
+  });
+  return vs;
+}
+function computeLaneRunExtent(ring, laneAxis, lo, hi) {
+  const runAxis = laneAxis === "x" ? "y" : "x";
+  const samples = laneSampleAxisValues(ring, laneAxis, lo, hi);
+  let best = null, bestMax = null;
+  samples.forEach((v) => {
+    const crossings = scanlineCrossings(ring, laneAxis, runAxis, v);
+    if (!crossings.length) return;
+    const first = crossings[0], last = crossings[crossings.length - 1];
+    if (!best || first.val < best.val) best = first;
+    if (!bestMax || last.val > bestMax.val) bestMax = last;
+  });
+  if (!best) return null;
+  return { min: best.val, minEdgeIndex: best.edgeIndex, max: bestMax.val, maxEdgeIndex: bestMax.edgeIndex };
+}
+function layoutRingStrips(item, direction, config) {
+  const ring = item.ring;
+  if (!ring || ring.length < 3) return [];
+  const laneAxis = direction === "ns" ? "x" : "y";
+  let lo = Infinity, hi = -Infinity;
+  ring.forEach((p) => {
+    lo = Math.min(lo, p[laneAxis]);
+    hi = Math.max(hi, p[laneAxis]);
+  });
+  const widthFt = hi - lo;
+  if (!(widthFt > 0)) return [];
+  const rollWidthIn = config.rollWidthFt * 12;
+  const n = computeLaneCount(widthFt * 12, rollWidthIn, config.seamAllowanceIn, config.wallOverageIn);
+  const laneWidthsFt = [];
+  let remaining = widthFt;
+  for (let i = 0; i < n; i++) {
+    const capFt = laneCapacityIn(n, i, rollWidthIn, config.seamAllowanceIn, config.wallOverageIn) / 12;
+    const w = i === n - 1 ? Math.max(0, remaining) : Math.min(capFt, remaining);
+    laneWidthsFt.push(w);
+    remaining -= w;
+  }
+  const hasDoor = item.hasDoorAtEdge || (() => false);
+  const wallOverageFt = config.wallOverageIn / 12;
+  const seamFt = config.seamAllowanceIn / 12;
+  const doorwayOverageFt = (config.doorwayOverageIn != null ? config.doorwayOverageIn : config.wallOverageIn) / 12;
+  let lowSideDoor = false, highSideDoor = false;
+  for (let e = 0; e < ring.length; e++) {
+    const A = ring[e], B = ring[(e + 1) % ring.length];
+    if (Math.abs(A[laneAxis] - lo) < 1e-6 && Math.abs(B[laneAxis] - lo) < 1e-6 && hasDoor(e)) lowSideDoor = true;
+    if (Math.abs(A[laneAxis] - hi) < 1e-6 && Math.abs(B[laneAxis] - hi) < 1e-6 && hasDoor(e)) highSideDoor = true;
+  }
+  const strips = [];
+  let cursor = lo;
+  for (let i = 0; i < n; i++) {
+    const laneLo = cursor, laneHi = cursor + laneWidthsFt[i];
+    cursor = laneHi;
+    const ext = computeLaneRunExtent(ring, laneAxis, laneLo, laneHi);
+    if (!ext) continue;
+    const minDoor = hasDoor(ext.minEdgeIndex), maxDoor = hasDoor(ext.maxEdgeIndex);
+    const minOverageFt = wallOverageFt + (minDoor ? doorwayOverageFt : 0);
+    const maxOverageFt = wallOverageFt + (maxDoor ? doorwayOverageFt : 0);
+    const runMin = ext.min - minOverageFt, runMax = ext.max + maxOverageFt;
+    const laneLowDoor = i === 0 && lowSideDoor;
+    const laneHighDoor = i === n - 1 && highSideDoor;
+    const lowExpand = (i === 0 ? wallOverageFt : seamFt) + (laneLowDoor ? doorwayOverageFt : 0);
+    const highExpand = (i === n - 1 ? wallOverageFt : seamFt) + (laneHighDoor ? doorwayOverageFt : 0);
+    strips.push({
+      // STABLE id (srcId + lane) so manual per-cut overrides can be re-associated
+      // across recomputes; unique within a layout since srcId is unique per item.
+      id: `${item.id}:${i}`,
+      srcId: item.id,
+      label: item.name || "",
+      laneIndex: i,
+      laneCount: n,
+      laneAxis,
+      laneMin: laneLo - lowExpand,
+      laneMax: laneHi + highExpand,
+      // physical piece width (incl. seam/wall/door)
+      coverMin: laneLo,
+      coverMax: laneHi,
+      // room-coverage slab (no allowances)
+      runMin,
+      runMax,
+      autoRunMin: runMin,
+      autoRunMax: runMax,
+      minOverageFt,
+      maxOverageFt,
+      minDoor,
+      maxDoor,
+      laneLowDoor,
+      laneHighDoor,
+      doorwayOverageFt,
+      seamFt,
+      rollWidthFt: config.rollWidthFt
+    });
+  }
+  return strips;
+}
+function sumStripLengthsFt(strips) {
+  return strips.reduce((s, st) => s + Math.max(0, st.runMax - st.runMin), 0);
+}
+function assignDefaultCutPositions(strips, rollWidthFt, seqById, rollLenFt = 0) {
+  const EPS = 1e-6;
+  const L = rollLenFt > 0 ? rollLenFt : Infinity;
+  const laneW = (s) => s.laneMax - s.laneMin;
+  const lenX = (s) => Math.max(0, s.runMax - s.runMin);
+  const makeRoll = () => ({ sky: [{ y: 0, width: rollWidthFt, x: 0 }] });
+  function findSpot(roll, lw, cutLen) {
+    const sky = roll.sky;
+    let best = null;
+    for (let i = 0; i < sky.length; i++) {
+      const y = sky[i].y;
+      if (y + lw > rollWidthFt + EPS) continue;
+      let spanned = 0, x = 0, j = i;
+      while (j < sky.length && spanned < lw - EPS) {
+        x = Math.max(x, sky[j].x);
+        spanned += sky[j].width;
+        j++;
+      }
+      if (spanned < lw - EPS) continue;
+      if (x + cutLen > L + EPS) continue;
+      if (!best || x < best.x - EPS || Math.abs(x - best.x) < EPS && y < best.y) best = { x, y };
+    }
+    return best;
+  }
+  function raise(roll, y, lw, newX) {
+    const spanEnd = y + lw, out = [];
+    let placed = false;
+    roll.sky.forEach((seg) => {
+      const segEnd = seg.y + seg.width;
+      if (segEnd <= y + EPS || seg.y >= spanEnd - EPS) {
+        out.push(seg);
+        return;
+      }
+      if (seg.y < y - EPS) out.push({ y: seg.y, width: y - seg.y, x: seg.x });
+      if (!placed) {
+        out.push({ y, width: lw, x: newX });
+        placed = true;
+      }
+      if (segEnd > spanEnd + EPS) out.push({ y: spanEnd, width: segEnd - spanEnd, x: seg.x });
+    });
+    if (!placed) out.push({ y, width: lw, x: newX });
+    const merged = [];
+    out.sort((a, b) => a.y - b.y).forEach((nn) => {
+      const last = merged[merged.length - 1];
+      if (last && Math.abs(last.x - nn.x) < EPS) last.width += nn.width;
+      else merged.push(nn);
+    });
+    roll.sky = merged;
+  }
+  const order = strips.slice().sort((a, b) => {
+    if (seqById) {
+      const sa = seqById[a.id], sb = seqById[b.id];
+      const ha = Number.isFinite(sa), hb = Number.isFinite(sb);
+      if (ha && hb && sa !== sb) return sa - sb;
+      if (ha !== hb) return ha ? -1 : 1;
+    }
+    const dw = laneW(b) - laneW(a);
+    if (Math.abs(dw) > EPS) return dw;
+    return lenX(b) - lenX(a);
+  });
+  const rolls = [makeRoll()];
+  order.forEach((s) => {
+    const lw = laneW(s), Lc = lenX(s);
+    let idx = -1, spot = null;
+    for (let k = 0; k < rolls.length; k++) {
+      const sp = findSpot(rolls[k], lw, Lc);
+      if (sp) {
+        idx = k;
+        spot = sp;
+        break;
+      }
+    }
+    if (idx < 0) {
+      idx = rolls.length;
+      rolls.push(makeRoll());
+      spot = findSpot(rolls[idx], lw, Lc);
+      if (!spot) {
+        spot = { x: 0, y: Math.max(0, (rollWidthFt - lw) / 2) };
+        s.overRoll = Number.isFinite(L) && Lc > L + EPS;
+      } else s.overRoll = false;
+    } else s.overRoll = false;
+    const baseX = Number.isFinite(L) ? idx * rollLenFt : 0;
+    s.cutX = baseX + spot.x;
+    s.cutY = spot.y;
+    s.autoCutX = s.cutX;
+    s.autoCutY = s.cutY;
+    s.rollIndex = idx;
+    raise(rolls[idx], spot.y, lw, spot.x + Lc);
+  });
+  return strips;
+}
+function rollLayoutRollCount(strips) {
+  return (strips || []).reduce((m, s) => Math.max(m, (s.rollIndex || 0) + 1), 0);
+}
+function rollLayoutOrderLengthFt(strips) {
+  return strips.reduce((m, s) => Math.max(m, (s.cutX || 0) + Math.max(0, s.runMax - s.runMin)), 0);
+}
+function roundUpToInch(ft) {
+  return Math.ceil(ft * 12 - 1e-6) / 12;
+}
+function applyStripOverrides(strips, overrides) {
+  if (!overrides) return;
+  strips.forEach((s) => {
+    const o = overrides[s.id];
+    if (o && o.laneCount === s.laneCount && Number.isFinite(o.runMin) && Number.isFinite(o.runMax) && o.runMax > o.runMin) {
+      s.runMin = o.runMin;
+      s.runMax = o.runMax;
+    }
+  });
+}
+function seqFromOverrides(strips, overrides) {
+  if (!overrides) return null;
+  const m = {};
+  let any = false;
+  strips.forEach((s) => {
+    const o = overrides[s.id];
+    if (o && o.laneCount === s.laneCount && Number.isFinite(o.seq)) {
+      m[s.id] = o.seq;
+      any = true;
+    }
+  });
+  return any ? m : null;
+}
+function computeRollLayout(items, config, overrides = {}, extraStrips = []) {
+  const build = (d) => items.flatMap((it) => layoutRingStrips(it, d, config));
+  let dir = config.direction, strips;
+  if (dir === "ns" || dir === "ew") {
+    strips = build(dir);
+  } else {
+    const ns = build("ns"), ew = build("ew");
+    if (sumStripLengthsFt(ns) <= sumStripLengthsFt(ew)) {
+      dir = "ns";
+      strips = ns;
+    } else {
+      dir = "ew";
+      strips = ew;
+    }
+  }
+  if (extraStrips && extraStrips.length) strips = strips.concat(extraStrips);
+  const maxW = config.rollWidthFt;
+  strips.forEach((s) => {
+    if (s.laneMax - s.laneMin > maxW + 1e-6) s.laneMax = s.laneMin + maxW;
+    if (s.coverMax - s.coverMin > maxW + 1e-6) s.coverMax = s.coverMin + maxW;
+  });
+  applyStripOverrides(strips, overrides);
+  assignDefaultCutPositions(strips, config.rollWidthFt, seqFromOverrides(strips, overrides), config.rollLengthFt || 0);
+  return { direction: dir, strips, totalLinearFt: sumStripLengthsFt(strips) };
+}
+function rollCutNumbers(strips) {
+  const m = /* @__PURE__ */ new Map();
+  strips.slice().sort((a, b) => {
+    const ax = a.cutX || 0, bx = b.cutX || 0;
+    if (Math.abs(ax - bx) > 1e-6) return ax - bx;
+    return (a.cutY || 0) - (b.cutY || 0);
+  }).forEach((s, i) => m.set(s.id, i + 1));
+  return m;
+}
+
+// ../web/src/lib/rollTakeoff.js
+function hasRollSetup(c) {
+  const rs = c?.roll_setup;
+  return !!rs && typeof rs === "object" && !Array.isArray(rs) && Number(rs.roll_width_ft) > 0;
+}
+function mintRollSetup(material) {
+  const ft = isRollType(material) ? material : "carpet";
+  return { material: ft, ...defaultRollSetup(ft) };
+}
+function rollConfig(rs) {
+  return {
+    rollWidthFt: Math.max(0.5, Number(rs.roll_width_ft) || 12),
+    rollLengthFt: Math.max(0, Number(rs.roll_length_ft) || 0),
+    seamAllowanceIn: Math.max(0, Number(rs.seam_allowance_in) || 0),
+    wallOverageIn: Math.max(0, Number(rs.wall_overage_in) || 0),
+    doorwayOverageIn: Math.max(0, Number(rs.doorway_overage_in) || 0),
+    direction: rs.direction === "ns" || rs.direction === "ew" ? rs.direction : "auto"
+  };
+}
+function collectRollOverrides(shapes) {
+  const out = {};
+  for (const s of shapes) {
+    const rl = s.roll_layout;
+    if (!rl || typeof rl !== "object" || !rl.lanes || typeof rl.lanes !== "object") continue;
+    for (const [li, o] of Object.entries(rl.lanes)) {
+      if (!o || typeof o !== "object") continue;
+      out[`${s.id}:${li}`] = { ...o, laneCount: rl.laneCount };
+    }
+  }
+  return out;
+}
+var stripLenFt = (s) => Math.max(0, s.runMax - s.runMin);
+var stripWidthFt = (s) => Math.max(0, s.laneMax - s.laneMin);
+function stripSheetRect(strip, upp) {
+  if (!(upp > 0)) return null;
+  const lane0 = strip.laneMin / upp, lane1 = strip.laneMax / upp;
+  const run0 = strip.runMin / upp, run1 = strip.runMax / upp;
+  return strip.laneAxis === "x" ? { x: lane0, y: run0, w: lane1 - lane0, h: run1 - run0 } : { x: run0, y: lane0, w: run1 - run0, h: lane1 - lane0 };
+}
+function computeRollTakeoff(conditions, shapes, dimsFor, uppFor) {
+  const byCond = /* @__PURE__ */ new Map();
+  const cutsBySheet = /* @__PURE__ */ new Map();
+  const rollConds = (conditions || []).filter(hasRollSetup);
+  if (!rollConds.length) return { byCond, cutsBySheet };
+  const shapeById = new Map(shapes.map((s) => [s.id, s]));
+  for (const c of rollConds) {
+    const rs = c.roll_setup;
+    const config = rollConfig(rs);
+    const items = [];
+    for (const s of shapes) {
+      if (s.condition_id !== c.id || s.measure_role !== "floor_area") continue;
+      if (!Array.isArray(s.verts_norm) || s.verts_norm.length < 3) continue;
+      const dims = dimsFor(s.sheet_id), upp = uppFor(s.sheet_id);
+      if (!dims || !(dims.w > 0) || !(upp > 0)) continue;
+      items.push({ id: s.id, name: s.label || "", ring: s.verts_norm.map(([nx, ny]) => ({ x: nx * dims.w * upp, y: ny * dims.h * upp })) });
+    }
+    if (!items.length) continue;
+    const layout = computeRollLayout(items, config, collectRollOverrides(shapes));
+    const nums = rollCutNumbers(layout.strips);
+    const orderFt = roundUpToInch(rollLayoutOrderLengthFt(layout.strips));
+    const material = isRollType(rs.material) ? rs.material : "carpet";
+    const unit = rs.price_unit === "lf" || rs.price_unit === "sf" || rs.price_unit === "sy" ? rs.price_unit : "sf";
+    byCond.set(c.id, {
+      material,
+      config,
+      direction: layout.direction,
+      strips: layout.strips,
+      nums,
+      orderFt,
+      rollCount: rollLayoutRollCount(layout.strips),
+      oversize: layout.strips.some((s) => s.overRoll),
+      qty: round22(rollQtyForUnit(orderFt, config.rollWidthFt, unit)),
+      unit,
+      cutCount: layout.strips.length
+    });
+    for (const strip of layout.strips) {
+      const src = shapeById.get(strip.srcId);
+      if (!src) continue;
+      const upp = uppFor(src.sheet_id);
+      const rect = stripSheetRect(strip, upp);
+      if (!rect) continue;
+      if (!cutsBySheet.has(src.sheet_id)) cutsBySheet.set(src.sheet_id, []);
+      cutsBySheet.get(src.sheet_id).push({
+        id: strip.id,
+        srcId: strip.srcId,
+        condId: c.id,
+        laneIndex: strip.laneIndex,
+        laneCount: strip.laneCount,
+        laneAxis: strip.laneAxis,
+        x: rect.x,
+        y: rect.y,
+        w: rect.w,
+        h: rect.h,
+        runMin: strip.runMin,
+        runMax: strip.runMax,
+        upp,
+        lenFt: stripLenFt(strip),
+        widthFt: stripWidthFt(strip),
+        num: nums.get(strip.id) || 0,
+        overRoll: !!strip.overRoll,
+        multi: strip.laneCount > 1,
+        material
+      });
+    }
+  }
+  return { byCond, cutsBySheet };
+}
+function rollReportRows(rollByCond, rows) {
+  if (!rollByCond || !rollByCond.size || !Array.isArray(rows)) return [];
+  const out = [];
+  for (const r of rows) {
+    const ri = rollByCond.get(r.id);
+    if (!ri) continue;
+    const mult = r.multiplier || 1;
+    out.push({
+      condition_id: r.id,
+      finish_tag: r.finish_tag,
+      material: ri.material,
+      roll_width_ft: ri.config.rollWidthFt,
+      roll_length_ft: ri.config.rollLengthFt,
+      direction: ri.direction,
+      cuts: ri.cutCount,
+      order_lf: round22(ri.orderFt * mult),
+      rolls: ri.rollCount * mult,
+      order_qty: round22(ri.qty * mult),
+      order_unit: ri.unit,
+      oversize: ri.oversize
+    });
+  }
+  return out;
+}
+
 // src/view.ts
 var INK = "#d91a1a";
 var PENCIL = "#2659e6";
@@ -1741,15 +2175,28 @@ function drawShapes(ctx, toCanvas, shapes, sheetW, sheetH, longEdge) {
   const w = Math.max(1.4, longEdge / 700);
   for (const s of shapes) {
     const pts = s.verts_norm.map(([nx, ny]) => toCanvas(nx * sheetW, ny * sheetH));
-    if (pts.length < 2) continue;
+    if (!pts.length) continue;
     const pending = s.origin?.reviewed === false;
     ctx.strokeStyle = pending ? PENCIL : INK;
     ctx.lineWidth = w;
+    if (s.measure_role === "count") {
+      const m = Math.max(4, longEdge / 160);
+      const [x, y] = pts[0];
+      ctx.setLineDash([]);
+      ctx.beginPath();
+      ctx.moveTo(x - m, y - m);
+      ctx.lineTo(x + m, y + m);
+      ctx.moveTo(x - m, y + m);
+      ctx.lineTo(x + m, y - m);
+      ctx.stroke();
+      continue;
+    }
+    if (pts.length < 2) continue;
     ctx.setLineDash(pending ? [w * 4, w * 3] : []);
     ctx.beginPath();
     ctx.moveTo(pts[0][0], pts[0][1]);
     for (let i = 1; i < pts.length; i++) ctx.lineTo(pts[i][0], pts[i][1]);
-    if (s.measure_role !== "linear") ctx.closePath();
+    if (s.measure_role !== "linear" && s.measure_role !== "surface_area") ctx.closePath();
     ctx.stroke();
   }
   ctx.setLineDash([]);
@@ -2398,6 +2845,78 @@ var Session = class _Session {
     this.flushCommits("measure_line");
     return { length_lf, npts: pts.length, ...shape_id ? { shape_id } : {} };
   }
+  /** Surface Area — the canvas's Surface tool (commitSurface): an OPEN run
+   * traced along the wall in plan view, quantified as traced LF × height.
+   * Height lives on the CONDITION (the canvas's H knob); an explicit height_ft
+   * here writes that knob first, exactly like typing H before tracing — and
+   * that write journals as its own condition step, so undo stays exact.
+   * The refusal path mints nothing: no height, no condition side effects. */
+  measureSurface(name, pts, opts) {
+    const s = this.sheet(name);
+    if (s.upp == null) throw new UserError(this.scaleGate(s));
+    const existing = this.conditions.find((x) => x.finish_tag === opts.condition);
+    const h = opts.height_ft ?? (Number(existing?.height_ft) || 0);
+    if (!(h > 0)) {
+      throw new UserError(`Set a height for ${opts.condition} first \u2014 Surface Area = traced LF \xD7 height. Pass height_ft on this call, or set it with edit_condition.`);
+    }
+    const c = this.conditionFor(opts.condition);
+    if (opts.height_ft !== void 0 && c.height_ft !== opts.height_ft) {
+      this.record({ op: "condition", tool: "measure_surface", condition_id: c.id, before: { waste_pct: c.waste_pct, multiplier: c.multiplier, height_ft: c.height_ft } });
+      c.height_ft = opts.height_ft;
+    }
+    const LF = openLen(pts) * s.upp;
+    const shape = this.commit(s, opts.condition, "surface_area", pts, { area_sf: round2(LF * h), perimeter_lf: round2(LF) }, { method: "manual", actor: "agent" });
+    shape.height_ft = h;
+    this.flushCommits("measure_surface");
+    return { condition: c.finish_tag, height_ft: h, length_lf: round2(LF), area_sf: round2(LF * h), npts: pts.length, shape_id: shape.id };
+  }
+  /** Count markers — the canvas's Count tool (commitCount): one point, one EA,
+   * computed {count: 1}, NO scale required (EA is scale-free; the canvas's
+   * recompute skips count shapes for the same reason). One shape per point,
+   * the whole call one journal gesture — undoing a placement sweep is one step,
+   * matching detect_rooms. */
+  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 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 };
+  }
+  /** 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
+   * payload to find one shape. Filters narrow, they never 404 an empty list. */
+  listShapes(f = {}) {
+    if (!this.doc) throw new UserError("No plan loaded \u2014 call load_plan first.");
+    let rows = this.shapes;
+    if (f.sheet) {
+      const s = this.sheet(f.sheet);
+      rows = rows.filter((x) => x.sheet_id === s.key);
+    }
+    if (f.condition) {
+      const c = this.conditions.find((x) => x.finish_tag === f.condition);
+      if (!c) throw new UserError(`No condition ${JSON.stringify(f.condition)} \u2014 tags: ${this.conditions.map((x) => x.finish_tag).join(", ") || "(none)"}.`);
+      rows = rows.filter((x) => x.condition_id === c.id);
+    }
+    const tagById = new Map(this.conditions.map((c) => [c.id, c.finish_tag]));
+    return {
+      shapes: rows.map((x) => ({
+        id: x.id,
+        sheet: x.sheet_id,
+        condition: tagById.get(x.condition_id) ?? "",
+        measure_role: x.measure_role,
+        ...x.computed.area_sf !== void 0 ? { area_sf: x.computed.area_sf } : {},
+        ...x.computed.perimeter_lf !== void 0 ? { perimeter_lf: x.computed.perimeter_lf } : {},
+        ...x.computed.count !== void 0 ? { count: x.computed.count } : {},
+        ...x.height_ft !== void 0 ? { height_ft: x.height_ft } : {},
+        nverts: x.verts_norm.length,
+        reviewed: x.origin?.reviewed === true,
+        ...x.origin?.agent_edits ? { agent_edits: x.origin.agent_edits } : {}
+      })),
+      count: rows.length
+    };
+  }
   summary() {
     const rows = conditionTotals(this.conditions, this.shapes);
     const lean = rows.map(({ color, fill, hatch, materials, ...rest }) => rest);
@@ -2441,15 +2960,25 @@ var Session = class _Session {
       throw new UserError("Nothing to change \u2014 pass at least one of verts, condition, role.");
     }
     const s = this.sheet(cur.sheet_id);
-    if (s.upp == null) throw new UserError(this.scaleGate(s));
-    const upp = s.upp;
     const role = patch.role ?? cur.measure_role;
+    if (role !== "count" && s.upp == null) throw new UserError(this.scaleGate(s));
+    const upp = s.upp ?? 0;
     const vertsPx = patch.verts ?? cur.verts_norm.map(([x, y]) => [x * s.widthPx, y * s.heightPx]);
-    const minPts = role === "linear" ? 2 : 3;
+    const minPts = role === "count" ? 1 : role === "linear" || role === "surface_area" ? 2 : 3;
     if (vertsPx.length < minPts) {
-      throw new UserError(`A ${role === "linear" ? "linear shape needs at least 2 points" : "closed shape needs at least 3 vertices"} \u2014 got ${vertsPx.length}.`);
+      throw new UserError(`A ${role === "count" ? "count marker needs at least 1 point" : role === "linear" || role === "surface_area" ? `${role} shape needs at least 2 points` : "closed shape needs at least 3 vertices"} \u2014 got ${vertsPx.length}.`);
     }
-    const computed = role === "linear" ? { area_sf: 0, perimeter_lf: round2(openLen(vertsPx) * upp) } : (() => {
+    const heightFor = () => {
+      const condId = patch.condition !== void 0 ? this.conditionFor(patch.condition).id : cur.condition_id;
+      const cond = this.conditions.find((x) => x.id === condId);
+      const h = Number(cur.height_ft) || Number(cond?.height_ft) || 0;
+      if (!(h > 0)) throw new UserError(`Surface Area needs a height \u2014 set height_ft on ${cond?.finish_tag ?? "the condition"} with edit_condition first.`);
+      return h;
+    };
+    const computed = role === "count" ? { count: cur.computed.count ?? 1 } : role === "linear" ? { area_sf: 0, perimeter_lf: round2(openLen(vertsPx) * upp) } : role === "surface_area" ? (() => {
+      const LF = openLen(vertsPx) * upp;
+      return { area_sf: round2(LF * heightFor()), perimeter_lf: round2(LF) };
+    })() : (() => {
       const met = closedMetrics(vertsPx);
       return { area_sf: round2(met.area * upp * upp), perimeter_lf: round2(met.perim * upp) };
     })();
@@ -2461,6 +2990,7 @@ var Session = class _Session {
       measure_role: role,
       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 } } : {}
     };
     this.record({ op: "edit", tool: "edit_shape", before });
@@ -2545,20 +3075,63 @@ var Session = class _Session {
    * mean anything on a condition that exists, and a typo'd tag must error,
    * not create an empty condition as a side effect. One journal entry
    * snapshots both knobs; undo restores them verbatim. */
+  /** dimsFor / uppFor as computeRollTakeoff wants them — bitmap px and real
+   * feet per px, null for sheets that can't participate. */
+  rollInputs() {
+    return {
+      dimsFor: (sheetId) => {
+        const s = this.sheets.get(sheetId);
+        return s ? { w: s.widthPx, h: s.heightPx } : null;
+      },
+      uppFor: (sheetId) => this.sheets.get(sheetId)?.upp ?? null
+    };
+  }
   editCondition(tag, opts) {
-    if (opts.waste_pct === void 0 && opts.multiplier === void 0) {
-      throw new UserError("Nothing to change \u2014 pass at least one of waste_pct, multiplier.");
+    if (opts.waste_pct === void 0 && opts.multiplier === void 0 && opts.height_ft === void 0 && opts.roll_setup === void 0) {
+      throw new UserError("Nothing to change \u2014 pass at least one of waste_pct, multiplier, height_ft, roll_setup.");
     }
     const c = this.conditions.find((x) => x.finish_tag === tag);
     if (!c) {
       const known = this.conditions.map((x) => x.finish_tag);
       throw new UserError(`No condition ${JSON.stringify(tag)}.${known.length ? ` Known tags: ${known.join(", ")}.` : " Nothing has minted a condition yet \u2014 commit a measurement or add materials first."}`);
     }
-    const before = { waste_pct: c.waste_pct, multiplier: c.multiplier };
+    const before = {
+      waste_pct: c.waste_pct,
+      multiplier: c.multiplier,
+      height_ft: c.height_ft,
+      roll_setup: c.roll_setup ? structuredClone(c.roll_setup) : void 0
+    };
     if (opts.waste_pct !== void 0) c.waste_pct = opts.waste_pct;
     if (opts.multiplier !== void 0) c.multiplier = opts.multiplier;
+    if (opts.height_ft !== void 0) c.height_ft = opts.height_ft;
+    if (opts.roll_setup !== void 0) {
+      if (opts.roll_setup === null) {
+        delete c.roll_setup;
+      } else {
+        const given = Object.fromEntries(Object.entries(opts.roll_setup).filter(([, v]) => v !== void 0));
+        const prevMaterial = c.roll_setup?.material;
+        const material = given.material ?? prevMaterial ?? "carpet";
+        const base = hasRollSetup(c) && material === prevMaterial ? c.roll_setup : mintRollSetup(material);
+        c.roll_setup = { ...base, ...given, material };
+      }
+    }
     this.record({ op: "condition", tool: "edit_condition", condition_id: c.id, before });
-    return { condition: tag, condition_id: c.id, waste_pct: c.waste_pct, multiplier: c.multiplier };
+    let roll;
+    if (hasRollSetup(c)) {
+      const { dimsFor, uppFor } = this.rollInputs();
+      const { byCond } = computeRollTakeoff([c], this.shapes, dimsFor, uppFor);
+      const rows = conditionTotals([c], this.shapes);
+      roll = rollReportRows(byCond, rows)[0];
+    }
+    return {
+      condition: tag,
+      condition_id: c.id,
+      waste_pct: c.waste_pct,
+      multiplier: c.multiplier,
+      ...c.height_ft !== void 0 ? { height_ft: c.height_ft } : {},
+      ...c.roll_setup ? { roll_setup: c.roll_setup } : {},
+      ...roll ? { roll } : {}
+    };
   }
   /** Step back over this session's own last n mutations, newest first. Each
    * entry's inverse is exact (see JournalEntry), so this restores state rather
@@ -2586,6 +3159,10 @@ var Session = class _Session {
         if (c) {
           c.waste_pct = e.before.waste_pct;
           c.multiplier = e.before.multiplier;
+          if (e.before.height_ft === void 0) delete c.height_ft;
+          else c.height_ft = e.before.height_ft;
+          if (e.before.roll_setup === void 0) delete c.roll_setup;
+          else c.roll_setup = e.before.roll_setup;
         }
         undone.push({ seq: e.seq, op: e.op, tool: e.tool, shapes: 0 });
       } else {
@@ -2616,8 +3193,9 @@ var Session = class _Session {
     const s = this.sheet(a.sheet);
     const n = ([x, y]) => [x / s.widthPx, y / s.heightPx];
     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.at) throw new UserError(`a ${a.type} needs at: [x,y] 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");
     const cond = a.condition ? this.conditionFor(a.condition) : null;
     const m = {
       id: uid("mk"),
@@ -2629,7 +3207,12 @@ var Session = class _Session {
       created_at: (/* @__PURE__ */ new Date()).toISOString(),
       ...a.at ? { at: n(a.at) } : {},
       ...a.target ? { target: n(a.target) } : {},
-      ...a.rect ? { rect: [n(a.rect[0]), n(a.rect[1])] } : {}
+      ...a.rect ? { rect: [n(a.rect[0]), n(a.rect[1])] } : {},
+      ...a.from ? { from: n(a.from) } : {},
+      ...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 } : {}
     };
     this.markups.push(m);
     return {
@@ -2673,7 +3256,10 @@ var Session = class _Session {
         condition_id: m.condition_id,
         ...m.at ? { at: px(m, m.at) } : {},
         ...m.target ? { target: px(m, m.target) } : {},
-        ...m.rect ? { rect: [px(m, m.rect[0]), px(m, m.rect[1])] } : {}
+        ...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)) } : {}
       })),
       count: rows.length,
       unattached: rows.filter((m) => !m.condition_id).length
@@ -2720,13 +3306,16 @@ var Session = class _Session {
   exportReport(projectName = "") {
     if (!this.doc) throw new UserError("No plan loaded \u2014 call load_plan first.");
     const rows = conditionTotals(this.conditions, this.shapes).filter((r) => r.shape_count > 0);
+    const { dimsFor, uppFor } = this.rollInputs();
+    const { byCond } = computeRollTakeoff(this.conditions, this.shapes, dimsFor, uppFor);
     return reportJson({
       projectName,
       rows,
       bySheet: sheetTotals(this.conditions, this.shapes),
       scaleInfo: [...this.sheets.values()].filter((s) => s.upp != null).map((s) => ({ sheet_id: s.key, scale_source: s.scaleSource ?? "unknown" })),
       markups: this.markups,
-      rfis: []
+      rfis: [],
+      rollGoods: rollReportRows(byCond, rows)
     });
   }
   // ── the sheet graph (#87) ─────────────────────────────────────────────────
@@ -2953,6 +3542,20 @@ var measurePolygonOutput = {
   nverts: z.number().int(),
   shape_id: z.string().optional().describe("Present when condition was passed and the shape committed")
 };
+var measureSurfaceOutput = {
+  condition: z.string(),
+  height_ft: z.number().describe("The height this shape was quantified at (snapshotted on the shape)"),
+  length_lf: z.number().describe("The traced run's open length"),
+  area_sf: z.number().describe("length_lf \xD7 height_ft \u2014 the wall SF committed"),
+  npts: z.number().int(),
+  shape_id: z.string()
+};
+var placeCountOutput = {
+  committed: z.number().int().describe("Count shapes committed by this call \u2014 one per point"),
+  shape_ids: z.array(z.string()),
+  condition: z.string(),
+  ea_total: z.number().describe("The condition's total EA after this call")
+};
 var measureLineOutput = {
   length_lf: z.number(),
   npts: z.number().int(),
@@ -3007,9 +3610,9 @@ var exportTakeoffOutput = {
     id: z.string(),
     sheet_id: z.string(),
     condition_id: z.string(),
-    measure_role: z.enum(["floor_area", "deduct", "linear"]),
+    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(), perimeter_lf: z.number() }).passthrough(),
+    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)")
   }).passthrough()),
   markups: z.array(z.unknown()),
@@ -3018,6 +3621,22 @@ var exportTakeoffOutput = {
   sheet_tabs: z.array(z.unknown()),
   sheet_levels: z.object({}).passthrough()
 };
+var listShapesOutput = {
+  shapes: z.array(z.object({
+    id: z.string(),
+    sheet: z.string(),
+    condition: z.string(),
+    measure_role: z.enum(["floor_area", "deduct", "linear", "surface_area", "count"]),
+    area_sf: z.number().optional(),
+    perimeter_lf: z.number().optional(),
+    count: z.number().optional(),
+    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"),
+    agent_edits: z.number().int().optional().describe("Present when the agent has revised this shape")
+  })),
+  count: z.number().int()
+};
 var deleteShapeOutput = {
   deleted: z.string().describe("The removed shape's id"),
   shape_count: z.number().int().describe("Committed shapes remaining")
@@ -3025,10 +3644,11 @@ var deleteShapeOutput = {
 var editShapeOutput = {
   shape_id: z.string(),
   changed: z.array(z.enum(["verts", "condition", "role"])).describe("Which fields this call actually changed"),
-  measure_role: z.enum(["floor_area", "deduct", "linear"]),
+  measure_role: z.enum(["floor_area", "deduct", "linear", "surface_area", "count"]),
   nverts: z.number().int(),
-  area_sf: z.number().describe("0 for linear shapes"),
-  perimeter_lf: z.number().describe("Length for linear shapes, perimeter for closed ones"),
+  area_sf: z.number().optional().describe("0 for linear shapes; LF \xD7 height for surface_area; absent for count"),
+  perimeter_lf: z.number().optional().describe("Length for linear/surface runs, perimeter for closed ones; absent for count"),
+  count: z.number().optional().describe("count shapes only \u2014 the marker's EA (preserved across the edit)"),
   agent_edits: z.number().int().describe("How many times the agent has revised this shape \u2014 separate from the human-correction tally")
 };
 var undoLastOutput = {
@@ -3119,7 +3739,23 @@ var editConditionOutput = {
   condition: z.string().describe("The finish tag passed in"),
   condition_id: z.string(),
   waste_pct: z.number().describe("The condition's waste % after this write"),
-  multiplier: z.number().describe("The condition's quantity multiplier after this write")
+  multiplier: z.number().describe("The condition's quantity multiplier after this write"),
+  height_ft: z.number().optional().describe("The condition's wall height after this write \u2014 present once set (measure_surface multiplies traced LF by it)"),
+  roll_setup: z.object({}).passthrough().optional().describe("The condition's roll-goods setup after this write \u2014 present while opted in"),
+  roll: z.object({
+    condition_id: z.string(),
+    finish_tag: z.string(),
+    material: z.string(),
+    roll_width_ft: z.number(),
+    roll_length_ft: z.number(),
+    direction: z.string(),
+    cuts: z.number().int(),
+    order_lf: z.number().describe("Full-width roll footage to order, \xD7N applied, rounded up to the inch"),
+    rolls: z.number(),
+    order_qty: z.number(),
+    order_unit: z.string(),
+    oversize: z.boolean().describe("true when a cut exceeds the physical roll length (roll_length_ft binds)")
+  }).passthrough().optional().describe("The figured order (same row export_report's roll_goods carries) \u2014 present when the roll-goods condition has floor shapes on scaled sheets")
 };
 var readSheetTextOutput = {
   sheet: z.string(),
@@ -3209,7 +3845,10 @@ var annotationRow = z.object({
   condition_id: z.string(),
   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()
+  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)")
 });
 var annotateOutput = {
   id: z.string(),
@@ -4456,6 +5095,25 @@ function registerTools(server, session) {
     },
     outputSchema: measureLineOutput
   }, run("measure_line", (a) => session.measureLine(a.sheet, a.pts, { condition: a.condition })));
+  server.registerTool("measure_surface", {
+    description: `Surface Area \u2014 wall SF (#146): trace an OPEN run along the wall in plan view (min 2 points, image px) and the quantity is traced LF \xD7 height. This is how wall tile, wainscot, and wall systems are taken off \u2014 the quantity family one_click and measure_polygon cannot produce. Height lives on the CONDITION (the canvas's H knob): pass height_ft to set it on this call (journals as its own undo step, like typing H before tracing), or set it once with edit_condition; with neither, this refuses and mints nothing. The shape snapshots the height it was quantified at. Requires the sheet's scale. ${COORDS}`,
+    inputSchema: {
+      sheet: z2.string(),
+      pts: z2.array(pointSchema).min(2).describe("The wall run, an open polyline (image px)"),
+      condition: z2.string().describe("Finish tag to commit under (minted on first use), e.g. 'CT-W1'"),
+      height_ft: z2.number().positive().optional().describe("Wall height in feet \u2014 written to the condition's H knob first, then used")
+    },
+    outputSchema: measureSurfaceOutput
+  }, run("measure_surface", (a) => session.measureSurface(a.sheet, a.pts, { condition: a.condition, height_ft: a.height_ft })));
+  server.registerTool("place_count", {
+    description: `Count markers \u2014 EA (#146): one point, one each. Thresholds, stair nosings, floor boxes, entrance mats \u2014 the scale-free quantity family. Commits one count shape per point (computed {count: 1}, exactly the canvas's Count tool), NO scale required, and the whole call is ONE undo step like a detect_rooms sweep. takeoff_summary reports them as ea; the marked set draws each marker. ${COORDS}`,
+    inputSchema: {
+      sheet: z2.string(),
+      points: z2.array(pointSchema).min(1).describe("Marker positions (image px), one committed count shape each"),
+      condition: z2.string().describe("Finish tag to commit under (minted on first use), e.g. 'TR-1'")
+    },
+    outputSchema: placeCountOutput
+  }, run("place_count", (a) => session.placeCount(a.sheet, a.points, { condition: a.condition })));
   server.registerTool("takeoff_summary", {
     description: `Per-condition totals (floor/wall/border SF, LF, EA, SY, with and without waste) plus grand totals \u2014 the Report's numbers, computed by the same rules. Numbers only: the deliverable that SHOWS the work on the drawings is export_marked_pdf. ${COORDS}`,
     inputSchema: {},
@@ -4496,6 +5154,14 @@ function registerTools(server, session) {
     },
     outputSchema: exportMarkedPdfOutput
   }, run("export_marked_pdf", (a) => exportMarkedPdf(session, a)));
+  server.registerTool("list_shapes", {
+    description: `The mid-session shape inventory (#149): every committed shape's id, sheet, condition tag, role, quantities, vertex count, and review state in one compact read \u2014 the ids edit_shape and delete_shape assume you have, without pulling the whole export_takeoff payload to find one shape. Filter by sheet, by condition, or both; filters narrow, an empty list is a result, not an error.`,
+    inputSchema: {
+      sheet: z2.string().optional().describe("Only shapes on this sheet"),
+      condition: z2.string().optional().describe("Only shapes under this finish tag (must exist)")
+    },
+    outputSchema: listShapesOutput
+  }, run("list_shapes", (a) => session.listShapes(a)));
   server.registerTool("delete_shape", {
     description: `Remove a committed shape by the id returned when it was committed. ${COORDS}`,
     inputSchema: { shape_id: z2.string() },
@@ -4515,9 +5181,9 @@ function registerTools(server, session) {
     description: `REVISE a shape you already committed, instead of deleting it and starting over: pass new verts to move the geometry, condition to reassign it to a different finish tag, role to switch between floor_area / deduct / linear, or any combination. Quantities are recomputed from the result \u2014 a role flip alone re-measures (closed area vs open length). The loop this is for: one_click or measure_polygon to commit, view_sheet with overlay:true to LOOK at what landed, then edit_shape to fix the two vertices that overshot into the corridor. Shapes a human affirmed (origin.reviewed) are ink and are refused \u2014 an agent revises its own pencil and nothing else. Agent self-revision is tallied on origin.agent_edits, kept deliberately separate from the human-correction fields. ${COORDS}`,
     inputSchema: {
       shape_id: z2.string().describe("Id returned when the shape was committed"),
-      verts: z2.array(pointSchema).optional().describe("Replacement geometry (image px): \u22653 vertices for an area shape, \u22652 points for a linear one"),
+      verts: z2.array(pointSchema).optional().describe("Replacement geometry (image px): \u22653 vertices for an area shape, \u22652 points for a linear/surface run, \u22651 for a count marker"),
       condition: z2.string().optional().describe("Reassign to this finish tag (minted on first use)"),
-      role: z2.enum(["floor_area", "deduct", "linear"]).optional().describe("Switch what the shape measures")
+      role: z2.enum(["floor_area", "deduct", "linear", "surface_area", "count"]).optional().describe("Switch what the shape measures \u2014 flipping INTO surface_area needs a height on the shape or its condition")
     },
     outputSchema: editShapeOutput
   }, run("edit_shape", (a) => session.editShape(a.shape_id, { verts: a.verts, condition: a.condition, role: a.role })));
@@ -4542,14 +5208,28 @@ function registerTools(server, session) {
     outputSchema: editMaterialsOutput
   }, run("edit_materials", (a) => session.editMaterials(a.condition, { add: a.add, remove: a.remove, patch: a.patch })));
   server.registerTool("edit_condition", {
-    description: `Set a condition's quantity knobs \u2014 waste % and/or multiplier. takeoff_summary emits waste-adjusted *_net order quantities and a per-condition multiplier, and every export carries both, but conditions minted through the measure tools start at waste 0 / multiplier 1 \u2014 without this tool an agent's takeoff always ships net === gross (#131). waste_pct is the estimator's cut-waste percentage (carpet commonly 5\u201310); multiplier scales every quantity on the condition (\xD7N identical floors \u2014 takeoff_summary applies it before waste). condition must resolve to an EXISTING finish tag \u2014 a typo'd tag errors rather than minting an empty condition (the edit_materials remove/patch rule, not its add rule: these knobs mean nothing on a condition that doesn't exist yet). No review gate \u2014 quantity config, not traced geometry; undo_last reverses a call in one step (both knobs snapshotted together, restored verbatim).`,
+    description: `Set a condition's quantity knobs \u2014 waste %, multiplier, height_ft (the H knob measure_surface quantifies against), and/or roll_setup (the roll-goods opt-in: seams and order footage figured from the committed rooms, #147). takeoff_summary emits waste-adjusted *_net order quantities and a per-condition multiplier, and every export carries both, but conditions minted through the measure tools start at waste 0 / multiplier 1 \u2014 without this tool an agent's takeoff always ships net === gross (#131). waste_pct is the estimator's cut-waste percentage (carpet commonly 5\u201310); multiplier scales every quantity on the condition (\xD7N identical floors \u2014 takeoff_summary applies it before waste). condition must resolve to an EXISTING finish tag \u2014 a typo'd tag errors rather than minting an empty condition (the edit_materials remove/patch rule, not its add rule: these knobs mean nothing on a condition that doesn't exist yet). No review gate \u2014 quantity config, not traced geometry; undo_last reverses a call in one step (both knobs snapshotted together, restored verbatim).`,
     inputSchema: {
       condition: z2.string().describe("Finish tag of an existing condition, e.g. 'CPT-1'"),
       waste_pct: z2.number().min(0).optional().describe("Waste percentage applied to net order quantities, e.g. 10 for 10%"),
-      multiplier: z2.number().positive().optional().describe("Quantity multiplier (\xD7N identical areas). Note: the canvas treats 0 as 1, so 0 is rejected here rather than silently meaning 'off'")
+      multiplier: z2.number().positive().optional().describe("Quantity multiplier (\xD7N identical areas). Note: the canvas treats 0 as 1, so 0 is rejected here rather than silently meaning 'off'"),
+      height_ft: z2.number().positive().optional().describe("Wall height in feet \u2014 the canvas's H knob; measure_surface quantifies traced LF \xD7 this"),
+      roll_setup: z2.union([
+        z2.null().describe("Opt the condition OUT of roll goods"),
+        z2.object({
+          material: z2.enum(["carpet", "sheet_vinyl", "rubber"]).optional().describe("Material class \u2014 fresh opt-ins and material changes start from this class's engine defaults (carpet sells sy, others sf)"),
+          roll_width_ft: z2.number().positive().optional(),
+          roll_length_ft: z2.number().min(0).optional().describe("Physical roll length; 0 = unlimited"),
+          seam_allowance_in: z2.number().min(0).optional(),
+          wall_overage_in: z2.number().min(0).optional(),
+          doorway_overage_in: z2.number().min(0).optional(),
+          direction: z2.enum(["auto", "ns", "ew"]).optional().describe("Run direction; auto lets the engine pick per room"),
+          price_unit: z2.enum(["sy", "sf", "lf"]).optional().describe("Sell unit the order quantity is figured in")
+        })
+      ]).optional().describe("Roll-goods opt-in (#147): presence of a setup is what makes the condition roll goods \u2014 seams figured, cuts packed, order footage beside the measured quantities. Same-material partial edits patch the existing setup; null opts out. The reply echoes the figured order (cuts, order_lf, rolls, order_qty) whenever floor shapes exist on scaled sheets, and export_report's roll_goods block carries the same rows")
     },
     outputSchema: editConditionOutput
-  }, run("edit_condition", (a) => session.editCondition(a.condition, { waste_pct: a.waste_pct, multiplier: a.multiplier })));
+  }, run("edit_condition", (a) => session.editCondition(a.condition, { waste_pct: a.waste_pct, multiplier: a.multiplier, height_ft: a.height_ft, roll_setup: a.roll_setup })));
   server.registerTool("undo_last", {
     description: `Step back over your OWN last n mutations, newest first \u2014 a committed one_click, a whole detect_rooms sweep, an edit_shape, a delete_shape, an edit_materials call, or an edit_condition call. Each step is reversed exactly (a commit is removed, an edit is restored verbatim, a delete is re-inserted where it was, a materials edit's whole array is restored, a condition edit's waste/multiplier pair is restored), so this restores state rather than approximating it. Reads are never journaled, so n counts gestures that changed something, not tool calls you made. Use it when a sweep committed against the wrong condition or a batch went in on the wrong sheet \u2014 one call instead of N deletes. Scope: this session's own history only. It is not the browser canvas's undo stack, and load_plan clears it along with the shapes it refers to.`,
     inputSchema: {
@@ -4612,19 +5292,22 @@ 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). 
+    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). 
 
 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"]).describe("cloud/highlight need rect; text/callout need at; callout also needs target"),
-      text: z2.string().default("").describe("The note. A cloud with no text still reads as 'look here'"),
+      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"),
       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 and callout"),
+      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")
+      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)"),
+      r: z2.number().positive().optional().describe("Bubble radius (image px); omitted \u2192 the canvas default (2% of sheet width)")
     },
     outputSchema: annotateOutput
   }, run("annotate", (a) => session.annotate(a)));
@@ -4725,7 +5408,7 @@ function registerResources(server, session) {
 // package.json
 var package_default = {
   name: "opentakeoff-mcp",
-  version: "0.9.8",
+  version: "0.9.12",
   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.8",
+  "version": "0.9.12",
   "mcpName": "io.github.Kentucky-ai/opentakeoff",
   "type": "module",
   "description": "OpenTakeoff MCP server \u2014 drive the takeoff engine from your MCP client over stdio.",