opentakeoff-mcp 0.9.31 → 0.9.33

package/README.md

@@ -121,13 +121,13 @@ includes document text, shape vertices, or result payload content.
 | `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_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`. |
 | `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. |
+| `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. |

package/dist/server-core.js

@@ -3043,6 +3043,136 @@ var fail = (err) => ({
 var round2 = (n) => +n.toFixed(2);
 var round1 = (n) => +n.toFixed(1);
 
+// ../web/src/lib/variants.ts
+var SEP = " \u2013 ";
+var ROW_LINK_FIELDS = ["id", "origin_id", "inherited"];
+function baseTagOf(tag) {
+  const s = String(tag ?? "");
+  const i = s.indexOf(SEP);
+  return (i === -1 ? s : s.slice(0, i)).trim();
+}
+function variantTag(baseOrTag, label) {
+  const base = baseTagOf(baseOrTag);
+  const l = String(label ?? "").trim();
+  return l ? `${base}${SEP}${l}` : base;
+}
+function copyRow(row, id, originId) {
+  return { ...row, id, origin_id: originId, inherited: true };
+}
+function childrenOf(conds, parentId) {
+  return conds.filter((c) => c.variant_of === parentId);
+}
+function stripLinks(patch) {
+  const out = { ...patch };
+  for (const f of ROW_LINK_FIELDS) delete out[f];
+  return out;
+}
+function mintTwin(parent, opts) {
+  const family_id = parent.family_id || opts.mintId("fam");
+  const materials = (parent.materials || []).map((r) => copyRow(r, opts.mintId("mat"), r.id));
+  const twin = {
+    ...parent,
+    id: opts.mintId("cnd"),
+    created_at: opts.nowIso(),
+    finish_tag: opts.tag || variantTag(parent.finish_tag, opts.label),
+    family_id,
+    variant_of: parent.id,
+    variant_label: String(opts.label ?? "").trim() || void 0,
+    materials,
+    ...opts.nextHatch ? { hatch: opts.nextHatch } : {}
+  };
+  delete twin.materials_dropped;
+  delete twin.updated_at;
+  if (twin.attrs && typeof twin.attrs === "object") twin.attrs = { ...twin.attrs };
+  return { twin, parentPatch: parent.family_id ? null : { family_id } };
+}
+function propagateRowPatch(conds, parentId, originId, patch, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(parentId)) return conds;
+  seen.add(parentId);
+  const clean = stripLinks(patch);
+  let out = conds;
+  for (const child of childrenOf(conds, parentId)) {
+    if ((child.materials_dropped || []).includes(originId)) continue;
+    const row = (child.materials || []).find((r) => r.origin_id === originId && r.inherited);
+    if (!row) continue;
+    out = out.map((c) => c.id !== child.id ? c : {
+      ...c,
+      materials: (c.materials || []).map((r) => r.id !== row.id ? r : { ...r, ...clean, id: r.id, origin_id: r.origin_id, inherited: true })
+    });
+    out = propagateRowPatch(out, child.id, row.id, clean, seen);
+  }
+  return out;
+}
+function propagateRowAdd(conds, parentId, parentRow, mintId, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(parentId)) return conds;
+  seen.add(parentId);
+  let out = conds;
+  for (const child of childrenOf(conds, parentId)) {
+    if ((child.materials_dropped || []).includes(parentRow.id)) continue;
+    if ((child.materials || []).some((r) => r.origin_id === parentRow.id)) continue;
+    const row = copyRow(parentRow, mintId("mat"), parentRow.id);
+    out = out.map((c) => c.id !== child.id ? c : { ...c, materials: [...c.materials || [], row] });
+    out = propagateRowAdd(out, child.id, row, mintId, seen);
+  }
+  return out;
+}
+function propagateRowRemove(conds, parentId, originId, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(parentId)) return conds;
+  seen.add(parentId);
+  let out = conds;
+  for (const child of childrenOf(conds, parentId)) {
+    const row = (child.materials || []).find((r) => r.origin_id === originId);
+    if (!row) continue;
+    if (row.inherited) {
+      out = out.map((c) => c.id !== child.id ? c : { ...c, materials: (c.materials || []).filter((r) => r.id !== row.id) });
+      out = propagateRowRemove(out, child.id, row.id, seen);
+    } else {
+      out = out.map((c) => c.id !== child.id ? c : {
+        ...c,
+        materials: (c.materials || []).map((r) => {
+          if (r.id !== row.id) return r;
+          const rest = { ...r };
+          delete rest.origin_id;
+          delete rest.inherited;
+          return rest;
+        })
+      });
+    }
+  }
+  return out;
+}
+function markRowLocal(cond, id) {
+  return {
+    ...cond,
+    materials: (cond.materials || []).map((r) => r.id === id ? { ...r, inherited: false } : r)
+  };
+}
+function dropRowLocal(cond, id) {
+  const row = (cond.materials || []).find((r) => r.id === id);
+  const materials = (cond.materials || []).filter((r) => r.id !== id);
+  if (!row?.inherited || !row.origin_id) return { ...cond, materials };
+  const dropped = [...cond.materials_dropped || []];
+  if (!dropped.includes(row.origin_id)) dropped.push(row.origin_id);
+  return { ...cond, materials, materials_dropped: dropped };
+}
+function splitFromFamily(conds, condId) {
+  return conds.map((c) => {
+    if (c.id !== condId) return c;
+    const next = {
+      ...c,
+      materials: (c.materials || []).map((r) => {
+        const rest = { ...r };
+        delete rest.origin_id;
+        delete rest.inherited;
+        return rest;
+      })
+    };
+    delete next.variant_of;
+    delete next.materials_dropped;
+    return next;
+  });
+}
+
 // ../web/src/lib/confidence.ts
 var CONF_RASTER = 0.9;
 var CONF_HATCH = 0.95;
