@sealab/mcp-server 1.0.2 → 1.0.4

package/src/tools/cart-cross-check.test.ts

@@ -0,0 +1,84 @@
+import { describe, expect, it } from 'vitest';
+import { crossCheckPlacementsAgainstCart, type CartItemLike } from './cart-cross-check';
+
+const cartItems: CartItemLike[] = [
+  { id: 'a1', positionName: 'U2A', serialNumber: 'WC_DD_1842', width: 18, height: 42, depth: 12 },
+  { id: 'a2', positionName: 'U2B', serialNumber: 'WC_DD_1842', width: 18, height: 42, depth: 12 },
+];
+
+describe('crossCheckPlacementsAgainstCart', () => {
+  it('passes when each placement matches a real item with matching width/height', () => {
+    const result = crossCheckPlacementsAgainstCart(
+      [
+        { positionName: 'U2A', widthInches: 18, heightInches: 42 },
+        { positionName: 'U2B', widthInches: 18, heightInches: 42 },
+      ],
+      cartItems
+    );
+    expect(result.blocking).toHaveLength(0);
+    expect(result.matchedCount).toBe(2);
+  });
+
+  it('blocks a placement that references no cart item', () => {
+    const result = crossCheckPlacementsAgainstCart(
+      [{ positionName: 'GHOST', widthInches: 18, heightInches: 42 }],
+      cartItems
+    );
+    expect(result.blocking.some((b) => b.code === 'no_matching_cart_item')).toBe(true);
+  });
+
+  it('blocks a box stretched wider than its real cabinet (lumped run)', () => {
+    const result = crossCheckPlacementsAgainstCart(
+      // Trying to cover a 36" run with the single 18" U2A item.
+      [{ positionName: 'U2A', widthInches: 36, heightInches: 42 }],
+      cartItems
+    );
+    expect(result.blocking.some((b) => b.code === 'width_mismatch')).toBe(true);
+  });
+
+  it('blocks two placements that resolve to the same cart item', () => {
+    const result = crossCheckPlacementsAgainstCart(
+      [
+        { positionName: 'U2A', aiCartItemId: 'a1', widthInches: 18, heightInches: 42 },
+        { positionName: 'U2A_dup', aiCartItemId: 'a1', widthInches: 18, heightInches: 42 },
+      ],
+      cartItems
+    );
+    expect(result.blocking.some((b) => b.code === 'duplicate_cart_item_reference')).toBe(true);
+  });
+
+  it('reads dimensions from orderReadyPayload when not on the item directly', () => {
+    const payloadItems: CartItemLike[] = [
+      { id: 'b1', positionName: 'B1A', orderReadyPayload: { width: 24, height: 30, depth: 24 } },
+    ];
+    const ok = crossCheckPlacementsAgainstCart(
+      [{ positionName: 'B1A', widthInches: 24, heightInches: 30 }],
+      payloadItems
+    );
+    expect(ok.blocking).toHaveLength(0);
+
+    const bad = crossCheckPlacementsAgainstCart(
+      [{ positionName: 'B1A', widthInches: 48, heightInches: 30 }],
+      payloadItems
+    );
+    expect(bad.blocking.some((b) => b.code === 'width_mismatch')).toBe(true);
+  });
+
+  it('warns (not blocks) when cart item width is unknown', () => {
+    const result = crossCheckPlacementsAgainstCart(
+      [{ positionName: 'X', widthInches: 18 }],
+      [{ id: 'x', positionName: 'X', serialNumber: 'NOPE' }]
+    );
+    expect(result.blocking).toHaveLength(0);
+    expect(result.warnings.some((w) => w.code === 'cart_item_dimensions_unknown')).toBe(true);
+  });
+
+  it('reports coverage gaps only when requested', () => {
+    const result = crossCheckPlacementsAgainstCart(
+      [{ positionName: 'U2A', widthInches: 18, heightInches: 42 }],
+      cartItems,
+      { reportCoverage: true }
+    );
+    expect(result.warnings.some((w) => w.code === 'cart_item_without_placement' && w.positionName === 'U2B')).toBe(true);
+  });
+});

package/src/tools/cart-cross-check.ts

