opentakeoff-mcp 0.9.18 → 0.9.19

package/README.md

@@ -109,7 +109,7 @@ 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; everything skipped is counted and reasoned in `withheld` (degenerate / duplicate / implausible), never dropped silently. 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 / unresolved), never dropped silently. To commit: `assign_from_schedule: true` routes each room through its OWN room-finish schedule row and commits under the FLOOR finish that row states (rooms the schedule can't answer for return in `unresolved[]` with reasons and re-seedable coordinates); or pass `condition` to commit every room under one stated tag. |
 | `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. |
@@ -123,8 +123,8 @@ includes document text, shape vertices, or result payload content.
 | `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. |
+| `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, and the cover states where the finish tags came from (`Finish assignment: N schedule-resolved · N agent-asserted · …`, plus any rooms the last assign run withheld). 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, review state, and assignment verdict (`schedule` \| `asserted` — where its finish tag came from) 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. |

package/dist/server-core.js

@@ -2292,6 +2292,12 @@ var Session = class _Session {
   conditions = [];
   markups = [];
   shapes = [];
+  /** The last assign-from-schedule run's unresolved rooms (0.9.18) — what the
+   * marked-set cover discloses as withheld. Replaced per assign run, cleared
+   * with the rest of the session on a non-merge load_plan. Seeds ride
+   * normalized so the export-time staleness drop can test them against
+   * committed rings in verts_norm space. */
+  scheduleWithheld = [];
   /** Newest-last. Capped at UNDO_CAP; the oldest entry falls off the front. */
   journal = [];
   seq = 0;
@@ -2331,6 +2337,7 @@ var Session = class _Session {
       this.file = null;
       this.filePath = null;
       this.nextOrd = 1;
+      this.scheduleWithheld = [];
       this.journal = [];
       this.pendingCommits = [];
     } else if (this.docs.has(base)) {
@@ -2734,6 +2741,7 @@ var Session = class _Session {
     return c;
   }
   commit(s, tag, role, vertsPx, computed, origin) {
+    if (origin?.actor === "agent" && !origin.assignment) origin = { ...origin, assignment: { source: "asserted" } };
     const c = this.conditionFor(tag);
     const shape = {
       id: uid("shp"),
@@ -2830,6 +2838,16 @@ var Session = class _Session {
    *       judge and nothing commits anyway. */
   async detectRooms(name, opts) {
     const s = this.sheet(name);
+    const assign = !!opts.assignFromSchedule;
+    let graph = null;
+    if (assign) {
+      if (s.upp == null) throw new UserError(this.scaleGate(s));
+      graph = await this.ensureGraph();
+      if (!graph.available) throw new UserError("This set has no text layer (a scan) \u2014 the sheet graph is unavailable, not empty.");
+      if (!graph.tables.some((t) => t.kind === "room-finish")) {
+        throw new UserError("No room-finish schedule in the working set \u2014 load_plan the schedule sheet with merge: true, or pass condition to commit every room under one tag.");
+      }
+    }
     const mask = await this.maskWithLayers(name, opts.layers);
     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;
@@ -2839,7 +2857,8 @@ var Session = class _Session {
       const num2 = (sp.str || "").trim().split(/\s+/).find((tok) => ROOM_LABEL_RE.test(tok));
       if (num2) labels.push({ str: num2, bbox: sp });
     }
-    const withheld = { degenerate: 0, duplicate: 0, bubble: 0, implausible: 0 };
+    const withheld = { degenerate: 0, duplicate: 0, bubble: 0, implausible: 0, unresolved: 0 };
+    const unresolved = [];
     const byRing = /* @__PURE__ */ new Map();
     const order = [];
     for (const lb of labels) {
@@ -2907,21 +2926,42 @@ var Session = class _Session {
         return null;
       }
       const perimeter_lf = round2(c.perimPx * upp);
+      let tag = opts.condition;
+      let assignment;
+      if (assign) {
+        const hit = this.floorTagFor(graph, c.label);
+        if ("reason" in hit) {
+          withheld.unresolved++;
+          unresolved.push({ label: c.label, reason: hit.reason, area_sf, perimeter_lf, seed: [round1(c.seed[0]), round1(c.seed[1])] });
+          return null;
+        }
+        tag = hit.tag;
+        assignment = { source: "schedule", room_tag: c.label, surface: "FLOOR", schedule_sheet: hit.sheet };
+      }
       let shape_id;
-      if (opts.condition) {
-        shape_id = this.commit(s, opts.condition, opts.role, c.ring, { area_sf, perimeter_lf }, {
+      if (tag) {
+        shape_id = this.commit(s, tag, opts.role, c.ring, { area_sf, perimeter_lf }, {
           method: "one_click_v1",
           actor: "agent",
           seed_norm: [c.seed[0] / s.widthPx, c.seed[1] / s.heightPx],
           reviewed: false,
           ...c.hatch ? { hatch_filtered: true } : {},
-          ...c.gap ? { gap_bridged_px: c.gap } : {}
+          ...c.gap ? { gap_bridged_px: c.gap } : {},
+          ...assignment ? { assignment } : {}
         }).id;
       }
-      return { ...common, area_sf, perimeter_lf, ...shape_id ? { shape_id } : {} };
+      return { ...common, area_sf, perimeter_lf, ...shape_id ? { shape_id, condition: tag } : {} };
     }).filter((r) => r !== null);
     this.flushCommits("detect_rooms");
-    const withheldTotal = withheld.degenerate + withheld.duplicate + withheld.bubble + withheld.implausible;
+    if (assign) {
+      this.scheduleWithheld = unresolved.map((u) => ({
+        sheet_id: s.key,
+        label: u.label,
+        reason: u.reason,
+        seed_norm: [u.seed[0] / s.widthPx, u.seed[1] / s.heightPx]
+      }));
+    }
+    const withheldTotal = withheld.degenerate + withheld.duplicate + withheld.bubble + withheld.implausible + withheld.unresolved;
     return {
       detected: rooms.length,
       rooms,
@@ -2930,8 +2970,11 @@ var Session = class _Session {
         ...withheld,
         ...upp != null ? { min_area_sf: minAreaSf } : {}
       },
+      // assign mode always states the answer, empty array included: [] is the
+      // positive claim "every detected room resolved against its own row"
+      ...assign ? { unresolved } : {},
       ...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.` } : {},
