opentakeoff-mcp 0.9.2 → 0.9.3

package/dist/server-core.js

@@ -28,6 +28,19 @@ import * as pdfjs from "pdfjs-dist";
 
 // ../web/src/lib/sheets.ts
 import * as pdfjsLib from "pdfjs-dist";
+
+// ../web/src/lib/sheetKey.ts
+function parseSheetKey(key) {
+  const i = key.lastIndexOf("#");
+  if (i > 0 && /^\d+$/.test(key.slice(i + 1))) return { file: key.slice(0, i), page: parseInt(key.slice(i + 1), 10) };
+  return { file: key, page: 1 };
+}
+function compareSheetKeys(ka, kb) {
+  const a = parseSheetKey(ka), b = parseSheetKey(kb);
+  return a.file === b.file ? a.page - b.page : a.file.localeCompare(b.file);
+}
+
+// ../web/src/lib/sheets.ts
 var RENDER_SCALE = 2;
 var PX_PER_IN = 72 * RENDER_SCALE;
 var arch = (inPerFt) => 1 / inPerFt / PX_PER_IN;
@@ -256,6 +269,7 @@ var LEAK_FRACTION = 0.3;
 var TINY_PX = 30;
 var MIN_THICK = 4;
 var CURVE_STEPS = 8;
+var GAP_BRIDGE_MAX = 2;
 var SEG_CURVE = 1;
 var SEG_CLIP = 2;
 var SEG_FILLONLY = 4;
@@ -718,24 +732,60 @@ function floodPass(maskObj, ix, iy, barrier) {
   if (count < TINY_PX || bx1 - bx0 + 1 < MIN_THICK || by1 - by0 + 1 < MIN_THICK) return { status: "tiny", count };
   return { status: "ok", region, count, mw, mh, ws, hardHits, softHits };
 }
+function dilateHard(maskObj, r) {
+  const { mask, mw, mh, ws, softCount } = maskObj;
+  const horiz = new Uint8Array(mask);
+  for (let y = 0; y < mh; y++) {
+    const row = y * mw;
+    for (let x = 0; x < mw; x++) {
+      if (mask[row + x] & 1) {
+        const x1 = Math.min(mw - 1, x + r);
+        for (let i = Math.max(0, x - r); i <= x1; i++) horiz[row + i] |= 1;
+      }
+    }
+  }
+  const out = new Uint8Array(horiz);
+  for (let y = 0; y < mh; y++) {
+    const row = y * mw;
+    for (let x = 0; x < mw; x++) {
+      if (horiz[row + x] & 1) {
+        const y1 = Math.min(mh - 1, y + r);
+        for (let j = Math.max(0, y - r); j <= y1; j++) out[j * mw + x] |= 1;
+      }
+    }
+  }
+  return { mask: out, mw, mh, ws, softCount };
+}
 function floodRegion(maskObj, ix, iy, sensitivity = SENS_BALANCED) {
-  const r1 = floodPass(maskObj, ix, iy, 3);
-  if (!maskObj.softCount) return r1;
-  if (r1.status === "leak") return r1;
-  const { escalateFrac, growthMax } = escalationParams(sensitivity);
-  let growthCap = Infinity;
-  if (r1.status === "ok") {
-    const blocks = (r1.hardHits || 0) + (r1.softHits || 0);
-    const softFrac = blocks ? (r1.softHits || 0) / blocks : 0;
-    if (softFrac < escalateFrac) return r1;
-    if (softFrac < HATCH_BOUND_FRAC) growthCap = growthMax;
-  }
-  const r2 = floodPass(maskObj, ix, iy, 1);
-  if (r2.status === "ok" && (r1.status !== "ok" || r2.count <= r1.count * growthCap)) {
-    r2.hatchFiltered = true;
-    return r2;
-  }
-  return r1;
+  const attempt = (m) => {
+    const r1 = floodPass(m, ix, iy, 3);
+    if (!m.softCount) return r1;
+    if (r1.status === "leak") return r1;
+    const { escalateFrac, growthMax } = escalationParams(sensitivity);
+    let growthCap = Infinity;
+    if (r1.status === "ok") {
+      const blocks = (r1.hardHits || 0) + (r1.softHits || 0);
+      const softFrac = blocks ? (r1.softHits || 0) / blocks : 0;
+      if (softFrac < escalateFrac) return r1;
+      if (softFrac < HATCH_BOUND_FRAC) growthCap = growthMax;
+    }
+    const r2 = floodPass(m, ix, iy, 1);
+    if (r2.status === "ok" && (r1.status !== "ok" || r2.count <= r1.count * growthCap)) {
+      r2.hatchFiltered = true;
+      return r2;
+    }
+    return r1;
+  };
+  const r = attempt(maskObj);
+  if (r.status !== "leak") return r;
+  for (let br = 1; br <= GAP_BRIDGE_MAX; br++) {
+    const rb = attempt(dilateHard(maskObj, br));
+    if (rb.status === "ok") {
+      rb.gapBridged = br;
+      return rb;
+    }
+  }
+  return r;
 }
 function traceRegion(reg, epsMaskPx = 1.5) {
   const { region, mw, mh, ws } = reg;
@@ -905,6 +955,12 @@ function openLen(pts) {
 // ../web/src/lib/num.js
 var round22 = (n) => Math.round((n + Number.EPSILON) * 100) / 100;
 
+// ../web/src/lib/conditionColumns.js
+var visible = (v) => typeof v === "string" && v.trim() ? v : "";
+function attrValue(attrs, colId) {
+  return visible(attrs?.[colId]);
+}
+
 // ../web/src/lib/totals.js
 function accumulateRole(acc, s) {
   const cp = s.computed || {};
@@ -977,6 +1033,63 @@ function conditionTotals(conditions, shapes) {
     };
   });
 }