@@ -0,0 +1,267 @@
+// ---------------------------------------------------------------------------
+// Cart-manifest cross-check for placement projection.
+//
+// Ground-truth fix for under-segmentation: a placement may only exist for a
+// real AI cart item, and its real-world size must match that item's catalog
+// dimensions. This anchors the drawing to the manifest — you cannot stretch one
+// 18" cabinet's box to cover a 36" run, and you cannot invent boxes for
+// cabinets that were never configured. Combined with one-placement-per-item, a
+// run can only hold as many cabinets as there are real items of the right size.
+//
+// Pure (no IO): the handler fetches session/cart state and passes the items in.
+// ---------------------------------------------------------------------------
+
+export interface CartItemLike {
+  id?: unknown;
+  aiCartItemId?: unknown;
+  positionName?: unknown;
+  serialNumber?: unknown;
+  displayName?: unknown;
+  width?: unknown;
+  height?: unknown;
+  depth?: unknown;
+  itemPayload?: unknown;
+  originalItemPayload?: unknown;
+  orderReadyPayload?: unknown;
+}
+
+export interface PlacementCheckSpec {
+  positionName: string;
+  aiCartItemId?: string;
+  widthInches: number;
+  heightInches?: number;
+  depthInches?: number;
+}
+
+export interface CartCrossCheckOptions {
+  widthToleranceInches?: number;
+  heightToleranceInches?: number;
+  depthToleranceInches?: number;
+  /** When true (replace mode), report active cart items that got no placement in this write. */
+  reportCoverage?: boolean;
+}
+
+export type CartCrossCheckBlockingCode =
+  | 'no_matching_cart_item'
+  | 'duplicate_cart_item_reference'
+  | 'width_mismatch'
+  | 'height_mismatch'
+  | 'depth_mismatch';
+
+export interface CartCrossCheckBlocking {
+  positionName: string;
+  code: CartCrossCheckBlockingCode;
+  message: string;
+}
+
+export interface CartCrossCheckWarning {
+  positionName: string;
+  code: 'cart_item_dimensions_unknown' | 'cart_item_without_placement';
+  message: string;
+}
+
+export interface CartCrossCheckResult {
+  matchedCount: number;
+  blocking: CartCrossCheckBlocking[];
+  warnings: CartCrossCheckWarning[];
+}
+
+const DEFAULT_WIDTH_TOLERANCE = 1.0;
+const DEFAULT_HEIGHT_TOLERANCE = 1.5;
+const DEFAULT_DEPTH_TOLERANCE = 1.5;
+
+function stringifyId(value: unknown): string | undefined {
+  if (value === null || value === undefined) {
+    return undefined;
+  }
+  const text = String(value).trim();
+  return text.length > 0 ? text : undefined;
+}
+
+function toFiniteNumber(value: unknown): number | undefined {
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === 'string' && value.trim() !== '') {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+  }
+  return undefined;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+/** Read a cabinet dimension from the item itself or any of its payloads. */
+function extractCartItemDimension(item: CartItemLike, key: 'width' | 'height' | 'depth'): number | undefined {
+  const direct = toFiniteNumber(item[key]);
+  if (direct !== undefined) {
+    return direct;
+  }
+  for (const payload of [item.orderReadyPayload, item.itemPayload, item.originalItemPayload]) {
+    if (isRecord(payload)) {
+      const value = toFiniteNumber(payload[key]);
+      if (value !== undefined) {
+        return value;
+      }
+    }
+  }
+  return undefined;
+}
+
+interface CartLookup {
+  byId: Map<string, CartItemLike>;
+  byPositionName: Map<string, CartItemLike>;
+}
+
+export function buildCartLookup(cartItems: CartItemLike[]): CartLookup {
+  const byId = new Map<string, CartItemLike>();
+  const byPositionName = new Map<string, CartItemLike>();
+  for (const item of cartItems) {
+    const itemId = stringifyId(item.id ?? item.aiCartItemId);
+    const positionName = stringifyId(item.positionName);
+    if (itemId) {
+      byId.set(itemId, item);
+    }
+    if (positionName) {
+      byPositionName.set(positionName, item);
+    }
+  }
+  return { byId, byPositionName };
+}
+
+function findMatchingCartItem(spec: PlacementCheckSpec, lookup: CartLookup): CartItemLike | undefined {
+  return (
+    (spec.aiCartItemId ? lookup.byId.get(spec.aiCartItemId) : undefined) ??
+    lookup.byPositionName.get(spec.positionName)
+  );
+}
+
+function cartItemKey(item: CartItemLike): string {
+  return stringifyId(item.id ?? item.aiCartItemId) ?? stringifyId(item.positionName) ?? '';
+}
+
+/**
+ * Cross-check projected placement specs against the real AI cart manifest.
+ * Returns blocking issues (refuse the write) and soft warnings.
+ */
+export function crossCheckPlacementsAgainstCart(
+  specs: PlacementCheckSpec[],
+  cartItems: CartItemLike[],
+  options: CartCrossCheckOptions = {}
+): CartCrossCheckResult {
+  const widthTol = options.widthToleranceInches ?? DEFAULT_WIDTH_TOLERANCE;
+  const heightTol = options.heightToleranceInches ?? DEFAULT_HEIGHT_TOLERANCE;
+  const depthTol = options.depthToleranceInches ?? DEFAULT_DEPTH_TOLERANCE;
+
+  const lookup = buildCartLookup(cartItems);
+  const blocking: CartCrossCheckBlocking[] = [];
+  const warnings: CartCrossCheckWarning[] = [];
+  const usedItemKeys = new Map<string, string>(); // cart item key -> first positionName that used it
+  let matchedCount = 0;
+
+  for (const spec of specs) {
+    const item = findMatchingCartItem(spec, lookup);
+    if (!item) {
+      blocking.push({
+        positionName: spec.positionName,
+        code: 'no_matching_cart_item',
+        message:
+          `Placement "${spec.positionName}" does not match any active AI cart item by aiCartItemId or positionName. ` +
+          'Create the AI cart item first (one physical cabinet = one cart item) and reference its backend id/positionName. ' +
+          'Do not place cabinets that are not in the manifest.',
+      });
+      continue;
+    }
+
+    matchedCount += 1;
+
+    const key = cartItemKey(item);
+    const priorPositionName = usedItemKeys.get(key);
+    if (priorPositionName !== undefined && priorPositionName !== spec.positionName) {
+      blocking.push({
+        positionName: spec.positionName,
+        code: 'duplicate_cart_item_reference',
+        message:
+          `Placements "${priorPositionName}" and "${spec.positionName}" both resolve to the same AI cart item. ` +
+          'One physical cabinet can have only one placement per canvas. If this is really two cabinets, create a ' +
+          'second AI cart item; if it is one cabinet, use a single placement.',
+      });
+    } else if (priorPositionName === undefined) {
+      usedItemKeys.set(key, spec.positionName);
+    }
+
+    const cartWidth = extractCartItemDimension(item, 'width');
+    if (cartWidth === undefined) {
+      warnings.push({
+        positionName: spec.positionName,
+        code: 'cart_item_dimensions_unknown',
+        message:
+          `AI cart item for "${spec.positionName}" has no readable width; could not verify the placement width ` +
+          'against the manifest. Confirm the cart item is configured with real catalog dimensions.',
+      });
+    } else if (Math.abs(cartWidth - spec.widthInches) > widthTol) {
+      blocking.push({
+        positionName: spec.positionName,
+        code: 'width_mismatch',
+        message:
+          `Placement "${spec.positionName}" width ${spec.widthInches}" does not match the AI cart item width ` +
+          `${cartWidth}" (tolerance ${widthTol}"). A box wider than its real cabinet usually means a run was lumped ` +
+          'into one box; split it into one cabinet per item, or correct the cart item width.',
+      });
+    }
+
+    if (spec.heightInches !== undefined) {
+      const cartHeight = extractCartItemDimension(item, 'height');
+      if (cartHeight !== undefined && Math.abs(cartHeight - spec.heightInches) > heightTol) {
+        blocking.push({
+          positionName: spec.positionName,
+          code: 'height_mismatch',
+          message:
+            `Placement "${spec.positionName}" height ${spec.heightInches}" does not match the AI cart item height ` +
+            `${cartHeight}" (tolerance ${heightTol}"). For base cabinets use the body height (excluding toekick and ` +
+            'countertop) and make the cart item height match.',
+        });
+      }
+    }
+
+    if (spec.depthInches !== undefined) {
+      const cartDepth = extractCartItemDimension(item, 'depth');
+      if (cartDepth !== undefined && Math.abs(cartDepth - spec.depthInches) > depthTol) {
+        blocking.push({
+          positionName: spec.positionName,
+          code: 'depth_mismatch',
+          message:
+            `Plan footprint "${spec.positionName}" depth ${spec.depthInches}" does not match the AI cart item depth ` +
+            `${cartDepth}" (tolerance ${depthTol}").`,
+        });
+      }
+    }
+  }
+
+  if (options.reportCoverage) {
+    const referencedKeys = new Set<string>();
+    for (const spec of specs) {
+      const item = findMatchingCartItem(spec, lookup);
+      if (item) {
+        referencedKeys.add(cartItemKey(item));
+      }
+    }
+    for (const item of cartItems) {
+      const key = cartItemKey(item);
+      if (key && !referencedKeys.has(key)) {
+        const positionName = stringifyId(item.positionName) ?? key;
+        warnings.push({
+          positionName,
+          code: 'cart_item_without_placement',
+          message:
+            `Active AI cart item "${positionName}" has no placement in this write. If it belongs on this canvas, ` +
+            'add it; if it only appears on another view, this is expected.',
+        });
+      }
+    }
+  }
+
+  return { matchedCount, blocking, warnings };
+}