@@ -3754,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);
@@ -3763,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 };
@@ -4110,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;
@@ -4341,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);
@@ -4394,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";
@@ -4500,6 +4675,7 @@ var PALETTE = ["#c96442", "#2f7d54", "#2563eb", "#9333ea", "#b8860b", "#0d9488",
 var HATCH_IDS = ["solid", "diag", "diag2", "cross", "diagdense", "horiz", "vert", "grid", "brick", "plank", "herring", "basket", "checker", "wave", "dots", "speckle", "iso", "honeycomb", "scan", "plus", "circuit", "topo"];
 var mintUuid2 = () => globalThis.crypto && typeof globalThis.crypto.randomUUID === "function" ? globalThis.crypto.randomUUID() : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
 var uid = (p) => `${p}-${mintUuid2()}`;
+var nowIso2 = () => (/* @__PURE__ */ new Date()).toISOString();
 var ANN_SCHEMA = "opentakeoff.takeoff_canvas.v1";
 var sanitizeApprovals2 = sanitizeApprovals;
 var applyApprovalCommand2 = applyApprovalCommand;
@@ -5352,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);
@@ -6117,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 } : {},
@@ -6126,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) };
   }
@@ -6149,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
@@ -6164,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;
@@ -6192,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,
@@ -6207,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,
@@ -6219,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
     };
   }
@@ -6249,7 +6438,19 @@ var Session = class _Session {
       if (!Object.keys(patch[i].fields).length) throw new UserError(`patch[${i}]: fields must be non-empty.`);
     }
     const c = this.conditionFor(tag);
