@sealab/mcp-server 1.0.3 → 1.0.4

package/src/tools/ai-drawing.ts

@@ -9,6 +9,21 @@ import {
   type AiDrawingReviewCanvasType,
   type AiDrawingSessionReviewRenderOptions,
 } from './ai-drawing-session-review-renderer';
+import {
+  projectElevationPlacement,
+  projectPlanPlacement,
+  projectPlanWallAnchoredPlacement,
+  isProjectedPlacementOutsideImage,
+  type ElevationCalibration,
+  type PlanCalibration,
+} from './placement-projection';
+import { segmentElevationRun } from './elevation-run-segmentation';
+import {
+  crossCheckPlacementsAgainstCart,
+  type CartItemLike,
+  type PlacementCheckSpec,
+  type CartCrossCheckResult,
+} from './cart-cross-check';
 
 const LEGACY_DRAWING_TOOL_NAME = 'the legacy frontend drawing route';
 const STORED_CARTS_TERM = 'stored carts';
@@ -18,10 +33,10 @@ const AI_CART_TOOL_BOUNDARY =
   ', or ' +
   LEGACY_DRAWING_TOOL_NAME +
   '. The AI cart is one physical cabinet manifest for the whole AI drawing session, not one manifest per canvas. positionName is the physical cabinet identity and must remain stable across plan and elevation placements. backend aiCartItemId is canonical after creation.';
-const AI_DRAWING_VISUAL_REVIEW_COMPLETION_GUIDANCE =
-  'Before reporting completion after canvas, AI cart, or placement writes, call render_ai_drawing_session_review, inspect every returned full-canvas PNG with native vision, apply the visual QA checklist and every returned sourceBoundaryReviewTasks[] item against the actual source drawing pixels, correct wrong placements with existing AI-only placement tools, rerender, and document PASS/FAIL/UNCERTAIN per canvas and placement. A placement may be PASS only when the agent writes explicit LEFT/RIGHT/TOP/BOTTOM boundary evidence from visible source linework; JSON validity is not visual correctness, and bbox non-overlap or bbox adjacency is not visual correctness. If the user asked to create an AI drawing session/cart from drawings, do not stop at a setup-only session with uploaded backgrounds: infer visible cabinet/catalog items from the drawings, create the AI cart items, place every visible cabinet/object on the relevant canvases, and only leave items unplaced when the user explicitly asked for setup-only or a view is genuinely ambiguous and reported UNCERTAIN.';
-const AI_DRAWING_VISUAL_QA_CHECKLIST =
-  'Visual QA checklist for every rendered review PNG: compare each rectangle against the visible drawing, not just labels; source drawing pixels are the authority and generated bbox relationships are never proof by themselves; every PASS must cite visible LEFT, RIGHT, TOP, and BOTTOM source linework; each cabinet box must sit inside the actual cabinet face or plan footprint boundaries; reject boxes that overlap other cabinets, appliances, fixtures, counters, toe kicks, walls, dimension strings, or blank/context areas; reject shifted boxes that extend beyond wood/front boundaries or include refrigerator/range/dishwasher/sink appliance surfaces unless the AI cart item is explicitly an appliance panel/opening; verify the same physical cabinet uses the same positionName/aiCartItemId across plan and elevation while plan footprints and elevation front faces stay on their own canvases; verify no obvious visible cabinet is missing; verify no side/return/context-only face is treated as a primary cabinet; verify labels do not hide boundary errors; when any item is ambiguous, mark it unresolved or ask the user instead of declaring the review correct.';
+const AI_DRAWING_VISUAL_REVIEW_COMPLETION_GUIDANCE =
+  'Before reporting completion after canvas, AI cart, or placement writes, call render_ai_drawing_session_review, inspect every returned full-canvas PNG with native vision, apply the visual QA checklist and every returned sourceBoundaryReviewTasks[] item against the actual source drawing pixels, correct wrong placements with existing AI-only placement tools, rerender, and document PASS/FAIL/UNCERTAIN per canvas and placement. A placement may be PASS only when the agent writes explicit LEFT/RIGHT/TOP/BOTTOM boundary evidence from visible source linework; JSON validity is not visual correctness, and bbox non-overlap or bbox adjacency is not visual correctness. If the user asked to create an AI drawing session/cart from drawings, do not stop at a setup-only session with uploaded backgrounds: infer visible cabinet/catalog items from the drawings, create the AI cart items, place every visible cabinet/object on the relevant canvases, and only leave items unplaced when the user explicitly asked for setup-only or a view is genuinely ambiguous and reported UNCERTAIN.';
+const AI_DRAWING_VISUAL_QA_CHECKLIST =
+  'Visual QA checklist for every rendered review PNG: compare each rectangle against the visible drawing, not just labels; source drawing pixels are the authority and generated bbox relationships are never proof by themselves; every PASS must cite visible LEFT, RIGHT, TOP, and BOTTOM source linework; each cabinet box must sit inside the actual cabinet face or plan footprint boundaries; reject boxes that overlap other cabinets, appliances, fixtures, counters, toe kicks, walls, dimension strings, or blank/context areas; reject shifted boxes that extend beyond wood/front boundaries or include refrigerator/range/dishwasher/sink appliance surfaces unless the AI cart item is explicitly an appliance panel/opening; verify the same physical cabinet uses the same positionName/aiCartItemId across plan and elevation while plan footprints and elevation front faces stay on their own canvases; verify no obvious visible cabinet is missing; verify no side/return/context-only face is treated as a primary cabinet; verify labels do not hide boundary errors; when any item is ambiguous, mark it unresolved or ask the user instead of declaring the review correct.';
 const AI_ARCHITECTURAL_DRAWING_INTERPRETATION_GUIDANCE =
   'Architectural drawing interpretation contract: use native vision and reasoning on the actual drawing images before writing MCP state. Identify each physical cabinet/object bbox from visible boundaries, scale callouts, known dimensions, and repeated modules. Differentiate base cabinets, uppers/wall cabinets, tall/pantry units, fillers, appliance panels/openings, drawer stacks, single-door fronts, and double-door fronts because door/front segmentation changes bbox boundaries and catalog matching. Toekicks are separate plinth objects in the Sealab catalog: create separate AI cart items and separate orange plinth/toekick bboxes for them when present. On any front elevation with base or sink-base cabinets, explicitly inspect the lower support/toekick band: if a visible plinth/toekick band exists, it must be represented as a separate plinth AI cart item and orange bbox before the review can pass. Do not include toekicks or countertops in front-facing cabinet bboxes. Do not include toekicks or countertops in base cabinet height; use called-out scale plus known cabinet/body dimensions to infer the cabinet body height exclusive of plinth/toekick and countertop. A drawing-derived base or sink-base item cannot be marked READY unless drawingClassificationEvidence.baseCabinetBodyHeightEvidence documents the measured cabinet body height, the top/bottom boundary evidence, and explicit exclusion of both countertop and toekick_plinth; the orderReadyPayload height must match that body-height evidence. Cabinet front-face bboxes must not extend below the Z0/floor reference line or into floors, walls, ceilings, counters, labels, dimension strings, or blank/context areas. If a cabinet bbox captures floor, wall, ceiling, countertop, or a toekick/plinth, the visual review must fail and the placement must be patched. Review overlays use blue for cabinet front-facing bboxes and orange for plinth/toekick bboxes.';
 const AI_CART_ORDER_READY_CREATION_GUIDANCE =
