opentakeoff-mcp 0.9.30 → 0.9.32

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;
@@ -4500,6 +4630,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;
@@ -6249,7 +6380,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 +6404,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
@@ -6347,6 +6524,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 +6653,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 +6674,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 });
@@ -7201,7 +7514,7 @@ 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"),
@@ -7227,7 +7540,9 @@ var materialRow = z.object({
   basis: z.enum(["area", "linear", "count"]).describe("Which of the condition's totals this row's quantity is computed against"),
   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"),
@@ -7282,6 +7597,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 +9121,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 +9136,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));
@@ -9195,6 +9543,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 +9759,7 @@ function registerResources(server, session) {
 // package.json
 var package_default = {
   name: "opentakeoff-mcp",
-  version: "0.9.30",
+  version: "0.9.32",
   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 +9775,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/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.30",
+  "version": "0.9.32",
   "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/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",