opentakeoff-mcp 0.6.0 → 0.7.0

package/README.md

@@ -108,15 +108,39 @@ includes document text, shape vertices, or result payload content.
 | `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; a leaked/dense-linework label is silently withheld. Pass `condition` to commit every detected room. |
+| `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. |
 | `takeoff_summary` | Per-condition totals + grand totals, computed by the Report's rules. |
 | `export_takeoff` | The full `opentakeoff.takeoff_canvas.v1` payload — exactly what the app autosaves. Inline, and to disk with `path`. |
 | `delete_shape` | Remove a committed shape by id. |
+| `edit_shape` | **Revise** a committed shape instead of redoing it: new `verts`, a different `condition`, a different `role`, or any combination — quantities recomputed from the result. Refuses shapes a human affirmed. |
+| `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 whole `detect_rooms` sweep is **one** step. |
 | `read_sheet_text` | Positioned page text (image px), optionally restricted to a region — title blocks, room labels, finish schedules. |
+| `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. |
 
+### The agent revises its own work
+
+`edit_shape` and `undo_last` exist because an agent that can only *append* has
+one recovery move: delete and re-derive. The loop they enable instead —
+**commit → `view_sheet overlay:true` → see the ring overshot into the corridor
+→ move those two vertices → look again** — is the loop a human estimator
+already runs, and it is the difference between an agent that drafts and one
+that works.
+
+Two rules hold the surface honest:
+
+- **Ink is not pencil.** A shape carrying `origin.reviewed === true` is work a
+  human affirmed, and no agent verb touches it. This server has no review gate
+  of its own, so the guard is inert here — it is the contract that makes the
+  surface safe to port to a host that *does* have one.
+- **Self-revision is not correction.** `edit_shape` bumps `origin.agent_edits`
+  and touches nothing in the human-correction vocabulary (`edited`, `edits`,
+  `proposed_verts_norm`). Those fields mean *a human corrected the machine*;
+  merging a machine's own fix into them would corrupt the one signal that
+  measures whether the machine is getting better.
+
 Every JSON tool declares an **`outputSchema`**, and every reply carries the
 payload as **`structuredContent`** — typed, machine-validated on every call —
 alongside the same compact JSON in a single text item for clients that predate

package/dist/server-core.js

@@ -216,6 +216,19 @@ function positionedText(ph) {
   }
   return out;
 }
+function textSpans(ph) {
+  const out = [];
+  for (const it of ph.textContent.items || []) {
+    const str = it.str || "";
+    if (!str.trim()) continue;
+    const t = pdfjs.Util.transform(ph.viewport.transform, it.transform);
+    const x = t[4], y = t[5];
+    const w = (it.width || 0) * RENDER_SCALE;
+    const h = (it.height || 0) * RENDER_SCALE || Math.hypot(t[2], t[3]);
+    out.push({ str, x0: +x.toFixed(1), y0: +(y - h).toFixed(1), x1: +(x + w).toFixed(1), y1: +y.toFixed(1) });
+  }
+  return out;
+}
 
 // src/format.ts
 var UserError = class extends Error {
@@ -427,16 +440,17 @@ function extractVectorGeometry(opList, transform, OPS3) {
   }
   return { points, segs, meta: Uint8Array.from(metaArr), imageArea };
 }