+      ...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${assign ? `, ${withheld.unresolved} unresolved against the schedule (see unresolved[])` : ""}.` } : {},
       ...s.upp == null ? { warning: `No scale set for ${s.key} \u2014 quantities unavailable. Call set_scale${s.detected ? ` (detected: ${s.detected.label})` : ""}.` } : {}
     };
   }
@@ -3085,6 +3128,7 @@ var Session = class _Session {
         ...x.height_ft !== void 0 ? { height_ft: x.height_ft } : {},
         nverts: x.verts_norm.length,
         reviewed: x.origin?.reviewed === true,
+        ...x.origin?.assignment ? { assignment: x.origin.assignment.source } : {},
         ...x.origin?.agent_edits ? { agent_edits: x.origin.agent_edits } : {}
       })),
       count: rows.length
@@ -3164,7 +3208,13 @@ var Session = class _Session {
       verts_norm: vertsPx.map(([x, y]) => [x / s.widthPx, y / s.heightPx]),
       computed,
       ...role === "surface_area" ? { height_ft: Number(cur.height_ft) || heightFor() } : {},
-      ...cur.origin ? { origin: { ...cur.origin, agent_edits: (cur.origin.agent_edits ?? 0) + 1 } } : {}
+      ...cur.origin ? { origin: {
+        ...cur.origin,
+        agent_edits: (cur.origin.agent_edits ?? 0) + 1,
+        // a reassign onto a different tag is the agent choosing the finish —
+        // keeping "schedule" (and its citation) past that point would be a lie
+        ...patch.condition !== void 0 && cur.origin.assignment?.source === "schedule" ? { assignment: { source: "asserted" } } : {}
+      } } : {}
     };
     this.record({ op: "edit", tool: "edit_shape", before });
     const changed = [
@@ -3534,6 +3584,24 @@ var Session = class _Session {
       counts: { rooms: g.rooms.length, schedules: g.tables.length, callouts: g.callouts.length }
     };
   }
+  /** The FLOOR finish a room's own schedule row states — assign-from-schedule's
+   * per-room resolver (0.9.18): resolveTag's chain narrowed to the one surface
+   * a floor takeoff commits. Refusal over guessing, per room: an unresolved
+   * tag returns resolveTag's own reason; a resolved row with no FLOOR cell
+   * says so; a compound cell ("CPT-1/VCT-1") is ambiguous — committing the
+   * whole room's SF under a two-finish literal would assert an area split the
+   * schedule never stated. Compound detection is narrow ("/", ",", " OR "),
+   * so a hyphenated code never trips it. BASE/WALL are deliberately ignored:
+   * those are derive_base's and measure_surface's measures. */
+  floorTagFor(g, tag) {
+    const res = resolveTag(g, tag);
+    if (res.status !== "resolved") return { reason: res.reason };
+    const floor = res.finishes.find((f) => f.surface === "FLOOR");
+    const code = floor?.code.trim();
+    if (!floor || !code) return { reason: `schedule row ${res.tag} states no FLOOR finish` };
+    if (/[/,]|\bOR\b/i.test(code)) return { reason: `ambiguous: floor cell "${code}" names more than one finish with no stated split` };
+    return { tag: code, sheet: floor.source.sheet };
+  }
   async resolveRoomTag(tag) {
     if (!tag || !tag.trim()) throw new UserError('Pass a room tag, e.g. resolve_tag { tag: "134" }.');
     const g = await this.ensureGraph();
@@ -3695,6 +3763,7 @@ var detectedRoom = z.object({
   area_sf: z.number().optional().describe("Scaled mode: traced area in SF"),
   perimeter_lf: z.number().optional().describe("Scaled mode: traced perimeter in LF"),
   shape_id: z.string().optional().describe("Scaled mode: id of the committed shape, when condition was passed"),
+  condition: z.string().optional().describe("The finish tag this room committed under \u2014 the passed condition, or in assign mode the FLOOR finish its own schedule row states. Present exactly when shape_id is"),
   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")
 });
@@ -3707,8 +3776,16 @@ var detectRoomsOutput = {
     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"),
+    unresolved: z.number().int().describe("Assign mode: rooms the schedule could not answer for (no row, no FLOOR cell, or a compound cell) \u2014 withheld into unresolved[], never committed under a guess. Always present; 0 outside assign mode"),
     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"),
+  unresolved: z.array(z.object({
+    label: z.string().describe("The room tag as drawn"),
+    reason: z.string().describe(`WHY the schedule could not answer \u2014 resolveTag's own reason, "states no FLOOR finish", or "ambiguous: \u2026" for a compound cell`),
+    area_sf: z.number().describe("The room's real traced area \u2014 withheld from committing, not from reporting"),
+    perimeter_lf: z.number(),
+    seed: z.tuple([z.number(), z.number()]).describe("The flood seed (image px) \u2014 once the estimator answers, one_click here with the stated condition commits it")
+  })).optional().describe("Assign mode only, empty array included: [] is the positive claim that every detected room resolved against its own schedule row"),
   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")
