opentakeoff-mcp 0.9.12 → 0.9.18

package/README.md

@@ -105,13 +105,14 @@ includes document text, shape vertices, or result payload content.
 
 | Tool | What it does |
 |---|---|
-| `load_plan` | Open a plan PDF from disk. Replaces the whole session (old doc, scales, conditions, shapes all cleared). Returns per-sheet dims, title-block `sheet_number`, and the detected drawn scale where present. |
+| `load_plan` | Open a plan PDF from disk. Default replaces the whole session; **`merge: true` ADDS the document to the working set** (#152) — plans + schedule + addenda as one takeoff, sheet graph spanning the whole set, marked set covering every worked sheet. Returns per-sheet dims, title-block `sheet_number`, and the detected drawn scale where present. |
 | `sheet_info` | One sheet's dims, vector segment count, scale status, detected suggestion, committed shape count. |
 | `set_scale` | Set a sheet's scale — exactly one of `label`, `upp`, `calibrate {p1, p2, feet}`, `use_detected`. |
 | `one_click` | One-Click Area at (x, y): flood fill bounded by the plan linework, traced, vertices snapped. Pass `condition` to commit; `role: "deduct"` subtracts. |
 | `detect_rooms` | Batch One-Click: reads every room-number label off the sheet's text layer and floods each — one call instead of `read_sheet_text` + reasoning + N `one_click` calls. Only cleanly-traced rooms come back; everything skipped is counted and reasoned in `withheld` (degenerate / duplicate / implausible), never dropped silently. Pass `condition` to commit every detected room. |
 | `measure_polygon` | Area + perimeter of a polygon you supply (min 3 verts). Requires scale. |
 | `measure_line` | Length of an open polyline (min 2 points). Requires scale. |
+| `derive_base` | **Base LF from committed rooms**: for every floor shape of a source condition, commits a linear base run tracing that room's boundary, quantified net of the door openings YOU state per room (`{shape_id, lf}` — your claim, recorded on `origin.derived`; the tool never guesses). All-or-nothing; one undo step. |
 | `measure_surface` | **Wall SF**: an open run traced along the wall, quantified as traced LF × the condition's height (the canvas's H knob — pass `height_ft` to set it, or set it once with `edit_condition`). Wall tile, wainscot, wall systems. Refuses without a height, minting nothing. |
 | `place_count` | **EA markers**: one point, one each — thresholds, stair nosings, floor boxes. No scale required (EA is scale-free). One shape per point; the whole call is one undo step. |
 | `takeoff_summary` | Per-condition totals + grand totals, computed by the Report's rules. |
@@ -121,11 +122,18 @@ includes document text, shape vertices, or result payload content.
 | `edit_materials` | Add/remove/patch supporting-materials rows on a condition — the coverage-rate lines (adhesive at N sf/gal, grout at N lf/bag, …) that turn a measured quantity into an order quantity, matching the canvas's Supporting Materials panel. `condition` mints on first touch, like `one_click`/`measure_polygon`. No review gate (materials rows are quantity config, not traced geometry) — edits directly, reversible with `undo_last`. |
 | `edit_condition` | Set a condition's **waste %**, **×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. Default path: `<plan> - marked set.pdf` next to the plan. Works without `@napi-rs/canvas`. |
 | `list_shapes` | The **mid-session inventory**: every committed shape's id, sheet, condition, role, quantities, and review state in one compact read — the ids `edit_shape`/`delete_shape` assume you have, without pulling the whole `export_takeoff` payload. Filters by sheet/condition narrow; empty is a result, not an error. |
 | `undo_last` | Step back over your own last `n` mutations, newest first. Exact inverses: a commit is removed, an edit restored verbatim, a delete re-inserted where it was, a materials edit's whole array restored, a condition edit's waste/multiplier pair restored. A whole `detect_rooms` sweep is **one** step. |