-function classifyHatchSegs(segs, meta, ws) {
+function sweepHatchRuns(segs, meta, ws) {
   const n = segs.length >> 2;
-  const soft = new Uint8Array(n);
-  if (!meta || !n) return soft;
+  const clipSoft = [];
+  const runs = [];
+  if (!meta || !n) return { clipSoft, runs };
   const cand = [];
   for (let i = 0; i < n; i++) {
     const mt = meta[i];
     if (mt & SEG_CURVE) continue;
     if (mt & SEG_CLIP) {
-      soft[i] = 1;
+      clipSoft.push(i);
       continue;
     }
     if (mt & SEG_FILLONLY) continue;
@@ -449,7 +463,7 @@ function classifyHatchSegs(segs, meta, ws) {
     if (ang >= 180) ang -= 180;
     cand.push({ i, ang, x1, y1, x2, y2, w: meta[i] >> 4 });
   }
-  if (cand.length < HATCH_MIN_RUN) return soft;
+  if (cand.length < HATCH_MIN_RUN) return { clipSoft, runs };
   cand.sort((a, b) => a.ang - b.ang);
   const clusters = [];
   let cl = [cand[0]];
@@ -517,11 +531,33 @@ function classifyHatchSegs(segs, meta, ws) {
       const spans = [];
       for (let k = a; k <= b; k++) spans.push(rows[k].t1 - rows[k].t0);
       const medSpan = Math.max(1, median(spans));
-      for (let k = a + 1; k < b; k++) {
-        if (rows[k].t1 - rows[k].t0 > SPAN_PROTECT_RATIO * medSpan) continue;
-        for (const s of rows[k].segs)
-          if (s.w < WIDE_PROTECT_RATIO * modalW) soft[s.i] = 1;
+      const memberIdx = [];
+      const softIdx = [];
+      let bx0 = Infinity, by0 = Infinity, bx1 = -Infinity, by1 = -Infinity;
+      let angSum = 0, angN = 0;
+      for (let k = a; k <= b; k++) {
+        const guarded = rows[k].t1 - rows[k].t0 > SPAN_PROTECT_RATIO * medSpan;
+        for (const s of rows[k].segs) {
+          memberIdx.push(s.i);
+          angSum += s.ang;
+          angN++;
+          bx0 = Math.min(bx0, s.x1, s.x2);
+          by0 = Math.min(by0, s.y1, s.y2);
+          bx1 = Math.max(bx1, s.x1, s.x2);
+          by1 = Math.max(by1, s.y1, s.y2);
+          if (k > a && k < b && !guarded && s.w < WIDE_PROTECT_RATIO * modalW) softIdx.push(s.i);
+        }
       }
+      const meanAng = (angSum / Math.max(1, angN) % 180 + 180) % 180;
+      runs.push({
+        angleDeg: meanAng,
+        pitch: med,
+        modalW,
+        rowCount: count,
+        bbox: [bx0, by0, bx1, by1],
+        memberIdx,
+        softIdx
+      });
     };
     for (let k = 1; k < rows.length; k++) {
       const gap = rows[k].d - rows[k - 1].d;
@@ -534,8 +570,34 @@ function classifyHatchSegs(segs, meta, ws) {
     }
     flushRun(runStart, rows.length - 1);
   }
+  return { clipSoft, runs };
+}
+function classifyHatchSegs(segs, meta, ws) {
+  const soft = new Uint8Array(segs.length >> 2);
+  const { clipSoft, runs } = sweepHatchRuns(segs, meta, ws);
+  for (const i of clipSoft) soft[i] = 1;
+  for (const r of runs) for (const i of r.softIdx) soft[i] = 1;
   return soft;
 }
+var HATCH_ID_ANGLE_Q = 0.5;
+var HATCH_ID_PITCH_Q = 0.1;
+function hatchFamilies(segs, meta) {
+  const { runs } = sweepHatchRuns(segs, meta, 1);
+  const q = (v, step) => Math.round(v / step) * step;
+  return runs.map((r) => {
+    const a = q(r.angleDeg, HATCH_ID_ANGLE_Q), p = q(r.pitch, HATCH_ID_PITCH_Q);
+    return {
+      id: `h-a${a.toFixed(1)}p${p.toFixed(1)}w${r.modalW}`,
+      angle_deg: +r.angleDeg.toFixed(2),
+      pitch_px: +r.pitch.toFixed(2),
+      pen_w_px: r.modalW,
+      rows: r.rowCount,
+      segments: r.memberIdx.length,
+      bbox: r.bbox.map((v) => +v.toFixed(1)),
+      memberIdx: r.memberIdx
+    };
+  });
+}
 function buildMask(segs, imgW, imgH, maxDim = MASK_MAX_DIM, meta = null) {
   const ws = Math.min(1, maxDim / Math.max(imgW, imgH, 1));
   const mw = Math.max(2, Math.ceil(imgW * ws)), mh = Math.max(2, Math.ceil(imgH * ws));
@@ -770,23 +832,22 @@ function ringArea(pts) {
 
 // ../web/src/lib/detectRooms.ts
 var ROOM_LABEL_RE = /^\d{2,3}[A-Z]?$/;
-function roomLabelSeeds(items) {
-  const out = [];
-  for (const it of items) {
-    const num = (it.str || "").trim().split(/\s+/).find((tok) => ROOM_LABEL_RE.test(tok));
-    if (!num) continue;
-    out.push({ str: num, seed: [it.x, it.y] });
-  }
-  return out;
+var BUBBLE_RATIO = 2.5;
+function seedLadderPx(b) {
+  const cx = (b.x0 + b.x1) / 2, cy = (b.y0 + b.y1) / 2;
+  const h = Math.max(b.y1 - b.y0, 1);
+  return [[cx, cy], [cx, cy + 2 * h], [cx, cy - 2 * h], [cx, cy + 3.5 * h]];
 }
-function detectRegions(maskObj, seeds, sensitivity = SENS_BALANCED) {
-  const out = [];
-  for (const s of seeds) {
-    const f = floodRegion(maskObj, s.seed[0], s.seed[1], sensitivity);
-    if (f.status !== "ok") continue;
-    out.push({ str: s.str, seed: s.seed, flood: f });
+function isLabelBubblePx(ring, b) {
+  let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+  for (const [x, y] of ring) {
+    if (x < x0) x0 = x;
+    if (y < y0) y0 = y;
+    if (x > x1) x1 = x;
+    if (y > y1) y1 = y;
   }
-  return out;
+  const lw = Math.max(b.x1 - b.x0, 1e-6), lh = Math.max(b.y1 - b.y0, 1e-6);
+  return x1 - x0 <= BUBBLE_RATIO * lw && y1 - y0 <= BUBBLE_RATIO * lh;
 }
 
 // ../web/src/lib/geometry.js
@@ -1016,10 +1077,35 @@ var HATCH_IDS = ["solid", "diag", "diag2", "cross", "diagdense", "horiz", "vert"
 var mintUuid = () => 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}-${mintUuid()}`;
 var ANN_SCHEMA = "opentakeoff.takeoff_canvas.v1";
+var CONTEXT_MIN_LEN_PX = 2;
+var CONTEXT_MAX_SEGMENTS = 4e3;
+var CONTEXT_MAX_SEGMENTS_CEIL = 2e4;
+function segIntersectsRect(x1, y1, x2, y2, r) {
+  if (Math.max(x1, x2) < r.x0 || Math.min(x1, x2) > r.x1 || Math.max(y1, y2) < r.y0 || Math.min(y1, y2) > r.y1) return false;
+  const dx = x2 - x1, dy = y2 - y1;
+  let t0 = 0, t1 = 1;
+  for (const [p, q] of [[-dx, x1 - r.x0], [dx, r.x1 - x1], [-dy, y1 - r.y0], [dy, r.y1 - y1]]) {
+    if (p === 0) {
+      if (q < 0) return false;
+      continue;
+    }
+    const t = q / p;
+    if (p < 0) {
+      if (t > t1) return false;
+      if (t > t0) t0 = t;
+    } else {
+      if (t < t0) return false;
+      if (t < t1) t1 = t;
+    }
+  }
+  return true;
+}
+var rectsOverlap = (a, r) => a[0] <= r.x1 && a[2] >= r.x0 && a[1] <= r.y1 && a[3] >= r.y0;
 var IMAGE_MAX_EDGE = 1568;
 var VIEW_MIN_PX = 200;
 var VIEW_DEFAULT_PX = 1400;
 var VIEW_MAX_PX = 2e3;
+var UNDO_CAP = 100;
 var sheetSummary = (s) => ({
   sheet: s.key,
   page: s.pageNum,
@@ -1036,6 +1122,23 @@ var Session = class {
   sheets = /* @__PURE__ */ new Map();
   conditions = [];
   shapes = [];
+  /** Newest-last. Capped at UNDO_CAP; the oldest entry falls off the front. */
+  journal = [];
+  seq = 0;
+  /** Ids minted by commit() since the last flush — one tool call may commit
+   * many shapes (detect_rooms), and they journal as a single reversible step. */
+  pendingCommits = [];
+  record(entry) {
+    this.journal.push({ ...entry, seq: ++this.seq });
+    if (this.journal.length > UNDO_CAP) this.journal.shift();
+  }
+  /** Journal whatever commit() minted during this tool call, as one entry.
+   * A call that committed nothing records nothing — undo steps over reads. */
+  flushCommits(tool) {
+    if (!this.pendingCommits.length) return;
+    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) {
@@ -1046,6 +1149,8 @@ var Session = class {
     this.conditions = [];
     this.shapes = [];
     this.file = null;
+    this.journal = [];
+    this.pendingCommits = [];
     const doc = await openPdf(filePath);
     this.doc = doc;
     this.file = path2.basename(filePath);
@@ -1149,6 +1254,87 @@ var Session = class {
       }
     };
   }
+  /** sheet_context (issue #29): the classified vectors, the positioned text,
+   * and the hatch-family instances of ONE region, in ONE frame — image px,
+   * the space every other tool already speaks. There is deliberately no
+   * transform in this method: everything below is a containment test against
+   * a rect, so frame agreement with view_sheet is a contract on the echoed
+   * region, not on a second renderer.
+   *
+   * Decimation is declared and ordered (issue #29 design comment): clip to
+   * region → drop segments shorter than min_len_px → cap at max_segments
+   * LONGEST-FIRST (walls are long, hatch strokes are short — truncation
+   * degrades toward structure). Whole segments drop with their meta intact;
+   * nothing is simplified or merged, because these are CLASSIFIED segments
+   * and a merge would silently rewrite the classification. The counts ride
+   * on every reply, truncated or not. */
+  async sheetContext(name, opts) {
+    const s = this.sheet(name);
+    const clampX = (v) => Math.max(0, Math.min(v, s.widthPx));
+    const clampY = (v) => Math.max(0, Math.min(v, s.heightPx));
+    const r = opts.region ? { x0: clampX(opts.region.x0), y0: clampY(opts.region.y0), x1: clampX(opts.region.x1), y1: clampY(opts.region.y1) } : { x0: 0, y0: 0, x1: s.widthPx, y1: s.heightPx };
+    if (!(r.x1 - r.x0 >= 1 && r.y1 - r.y0 >= 1)) {
+      throw new UserError(`Empty context region \u2014 need x1 > x0 and y1 > y0 in image px inside the sheet (${s.widthPx} \xD7 ${s.heightPx}).`);
+    }
+    const minLen = opts.min_len_px ?? CONTEXT_MIN_LEN_PX;
+    const cap = opts.max_segments ?? CONTEXT_MAX_SEGMENTS;
+    const geo = await this.ensureGeometry(s);
+    const hasVectors = geo.segs.length > 0;
+    if (!s.hatch) s.hatch = hasVectors ? hatchFamilies(geo.segs, geo.meta) : [];
+    if (!s.spans) s.spans = textSpans(s.page);
+    const famBySeg = /* @__PURE__ */ new Map();
+    for (const f of s.hatch) for (const i of f.memberIdx) famBySeg.set(i, f.id);
+    const inRegion = [];
+    const nSeg = geo.segs.length >> 2;
+    for (let i = 0; i < nSeg; i++) {
+      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;
+    let droppedCap = 0;
+    if (visible.length > cap) {
+      kept = visible.slice().sort((a, b) => b.len - a.len).slice(0, cap);
+      droppedCap = visible.length - cap;
+    }
+    const segments = [], metaOut = [], family = [];
+    for (const { i } of kept) {
+      segments.push([
+        round1(geo.segs[i * 4]),
+        round1(geo.segs[i * 4 + 1]),
+        round1(geo.segs[i * 4 + 2]),
+        round1(geo.segs[i * 4 + 3])
+      ]);
+      metaOut.push(geo.meta[i]);
+      family.push(famBySeg.get(i) ?? null);
+    }
+    const spans = s.spans.filter((sp) => sp.x0 <= r.x1 && sp.x1 >= r.x0 && sp.y0 <= r.y1 && sp.y1 >= r.y0);
+    const keptIdx = new Set(kept.map((k) => k.i));
+    const families = s.hatch.filter((f) => rectsOverlap(f.bbox, r)).map(({ memberIdx, ...f }) => ({
+      ...f,
+      segments_in_region: memberIdx.reduce((acc, i) => acc + (keptIdx.has(i) ? 1 : 0), 0)
+    }));
+    return {
+      sheet: s.key,
+      page: s.pageNum,
+      sheet_px: [s.widthPx, s.heightPx],
+      region: [round1(r.x0), round1(r.y0), round1(r.x1), round1(r.y1)],
+      has_vector_linework: hasVectors,
+      vectors: {
+        segments,
+        meta: metaOut,
+        family,
+        kept: kept.length,
+        total_in_region: inRegion.length,
+        truncated: droppedShort + droppedCap > 0,
+        dropped: { short: droppedShort, cap: droppedCap },
+        ...droppedCap > 0 ? { note: `Region exceeds max_segments \u2014 the ${droppedCap} SHORTEST segments were dropped, so structure (walls) survives and fill (hatch) goes first. Narrow the region or raise max_segments for the full set.` } : {}
+      },
+      text: { spans, count: spans.length },
+      hatch: { families, count: families.length }
+    };
+  }
   async ensureGeometry(s) {
     if (!s.geo) {
       const opList = await s.page.operatorList();
@@ -1246,13 +1432,14 @@ var Session = class {
       ...origin ? { origin } : {}
     };
     this.shapes.push(shape);
+    this.pendingCommits.push(shape.id);
     return shape;
   }
   async oneClick(name, x, y, opts) {
     const s = this.sheet(name);
     const mask = await this.ensureMask(name);
     if (!mask) throw new UserError("This sheet has no vector linework (likely a scan); raster fallback not yet available in the MCP server.");
-    const f = floodRegion(mask, x, y);
+    const f = floodRegion(mask, x, y, opts.sensitivity ?? SENS_BALANCED);
     if (f.status === "leak") throw new UserError("That space isn't enclosed on the plan linework \u2014 the fill spilled through a gap or opening.");
     if (f.status !== "ok") throw new UserError("Landed in dense linework (hatching or text).");
     const ring = snapVertices(traceRegion(f), (px, py, d) => s.snap ? nearestSnap(s.snap, px, py, d) : null, SNAP_TOL);
@@ -1283,9 +1470,13 @@ var Session = class {
         actor: "agent",
         seed_norm: [x / s.widthPx, y / s.heightPx],
         reviewed: false,
-        ...f.hatchFiltered ? { hatch_filtered: true } : {}
+        ...f.hatchFiltered ? { hatch_filtered: true } : {},
+        // 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 } : {}
       }).id;
     }
+    this.flushCommits("one_click");
     return { ...common, area_sf, perimeter_lf, ...shape_id ? { shape_id } : {} };
   }
   /** Batch room detection: read every room-number label off the sheet's text
@@ -1293,48 +1484,130 @@ var Session = class {
    *  exactly like oneClick — just N of them from one call instead of N
    *  reasoning-heavy round-trips. Same contract as oneClick: no scale → a
    *  px-only preview per room; no condition → nothing commits (a review
-   *  pass, not a proposal-acceptance gate — this server has none). A region
-   *  that traces to a degenerate ring (<3 verts) is dropped from the batch
-   *  rather than failing the whole call — one bad label must not sink every
-   *  other clean detection on the sheet. */
+   *  pass, not a proposal-acceptance gate — this server has none).
+   *
+   *  Withholding — nothing is committed until it survives all three, and the
+   *  batch NEVER silently drops work: every withheld seed is counted and
+   *  reasoned in `withheld`, because a room the tool knows it skipped is a
+   *  question the caller can ask, while a room it skipped silently is a hole
+   *  in a bid.
+   *    1. degenerate — traced to fewer than 3 vertices.
+   *    2. duplicate — two labels flooding one region (a room tagged twice, or
+   *       a legend number landing in the same space) trace to an identical
+   *       ring. Committing both double-counts the area with no signal, which
+   *       is the worst failure mode an estimating tool has. One region commits
+   *       once; the collapsed labels ride along on `merged_labels`.
+   *    3. bubble — plans draw room numbers inside little boxes, and a seed at
+   *       the label floods the label's own BUBBLE: fully enclosed, traces
+   *       clean at label size, and is not a room (found live: 25 of 26). Each
+   *       label runs a SEED LADDER (anchor first, then label-height offsets)
+   *       and bubble rings are rejected scale-free (ring bbox ≈ label bbox) —
+   *       so the guard holds even before any scale is set. A label whose
+   *       every clean flood was its bubble counts here.
+   *    4. implausible — enclosed, clean, non-bubble, and still smaller than
+   *       `minAreaSf` (default 5 SF — smaller than any real finished space; a
+   *       broom closet is ~10 SF): a door swing or wall cavity. Only applied
+   *       once a scale exists, since without one there is no real area to
+   *       judge and nothing commits anyway. */
   async detectRooms(name, opts) {
     const s = this.sheet(name);
     const mask = await this.ensureMask(name);
     if (!mask) throw new UserError("This sheet has no vector linework (likely a scan); raster fallback not yet available in the MCP server.");
-    const seeds = roomLabelSeeds(s.text);
-    const regions = detectRegions(mask, seeds);
-    const rooms = regions.map((r) => {
-      const ring = snapVertices(traceRegion(r.flood), (px, py, d) => s.snap ? nearestSnap(s.snap, px, py, d) : null, SNAP_TOL);
-      if (ring.length < 3) return null;
-      const areaPx2 = ringArea(ring);
-      const perimPx = closedMetrics(ring).perim;
+    const minAreaSf = opts.minAreaSf ?? 5;
+    if (!s.spans) s.spans = textSpans(s.page);
+    const labels = [];
+    for (const sp of s.spans) {
+      const num = (sp.str || "").trim().split(/\s+/).find((tok) => ROOM_LABEL_RE.test(tok));
+      if (num) labels.push({ str: num, bbox: sp });
+    }
+    const withheld = { degenerate: 0, duplicate: 0, bubble: 0, implausible: 0 };
+    const byRing = /* @__PURE__ */ new Map();
+    const order = [];
+    for (const lb of labels) {
+      let ring = null, hatch = false, 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);
+        if (f.status !== "ok") continue;
+        const r = snapVertices(traceRegion(f), (px, py, d) => s.snap ? nearestSnap(s.snap, px, py, d) : null, SNAP_TOL);
+        if (r.length < 3) {
+          sawDegenerate = true;
+          continue;
+        }
+        if (isLabelBubblePx(r, lb.bbox)) {
+          sawBubble = true;
+          continue;
+        }
+        ring = r;
+        hatch = !!f.hatchFiltered;
+        seed = probe;
+        break;
+      }
+      if (!ring || !seed) {
+        if (sawBubble) withheld.bubble++;
+        else if (sawDegenerate) withheld.degenerate++;
+        continue;
+      }
+      const key = ring.map(([x, y]) => `${Math.round(x)},${Math.round(y)}`).join(";");
+      const seen = byRing.get(key);
+      if (seen) {
+        seen.merged.push(lb.str);
+        withheld.duplicate++;
+        continue;
+      }
+      const cand = {
+        label: lb.str,
+        ring,
+        areaPx2: ringArea(ring),
+        perimPx: closedMetrics(ring).perim,
+        seed,
+        hatch,
+        merged: []
+      };
+      byRing.set(key, cand);
+      order.push(cand);
+    }
+    const upp = s.upp;
+    const rooms = order.map((c) => {
       const common = {
-        label: r.str,
-        nverts: ring.length,
-        ...r.flood.hatchFiltered ? { hatch_filtered: true } : {},
-        ...opts.returnVerts ? { verts: ring.map(([vx, vy]) => [round1(vx), round1(vy)]) } : {}
+        label: c.label,
+        nverts: c.ring.length,
+        ...c.merged.length ? { merged_labels: c.merged } : {},
+        ...c.hatch ? { hatch_filtered: true } : {},
+        ...opts.returnVerts ? { verts: c.ring.map(([vx, vy]) => [round1(vx), round1(vy)]) } : {}
       };
-      if (s.upp == null) {
-        return { ...common, area_px2: round1(areaPx2), perimeter_px: round1(perimPx) };
+      if (upp == null) {
+        return { ...common, area_px2: round1(c.areaPx2), perimeter_px: round1(c.perimPx) };
+      }
+      const area_sf = round2(c.areaPx2 * upp * upp);
+      if (area_sf < minAreaSf) {
+        withheld.implausible++;
+        return null;
       }
-      const upp = s.upp;
-      const area_sf = round2(areaPx2 * upp * upp);
-      const perimeter_lf = round2(perimPx * upp);
+      const perimeter_lf = round2(c.perimPx * upp);
       let shape_id;
       if (opts.condition) {
-        shape_id = this.commit(s, opts.condition, opts.role, ring, { area_sf, perimeter_lf }, {
+        shape_id = this.commit(s, opts.condition, opts.role, c.ring, { area_sf, perimeter_lf }, {
           method: "one_click_v1",
           actor: "agent",
-          seed_norm: [r.seed[0] / s.widthPx, r.seed[1] / s.heightPx],
+          seed_norm: [c.seed[0] / s.widthPx, c.seed[1] / s.heightPx],
           reviewed: false,
-          ...r.flood.hatchFiltered ? { hatch_filtered: true } : {}
+          ...c.hatch ? { hatch_filtered: true } : {}
         }).id;
       }
       return { ...common, area_sf, perimeter_lf, ...shape_id ? { shape_id } : {} };
     }).filter((r) => r !== null);
+    this.flushCommits("detect_rooms");
+    const withheldTotal = withheld.degenerate + withheld.duplicate + withheld.bubble + withheld.implausible;
     return {
       detected: rooms.length,
       rooms,
+      withheld: {
+        total: withheldTotal,
+        ...withheld,
+        ...upp != null ? { min_area_sf: minAreaSf } : {}
+      },
+      ...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})` : ""}.` } : {}
     };
   }
@@ -1346,6 +1619,7 @@ var Session = class {
     const perimeter_lf = round2(met.perim * s.upp);
     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 } : {} };
   }
   measureLine(name, pts, opts) {
@@ -1354,6 +1628,7 @@ var Session = class {
     const length_lf = round2(openLen(pts) * s.upp);
     let shape_id;
     if (opts.condition) shape_id = this.commit(s, opts.condition, "linear", pts, { area_sf: 0, perimeter_lf: length_lf }, { method: "manual", actor: "agent" }).id;
+    this.flushCommits("measure_line");
     return { length_lf, npts: pts.length, ...shape_id ? { shape_id } : {} };
   }
   summary() {
@@ -1364,9 +1639,110 @@ var Session = class {
   deleteShape(id) {
     const i = this.shapes.findIndex((x) => x.id === id);
     if (i < 0) throw new UserError(`No shape with id ${JSON.stringify(id)}.`);
-    this.shapes.splice(i, 1);
+    const [shape] = this.shapes.splice(i, 1);
+    this.record({ op: "delete", tool: "delete_shape", removed: [{ shape, index: i }] });
     return { deleted: id, shape_count: this.shapes.length };
   }
+  /** Revise a committed shape in place: new geometry, a different condition, a
+   * different role, or any combination. This is the verb that turns the agent
+   * from an appender into an editor — it can propose a ring, look at the
+   * overlay, see it overshot into the corridor, and move the two offending
+   * vertices, instead of deleting and re-deriving the whole room.
+   *
+   * The review gate is absolute: a shape a human affirmed (origin.reviewed ===
+   * true) is ink, and no agent verb touches ink. This server never sets that
+   * flag itself, so the guard is inert here today — it is the contract that
+   * makes this surface portable to a host that DOES have a review gate, and it
+   * belongs in the code rather than in a host's good intentions.
+   *
+   * Provenance: agent self-revision bumps origin.agent_edits and touches
+   * NOTHING in the human-correction vocabulary (edited / edits /
+   * proposed_verts_norm — see web/src/lib/provenance.js). Those fields grade a
+   * human's correction of a machine proposal; an agent fixing its own work is
+   * not that, and conflating the two would poison the exact signal the capture
+   * layer exists to collect. Freezing proposed_verts_norm stays correct on the
+   * human's first edit, because the geometry a reviewer saw IS the agent's
+   * final revision, not its first draft. */
+  editShape(id, patch) {
+    const i = this.shapes.findIndex((x) => x.id === id);
+    if (i < 0) throw new UserError(`No shape with id ${JSON.stringify(id)}.`);
+    const cur = this.shapes[i];
+    if (cur.origin?.reviewed === true) {
+      throw new UserError(`Shape ${JSON.stringify(id)} was affirmed by a human \u2014 reviewed work is ink, not pencil, and cannot be edited by an agent.`);
+    }
+    if (patch.verts === void 0 && patch.condition === void 0 && patch.role === void 0) {
+      throw new UserError("Nothing to change \u2014 pass at least one of verts, condition, role.");
+    }
+    const s = this.sheet(cur.sheet_id);
+    if (s.upp == null) throw new UserError(this.scaleGate(s));
+    const upp = s.upp;
+    const role = patch.role ?? cur.measure_role;
+    const vertsPx = patch.verts ?? cur.verts_norm.map(([x, y]) => [x * s.widthPx, y * s.heightPx]);
+    const minPts = role === "linear" ? 2 : 3;
+    if (vertsPx.length < minPts) {
+      throw new UserError(`A ${role === "linear" ? "linear shape needs at least 2 points" : "closed shape needs at least 3 vertices"} \u2014 got ${vertsPx.length}.`);
+    }
+    const computed = role === "linear" ? { area_sf: 0, perimeter_lf: round2(openLen(vertsPx) * upp) } : (() => {
+      const met = closedMetrics(vertsPx);
+      return { area_sf: round2(met.area * upp * upp), perimeter_lf: round2(met.perim * upp) };
+    })();
+    const before = structuredClone(cur);
+    const condition_id = patch.condition !== void 0 ? this.conditionFor(patch.condition).id : cur.condition_id;
+    this.shapes[i] = {
+      ...cur,
+      condition_id,
+      measure_role: role,
+      verts_norm: vertsPx.map(([x, y]) => [x / s.widthPx, y / s.heightPx]),
+      computed,
+      ...cur.origin ? { origin: { ...cur.origin, agent_edits: (cur.origin.agent_edits ?? 0) + 1 } } : {}
+    };
+    this.record({ op: "edit", tool: "edit_shape", before });
+    const changed = [
+      ...patch.verts !== void 0 ? ["verts"] : [],
+      ...patch.condition !== void 0 ? ["condition"] : [],
+      ...patch.role !== void 0 ? ["role"] : []
+    ];
+    return {
+      shape_id: id,
+      changed,
+      measure_role: role,
+      nverts: vertsPx.length,
+      ...computed,
+      agent_edits: this.shapes[i].origin?.agent_edits ?? 0
+    };
+  }
+  /** 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
+   * over a look — n counts gestures that changed something. */
+  undoLast(n) {
+    const undone = [];
+    for (let k = 0; k < n; k++) {
+      const e = this.journal.pop();
+      if (!e) break;
+      if (e.op === "commit") {
+        const dead = new Set(e.ids);
+        this.shapes = this.shapes.filter((x) => !dead.has(x.id));
+        undone.push({ seq: e.seq, op: e.op, tool: e.tool, shapes: e.ids.length });
+      } else if (e.op === "edit") {
+        const i = this.shapes.findIndex((x) => x.id === e.before.id);
+        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 {
+        for (const { shape, index } of e.removed) {
+          this.shapes.splice(Math.min(index, this.shapes.length), 0, shape);
+        }
+        undone.push({ seq: e.seq, op: e.op, tool: e.tool, shapes: e.removed.length });
+      }
+    }
+    return {
+      undone: undone.length,
+      steps: undone,
+      shape_count: this.shapes.length,
+      remaining: this.journal.length,
+      ...undone.length < n ? { note: `Only ${undone.length} step(s) were available to undo.` } : {}
+    };
+  }
   /** The exact browser save payload (TakeoffCanvas.jsx autosave + the schema key
    * store.saveAnnotations stamps) — importable by the app. */
   exportPayload() {
@@ -1462,6 +1838,7 @@ var oneClickOutput = {
 var detectedRoom = z.object({
   label: z.string().describe('The room-number text the seed was read from (e.g. "104", "139A")'),
   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"),
   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"),
@@ -1473,6 +1850,15 @@ var detectedRoom = z.object({
 var detectRoomsOutput = {
   detected: z.number().int().describe("Count of cleanly-detected rooms \u2014 may be fewer than the labels found on the sheet"),
   rooms: z.array(detectedRoom),
+  withheld: z.object({
+    total: z.number().int().describe("Seeds found on the sheet but not reported as rooms"),
+    degenerate: z.number().int().describe("Traced to fewer than 3 vertices"),
+    duplicate: z.number().int().describe("Flooded to a region another label already claimed \u2014 counted once, never twice"),
+    bubble: z.number().int().describe("Labels whose every clean flood was their own label BUBBLE (ring bbox \u2248 label bbox \u2014 plans box their room numbers). Scale-free, so it guards unscaled previews too"),
+    implausible: z.number().int().describe("Enclosed, clean, non-bubble, but smaller than min_area_sf \u2014 a door swing or wall cavity rather than a room"),
+    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"),
   warning: z.string().optional().describe("Preview mode (no scale): why quantities are unavailable and what to do")
 };
 var measurePolygonOutput = {
@@ -1550,11 +1936,67 @@ var deleteShapeOutput = {
   deleted: z.string().describe("The removed shape's id"),
   shape_count: z.number().int().describe("Committed shapes remaining")
 };
+var editShapeOutput = {
+  shape_id: z.string(),
+  changed: z.array(z.enum(["verts", "condition", "role"])).describe("Which fields this call actually changed"),
+  measure_role: z.enum(["floor_area", "deduct", "linear"]),
+  nverts: z.number().int(),
+  area_sf: z.number().describe("0 for linear shapes"),
+  perimeter_lf: z.number().describe("Length for linear shapes, perimeter for closed ones"),
+  agent_edits: z.number().int().describe("How many times the agent has revised this shape \u2014 separate from the human-correction tally")
+};
+var undoLastOutput = {
+  undone: z.number().int().describe("Steps actually reversed"),
+  steps: z.array(z.object({
+    seq: z.number().int(),
+    op: z.enum(["commit", "edit", "delete"]),
+    tool: z.string().describe("The tool call this step came from"),
+    shapes: z.number().int().describe("Shapes affected by reversing this step")
+  })).describe("Newest first"),
+  shape_count: z.number().int().describe("Committed shapes after the undo"),
+  remaining: z.number().int().describe("Steps still available to undo"),
+  note: z.string().optional()
+};
 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)"),
   text: z.string().describe("The items joined with spaces")
 };
+var hatchFamilyRow = z.object({
+  id: z.string().describe("Content hash of the quantized (angle, pitch, pen-width) signature \u2014 the SAME id for the same pattern spec anywhere on the sheet, so legend\u2194plan matching is id === id. Identifies a pattern, not a material; the legend maps pattern \u2192 material."),
+  angle_deg: z.number().describe("Raw mean angle [0, 180) \u2014 rides beside the id for tolerance matching at bucket boundaries"),
+  pitch_px: z.number().describe("Raw median row pitch, image px"),
+  pen_w_px: z.number().int().describe("Modal device pen width of the members"),
+  rows: z.number().int(),
+  segments: z.number().int().describe("Member segments in the whole instance"),
+  segments_in_region: z.number().int().describe("\u2026of which this many were returned in vectors (post-decimation)"),
+  bbox: z.array(z.number()).length(4).describe("The instance's tight bbox [x0, y0, x1, y1], image px")
+});
+var sheetContextOutput = {
+  sheet: z.string(),
+  page: z.number().int(),
+  sheet_px: z.array(z.number()).length(2),
+  region: z.array(z.number()).length(4).describe("The region actually resolved, post-clamp \u2014 pass this same rect to view_sheet and the render is in the same frame by construction"),
+  has_vector_linework: z.boolean().describe("false = a scan: vectors and hatch are empty because there are none, not because the region is blank"),
+  vectors: z.object({
+    segments: z.array(z.array(z.number()).length(4)).describe("[x0, y0, x1, y1] per segment, image px, endpoints exactly as drawn \u2014 clipped by KEEPING whole intersecting segments, never by rewriting them"),
+    meta: z.array(z.number().int()).describe("One byte per segment, aligned with segments: bit 1 = curve chord, bit 2 = clip-only, bit 4 = filled-not-stroked; high nibble = device pen width"),
+    family: z.array(z.string().nullable()).describe("Aligned with segments: the hatch-family id this segment belongs to, or null for structural linework"),
+    kept: z.number().int(),
+    total_in_region: z.number().int().describe("Segments intersecting the region before any decimation \u2014 kept + dropped always reconciles to this"),
+    truncated: z.boolean(),
+    dropped: z.object({
+      short: z.number().int().describe("Below min_len_px (invisible ink)"),
+      cap: z.number().int().describe("Over max_segments \u2014 the SHORTEST went first, so walls survive")
+    }),
+    note: z.string().optional()
+  }),
+  text: z.object({
+    spans: z.array(z.object({ str: z.string(), x0: z.number(), y0: z.number(), x1: z.number(), y1: z.number() })).describe("Text with bboxes, image px, same frame as the vectors"),
+    count: z.number().int()
+  }),
+  hatch: z.object({ families: z.array(hatchFamilyRow), count: z.number().int() })
+};
 
 // 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.";
@@ -1609,20 +2051,23 @@ function registerTools(server, session) {
       y: z2.number(),
       condition: z2.string().optional().describe("Finish tag to commit under (minted on first use)"),
       role: roleSchema,
-      return_verts: z2.boolean().default(false).describe("Include the traced polygon's vertices (image px)")
+      return_verts: z2.boolean().default(false).describe("Include the traced polygon's vertices (image px)"),
+      sensitivity: z2.number().min(0).max(1).optional().describe("Fill sensitivity, the same knob the canvas has: 0 strict (hatch/light linework always blocks), 0.5 balanced (default), 1 aggressive (crosses more hatch, tolerates more growth). Raise it when a flood stops short at hatching INSIDE the room; verify the grown ring with view_sheet overlay before committing")
     },
     outputSchema: oneClickOutput
-  }, run("one_click", (a) => session.oneClick(a.sheet, a.x, a.y, { condition: a.condition, role: a.role, returnVerts: a.return_verts })));
+  }, run("one_click", (a) => session.oneClick(a.sheet, a.x, a.y, { condition: a.condition, role: a.role, returnVerts: a.return_verts, sensitivity: a.sensitivity })));
   server.registerTool("detect_rooms", {
-    description: `Batch room detection: reads every room-number label off the sheet's text layer (e.g. "134", "OFFICE 101") and runs One-Click at each \u2014 one call instead of read_sheet_text + reasoning + N one_click calls. Only cleanly-traced rooms are returned; a label that leaked or landed in dense linework is silently withheld, never reported as a bad room. With the sheet's scale set, returns area_sf/perimeter_lf per room; pass condition to commit every detected room under that finish tag (role "deduct" makes them subtract). Without a scale, returns px-only quantities per room and commits nothing. ${COORDS}`,
+    description: `Batch room detection: reads every room-number label off the sheet's text layer (e.g. "134", "OFFICE 101") and runs One-Click at each \u2014 one call instead of read_sheet_text + reasoning + N one_click calls. A seed is only reported as a room once it survives three gates, and everything skipped is counted and reasoned in \`withheld\` \u2014 never dropped silently, because a room the tool tells you it skipped is a question you can ask, while one it hides is a hole in a bid. The gates: a flood that leaked or landed in dense linework never becomes a region; two labels flooding the SAME region commit once (the extra labels ride on \`merged_labels\` \u2014 double-counting an area is the worst failure an estimating tool has); and a flood that is enclosed and clean but smaller than min_area_sf is a room-number bubble, a door swing, or a wall cavity rather than a room. With the sheet's scale set, returns area_sf/perimeter_lf per room; pass condition to commit every detected room under that finish tag (role "deduct" makes them subtract). Without a scale, returns px-only quantities per room and commits nothing \u2014 the plausibility floor needs real units, so it only applies once a scale is set. ${COORDS}`,
     inputSchema: {
       sheet: z2.string(),
       condition: z2.string().optional().describe("Finish tag to commit every detected room under (minted on first use)"),
       role: roleSchema,
-      return_verts: z2.boolean().default(false).describe("Include each traced polygon's vertices (image px)")
+      return_verts: z2.boolean().default(false).describe("Include each traced polygon's vertices (image px)"),
+      min_area_sf: z2.number().positive().default(5).describe("Plausibility floor: enclosed non-bubble regions smaller than this are withheld as cavities, not rooms. Default 5 SF \u2014 below any real finished space (a broom closet is ~10 SF). Lower it to inspect what was skipped."),
+      sensitivity: z2.number().min(0).max(1).optional().describe("Fill sensitivity, the same knob the canvas has: 0 strict (hatch/light linework always blocks), 0.5 balanced (default), 1 aggressive (crosses more hatch, tolerates more growth). Raise it when a flood stops short at hatching INSIDE the room; verify the grown ring with view_sheet overlay before committing")
     },
     outputSchema: detectRoomsOutput
-  }, run("detect_rooms", (a) => session.detectRooms(a.sheet, { condition: a.condition, role: a.role, returnVerts: a.return_verts })));
+  }, run("detect_rooms", (a) => session.detectRooms(a.sheet, { condition: a.condition, role: a.role, returnVerts: a.return_verts, minAreaSf: a.min_area_sf, sensitivity: a.sensitivity })));
   server.registerTool("measure_polygon", {
     description: `Measure a closed polygon you supply (min 3 vertices, image px): area_sf and perimeter_lf at the sheet's scale. Requires the scale to be set. Pass condition to commit it; role "deduct" subtracts. ${COORDS}`,
     inputSchema: {
@@ -1664,6 +2109,33 @@ function registerTools(server, session) {
     inputSchema: { shape_id: z2.string() },
     outputSchema: deleteShapeOutput
   }, run("delete_shape", ({ shape_id }) => session.deleteShape(shape_id)));
+  server.registerTool("sheet_context", {
+    description: `The sheet's STRUCTURE in one call and one frame: the classified vector segments, the positioned text spans, and the hatch-family instances of a region \u2014 everything the engine itself floods against, exposed as data instead of pixels. Use it when you need to REASON about a region rather than look at it: which lines bound this space and at what pen weight, what the region says, and which periodic fill pattern covers it. The join is the point \u2014 all three arrive in image px with no reconciliation left to do, and the reply echoes the post-clamp region so passing that same rect to view_sheet gives you the matching render by construction. Hatch families carry a content-derived id (same pattern spec \u21D2 same id, anywhere on the sheet), so matching a plan region to a legend swatch is comparing two ids, not guessing from a render \u2014 read the legend region, read the room region, match ids, and cite both bboxes as evidence. Decimation is declared, ordered, and counted on every reply: segments shorter than min_len_px drop first (invisible ink), then a max_segments cap applies LONGEST-FIRST so walls survive and hatch strokes go; kept + dropped always reconciles to total_in_region, and whole segments drop with their meta intact \u2014 nothing is ever simplified or merged, because these are classified segments and a merge would rewrite the classification. A scan returns has_vector_linework: false with empty vectors \u2014 absence of linework, never a claim the region is blank. ${COORDS}`,
+    inputSchema: {
+      sheet: z2.string(),
+      region: z2.object({ x0: z2.number(), y0: z2.number(), x1: z2.number(), y1: z2.number() }).optional().describe("Rect in image px (origin top-left, y down); omit for the full sheet"),
+      min_len_px: z2.number().min(0).default(CONTEXT_MIN_LEN_PX).describe(`Drop segments shorter than this (default ${CONTEXT_MIN_LEN_PX} \u2014 one PDF point at render scale 2.0, below any pen width). 0 keeps everything`),
+      max_segments: z2.number().int().min(1).max(CONTEXT_MAX_SEGMENTS_CEIL).default(CONTEXT_MAX_SEGMENTS).describe(`Segment cap, applied longest-first (default ${CONTEXT_MAX_SEGMENTS}). The reply's dropped.cap says exactly what a smaller region would recover`)
+    },
+    outputSchema: sheetContextOutput
+  }, run("sheet_context", (a) => session.sheetContext(a.sheet, { region: a.region, min_len_px: a.min_len_px, max_segments: a.max_segments })));
+  server.registerTool("edit_shape", {
+    description: `REVISE a shape you already committed, instead of deleting it and starting over: pass new verts to move the geometry, condition to reassign it to a different finish tag, role to switch between floor_area / deduct / linear, or any combination. Quantities are recomputed from the result \u2014 a role flip alone re-measures (closed area vs open length). The loop this is for: one_click or measure_polygon to commit, view_sheet with overlay:true to LOOK at what landed, then edit_shape to fix the two vertices that overshot into the corridor. Shapes a human affirmed (origin.reviewed) are ink and are refused \u2014 an agent revises its own pencil and nothing else. Agent self-revision is tallied on origin.agent_edits, kept deliberately separate from the human-correction fields. ${COORDS}`,
+    inputSchema: {
+      shape_id: z2.string().describe("Id returned when the shape was committed"),
+      verts: z2.array(pointSchema).optional().describe("Replacement geometry (image px): \u22653 vertices for an area shape, \u22652 points for a linear one"),
+      condition: z2.string().optional().describe("Reassign to this finish tag (minted on first use)"),
+      role: z2.enum(["floor_area", "deduct", "linear"]).optional().describe("Switch what the shape measures")
+    },
+    outputSchema: editShapeOutput
+  }, run("edit_shape", (a) => session.editShape(a.shape_id, { verts: a.verts, condition: a.condition, role: a.role })));
+  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, or a delete_shape. Each step is reversed exactly (a commit is removed, an edit is restored verbatim, a delete is re-inserted where it was), 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})`)
+    },
+    outputSchema: undoLastOutput
+  }, run("undo_last", ({ n }) => session.undoLast(n)));
   server.registerTool("read_sheet_text", {
     description: `The sheet's text with positions \u2014 items [{str, x, y}] in image px plus the joined text. Optionally restrict to a region {x0, y0, x1, y1}. Use it to read title blocks, room labels, finish schedules, and scale notes. ${COORDS}`,
     inputSchema: {
@@ -1774,7 +2246,7 @@ function registerResources(server, session) {
 // package.json
 var package_default = {
   name: "opentakeoff-mcp",
-  version: "0.6.0",
+  version: "0.7.0",
   mcpName: "io.github.Kentucky-ai/opentakeoff",
   type: "module",
   description: "OpenTakeoff MCP server \u2014 drive the takeoff engine from your MCP client over stdio.",
@@ -1790,7 +2262,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/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/session.test.ts test/tools.test.ts test/view.test.ts"
   },
   dependencies: {
     "@modelcontextprotocol/sdk": "^1.12.0",
@@ -1801,7 +2273,7 @@ var package_default = {
     "@types/node": "^22.19.21",
     typescript: "^5.7.2",
     tsx: "^4.19.2",
-    esbuild: "^0.24.2"
+    esbuild: "^0.25.0"
   },
   bin: {
     "opentakeoff-mcp": "dist/server.js"
@@ -1826,7 +2298,11 @@ var package_default = {
     "pdf",
     "quantity-takeoff",
     "flooring"
-  ]
+  ],
+  overrides: {
+    "fast-uri": "^3.1.4",
+    "@hono/node-server": "^2.0.5"
+  }
 };
 
 // server.ts

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "opentakeoff-mcp",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "mcpName": "io.github.Kentucky-ai/opentakeoff",
   "type": "module",
-  "description": "OpenTakeoff MCP server — drive the takeoff engine from your MCP client over stdio.",
+  "description": "OpenTakeoff MCP server \u2014 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/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/session.test.ts test/tools.test.ts test/view.test.ts"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.0",
@@ -27,7 +27,7 @@
     "@types/node": "^22.19.21",
     "typescript": "^5.7.2",
     "tsx": "^4.19.2",
-    "esbuild": "^0.24.2"
+    "esbuild": "^0.25.0"
   },
   "bin": {
     "opentakeoff-mcp": "dist/server.js"
@@ -52,5 +52,9 @@
     "pdf",
     "quantity-takeoff",
     "flooring"
-  ]
-}
+  ],
+  "overrides": {
+    "fast-uri": "^3.1.4",
+    "@hono/node-server": "^2.0.5"
+  }
+}