@@ -3791,7 +3868,7 @@ var exportTakeoffOutput = {
     measure_role: z.enum(["floor_area", "deduct", "linear", "surface_area", "count"]),
     verts_norm: z.array(point).describe("Vertices normalized to sheet dims (0\u20131)"),
     computed: z.object({ area_sf: z.number().optional(), perimeter_lf: z.number().optional(), count: z.number().optional() }).passthrough().describe("count shapes carry {count} alone; every other role carries area_sf + perimeter_lf"),
-    origin: z.object({}).passthrough().optional().describe("Provenance: method (manual|one_click_v1), actor (omitted=human, 'agent'=MCP/automation), reviewed (human affirmed at an explicit gate), and correction fields (edited, edited_before_create, copied, proposed_verts_norm, edits)")
+    origin: z.object({}).passthrough().optional().describe("Provenance: method (manual|one_click_v1), actor (omitted=human, 'agent'=MCP/automation), reviewed (human affirmed at an explicit gate), assignment (where the finish tag came from \u2014 {source: 'schedule', room_tag, surface, schedule_sheet} when the room's own schedule row decided it, {source: 'asserted'} when the agent chose; stamped on every agent commit), and correction fields (edited, edited_before_create, copied, proposed_verts_norm, edits)")
   }).passthrough()),
   markups: z.array(z.unknown()),
   sheet_group: z.array(z.unknown()),