+| `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). 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. |
+| `link_annotation` | Attach an existing annotation to a condition (or detach with an empty tag) — the canvas's Attach/Detach control, reachable by an agent. |
 | `read_sheet_text` | Positioned page text (image px), optionally restricted to a region — title blocks, room labels, finish schedules. |
 | `find_text` | **Locate** a known string — the complement to `read_sheet_text` (which returns what a region *says*; this finds *where* a string sits). Case-insensitive substring match per pdf.js text run; each hit's center feeds straight into `one_click`'s seed. |
+| `sheet_graph` | The plan-set INDEX (#87): every sheet's role with evidence, the schedule tables found, every room tag with its stacked name, the detail callouts — how an agent decides WHAT to measure without a human enumerating rooms. |
+| `resolve_tag` | ONE room tag → its room-finish schedule row → each code's finish/material definition, every edge cited (sheet + literal text + bbox). Refusal over guessing: `unresolved` comes back with a reason, never as silence. |
+| `find_schedule` | Locate a schedule table by kind ("room finish", "material") — sheet, title, headers, row count, and a `view_sheet`-ready region. |
 | `sheet_context` | The region's STRUCTURE in one frame: classified vector segments (endpoints as drawn, meta byte per segment), text spans with bboxes, and hatch-family instances with content-derived ids — same pattern spec ⇒ same id anywhere on the sheet, so plan↔legend matching is `id === id`. Decimation is declared and counted on every reply: `kept + dropped === total_in_region`, cap applies longest-first so walls survive. |
 | `view_sheet` | The agent's eyes: render the sheet (or an image-px crop) to PNG. `overlay` burns committed shapes in (solid = human-affirmed, dashed = unreviewed) to verify geometry landed; `grid` burns in a calibrated 1-ft/5-ft measuring grid with foot labels (`"auto"` from the set scale, or the drawing scale like `"1/4"`) so dimensions are counted off cells, not guessed. |
 
@@ -238,7 +246,7 @@ sheet number (`A-101`) wherever a sheet is named.
 - **Vector + text sheets only.** A scanned sheet has no vector linework, so
   `one_click` reports it plainly; a raster fallback is a planned seam
   (`src/session.ts`, `ensureMask`), not yet built.
-- One document per session; `load_plan` replaces it.
+- `load_plan` replaces the session by default; `merge: true` builds a multi-document working set (#152). Reloading a merged file is refused — reload = replace, deliberately.
 - The takeoff lives in memory. `export_takeoff` (the app's exact save payload,
   nothing lost in translation) and `export_marked_pdf` (the reviewable marked
   planset) are the ways out.

package/dist/server-core.js

@@ -236,6 +236,15 @@ function positionedText(ph) {
   }
   return out;
 }
+function textItemsInRegion(ph, r) {
+  const items = [];
+  for (const it of ph.textContent.items || []) {
+    if (!(it.str || "").trim()) continue;
+    const t = pdfjs.Util.transform(ph.viewport.transform, it.transform);
+    if (t[4] >= r.x0 && t[4] <= r.x1 && t[5] >= r.y0 && t[5] <= r.y1) items.push(it);
+  }
+  return { items };
+}
 function textSpans(ph) {
   const out = [];
   for (const it of ph.textContent.items || []) {
@@ -250,6 +259,27 @@ function textSpans(ph) {
   return out;
 }
 
+// src/scalewarn.ts
+var SCALE_NOTE_MARGIN_XY = 0.1;
+var SCALE_NOTE_MARGIN_BELOW = 0.35;
+var UPP_TOLERANCE = 0.05;
+function expandForScaleNotes(b) {
+  const w = b.x1 - b.x0, h = b.y1 - b.y0;
+  return {
+    x0: b.x0 - w * SCALE_NOTE_MARGIN_XY,
+    y0: b.y0 - h * SCALE_NOTE_MARGIN_XY,
+    x1: b.x1 + w * SCALE_NOTE_MARGIN_XY,
+    y1: b.y1 + h * SCALE_NOTE_MARGIN_BELOW
+  };
+}
+function mixedScaleWarning(regionText, viewport, adoptedUpp, adoptedLabel) {
+  if (adoptedUpp == null) return void 0;
+  const hit = detectScale(regionText, viewport);
+  if (!hit) return void 0;
+  if (Math.abs(hit.upp - adoptedUpp) / adoptedUpp <= UPP_TOLERANCE) return void 0;
+  return `Scale note ${JSON.stringify(hit.label)} sits in or just below this region, but quantities were figured at ${adoptedLabel ? JSON.stringify(adoptedLabel) : `upp ${adoptedUpp}`} \u2014 if this is an enlarged plan or detail viewport, these numbers are wrong. Verify with view_sheet grid, or set_scale/calibrate for the right value before trusting them.`;
+}
+
 // ../web/src/lib/layers.ts
 var ROLE_CODE = {
   unknown: 0,
@@ -638,8 +668,8 @@ function sweepHatchRuns(segs, meta, ws) {
       clusters.pop();
     }
   }
-  const median = (arr) => {
-    const a = arr.slice().sort((x, y) => x - y);
+  const median = (arr2) => {
+    const a = arr2.slice().sort((x, y) => x - y);
     return a[a.length >> 1];
   };
   for (const members of clusters) {
@@ -2251,10 +2281,13 @@ var sheetSummary = (s) => ({
 });
 var Session = class _Session {
   file = null;
-  /** Absolute path the plan was loaded from — the marked-set export re-reads
-   * the source bytes here to vector-copy pages (pdf.js never hands them back). */
+  /** Absolute path of the PRIMARY (first-loaded) plan — the marked set's
+   * default output lands beside it; per-file paths live in `docs`. */
   filePath = null;
-  doc = null;
+  /** The working document set (#152), by basename — one entry per load_plan,
+   * several under merge: true. Source paths ride along for byte re-reads. */
+  docs = /* @__PURE__ */ new Map();
+  nextOrd = 1;
   sheets = /* @__PURE__ */ new Map();
   conditions = [];
   markups = [];
@@ -2276,30 +2309,48 @@ var Session = class _Session {
     this.record({ op: "commit", tool, ids: this.pendingCommits });
     this.pendingCommits = [];
   }
-  /** load_plan replaces the session's document: the old doc is destroyed and
-   * ALL state — scales, caches, conditions, shapes — is cleared. */
-  async loadPlan(filePath) {
-    if (this.doc) await this.doc.destroy().catch(() => {
-    });
-    this.doc = null;
-    this.sheets.clear();
-    this.conditions = [];
-    this.shapes = [];
-    this.markups = [];
-    this.file = null;
-    this.filePath = null;
-    this.journal = [];
-    this.pendingCommits = [];
+  /** load_plan (#152): without merge, replaces the whole session — every doc
+   * destroyed, ALL state (scales, caches, conditions, shapes) cleared. With
+   * merge: true, ADDS a document to the working set — a bid set is plans +
+   * schedule + addenda, not one PDF — keeping every scale, condition, and
+   * shape already in the session. Sheet keys already carry file names
+   * (plan.pdf, plan.pdf#2), so two documents never collide; loading the SAME
+   * file again under merge is refused (an addendum is a new file — reloading
+   * one in place is a replace-the-session decision, not a merge). */
+  async loadPlan(filePath, opts = {}) {
+    const base = path2.basename(filePath);
+    const merging = !!opts.merge && this.docs.size > 0;
+    if (!merging) {
+      for (const d of this.docs.values()) await d.doc.destroy().catch(() => {
+      });
+      this.docs.clear();
+      this.sheets.clear();
+      this.conditions = [];
+      this.shapes = [];
+      this.markups = [];
+      this.file = null;
+      this.filePath = null;
+      this.nextOrd = 1;
+      this.journal = [];
+      this.pendingCommits = [];
+    } else if (this.docs.has(base)) {
+      throw new UserError(`${base} is already loaded \u2014 merge adds NEW documents. To reload it, call load_plan without merge (replaces the whole session).`);
+    }
     this.graph = null;
     const doc = await openPdf(filePath);
-    this.doc = doc;
-    this.file = path2.basename(filePath);
-    this.filePath = path2.resolve(filePath);
+    const resolved = path2.resolve(filePath);
+    this.docs.set(base, { doc, path: resolved });
+    if (!this.file) {
+      this.file = base;
+      this.filePath = resolved;
+    }
+    const added = [];
     for (let n = 1; n <= doc.numPages; n++) {
       const ph = await doc.page(n);
-      const key = n === 1 ? this.file : `${this.file}#${n}`;
-      this.sheets.set(key, {
+      const key = n === 1 ? base : `${base}#${n}`;
+      const state = {
         key,
+        ord: this.nextOrd++,
         pageNum: n,
         widthPt: ph.widthPt,
         heightPt: ph.heightPt,
@@ -2310,43 +2361,72 @@ var Session = class _Session {
         upp: null,
         text: positionedText(ph),
         page: ph
-      });
+      };
+      this.sheets.set(key, state);
+      added.push(sheetSummary(state));
     }
     return {
-      file: this.file,
-      page_count: doc.numPages,
+      file: base,
+      files: this.files,
+      page_count: this.sheets.size,
       sheets: [...this.sheets.values()].map(sheetSummary),
-      note: "Replaced the previous session \u2014 all prior scales, conditions, and shapes were cleared."
+      note: merging ? `Merged ${base} into the working set (${added.length} sheet${added.length === 1 ? "" : "s"} added) \u2014 every prior scale, condition, and shape kept. The sheet graph now spans ${this.docs.size} documents.` : "Replaced the previous session \u2014 all prior scales, conditions, and shapes were cleared."
     };
   }
