@sealab/mcp-server 1.0.3 → 1.0.4

package/src/tools/ai-drawing.test.ts

@@ -34,6 +34,8 @@ import {
   AiCanvasCabinetPlacementsPatchInputSchema,
   AiCanvasCabinetPlacementsReplaceInputSchema,
   AiCanvasCabinetPlacementsUpsertInputSchema,
+  ProjectAiCanvasCabinetPlacementsInputSchema,
+  ProjectAiCanvasElevationRunInputSchema,
   AiCartIdParamSchema,
   AiCartCreateInputSchema,
   AiCartItemIdParamSchema,
@@ -72,6 +74,8 @@ import {
   upsertAiCanvasCabinetPlacements,
   patchAiCanvasCabinetPlacements,
   deleteAiCanvasCabinetPlacements,
+  projectAiCanvasCabinetPlacements,
+  projectAiCanvasElevationRun,
   replaceAiCabinetCoordinates,
   patchAiCabinetCoordinates,
   deleteAiCabinetCoordinates,
@@ -135,26 +139,26 @@ describe('renderAiDrawingSessionReviewTool', () => {
     vi.mocked(rendererModule.renderAiDrawingSessionReview).mockReturnValue({
       sessionId,
       generatedAt: '2026-05-07T00:00:00.000Z',
-      visualInspectionRequired: true,
-      visualReviewStatus: 'requires_native_vision',
-      completionBlockedUntil: 'Open every full-canvas outputImagePath with native vision, record PASS/FAIL/UNCERTAIN per canvas and placement, patch failures, and rerender.',
-      visualInspectionChecklist: [
-        'Open every full-canvas overlay with native vision.',
-        'Separate cabinet boxes must not overlap each other.',
-        'Do not include appliances, fixtures, counters, toe kicks, walls, dimension strings, labels, or blank/context areas.',
-      ],
+      visualInspectionRequired: true,
+      visualReviewStatus: 'requires_native_vision',
+      completionBlockedUntil: 'Open every full-canvas outputImagePath with native vision, record PASS/FAIL/UNCERTAIN per canvas and placement, patch failures, and rerender.',
+      visualInspectionChecklist: [
+        'Open every full-canvas overlay with native vision.',
+        'Separate cabinet boxes must not overlap each other.',
+        'Do not include appliances, fixtures, counters, toe kicks, walls, dimension strings, labels, or blank/context areas.',
+      ],
       manifestPath: 'D:\\review\\manifest.json',
       canvases: [
         {
           canvasType: 'plan',
           outputImagePath: 'D:\\review\\plan.png',
-          imageWidth: 100,
-          imageHeight: 80,
-          renderedPlacementCount: 1,
-          sourceBoundaryReviewTasks: [],
-          issues: [],
-        },
-      ],
+          imageWidth: 100,
+          imageHeight: 80,
+          renderedPlacementCount: 1,
+          sourceBoundaryReviewTasks: [],
+          issues: [],
+        },
+      ],
       issues: [],
     });
 
@@ -178,30 +182,30 @@ describe('renderAiDrawingSessionReviewTool', () => {
       manifestPath: 'D:\\review\\manifest.json',
       aggregateIssueCount: 0,
       visualReviewRequired: true,
-      visualReviewStatus: 'requires_native_vision',
-      completionBlockedUntil: expect.stringContaining('PASS/FAIL/UNCERTAIN'),
-      machineValidationScope: expect.stringContaining('aggregateIssueCount 0 is not visual approval'),
-      completionPolicy: expect.stringContaining('source_boundary_review_required'),
-      visualQaChecklist: expect.arrayContaining([
-        expect.stringContaining('Separate cabinet boxes must not overlap each other'),
-        expect.stringContaining('Do not include appliances, fixtures, counters, toe kicks, walls, dimension strings, labels, or blank/context areas'),
+      visualReviewStatus: 'requires_native_vision',
+      completionBlockedUntil: expect.stringContaining('PASS/FAIL/UNCERTAIN'),
+      machineValidationScope: expect.stringContaining('aggregateIssueCount 0 is not visual approval'),
+      completionPolicy: expect.stringContaining('source_boundary_review_required'),
+      visualQaChecklist: expect.arrayContaining([
+        expect.stringContaining('Separate cabinet boxes must not overlap each other'),
+        expect.stringContaining('Do not include appliances, fixtures, counters, toe kicks, walls, dimension strings, labels, or blank/context areas'),
       ]),
       reviewImages: [
         {
           canvasType: 'plan',
-          outputImagePath: 'D:\\review\\plan.png',
-          imageWidth: 100,
-          imageHeight: 80,
-          renderedPlacementCount: 1,
-          sourceBoundaryReviewTaskCount: 0,
-          issueCount: 0,
-        },
-      ],
-      sourceBoundaryReviewTasks: [],
-    });
-    expect(parsed).not.toHaveProperty('placementReviewCrops');
-    expect(parsed.canvases[0]).not.toHaveProperty('placementReviewCrops');
-    expect(parsed.canvases[0].sourceBoundaryReviewTasks).toEqual([]);
+          outputImagePath: 'D:\\review\\plan.png',
+          imageWidth: 100,
+          imageHeight: 80,
+          renderedPlacementCount: 1,
+          sourceBoundaryReviewTaskCount: 0,
+          issueCount: 0,
+        },
+      ],
+      sourceBoundaryReviewTasks: [],
+    });
+    expect(parsed).not.toHaveProperty('placementReviewCrops');
+    expect(parsed.canvases[0]).not.toHaveProperty('placementReviewCrops');
+    expect(parsed.canvases[0].sourceBoundaryReviewTasks).toEqual([]);
   });
 
   it('materializes uploaded session s3Key backgrounds before rendering', async () => {
@@ -339,6 +343,8 @@ describe('aiDrawingTools', () => {
       'upsert_ai_canvas_cabinet_placements',
       'patch_ai_canvas_cabinet_placements',
       'delete_ai_canvas_cabinet_placements',
+      'project_ai_canvas_cabinet_placements',
+      'project_ai_canvas_elevation_run',
       'replace_ai_cabinet_coordinates',
       'patch_ai_cabinet_coordinates',
       'delete_ai_cabinet_coordinates',
@@ -432,12 +438,12 @@ describe('aiDrawingTools', () => {
   it('describes the review renderer workflow as render, vision inspect, correct, and rerender', () => {
     const tool = aiDrawingTools.find((candidate) => candidate.name === 'render_ai_drawing_session_review');
 
-    expect(tool?.description).toContain('after writing or updating AI cart items and per-canvas placements');
-    expect(tool?.description).toContain('open every returned full-canvas PNG path with native vision');
-    expect(tool?.description).toContain('complete every returned sourceBoundaryReviewTasks[] item against the actual source drawing pixels');
-    expect(tool?.description).toContain('no per-placement crop artifacts are generated');
+    expect(tool?.description).toContain('after writing or updating AI cart items and per-canvas placements');
+    expect(tool?.description).toContain('open every returned full-canvas PNG path with native vision');
+    expect(tool?.description).toContain('complete every returned sourceBoundaryReviewTasks[] item against the actual source drawing pixels');
+    expect(tool?.description).toContain('no per-placement crop artifacts are generated');
     expect(tool?.description).toContain('apply the visual QA checklist');
-    expect(tool?.description).toContain('Correct bad placements through the existing AI-only placement tools');
+    expect(tool?.description).toContain('Correct bad placements through the existing AI-only placement tools');
     expect(tool?.description).toContain('render again/rerender');
     expect(tool?.description).toContain('JSON validity');
     expect(tool?.description).toContain('not visual correctness');
@@ -461,8 +467,8 @@ describe('aiDrawingTools', () => {
   it('describes concrete visual QA failure modes for rendered placement review', () => {
     const tool = aiDrawingTools.find((candidate) => candidate.name === 'render_ai_drawing_session_review');
 
-    expect(tool?.description).toContain('compare each rectangle against the visible drawing');
-    expect(tool?.description).toContain('source drawing pixels are the authority');
+    expect(tool?.description).toContain('compare each rectangle against the visible drawing');
+    expect(tool?.description).toContain('source drawing pixels are the authority');
     expect(tool?.description).toContain('inside the actual cabinet face or plan footprint boundaries');
     expect(tool?.description).toContain('overlap other cabinets, appliances, fixtures, counters, toe kicks, walls, dimension strings, or blank/context areas');
     expect(tool?.description).toContain('shifted boxes that extend beyond wood/front boundaries');
@@ -879,6 +885,420 @@ describe('AI drawing operation tool handlers', () => {
     expect(result).toContain('BASE_01');
   });
 
+  it('project_ai_canvas_cabinet_placements computes elevation rectangles from calibration and upserts them', async () => {
+    vi.mocked(apiClientModule.aiDrawingClient.post).mockResolvedValue({
+      data: { canvasType: 'north', placements: [{ positionName: 'BASE_01' }] },
+    });
+
+    const result = await projectAiCanvasCabinetPlacements({
+      sessionId,
+      canvasType: 'north',
+      elevationCalibration: {
+        canvasType: 'north',
+        imageSizePx: { width: 1000, height: 600 },
+        horizontalPixelsPerInch: 5,
+        verticalPixelsPerInch: 5,
+        floorZ0Px: 550,
+        horizontalOriginPx: { x: 100, y: 550 },
+        horizontalOriginCoordinateInches: 0,
+        horizontalAxisPositiveDirection: 'right',
+        verticalAxisPositiveDirection: 'up',
+      },
+      placements: [
+        { positionName: 'BASE_01', horizontalStartInches: 12, widthInches: 36, heightInches: 30, bottomFromFloorInches: 0 },
+      ],
+      writeMode: 'upsert',
+      crossCheckCartItems: false,
+      source: 'MCP',
+    });
+
+    expect(apiClientModule.aiDrawingClient.post).toHaveBeenCalledWith(`/sessions/${sessionId}/placements/north`, {
+      placements: [
+        {
+          positionName: 'BASE_01',
+          centerX: 250,
+          centerY: 475,
+          width: 180,
+          height: 150,
+          rotation: 0,
+          placementSpace: 'IMAGE_PIXELS',
+          basisImageWidthPx: 1000,
+          basisImageHeightPx: 600,
+          source: 'MCP',
+        },
+      ],
+    });
+    expect(result).toContain('"wrote": true');
+  });
+
+  it('project_ai_canvas_cabinet_placements return_only does a dry run without writing', async () => {
+    const result = await projectAiCanvasCabinetPlacements({
+      sessionId,
+      canvasType: 'north',
+      elevationCalibration: {
+        canvasType: 'north',
+        imageSizePx: { width: 1000, height: 600 },
+        horizontalPixelsPerInch: 5,
+        verticalPixelsPerInch: 5,
+        floorZ0Px: 550,
+        horizontalOriginPx: { x: 100, y: 550 },
+        horizontalOriginCoordinateInches: 0,
+        horizontalAxisPositiveDirection: 'right',
+        verticalAxisPositiveDirection: 'up',
+      },
+      placements: [
+        { positionName: 'BASE_01', horizontalStartInches: 12, widthInches: 36, heightInches: 30, bottomFromFloorInches: 0 },
+      ],
+      writeMode: 'return_only',
+      crossCheckCartItems: false,
+    });
+
+    expect(apiClientModule.aiDrawingClient.post).not.toHaveBeenCalled();
+    expect(apiClientModule.aiDrawingClient.put).not.toHaveBeenCalled();
+    expect(result).toContain('"wrote": false');
+  });
+
+  it('project_ai_canvas_cabinet_placements reports out-of-bounds rectangles as warnings', async () => {
+    const result = await projectAiCanvasCabinetPlacements({
+      sessionId,
+      canvasType: 'north',
+      elevationCalibration: {
+        canvasType: 'north',
+        imageSizePx: { width: 200, height: 200 },
+        horizontalPixelsPerInch: 5,
+        verticalPixelsPerInch: 5,
+        floorZ0Px: 190,
+        horizontalOriginPx: { x: 100, y: 190 },
+        horizontalOriginCoordinateInches: 0,
+        horizontalAxisPositiveDirection: 'right',
+        verticalAxisPositiveDirection: 'up',
+      },
+      // 60" wide cabinet at 5 ppi = 300px, far wider than the 200px image.
+      placements: [
+        { positionName: 'BASE_01', horizontalStartInches: 0, widthInches: 60, heightInches: 30 },
+      ],
+      writeMode: 'return_only',
+      crossCheckCartItems: false,
+    });
+
+    expect(result).toContain('outOfBoundsWarnings');
+    expect(result).toContain('extends outside');
+  });
+
+  it('project schema requires elevationCalibration for an elevation canvas', () => {
+    const parsed = ProjectAiCanvasCabinetPlacementsInputSchema.safeParse({
+      sessionId,
+      canvasType: 'north',
+      placements: [
+        { positionName: 'BASE_01', horizontalStartInches: 0, widthInches: 36, heightInches: 30 },
+      ],
+    });
+    expect(parsed.success).toBe(false);
+  });
+
+  it('project schema requires plan fields for a plan canvas', () => {
+    const parsed = ProjectAiCanvasCabinetPlacementsInputSchema.safeParse({
+      sessionId,
+      canvasType: 'plan',
+      planCalibration: {
+        canvasType: 'plan',
+        imageSizePx: { width: 800, height: 800 },
+        pixelsPerInch: 2,
+        roomOriginPx: { x: 50, y: 750 },
+        xPositiveDirection: 'right',
+        yPositiveDirection: 'up',
+      },
+      // Missing centerXInches/centerYInches/depthInches.
+      placements: [{ positionName: 'BASE_01', widthInches: 30 }],
+    });
+    expect(parsed.success).toBe(false);
+  });
+
+  it('project_ai_canvas_cabinet_placements wall-anchored plan pins the back edge to the wall face', async () => {
+    const result = await projectAiCanvasCabinetPlacements({
+      sessionId,
+      canvasType: 'plan',
+      planCalibration: {
+        canvasType: 'plan',
+        imageSizePx: { width: 800, height: 800 },
+        pixelsPerInch: 2,
+        roomOriginPx: { x: 50, y: 750 },
+        xPositiveDirection: 'right',
+        yPositiveDirection: 'up',
+      },
+      placements: [
+        {
+          positionName: 'WALL1',
+          widthInches: 36,
+          depthInches: 24,
+          wallBackEdgeInches: 120,
+          depthAxis: 'y',
+          depthDirection: 'negative',
+          alongWallStartInches: 30,
+        },
+      ],
+      writeMode: 'return_only',
+      crossCheckCartItems: false,
+    });
+
+    const parsed = JSON.parse(result);
+    const box = parsed.projectedPlacements[0];
+    // Back edge (room y=120) -> pixel y = 750 - 240 = 510; box top edge must equal it.
+    expect(box.centerY - box.height / 2).toBe(510);
+    expect(box.width).toBe(72); // 36" along wall * 2
+    expect(box.height).toBe(48); // 24" depth * 2
+  });
+
+  it('project schema rejects mixing wall-anchored and center plan fields', () => {
+    const parsed = ProjectAiCanvasCabinetPlacementsInputSchema.safeParse({
+      sessionId,
+      canvasType: 'plan',
+      planCalibration: {
+        canvasType: 'plan',
+        imageSizePx: { width: 800, height: 800 },
+        pixelsPerInch: 2,
+        roomOriginPx: { x: 50, y: 750 },
+        xPositiveDirection: 'right',
+        yPositiveDirection: 'up',
+      },
+      placements: [
+        {
+          positionName: 'WALL1',
+          widthInches: 36,
+          depthInches: 24,
+          wallBackEdgeInches: 120,
+          depthAxis: 'y',
+          depthDirection: 'negative',
+          alongWallStartInches: 30,
+          centerXInches: 48, // conflict
+        },
+      ],
+    });
+    expect(parsed.success).toBe(false);
+  });
+
+  it('project_ai_canvas_elevation_run splits a run into one placement per cabinet', async () => {
+    vi.mocked(apiClientModule.aiDrawingClient.post).mockResolvedValue({
+      data: { canvasType: 'north', placements: [] },
+    });
+
+    const result = await projectAiCanvasElevationRun({
+      sessionId,
+      canvasType: 'north',
+      elevationCalibration: {
+        canvasType: 'north',
+        imageSizePx: { width: 2000, height: 1000 },
+        horizontalPixelsPerInch: 5,
+        verticalPixelsPerInch: 5,
+        floorZ0Px: 900,
+        horizontalOriginPx: { x: 100, y: 900 },
+        horizontalOriginCoordinateInches: 0,
+        horizontalAxisPositiveDirection: 'right',
+        verticalAxisPositiveDirection: 'up',
+      },
+      runs: [
+        {
+          runStartInches: 0,
+          expectedRunTotalInches: 36,
+          declaredSubdivisionCount: 2,
+          modules: [
+            { positionName: 'U2A', widthInches: 18, heightInches: 42, bottomFromFloorInches: 54, frontType: 'double_door' },
+            { positionName: 'U2B', widthInches: 18, heightInches: 42, bottomFromFloorInches: 54, frontType: 'double_door' },
+          ],
+        },
+      ],
+      writeMode: 'upsert',
+      crossCheckCartItems: false,
+      source: 'MCP',
+    });
+
+    const [, body] = vi.mocked(apiClientModule.aiDrawingClient.post).mock.calls[0];
+    expect(body.placements).toHaveLength(2);
+    expect(body.placements[0].positionName).toBe('U2A');
+    expect(body.placements[1].positionName).toBe('U2B');
+    // Two distinct boxes, side by side, not one lumped box.
+    expect(body.placements[0].centerX).not.toBe(body.placements[1].centerX);
+    expect(result).toContain('"moduleCount": 2');
+  });
+
+  it('project_ai_canvas_elevation_run warns when a lumped run looks like multiple cabinets', async () => {
+    const result = await projectAiCanvasElevationRun({
+      sessionId,
+      canvasType: 'north',
+      elevationCalibration: {
+        canvasType: 'north',
+        imageSizePx: { width: 2000, height: 1000 },
+        horizontalPixelsPerInch: 5,
+        verticalPixelsPerInch: 5,
+        floorZ0Px: 900,
+        horizontalOriginPx: { x: 100, y: 900 },
+        horizontalOriginCoordinateInches: 0,
+        horizontalAxisPositiveDirection: 'right',
+        verticalAxisPositiveDirection: 'up',
+      },
+      runs: [
+        {
+          runStartInches: 0,
+          expectedRunTotalInches: 36,
+          declaredSubdivisionCount: 2,
+          maxSingleCabinetWidthInches: 24,
+          modules: [
+            { positionName: 'U2A', widthInches: 36, heightInches: 42, bottomFromFloorInches: 54, frontType: 'double_door' },
+          ],
+        },
+      ],
+      writeMode: 'return_only',
+      crossCheckCartItems: false,
+    });
+
+    expect(result).toContain('segmentationWarnings');
+    expect(result).toContain('single-cabinet threshold');
+    expect(result).toContain('equal subdivisions');
+  });
+
+  it('project_ai_canvas_elevation_run rejects duplicate positionName across runs on one canvas', () => {
+    const parsed = ProjectAiCanvasElevationRunInputSchema.safeParse({
+      sessionId,
+      canvasType: 'north',
+      elevationCalibration: {
+        canvasType: 'north',
+        imageSizePx: { width: 2000, height: 1000 },
+        horizontalPixelsPerInch: 5,
+        verticalPixelsPerInch: 5,
+        floorZ0Px: 900,
+        horizontalOriginPx: { x: 100, y: 900 },
+        horizontalOriginCoordinateInches: 0,
+        horizontalAxisPositiveDirection: 'right',
+      },
+      runs: [
+        { runStartInches: 0, modules: [{ positionName: 'DUP', widthInches: 18, heightInches: 42, frontType: 'double_door' }] },
+        { runStartInches: 40, modules: [{ positionName: 'DUP', widthInches: 18, heightInches: 42, frontType: 'double_door' }] },
+      ],
+    });
+    expect(parsed.success).toBe(false);
+  });
+
+  it('project_ai_canvas_elevation_run blocks the write when a box is wider than its real cart item', async () => {
+    // Manifest has two 18" cabinets; agent tries to place one 36" box for U2A.
+    vi.mocked(apiClientModule.aiDrawingClient.get).mockResolvedValue({
+      data: { activeCart: { items: [
+        { id: 'a1', positionName: 'U2A', width: 18, height: 42 },
+        { id: 'a2', positionName: 'U2B', width: 18, height: 42 },
+      ] } },
+    });
+
+    const result = await projectAiCanvasElevationRun({
+      sessionId,
+      canvasType: 'north',
+      elevationCalibration: {
+        canvasType: 'north',
+        imageSizePx: { width: 2000, height: 1000 },
+        horizontalPixelsPerInch: 5,
+        verticalPixelsPerInch: 5,
+        floorZ0Px: 900,
+        horizontalOriginPx: { x: 100, y: 900 },
+        horizontalOriginCoordinateInches: 0,
+        horizontalAxisPositiveDirection: 'right',
+        verticalAxisPositiveDirection: 'up',
+      },
+      runs: [
+        {
+          runStartInches: 0,
+          modules: [
+            { positionName: 'U2A', widthInches: 36, heightInches: 42, bottomFromFloorInches: 54, frontType: 'double_door' },
+          ],
+        },
+      ],
+      writeMode: 'upsert',
+      crossCheckCartItems: true,
+    });
+
+    expect(apiClientModule.aiDrawingClient.post).not.toHaveBeenCalled();
+    expect(result).toContain('"crossCheckBlocked": true');
+    expect(result).toContain('width_mismatch');
+  });
+
+  it('project_ai_canvas_elevation_run writes when modules match real cart items', async () => {
+    vi.mocked(apiClientModule.aiDrawingClient.get).mockResolvedValue({
+      data: { activeCart: { items: [
+        { id: 'a1', positionName: 'U2A', width: 18, height: 42 },
+        { id: 'a2', positionName: 'U2B', width: 18, height: 42 },
+      ] } },
+    });
+    vi.mocked(apiClientModule.aiDrawingClient.post).mockResolvedValue({ data: { canvasType: 'north', placements: [] } });
+
+    const result = await projectAiCanvasElevationRun({
+      sessionId,
+      canvasType: 'north',
+      elevationCalibration: {
+        canvasType: 'north',
+        imageSizePx: { width: 2000, height: 1000 },
+        horizontalPixelsPerInch: 5,
+        verticalPixelsPerInch: 5,
+        floorZ0Px: 900,
+        horizontalOriginPx: { x: 100, y: 900 },
+        horizontalOriginCoordinateInches: 0,
+        horizontalAxisPositiveDirection: 'right',
+        verticalAxisPositiveDirection: 'up',
+      },
+      runs: [
+        {
+          runStartInches: 0,
+          modules: [
+            { positionName: 'U2A', widthInches: 18, heightInches: 42, bottomFromFloorInches: 54, frontType: 'double_door' },
+            { positionName: 'U2B', widthInches: 18, heightInches: 42, bottomFromFloorInches: 54, frontType: 'double_door' },
+          ],
+        },
+      ],
+      writeMode: 'upsert',
+      crossCheckCartItems: true,
+    });
+
+    expect(apiClientModule.aiDrawingClient.post).toHaveBeenCalledTimes(1);
+    expect(result).toContain('"wrote": true');
+    expect(result).toContain('"matchedCartItemCount": 2');
+  });
+
+  it('project_ai_canvas_cabinet_placements fails closed when the active cart cannot be read', async () => {
+    vi.mocked(apiClientModule.aiDrawingClient.get).mockResolvedValue({ data: {} });
+
+    const result = await projectAiCanvasCabinetPlacements({
+      sessionId,
+      canvasType: 'north',
+      elevationCalibration: {
+        canvasType: 'north',
+        imageSizePx: { width: 1000, height: 600 },
+        horizontalPixelsPerInch: 5,
+        verticalPixelsPerInch: 5,
+        floorZ0Px: 550,
+        horizontalOriginPx: { x: 100, y: 550 },
+        horizontalOriginCoordinateInches: 0,
+        horizontalAxisPositiveDirection: 'right',
+        verticalAxisPositiveDirection: 'up',
+      },
+      placements: [
+        { positionName: 'BASE_01', horizontalStartInches: 12, widthInches: 36, heightInches: 30 },
+      ],
+      writeMode: 'upsert',
+      crossCheckCartItems: true,
+    });
+
+    expect(apiClientModule.aiDrawingClient.post).not.toHaveBeenCalled();
+    expect(result).toContain('Could not read an active AI cart');
+  });
+
+  it('placement writes reject duplicate positionName on one canvas', () => {
+    const parsed = AiCanvasCabinetPlacementsUpsertInputSchema.safeParse({
+      sessionId,
+      canvasType: 'north',
+      placements: [
+        { positionName: 'BASE_01', centerX: 10, centerY: 10, width: 5, height: 5 },
+        { positionName: 'BASE_01', centerX: 20, centerY: 20, width: 5, height: 5 },
+      ],
+    });
+    expect(parsed.success).toBe(false);
+  });
+
   it('duplicate_ai_cabinet posts to the session cabinet duplicate endpoint with selected placement copy fields', async () => {
     vi.mocked(apiClientModule.aiDrawingClient.post).mockResolvedValue({
       data: { duplicateItem: { id: itemId, positionName: 'BASE_01_copy' } },
@@ -3018,8 +3438,8 @@ function validElevationProjectionCalibration(canvasType: 'north' | 'south' | 'ea
 function expectDescriptionRequiresVisualReview(toolName: string): void {
   const tool = aiDrawingTools.find((candidate) => candidate.name === toolName);
 
-  expect(tool?.description).toContain('render_ai_drawing_session_review');
-  expect(tool?.description).toContain('inspect every returned full-canvas PNG with native vision');
+  expect(tool?.description).toContain('render_ai_drawing_session_review');
+  expect(tool?.description).toContain('inspect every returned full-canvas PNG with native vision');
   expect(tool?.description).toContain('correct wrong placements with existing AI-only placement tools');
   expect(tool?.description).toContain('rerender');
   expect(tool?.description).toContain('PASS/FAIL/UNCERTAIN');