@sealab/mcp-server 1.0.2 → 1.0.3

package/dist/tools/ai-drawing.js

@@ -0,0 +1,2080 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aiDrawingTools = exports.AiCabinetCoordinatesDeleteInputSchema = exports.AiCabinetCoordinatesPatchInputListSchema = exports.AiCabinetCoordinatesReplaceInputSchema = exports.AiCabinetCoordinatePatchInputSchema = exports.AiCabinetCoordinateInputSchema = exports.AiCanvasCabinetPlacementsDeleteInputSchema = exports.AiCanvasCabinetPlacementsPatchInputSchema = exports.AiCanvasCabinetPlacementsByCanvasInputSchema = exports.AiCanvasCabinetPlacementsUpsertInputSchema = exports.AiCanvasCabinetPlacementsReplaceInputSchema = exports.AiCanvasCabinetPlacementPatchSchema = exports.AiCanvasCabinetPlacementInputSchema = exports.AiCanvasImageDeleteInputSchema = exports.AiCanvasImageUploadInputSchema = exports.AiCanvasImageInputSchema = exports.AiCanvasMetadataInputSchema = exports.LinkAiCartToDrawingSessionInputSchema = exports.AiDrawingSessionReviewRenderInputSchema = exports.AiReduxCartImportInputSchema = exports.AiOrderReadyPayloadClearInputSchema = exports.AiOrderReadyPayloadSetInputSchema = exports.AiOrderReadyPayloadReadInputSchema = exports.DeleteAiCabinetInputSchema = exports.ConfigureAiCabinetInputSchema = exports.DuplicateAiCabinetInputSchema = exports.AiCartCreateInputSchema = exports.AiCartSnapshotInputSchema = exports.AiCartItemPatchSchema = exports.AiCartItemInputSchema = exports.AiCartItemIdParamSchema = exports.AiCartIdParamSchema = exports.AiDrawingSessionCreateInputSchema = exports.AiCanvasMetaSchema = exports.AiCanvasProjectionCalibrationSchema = void 0;
+exports.getAiDrawingState = getAiDrawingState;
+exports.renderAiDrawingSessionReviewTool = renderAiDrawingSessionReviewTool;
+exports.createAiDrawingSession = createAiDrawingSession;
+exports.linkAiCartToDrawingSession = linkAiCartToDrawingSession;
+exports.upsertAiCanvasMetadata = upsertAiCanvasMetadata;
+exports.upsertAiCanvasImage = upsertAiCanvasImage;
+exports.uploadAiCanvasImage = uploadAiCanvasImage;
+exports.deleteAiCanvasImage = deleteAiCanvasImage;
+exports.getAiCanvasCabinetPlacements = getAiCanvasCabinetPlacements;
+exports.getAiCanvasCabinetPlacementsByCanvas = getAiCanvasCabinetPlacementsByCanvas;
+exports.replaceAiCanvasCabinetPlacements = replaceAiCanvasCabinetPlacements;
+exports.upsertAiCanvasCabinetPlacements = upsertAiCanvasCabinetPlacements;
+exports.patchAiCanvasCabinetPlacements = patchAiCanvasCabinetPlacements;
+exports.deleteAiCanvasCabinetPlacements = deleteAiCanvasCabinetPlacements;
+exports.replaceAiCabinetCoordinates = replaceAiCabinetCoordinates;
+exports.patchAiCabinetCoordinates = patchAiCabinetCoordinates;
+exports.deleteAiCabinetCoordinates = deleteAiCabinetCoordinates;
+exports.createAiCart = createAiCart;
+exports.getAiCart = getAiCart;
+exports.getAiCartBySession = getAiCartBySession;
+exports.syncAiCartSnapshot = syncAiCartSnapshot;
+exports.patchAiCartItem = patchAiCartItem;
+exports.deleteAiCartItem = deleteAiCartItem;
+exports.duplicateAiCabinet = duplicateAiCabinet;
+exports.configureAiCabinet = configureAiCabinet;
+exports.deleteAiCabinet = deleteAiCabinet;
+exports.getAiCartItemOrderReadyPayload = getAiCartItemOrderReadyPayload;
+exports.setAiCartItemOrderReadyPayload = setAiCartItemOrderReadyPayload;
+exports.clearAiCartItemOrderReadyPayload = clearAiCartItemOrderReadyPayload;
+exports.importReduxCartItemsToAiCart = importReduxCartItemsToAiCart;
+const zod_1 = require("zod");
+const api_client_1 = require("../client/api-client");
+const orders_1 = require("./orders");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const form_data_1 = __importDefault(require("form-data"));
+const ai_drawing_session_review_renderer_1 = require("./ai-drawing-session-review-renderer");
+const LEGACY_DRAWING_TOOL_NAME = 'the legacy frontend drawing route';
+const STORED_CARTS_TERM = 'stored carts';
+const AI_CART_TOOL_BOUNDARY = 'AIDrawingTool is backend-owned and isolated. These tools do not mutate the Redux cart, ' +
+    STORED_CARTS_TERM +
+    ', 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_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 = 'When the agent creates or syncs AI cart items that did not come from a rich frontend cart snapshot, it must run the same configuration discovery flow used for normal saved-cart/order creation before creating the item manifest: for each serialNumber, call get_article_context, then get_article_options, check get_my_saved_settings/get_saved_settings_presets when saved settings could answer user preferences, present the applicable options, and ask the user for every missing order-critical choice. If the drawing has no explicit material/configuration callouts, stop and ask the user to choose exact options or a saved setting/preset before syncing cabinet items. Only after that flow should the agent call set_ai_cart_item_order_ready_payload with orderReadyStatus READY and a full ArticleItemSchema-compatible payload. If required choices are still missing, do not create an unconfigured cabinet manifest; keep only non-item drawing/canvas setup until the user answers. Creating positionName, serialNumber, width, height, and depth is not enough for a cart-ready cabinet. READY order-ready payloads automatically mirror into the browser Redux checkout cart while the matching AI drawing session is loaded; there is no normal Seed AI Cart or Apply to cart button step. ' +
+    AI_ARCHITECTURAL_DRAWING_INTERPRETATION_GUIDANCE +
+    ' ' +
+    AI_DRAWING_VISUAL_REVIEW_COMPLETION_GUIDANCE;
+const AI_AUTOMATIC_CART_MIRROR_GUIDANCE = 'Phase 14 automatic mirror lifecycle: backend AI cart remains the persistent planner state and browser Redux cart remains checkout state. READY AI cart items with validated ArticleItemSchema-compatible orderReadyPayload values automatically upsert into the browser Redux checkout cart while that session is loaded. Non-ready statuses such as NEEDS_AGENT_CONFIGURATION, BLOCKED, STALE, SKIPPED, or NOT_PREPARED must be explicit and user-actionable with messages. Do not tell users to press Seed AI Cart or Apply to cart as the normal workflow. Use catalog/configuration/order tools and exact user-confirmed options; never guess order-critical material, edge, drawer, hinge, shelf, back-panel, joint, or saved setting values. For AI cart items, the normal path is the same as saved-cart/order preparation: call get_article_context and get_article_options for each article, consult get_my_saved_settings/get_saved_settings_presets when preferences may already exist, ask the user for missing required options, then write READY only with a full validated payload. These MCP tools do not submit orders, generate CAD/XML, mutate stored carts, or write production coordinate tables.';
+const AI_DRAWING_TOOL_BOUNDARY = 'AIDrawingTool is backend-owned and isolated. These tools do not mutate the Redux cart, ' +
+    STORED_CARTS_TERM +
+    ', or ' +
+    LEGACY_DRAWING_TOOL_NAME +
+    '. Coordinates use canonical room/global inches: x is cabinet center X in room/global plan coordinates, y is cabinet center Y in room/global plan coordinates, z is finished-floor-to-cabinet-bottom height, and rotation is wall orientation 0/90/180/270 degrees. Agents must never write image-local pixels or image-local elevation coordinates into canonical x/y/z.';
+const AI_CANONICAL_PROJECTION_GUIDANCE = 'Plan projects canonical x/y with cabinet width/depth. North/south elevations project canonical x/z with cabinet width/height. East/west elevations project canonical y/z with cabinet width/height. Rotation 0 belongs to north, 90 to east, 180 to south, and 270 to west.';
+const AI_CANVAS_CALIBRATION_GUIDANCE = 'canvasMeta is flexible, but canvasMeta.projectionCalibration is not free-form notes. Only include projectionCalibration when providing the complete canonical coordinate projection schemaVersion ai-canvas-calibration/v1. For direct IMAGE_PIXELS per-canvas placements, omit projectionCalibration unless canonical room-inch projection is actually known. Put sourceFile, imageSizePx, plan/elevation marker association, orientation evidence, z0 notes, floor-line notes, and other visual-analysis notes in other canvasMeta keys outside projectionCalibration.';
+const AI_REVIEW_TOKEN_GUIDANCE = 'Native vision on the actual source plan/elevation images is the source of truth for drawing interpretation. Run native image analysis first to identify real cabinet faces/footprints, appliances, fixtures, returns, exclusions, and plan/elevation binding; then use MCP tools only to persist the reviewed session, cart, placements, and review artifacts. MCP extraction, reviewed overlay, association objects, catalog labels, and evidence JSON are optional trace/diagnostic metadata only. Do not let raw extracted candidates, tool labels, evidence JSON, schema validity, or MCP-derived guesses override what is visibly in the drawing.';
+const AI_DRAWING_SCALE_ANCHOR_GUIDANCE = 'Use visible dimensions as scale anchors before persisting placements: read explicit dimension strings, known catalog widths/heights, appliance/opening dimensions, and repeated cabinet modules; compute pixels-per-inch per canvas when possible; use that scale to sanity-check other cabinet sizes and gaps. Do not resize boxes away from visible boundaries just to force a dimension, but if a box dimension is inconsistent with nearby explicit dimensions or known cabinet/article size, reinspect the source image and correct or ask the user before persisting.';
+const AI_CANVAS_PLACEMENT_GUIDANCE = 'These are backend-owned AIDrawingTool per-canvas cabinet placements using canvas-local visual rectangles in original image pixels. Placement writes require the session to have an active linked AI cart and each placement must link to an active AI cart item by aiCartItemId or exact positionName. After create_ai_cart/link_ai_cart_to_drawing_session/sync_ai_cart_snapshot, read back get_ai_drawing_state or get_ai_cart_by_session and use the returned backend aiCartItemId values before writing placements. If cart sync failed or activeCart/items are missing, stop and fix the cart flow; do not call placement tools. width/height in these placement tools are visual rectangle pixel dimensions, not cabinet inch dimensions. Plan rectangles are footprints; elevation rectangles are primary front faces. Reuse the same aiCartItemId/positionName for the same physical cabinet across canvases. A plan placement does not make the cabinet appear on an elevation: every visible cabinet face on north/south/east/west must also get its own placement on that elevation canvas using the same aiCartItemId/positionName, without creating another AI cart item. Do not derive plan placements from elevation boxes or elevation placements from plan boxes. Do not rely on filenames, compass words, object order, or catalog labels alone; use native vision and user confirmation when ambiguous. ' +
+    AI_ARCHITECTURAL_DRAWING_INTERPRETATION_GUIDANCE +
+    ' ' +
+    AI_DRAWING_SCALE_ANCHOR_GUIDANCE +
+    ' After writes, render and inspect the stored session, correct bad placements, and rerender. These tools do not mutate Redux cart, stored carts, production coordinates, CAD/XML, or the legacy frontend drawing route. ' +
+    AI_DRAWING_VISUAL_QA_CHECKLIST +
+    ' ' +
+    AI_DRAWING_VISUAL_REVIEW_COMPLETION_GUIDANCE +
+    ' ' +
+    AI_REVIEW_TOKEN_GUIDANCE;
+const AI_CANVAS_PLACEMENT_ROTATION_GUIDANCE = 'Nonzero placement rotation is allowed only on plan. Elevation canvases are front-facing and must use rotation 0.';
+const AI_CABINET_OPERATION_GUIDANCE = 'These are AI-native backend operations for one physical cabinet item in the AIDrawingTool AI cart. The AI cart is one physical cabinet manifest shared across plan and elevation canvases. Plan and elevation placements for the same cabinet must use the same shared aiCartItemId and positionName. Do not create separate physical AI cart items for plan versus elevation views; use per-canvas placement tools for placement geometry when representing the same cabinet on another canvas. duplicate_ai_cabinet creates a new physical cabinet. configure_ai_cabinet mutates backend AI cart item fields and linked AI-only placement dimensions. delete_ai_cabinet removes the backend AI cabinet and linked AI-only placements. ' +
+    AI_ARCHITECTURAL_DRAWING_INTERPRETATION_GUIDANCE +
+    ' ' +
+    AI_DRAWING_VISUAL_REVIEW_COMPLETION_GUIDANCE +
+    ' These tools do not mutate the Redux cart, stored carts, production coordinate tables, CAD/XML, or any external production target.';
+const AI_ORDER_READY_GUIDANCE = 'These tools store AI-only order-ready article payloads on backend-owned AIDrawingTool AI cart items for browser automatic mirroring. serialNumber, positionName, width, height, and depth alone are not order-ready. Before READY, use catalog/configuration/saved setting tools, ask the user for every required missing order-critical choice, use exact option strings, and pass ArticleItemSchema/order-contract validation. Drawing evidence JSON is optional trace metadata and is not visual certification; correctness should be verified with rendered visual review. ' +
+    AI_ARCHITECTURAL_DRAWING_INTERPRETATION_GUIDANCE +
+    ' ' +
+    AI_REVIEW_TOKEN_GUIDANCE +
+    ' ' +
+    AI_DRAWING_VISUAL_REVIEW_COMPLETION_GUIDANCE +
+    ' ' +
+    AI_AUTOMATIC_CART_MIRROR_GUIDANCE;
+const AI_REDUX_IMPORT_GUIDANCE = 'Import one or more existing rich browser Redux checkout cart items into the active backend-owned AIDrawingTool AI cart as physical AI cart items. This MCP tool is only for real existing browser checkout cart items that are already ArticleItemSchema/order-ready; do not use it to seed AI cart items from drawing takeoff, overlay output, catalog serials, dimensions, or other agent-created planner guesses. Provide the full original Redux cart item payload, not a thin serial/dimensions-only object. Use frontendItemId/originalFrontendItemId or stable source identity fields for idempotency; the backend must not rely on positionName alone. MCP imports must be READY and order-ready. If an item is not order-ready, do not import it through this tool; ask the user for configuration first, then use sync_ai_cart_snapshot with USER_CONFIRMED_ORDER_READY or set_ai_cart_item_order_ready_payload after backend ids exist. Imported READY items can then participate in the automatic mirror lifecycle. ' +
+    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. ' +
+    AI_ARCHITECTURAL_DRAWING_INTERPRETATION_GUIDANCE +
+    ' ' +
+    AI_DRAWING_VISUAL_QA_CHECKLIST +
+    ' ' +
+    AI_DRAWING_SCALE_ANCHOR_GUIDANCE +
+    ' ' +
+    AI_REVIEW_TOKEN_GUIDANCE +
+    ' This tool reads session state and writes only local review artifacts; it does not create sessions, upload images, mutate AI cart items, write order-ready payloads, import browser cart items, submit orders, or call legacy canvas tools.';
+const AI_DRAWING_REVIEW_ASSET_BASE_URL = (process.env.SEALAB_ASSET_BASE_URL || process.env.REACT_APP_S3_BASE_URL || 'https://www.thesealab.com').replace(/\/+$/, '');
+// ---------------------------------------------------------------------------
+// Schemas
+// ---------------------------------------------------------------------------
+const GetAiDrawingStateSchema = zod_1.z.object({
+    sessionId: zod_1.z.string().uuid().describe('UUID of the backend-owned AIDrawingTool session. This reads the isolated AI drawing state, not the existing frontend drawing tool state.'),
+});
+const AiDrawingSessionIdParamSchema = zod_1.z.object({
+    sessionId: zod_1.z.string().uuid().describe('UUID of the backend-owned AIDrawingTool session.'),
+}).strict();
+const CanvasTypeSchema = zod_1.z.enum(['plan', 'north', 'south', 'east', 'west']).describe('AI drawing canvas type. These values are independent from the existing frontend drawing route.');
+const ImageTypeSchema = zod_1.z.enum(['background', 'snapshot']).describe('AI drawing image type accepted by the backend AI drawing service.');
+const IMAGE_MIME_TYPES = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.webp': 'image/webp',
+};
+const CoordinateRotationSchema = zod_1.z.union([
+    zod_1.z.literal(0),
+    zod_1.z.literal(90),
+    zod_1.z.literal(180),
+    zod_1.z.literal(270),
+]).describe('AI coordinate rotation in degrees: 0 north, 90 east, 180 south, 270 west.');
+const CoordinateSourceSchema = zod_1.z.enum(['AI', 'MCP', 'BROWSER']).describe('Source metadata for an isolated AI drawing coordinate update.');
+const PlacementSourceSchema = zod_1.z.enum(['AI', 'MCP', 'BROWSER']).describe('Source metadata for an isolated AI canvas placement update.');
+const PlacementSpaceSchema = zod_1.z.literal('IMAGE_PIXELS').describe('Placement coordinate space. IMAGE_PIXELS means original canvas image pixels or the stored blank canvas basis.');
+const PlanMarkerSideSchema = zod_1.z.enum(['left', 'right', 'up', 'down']);
+const DrawingViewPlaneRoleSchema = zod_1.z.enum([
+    'primary_elevation_face',
+    'return_side_face',
+    'context_anchor',
+    'plan_footprint',
+    'needs_user_confirmation',
+]);
+const DrawingFrontFaceFeatureSchema = zod_1.z.enum([
+    'door_drawer_fronts',
+    'single_door_front',
+    'double_door_front',
+    'drawer_stack_front',
+    'front_handles_or_pulls',
+    'appliance_front_or_handles',
+    'open_shelf_front',
+    'sink_basin_or_faucet_on_primary_face',
+    'front_panel_boundaries',
+    'toekick_plinth',
+    'countertop_context',
+    'z0_floor_line',
+    'side_panel_or_return_visible',
+    'context_only',
+    'user_confirmed_front_face',
+]);
+const DrawingReviewedObjectTypeSchema = zod_1.z.enum([
+    'base_cabinet',
+    'wall_cabinet',
+    'tall_cabinet',
+    'drawer_stack',
+    'sink_base',
+    'appliance_panel',
+    'appliance_opening',
+    'filler',
+    'plinth',
+    'countertop',
+    'wall',
+    'floor',
+    'ceiling',
+    'unknown',
+]);
+const DrawingReviewedObjectEvidenceSchema = zod_1.z.object({
+    objectId: zod_1.z.string().min(1),
+    canvasType: CanvasTypeSchema,
+    objectType: DrawingReviewedObjectTypeSchema,
+    reviewStatus: zod_1.z.literal('reviewed_cabinet'),
+    viewPlaneRole: DrawingViewPlaneRoleSchema,
+    frontFaceFeatures: zod_1.z.array(DrawingFrontFaceFeatureSchema).default([]),
+    reviewToken: zod_1.z.string().min(20).optional().describe('Optional trace token from a reviewed drawing artifact. Trace metadata only.'),
+    bbox: zod_1.z.object({
+        x: zod_1.z.number().finite(),
+        y: zod_1.z.number().finite(),
+        width: zod_1.z.number().finite().positive(),
+        height: zod_1.z.number().finite().positive(),
+    }).strict().optional(),
+    evidence: zod_1.z.string().min(20),
+}).strict().describe('Optional structured reviewed object evidence from MCP drawing-analysis/review artifacts. Trace metadata only; MCP does not certify visual semantics.');
+const DrawingBboxPxSchema = zod_1.z.object({
+    x: zod_1.z.number().finite(),
+    y: zod_1.z.number().finite(),
+    width: zod_1.z.number().finite().positive(),
+    height: zod_1.z.number().finite().positive(),
+}).strict();
+const BaseCabinetBodyHeightEvidenceSchema = zod_1.z.object({
+    cabinetBodyHeightInches: zod_1.z.number().finite().positive().describe('Measured or inferred base cabinet body height in inches, excluding countertop and toekick/plinth.'),
+    measurementBasis: zod_1.z.enum([
+        'explicit_dimension_callout',
+        'called_out_scale_and_known_dimension',
+        'known_catalog_body_height',
+        'user_confirmed',
+    ]).describe('How the agent established the base cabinet body height without including countertop or plinth/toekick.'),
+    scaleEvidence: zod_1.z.string().min(20).describe('Specific drawing scale, known dimension, repeated module, or user-confirmed basis used for the height measurement.'),
+    topBoundaryEvidence: zod_1.z.string().min(20).describe('Evidence for the top of the base cabinet body. Must explain how countertop height/thickness was excluded.'),
+    bottomBoundaryEvidence: zod_1.z.string().min(20).describe('Evidence for the bottom of the base cabinet body. Must explain how toekick/plinth height and Z0/floor were excluded.'),
+    excludedElements: zod_1.z.array(zod_1.z.enum([
+        'toekick_plinth',
+        'countertop',
+        'floor',
+        'wall',
+        'ceiling',
+        'dimension_text',
+        'blank_context',
+    ])).min(2).describe('Elements explicitly excluded from the base cabinet body height and bbox.'),
+    plinthDecision: zod_1.z.enum([
+        'separate_plinth_item_created',
+        'no_visible_plinth',
+        'user_confirmed_no_plinth',
+    ]).describe('Agent decision for the toekick/plinth band. If visible, it must be a separate plinth item and orange placement.'),
+    countertopDecision: zod_1.z.enum([
+        'excluded_visible_countertop',
+        'no_visible_countertop',
+        'user_confirmed_no_countertop',
+    ]).describe('Agent decision for countertop geometry. Visible countertops must be excluded from the cabinet body height.'),
+    z0Evidence: zod_1.z.string().min(20).describe('Evidence that the cabinet body bbox/height does not extend below the finished-floor Z0 reference into floor/wall/ceiling context.'),
+    cabinetBodyBboxPx: DrawingBboxPxSchema.optional().describe('Optional blue cabinet body bbox used for the base item, excluding countertop and toekick/plinth.'),
+    plinthBboxPx: DrawingBboxPxSchema.optional().describe('Optional orange plinth/toekick bbox if a visible plinth/toekick was separated.'),
+    countertopBboxPx: DrawingBboxPxSchema.optional().describe('Optional countertop context bbox used only to document exclusion from the base cabinet body.'),
+    evidence: zod_1.z.string().min(20).describe('Plain-language audit explanation of why the persisted base height excludes countertop and plinth/toekick.'),
+}).strict().superRefine((value, ctx) => {
+    if (!value.excludedElements.includes('toekick_plinth')) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            path: ['excludedElements'],
+            message: 'Base cabinet body height evidence must explicitly exclude toekick_plinth.',
+        });
+    }
+    if (!value.excludedElements.includes('countertop')) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            path: ['excludedElements'],
+            message: 'Base cabinet body height evidence must explicitly exclude countertop.',
+        });
+    }
+    if (value.plinthDecision === 'separate_plinth_item_created' && !value.plinthBboxPx) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            path: ['plinthBboxPx'],
+            message: 'separate_plinth_item_created requires the separated plinth/toekick bbox evidence.',
+        });
+    }
+}).describe('Required measurement evidence for drawing-derived base/sink cabinet READY payloads. This is the agent contract that forces base height to exclude countertop and toekick/plinth.');
+const OrderReadyStatusSchema = zod_1.z.enum([
+    'NOT_PREPARED',
+    'READY',
+    'NEEDS_USER_INPUT',
+    'NEEDS_AGENT_CONFIGURATION',
+    'BLOCKED',
+    'SKIPPED',
+    'STALE',
+]).describe('AI-only order-ready validation status for one backend AI cart item.');
+const OrderReadySourceSchema = zod_1.z.enum(['AI', 'MCP', 'BROWSER']).default('MCP').describe('Source metadata for the AI-only order-ready payload update.');
+const OrderReadyMessageSchema = zod_1.z.object({
+    code: zod_1.z.string().min(1).optional(),
+    severity: zod_1.z.enum(['info', 'warning', 'error', 'blocker']).default('error'),
+    field: zod_1.z.string().min(1).optional(),
+    message: zod_1.z.string().min(1),
+}).strict().describe('Structured order-ready validation message for MCP/frontend display.');
+const AxisHorizontalDirectionSchema = zod_1.z.enum(['left', 'right']);
+const AxisVerticalDirectionSchema = zod_1.z.enum(['up', 'down']);
+const CalibrationSchemaVersionSchema = zod_1.z.literal('ai-canvas-calibration/v1');
+const CalibrationUnitSchema = zod_1.z.literal('inches');
+const ImageSizePxSchema = zod_1.z.object({
+    width: zod_1.z.number().positive().describe('Positive image width in pixels.'),
+    height: zod_1.z.number().positive().describe('Positive image height in pixels.'),
+}).strict();
+const PixelPointSchema = zod_1.z.object({
+    x: zod_1.z.number().finite().describe('Image pixel X coordinate.'),
+    y: zod_1.z.number().finite().describe('Image pixel Y coordinate.'),
+}).strict();
+const PlanProjectionCalibrationSchema = zod_1.z.object({
+    schemaVersion: CalibrationSchemaVersionSchema,
+    canvasType: zod_1.z.literal('plan'),
+    imageSizePx: ImageSizePxSchema,
+    unit: CalibrationUnitSchema,
+    pixelsPerInch: zod_1.z.number().positive().describe('Positive pixels per room inch for plan projection.'),
+    roomOriginPx: PixelPointSchema.describe('Image pixel reference point for room/global coordinate origin.'),
+    roomAxis: zod_1.z.object({
+        xPositiveDirection: AxisHorizontalDirectionSchema,
+        yPositiveDirection: AxisVerticalDirectionSchema,
+    }).strict(),
+    roomSizeInches: zod_1.z.object({
+        width: zod_1.z.number().positive().optional(),
+        depth: zod_1.z.number().positive().optional(),
+    }).strict().optional(),
+    displayTransform: zod_1.z.record(zod_1.z.unknown()).optional().describe('Optional UI-only zoom/pan metadata. It is not projection calibration.'),
+}).strict().describe('Plan projection calibration for canonical room/global AI coordinates.');
+const ElevationVisibilityRuleSchema = zod_1.z.object({
+    mode: zod_1.z.literal('rotation'),
+    rotations: zod_1.z.array(CoordinateRotationSchema).optional().describe('Allowed wall rotations for this elevation. Use 0 north, 90 east, 180 south, 270 west.'),
+    visibleRotations: zod_1.z.array(CoordinateRotationSchema).optional().describe('Backend-compatible allowed wall rotations for this elevation. Use 0 north, 90 east, 180 south, 270 west.'),
+    includePositionNames: zod_1.z.array(zod_1.z.string().min(1)).optional(),
+    excludePositionNames: zod_1.z.array(zod_1.z.string().min(1)).optional(),
+}).strict().superRefine((value, ctx) => {
+    if (!value.rotations && !value.visibleRotations) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: 'visibilityRule requires rotations or visibleRotations',
+            path: ['rotations'],
+        });
+    }
+});
+const ElevationCanvasTypeSchema = zod_1.z.enum(['north', 'south', 'east', 'west']);
+const AiDrawingItemClassificationEvidenceSchema = zod_1.z.object({
+    sourceCanvases: zod_1.z.array(CanvasTypeSchema).min(1).describe('Canvases actually used to classify this physical item.'),
+    primaryCanvasType: CanvasTypeSchema.describe('Canvas that directly shows the cabinet geometry used to classify this item.'),
+    classificationBasis: zod_1.z.enum([
+        'same_canvas_visible_geometry',
+        'plan_elevation_association',
+        'user_confirmed',
+    ]).describe('Basis for semantic classification. Plan symbols from unrelated elevation/detail regions are not valid.'),
+    semanticTypeEvidence: zod_1.z.string().min(20).describe('Human-readable same-canvas or user-confirmed evidence for the item type, such as base, upper, pantry/tall, sink base, appliance surround, or filler.'),
+    primaryViewPlaneRole: DrawingViewPlaneRoleSchema.optional().describe('View-plane role for the primary classification canvas. Elevation-derived items must be primary_elevation_face; return_side_face/context_anchor objects are not physical items for that elevation.'),
+    frontFaceEvidence: zod_1.z.string().min(20).optional().describe('Required visual evidence for elevation-derived primary_elevation_face items, such as visible doors, drawers, appliance front/handles, or front cabinet face boundaries.'),
+    frontFaceFeatures: zod_1.z.array(DrawingFrontFaceFeatureSchema).optional().describe('Required for elevation-derived items. Declare concrete visual signals visible on the primary face. side_panel_or_return_visible/context_only are exclusion signals, not placement evidence.'),
+    sourceElevationObject: DrawingReviewedObjectEvidenceSchema.optional().describe('Required for elevation-derived item classifications. Must cite the reviewed elevation object that directly supports the physical item.'),
+    baseCabinetBodyHeightEvidence: BaseCabinetBodyHeightEvidenceSchema.optional().describe('Required when a drawing-derived base or sink-base item is marked READY. Documents the measured body height excluding countertop and toekick/plinth.'),
+    sourcePlanObject: DrawingReviewedObjectEvidenceSchema.optional().describe('Required for plan_elevation_association classifications. Must cite the exact reviewed selected plan object.'),
+    elevationCanvasType: ElevationCanvasTypeSchema.optional(),
+    detailNumber: zod_1.z.string().min(1).optional(),
+    planMarkerSide: PlanMarkerSideSchema.optional(),
+    selectedPlanObjectIds: zod_1.z.array(zod_1.z.string().min(1)).optional(),
+    anchorPlanObjectIds: zod_1.z.array(zod_1.z.string().min(1)).optional(),
+    selectedPlanObjectBboxPx: zod_1.z.object({
+        x: zod_1.z.number().finite(),
+        y: zod_1.z.number().finite(),
+        width: zod_1.z.number().finite().positive(),
+        height: zod_1.z.number().finite().positive(),
+    }).strict().optional(),
+    rejectedConflictingEvidence: zod_1.z.array(zod_1.z.string().min(1)).default([]).describe('Plan-only symbols/anchors/callouts rejected because they belong to another elevation/detail marker side.'),
+}).strict().describe('Optional trace metadata for the model-visible drawing interpretation. MCP accepts it for audit/debugging but does not certify visual semantics.');
+const PlacementViewAssociationEvidenceSchema = zod_1.z.object({
+    basis: zod_1.z.enum(['plan_elevation_marker_review', 'same_canvas_reviewed_plan_object', 'user_confirmed', 'plan_only_no_elevation']).describe('Optional trace note for how this plan placement was associated to the physical cabinet/wall view.'),
+    elevationCanvasType: ElevationCanvasTypeSchema.optional().describe('Elevation canvas this plan placement is associated with, when applicable.'),
+    detailNumber: zod_1.z.string().min(1).optional().describe('Elevation/detail marker number used for plan/elevation binding, when applicable.'),
+    planMarkerSide: PlanMarkerSideSchema.optional().describe('Side of the plan detail marker used for binding, when applicable.'),
+    selectedPlanObjectIds: zod_1.z.array(zod_1.z.string().min(1)).optional().describe('Optional plan object ids selected during analysis. Trace metadata only.'),
+    anchorPlanObjectIds: zod_1.z.array(zod_1.z.string().min(1)).optional().describe('Optional contextual plan anchor ids. Do not use this to block REF/refrigerator footprints; REF can be the selected placement object when matched elevation vision confirms an appliance/surround condition.'),
+    selectedPlanObjectBboxPx: zod_1.z.object({
+        x: zod_1.z.number().finite(),
+        y: zod_1.z.number().finite(),
+        width: zod_1.z.number().finite().positive(),
+        height: zod_1.z.number().finite().positive(),
+    }).strict().optional().describe('Optional pixel bbox of a selected plan object used during analysis. Trace metadata only.'),
+    selectedPlanObjectRole: zod_1.z.enum([
+        'physical_plan_footprint',
+        'appliance_footprint',
+        'dashed_overhead_only',
+        'context_anchor',
+        'annotation_or_clearance',
+        'needs_user_confirmation',
+    ]).optional().describe('Optional structured role of the selected plan object. Trace metadata only.'),
+    userExplicitConfirmation: zod_1.z.boolean().optional().describe('Optional trace flag for user confirmation.'),
+    userConfirmationText: zod_1.z.string().min(20).optional().describe('Optional user-confirmation trace text.'),
+    sourcePlanObject: DrawingReviewedObjectEvidenceSchema.optional().describe('Optional reviewed plan object selected during analysis. Trace metadata only.'),
+    sharedAnchors: zod_1.z.array(zod_1.z.string().min(1)).optional().describe('Shared semantic anchors used for the association, such as appliance_label:REF.'),
+    conflictingPlanAnchorsRejected: zod_1.z.array(zod_1.z.string().min(1)).optional().describe('Plan-only anchors that were rejected for this elevation association, such as fixture_symbol:SINK.'),
+    evidence: zod_1.z.string().optional().describe('Optional plain-language trace note for this placement.'),
+}).strict().describe('Optional trace metadata for a placement. MCP does not certify plan/elevation visual semantics from this object.');
+const ElevationProjectionCalibrationBaseSchema = zod_1.z.object({
+    schemaVersion: CalibrationSchemaVersionSchema,
+    canvasType: ElevationCanvasTypeSchema,
+    imageSizePx: ImageSizePxSchema,
+    unit: CalibrationUnitSchema,
+    horizontalPixelsPerInch: zod_1.z.number().positive(),
+    verticalPixelsPerInch: zod_1.z.number().positive(),
+    floorZ0Px: zod_1.z.number().finite(),
+    wallType: ElevationCanvasTypeSchema,
+    wallPlaneCoordinateInches: zod_1.z.number().finite(),
+    horizontalOriginPx: PixelPointSchema,
+    horizontalOriginCoordinateInches: zod_1.z.number().finite(),
+    horizontalAxisPositiveDirection: AxisHorizontalDirectionSchema,
+    verticalAxisPositiveDirection: AxisVerticalDirectionSchema,
+    visibilityRule: ElevationVisibilityRuleSchema,
+    displayTransform: zod_1.z.record(zod_1.z.unknown()).optional().describe('Optional UI-only zoom/pan metadata. It is not projection calibration.'),
+}).strict();
+const ElevationProjectionCalibrationSchema = ElevationProjectionCalibrationBaseSchema.superRefine((value, ctx) => {
+    if (value.wallType !== value.canvasType) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: 'wallType must match canvasType',
+            path: ['wallType'],
+        });
+    }
+}).describe('Elevation projection calibration for canonical room/global AI coordinates.');
+exports.AiCanvasProjectionCalibrationSchema = zod_1.z.union([
+    PlanProjectionCalibrationSchema,
+    ElevationProjectionCalibrationSchema,
+]).describe('Canonical AIDrawingTool projection calibration stored at canvasMeta.projectionCalibration.');
+exports.AiCanvasMetaSchema = zod_1.z.record(zod_1.z.unknown()).superRefine((canvasMeta, ctx) => {
+    const projectionCalibration = canvasMeta.projectionCalibration;
+    if (projectionCalibration === undefined) {
+        return;
+    }
+    const result = exports.AiCanvasProjectionCalibrationSchema.safeParse(projectionCalibration);
+    if (!result.success) {
+        for (const issue of result.error.issues) {
+            ctx.addIssue({
+                ...issue,
+                path: ['projectionCalibration', ...issue.path],
+            });
+        }
+    }
+}).describe('Flexible AI canvas metadata. If projectionCalibration is present, it must follow ai-canvas-calibration/v1. Other legacy metadata keys remain flexible during transition.');
+exports.AiDrawingSessionCreateInputSchema = zod_1.z.object({
+    sourceType: zod_1.z.enum(['REDUX_SNAPSHOT', 'ORDER', 'SAVED_CART']).default('REDUX_SNAPSHOT').describe('Session source metadata. Stored draft cart references are metadata only and are not the live AI drawing cart.'),
+    sourceOrderId: zod_1.z.string().optional().describe('Optional source order id metadata.'),
+    sourceSavedCartId: zod_1.z.number().int().optional().describe('Optional source stored cart id metadata only.'),
+    activeAiCartId: zod_1.z.string().uuid().optional().describe('Optional active backend-owned AI cart UUID to link at session creation.'),
+}).strict().describe('Create an isolated backend-owned AIDrawingTool session. Owner fields are supplied by backend authentication, not by MCP input.');
+exports.AiCartIdParamSchema = zod_1.z.object({
+    cartId: zod_1.z.string().uuid().describe('UUID of the isolated backend-owned AIDrawingTool AI cart. This is not the frontend Redux cart and not a stored draft cart.'),
+}).strict();
+exports.AiCartItemIdParamSchema = exports.AiCartIdParamSchema.extend({
+    itemId: zod_1.z.string().uuid().describe('UUID of the backend canonical AI cart item. This backend aiCartItemId is the primary cart item identity after creation.'),
+}).strict();
+exports.AiCartItemInputSchema = zod_1.z.object({
+    frontendItemId: zod_1.z.string().optional().describe('Optional source frontend item id retained only as trace metadata. It is not canonical identity.'),
+    originalFrontendItemId: zod_1.z.string().optional().describe('Optional original source frontend item id retained when an input quantity expands into physical AI cart items.'),
+    serialNumber: zod_1.z.string().optional().describe('Optional catalog serial number. It identifies the cabinet catalog item only, not the cart item identity.'),
+    positionName: zod_1.z.string().min(1).describe('Required physical cabinet identity. It must be unique within an AI cart after backend expansion and must be reused by every plan/elevation placement that represents this same cabinet.'),
+    originalPositionName: zod_1.z.string().optional().describe('Optional original position name retained as source metadata when backend expansion creates physical item instances.'),
+    groupId: zod_1.z.string().optional().describe('Optional source grouping id retained as metadata.'),
+    quantity: zod_1.z.number().int().positive().default(1).describe('Positive source quantity. Quantity greater than 1 is accepted for snapshot input and the backend expands it into separate physical AI cart items with unique positionName values.'),
+    originalQuantity: zod_1.z.number().int().positive().optional().describe('Optional original source quantity. If omitted, the backend can preserve the input quantity as original quantity.'),
+    width: zod_1.z.number().positive().optional().describe('Optional cabinet width in inches.'),
+    height: zod_1.z.number().positive().optional().describe('Optional cabinet height in inches.'),
+    depth: zod_1.z.number().positive().optional().describe('Optional cabinet depth in inches.'),
+    displayName: zod_1.z.string().optional().describe('Optional cabinet display name for UI and agent context.'),
+    drawingClassificationEvidence: AiDrawingItemClassificationEvidenceSchema.optional().describe('Optional drawing interpretation trace metadata. MCP stores it for audit/debugging but does not validate visual semantics.'),
+    itemPayload: zod_1.z.record(zod_1.z.unknown()).optional().describe('Optional full original cart item payload object. If omitted, the MCP tool will synthesize a compact provenance payload from the item identity, catalog, dimensions, quantity, and display fields so the backend originalItemPayload requirement is still satisfied.'),
+}).strict().describe('AI cart item snapshot input for the isolated backend-owned AIDrawingTool AI cart. The snapshot must be one physical cabinet manifest for the whole session, not separate plan/elevation manifests. positionName is physical cabinet identity; backend aiCartItemId becomes canonical after creation; frontendItemId is trace metadata only; serialNumber is catalog identity only. For agent-created cabinets, creating this row is not enough: after backend ids are returned, write an order-ready payload/status for this item with set_ai_cart_item_order_ready_payload. This schema is separate from the Redux cart, stored draft carts, and the legacy frontend drawing route.');
+exports.AiCartItemPatchSchema = zod_1.z.object({
+    frontendItemId: zod_1.z.string().optional().describe('Optional trace metadata update. Not canonical identity.'),
+    originalFrontendItemId: zod_1.z.string().optional().describe('Optional original source frontend item id metadata update.'),
+    serialNumber: zod_1.z.string().optional().describe('Optional catalog identity update. Not cart item identity.'),
+    positionName: zod_1.z.string().min(1).optional().describe('Optional drawing identity update. Backend validation requires it to remain unique within the AI cart.'),
+    originalPositionName: zod_1.z.string().optional().describe('Optional original source position name metadata update.'),
+    groupId: zod_1.z.string().optional().describe('Optional source grouping metadata update.'),
+    quantity: zod_1.z.number().int().positive().optional().describe('Optional physical instance quantity update. Backend AI cart items represent physical cabinet instances, so service validation permits only quantity 1.'),
+    originalQuantity: zod_1.z.number().int().positive().optional().describe('Optional original source quantity metadata update.'),
+    width: zod_1.z.number().positive().optional().describe('Optional cabinet width in inches.'),
+    height: zod_1.z.number().positive().optional().describe('Optional cabinet height in inches.'),
+    depth: zod_1.z.number().positive().optional().describe('Optional cabinet depth in inches.'),
+    displayName: zod_1.z.string().optional().describe('Optional cabinet display name update.'),
+    itemPayload: zod_1.z.record(zod_1.z.unknown()).optional().describe('Optional replacement for the preserved original cart item payload object. Future tools should serialize it for backend storage.'),
+}).strict().describe('AI cart item patch input for isolated backend-owned AIDrawingTool AI cart items. Unknown fields are rejected so future tools cannot accidentally mutate unsupported state.');
+const AiCartSnapshotOrderConfigurationWorkflowSchema = zod_1.z.object({
+    mode: zod_1.z.literal('USER_CONFIRMED_ORDER_READY').describe('Required workflow gate before syncing agent-created AI cart items. The agent already ran configuration discovery, asked the user for exact order-critical options or a saved setting, and has enough confirmed inputs to write READY payloads after backend ids are returned.'),
+    evidence: zod_1.z.string().min(1).describe('Brief human-readable audit note for the configuration workflow. Prose is not used as a hard correctness gate; actual READY payloads are validated separately by ArticleItemSchema/order-contract checks.'),
+    checkedSerialNumbers: zod_1.z.array(zod_1.z.string().min(1)).min(1).optional().describe('Catalog serialNumbers for which configuration context/options were checked before syncing the AI cart snapshot.'),
+}).strict().describe('Pre-sync workflow gate for agent-created AIDrawingTool AI cart items.');
+exports.AiCartSnapshotInputSchema = exports.AiCartIdParamSchema.extend({
+    sourceSnapshotPayload: zod_1.z.string().optional().describe('Optional serialized full source cart snapshot for backend preservation.'),
+    items: zod_1.z.array(exports.AiCartItemInputSchema).default([]).describe('AI cart snapshot items. Provide each physical cabinet once for the whole AI drawing session. Do not create separate cart items for the plan view and elevation views of the same cabinet. First snapshot into a new or empty AI cart is allowed; a later snapshot must not silently overwrite cart state after AI or MCP edits. After creating agent-created items, use returned backend aiCartItemId values to write order-ready payload/status records for each item.'),
+    orderConfigurationWorkflow: AiCartSnapshotOrderConfigurationWorkflowSchema.optional(),
+}).describe('Full AI cart snapshot input for future MCP tools. It targets only the isolated backend-owned AIDrawingTool AI cart and persists one physical cabinet manifest for the session. Visual interpretation belongs to native vision and rendered review; this schema validates persistence shape only.');
+exports.AiCartCreateInputSchema = zod_1.z.object({
+    aiDrawingSessionId: zod_1.z.string().uuid().optional().describe('Optional UUID of the AI drawing session that owns this backend AI cart.'),
+    sourceType: zod_1.z.enum(['REDUX_SNAPSHOT', 'ORDER', 'SAVED_CART']).default('REDUX_SNAPSHOT').describe('Source metadata for the initial AI cart. This is metadata only and does not make stored draft carts the live AI cart.'),
+    sourceOrderId: zod_1.z.string().optional().describe('Optional source order id metadata.'),
+    sourceSavedCartId: zod_1.z.number().int().optional().describe('Optional source stored cart id metadata only.'),
+    sourceSnapshotPayload: zod_1.z.string().optional().describe('Optional serialized source cart snapshot for backend preservation.'),
+    orderConfigurationWorkflow: AiCartSnapshotOrderConfigurationWorkflowSchema.optional().describe('Optional audit note for user/configuration workflow. It is not forwarded to the backend create-cart endpoint.'),
+}).strict();
+const PatchAiCartItemInputSchema = exports.AiCartItemIdParamSchema.extend({
+    patch: exports.AiCartItemPatchSchema.describe('Patch fields for one backend-owned AI cart item.'),
+}).strict();
+const AiCabinetOperationItemParamSchema = AiDrawingSessionIdParamSchema.extend({
+    itemId: zod_1.z.string().uuid().describe('UUID of the physical backend AI cart item in the session active AI cart.'),
+}).strict();
+exports.DuplicateAiCabinetInputSchema = AiCabinetOperationItemParamSchema.extend({
+    positionName: zod_1.z.string().min(1).optional().describe('Optional unique positionName for the new physical cabinet. If omitted, the backend generates a copy name.'),
+    sourceCanvasType: CanvasTypeSchema.optional().describe('Optional selected source canvas whose placement should be copied for the duplicate. This maps to the backend selectedCanvasType field.'),
+    sourcePlacementPositionName: zod_1.z.string().min(1).optional().describe('Optional source placement positionName to copy from the selected canvas. Defaults to the source item positionName in the backend.'),
+    placementOffsetX: zod_1.z.number().finite().optional().describe('Optional X offset for the copied selected-canvas placement.'),
+    placementOffsetY: zod_1.z.number().finite().optional().describe('Optional Y offset for the copied selected-canvas placement.'),
+    source: PlacementSourceSchema.optional(),
+}).strict().describe('Duplicate one physical backend AI cabinet item and optionally copy one selected-canvas placement. ' +
+    AI_CABINET_OPERATION_GUIDANCE);
+const ConfigurePayloadSchema = zod_1.z.union([zod_1.z.string().min(1), zod_1.z.record(zod_1.z.unknown())]);
+exports.ConfigureAiCabinetInputSchema = AiCabinetOperationItemParamSchema.extend({
+    positionName: zod_1.z.string().min(1).optional().describe('Optional rename for the physical cabinet identity. The backend enforces uniqueness in the session active AI cart and updates linked AI-only placements.'),
+    frontendItemId: zod_1.z.string().optional().describe('Optional trace metadata update. Not physical identity.'),
+    originalFrontendItemId: zod_1.z.string().optional().describe('Optional original source frontend item id metadata update.'),
+    serialNumber: zod_1.z.string().optional().describe('Optional catalog identity update. Not physical AI cart item identity.'),
+    originalPositionName: zod_1.z.string().optional().describe('Optional original source position name metadata update.'),
+    groupId: zod_1.z.string().optional().describe('Optional source grouping metadata update.'),
+    quantity: zod_1.z.literal(1).optional().describe('Optional physical instance quantity. Backend AI cart items represent one physical cabinet, so only 1 is valid.'),
+    originalQuantity: zod_1.z.number().int().positive().optional().describe('Optional original source quantity metadata update.'),
+    width: zod_1.z.number().positive().optional().describe('Optional cabinet width in inches. Linked plan placements resize width/depth; linked elevation placements resize width/height.'),
+    height: zod_1.z.number().positive().optional().describe('Optional cabinet height in inches. Linked elevation placements use this as visual height.'),
+    depth: zod_1.z.number().positive().optional().describe('Optional cabinet depth in inches. Linked plan placements use this as visual height.'),
+    displayName: zod_1.z.string().optional().describe('Optional cabinet display name update.'),
+    originalItemPayload: ConfigurePayloadSchema.optional().describe('Optional preserved source payload. Objects are serialized before sending to the backend.'),
+    source: PlacementSourceSchema.optional(),
+}).strict().describe('Configure one physical backend AI cabinet item and resize linked AI-only placements when dimensions change. ' +
+    AI_CABINET_OPERATION_GUIDANCE);
+exports.DeleteAiCabinetInputSchema = AiCabinetOperationItemParamSchema.describe('Delete one physical backend AI cabinet item and all linked AI-only per-canvas placements. ' +
+    AI_CABINET_OPERATION_GUIDANCE);
+exports.AiOrderReadyPayloadReadInputSchema = AiCabinetOperationItemParamSchema.describe('Read the AI-only order-ready payload/status for one backend AI cart item. ' +
+    AI_ORDER_READY_GUIDANCE);
+exports.AiOrderReadyPayloadSetInputSchema = AiCabinetOperationItemParamSchema.extend({
+    orderReadyStatus: OrderReadyStatusSchema,
+    orderReadyPayload: zod_1.z.record(zod_1.z.unknown()).optional().describe('Agent-prepared order-ready article payload. Required and validated against the MCP ArticleItemSchema when orderReadyStatus is READY.'),
+    orderReadyMessages: zod_1.z.array(OrderReadyMessageSchema).optional().describe('Structured validation messages. Use this for NEEDS_AGENT_CONFIGURATION, BLOCKED, STALE, or other non-ready states.'),
+    orderReadySource: OrderReadySourceSchema.optional(),
+    drawingClassificationEvidence: AiDrawingItemClassificationEvidenceSchema.optional().describe('Optional drawing interpretation trace metadata. MCP does not certify visual semantics from this object.'),
+}).strict().superRefine((value, ctx) => {
+    if (value.orderReadyStatus === 'READY') {
+        const result = orders_1.ArticleItemSchema.safeParse(value.orderReadyPayload);
+        if (!result.success || !hasOrderConfigurationEvidence(value.orderReadyPayload)) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                path: ['orderReadyPayload'],
+                message: 'READY requires an ArticleItemSchema-compatible payload with order-critical configuration evidence; arbitrary objects or thin AI item fields are not order-ready.',
+            });
+        }
+        if (result.success) {
+            addBaseCabinetBodyHeightEvidenceIssues(value.orderReadyPayload, value.drawingClassificationEvidence, ctx);
+        }
+    }
+    if (value.orderReadyStatus === 'NOT_PREPARED' && value.orderReadyPayload !== undefined) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            path: ['orderReadyPayload'],
+            message: 'NOT_PREPARED must not include orderReadyPayload. Use clear_ai_cart_item_order_ready_payload to reset.',
+        });
+    }
+}).describe('Set the AI-only order-ready payload/status for one backend AI cart item. ' +
+    AI_ORDER_READY_GUIDANCE);
+exports.AiOrderReadyPayloadClearInputSchema = AiCabinetOperationItemParamSchema.describe('Clear the AI-only order-ready payload/status for one backend AI cart item. ' +
+    AI_ORDER_READY_GUIDANCE);
+const AiReduxCartImportStatusSchema = zod_1.z.literal('READY').describe('MCP imports must be existing order-ready browser Redux cart items. Non-ready planner/takeoff items must not be imported through MCP.');
+const AiReduxCartImportItemSchema = zod_1.z.object({
+    frontendItemId: zod_1.z.string().min(1).optional().describe('Source browser Redux cart item id for idempotent import. Provide when available.'),
+    originalFrontendItemId: zod_1.z.string().min(1).optional().describe('Original source browser Redux cart item id when different from frontendItemId.'),
+    positionName: zod_1.z.string().min(1).describe('Position name from the full Redux cart item payload.'),
+    originalPositionName: zod_1.z.string().min(1).optional(),
+    serialNumber: zod_1.z.string().min(1).describe('Catalog/article serial number from the Redux cart item.'),
+    displayName: zod_1.z.string().min(1).optional(),
+    groupId: zod_1.z.string().min(1).optional(),
+    quantity: zod_1.z.number().int().positive().default(1).describe('Source quantity. Backend import expands quantity greater than 1 into physical AI cart item instances.'),
+    originalQuantity: zod_1.z.number().int().positive().optional(),
+    width: zod_1.z.number().positive().describe('Cabinet width from the Redux cart item payload.'),
+    height: zod_1.z.number().positive().describe('Cabinet height from the Redux cart item payload.'),
+    depth: zod_1.z.number().positive().describe('Cabinet depth from the Redux cart item payload.'),
+    originalItemPayload: zod_1.z.record(zod_1.z.unknown()).describe('Full original browser Redux checkout cart item payload. Do not send thin serial/dimensions-only objects.'),
+    orderReadyPayload: zod_1.z.record(zod_1.z.unknown()).optional().describe('Optional prepared order-ready ArticleItemSchema-compatible payload. Required when orderReadyStatus is READY unless originalItemPayload itself is order-ready.'),
+    orderReadyStatus: AiReduxCartImportStatusSchema.optional(),
+    orderReadyMessages: zod_1.z.array(OrderReadyMessageSchema).optional(),
+    orderReadySource: OrderReadySourceSchema.optional(),
+    orderReadyRevision: zod_1.z.number().int().nonnegative().optional(),
+    aiDrawingSessionId: zod_1.z.string().uuid().optional().describe('Optional existing mirror provenance session id.'),
+    aiCartId: zod_1.z.string().uuid().optional().describe('Optional existing mirror provenance AI cart id.'),
+    aiCartItemId: zod_1.z.string().uuid().optional().describe('Optional existing mirror provenance AI cart item id.'),
+    aiMirrorStatus: zod_1.z.string().min(1).optional(),
+    aiMirrorSource: zod_1.z.string().min(1).optional(),
+}).strict().superRefine((value, ctx) => {
+    if (!hasCoreReduxPayloadFields(value.originalItemPayload)) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            path: ['originalItemPayload'],
+            message: 'originalItemPayload must be the full Redux cart item object with positionName, serialNumber, quantity, width, height, and depth.',
+        });
+    }
+    const originalIsOrderReady = orders_1.ArticleItemSchema.safeParse(value.originalItemPayload).success &&
+        hasOrderConfigurationEvidence(value.originalItemPayload);
+    const suppliedReadyPayloadIsOrderReady = orders_1.ArticleItemSchema.safeParse(value.orderReadyPayload).success &&
+        hasOrderConfigurationEvidence(value.orderReadyPayload);
+    if (value.orderReadyStatus === 'READY' && !suppliedReadyPayloadIsOrderReady && !originalIsOrderReady) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            path: ['orderReadyPayload'],
+            message: 'READY import requires orderReadyPayload or originalItemPayload to satisfy ArticleItemSchema with order-critical configuration evidence.',
+        });
+    }
+    if (value.orderReadyStatus !== 'READY') {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            path: ['orderReadyStatus'],
+            message: 'MCP import requires orderReadyStatus READY. Do not use import_redux_cart_items_to_ai_cart for drawing-takeoff or unconfigured planner items.',
+        });
+    }
+    if (!suppliedReadyPayloadIsOrderReady && !originalIsOrderReady) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            path: ['originalItemPayload'],
+            message: 'MCP import requires originalItemPayload or orderReadyPayload to satisfy ArticleItemSchema with order-critical configuration evidence.',
+        });
+    }
+}).describe('One rich Redux checkout cart item import candidate for the backend-owned AIDrawingTool AI cart. ' +
+    AI_REDUX_IMPORT_GUIDANCE);
+exports.AiReduxCartImportInputSchema = AiDrawingSessionIdParamSchema.extend({
+    items: zod_1.z.array(AiReduxCartImportItemSchema).min(1).describe('One or more full Redux cart items to import idempotently into the active AI drawing cart.'),
+}).strict().describe('Import rich Redux checkout cart items into the active backend-owned AIDrawingTool AI cart. ' +
+    AI_REDUX_IMPORT_GUIDANCE);
+exports.AiDrawingSessionReviewRenderInputSchema = AiDrawingSessionIdParamSchema.extend({
+    canvasTypes: zod_1.z.array(CanvasTypeSchema).optional().describe('Optional list of AI drawing canvases to render. When omitted, the tool renders the active canvases returned by the stored AI drawing state.'),
+    outputDir: zod_1.z.string().min(1).refine((value) => value.trim().length > 0, {
+        message: 'outputDir must not be blank',
+    }).describe('Local directory where the MCP server should write review PNG artifacts and an optional JSON manifest.'),
+    includeManifest: zod_1.z.boolean().optional().default(false).describe('When true, also write a JSON manifest next to the review PNG artifacts.'),
+}).strict().describe('Render read-only AI drawing session visual review artifacts. ' + AI_DRAWING_VISUAL_REVIEW_GUIDANCE);
+exports.LinkAiCartToDrawingSessionInputSchema = AiDrawingSessionIdParamSchema.extend({
+    cartId: zod_1.z.string().uuid().describe('UUID of the backend-owned AI cart to link as the session active cart.'),
+}).strict();
+exports.AiCanvasMetadataInputSchema = AiDrawingSessionIdParamSchema.extend({
+    canvasType: CanvasTypeSchema,
+    canvasMeta: exports.AiCanvasMetaSchema.optional().describe('Optional AI canvas metadata payload. canvasMeta itself is flexible. Use canvasMeta.projectionCalibration only for the strict canonical coordinate projection schema; do not put free-form notes there. For IMAGE_PIXELS placement-only workflows, store notes in other canvasMeta keys and omit projectionCalibration.'),
+    z0Reference: zod_1.z.record(zod_1.z.unknown()).optional().describe('Optional Z0/floor reference metadata payload.'),
+    verticalCalibration: zod_1.z.record(zod_1.z.unknown()).optional().describe('Optional vertical calibration metadata payload.'),
+    calibrationOffsets: zod_1.z.record(zod_1.z.unknown()).optional().describe('Optional calibration offset metadata payload.'),
+    elevationVisibility: zod_1.z.record(zod_1.z.unknown()).optional().describe('Optional elevation visibility metadata payload.'),
+    fixedElevationPositions: zod_1.z.record(zod_1.z.unknown()).optional().describe('Optional fixed elevation position metadata payload.'),
+    elevationCalibrated: zod_1.z.record(zod_1.z.unknown()).optional().describe('Optional elevation calibration state metadata payload.'),
+    globalElevationOffsets: zod_1.z.record(zod_1.z.unknown()).optional().describe('Optional global elevation offset metadata payload.'),
+    calibratedCabinets: zod_1.z.record(zod_1.z.unknown()).optional().describe('Optional calibrated cabinet metadata payload.'),
+    activeCanvases: zod_1.z.array(CanvasTypeSchema).optional().describe('Optional active AI canvas list.'),
+}).strict().describe('Upsert metadata for one isolated backend-owned AIDrawingTool canvas. This does not mutate legacy drawing metadata. ' +
+    AI_CANVAS_CALIBRATION_GUIDANCE);
+exports.AiCanvasImageInputSchema = AiDrawingSessionIdParamSchema.extend({
+    canvasType: CanvasTypeSchema,
+    imageType: ImageTypeSchema,
+    s3Key: zod_1.z.string().min(1).describe('Required S3 key or backend image reference for the AI drawing canvas image.'),
+}).strict().describe('Upsert an image reference for one isolated backend-owned AIDrawingTool canvas.');
+exports.AiCanvasImageUploadInputSchema = AiDrawingSessionIdParamSchema.extend({
+    canvasType: CanvasTypeSchema,
+    imageType: ImageTypeSchema.default('background'),
+    imagePath: zod_1.z.string().min(1).describe('Absolute path to a local image file readable by the MCP server. Supported formats: .png, .jpg, .jpeg, .webp. The MCP server uploads the actual bytes to the AI backend; do not use upsert_ai_canvas_image for local file paths.'),
+}).strict().describe('Upload a local image file into backend-owned AIDrawingTool storage for one canvas.');
+exports.AiCanvasImageDeleteInputSchema = AiDrawingSessionIdParamSchema.extend({
+    canvasType: CanvasTypeSchema,
+    imageType: ImageTypeSchema,
+}).strict().describe('Delete one image reference for one isolated backend-owned AIDrawingTool canvas. If the stored backend image is an AI-owned object under ai-drawings/{sessionId}/, the backend may delete that S3 object; arbitrary external URL references are not S3-deleted.');
+exports.AiCanvasCabinetPlacementInputSchema = zod_1.z.object({
+    aiCartItemId: zod_1.z.string().uuid().optional().describe('Optional backend AI cart item UUID. Required unless positionName exactly matches an active AI cart item positionName for backend auto-linking.'),
+    positionName: zod_1.z.string().min(1).describe('Required physical AI cart item positionName and per-canvas placement identity. This must match the linked aiCartItemId when provided. Do not use aggregate footprint/reference labels such as P_*_FOOTPRINT as cabinet placements.'),
+    centerX: zod_1.z.number().finite().describe('Required placement center X in the selected canvas coordinate space.'),
+    centerY: zod_1.z.number().finite().describe('Required placement center Y in the selected canvas coordinate space.'),
+    width: zod_1.z.number().finite().positive().describe('Required positive visual rectangle width in the selected canvas coordinate space.'),
+    height: zod_1.z.number().finite().positive().describe('Required positive visual rectangle height in the selected canvas coordinate space.'),
+    rotation: zod_1.z.number().finite().optional().describe('Optional visual rectangle rotation for this canvas. Backend defaults to 0 when omitted.'),
+    placementSpace: PlacementSpaceSchema.optional(),
+    basisImageWidthPx: zod_1.z.number().finite().positive().optional().describe('Optional positive width of the source image or blank canvas basis used for this placement.'),
+    basisImageHeightPx: zod_1.z.number().finite().positive().optional().describe('Optional positive height of the source image or blank canvas basis used for this placement.'),
+    source: PlacementSourceSchema.optional(),
+    viewAssociationEvidence: PlacementViewAssociationEvidenceSchema.optional().describe('Optional plan/elevation association trace metadata. It is not sent to the backend placement DTO.'),
+}).strict().describe('One AIDrawingTool per-canvas cabinet placement rectangle. ' + AI_CANVAS_PLACEMENT_GUIDANCE);
+exports.AiCanvasCabinetPlacementPatchSchema = zod_1.z.object({
+    aiCartItemId: zod_1.z.string().uuid().optional().describe('Optional backend AI cart item UUID association update. Required for unlinked legacy placements unless positionName exactly matches an active AI cart item.'),
+    positionName: zod_1.z.string().min(1).describe('Required per-canvas placement identity to patch.'),
+    centerX: zod_1.z.number().finite().optional().describe('Optional placement center X update in the selected canvas coordinate space.'),
+    centerY: zod_1.z.number().finite().optional().describe('Optional placement center Y update in the selected canvas coordinate space.'),
+    width: zod_1.z.number().finite().positive().optional().describe('Optional positive visual rectangle width update.'),
+    height: zod_1.z.number().finite().positive().optional().describe('Optional positive visual rectangle height update.'),
+    rotation: zod_1.z.number().finite().optional().describe('Optional visual rectangle rotation update for this canvas.'),
+    placementSpace: PlacementSpaceSchema.optional(),
+    basisImageWidthPx: zod_1.z.number().finite().positive().optional().describe('Optional positive source image or blank canvas basis width update.'),
+    basisImageHeightPx: zod_1.z.number().finite().positive().optional().describe('Optional positive source image or blank canvas basis height update.'),
+    source: PlacementSourceSchema.optional(),
+    viewAssociationEvidence: PlacementViewAssociationEvidenceSchema.optional().describe('Optional plan/elevation association trace metadata for placement geometry patches. It is not sent to the backend placement DTO.'),
+}).strict().describe('Patch input for one AIDrawingTool per-canvas cabinet placement rectangle. ' + AI_CANVAS_PLACEMENT_GUIDANCE);
+exports.AiCanvasCabinetPlacementsReplaceInputSchema = AiDrawingSessionIdParamSchema.extend({
+    canvasType: CanvasTypeSchema,
+    placements: zod_1.z.array(exports.AiCanvasCabinetPlacementInputSchema).min(1).describe('Nonempty replacement placements for exactly this canvas. This must not replace placements on any other canvas. Use delete_ai_canvas_cabinet_placements for selected removals.'),
+}).strict().superRefine((input, ctx) => validatePlacementOperationForCanvas(input.canvasType, input.placements, ctx)).describe('Replace one selected canvas placement set for backend-owned AIDrawingTool. ' + AI_CANVAS_PLACEMENT_GUIDANCE + ' ' + AI_CANVAS_PLACEMENT_ROTATION_GUIDANCE);
+exports.AiCanvasCabinetPlacementsUpsertInputSchema = AiDrawingSessionIdParamSchema.extend({
+    canvasType: CanvasTypeSchema,
+    placements: zod_1.z.array(exports.AiCanvasCabinetPlacementInputSchema).min(1).describe('Nonempty create-or-update placements for exactly this canvas, keyed by positionName. This must not replace or delete placements omitted from the request.'),
+}).strict().superRefine((input, ctx) => validatePlacementOperationForCanvas(input.canvasType, input.placements, ctx)).describe('Upsert selected placement rectangles for one backend-owned AIDrawingTool canvas. ' + AI_CANVAS_PLACEMENT_GUIDANCE + ' ' + AI_CANVAS_PLACEMENT_ROTATION_GUIDANCE);
+exports.AiCanvasCabinetPlacementsByCanvasInputSchema = AiDrawingSessionIdParamSchema.extend({
+    canvasType: CanvasTypeSchema,
+}).strict().describe('Read placement rectangles for one backend-owned AIDrawingTool canvas. ' + AI_CANVAS_PLACEMENT_GUIDANCE);
+exports.AiCanvasCabinetPlacementsPatchInputSchema = AiDrawingSessionIdParamSchema.extend({
+    canvasType: CanvasTypeSchema,
+    placements: zod_1.z.array(exports.AiCanvasCabinetPlacementPatchSchema).min(1).describe('Patch operations for exactly this canvas, keyed by positionName.'),
+}).strict().superRefine((input, ctx) => validatePlacementOperationForCanvas(input.canvasType, input.placements, ctx)).describe('Patch selected placements for one backend-owned AIDrawingTool canvas. ' + AI_CANVAS_PLACEMENT_GUIDANCE + ' ' + AI_CANVAS_PLACEMENT_ROTATION_GUIDANCE);
+exports.AiCanvasCabinetPlacementsDeleteInputSchema = AiDrawingSessionIdParamSchema.extend({
+    canvasType: CanvasTypeSchema,
+    positionNames: zod_1.z.array(zod_1.z.string().min(1)).min(1).describe('Nonempty list of per-canvas placement positionName values to delete from exactly this canvas.'),
+}).strict().describe('Delete selected placements from one backend-owned AIDrawingTool canvas. ' + AI_CANVAS_PLACEMENT_GUIDANCE);
+const AiCoordinateDerivationEvidenceSchema = zod_1.z.object({
+    basis: zod_1.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.'),
+    sourceCanvasType: zod_1.z.literal('plan').describe('Canonical x/y coordinates must be derived from validated plan placement geometry, not elevation-local pixels.'),
+    planPlacementPositionName: zod_1.z.string().min(1).optional().describe('Position name of the validated plan placement used to derive this coordinate.'),
+    planPlacementEvidence: PlacementViewAssociationEvidenceSchema.optional().describe('Plan placement evidence used for the coordinate derivation. Required unless basis is explicit user_confirmed.'),
+    userExplicitConfirmation: zod_1.z.boolean().optional(),
+    userConfirmationText: zod_1.z.string().min(20).optional(),
+    evidence: zod_1.z.string().min(20),
+}).strict().superRefine((value, ctx) => {
+    if (value.basis === 'validated_plan_placement') {
+        if (!value.planPlacementPositionName || !value.planPlacementEvidence) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                path: ['planPlacementEvidence'],
+                message: 'validated_plan_placement coordinate writes require planPlacementPositionName and planPlacementEvidence.',
+            });
+        }
+    }
+    if (value.basis === 'user_confirmed') {
+        const confirmation = `${value.userConfirmationText ?? ''} ${value.evidence}`.toLowerCase();
+        if (!value.userExplicitConfirmation || !value.userConfirmationText) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                path: ['userConfirmationText'],
+                message: 'user_confirmed coordinate writes require explicit user confirmation text for the exact coordinate/placement.',
+            });
+        }
+        if (/\b(provided|uploaded|supplied)\b.*\b(drawings?|images?)\b|\basked\b.*\b(verify|analy[sz]e)\b/.test(confirmation)) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                path: ['userConfirmationText'],
+                message: 'Generic statements that the user supplied drawings or asked the agent to verify are not coordinate confirmation.',
+            });
+        }
+    }
+});
+function validatePlacementRotationsForCanvas(canvasType, placements, ctx) {
+    if (canvasType === 'plan') {
+        return;
+    }
+    placements.forEach((placement, index) => {
+        if (placement.rotation !== undefined && placement.rotation !== 0) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                path: ['placements', index, 'rotation'],
+                message: AI_CANVAS_PLACEMENT_ROTATION_GUIDANCE,
+            });
+        }
+    });
+}
+function validatePlacementOperationForCanvas(canvasType, placements, ctx) {
+    validatePlacementRotationsForCanvas(canvasType, placements, ctx);
+}
+exports.AiCabinetCoordinateInputSchema = zod_1.z.object({
+    positionName: zod_1.z.string().min(1).describe('Required AI drawing coordinate identity. It is unique within an AI drawing session.'),
+    aiCartItemId: zod_1.z.string().uuid().optional().describe('Optional canonical backend AI cart item UUID associated with this coordinate.'),
+    x: zod_1.z.number().finite().describe('Canonical cabinet center X in room/global plan coordinates, in inches. Never use image-local pixels or elevation-local X here.'),
+    y: zod_1.z.number().finite().describe('Canonical cabinet center Y in room/global plan coordinates, in inches. Never use image-local pixels or elevation-local horizontal coordinates here.'),
+    z: zod_1.z.number().finite().default(0).describe('Canonical height from finished floor to cabinet bottom, in inches.'),
+    rotation: CoordinateRotationSchema.default(0),
+    source: CoordinateSourceSchema.optional(),
+    coordinateEvidence: AiCoordinateDerivationEvidenceSchema.optional().describe('Optional canonical coordinate trace metadata.'),
+}).strict().describe('AI cabinet coordinate input using canonical room/global inches for the AIDrawingTool coordinate contract. ' +
+    AI_CANONICAL_PROJECTION_GUIDANCE);
+exports.AiCabinetCoordinatePatchInputSchema = zod_1.z.object({
+    positionName: zod_1.z.string().min(1).describe('Required AI drawing coordinate identity to patch.'),
+    aiCartItemId: zod_1.z.string().uuid().optional().describe('Optional canonical backend AI cart item UUID association update.'),
+    x: zod_1.z.number().finite().optional().describe('Optional canonical cabinet center X update in room/global plan coordinates, in inches. Never use image-local pixels or elevation-local X.'),
+    y: zod_1.z.number().finite().optional().describe('Optional canonical cabinet center Y update in room/global plan coordinates, in inches. Never use image-local pixels or elevation-local horizontal coordinates.'),
+    z: zod_1.z.number().finite().optional().describe('Optional canonical finished-floor-to-cabinet-bottom height update, in inches.'),
+    rotation: CoordinateRotationSchema.optional(),
+    source: CoordinateSourceSchema.optional(),
+    coordinateEvidence: AiCoordinateDerivationEvidenceSchema.optional().describe('Optional canonical coordinate trace metadata for coordinate patches.'),
+}).strict().describe('AI cabinet coordinate patch input. Unknown fields are rejected so tools cannot accidentally mutate unsupported state. ' +
+    AI_CANONICAL_PROJECTION_GUIDANCE);
+exports.AiCabinetCoordinatesReplaceInputSchema = AiDrawingSessionIdParamSchema.extend({
+    coordinates: zod_1.z.array(exports.AiCabinetCoordinateInputSchema).default([]).describe('Full replacement AI coordinate list for the session.'),
+}).strict();
+exports.AiCabinetCoordinatesPatchInputListSchema = AiDrawingSessionIdParamSchema.extend({
+    coordinates: zod_1.z.array(exports.AiCabinetCoordinatePatchInputSchema).min(1).describe('AI coordinate patch operations keyed by positionName.'),
+}).strict();
+exports.AiCabinetCoordinatesDeleteInputSchema = AiDrawingSessionIdParamSchema.extend({
+    positionNames: zod_1.z.array(zod_1.z.string().min(1)).min(1).describe('AI coordinate position names to delete.'),
+}).strict();
+// ---------------------------------------------------------------------------
+// Handlers
+// ---------------------------------------------------------------------------
+async function getAiDrawingState(input) {
+    try {
+        const { data } = await api_client_1.aiDrawingClient.get(`/sessions/${input.sessionId}/state`);
+        return JSON.stringify(data, null, 2);
+    }
+    catch (error) {
+        try {
+            (0, api_client_1.handleAxiosError)(error);
+        }
+        catch (e) {
+            return e.message;
+        }
+        return 'Unexpected error fetching AI drawing state.';
+    }
+}
+async function renderAiDrawingSessionReviewTool(input) {
+    try {
+        const { data } = await api_client_1.aiDrawingClient.get(`/sessions/${input.sessionId}/state`);
+        const imagePathByCanvas = await materializeReviewBackgroundImages(data, input.outputDir);
+        const renderOptions = {
+            outputDir: input.outputDir,
+            canvases: input.canvasTypes,
+            writeJsonManifest: input.includeManifest ?? false,
+        };
+        if (Object.keys(imagePathByCanvas).length > 0) {
+            renderOptions.imagePathByCanvas = imagePathByCanvas;
+        }
+        const manifest = (0, ai_drawing_session_review_renderer_1.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({
+            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,
+            })),
+            perCanvasIssues: Object.fromEntries(manifest.canvases.map((canvas) => [canvas.canvasType, canvas.issues])),
+            aggregateIssueCount: manifest.issues.length,
+            issues: manifest.issues,
+            manifestPath: manifest.manifestPath,
+        }, null, 2);
+    }
+    catch (error) {
+        try {
+            (0, api_client_1.handleAxiosError)(error);
+        }
+        catch (e) {
+            return e.message;
+        }
+        return `Unexpected error rendering AI drawing session review: ${formatUnknownError(error)}`;
+    }
+}
+async function materializeReviewBackgroundImages(state, outputDir) {
+    const stateRecord = isRecord(state) ? state : {};
+    const images = Array.isArray(stateRecord.canvasImages) ? stateRecord.canvasImages : [];
+    const paths = {};
+    for (const image of images) {
+        if (!isRecord(image)) {
+            continue;
+        }
+        const canvasType = typeof image.canvasType === 'string' && isAiDrawingReviewCanvasType(image.canvasType)
+            ? image.canvasType
+            : null;
+        const imageType = typeof image.imageType === 'string' ? image.imageType.toLowerCase() : '';
+        const reference = stringifyReviewImageReference(image.imagePath ?? image.path ?? image.s3Key);
+        if (!canvasType || imageType !== 'background' || !reference) {
+            continue;
+        }
+        if (isReadableLocalPng(reference)) {
+            paths[canvasType] = normalizeFileSchemePath(reference);
+            continue;
+        }
+        const remoteUrl = resolveReviewBackgroundUrl(reference);
+        if (!remoteUrl || path.extname(new URL(remoteUrl).pathname).toLowerCase() !== '.png') {
+            continue;
+        }
+        const downloadedPath = await downloadReviewBackground(remoteUrl, outputDir, canvasType);
+        if (downloadedPath) {
+            paths[canvasType] = downloadedPath;
+        }
+    }
+    return paths;
+}
+async function downloadReviewBackground(remoteUrl, outputDir, canvasType) {
+    try {
+        fs.mkdirSync(outputDir, { recursive: true });
+        const response = await fetch(remoteUrl);
+        if (!response.ok) {
+            return undefined;
+        }
+        const contentType = response.headers.get('content-type') ?? '';
+        if (contentType && !contentType.toLowerCase().includes('image/png')) {
+            return undefined;
+        }
+        const bytes = Buffer.from(await response.arrayBuffer());
+        if (!isPngBuffer(bytes)) {
+            return undefined;
+        }
+        const outputPath = path.join(outputDir, `ai-drawing-session-review-background-${canvasType}.png`);
+        fs.writeFileSync(outputPath, bytes);
+        return outputPath;
+    }
+    catch {
+        return undefined;
+    }
+}
+function resolveReviewBackgroundUrl(reference) {
+    if (/^https?:\/\//i.test(reference)) {
+        return reference;
+    }
+    if (/^(data|blob):/i.test(reference) || path.isAbsolute(normalizeFileSchemePath(reference))) {
+        return undefined;
+    }
+    const normalizedReference = reference.replace(/^\/+/, '');
+    return `${AI_DRAWING_REVIEW_ASSET_BASE_URL}/${normalizedReference}`;
+}
+function isReadableLocalPng(reference) {
+    const localPath = normalizeFileSchemePath(reference);
+    return path.isAbsolute(localPath) && path.extname(localPath).toLowerCase() === '.png' && fs.existsSync(localPath);
+}
+function normalizeFileSchemePath(reference) {
+    return reference.startsWith('file://')
+        ? decodeURIComponent(reference.slice('file://'.length))
+        : reference;
+}
+function stringifyReviewImageReference(value) {
+    if (value === null || value === undefined) {
+        return undefined;
+    }
+    const text = String(value).trim();
+    return text.length > 0 ? text : undefined;
+}
+function isAiDrawingReviewCanvasType(value) {
+    return ['plan', 'north', 'south', 'east', 'west'].includes(value);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isPngBuffer(bytes) {
+    return bytes.length >= 8 &&
+        bytes[0] === 0x89 &&
+        bytes[1] === 0x50 &&
+        bytes[2] === 0x4e &&
+        bytes[3] === 0x47 &&
+        bytes[4] === 0x0d &&
+        bytes[5] === 0x0a &&
+        bytes[6] === 0x1a &&
+        bytes[7] === 0x0a;
+}
+async function createAiDrawingSession(input) {
+    try {
+        const { data } = await api_client_1.aiDrawingClient.post('/sessions', input);
+        return JSON.stringify(data, null, 2);
+    }
+    catch (error) {
+        try {
+            (0, api_client_1.handleAxiosError)(error);
+        }
+        catch (e) {
+            return e.message;
+        }
+        return 'Unexpected error creating AI drawing session.';
+    }
+}
+async function linkAiCartToDrawingSession(input) {
+    try {
+        const { data } = await api_client_1.aiDrawingClient.put(`/sessions/${input.sessionId}/active-cart/${input.cartId}`);
+        return JSON.stringify(data, null, 2);
+    }
+    catch (error) {
+        try {
+            (0, api_client_1.handleAxiosError)(error);
+        }
+        catch (e) {
+            return e.message;
+        }
+        return 'Unexpected error linking AI cart to AI drawing session.';
+    }
+}
+async function upsertAiCanvasMetadata(input) {
+    try {
+        const { data } = await api_client_1.aiDrawingClient.put(`/sessions/${input.sessionId}/metadata/${input.canvasType}`, removeUndefined({
+            canvasType: input.canvasType,
+            canvasMeta: input.canvasMeta,
+            z0Reference: input.z0Reference,
+            verticalCalibration: input.verticalCalibration,
+            calibrationOffsets: input.calibrationOffsets,
+            elevationVisibility: input.elevationVisibility,
+            fixedElevationPositions: input.fixedElevationPositions,
+            elevationCalibrated: input.elevationCalibrated,
+            globalElevationOffsets: input.globalElevationOffsets,
+            calibratedCabinets: input.calibratedCabinets,
+            activeCanvases: input.activeCanvases,
+        }));
+        return JSON.stringify(data, null, 2);
+    }
+    catch (error) {
+        try {
+            (0, api_client_1.handleAxiosError)(error);
+        }
+        catch (e) {
+            return e.message;
+        }
+        return 'Unexpected error upserting AI canvas metadata.';
+    }
+}
+async function upsertAiCanvasImage(input) {
+    try {
+        const { data } = await api_client_1.aiDrawingClient.put(`/sessions/${input.sessionId}/images/${input.canvasType}/${input.imageType}`, {
+            canvasType: input.canvasType,
+            imageType: input.imageType,
+            s3Key: input.s3Key,
+        });
+        return JSON.stringify(data, null, 2);
+    }
+    catch (error) {
+        try {
+            (0, api_client_1.handleAxiosError)(error);
+        }
+        catch (e) {
+            return e.message;
+        }
+        return 'Unexpected error upserting AI canvas image.';
+    }
+}
+async function uploadAiCanvasImage(input) {
+    const extension = path.extname(input.imagePath).toLowerCase();
+    const mimeType = IMAGE_MIME_TYPES[extension];
+    if (!mimeType) {
+        return `Unsupported file extension "${extension}". Supported: .png, .jpg, .jpeg, .webp`;
+    }
+    if (!fs.existsSync(input.imagePath)) {
+        return `File not found at "${input.imagePath}"`;
+    }
+    const form = new form_data_1.default();
+    form.append('file', fs.createReadStream(input.imagePath), {
+        filename: path.basename(input.imagePath),
+        contentType: mimeType,
+    });
+    try {
+        const { data } = await api_client_1.aiDrawingClient.post(`/sessions/${input.sessionId}/images/${input.canvasType}/${input.imageType}/upload`, form, { headers: form.getHeaders() });
+        return JSON.stringify(data, null, 2);
+    }
+    catch (error) {
+        try {
+            (0, api_client_1.handleAxiosError)(error);
+        }
+        catch (e) {
+            return e.message;
+        }
+        return 'Unexpected error uploading AI canvas image.';
+    }
+}
+async function deleteAiCanvasImage(input) {
+    try {
+        const { data } = await api_client_1.aiDrawingClient.delete(`/sessions/${input.sessionId}/images/${input.canvasType}/${input.imageType}`);
+        return JSON.stringify(data, null, 2);
+    }
+    catch (error) {
+        try {
+            (0, api_client_1.handleAxiosError)(error);
+        }
+        catch (e) {
+            return e.message;
+        }
+        return 'Unexpected error deleting AI canvas image.';
+    }
+}
+async function getAiCanvasCabinetPlacements(input) {
+    try {
+        const { data } = await api_client_1.aiDrawingClient.get(`/sessions/${input.sessionId}/placements`);
+        return JSON.stringify(data, null, 2);
+    }
+    catch (error) {
+        try {
+            (0, api_client_1.handleAxiosError)(error);
+        }
+        catch (e) {
+            return e.message;
+        }
+        return 'Unexpected error fetching AI canvas cabinet placements.';
+    }
+}
+async function getAiCanvasCabinetPlacementsByCanvas(input) {
+    try {
+        const { data } = await api_client_1.aiDrawingClient.get(`/sessions/${input.sessionId}/placements/${input.canvasType}`);
+        return JSON.stringify(data, null, 2);
+    }
+    catch (error) {
+        try {
+            (0, api_client_1.handleAxiosError)(error);
+        }
+        catch (e) {
+            return e.message;
+        }
+        return 'Unexpected error fetching AI canvas cabinet placements by canvas.';
+    }
+}
+async function replaceAiCanvasCabinetPlacements(input) {
+    try {
+        const { data } = await api_client_1.aiDrawingClient.put(`/sessions/${input.sessionId}/placements/${input.canvasType}`, {
+            placements: input.placements.map(toBackendPlacementPayload),
+        });
+        return JSON.stringify(data, null, 2);
+    }
+    catch (error) {
+        try {
+            (0, api_client_1.handleAxiosError)(error);
+        }
+        catch (e) {
+            return e.message;
+        }
+        return 'Unexpected error replacing AI canvas cabinet placements.';
+    }
+}
+async function upsertAiCanvasCabinetPlacements(input) {
+    try {
+        const { data } = await api_client_1.aiDrawingClient.post(`/sessions/${input.sessionId}/placements/${input.canvasType}`, {
+            placements: input.placements.map(toBackendPlacementPayload),
+        });
+        return JSON.stringify(data, null, 2);
+    }
+    catch (error) {
+        try {
+            (0, api_client_1.handleAxiosError)(error);
+        }
+        catch (e) {
+            return e.message;
+        }
+        return 'Unexpected error upserting AI canvas cabinet placements.';
+    }
+}
+async function patchAiCanvasCabinetPlacements(input) {
+    try {
+        const { data } = await api_client_1.aiDrawingClient.patch(`/sessions/${input.sessionId}/placements/${input.canvasType}`, {
+            placements: input.placements.map(toBackendPlacementPatchPayload),
+        });
+        return JSON.stringify(data, null, 2);
+    }
+    catch (error) {
+        try {
+            (0, api_client_1.handleAxiosError)(error);
+        }
+        catch (e) {
+            return e.message;
+        }
+        return 'Unexpected error patching AI canvas cabinet placements.';
+    }
+}
+async function deleteAiCanvasCabinetPlacements(input) {
+    try {
+        const { data } = await api_client_1.aiDrawingClient.post(`/sessions/${input.sessionId}/placements/${input.canvasType}/delete`, {
+            positionNames: input.positionNames,
+        });
+        return JSON.stringify(data, null, 2);
+    }
+    catch (error) {
+        try {
+            (0, api_client_1.handleAxiosError)(error);
+        }
+        catch (e) {
+            return e.message;
+        }
+        return 'Unexpected error deleting AI canvas cabinet placements.';
+    }
+}
+async function replaceAiCabinetCoordinates(input) {
+    try {
+        const { data } = await api_client_1.aiDrawingClient.put(`/sessions/${input.sessionId}/coordinates`, {
+            coordinates: input.coordinates.map(toBackendCoordinatePayload),
+        });
+        return JSON.stringify(data, null, 2);
+    }
+    catch (error) {
+        try {
+            (0, api_client_1.handleAxiosError)(error);
+        }
+        catch (e) {
+            return e.message;
+        }
+        return 'Unexpected error replacing AI cabinet coordinates.';
+    }
+}
+async function patchAiCabinetCoordinates(input) {
+    try {
+        const { data } = await api_client_1.aiDrawingClient.patch(`/sessions/${input.sessionId}/coordinates`, {
+            coordinates: input.coordinates.map(toBackendCoordinatePatchPayload),
+        });
+        return JSON.stringify(data, null, 2);
+    }
+    catch (error) {
+        try {
+            (0, api_client_1.handleAxiosError)(error);
+        }
+        catch (e) {
+            return e.message;
+        }
+        return 'Unexpected error patching AI cabinet coordinates.';
+    }
+}
+async function deleteAiCabinetCoordinates(input) {
+    try {
+        const { data } = await api_client_1.aiDrawingClient.post(`/sessions/${input.sessionId}/coordinates/delete`, {
+            positionNames: input.positionNames,
+        });
+        return JSON.stringify(data, null, 2);
+    }
+    catch (error) {
+        try {
+            (0, api_client_1.handleAxiosError)(error);
+        }
+        catch (e) {
+            return e.message;
+        }
+        return 'Unexpected error deleting AI cabinet coordinates.';
+    }
+}
+async function createAiCart(input) {
+    const parsedInput = exports.AiCartCreateInputSchema.safeParse(input);
+    if (!parsedInput.success) {
+        return `Invalid input: ${parsedInput.error.message}`;
+    }
+    try {
+        const { orderConfigurationWorkflow, ...backendInput } = parsedInput.data;
+        const { data } = await api_client_1.aiDrawingClient.post('/carts', backendInput);
+        return JSON.stringify(data, null, 2);
+    }
+    catch (error) {
+        try {
+            (0, api_client_1.handleAxiosError)(error);
+        }
+        catch (e) {
+            return e.message;
+        }
+        return 'Unexpected error creating AI cart.';
+    }
+}
+async function getAiCart(input) {
+    try {
+        const { data } = await api_client_1.aiDrawingClient.get(`/carts/${input.cartId}`);
+        return JSON.stringify(data, null, 2);
+    }
+    catch (error) {
+        try {
+            (0, api_client_1.handleAxiosError)(error);
+        }
+        catch (e) {
+            return e.message;
+        }
+        return 'Unexpected error fetching AI cart.';
+    }
+}
+async function getAiCartBySession(input) {
+    try {
+        const { data } = await api_client_1.aiDrawingClient.get(`/carts/session/${input.sessionId}`);
+        return JSON.stringify(data, null, 2);
+    }
+    catch (error) {
+        try {
+            (0, api_client_1.handleAxiosError)(error);
+        }
+        catch (e) {
+            return e.message;
+        }
+        return 'Unexpected error fetching AI cart by session.';
+    }
+}
+async function syncAiCartSnapshot(input) {
+    const parsedInput = exports.AiCartSnapshotInputSchema.safeParse(input);
+    if (!parsedInput.success) {
+        return `Invalid input: ${parsedInput.error.message}`;
+    }
+    try {
+        const { data } = await api_client_1.aiDrawingClient.put(`/carts/${parsedInput.data.cartId}/snapshot`, {
+            sourceSnapshotPayload: parsedInput.data.sourceSnapshotPayload,
+            items: parsedInput.data.items.map(toBackendCartItemPayload),
+        });
+        return JSON.stringify(data, null, 2);
+    }
+    catch (error) {
+        try {
+            (0, api_client_1.handleAxiosError)(error);
+        }
+        catch (e) {
+            return e.message;
+        }
+        return 'Unexpected error syncing AI cart snapshot.';
+    }
+}
+async function patchAiCartItem(input) {
+    try {
+        const { data } = await api_client_1.aiDrawingClient.patch(`/carts/${input.cartId}/items/${input.itemId}`, toBackendCartItemPatchPayload(input.patch));
+        return JSON.stringify(data, null, 2);
+    }
+    catch (error) {
+        try {
+            (0, api_client_1.handleAxiosError)(error);
+        }
+        catch (e) {
+            return e.message;
+        }
+        return 'Unexpected error patching AI cart item.';
+    }
+}
+async function deleteAiCartItem(input) {
+    try {
+        const { data } = await api_client_1.aiDrawingClient.delete(`/carts/${input.cartId}/items/${input.itemId}`);
+        return JSON.stringify(data, null, 2);
+    }
+    catch (error) {
+        try {
+            (0, api_client_1.handleAxiosError)(error);
+        }
+        catch (e) {
+            return e.message;
+        }
+        return 'Unexpected error deleting AI cart item.';
+    }
+}
+async function duplicateAiCabinet(input) {
+    try {
+        const { data } = await api_client_1.aiDrawingClient.post(`/sessions/${input.sessionId}/cart-items/${input.itemId}/duplicate`, toBackendDuplicateCabinetPayload(input));
+        return JSON.stringify(data, null, 2);
+    }
+    catch (error) {
+        try {
+            (0, api_client_1.handleAxiosError)(error);
+        }
+        catch (e) {
+            return e.message;
+        }
+        return 'Unexpected error duplicating AI cabinet.';
+    }
+}
+async function configureAiCabinet(input) {
+    try {
+        const { data } = await api_client_1.aiDrawingClient.patch(`/sessions/${input.sessionId}/cart-items/${input.itemId}/configure`, toBackendConfigureCabinetPayload(input));
+        return JSON.stringify(data, null, 2);
+    }
+    catch (error) {
+        try {
+            (0, api_client_1.handleAxiosError)(error);
+        }
+        catch (e) {
+            return e.message;
+        }
+        return 'Unexpected error configuring AI cabinet.';
+    }
+}
+async function deleteAiCabinet(input) {
+    try {
+        const { data } = await api_client_1.aiDrawingClient.delete(`/sessions/${input.sessionId}/cart-items/${input.itemId}`);
+        return JSON.stringify(data, null, 2);
+    }
+    catch (error) {
+        try {
+            (0, api_client_1.handleAxiosError)(error);
+        }
+        catch (e) {
+            return e.message;
+        }
+        return 'Unexpected error deleting AI cabinet.';
+    }
+}
+async function getAiCartItemOrderReadyPayload(input) {
+    try {
+        const { data } = await api_client_1.aiDrawingClient.get(`/sessions/${input.sessionId}/cart-items/${input.itemId}/order-ready-payload`);
+        return JSON.stringify(data, null, 2);
+    }
+    catch (error) {
+        try {
+            (0, api_client_1.handleAxiosError)(error);
+        }
+        catch (e) {
+            return e.message;
+        }
+        return 'Unexpected error fetching AI cart item order-ready payload.';
+    }
+}
+async function setAiCartItemOrderReadyPayload(input) {
+    const validation = validateOrderReadyPayloadInput(input);
+    if (!validation.success) {
+        return validation.message;
+    }
+    try {
+        const { data } = await api_client_1.aiDrawingClient.put(`/sessions/${input.sessionId}/cart-items/${input.itemId}/order-ready-payload`, toBackendOrderReadyPayload(input));
+        return JSON.stringify(data, null, 2);
+    }
+    catch (error) {
+        try {
+            (0, api_client_1.handleAxiosError)(error);
+        }
+        catch (e) {
+            return e.message;
+        }
+        return 'Unexpected error setting AI cart item order-ready payload.';
+    }
+}
+async function clearAiCartItemOrderReadyPayload(input) {
+    try {
+        const { data } = await api_client_1.aiDrawingClient.delete(`/sessions/${input.sessionId}/cart-items/${input.itemId}/order-ready-payload`);
+        return JSON.stringify(data, null, 2);
+    }
+    catch (error) {
+        try {
+            (0, api_client_1.handleAxiosError)(error);
+        }
+        catch (e) {
+            return e.message;
+        }
+        return 'Unexpected error clearing AI cart item order-ready payload.';
+    }
+}
+async function importReduxCartItemsToAiCart(input) {
+    try {
+        const { data } = await api_client_1.aiDrawingClient.post(`/sessions/${input.sessionId}/cart-items/import-redux`, toBackendReduxCartImportPayload(input));
+        return JSON.stringify(data, null, 2);
+    }
+    catch (error) {
+        try {
+            (0, api_client_1.handleAxiosError)(error);
+        }
+        catch (e) {
+            return e.message;
+        }
+        return 'Unexpected error importing Redux cart items into AI cart.';
+    }
+}
+function synthesizeAiCartItemOriginalPayload(item) {
+    return removeUndefined({
+        frontendItemId: item.frontendItemId,
+        originalFrontendItemId: item.originalFrontendItemId,
+        serialNumber: item.serialNumber,
+        positionName: item.positionName,
+        originalPositionName: item.originalPositionName,
+        groupId: item.groupId,
+        quantity: item.quantity,
+        originalQuantity: item.originalQuantity,
+        width: item.width,
+        height: item.height,
+        depth: item.depth,
+        displayName: item.displayName,
+    });
+}
+function toOriginalItemPayloadJson(item) {
+    return JSON.stringify(removeUndefined({
+        ...synthesizeAiCartItemOriginalPayload(item),
+        ...(item.itemPayload ?? {}),
+        __aiDrawingClassificationEvidence: item.drawingClassificationEvidence,
+    }));
+}
+function toBackendCartItemPayload(item) {
+    return removeUndefined({
+        frontendItemId: item.frontendItemId,
+        originalFrontendItemId: item.originalFrontendItemId,
+        serialNumber: item.serialNumber,
+        positionName: item.positionName,
+        originalPositionName: item.originalPositionName,
+        groupId: item.groupId,
+        quantity: item.quantity,
+        originalQuantity: item.originalQuantity,
+        width: item.width,
+        height: item.height,
+        depth: item.depth,
+        displayName: item.displayName,
+        originalItemPayload: toOriginalItemPayloadJson(item),
+    });
+}
+function toBackendCartItemPatchPayload(patch) {
+    return removeUndefined({
+        frontendItemId: patch.frontendItemId,
+        originalFrontendItemId: patch.originalFrontendItemId,
+        serialNumber: patch.serialNumber,
+        positionName: patch.positionName,
+        originalPositionName: patch.originalPositionName,
+        groupId: patch.groupId,
+        quantity: patch.quantity,
+        originalQuantity: patch.originalQuantity,
+        width: patch.width,
+        height: patch.height,
+        depth: patch.depth,
+        displayName: patch.displayName,
+        originalItemPayload: patch.itemPayload === undefined ? undefined : JSON.stringify(patch.itemPayload),
+    });
+}
+function toBackendDuplicateCabinetPayload(input) {
+    return removeUndefined({
+        positionName: input.positionName,
+        selectedCanvasType: input.sourceCanvasType,
+        sourcePlacementPositionName: input.sourcePlacementPositionName,
+        placementOffsetX: input.placementOffsetX,
+        placementOffsetY: input.placementOffsetY,
+        source: input.source,
+    });
+}
+function toBackendConfigureCabinetPayload(input) {
+    return removeUndefined({
+        frontendItemId: input.frontendItemId,
+        originalFrontendItemId: input.originalFrontendItemId,
+        serialNumber: input.serialNumber,
+        positionName: input.positionName,
+        originalPositionName: input.originalPositionName,
+        groupId: input.groupId,
+        quantity: input.quantity,
+        originalQuantity: input.originalQuantity,
+        width: input.width,
+        height: input.height,
+        depth: input.depth,
+        displayName: input.displayName,
+        originalItemPayload: serializePayload(input.originalItemPayload),
+        source: input.source,
+    });
+}
+function validateOrderReadyPayloadInput(input) {
+    if (input.orderReadyStatus !== 'READY') {
+        return { success: true };
+    }
+    const result = orders_1.ArticleItemSchema.safeParse(input.orderReadyPayload);
+    if (result.success && hasOrderConfigurationEvidence(input.orderReadyPayload)) {
+        const baseCabinetHeightIssue = getBaseCabinetBodyHeightValidationMessage(input.orderReadyPayload, input.drawingClassificationEvidence);
+        if (baseCabinetHeightIssue) {
+            return {
+                success: false,
+                message: 'READY rejected: base/sink cabinet height evidence is required for drawing-derived order-ready payloads. ' +
+                    baseCabinetHeightIssue,
+            };
+        }
+        return { success: true };
+    }
+    const issueText = result.success
+        ? 'payload: order-critical material/configuration fields are missing'
+        : result.error.issues.map((issue) => `${issue.path.join('.') || 'payload'}: ${issue.message}`).join('; ');
+    return {
+        success: false,
+        message: 'READY rejected: orderReadyPayload must satisfy the MCP ArticleItemSchema/order-ready article contract. ' +
+            'serialNumber, positionName, width, height, and depth alone are not enough; use get_article_context, get_article_options, catalog lookup, saved settings where applicable, and exact user-confirmed configuration option strings before writing READY. ' +
+            issueText,
+    };
+}
+function toBackendOrderReadyPayload(input) {
+    return removeUndefined({
+        orderReadyPayload: input.orderReadyPayload,
+        orderReadyStatus: input.orderReadyStatus,
+        orderReadyMessages: input.orderReadyMessages,
+        orderReadySource: input.orderReadySource ?? 'MCP',
+    });
+}
+function toBackendReduxCartImportPayload(input) {
+    return {
+        items: input.items.map((item) => removeUndefined({
+            frontendItemId: item.frontendItemId,
+            originalFrontendItemId: item.originalFrontendItemId,
+            positionName: item.positionName,
+            originalPositionName: item.originalPositionName,
+            serialNumber: item.serialNumber,
+            displayName: item.displayName,
+            groupId: item.groupId,
+            quantity: item.quantity,
+            originalQuantity: item.originalQuantity,
+            width: item.width,
+            height: item.height,
+            depth: item.depth,
+            originalItemPayload: item.originalItemPayload,
+            orderReadyPayload: item.orderReadyPayload,
+            orderReadyStatus: item.orderReadyStatus,
+            orderReadyMessages: item.orderReadyMessages,
+            orderReadySource: item.orderReadySource,
+            orderReadyRevision: item.orderReadyRevision,
+            aiDrawingSessionId: item.aiDrawingSessionId,
+            aiCartId: item.aiCartId,
+            aiCartItemId: item.aiCartItemId,
+            aiMirrorStatus: item.aiMirrorStatus,
+            aiMirrorSource: item.aiMirrorSource,
+        })),
+    };
+}
+function hasCoreReduxPayloadFields(payload) {
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+        return false;
+    }
+    const record = payload;
+    return hasNonBlankValue(record.positionName) &&
+        hasNonBlankValue(record.serialNumber) &&
+        hasPositiveNumberValue(record.quantity) &&
+        hasPositiveNumberValue(record.width) &&
+        hasPositiveNumberValue(record.height) &&
+        hasPositiveNumberValue(record.depth);
+}
+function hasNonBlankValue(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+function hasPositiveNumberValue(value) {
+    if (typeof value === 'number') {
+        return Number.isFinite(value) && value > 0;
+    }
+    if (typeof value === 'string') {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) && parsed > 0;
+    }
+    return false;
+}
+function addBaseCabinetBodyHeightEvidenceIssues(orderReadyPayload, drawingClassificationEvidence, ctx) {
+    const message = getBaseCabinetBodyHeightValidationMessage(orderReadyPayload, drawingClassificationEvidence);
+    if (!message) {
+        return;
+    }
+    const path = message.startsWith('READY base/sink cabinet height')
+        ? ['orderReadyPayload', 'height']
+        : ['drawingClassificationEvidence', 'baseCabinetBodyHeightEvidence'];
+    ctx.addIssue({
+        code: zod_1.z.ZodIssueCode.custom,
+        path,
+        message,
+    });
+}
+function getBaseCabinetBodyHeightValidationMessage(orderReadyPayload, drawingClassificationEvidence) {
+    if (!isBaseOrSinkCabinetPayload(orderReadyPayload, drawingClassificationEvidence)) {
+        return null;
+    }
+    const evidenceRecord = isPlainRecord(drawingClassificationEvidence)
+        ? drawingClassificationEvidence
+        : undefined;
+    const bodyHeightEvidence = evidenceRecord?.baseCabinetBodyHeightEvidence;
+    const evidenceResult = BaseCabinetBodyHeightEvidenceSchema.safeParse(bodyHeightEvidence);
+    if (!evidenceResult.success) {
+        return 'READY base/sink cabinet payloads from drawing takeoff require baseCabinetBodyHeightEvidence documenting body height with countertop and toekick_plinth excluded.';
+    }
+    const payloadHeight = getPositiveNumberField(orderReadyPayload, 'height');
+    if (payloadHeight === null) {
+        return null;
+    }
+    const measuredBodyHeight = evidenceResult.data.cabinetBodyHeightInches;
+    if (Math.abs(payloadHeight - measuredBodyHeight) > 0.125) {
+        return `READY base/sink cabinet height (${payloadHeight}) must match baseCabinetBodyHeightEvidence.cabinetBodyHeightInches (${measuredBodyHeight}) within 1/8". ` +
+            'Do not include countertop or toekick/plinth height in the base cabinet height.';
+    }
+    return null;
+}
+function isBaseOrSinkCabinetPayload(orderReadyPayload, drawingClassificationEvidence) {
+    const payload = isPlainRecord(orderReadyPayload) ? orderReadyPayload : {};
+    const searchableValues = [
+        payload.serialNumber,
+        payload.positionName,
+        payload.displayName,
+        ...collectSemanticStrings(drawingClassificationEvidence),
+    ]
+        .filter((value) => (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean'))
+        .map((value) => String(value).toLowerCase());
+    return searchableValues.some((value) => (value === 'base' ||
+        value === 'base_cabinet' ||
+        value === 'sink_base' ||
+        value.includes('base cabinet') ||
+        value.includes('sink base') ||
+        value.includes('base_cabinet') ||
+        value.includes('sink_base') ||
+        /^bc[_-]/.test(value) ||
+        /^sb\d*/.test(value) ||
+        /^base([_\s.-]|$)/.test(value) ||
+        /(^|[^a-z])base([^a-z]|$)/.test(value)));
+}
+function getPositiveNumberField(value, fieldName) {
+    if (!isPlainRecord(value)) {
+        return null;
+    }
+    const fieldValue = value[fieldName];
+    if (typeof fieldValue === 'number') {
+        return Number.isFinite(fieldValue) && fieldValue > 0 ? fieldValue : null;
+    }
+    if (typeof fieldValue === 'string') {
+        const parsed = Number(fieldValue);
+        return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+    }
+    return null;
+}
+function collectSemanticStrings(value, depth = 0) {
+    if (value === null || value === undefined || depth > 4) {
+        return [];
+    }
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+        return [value];
+    }
+    if (Array.isArray(value)) {
+        return value.flatMap((item) => collectSemanticStrings(item, depth + 1));
+    }
+    if (isPlainRecord(value)) {
+        return Object.values(value).flatMap((item) => collectSemanticStrings(item, depth + 1));
+    }
+    return [];
+}
+function isPlainRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function hasOrderConfigurationEvidence(payload) {
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+        return false;
+    }
+    const record = payload;
+    const configurationKeys = [
+        'caseMaterial',
+        'frontMaterial',
+        'innerCaseMaterial',
+        'backPanelMaterial',
+        'caseEdge',
+        'frontEdge',
+        'edgeBandingType',
+        'drawerType',
+        'jointMethod',
+        'hingePlate',
+        'backPanel',
+        'numOfShelves',
+        'gapTop',
+        'gapBottom',
+        'gapLeft',
+        'gapRight',
+        'gapCenter',
+        'topDrwrHeightValue',
+        'leftCornerWidth',
+        'rightCornerDepth',
+        'excludeFronts',
+        'includeLegLevelers',
+        'settingsName',
+    ];
+    return configurationKeys.some((key) => {
+        const value = record[key];
+        if (typeof value === 'string') {
+            return value.trim().length > 0;
+        }
+        return value !== undefined && value !== null;
+    });
+}
+function serializePayload(payload) {
+    if (payload === undefined) {
+        return undefined;
+    }
+    return typeof payload === 'string' ? payload : JSON.stringify(payload);
+}
+function toBackendCoordinatePayload(coordinate) {
+    return removeUndefined({
+        positionName: coordinate.positionName,
+        aiCartItemId: coordinate.aiCartItemId,
+        x: coordinate.x,
+        y: coordinate.y,
+        z: coordinate.z,
+        rotation: coordinate.rotation,
+        source: coordinate.source,
+    });
+}
+function toBackendCoordinatePatchPayload(coordinate) {
+    return removeUndefined({
+        positionName: coordinate.positionName,
+        aiCartItemId: coordinate.aiCartItemId,
+        x: coordinate.x,
+        y: coordinate.y,
+        z: coordinate.z,
+        rotation: coordinate.rotation,
+        source: coordinate.source,
+    });
+}
+function toBackendPlacementPayload(placement) {
+    return removeUndefined({
+        aiCartItemId: placement.aiCartItemId,
+        positionName: placement.positionName,
+        centerX: placement.centerX,
+        centerY: placement.centerY,
+        width: placement.width,
+        height: placement.height,
+        rotation: placement.rotation,
+        placementSpace: placement.placementSpace,
+        basisImageWidthPx: placement.basisImageWidthPx,
+        basisImageHeightPx: placement.basisImageHeightPx,
+        source: placement.source,
+    });
+}
+function toBackendPlacementPatchPayload(placement) {
+    return removeUndefined({
+        aiCartItemId: placement.aiCartItemId,
+        positionName: placement.positionName,
+        centerX: placement.centerX,
+        centerY: placement.centerY,
+        width: placement.width,
+        height: placement.height,
+        rotation: placement.rotation,
+        placementSpace: placement.placementSpace,
+        basisImageWidthPx: placement.basisImageWidthPx,
+        basisImageHeightPx: placement.basisImageHeightPx,
+        source: placement.source,
+    });
+}
+function removeUndefined(payload) {
+    return Object.fromEntries(Object.entries(payload).filter(([, value]) => value !== undefined));
+}
+function formatUnknownError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+// ---------------------------------------------------------------------------
+// Exports
+// ---------------------------------------------------------------------------
+exports.aiDrawingTools = [
+    {
+        name: 'get_ai_drawing_state',
+        description: 'Retrieve the combined state for an isolated backend-owned AIDrawingTool session. ' +
+            'Returns session metadata, active AI cart data, canvas metadata, canvas images, cabinet coordinates, active canvases, and revisions. ' +
+            'This tool reads only the AI drawing session API and is separate from the existing frontend drawing tool canvas tools.',
+        inputSchema: GetAiDrawingStateSchema,
+        handler: getAiDrawingState,
+    },
+    {
+        name: 'render_ai_drawing_session_review',
+        description: 'Render per-canvas visual review PNGs from an existing backend-owned AIDrawingTool session. ' +
+            AI_DRAWING_VISUAL_REVIEW_GUIDANCE,
+        inputSchema: exports.AiDrawingSessionReviewRenderInputSchema,
+        handler: renderAiDrawingSessionReviewTool,
+    },
+    {
+        name: 'create_ai_drawing_session',
+        description: 'Create an isolated backend-owned AIDrawingTool session. ' +
+            AI_DRAWING_TOOL_BOUNDARY +
+            ' Owner fields are taken from backend authentication, not MCP input.',
+        inputSchema: exports.AiDrawingSessionCreateInputSchema,
+        handler: createAiDrawingSession,
+    },
+    {
+        name: 'link_ai_cart_to_drawing_session',
+        description: 'Link a backend-owned AI cart as the active cart for an isolated AIDrawingTool session. ' +
+            AI_DRAWING_TOOL_BOUNDARY,
+        inputSchema: exports.LinkAiCartToDrawingSessionInputSchema,
+        handler: linkAiCartToDrawingSession,
+    },
+    {
+        name: 'upsert_ai_canvas_metadata',
+        description: 'Create or update metadata for one backend-owned AIDrawingTool canvas. ' +
+            AI_CANVAS_CALIBRATION_GUIDANCE +
+            ' ' +
+            AI_DRAWING_VISUAL_REVIEW_COMPLETION_GUIDANCE +
+            ' ' +
+            AI_DRAWING_TOOL_BOUNDARY,
+        inputSchema: exports.AiCanvasMetadataInputSchema,
+        handler: upsertAiCanvasMetadata,
+    },
+    {
+        name: 'upsert_ai_canvas_image',
+        description: 'Create or update an existing public/S3 image reference for one backend-owned AIDrawingTool canvas. Do not use this for local filesystem paths; use upload_ai_canvas_image for local image files. ' +
+            AI_DRAWING_VISUAL_REVIEW_COMPLETION_GUIDANCE +
+            ' ' +
+            AI_DRAWING_TOOL_BOUNDARY,
+        inputSchema: exports.AiCanvasImageInputSchema,
+        handler: upsertAiCanvasImage,
+    },
+    {
+        name: 'upload_ai_canvas_image',
+        description: 'Upload a local image file into backend-owned AIDrawingTool S3 storage for one canvas, then store the returned AI-owned S3 key in AI drawing state. Use this when the image is a local file such as an overlay preview PNG. ' +
+            AI_DRAWING_VISUAL_REVIEW_COMPLETION_GUIDANCE +
+            ' ' +
+            AI_DRAWING_TOOL_BOUNDARY,
+        inputSchema: exports.AiCanvasImageUploadInputSchema,
+        handler: uploadAiCanvasImage,
+    },
+    {
+        name: 'delete_ai_canvas_image',
+        description: 'Delete one backend-owned AIDrawingTool canvas image reference. The backend deletes the S3 object only when the stored key is AI-owned under ai-drawings/{sessionId}/; arbitrary external image references are removed from AI state but not S3-deleted. ' +
+            AI_DRAWING_VISUAL_REVIEW_COMPLETION_GUIDANCE +
+            ' ' +
+            AI_DRAWING_TOOL_BOUNDARY,
+        inputSchema: exports.AiCanvasImageDeleteInputSchema,
+        handler: deleteAiCanvasImage,
+    },
+    {
+        name: 'get_ai_canvas_cabinet_placements',
+        description: 'Read all backend-owned AIDrawingTool per-canvas cabinet placements for one session. ' +
+            AI_CANVAS_PLACEMENT_GUIDANCE,
+        inputSchema: AiDrawingSessionIdParamSchema,
+        handler: getAiCanvasCabinetPlacements,
+    },
+    {
+        name: 'get_ai_canvas_cabinet_placements_by_canvas',
+        description: 'Read backend-owned AIDrawingTool cabinet placements for one specific canvas. ' +
+            AI_CANVAS_PLACEMENT_GUIDANCE,
+        inputSchema: exports.AiCanvasCabinetPlacementsByCanvasInputSchema,
+        handler: getAiCanvasCabinetPlacementsByCanvas,
+    },
+    {
+        name: 'replace_ai_canvas_cabinet_placements',
+        description: 'Replace backend-owned AIDrawingTool cabinet placements for exactly one canvas. This replacement must not delete or rewrite any other canvas. ' +
+            AI_CANVAS_PLACEMENT_GUIDANCE,
+        inputSchema: exports.AiCanvasCabinetPlacementsReplaceInputSchema,
+        handler: replaceAiCanvasCabinetPlacements,
+    },
+    {
+        name: 'upsert_ai_canvas_cabinet_placements',
+        description: 'Create or update backend-owned AIDrawingTool cabinet placements for exactly one canvas by positionName without deleting omitted placements. ' +
+            AI_CANVAS_PLACEMENT_GUIDANCE,
+        inputSchema: exports.AiCanvasCabinetPlacementsUpsertInputSchema,
+        handler: upsertAiCanvasCabinetPlacements,
+    },
+    {
+        name: 'patch_ai_canvas_cabinet_placements',
+        description: 'Patch backend-owned AIDrawingTool cabinet placements for exactly one canvas by positionName. ' +
+            AI_CANVAS_PLACEMENT_GUIDANCE,
+        inputSchema: exports.AiCanvasCabinetPlacementsPatchInputSchema,
+        handler: patchAiCanvasCabinetPlacements,
+    },
+    {
+        name: 'delete_ai_canvas_cabinet_placements',
+        description: 'Delete selected backend-owned AIDrawingTool cabinet placements from exactly one canvas by positionName. ' +
+            AI_CANVAS_PLACEMENT_GUIDANCE,
+        inputSchema: exports.AiCanvasCabinetPlacementsDeleteInputSchema,
+        handler: deleteAiCanvasCabinetPlacements,
+    },
+    {
+        name: 'replace_ai_cabinet_coordinates',
+        description: 'Replace all backend-owned AIDrawingTool cabinet coordinates for a session. ' +
+            AI_CANONICAL_PROJECTION_GUIDANCE +
+            ' ' +
+            AI_DRAWING_TOOL_BOUNDARY,
+        inputSchema: exports.AiCabinetCoordinatesReplaceInputSchema,
+        handler: replaceAiCabinetCoordinates,
+    },
+    {
+        name: 'patch_ai_cabinet_coordinates',
+        description: 'Patch backend-owned AIDrawingTool cabinet coordinates by positionName. ' +
+            AI_CANONICAL_PROJECTION_GUIDANCE +
+            ' ' +
+            AI_DRAWING_TOOL_BOUNDARY,
+        inputSchema: exports.AiCabinetCoordinatesPatchInputListSchema,
+        handler: patchAiCabinetCoordinates,
+    },
+    {
+        name: 'delete_ai_cabinet_coordinates',
+        description: 'Delete backend-owned AIDrawingTool cabinet coordinates by positionName. ' +
+            AI_CANONICAL_PROJECTION_GUIDANCE +
+            ' ' +
+            AI_DRAWING_TOOL_BOUNDARY,
+        inputSchema: exports.AiCabinetCoordinatesDeleteInputSchema,
+        handler: deleteAiCabinetCoordinates,
+    },
+    {
+        name: 'create_ai_cart',
+        description: 'Create a backend-owned AI cart for AIDrawingTool. ' +
+            AI_CART_TOOL_BOUNDARY +
+            ' ' +
+            AI_CART_ORDER_READY_CREATION_GUIDANCE +
+            ' This creates only the isolated AI cart, not a frontend cart or stored draft cart.',
+        inputSchema: exports.AiCartCreateInputSchema,
+        handler: createAiCart,
+    },
+    {
+        name: 'get_ai_cart',
+        description: 'Read one backend-owned AIDrawingTool AI cart by cart UUID. ' +
+            AI_CART_TOOL_BOUNDARY,
+        inputSchema: exports.AiCartIdParamSchema,
+        handler: getAiCart,
+    },
+    {
+        name: 'get_ai_cart_by_session',
+        description: 'Read the backend-owned AIDrawingTool AI cart linked to a session UUID. ' +
+            AI_CART_TOOL_BOUNDARY,
+        inputSchema: AiDrawingSessionIdParamSchema,
+        handler: getAiCartBySession,
+    },
+    {
+        name: 'sync_ai_cart_snapshot',
+        description: 'Store a full snapshot into a backend-owned AIDrawingTool AI cart. ' +
+            'Use this to persist the model-reviewed physical cabinet manifest after native vision has interpreted the drawings. orderConfigurationWorkflow is optional audit metadata; visual semantics are not certified by this schema. When the agent intends items to become READY/order-ready checkout payloads, it must still call get_article_context and get_article_options for each selected catalog serial, check get_my_saved_settings/get_saved_settings_presets when saved settings could satisfy preferences, and ask the user to choose exact configuration options or a saved setting before writing READY order-ready payloads. ' +
+            'Build this snapshot from one deduplicated physical cabinet manifest across all canvases; the plan is only a top-view placement of the same cabinets shown in the elevations. ' +
+            AI_REVIEW_TOKEN_GUIDANCE +
+            ' ' +
+            'First snapshot into an empty or new AI cart is allowed; the backend rejects silent replacement after AI or MCP edits. ' +
+            'Quantity greater than 1 expands in the backend into separate physical item instances. ' +
+            AI_CART_ORDER_READY_CREATION_GUIDANCE +
+            ' ' +
+            AI_CART_TOOL_BOUNDARY,
+        inputSchema: exports.AiCartSnapshotInputSchema,
+        handler: syncAiCartSnapshot,
+    },
+    {
+        name: 'patch_ai_cart_item',
+        description: 'Patch one backend-owned AIDrawingTool AI cart item by canonical backend aiCartItemId. ' +
+            'If positionName is patched, backend validation requires it to remain unique in the AI cart. ' +
+            'If the patch changes serialNumber, dimensions, displayName, or any order-relevant field, refresh that item with set_ai_cart_item_order_ready_payload or mark it NEEDS_AGENT_CONFIGURATION/BLOCKED. ' +
+            AI_DRAWING_VISUAL_REVIEW_COMPLETION_GUIDANCE +
+            ' ' +
+            AI_CART_TOOL_BOUNDARY,
+        inputSchema: PatchAiCartItemInputSchema,
+        handler: patchAiCartItem,
+    },
+    {
+        name: 'delete_ai_cart_item',
+        description: 'Delete one backend-owned AIDrawingTool AI cart item by canonical backend aiCartItemId. ' +
+            AI_DRAWING_VISUAL_REVIEW_COMPLETION_GUIDANCE +
+            ' ' +
+            AI_CART_TOOL_BOUNDARY,
+        inputSchema: exports.AiCartItemIdParamSchema,
+        handler: deleteAiCartItem,
+    },
+    {
+        name: 'duplicate_ai_cabinet',
+        description: 'Duplicate one backend-owned AIDrawingTool physical AI cabinet item. ' +
+            AI_CABINET_OPERATION_GUIDANCE,
+        inputSchema: exports.DuplicateAiCabinetInputSchema,
+        handler: duplicateAiCabinet,
+    },
+    {
+        name: 'configure_ai_cabinet',
+        description: 'Configure one backend-owned AIDrawingTool physical AI cabinet item and synchronize linked AI-only placement dimensions. ' +
+            AI_CABINET_OPERATION_GUIDANCE,
+        inputSchema: exports.ConfigureAiCabinetInputSchema,
+        handler: configureAiCabinet,
+    },
+    {
+        name: 'delete_ai_cabinet',
+        description: 'Delete one backend-owned AIDrawingTool physical AI cabinet item and linked AI-only placements. ' +
+            AI_CABINET_OPERATION_GUIDANCE,
+        inputSchema: exports.DeleteAiCabinetInputSchema,
+        handler: deleteAiCabinet,
+    },
+    {
+        name: 'get_ai_cart_item_order_ready_payload',
+        description: 'Read the AI-only order-ready article payload and validation status stored on one backend-owned AIDrawingTool AI cart item. ' +
+            AI_ORDER_READY_GUIDANCE,
+        inputSchema: exports.AiOrderReadyPayloadReadInputSchema,
+        handler: getAiCartItemOrderReadyPayload,
+    },
+    {
+        name: 'set_ai_cart_item_order_ready_payload',
+        description: 'Write the AI-only order-ready article payload and validation status for one backend-owned AIDrawingTool AI cart item. ' +
+            AI_ORDER_READY_GUIDANCE,
+        inputSchema: exports.AiOrderReadyPayloadSetInputSchema,
+        handler: setAiCartItemOrderReadyPayload,
+    },
+    {
+        name: 'clear_ai_cart_item_order_ready_payload',
+        description: 'Clear the AI-only order-ready article payload and reset validation status for one backend-owned AIDrawingTool AI cart item. ' +
+            AI_ORDER_READY_GUIDANCE,
+        inputSchema: exports.AiOrderReadyPayloadClearInputSchema,
+        handler: clearAiCartItemOrderReadyPayload,
+    },
+    {
+        name: 'import_redux_cart_items_to_ai_cart',
+        description: 'Import rich browser Redux checkout cart items into the active backend-owned AIDrawingTool AI cart without a Seed AI Cart button. ' +
+            AI_REDUX_IMPORT_GUIDANCE,
+        inputSchema: exports.AiReduxCartImportInputSchema,
+        handler: importReduxCartItemsToAiCart,
+    },
+];