package/src/tools/elevation-run-segmentation.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from 'vitest';
+import { segmentElevationRun, type ElevationRunSpec } from './elevation-run-segmentation';
+
+const baseRun = (overrides: Partial<ElevationRunSpec> = {}): ElevationRunSpec => ({
+  runStartInches: 0,
+  modules: [
+    { positionName: 'U2A', widthInches: 18, heightInches: 42, frontType: 'double_door' },
+    { positionName: 'U2B', widthInches: 18, heightInches: 42, frontType: 'double_door' },
+  ],
+  ...overrides,
+});
+
+describe('segmentElevationRun', () => {
+  it('tiles modules contiguously, computing each along-wall start/end', () => {
+    const result = segmentElevationRun(baseRun());
+    expect(result.modules[0].horizontalStartInches).toBe(0);
+    expect(result.modules[0].horizontalEndInches).toBe(18);
+    expect(result.modules[1].horizontalStartInches).toBe(18);
+    expect(result.modules[1].horizontalEndInches).toBe(36);
+    expect(result.modulesWidthInches).toBe(36);
+  });
+
+  it('inserts reveal gaps between modules when specified', () => {
+    const result = segmentElevationRun(baseRun({ revealBetweenModulesInches: 2 }));
+    expect(result.modules[0].horizontalEndInches).toBe(18);
+    expect(result.modules[1].horizontalStartInches).toBe(20); // 18 + 2 reveal
+  });
+
+  it('warns when a single module exceeds the single-cabinet width threshold (under-segmentation)', () => {
+    const result = segmentElevationRun({
+      runStartInches: 0,
+      modules: [{ positionName: 'U2A', widthInches: 36, heightInches: 42, frontType: 'double_door' }],
+      maxSingleCabinetWidthInches: 24,
+    });
+    expect(result.warnings.some((w) => w.includes('single-cabinet threshold'))).toBe(true);
+  });
+
+  it('warns when a single_door is implausibly wide', () => {
+    const result = segmentElevationRun({
+      runStartInches: 0,
+      modules: [{ positionName: 'B1A', widthInches: 30, heightInches: 30, frontType: 'single_door' }],
+    });
+    expect(result.warnings.some((w) => w.includes('single door this wide') || w.includes('single_door'))).toBe(true);
+  });
+
+  it('warns when declared subdivisions exceed the module count', () => {
+    const result = segmentElevationRun({
+      runStartInches: 0,
+      modules: [{ positionName: 'U2A', widthInches: 36, heightInches: 42, frontType: 'double_door' }],
+      declaredSubdivisionCount: 2,
+    });
+    expect(result.warnings.some((w) => w.includes('equal subdivisions'))).toBe(true);
+  });
+
+  it('warns when tiled widths do not match the run dimension', () => {
+    const result = segmentElevationRun(baseRun({ expectedRunTotalInches: 48 }));
+    expect(result.warnings.some((w) => w.includes('run dimension'))).toBe(true);
+  });
+
+  it('does not warn for a clean two-module run that matches the run dimension', () => {
+    const result = segmentElevationRun(baseRun({ expectedRunTotalInches: 36 }));
+    expect(result.warnings).toHaveLength(0);
+  });
+});