-    const before = structuredClone(c.materials);
+    const cid = c.id;
+    const snap = [cid, ...this.descendantConditionIds(cid)].map((id) => {
+      const x = this.conditions.find((q) => q.id === id);
+      return {
+        condition_id: id,
+        before: structuredClone(x.materials),
+        ...x.materials_dropped ? { dropped_before: [...x.materials_dropped] } : {}
+      };
+    });
+    let conds = this.conditions;
+    const isParent = () => conds.some((x) => x.variant_of === cid);
+    const target = () => conds.find((x) => x.id === cid);
+    const mint = (p) => uid(p);
     const added = [];
     for (const a of add) {
       const row = {
@@ -6261,23 +6462,57 @@ var Session = class _Session {
         round: a.round ?? true,
         ...a.note ? { note: a.note } : {}
       };
-      c.materials.push(row);
+      conds = conds.map((x) => x.id !== cid ? x : { ...x, materials: [...x.materials || [], row] });
       added.push(row.id);
+      if (isParent()) conds = propagateRowAdd(conds, cid, row, mint);
     }
     const removed = new Set(remove);
-    if (removed.size) c.materials = c.materials.filter((m) => !removed.has(m.id));
+    for (const id of remove) {
+      if (target().variant_of) {
+        conds = conds.map((x) => x.id !== cid ? x : dropRowLocal(x, id));
+      } else {
+        conds = conds.map((x) => x.id !== cid ? x : { ...x, materials: (x.materials || []).filter((r) => r.id !== id) });
+        conds = propagateRowRemove(conds, cid, id);
+      }
+    }
     const patched = [];
     for (const p of patch) {
-      const m = c.materials.find((x) => x.id === p.id);
-      Object.assign(m, p.fields);
+      conds = conds.map((x) => x.id !== cid ? x : {
+        ...x,
+        materials: (x.materials || []).map((r) => {
+          if (r.id !== p.id) return r;
+          const merged = { ...r, ...p.fields, id: r.id };
+          if (r.origin_id === void 0) delete merged.origin_id;
+          else merged.origin_id = r.origin_id;
+          if (r.inherited === void 0) delete merged.inherited;
+          else merged.inherited = r.inherited;
+          return merged;
+        })
+      });
       patched.push(p.id);
-    }
-    this.record({ op: "materials", tool: "edit_materials", condition_id: c.id, before });
+      const cur = target();
+      if (cur.variant_of) {
+        conds = conds.map((x) => x.id !== cid ? x : markRowLocal(x, p.id));
+      } else if (isParent()) {
+        const row = (cur.materials || []).find((r) => r.id === p.id);
+        if (row) conds = propagateRowPatch(conds, cid, p.id, row);
+      }
+    }
+    this.conditions = conds;
+    const [primary, ...familySnap] = snap;
+    this.record({
+      op: "materials",
+      tool: "edit_materials",
+      condition_id: cid,
+      before: primary.before,
+      ...primary.dropped_before ? { dropped_before: primary.dropped_before } : {},
+      ...familySnap.length ? { family: familySnap } : {}
+    });
     return {
       condition: tag,
-      condition_id: c.id,
+      condition_id: cid,
       changed: { added, removed: [...removed], patched },
-      materials: c.materials
+      materials: target().materials
     };
   }
   /** Set a condition's quantity knobs — waste % and multiplier. Both are
@@ -6300,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.");
@@ -6347,6 +6592,117 @@ var Session = class _Session {
       ...roll ? { roll } : {}
     };
   }
+  /**
+   * Twin a condition — the same finish measured somewhere else, with its own materials.
+   *
+   * The same sheet goods over a slab and over a raised deck take the same field material and
+   * different preparation underneath. The twin carries the original's whole materials list and
+   * keeps FOLLOWING it: change a coverage rate on the original and every twin that hasn't
+   * touched that row gets it; edit a row on the twin and only that row goes local. The rule
+   * lives in web/src/lib/variants.ts — one copy, shared with the canvas, so a headless session
+   * and the app can never disagree about what a twin holds.
+   *
+   * A twin needs its OWN tag, and that is not cosmetic here: every tool in this server resolves
+   * a condition by finish tag and takes the FIRST match, so two conditions sharing one would
+   * make the second permanently unreachable — and a takeoff re-import collapses them last-wins.
+   * So the label is required and a collision is refused rather than de-collided.
+   */
+  /** Every condition below `rootId` in the family tree, children first. The
+   * propagate functions walk this same tree; undo snapshots ride it so a
+   * family edit's inverse restores exactly the set the write could touch.
+   * The `seen` guard mirrors variants.ts — a hand-edited payload with a
+   * cycle must not hang the session. */
+  descendantConditionIds(rootId) {
+    const out = [];
+    const seen = /* @__PURE__ */ new Set([rootId]);
+    const walk = (pid) => {
+      for (const child of this.conditions) {
+        if (child.variant_of === pid && !seen.has(child.id)) {
+          seen.add(child.id);
+          out.push(child.id);
+          walk(child.id);
+        }
+      }
+    };
+    walk(rootId);
+    return out;
+  }
+  duplicateCondition(tag, label) {
+    const src = this.conditions.find((x) => x.finish_tag === tag);
+    if (!src) {
+      const known = this.conditions.map((x) => x.finish_tag);
+      throw new UserError(`No condition ${JSON.stringify(tag)} to duplicate.${known.length ? ` Known tags: ${known.join(", ")}.` : ""}`);
+    }
+    const lab = String(label || "").trim();
+    if (!lab) throw new UserError("label is required \u2014 it is what gives the twin its own finish tag, and a tag is how every tool here resolves a condition.");
+    const newTag = variantTag(src.finish_tag, lab);
+    if (this.conditions.some((x) => x.finish_tag.trim().toUpperCase() === newTag.trim().toUpperCase())) {
+      throw new UserError(`A condition is already called ${JSON.stringify(newTag)} \u2014 pick a different label. Two conditions sharing a tag would make one of them unreachable to every tool.`);
+    }
+    const { twin, parentPatch } = mintTwin(src, {
+      label: lab,
+      tag: newTag,
+      mintId: (p) => uid(p),
+      nowIso: nowIso2,
+      nextHatch: HATCH_IDS[1 + (this.conditions.length + 1) % (HATCH_IDS.length - 1)]
+    });
+    if (parentPatch) Object.assign(src, parentPatch);
+    this.conditions.push(twin);
+    this.record({
+      op: "duplicate_condition",
+      tool: "duplicate_condition",
+      condition_id: twin.id,
+      parent_id: src.id,
+      parent_had_family: !parentPatch
+    });
+    return {
+      condition: newTag,
+      condition_id: twin.id,
+      variant_of: src.id,
+      variant_label: lab,
+      family_id: twin.family_id,
+      inherited_rows: (twin.materials || []).length,
+      note: `Materials follow ${src.finish_tag} until you edit them on this condition. No takeoffs came along \u2014 measure into ${newTag}.`
+    };
+  }
+  /** Cut a twin loose: every following row freezes where it stands. It KEEPS its family_id, so
+   * it still groups with its siblings — only the inheritance ends. */
+  splitCondition(tag) {
+    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(", ")}.` : ""}`);
+    }
+    const cond = c;
+    if (!cond.variant_of) {
+      return {
+        condition: tag,
+        condition_id: c.id,
+        split: false,
+        frozen_rows: 0,
+        note: "Already owns its materials \u2014 nothing was following."
+      };
+    }
+    const frozen = (cond.materials || []).filter((r) => r.inherited).length;
+    const before = structuredClone({
+      variant_of: cond.variant_of,
+      materials: cond.materials,
+      materials_dropped: cond.materials_dropped
+    });
+    const [next] = splitFromFamily([cond], cond.id);
+    Object.assign(c, next);
+    delete c.variant_of;
+    delete c.materials_dropped;
+    this.record({ op: "split_condition", tool: "split_condition", condition_id: c.id, before });
+    return {
+      condition: tag,
+      condition_id: c.id,
+      split: true,
+      frozen_rows: frozen,
+      family_id: cond.family_id,
+      note: "Frozen at its current values; edits to the original no longer reach it. It still groups with its family."
+    };
+  }
   /** 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
    * than approximating it. Reads are not journaled, so undo never has to step
@@ -6365,8 +6721,15 @@ var Session = class _Session {
         if (i >= 0) this.shapes[i] = e.before;
         undone.push({ seq: e.seq, op: e.op, tool: e.tool, shapes: i >= 0 ? 1 : 0 });
       } else if (e.op === "materials") {
-        const c = this.conditions.find((x) => x.id === e.condition_id);
-        if (c) c.materials = e.before;
+        const put = (condition_id, before, dropped) => {
+          const cc = this.conditions.find((x) => x.id === condition_id);
+          if (!cc) return;
+          cc.materials = before;
+          if (dropped === void 0) delete cc.materials_dropped;
+          else cc.materials_dropped = dropped;
+        };
+        put(e.condition_id, e.before, e.dropped_before);
+        for (const f of e.family ?? []) put(f.condition_id, f.before, f.dropped_before);
         undone.push({ seq: e.seq, op: e.op, tool: e.tool, shapes: 0 });
       } else if (e.op === "condition") {
         const c = this.conditions.find((x) => x.id === e.condition_id);
@@ -6379,6 +6742,24 @@ var Session = class _Session {
           else c.roll_setup = e.before.roll_setup;
         }
         undone.push({ seq: e.seq, op: e.op, tool: e.tool, shapes: 0 });
+      } else if (e.op === "duplicate_condition") {
+        const at = this.conditions.findIndex((x) => x.id === e.condition_id);
+        if (at >= 0) this.conditions.splice(at, 1);
+        if (!e.parent_had_family) {
+          const parent = this.conditions.find((x) => x.id === e.parent_id);
+          if (parent) delete parent.family_id;
+        }
+        undone.push({ seq: e.seq, op: e.op, tool: e.tool, shapes: 0 });
+      } else if (e.op === "split_condition") {
+        const c = this.conditions.find((x) => x.id === e.condition_id);
+        if (c) {
+          if (e.before.variant_of === void 0) delete c.variant_of;
+          else c.variant_of = e.before.variant_of;
+          c.materials = structuredClone(e.before.materials);
+          if (e.before.materials_dropped === void 0) delete c.materials_dropped;
+          else c.materials_dropped = structuredClone(e.before.materials_dropped);
+        }
+        undone.push({ seq: e.seq, op: e.op, tool: e.tool, shapes: 0 });
       } else if (e.op === "approval") {
         this.approvals = applyApprovalCommand2(this.approvals, e.inverse).approvals;
         undone.push({ seq: e.seq, op: e.op, tool: e.tool, shapes: 0 });
@@ -6678,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,
@@ -7176,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`),
@@ -7189,19 +7571,20 @@ 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 = {
   undone: z.number().int().describe("Steps actually reversed"),
   steps: z.array(z.object({
     seq: z.number().int(),
-    op: z.enum(["commit", "edit", "delete", "materials", "condition", "approval"]),
+    op: z.enum(["commit", "edit", "delete", "materials", "condition", "approval", "duplicate_condition", "split_condition"]),
     tool: z.string().describe("The tool call this step came from"),
     shapes: z.number().int().describe("Shapes affected by reversing this step \u2014 0 for a materials step (it restores a condition's supporting-materials rows, not shapes), for a condition step (it restores the waste/multiplier pair), and for an approval step (it re-seats or removes a verdict mark)")
   })).describe("Newest first"),
@@ -7224,10 +7607,12 @@ 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()
+  note: z.string().optional(),
+  origin_id: z.string().optional().describe("On a twin: the parent row this one follows (the variants.ts family link)"),
+  inherited: z.boolean().optional().describe("On a twin: true while the row still follows the family \u2014 a patch on it takes it local, split_condition freezes them all")
 });
 var editMaterialsOutput = {
   condition: z.string().describe("The finish tag passed in"),
@@ -7243,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 = {
@@ -7282,6 +7667,23 @@ var exportMarkedPdfOutput = {
   approvals_drawn: z.number().int().describe("Approval-family glyphs burned in (#176) \u2014 estimator APPROVED rings + agent AGENT diamonds; the cover tallies the split when any exist"),
   note: z.string()
 };
+var duplicateConditionOutput = {
+  condition: z.string().describe("The twin's finish tag \u2014 base tag + the label, e.g. 'CPT-1 \u2013 Level 2'"),
+  condition_id: z.string().describe("The TWIN \u2014 measure the new area against this"),
+  variant_of: z.string().describe("The condition whose material rows this one follows"),
+  variant_label: z.string(),
+  family_id: z.string().describe("Shared by every variant of this finish \u2014 survives a split"),
+  inherited_rows: z.number().int().describe("Material rows copied, all still following the original"),
+  note: z.string()
+};
+var splitConditionOutput = {
+  condition: z.string(),
+  condition_id: z.string(),
+  split: z.boolean().describe("false = it already owned its materials; nothing was following"),
+  frozen_rows: z.number().int().describe("Following rows frozen at their current values"),
+  family_id: z.string().optional().describe("Kept \u2014 it still groups with its siblings"),
+  note: z.string()
+};
 var editConditionOutput = {
   condition: z.string().describe("The finish tag passed in"),
   condition_id: z.string(),
@@ -8789,6 +9191,7 @@ function mergeTakeoffImport(current, imported, knownFiles = null) {
   const byTag = new Map(conditions.map((c) => [tagKey(c.finish_tag), c.id]));
   const condIds = new Set(conditions.map((c) => c.id));
   const condMap = /* @__PURE__ */ new Map();