+function sheetTotals(conditions, shapes) {
+  const bySheet = /* @__PURE__ */ new Map();
+  for (const s of shapes) {
+    let conds = bySheet.get(s.sheet_id);
+    if (!conds) {
+      conds = /* @__PURE__ */ new Map();
+      bySheet.set(s.sheet_id, conds);
+    }
+    let a = conds.get(s.condition_id);
+    if (!a) {
+      a = { n: 0, floor: 0, wall: 0, border: 0, lf: 0, ea: 0 };
+      conds.set(s.condition_id, a);
+    }
+    a.n += 1;
+    accumulateRole(a, s);
+  }
+  const order = [...bySheet.keys()].sort((ka, kb) => compareSheetKeys(String(ka), String(kb)));
+  return order.map((sheet_id) => {
+    const conds = bySheet.get(sheet_id);
+    const rows = conditions.filter((c) => conds.has(c.id)).map((c) => {
+      const a = conds.get(c.id);
+      return {
+        id: c.id,
+        finish_tag: c.finish_tag,
+        color: c.color,
+        multiplier: c.multiplier || 1,
+        shape_count: a.n,
+        floor_sf: a.floor,
+        wall_sf: a.wall,
+        border_sf: a.border,
+        lf: a.lf,
+        ea: a.ea
+      };
+    });
+    return { sheet_id, rows };
+  }).filter((g) => g.rows.length);
+}
+function roundSheetRow(r) {
+  return {
+    ...r,
+    floor_sf: round22(r.floor_sf),
+    wall_sf: round22(r.wall_sf),
+    border_sf: round22(r.border_sf),
+    lf: round22(r.lf),
+    ea: round22(r.ea)
+  };
+}
+function materialsSummary(rows) {
+  const map = /* @__PURE__ */ new Map();
+  for (const r of rows) for (const m of r.materials || []) {
+    const key = `${m.name}\0${m.unit}`;
+    const cur = map.get(key) || { name: m.name, unit: m.unit, qty: 0 };
+    cur.qty += m.qty;
+    map.set(key, cur);
+  }
+  return [...map.values()].map((x) => ({ ...x, qty: round22(x.qty) }));
+}
 function grandTotals(rows) {
   const sum = (k) => rows.reduce((n, r) => n + (r[k] || 0), 0);
   return {
@@ -988,6 +1101,90 @@ function grandTotals(rows) {
     sy_net: round22(sum("sy_net"))
   };
 }
+function reportJson({ projectName = "", rows = [], bySheet = [], scaleInfo = [], markups = [], rfis = [], sheetLabel = null, conditionColumns = [], attrsByCond = null, shapeLabels = [], byLabel = [], displayUnits = "imperial" }) {
+  const label = (id) => sheetLabel ? sheetLabel(id) : id;
+  const colDefs = (Array.isArray(conditionColumns) ? conditionColumns : []).filter((cc) => cc && typeof cc === "object" && typeof cc.id === "string");
+  const attrs = attrsByCond instanceof Map ? attrsByCond : /* @__PURE__ */ new Map();
+  return {
+    schema: "opentakeoff.report.v1",
+    project_name: projectName || null,
+    generated_with: "OpenTakeoff",
+    sheets: scaleInfo.map((si) => ({ sheet_id: si.sheet_id, sheet: label(si.sheet_id), scale_source: si.scale_source ?? si.source ?? "unknown" })),
+    // custom-column values APPEND after materials (row key order otherwise
+    // untouched). Iterating the DEFINED columns — never raw attrs — naturally
+    // drops orphaned colIds; attrValue (the shared assigned-value rule) keeps
+    // corrupted and empty values out of the export.
+    conditions: rows.map((r) => ({
+      ...r,
+      columns: colDefs.flatMap((cc) => {
+        const v = attrValue(attrs.get(r.id), cc.id);
+        return v ? [{ id: cc.id, name: cc.name, value: v }] : [];
+      })
+    })),
+    by_sheet: bySheet.map((gp) => ({
+      sheet_id: gp.sheet_id,
+      sheet: label(gp.sheet_id),
+      rows: gp.rows.map(roundSheetRow)
+    })),
+    totals: grandTotals(rows),
+    materials: materialsSummary(rows),
+    // id + rfi_id APPEND after the original four keys (the additive-only v1
+    // convention — see scale_source above): a cloud with empty text was fully
+    // anonymous in the export. Legacy markups: id → null, rfi_id → "".
+    // condition_id + condition APPEND again, same rule. condition is the
+    // resolved finish_tag rather than only the id, so a reader of the export
+    // can see WHICH scope an annotation is about without joining two arrays;
+    // the id stays authoritative. Unattached markups: "" for both.
+    markups: markups.map((m) => {
+      const c = m.condition_id ? (rows || []).find((r) => r.id === m.condition_id) : null;
+      return { type: m.type, sheet_id: m.sheet_id, sheet: label(m.sheet_id), text: m.text || "", id: m.id ?? null, rfi_id: m.rfi_id || "", condition_id: m.condition_id || "", condition: c?.finish_tag || "" };
+    }),
+    // rfis APPENDS after markups (additive-only v1 — old exports had no RFI
+    // register). linked_markups/linked_sheets are DERIVED from markup.rfi_id,
+    // never a second store of the link.
+    rfis: (rfis || []).map((r) => {
+      const linked = (markups || []).filter((m) => m.rfi_id === r.id);
+      return {
+        id: r.id ?? null,
+        number: r.number || "",
+        subject: r.subject || "",
+        question: r.question || "",
+        status: r.status || "open",
+        to: r.to || "",
+        priority: r.priority || "",
+        cost_impact: !!r.cost_impact,
+        schedule_impact: !!r.schedule_impact,
+        date: r.date || "",
+        response: r.response || "",
+        response_date: r.response_date || "",
+        sheet_id: r.sheet_id ?? null,
+        sheet: r.sheet_id != null ? label(r.sheet_id) : null,
+        linked_markups: linked.length,
+        linked_sheets: [...new Set(linked.map((m) => label(m.sheet_id)))]
+      };
+    }),
+    // the custom-column definitions themselves, so row `columns` values can be
+    // read against the project vocabulary
+    condition_columns: colDefs.map(({ id, name, values }) => ({ id, name, values: Array.isArray(values) ? values : [] })),
+    // shape-level phase/area labels (#112) APPEND after condition_columns and
+    // are always emitted (empty when unused) per the additive-only v1 rule:
+    // shape_labels is the project vocabulary; by_label is the group-by-label
+    // breakdown — ORDERED per-bucket quantities (waste/×N applied), matching the
+    // report's interactive view, unlike the BASE by_sheet reference above.
+    shape_labels: (Array.isArray(shapeLabels) ? shapeLabels : []).filter((v) => typeof v === "string" && v.trim()),
+    by_label: (Array.isArray(byLabel) ? byLabel : []).map((gp) => ({
+      label: gp.value ?? null,
+      // null = Unlabeled
+      rows: (gp.rows || []).map((r) => ({ id: r.id, finish_tag: r.finish_tag, floor_sf: r.floor_sf, wall_sf: r.wall_sf, border_sf: r.border_sf, lf: r.lf, ea: r.ea, total_sf: r.total_sf, total_sf_net: r.total_sf_net }))
+    })),
+    // units metadata APPENDS last (additive-only v1): every quantity above is
+    // RAW internal feet (SF/LF/SY keys, uninterpretable otherwise); this is
+    // the display system the exporting user was reading — the units port's
+    // "JSON stays raw, but says so" contract.
+    units: "imperial (SF/LF \u2014 raw internal values)",
+    display_units: displayUnits === "metric" ? "metric" : "imperial"
+  };
+}
 
 // src/view.ts
 var INK = "#d91a1a";
@@ -1292,13 +1489,13 @@ var Session = class {
       const x1 = geo.segs[i * 4], y1 = geo.segs[i * 4 + 1], x2 = geo.segs[i * 4 + 2], y2 = geo.segs[i * 4 + 3];
       if (segIntersectsRect(x1, y1, x2, y2, r)) inRegion.push({ i, len: Math.hypot(x2 - x1, y2 - y1) });
     }
-    const visible = inRegion.filter((e) => e.len >= minLen);
-    const droppedShort = inRegion.length - visible.length;
-    let kept = visible;
+    const visible2 = inRegion.filter((e) => e.len >= minLen);
+    const droppedShort = inRegion.length - visible2.length;
+    let kept = visible2;
     let droppedCap = 0;
-    if (visible.length > cap) {
-      kept = visible.slice().sort((a, b) => b.len - a.len).slice(0, cap);
-      droppedCap = visible.length - cap;
+    if (visible2.length > cap) {
+      kept = visible2.slice().sort((a, b) => b.len - a.len).slice(0, cap);
+      droppedCap = visible2.length - cap;
     }
     const segments = [], metaOut = [], family = [];
     for (const { i } of kept) {
@@ -1402,6 +1599,7 @@ var Session = class {
       throw new UserError("Provide exactly one of: label, upp, calibrate, use_detected.");
     }
     s.upp = upp;
+    s.scaleSource = source === "label" ? "standard" : source === "calibrate" ? "calibrated" : source;
     return { sheet: s.key, upp, ...label ? { label } : {}, source };
   }
   conditionFor(tag) {
@@ -1452,6 +1650,7 @@ var Session = class {
       status: "ok",
       nverts: ring.length,
       ...f.hatchFiltered ? { hatch_filtered: true } : {},
+      ...f.gapBridged ? { gap_bridged_px: f.gapBridged } : {},
       ...opts.returnVerts ? { verts: ring.map(([vx, vy]) => [round1(vx), round1(vy)]) } : {}
     };
     if (s.upp == null) {
@@ -1473,6 +1672,7 @@ var Session = class {
         seed_norm: [x / s.widthPx, y / s.heightPx],
         reviewed: false,
         ...f.hatchFiltered ? { hatch_filtered: true } : {},
+        ...f.gapBridged ? { gap_bridged_px: f.gapBridged } : {},
         // canvas-parity provenance: a non-default fill sensitivity is part of
         // how the shape was made (ShapeOrigin.fill_sensitivity)
         ...opts.sensitivity !== void 0 && opts.sensitivity !== SENS_BALANCED ? { fill_sensitivity: opts.sensitivity } : {}
@@ -1526,7 +1726,7 @@ var Session = class {
     const byRing = /* @__PURE__ */ new Map();
     const order = [];
     for (const lb of labels) {
-      let ring = null, hatch = false, seed = null;
+      let ring = null, hatch = false, gap = 0, seed = null;
       let sawBubble = false, sawDegenerate = false;
       for (const probe of seedLadderPx(lb.bbox)) {
         const f = floodRegion(mask, probe[0], probe[1], opts.sensitivity ?? SENS_BALANCED);
@@ -1542,6 +1742,7 @@ var Session = class {
         }
         ring = r;
         hatch = !!f.hatchFiltered;
+        gap = f.gapBridged || 0;
         seed = probe;
         break;
       }
@@ -1564,6 +1765,7 @@ var Session = class {
         perimPx: closedMetrics(ring).perim,
         seed,
         hatch,
+        gap,
         merged: []
       };
       byRing.set(key, cand);
@@ -1576,6 +1778,7 @@ var Session = class {
         nverts: c.ring.length,
         ...c.merged.length ? { merged_labels: c.merged } : {},
         ...c.hatch ? { hatch_filtered: true } : {},
+        ...c.gap ? { gap_bridged_px: c.gap } : {},
         ...opts.returnVerts ? { verts: c.ring.map(([vx, vy]) => [round1(vx), round1(vy)]) } : {}
       };
       if (upp == null) {
@@ -1594,7 +1797,8 @@ var Session = class {
           actor: "agent",
           seed_norm: [c.seed[0] / s.widthPx, c.seed[1] / s.heightPx],
           reviewed: false,
-          ...c.hatch ? { hatch_filtered: true } : {}
+          ...c.hatch ? { hatch_filtered: true } : {},
+          ...c.gap ? { gap_bridged_px: c.gap } : {}
         }).id;
       }
       return { ...common, area_sf, perimeter_lf, ...shape_id ? { shape_id } : {} };
@@ -1771,6 +1975,30 @@ var Session = class {
       materials: c.materials
     };
   }
+  /** Set a condition's quantity knobs — waste % and multiplier. Both are
+   * emitted by takeoff_summary (`waste_pct`, the `*_net` order quantities) and
+   * carried by every export, but nothing in the tool surface could set them,
+   * so an agent's takeoff always shipped net === gross (#131). Same class as
+   * editMaterials — quantity config, not traced geometry, so no review gate —
+   * but resolve-or-error rather than mint-on-first-touch: these knobs only
+   * mean anything on a condition that exists, and a typo'd tag must error,
+   * not create an empty condition as a side effect. One journal entry
+   * snapshots both knobs; undo restores them verbatim. */
+  editCondition(tag, opts) {
+    if (opts.waste_pct === void 0 && opts.multiplier === void 0) {
+      throw new UserError("Nothing to change \u2014 pass at least one of waste_pct, multiplier.");
+    }
+    const c = this.conditions.find((x) => x.finish_tag === tag);
+    if (!c) {
+      const known = this.conditions.map((x) => x.finish_tag);
+      throw new UserError(`No condition ${JSON.stringify(tag)}.${known.length ? ` Known tags: ${known.join(", ")}.` : " Nothing has minted a condition yet \u2014 commit a measurement or add materials first."}`);
+    }
+    const before = { waste_pct: c.waste_pct, multiplier: c.multiplier };
+    if (opts.waste_pct !== void 0) c.waste_pct = opts.waste_pct;
+    if (opts.multiplier !== void 0) c.multiplier = opts.multiplier;
+    this.record({ op: "condition", tool: "edit_condition", condition_id: c.id, before });
+    return { condition: tag, condition_id: c.id, waste_pct: c.waste_pct, multiplier: c.multiplier };
+  }
   /** 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
@@ -1792,6 +2020,13 @@ var Session = class {
         const c = this.conditions.find((x) => x.id === e.condition_id);
         if (c) c.materials = e.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);
+        if (c) {
+          c.waste_pct = e.before.waste_pct;
+          c.multiplier = e.before.multiplier;
+        }
+        undone.push({ seq: e.seq, op: e.op, tool: e.tool, shapes: 0 });
       } else {
         for (const { shape, index } of e.removed) {
           this.shapes.splice(Math.min(index, this.shapes.length), 0, shape);
@@ -1914,6 +2149,25 @@ var Session = class {
       sheet_levels: {}
     };
   }
+  /** The computed Report document — "opentakeoff.report.v1", the SAME schema
+   * and math as the canvas Report's JSON export (web reportJson, totals.js):
+   * per-condition quantities with waste and multiplier applied, the computed
+   * materials buy list, per-sheet BASE subtotals, scale provenance. This is
+   * the contract a pricing consumer reads (#130) — export_takeoff carries
+   * materials as CONFIG rows and takeoff_summary strips them; only this
+   * document carries the computed order quantities. */
+  exportReport() {
+    if (!this.doc) throw new UserError("No plan loaded \u2014 call load_plan first.");
+    const rows = conditionTotals(this.conditions, this.shapes).filter((r) => r.shape_count > 0);
+    return reportJson({
+      projectName: "",
+      rows,
+      bySheet: sheetTotals(this.conditions, this.shapes),
+      scaleInfo: [...this.sheets.values()].filter((s) => s.upp != null).map((s) => ({ sheet_id: s.key, scale_source: s.scaleSource ?? "unknown" })),
+      markups: this.markups,
+      rfis: []
+    });
+  }
   readSheetText(name, region) {
     const s = this.sheet(name);
     const items = region ? s.text.filter((t) => t.x >= region.x0 && t.x <= region.x1 && t.y >= region.y0 && t.y <= region.y1) : s.text;
@@ -2004,6 +2258,7 @@ var oneClickOutput = {
   status: z.literal("ok"),
   nverts: z.number().int().describe("Vertex count of the traced polygon"),
   hatch_filtered: z.literal(true).optional().describe("Present when hatch/pattern linework was classified out of the boundary"),
+  gap_bridged_px: z.number().optional().describe("Present when the seal ladder bridged a drafting pinhole this many px wide to close the region \u2014 the rescue rides provenance (origin.gap_bridged_px) rather than passing as a clean fill"),
   verts: z.array(point).optional().describe("Traced polygon vertices (image px), when return_verts was set"),
   area_sf: z.number().optional().describe("Scaled mode: traced area in SF"),
   perimeter_lf: z.number().optional().describe("Scaled mode: traced perimeter in LF"),
@@ -2017,6 +2272,7 @@ var detectedRoom = z.object({
   nverts: z.number().int().describe("Vertex count of the traced polygon"),
   merged_labels: z.array(z.string()).optional().describe("Other labels that flooded to this same region \u2014 the area is counted once, under `label`"),
   hatch_filtered: z.literal(true).optional().describe("Present when hatch/pattern linework was classified out of the boundary"),
+  gap_bridged_px: z.number().optional().describe("Present when the seal ladder bridged a drafting pinhole this many px wide to close the region"),
   verts: z.array(point).optional().describe("Traced polygon vertices (image px), when return_verts was set"),
   area_sf: z.number().optional().describe("Scaled mode: traced area in SF"),
   perimeter_lf: z.number().optional().describe("Scaled mode: traced perimeter in LF"),
@@ -2126,9 +2382,9 @@ 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"]),
+    op: z.enum(["commit", "edit", "delete", "materials", "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)")
+    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) and for a condition step (it restores the waste/multiplier pair)")
   })).describe("Newest first"),
   shape_count: z.number().int().describe("Committed shapes after the undo"),
   remaining: z.number().int().describe("Steps still available to undo"),
@@ -2164,6 +2420,45 @@ var editMaterialsOutput = {
   }),
   materials: z.array(materialRow).describe("The condition's full materials array after this write")
 };
+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"]),
+  round: z.boolean(),
+  basis_qty: z.number().describe("The condition total this row divides (SF, LF, or EA \u2014 multiplier applied, waste not)"),
+  qty: z.number().describe("Computed order quantity")
+}).passthrough();
+var exportReportOutput = {
+  schema: z.literal("opentakeoff.report.v1"),
+  project_name: z.string().nullable(),
+  generated_with: z.string(),
+  sheets: z.array(z.object({ sheet_id: z.string(), sheet: z.string(), scale_source: z.string() }).passthrough()).describe("Scale provenance per sheet \u2014 how each scale was set"),
+  conditions: z.array(summaryRow.extend({ materials: z.array(reportMaterialLine) }).passthrough()).describe("conditionTotals rows: gross + *_net quantities AND the computed materials buy list"),
+  by_sheet: z.array(z.object({ sheet_id: z.string(), sheet: z.string(), rows: z.array(z.record(z.unknown())) }).passthrough()).describe("BASE per-sheet subtotals \u2014 multiplier NOT applied, no waste, no materials"),
+  totals: z.object({
+    total_sf: z.number(),
+    total_sf_net: z.number(),
+    lf: z.number(),
+    lf_net: z.number(),
+    ea: z.number(),
+    sy_net: z.number()
+  }).passthrough(),
+  materials: z.array(z.object({ name: z.string(), unit: z.string(), qty: z.number() }).passthrough()).describe("Project-wide buy list \u2014 condition rows summed by (name, unit)"),
+  markups: z.array(z.record(z.unknown())),
+  rfis: z.array(z.record(z.unknown())),
+  condition_columns: z.array(z.record(z.unknown())),
+  shape_labels: z.array(z.string()),
+  by_label: z.array(z.record(z.unknown())),
+  units: z.string(),
+  display_units: z.string()
+};
+var editConditionOutput = {
+  condition: z.string().describe("The finish tag passed in"),
+  condition_id: z.string(),
+  waste_pct: z.number().describe("The condition's waste % after this write"),
+  multiplier: z.number().describe("The condition's quantity multiplier after this write")
+};
 var readSheetTextOutput = {
   sheet: z.string(),
   items: z.array(z.object({ str: z.string(), x: z.number(), y: z.number() })).describe("Positioned text items (image px)"),
@@ -2342,6 +2637,18 @@ function registerTools(server, session) {
     }
     return payload;
   }));