package/src/tools/elevation-run-segmentation.ts

@@ -0,0 +1,175 @@
+// ---------------------------------------------------------------------------
+// Elevation run segmentation.
+//
+// Second root cause of bad placement (after raw pixel-guessing): the agent
+// does not reliably decide HOW MANY physical cabinets a dimensioned run holds,
+// or WHAT front type each is. It draws one rectangle around a whole run — e.g.
+// a 3'-0" "EQ A | EQ A" upper run that is actually two double-door cabinets gets
+// treated as a single cabinet.
+//
+// This module makes segmentation explicit and checkable. The agent enumerates
+// each module of a run with its real width and declared front type; this code
+// tiles them contiguously (computing each module's along-wall start so there is
+// exactly one box per cabinet) and emits warnings when the declared layout is
+// implausible or contradicts the dimension chain the agent says it read. The
+// act of filling in per-module front types + widths forces the single-vs-double
+// and one-vs-many reasoning the model was skipping.
+//
+// Pure (no IO) so it can be unit-tested directly.
+// ---------------------------------------------------------------------------
+
+export type ElevationFrontType =
+  | 'single_door'
+  | 'double_door'
+  | 'pair_of_doors'
+  | 'drawer_stack'
+  | 'door_over_drawer'
+  | 'open_shelf'
+  | 'appliance_panel'
+  | 'filler';
+
+export interface RunModuleSpec {
+  positionName: string;
+  aiCartItemId?: string;
+  widthInches: number;
+  heightInches: number;
+  bottomFromFloorInches?: number;
+  frontType: ElevationFrontType;
+}
+
+export interface ElevationRunSpec {
+  /** Along-wall inch coordinate of the run's left edge. */
+  runStartInches: number;
+  /** Ordered left-to-right modules that make up the run. */
+  modules: RunModuleSpec[];
+  /** Optional run total from the primary dimension string (e.g. 3'-0" => 36). */
+  expectedRunTotalInches?: number;
+  /** Optional equal-subdivision count the agent read from the secondary chain (e.g. "EQ A | EQ A" => 2). */
+  declaredSubdivisionCount?: number;
+  /** Reveal/gap between adjacent modules in inches (e.g. the "2" TYP." callout). Default 0. */
+  revealBetweenModulesInches?: number;
+  /** Width above which a single module is suspected to be more than one cabinet. Default 48. */
+  maxSingleCabinetWidthInches?: number;
+}
+
+export interface SegmentedModule extends RunModuleSpec {
+  /** Computed along-wall left edge for this module. */
+  horizontalStartInches: number;
+  /** Computed along-wall right edge for this module. */
+  horizontalEndInches: number;
+}
+
+export interface RunSegmentationResult {
+  modules: SegmentedModule[];
+  /** Sum of module widths (excludes reveals). */
+  modulesWidthInches: number;
+  /** Span from the first module's left edge to the last module's right edge (includes reveals). */
+  occupiedSpanInches: number;
+  warnings: string[];
+}
+
+const DEFAULT_MAX_SINGLE_CABINET_WIDTH = 48;
+const DEFAULT_REVEAL = 0;
+// Industry-typical door sizing used only to raise warnings, never hard errors.
+const SINGLE_DOOR_MAX_WIDTH = 24;
+const DOUBLE_DOOR_MIN_WIDTH = 12;
+const RUN_TOTAL_TOLERANCE = 0.51;
+
+/**
+ * Tile a run's modules left-to-right and collect segmentation warnings.
+ * This never throws; structural requirements (non-empty modules, positive
+ * widths, required frontType) are enforced by the Zod schema at the tool layer.
+ */
+export function segmentElevationRun(run: ElevationRunSpec): RunSegmentationResult {
+  const reveal = run.revealBetweenModulesInches ?? DEFAULT_REVEAL;
+  const maxSingle = run.maxSingleCabinetWidthInches ?? DEFAULT_MAX_SINGLE_CABINET_WIDTH;
+
+  const modules: SegmentedModule[] = [];
+  let cursor = run.runStartInches;
+  for (let i = 0; i < run.modules.length; i += 1) {
+    const moduleSpec = run.modules[i];
+    const start = cursor;
+    const end = start + moduleSpec.widthInches;
+    modules.push({ ...moduleSpec, horizontalStartInches: start, horizontalEndInches: end });
+    cursor = end + reveal;
+  }
+
+  const modulesWidthInches = run.modules.reduce((sum, m) => sum + m.widthInches, 0);
+  const occupiedSpanInches =
+    modules.length > 0
+      ? modules[modules.length - 1].horizontalEndInches - modules[0].horizontalStartInches
+      : 0;
+
+  const warnings = collectSegmentationWarnings(run, modules, modulesWidthInches, maxSingle);
+
+  return { modules, modulesWidthInches, occupiedSpanInches, warnings };
+}
+
+function collectSegmentationWarnings(
+  run: ElevationRunSpec,
+  modules: SegmentedModule[],
+  modulesWidthInches: number,
+  maxSingle: number
+): string[] {
+  const warnings: string[] = [];
+
+  // Under-segmentation: a single very wide module is the classic "one box for
+  // multiple cabinets" failure.
+  for (const m of modules) {
+    if (m.widthInches > maxSingle) {
+      warnings.push(
+        `Module "${m.positionName}" is ${m.widthInches}" wide, above the ${maxSingle}" single-cabinet threshold. ` +
+          'Verify this is one physical cabinet and not several lumped into one box; if the dimension chain subdivides ' +
+          'this span, split it into separate cabinets with their own cart items and placements.'
+      );
+    }
+  }
+
+  // Front-type vs width plausibility.
+  for (const m of modules) {
+    if (m.frontType === 'single_door' && m.widthInches > SINGLE_DOOR_MAX_WIDTH) {
+      warnings.push(
+        `Module "${m.positionName}" is declared single_door but is ${m.widthInches}" wide (> ${SINGLE_DOOR_MAX_WIDTH}"). ` +
+          'A single door this wide is unusual; confirm it is not a double_door cabinet or two separate cabinets.'
+      );
+    }
+    if ((m.frontType === 'double_door' || m.frontType === 'pair_of_doors') && m.widthInches < DOUBLE_DOOR_MIN_WIDTH) {
+      warnings.push(
+        `Module "${m.positionName}" is declared ${m.frontType} but is only ${m.widthInches}" wide (< ${DOUBLE_DOOR_MIN_WIDTH}"). ` +
+          'Two doors in a span this narrow is unusual; confirm the front type.'
+      );
+    }
+  }
+
+  // Declared subdivisions vs module count: the secondary dimension chain
+  // ("EQ A | EQ A") is explicit segmentation evidence in the drawing.
+  if (run.declaredSubdivisionCount !== undefined && run.declaredSubdivisionCount > modules.length) {
+    warnings.push(
+      `You read ${run.declaredSubdivisionCount} equal subdivisions in the dimension chain but provided only ` +
+        `${modules.length} module(s). Confirm whether each subdivision is a separate cabinet (split it) or just ` +
+        'multiple doors within one cabinet (keep one module and set the front type accordingly).'
+    );
+  }
+
+  // Tiled width vs the run's primary dimension string.
+  if (run.expectedRunTotalInches !== undefined) {
+    const reveal = run.revealBetweenModulesInches ?? DEFAULT_REVEAL;
+    const totalWithReveals = modulesWidthInches + reveal * Math.max(0, modules.length - 1);
+    const delta = run.expectedRunTotalInches - totalWithReveals;
+    if (Math.abs(delta) > RUN_TOTAL_TOLERANCE) {
+      warnings.push(
+        `Module widths${reveal ? ' plus reveals' : ''} total ${round2(totalWithReveals)}" but the run dimension is ` +
+          `${run.expectedRunTotalInches}" (off by ${round2(delta)}"). Re-check module count, widths, or reveal: ` +
+          (delta > 0
+            ? 'the run has unaccounted width — a cabinet or filler may be missing.'
+            : 'the modules overflow the run — a width is too large or there are too many cabinets.')
+      );
+    }
+  }
+
+  return warnings;
+}
+
+function round2(value: number): number {
+  return Math.round(value * 100) / 100;
+}