@@ -78,8 +93,8 @@ const AI_REDUX_IMPORT_GUIDANCE =
   AI_DRAWING_VISUAL_REVIEW_COMPLETION_GUIDANCE +
   ' ' +
   AI_AUTOMATIC_CART_MIRROR_GUIDANCE;
-const AI_DRAWING_VISUAL_REVIEW_GUIDANCE =
-  'Render local review PNG artifacts from the actual stored backend AIDrawingTool session state after writing or updating AI cart items and per-canvas placements. The output includes full-canvas review PNGs only; no per-placement crop artifacts are generated. Agents must open every returned full-canvas PNG path with native vision, apply the visual QA checklist to each canvas, and complete every returned sourceBoundaryReviewTasks[] item against the actual source drawing pixels. For each placement, PASS requires a written boundary-evidence sentence naming visible source linework for LEFT, RIGHT, TOP, and BOTTOM and listing excluded non-object context; otherwise mark FAIL or UNCERTAIN. Do not use bbox non-overlap, bbox adjacency, labels, dimensions, or evidence prose as proof that a base cabinet, plinth/toekick, floor/Z0, countertop, plan footprint, or cabinet face boundary is visually correct. Correct bad placements through the existing AI-only placement tools, render again/rerender, and only then report completion. JSON validity and structurally valid placement payloads are not visual correctness. Completion is blocked until the agent records PASS/FAIL/UNCERTAIN for every rendered canvas and placement with required boundary evidence, patches failures, rerenders, and explicitly documents any remaining unresolved issues. ' +
+const AI_DRAWING_VISUAL_REVIEW_GUIDANCE =
+  'Render local review PNG artifacts from the actual stored backend AIDrawingTool session state after writing or updating AI cart items and per-canvas placements. The output includes full-canvas review PNGs only; no per-placement crop artifacts are generated. Agents must open every returned full-canvas PNG path with native vision, apply the visual QA checklist to each canvas, and complete every returned sourceBoundaryReviewTasks[] item against the actual source drawing pixels. For each placement, PASS requires a written boundary-evidence sentence naming visible source linework for LEFT, RIGHT, TOP, and BOTTOM and listing excluded non-object context; otherwise mark FAIL or UNCERTAIN. Do not use bbox non-overlap, bbox adjacency, labels, dimensions, or evidence prose as proof that a base cabinet, plinth/toekick, floor/Z0, countertop, plan footprint, or cabinet face boundary is visually correct. Correct bad placements through the existing AI-only placement tools, render again/rerender, and only then report completion. JSON validity and structurally valid placement payloads are not visual correctness. Completion is blocked until the agent records PASS/FAIL/UNCERTAIN for every rendered canvas and placement with required boundary evidence, patches failures, rerenders, and explicitly documents any remaining unresolved issues. ' +
   AI_ARCHITECTURAL_DRAWING_INTERPRETATION_GUIDANCE +
   ' ' +
   AI_DRAWING_VISUAL_QA_CHECKLIST +
@@ -1027,6 +1042,274 @@ export const AiCanvasCabinetPlacementsDeleteInputSchema = AiDrawingSessionIdPara
   'Delete selected placements from one backend-owned AIDrawingTool canvas. ' + AI_CANVAS_PLACEMENT_GUIDANCE
 );
 