+  const addedCondIds = /* @__PURE__ */ new Set();
   let condMerged = 0, condAdded = 0;
   for (const c of impConds) {
     const hit = byTag.get(tagKey(c.finish_tag));
@@ -8803,8 +9206,23 @@ function mergeTakeoffImport(current, imported, knownFiles = null) {
     condIds.add(id);
     byTag.set(tagKey(c.finish_tag), id);
     condMap.set(c.id, id);
+    addedCondIds.add(id);
     condAdded++;
   }
+  for (let i = 0; i < conditions.length; i++) {
+    const c = conditions[i];
+    if (!c?.variant_of || !addedCondIds.has(c.id)) continue;
+    const mapped = condMap.get(c.variant_of);
+    const parentArrived = !!mapped && addedCondIds.has(mapped);
+    if (parentArrived && mapped !== c.variant_of) {
+      conditions[i] = { ...c, variant_of: mapped };
+    } else if (!parentArrived) {
+      const next = { ...c, materials: (c.materials || []).map(({ origin_id: _o, inherited: _i, ...m }) => m) };
+      delete next.variant_of;
+      delete next.materials_dropped;
+      conditions[i] = next;
+    }
+  }
   const shapeIds = new Set(arr(cur.shapes).map((s) => s.id));
   const addedShapes = impShapes.filter((s) => !shapeIds.has(s.id)).map((s) => condMap.has(s.condition_id) && condMap.get(s.condition_id) !== s.condition_id ? { ...s, condition_id: condMap.get(s.condition_id) } : s);
   const markupIds = new Set(arr(cur.markups).map((m) => m?.id).filter(Boolean));
@@ -8945,7 +9363,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"),
@@ -9120,7 +9538,7 @@ All-or-nothing, like derive_base: an unknown tag, a transition landing on either
     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)")