package/src/tools/orders.ts

@@ -212,7 +212,7 @@ async function applySavedSettingsToArticles<T extends { settingsName?: string; [
   return Promise.all(articles.map(applySavedSettingToArticle));
 }
 
-const ArticleItemSchema = z.object({
+export const ArticleItemSchema = z.object({
   serialNumber: z.string(),
   positionName: z.string().max(25).describe(
     'Unique label for this cabinet within the order. Must be unique across ALL articles in the order. ' +
@@ -450,9 +450,13 @@ const DeleteSavedCartArticlesSchema = z.object({
   positionNames: flexArray(z.string()).describe('Position names of the articles to delete.'),
 });
 
-const CreateOrderSchema = z.object({
-  articles: flexArray(ArticleItemSchema).describe('Line items to order.'),
-  projectName: z.string().describe('Project name for this order'),
+const CreateOrderSchema = z.object({
+  articles: flexArray(ArticleItemSchema).describe('Line items to order.'),
+  projectId: z.number().int().positive().optional().describe(
+    'Optional existing project ID to place this order into. Use list_projects or create_project first. ' +
+    'When provided, the backend copies that project name/address and pricing snapshot to the order.'
+  ),
+  projectName: z.string().describe('Project name for this order'),
   purchaseOrder: z.string().describe('Purchase order number'),
   projectAddress: ProjectAddressSchema.optional().describe('Project address (where cabinets will be installed)'),
   includeDrawerboxes: z.boolean().optional(),