opentakeoff-mcp 0.9.56 → 0.9.59

package/dist/server-core.js

@@ -77,18 +77,49 @@ var STANDARD_SCALES = [
 var SHEET_NO_RE = /^[A-Z]{1,3}[-. ]?\d{1,3}(\.\d{1,2})?[A-Z]?$/;
 function extractSheetNumber(textContent, viewport) {
   const W = viewport.width, H = viewport.height;
-  let best = null, bestH = 0;
+  const placed = [];
+  const vscale = Math.hypot(viewport.transform?.[0] ?? 1, viewport.transform?.[1] ?? 0) || 1;
   for (const it of textContent.items || []) {
     const raw = (it.str || "").trim().toUpperCase().replace(/\s+/g, "");
-    if (raw.length < 2 || raw.length > 8 || !SHEET_NO_RE.test(raw)) continue;
+    if (!raw) continue;
     const t = pdfjsLib.Util.transform(viewport.transform, it.transform);
     const x = t[4], y = t[5], h = Math.hypot(t[2], t[3]) || it.height || 0;
     if (x < W * 0.6 || y < H * 0.55) continue;
+    const w = it.width != null ? it.width * vscale : raw.length * 0.62 * h;
+    placed.push({ raw, x, y, h, w });
+  }
+  let best = null, bestScore = 0;
+  const consider = (raw, x, y, h) => {
+    if (raw.length < 2 || raw.length > 8 || !SHEET_NO_RE.test(raw)) return;
     const score = h + x / W * 4 + y / H * 4;
-    if (score > bestH) {
-      bestH = score;
+    if (score > bestScore) {
+      bestScore = score;
       best = raw;
     }
+  };
+  for (const p of placed) consider(p.raw, p.x, p.y, p.h);
+  const rows = [];
+  for (const p of [...placed].sort((a, b) => a.y - b.y || a.x - b.x)) {
+    const row = rows[rows.length - 1];
+    if (row && Math.abs(p.y - row[0].y) <= Math.max(2, row[0].h * 0.35)) row.push(p);
+    else rows.push([p]);
+  }
+  for (const row of rows) {
+    row.sort((a, b) => a.x - b.x);
+    let run2 = [];
+    const flush = () => {
+      if (run2.length > 1) {
+        const h = Math.max(...run2.map((r) => r.h));
+        consider(run2.map((r) => r.raw).join(""), run2[0].x, run2[0].y, h);
+      }
+      run2 = [];
+    };
+    for (const p of row) {
+      const prev = run2[run2.length - 1];
+      if (prev && p.x - (prev.x + prev.w) > Math.max(...run2.map((r) => r.h)) * 1.2) flush();
+      run2.push(p);
+    }
+    flush();
   }
   return best;
 }
@@ -2580,7 +2611,9 @@ var isVertical = (s) => s.rot != null ? Math.abs(s.rot % 180) === 90 : (s.str ||
 var SCHEDULE_TITLE_RE = /^[A-Z][A-Z ()/&.'’-]* SCHEDULE( *[-–] *[A-Z0-9 ()/&.'’-]+)?( *\(?(?:CONTINUATION|CONTINUED|CONT['’]?D?)\.?\)?)?$/;
 var ROLE_SIGNALS = [
   { re: /DEMOLITION\s+PLAN|DEMO\s+PLAN/, role: "demolition", conf: 0.9 },
-  { re: /FINISH\s+PLAN|FLOOR\s+PLAN|FURNITURE\s+PLAN|CEILING\s+PLAN/, role: "plan", conf: 0.85 },
+  // every discipline draws plans, not just finishes — an M-sheet's "SECOND
+  // FLOOR DUCTWORK PLAN" is as much a plan title as an A-sheet's finish plan
+  { re: /(?:FINISH|FLOOR|FURNITURE|CEILING|DUCTWORK|PIPING|MECHANICAL|ELECTRICAL|LIGHTING|POWER|PLUMBING|SPRINKLER|HVAC|FRAMING|FOUNDATION|ROOF|SITE|EQUIPMENT)\s+PLAN\b/, role: "plan", conf: 0.85 },
   { re: SCHEDULE_TITLE_RE, role: "schedule", conf: 0.85 },
   { re: /SCHEDULE/, role: "schedule", conf: 0.5 },
   { re: /LEGEND/, role: "legend", conf: 0.5 },
@@ -2600,7 +2633,7 @@ function classifySheetRole(sheet) {
   }
   if (!hits.length) {
     const n = norm(sheet.sheet_number || "");
-    if (/^A-?1\d\d/.test(n)) return { role: "plan", confidence: 0.4, evidence: null };
+    if (/^(A|M|E|P|S|FP)-?1\d\d/.test(n)) return { role: "plan", confidence: 0.4, evidence: null };
     return { role: "unknown", confidence: 0, evidence: null };
   }
   hits.sort((a, b) => b.conf - a.conf);
@@ -2916,13 +2949,23 @@ var isNonFinishSchedule = (title) => {
   return OTHER_FAMILY_RE.test(u) && !/\b(FINISH|MATERIAL)S?\b/.test(u);
 };
 function rowKeyOf(raw, kind, buildings) {
-  const key = norm(raw).replace(/[^A-Z0-9-]/g, "");
-  if (kind === "finish") return CODE_RE.test(key) ? { key } : null;
+  const kept = norm(raw).replace(/[^A-Z0-9/-]/g, "");
+  const key = kept.replace(/\//g, "");
+  if (kind === "finish") {
+    const parts = kept.split("/").filter(Boolean);
+    if (parts.length > 1 && parts.every((p) => CODE_RE.test(p))) return { key: parts.join("/") };
+    return CODE_RE.test(key) ? { key } : null;
+  }
   if (ROW_KEY_RE.test(key)) return { key };
   const q = key.match(QUALIFIED_KEY_RE);
   if (q && buildings?.has(q[1])) return { key, building: q[1] };
   return null;
 }
+var rowKeyAnswersFor = (key, want) => {
+  const c = norm(key).replace(/\s+/g, "");
+  const w = norm(want).replace(/\s+/g, "");
+  return c === w || c.split("/").filter(Boolean).includes(w);
+};
 var numOf = (key) => key.match(QUALIFIED_KEY_RE)?.[2] ?? key;
 var centerX = (t) => t.x + (t.w || 0) / 2;
 function columnMapFor(rows, anchors, cfg, x0, x1, coord) {
@@ -3470,7 +3513,7 @@ function resolveTag(graph, tag) {
     const code = norm(cell.text).replace(/[^A-Z0-9-]/g, "");
     const fin = { surface, code: cell.text.trim(), source: { sheet: r.sheet, text: cell.text.trim(), bbox: cell.bbox } };
     for (const ft of finTables) {
-      const def = ft.rows.find((fr) => norm(fr.key) === code);
+      const def = ft.rows.find((fr) => rowKeyAnswersFor(fr.key, code));
       if (def) {
         const cells = {};
         for (const [k, v] of Object.entries(def.cells)) cells[k] = v.text;
@@ -6994,6 +7037,158 @@ var Session = class _Session {
    * through this same path while telling the truth about the method —
    * symbol_sweep stamps `{method: "symbol_sweep", …, symbol: {score, …}}` per
    * marker; a bare place_count stays exactly the manual agent gesture it is. */
+  /** count_marks — the deterministic census, the whole count takeoff in ONE
+   * call: every VALUE-ANNOTATED mark tag on the plan sheets, counted per
+   * schedule mark, committed as EA markers, residue disclosed.
+   *
+   * The identity rule is the annotated-device drafting pattern: a device is
+   * drawn with its mark tag and a value under it ("S1" over "200" — CFM, GPM,
+   * a fixture count). Tag text WITH a paired value counts; a tag inside a
+   * schedule table's own region is a row label and is excluded; everything
+   * else is WITHHELD with a reason and coordinates — a tag amid linework but
+   * unvalued may be a real device (look), a bare tag is probably a note. A
+   * mark drawn ON its marker with no value is sweep_schedule_row's family,
+   * not this one. Refusal-honest throughout: scans refuse (no text layer),
+   * a set with no mark-shaped schedule rows refuses unless the marks are
+   * stated, and non-plan sheets are skipped with the role that excused them. */
+  async countMarks(opts = {}) {
+    const graph = await this.ensureGraph();
+    if (!graph.available) {
+      throw new UserError("This set has no text layer (a scan) \u2014 the census reads drawn tag text, so it cannot run. Marquee one device with symbol_sweep instead.");
+    }
+    const canon = (k) => (k || "").trim().toUpperCase().replace(/\s+/g, "");
+    const MARK_RE = /^[A-Z]{1,3}-?\d{1,3}[A-Z]?$/;
+    const rowCite = /* @__PURE__ */ new Map();
+    for (const tb of graph.tables) {
+      const table = tb.title?.text || `${tb.kind} schedule`;
+      for (const row of tb.rows) {
+        for (const part of canon(row.key).split("/").filter(Boolean)) {
+          if (!rowCite.has(part)) rowCite.set(part, { sheet: tb.sheet, key: row.key, table });
+        }
+      }
+    }
+    let marks;
+    if (opts.marks?.length) {
+      marks = [...new Set(opts.marks.map(canon).filter(Boolean))];
+    } else {
+      marks = [...rowCite.keys()].filter((k) => MARK_RE.test(k)).sort();
+      if (!marks.length) {
+        throw new UserError('No mark-shaped schedule row keys in the set to census \u2014 state the marks yourself: count_marks { marks: ["S1", "R1"] }.');
+      }
+    }
+    const roleOf = new Map(graph.sheets.map((g) => [g.key, g.role]));
+    const skipped = [];
+    const planSheets = [];
+    for (const sh of this.sheetList()) {
+      const role = roleOf.get(sh.key) ?? "unknown";
+      if (role === "plan") planSheets.push(sh);
+      else {
+        skipped.push({
+          sheet: sh.key,
+          role,
+          reason: role === "unknown" ? "role unknown (no classifiable title text) \u2014 tags here are not censused" : `a ${role} sheet \u2014 tags here are reference text, never installed work`
+        });
+      }
+    }
+    if (!planSheets.length) {
+      throw new UserError("No plan-role sheet in the set \u2014 the census counts installed work, and every sheet classified as schedule/legend/detail/unknown. sheet_graph shows each sheet's role and evidence.");
+    }
+    const tableRegions = /* @__PURE__ */ new Map();
+    for (const tb of graph.tables) {
+      const arr2 = tableRegions.get(tb.sheet) ?? [];
+      arr2.push(tb.region);
+      tableRegions.set(tb.sheet, arr2);
+    }
+    const VAL_RE = /^[0-9][0-9,]{0,6}$/;
+    const perMark = /* @__PURE__ */ new Map();
+    for (const m of marks) perMark.set(m, { counted: [], withheld: [] });
+    let excludedInTables = 0;
+    const perSheetRows = [];
+    for (const sh of planSheets) {
+      if (!sh.spans) sh.spans = textSpans(sh.page);
+      const regions = tableRegions.get(sh.key) ?? [];
+      const values = sh.spans.filter((sp) => VAL_RE.test(sp.str.trim()));
+      const counts = {};
+      let segs = null;
+      for (const m of marks) {
+        const rec = perMark.get(m);
+        for (const sp of sh.spans) {
+          if (canon(sp.str) !== m) continue;
+          const cx = (sp.x0 + sp.x1) / 2, cy = (sp.y0 + sp.y1) / 2;
+          const h = Math.max(sp.y1 - sp.y0, 6);
+          if (regions.some((r) => cx >= r[0] && cx <= r[2] && cy >= r[1] && cy <= r[3])) {
+            excludedInTables++;
+            continue;
+          }
+          const paired = values.find((v) => Math.abs((v.x0 + v.x1) / 2 - cx) <= Math.max(sp.x1 - sp.x0, 1.5 * h) && v.y0 >= sp.y1 - 0.4 * h && v.y0 <= sp.y1 + 2.4 * h);
+          if (paired) {
+            rec.counted.push({ at: [round1(cx), round1(cy)], value: paired.str.trim(), sheet: sh.key });
+            counts[m] = (counts[m] || 0) + 1;
+          } else {
+            if (segs === null) segs = (await this.ensureGeometry(sh)).segs;
+            const pad = 2.5 * h;
+            const bx0 = sp.x0 - pad, by0 = sp.y0 - pad, bx1 = sp.x1 + pad, by1 = sp.y1 + pad;
+            let n = 0;
+            for (let i = 0; i + 3 < segs.length && n < 3; i += 4) {
+              if (segs[i] >= bx0 && segs[i] <= bx1 && segs[i + 1] >= by0 && segs[i + 1] <= by1 && segs[i + 2] >= bx0 && segs[i + 2] <= bx1 && segs[i + 3] >= by0 && segs[i + 3] <= by1) n++;
+            }
+            rec.withheld.push({
+              at: [round1(cx), round1(cy)],
+              sheet: sh.key,
+              reason: n >= 3 ? "tag amid linework but no paired value \u2014 may be a device labeled without one, or a legend/detail reference; look before counting it" : "bare tag text \u2014 no paired value, no adjacent linework; likely a note mention, not an instance"
+            });
+          }
+        }
+      }
+      perSheetRows.push({ sheet: sh.key, counts });
+    }
+    const committedByMark = {};
+    if (opts.commit) {
+      for (const m of marks) {
+        const rec = perMark.get(m);
+        if (!rec.counted.length) continue;
+        const cite = rowCite.get(m);
+        let n = 0;
+        for (const occ of rec.counted) {
+          this.commit(this.sheet(occ.sheet), m, "count", [occ.at], { count: 1 }, {
+            method: "manual",
+            actor: "agent",
+            reviewed: false,
+            ...cite ? { assignment: { source: "schedule", schedule_sheet: cite.sheet } } : {}
+          });
+          n++;
+        }
+        const c = this.conditions.find((x) => x.finish_tag === m);
+        const ea_total = this.shapes.filter((x) => x.condition_id === c.id && x.measure_role === "count").reduce((t2, x) => t2 + (x.computed.count || 1), 0);
+        committedByMark[m] = { committed: n, ea_total };
+      }
+      if (Object.keys(committedByMark).length) this.flushCommits("count_marks");
+    }
+    const cap = (a, n) => a.length > n ? { list: a.slice(0, n), elided: a.length - n } : { list: a, elided: 0 };
+    return {
+      marks: marks.map((m) => {
+        const rec = perMark.get(m);
+        const cite = rowCite.get(m);
+        const c = cap(rec.counted, 150);
+        const w = cap(rec.withheld, 60);
+        return {
+          mark: m,
+          count: rec.counted.length,
+          ...cite ? { row: cite } : { unscheduled: true },
+          occurrences: c.list,
+          ...c.elided ? { occurrences_elided: c.elided } : {},
+          withheld: w.list,
+          ...w.elided ? { withheld_elided: w.elided } : {},
+          ...committedByMark[m] ? { committed: committedByMark[m] } : {}
+        };
+      }),
+      total: [...perMark.values()].reduce((n, r) => n + r.counted.length, 0),
+      per_sheet: perSheetRows,
+      ...excludedInTables ? { excluded_in_tables: excludedInTables } : {},
+      skipped,
+      complete: true
+    };
+  }
   placeCount(name, points, opts) {
     const s = this.sheet(name);
     const ids = points.map(([x, y], i) => this.commit(
@@ -7297,16 +7492,20 @@ var Session = class _Session {
     if (!t) throw new UserError('Pass a schedule-row tag as drawn, e.g. sweep_schedule_row { tag: "T1" }.');
     const graph = await this.ensureGraph();
     if (!graph.available) throw new UserError("This set has no text layer (a scan) \u2014 the sheet graph is unavailable, so schedule rows cannot be read.");
-    const rowHits = graph.tables.flatMap((tb2) => tb2.rows.filter((r2) => r2.key === t).map((r2) => ({ tb: tb2, r: r2 })));
+    const canonKey = (k) => (k || "").trim().toUpperCase().replace(/\s+/g, "");
+    const rowHits = graph.tables.flatMap((tb2) => tb2.rows.filter((r2) => rowKeyAnswersFor(r2.key, t)).map((r2) => ({ tb: tb2, r: r2 })));
     if (!rowHits.length) {
-      const found2 = graph.tables.map((x) => `${x.kind} on ${x.sheet} (${x.rows.length} rows)`).join(" | ");
+      const found2 = graph.tables.map((x) => {
+        const keys = x.rows.map((row) => row.key).slice(0, 12).join(", ");
+        return `${x.kind} on ${x.sheet} (${x.rows.length} rows: ${keys}${x.rows.length > 12 ? ", \u2026" : ""})`;
+      }).join(" | ");
       throw new UserError(`No schedule row "${t}" in the set \u2014 tables found: ${found2 || "none"}. Check the tag as drawn (find_schedule shows each table's region), or merge the schedule sheet in with load_plan.`);
     }
     if (rowHits.length > 1) {
       throw new UserError(`Ambiguous: ${rowHits.length} schedule rows carry the key "${t}" \u2014 the same mark defined twice cannot seed one sweep. Marquee the marker yourself with symbol_sweep.`);
     }
     const { tb, r } = rowHits[0];
-    const siblings = [...new Set(graph.tables.flatMap((x) => x.rows.map((row) => row.key)))].filter((k) => k !== t).sort();
+    const siblings = [...new Set(graph.tables.flatMap((x) => x.rows.flatMap((row) => canonKey(row.key).split("/").filter(Boolean))))].filter((k) => k !== t).sort();
     const table = tb.title?.text || `${tb.kind} schedule`;
     const roleOf = new Map(graph.sheets.map((g) => [g.key, g.role]));
     const skipped = [];
@@ -7364,6 +7563,7 @@ var Session = class _Session {
         if (e instanceof Error && /region, not one symbol/.test(e.message)) break;
         continue;
       }
+      if (cand.segments < 3) continue;
       if (!corro) {
         fp = cand;
         anchorRect = rect;
@@ -9370,6 +9570,34 @@ var linkAnnotationOutput = {
   condition_id: z.string().optional(),
   note: z.string()
 };
+var censusOccurrence = {
+  at: z.tuple([z.number(), z.number()]).describe("The tag's center (image px)"),
+  value: z.string().describe("The paired value drawn under the tag (CFM, GPM, a count \u2014 the annotation that makes it an instance)"),
+  sheet: z.string()
+};
+var censusWithheld = {
+  at: z.tuple([z.number(), z.number()]).describe("The tag's center (image px) \u2014 view_sheet here"),
+  sheet: z.string(),
+  reason: z.string()
+};
+var countMarksOutput = {
+  marks: z.array(z.object({
+    mark: z.string(),
+    count: z.number().int().describe("Value-paired instances counted on plan-role sheets"),
+    row: z.object({ sheet: z.string(), key: z.string(), table: z.string() }).optional().describe("The schedule row that answers for this mark (a compound key answers for each part)"),
+    unscheduled: z.boolean().optional().describe("true when the mark was stated by the caller but no schedule row answers for it"),
+    occurrences: z.array(z.object(censusOccurrence)),
+    occurrences_elided: z.number().int().optional(),
+    withheld: z.array(z.object(censusWithheld)).describe("Tag occurrences that did NOT count, each with the reason \u2014 read them, look, resolve or report"),
+    withheld_elided: z.number().int().optional(),
+    committed: z.object({ committed: z.number().int(), ea_total: z.number() }).optional()
+  })),
+  total: z.number().int().describe("All counted instances across every mark"),
+  per_sheet: z.array(z.object({ sheet: z.string(), counts: z.record(z.number().int()) })),
+  excluded_in_tables: z.number().int().optional().describe("Tag occurrences inside a schedule table's own region \u2014 row labels, never instances"),
+  skipped: z.array(z.object({ sheet: z.string(), role: z.string(), reason: z.string() })),
+  complete: z.boolean()
+};
 
 // src/marked.ts
 import path3 from "node:path";
@@ -11135,6 +11363,14 @@ function registerTools(realServer, session) {
     mirror: a.mirror,
     tolerancePx: a.tolerance_px
   })));
+  server.registerTool("count_marks", {
+    description: `The COUNT TAKEOFF in one deterministic call \u2014 no seeds, no model, seconds: census every VALUE-ANNOTATED mark tag on the plan-role sheets, counted per schedule mark, committed as EA markers when asked. The identity rule is the annotated-device drafting pattern: a device is drawn as its mark tag with a value under it ("S1" over "200" \u2014 CFM on air devices, GPM on fixtures, a rating on equipment), so a tag WITH a paired value counts, a tag inside a schedule table's own region is a row label (excluded, tallied), and every other occurrence is WITHHELD with a reason and coordinates \u2014 a tag amid linework but unvalued may be a real device (view_sheet it), a bare tag is probably a note mention. Marks default to the set's schedule row keys (a compound row "R1 / E1" answers for R1 AND E1; each mark cites its row), or state them: {marks: ["S1","R1"]}. The complement to sweep_schedule_row: THAT tool is for marks drawn ON their marker with no value (finish tags in bubbles) and matches geometry; this one is for annotated devices and needs no fingerprint at all. Refusal-honest: scans refuse (no text layer), a set with no mark-shaped rows refuses unless marks are stated, non-plan sheets are skipped with the role that excused them. commit: true commits every counted occurrence under its mark's own tag \u2014 ONE undo step for the whole census, schedule citation on origin. Counts are scale-free (EA) \u2014 no set_scale needed. Then AUDIT: view_sheet {overlay: true} where the markers landed, and read every withheld entry \u2014 a withheld item you ignore is a hole in the bid. ${COORDS}`,
+    inputSchema: {
+      marks: z2.array(z2.string().min(1)).optional().describe(`The marks to census, e.g. ["S1", "R1"] \u2014 omit to take them from the schedule tables' row keys`),
+      commit: z2.boolean().default(false).describe("Commit every counted occurrence as one EA count marker under its mark (withheld/excluded never commit)")
+    },
+    outputSchema: countMarksOutput
+  }, run("count_marks", (a) => session.countMarks({ marks: a.marks, commit: a.commit })));
   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: {
@@ -11544,6 +11780,7 @@ var TOOL_STAGES = {
     "measure_line",
     "measure_surface",
     "place_count",
+    "count_marks",
     "symbol_sweep",
     "sweep_schedule_row",
     "derive_base",
@@ -11659,7 +11896,7 @@ function nameTheStageInRefusals(server) {
 // package.json
 var package_default = {
   name: "opentakeoff-mcp",
-  version: "0.9.56",
+  version: "0.9.59",
   mcpName: "io.github.Kentucky-ai/opentakeoff",
   type: "module",
   description: "OpenTakeoff MCP server \u2014 drive the takeoff engine from your MCP client over stdio.",
@@ -11741,12 +11978,12 @@ function buildServer(session = new Session(), opts = {}) {
       "OpenTakeoff: quantity takeoff on construction plan PDFs.",
       "A takeoff's deliverable is the marked-up planset, not a numbers report. Standard finish for ANY takeoff:",
       "1. load_plan, then set_scale on each sheet you measure (quantities are px-only until the scale is set).",
-      "2. Commit shapes under finish-tag conditions (one_click / detect_rooms / measure_polygon / measure_line with `condition`; when the set carries a room-finish schedule, prefer detect_rooms assign_from_schedule so each room commits under its OWN row).",
+      "2. Commit shapes under finish-tag conditions (one_click / detect_rooms / measure_polygon / measure_line with `condition`; when the set carries a room-finish schedule, prefer detect_rooms assign_from_schedule so each room commits under its OWN row). A COUNT takeoff of value-annotated device marks (GRDs, fixtures, equipment \u2014 the tag-over-value pattern) starts with count_marks {commit: true}: the whole census in one deterministic call, then audit its withheld entries \u2014 reach for the agent-driven per-mark tools only where it refuses or withholds.",
       "3. DERIVE what follows from the rooms instead of re-measuring it: derive_base for base LF (perimeter \u2212 the door openings YOU state), derive_transitions for the line where two finishes meet. Both read committed floor shapes, so they come after step 2 and their output is audited in step 4 like anything else.",
       "4. LOOK at what landed with view_sheet overlay:true and fix misses with edit_shape before trusting totals \u2014 crop the work region tight (full-sheet renders downsample too far to audit a ring).",
       "5. Finish by writing the marked-up planset with export_marked_pdf and give the user its file path, alongside export_report for the numbers. Never end a takeoff with numbers alone.",
       "A floor split across sheets at a MATCH LINE: there is no stitch verb, deliberately \u2014 joining and aligning a match line is human judgment in the canvas (a sloppy join silently skews every seam-crossing quantity). Measure each member sheet as its own surface and tell the user a seam-crossing room needs their stitch in the app; never approximate one by combining sheets yourself.",
-      "WITHHELD IS NOT A FAILURE \u2014 IT IS THE ANSWER. detect_rooms, symbol_sweep, sweep_schedule_row and derive_transitions all measure things they then decline to commit, and say why: a near-match in the score band, a room the schedule cannot answer for, adjacency across a WALL rather than a butt joint. Read those arrays, view_sheet the coordinates they hand you, and resolve them or report them. A withheld item you ignore is a hole in the bid; one you never mention is worse.",
+      "WITHHELD IS NOT A FAILURE \u2014 IT IS THE ANSWER. detect_rooms, symbol_sweep, sweep_schedule_row, count_marks and derive_transitions all measure things they then decline to commit, and say why: a near-match in the score band, a room the schedule cannot answer for, adjacency across a WALL rather than a butt joint. Read those arrays, view_sheet the coordinates they hand you, and resolve them or report them. A withheld item you ignore is a hole in the bid; one you never mention is worse.",
       ...staged ? [STAGED_INSTRUCTIONS] : []
     ].join("\n")
   });

package/package.json

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