@@ -3838,6 +3915,7 @@ var listShapesOutput = {
     height_ft: z.number().optional().describe("surface_area shapes \u2014 the height they were quantified at"),
     nverts: z.number().int(),
     reviewed: z.boolean().describe("true = human-affirmed ink, refused by every agent mutation"),
+    assignment: z.enum(["schedule", "asserted"]).optional().describe(`Where the finish tag came from: "schedule" = resolved from the room's own schedule row, "asserted" = the agent chose it. origin.assignment in export_takeoff carries the citation. Absent on human canvas shapes`),
     agent_edits: z.number().int().optional().describe("Present when the agent has revised this shape")
   })),
   count: z.number().int()
@@ -4735,7 +4813,7 @@ function invertPixels(cv) {
   ctx.fillRect(0, 0, cv.width, cv.height);
   ctx.restore();
 }
-async function buildMarkedSetPdf({ projectName, dark, sheets, shapes, markups, rfis = [], conditions, getPage, loadPdfData, company, clientInfo, credit = null, coverTitle = "Marked Set", units = "imperial" }) {
+async function buildMarkedSetPdf({ projectName, dark, sheets, shapes, markups, rfis = [], conditions, getPage, loadPdfData, company, clientInfo, credit = null, provenance = null, coverTitle = "Marked Set", units = "imperial" }) {
   const M = units === "metric";
   const uA = (sf) => M ? sf * 0.09290304 : sf;
   const uL = (lf) => M ? lf * 0.3048 : lf;
@@ -4825,6 +4903,10 @@ async function buildMarkedSetPdf({ projectName, dark, sheets, shapes, markups, r
       }
     }
     draw(`${marked.length} marked sheet${marked.length === 1 ? "" : "s"} \xB7 ${markedShapes.length} takeoff item${markedShapes.length === 1 ? "" : "s"} \xB7 quantities net of deducts, waste-adjusted where noted`, { x: 52, y: metaY, size: 9.5, font, color: muted });
+    if (provenance) {
+      metaY -= 12;
+      draw(provenance, { x: 52, y: metaY, size: 9.5, font, color: muted });
+    }
     let y = metaY - 34;
     const rows = conditionTotals(conditions, markedShapes).filter((r) => r.shape_count > 0);
     draw("CONDITIONS", { x: 52, y, size: 9, font: bold, color: muted });
@@ -5146,6 +5228,20 @@ async function buildMarkedSetPdf({ projectName, dark, sheets, shapes, markups, r
 }
 
 // src/marked.ts
+function assignmentDisclosure(shapes, withheld = []) {
+  const agent = shapes.filter((s) => s.origin?.actor === "agent");
+  const live = withheld.filter((w) => !shapes.some((s) => s.sheet_id === w.sheet_id && (s.measure_role === "floor_area" || s.measure_role === "deduct") && s.verts_norm.length >= 3 && pointInPoly(w.seed_norm[0], w.seed_norm[1], s.verts_norm)));
+  if (!agent.length && !live.length) return null;
+  const schedule = agent.filter((s) => s.origin?.assignment?.source === "schedule").length;
+  const asserted = agent.filter((s) => s.origin?.assignment?.source === "asserted").length;
+  const pending = agent.filter((s) => s.origin?.reviewed !== true).length;
+  const parts = [];
+  if (schedule) parts.push(`${schedule} schedule-resolved`);
+  if (asserted) parts.push(`${asserted} agent-asserted`);
+  if (pending) parts.push(`${pending} pending human review`);
+  if (live.length) parts.push(`${live.length} room${live.length === 1 ? "" : "s"} withheld, unresolved against the schedule`);
+  return parts.length ? `Finish assignment: ${parts.join(" \xB7 ")}` : null;
+}
 var buildMarkedSetPdf2 = buildMarkedSetPdf;
 async function exportMarkedPdf(session, opts) {
   const { file, filePath } = session;
@@ -5199,6 +5295,7 @@ async function exportMarkedPdf(session, opts) {
     getPage,
     loadPdfData,
     credit,
+    provenance: assignmentDisclosure(session.shapes, session.scheduleWithheld),
     coverTitle: "OpenTakeoff \xB7 Marked Set"
   });
   const outPath = path3.resolve(opts.path ?? path3.join(path3.dirname(filePath), `${base} - marked set.pdf`));
@@ -5421,7 +5518,7 @@ function registerTools(server, session) {
     return session.setScale(a.sheet, a);
   }));
   server.registerTool("one_click", {
-    description: `One-Click Area: click inside a room (image px) and the plan's vector linework bounds it \u2014 flood fill, contour trace, vertices snapped to true PDF endpoints. With the sheet's scale set, returns area_sf / perimeter_lf; pass condition (a finish tag, e.g. "CPT-1") to commit the traced shape to the takeoff. Without a scale it returns px-only quantities with a warning and commits nothing. role "deduct" makes the committed shape subtract. ${COORDS}`,
+    description: `One-Click Area: click inside a room (image px) and the plan's vector linework bounds it \u2014 flood fill, contour trace, vertices snapped to true PDF endpoints. With the sheet's scale set, returns area_sf / perimeter_lf; pass condition (a finish tag, e.g. "CPT-1") to commit the traced shape to the takeoff. Without a scale it returns px-only quantities with a warning and commits nothing. role "deduct" makes the committed shape subtract. After committing, LOOK at what landed \u2014 view_sheet {overlay: true} \u2014 and fix an overshot ring with edit_shape before trusting any total. ${COORDS}`,
     inputSchema: {
       sheet: z2.string(),
       x: z2.number(),
@@ -5435,10 +5532,11 @@ 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, sensitivity: a.sensitivity, layers: a.layers })));
   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. 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}`,
+    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. TO COMMIT, choose the honest source of the finish tag: assign_from_schedule: true routes every room through its OWN room-finish schedule row and commits each under the FLOOR finish that row states \u2014 when a schedule exists in the set, THIS is the default move, because one agent-chosen tag across N rooms flattens real finish variety into a wrong bid; condition commits every room under that one stated tag (only right when the rooms genuinely share it; 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. A batch commit is NOT finished until you have LOOKED at it: view_sheet {overlay: true}, audit every ring against the walls, fix misses with edit_shape / delete_shape \u2014 before the totals mean anything. ${COORDS}`,
     inputSchema: {
       sheet: z2.string(),
-      condition: z2.string().optional().describe("Finish tag to commit every detected room under (minted on first use)"),
+      condition: z2.string().optional().describe("Finish tag to commit every detected room under (minted on first use). Mutually exclusive with assign_from_schedule"),
+      assign_from_schedule: z2.boolean().default(false).describe(`Commit each room under the FLOOR finish its OWN room-finish schedule row states (resolve_tag's chain, per room): the citation rides origin.assignment, and rooms the schedule cannot answer for \u2014 no row, no FLOOR cell, a compound cell like "CPT-1/VCT-1" \u2014 are returned in unresolved[] with reasons and seeds instead of committed under a guess. Needs the sheet's scale and a room-finish schedule in the working set (merge the schedule sheet in with load_plan first). Mutually exclusive with condition`),
       role: roleSchema,
       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."),
@@ -5446,7 +5544,12 @@ function registerTools(server, session) {
       layers: layersFilterSchema
     },
     outputSchema: detectRoomsOutput
-  }, 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, layers: a.layers })));
+  }, run("detect_rooms", (a) => {
+    if (a.assign_from_schedule && a.condition !== void 0) {
+      throw new UserError("Provide at most one of: condition (every room under one stated tag) or assign_from_schedule (each room's own schedule row decides).");
+    }
+    return session.detectRooms(a.sheet, { condition: a.condition, role: a.role, returnVerts: a.return_verts, minAreaSf: a.min_area_sf, sensitivity: a.sensitivity, layers: a.layers, assignFromSchedule: a.assign_from_schedule });
+  }));
   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: {
@@ -5661,7 +5764,7 @@ function registerTools(server, session) {
     outputSchema: findTextOutput
   }, run("find_text", (a) => session.findText(a.sheet, a.q, { region: a.region, limit: a.limit })));
   server.registerTool("view_sheet", {
-    description: `SEE the sheet \u2014 render the page (or a crop of it) to a PNG image. This is your eyes on the plan: full-sheet overview first, then tight crops at higher px until dimension strings and room labels read cleanly. region is in image px \u2014 the same space as every other tool \u2014 so a feature at pixel (ix, iy) of the returned image sits at x = region_x0 + ix \xD7 (region_x1 \u2212 region_x0) / img_w (same for y), and those coordinates go straight into one_click, measure_polygon, or read_sheet_text. overlay:true burns the session's committed shapes into the render (human-affirmed ink solid red, unreviewed machine shapes dashed blue) \u2014 render again after committing to verify your geometry landed where you intended, and sanity-check what you see: a fixture-sized ring where a room should be means the seed landed inside a stall or casework; an outsized ring means the flood escaped through an opening. To MEASURE rather than guess, pass grid: a calibrated measuring grid is burned in \u2014 thin lines every 1 ft, heavy blue every 5 ft, foot labels along the crop edges, feet counted from the crop's top-left corner. Count grid cells between walls exactly like an estimator scaling a plan; never derive a dimension by eye when the grid can give it to you. grid "auto" uses the sheet's set scale; before set_scale, pass the drawing scale read off the title block as inches-per-foot \u2014 "1/4" for a 1/4" = 1'-0" plan, "3/16", "0.25". Rendering needs the optional native canvas (@napi-rs/canvas); where it isn't installed this tool errors cleanly and every other tool still works. ${COORDS}`,
+    description: `SEE the sheet \u2014 render the page (or a crop of it) to a PNG image. This is your eyes on the plan, so CROP, DON'T SQUINT: the render downsamples to the px budget (\u22642000 long side), which on an E-size sheet is ~4 sheet pixels per returned pixel \u2014 a full-sheet render finds WHERE things are, and only a tight region crop can tell you what the linework and labels actually say. Never audit a trace or read a dimension off a full-sheet render. region is in image px \u2014 the same space as every other tool \u2014 so a feature at pixel (ix, iy) of the returned image sits at x = region_x0 + ix \xD7 (region_x1 \u2212 region_x0) / img_w (same for y), and those coordinates go straight into one_click, measure_polygon, or read_sheet_text. overlay:true burns the session's committed shapes into the render (human-affirmed ink solid red, unreviewed machine shapes dashed blue) \u2014 render again after committing to verify your geometry landed where you intended, and sanity-check what you see: a fixture-sized ring where a room should be means the seed landed inside a stall or casework; an outsized ring means the flood escaped through an opening. To MEASURE rather than guess, pass grid: a calibrated measuring grid is burned in \u2014 thin lines every 1 ft, heavy blue every 5 ft, foot labels along the crop edges, feet counted from the crop's top-left corner. Count grid cells between walls exactly like an estimator scaling a plan; never derive a dimension by eye when the grid can give it to you. grid "auto" uses the sheet's set scale; before set_scale, pass the drawing scale read off the title block as inches-per-foot \u2014 "1/4" for a 1/4" = 1'-0" plan, "3/16", "0.25". Rendering needs the optional native canvas (@napi-rs/canvas); where it isn't installed this tool errors cleanly and every other tool still works. ${COORDS}`,
     inputSchema: {
       sheet: z2.string(),
       region: z2.object({ x0: z2.number(), y0: z2.number(), x1: z2.number(), y1: z2.number() }).optional().describe("Crop rect in image px (origin top-left, y down); omit for the full sheet"),
@@ -5798,7 +5901,7 @@ function registerResources(server, session) {
 // package.json
 var package_default = {
   name: "opentakeoff-mcp",
-  version: "0.9.18",
+  version: "0.9.19",
   mcpName: "io.github.Kentucky-ai/opentakeoff",
   type: "module",
   description: "OpenTakeoff MCP server \u2014 drive the takeoff engine from your MCP client over stdio.",
@@ -5875,8 +5978,8 @@ function buildServer(session = new Session()) {
       "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`).",
-      "3. LOOK at what landed with view_sheet overlay:true and fix misses with edit_shape before trusting totals.",
+      "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).",
+      "3. 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).",
       "4. 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."
     ].join("\n")
   });

package/package.json

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