@@ -9143,23 +9561,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()
@@ -9195,6 +9614,21 @@ All-or-nothing, like derive_base: an unknown tag, a transition landing on either
     },
     outputSchema: editConditionOutput
   }, 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("duplicate_condition", {
+    description: `Twin a condition \u2014 the same finish measured somewhere else, with its own supporting materials. One finish in two areas is not two conditions and it is not one either: the same sheet goods over a slab and over a raised deck take the same field material and different preparation underneath (one wants a moisture barrier, the other a primer and a different adhesive). The twin arrives carrying the original's whole materials list and keeps FOLLOWING it \u2014 change a coverage rate on the original and every twin that has not touched that row gets it; edit a row on the twin and only THAT row stops following. \`label\` is REQUIRED and becomes the tag suffix ('CPT-1' + 'Level 2' \u2192 'CPT-1 \u2013 Level 2'), because every tool in this server resolves a condition by finish tag and takes the FIRST match: two conditions sharing a tag would make one permanently unreachable, and a takeoff re-import collapses them last-wins. A label already in use is refused rather than de-collided. No takeoffs come along \u2014 measure the new area against the returned condition_id. Reversible with undo_last; use split_condition to end the inheritance permanently.`,
+    inputSchema: {
+      condition: z2.string().describe("Finish tag of the condition to twin, e.g. 'CPT-1'"),
+      label: z2.string().describe("What makes this one different, usually the area: 'Level 2', 'Building B', 'Phase 2'")
+    },
+    outputSchema: duplicateConditionOutput
+  }, run("duplicate_condition", (a) => session.duplicateCondition(a.condition, a.label)));
+  server.registerTool("split_condition", {
+    description: `Cut a twin loose from its family: every following material row freezes at its current values and edits to the original stop reaching it. It keeps its finish tag and still groups with its siblings \u2014 only the inheritance ends. Use when two variants have diverged far enough that following one another is wrong. A condition that already owns its materials returns split:false rather than erroring. Reversible with undo_last.`,
+    inputSchema: {
+      condition: z2.string().describe("Finish tag of the twin to split, e.g. 'CPT-1 \u2013 Level 2'")
+    },
+    outputSchema: splitConditionOutput
+  }, run("split_condition", (a) => session.splitCondition(a.condition)));
   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: {
@@ -9396,7 +9830,7 @@ function registerResources(server, session) {
 // package.json
 var package_default = {
   name: "opentakeoff-mcp",
-  version: "0.9.31",
+  version: "0.9.33",
   mcpName: "io.github.Kentucky-ai/opentakeoff",
   type: "module",
   description: "OpenTakeoff MCP server \u2014 drive the takeoff engine from your MCP client over stdio.",
@@ -9412,7 +9846,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/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/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.31",
+  "version": "0.9.33",
   "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/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/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",