+  /** Every loaded document's basename, load order. */
+  get files() {
+    return [...this.docs.keys()];
+  }
+  /** The file (basename) a sheet key belongs to — the key codec's inverse. */
+  fileFor(sheetKey) {
+    return sheetKey.split("#")[0];
+  }
+  /** Absolute source path for a loaded file — the marked set re-reads bytes. */
+  pathFor(file) {
+    return this.docs.get(file)?.path ?? null;
+  }
   sheet(name) {
-    if (!this.doc) throw new UserError("No plan loaded \u2014 call load_plan first.");
+    if (!this.docs.size) throw new UserError("No plan loaded \u2014 call load_plan first.");
     const hit = this.sheets.get(name);
     if (hit) return hit;
     const wanted = name.toUpperCase().replace(/\s+/g, "");
     for (const s of this.sheets.values()) if (s.sheetNumber === wanted) return s;
     throw new UserError(`Unknown sheet "${name}" \u2014 loaded sheets: ${[...this.sheets.keys()].join(", ")}.`);
   }
-  /** Resource-URI addressing: sheets by 1-based page number. */
-  sheetForPage(page) {
-    if (!this.doc) throw new UserError("No plan loaded \u2014 call load_plan first.");
-    for (const s of this.sheets.values()) if (s.pageNum === page) return s;
-    throw new UserError(`No page ${page} \u2014 the loaded plan has pages 1\u2013${this.sheets.size}.`);
+  /** Like sheet(), but null for an unknown key — import adoption iterates
+   * merged rows that may reference files this document doesn't have. */
+  sheetOrNull(name) {
+    return this.sheets.get(name) ?? null;
+  }
+  /** Journal an externally-assembled commit gesture (import_takeoff) as one
+   * reversible step — the same entry shape commit()+flushCommits() writes. */
+  journalCommit(tool, ids) {
+    this.record({ op: "commit", tool, ids });
+  }
+  /** Resource-URI addressing: 1-based position in load order across every
+   * loaded document (=== page number for a single-document session). */
+  sheetForPage(ord) {
+    if (!this.docs.size) throw new UserError("No plan loaded \u2014 call load_plan first.");
+    const hit = this.sheetList()[ord - 1];
+    if (!hit) throw new UserError(`No sheet ${ord} \u2014 the working set has sheets 1\u2013${this.sheets.size}.`);
+    return hit;
   }
   /** Every loaded sheet, in page order — [] before any plan loads. */
   sheetList() {
-    return [...this.sheets.values()].sort((a, b) => a.pageNum - b.pageNum);
+    return [...this.sheets.values()].sort((a, b) => a.ord - b.ord);
   }
   /** The takeoff://sheets index payload — cheap (no geometry is built). */
   index() {
-    if (!this.doc) {
+    if (!this.docs.size) {
       return { file: null, page_count: 0, sheets: [], hint: "No plan loaded \u2014 call the load_plan tool with a PDF path, then list resources again." };
     }
     return {
       file: this.file,
+      files: this.files,
       page_count: this.sheets.size,
       sheets: this.sheetList().map((s) => ({
         ...sheetSummary(s),
+        ord: s.ord,
         scale_set: s.upp != null,
         shape_count: this.shapes.filter((x) => x.sheet_id === s.key).length
       }))
@@ -2354,8 +2434,8 @@ var Session = class _Session {
   }
   /** Rendered-page PNG, long edge capped at IMAGE_MAX_EDGE (never above the
    * canvas-native RENDER_SCALE), cached per sheet until the next load_plan. */
-  async renderSheetPng(page) {
-    const s = this.sheetForPage(page);
+  async renderSheetPng(ord) {
+    const s = this.sheetForPage(ord);
     if (!s.png) {
       const scale = Math.min(RENDER_SCALE, IMAGE_MAX_EDGE / Math.max(s.widthPt, s.heightPt));
       s.png = await s.page.renderPng(scale);
@@ -2482,8 +2562,9 @@ var Session = class _Session {
       s.geo = extractVectorGeometry(opList, s.page.viewport.transform, OPS2);
       s.snap = buildSnapGrid(s.geo.points, SNAP_CELL);
       const layerIds = s.geo.layerIds || [];
-      if (layerIds.length && this.doc) {
-        const byId = new Map((await this.doc.layers()).map((g) => [g.id, g]));
+      if (layerIds.length && this.docs.size) {
+        const owner = this.docs.get(this.fileFor(s.key));
+        const byId = new Map(owner ? (await owner.doc.layers()).map((g) => [g.id, g]) : []);
         const counts = /* @__PURE__ */ new Map();
         const lo = s.geo.layerOf;
         if (lo) {
@@ -2564,6 +2645,7 @@ var Session = class _Session {
       has_vector_linework: geo.segs.length > 0,
       scale_set: s.upp != null,
       ...s.upp != null ? { upp: s.upp } : {},
+      ...s.detected?.multi ? { multiple_scales: true } : {},
       shape_count: this.shapes.filter((x) => x.sheet_id === s.key).length,
       // the sheet's PDF layer table (#85) — always emitted; [] = no Optional
       // Content survived export and every engine path runs the heuristics
@@ -2605,7 +2687,33 @@ var Session = class _Session {
     }
     s.upp = upp;
     s.scaleSource = source === "label" ? "standard" : source === "calibrate" ? "calibrated" : source;
-    return { sheet: s.key, upp, ...label ? { label } : {}, source };
+    return {
+      sheet: s.key,
+      upp,
+      ...label ? { label } : {},
+      source,
+      // #153 — several DISTINCT scale notes on one sheet means enlarged plans
+      // or details are likely; region measurements will warn when a
+      // disagreeing note sits inside them, but say it up front too
+      ...s.detected?.multi ? { warning: "This sheet carries MULTIPLE distinct scale notes \u2014 enlarged plans/details likely. Measurements inside a viewport whose note disagrees with this scale will carry a warning; calibrate or re-set_scale before trusting them." } : {}
+    };
+  }
+  /** Mixed-scale check (#153): does the measured region carry a scale note
+   * that DISAGREES with the scale these quantities were figured at? Runs the
+   * sheet-level detector on a region-filtered text set — same detector, no
+   * second regex. Returns the warning to ride the reply, or undefined. */
+  scaleWarningFor(s, ptsPx) {
+    if (s.upp == null || !ptsPx.length) return void 0;
+    let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+    for (const [x, y] of ptsPx) {
+      x0 = Math.min(x0, x);
+      y0 = Math.min(y0, y);
+      x1 = Math.max(x1, x);
+      y1 = Math.max(y1, y);
+    }
+    const region = expandForScaleNotes({ x0, y0, x1, y1 });
+    const adoptedLabel = s.detected && Math.abs(s.detected.upp - s.upp) / s.upp <= 1e-6 ? s.detected.label : void 0;
+    return mixedScaleWarning(textItemsInRegion(s.page, region), s.page.viewport, s.upp, adoptedLabel);
   }
   conditionFor(tag) {
     let c = this.conditions.find((x) => x.finish_tag === tag);
@@ -2687,7 +2795,8 @@ var Session = class _Session {
       }).id;
     }
     this.flushCommits("one_click");
-    return { ...common, area_sf, perimeter_lf, ...shape_id ? { shape_id } : {} };
+    const mixed = this.scaleWarningFor(s, ring);
+    return { ...common, area_sf, perimeter_lf, ...shape_id ? { shape_id } : {}, ...mixed ? { warning: mixed } : {} };
   }
   /** Batch room detection: read every room-number label off the sheet's text
    *  layer, seed the existing One-Click flood at each, and trace/commit
@@ -2821,6 +2930,7 @@ var Session = class _Session {
         ...withheld,
         ...upp != null ? { min_area_sf: minAreaSf } : {}
       },
+      ...s.detected?.multi ? { multiple_scales: true } : {},
       ...withheldTotal ? { note: `${withheldTotal} seed(s) withheld \u2014 ${withheld.duplicate} duplicate region(s), ${withheld.bubble} label-bubble(s), ${withheld.implausible} under ${minAreaSf} SF, ${withheld.degenerate} untraceable.` } : {},
       ...s.upp == null ? { warning: `No scale set for ${s.key} \u2014 quantities unavailable. Call set_scale${s.detected ? ` (detected: ${s.detected.label})` : ""}.` } : {}
     };
@@ -2834,7 +2944,8 @@ var Session = class _Session {
     let shape_id;
     if (opts.condition) shape_id = this.commit(s, opts.condition, opts.role, verts, { area_sf, perimeter_lf }, { method: "manual", actor: "agent" }).id;
     this.flushCommits("measure_polygon");
-    return { area_sf, perimeter_lf, nverts: verts.length, ...shape_id ? { shape_id } : {} };
+    const mixed = this.scaleWarningFor(s, verts);
+    return { area_sf, perimeter_lf, nverts: verts.length, ...shape_id ? { shape_id } : {}, ...mixed ? { warning: mixed } : {} };
   }
   measureLine(name, pts, opts) {
     const s = this.sheet(name);
@@ -2870,6 +2981,68 @@ var Session = class _Session {
     this.flushCommits("measure_surface");
     return { condition: c.finish_tag, height_ft: h, length_lf: round2(LF), area_sf: round2(LF * h), npts: pts.length, shape_id: shape.id };
   }
+  /** derive_base (#148): the estimator's most mechanical derivation — wall
+   * base LF = room perimeter − stated door openings — minted as committed
+   * linear shapes from the floor shapes an agent (or detect_rooms) already
+   * traced. Every committed floor shape carries its perimeter; the openings
+   * stay the CALLER'S stated claim per room (it can see the doors in
+   * view_sheet) — refusal over guessing, and the claim rides provenance.
+   * Geometry: each base shape re-uses its source ring CLOSED (ring + the
+   * first vertex again) so the run traces the whole room boundary on the
+   * canvas and in the marked set. NOTE: quantities are assigned at derive
+   * time (net of openings); a later edit_shape re-measure of the polyline is
+   * the gross boundary again — the openings deduction lives here and in
+   * origin.derived, not in the geometry. */
+  deriveBase(opts) {
+    const src = this.conditions.find((x) => x.finish_tag === opts.source_condition);
+    if (!src) {
+      throw new UserError(`No condition ${JSON.stringify(opts.source_condition)} \u2014 tags: ${this.conditions.map((x) => x.finish_tag).join(", ") || "(none)"}.`);
+    }
+    if (opts.condition === opts.source_condition) {
+      throw new UserError("Base must land on its OWN condition (e.g. 'RB-1') \u2014 deriving onto the source would add its perimeter to the same tag's LF.");
+    }
+    const floors = this.shapes.filter((x) => x.condition_id === src.id && x.measure_role === "floor_area");
+    if (!floors.length) {
+      throw new UserError(`${src.finish_tag} has no floor_area shapes to derive from \u2014 commit rooms first (one_click / detect_rooms).`);
+    }
+    const byShape = /* @__PURE__ */ new Map();
+    for (const [i, o] of (opts.openings ?? []).entries()) {
+      const hit = floors.find((f) => f.id === o.shape_id);
+      if (!hit) throw new UserError(`openings[${i}]: ${JSON.stringify(o.shape_id)} is not a floor_area shape of ${src.finish_tag} \u2014 list_shapes for real ids.`);
+      if (!(o.lf >= 0)) throw new UserError(`openings[${i}]: lf must be >= 0.`);
+      byShape.set(o.shape_id, (byShape.get(o.shape_id) ?? 0) + o.lf);
+    }
+    for (const f of floors) {
+      const open = byShape.get(f.id) ?? 0;
+      const gross = f.computed.perimeter_lf ?? 0;
+      if (open >= gross) {
+        throw new UserError(`Shape ${f.id}: stated openings (${round2(open)} LF) meet or exceed its perimeter (${round2(gross)} LF) \u2014 nothing would remain.`);
+      }
+    }
+    const rooms = floors.map((f) => {
+      const s = this.sheet(f.sheet_id);
+      const gross = f.computed.perimeter_lf ?? 0;
+      const open = byShape.get(f.id) ?? 0;
+      const net = round2(gross - open);
+      const ringPx = f.verts_norm.map(([x, y]) => [x * s.widthPx, y * s.heightPx]);
+      const shape = this.commit(s, opts.condition, "linear", [...ringPx, ringPx[0]], { area_sf: 0, perimeter_lf: net }, {
+        method: "agent_v1",
+        actor: "agent",
+        reviewed: false,
+        derived: { from_shape_id: f.id, gross_lf: round2(gross), openings_lf: round2(open) }
+      });
+      return { source_shape_id: f.id, base_shape_id: shape.id, sheet: f.sheet_id, gross_lf: round2(gross), openings_lf: round2(open), net_lf: net };
+    });
+    this.flushCommits("derive_base");
+    return {
+      condition: opts.condition,
+      source_condition: src.finish_tag,
+      rooms,
+      committed: rooms.length,
+      total_lf: round2(rooms.reduce((n, r) => n + r.net_lf, 0)),
+      note: "Base runs trace each room's boundary; openings are your stated claim, recorded on origin.derived. Verify with view_sheet overlay:true."
+    };
+  }
   /** Count markers — the canvas's Count tool (commitCount): one point, one EA,
    * computed {count: 1}, NO scale required (EA is scale-free; the canvas's
    * recompute skips count shapes for the same reason). One shape per point,
@@ -2888,7 +3061,7 @@ var Session = class _Session {
    * delete_shape assume you have, without pulling the whole export_takeoff
    * payload to find one shape. Filters narrow, they never 404 an empty list. */
   listShapes(f = {}) {
-    if (!this.doc) throw new UserError("No plan loaded \u2014 call load_plan first.");
+    if (!this.docs.size) throw new UserError("No plan loaded \u2014 call load_plan first.");
     let rows = this.shapes;
     if (f.sheet) {
       const s = this.sheet(f.sheet);
@@ -3281,7 +3454,7 @@ var Session = class _Session {
   /** The exact browser save payload (TakeoffCanvas.jsx autosave + the schema key
    * store.saveAnnotations stamps) — importable by the app. */
   exportPayload() {
-    if (!this.doc) throw new UserError("No plan loaded \u2014 call load_plan first.");
+    if (!this.docs.size) throw new UserError("No plan loaded \u2014 call load_plan first.");
     return {
       schema: ANN_SCHEMA,
       project_name: "",
@@ -3304,7 +3477,7 @@ var Session = class _Session {
    * materials as CONFIG rows and takeoff_summary strips them; only this
    * document carries the computed order quantities. */
   exportReport(projectName = "") {
-    if (!this.doc) throw new UserError("No plan loaded \u2014 call load_plan first.");
+    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);
@@ -3324,7 +3497,7 @@ var Session = class _Session {
   // span plumbing plus the wire shapes.
   graph = null;
   async ensureGraph() {
-    if (!this.doc) throw new UserError("No plan loaded \u2014 call load_plan first.");
+    if (!this.docs.size) throw new UserError("No plan loaded \u2014 call load_plan first.");
     if (!this.graph) {
       const inputs = [];
       for (const s of this.sheets.values()) {
@@ -3469,9 +3642,10 @@ var sheetSummary2 = {
   detected_scale: z.string().optional().describe("Drawn scale note read off the sheet \u2014 a suggestion, never auto-applied")
 };
 var loadPlanOutput = {
-  file: z.string(),
-  page_count: z.number().int(),
-  sheets: z.array(z.object(sheetSummary2)),
+  file: z.string().describe("The document just loaded (basename)"),
+  files: z.array(z.string()).describe("Every document in the working set, load order (#152 \u2014 one entry unless merge was used)"),
+  page_count: z.number().int().describe("Total sheets across the working set"),
+  sheets: z.array(z.object(sheetSummary2)).describe("EVERY sheet in the working set, not just the file loaded by this call"),
   note: z.string()
 };
 var sheetInfoOutput = {
@@ -3481,6 +3655,7 @@ var sheetInfoOutput = {
   scale_set: z.boolean(),
   upp: z.number().optional().describe("Real feet per image px at render scale 2.0 \u2014 present once the scale is set"),
   shape_count: z.number().int().describe("Committed shapes on this sheet"),
+  multiple_scales: z.literal(true).optional().describe("Several DISTINCT scale notes on this sheet (#153) \u2014 enlarged plans/details likely"),
   layers: z.array(z.object({
     id: z.string().describe("Optional Content Group id \u2014 pass to one_click/detect_rooms layers.include/exclude"),
     name: z.string().describe("The CAD layer name as exported (e.g. A-WALL-FULL)"),
@@ -3494,7 +3669,8 @@ var setScaleOutput = {
   sheet: z.string(),
   upp: z.number().describe("Real feet per image px at render scale 2.0"),
   label: z.string().optional().describe("The standard scale label, when set by label or detected note"),
-  source: z.enum(["label", "upp", "calibrate", "detected"])
+  source: z.enum(["label", "upp", "calibrate", "detected"]),
+  warning: z.string().optional().describe("Present when the sheet carries MULTIPLE distinct scale notes (#153) \u2014 enlarged plans/details likely; region measurements under a disagreeing note will warn")
 };
 var oneClickOutput = {
   status: z.literal("ok"),
@@ -3507,7 +3683,7 @@ var oneClickOutput = {
   shape_id: z.string().optional().describe("Scaled mode: id of the committed shape, when condition was passed"),
   area_px2: z.number().optional().describe("Preview mode (no scale): raw area in px\xB2"),
   perimeter_px: z.number().optional().describe("Preview mode (no scale): raw perimeter in px"),
-  warning: z.string().optional().describe("Preview mode (no scale): why quantities are unavailable and what to do")
+  warning: z.string().optional().describe("Preview mode (no scale): why quantities are unavailable \u2014 OR, in scaled mode, a mixed-scale warning (#153): a scale note disagreeing with the sheet's sits in the measured region (enlarged plan/detail viewport likely)")
 };
 var detectedRoom = z.object({
   label: z.string().describe('The room-number text the seed was read from (e.g. "104", "139A")'),
@@ -3534,13 +3710,15 @@ var detectRoomsOutput = {
     min_area_sf: z.number().optional().describe("The plausibility floor applied (scaled mode only)")
   }).describe("What detection skipped and why \u2014 a withheld room is a question the caller can ask; a silently dropped one is a hole in a bid"),
   note: z.string().optional().describe("Human-readable summary of what was withheld, when anything was"),
+  multiple_scales: z.literal(true).optional().describe("Several DISTINCT scale notes on this sheet (#153) \u2014 rooms inside an enlarged viewport may be figured at the wrong scale"),
   warning: z.string().optional().describe("Preview mode (no scale): why quantities are unavailable and what to do")
 };
 var measurePolygonOutput = {
   area_sf: z.number(),
   perimeter_lf: z.number(),
   nverts: z.number().int(),
-  shape_id: z.string().optional().describe("Present when condition was passed and the shape committed")
+  shape_id: z.string().optional().describe("Present when condition was passed and the shape committed"),
+  warning: z.string().optional().describe("Mixed-scale warning (#153): a scale note disagreeing with the sheet's sits in the measured region \u2014 verify before trusting these numbers")
 };
 var measureSurfaceOutput = {
   condition: z.string(),
@@ -3621,6 +3799,33 @@ var exportTakeoffOutput = {
   sheet_tabs: z.array(z.unknown()),
   sheet_levels: z.object({}).passthrough()
 };
+var importTakeoffOutput = {
+  file: z.string().describe("Basename of the imported file"),
+  replaced: z.boolean().describe("true = the session was empty and adopted the file wholesale"),
+  shapes_added: z.number().int(),
+  shapes_pending: z.number().int().describe("Of the added shapes, how many are unreviewed machine pencil"),
+  conditions_merged: z.number().int().describe("Imported conditions that joined an existing finish tag (its knobs won)"),
+  conditions_added: z.number().int(),
+  scales_adopted: z.number().int().describe("Sheets whose calibration came from the file (this session's own always wins)"),
+  unknown_files: z.array(z.string()).describe("Files referenced by imported shapes that this document doesn't have \u2014 they count in totals but can't be viewed here"),
+  shapes_total: z.number().int(),
+  note: z.string()
+};
+var deriveBaseOutput = {
+  condition: z.string().describe("The tag the base committed under"),
+  source_condition: z.string(),
+  rooms: z.array(z.object({
+    source_shape_id: z.string(),
+    base_shape_id: z.string().describe("The committed linear base shape"),
+    sheet: z.string(),
+    gross_lf: z.number().describe("The room's full perimeter"),
+    openings_lf: z.number().describe("The openings you stated for this room"),
+    net_lf: z.number().describe("gross \u2212 openings \u2014 the committed quantity")
+  })),
+  committed: z.number().int(),
+  total_lf: z.number().describe("Sum of net_lf across rooms"),
+  note: z.string()
+};
 var listShapesOutput = {
   shapes: z.array(z.object({
     id: z.string(),
@@ -4538,9 +4743,9 @@ async function buildMarkedSetPdf({ projectName, dark, sheets, shapes, markups, r
   const { PDFDocument, StandardFonts, rgb, degrees, LineCapStyle } = await import("pdf-lib");
   const condById = Object.fromEntries(conditions.map((c) => [c.id, c]));
   const rfiNum = new Map((rfis || []).map((r) => [r.id, r.number]));
-  const byKey = (arr) => {
+  const byKey = (arr2) => {
     const m = /* @__PURE__ */ new Map();
-    for (const s of arr) {
+    for (const s of arr2) {
       const a = m.get(s.sheet_id) || [];
       a.push(s);
       m.set(s.sheet_id, a);
@@ -4949,16 +5154,16 @@ async function exportMarkedPdf(session, opts) {
     throw new UserError("Nothing to mark yet \u2014 commit shapes (one_click / detect_rooms / measure_polygon / measure_line with a condition) or annotate before exporting the marked set.");
   }
   const sheetStates = session.sheetList();
-  const byPage = new Map(sheetStates.map((s) => [s.pageNum, s.page]));
+  const byFilePage = new Map(sheetStates.map((s) => [`${session.fileFor(s.key)}#${s.pageNum}`, s.page]));
   const sheets = sheetStates.map((s) => ({
     key: s.key,
-    file,
+    file: session.fileFor(s.key),
     page: s.pageNum,
     label: s.sheetNumber ? `${s.sheetNumber} \xB7 p${s.pageNum}` : s.key
   }));
-  const getPage = async (_file, pageNum) => {
-    const ph = byPage.get(pageNum);
-    if (!ph) throw new UserError(`No page ${pageNum} in the loaded plan.`);
+  const getPage = async (srcFile, pageNum) => {
+    const ph = byFilePage.get(`${srcFile}#${pageNum}`);
+    if (!ph) throw new UserError(`No page ${pageNum} of ${srcFile} in the working set.`);
     return {
       rotate: ph.rotate,
       getViewport: ({ scale }) => {
@@ -4968,8 +5173,17 @@ async function exportMarkedPdf(session, opts) {
       }
     };
   };
-  let srcBytes = null;
-  const loadPdfData = async () => srcBytes ??= new Uint8Array(await readFile2(filePath));
+  const srcBytes = /* @__PURE__ */ new Map();
+  const loadPdfData = async (srcFile) => {
+    let bytes2 = srcBytes.get(srcFile);
+    if (!bytes2) {
+      const p = session.pathFor(srcFile);
+      if (!p) throw new UserError(`No source path for ${srcFile} \u2014 is it loaded?`);
+      bytes2 = new Uint8Array(await readFile2(p));
+      srcBytes.set(srcFile, bytes2);
+    }
+    return bytes2;
+  };
   const base = file.replace(/\.pdf$/i, "");
   const machine = session.shapes.filter((s) => s.origin?.reviewed !== true).length;
   const credit = machine ? `Machine-traced via OpenTakeoff MCP \u2014 ${machine} shape${machine === 1 ? "" : "s"} pending human review` : null;
@@ -5000,6 +5214,160 @@ async function exportMarkedPdf(session, opts) {
   };
 }
 
+// src/importing.ts
+import path4 from "node:path";
+import { readFile as readFile3 } from "node:fs/promises";
+
+// ../web/src/lib/stamps.js
+var DEFAULT_STAMPS = [
+  { id: "stmp-direction", name: "Plank / tile direction", elements: [
+    { type: "arrow", from: [-0.05, 0], to: [0.05, 0], color: "#1f3fc7", weight: 1.5 }
+  ] },
+  { id: "stmp-seam", name: "Seam direction", elements: [
+    { type: "arrow", from: [-0.05, 0], to: [0.05, 0], color: "#b03a26", line_style: "dashed" }
+  ] },
+  { id: "stmp-origin", name: "Pattern origin", elements: [
+    { type: "bubble", at: [0, 0], r: 0.018, text: "PO", color: "#0d9488" }
+  ] }
+];
+var DEFAULT_STAMP_SETS = [
+  { id: "set-flooring", name: "Flooring shop drawings", stampIds: DEFAULT_STAMPS.map((s) => s.id) }
+];
+
+// ../web/src/lib/store.js
+var ANN_SCHEMA2 = "opentakeoff.takeoff_canvas.v1";
+
+// ../web/src/lib/importTakeoff.js
+function parseTakeoffImport(text) {
+  let doc;
+  try {
+    doc = JSON.parse(text);
+  } catch {
+    throw new Error("Couldn't import takeoff: that file is not valid JSON.");
+  }
+  if (!doc || typeof doc !== "object" || Array.isArray(doc) || doc.schema !== ANN_SCHEMA2) {
+    throw new Error(`Couldn't import takeoff: not a takeoff export (expected schema "${ANN_SCHEMA2}" \u2014 the file export_takeoff or the app writes).`);
+  }
+  return doc;
+}
+var arr = (v) => Array.isArray(v) ? v : [];
+var tagKey = (t) => String(t || "").trim().toUpperCase();
+var freeId = (id, taken) => {
+  let n = 2, next = id;
+  while (taken.has(next)) next = `${id}~${n++}`;
+  return next;
+};
+function mergeTakeoffImport(current, imported, knownFiles = null) {
+  const cur = current && typeof current === "object" ? current : {};
+  const impShapes = arr(imported.shapes).filter((s) => s && typeof s === "object" && typeof s.sheet_id === "string" && typeof s.id === "string");
+  const impConds = arr(imported.conditions).filter((c) => c && typeof c === "object" && typeof c.id === "string");
+  const unknownFiles = (added) => {
+    if (!Array.isArray(knownFiles)) return [];
+    const known = new Set(knownFiles);
+    return [...new Set(added.map((s) => String(s.sheet_id).split("#")[0]).filter((f) => !known.has(f)))];
+  };
+  const pendingCount = (shapes) => shapes.filter((s) => s.origin?.reviewed === false).length;
+  if (!arr(cur.shapes).length && !arr(cur.markups).length) {
+    const payload2 = {
+      ...imported,
+      ...arr(imported.sheet_tabs).length ? {} : { sheet_tabs: arr(cur.sheet_tabs) },
+      ...arr(imported.sheet_group).length ? {} : { sheet_group: arr(cur.sheet_group) },
+      ...arr(imported.last_group).length ? {} : { last_group: arr(cur.last_group) }
+    };
+    return {
+      payload: payload2,
+      note: { replaced: true, shapes_added: impShapes.length, shapes_pending: pendingCount(impShapes), conditions_merged: 0, conditions_added: impConds.length, scales_adopted: arr(imported.sheets).length, unknown_files: unknownFiles(impShapes) }
+    };
+  }
+  const conditions = [...arr(cur.conditions)];
+  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();
+  let condMerged = 0, condAdded = 0;
+  for (const c of impConds) {
+    const hit = byTag.get(tagKey(c.finish_tag));
+    if (hit) {
+      condMap.set(c.id, hit);
+      condMerged++;
+      continue;
+    }
+    const id = condIds.has(c.id) ? freeId(c.id, condIds) : c.id;
+    const next = id === c.id ? c : { ...c, id };
+    conditions.push(next);
+    condIds.add(id);
+    byTag.set(tagKey(c.finish_tag), id);
+    condMap.set(c.id, id);
+    condAdded++;
+  }
+  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));
+  const addedMarkups = arr(imported.markups).filter((m) => m && typeof m === "object" && (!m.id || !markupIds.has(m.id)));
+  const rfiIds = new Set(arr(cur.rfis).map((r) => r?.id).filter(Boolean));
+  const addedRfis = arr(imported.rfis).filter((r) => r && typeof r === "object" && r.id && !rfiIds.has(r.id));
+  const sheets = [...arr(cur.sheets)];
+  const scaled = new Set(sheets.map((s) => s?.sheet_id));
+  let scalesAdopted = 0;
+  for (const s of arr(imported.sheets)) {
+    if (s && typeof s === "object" && s.sheet_id && s.units_per_px && !scaled.has(s.sheet_id)) {
+      sheets.push(s);
+      scaled.add(s.sheet_id);
+      scalesAdopted++;
+    }
+  }
+  const payload = {
+    ...cur,
+    conditions,
+    shapes: [...arr(cur.shapes), ...addedShapes],
+    markups: [...arr(cur.markups), ...addedMarkups],
+    ...addedRfis.length ? { rfis: [...arr(cur.rfis), ...addedRfis] } : {},
+    sheets
+  };
+  return {
+    payload,
+    note: { replaced: false, shapes_added: addedShapes.length, shapes_pending: pendingCount(addedShapes), conditions_merged: condMerged, conditions_added: condAdded, scales_adopted: scalesAdopted, unknown_files: unknownFiles(addedShapes) }
+  };
+}
+
+// src/importing.ts
+var parseTakeoffImport2 = parseTakeoffImport;
+var mergeTakeoffImport2 = mergeTakeoffImport;
+async function importTakeoff(session, filePath) {
+  if (!session.file) throw new UserError("No plan loaded \u2014 call load_plan first (the import lands on the loaded document).");
+  let text;
+  try {
+    text = await readFile3(filePath, "utf8");
+  } catch {
+    throw new UserError(`Couldn't read ${JSON.stringify(filePath)} \u2014 is the path right?`);
+  }
+  let imported;
+  try {
+    imported = parseTakeoffImport2(text);
+  } catch (e) {
+    throw new UserError(e instanceof Error ? e.message : String(e));
+  }
+  const prevShapeIds = new Set(session.shapes.map((s) => s.id));
+  const { payload, note } = mergeTakeoffImport2(session.exportPayload(), imported, session.files);
+  session.conditions = payload.conditions ?? [];
+  session.shapes = payload.shapes ?? [];
+  session.markups = payload.markups ?? [];
+  for (const row of payload.sheets ?? []) {
+    const s = session.sheetOrNull(row.sheet_id);
+    if (s && s.upp == null && row.units_per_px > 0) {
+      s.upp = row.units_per_px;
+      s.scaleSource = row.scale_source ?? "upp";
+    }
+  }
+  const addedIds = session.shapes.filter((s) => !prevShapeIds.has(s.id)).map((s) => s.id);
+  if (addedIds.length) session.journalCommit("import_takeoff", addedIds);
+  return {
+    file: path4.basename(filePath),
+    ...note,
+    shapes_total: session.shapes.length,
+    note: note.replaced ? "Empty session \u2014 the import IS the takeoff now. Unreviewed machine shapes stay pencil; verify with view_sheet overlay:true." : "Merged: same finish tags joined your conditions, new ids appended, duplicates skipped (re-import is idempotent), this session's calibration won per sheet."
+  };
+}
+
 // src/tools.ts
 var COORDS = "Coordinates are image px at render scale 2.0: PDF pt \xD7 2, origin top-left, y down (the browser canvas's native space). Sheet payloads carry dims in both px and pt.";
 var pointSchema = z2.tuple([z2.number(), z2.number()]);
@@ -5021,11 +5389,14 @@ var run = (tool, fn) => async (args) => {
 };
 function registerTools(server, session) {
   server.registerTool("load_plan", {
-    description: `Open a plan PDF from disk and replace the whole session (previous document, scales, conditions, and shapes are cleared). Returns file, page_count, and one entry per sheet: dims, title-block sheet_number, and the detected drawn scale where present. The loaded sheets also become browsable resources (takeoff://sheets). ${COORDS}`,
-    inputSchema: { path: z2.string().describe("Path to a plan PDF on disk") },
+    description: `Open a plan PDF from disk. Default: replace the whole session (previous documents, scales, conditions, and shapes are cleared). merge: true ADDS the document to the working set instead (#152) \u2014 a bid set is plans + schedule + addenda, not one PDF \u2014 keeping every scale, condition, and shape; sheet keys carry file names so documents never collide, the sheet graph spans the whole set (resolve_tag can chain a plan tag on one file to a schedule row in another), and the marked set covers every worked sheet. Re-loading an already-merged file is refused \u2014 reload = replace, deliberately. Returns file, files, page_count, and one entry per sheet. The loaded sheets also become browsable resources (takeoff://sheets). ${COORDS}`,
+    inputSchema: {
+      path: z2.string().describe("Path to a plan PDF on disk"),
+      merge: z2.boolean().optional().describe("true = ADD this document to the working set, keeping all existing work (merge into an empty session is just a load)")
+    },
     outputSchema: loadPlanOutput
-  }, run("load_plan", async ({ path: path4 }) => {
-    const loaded = await session.loadPlan(path4);
+  }, run("load_plan", async ({ path: path5, merge: merge2 }) => {
+    const loaded = await session.loadPlan(path5, { merge: merge2 });
     server.sendResourceListChanged();
     return loaded;
   }));
@@ -5114,6 +5485,18 @@ function registerTools(server, session) {
     },
     outputSchema: placeCountOutput
   }, run("place_count", (a) => session.placeCount(a.sheet, a.points, { condition: a.condition })));
+  server.registerTool("derive_base", {
+    description: `Mint the wall base from committed rooms (#148) \u2014 the estimator's most mechanical derivation: base LF = room perimeter \u2212 stated door openings. For every floor_area shape of source_condition, commits ONE linear shape under condition (e.g. 'RB-1') tracing that room's boundary, quantified NET of the openings you state per room. The openings are YOUR claim to make \u2014 look at the doors with view_sheet, state {shape_id, lf} per room (repeat a shape_id to stack openings); the tool never guesses, and your claim is recorded on origin.derived (from_shape_id, gross_lf, openings_lf). All-or-nothing: an unknown shape_id, a negative lf, or openings meeting a room's whole perimeter refuses the call before anything commits. The whole derivation is ONE undo step. Deriving onto the source condition is refused \u2014 base lands on its own tag.`,
+    inputSchema: {
+      source_condition: z2.string().describe("Finish tag whose floor_area rooms the base derives from, e.g. 'CPT-1'"),
+      condition: z2.string().describe("Finish tag the base commits under (minted on first use), e.g. 'RB-1'"),
+      openings: z2.array(z2.object({
+        shape_id: z2.string().describe("A floor_area shape id of source_condition (list_shapes)"),
+        lf: z2.number().min(0).describe("Door/opening width to deduct from that room's perimeter, in feet")
+      })).optional().describe("Stated openings per room \u2014 omit for gross perimeters")
+    },
+    outputSchema: deriveBaseOutput
+  }, run("derive_base", (a) => session.deriveBase(a)));
   server.registerTool("takeoff_summary", {
     description: `Per-condition totals (floor/wall/border SF, LF, EA, SY, with and without waste) plus grand totals \u2014 the Report's numbers, computed by the same rules. Numbers only: the deliverable that SHOWS the work on the drawings is export_marked_pdf. ${COORDS}`,
     inputSchema: {},
@@ -5146,6 +5529,13 @@ function registerTools(server, session) {
     }
     return doc;
   }));
+  server.registerTool("import_takeoff", {
+    description: `The way BACK IN (#151): load an "opentakeoff.takeoff_canvas.v1" file \u2014 a prior export_takeoff, or the app's own save \u2014 into this session, through the SAME tested merge rules as the app's Sheet-menu import: finish-tag identity joins imported conditions onto this session's own (their knobs win), new ids append, duplicate ids skip (re-import is idempotent), and THIS session's calibration wins per sheet. An empty session adopts the file wholesale. Resume yesterday's work, extend a takeoff a human already reviewed (their ink stays ink \u2014 reviewed shapes arrive untouchable by agent verbs), or audit someone else's export with list_shapes/takeoff_summary. Requires a loaded plan; shapes referencing OTHER files ride along and count in totals but can't be viewed against this document \u2014 the reply's unknown_files names them. undo_last removes the imported SHAPES as one step; adopted conditions, scales, and annotations stay.`,
+    inputSchema: {
+      path: z2.string().describe("Path to a takeoff_canvas.v1 JSON file on disk")
+    },
+    outputSchema: importTakeoffOutput
+  }, run("import_takeoff", (a) => importTakeoff(session, a.path)));
   server.registerTool("export_marked_pdf", {
     description: `The MARKED-UP PLANSET \u2014 the deliverable of every takeoff. Writes a distribution-ready PDF to disk: a legend cover (per-condition totals, swatches, a by-sheet breakdown) followed by every sheet that carries takeoff shapes or annotations, vector-copied from the source plan with the work burned in as drawn \u2014 condition colors and hatches, a quantity chip on every shape, annotation clouds/callouts/highlights. Built by the same module as the canvas's MARKED SET button, so agent output and app output are one implementation. A construction takeoff is no good without markup: finish EVERY takeoff by writing this file and giving the user its path (export_report carries the numbers for pricing; this carries the evidence). When the shapes were machine-traced and unreviewed, the document says so on its last page \u2014 the review path is importing the export_takeoff payload into the app, where agent shapes arrive as pencil proposals. Default path: next to the loaded plan as "<plan> - marked set.pdf". Needs no native canvas \u2014 pure vector copy, so it works even where view_sheet cannot render.`,
     inputSchema: {
@@ -5342,7 +5732,7 @@ function parsePage(session, raw) {
 function registerResources(server, session) {
   const sheetEntries = (suffix, mimeType, what) => () => ({
     resources: session.sheetList().map((s) => ({
-      uri: `takeoff://sheet/${s.pageNum}${suffix}`,
+      uri: `takeoff://sheet/${s.ord}${suffix}`,
       name: `${s.key}${suffix.replace("/", " \xB7 ")}`,
       ...s.sheetNumber ? { title: `${s.sheetNumber} \u2014 ${what}` } : { title: `page ${s.pageNum} \u2014 ${what}` },
       description: `${what} for ${s.key}${s.sheetNumber ? ` (${s.sheetNumber})` : ""}`,
@@ -5372,7 +5762,7 @@ function registerResources(server, session) {
     async (uri, { page }) => {
       const s = parsePage(session, page);
       const idx = session.index();
-      const row = idx.sheets.find((x) => x.page === s.pageNum);
+      const row = idx.sheets.find((x) => x.sheet === s.key);
       return { contents: [{ uri: uri.href, mimeType: "application/json", text: JSON.stringify(row) }] };
     }
   );
@@ -5399,7 +5789,7 @@ function registerResources(server, session) {
     },
     async (uri, { page }) => {
       const s = parsePage(session, page);
-      const png = await session.renderSheetPng(s.pageNum);
+      const png = await session.renderSheetPng(s.ord);
       return { contents: [{ uri: uri.href, mimeType: "image/png", blob: toBase64(png) }] };
     }
   );
@@ -5408,7 +5798,7 @@ function registerResources(server, session) {
 // package.json
 var package_default = {
   name: "opentakeoff-mcp",
-  version: "0.9.12",
+  version: "0.9.18",
   mcpName: "io.github.Kentucky-ai/opentakeoff",
   type: "module",
   description: "OpenTakeoff MCP server \u2014 drive the takeoff engine from your MCP client over stdio.",
@@ -5424,7 +5814,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/resources.test.ts test/session.test.ts test/tools.test.ts test/view.test.ts"
+    test: "node --import tsx --test test/conformance.test.ts test/context.test.ts test/e2e.test.ts test/resources.test.ts test/scalewarn.test.ts test/session.test.ts test/tools.test.ts test/view.test.ts"
   },
   dependencies: {
     "@modelcontextprotocol/sdk": "^1.12.0",

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "opentakeoff-mcp",
-  "version": "0.9.12",
+  "version": "0.9.18",
   "mcpName": "io.github.Kentucky-ai/opentakeoff",
   "type": "module",
-  "description": "OpenTakeoff MCP server \u2014 drive the takeoff engine from your MCP client over stdio.",
+  "description": "OpenTakeoff MCP server — drive the takeoff engine from your MCP client over stdio.",
   "license": "Apache-2.0",
   "engines": {
     "node": ">=20"
@@ -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/resources.test.ts test/session.test.ts test/tools.test.ts test/view.test.ts"
+    "test": "node --import tsx --test test/conformance.test.ts test/context.test.ts test/e2e.test.ts test/resources.test.ts test/scalewarn.test.ts test/session.test.ts test/tools.test.ts test/view.test.ts"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.0",