+// ---------------------------------------------------------------------------
+// Deterministic placement projection (project_ai_canvas_cabinet_placements)
+// ---------------------------------------------------------------------------
+
+const AI_PLACEMENT_PROJECTION_GUIDANCE =
+  'Compute exact per-canvas placement rectangles from one pixels-per-inch calibration plus each cabinet\'s real ' +
+  'inch dimensions, instead of eyeballing raw pixel boxes. This is the preferred way to create placements: a ' +
+  'vision model cannot reliably guess precise pixel rectangles, and per-box guesses drift, overlap, and double up ' +
+  'across rows of similar cabinets. Workflow: (1) read a visible dimension string and the finished-floor/Z0 line on ' +
+  'the actual source image to establish horizontalPixelsPerInch, verticalPixelsPerInch, floorZ0Px, and one horizontal ' +
+  'origin reference; (2) supply each cabinet face by its real along-wall start, width, body height, and ' +
+  'finished-floor-to-bottom height in inches (read width/height from the catalog/order-ready payload and the ' +
+  'drawing dimension strings, never from guessed pixels); (3) this tool projects every rectangle from the same scale ' +
+  'so the whole run stays aligned and gap-correct. imageSizePx, basisImageWidthPx, and basisImageHeightPx must all ' +
+  'equal the true pixel size of the source image the calibration was measured on, so the review renderer rescales ' +
+  'consistently. Elevation faces project along-wall position and height-above-floor; plan footprints project ' +
+  'room/global center X/Y with width/depth. After projecting, render_ai_drawing_session_review and verify against the ' +
+  'source pixels. ' +
+  AI_CANVAS_PLACEMENT_GUIDANCE;
+
+const ProjectionImageSizePxSchema = z.object({
+  width: z.number().finite().positive().describe('True source image width in pixels.'),
+  height: z.number().finite().positive().describe('True source image height in pixels.'),
+}).strict();
+
+const ProjectionPixelPointSchema = z.object({
+  x: z.number().finite().describe('Image pixel X.'),
+  y: z.number().finite().describe('Image pixel Y.'),
+}).strict();
+
+const ProjectorElevationCalibrationSchema = z.object({
+  canvasType: ElevationCanvasTypeSchema.describe('Elevation canvas this calibration applies to.'),
+  imageSizePx: ProjectionImageSizePxSchema.describe(
+    'True pixel size of the elevation source image the calibration was measured on.'
+  ),
+  horizontalPixelsPerInch: z.number().finite().positive().describe(
+    'Pixels per inch along the wall, derived from a visible horizontal dimension string.'
+  ),
+  verticalPixelsPerInch: z.number().finite().positive().describe(
+    'Pixels per inch vertically, derived from a visible vertical dimension (e.g. ceiling height A.F.F.).'
+  ),
+  floorZ0Px: z.number().finite().describe('Pixel Y of the finished-floor / Z0 reference line.'),
+  horizontalOriginPx: ProjectionPixelPointSchema.describe(
+    'A pixel point whose along-wall inch coordinate is known (e.g. the left wall corner).'
+  ),
+  horizontalOriginCoordinateInches: z.number().finite().default(0).describe(
+    'The along-wall inch coordinate that horizontalOriginPx maps to. Usually 0 at the chosen origin.'
+  ),
+  horizontalAxisPositiveDirection: AxisHorizontalDirectionSchema.describe(
+    'Screen direction in which the along-wall inch coordinate increases.'
+  ),
+  verticalAxisPositiveDirection: AxisVerticalDirectionSchema.default('up').describe(
+    'Screen direction in which height-above-floor increases. Normally "up".'
+  ),
+}).strict();
+
+const ProjectorPlanCalibrationSchema = z.object({
+  canvasType: z.literal('plan'),
+  imageSizePx: ProjectionImageSizePxSchema.describe(
+    'True pixel size of the plan source image the calibration was measured on.'
+  ),
+  pixelsPerInch: z.number().finite().positive().describe('Pixels per room inch on the plan.'),
+  roomOriginPx: ProjectionPixelPointSchema.describe('Pixel point that maps to room/global origin (0, 0).'),
+  xPositiveDirection: AxisHorizontalDirectionSchema.describe('Screen direction in which room X increases.'),
+  yPositiveDirection: AxisVerticalDirectionSchema.describe('Screen direction in which room Y increases.'),
+}).strict();
+
+const ProjectorPlacementSpecSchema = z.object({
+  aiCartItemId: z.string().uuid().optional().describe(
+    'Optional backend AI cart item UUID. Required unless positionName exactly matches an active AI cart item.'
+  ),
+  positionName: z.string().min(1).describe('Physical AI cart item positionName and per-canvas placement identity.'),
+  // Elevation fields
+  horizontalStartInches: z.number().finite().optional().describe(
+    'Elevation only: left edge of the face along the wall, in the wall\'s horizontal inch coordinate.'
+  ),
+  heightInches: z.number().finite().positive().optional().describe(
+    'Elevation only: cabinet face height in inches (base cabinet body height excludes toekick and countertop).'
+  ),
+  bottomFromFloorInches: z.number().finite().nonnegative().default(0).describe(
+    'Elevation only: finished-floor-to-bottom of this face in inches. 0 for a base cabinet on the floor.'
+  ),
+  // Plan fields (center mode)
+  centerXInches: z.number().finite().optional().describe('Plan center mode: cabinet center X in room/global inches.'),
+  centerYInches: z.number().finite().optional().describe('Plan center mode: cabinet center Y in room/global inches.'),
+  depthInches: z.number().finite().positive().optional().describe('Plan only: cabinet front-to-back depth in inches.'),
+  rotation: CoordinateRotationSchema.optional().describe('Plan center mode: wall rotation 0/90/180/270; swaps width/depth axes.'),
+  // Plan fields (wall-anchored mode — preferred: pins the back edge to the wall so the box cannot bleed into the wall)
+  wallBackEdgeInches: z.number().finite().optional().describe(
+    'Plan wall-anchored mode: room-inch coordinate of the cabinet BACK edge on the depth axis — i.e. the wall inner face. The footprint grows into the room from here.'
+  ),
+  depthAxis: z.enum(['x', 'y']).optional().describe('Plan wall-anchored mode: room axis perpendicular to the wall (the depth direction).'),
+  depthDirection: z.enum(['positive', 'negative']).optional().describe('Plan wall-anchored mode: direction in room coordinates that depth grows from the wall into the room.'),
+  alongWallStartInches: z.number().finite().optional().describe('Plan wall-anchored mode: start of the run along the wall, in room inches on the non-depth axis.'),
+  // Common
+  widthInches: z.number().finite().positive().describe('Cabinet width in inches (along the face / along the wall).'),
+}).strict();
+
+export const ProjectAiCanvasCabinetPlacementsInputSchema = AiDrawingSessionIdParamSchema.extend({
+  canvasType: CanvasTypeSchema,
+  elevationCalibration: ProjectorElevationCalibrationSchema.optional().describe(
+    'Required when canvasType is an elevation (north/south/east/west).'
+  ),
+  planCalibration: ProjectorPlanCalibrationSchema.optional().describe(
+    'Required when canvasType is plan.'
+  ),
+  placements: z.array(ProjectorPlacementSpecSchema).min(1).describe(
+    'Cabinet specs in real inches. Elevation specs need horizontalStartInches + widthInches + heightInches ' +
+    '(+ optional bottomFromFloorInches). Plan specs need centerXInches + centerYInches + widthInches + depthInches ' +
+    '(+ optional rotation).'
+  ),
+  writeMode: z.enum(['replace', 'upsert', 'return_only']).default('upsert').describe(
+    'replace: overwrite all placements on this canvas. upsert: create/update by positionName without deleting others. ' +
+    'return_only: compute and return rectangles without writing to the backend (useful for a dry run before committing).'
+  ),
+  crossCheckCartItems: z.boolean().default(true).describe(
+    'When true (default), verify each placement against the active AI cart manifest before writing: every placement ' +
+    'must match a real cart item and its width/height must match that cabinet (within tolerance). Blocks the write on ' +
+    'mismatch so a box cannot be stretched to cover multiple cabinets. Set false only for a calibration dry run.'
+  ),
+  widthToleranceInches: z.number().finite().positive().optional().describe('Allowed width difference vs the cart item (default 1.0").'),
+  heightToleranceInches: z.number().finite().positive().optional().describe('Allowed height/depth difference vs the cart item (default 1.5").'),
+  source: PlacementSourceSchema.optional(),
+}).strict().superRefine((input, ctx) => {
+  const isPlan = input.canvasType === 'plan';
+  if (isPlan && !input.planCalibration) {
+    ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['planCalibration'], message: 'planCalibration is required when canvasType is plan.' });
+  }
+  if (isPlan && input.elevationCalibration) {
+    ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['elevationCalibration'], message: 'Do not provide elevationCalibration for a plan canvas.' });
+  }
+  if (!isPlan && !input.elevationCalibration) {
+    ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['elevationCalibration'], message: 'elevationCalibration is required when canvasType is an elevation.' });
+  }
+  if (!isPlan && input.planCalibration) {
+    ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['planCalibration'], message: 'Do not provide planCalibration for an elevation canvas.' });
+  }
+  if (!isPlan && input.elevationCalibration && input.elevationCalibration.canvasType !== input.canvasType) {
+    ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['elevationCalibration', 'canvasType'], message: 'elevationCalibration.canvasType must match canvasType.' });
+  }
+  input.placements.forEach((placement, index) => {
+    if (isPlan) {
+      if (placement.depthInches === undefined) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['placements', index, 'depthInches'], message: 'depthInches is required for plan placements.' });
+      }
+      const hasWallAnchor =
+        placement.wallBackEdgeInches !== undefined ||
+        placement.depthAxis !== undefined ||
+        placement.depthDirection !== undefined ||
+        placement.alongWallStartInches !== undefined;
+      const hasCenter = placement.centerXInches !== undefined || placement.centerYInches !== undefined;
+      if (hasWallAnchor) {
+        // Wall-anchored mode (preferred): all four anchor fields required, and no center fields.
+        for (const field of ['wallBackEdgeInches', 'depthAxis', 'depthDirection', 'alongWallStartInches'] as const) {
+          if (placement[field] === undefined) {
+            ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['placements', index, field], message: `${field} is required for wall-anchored plan placements.` });
+          }
+        }
+        if (hasCenter) {
+          ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['placements', index, 'centerXInches'], message: 'Use either wall-anchored fields or centerXInches/centerYInches, not both.' });
+        }
+      } else {
+        // Center mode (fallback).
+        if (placement.centerXInches === undefined) {
+          ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['placements', index, 'centerXInches'], message: 'Provide wall-anchored fields (preferred) or centerXInches for plan placements.' });
+        }
+        if (placement.centerYInches === undefined) {
+          ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['placements', index, 'centerYInches'], message: 'Provide wall-anchored fields (preferred) or centerYInches for plan placements.' });
+        }
+      }
+    } else {
+      if (placement.horizontalStartInches === undefined) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['placements', index, 'horizontalStartInches'], message: 'horizontalStartInches is required for elevation placements.' });
+      }
+      if (placement.heightInches === undefined) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['placements', index, 'heightInches'], message: 'heightInches is required for elevation placements.' });
+      }
+      if (placement.rotation !== undefined && placement.rotation !== 0) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['placements', index, 'rotation'], message: AI_CANVAS_PLACEMENT_ROTATION_GUIDANCE });
+      }
+    }
+  });
+  validateUniquePositionNamesForCanvas(input.placements, ctx);
+}).describe(
+  'Project exact AIDrawingTool per-canvas cabinet placement rectangles from a pixels-per-inch calibration and real ' +
+  'cabinet inch dimensions, then optionally write them. ' + AI_PLACEMENT_PROJECTION_GUIDANCE
+);
+
+const AI_ELEVATION_RUN_SEGMENTATION_GUIDANCE =
+  'Decompose each dimensioned elevation run into its individual physical cabinets BEFORE placing boxes, so each ' +
+  'cabinet gets its own rectangle instead of one box spanning a whole run. This fixes under-segmentation, where a ' +
+  'multi-cabinet run (for example a 3\'-0" "EQ A | EQ A" upper that is actually two double-door cabinets) is wrongly ' +
+  'treated as a single cabinet. Workflow per run: (1) read the primary dimension string for the run total and the ' +
+  'secondary chain (EQ / EQ A / EQ B subdivisions) plus the "2" TYP." reveals and the visible vertical seams between ' +
+  'cabinets and doors; (2) decide how many physical cabinets the run contains — a vertical seam with its own stiles ' +
+  'and a separate cart item is a separate cabinet, whereas two doors sharing one box with no center stile gap are one ' +
+  'double-door cabinet; (3) enumerate the modules left to right, each with its real width and an explicit frontType ' +
+  '(single_door, double_door, drawer_stack, etc.) and its own positionName/aiCartItemId; (4) this tool tiles them ' +
+  'contiguously, projects one rectangle per module from the shared calibration, and returns segmentationWarnings when ' +
+  'a module looks too wide for one cabinet, a door type is implausible for its width, the module count is fewer than ' +
+  'the equal subdivisions you read, or the widths do not match the run dimension. Resolve every segmentationWarning ' +
+  'by re-reading the source drawing and creating the correct number of cabinets (each with its own AI cart item) ' +
+  'before reporting completion. Each module must correspond to a real AI cart item; do not invent modules to satisfy ' +
+  'the dimension total. ' +
+  AI_PLACEMENT_PROJECTION_GUIDANCE;
+
+const ProjectorElevationRunModuleSchema = z.object({
+  positionName: z.string().min(1).describe('Physical AI cart item positionName / placement identity for this single cabinet.'),
+  aiCartItemId: z.string().uuid().optional().describe(
+    'Backend AI cart item UUID for this cabinet. Required unless positionName matches an active AI cart item.'
+  ),
+  widthInches: z.number().finite().positive().describe('Real cabinet width in inches for this one module.'),
+  heightInches: z.number().finite().positive().describe('Real cabinet face height in inches (base body height excludes toekick/countertop).'),
+  bottomFromFloorInches: z.number().finite().nonnegative().default(0).describe('Finished-floor-to-bottom of this face in inches.'),
+  frontType: z.enum([
+    'single_door',
+    'double_door',
+    'pair_of_doors',
+    'drawer_stack',
+    'door_over_drawer',
+    'open_shelf',
+    'appliance_panel',
+    'filler',
+  ]).describe('Front type for this module. Declaring it forces the single-vs-double-door determination per cabinet.'),
+}).strict();
+
+const ProjectorElevationRunSchema = z.object({
+  runStartInches: z.number().finite().describe('Along-wall inch coordinate of this run\'s left edge, in the calibration horizontal coordinate.'),
+  modules: z.array(ProjectorElevationRunModuleSchema).min(1).describe('Ordered left-to-right cabinets that make up this run.'),
+  expectedRunTotalInches: z.number().finite().positive().optional().describe(
+    'Run total from the primary dimension string (e.g. 3\'-0" => 36). Used to warn when module widths do not add up.'
+  ),
+  declaredSubdivisionCount: z.number().int().positive().optional().describe(
+    'Number of equal subdivisions you read in the secondary chain (e.g. "EQ A | EQ A" => 2). Warns if you provide fewer modules.'
+  ),
+  revealBetweenModulesInches: z.number().finite().nonnegative().optional().describe('Reveal/gap between adjacent cabinets in inches (e.g. "2" TYP.").'),
+  maxSingleCabinetWidthInches: z.number().finite().positive().optional().describe('Width above which a module is flagged as suspected multiple cabinets. Default 48.'),
+}).strict();
+
+export const ProjectAiCanvasElevationRunInputSchema = AiDrawingSessionIdParamSchema.extend({
+  canvasType: ElevationCanvasTypeSchema.describe('Elevation canvas (north/south/east/west). Run segmentation is elevation-only.'),
+  elevationCalibration: ProjectorElevationCalibrationSchema,
+  runs: z.array(ProjectorElevationRunSchema).min(1).describe('One or more dimensioned runs to decompose and place.'),
+  writeMode: z.enum(['replace', 'upsert', 'return_only']).default('upsert').describe(
+    'replace: overwrite all placements on this canvas. upsert: create/update by positionName. return_only: dry run.'
+  ),
+  crossCheckCartItems: z.boolean().default(true).describe(
+    'When true (default), verify each module against the active AI cart manifest before writing: every module must ' +
+    'match a real cart item of matching width/height. Blocks the write on mismatch, so a run can only hold as many ' +
+    'cabinets as there are real items of the right size. Set false only for a calibration dry run.'
+  ),
+  widthToleranceInches: z.number().finite().positive().optional().describe('Allowed width difference vs the cart item (default 1.0").'),
+  heightToleranceInches: z.number().finite().positive().optional().describe('Allowed height difference vs the cart item (default 1.5").'),
+  source: PlacementSourceSchema.optional(),
+}).strict().superRefine((input, ctx) => {
+  if (input.elevationCalibration.canvasType !== input.canvasType) {
+    ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['elevationCalibration', 'canvasType'], message: 'elevationCalibration.canvasType must match canvasType.' });
+  }
+  const allPositionNames = input.runs.flatMap((run) => run.modules.map((m) => m.positionName));
+  validateUniquePositionNamesForCanvas(
+    allPositionNames.map((positionName) => ({ positionName })),
+    ctx
+  );
+}).describe(
+  'Decompose dimensioned elevation runs into individual cabinets and project one placement rectangle per cabinet. ' +
+  AI_ELEVATION_RUN_SEGMENTATION_GUIDANCE
+);
+
 const AiCoordinateDerivationEvidenceSchema = z.object({
   basis: z.enum(['validated_plan_placement', 'user_confirmed']).describe(
     'How this canonical x/y/z coordinate was derived. MCP must not write canonical coordinates from guessed elevation rectangles.'
@@ -1092,9 +1375,36 @@ function validatePlacementRotationsForCanvas(
   });
 }
 
+function validateUniquePositionNamesForCanvas(
+  placements: Array<{ positionName?: string }>,
+  ctx: z.RefinementCtx
+): void {
+  const seenIndexByPositionName = new Map<string, number>();
+  placements.forEach((placement, index) => {
+    const positionName = placement.positionName;
+    if (positionName === undefined) {
+      return;
+    }
+    const firstIndex = seenIndexByPositionName.get(positionName);
+    if (firstIndex !== undefined) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ['placements', index, 'positionName'],
+        message:
+          `Duplicate positionName "${positionName}" in one canvas write. Each physical cabinet must have exactly ` +
+          'one placement per canvas; duplicates render as stacked/doubled boxes. Use one placement per positionName ' +
+          'on this canvas and reuse the same positionName on other canvases instead.',
+      });
+    } else {
+      seenIndexByPositionName.set(positionName, index);
+    }
+  });
+}
+
 function validatePlacementOperationForCanvas(
   canvasType: string,
   placements: Array<{
+    positionName?: string;
     centerX?: number;
     centerY?: number;
     width?: number;
@@ -1105,6 +1415,7 @@ function validatePlacementOperationForCanvas(
   ctx: z.RefinementCtx
 ): void {
   validatePlacementRotationsForCanvas(canvasType, placements, ctx);
+  validateUniquePositionNamesForCanvas(placements, ctx);
 }
 
 export const AiCabinetCoordinateInputSchema = z.object({
@@ -1164,6 +1475,8 @@ export type AiCanvasCabinetPlacementsReplaceInput = z.infer<typeof AiCanvasCabin
 export type AiCanvasCabinetPlacementsUpsertInput = z.infer<typeof AiCanvasCabinetPlacementsUpsertInputSchema>;
 export type AiCanvasCabinetPlacementsPatchInput = z.infer<typeof AiCanvasCabinetPlacementsPatchInputSchema>;
 export type AiCanvasCabinetPlacementsDeleteInput = z.infer<typeof AiCanvasCabinetPlacementsDeleteInputSchema>;
+export type ProjectAiCanvasCabinetPlacementsInput = z.infer<typeof ProjectAiCanvasCabinetPlacementsInputSchema>;
+export type ProjectAiCanvasElevationRunInput = z.infer<typeof ProjectAiCanvasElevationRunInputSchema>;
 export type AiCabinetCoordinateInput = z.infer<typeof AiCabinetCoordinateInputSchema>;
 export type AiCabinetCoordinatePatchInput = z.infer<typeof AiCabinetCoordinatePatchInputSchema>;
 export type AiCabinetCoordinatesReplaceInput = z.infer<typeof AiCabinetCoordinatesReplaceInputSchema>;
@@ -1197,42 +1510,42 @@ export async function renderAiDrawingSessionReviewTool(input: AiDrawingSessionRe
       renderOptions.imagePathByCanvas = imagePathByCanvas;
     }
 
-    const manifest = renderAiDrawingSessionReview(data, renderOptions);
-    const sourceBoundaryReviewTasks = manifest.canvases.flatMap((canvas) => canvas.sourceBoundaryReviewTasks);
-    const reviewImages = manifest.canvases
-      .filter((canvas) => Boolean(canvas.outputImagePath))
-      .map((canvas) => ({
+    const manifest = renderAiDrawingSessionReview(data, renderOptions);
+    const sourceBoundaryReviewTasks = manifest.canvases.flatMap((canvas) => canvas.sourceBoundaryReviewTasks);
+    const reviewImages = manifest.canvases
+      .filter((canvas) => Boolean(canvas.outputImagePath))
+      .map((canvas) => ({
         canvasType: canvas.canvasType,
-        outputImagePath: canvas.outputImagePath,
-        imageWidth: canvas.imageWidth,
-        imageHeight: canvas.imageHeight,
-        renderedPlacementCount: canvas.renderedPlacementCount,
-        sourceBoundaryReviewTaskCount: canvas.sourceBoundaryReviewTasks.length,
-        issueCount: canvas.issues.length,
-      }));
-
-    return JSON.stringify({
+        outputImagePath: canvas.outputImagePath,
+        imageWidth: canvas.imageWidth,
+        imageHeight: canvas.imageHeight,
+        renderedPlacementCount: canvas.renderedPlacementCount,
+        sourceBoundaryReviewTaskCount: canvas.sourceBoundaryReviewTasks.length,
+        issueCount: canvas.issues.length,
+      }));
+
+    return JSON.stringify({
       sessionId: input.sessionId,
       outputDir: input.outputDir,
       visualReviewRequired: true,
       visualReviewStatus: manifest.visualReviewStatus,
       completionBlockedUntil: manifest.completionBlockedUntil,
-      machineValidationScope:
-        'Renderer issues include deterministic structural checks plus blocking source_boundary_review_required tasks. aggregateIssueCount 0 is not visual approval and does not prove cabinet boundaries are correct. sourceBoundaryReviewTasks must be checked against the full source image with native vision.',
-      completionPolicy:
-        'Open every reviewImages[].outputImagePath with native vision. Resolve every source_boundary_review_required issue by completing every sourceBoundaryReviewTasks[] item against the visible source drawing pixels, not generated bbox relationships. Record PASS/FAIL/UNCERTAIN for each canvas and placement. PASS requires explicit LEFT/RIGHT/TOP/BOTTOM source-linework evidence using each task passRequiresEvidenceFormat; if any side cannot be named from visible drawing geometry, mark FAIL or UNCERTAIN. Fix any overlap, shifted box, missing placement, wrong object, wrong canvas, wrong-surface placement, wrong plan footprint, wrong cabinet face, wrong plinth/toekick, wrong floor/Z0 boundary, or wrong countertop boundary, rerender, and only then report completion or document unresolved issues.',
-      visualQaChecklist: manifest.visualInspectionChecklist,
-      reviewImages,
-      sourceBoundaryReviewTasks,
-      canvases: manifest.canvases.map((canvas) => ({
-        canvasType: canvas.canvasType,
-        outputImagePath: canvas.outputImagePath,
-        imageWidth: canvas.imageWidth,
-        imageHeight: canvas.imageHeight,
-        renderedPlacementCount: canvas.renderedPlacementCount,
-        sourceBoundaryReviewTasks: canvas.sourceBoundaryReviewTasks,
-        issues: canvas.issues,
-      })),
+      machineValidationScope:
+        'Renderer issues include deterministic structural checks plus blocking source_boundary_review_required tasks. aggregateIssueCount 0 is not visual approval and does not prove cabinet boundaries are correct. sourceBoundaryReviewTasks must be checked against the full source image with native vision.',
+      completionPolicy:
+        'Open every reviewImages[].outputImagePath with native vision. Resolve every source_boundary_review_required issue by completing every sourceBoundaryReviewTasks[] item against the visible source drawing pixels, not generated bbox relationships. Record PASS/FAIL/UNCERTAIN for each canvas and placement. PASS requires explicit LEFT/RIGHT/TOP/BOTTOM source-linework evidence using each task passRequiresEvidenceFormat; if any side cannot be named from visible drawing geometry, mark FAIL or UNCERTAIN. Fix any overlap, shifted box, missing placement, wrong object, wrong canvas, wrong-surface placement, wrong plan footprint, wrong cabinet face, wrong plinth/toekick, wrong floor/Z0 boundary, or wrong countertop boundary, rerender, and only then report completion or document unresolved issues.',
+      visualQaChecklist: manifest.visualInspectionChecklist,
+      reviewImages,
+      sourceBoundaryReviewTasks,
+      canvases: manifest.canvases.map((canvas) => ({
+        canvasType: canvas.canvasType,
+        outputImagePath: canvas.outputImagePath,
+        imageWidth: canvas.imageWidth,
+        imageHeight: canvas.imageHeight,
+        renderedPlacementCount: canvas.renderedPlacementCount,
+        sourceBoundaryReviewTasks: canvas.sourceBoundaryReviewTasks,
+        issues: canvas.issues,
+      })),
       perCanvasIssues: Object.fromEntries(
         manifest.canvases.map((canvas) => [canvas.canvasType, canvas.issues])
       ),
@@ -1541,6 +1854,386 @@ export async function deleteAiCanvasCabinetPlacements(input: AiCanvasCabinetPlac
   }
 }
 
+async function fetchActiveAiCartItems(
+  sessionId: string
+): Promise<{ items: CartItemLike[] } | { error: string }> {
+  try {
+    const { data } = await aiDrawingClient.get(`/sessions/${sessionId}/state`);
+    const items = (data as any)?.activeCart?.items;
+    if (!Array.isArray(items)) {
+      return {
+        error:
+          'Could not read an active AI cart for this session, so placements cannot be cross-checked against the ' +
+          'manifest. Create the AI cart, link it to the session, and sync items first (create_ai_cart / ' +
+          'link_ai_cart_to_drawing_session / sync_ai_cart_snapshot), or rerun with crossCheckCartItems false for a dry run.',
+      };
+    }
+    return { items: items as CartItemLike[] };
+  } catch (error) {
+    try { handleAxiosError(error); } catch (e: any) { return { error: e.message }; }
+    return { error: 'Unexpected error reading AI drawing session state for cart cross-check.' };
+  }
+}
+
+function buildCrossCheckBlockedResult(
+  sessionId: string,
+  canvasType: string,
+  result: CartCrossCheckResult,
+  extra?: Record<string, unknown>
+): string {
+  return JSON.stringify(
+    {
+      sessionId,
+      canvasType,
+      wrote: false,
+      crossCheckBlocked: true,
+      matchedCartItemCount: result.matchedCount,
+      cartCrossCheckBlocking: result.blocking,
+      cartCrossCheckWarnings: result.warnings,
+      ...extra,
+      note:
+        'Write blocked: placements did not reconcile with the active AI cart manifest. Each placement must match a ' +
+        'real cart item and its real-world dimensions. Fix the cabinet count/widths (or the cart items) and rerun. ' +
+        'This guarantees a run cannot hold more cabinets than there are real items of the right size.',
+    },
+    null,
+    2
+  );
+}
+
+export async function projectAiCanvasCabinetPlacements(
+  input: ProjectAiCanvasCabinetPlacementsInput
+): Promise<string> {
+  const isPlan = input.canvasType === 'plan';
+  const imageSizePx = isPlan
+    ? input.planCalibration!.imageSizePx
+    : input.elevationCalibration!.imageSizePx;
+
+  const elevationCalibration: ElevationCalibration | undefined = isPlan
+    ? undefined
+    : {
+        canvasType: input.elevationCalibration!.canvasType,
+        imageSizePx: input.elevationCalibration!.imageSizePx,
+        horizontalPixelsPerInch: input.elevationCalibration!.horizontalPixelsPerInch,
+        verticalPixelsPerInch: input.elevationCalibration!.verticalPixelsPerInch,
+        floorZ0Px: input.elevationCalibration!.floorZ0Px,
+        horizontalOriginPx: input.elevationCalibration!.horizontalOriginPx,
+        horizontalOriginCoordinateInches: input.elevationCalibration!.horizontalOriginCoordinateInches,
+        horizontalAxisPositiveDirection: input.elevationCalibration!.horizontalAxisPositiveDirection,
+        verticalAxisPositiveDirection: input.elevationCalibration!.verticalAxisPositiveDirection,
+      };
+
+  const planCalibration: PlanCalibration | undefined = isPlan
+    ? {
+        canvasType: 'plan',
+        imageSizePx: input.planCalibration!.imageSizePx,
+        pixelsPerInch: input.planCalibration!.pixelsPerInch,
+        roomOriginPx: input.planCalibration!.roomOriginPx,
+        xPositiveDirection: input.planCalibration!.xPositiveDirection,
+        yPositiveDirection: input.planCalibration!.yPositiveDirection,
+      }
+    : undefined;
+
+  const outOfBounds: Array<{ positionName: string; reason: string }> = [];
+  const projectedPlacements: AiCanvasCabinetPlacementInput[] = input.placements.map((spec) => {
+    const isWallAnchored = isPlan && spec.wallBackEdgeInches !== undefined;
+    const projected = isWallAnchored
+      ? projectPlanWallAnchoredPlacement(
+          {
+            wallBackEdgeInches: spec.wallBackEdgeInches!,
+            depthAxis: spec.depthAxis!,
+            depthDirection: spec.depthDirection!,
+            alongWallStartInches: spec.alongWallStartInches!,
+            widthInches: spec.widthInches,
+            depthInches: spec.depthInches!,
+          },
+          planCalibration!
+        )
+      : isPlan
+      ? projectPlanPlacement(
+          {
+            centerXInches: spec.centerXInches!,
+            centerYInches: spec.centerYInches!,
+            widthInches: spec.widthInches,
+            depthInches: spec.depthInches!,
+            rotation: spec.rotation,
+          },
+          planCalibration!
+        )
+      : projectElevationPlacement(
+          {
+            horizontalStartInches: spec.horizontalStartInches!,
+            widthInches: spec.widthInches,
+            heightInches: spec.heightInches!,
+            bottomFromFloorInches: spec.bottomFromFloorInches,
+          },
+          elevationCalibration!
+        );
+
+    if (isProjectedPlacementOutsideImage(projected, imageSizePx)) {
+      outOfBounds.push({
+        positionName: spec.positionName,
+        reason:
+          `Projected rectangle (centerX ${projected.centerX}, centerY ${projected.centerY}, width ${projected.width}, ` +
+          `height ${projected.height}) extends outside the ${imageSizePx.width}x${imageSizePx.height} calibration image. ` +
+          'Re-check the calibration (pixels-per-inch, origin, floor line) or the cabinet inch dimensions against the source drawing.',
+      });
+    }
+
+    return {
+      aiCartItemId: spec.aiCartItemId,
+      positionName: spec.positionName,
+      centerX: projected.centerX,
+      centerY: projected.centerY,
+      width: projected.width,
+      height: projected.height,
+      rotation: projected.rotation,
+      placementSpace: 'IMAGE_PIXELS' as const,
+      basisImageWidthPx: imageSizePx.width,
+      basisImageHeightPx: imageSizePx.height,
+      source: input.source,
+    };
+  });
+
+  let crossCheckExtra: Record<string, unknown> | undefined;
+  if (input.crossCheckCartItems) {
+    const cart = await fetchActiveAiCartItems(input.sessionId);
+    if ('error' in cart) {
+      return cart.error;
+    }
+    const checkSpecs: PlacementCheckSpec[] = input.placements.map((spec) => ({
+      positionName: spec.positionName,
+      aiCartItemId: spec.aiCartItemId,
+      widthInches: spec.widthInches,
+      heightInches: isPlan ? undefined : spec.heightInches,
+      depthInches: isPlan ? spec.depthInches : undefined,
+    }));
+    const result = crossCheckPlacementsAgainstCart(checkSpecs, cart.items, {
+      widthToleranceInches: input.widthToleranceInches,
+      heightToleranceInches: input.heightToleranceInches,
+      depthToleranceInches: input.heightToleranceInches,
+      reportCoverage: input.writeMode === 'replace',
+    });
+    if (result.blocking.length > 0) {
+      return buildCrossCheckBlockedResult(input.sessionId, input.canvasType, result);
+    }
+    crossCheckExtra = {
+      matchedCartItemCount: result.matchedCount,
+      cartCrossCheckWarnings: result.warnings,
+    };
+  }
+
+  return commitProjectedPlacements({
+    sessionId: input.sessionId,
+    canvasType: input.canvasType,
+    writeMode: input.writeMode,
+    imageSizePx,
+    projectedPlacements,
+    outOfBounds,
+    extra: crossCheckExtra,
+  });
+}
+
+async function commitProjectedPlacements(params: {
+  sessionId: string;
+  canvasType: string;
+  writeMode: 'replace' | 'upsert' | 'return_only';
+  imageSizePx: { width: number; height: number };
+  projectedPlacements: AiCanvasCabinetPlacementInput[];
+  outOfBounds: Array<{ positionName: string; reason: string }>;
+  extra?: Record<string, unknown>;
+}): Promise<string> {
+  const { sessionId, canvasType, writeMode, imageSizePx, projectedPlacements, outOfBounds, extra } = params;
+
+  if (writeMode === 'return_only') {
+    return JSON.stringify(
+      {
+        sessionId,
+        canvasType,
+        writeMode,
+        wrote: false,
+        basisImageWidthPx: imageSizePx.width,
+        basisImageHeightPx: imageSizePx.height,
+        projectedPlacements: projectedPlacements.map(toBackendPlacementPayload),
+        outOfBoundsWarnings: outOfBounds,
+        ...extra,
+        note:
+          'return_only dry run: nothing was written. Inspect projectedPlacements, outOfBoundsWarnings, and any ' +
+          'segmentationWarnings, then rerun with writeMode upsert or replace to persist. After writing, call ' +
+          'render_ai_drawing_session_review and verify against the source image.',
+      },
+      null,
+      2
+    );
+  }
+
+  try {
+    const path = `/sessions/${sessionId}/placements/${canvasType}`;
+    const body = { placements: projectedPlacements.map(toBackendPlacementPayload) };
+    const { data } =
+      writeMode === 'replace' ? await aiDrawingClient.put(path, body) : await aiDrawingClient.post(path, body);
+    return JSON.stringify(
+      {
+        sessionId,
+        canvasType,
+        writeMode,
+        wrote: true,
+        basisImageWidthPx: imageSizePx.width,
+        basisImageHeightPx: imageSizePx.height,
+        projectedPlacementCount: projectedPlacements.length,
+        outOfBoundsWarnings: outOfBounds,
+        ...extra,
+        backendResponse: data,
+        note:
+          'Placements were projected from calibration and written. Resolve any segmentationWarnings, then call ' +
+          'render_ai_drawing_session_review and verify each rectangle against the visible source linework before reporting completion.',
+      },
+      null,
+      2
+    );
+  } catch (error) {
+    try { handleAxiosError(error); } catch (e: any) { return e.message; }
+    return 'Unexpected error projecting and writing AI canvas cabinet placements.';
+  }
+}
+
+export async function projectAiCanvasElevationRun(
+  input: ProjectAiCanvasElevationRunInput
+): Promise<string> {
+  const cal = input.elevationCalibration;
+  const imageSizePx = cal.imageSizePx;
+  const elevationCalibration: ElevationCalibration = {
+    canvasType: cal.canvasType,
+    imageSizePx: cal.imageSizePx,
+    horizontalPixelsPerInch: cal.horizontalPixelsPerInch,
+    verticalPixelsPerInch: cal.verticalPixelsPerInch,
+    floorZ0Px: cal.floorZ0Px,
+    horizontalOriginPx: cal.horizontalOriginPx,
+    horizontalOriginCoordinateInches: cal.horizontalOriginCoordinateInches,
+    horizontalAxisPositiveDirection: cal.horizontalAxisPositiveDirection,
+    verticalAxisPositiveDirection: cal.verticalAxisPositiveDirection,
+  };
+
+  // Decompose each run into tiled modules — one placement per physical cabinet.
+  const segmentationWarnings: string[] = [];
+  const segmentedModules: Array<{
+    positionName: string;
+    aiCartItemId?: string;
+    horizontalStartInches: number;
+    widthInches: number;
+    heightInches: number;
+    bottomFromFloorInches?: number;
+    frontType: string;
+    runIndex: number;
+  }> = [];
+
+  input.runs.forEach((run, runIndex) => {
+    const result = segmentElevationRun({
+      runStartInches: run.runStartInches,
+      modules: run.modules,
+      expectedRunTotalInches: run.expectedRunTotalInches,
+      declaredSubdivisionCount: run.declaredSubdivisionCount,
+      revealBetweenModulesInches: run.revealBetweenModulesInches,
+      maxSingleCabinetWidthInches: run.maxSingleCabinetWidthInches,
+    });
+    for (const warning of result.warnings) {
+      segmentationWarnings.push(`run[${runIndex}]: ${warning}`);
+    }
+    for (const m of result.modules) {
+      segmentedModules.push({
+        positionName: m.positionName,
+        aiCartItemId: m.aiCartItemId,
+        horizontalStartInches: m.horizontalStartInches,
+        widthInches: m.widthInches,
+        heightInches: m.heightInches,
+        bottomFromFloorInches: m.bottomFromFloorInches,
+        frontType: m.frontType,
+        runIndex,
+      });
+    }
+  });
+
+  const outOfBounds: Array<{ positionName: string; reason: string }> = [];
+  const projectedPlacements: AiCanvasCabinetPlacementInput[] = segmentedModules.map((m) => {
+    const projected = projectElevationPlacement(
+      {
+        horizontalStartInches: m.horizontalStartInches,
+        widthInches: m.widthInches,
+        heightInches: m.heightInches,
+        bottomFromFloorInches: m.bottomFromFloorInches,
+      },
+      elevationCalibration
+    );
+    if (isProjectedPlacementOutsideImage(projected, imageSizePx)) {
+      outOfBounds.push({
+        positionName: m.positionName,
+        reason:
+          `Projected rectangle for ${m.positionName} extends outside the ${imageSizePx.width}x${imageSizePx.height} ` +
+          'calibration image. Re-check the calibration or this module\'s width/height/start against the source drawing.',
+      });
+    }
+    return {
+      aiCartItemId: m.aiCartItemId,
+      positionName: m.positionName,
+      centerX: projected.centerX,
+      centerY: projected.centerY,
+      width: projected.width,
+      height: projected.height,
+      rotation: 0,
+      placementSpace: 'IMAGE_PIXELS' as const,
+      basisImageWidthPx: imageSizePx.width,
+      basisImageHeightPx: imageSizePx.height,
+      source: input.source,
+    };
+  });
+
+  const segmentationExtra: Record<string, unknown> = {
+    moduleCount: segmentedModules.length,
+    runCount: input.runs.length,
+    segmentationWarnings,
+    moduleSummary: segmentedModules.map((m) => ({
+      positionName: m.positionName,
+      runIndex: m.runIndex,
+      frontType: m.frontType,
+      widthInches: m.widthInches,
+      horizontalStartInches: m.horizontalStartInches,
+    })),
+  };
+
+  if (input.crossCheckCartItems) {
+    const cart = await fetchActiveAiCartItems(input.sessionId);
+    if ('error' in cart) {
+      return cart.error;
+    }
+    const checkSpecs: PlacementCheckSpec[] = segmentedModules.map((m) => ({
+      positionName: m.positionName,
+      aiCartItemId: m.aiCartItemId,
+      widthInches: m.widthInches,
+      heightInches: m.heightInches,
+    }));
+    const result = crossCheckPlacementsAgainstCart(checkSpecs, cart.items, {
+      widthToleranceInches: input.widthToleranceInches,
+      heightToleranceInches: input.heightToleranceInches,
+      reportCoverage: input.writeMode === 'replace',
+    });
+    if (result.blocking.length > 0) {
+      return buildCrossCheckBlockedResult(input.sessionId, input.canvasType, result, segmentationExtra);
+    }
+    segmentationExtra.matchedCartItemCount = result.matchedCount;
+    segmentationExtra.cartCrossCheckWarnings = result.warnings;
+  }
+
+  return commitProjectedPlacements({
+    sessionId: input.sessionId,
+    canvasType: input.canvasType,
+    writeMode: input.writeMode,
+    imageSizePx,
+    projectedPlacements,
+    outOfBounds,
+    extra: segmentationExtra,
+  });
+}
+
 export async function replaceAiCabinetCoordinates(input: AiCabinetCoordinatesReplaceInput): Promise<string> {
   try {
     const { data } = await aiDrawingClient.put(`/sessions/${input.sessionId}/coordinates`, {
@@ -2291,6 +2984,27 @@ export const aiDrawingTools = [
     inputSchema: AiCanvasCabinetPlacementsDeleteInputSchema,
     handler: deleteAiCanvasCabinetPlacements,
   },
+  {
+    name: 'project_ai_canvas_cabinet_placements',
+    description:
+      'Compute and write exact backend-owned AIDrawingTool per-canvas cabinet placement rectangles from a ' +
+      'pixels-per-inch calibration plus real cabinet inch dimensions. Prefer this over hand-writing centerX/centerY/' +
+      'width/height placement boxes: it removes pixel-guessing error and keeps a whole run of cabinets aligned and ' +
+      'gap-correct from one shared scale. ' +
+      AI_PLACEMENT_PROJECTION_GUIDANCE,
+    inputSchema: ProjectAiCanvasCabinetPlacementsInputSchema,
+    handler: projectAiCanvasCabinetPlacements,
+  },
+  {
+    name: 'project_ai_canvas_elevation_run',
+    description:
+      'Decompose dimensioned elevation runs into individual cabinets and write one placement rectangle per cabinet. ' +
+      'Use this whenever an elevation run could contain more than one cabinet (almost always): it forces you to ' +
+      'enumerate each cabinet with its width and front type so a multi-cabinet run is never collapsed into one box. ' +
+      AI_ELEVATION_RUN_SEGMENTATION_GUIDANCE,
+    inputSchema: ProjectAiCanvasElevationRunInputSchema,
+    handler: projectAiCanvasElevationRun,
+  },
   {
     name: 'replace_ai_cabinet_coordinates',
     description: