opentakeoff-mcp 0.9.32 → 0.9.35

package/README.md

@@ -119,15 +119,15 @@ includes document text, shape vertices, or result payload content.
 | `symbol_sweep` | **Every instance of a repeated plan symbol, from ONE example**: marquee a tight `seed_rect` around a single drain/threshold/fixture symbol and the vector linework is searched deterministically for every other placement — translation plus 0/90/180/270 rotation and mirroring (both on by default). Score = length-weighted fraction of the seed's segments matched within `tolerance_px`; ≥ 0.92 is a match, the 0.75–0.92 band returns in `withheld` with reasons (never committed, never dropped silently), and the work cap is disclosed when it bites. **`scope: "set"` sweeps the whole working set, counting on PLAN-role sheets only** (the sheet graph decides; every excluded sheet disclosed in `skipped` with role and reason) — and the seed rect may sit on a detail or legend sheet, which then serves as the fingerprint SOURCE while staying excluded from counting: the estimator's "click the assembly in the detail, count it on the plans" gesture. Per-sheet results carry their own match/withheld lists, per-sheet cap accounting, and wall-clock `elapsed_ms`. `commit: true` + `condition` commits every match center as an EA count marker — the whole sweep (set-wide included) is one undo step, `origin.method "symbol_sweep"` with per-marker score, transform, and seed source (`origin.symbol.seed`). No scale required. |
 | `sweep_schedule_row` | **Take off a schedule row's mark from the row itself**: pass the row's key (e.g. `T1`) and the tool reads the row from the set's schedule tables (the row is the condition's cited source), anchors a fingerprint on the marker the tag is DRAWN as on a plan sheet (a deterministic pad ladder around the tag text; where the tag occurs more than once the fingerprint must recur at a second occurrence — `anchor.corroborated` — before it is trusted), and sweeps every plan-role sheet. **The count is geometry AND text agreeing**: drafting reuses one bubble shape across many marks, so a match counts only when the row's own tag sits within the marker footprint (its bbox rides the match as `tag_at` evidence); a match labeled with a sibling key is `excluded` and says whose it is, an unlabeled match is `withheld` as a question, a tag drawn with no matching marker is `text_only`. Refusal over guessing, each with the reason and the fix: no such row, an ambiguous key, a tag drawn on no plan sheet, no repeatable marker linework — a fingerprint is never guessed from text alone. `commit: true` commits the counted matches under the row's own key — one undo step, `origin.assignment {source: "schedule"}` plus the anchor and row citation on `origin.symbol.seed`. No scale required. |
 | `takeoff_summary` | Per-condition totals + grand totals, computed by the Report's rules. |
-| `export_takeoff` | The full `opentakeoff.takeoff_canvas.v1` payload — exactly what the app autosaves. Inline, and to disk with `path`. |
+| `export_takeoff` | The full `opentakeoff.takeoff_canvas.v1` payload — exactly what the app autosaves. Inline, and to disk with `path` (see **Writing to disk** below). |
 | `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_shape` | **Revise** a committed shape instead of redoing it: new `verts`, a different `condition`, a different `role`, a `label` (the room it belongs to — what per-room reporting groups by; `""` clears it), 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. `basis` is `area` \| `linear` \| `count` \| **`seam_lf`** — the last is the *figured* roll-layout seam length a weld rod or seam tape is bought by (set `roll_setup` on the condition first; without one it reads 0, because nothing has decided how that floor gets cut). `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 %**, **×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_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` (see **Writing to disk** below). |
 | `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, 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. |
+| `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 (see **Writing to disk** below). Works without `@napi-rs/canvas`. |
+| `list_shapes` | The **mid-session inventory**: every committed shape's id, sheet, condition, role, quantities, room `label`, 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), **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. `verdicts[]` is the approval family's inventory — every mark with its actor stated, a condition filter reaching a verdict through its target shape. |
@@ -245,6 +245,26 @@ A takeoff finishes with **both** exports: `export_marked_pdf` is what a human
 reviews (construction takeoffs are no good without markup), `export_report` is
 what pricing consumes.
 
+### Writing to disk
+
+`path` is not confined to a working directory, and deliberately so — the marked
+set belongs in the job folder, wherever that is. What the export tools will not
+do is destroy a file they didn't write:
+
+- **Nothing at the path** → written.
+- **A previous export of ours at the path** → overwritten silently. Fix a
+  condition and export again to the same path as often as you like; that's the
+  normal loop, and it needs no flag.
+- **Any other existing file** → refused, with the path named. Pass
+  `overwrite: true` to replace it anyway.
+- **Corrupt, encrypted, or unreadable** → treated as *not* ours, so refused. An
+  unrecognizable file is exactly the kind worth not overwriting.
+
+A marked set is recognized by its PDF `Producer`; the JSON exports by the
+`schema` key they stamp. This is data-loss protection, not a sandbox — the
+server runs as you, with your privileges. See [`SECURITY.md`](../SECURITY.md)
+for the threat model.
+
 Sheet keys follow the app's codec: page 1 is the bare file name
 (`plan.pdf`), pages 2+ are `plan.pdf#2`. Tools also accept the title-block
 sheet number (`A-101`) wherever a sheet is named.

package/dist/server-core.js

@@ -3884,7 +3884,8 @@ function accumulateRole(acc, s) {
       break;
   }
 }
-function conditionTotals(conditions, shapes) {
+function conditionTotals(conditions, shapes, ctx = null) {
+  const seamByShape = ctx?.seamByShape instanceof Map ? ctx.seamByShape : null;
   return conditions.map((c) => {
     const mult = c.multiplier || 1;
     const waste = Math.max(0, Number(c.waste_pct) || 0);
@@ -3893,15 +3894,17 @@ function conditionTotals(conditions, shapes) {
     const acc = { floor: 0, wall: 0, border: 0, lf: 0, ea: 0 };
     for (const s of cs) accumulateRole(acc, s);
     let { floor, wall, border, lf, ea } = acc;
+    let seam = seamByShape ? cs.reduce((n, s) => n + (seamByShape.get(s.id) || 0), 0) : 0;
     floor *= mult;
     wall *= mult;
     border *= mult;
     lf *= mult;
     ea *= mult;
+    seam *= mult;
     const total = floor + wall + border;
     const materials = (c.materials || []).filter((m) => m && m.name).map((m) => {
       const per = Math.max(0, Number(m.per) || 0);
-      const basisVal = m.basis === "linear" ? lf : m.basis === "count" ? ea : total;
+      const basisVal = m.basis === "linear" ? lf : m.basis === "count" ? ea : m.basis === "seam_lf" ? seam : total;
       let qty = per > 0 ? basisVal / per : 0;
       qty = m.round === false ? round22(qty) : Math.ceil(qty - 1e-9);
       return { name: m.name, unit: m.unit || "", per, basis: m.basis || "area", round: m.round !== false, note: m.note || "", basis_qty: round22(basisVal), qty };
@@ -4240,6 +4243,32 @@ function layoutRingStrips(item, direction, config) {
 function sumStripLengthsFt(strips) {
   return strips.reduce((s, st) => s + Math.max(0, st.runMax - st.runMin), 0);
 }
+function seamLfBySrc(strips) {
+  const bySrc = /* @__PURE__ */ new Map();
+  for (const st of strips || []) {
+    if (!bySrc.has(st.srcId)) bySrc.set(st.srcId, []);
+    bySrc.get(st.srcId).push(st);
+  }
+  const out = /* @__PURE__ */ new Map();
+  for (const [srcId, lanes] of bySrc) {
+    lanes.sort((a, b) => (a.laneIndex || 0) - (b.laneIndex || 0));
+    let total = 0;
+    for (let i = 0; i + 1 < lanes.length; i++) {
+      const a = lanes[i], b = lanes[i + 1];
+      if ((b.laneIndex || 0) !== (a.laneIndex || 0) + 1) continue;
+      const aLo = a.runMin + (a.minOverageFt || 0), aHi = a.runMax - (a.maxOverageFt || 0);
+      const bLo = b.runMin + (b.minOverageFt || 0), bHi = b.runMax - (b.maxOverageFt || 0);
+      total += Math.max(0, Math.min(aHi, bHi) - Math.max(aLo, bLo));
+    }
+    if (total > 0) out.set(srcId, Math.round(total * 100) / 100);
+  }
+  return out;
+}
+function seamLfForStrips(strips) {
+  let total = 0;
+  for (const v of seamLfBySrc(strips).values()) total += v;
+  return Math.round(total * 100) / 100;
+}
 function assignDefaultCutPositions(strips, rollWidthFt, seqById, rollLenFt = 0) {
   const EPS = 1e-6;
   const L = rollLenFt > 0 ? rollLenFt : Infinity;
@@ -4471,7 +4500,9 @@ function computeRollTakeoff(conditions, shapes, dimsFor, uppFor) {
       oversize: layout.strips.some((s) => s.overRoll),
       qty: round22(rollQtyForUnit(orderFt, config.rollWidthFt, unit)),
       unit,
-      cutCount: layout.strips.length
+      cutCount: layout.strips.length,
+      seamLf: seamLfForStrips(layout.strips),
+      seamByShape: seamLfBySrc(layout.strips)
     });
     for (const strip of layout.strips) {
       const src = shapeById.get(strip.srcId);
@@ -4524,11 +4555,25 @@ function rollReportRows(rollByCond, rows) {
       rolls: ri.rollCount * mult,
       order_qty: round22(ri.qty * mult),
       order_unit: ri.unit,
-      oversize: ri.oversize
+      oversize: ri.oversize,
+      // seam_lf APPENDS last (the additive-only convention the roll_goods
+      // block already follows): the figured weld-rod / seam-tape length, ×N
+      // like every other reported quantity. 0 is a real answer — a layout
+      // whose rooms each fit one strip has no seams to weld.
+      seam_lf: round22((ri.seamLf || 0) * mult)
     });
   }
   return out;
 }
+function seamLfByShape(rollByCond) {
+  const out = /* @__PURE__ */ new Map();
+  if (!rollByCond || typeof rollByCond.forEach !== "function") return out;
+  rollByCond.forEach((ri) => {
+    if (!ri || !(ri.seamByShape instanceof Map)) return;
+    ri.seamByShape.forEach((lf, shapeId) => out.set(shapeId, (out.get(shapeId) || 0) + lf));
+  });
+  return out;
+}
 
 // src/view.ts
 var INK = "#d91a1a";
@@ -5483,13 +5528,15 @@ var Session = class _Session {
       }
       let shape_id;
       if (tag) {
-        shape_id = this.commit(s, tag, opts.role, c.ring, { area_sf, perimeter_lf }, {
+        const shape = 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,
           ...assignment ? { assignment } : {}
-        }, c.ev).id;
+        }, c.ev);
+        shape.label = c.label;
+        shape_id = shape.id;
       }
       return { ...common, area_sf, perimeter_lf, ...shape_id ? { shape_id, condition: tag } : {} };
     }).filter((r) => r !== null);
@@ -5597,25 +5644,25 @@ var Session = class _Session {
       byShape.set(o.shape_id, (byShape.get(o.shape_id) ?? 0) + o.lf);
     }
     for (const f of floors) {
-      const open = byShape.get(f.id) ?? 0;
+      const open2 = byShape.get(f.id) ?? 0;
       const gross = f.computed.perimeter_lf ?? 0;
-      if (open >= gross) {
-        throw new UserError(`Shape ${f.id}: stated openings (${round2(open)} LF) meet or exceed its perimeter (${round2(gross)} LF) \u2014 nothing would remain.`);
+      if (open2 >= gross) {
+        throw new UserError(`Shape ${f.id}: stated openings (${round2(open2)} LF) meet or exceed its perimeter (${round2(gross)} LF) \u2014 nothing would remain.`);
       }
     }
     const rooms = floors.map((f) => {
       const s = this.sheet(f.sheet_id);
       const gross = f.computed.perimeter_lf ?? 0;
-      const open = byShape.get(f.id) ?? 0;
-      const net = round2(gross - open);
+      const open2 = byShape.get(f.id) ?? 0;
+      const net = round2(gross - open2);
       const ringPx = f.verts_norm.map(([x, y]) => [x * s.widthPx, y * s.heightPx]);
       const shape = this.commit(s, opts.condition, "linear", [...ringPx, ringPx[0]], { area_sf: 0, perimeter_lf: net }, {
         method: "agent_v1",
         actor: "agent",
         reviewed: false,
-        derived: { from_shape_id: f.id, gross_lf: round2(gross), openings_lf: round2(open) }
+        derived: { from_shape_id: f.id, gross_lf: round2(gross), openings_lf: round2(open2) }
       });
-      return { source_shape_id: f.id, base_shape_id: shape.id, sheet: f.sheet_id, gross_lf: round2(gross), openings_lf: round2(open), net_lf: net };
+      return { source_shape_id: f.id, base_shape_id: shape.id, sheet: f.sheet_id, gross_lf: round2(gross), openings_lf: round2(open2), net_lf: net };
     });
     this.flushCommits("derive_base");
     return {
@@ -6248,6 +6295,7 @@ var Session = class _Session {
         ...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 } : {},
+        ...x.label ? { label: x.label } : {},
         nverts: x.verts_norm.length,
         reviewed: x.origin?.reviewed === true,
         ...x.origin?.assignment ? { assignment: x.origin.assignment.source } : {},
@@ -6257,7 +6305,7 @@ var Session = class _Session {
     };
   }
   summary() {
-    const rows = conditionTotals(this.conditions, this.shapes);
+    const rows = conditionTotals(this.conditions, this.shapes, this.seamCtx());
     const lean = rows.map(({ color, fill, hatch, materials, ...rest }) => rest);
     return { conditions: lean, totals: grandTotals(rows) };
   }
@@ -6280,6 +6328,11 @@ var Session = class _Session {
    * makes this surface portable to a host that DOES have a review gate, and it
    * belongs in the code rather than in a host's good intentions.
    *
+   * `label` is the room (or phase, or area) the shape belongs to — the same
+   * per-shape field the canvas groups the Report by. A visible string sets it,
+   * "" clears it, and the whole shape is snapshotted before the write, so undo
+   * restores a cleared label as exactly as it restores geometry.
+   *
    * Provenance: agent self-revision bumps origin.agent_edits and touches
    * NOTHING in the human-correction vocabulary (edited / edits /
    * proposed_verts_norm — see web/src/lib/provenance.js). Those fields grade a
@@ -6295,8 +6348,8 @@ var Session = class _Session {
     if (cur.origin?.reviewed === true) {
       throw new UserError(`Shape ${JSON.stringify(id)} was affirmed by a human \u2014 reviewed work is ink, not pencil, and cannot be edited by an agent.`);
     }
-    if (patch.verts === void 0 && patch.condition === void 0 && patch.role === void 0) {
-      throw new UserError("Nothing to change \u2014 pass at least one of verts, condition, role.");
+    if (patch.verts === void 0 && patch.condition === void 0 && patch.role === void 0 && patch.label === void 0) {
+      throw new UserError("Nothing to change \u2014 pass at least one of verts, condition, role, label.");
     }
     const s = this.sheet(cur.sheet_id);
     const role = patch.role ?? cur.measure_role;
@@ -6323,12 +6376,14 @@ var Session = class _Session {
     })();
     const before = structuredClone(cur);
     const condition_id = patch.condition !== void 0 ? this.conditionFor(patch.condition).id : cur.condition_id;
+    const nextLabel = patch.label !== void 0 ? patch.label.trim() : cur.label ?? "";
     this.shapes[i] = {
       ...cur,
       condition_id,
       measure_role: role,
       verts_norm: vertsPx.map(([x, y]) => [x / s.widthPx, y / s.heightPx]),
       computed,
+      ...nextLabel ? { label: nextLabel } : {},
       ...role === "surface_area" ? { height_ft: Number(cur.height_ft) || heightFor() } : {},
       ...cur.origin ? { origin: {
         ...cur.origin,
@@ -6338,11 +6393,13 @@ var Session = class _Session {
         ...patch.condition !== void 0 && cur.origin.assignment?.source === "schedule" ? { assignment: { source: "asserted" } } : {}
       } } : {}
     };
+    if (!nextLabel) delete this.shapes[i].label;
     this.record({ op: "edit", tool: "edit_shape", before });
     const changed = [
       ...patch.verts !== void 0 ? ["verts"] : [],
       ...patch.condition !== void 0 ? ["condition"] : [],
-      ...patch.role !== void 0 ? ["role"] : []
+      ...patch.role !== void 0 ? ["role"] : [],
+      ...patch.label !== void 0 ? ["label"] : []
     ];
     return {
       shape_id: id,
@@ -6350,6 +6407,7 @@ var Session = class _Session {
       measure_role: role,
       nverts: vertsPx.length,
       ...computed,
+      ...nextLabel ? { label: nextLabel } : {},
       agent_edits: this.shapes[i].origin?.agent_edits ?? 0
     };
   }
@@ -6477,6 +6535,16 @@ var Session = class _Session {
       uppFor: (sheetId) => this.sheets.get(sheetId)?.upp ?? null
     };
   }
+  /** The figured seam length per SHAPE, as conditionTotals wants it — the
+   * basis a materials row with basis "seam_lf" (weld rod, seam tape) divides
+   * against. computeRollTakeoff returns immediately when no condition carries
+   * a roll setup, so this costs nothing on a job that has none, and every
+   * seam_lf row on such a job reads 0 rather than guessing. */
+  seamCtx() {
+    const { dimsFor, uppFor } = this.rollInputs();
+    const { byCond } = computeRollTakeoff(this.conditions, this.shapes, dimsFor, uppFor);
+    return { seamByShape: seamLfByShape(byCond) };
+  }
   editCondition(tag, opts) {
     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.");
@@ -6991,9 +7059,9 @@ var Session = class _Session {
    * document carries the computed order quantities. */
   exportReport(projectName = "") {
     if (!this.docs.size) 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);
+    const rows = conditionTotals(this.conditions, this.shapes, { seamByShape: seamLfByShape(byCond) }).filter((r) => r.shape_count > 0);
     return reportJson({
       projectName,
       rows,
@@ -7489,6 +7557,7 @@ var listShapesOutput = {
     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"),
+    label: z.string().optional().describe("The room (or phase/area) this shape belongs to \u2014 detect_rooms stamps the room number it traced from; edit_shape sets or clears it. Absent when unlabeled"),
     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`),
@@ -7502,12 +7571,13 @@ var deleteShapeOutput = {
 };
 var editShapeOutput = {
   shape_id: z.string(),
-  changed: z.array(z.enum(["verts", "condition", "role"])).describe("Which fields this call actually changed"),
+  changed: z.array(z.enum(["verts", "condition", "role", "label"])).describe("Which fields this call actually changed"),
   measure_role: z.enum(["floor_area", "deduct", "linear", "surface_area", "count"]),
   nverts: z.number().int(),
   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)"),
+  label: z.string().optional().describe("The shape's room/phase label after this call \u2014 absent when it carries none (a cleared label reports as absent, not as an empty string)"),
   agent_edits: z.number().int().describe("How many times the agent has revised this shape \u2014 separate from the human-correction tally")
 };
 var undoLastOutput = {
@@ -7537,7 +7607,7 @@ var materialRow = z.object({
   id: z.string(),
   name: z.string(),
   per: z.number().describe("Coverage rate: basis \xF7 per = order quantity"),
-  basis: z.enum(["area", "linear", "count"]).describe("Which of the condition's totals this row's quantity is computed against"),
+  basis: z.enum(["area", "linear", "count", "seam_lf"]).describe("Which of the condition's totals this row's quantity is computed against \u2014 'seam_lf' is the FIGURED roll-layout seam length (weld rod, seam tape), 0 until the condition carries a roll_setup"),
   unit: z.string(),
   round: z.boolean().describe("true = round up to whole purchase units (the default \u2014 you buy whole bags/buckets)"),
   note: z.string().optional(),
@@ -7558,9 +7628,9 @@ var reportMaterialLine = z.object({
   name: z.string(),
   unit: z.string().describe("Purchase unit, e.g. 'gal', 'bag'"),
   per: z.number().describe("Coverage rate \u2014 basis units per purchase unit"),
-  basis: z.enum(["area", "linear", "count"]),
+  basis: z.enum(["area", "linear", "count", "seam_lf"]),
   round: z.boolean(),
-  basis_qty: z.number().describe("The condition total this row divides (SF, LF, or EA \u2014 multiplier applied, waste not)"),
+  basis_qty: z.number().describe("The condition total this row divides (SF, LF, EA, or figured seam LF \u2014 multiplier applied, waste not)"),
   qty: z.number().describe("Computed order quantity")
 }).passthrough();
 var exportReportOutput = {
@@ -8531,6 +8601,8 @@ async function buildMarkedSetPdf({ projectName, dark, sheets, shapes, markups, a
   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();
+  doc.setProducer("OpenTakeoff");
+  doc.setCreator("OpenTakeoff");
   const font = await doc.embedFont(StandardFonts.Helvetica);
   const bold = await doc.embedFont(StandardFonts.HelveticaBold);
   const ink = dark ? rgb(0.93, 0.92, 0.89) : rgb(0.13, 0.12, 0.1);
@@ -8963,6 +9035,54 @@ async function buildMarkedSetPdf({ projectName, dark, sheets, shapes, markups, a
   return { bytes, filename };
 }
 
+// src/safewrite.ts
+import { open, stat } from "node:fs/promises";
+var PDF_PRODUCER = "OpenTakeoff";
+async function head(p, n) {
+  const fh = await open(p, "r");
+  try {
+    const buf = Buffer.alloc(n);
+    const { bytesRead } = await fh.read(buf, 0, n, 0);
+    return buf.subarray(0, bytesRead);
+  } finally {
+    await fh.close();
+  }
+}
+async function isOwnExport(outPath, kind) {
+  try {
+    if (kind === "json") {
+      return /"schema"\s*:\s*"opentakeoff\./.test((await head(outPath, 4096)).toString("utf8"));
+    }
+    if ((await head(outPath, 5)).toString("latin1") !== "%PDF-") return false;
+    const { readFile: readFile4 } = await import("node:fs/promises");
+    const { PDFDocument } = await import("pdf-lib");
+    const doc = await PDFDocument.load(await readFile4(outPath), {
+      ignoreEncryption: true,
+      updateMetadata: false
+    });
+    return (doc.getProducer() ?? "").includes(PDF_PRODUCER);
+  } catch {
+    return false;
+  }
+}
+async function assertWritable(outPath, kind, overwrite) {
+  if (overwrite === true) return;
+  let st;
+  try {
+    st = await stat(outPath);
+  } catch {
+    return;
+  }
+  if (st.isDirectory()) {
+    throw new UserError(`${outPath} is a directory \u2014 pass the full file path to write, not the folder.`);
+  }
+  if (await isOwnExport(outPath, kind)) return;
+  throw new UserError(
+    `${outPath} already exists and is not an OpenTakeoff export, so writing there would destroy it. Write somewhere else, or pass overwrite: true if replacing that exact file is what you mean to do.`
+  );
+}
+var OVERWRITE_DESC = "Replace the file at path even when it is not an OpenTakeoff export. Off by default: re-exporting over a previous export of your own already overwrites without this, so you only need it to deliberately destroy an unrelated file.";
+
 // src/marked.ts
 function assignmentDisclosure(shapes, withheld = []) {
   const agent = shapes.filter((s) => s.origin?.actor === "agent");
@@ -8985,6 +9105,9 @@ async function exportMarkedPdf(session, opts) {
   if (!session.shapes.length && !session.markups.length && !session.approvals.length) {
     throw new UserError("Nothing to mark yet \u2014 commit shapes (one_click / detect_rooms / measure_polygon / measure_line with a condition) or annotate before exporting the marked set.");
   }
+  const base = file.replace(/\.pdf$/i, "");
+  const outPath = path3.resolve(opts.path ?? path3.join(path3.dirname(filePath), `${base} - marked set.pdf`));
+  await assertWritable(outPath, "pdf", opts.overwrite);
   const sheetStates = session.sheetList();
   const byFilePage = new Map(sheetStates.map((s) => [`${session.fileFor(s.key)}#${s.pageNum}`, s.page]));
   const sheets = sheetStates.map((s) => ({
@@ -9016,7 +9139,6 @@ async function exportMarkedPdf(session, opts) {
     }
     return bytes2;
   };
-  const base = file.replace(/\.pdf$/i, "");
   const machine = session.shapes.filter((s) => s.origin?.reviewed !== true).length;
   const credit = machine ? `Machine-traced via OpenTakeoff MCP \u2014 ${machine} shape${machine === 1 ? "" : "s"} pending human review` : null;
   const { bytes } = await buildMarkedSetPdf2({
@@ -9038,7 +9160,6 @@ async function exportMarkedPdf(session, opts) {
     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`));
   await writeFile(outPath, bytes);
   const markedKeys = /* @__PURE__ */ new Set([...session.shapes.map((s) => s.sheet_id), ...session.markups.map((m) => m.sheet_id), ...session.approvals.map((a) => a.sheet_id)]);
   return {
@@ -9293,7 +9414,7 @@ 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. An OCR'd scan (text layer, no vector linework) floods the rendered pixels instead (#154), disclosed per room and on origin as raster_traced. 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. Every room floods through the SAME sealed engine a single one_click runs (RFC #60 \u2014 feet-true gap sealing, door-swing wedges, the minimum-passage rule), so a batch detection and a click at the same seed measure the same square footage; each room carries the engine's account of its own trace (confidence + confidence_factors, gap_sealed_px, door_wedges, min_pass_px/min_pass_delta), and the same account rides origin on everything committed. Confidence is a review prioritizer, never a verification \u2014 a low-confidence room is a view_sheet {overlay: true} audit prompt, not a fact to bid from. 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}`,
+    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. An OCR'd scan (text layer, no vector linework) floods the rendered pixels instead (#154), disclosed per room and on origin as raster_traced. 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. Every room floods through the SAME sealed engine a single one_click runs (RFC #60 \u2014 feet-true gap sealing, door-swing wedges, the minimum-passage rule), so a batch detection and a click at the same seed measure the same square footage; each room carries the engine's account of its own trace (confidence + confidence_factors, gap_sealed_px, door_wedges, min_pass_px/min_pass_delta), and the same account rides origin on everything committed. Confidence is a review prioritizer, never a verification \u2014 a low-confidence room is a view_sheet {overlay: true} audit prompt, not a fact to bid from. With the sheet's scale set, returns area_sf/perimeter_lf per room. Every committed room carries the room number it was traced from as the shape's \`label\`, so a sweep arrives already sliced by room \u2014 that field is what the Report's per-room grouping and the workbook's floor \xD7 room tab read, and it is the one thing about a batch that cannot be recovered downstream if it is dropped. 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). Mutually exclusive with assign_from_schedule"),
@@ -9427,11 +9548,15 @@ All-or-nothing, like derive_base: an unknown tag, a transition landing on either
   }, run("takeoff_summary", () => session.summary()));
   server.registerTool("export_takeoff", {
     description: `The full "opentakeoff.takeoff_canvas.v1" annotations payload \u2014 exactly what the app autosaves, importable by it. Returned inline; pass path to also write it to disk as JSON. ${COORDS}`,
-    inputSchema: { path: z2.string().optional().describe("File path to write the payload to") },
+    inputSchema: {
+      path: z2.string().optional().describe("File path to write the payload to"),
+      overwrite: z2.boolean().optional().describe(OVERWRITE_DESC)
+    },
     outputSchema: exportTakeoffOutput
-  }, run("export_takeoff", async ({ path: outPath }) => {
+  }, run("export_takeoff", async ({ path: outPath, overwrite }) => {
     const payload = session.exportPayload();
     if (outPath) {
+      await assertWritable(outPath, "json", overwrite);
       const { writeFile: writeFile2 } = await import("node:fs/promises");
       await writeFile2(outPath, JSON.stringify(payload));
     }
@@ -9441,12 +9566,14 @@ All-or-nothing, like derive_base: an unknown tag, a transition landing on either
     description: `The computed Report document \u2014 "opentakeoff.report.v1", the same schema the canvas Report's JSON export writes. Everything a pricing consumer needs without re-implementing the app's math: per-condition quantities with waste and multiplier applied (gross and *_net), the computed materials BUY LIST per condition (order quantity = basis \xF7 coverage rate, rounded up to whole purchase units) plus the project-wide roll-up summed by (name, unit), per-sheet BASE subtotals, scale provenance per sheet, and annotations. Contrast: export_takeoff is the raw canvas payload (materials as CONFIG rows, no computed quantities) and takeoff_summary strips materials for a compact reply \u2014 when the numbers are leaving for pricing, consume this. A report alone is HALF the deliverable: pair it with export_marked_pdf, because a takeoff is reviewed on marked drawings, not on numbers. Returned inline; pass path to also write it to disk as JSON.`,
     inputSchema: {
       path: z2.string().optional().describe("File path to write the document to"),
-      project_name: z2.string().optional().describe("Label for the document's project_name field (a headless session has no project of its own; omitted \u2192 null)")
+      project_name: z2.string().optional().describe("Label for the document's project_name field (a headless session has no project of its own; omitted \u2192 null)"),
+      overwrite: z2.boolean().optional().describe(OVERWRITE_DESC)
     },
     outputSchema: exportReportOutput
-  }, run("export_report", async ({ path: outPath, project_name: projectName }) => {
+  }, run("export_report", async ({ path: outPath, project_name: projectName, overwrite }) => {
     const doc = session.exportReport(projectName);
     if (outPath) {
+      await assertWritable(outPath, "json", overwrite);
       const { writeFile: writeFile2 } = await import("node:fs/promises");
       await writeFile2(outPath, JSON.stringify(doc));
     }
@@ -9463,12 +9590,13 @@ All-or-nothing, like derive_base: an unknown tag, a transition landing on either
     description: `The MARKED-UP PLANSET \u2014 the deliverable of every takeoff. Writes a distribution-ready PDF to disk: a legend cover (per-condition totals, swatches, a by-sheet breakdown) followed by every sheet that carries takeoff shapes or annotations, vector-copied from the source plan with the work burned in as drawn \u2014 condition colors and hatches, a quantity chip on every shape, annotation clouds/callouts/highlights, and approval marks (the estimator's APPROVED rings, the agent's AGENT diamonds \u2014 the cover tallies the split). Built by the same module as the canvas's MARKED SET button, so agent output and app output are one implementation. A construction takeoff is no good without markup: finish EVERY takeoff by writing this file and giving the user its path (export_report carries the numbers for pricing; this carries the evidence). When the shapes were machine-traced and unreviewed, the document says so on its last page \u2014 the review path is importing the export_takeoff payload into the app, where agent shapes arrive as pencil proposals. Default path: next to the loaded plan as "<plan> - marked set.pdf". Needs no native canvas \u2014 pure vector copy, so it works even where view_sheet cannot render.`,
     inputSchema: {
       path: z2.string().optional().describe('Where to write the PDF (default: "<plan dir>/<plan> - marked set.pdf")'),
-      project_name: z2.string().optional().describe("Cover-page project name (default: the plan file's name)")
+      project_name: z2.string().optional().describe("Cover-page project name (default: the plan file's name)"),
+      overwrite: z2.boolean().optional().describe(OVERWRITE_DESC)
     },
     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.`,
+    description: `The mid-session shape inventory (#149): every committed shape's id, sheet, condition tag, role, quantities, room label, 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)")
@@ -9491,23 +9619,24 @@ All-or-nothing, like derive_base: an unknown tag, a transition landing on either
     outputSchema: sheetContextOutput
   }, run("sheet_context", (a) => session.sheetContext(a.sheet, { region: a.region, min_len_px: a.min_len_px, max_segments: a.max_segments })));
   server.registerTool("edit_shape", {
-    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}`,
+    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, label to name the room it belongs to, 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. label is the per-room reporting seam: detect_rooms already stamps the room number it traced from, so this is how a shape traced by hand \u2014 or one whose room number the sweep read wrong \u2014 joins the same per-room breakdown the Report and the workbook's floor \xD7 room tab group by. 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/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", "surface_area", "count"]).optional().describe("Switch what the shape measures \u2014 flipping INTO surface_area needs a height on the shape or its condition")
+      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"),
+      label: z2.string().optional().describe('The room (or phase/area) this shape belongs to, e.g. "134" or "OFFICE 101" \u2014 what per-room reporting groups by. Pass "" to clear it')
     },
     outputSchema: editShapeOutput
-  }, run("edit_shape", (a) => session.editShape(a.shape_id, { verts: a.verts, condition: a.condition, role: a.role })));
+  }, run("edit_shape", (a) => session.editShape(a.shape_id, { verts: a.verts, condition: a.condition, role: a.role, label: a.label })));
   server.registerTool("edit_materials", {
-    description: `Add, remove, or patch supporting-materials rows on a condition \u2014 the coverage-rate lines that turn a measured area/length/count into an order quantity (adhesive at N sf/gal, grout at N lf/bag, \u2026), matching the canvas's per-condition Supporting Materials panel. Each row is {name, per, basis, unit, round, note}: quantity = the condition's basis total (area/linear/count) \xF7 per, rounded up to whole purchase units unless round:false. condition names an existing OR NEW finish tag (minted on first touch, same as one_click/measure_polygon) \u2014 add alone is enough to seed materials on a condition before you've traced anything. remove/patch target existing row ids from this reply or export_takeoff (takeoff_summary strips materials for a compact quantities-only reply); a bad id 404s the WHOLE call before anything is written, and referencing an id on a tag with no condition yet errors rather than silently minting an empty one. No review gate here \u2014 materials rows are quantity config, not traced geometry, so this edits directly; undo_last reverses a call in one step (the condition's whole materials array, snapshotted before the write, restored verbatim).`,
+    description: `Add, remove, or patch supporting-materials rows on a condition \u2014 the coverage-rate lines that turn a measured area/length/count into an order quantity (adhesive at N sf/gal, grout at N lf/bag, \u2026), matching the canvas's per-condition Supporting Materials panel. Each row is {name, per, basis, unit, round, note}: quantity = the condition's basis total (area/linear/count/seam_lf) \xF7 per, rounded up to whole purchase units unless round:false. basis "seam_lf" is the one basis that is FIGURED rather than measured: it is the length where two cuts meet on the floor, read off the condition's roll layout (set roll_setup with edit_condition), which is what a heat-weld rod or a carpet seam tape is bought by. A 20-ft-wide room off a 12-ft roll seams once down its length; the same square footage as two 10-ft rooms seams not at all, and no percentage of the area or the perimeter can tell those two jobs apart. Without a roll_setup \u2014 or with no committed floor shapes to lay out \u2014 a seam_lf row reads 0, which is the honest state rather than a guess. condition names an existing OR NEW finish tag (minted on first touch, same as one_click/measure_polygon) \u2014 add alone is enough to seed materials on a condition before you've traced anything. remove/patch target existing row ids from this reply or export_takeoff (takeoff_summary strips materials for a compact quantities-only reply); a bad id 404s the WHOLE call before anything is written, and referencing an id on a tag with no condition yet errors rather than silently minting an empty one. No review gate here \u2014 materials rows are quantity config, not traced geometry, so this edits directly; undo_last reverses a call in one step (the condition's whole materials array, snapshotted before the write, restored verbatim).`,
     inputSchema: {
       condition: z2.string().describe("Finish tag, e.g. 'CPT-1'"),
       add: z2.array(z2.object({
         name: z2.string().min(1),
         per: z2.number().min(0).optional().describe("Coverage rate \u2014 basis units per purchase unit, e.g. 250 for 1 gal / 250 sf. Default 0 (quantity 0 until set)"),
-        basis: z2.enum(["area", "linear", "count"]).optional().describe("Which of the condition's totals this row divides against \u2014 default 'area' (total SF)"),
+        basis: z2.enum(["area", "linear", "count", "seam_lf"]).optional().describe("Which of the condition's totals this row divides against \u2014 default 'area' (total SF). 'seam_lf' is the figured roll-layout seam length (weld rod, seam tape), 0 until the condition carries a roll_setup"),
         unit: z2.string().optional().describe("Purchase unit, e.g. 'gal', 'bag', 'roll'"),
         round: z2.boolean().optional().describe("Round up to whole purchase units \u2014 default true"),
         note: z2.string().optional()
@@ -9759,7 +9888,7 @@ function registerResources(server, session) {
 // package.json
 var package_default = {
   name: "opentakeoff-mcp",
-  version: "0.9.32",
+  version: "0.9.35",
   mcpName: "io.github.Kentucky-ai/opentakeoff",
   type: "module",
   description: "OpenTakeoff MCP server \u2014 drive the takeoff engine from your MCP client over stdio.",
@@ -9775,7 +9904,7 @@ var package_default = {
     mcpb: "npm run build && node scripts/build-mcpb.mjs",
     prepublishOnly: "npm run typecheck && npm test && npm run build",
     typecheck: "tsc --noEmit",
-    test: "node --import tsx --test test/conformance.test.ts test/context.test.ts test/e2e.test.ts test/parity.test.ts test/raster.test.ts test/resources.test.ts test/scalewarn.test.ts test/session.test.ts test/tools.test.ts test/transitions.test.ts test/twins.test.ts test/view.test.ts"
+    test: "node --import tsx --test test/conformance.test.ts test/context.test.ts test/e2e.test.ts test/labels.test.ts test/parity.test.ts test/raster.test.ts test/resources.test.ts test/safewrite.test.ts test/scalewarn.test.ts test/session.test.ts test/tools.test.ts test/transitions.test.ts test/twins.test.ts test/view.test.ts"
   },
   dependencies: {
     "@modelcontextprotocol/sdk": "^1.12.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opentakeoff-mcp",
-  "version": "0.9.32",
+  "version": "0.9.35",
   "mcpName": "io.github.Kentucky-ai/opentakeoff",
   "type": "module",
   "description": "OpenTakeoff MCP server — drive the takeoff engine from your MCP client over stdio.",
@@ -16,7 +16,7 @@
     "mcpb": "npm run build && node scripts/build-mcpb.mjs",
     "prepublishOnly": "npm run typecheck && npm test && npm run build",
     "typecheck": "tsc --noEmit",
-    "test": "node --import tsx --test test/conformance.test.ts test/context.test.ts test/e2e.test.ts test/parity.test.ts test/raster.test.ts test/resources.test.ts test/scalewarn.test.ts test/session.test.ts test/tools.test.ts test/transitions.test.ts test/twins.test.ts test/view.test.ts"
+    "test": "node --import tsx --test test/conformance.test.ts test/context.test.ts test/e2e.test.ts test/labels.test.ts test/parity.test.ts test/raster.test.ts test/resources.test.ts test/safewrite.test.ts test/scalewarn.test.ts test/session.test.ts test/tools.test.ts test/transitions.test.ts test/twins.test.ts test/view.test.ts"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.0",