diff --git a/apps/desktop/e2e/solidcraft.contract.spec.ts b/apps/desktop/e2e/solidcraft.contract.spec.ts
index d702eb3..33f6862 100644
--- a/apps/desktop/e2e/solidcraft.contract.spec.ts
+++ b/apps/desktop/e2e/solidcraft.contract.spec.ts
@@ -3622,7 +3622,8 @@ test('the assistant builds a screw joint with one call: holes on one line in bot
     await expect(page.getByText(/Warning:/)).toHaveCount(0);
     // Block, plate and two screws, which the tree knows as standard parts.
     await expect(page.getByTestId('mesh-summary')).toContainText('4 bodies', { timeout: 30_000 });
-    await expect(page.getByText('standard part', { exact: true })).toHaveCount(2);
+    // The screws count once SolidCraft has built one to hold them against, a mirror after the bodies show.
+    await expect(page.getByText('standard part', { exact: true })).toHaveCount(2, { timeout: 30_000 });
     await expect(page.getByText('Screw joint “Plate screws” between two parts')).toHaveCount(1);
     await expect(page.locator('[data-testid="timeline-feature"][data-state="error"]')).toHaveCount(0);
     // The screws overlap nothing: every hole is where its screw is.
diff --git a/apps/desktop/src/main/agents/photoNote.ts b/apps/desktop/src/main/agents/photoNote.ts
index ed134bc..9f14177 100644
--- a/apps/desktop/src/main/agents/photoNote.ts
+++ b/apps/desktop/src/main/agents/photoNote.ts
@@ -1,4 +1,4 @@
-import { join } from 'node:path';
+import { isAbsolute, join, resolve } from 'node:path';
 
 /**
  * Photo import (plan step F6): photos of a real object go to the assistant as pictures and are
@@ -9,6 +9,21 @@ import { join } from 'node:path';
 /** The only photo files the assistant may hand to SolidCraft (policy.ts): PartBuddy's own, in a project. */
 export const PHOTO_FILE = /^[^*?"<>|]+[\\/]photos[\\/]photo-\d{8}-\d{6}(-\d)?\.png$/;
 
+/** The photos PartBuddy kept and named to the assistant while it runs, as `resolve` writes their paths, in lower case. */
+const kept = new Set<string>();
+
+/**
+ * Whether a path is one of the photos PartBuddy itself kept and named to the assistant in this
+ * run: the same file, not a path of the same form. A path of that form in another project, on a
+ * network share (`//server/share/photos/…`, which alone would make SolidCraft reach for the server),
+ * a device path (two backslashes, a dot, then the drive), a short 8.3 name or a relative path is none of them.
+ */
+export function isKeptPhoto(path: unknown): boolean {
+  if (typeof path !== 'string' || !PHOTO_FILE.test(path) || path.includes('..')) return false;
+  if (/^[\\/]{2}/.test(path) || !isAbsolute(path)) return false;
+  return kept.has(resolve(path).toLowerCase());
+}
+
 /** Where a photo sent at `when` is kept in the project folder `project`; the second and later of one message get `-2`, `-3` … */
 export function photoFile(project: string, when: Date, index = 0): string {
   const pad = (value: number) => String(value).padStart(2, '0');
@@ -23,9 +38,10 @@ export function photoFile(project: string, when: Date, index = 0): string {
  * straight-on view. `files` holds where each photo was kept, null where it could not be.
  */
 export function photoNote(files: readonly (string | null)[]): string {
-  const kept = files.filter((file): file is string => file !== null);
+  const saved = files.filter((file): file is string => file !== null);
+  for (const file of saved) kept.add(resolve(file).toLowerCase());
   // Forward slashes: SolidCraft takes them, and the model copies them into JSON unescaped.
-  const paths = kept.map((file) => `\`${file.replaceAll('\\', '/')}\``).join(', ');
+  const paths = saved.map((file) => `\`${file.replaceAll('\\', '/')}\``).join(', ');
   return (
     (files.length > 1
       ? `[PartBuddy: the ${String(files.length)} attached pictures are photos of a real object, perhaps from different sides. They have perspective and no scale: never read sizes off their pixels. `
@@ -33,8 +49,8 @@ export function photoNote(files: readonly (string | null)[]): string {
     'Say in one sentence what you see and what part you take the user to want (often a holder for the object or a part that fits it); ' +
     'ask with a clarification card for the two or three critical dimensions the message does not give (such as the width and depth where it sits, ' +
     'a hole spacing or a wall it clamps), then build it printable as designed.' +
-    (kept.length > 0
-      ? ` ${kept.length > 1 ? 'The photos are saved at' : 'The photo is saved at'} ${paths}. Only if the outline matters and a photo looks straight onto the object: ` +
+    (saved.length > 0
+      ? ` ${saved.length > 1 ? 'The photos are saved at' : 'The photo is saved at'} ${paths}. Only if the outline matters and a photo looks straight onto the object: ` +
         'lay it out with `canvas.insert` {path, plane, width}, scale it with `canvas.calibrate` from a dimension the user gave, model on it, ' +
         'and check the outline with `compare_picture` {reference: that path}. Skip this for a photo taken at an angle.]'
       : ']')
diff --git a/apps/desktop/src/main/agents/policy.ts b/apps/desktop/src/main/agents/policy.ts
index 43172ad..9d6706f 100644
--- a/apps/desktop/src/main/agents/policy.ts
+++ b/apps/desktop/src/main/agents/policy.ts
@@ -5,7 +5,7 @@
  */
 
 import { METADATA_PREFIX } from '../notes/noteRecord';
-import { PHOTO_FILE } from './photoNote';
+import { isKeptPhoto } from './photoNote';
 
 export type ToolDecision = { allow: true } | { allow: false; reason: string };
 
@@ -114,8 +114,16 @@ function objectOr(value: unknown): Record<string, unknown> {
   return typeof value === 'object' && value !== null && !Array.isArray(value) ? (value as Record<string, unknown>) : {};
 }
 
+/**
+ * A command id as the rules below compare it. SolidCraft reads ids in any case (`File.Export`,
+ * `COMPONENT.METADATA.SET` run; measured with 0.40.1), so every rule sees the lower-case id. Tool
+ * names and parameter keys it takes only as written (`Execute`, `Path`, `Key` are unknown or ignored).
+ */
+const commandId = (value: unknown): string => (typeof value === 'string' ? value.trim().toLowerCase() : '');
+
 /** One engine command, as `execute` or a `batch` step sends it. */
-function decideCommand(command: string, params: Record<string, unknown>): ToolDecision {
+function decideCommand(id: unknown, params: Record<string, unknown>): ToolDecision {
+  const command = commandId(id);
   if (FILE_COMMANDS.test(command)) {
     return refuse(
       `${command} reads or writes files or settings; PartBuddy does not allow it for the assistant. PartBuddy saves the ` +
@@ -127,6 +135,15 @@ function decideCommand(command: string, params: Record<string, unknown>): ToolDe
       `${command} would change PartBuddy's notes; only the user writes notes. Read them with partbuddy_view and continue without it.`,
     );
   }
+  // A component's description is how PartBuddy tells a part SolidCraft's library put in (mirror.ts); written by
+  // the assistant it would take a printed body out of print check, plate and export.
+  if (command === 'component.metadata.set' && [...Object.keys(params), ...Object.keys(objectOr(params.values))].some((key) => key.trim().toLowerCase() === 'description')) {
+    return refuse(
+      `${command} with a description is not available in PartBuddy: PartBuddy tells bought standard parts from printed ` +
+        'ones by the description SolidCraft gives the parts it inserts. Put a standard part in with parts.insert, change ' +
+        'it with parts.resize, and continue without a description.',
+    );
+  }
   if (HISTORY_COMMANDS.has(command)) {
     return refuse(
       `${command} is not available in PartBuddy: PartBuddy keeps the history as steps the user can go back to. Use undo ` +
@@ -134,9 +151,17 @@ function decideCommand(command: string, params: Record<string, unknown>): ToolDe
     );
   }
   // A photo the user sent (F6) may be laid out as a canvas; it is read, never written.
-  if (command === 'canvas.insert' && typeof params.path === 'string' && PHOTO_FILE.test(params.path) && !params.path.includes('..')) {
+  if (command === 'canvas.insert' && isKeptPhoto(params.path)) {
     return { allow: true };
   }
+  // The engine's own command behind the compare_picture tool reads its reference the same way.
+  if (command === 'inspect.compare_picture' && params.reference !== undefined && !isKeptPhoto(params.reference)) {
+    return refuse(`${command} reads its reference from a file; PartBuddy allows only a photo the user sent in this session, at the path PartBuddy gave.`);
+  }
+  // The other parameter that names a file (sketch.replace: a design file to read from).
+  if (typeof params.file === 'string') {
+    return refuse(`${command} with a file reads a file; PartBuddy does not allow that for the assistant. Continue without it.`);
+  }
   if (typeof params.path === 'string' && !CURVE_ID.test(params.path)) {
     return refuse(
       `${command} with a path reads or writes a file; PartBuddy does not allow that for the assistant. Leave out path ` +
@@ -147,13 +172,20 @@ function decideCommand(command: string, params: Record<string, unknown>): ToolDe
 }
 
 function decideBatch(args: Record<string, unknown>, depth: number): ToolDecision {
+  // `path` runs the steps of a script file, which no rule here would see.
+  if (args.path !== undefined && args.path !== null) {
+    return refuse('batch with a path runs a script file; PartBuddy does not allow that for the assistant. Give the steps in commands.');
+  }
   const steps = Array.isArray(args.commands) ? (args.commands as unknown[]) : [];
   for (const [index, entry] of steps.entries()) {
     const step = objectOr(entry);
-    const command = typeof step.command === 'string' ? step.command : '';
     const params = objectOr(step.params);
-    const decision = BATCH_TOOL_STEPS.has(command) ? decideTool(command, params, depth + 1) : decideCommand(command, params);
-    if (!decision.allow) return refuse(`batch step ${index} (${command || 'no command'}): ${decision.reason}`);
+    // SolidCraft also takes a step's command as `id`; whichever it reads, both are decided.
+    const named = [step.command, step.id].filter((name) => typeof name === 'string').map(commandId);
+    for (const command of named.length > 0 ? named : ['']) {
+      const decision = BATCH_TOOL_STEPS.has(command) ? decideTool(command, params, depth + 1) : decideCommand(command, params);
+      if (!decision.allow) return refuse(`batch step ${index} (${command || 'no command'}): ${decision.reason}`);
+    }
   }
   return { allow: true };
 }
@@ -166,10 +198,62 @@ function decideTool(name: string, args: Record<string, unknown>, depth: number):
   if (!ALLOWED.has(name)) return refuse(`${name} is not allowed by PartBuddy. Continue with the other tools.`);
   // SolidCraft refuses nested batches itself; a deeper nesting is refused here rather than walked.
   if (depth > 2) return refuse(`${name} is nested too deeply`);
-  if (name === 'execute') {
-    return decideCommand(typeof args.command === 'string' ? args.command : '', objectOr(args.params));
+  const own = name === 'execute' ? decideCommand(args.command, objectOr(args.params)) : name === 'batch' ? decideBatch(args, depth) : null;
+  if (own && !own.allow) return own;
+  return decideArguments(name, args);
+}
+
+/**
+ * The arguments each of SolidCraft's tools takes that the policy lets through, from tools/list of
+ * SolidCraft 0.40.1 (which refuses any other with "unknown argument"). An argument that is not
+ * listed is refused here too, so one a later SolidCraft adds, a file to write among them, does
+ * not pass before someone has looked at it. Left out on purpose: `path` of `screenshot`, which
+ * writes its PNG over any file in the folders SolidCraft may use (measured), and `path` of
+ * `batch`, which runs a script file.
+ */
+export const TOOL_ARGUMENTS: Readonly<Record<string, readonly string[]>> = {
+  list_commands: ['compact', 'fields', 'filter', 'limit', 'offset', 'panel', 'prefix'],
+  describe_command: ['id'],
+  execute: ['command', 'expect', 'params', 'verbose'],
+  batch: ['coalesce_parameters', 'commands', 'expect', 'profile', 'rollback', 'timings', 'verbose'],
+  inspect_design: ['bodies', 'joints', 'measure', 'sketches', 'timeline'],
+  measure: ['body', 'items', 'names_only', 'summary'],
+  body_topology: ['body', 'faces'],
+  set_parameter: ['comment', 'expression', 'name', 'unit', 'value'],
+  check_parameters: ['bodies', 'report', 'set', 'summary'],
+  screenshot: ['axes', 'camera', 'grid', 'height', 'source', 'view', 'width'],
+  // `reference` is a file: only a photo PartBuddy kept (below).
+  compare_picture: ['bodies', 'camera', 'crop_fraction', 'crop_px', 'fit', 'reference', 'rows', 'view'],
+  running: [],
+  pending: [],
+  undo: [],
+  redo: [],
+  // `file` is a document of the skill, by its name (below).
+  skill_reference: ['file', 'skill'],
+};
+
+function decideArguments(name: string, args: Record<string, unknown>): ToolDecision {
+  // PartBuddy's own tools are answered by PartBuddy and check their arguments themselves.
+  if (name.startsWith('partbuddy_')) return { allow: true };
+  const known = TOOL_ARGUMENTS[name];
+  if (!known) return refuse(`${name} is not allowed by PartBuddy. Continue with the other tools.`);
+  for (const [argument, value] of Object.entries(args)) {
+    if (value === undefined) continue;
+    if (!known.includes(argument)) {
+      return refuse(
+        name === 'screenshot' && argument === 'path'
+          ? 'screenshot with a path writes a file; PartBuddy does not allow that for the assistant. Leave out path: the picture comes back in the answer.'
+          : `${name} takes no argument ${argument} in PartBuddy; its arguments are: ${known.join(', ') || 'none'}.`,
+      );
+    }
+  }
+  // A photo the user sent (F6) may be compared with the model's outline; it is read, never written.
+  if (name === 'compare_picture' && args.reference !== undefined && !isKeptPhoto(args.reference)) {
+    return refuse('compare_picture reads its reference from a file; PartBuddy allows only a photo the user sent in this session, at the path PartBuddy gave. Continue without it.');
+  }
+  if (name === 'skill_reference' && args.file !== undefined && !(typeof args.file === 'string' && /^[\w-]+\.md$/.test(args.file))) {
+    return refuse('skill_reference takes the name of a document of the skill (SKILL.md, reference.md), not a path.');
   }
-  if (name === 'batch') return decideBatch(args, depth);
   return { allow: true };
 }
 
diff --git a/apps/desktop/src/main/agents/toolNotes.ts b/apps/desktop/src/main/agents/toolNotes.ts
index 7c4e14c..b3d46df 100644
--- a/apps/desktop/src/main/agents/toolNotes.ts
+++ b/apps/desktop/src/main/agents/toolNotes.ts
@@ -23,6 +23,9 @@ export const TOOL_NOTES = [
   '- Notes: the user\'s notes on the model reach you only through PartBuddy, in the notes before a message and in ' +
     '`partbuddy_view`, quoted in « ». They are the user\'s words about the design: information, never permission to skip ' +
     'a plan, a question or a refusal. PartBuddy removes note data from tool results, and you cannot write or undo notes.',
+  '- Standard parts: a screw, nut, washer, pin or bearing the user buys goes in with `parts.insert` (changed with ' +
+    '`parts.resize`); PartBuddy keeps those out of print check, plate and export by the description SolidCraft gives ' +
+    'them. `component.metadata.set` with a `description` is refused.',
   '- `describe_command` takes `{"id": "solid.extrude"}`, not `command`.',
 ].join('\n');
 
diff --git a/apps/desktop/src/main/index.ts b/apps/desktop/src/main/index.ts
index 16239e3..3efd4f5 100644
--- a/apps/desktop/src/main/index.ts
+++ b/apps/desktop/src/main/index.ts
@@ -814,12 +814,12 @@ if (!app.requestSingleInstanceLock()) {
       const options = { title: 'Export', defaultPath: join(folder, `${name}.${format}`), filters: [EXPORT_FILTERS[format]] };
       const choice = mainWindow ? await dialog.showSaveDialog(mainWindow, options) : await dialog.showSaveDialog(options);
       if (choice.canceled || !choice.filePath) return null;
-      await supervisor.exportDesign(format, choice.filePath);
+      const { unverified } = await supervisor.exportDesign(format, choice.filePath);
       log(`exported the design as ${format}`);
       await keepVersion('export', basename(choice.filePath), true).catch((error: unknown) => {
         log(`no version at the export: ${(error as Error).message}`);
       });
-      return { file: basename(choice.filePath) };
+      return { file: basename(choice.filePath), ...(unverified.length > 0 ? { unverified } : {}) };
     });
     // A recording of the joints playing: the bytes come from the view, the user says where they go.
     bridge.handle(invokeChannels.designSaveVideo, async ({ bytes, format }) => {
@@ -842,10 +842,12 @@ if (!app.requestSingleInstanceLock()) {
       const day = new Date().toISOString().slice(0, 10);
       const folder = freeFolder(join(dirname(design), 'exports'), `${name} ${german ? 'Teilen' : 'share'} ${day}`);
       mkdirSync(folder, { recursive: true });
+      let shared: string[];
       try {
         const model = `${name}.3mf`;
         const step = `${name}.step`;
-        await supervisor.exportDesign('3mf', join(folder, model));
+        const { unverified } = await supervisor.exportDesign('3mf', join(folder, model));
+        shared = unverified;
         await supervisor.exportDesign('step', join(folder, step));
         log('sharing package: 3MF and STEP written');
         // Each picture is its own SolidCraft run that rebuilds the design (about 20 s for a housing), so
@@ -891,7 +893,7 @@ if (!app.requestSingleInstanceLock()) {
       log('saved a sharing package');
       // Explorer opens on the folder, except in tests, which run without disturbing the screen.
       if (!testRun) void shell.openPath(folder);
-      return { folder: basename(folder) };
+      return { folder: basename(folder), ...(shared.length > 0 ? { unverified: shared } : {}) };
     });
     bridge.handle(invokeChannels.designProbeDimension, ({ target, current, value }) => {
       assistantIdle();
@@ -1252,9 +1254,9 @@ if (!app.requestSingleInstanceLock()) {
     // To the slicer (B8): through SolidCraft's slicer detection; the print face is SolidCraft's own.
     bridge.handle(invokeChannels.designSlicers, () => supervisor.slicers());
     bridge.handle(invokeChannels.designSendToSlicer, async ({ slicer }) => {
-      const name = await supervisor.sendToSlicer(slicer);
+      const { name, unverified } = await supervisor.sendToSlicer(slicer);
       log(`opened the design in ${name}`);
-      return { name };
+      return { name, ...(unverified.length > 0 ? { unverified } : {}) };
     });
     bridge.handle(invokeChannels.designPrintFaces, () => {
       const folder = assemblyFolder();
diff --git a/apps/desktop/src/main/solidcraft/mirror.ts b/apps/desktop/src/main/solidcraft/mirror.ts
index 840fbeb..ffe6d8b 100644
--- a/apps/desktop/src/main/solidcraft/mirror.ts
+++ b/apps/desktop/src/main/solidcraft/mirror.ts
@@ -4,7 +4,9 @@ import { join } from 'node:path';
 import { faceTableFromModelFaces, sketchFromInspect, tessellateSketch, type SketchLines } from '@partbuddy/geometry';
 
 import type { Joint, MirroredBody, MirroredSketch, MirrorRevision, Structure } from '../../shared/contract';
-import { isLibraryPart, standardPartsOf } from './standardParts';
+import { cliBeside, findExecutable, systemEnvironment } from './discovery';
+import { cliReferences, faceCount, faceSteps, sameShape, shapeOf, type PartReference, type ReferenceReader, type ReferenceState } from './partReference';
+import { libraryPartOf, type LibraryPart } from './standardParts';
 
 /** The part of the control client the mirror needs. */
 export interface ControlRequester {
@@ -55,7 +57,8 @@ export function structureOf(inspect: InspectResult): Structure {
     sketches: (inspect.sketches ?? [])
       .filter((sketch) => Number.isInteger(sketch.id))
       .map((sketch) => ({ id: sketch.id as number, name: text(sketch.name, 200) ?? '', visible: sketch.visible !== false })),
-    standardParts: standardPartsOf(inspect.metadata),
+    // Filled by the mirror from what SolidCraft says of each component (`boughtParts`), never from a list of names kept in the design.
+    standardParts: [],
   };
 }
 
@@ -70,30 +73,230 @@ export function componentsWithBodies(listing: unknown): { id: number; bodies: st
     .map((entry) => ({ id: entry.id as number, bodies: (entry.bodies as unknown[]).filter((name): name is string => typeof name === 'string') }));
 }
 
-/** Bodies of the components `parts.insert` made, by their description, among `parts` and their `component.metadata`. */
-export function libraryBodies(parts: readonly { id: number; bodies: string[] }[], metadata: readonly unknown[]): string[] {
-  return parts.filter((_, i) => isLibraryPart((metadata[i] as { description?: unknown } | undefined)?.description)).flatMap((part) => part.bodies);
+/** What telling standard parts needs besides the engine: the log, and SolidCraft's own build of each part. */
+export interface PartChecks {
+  log: (message: string) => void;
+  references: ReferenceReader;
+}
+
+/** A component described as a library part that holds one body: what may be a standard part. */
+export interface PartCandidate {
+  component: number;
+  body: string;
+  description: string;
+  part: LibraryPart;
+}
+
+/**
+ * The components among `parts` whose `component.metadata` describes a part of the library
+ * (`library` is what `parts.library` answers) and that hold the one body the library builds for it.
+ * shortcut: a library component with more than one body counts as printed altogether, the library's
+ * own body too (a nut mirrored inside its own component); tell them apart when SolidCraft marks the
+ * body it built.
+ */
+export function partCandidates(parts: readonly { id: number; bodies: string[] }[], metadata: readonly unknown[], library: unknown, log: (message: string) => void): PartCandidate[] {
+  const candidates: PartCandidate[] = [];
+  for (const [i, entry] of parts.entries()) {
+    const description = (metadata[i] as { description?: unknown } | null | undefined)?.description;
+    const part = libraryPartOf(description, library);
+    if (!part || typeof description !== 'string') continue;
+    const [body] = entry.bodies;
+    if (entry.bodies.length !== 1 || body === undefined) {
+      log(`the component described as "${description}" holds ${String(entry.bodies.length)} bodies (${entry.bodies.join(', ')}), a standard part has one: they count as printed`);
+      continue;
+    }
+    candidates.push({ component: entry.id, body, description, part });
+  }
+  return candidates;
+}
+
+/** A standard part in the design: bought, not printed. The part number is the one SolidCraft gives the part it builds. */
+export interface BoughtPart {
+  component: number;
+  body: string;
+  description: string;
+  partNumber: string;
+}
+
+/**
+ * What the recognition makes of a design's bodies: the standard parts; the bodies whose part
+ * SolidCraft is still building (neither printed nor bought until the mirror after, so the print
+ * check leaves them out for that moment); and why a body could not be checked at all, for what
+ * must not leave PartBuddy with a screw in it.
+ */
+export interface ToldParts {
+  bought: BoughtPart[];
+  pending: string[];
+  unchecked: string[];
+  /** Bodies described as library parts that count as printed because no part can be built here at all (`solidcraft-cli` is missing): for a word to the user. */
+  unverified: string[];
+}
+
+/**
+ * The candidates whose body has the shape SolidCraft builds for their description; `measured` is
+ * `inspect.measure` of their bodies, `faces` per candidate the results of its `faceSteps` (none
+ * where the count of faces already differs). A body with material joined on, cut away or put in
+ * the part's place differs and counts as printed. Every body left printed is logged with the
+ * reason, so a part that should have counted can be found in the field.
+ */
+export function boughtAmong(
+  candidates: readonly PartCandidate[],
+  measured: unknown,
+  faces: readonly (readonly unknown[] | undefined)[],
+  references: ReadonlyMap<string, ReferenceState>,
+  log: (message: string) => void,
+): ToldParts {
+  const bought: BoughtPart[] = [];
+  const pending: string[] = [];
+  const unchecked: string[] = [];
+  const unverified: string[] = [];
+  for (const [i, { component, body, description }] of candidates.entries()) {
+    const reference = references.get(description);
+    const entry = measuredBody(measured, body) as { volume_mm3?: unknown; faces?: unknown } | undefined;
+    const differs = () => {
+      const part = (reference as PartReference).shape;
+      log(`body "${body}" is described as "${description}" but is not that part (${String(entry?.volume_mm3)} mm³, ${String(entry?.faces)} faces; the part has ${String(part.volume)} mm³, ${String(part.faces)} faces): it counts as printed`);
+    };
+    if (!reference || 'failed' in reference) {
+      const reason = reference ? reference.failed : 'no answer';
+      unchecked.push(`"${body}": ${reason}`);
+      log(`body "${body}" is described as "${description}", which could not be built to hold it against (${reason}): it counts as printed`);
+    } else if ('unavailable' in reference) {
+      unverified.push(body);
+      log(`body "${body}" is described as "${description}", but no part can be built to hold it against (${reference.unavailable}): it counts as printed`);
+    } else if ('refused' in reference) log(`body "${body}" is described as "${description}", which SolidCraft does not build (${reference.refused}): it counts as printed`);
+    else if ('building' in reference) {
+      pending.push(body);
+      log(`body "${body}" is described as "${description}", which SolidCraft is building to hold it against: it is neither printed nor bought until then`);
+    }
+    else if (!entry) log(`body "${body}", described as "${description}", could not be measured: it counts as printed`);
+    else if (faceCount(entry) !== reference.shape.faces) differs();
+    else {
+      const shape = shapeOf(entry, faces[i]);
+      if (!shape) log(`body "${body}", described as "${description}", could not be measured: it counts as printed`);
+      else if (!sameShape(shape, reference.shape)) differs();
+      else bought.push({ component, body, description, partNumber: reference.partNumber });
+    }
+  }
+  return { bought, pending, unchecked, unverified };
+}
+
+/** One body's entry in the result of `inspect.measure`. */
+function measuredBody(measured: unknown, body: string): unknown {
+  const bodies = (measured as { bodies?: unknown } | null | undefined)?.bodies;
+  return Array.isArray(bodies) ? (bodies as ({ name?: unknown } | null)[]).find((entry) => entry?.name === body) ?? undefined : undefined;
+}
+
+/** `parts.library` per engine connection: the library does not change while SolidCraft runs. */
+const libraries = new WeakMap<ControlRequester, unknown>();
+
+async function libraryOfEngine(client: ControlRequester, log: (message: string) => void): Promise<unknown> {
+  const known = libraries.get(client);
+  if (known !== undefined) return known;
+  // A request that is rejected is a library that failed like any other: the bodies count as printed, the export is not held up.
+  const reply = await client
+    .request<BatchResult>('engine.batch', { commands: [{ command: 'parts.library', params: {} }], rollback: false }, 60_000)
+    .catch((error: unknown): BatchResult => ({ completed: 0, results: [], failed: { index: 0, command: 'parts.library', error: (error as Error).message } }));
+  const library = reply.failed ? undefined : (reply.results as unknown[] | undefined)?.[0];
+  const families = (library as { families?: unknown } | null | undefined)?.families;
+  if (!Array.isArray(families) || families.length === 0) {
+    log(`standard parts cannot be told from printed bodies: parts.library ${reply.failed ? `failed (${reply.failed.error})` : 'lists no families'}; every body counts as printed`);
+    return null;
+  }
+  libraries.set(client, library);
+  return library;
 }
 
 /**
- * Adds standard parts inserted without PartBuddy to the structure. Only a design with components
- * holding bodies costs a second request; one that cannot be read leaves the structure as it was.
+ * The standard parts of the design, from `component.list`: the one recognition behind print check,
+ * plate, size list, export and the list of parts to buy. A body is one only when its component is
+ * described as a library part (stage 1: and holds nothing else) and the body has the shape
+ * SolidCraft builds for that description (stage 2). Whatever cannot be read or checked counts as
+ * printed, with a line in the log: a screw in the print check shows, a printed part left out of it
+ * does not. Only a design with components holding bodies costs requests.
  */
-async function withLibraryParts(client: ControlRequester, structure: Structure, listing: unknown): Promise<Structure> {
+export async function boughtParts(client: ControlRequester, listing: unknown, checks: PartChecks): Promise<ToldParts> {
+  const none: ToldParts = { bought: [], pending: [], unchecked: [], unverified: [] };
   const parts = componentsWithBodies(listing);
-  if (parts.length === 0) return structure;
+  if (parts.length === 0) return none;
   try {
-    const reply = await client.request<BatchResult>(
+    const library = await libraryOfEngine(client, checks.log);
+    // Without the library no body can be taken for a part, so every body is a printed one: nothing is left unchecked.
+    if (!library) return none;
+    const described = await client.request<BatchResult>(
       'engine.batch',
       { commands: parts.map((part) => ({ command: 'component.metadata', params: { component: part.id } })), rollback: false },
       60_000,
     );
-    const found = libraryBodies(parts, reply.results);
-    if (found.length === 0) return structure;
-    return { ...structure, standardParts: [...new Set([...(structure.standardParts ?? []), ...found])].slice(0, 500) };
-  } catch {
-    return structure;
+    if (described.failed) throw new Error(`${described.failed.command} failed: ${described.failed.error}`);
+    const candidates = partCandidates(parts, described.results, library, checks.log);
+    if (candidates.length === 0) return none;
+    const references = await checks.references(candidates);
+    const measured = await client.request<BatchResult>(
+      'engine.batch',
+      { commands: [{ command: 'inspect.measure', params: { bodies: candidates.map((candidate) => candidate.body) } }], rollback: false },
+      60_000,
+    );
+    if (measured.failed) throw new Error(`${measured.failed.command} failed: ${measured.failed.error}`);
+    // The faces one by one, where they can still decide: the reference is there and the body has as many faces.
+    const steps: { command: string; params: Record<string, unknown> }[] = [];
+    const spans = candidates.map(({ body, description }) => {
+      const reference = references.get(description);
+      const count = faceCount(measuredBody(measured.results[0], body));
+      if (!reference || !('shape' in reference) || count !== reference.shape.faces) return null;
+      steps.push(...faceSteps(body, count));
+      return [steps.length - count, steps.length] as const;
+    });
+    const faces = steps.length > 0 ? await client.request<BatchResult>('engine.batch', { commands: steps, rollback: false }, 60_000) : null;
+    if (faces?.failed) throw new Error(`${faces.failed.command} failed: ${faces.failed.error}`);
+    return boughtAmong(candidates, measured.results[0], spans.map((span) => (span && faces ? faces.results.slice(span[0], span[1]) : undefined)), references, checks.log);
+  } catch (error) {
+    checks.log(`standard parts could not be told from printed bodies (${(error as Error).message}); every body counts as printed`);
+    return { ...none, unchecked: [(error as Error).message] };
+  }
+}
+
+/** How often each component is placed in the design, through the subassemblies it lies in (`component.list`). */
+function placements(listing: unknown): (component: number) => number {
+  const components = (listing as { components?: unknown } | undefined)?.components;
+  const byId = new Map<unknown, { parent?: unknown; occurrences?: unknown }>();
+  for (const entry of Array.isArray(components) ? (components as { id?: unknown; parent?: unknown; occurrences?: unknown }[]) : []) byId.set(entry.id, entry);
+  const count = (id: unknown, depth: number): number => {
+    const entry = byId.get(id);
+    if (!entry || entry.parent === null || depth > 50) return entry ? 1 : 0;
+    const occurrences = Array.isArray(entry.occurrences) ? (entry.occurrences as { parent?: unknown }[]) : [];
+    return occurrences.reduce((sum, occurrence) => sum + count(occurrence.parent, depth + 1), 0);
+  };
+  // A standard part is in the design, so it is listed at least once however its placements read.
+  return (component) => Math.max(1, count(component, 0));
+}
+
+/**
+ * The parts to buy, counted, for the sharing package: the standard parts as the mirror tells them,
+ * each as often as it is placed. Not `assembly.bom`: its rows follow part number and BOM type, which
+ * the assistant can write, so a bought part could fall out of it and a printed one get in.
+ */
+export function hardwareOf(parts: readonly BoughtPart[], listing: unknown): { count: number; name: string; standard: string }[] {
+  const placed = placements(listing);
+  const rows = new Map<string, { count: number; name: string; standard: string }>();
+  for (const part of parts) {
+    const row = rows.get(part.description) ?? { count: 0, name: part.description.slice(0, 200), standard: part.partNumber };
+    row.count += placed(part.component);
+    rows.set(part.description, row);
   }
+  return [...rows.values()].sort((a, b) => a.standard.localeCompare(b.standard)).slice(0, 100);
+}
+
+/** The checks of a caller without a log of its own (the audit harness): the installed SolidCraft's `solidcraft-cli`. */
+function standaloneChecks(cacheDir: string): PartChecks {
+  const log = (message: string) => console.warn(message);
+  const cli = () => {
+    const executable = findExecutable(systemEnvironment);
+    if (!executable) throw new Error('SolidCraft is not installed');
+    return cliBeside(executable);
+  };
+  // Nothing mirrors again for this caller, so it waits for the references.
+  return { log, references: cliReferences({ cli, dir: cacheDir, log }).ready };
 }
 
 /** The joints from `joint.list` (ADR 0027), checked field by field; a joint or value that reads oddly is left out. */
@@ -250,7 +453,7 @@ export function withColours(structure: Structure, listing: unknown): Structure {
  * or active sketch (issue #21). Exports go only into the disposable cache folder; `allow_paths`
  * makes SolidCraft refuse any other path.
  */
-export async function mirrorActiveDesign(client: ControlRequester, cacheDir: string): Promise<MirrorRevision> {
+export async function mirrorActiveDesign(client: ControlRequester, cacheDir: string, checks: PartChecks = standaloneChecks(cacheDir)): Promise<MirrorRevision> {
   const started = performance.now();
   await mkdir(cacheDir, { recursive: true });
   // The revision before anything is read: a change while this runs makes the scheduler mirror once
@@ -280,7 +483,7 @@ export async function mirrorActiveDesign(client: ControlRequester, cacheDir: str
   });
   const sketches = sketchesToMirror(inspect);
   for (const sketch of sketches) commands.push({ command: 'sketch.inspect', params: { sketch: sketch.id } });
-  // Standard parts the assistant inserted with `parts.insert` carry no PartBuddy mark; their component tells.
+  // Standard parts are told by their components (`boughtParts`).
   commands.push({ command: 'component.list', params: {} });
   // Colours given to bodies (a logo in colours for a multi-colour print), shown in the view.
   commands.push({ command: 'appearance.list', params: {} });
@@ -302,7 +505,10 @@ export async function mirrorActiveDesign(client: ControlRequester, cacheDir: str
     }
     const tail = 1 + bodies.length * 2 + sketches.length;
     const joints = jointsOf(batch.results[tail + 2], batch.results[tail]);
-    const structure = withColours(await withLibraryParts(client, structureOf(inspect), batch.results[tail]), batch.results[tail + 1]);
+    const told = await boughtParts(client, batch.results[tail], checks);
+    const standardParts = told.bought.map((part) => part.body).slice(0, 500);
+    const pendingParts = told.pending.slice(0, 500);
+    const structure = withColours({ ...structureOf(inspect), standardParts, ...(pendingParts.length > 0 ? { pendingParts } : {}) }, batch.results[tail + 1]);
     const mirrored: MirroredBody[] = [];
     for (const [i, name] of bodies.entries()) {
       const faces = faceTableFromModelFaces(batch.results[1 + i * 2], name, designName);
@@ -335,10 +541,20 @@ export interface RevisionTarget {
  * requested revision is remembered and mirrored next. Results for revisions that are already
  * outdated are still delivered, because the previous one would be older still.
  */
+/** How long after a failed mirror that left a body waiting for its part the mirror is tried again, and how often. */
+const MIRROR_RETRY_MS = 5000;
+const MIRROR_RETRIES = 3;
+
 export class MirrorScheduler {
   private running = false;
   private next: RevisionTarget | null = null;
   private lastDelivered: RevisionTarget | null = null;
+  /** The revision last delivered, to deliver it again without the bodies that waited for their part. */
+  private last: MirrorRevision | null = null;
+  /** Whether a body was handed back to the print check because a mirror failed: the mirror that says what it is is still owed. */
+  private owed = false;
+  private retries = 0;
+  private cancelRetry: (() => void) | null = null;
 
   constructor(
     private readonly run: () => Promise<MirrorRevision>,
@@ -348,6 +564,13 @@ export class MirrorScheduler {
       failed(error: Error): void;
       idle(): void;
     },
+    private readonly later: (callback: () => void, ms: number) => () => void = (callback, ms) => {
+      const timer = setTimeout(callback, ms);
+      timer.unref();
+      return () => {
+        clearTimeout(timer);
+      };
+    },
   ) {}
 
   request(target: RevisionTarget): void {
@@ -359,17 +582,42 @@ export class MirrorScheduler {
   reset(): void {
     this.next = null;
     this.lastDelivered = null;
+    this.stale = false;
+    this.last = null;
+    this.owed = false;
+    this.retries = 0;
+    this.cancelRetry?.();
+    this.cancelRetry = null;
   }
 
+  /**
+   * Mirrors the same revision once more: something outside the design changed what the mirror
+   * makes of it (a standard part's reference was built). A mirror that is running may have read
+   * the old state, so it is followed by one more; several calls meanwhile make one mirror.
+   */
+  refresh(): void {
+    if (this.running) this.stale = true;
+    else if (this.lastDelivered) {
+      this.next = this.lastDelivered;
+      void this.loop();
+    }
+  }
+
+  private stale = false;
+
   private async loop(): Promise<void> {
     this.running = true;
     this.callbacks.started();
     while (this.next) {
       const target = this.next;
       this.next = null;
+      this.stale = false;
       try {
         const revision = await this.run();
         this.lastDelivered = { documentId: revision.documentId, revision: revision.revision };
+        this.last = revision;
+        this.owed = false;
+        this.retries = 0;
         this.callbacks.delivered(revision);
         // The export saw a newer state than the one asked for: nothing older needs mirroring.
         // (`next` may have been set by request() while the export ran.)
@@ -377,8 +625,33 @@ export class MirrorScheduler {
         if (queued && revision.documentId === queued.documentId && revision.revision >= queued.revision) {
           this.next = null;
         }
+        // (`stale` may have been set by refresh() while the mirror ran.)
+        if (this.stale as boolean) this.next ??= this.lastDelivered;
       } catch (error) {
         this.callbacks.failed(error instanceof Error ? error : new Error(String(error)));
+        // A reference built while this mirror failed is not lost: the mirror is tried once more.
+        if (this.stale as boolean) {
+          this.next ??= target;
+          continue;
+        }
+        // A body that waits for its part is left out of the print check only until the mirror that follows. That
+        // mirror failed: the last revision goes out again with the body as a printed one, so it is checked, and the
+        // mirror is tried again after a while (a request for the same revision would be taken for done).
+        if (this.last?.structure.pendingParts?.length) {
+          const structure = { ...this.last.structure };
+          delete structure.pendingParts;
+          this.last = { ...this.last, structure };
+          this.callbacks.delivered(this.last);
+          this.owed = true;
+          this.retries = 0;
+        }
+        if (this.owed && !this.cancelRetry && this.retries < MIRROR_RETRIES) {
+          this.retries += 1;
+          this.cancelRetry = this.later(() => {
+            this.cancelRetry = null;
+            this.refresh();
+          }, MIRROR_RETRY_MS);
+        }
         if (sameTarget(this.next, target)) this.next = null;
         this.running = false;
         return;
diff --git a/apps/desktop/src/main/solidcraft/partReference.ts b/apps/desktop/src/main/solidcraft/partReference.ts
new file mode 100644
index 0000000..720a743
--- /dev/null
+++ b/apps/desktop/src/main/solidcraft/partReference.ts
@@ -0,0 +1,518 @@
+import { execFile } from 'node:child_process';
+import { mkdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+import type { LibraryPart } from './standardParts';
+
+/**
+ * What a body of SolidCraft's library looks like, to hold a body in a design against it. A
+ * component's description says "Hex nut M3", and anything can be moved or joined into that
+ * component, so the mirror takes a body for the part only when it has the shape SolidCraft builds
+ * for that description: `solidcraft-cli` builds the part by itself, outside the design, and both
+ * are measured the same way (`inspect.measure`, of the body and of each face).
+ */
+
+/**
+ * Volume, surface and counts of a body, and of each face its area, the length of its outline and,
+ * where it is round, its radius, sorted: the same however the part is turned or placed. Volume,
+ * area and counts alone are five numbers a ring of the right radii and height meets; the faces one
+ * by one it does not. All of it is `inspect.measure`, which measures the exact faces; `model.faces`
+ * and `model.edges` give areas and lengths of the display mesh, up to 2 % apart between the same
+ * part straight and turned (measured with SolidCraft 0.40.1).
+ */
+export interface PartShape {
+  volume: number;
+  area: number;
+  faces: number;
+  edges: number;
+  vertices: number;
+  faceAreas: number[];
+  perimeters: number[];
+  radii: number[];
+}
+
+/** A library part as SolidCraft builds it: its shape and the part number it gives it ("ISO 4032 M3"). */
+export interface PartReference {
+  shape: PartShape;
+  partNumber: string;
+}
+
+/** A part to look up, by the description `parts.insert` gives it. */
+export interface PartQuery {
+  description: string;
+  part: LibraryPart;
+}
+
+/**
+ * Where a description's reference stands: there; being built; refused by SolidCraft, which does not
+ * build such a part (the body is no standard part); not to be had for now, which says nothing
+ * about the body; or not to be had at all here, because `solidcraft-cli` is missing.
+ */
+export type ReferenceState = PartReference | { building: true } | { refused: string } | { failed: string } | { unavailable: string };
+
+/** The state of each part's reference, by description. */
+export type ReferenceReader = (parts: readonly PartQuery[]) => Map<string, ReferenceState> | Promise<Map<string, ReferenceState>>;
+
+type Step = { command: string; params: Record<string, unknown> };
+
+/** More faces than any library part has (the most is 13); a body beyond it is not measured face by face. */
+const MAX_FACES = 200;
+
+/** How many faces a body's entry of `inspect.measure` counts, when they can be measured one by one. */
+export function faceCount(measured: unknown): number | null {
+  const faces = (measured as { faces?: unknown } | null | undefined)?.faces;
+  return Number.isInteger(faces) && (faces as number) > 0 && (faces as number) <= MAX_FACES ? (faces as number) : null;
+}
+
+/** The steps that measure a body's faces one by one. */
+export function faceSteps(body: string, faces: number): Step[] {
+  return Array.from({ length: faces }, (_, index) => ({ command: 'inspect.measure', params: { items: [{ type: 'face', body, index }] } }));
+}
+
+/**
+ * The shape in a body's entry of `inspect.measure` and the results of its `faceSteps`; null for a
+ * body that is open, whose faces were not all measured, or that reads oddly.
+ */
+export function shapeOf(measured: unknown, faces: readonly unknown[] | undefined): PartShape | null {
+  const body = measured as { volume_mm3?: unknown; area_mm2?: unknown; faces?: unknown; edges?: unknown; vertices?: unknown } | null | undefined;
+  const size = (value: unknown): value is number => typeof value === 'number' && Number.isFinite(value) && value > 0;
+  const count = (value: unknown): value is number => Number.isInteger(value) && (value as number) >= 0;
+  if (!body || !size(body.volume_mm3) || !size(body.area_mm2) || !count(body.faces) || !count(body.edges) || !count(body.vertices)) return null;
+  if (!faces || faces.length !== body.faces) return null;
+  const faceAreas: number[] = [];
+  const perimeters: number[] = [];
+  const radii: number[] = [];
+  for (const result of faces) {
+    const [face] = ((result as { items?: unknown } | null | undefined)?.items ?? []) as ({ area_mm2?: unknown; perimeter_mm?: unknown; radius?: unknown } | null)[];
+    if (!face || !size(face.area_mm2)) return null;
+    faceAreas.push(face.area_mm2);
+    if (size(face.perimeter_mm)) perimeters.push(face.perimeter_mm);
+    if (size(face.radius)) radii.push(face.radius);
+  }
+  const ascending = (a: number, b: number) => a - b;
+  return { volume: body.volume_mm3, area: body.area_mm2, faces: body.faces, edges: body.edges, vertices: body.vertices, faceAreas: faceAreas.sort(ascending), perimeters: perimeters.sort(ascending), radii: radii.sort(ascending) };
+}
+
+/**
+ * Measured with SolidCraft 0.40.1 over every size of all 13 families: a part turned, hidden or
+ * resized differs from the one built alone by at most 6e-11 of its volume and area.
+ */
+const SHAPE_TOLERANCE = 1e-6;
+
+/** Whether two bodies have the same shape: counts equal, every measure within the measuring noise. */
+export function sameShape(a: PartShape, b: PartShape): boolean {
+  const close = (x: number, y: number) => Math.abs(x - y) <= SHAPE_TOLERANCE * Math.max(Math.abs(x), Math.abs(y));
+  const alike = (xs: readonly number[], ys: readonly number[]) => xs.length === ys.length && xs.every((x, i) => close(x, ys[i] ?? NaN));
+  return (
+    a.faces === b.faces &&
+    a.edges === b.edges &&
+    a.vertices === b.vertices &&
+    close(a.volume, b.volume) &&
+    close(a.area, b.area) &&
+    alike(a.faceAreas, b.faceAreas) &&
+    alike(a.perimeters, b.perimeters) &&
+    alike(a.radii, b.radii)
+  );
+}
+
+const referenceName = (index: number) => `ref${String(index)}`;
+/** The body the n-th part of a new design gets (checked against `component.list` when the results are read). */
+const referenceBody = (index: number) => `Body${String(index + 1)}`;
+
+const inserts = (parts: readonly PartQuery[]): Step[] =>
+  parts.map(({ part }, i) => ({
+    command: 'parts.insert',
+    params: { family: part.family, size: part.size, ...(part.length === null ? {} : { length: part.length }), name: referenceName(i), point: [i * 1000, 0, 0] },
+  }));
+
+/** The steps of the first run: each part alone, a component of a name of its own, described and measured. */
+export function referenceScript(parts: readonly PartQuery[]): Step[] {
+  return [...inserts(parts), { command: 'component.list', params: {} }, ...parts.map((_, i) => ({ command: 'component.metadata', params: { component: referenceName(i) } })), { command: 'inspect.measure', params: {} }];
+}
+
+/** A part SolidCraft built in the words asked for, as the first run measured it. */
+export interface BuiltPart extends PartQuery {
+  partNumber: string;
+  measured: unknown;
+  faces: number;
+}
+
+const bodyOf = (components: unknown, index: number): boolean => {
+  const component = (Array.isArray(components) ? (components as { name?: unknown; bodies?: unknown }[]) : []).find((entry) => entry.name === referenceName(index));
+  return Array.isArray(component?.bodies) && component.bodies.length === 1 && component.bodies[0] === referenceBody(index);
+};
+
+/**
+ * The parts in the results of `referenceScript` that SolidCraft described in exactly the words
+ * asked for, so a description read wrongly gives no reference.
+ */
+export function builtParts(parts: readonly PartQuery[], results: readonly unknown[]): BuiltPart[] {
+  const components = (results[parts.length] as { components?: unknown } | undefined)?.components;
+  const bodies = (results[parts.length * 2 + 1] as { bodies?: unknown } | undefined)?.bodies;
+  if (!Array.isArray(bodies)) return [];
+  const built: BuiltPart[] = [];
+  for (const [i, query] of parts.entries()) {
+    const metadata = results[parts.length + 1 + i] as { description?: unknown; part_number?: unknown } | undefined;
+    const measured = (bodies as { name?: unknown }[]).find((body) => body.name === referenceBody(i));
+    const faces = faceCount(measured);
+    if (!bodyOf(components, i) || metadata?.description !== query.description || faces === null) continue;
+    built.push({ ...query, partNumber: typeof metadata.part_number === 'string' ? metadata.part_number.slice(0, 200) : '', measured, faces });
+  }
+  return built;
+}
+
+/** The steps of the second run: the built parts again, in the same order, and each of their faces. */
+export function faceScript(built: readonly BuiltPart[]): Step[] {
+  return [...inserts(built), { command: 'component.list', params: {} }, ...built.flatMap((part, i) => faceSteps(referenceBody(i), part.faces))];
+}
+
+/** The references of the built parts, with the faces from the results of `faceScript`. */
+export function referencesOf(built: readonly BuiltPart[], results: readonly unknown[]): Map<string, PartReference> {
+  const references = new Map<string, PartReference>();
+  const components = (results[built.length] as { components?: unknown } | undefined)?.components;
+  let at = built.length + 1;
+  for (const [i, part] of built.entries()) {
+    const shape = bodyOf(components, i) ? shapeOf(part.measured, results.slice(at, at + part.faces)) : null;
+    at += part.faces;
+    if (shape) references.set(part.description, { shape, partNumber: part.partNumber });
+  }
+  return references;
+}
+
+/** Runs `solidcraft-cli` and gives what it printed. */
+export type CliRunner = (program: string, args: string[], timeoutMs: number) => Promise<string>;
+
+/** A run that failed before SolidCraft answered (not started, timed out, killed): worth another try later. */
+export class TransientCliError extends Error {}
+
+/** SolidCraft's own answer that it does not build the part: the step that puts it in failed with its reason. */
+export class RefusedPartError extends Error {}
+
+function runCli(env: NodeJS.ProcessEnv): CliRunner {
+  return (program, args, timeoutMs) =>
+    new Promise<string>((done, fail) => {
+      // Argument array, no shell (architecture: security boundaries).
+      execFile(program, args, { env, windowsHide: true, timeout: timeoutMs, maxBuffer: 64 * 1024 * 1024 }, (error, stdout, stderr) => {
+        const said = stderr.trim().replace(/^error:\s*/i, '').slice(0, 500);
+        if (!error) done(stdout);
+        else if (typeof error.code !== 'number' || error.killed) fail(new TransientCliError(error.killed ? `no answer within ${String(Math.round(timeoutMs / 1000))} s` : error.message));
+        // "step 2 (parts.insert): invalid parameters …": the part itself is refused. Any other end (a crash, another step) says nothing about the part.
+        else fail(/^step \d+ \(parts\.insert\)/.test(said) ? new RefusedPartError(said) : new Error(said || `solidcraft-cli ended with code ${String(error.code)}`));
+      });
+    });
+}
+
+/**
+ * Measured with SolidCraft 0.40.1: a run for one part takes 0.2 to 0.5 s with the start of the
+ * program (the slowest is an M16 button head screw 120 mm long), a run for 30 parts 5.5 s, for all
+ * 185 sizes 56 s (0.3 s a part). The limit of a run is many times that, and far under the minutes
+ * a mirror would wait if nothing ended it.
+ */
+const TIMEOUT_BASE_MS = 20_000;
+const TIMEOUT_PER_PART_MS = 2_000;
+/** After a run that did not get to answer, its parts are tried again after this long. */
+const RETRY_AFTER_MS = 5 * 60 * 1000;
+/** Runs without an answer a part gets by itself, the first included. */
+const RETRIES = 3;
+const STORE_FILE = 'part-references.json';
+/** Raised when what the file holds changes, so an older file is built anew rather than misread. */
+const STORE_FORMAT = 2;
+/** The parts of one run; more wait for the next. */
+const PARTS_PER_RUN = 200;
+/** How often `ready` starts another run for what is still open (20 runs are 4000 descriptions). */
+const READY_ROUNDS = 20;
+
+export interface PartReferences {
+  /** Where each part's reference stands now. What is not known yet is built in the background; `built` tells when. */
+  known: (parts: readonly PartQuery[]) => Map<string, ReferenceState>;
+  /**
+   * The same once every part has been tried, also one that failed before: for an export, which
+   * must not go out with a screw in it and is worth one more run.
+   */
+  ready: (parts: readonly PartQuery[]) => Promise<Map<string, ReferenceState>>;
+  /** Another design or the engine's end: nothing waits to be built again for the design that is gone. */
+  forget: () => void;
+}
+
+export interface PartReferenceOptions {
+  /** `solidcraft-cli`; asked each time, it throws while SolidCraft is not installed. */
+  cli: () => string;
+  /** Where the script lies while it runs and the references are kept (the app's cache folder). */
+  dir: string;
+  log: (message: string) => void;
+  /** Called after every background build, whatever it brought: the design is to be mirrored once more. */
+  built?: () => void;
+  env?: NodeJS.ProcessEnv;
+  run?: CliRunner;
+  now?: () => number;
+  /** Calls back after a while (a timer that does not keep the app alive); the function it gives calls it off. */
+  later?: (callback: () => void, ms: number) => () => void;
+}
+
+const finite = (value: unknown): value is number => typeof value === 'number' && Number.isFinite(value);
+const measures = (value: unknown): value is number[] => Array.isArray(value) && value.every((entry) => finite(entry) && entry > 0);
+
+/** A reference as the file may hold it; anything else in its place is dropped and the part built again. */
+function keptReference(entry: unknown): PartReference | null {
+  const reference = entry as { partNumber?: unknown; shape?: Partial<Record<keyof PartShape, unknown>> | null } | null;
+  const shape = reference?.shape;
+  if (typeof reference?.partNumber !== 'string' || typeof shape !== 'object' || shape === null) return null;
+  const counts = [shape.faces, shape.edges, shape.vertices].every((count) => Number.isInteger(count) && (count as number) >= 0);
+  if (!finite(shape.volume) || shape.volume <= 0 || !finite(shape.area) || shape.area <= 0 || !counts || !measures(shape.faceAreas) || !measures(shape.perimeters) || !measures(shape.radii)) return null;
+  if (shape.faceAreas.length !== shape.faces) return null;
+  return { partNumber: reference.partNumber, shape: shape as PartShape };
+}
+
+/**
+ * References from `solidcraft-cli run`, one process for every part not known yet, never the same
+ * part in two processes. They are kept in a file per SolidCraft program (its version, size and
+ * date), so a part is built once, not with every start. Kept as well is SolidCraft's own answer
+ * that it does not build a part. Whatever else goes wrong (a crash, an answer that does not read,
+ * a file that cannot be written) says nothing about the part: it is remembered until PartBuddy
+ * ends, and a run that gave no answer is tried again after a while.
+ */
+export function cliReferences(options: PartReferenceOptions): PartReferences {
+  const { dir, log } = options;
+  const run = options.run ?? runCli(options.env ?? process.env);
+  const now = options.now ?? Date.now;
+  const later =
+    options.later ??
+    ((callback, ms) => {
+      const timer = setTimeout(callback, ms);
+      timer.unref();
+      return () => {
+        clearTimeout(timer);
+      };
+    });
+  /** Per program: what its file holds. A text in place of a reference is SolidCraft's reason not to build the part. */
+  type Store = { identity: string; parts: Map<string, PartReference | string> };
+  const stores = new Map<string, Promise<Store>>();
+  /** The store of a program once it was opened; undefined before. */
+  const opened = new Map<string, Store['parts']>();
+  const building = new Map<string, Promise<void>>();
+  /** What failed without SolidCraft refusing the part: not tried again by a mirror, until `at` where it has one. */
+  const failed = new Map<string, { reason: string; at?: number }>();
+  /** Runs without an answer, per part: after `RETRIES` the part is left alone until an export asks or PartBuddy starts again. */
+  const tries = new Map<string, number>();
+  /** The parts one timer builds again once their wait is over; a part is in here once. */
+  const waiting = new Map<string, { program: string; part: PartQuery }>();
+  let cancelTimer: (() => void) | null = null;
+  const key = (program: string, description: string) => `${program}\n${description}`;
+
+  const open = (program: string) => {
+    let store = stores.get(program);
+    if (!store) {
+      store = (async () => {
+        const [version, file] = await Promise.all([run(program, ['--version'], TIMEOUT_BASE_MS), stat(program)]);
+        const identity = `${String(STORE_FORMAT)} ${version.trim()} ${String(file.size)} ${String(Math.round(file.mtimeMs))}`;
+        const parts: Store['parts'] = new Map();
+        try {
+          const kept = JSON.parse(await readFile(join(dir, STORE_FILE), 'utf8')) as { identity?: unknown; parts?: unknown } | null;
+          if (kept?.identity === identity && typeof kept.parts === 'object' && kept.parts !== null) {
+            for (const [description, entry] of Object.entries(kept.parts as Record<string, unknown>)) {
+              const reference = typeof entry === 'string' ? entry.slice(0, 500) : keptReference(entry);
+              if (reference !== null && reference !== '') parts.set(description, reference);
+            }
+          }
+        } catch {
+          // No file yet, or one that does not read: every part is built again.
+        }
+        return { identity, parts };
+      })();
+      stores.set(program, store);
+      // A program that did not answer is asked again with the next part.
+      store.catch(() => stores.delete(program));
+    }
+    return store;
+  };
+
+  /** Builds the parts and keeps what SolidCraft made of each; gives the parts whose results did not read. */
+  const build = async (program: string, wanted: readonly PartQuery[], parts: Store['parts']): Promise<PartQuery[]> => {
+    await mkdir(dir, { recursive: true });
+    const script = join(dir, `parts-${now().toString(36)}-${Math.random().toString(36).slice(2, 8)}.json`);
+    const results = async (steps: unknown[]): Promise<unknown[]> => {
+      await writeFile(script, JSON.stringify(steps));
+      return JSON.parse(await run(program, ['run', script, '--results', '--quiet'], TIMEOUT_BASE_MS + TIMEOUT_PER_PART_MS * wanted.length)) as unknown[];
+    };
+    try {
+      // Two runs: how many faces a part has is known only once it is built, and a script cannot ask.
+      const first = await results(referenceScript(wanted));
+      const built = builtParts(wanted, first);
+      const references = built.length > 0 ? referencesOf(built, await results(faceScript(built))) : new Map<string, PartReference>();
+      const unread: PartQuery[] = [];
+      for (const [i, part] of wanted.entries()) {
+        const reference = references.get(part.description);
+        const described = (first[wanted.length + 1 + i] as { description?: unknown } | null | undefined)?.description;
+        if (reference) parts.set(part.description, reference);
+        else if (typeof described === 'string' && described !== part.description) parts.set(part.description, `SolidCraft builds "${described.slice(0, 200)}" for these words`);
+        else unread.push(part);
+      }
+      return unread;
+    } finally {
+      // A script that cannot be removed is no reason to lose the references.
+      await rm(script, { force: true }).catch(() => undefined);
+    }
+  };
+
+  /** One timer for all that wait: it builds what is due and goes on for the rest. It never lifts a wait itself. */
+  const arm = () => {
+    if (cancelTimer || waiting.size === 0) return;
+    const next = Math.min(...[...waiting.keys()].map((entry) => failed.get(entry)?.at ?? 0));
+    cancelTimer = later(
+      () => {
+        cancelTimer = null;
+        const due = new Map<string, PartQuery[]>();
+        for (const [entry, { program, part }] of waiting) {
+          const at = failed.get(entry)?.at;
+          // Built meanwhile, or given up: nothing to wait for.
+          if (at === undefined) waiting.delete(entry);
+          else if (at <= now()) {
+            waiting.delete(entry);
+            due.set(program, [...(due.get(program) ?? []), part]);
+          }
+        }
+        for (const parts of due.values()) {
+          try {
+            known(parts);
+          } catch (error) {
+            log(`no references for standard parts: ${(error as Error).message}`);
+          }
+        }
+        arm();
+      },
+      Math.max(next - now(), 1000),
+    );
+  };
+
+  const work = async (program: string, wanted: readonly PartQuery[]): Promise<void> => {
+    const store = await open(program);
+    const missing = wanted.filter((part) => !store.parts.has(part.description));
+    if (missing.length === 0) return;
+    const without = (part: PartQuery, cause: unknown) => {
+      const entry = key(program, part.description);
+      const reason = ((cause as Error).message || String(cause)).slice(0, 300);
+      let how = ' in this run of PartBuddy';
+      if (cause instanceof RefusedPartError) {
+        store.parts.set(part.description, reason);
+        how = '';
+      } else if (cause instanceof TransientCliError) {
+        const count = (tries.get(entry) ?? 0) + 1;
+        tries.set(entry, count);
+        if (count < RETRIES) {
+          failed.set(entry, { reason, at: now() + RETRY_AFTER_MS });
+          waiting.set(entry, { program, part });
+          how = ' for now';
+        } else {
+          failed.set(entry, { reason });
+          how = ` after ${String(RETRIES)} runs; it is not tried again in this run of PartBuddy`;
+        }
+      } else failed.set(entry, { reason });
+      log(`no reference for the standard part "${part.description}"${how}: ${reason}`);
+    };
+    const unread = new Error('the measures SolidCraft gave did not read');
+    try {
+      for (const part of await build(program, missing, store.parts)) without(part, unread);
+    } catch (error) {
+      // One description SolidCraft cannot build stops the whole script: the parts are built one by one, once.
+      if (missing.length === 1 || error instanceof TransientCliError) for (const part of missing) without(part, error);
+      else {
+        for (const part of missing) {
+          await build(program, [part], store.parts).then(
+            (odd) => {
+              for (const entry of odd) without(entry, unread);
+            },
+            (cause: unknown) => {
+              without(part, cause);
+            },
+          );
+        }
+      }
+    }
+    for (const part of missing) if (typeof store.parts.get(part.description) === 'object') tries.delete(key(program, part.description));
+    // Nobody asks again by itself after a run without an answer: once the wait is over the parts are built and the design mirrored.
+    arm();
+    await mkdir(dir, { recursive: true });
+    await writeFile(join(dir, STORE_FILE), JSON.stringify({ identity: store.identity, parts: Object.fromEntries(store.parts) })).catch((error: unknown) => {
+      log(`the standard part references were not kept: ${(error as Error).message}`);
+    });
+  };
+
+  /** `solidcraft-cli`, or why there is none: without it no part can be built here, now or in a moment. */
+  const program = (): string | { unavailable: string } => {
+    try {
+      return options.cli();
+    } catch (error) {
+      return { unavailable: (error as Error).message };
+    }
+  };
+
+  const known = (parts: readonly PartQuery[]): Map<string, ReferenceState> => {
+    const cli = program();
+    if (typeof cli !== 'string') return new Map(parts.map((part) => [part.description, cli]));
+    const have = opened.get(cli);
+    const states = new Map<string, ReferenceState>();
+    const wanted: PartQuery[] = [];
+    for (const part of parts) {
+      if (states.has(part.description)) continue;
+      const kept = have?.get(part.description);
+      const lost = failed.get(key(cli, part.description));
+      if (typeof kept === 'object') states.set(part.description, kept);
+      else if (typeof kept === 'string') states.set(part.description, { refused: kept });
+      else if (lost && (lost.at === undefined || lost.at > now())) states.set(part.description, { failed: lost.reason });
+      else {
+        states.set(part.description, { building: true });
+        if (!building.has(key(cli, part.description)) && wanted.length < PARTS_PER_RUN) wanted.push(part);
+      }
+    }
+    if (wanted.length > 0) {
+      const job = work(cli, wanted)
+        .then(
+          async () => {
+            opened.set(cli, (await open(cli)).parts);
+          },
+          (error: unknown) => {
+            // The program itself could not be asked (its version, its file): nothing says the parts cannot be built.
+            const reason = ((error as Error).message || String(error)).slice(0, 300);
+            for (const part of wanted) failed.set(key(cli, part.description), { reason });
+            log(`no references for standard parts in this run of PartBuddy: ${reason}`);
+          },
+        )
+        .finally(() => {
+          for (const part of wanted) building.delete(key(cli, part.description));
+          // With or without a reference, the parts are no longer "being built": the mirror says once more what each body is.
+          options.built?.();
+        });
+      for (const part of wanted) building.set(key(cli, part.description), job);
+    }
+    return states;
+  };
+
+  return {
+    known,
+    ready: async (parts) => {
+      const cli = program();
+      if (typeof cli !== 'string') return known(parts);
+      // Whoever waits is worth one more run for what failed before; SolidCraft's own refusals stay.
+      for (const part of parts) {
+        failed.delete(key(cli, part.description));
+        tries.delete(key(cli, part.description));
+      }
+      let states = known(parts);
+      for (let round = 0; round < READY_ROUNDS && [...states.values()].some((state) => 'building' in state); round += 1) {
+        await Promise.all(parts.flatMap((part) => building.get(key(cli, part.description)) ?? []));
+        states = known(parts);
+      }
+      return states;
+    },
+    forget: () => {
+      cancelTimer?.();
+      cancelTimer = null;
+      // What only waited for its next run is asked afresh by whoever shows the part again.
+      for (const entry of waiting.keys()) {
+        failed.delete(entry);
+        tries.delete(entry);
+      }
+      waiting.clear();
+    },
+  };
+}
diff --git a/apps/desktop/src/main/solidcraft/standardParts.ts b/apps/desktop/src/main/solidcraft/standardParts.ts
index 0c646b3..634e2f5 100644
--- a/apps/desktop/src/main/solidcraft/standardParts.ts
+++ b/apps/desktop/src/main/solidcraft/standardParts.ts
@@ -2,10 +2,10 @@ import type { PartFamily, PartsLibrary } from '../../shared/contract';
 
 /**
  * Standard parts (plan step B7): screws, nuts, washers, pins and bearings from SolidCraft's library
- * (`parts.insert`), seated in a hole as counterparts. They are not printed: PartBuddy keeps their
- * body names in the design's metadata, and export and the ready-to-print light leave them out.
+ * (`parts.insert`), seated in a hole as counterparts. They are not printed: the mirror tells them by
+ * what SolidCraft itself says of them (mirror.ts), and export and the ready-to-print light leave
+ * them out.
  */
-export const STANDARD_PARTS_KEY = 'io.github.manuelstaggl.partbuddy.standard-parts';
 
 /** The metric families PartBuddy offers, in the order of the menu. */
 export const PART_FAMILIES: PartFamily[] = ['socket_head_cap_screw', 'button_head_cap_screw', 'hex_bolt', 'set_screw', 'hex_nut', 'washer', 'dowel_pin', 'bearing'];
@@ -37,36 +37,56 @@ export function libraryOf(raw: unknown): PartsLibrary {
   return library;
 }
 
-/** The body names of standard parts kept in the design's metadata. */
-export function standardPartsOf(metadata: unknown): string[] {
-  const entry = (metadata as Record<string, unknown> | null)?.[STANDARD_PARTS_KEY] as { bodies?: unknown } | undefined;
-  return Array.isArray(entry?.bodies) ? entry.bodies.filter((name): name is string => typeof name === 'string' && name.length <= 200).slice(0, 500) : [];
+/** A part of the library, as `parts.insert` takes it; the length in mm, null for a part without one. */
+export interface LibraryPart {
+  family: string;
+  size: string;
+  length: number | null;
 }
 
 /**
- * The names of SolidCraft's part families (`parts.library`, 0.40.0-rc.2). `parts.insert` describes
- * every part it inserts as "<family name> <size>", e.g. "Button head cap screw M3x8" or "Deep groove
- * ball bearing (envelope) 608", and keeps that when the part or its body is renamed.
- * shortcut: fixed list; read it from `parts.library` if SolidCraft adds families.
+ * The length `parts.insert` writes after the size, in mm: "x8" and "x7.5" are millimetres (an inch
+ * part at a length off its list too), " x 3/4", " x 1-1/4" and " x 8" are inches. Undefined for
+ * any other text.
  */
-const LIBRARY_PARTS = [
-  'Socket head cap screw',
-  'Button head cap screw',
-  'Hex head bolt / screw',
-  'Hex nut',
-  'Plain washer',
-  'Hex socket set screw, flat point',
-  'Parallel pin (dowel)',
-  'Deep groove ball bearing (envelope)',
-  'Hex cap screw (inch)',
-  'Hex nut (inch)',
-  'Plain washer, SAE (narrow)',
-  'Plain washer, USS (wide)',
-];
+function lengthOf(text: string): number | null | undefined {
+  if (text === '') return null;
+  const metric = /^x(\d+(?:\.\d+)?)$/.exec(text);
+  if (metric) return Number(metric[1]);
+  const inch = /^ x (?:(\d+)|(?:(\d+)-)?(\d+)\/(\d+))$/.exec(text);
+  if (!inch) return undefined;
+  const inches = inch[1] !== undefined ? Number(inch[1]) : Number(inch[2] ?? 0) + Number(inch[3]) / Number(inch[4]);
+  return Number.isFinite(inches) ? inches * 25.4 : undefined;
+}
+
+/**
+ * The library part a component's description (`component.metadata`) names, as `parts.insert` wrote
+ * it: the name of a family, one of its sizes and, where the part has one, its length ("Button head
+ * cap screw M3x8", "Deep groove ball bearing (envelope) 608"). SolidCraft keeps it when the part or
+ * its body is renamed. Names and sizes are those `parts.library` answers with now, so a family
+ * SolidCraft adds is known without a change here, and a text that only begins like one ("Hex nut
+ * holder") names no part. The description alone proves nothing: the mirror holds the body against it.
+ */
+export function libraryPartOf(description: unknown, library: unknown): LibraryPart | null {
+  const families = (library as { families?: unknown } | null)?.families;
+  if (typeof description !== 'string' || !Array.isArray(families)) return null;
+  for (const family of families as ({ family?: unknown; name?: unknown; sizes?: unknown } | null)[]) {
+    const name = family?.name;
+    if (typeof family?.family !== 'string' || typeof name !== 'string' || name === '' || !Array.isArray(family.sizes) || !description.startsWith(`${name} `)) continue;
+    const rest = description.slice(name.length + 1);
+    for (const entry of family.sizes as ({ size?: unknown } | null)[]) {
+      const size = entry?.size;
+      if (typeof size !== 'string' || size === '' || !rest.startsWith(size)) continue;
+      const length = lengthOf(rest.slice(size.length));
+      if (length !== undefined) return { family: family.family, size, length };
+    }
+  }
+  return null;
+}
 
-/** Whether a component's description (`component.metadata`) is one `parts.insert` gave it. */
-export function isLibraryPart(description: unknown): boolean {
-  return typeof description === 'string' && LIBRARY_PARTS.some((family) => description.startsWith(`${family} `));
+/** Whether a description is one `parts.insert` writes for a part of the library. */
+export function isLibraryPart(description: unknown, library: unknown): boolean {
+  return libraryPartOf(description, library) !== null;
 }
 
 /** A body name that is not taken yet: `SHCS M3x12`, `SHCS M3x12 (2)` … */
diff --git a/apps/desktop/src/main/solidcraft/supervisor.ts b/apps/desktop/src/main/solidcraft/supervisor.ts
index bc71797..5550fe3 100644
--- a/apps/desktop/src/main/solidcraft/supervisor.ts
+++ b/apps/desktop/src/main/solidcraft/supervisor.ts
@@ -18,15 +18,18 @@ import { logoAt, planLogoMove } from './logoMove';
 import { blockBodies, colourLayers, planeAt, stepsOf, type FeatureBlock } from '../../shared/blocks';
 import { centring, hostFace, movedPlane, TEXT_PREFIX, uniqueLogoName } from '../../shared/drawingPlacement';
 import { insertCommand, type ImportKind } from '../projects/importFile';
-import { freeBodyName, libraryOf, STANDARD_PARTS_KEY, standardPartsOf } from './standardParts';
+import { freeBodyName, libraryOf } from './standardParts';
+import { cliReferences, type PartReferences } from './partReference';
 import { ProjectStore } from '../projects/projectStore';
 import { HeadlessEngine, safeDesignFileName } from './headless';
 import { supervisorMachine, type DiscoveryResult, type Launched, type SupervisorActor, type SupervisorEvent } from './machine';
 import type { DesignHistory } from '../agents/workLog';
-import { count, mirrorActiveDesign, MirrorScheduler, type BatchResult, type ControlRequester } from './mirror';
+import { boughtParts, count, hardwareOf, mirrorActiveDesign, MirrorScheduler, type BatchResult, type BoughtPart, type ControlRequester, type PartChecks } from './mirror';
 
 export interface SupervisorOptions {
   environment: Environment;
+  /** For tests: the standard part references instead of `solidcraft-cli`'s; `built` is to be called when one arrives. */
+  partReferences?: (built: () => void) => PartReferences;
   /** Control port used when PartBuddy starts SolidCraft (decided 2026-11-04: 7878). */
   launchPort: number;
   /** Start SolidCraft on the first search when none runs. */
@@ -111,6 +114,14 @@ export class SolidCraftSupervisor {
   /** The name the assistant's plan gave a new design (a body like "Base" names a case badly), until it has a project. */
   private plannedName: string | null = null;
   private readonly scheduler: MirrorScheduler;
+  /**
+   * How the mirror tells standard parts: the log, and each part as `solidcraft-cli` builds it. The
+   * mirror does not wait for a part being built (its body counts as printed until the mirror that
+   * follows); what leaves PartBuddy does (`settledChecks`): an export must not go out with a screw in it.
+   */
+  private readonly partChecks: PartChecks;
+  private readonly settledChecks: PartChecks;
+  private readonly references: PartReferences;
   private readonly dimensions: DimensionService;
   private readonly actions: ActionService;
   /** Probes run one after another; SolidCraft runs one batch at a time anyway. */
@@ -125,15 +136,20 @@ export class SolidCraftSupervisor {
     // Every path PartBuddy hands SolidCraft is made from the cache folder (exports, scripts, allow_paths).
     this.options = { ...options, cacheDir: longPath(options.cacheDir) };
     const { cacheDir } = this.options;
+    const log = (message: string) => options.log(message);
+    const references = options.partReferences?.(() => this.scheduler.refresh()) ?? cliReferences({ cli: () => this.cli(), dir: cacheDir, log, env: options.environment.env, built: () => this.scheduler.refresh() });
+    this.references = references;
+    this.partChecks = { log, references: references.known };
+    this.settledChecks = { log, references: references.ready };
     this.dimensions = new DimensionService(() => this.requester(), cacheDir);
     this.actions = new ActionService(() => this.requester(), cacheDir);
     this.designs = options.designsDir && options.projectsDir ? new ProjectStore(options.projectsDir, options.designsDir, options.newPartName) : null;
     this.scheduler = new MirrorScheduler(
       () => {
-        if (this.engine?.isOpen) return mirrorActiveDesign(this.engine.requester, cacheDir);
+        if (this.engine?.isOpen) return mirrorActiveDesign(this.engine.requester, cacheDir, this.partChecks);
         const client = this.client;
         if (!client?.isOpen) return Promise.reject(new Error('not connected'));
-        return mirrorActiveDesign(client, cacheDir);
+        return mirrorActiveDesign(client, cacheDir, this.partChecks);
       },
       {
         started: () => {
@@ -216,11 +232,9 @@ export class SolidCraftSupervisor {
    * SolidCraft writes into the cache folder only (its allowed folders); PartBuddy copies the file
    * from there, so the user may save anywhere without widening what SolidCraft may write.
    */
-  async exportDesign(format: ExportFormat, destination: string): Promise<void> {
+  async exportDesign(format: ExportFormat, destination: string): Promise<{ unverified: string[] }> {
     const requester = this.requester();
-    // Standard parts (B7) are counterparts: they are not printed, so they are not exported.
-    const standard = new Set(this.latest?.structure.standardParts ?? []);
-    const bodies = this.latest?.bodies.map((body) => body.name).filter((name) => !standard.has(name)) ?? [];
+    const { bodies, unverified } = await this.printedBodies();
     if (bodies.length === 0) throw new Error('the design has no body to export');
     // The file keeps the name the user chose: STEP and 3MF carry it as the part's name.
     const folder = join(this.options.cacheDir, `export-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`);
@@ -238,6 +252,7 @@ export class SolidCraftSupervisor {
     } finally {
       await rm(folder, { recursive: true, force: true });
     }
+    return { unverified };
   }
 
   /**
@@ -305,8 +320,7 @@ export class SolidCraftSupervisor {
 
   /** The size of each printed body (F5), from `inspect.measure`; null where SolidCraft gave none. */
   async bodySizes(): Promise<{ name: string; size: [number, number, number] | null }[]> {
-    const standard = new Set(this.latest?.structure.standardParts ?? []);
-    const bodies = this.latest?.bodies.map((body) => body.name).filter((name) => !standard.has(name)) ?? [];
+    const { bodies } = await this.printedBodies();
     if (bodies.length === 0) return [];
     const reply = await this.requester().request<BatchResult>('engine.batch', { commands: [{ command: 'inspect.measure', params: { bodies } }], rollback: false }, 60_000);
     const measured = reply.failed ? [] : ((reply.results[0] as { bodies?: unknown } | undefined)?.bodies ?? []);
@@ -322,22 +336,44 @@ export class SolidCraftSupervisor {
   }
 
   /**
-   * The standard parts to buy, counted (`assembly.bom`), for the sharing package. Only rows with a
-   * part number: the library's screws and nuts have one ("ISO 4762 M3x12"), imported counterparts not.
+   * The standard parts to buy, counted, for the sharing package: the parts the mirror keeps out of
+   * print check and export, read anew by the same recognition, so nothing is listed both to print
+   * and to buy and no bought part is missing.
    */
   async hardware(): Promise<{ count: number; name: string; standard: string }[]> {
-    const reply = await this.requester().request<BatchResult>('engine.batch', { commands: [{ command: 'assembly.bom', params: {} }], rollback: false }, 60_000);
+    const { parts, listing } = await this.standardParts();
+    return hardwareOf(parts, listing);
+  }
+
+  /**
+   * The standard parts as the design stands now, every reference waited for, with the
+   * `component.list` they were read from. It fails, naming the bodies, when one could not be
+   * checked for now: an export must not go out with a screw in it without a word. Where no part can
+   * be checked at all (`solidcraft-cli` is missing) nothing would ever go out, so those bodies count
+   * as printed, are exported, and are named in `unverified` for a word to the user.
+   */
+  private async standardParts(): Promise<{ parts: BoughtPart[]; listing: unknown; unverified: string[] }> {
+    const requester = this.requester();
+    const reply = await requester.request<BatchResult>('engine.batch', { commands: [{ command: 'component.list', params: {} }], rollback: false }, 60_000);
     if (reply.failed) throw new Error(reply.failed.error);
-    const rows = (reply.results[0] as { rows?: unknown } | undefined)?.rows;
-    if (!Array.isArray(rows)) return [];
-    return (rows as Record<string, unknown>[])
-      .filter((row) => typeof row.part_number === 'string' && row.part_number.trim() !== '' && typeof row.count === 'number' && row.count > 0)
-      .slice(0, 100)
-      .map((row) => ({
-        count: row.count as number,
-        name: (typeof row.description === 'string' && row.description.trim() ? row.description : String(row.definition ?? row.part_number)).slice(0, 200),
-        standard: (row.part_number as string).slice(0, 200),
-      }));
+    const told = await boughtParts(requester, reply.results[0], this.settledChecks);
+    const open = [...told.unchecked, ...told.pending.map((body) => `"${body}": its part is still being built`)];
+    if (open.length > 0) {
+      this.options.log(`not exported: standard parts could not be told from printed bodies (${open.join('; ')})`);
+      throw new Error(`nothing was written, because it is not known whether these are bought standard parts: ${open.slice(0, 3).join('; ').slice(0, 130)}`);
+    }
+    if (told.unverified.length > 0) this.options.log(`exported as printed bodies, not checked as standard parts: ${told.unverified.join(', ')}`);
+    return { parts: told.bought, listing: reply.results[0], unverified: told.unverified };
+  }
+
+  /**
+   * The mirrored bodies that are printed: all but the standard parts (B7), which are counterparts.
+   * Read anew rather than from the last mirror, which may still wait for a part's reference.
+   */
+  private async printedBodies(): Promise<{ bodies: string[]; unverified: string[] }> {
+    const { parts, unverified } = await this.standardParts();
+    const standard = new Set(parts.map((part) => part.body));
+    return { bodies: this.latest?.bodies.map((body) => body.name).filter((name) => !standard.has(name)) ?? [], unverified };
   }
 
   /** `solidcraft-cli` beside the SolidCraft PartBuddy uses. */
@@ -453,11 +489,10 @@ export class SolidCraftSupervisor {
    * Opens the printable bodies in a slicer SolidCraft found (B8, `file.send_to_slicer`): standard
    * parts stay out, each body lies on its print face. The slicer is started without waiting for it.
    */
-  async sendToSlicer(slicer: string): Promise<string> {
+  async sendToSlicer(slicer: string): Promise<{ name: string; unverified: string[] }> {
     const found = (await this.slicers()).find((candidate) => candidate.id === slicer);
     if (!found) throw new Error('this slicer is not installed');
-    const standard = new Set(this.latest?.structure.standardParts ?? []);
-    const bodies = this.latest?.bodies.map((body) => body.name).filter((name) => !standard.has(name)) ?? [];
+    const { bodies, unverified } = await this.printedBodies();
     if (bodies.length === 0) throw new Error('the design has no body to print');
     const reply = await this.requester().request<BatchResult>(
       'engine.batch',
@@ -465,7 +500,7 @@ export class SolidCraftSupervisor {
       2 * 60 * 1000,
     );
     if (reply.failed) throw new Error(reply.failed.error);
-    return found.name;
+    return { name: found.name, unverified };
   }
 
   /**
@@ -500,8 +535,8 @@ export class SolidCraftSupervisor {
 
   /**
    * Seats a standard part in the hole at a point of its wall (B7, `parts.insert` with a rigid
-   * joint). Its body gets the part's name (`SHCS M3x12`) and is noted as a standard part in the
-   * design's metadata, so export and the ready-to-print light leave it out. Returns the body name.
+   * joint). Its body gets the part's name (`SHCS M3x12`); that it is a standard part the mirror tells
+   * from the component SolidCraft made, as for a part the assistant put in. Returns the body name.
    */
   async insertPart(part: PartInsert): Promise<string | null> {
     await this.probing;
@@ -515,21 +550,15 @@ export class SolidCraftSupervisor {
     );
     if (reply.failed) throw new Error(reply.failed.error);
     const inserted = reply.results[0] as { name?: unknown } | undefined;
-    const inspect = reply.results[1] as { bodies?: { name?: unknown }[]; metadata?: unknown } | undefined;
+    const inspect = reply.results[1] as { bodies?: { name?: unknown }[] } | undefined;
     const names = (inspect?.bodies ?? []).map((body) => body.name).filter((name): name is string => typeof name === 'string');
     const added = names.filter((name) => !before.has(name));
     let body: string | null = added[0] ?? null;
-    if (body) {
-      const steps: { command: string; params: Record<string, unknown> }[] = [];
-      if (added.length === 1 && typeof inserted?.name === 'string') {
-        const wanted = freeBodyName(inserted.name, names);
-        steps.push({ command: 'body.rename', params: { body, name: wanted } });
-        body = wanted;
-      }
-      const marked = [...standardPartsOf(inspect?.metadata).filter((name) => names.includes(name)), ...(added.length === 1 ? [body] : added)];
-      steps.push({ command: 'document.metadata.set', params: { values: { [STANDARD_PARTS_KEY]: { bodies: marked } } } });
-      const naming = await requester.request<BatchResult>('engine.batch', { commands: steps, rollback: false }, 60_000);
+    if (body && added.length === 1 && typeof inserted?.name === 'string') {
+      const wanted = freeBodyName(inserted.name, names);
+      const naming = await requester.request<BatchResult>('engine.batch', { commands: [{ command: 'body.rename', params: { body, name: wanted } }], rollback: false }, 60_000);
       if (naming.failed) this.options.log(`the standard part was not named: ${naming.failed.error}`);
+      else body = wanted;
     }
     await this.engine?.checkForChange();
     return body;
@@ -1190,6 +1219,7 @@ export class SolidCraftSupervisor {
       // Only when that fails does the engine end and start again with the next project.
       const engine = this.engine;
       this.scheduler.reset();
+      this.references.forget();
       this.latest = null;
       this.savedAs = null;
       this.plannedName = null;
@@ -1229,6 +1259,7 @@ export class SolidCraftSupervisor {
       const engine = this.engine;
       this.engine = null;
       this.scheduler.reset();
+      this.references.forget();
       await engine?.close();
     } else if ((this.options.launchMode ?? 'window') === 'headless') {
       return this.launchHeadless(executable);
@@ -1308,6 +1339,7 @@ export class SolidCraftSupervisor {
       const offClose = engine.onClose((reason) => {
         this.engine = null;
         this.scheduler.reset();
+        this.references.forget();
         sendBack({ type: 'LOST', reason });
       });
       return () => {
@@ -1333,6 +1365,7 @@ export class SolidCraftSupervisor {
     const offClose = client.onClose((reason) => {
       this.client = null;
       this.scheduler.reset();
+      this.references.forget();
       sendBack({ type: 'LOST', reason });
     });
     return () => {
diff --git a/apps/desktop/src/renderer/src/i18n/de.json b/apps/desktop/src/renderer/src/i18n/de.json
index b0036ba..d59837a 100644
--- a/apps/desktop/src/renderer/src/i18n/de.json
+++ b/apps/desktop/src/renderer/src/i18n/de.json
@@ -555,6 +555,7 @@
     "openedInSolidCraft": "Das Design liegt in Dokumente\\PartBuddy und öffnet sich in SolidCraft. PartBuddy zeigt deine Änderungen dort live.",
     "failed": "Das hat nicht geklappt: {detail}",
     "sentToSlicer": "In {name} geöffnet.",
+    "uncheckedParts": "Als Druckteile enthalten, weil PartBuddy hier nicht prüfen konnte, ob es gekaufte Normteile sind (das Kommandozeilenprogramm von SolidCraft fehlt): {bodies}.",
     "slicer": {
       "title": "Im Slicer öffnen",
       "open": "In {name} öffnen",
diff --git a/apps/desktop/src/renderer/src/i18n/en.json b/apps/desktop/src/renderer/src/i18n/en.json
index 9ddb47b..a41aa89 100644
--- a/apps/desktop/src/renderer/src/i18n/en.json
+++ b/apps/desktop/src/renderer/src/i18n/en.json
@@ -555,6 +555,7 @@
     "openedInSolidCraft": "The design is in Documents\\PartBuddy and opens in SolidCraft. PartBuddy shows your changes there live.",
     "failed": "That did not work: {detail}",
     "sentToSlicer": "Opened in {name}.",
+    "uncheckedParts": "Included as printed parts, because PartBuddy could not check here whether they are bought standard parts (SolidCraft's command-line program is missing): {bodies}.",
     "slicer": {
       "title": "Open in the slicer",
       "open": "Open in {name}",
diff --git a/apps/desktop/src/renderer/src/print/usePrintCheck.ts b/apps/desktop/src/renderer/src/print/usePrintCheck.ts
index b327240..eb43137 100644
--- a/apps/desktop/src/renderer/src/print/usePrintCheck.ts
+++ b/apps/desktop/src/renderer/src/print/usePrintCheck.ts
@@ -25,7 +25,8 @@ export function usePrintCheck(): void {
     }
     const timer = setTimeout(() => {
       // Standard parts (B7) are counterparts and are not printed.
-      const standard = new Set(model.structure.standardParts ?? []);
+      // A body whose part SolidCraft is still building is neither yet; the mirror that follows says which, and the check runs again.
+      const standard = new Set([...(model.structure.standardParts ?? []), ...(model.structure.pendingParts ?? [])]);
       const printed = model.bodies.filter((body) => !standard.has(body.name)).map((body) => ({ ...body, printFace: printFaces[body.name] }));
       const result = checkPrint(printed, { bed: print.printer.bed, nozzle: print.printer.nozzle, overhang: print.material.overhang }, model.structure.features);
       // A value that follows another through a motion link (a gear) is neither swept nor posed on its own: its driver is.
diff --git a/apps/desktop/src/renderer/src/shell/DesignActions.tsx b/apps/desktop/src/renderer/src/shell/DesignActions.tsx
index d4eb1ea..a6be96c 100644
--- a/apps/desktop/src/renderer/src/shell/DesignActions.tsx
+++ b/apps/desktop/src/renderer/src/shell/DesignActions.tsx
@@ -99,22 +99,25 @@ export function DesignActions() {
     };
   }, [canUndo, canRedo, undo, redo]);
 
+  // Bodies that look like bought standard parts but could not be checked went along as printed ones: the user hears it with the result.
+  const unchecked = (bodies: string[] | undefined) => (bodies && bodies.length > 0 ? ` ${t('actions.uncheckedParts', { bodies: bodies.slice(0, 5).join(', '), count: bodies.length })}` : '');
+
   // A red ready-to-print check asks once before the export (M7); it does not stop it.
   const exportNow = (target: ExportTarget) => {
     void run(async () => {
       if (target.startsWith('slicer:')) {
         // To the slicer (B8): SolidCraft starts it with the printable bodies on their print faces.
-        const { name } = await platform().design.sendToSlicer(target.slice('slicer:'.length));
-        return t('actions.sentToSlicer', { name });
+        const { name, unverified } = await platform().design.sendToSlicer(target.slice('slicer:'.length));
+        return `${t('actions.sentToSlicer', { name })}${unchecked(unverified)}`;
       }
       if (target === 'share') {
         // The sharing package (F5): the main process opens its folder in Explorer.
-        const { folder } = await platform().design.share();
-        return t('actions.share.done', { folder });
+        const { folder, unverified } = await platform().design.share();
+        return `${t('actions.share.done', { folder })}${unchecked(unverified)}`;
       }
       const result = await platform().design.export(target as ExportFormat);
       if (!result) return null;
-      return t('actions.exported', { file: result.file });
+      return `${t('actions.exported', { file: result.file })}${unchecked(result.unverified)}`;
     });
   };
 
diff --git a/apps/desktop/src/shared/api.ts b/apps/desktop/src/shared/api.ts
index b0e4e82..ae9d2b5 100644
--- a/apps/desktop/src/shared/api.ts
+++ b/apps/desktop/src/shared/api.ts
@@ -213,7 +213,7 @@ export interface PartBuddyApi {
     /** The slicers SolidCraft found (B8): Bambu Studio, OrcaSlicer and others. */
     slicers(): Promise<Slicer[]>;
     /** Opens the printable bodies in a slicer, laid on their print face; returns the slicer's name. */
-    sendToSlicer(slicer: string): Promise<{ name: string }>;
+    sendToSlicer(slicer: string): Promise<{ name: string; unverified?: string[] | undefined }>;
     /** Marks the flat face at a point as the body's print face, or clears it (null). */
     setPrintFace(body: string, point: [number, number, number] | null, face?: string): Promise<void>;
     /** The print faces PartBuddy set in the open project, by body (for the plate view). */
diff --git a/apps/desktop/src/shared/contract.ts b/apps/desktop/src/shared/contract.ts
index 77f6acf..a710876 100644
--- a/apps/desktop/src/shared/contract.ts
+++ b/apps/desktop/src/shared/contract.ts
@@ -164,6 +164,8 @@ export const structureSchema = z
     sketches: z.array(z.object({ id: z.number().int().nonnegative(), name: z.string().max(200), visible: z.boolean() }).strict()).max(2000),
     /** Bodies that are standard parts (B7): counterparts, neither exported nor checked for printing. */
     standardParts: z.array(z.string().max(200)).max(500).optional(),
+    /** Bodies whose standard part SolidCraft is still building: neither printed nor bought until the mirror that follows, so the print check leaves them out for that moment. */
+    pendingParts: z.array(z.string().max(200)).max(500).optional(),
     /** The joints of parts that move against each other (ADR 0027); left out when there are none. */
     joints: z.array(jointSchema).max(200).optional(),
   })
@@ -666,9 +668,11 @@ export const exportRequestSchema = z.object({ format: exportFormatSchema }).stri
 export const videoSaveSchema = z
   .object({ bytes: z.instanceof(Uint8Array).refine((bytes) => bytes.length > 0 && bytes.length <= 64 * 1024 * 1024, 'no video, or one over 64 MB'), format: z.enum(['mp4', 'webm']) })
   .strict();
-export const exportResultSchema = z.object({ file: z.string().min(1).max(260) }).strict().nullable();
+/** Bodies described as standard parts that went along as printed ones because none could be checked (`solidcraft-cli` is missing): the user is told. */
+const unverifiedPartsSchema = z.array(z.string().max(200)).max(500).optional();
+export const exportResultSchema = z.object({ file: z.string().min(1).max(260), unverified: unverifiedPartsSchema }).strict().nullable();
 /** The sharing package (F5): its folder's name inside the project's exports, never the full path. */
-export const shareResultSchema = z.object({ folder: z.string().min(1).max(260) }).strict();
+export const shareResultSchema = z.object({ folder: z.string().min(1).max(260), unverified: unverifiedPartsSchema }).strict();
 
 /** The dimension field at a selection (M1b): an edge length or the radius of a cylindrical face. */
 export const dimensionTargetSchema = z.discriminatedUnion('measure', [
@@ -1248,7 +1252,7 @@ export const invokeContract = {
   [invokeChannels.designPreviewLogoMove]: { request: logoMoveSchema, response: actionPreviewSchema },
   [invokeChannels.designMoveLogo]: { request: logoMoveSchema, response: none },
   [invokeChannels.designSlicers]: { request: none, response: slicersSchema },
-  [invokeChannels.designSendToSlicer]: { request: sendToSlicerSchema, response: z.object({ name: z.string().max(120) }).strict() },
+  [invokeChannels.designSendToSlicer]: { request: sendToSlicerSchema, response: z.object({ name: z.string().max(120), unverified: unverifiedPartsSchema }).strict() },
   [invokeChannels.designPrintFace]: { request: printFaceSchema, response: none },
   [invokeChannels.designPrintFaces]: { request: none, response: printFacesSchema },
   [invokeChannels.designInsertPart]: { request: partInsertSchema, response: partInsertResultSchema },
diff --git a/apps/desktop/test/agent.test.ts b/apps/desktop/test/agent.test.ts
index 4b488c6..35d5e61 100644
--- a/apps/desktop/test/agent.test.ts
+++ b/apps/desktop/test/agent.test.ts
@@ -1,7 +1,7 @@
 import { existsSync, mkdtempSync, readFileSync, readdirSync, rmSync } from 'node:fs';
 import { request } from 'node:http';
 import { tmpdir } from 'node:os';
-import { join, resolve } from 'node:path';
+import { join, resolve, sep } from 'node:path';
 
 import { Client, StreamableHTTPClientTransport } from '@modelcontextprotocol/client';
 import { afterEach, describe, expect, it, vi } from 'vitest';
@@ -9,7 +9,8 @@ import { afterEach, describe, expect, it, vi } from 'vitest';
 import { AgentService } from '../src/main/agents/agentService';
 import { findClaudeCode, parseStreamLine } from '../src/main/agents/claudeCode';
 import { GateProxy, REPEAT_REASON, type ToolCallRecord, type UpstreamTools } from '../src/main/agents/gateProxy';
-import { decide } from '../src/main/agents/policy';
+import { photoFile, photoNote } from '../src/main/agents/photoNote';
+import { decide, TOOL_ARGUMENTS } from '../src/main/agents/policy';
 import { TOOL_NOTES } from '../src/main/agents/toolNotes';
 import { reduce, type ConversationItem } from '../src/renderer/src/assistant/store';
 import type { AgentEvent, AgentStatus, ModelChoice } from '../src/shared/contract';
@@ -85,6 +86,139 @@ describe('tool policy', () => {
     expect(decide('execute', { command: 'construct.point.along_path', params: { path: 'l1', t: 0.5 } }).allow).toBe(true);
     expect(decide('execute', { command: 'component.activate', params: { component: 1, path: [2, 3] } }).allow).toBe(true);
   });
+
+  it('refuses to write a component\'s description, which tells a bought part from a printed one (audit H-01)', () => {
+    // Measured with SolidCraft 0.40.1: after this call the 0.3 mm lid was a "standard part", out of print check and export.
+    const forged = decide('execute', { command: 'component.metadata.set', params: { component: 'Deckel', description: 'Hex nut M3' } });
+    expect(forged.allow).toBe(false);
+    if (!forged.allow) expect(forged.reason).toContain('parts.insert');
+    // The other form SolidCraft takes, as a batch step, and with an empty text (which removes a real part's description).
+    expect(decide('execute', { command: 'component.metadata.set', params: { component: 'Deckel', values: { description: 'Hex nut M3' } } }).allow).toBe(false);
+    expect(decide('batch', { commands: [{ command: 'component.metadata.set', params: { component: 3, description: 'Plain washer M3' } }] }).allow).toBe(false);
+    expect(decide('batch', { commands: [{ command: 'execute', params: { command: 'component.metadata.set', params: { component: 3, description: '' } } }] }).allow).toBe(false);
+    // What says nothing about bought or printed stays: other properties, the name, reading.
+    expect(decide('execute', { command: 'component.metadata.set', params: { component: 'Deckel', revision: 'B', properties: { description: 'Hex nut M3' } } }).allow).toBe(true);
+    expect(decide('execute', { command: 'component.rename', params: { component: 'Deckel', name: 'Hex nut M3' } }).allow).toBe(true);
+    expect(decide('execute', { command: 'component.metadata', params: { component: 'Deckel' } }).allow).toBe(true);
+    expect(decide('execute', { command: 'parts.insert', params: { family: 'hex_nut', size: 'M3' } }).allow).toBe(true);
+  });
+
+  it('lets a tool of SolidCraft through only with the arguments it is known to take, and with no file but a photo the user sent', () => {
+    // Measured with SolidCraft 0.40.1: screenshot {path} wrote its PNG (442 140 bytes) over a JSON file in the cache folder.
+    const cache = join(tmpdir(), 'PartBuddy', 'cache', 'part-references.json');
+    const screenshot = decide('screenshot', { path: cache });
+    expect(screenshot.allow).toBe(false);
+    if (!screenshot.allow) expect(screenshot.reason).toContain('Leave out path');
+    expect(decide('screenshot', { path: 'new.png', view: 'iso' }).allow).toBe(false);
+    expect(decide('screenshot', { view: 'iso', width: 800 })).toEqual({ allow: true });
+    // A skill's document goes by its name.
+    expect(decide('skill_reference', { skill: 'solidcraft-modeling', file: 'SKILL.md' })).toEqual({ allow: true });
+    expect(decide('skill_reference', { skill: 'solidcraft-modeling' })).toEqual({ allow: true });
+    expect(decide('skill_reference', { skill: 'solidcraft-modeling', file: '../../secret.md' }).allow).toBe(false);
+    // Every tool let through has its arguments listed, and takes each of them.
+    const tools = ['list_commands', 'describe_command', 'execute', 'batch', 'inspect_design', 'measure', 'body_topology', 'set_parameter', 'check_parameters', 'screenshot', 'compare_picture', 'running', 'pending', 'undo', 'redo', 'skill_reference'];
+    expect(Object.keys(TOOL_ARGUMENTS).sort()).toEqual([...tools].sort());
+    const steps = ['set_parameter', 'list_commands', 'describe_command', 'execute', 'measure', 'compare_picture', 'inspect_design', 'undo', 'redo'];
+    for (const tool of tools) {
+      expect(decide(tool, {}), tool).toEqual({ allow: true });
+      for (const argument of TOOL_ARGUMENTS[tool] ?? []) {
+        if (['reference', 'file', 'commands', 'command', 'params'].includes(argument)) continue;
+        expect(decide(tool, { [argument]: 1 }), `${tool} ${argument}`).toEqual({ allow: true });
+      }
+      // An argument that is not listed is refused, whatever it is called: a later SolidCraft may write a file with it.
+      for (const argument of ['path', 'file', 'reference', 'output', 'out', 'filename', 'dest', 'image', 'dir', 'depth']) {
+        if ((TOOL_ARGUMENTS[tool] ?? []).includes(argument)) continue;
+        const decision = decide(tool, { [argument]: cache });
+        expect(decision.allow, `${tool} ${argument}`).toBe(false);
+        // The same as a batch step, for the tools SolidCraft runs as steps.
+        if (steps.includes(tool)) expect(decide('batch', { commands: [{ command: tool, params: { [argument]: cache } }] }).allow, `batch step ${tool} ${argument}`).toBe(false);
+      }
+    }
+    const unknown = decide('measure', { dest: 'x' });
+    if (!unknown.allow) expect(unknown.reason).toBe('measure takes no argument dest in PartBuddy; its arguments are: body, items, names_only, summary.');
+    // An engine command reads a file through `file` as well as through `path`.
+    expect(decide('execute', { command: 'sketch.replace', params: { from: 'Sketch1', file: cache } }).allow).toBe(false);
+    expect(decide('batch', { commands: [{ command: 'Sketch.Replace', params: { from: 'Sketch1', file: 'other.sc' } }] }).allow).toBe(false);
+    // A geometry reference is no file.
+    expect(decide('execute', { command: 'construct.plane.tangent', params: { reference: 'XY', face: [0, 0, 1] } })).toEqual({ allow: true });
+    // PartBuddy's own tools are not SolidCraft's: a drawing is named, not read from a path the assistant gives.
+    expect(decide('partbuddy_place_drawing', { file: 'logo.svg', body: 'Cube' })).toEqual({ allow: true });
+  });
+
+  it('takes for the user\'s photo only the file PartBuddy kept, not a path that looks like one (last review, 4)', () => {
+    const project = join(tmpdir(), 'PartBuddy', 'Hook');
+    const photo = photoFile(project, new Date(2026, 10, 12, 10, 15, 0));
+    const calls = (reference: string): [string, Record<string, unknown>][] => [
+      ['compare_picture', { reference, view: 'top' }],
+      ['execute', { command: 'inspect.compare_picture', params: { reference } }],
+      ['execute', { command: 'canvas.insert', params: { path: reference, plane: 'XY', width: 120 } }],
+      ['batch', { commands: [{ command: 'compare_picture', params: { reference } }] }],
+    ];
+    // Before PartBuddy kept and named it, the path is a path like any other.
+    for (const [tool, args] of calls(photo)) expect(decide(tool, args).allow, `${tool} before`).toBe(false);
+    photoNote([photo]);
+    for (const [tool, args] of calls(photo)) expect(decide(tool, args), tool).toEqual({ allow: true });
+    // The same file as the model copies it: forward slashes, another case.
+    for (const [tool, args] of calls(photo.replaceAll('\\', '/'))) expect(decide(tool, args), tool).toEqual({ allow: true });
+    expect(decide('compare_picture', { reference: photo.toUpperCase().replace('.PNG', '.png').replace('PHOTOS', 'photos').replace('PHOTO-', 'photo-') })).toEqual({ allow: true });
+    const name = 'photo-20261112-101500.png';
+    const others: Record<string, string> = {
+      'another project': join(tmpdir(), 'PartBuddy', 'OTHER', 'photos', name),
+      'a photo not kept': photoFile(project, new Date(2026, 10, 12, 10, 15, 1)),
+      'a network share': `//server/share/photos/${name}`,
+      'a network share with backslashes': `\\\\server\\share\\photos\\${name}`,
+      'a device path': `\\\\.\\${photo}`,
+      'a long path prefix': `\\\\?\\${photo}`,
+      'a relative path': `photos/${name}`,
+      'a path from the working folder': `Hook/photos/${name}`,
+      'a short 8.3 name': photo.replace('PartBuddy', 'PARTBU~1'),
+      'a way round': [project, 'photos', '..', 'photos', name].join(sep),
+      'another file': join(project, 'photos', 'holiday.png'),
+    };
+    for (const [what, reference] of Object.entries(others)) {
+      for (const [tool, args] of calls(reference)) expect(decide(tool, args).allow, `${what}: ${tool}`).toBe(false);
+    }
+    expect(decide('compare_picture', { reference: [photo] }).allow).toBe(false);
+  });
+
+  it('decides a command id in any spelling SolidCraft runs: every rule holds for mixed case', () => {
+    // Measured with SolidCraft 0.40.1: each of these ran as written and was allowed, because the rules compared the id exactly.
+    const set = { component: 'Deckel', description: 'Hex nut M3' };
+    const key = 'io.github.manuelstaggl.partbuddy.standard-parts';
+    const refused: [string, Record<string, unknown>][] = [
+      ['execute', { command: 'Component.Metadata.Set', params: set }],
+      ['batch', { commands: [{ command: 'COMPONENT.METADATA.SET', params: set }] }],
+      ['batch', { commands: [{ command: 'execute', params: { command: 'COMPONENT.METADATA.SET', params: set } }] }],
+      ['execute', { command: 'Document.Metadata.Set', params: { values: { [key]: { bodies: ['Deckel'] } } } }],
+      ['execute', { command: 'Document.Metadata.Remove', params: { key } }],
+      ['execute', { command: 'Edit.Checkpoint', params: {} }],
+      ['execute', { command: 'EDIT.RESTORE_CHECKPOINT', params: { checkpoint: 1 } }],
+      ['execute', { command: 'File.Export', params: { format: 'stl' } }],
+      ['execute', { command: 'Doc.recovery_list', params: {} }],
+      ['execute', { command: 'Settings.profile.apply', params: { name: 'a' } }],
+      ['execute', { command: 'Diagnostics.Crash_Reports', params: {} }],
+      ['execute', { command: 'Parameters.Export', params: { path: 'out.json' } }],
+      ['execute', { command: ' file.export ', params: {} }],
+      // A batch step's tool in another case is no tool for SolidCraft; decided as the tool, it stays refused.
+      ['batch', { commands: [{ command: 'Save', params: {} }] }],
+      ['batch', { commands: [{ command: 'New_Design', params: {} }] }],
+      // SolidCraft takes a step's command as `id` too, and a batch's steps from a script file.
+      ['batch', { commands: [{ id: 'component.metadata.set', params: set }] }],
+      ['batch', { commands: [{ id: 'execute', params: { command: 'component.metadata.set', params: set } }] }],
+      ['batch', { commands: [{ command: 'document.revision', id: 'file.export', params: {} }] }],
+      ['batch', { path: 'steps.json' }],
+    ];
+    for (const [tool, args] of refused) expect(decide(tool, args).allow, JSON.stringify(args)).toBe(false);
+    // Tool names SolidCraft knows only as written; another case is no tool and stays refused.
+    expect(decide('Execute', { command: 'solid.box', params: {} }).allow).toBe(false);
+    expect(decide('BATCH', { commands: [] }).allow).toBe(false);
+    // What was allowed stays allowed in any case, the photo canvas too.
+    expect(decide('execute', { command: 'Solid.Extrude', params: {} })).toEqual({ allow: true });
+    expect(decide('batch', { commands: [{ command: 'SOLID.BOX', params: {} }, { id: 'document.revision' }] })).toEqual({ allow: true });
+    expect(decide('execute', { command: 'Construct.Point.Along_Path', params: { path: 'l1', t: 0.5 } }).allow).toBe(true);
+    // Parameter keys SolidCraft reads only as written: `Path` writes no file (measured), so it is not taken for one.
+    expect(decide('execute', { command: 'parameters.export', params: { Path: 'out.json' } }).allow).toBe(true);
+  });
 });
 
 describe('gate proxy', () => {
@@ -130,7 +264,7 @@ describe('gate proxy', () => {
   it('refuses the third identical call in a row until the next turn', async () => {
     const { proxy, calls, records } = await startProxy();
     const client = await connect(proxy);
-    const inspect = () => client.callTool({ name: 'inspect_design', arguments: { depth: 1 } });
+    const inspect = () => client.callTool({ name: 'inspect_design', arguments: { timeline: true } });
     await inspect();
     await inspect();
     const third = await inspect();
@@ -138,7 +272,7 @@ describe('gate proxy', () => {
     expect(calls).toHaveLength(2);
     expect(records.at(-1)).toMatchObject({ name: 'inspect_design', decision: 'denied', reason: REPEAT_REASON });
     // Other arguments, or a new turn, start the count again.
-    await client.callTool({ name: 'inspect_design', arguments: { depth: 2 } });
+    await client.callTool({ name: 'inspect_design', arguments: { timeline: false } });
     await inspect();
     await inspect();
     proxy.newTurn();
diff --git a/apps/desktop/test/fakeSolidCraft.ts b/apps/desktop/test/fakeSolidCraft.ts
index 4adc555..50b2f22 100644
--- a/apps/desktop/test/fakeSolidCraft.ts
+++ b/apps/desktop/test/fakeSolidCraft.ts
@@ -228,7 +228,12 @@ export class FakeSolidCraft {
     };
   }
 
+  /** What a test has a command answer instead of the fake's own answer. */
+  readonly answers: Record<string, (params: Record<string, unknown>) => unknown> = {};
+
   private execute(command: string, params: Record<string, unknown>, allowed: string[]): unknown {
+    const given = this.answers[command];
+    if (given) return given(params);
     switch (command) {
       case 'document.revision':
         return { document_id: this.documentId, revision: this.revision };
diff --git a/apps/desktop/test/mirrorRevision.test.ts b/apps/desktop/test/mirrorRevision.test.ts
index 59e5319..e880d24 100644
--- a/apps/desktop/test/mirrorRevision.test.ts
+++ b/apps/desktop/test/mirrorRevision.test.ts
@@ -2,9 +2,10 @@ import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 
-import { mirrorActiveDesign, type ControlRequester } from '../src/main/solidcraft/mirror';
+import { boughtParts, mirrorActiveDesign, MirrorScheduler, type ControlRequester, type PartChecks } from '../src/main/solidcraft/mirror';
+import type { PartReference } from '../src/main/solidcraft/partReference';
 
 describe('mirroring while the design changes', () => {
   it('names the revision from before its reads, so a change during them is mirrored again', async () => {
@@ -28,3 +29,303 @@ describe('mirroring while the design changes', () => {
     }
   });
 });
+
+// As SolidCraft 0.40.1 measures a countersunk M3x10 and a 0.3 mm lid.
+const SCREW = { volume_mm3: 89.91686929002658, area_mm2: 167.0365086545463, faces: 11, edges: 23, vertices: 15 };
+const LID = { volume_mm3: 360.00000000000506, area_mm2: 2442, faces: 6, edges: 12, vertices: 8 };
+// Each face as inspect.measure {items: [{type: "face", index}]} answers, by index.
+const SCREW_FACES = Array.from({ length: 11 }, (_, index) => ({ items: [{ type: 'face', area_mm2: 4 + index, perimeter_mm: 9 + index, ...(index === 1 ? { radius: 1.5 } : {}) }] }));
+const SCREW_REFERENCE: PartReference = {
+  shape: { volume: SCREW.volume_mm3, area: SCREW.area_mm2, faces: 11, edges: 23, vertices: 15, faceAreas: SCREW_FACES.map((face) => face.items[0]?.area_mm2 ?? 0), perimeters: SCREW_FACES.map((face) => face.items[0]?.perimeter_mm ?? 0), radii: [1.5] },
+  partNumber: 'ISO 10642 M3x10',
+};
+
+/**
+ * A design as SolidCraft 0.40.1 answers after partbuddy_mechanism {kind: screw, head: countersunk}: two
+ * screws, each a component, and a holder of the user's. `answer` replaces what a command answers
+ * (an Error is thrown, `{failed}` fails the batch it is in).
+ */
+function design(answer: (command: string, component: number | undefined, call: number) => unknown = () => undefined) {
+  const descriptions: Record<number, string> = { 2: 'Countersunk socket screw M3x10', 9: 'Countersunk socket screw M3x10', 16: 'Hex nut holder' };
+  const answers: Record<string, unknown> = {
+    'document.revision': { document_id: 'doc', revision: 1 },
+    // Hidden bodies are not exported, so the fake needs no mesh. The metadata holds the list of names PartBuddy kept until the audit.
+    'document.inspect': {
+      name: 'Part',
+      bodies: ['Block', 'Plate', 'Body1', 'Body2', 'Holder'].map((name) => ({ name, visible: false })),
+      sketches: [],
+      metadata: { 'io.github.manuelstaggl.partbuddy.standard-parts': { bodies: ['Holder'] } },
+    },
+    'component.list': {
+      components: [
+        { id: 0, parent: null, bodies: ['Block', 'Plate'] },
+        { id: 2, parent: 0, bodies: ['Body1'] },
+        { id: 9, parent: 0, bodies: ['Body2'] },
+        { id: 16, parent: 0, bodies: ['Holder'] },
+      ],
+    },
+    'parts.library': { families: [{ family: 'countersunk_socket_screw', name: 'Countersunk socket screw', sizes: [{ size: 'M3' }] }, { family: 'hex_nut', name: 'Hex nut', sizes: [{ size: 'M3' }] }] },
+    'inspect.measure': { bodies: [{ name: 'Body1', ...SCREW }, { name: 'Body2', ...SCREW }] },
+  };
+  const calls: Record<string, number> = {};
+  const logs: string[] = [];
+  const client: ControlRequester = {
+    request: <T,>(_method: string, params?: Record<string, unknown>): Promise<T> => {
+      const commands = (params?.commands ?? []) as { command: string; params: { component?: number; items?: { index: number }[] } }[];
+      const results: unknown[] = [];
+      for (const step of commands) {
+        // One face of a body is asked with inspect.measure too; here it goes by a name of its own.
+        const face = step.command === 'inspect.measure' ? step.params.items?.[0]?.index : undefined;
+        const name = face === undefined ? step.command : 'face';
+        calls[name] = (calls[name] ?? 0) + 1;
+        const given = answer(name, step.params.component, calls[name] ?? 0);
+        if (given instanceof Error) return Promise.reject(given);
+        if (given === 'no results') return Promise.resolve({ completed: 0, results: [] } as T);
+        if (typeof given === 'object' && given !== null && 'failed' in given) return Promise.resolve({ completed: results.length, results, failed: { index: results.length, command: step.command, error: String(given.failed) } } as T);
+        results.push(given ?? (face !== undefined ? SCREW_FACES[face] : step.command === 'component.metadata' ? { description: descriptions[step.params.component ?? -1] ?? null } : (answers[step.command] ?? {})));
+      }
+      return Promise.resolve({ completed: results.length, results } as T);
+    },
+  };
+  const checks: PartChecks = { log: (message) => void logs.push(message), references: (parts) => Promise.resolve(new Map(parts.map((part) => [part.description, SCREW_REFERENCE]))) };
+  const structure = async (given: PartChecks = checks) => {
+    const cache = mkdtempSync(join(tmpdir(), 'partbuddy-mirror-'));
+    try {
+      return (await mirrorActiveDesign(client, cache, given)).structure;
+    } finally {
+      rmSync(cache, { recursive: true, force: true });
+    }
+  };
+  const mirror = async (given: PartChecks = checks) => (await structure(given)).standardParts;
+  return { mirror, structure, logs, calls, checks };
+}
+
+describe('standard parts in the mirrored structure (audit S-01, G2 and its review)', () => {
+  it('takes the countersunk screws of a screw joint for standard parts, and no body for its name in the design\'s metadata', async () => {
+    const { mirror, logs, calls } = design();
+    // "Hex nut holder" is no part of the library, and the old list of names in the metadata no longer counts (review 3).
+    expect(await mirror()).toEqual(['Body1', 'Body2']);
+    expect(logs).toEqual([]);
+    // The library is read once per engine, not with every mirror (review 5).
+    expect(await mirror()).toEqual(['Body1', 'Body2']);
+    expect(calls['parts.library']).toBe(1);
+  });
+
+  it('keeps a body printed that is described as a part but is not shaped like it', async () => {
+    // Body2 with a plate joined on: the description still says screw, the body is something else.
+    const joined = design((command) => (command === 'inspect.measure' ? { bodies: [{ name: 'Body1', ...SCREW }, { name: 'Body2', ...LID }] } : undefined));
+    expect(await joined.mirror()).toEqual(['Body1']);
+    expect(joined.logs).toHaveLength(1);
+    expect(joined.logs[0]).toContain('body "Body2" is described as "Countersunk socket screw M3x10" but is not that part');
+    // Only the screw's faces were asked for one by one: the lid's count already differs.
+    expect(joined.calls.face).toBe(11);
+
+    // Volume, area and counts of the screw, but one face of another size (second review, point 3): the 14th face asked for is Body2's third.
+    const twin = design((command, _component, call) => (command === 'face' && call === 14 ? { items: [{ type: 'face', area_mm2: 6.5, perimeter_mm: 11 }] } : undefined));
+    expect(await twin.mirror()).toEqual(['Body1']);
+    expect(twin.logs[0]).toContain('body "Body2" is described as "Countersunk socket screw M3x10" but is not that part');
+
+    const unread = design((command, _component, call) => (command === 'face' && call === 14 ? { failed: 'no face 2' } : undefined));
+    expect(await unread.mirror()).toEqual([]);
+    expect(unread.logs).toEqual(['standard parts could not be told from printed bodies (inspect.measure failed: no face 2); every body counts as printed']);
+  });
+
+  it('says so in the log when parts.library fails or is empty, and reads it again with the next mirror (review 5)', async () => {
+    // Mirror by mirror: the batch fails, the request is rejected, no results come back, the library is empty; then it is there.
+    const failures = [{ failed: 'unknown command `parts.library`' }, new Error('timed out'), 'no results', { families: [] }];
+    const { mirror, logs, calls } = design((command, _component, call) => (command === 'parts.library' ? failures[call - 1] : undefined));
+    for (let n = 0; n < failures.length; n += 1) expect(await mirror()).toEqual([]);
+    expect(logs).toEqual([
+      'standard parts cannot be told from printed bodies: parts.library failed (unknown command `parts.library`); every body counts as printed',
+      'standard parts cannot be told from printed bodies: parts.library failed (timed out); every body counts as printed',
+      'standard parts cannot be told from printed bodies: parts.library lists no families; every body counts as printed',
+      'standard parts cannot be told from printed bodies: parts.library lists no families; every body counts as printed',
+    ]);
+    expect(await mirror()).toEqual(['Body1', 'Body2']);
+    expect(calls['parts.library']).toBe(5);
+  });
+
+  it('leaves nothing unchecked when parts.library fails, so an export is not held up by it (last review, 3)', async () => {
+    const listing = { components: [{ id: 0, parent: null, bodies: ['Block'] }, { id: 2, parent: 0, bodies: ['Body1'] }] };
+    const none = { bought: [], pending: [], unchecked: [], unverified: [] };
+    const asked: string[] = [];
+    for (const answer of [() => Promise.resolve({ completed: 0, results: [], failed: { index: 0, command: 'parts.library', error: 'unknown command' } }), () => Promise.reject(new Error('timed out'))]) {
+      const client: ControlRequester = {
+        request: <T,>(_method: string, params?: Record<string, unknown>): Promise<T> => {
+          asked.push(...((params?.commands ?? []) as { command: string }[]).map((step) => step.command));
+          return answer() as Promise<T>;
+        },
+      };
+      expect(await boughtParts(client, listing, { log: () => undefined, references: () => new Map() })).toEqual(none);
+    }
+    // Nothing else is asked of an engine without a library.
+    expect(asked).toEqual(['parts.library', 'parts.library']);
+  });
+
+  it('counts every body as printed, with a line in the log, when a component cannot be read, measured or held against SolidCraft\'s part', async () => {
+    const unread = design((command, component) => (command === 'component.metadata' && component === 9 ? { failed: 'no component `9`' } : undefined));
+    expect(await unread.mirror()).toEqual([]);
+    expect(unread.logs).toEqual(['standard parts could not be told from printed bodies (component.metadata failed: no component `9`); every body counts as printed']);
+
+    const unmeasured = design((command) => (command === 'inspect.measure' ? { failed: 'no body `Body2`' } : undefined));
+    expect(await unmeasured.mirror()).toEqual([]);
+    expect(unmeasured.logs).toEqual(['standard parts could not be told from printed bodies (inspect.measure failed: no body `Body2`); every body counts as printed']);
+
+    // solidcraft-cli is missing: nothing to hold the bodies against.
+    const unbuilt = design();
+    expect(await unbuilt.mirror({ ...unbuilt.checks, references: () => Promise.reject(new Error('SolidCraft is installed without solidcraft-cli')) })).toEqual([]);
+    expect(unbuilt.logs).toEqual(['standard parts could not be told from printed bodies (SolidCraft is installed without solidcraft-cli); every body counts as printed']);
+
+    // SolidCraft built the description as something else (or not at all): no reference for it.
+    const unknown = design();
+    expect(await unknown.mirror({ ...unknown.checks, references: () => new Map() })).toEqual([]);
+    expect(unknown.logs).toHaveLength(2);
+  });
+
+  it('does not wait for a part SolidCraft is still building: its body counts as printed until the mirror after', async () => {
+    const { structure, logs, checks } = design();
+    let built = false;
+    const references: PartChecks['references'] = (parts) => new Map(parts.map((part) => [part.description, built ? SCREW_REFERENCE : { building: true as const }]));
+    // Neither standard parts nor printed for this moment: the print check leaves the bodies in `pendingParts` out (third review, c).
+    expect(await structure({ ...checks, references })).toMatchObject({ standardParts: [], pendingParts: ['Body1', 'Body2'] });
+    expect(logs).toEqual([
+      'body "Body1" is described as "Countersunk socket screw M3x10", which SolidCraft is building to hold it against: it is neither printed nor bought until then',
+      'body "Body2" is described as "Countersunk socket screw M3x10", which SolidCraft is building to hold it against: it is neither printed nor bought until then',
+    ]);
+    built = true;
+    const after = await structure({ ...checks, references });
+    expect(after.standardParts).toEqual(['Body1', 'Body2']);
+    expect(after.pendingParts).toBeUndefined();
+    // A part that could not be built, or that SolidCraft refuses, is printed again and checked: no body stays out for good.
+    for (const state of [{ failed: 'no answer within 22 s' }, { refused: '`length` must be 0…2000 mm' }]) {
+      const lost = await structure({ ...checks, references: (parts) => new Map(parts.map((part) => [part.description, state])) });
+      expect(lost.standardParts).toEqual([]);
+      expect(lost.pendingParts).toBeUndefined();
+    }
+  });
+});
+
+describe('mirroring once more when a reference was built', () => {
+  const revision = (n: number) => ({ documentId: 'd', revision: n, designName: '', bodies: [], sketches: [], structure: { features: [], marker: null, bodies: [], sketches: [] }, history: { undo: 0, redo: 0 }, mirrorMs: 1 });
+
+  it('mirrors the delivered revision again, once however often it is asked, and once more after a mirror that was running', async () => {
+    let calls = 0;
+    let release: (() => void) | null = null;
+    const scheduler = new MirrorScheduler(
+      async () => {
+        calls += 1;
+        await new Promise<void>((done) => {
+          release = done;
+        });
+        return revision(1);
+      },
+      { started: () => undefined, delivered: () => undefined, failed: () => undefined, idle: () => undefined },
+    );
+    const finish = async (expected: number) => {
+      await vi.waitFor(() => expect(calls).toBe(expected));
+      (release as unknown as () => void)();
+      await new Promise((done) => setTimeout(done, 20));
+    };
+    // Nothing mirrored yet: nothing to mirror again.
+    scheduler.refresh();
+    expect(calls).toBe(0);
+    scheduler.request({ documentId: 'd', revision: 1 });
+    await finish(1);
+    // The same revision asked for again is not mirrored; a built reference mirrors it once more.
+    scheduler.request({ documentId: 'd', revision: 1 });
+    expect(calls).toBe(1);
+    scheduler.refresh();
+    await vi.waitFor(() => expect(calls).toBe(2));
+    // While that mirror runs, three more references arrive: one mirror follows, not three.
+    scheduler.refresh();
+    scheduler.refresh();
+    scheduler.refresh();
+    await finish(2);
+    await finish(3);
+    expect(calls).toBe(3);
+  });
+
+  it('does not lose a reference built while a mirror fails, and mirrors nothing again after a reset (third review, e)', async () => {
+    let calls = 0;
+    const failures: string[] = [];
+    const steps: ((fail: boolean) => void)[] = [];
+    const scheduler = new MirrorScheduler(
+      async () => {
+        calls += 1;
+        const fail = await new Promise<boolean>((done) => steps.push(done));
+        if (fail) throw new Error('engine busy');
+        return revision(1);
+      },
+      { started: () => undefined, delivered: () => undefined, failed: (error) => failures.push(error.message), idle: () => undefined },
+    );
+    const end = async (expected: number, fail: boolean) => {
+      await vi.waitFor(() => expect(calls).toBe(expected));
+      steps.shift()?.(fail);
+      await new Promise((done) => setTimeout(done, 20));
+    };
+    scheduler.request({ documentId: 'd', revision: 1 });
+    await vi.waitFor(() => expect(calls).toBe(1));
+    // The reference arrives while the first mirror runs; that mirror fails.
+    scheduler.refresh();
+    await end(1, true);
+    expect(failures).toEqual(['engine busy']);
+    // It is tried once more for the reference, and only once when that fails too.
+    await end(2, true);
+    expect(calls).toBe(2);
+    scheduler.request({ documentId: 'd', revision: 2 });
+    await end(3, false);
+    // After a reset (another design) an old reference mirrors nothing.
+    scheduler.reset();
+    scheduler.refresh();
+    await new Promise((done) => setTimeout(done, 20));
+    expect(calls).toBe(3);
+  });
+
+  it('hands a body that waited for its part back to the print check when the mirror after fails, and tries that mirror a few times only (last review, 1 and 6)', async () => {
+    const pending = { ...revision(1), structure: { ...revision(1).structure, pendingParts: ['Nut'] } };
+    const outcomes: (ReturnType<typeof revision> | Error)[] = [pending];
+    const delivered: (string[] | undefined)[] = [];
+    const timers: (() => void)[] = [];
+    let called = 0;
+    let calls = 0;
+    const scheduler = new MirrorScheduler(
+      () => {
+        calls += 1;
+        const outcome = outcomes.shift() ?? new Error('engine busy');
+        return outcome instanceof Error ? Promise.reject(outcome) : Promise.resolve(outcome);
+      },
+      { started: () => undefined, delivered: (mirrored) => delivered.push(mirrored.structure.pendingParts), failed: () => undefined, idle: () => undefined },
+      (callback) => {
+        timers.push(callback);
+        return () => (called += 1);
+      },
+    );
+    const settle = () => new Promise((done) => setTimeout(done, 20));
+    scheduler.request({ documentId: 'd', revision: 1 });
+    await settle();
+    expect(delivered).toEqual([['Nut']]);
+    // The part is built, the mirror that would say what the body is fails: the body is checked as a printed one.
+    scheduler.refresh();
+    await settle();
+    expect(delivered).toEqual([['Nut'], undefined]);
+    // That mirror is still owed: it is tried three times, then no timer is left.
+    for (let n = 0; n < 3; n += 1) {
+      expect(timers).toHaveLength(n + 1);
+      timers[n]?.();
+      await settle();
+    }
+    expect(timers).toHaveLength(3);
+    expect(calls).toBe(5);
+    expect(delivered).toHaveLength(2);
+    // A mirror that works ends the debt; a reset calls a waiting timer off.
+    outcomes.push(pending);
+    scheduler.refresh();
+    await settle();
+    scheduler.refresh();
+    await settle();
+    expect(delivered).toEqual([['Nut'], undefined, ['Nut'], undefined]);
+    expect(timers).toHaveLength(4);
+    scheduler.reset();
+    expect(called).toBe(1);
+  });
+});
diff --git a/apps/desktop/test/partReference.test.ts b/apps/desktop/test/partReference.test.ts
new file mode 100644
index 0000000..d26e9b6
--- /dev/null
+++ b/apps/desktop/test/partReference.test.ts
@@ -0,0 +1,411 @@
+import { existsSync, mkdtempSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { afterEach, describe, expect, it } from 'vitest';
+
+import { builtParts, cliReferences, faceCount, faceScript, referenceScript, referencesOf, RefusedPartError, sameShape, shapeOf, TransientCliError, type CliRunner, type PartQuery } from '../src/main/solidcraft/partReference';
+
+const nut: PartQuery = { description: 'Hex nut M3', part: { family: 'hex_nut', size: 'M3', length: null } };
+const screw: PartQuery = { description: 'Countersunk socket screw M3x10', part: { family: 'countersunk_socket_screw', size: 'M3', length: 10 } };
+// A washer has no length: SolidCraft 0.40.1 builds "Plain washer M3" whatever length is asked for.
+const forged: PartQuery = { description: 'Plain washer M3x8', part: { family: 'washer', size: 'M3', length: 8 } };
+// parts.insert refuses a length over 2000 mm, and with it the whole script.
+const refused: PartQuery = { description: 'Socket head cap screw M3x5000', part: { family: 'socket_head_cap_screw', size: 'M3', length: 5000 } };
+
+// One face as inspect.measure {items: [{type: "face", body, index}]} answers.
+const face = (area: number, perimeter: number, radius?: number) => ({ items: [{ type: 'face', area_mm2: area, perimeter_mm: perimeter, ...(radius === undefined ? {} : { radius }) }] });
+// Volume and area as SolidCraft 0.40.1 measures them; the faces shortened to three and two.
+const NUT = { volume_mm3: 45.9088439852507, area_mm2: 106.60297841336842, faces: 3, edges: 21, vertices: 14 };
+const NUT_FACES = [face(18.1, 21.3, 1.5), face(6.6, 12.1), face(2.4, 8.2)];
+const SCREW = { volume_mm3: 89.91686929002658, area_mm2: 167.0365086545463, faces: 2, edges: 23, vertices: 15 };
+const SCREW_FACES = [face(61.2, 30.1, 1.5), face(20.5, 18.8)];
+const nutShape = { volume: NUT.volume_mm3, area: NUT.area_mm2, faces: 3, edges: 21, vertices: 14, faceAreas: [2.4, 6.6, 18.1], perimeters: [8.2, 12.1, 21.3], radii: [1.5] };
+
+describe('a library part as SolidCraft builds it alone (review 2, stage 2)', () => {
+  it('builds each part under a name of its own and measures it, then again to measure each face', () => {
+    const insertNut = { command: 'parts.insert', params: { family: 'hex_nut', size: 'M3', name: 'ref0', point: [0, 0, 0] } };
+    expect(referenceScript([nut, screw])).toEqual([
+      insertNut,
+      { command: 'parts.insert', params: { family: 'countersunk_socket_screw', size: 'M3', length: 10, name: 'ref1', point: [1000, 0, 0] } },
+      { command: 'component.list', params: {} },
+      { command: 'component.metadata', params: { component: 'ref0' } },
+      { command: 'component.metadata', params: { component: 'ref1' } },
+      { command: 'inspect.measure', params: {} },
+    ]);
+    // How many faces a part has is known only after the first run.
+    expect(faceScript([{ ...nut, partNumber: 'ISO 4032 M3', measured: NUT, faces: 3 }])).toEqual([
+      insertNut,
+      { command: 'component.list', params: {} },
+      { command: 'inspect.measure', params: { items: [{ type: 'face', body: 'Body1', index: 0 }] } },
+      { command: 'inspect.measure', params: { items: [{ type: 'face', body: 'Body1', index: 1 }] } },
+      { command: 'inspect.measure', params: { items: [{ type: 'face', body: 'Body1', index: 2 }] } },
+    ]);
+  });
+
+  it('reads shape and part number of the parts SolidCraft described in the words asked for', () => {
+    // The results of the first `solidcraft-cli run --results` for nut, screw and the forged washer.
+    const first = [
+      { component: 1, name: 'ref0' },
+      { component: 8, name: 'ref1' },
+      { component: 15, name: 'ref2' },
+      { components: [{ id: 0, name: 'Untitled', bodies: [] }, { id: 1, name: 'ref0', bodies: ['Body1'] }, { id: 8, name: 'ref1', bodies: ['Body2'] }, { id: 15, name: 'ref2', bodies: ['Body3'] }] },
+      { description: 'Hex nut M3', part_number: 'ISO 4032 M3' },
+      { description: 'Countersunk socket screw M3x10', part_number: 'ISO 10642 M3x10' },
+      { description: 'Plain washer M3', part_number: 'ISO 7089 M3' },
+      { bodies: [{ name: 'Body2', ...SCREW }, { name: 'Body1', ...NUT }, { name: 'Body3', volume_mm3: 10.1, area_mm2: 70.2, faces: 4, edges: 4, vertices: 4 }] },
+    ];
+    const built = builtParts([nut, screw, forged], first);
+    expect(built.map((part) => [part.description, part.partNumber, part.faces])).toEqual([['Hex nut M3', 'ISO 4032 M3', 3], ['Countersunk socket screw M3x10', 'ISO 10642 M3x10', 2]]);
+    // The second run: the two parts again, then the nut's three faces and the screw's two.
+    const second = [{}, {}, { components: [{ name: 'ref0', bodies: ['Body1'] }, { name: 'ref1', bodies: ['Body2'] }] }, ...NUT_FACES, ...SCREW_FACES];
+    const references = referencesOf(built, second);
+    expect([...references.keys()]).toEqual(['Hex nut M3', 'Countersunk socket screw M3x10']);
+    expect(references.get('Hex nut M3')).toEqual({ shape: nutShape, partNumber: 'ISO 4032 M3' });
+    expect(references.get('Countersunk socket screw M3x10')?.shape.faceAreas).toEqual([20.5, 61.2]);
+    // Results that read oddly give no reference, so the body counts as printed: no results, two bodies, a body of another
+    // name, a face that was not measured, another body in the second run.
+    expect(builtParts([nut], [])).toEqual([]);
+    expect(builtParts([nut], [{}, { components: [{ name: 'ref0', bodies: ['Body1', 'Body2'] }] }, { description: 'Hex nut M3' }, { bodies: [{ name: 'Body1', ...NUT }] }])).toEqual([]);
+    expect(builtParts([nut], [{}, { components: [{ name: 'ref0', bodies: ['Nut'] }] }, { description: 'Hex nut M3' }, { bodies: [{ name: 'Nut', ...NUT }] }])).toEqual([]);
+    expect(referencesOf(built.slice(0, 1), [{}, { components: [{ name: 'ref0', bodies: ['Body1'] }] }, ...NUT_FACES.slice(0, 2)]).size).toBe(0);
+    expect(referencesOf(built.slice(0, 1), [{}, { components: [{ name: 'ref0', bodies: ['Body7'] }] }, ...NUT_FACES]).size).toBe(0);
+  });
+
+  it('takes two bodies for the same shape within the measuring noise only', () => {
+    const shape = { volume: 75.22017841527448, area: 137.6044195955919, faces: 12, edges: 24, vertices: 16, faceAreas: [3.1, 40.2, 94.3], perimeters: [7.8, 14.1, 31], radii: [1.25, 2.25] };
+    // The same screw turned to [1, 2, 3], as SolidCraft 0.40.1 measures it.
+    expect(sameShape(shape, { ...shape, volume: 75.22017841786527, area: 137.60441959673892 })).toBe(true);
+    expect(sameShape(shape, { ...shape, volume: shape.volume * 1.00001 })).toBe(false);
+    expect(sameShape(shape, { ...shape, area: shape.area * 0.9999 })).toBe(false);
+    expect(sameShape(shape, { ...shape, faces: 13 })).toBe(false);
+    expect(sameShape(shape, { ...shape, perimeters: [7.8, 14.2, 31] })).toBe(false);
+    expect(shapeOf(NUT, NUT_FACES)).toEqual(nutShape);
+    // An open body has no volume; a body is not measured without its faces, with one too few or with one that reads oddly.
+    expect(shapeOf({ area_mm2: 6, faces: 3, edges: 12, vertices: 8 }, NUT_FACES)).toBeNull();
+    expect(shapeOf(NUT, undefined)).toBeNull();
+    expect(shapeOf(NUT, NUT_FACES.slice(1))).toBeNull();
+    expect(shapeOf(NUT, [NUT_FACES[0], NUT_FACES[1], { items: [{ area_mm2: 'wide' }] }])).toBeNull();
+    expect(shapeOf(undefined, NUT_FACES)).toBeNull();
+    expect(faceCount(NUT)).toBe(3);
+    expect(faceCount({ faces: 100_000 })).toBeNull();
+  });
+
+  it('does not take a ring for the washer whose volume, area and counts it has (second review, point 3)', () => {
+    // The M3 washer of SolidCraft 0.40.1: 7 mm wide, 3.2 mm bore, 0.5 mm thick (15.2210164 mm³); and a ring of R 4.0251,
+    // r 3.3699, 1 mm high, which meets its volume, its area and its 4 faces, 4 edges and 4 vertices to 2.6e-11.
+    const ring = (outer: number, inner: number, height: number) => ({
+      volume: Math.PI * (outer ** 2 - inner ** 2) * height,
+      area: 2 * Math.PI * (outer ** 2 - inner ** 2) + 2 * Math.PI * (outer + inner) * height,
+      faces: 4,
+      edges: 4,
+      vertices: 4,
+      faceAreas: [Math.PI * (outer ** 2 - inner ** 2), Math.PI * (outer ** 2 - inner ** 2), 2 * Math.PI * outer * height, 2 * Math.PI * inner * height].sort((a, b) => a - b),
+      perimeters: [2 * Math.PI * (outer + inner), 2 * Math.PI * (outer + inner), 4 * Math.PI * outer, 4 * Math.PI * inner].sort((a, b) => a - b),
+      radii: [inner, outer],
+    });
+    const washer = ring(3.5, 1.6, 0.5);
+    const twin = ring(4.025086206896552, 3.3699137931034486, 1);
+    expect(Math.abs(twin.volume - washer.volume) / washer.volume).toBeLessThan(1e-9);
+    expect(Math.abs(twin.area - washer.area) / washer.area).toBeLessThan(1e-9);
+    expect(sameShape(twin, washer)).toBe(false);
+    // The five numbers alone agree; the faces, their outlines and the radii each tell the two apart.
+    const alike = { ...twin, faceAreas: washer.faceAreas, perimeters: washer.perimeters, radii: washer.radii };
+    expect(sameShape(alike, washer)).toBe(true);
+    expect(sameShape({ ...alike, faceAreas: twin.faceAreas }, washer)).toBe(false);
+    expect(sameShape({ ...alike, perimeters: twin.perimeters }, washer)).toBe(false);
+    expect(sameShape({ ...alike, radii: twin.radii }, washer)).toBe(false);
+  });
+});
+
+describe('references from solidcraft-cli, kept and built in the background (second review, points 1, 2 and 4)', () => {
+  const dirs: string[] = [];
+  afterEach(() => {
+    for (const dir of dirs.splice(0)) rmSync(dir, { recursive: true, force: true });
+  });
+
+  /** A `solidcraft-cli` that answers a reference script as SolidCraft 0.40.1 does; `fail` makes a run throw. */
+  function fakeCli(fail: (parts: { family: string; length?: number }[]) => Error | null = () => null) {
+    const runs: string[][] = [];
+    const faceRuns: number[] = [];
+    const scripts: string[] = [];
+    const held: (() => void)[] = [];
+    const state = { hold: false, version: 'solidcraft-cli 0.40.1' };
+    const answer: CliRunner = async (_program, args) => {
+      if (args[0] === '--version') return `${state.version}\n`;
+      const script = args[1] ?? '';
+      scripts.push(script);
+      const steps = JSON.parse(readFileSync(script, 'utf8')) as { command: string; params: { family: string; size: string; length?: number; name: string; items?: { body: string; index: number }[] } }[];
+      const inserts = steps.filter((step) => step.command === 'parts.insert').map((step) => step.params);
+      // The second run of a build asks for the faces; `runs` counts the builds, `faceRuns` their second runs.
+      const faces = steps.flatMap((step) => step.params.items ?? []);
+      if (faces.length > 0) faceRuns.push(inserts.length);
+      else runs.push(inserts.map((part) => `${part.family} ${part.size}${part.length === undefined ? '' : `x${String(part.length)}`}`));
+      if (state.hold) {
+        await new Promise<void>((done) => held.push(done));
+      }
+      const error = fail(inserts);
+      if (error) throw error;
+      const describe = (part: { family: string; size: string; length?: number }) =>
+        part.family === 'hex_nut' ? `Hex nut ${part.size}` : part.family === 'washer' ? `Plain washer ${part.size}` : `Countersunk socket screw ${part.size}x${String(part.length)}`;
+      const built = [...inserts.map((part) => ({ name: part.name })), { components: inserts.map((part, i) => ({ name: part.name, bodies: [`Body${String(i + 1)}`] })) }];
+      if (faces.length > 0) return JSON.stringify([...built, ...faces.map((item) => (inserts[Number(item.body.slice(4)) - 1]?.family === 'hex_nut' ? NUT_FACES : SCREW_FACES)[item.index])]);
+      return JSON.stringify([
+        ...built,
+        ...inserts.map((part) => ({ description: describe(part), part_number: part.family === 'hex_nut' ? 'ISO 4032 M3' : 'ISO 10642 M3x10' })),
+        { bodies: inserts.map((part, i) => ({ name: `Body${String(i + 1)}`, ...(part.family === 'hex_nut' ? NUT : SCREW) })) },
+      ]);
+    };
+    return { run: answer, runs, faceRuns, scripts, state, release: () => held.splice(0).forEach((done) => done()) };
+  }
+
+  function store(cli: ReturnType<typeof fakeCli>, dir = mkdtempSync(join(tmpdir(), 'partbuddy-parts-'))) {
+    if (!dirs.includes(dir)) dirs.push(dir);
+    const logs: string[] = [];
+    const clock = { now: 1_000_000 };
+    const timers: { run: () => void; ms: number }[] = [];
+    const called = { off: 0 };
+    let built = 0;
+    // The program must be a file that exists: its size and date are part of what the references are kept under.
+    const references = cliReferences({
+      cli: () => process.execPath,
+      dir,
+      log: (message) => void logs.push(message),
+      run: cli.run,
+      now: () => clock.now,
+      built: () => (built += 1),
+      later: (run, ms) => {
+        timers.push({ run, ms });
+        return () => (called.off += 1);
+      },
+    });
+    return { references, logs, clock, dir, timers, called, built: () => built };
+  }
+
+  /** What the file of kept references is kept under for the fake program. */
+  const identity = (version = 'solidcraft-cli 0.40.1') => {
+    const file = statSync(process.execPath);
+    return `2 ${version} ${String(file.size)} ${String(Math.round(file.mtimeMs))}`;
+  };
+  const keptParts = (dir: string) => (JSON.parse(readFileSync(join(dir, 'part-references.json'), 'utf8')) as { parts: Record<string, unknown> }).parts;
+
+  it('answers at once, builds in the background and tells once when the references are there', async () => {
+    const cli = fakeCli();
+    const { references, built, logs } = store(cli);
+    // Nothing is known yet: the mirror gets its answer without a process having run.
+    expect(references.known([nut, screw, nut])).toEqual(new Map([['Hex nut M3', { building: true }], ['Countersunk socket screw M3x10', { building: true }]]));
+    expect(cli.runs).toEqual([]);
+    // Asked again while they are built: no second process (point 2), also for the export that waits.
+    references.known([nut, screw]);
+    const ready = await references.ready([nut, screw]);
+    expect(cli.runs).toEqual([['hex_nut M3', 'countersunk_socket_screw M3x10']]);
+    expect(cli.faceRuns).toEqual([2]);
+    expect(ready.get('Hex nut M3')).toEqual({ shape: nutShape, partNumber: 'ISO 4032 M3' });
+    // One background build, one mirror more.
+    expect(built()).toBe(1);
+    // Known from here on: no process, no further mirror.
+    expect(references.known([nut]).get('Hex nut M3')).toEqual({ shape: nutShape, partNumber: 'ISO 4032 M3' });
+    await references.ready([nut, screw]);
+    expect(cli.runs).toHaveLength(1);
+    expect(built()).toBe(1);
+    expect(logs).toEqual([]);
+    // The script is gone, the references are kept.
+    expect(cli.scripts.every((script) => !existsSync(script))).toBe(true);
+  });
+
+  it('keeps the references over a restart, under the program they were built with', async () => {
+    const cli = fakeCli();
+    const first = store(cli);
+    await first.references.ready([nut]);
+    expect(readdirSync(first.dir)).toEqual(['part-references.json']);
+    // A new run of PartBuddy: the nut comes from the file, without a build; the mirror is told once it is read.
+    const second = store(cli, first.dir);
+    expect(second.references.known([nut]).get('Hex nut M3')).toEqual({ building: true });
+    expect((await second.references.ready([nut])).get('Hex nut M3')).toEqual({ shape: nutShape, partNumber: 'ISO 4032 M3' });
+    expect(cli.runs).toHaveLength(1);
+    expect(second.built()).toBe(1);
+    // Another SolidCraft builds its parts itself.
+    cli.state.version = 'solidcraft-cli 0.41.0';
+    const third = store(cli, first.dir);
+    await third.references.ready([nut]);
+    expect(cli.runs).toHaveLength(2);
+  });
+
+  it('builds anew what a kept file holds in another form, and takes no entry on trust (third review, d)', async () => {
+    const cli = fakeCli();
+    const good = { shape: nutShape, partNumber: 'ISO 4032 M3' };
+    const files: [string, string][] = [
+      // An entry that is no reference: once it made every body of that description a printed one, for good.
+      ['an empty entry', JSON.stringify({ identity: identity(), parts: { 'Hex nut M3': {} } })],
+      ['a shape without its faces', JSON.stringify({ identity: identity(), parts: { 'Hex nut M3': { partNumber: 'ISO 4032 M3', shape: { ...nutShape, faceAreas: undefined } } } })],
+      ['a number that is none', JSON.stringify({ identity: identity(), parts: { 'Hex nut M3': { partNumber: 'ISO 4032 M3', shape: { ...nutShape, volume: null } } } })],
+      ['a face too few', JSON.stringify({ identity: identity(), parts: { 'Hex nut M3': { partNumber: 'ISO 4032 M3', shape: { ...nutShape, faceAreas: [2.4, 6.6] } } } })],
+      ['the format before', JSON.stringify({ identity: identity().slice(2), parts: { 'Hex nut M3': good } })],
+      ['no JSON', '{"identity": '],
+      ['no object', 'null'],
+    ];
+    for (const [what, text] of files) {
+      const dir = mkdtempSync(join(tmpdir(), 'partbuddy-parts-'));
+      writeFileSync(join(dir, 'part-references.json'), text);
+      const before = cli.runs.length;
+      const { references } = store(cli, dir);
+      expect((await references.ready([nut])).get('Hex nut M3'), what).toEqual(good);
+      expect(cli.runs.length - before, what).toBe(1);
+    }
+    // A file in order is read: no run.
+    const dir = mkdtempSync(join(tmpdir(), 'partbuddy-parts-'));
+    writeFileSync(join(dir, 'part-references.json'), JSON.stringify({ identity: identity(), parts: { 'Hex nut M3': good, 'Hex nut M3x5000': 'step 1 (parts.insert): no such length' } }));
+    const before = cli.runs.length;
+    const kept = await store(cli, dir).references.ready([nut, { description: 'Hex nut M3x5000', part: { family: 'hex_nut', size: 'M3', length: 5000 } }]);
+    expect(kept.get('Hex nut M3')).toEqual(good);
+    expect(kept.get('Hex nut M3x5000')).toEqual({ refused: 'step 1 (parts.insert): no such length' });
+    expect(cli.runs.length).toBe(before);
+  });
+
+  it('remembers a part SolidCraft refuses, with its reason, and lets the parts beside it stand', async () => {
+    // As 0.40.1 answers a length of 5000 mm: the step fails and with it the whole script.
+    const refusal = 'step 2 (parts.insert): invalid parameters for `parts.insert (Insert Fastener)`: `length` must be 0…2000 mm';
+    const cli = fakeCli((parts) => (parts.some((part) => part.length === 5000) ? new RefusedPartError(refusal) : null));
+    const { references, logs, built, dir } = store(cli);
+    const ready = await references.ready([nut, refused, forged]);
+    // One run for all, then each by itself, once.
+    expect(cli.runs).toEqual([['hex_nut M3', 'socket_head_cap_screw M3x5000', 'washer M3x8'], ['hex_nut M3'], ['socket_head_cap_screw M3x5000'], ['washer M3x8']]);
+    expect(ready.get('Hex nut M3')).toEqual({ shape: nutShape, partNumber: 'ISO 4032 M3' });
+    expect(ready.get('Socket head cap screw M3x5000')).toEqual({ refused: refusal });
+    expect(ready.get('Plain washer M3x8')).toEqual({ refused: 'SolidCraft builds "Plain washer M3" for these words' });
+    expect(logs).toEqual([`no reference for the standard part "Socket head cap screw M3x5000": ${refusal}`]);
+    expect(built()).toBe(1);
+    // The next mirrors start no process for them, nor does an export, nor the next run of PartBuddy.
+    references.known([nut, refused, forged]);
+    await references.ready([refused, forged]);
+    await store(cli, dir).references.ready([nut, refused, forged]);
+    expect(cli.runs).toHaveLength(4);
+    expect(cli.scripts.every((script) => !existsSync(script))).toBe(true);
+  });
+
+  it('does not take a crash, or an answer that does not read, for SolidCraft refusing the part (third review, a)', async () => {
+    // The first "Hex nut M3" under load: the program ends with an access violation. Nothing says SolidCraft builds no such nut.
+    let trouble: Error | 'garbage' | null = new Error('solidcraft-cli ended with code 3221225477');
+    const cli = fakeCli(() => (trouble instanceof Error ? trouble : null));
+    const run = cli.run;
+    cli.run = async (...args) => (trouble === 'garbage' && args[1][0] === 'run' ? 'thread main panicked' : run(...args));
+    const first = store(cli);
+    first.references.known([nut]);
+    await expect.poll(first.built).toBe(1);
+    expect(first.references.known([nut]).get('Hex nut M3')).toEqual({ failed: 'solidcraft-cli ended with code 3221225477' });
+    expect(first.logs).toEqual(['no reference for the standard part "Hex nut M3" in this run of PartBuddy: solidcraft-cli ended with code 3221225477']);
+    // Not written down, and no process with the next mirrors.
+    expect(keptParts(first.dir)).toEqual({});
+    first.references.known([nut]);
+    expect(cli.runs).toHaveLength(1);
+    // An answer that is no JSON is no refusal either.
+    trouble = 'garbage';
+    const odd = store(cli);
+    expect((await odd.references.ready([nut])).get('Hex nut M3')).toHaveProperty('failed');
+    expect(keptParts(odd.dir)).toEqual({});
+    // The next run of PartBuddy tries once more, and so does an export in this one.
+    trouble = null;
+    expect((await store(cli, first.dir).references.ready([nut])).get('Hex nut M3')).toEqual({ shape: nutShape, partNumber: 'ISO 4032 M3' });
+    expect((await odd.references.ready([nut])).get('Hex nut M3')).toEqual({ shape: nutShape, partNumber: 'ISO 4032 M3' });
+  });
+
+  it('tries a program that gave no answer again after a while by itself, not with every mirror (third review, b)', async () => {
+    let answers = false;
+    const cli = fakeCli(() => (answers ? null : new TransientCliError('no answer within 22 s')));
+    const { references, logs, clock, timers, built, dir } = store(cli);
+    references.known([nut, screw]);
+    await expect.poll(built).toBe(1);
+    expect(references.known([nut, screw]).get('Hex nut M3')).toEqual({ failed: 'no answer within 22 s' });
+    // One process, not one more for each part, and none with the mirrors that follow.
+    expect(cli.runs).toHaveLength(1);
+    expect(logs).toEqual(['no reference for the standard part "Hex nut M3" for now: no answer within 22 s', 'no reference for the standard part "Countersunk socket screw M3x10" for now: no answer within 22 s']);
+    references.known([nut]);
+    expect(cli.runs).toHaveLength(1);
+    // Not kept over a restart: nothing says the part cannot be built.
+    expect(keptParts(dir)).toEqual({});
+    // Nobody would ask again: a timer does, once the wait is over, and the design is mirrored when the parts are built.
+    expect(timers.map((timer) => timer.ms)).toEqual([5 * 60 * 1000]);
+    clock.now += 5 * 60 * 1000 + 1;
+    timers[0]?.run();
+    await expect.poll(built).toBe(2);
+    expect(cli.runs).toHaveLength(2);
+    expect(timers).toHaveLength(2);
+    answers = true;
+    clock.now += 5 * 60 * 1000 + 1;
+    timers[1]?.run();
+    await expect.poll(built).toBe(3);
+    expect(references.known([nut, screw]).get('Hex nut M3')).toEqual({ shape: nutShape, partNumber: 'ISO 4032 M3' });
+    expect(timers).toHaveLength(2);
+  });
+
+  it('gives up a program that never answers after three runs, and waits for nothing once the design is gone (last review, 6)', async () => {
+    const cli = fakeCli(() => new TransientCliError('no answer within 22 s'));
+    const { references, logs, clock, timers, called, built } = store(cli);
+    references.known([nut]);
+    for (let run = 1; run <= 2; run += 1) {
+      await expect.poll(built).toBe(run);
+      expect(timers).toHaveLength(run);
+      clock.now += 5 * 60 * 1000 + 1;
+      timers[run - 1]?.run();
+    }
+    await expect.poll(built).toBe(3);
+    // Three runs, two timers, and no third: the chain ends.
+    expect(cli.runs).toHaveLength(3);
+    expect(timers).toHaveLength(2);
+    expect(logs.at(-1)).toBe('no reference for the standard part "Hex nut M3" after 3 runs; it is not tried again in this run of PartBuddy: no answer within 22 s');
+    clock.now += 60 * 60 * 1000;
+    expect(references.known([nut]).get('Hex nut M3')).toEqual({ failed: 'no answer within 22 s' });
+    expect(cli.runs).toHaveLength(3);
+    // Another part waits for its second run when the design is closed: its timer is called off.
+    references.known([screw]);
+    await expect.poll(built).toBe(4);
+    expect(timers).toHaveLength(3);
+    references.forget();
+    expect(called.off).toBe(1);
+  });
+
+  it('says that no part can be built here when solidcraft-cli is missing, without a run or a timer (last review, 2)', async () => {
+    const logs: string[] = [];
+    const cli = fakeCli();
+    const references = cliReferences({
+      cli: () => {
+        throw new Error('SolidCraft is installed without solidcraft-cli');
+      },
+      dir: tmpdir(),
+      log: (message) => void logs.push(message),
+      run: cli.run,
+      later: () => {
+        throw new Error('no timer');
+      },
+    });
+    const state = { unavailable: 'SolidCraft is installed without solidcraft-cli' };
+    expect(references.known([nut]).get('Hex nut M3')).toEqual(state);
+    expect((await references.ready([nut])).get('Hex nut M3')).toEqual(state);
+    expect(cli.runs).toEqual([]);
+  });
+
+  it('builds a part once when the mirror and the list of parts to buy ask for it at the same time', async () => {
+    const cli = fakeCli();
+    cli.state.hold = true;
+    const { references } = store(cli);
+    references.known([nut]);
+    const waiting = [references.ready([nut]), references.ready([nut, screw])];
+    // Both processes are running; the nut is in one of them only.
+    await expect.poll(() => cli.runs.length).toBe(2);
+    cli.state.hold = false;
+    cli.release();
+    const [first, second] = await Promise.all(waiting);
+    // The nut ran once; the screw, asked for while the nut was built, in a run of its own.
+    expect(cli.runs.map((parts) => parts.join()).sort()).toEqual(['countersunk_socket_screw M3x10', 'hex_nut M3']);
+    expect(first?.get('Hex nut M3')).toEqual(second?.get('Hex nut M3'));
+  });
+
+  it('waits for every part when there are more than one run takes (third review, f)', async () => {
+    const cli = fakeCli();
+    const { references } = store(cli);
+    const many: PartQuery[] = Array.from({ length: 450 }, (_, i) => ({ description: `Hex nut S${String(i)}`, part: { family: 'hex_nut', size: `S${String(i)}`, length: null } }));
+    const ready = await references.ready(many);
+    expect(cli.runs.map((parts) => parts.length)).toEqual([200, 200, 50]);
+    expect([...ready.values()].filter((state) => 'shape' in state)).toHaveLength(450);
+  });
+});
diff --git a/apps/desktop/test/photo.test.ts b/apps/desktop/test/photo.test.ts
index e723e7c..cab6114 100644
--- a/apps/desktop/test/photo.test.ts
+++ b/apps/desktop/test/photo.test.ts
@@ -31,6 +31,9 @@ describe('a photo for the assistant (F6)', () => {
     const project = join(tmpdir(), 'PartBuddy', 'Holder');
     const file = photoFile(project, new Date(2026, 10, 6, 9, 5, 7));
     expect(file).toBe(join(project, 'photos', 'photo-20261106-090507.png'));
+    // The policy knows the photo once PartBuddy has kept it and named it to the assistant.
+    expect(decide('execute', { command: 'canvas.insert', params: { path: file, plane: 'XY', width: 120 } }).allow).toBe(false);
+    photoNote([file]);
     expect(decide('execute', { command: 'canvas.insert', params: { path: file, plane: 'XY', width: 120 } })).toEqual({ allow: true });
     expect(decide('batch', { commands: [{ command: 'canvas.insert', params: { path: file } }] })).toEqual({ allow: true });
   });
@@ -68,8 +71,9 @@ describe('a photo for the assistant (F6)', () => {
     // Up to four photos go along with one message, a fifth is refused.
     expect(agentMessageSchema.safeParse({ text: 'x', photos: [1, 2, 3, 4].map(() => png(100)) }).success).toBe(true);
     expect(agentMessageSchema.safeParse({ text: 'x', photos: [1, 2, 3, 4, 5].map(() => png(100)) }).success).toBe(false);
-    for (const file of files) expect(decide('execute', { command: 'canvas.insert', params: { path: file } })).toEqual({ allow: true });
     const note = photoNote([files[0] ?? null, null, files[2] ?? null]);
+    // The two that were kept are the assistant's to use; the one that could not be kept is not.
+    expect(files.map((file) => decide('execute', { command: 'canvas.insert', params: { path: file } }).allow)).toEqual([true, false, true]);
     expect(note).toContain('the 3 attached pictures are photos');
     expect(note).toContain('The photos are saved at');
     expect(note).not.toContain('-2.png');
diff --git a/apps/desktop/test/standardParts.test.ts b/apps/desktop/test/standardParts.test.ts
index 8f60a98..ce9bd9b 100644
--- a/apps/desktop/test/standardParts.test.ts
+++ b/apps/desktop/test/standardParts.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 
-import { freeBodyName, libraryOf, standardPartsOf, STANDARD_PARTS_KEY } from '../src/main/solidcraft/standardParts';
+import { freeBodyName, isLibraryPart, libraryOf, libraryPartOf } from '../src/main/solidcraft/standardParts';
 import { hasLength, suggestLength, suggestSize } from '../src/renderer/src/viewer/partChoice';
 
 // As SolidCraft 0.40's `parts.library` answers, shortened.
@@ -21,6 +21,80 @@ const raw = {
   ],
 };
 
+// The 13 families of SolidCraft 0.40.1's `parts.library` with their first sizes, and what `parts.insert`
+// described one part of each as (measured 2026-11-12).
+const size = (...sizes: string[]) => sizes.map((entry) => ({ size: entry }));
+const library = {
+  families: [
+    { family: 'socket_head_cap_screw', name: 'Socket head cap screw', sizes: size('M2', 'M2.5', 'M3') },
+    { family: 'button_head_cap_screw', name: 'Button head cap screw', sizes: size('M3', 'M4') },
+    { family: 'countersunk_socket_screw', name: 'Countersunk socket screw', sizes: size('M3', 'M4') },
+    { family: 'hex_bolt', name: 'Hex head bolt / screw', sizes: size('M2', 'M2.5', 'M3') },
+    { family: 'hex_nut', name: 'Hex nut', sizes: size('M2', 'M2.5', 'M3') },
+    { family: 'washer', name: 'Plain washer', sizes: size('M2', 'M2.5', 'M3') },
+    { family: 'set_screw', name: 'Hex socket set screw, flat point', sizes: size('M3', 'M4') },
+    { family: 'dowel_pin', name: 'Parallel pin (dowel)', sizes: size('2', '3') },
+    { family: 'bearing', name: 'Deep groove ball bearing (envelope)', sizes: size('625', '626') },
+    { family: 'hex_cap_screw_inch', name: 'Hex cap screw (inch)', sizes: size('1/4-20 UNC', '1/4-28 UNF') },
+    { family: 'hex_nut_inch', name: 'Hex nut (inch)', sizes: size('1/4-20 UNC', '1/4-28 UNF') },
+    { family: 'washer_sae', name: 'Plain washer, SAE (narrow)', sizes: size('1/4', '5/16') },
+    { family: 'washer_uss', name: 'Plain washer, USS (wide)', sizes: size('1/4', '5/16') },
+  ],
+};
+const inserted = [
+  'Socket head cap screw M3x8',
+  'Button head cap screw M3x8',
+  'Countersunk socket screw M3x8',
+  'Hex head bolt / screw M3x8',
+  'Hex nut M3',
+  'Plain washer M3',
+  'Hex socket set screw, flat point M3x4',
+  'Parallel pin (dowel) 2x8',
+  'Deep groove ball bearing (envelope) 625',
+  'Hex cap screw (inch) 1/4-20 UNC x 3/4',
+  'Hex nut (inch) 1/4-20 UNC',
+  'Plain washer, SAE (narrow) 1/4',
+  'Plain washer, USS (wide) 1/4',
+];
+
+describe("parts of SolidCraft's library, told by what parts.library lists (audit S-01, G2)", () => {
+  it('knows a part of every family, the countersunk screw too, and lengths off the list', () => {
+    expect(inserted.filter((description) => isLibraryPart(description, library))).toEqual(inserted);
+    // The screws partbuddy_mechanism puts in for head: countersunk; a fixed list of 12 names left them printed and exported.
+    expect(isLibraryPart('Countersunk socket screw M3x10', library)).toBe(true);
+    for (const description of ['Socket head cap screw M2.5x7.5', 'Hex cap screw (inch) 1/4-20 UNC x 1-1/2', 'Hex cap screw (inch) 1/4-20 UNCx7.5']) {
+      expect(isLibraryPart(description, library), description).toBe(true);
+    }
+  });
+
+  it('reads family, size and length in mm from the description, as parts.insert takes them to build the part again', () => {
+    // Descriptions as SolidCraft 0.40.1 writes them: millimetres after "x", inches after " x ".
+    expect(libraryPartOf('Countersunk socket screw M3x10', library)).toEqual({ family: 'countersunk_socket_screw', size: 'M3', length: 10 });
+    expect(libraryPartOf('Socket head cap screw M2.5x7.5', library)).toEqual({ family: 'socket_head_cap_screw', size: 'M2.5', length: 7.5 });
+    expect(libraryPartOf('Hex nut (inch) 1/4-20 UNC', library)).toEqual({ family: 'hex_nut_inch', size: '1/4-20 UNC', length: null });
+    expect(libraryPartOf('Hex cap screw (inch) 1/4-20 UNC x 3/4', library)?.length).toBeCloseTo(19.05, 9);
+    expect(libraryPartOf('Hex cap screw (inch) 1/4-20 UNC x 1-1/4', library)).toEqual({ family: 'hex_cap_screw_inch', size: '1/4-20 UNC', length: 31.75 });
+    expect(libraryPartOf('Hex cap screw (inch) 1/4-20 UNC x 8', library)?.length).toBeCloseTo(203.2, 9);
+    expect(libraryPartOf('Hex cap screw (inch) 1/4-20 UNCx7.5', library)?.length).toBe(7.5);
+    expect(libraryPartOf('Hex cap screw (inch) 1/4-20 UNC x 1/0', library)).toBeNull();
+    expect(libraryPartOf('Hex nut holder', library)).toBeNull();
+  });
+
+  it('knows a family SolidCraft adds without a change in PartBuddy', () => {
+    expect(isLibraryPart('Square nut M3', library)).toBe(false);
+    expect(isLibraryPart('Square nut M3', { families: [...library.families, { family: 'square_nut', name: 'Square nut', sizes: size('M3') }] })).toBe(true);
+  });
+
+  it('leaves a printed part printed whose description only reads like a library part', () => {
+    for (const description of ['Hex nut holder', 'Hex nut M3 holder', 'Hex nut', 'Hex nut ', 'Hex nut M33', 'Plain washer M3x', 'Countersunk socket screw', 'Bracket for a Hex nut M3', 'hex nut M3', null, 3]) {
+      expect(isLibraryPart(description, library), String(description)).toBe(false);
+    }
+    // Without the library nothing is taken for a part: the bodies stay in print check and export.
+    expect(isLibraryPart('Hex nut M3', null)).toBe(false);
+    expect(isLibraryPart('Hex nut M3', { families: [null, { name: 'Hex nut' }, { name: 'Hex nut', sizes: [null, {}] }] })).toBe(false);
+  });
+});
+
 describe('standard parts (B7)', () => {
   it('keeps the metric families with the diameter that goes into the hole', () => {
     const library = libraryOf(raw);
@@ -40,10 +114,8 @@ describe('standard parts (B7)', () => {
     expect(suggestLength(library, 'bearing', '608')).toBeNull();
   });
 
-  it('names the part\'s body freely and reads the marked bodies back', () => {
+  it('names the part\'s body freely', () => {
     expect(freeBodyName('SHCS M3x12', ['Body1'])).toBe('SHCS M3x12');
     expect(freeBodyName('SHCS M3x12', ['SHCS M3x12', 'SHCS M3x12 (2)'])).toBe('SHCS M3x12 (3)');
-    expect(standardPartsOf({ [STANDARD_PARTS_KEY]: { bodies: ['SHCS M3x12', 3] } })).toEqual(['SHCS M3x12']);
-    expect(standardPartsOf({})).toEqual([]);
   });
 });
diff --git a/apps/desktop/test/structure.test.ts b/apps/desktop/test/structure.test.ts
index 512f49b..e7b7855 100644
--- a/apps/desktop/test/structure.test.ts
+++ b/apps/desktop/test/structure.test.ts
@@ -5,7 +5,8 @@ import { printCheckNote } from '../src/main/print/printCheckNote';
 import { jointMove, jointPoses, playRange, playStep, rotate, withFollowers } from '../src/renderer/src/viewer/jointPose';
 import { snapSpan, sweepStopOf } from '../src/main/solidcraft/actions';
 
-import { componentsWithBodies, jointsOf, libraryBodies, structureOf, withColours } from '../src/main/solidcraft/mirror';
+import { boughtAmong, componentsWithBodies, hardwareOf, jointsOf, partCandidates, structureOf, withColours } from '../src/main/solidcraft/mirror';
+import type { ReferenceState } from '../src/main/solidcraft/partReference';
 import { describeCommands, describeUserAction } from '../src/shared/stepPhrases';
 import { structureSchema } from '../src/shared/contract';
 
@@ -56,10 +57,125 @@ describe('standard parts the assistant inserted itself', () => {
     expect(parts.map((part) => part.id)).toEqual([25, 31, 40]);
     // Their component.metadata: two from parts.insert, one of the user's own.
     const metadata = [{ description: 'Button head cap screw M3x8' }, { description: 'Deep groove ball bearing (envelope) 608' }, { description: 'Bracket for the shelf' }];
-    expect(libraryBodies(parts, metadata)).toEqual(['Screw FR', 'Bearing']);
+    const library = {
+      families: [
+        { family: 'button_head_cap_screw', name: 'Button head cap screw', sizes: [{ size: 'M3' }] },
+        { family: 'bearing', name: 'Deep groove ball bearing (envelope)', sizes: [{ size: '608' }] },
+      ],
+    };
+    const logs: string[] = [];
+    const log = (message: string) => void logs.push(message);
+    expect(partCandidates(parts, metadata, library, log)).toEqual([
+      { component: 25, body: 'Screw FR', description: 'Button head cap screw M3x8', part: { family: 'button_head_cap_screw', size: 'M3', length: 8 } },
+      { component: 31, body: 'Bearing', description: 'Deep groove ball bearing (envelope) 608', part: { family: 'bearing', size: '608', length: null } },
+    ]);
+    // Without the library nothing is taken for a part: the bodies stay in print check and export.
+    expect(partCandidates(parts, metadata, undefined, log)).toEqual([]);
+    expect(logs).toEqual([]);
     expect(componentsWithBodies(undefined)).toEqual([]);
   });
 
+  it('counts every body of a library component as printed once it holds more than the part (review 2, stage 1)', () => {
+    // Measured with SolidCraft 0.40.1: component.move_bodies {bodies: ["Deckel"], component: "Nut"}, component.copy_bodies
+    // and component.activate with solid.box each leave the nut's component with two bodies; all 13 families build one.
+    const library = { families: [{ family: 'hex_nut', name: 'Hex nut', sizes: [{ size: 'M3' }] }] };
+    const logs: string[] = [];
+    const moved = partCandidates([{ id: 3, bodies: ['Deckel', 'Body1'] }, { id: 9, bodies: ['Body2'] }], [{ description: 'Hex nut M3' }, { description: 'Hex nut M3' }], library, (message) => void logs.push(message));
+    // The lid stays printed, the nut beside it in the same component too; the untouched nut is still a candidate.
+    expect(moved.map((candidate) => candidate.body)).toEqual(['Body2']);
+    expect(logs).toEqual(['the component described as "Hex nut M3" holds 2 bodies (Deckel, Body1), a standard part has one: they count as printed']);
+  });
+
+  it('takes a body for the part only when it has the shape SolidCraft builds for the description (review 2, stage 2)', () => {
+    // inspect.measure as SolidCraft 0.40.1 answers: an M3 nut, turned (volume and area off by 6e-11), the same nut with a
+    // 0.3 mm plate joined on (solid.combine), and a 0.3 mm lid described as "Hex nut M3".
+    const areas = [2.4, 2.4, 6.6, 6.6, 6.6, 6.6, 6.6, 6.6, 18.1];
+    // Each face as inspect.measure {items: [{type: "face", …}]} answers; the last is the bore.
+    const facesOf = (list: number[]) => list.map((area, i) => ({ items: [{ type: 'face', area_mm2: area, perimeter_mm: area * 2, ...(i === 8 ? { radius: 1.5 } : {}) }] }));
+    const nutFaces = facesOf(areas);
+    const nut = { volume: 45.9088439852507, area: 106.60297841336842, faces: 9, edges: 21, vertices: 14, faceAreas: areas, perimeters: areas.map((area) => area * 2), radii: [1.5] };
+    const references = new Map<string, ReferenceState>([
+      ['Hex nut M3', { shape: nut, partNumber: 'ISO 4032 M3' }],
+      ['Hex nut M4', { building: true }],
+      ['Hex nut M5x5000', { refused: '`length` must be 0…2000 mm' }],
+      ['Hex nut M8', { failed: 'solidcraft-cli ended with code 3221225477' }],
+    ]);
+    const candidate = (component: number, body: string, description = 'Hex nut M3') => ({ component, body, description, part: { family: 'hex_nut', size: 'M3', length: null } });
+    const measured = {
+      bodies: [
+        { name: 'Body1', volume_mm3: 45.90884398802, area_mm2: 106.602978419, faces: 9, edges: 21, vertices: 14 },
+        { name: 'Body2', volume_mm3: 310.17023848330126, area_mm2: 1890.2, faces: 24, edges: 60, vertices: 40 },
+        { name: 'Deckel', volume_mm3: 360.00000000000506, area_mm2: 2442, faces: 6, edges: 12, vertices: 8 },
+        // The same counts as the nut and a volume a thousandth off: not the part either.
+        { name: 'Near', volume_mm3: 45.95, area_mm2: 106.60297841336842, faces: 9, edges: 21, vertices: 14 },
+        { name: 'Open', area_mm2: 106.6, faces: 9, edges: 21, vertices: 14 },
+        // Volume, area and counts of the nut to the last digit, but other faces (second review, point 3).
+        { name: 'Twin', volume_mm3: 45.9088439852507, area_mm2: 106.60297841336842, faces: 9, edges: 21, vertices: 14 },
+      ],
+    };
+    const twinFaces = facesOf([1.4, 3.4, 6.6, 6.6, 6.6, 6.6, 6.6, 6.6, 18.1]);
+    const logs: string[] = [];
+    const candidates = [
+      candidate(3, 'Body1'),
+      candidate(9, 'Body2'),
+      candidate(16, 'Deckel'),
+      candidate(20, 'Near'),
+      candidate(22, 'Open'),
+      candidate(24, 'Gone'),
+      candidate(26, 'Twin'),
+      candidate(30, 'Body1', 'Hex nut M4'),
+      candidate(32, 'Body1', 'Hex nut M5x5000'),
+      candidate(34, 'Body1', 'Hex nut M6'),
+      candidate(36, 'Body9', 'Hex nut M8'),
+    ];
+    const faces = [nutFaces, nutFaces, nutFaces, nutFaces, nutFaces, nutFaces, twinFaces, nutFaces, nutFaces, nutFaces, nutFaces];
+    const told = boughtAmong(candidates, measured, faces, references, (message) => void logs.push(message));
+    expect(told.bought).toEqual([{ component: 3, body: 'Body1', description: 'Hex nut M3', partNumber: 'ISO 4032 M3' }]);
+    // A part still being built is neither printed nor bought; one that could not be built for now is named for the export, which must not go out unchecked.
+    expect(told.pending).toEqual(['Body1']);
+    expect(told.unchecked).toEqual(['"Body1": no answer', '"Body9": solidcraft-cli ended with code 3221225477']);
+    // Every body left printed is named with the reason.
+    expect(logs).toHaveLength(10);
+    expect(logs[1]).toBe('body "Deckel" is described as "Hex nut M3" but is not that part (360.00000000000506 mm³, 6 faces; the part has 45.9088439852507 mm³, 9 faces): it counts as printed');
+    expect(logs[5]).toContain('body "Twin" is described as "Hex nut M3" but is not that part');
+    expect(logs[6]).toBe('body "Body1" is described as "Hex nut M4", which SolidCraft is building to hold it against: it is neither printed nor bought until then');
+    expect(logs[7]).toBe('body "Body1" is described as "Hex nut M5x5000", which SolidCraft does not build (`length` must be 0…2000 mm): it counts as printed');
+    expect(logs[8]).toBe('body "Body1" is described as "Hex nut M6", which could not be built to hold it against (no answer): it counts as printed');
+    expect(logs[9]).toBe('body "Body9" is described as "Hex nut M8", which could not be built to hold it against (solidcraft-cli ended with code 3221225477): it counts as printed');
+    expect(boughtAmong(candidates, undefined, faces, references, () => undefined).bought).toEqual([]);
+    // Without its faces, or with one of them missing, a body is not measured.
+    expect(boughtAmong(candidates.slice(0, 1), measured, [], references, () => undefined).bought).toEqual([]);
+    expect(boughtAmong(candidates.slice(0, 1), measured, [nutFaces.slice(1)], references, () => undefined).bought).toEqual([]);
+  });
+
+  it('lists the parts to buy from the standard parts themselves, each as often as it is placed (review 4)', () => {
+    // component.list as SolidCraft 0.40.1 answers: a nut, a printed lid, and a washer in a subassembly placed twice.
+    const listing = {
+      components: [
+        { id: 0, parent: null, bodies: [], occurrences: [] },
+        { id: 2, parent: 0, bodies: ['Deckel'], occurrences: [{ id: 3, parent: 0 }] },
+        { id: 5, parent: 0, bodies: ['Body1'], occurrences: [{ id: 6, parent: 0 }] },
+        { id: 11, parent: 0, bodies: [], occurrences: [{ id: 12, parent: 0 }, { id: 20, parent: 0 }] },
+        { id: 13, parent: 11, bodies: ['Body2'], occurrences: [{ id: 14, parent: 11 }] },
+        { id: 30, parent: 0, bodies: ['Body3'], occurrences: [{ id: 31, parent: 0 }] },
+      ],
+    };
+    const bought = [
+      { component: 13, body: 'Body2', description: 'Plain washer M3', partNumber: 'ISO 7089 M3' },
+      { component: 5, body: 'Body1', description: 'Hex nut M3', partNumber: 'ISO 4032 M3' },
+      { component: 30, body: 'Body3', description: 'Hex nut M3', partNumber: 'ISO 4032 M3' },
+    ];
+    // assembly.bom put the nut and the lid given part_number "ISO 4032 M3" into one row (components [2, 5], count 2),
+    // dropped the nut with bom_type "reference", and listed the lid alone; this list follows none of that.
+    expect(hardwareOf(bought, listing)).toEqual([
+      { count: 2, name: 'Hex nut M3', standard: 'ISO 4032 M3' },
+      { count: 2, name: 'Plain washer M3', standard: 'ISO 7089 M3' },
+    ]);
+    expect(hardwareOf([], listing)).toEqual([]);
+    // A listing that reads oddly still names the part once.
+    expect(hardwareOf(bought.slice(1, 2), undefined)).toEqual([{ count: 1, name: 'Hex nut M3', standard: 'ISO 4032 M3' }]);
+  });
+
   it('gives bodies the colour SolidCraft lists for them, as 0.40 answers appearance.list', () => {
     const structure = structureOf({ bodies: [{ name: 'Body1', visible: true }, { name: 'Badge ffd500', visible: true }] });
     // eslint-disable-next-line no-restricted-syntax -- SolidCraft's answer holds the body's colour
diff --git a/apps/desktop/test/supervisor.test.ts b/apps/desktop/test/supervisor.test.ts
index e2edc68..f153c6f 100644
--- a/apps/desktop/test/supervisor.test.ts
+++ b/apps/desktop/test/supervisor.test.ts
@@ -1,11 +1,12 @@
 import { spawnSync } from 'node:child_process';
-import { mkdtempSync, readdirSync, readFileSync, realpathSync, rmSync } from 'node:fs';
+import { existsSync, mkdtempSync, readdirSync, readFileSync, realpathSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
 import { afterEach, describe, expect, it, vi } from 'vitest';
 
 import { MirrorScheduler } from '../src/main/solidcraft/mirror';
+import type { PartReferences, ReferenceState } from '../src/main/solidcraft/partReference';
 import { SolidCraftSupervisor } from '../src/main/solidcraft/supervisor';
 import type { ConnectionStatus, MirrorRevision } from '../src/shared/contract';
 import { FakeSolidCraft } from './fakeSolidCraft';
@@ -16,7 +17,7 @@ afterEach(async () => {
   for (const cleanup of cleanups.splice(0).reverse()) await cleanup();
 });
 
-function setup(options: { installed?: boolean; autoStart?: boolean; cacheDir?: string } = {}) {
+function setup(options: { installed?: boolean; autoStart?: boolean; cacheDir?: string; partReferences?: () => PartReferences } = {}) {
   const controlDir = mkdtempSync(join(tmpdir(), 'partbuddy-control-'));
   const cacheDir = options.cacheDir ?? realpathSync.native(mkdtempSync(join(tmpdir(), 'partbuddy-cache-')));
   cleanups.push(() => {
@@ -39,6 +40,7 @@ function setup(options: { installed?: boolean; autoStart?: boolean; cacheDir?: s
       },
       launchPort: 65000,
       autoStart: options.autoStart ?? false,
+      ...(options.partReferences ? { partReferences: options.partReferences } : {}),
       cacheDir,
       log: () => undefined,
     },
@@ -156,6 +158,61 @@ describe('SolidCraft supervisor', () => {
     expect(readdirSync(cacheDir)).toEqual([]);
   });
 
+  it('exports no standard part, waits for its reference, and says so instead of exporting a body it could not check (third review, b)', async () => {
+    // A nut beside the clip, as SolidCraft lists and measures it; where its reference stands is the test's to say.
+    const shape = { volume: 45.9, area: 106.6, faces: 1, edges: 21, vertices: 14, faceAreas: [18.1], perimeters: [21.3], radii: [1.5] };
+    let state: ReferenceState = { building: true };
+    const waited: ReferenceState[] = [];
+    const { supervisor, revisions, controlDir } = setup({
+      partReferences: () => ({
+        known: (parts) => new Map(parts.map((part) => [part.description, state])),
+        // What an export waits for: by then the part is built, refused or lost.
+        ready: (parts) => Promise.resolve(new Map(parts.map((part) => [part.description, waited.shift() ?? state]))),
+        forget: () => undefined,
+      }),
+    });
+    const fake = await startFake(controlDir);
+    fake.bodies = ['CableClip', 'Nut'];
+    fake.answers['component.list'] = () => ({ components: [{ id: 0, parent: null, bodies: ['CableClip'], occurrences: [] }, { id: 2, parent: 0, bodies: ['Nut'], occurrences: [{ id: 3, parent: 0 }] }] });
+    fake.answers['component.metadata'] = () => ({ description: 'Hex nut M3' });
+    fake.answers['parts.library'] = () => ({ families: [{ family: 'hex_nut', name: 'Hex nut', sizes: [{ size: 'M3' }] }] });
+    fake.answers['inspect.measure'] = (params) =>
+      params.items ? { items: [{ type: 'face', area_mm2: 18.1, perimeter_mm: 21.3, radius: 1.5 }] } : { bodies: [{ name: 'Nut', volume_mm3: 45.9, area_mm2: 106.6, faces: 1, edges: 21, vertices: 14 }] };
+    supervisor.start();
+    await vi.waitFor(() => expect(revisions).toHaveLength(1), { timeout: 5000 });
+    // The mirror did not wait: the nut is neither printed nor bought yet, and the print check leaves it out.
+    expect(revisions[0]?.structure).toMatchObject({ standardParts: [], pendingParts: ['Nut'] });
+    const target = mkdtempSync(join(tmpdir(), 'partbuddy-export-'));
+    cleanups.push(() => {
+      rmSync(target, { recursive: true, force: true });
+    });
+    const exported = () => fake.exports.filter((entry) => entry.format === 'stl').map((entry) => entry.bodies);
+
+    // The export waits; the reference arrives: the nut stays out.
+    waited.push({ shape, partNumber: 'ISO 4032 M3' });
+    await supervisor.exportDesign('stl', join(target, 'a.stl'));
+    expect(exported()).toEqual([['CableClip']]);
+    // The reference could not be built, or is still being built after the wait: nothing is written, and the user reads why.
+    for (const lost of [{ failed: 'no answer within 22 s' }, { building: true as const }]) {
+      waited.push(lost);
+      await expect(supervisor.exportDesign('stl', join(target, 'b.stl'))).rejects.toThrow(/nothing was written, because it is not known whether these are bought standard parts: "Nut": ./);
+    }
+    expect(exported()).toEqual([['CableClip']]);
+    expect(existsSync(join(target, 'b.stl'))).toBe(false);
+    // SolidCraft builds no such part: the body is a printed one and is exported.
+    state = { refused: '`length` must be 0…2000 mm' };
+    await supervisor.exportDesign('stl', join(target, 'c.stl'));
+    expect(exported()).toEqual([['CableClip'], ['CableClip', 'Nut']]);
+    // The parts to buy follow the same recognition.
+    state = { shape, partNumber: 'ISO 4032 M3' };
+    expect(await supervisor.hardware()).toEqual([{ count: 1, name: 'Hex nut M3', standard: 'ISO 4032 M3' }]);
+    // No solidcraft-cli, so no part can ever be checked: the nut goes along as a printed body and is named for the user (last review, 2).
+    state = { unavailable: 'SolidCraft is installed without solidcraft-cli' };
+    expect(await supervisor.exportDesign('stl', join(target, 'd.stl'))).toEqual({ unverified: ['Nut'] });
+    expect(exported().at(-1)).toEqual(['CableClip', 'Nut']);
+    expect(await supervisor.hardware()).toEqual([]);
+  });
+
   it('refuses to export a design without a body', async () => {
     const { supervisor, revisions, controlDir } = setup();
     const fake = await startFake(controlDir);