+  server.registerTool("export_report", {
+    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. 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") },
+    outputSchema: exportReportOutput
+  }, run("export_report", async ({ path: outPath }) => {
+    const doc = session.exportReport();
+    if (outPath) {
+      const { writeFile } = await import("node:fs/promises");
+      await writeFile(outPath, JSON.stringify(doc));
+    }
+    return doc;
+  }));
   server.registerTool("delete_shape", {
     description: `Remove a committed shape by the id returned when it was committed. ${COORDS}`,
     inputSchema: { shape_id: z2.string() },
@@ -2387,8 +2694,17 @@ function registerTools(server, session) {
     },
     outputSchema: editMaterialsOutput
   }, run("edit_materials", (a) => session.editMaterials(a.condition, { add: a.add, remove: a.remove, patch: a.patch })));
+  server.registerTool("edit_condition", {
+    description: `Set a condition's quantity knobs \u2014 waste % and/or multiplier. takeoff_summary emits waste-adjusted *_net order quantities and a per-condition multiplier, and every export carries both, but conditions minted through the measure tools start at waste 0 / multiplier 1 \u2014 without this tool an agent's takeoff always ships net === gross (#131). waste_pct is the estimator's cut-waste percentage (carpet commonly 5\u201310); multiplier scales every quantity on the condition (\xD7N identical floors \u2014 takeoff_summary applies it before waste). condition must resolve to an EXISTING finish tag \u2014 a typo'd tag errors rather than minting an empty condition (the edit_materials remove/patch rule, not its add rule: these knobs mean nothing on a condition that doesn't exist yet). No review gate \u2014 quantity config, not traced geometry; undo_last reverses a call in one step (both knobs snapshotted together, restored verbatim).`,
+    inputSchema: {
+      condition: z2.string().describe("Finish tag of an existing condition, e.g. 'CPT-1'"),
+      waste_pct: z2.number().min(0).optional().describe("Waste percentage applied to net order quantities, e.g. 10 for 10%"),
+      multiplier: z2.number().positive().optional().describe("Quantity multiplier (\xD7N identical areas). Note: the canvas treats 0 as 1, so 0 is rejected here rather than silently meaning 'off'")
+    },
+    outputSchema: editConditionOutput
+  }, run("edit_condition", (a) => session.editCondition(a.condition, { waste_pct: a.waste_pct, multiplier: a.multiplier })));
   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, or an edit_materials 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), 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.`,
+    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: {
       n: z2.number().int().min(1).max(UNDO_CAP).default(1).describe(`How many steps to reverse (1\u2013${UNDO_CAP})`)
     },
@@ -2547,7 +2863,7 @@ function registerResources(server, session) {
 // package.json
 var package_default = {
   name: "opentakeoff-mcp",
-  version: "0.9.2",
+  version: "0.9.3",
   mcpName: "io.github.Kentucky-ai/opentakeoff",
   type: "module",
   description: "OpenTakeoff MCP server \u2014 drive the takeoff engine from your MCP client over stdio.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opentakeoff-mcp",
-  "version": "0.9.2",
+  "version": "0.9.3",
   "mcpName": "io.github.Kentucky-ai/opentakeoff",
   "type": "module",
   "description": "OpenTakeoff MCP server \u2014 drive the takeoff engine from your MCP client over stdio.",