opentakeoff-mcp 0.6.0 → 0.6.1

package/dist/server-core.js

@@ -1293,48 +1293,101 @@ 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. implausible — a flood trapped inside a room-number bubble, a door
+   *       swing, or a wall cavity is fully enclosed, so it traces clean and
+   *       `detectRegions` passes it. Area is the only thing that separates it
+   *       from a room. Withheld below `minAreaSf` (default 5 SF — smaller than
+   *       any real finished space; a broom closet is ~10 SF). 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 minAreaSf = opts.minAreaSf ?? 5;
     const seeds = roomLabelSeeds(s.text);
     const regions = detectRegions(mask, seeds);
-    const rooms = regions.map((r) => {
+    const withheld = { degenerate: 0, duplicate: 0, implausible: 0 };
+    const byRing = /* @__PURE__ */ new Map();
+    const order = [];
+    for (const r of regions) {
       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 common = {
+      if (ring.length < 3) {
+        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(r.str);
+        withheld.duplicate++;
+        continue;
+      }
+      const cand = {
         label: r.str,
-        nverts: ring.length,
-        ...r.flood.hatchFiltered ? { hatch_filtered: true } : {},
-        ...opts.returnVerts ? { verts: ring.map(([vx, vy]) => [round1(vx), round1(vy)]) } : {}
+        ring,
+        areaPx2: ringArea(ring),
+        perimPx: closedMetrics(ring).perim,
+        seed: r.seed,
+        hatch: !!r.flood.hatchFiltered,
+        merged: []
       };
-      if (s.upp == null) {
-        return { ...common, area_px2: round1(areaPx2), perimeter_px: round1(perimPx) };
+      byRing.set(key, cand);
+      order.push(cand);
+    }
+    const upp = s.upp;
+    const rooms = order.map((c) => {
+      const common = {
+        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 (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);
+    const withheldTotal = withheld.degenerate + withheld.duplicate + 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.implausible} under ${minAreaSf} SF, ${withheld.degenerate} untraceable. Raise or lower min_area_sf to see more.` } : {},
       ...s.upp == null ? { warning: `No scale set for ${s.key} \u2014 quantities unavailable. Call set_scale${s.detected ? ` (detected: ${s.detected.label})` : ""}.` } : {}
     };
   }
@@ -1462,6 +1515,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 +1527,14 @@ 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"),
+    implausible: z.number().int().describe("Enclosed and clean, but smaller than min_area_sf \u2014 a label bubble, 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 = {
@@ -1614,15 +1676,16 @@ function registerTools(server, session) {
     outputSchema: oneClickOutput
   }, run("one_click", (a) => session.oneClick(a.sheet, a.x, a.y, { condition: a.condition, role: a.role, returnVerts: a.return_verts })));
   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 regions smaller than this are withheld as label bubbles/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.")
     },
     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 })));
   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: {
@@ -1774,7 +1837,7 @@ function registerResources(server, session) {
 // package.json
 var package_default = {
   name: "opentakeoff-mcp",
-  version: "0.6.0",
+  version: "0.6.1",
   mcpName: "io.github.Kentucky-ai/opentakeoff",
   type: "module",
   description: "OpenTakeoff MCP server \u2014 drive the takeoff engine from your MCP client over stdio.",

package/package.json

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