@pixel-point/toolcraft 0.0.17 → 0.0.19

package/templates/starter/src/app/starter-acceptance.product-output-export.test.ts

@@ -1,9 +1,10 @@
 import { describe, expect, it } from "vitest";
 
-import { schemaHasVideoExportPanelAction } from "./acceptance/output-export";
+import { resolveToolcraftArtifactExportIntent } from "./acceptance/artifact-export-intent";
 import { starterProductReadiness } from "./starter-acceptance";
 import {
   textLooksLikePngExport,
+  textLooksLikeSvgExport,
   textLooksLikeVideoExport,
 } from "./starter-acceptance.export-test-utils";
 import {
@@ -14,38 +15,37 @@ import {
   getSchemaVideoExportSection,
   getSectionControlByTarget,
   getSectionControlIdByTarget,
-  schemaHasProductSurface,
 } from "./starter-acceptance.schema-test-utils";
-import { starterSchema } from "./starter-schema";
 
 describe("Toolcraft output export acceptance contract", () => {
   it("requires product output apps to expose export actions in the sticky footer", () => {
-    if (starterProductReadiness.mode !== "product" && !schemaHasProductSurface()) {
+    if (starterProductReadiness.mode === "starter") {
       return;
     }
 
+    const delivery = resolveToolcraftArtifactExportIntent(
+      starterProductReadiness.exportIntent,
+    );
     const panelActionTexts = getSchemaPanelActionSearchTexts();
     const backgroundColorTargets = getSchemaBackgroundControlTargets(new Set(["color"]));
     const backgroundToggleTargets = getSchemaBackgroundControlTargets(
       new Set(["checkbox", "select", "segmented", "switch"]),
     );
 
-    expect(
-      panelActionTexts.length,
-      "Product apps must define panelActions in the controls panel sticky footer.",
-    ).toBeGreaterThan(0);
-    expect(
-      panelActionTexts.some(textLooksLikePngExport),
-      "Every product app must expose Export PNG or Download PNG through panelActions.",
-    ).toBe(true);
-    expect(
-      backgroundColorTargets.length,
-      "Every product app with Export PNG must expose a user-facing background color control.",
-    ).toBeGreaterThan(0);
-    expect(
-      backgroundToggleTargets.length,
-      'Every product app with Export PNG must expose export.includeBackground in runtime Setup as a Switch labeled "Background".',
-    ).toBeGreaterThan(0);
+    if (delivery.imageEnabled || delivery.svgEnabled || delivery.videoEnabled) {
+      expect(
+        panelActionTexts.length,
+        "Product apps with artifact delivery must define panelActions in the controls panel sticky footer.",
+      ).toBeGreaterThan(0);
+      expect(
+        backgroundColorTargets.length,
+        "Product apps with artifact delivery must expose a user-facing background color control.",
+      ).toBeGreaterThan(0);
+      expect(
+        backgroundToggleTargets.length,
+        'Product apps with artifact delivery must expose export.includeBackground in runtime Setup as a Switch labeled "Background".',
+      ).toBeGreaterThan(0);
+    }
 
     const imageExportSection = getSchemaImageExportSection();
     const imageFormatControl = getSectionControlByTarget(
@@ -78,47 +78,55 @@ describe("Toolcraft output export acceptance contract", () => {
           ) === true;
 
     expect(
-      imageExportSection,
-      'Apps with Export PNG must expose image settings in a separate controls section titled "Image Export".',
-    ).toBeDefined();
-    expect(
-      imageFormatControl,
-      'The separate "Image Export" section must include a format control with target "export.image.format".',
-    ).toBeDefined();
-    expect(
-      imageFormatControl?.type,
-      "Image Export format must use the same Select/dropdown structure as Video Export.",
-    ).toBe("select");
-    expect(
-      imageFormatOptionValues,
-      'Image format options must include "png" and "jpg".',
-    ).toEqual(expect.arrayContaining(["png", "jpg"]));
-    expect(
-      imageFormatControl?.defaultValue,
-      'Image format must default to "png".',
-    ).toBe("png");
-    expect(
-      imageResolutionControl,
-      'The separate "Image Export" section must include a resolution control with target "export.image.resolution".',
-    ).toBeDefined();
-    expect(
-      imageResolutionControl?.type,
-      "Image Export resolution must use the same Select/dropdown structure as Video Export.",
-    ).toBe("select");
-    expect(
-      imageResolutionOptionValues,
-      'Image resolution options must include "2k", "4k", and "8k".',
-    ).toEqual(expect.arrayContaining(["2k", "4k", "8k"]));
+      panelActionTexts.some(textLooksLikePngExport),
+      "Image export action presence must match resolved product export intent.",
+    ).toBe(delivery.imageEnabled);
     expect(
-      imageResolutionControl?.defaultValue,
-      'Image resolution must default to "4k".',
-    ).toBe("4k");
+      imageExportSection !== undefined,
+      '"Image Export" section presence must match resolved product export intent.',
+    ).toBe(delivery.imageEnabled);
     expect(
-      imageExportHasInlinePair,
-      "Image Export format and resolution must render as a compact inline pair.",
-    ).toBe(true);
-    if (!schemaHasVideoExportPanelAction(starterSchema)) {
-      return;
+      panelActionTexts.some(textLooksLikeSvgExport),
+      "SVG export action presence must match resolved product export intent.",
+    ).toBe(delivery.svgEnabled);
+
+    if (delivery.imageEnabled) {
+      expect(
+        imageFormatControl,
+        'The separate "Image Export" section must include a format control with target "export.image.format".',
+      ).toBeDefined();
+      expect(
+        imageFormatControl?.type,
+        "Image Export format must use the same Select/dropdown structure as Video Export.",
+      ).toBe("select");
+      expect(
+        imageFormatOptionValues,
+        'Image format options must include "png" and "jpg".',
+      ).toEqual(expect.arrayContaining(["png", "jpg"]));
+      expect(
+        imageFormatControl?.defaultValue,
+        'Image format must default to "png".',
+      ).toBe("png");
+      expect(
+        imageResolutionControl,
+        'The separate "Image Export" section must include a resolution control with target "export.image.resolution".',
+      ).toBeDefined();
+      expect(
+        imageResolutionControl?.type,
+        "Image Export resolution must use the same Select/dropdown structure as Video Export.",
+      ).toBe("select");
+      expect(
+        imageResolutionOptionValues,
+        'Image resolution options must include "2k", "4k", and "8k".',
+      ).toEqual(expect.arrayContaining(["2k", "4k", "8k"]));
+      expect(
+        imageResolutionControl?.defaultValue,
+        'Image resolution must default to "4k".',
+      ).toBe("4k");
+      expect(
+        imageExportHasInlinePair,
+        "Image Export format and resolution must render as a compact inline pair.",
+      ).toBe(true);
     }
 
     const videoExportSection = getSchemaVideoExportSection();
@@ -134,48 +142,12 @@ describe("Toolcraft output export acceptance contract", () => {
     const videoResolutionOptionValues = getControlOptionValues(videoResolutionControl);
     expect(
       panelActionTexts.some(textLooksLikeVideoExport),
-      "Apps that declare video delivery must expose Export Video through panelActions.",
-    ).toBe(true);
-    expect(
-      panelActionTexts.length,
-      "Apps with image and video delivery need separate footer actions for Export Video and Export PNG.",
-    ).toBeGreaterThanOrEqual(2);
-    expect(
-      videoExportSection,
-      'Apps with Export Video must expose video settings in a separate controls section titled "Video Export".',
-    ).toBeDefined();
-    expect(
-      videoFormatControl,
-      'The separate "Video Export" section must include a format control with target "export.video.format".',
-    ).toBeDefined();
-    expect(
-      ["select", "segmented"],
-      "Video format must be a Select or Segmented control so the user chooses a supported container instead of typing a freeform value.",
-    ).toContain(videoFormatControl?.type);
+      "Video export action presence must match resolved product export intent.",
+    ).toBe(delivery.videoEnabled);
     expect(
-      videoFormatOptionValues,
-      'Video format options must include safe browser baseline choices: "webm" and "mp4".',
-    ).toEqual(expect.arrayContaining(["webm", "mp4"]));
-    expect(
-      videoResolutionControl,
-      'The separate "Video Export" section must include a resolution control with target "export.video.resolution".',
-    ).toBeDefined();
-    expect(
-      ["select"],
-      "Video resolution must be a Select control with explicit output-size choices.",
-    ).toContain(videoResolutionControl?.type);
-    expect(
-      videoResolutionOptionValues,
-      'Video resolution options must include "current" and "4k".',
-    ).toEqual(expect.arrayContaining(["current", "4k"]));
-    expect(
-      videoResolutionControl?.defaultValue,
-      'Video resolution must default to "current".',
-    ).toBe("current");
-    expect(
-      videoFormatControl?.defaultValue,
-      'Video format must default to "mp4".',
-    ).toBe("mp4");
+      videoExportSection !== undefined,
+      '"Video Export" section presence must match resolved product export intent.',
+    ).toBe(delivery.videoEnabled);
     const videoFormatControlId = getSectionControlIdByTarget(
       videoExportSection,
       "export.video.format",
@@ -194,9 +166,49 @@ describe("Toolcraft output export acceptance contract", () => {
               group.controls.includes(videoResolutionControlId),
           ) === true;
 
-    expect(
-      videoExportHasInlinePair,
-      "Video Export format and resolution must render as a compact inline pair unless a documented fit fallback is used.",
-    ).toBe(true);
+    if (delivery.videoEnabled) {
+      if (delivery.imageEnabled) {
+        expect(
+          panelActionTexts.length,
+          "Apps with image and video delivery need separate footer actions for Export Video and Export PNG.",
+        ).toBeGreaterThanOrEqual(2);
+      }
+      expect(
+        videoFormatControl,
+        'The separate "Video Export" section must include a format control with target "export.video.format".',
+      ).toBeDefined();
+      expect(
+        ["select", "segmented"],
+        "Video format must be a Select or Segmented control so the user chooses a supported container instead of typing a freeform value.",
+      ).toContain(videoFormatControl?.type);
+      expect(
+        videoFormatOptionValues,
+        'Video format options must include safe browser baseline choices: "webm" and "mp4".',
+      ).toEqual(expect.arrayContaining(["webm", "mp4"]));
+      expect(
+        videoResolutionControl,
+        'The separate "Video Export" section must include a resolution control with target "export.video.resolution".',
+      ).toBeDefined();
+      expect(
+        ["select"],
+        "Video resolution must be a Select control with explicit output-size choices.",
+      ).toContain(videoResolutionControl?.type);
+      expect(
+        videoResolutionOptionValues,
+        'Video resolution options must include "current" and "4k".',
+      ).toEqual(expect.arrayContaining(["current", "4k"]));
+      expect(
+        videoResolutionControl?.defaultValue,
+        'Video resolution must default to "current".',
+      ).toBe("current");
+      expect(
+        videoFormatControl?.defaultValue,
+        'Video format must default to "mp4".',
+      ).toBe("mp4");
+      expect(
+        videoExportHasInlinePair,
+        "Video Export format and resolution must render as a compact inline pair unless a documented fit fallback is used.",
+      ).toBe(true);
+    }
   });
 });

package/templates/starter/src/app/starter-acceptance.product-readiness.test.ts

@@ -4,6 +4,10 @@ import {
   starterProductReadiness,
   starterTransferMode,
 } from "./starter-acceptance";
+import {
+  schemaHasSvgExportPanelAction,
+  schemaHasVideoExportPanelAction,
+} from "./acceptance/output-export";
 import { isNeutralTemplateProject } from "./starter-acceptance.product-readiness-test-utils";
 import { schemaHasProductSurface } from "./starter-acceptance.schema-test-utils";
 import { starterSchema } from "./starter-schema";
@@ -17,11 +21,36 @@ describe("Toolcraft product readiness", () => {
     expect(starterTransferMode).toEqual({
       animationIntent: { mode: "none" },
       mode: "new-toolcraft-app",
+      referenceInputs: [],
     });
   });
 
+  it("makes the no-reference decision explicit", () => {
+    if (starterProductReadiness.mode !== "starter") {
+      return;
+    }
+
+    expect(starterTransferMode.referenceInputs).toEqual([]);
+  });
+
   it("allows neutral readiness only for the source starter/template folder", () => {
     if (starterProductReadiness.mode === "product") {
+      expect(starterProductReadiness.exportIntent).toBeDefined();
+      if (starterProductReadiness.exportIntent.image.mode === "toolcraft-default") {
+        expect(starterProductReadiness.exportIntent.image).toEqual({
+          mode: "toolcraft-default",
+        });
+      }
+      expect(starterProductReadiness.exportIntent.video.mode).toBe(
+        schemaHasVideoExportPanelAction(starterSchema)
+          ? "user-requested"
+          : "not-requested",
+      );
+      expect(starterProductReadiness.exportIntent.svg.mode).toBe(
+        schemaHasSvgExportPanelAction(starterSchema)
+          ? "user-requested"
+          : "not-requested",
+      );
       expect(starterProductReadiness.productName.trim()).not.toBe("");
       expect(starterProductReadiness.productSummary.trim()).not.toBe("");
       expect(starterProductReadiness.requestedBehavior.trim()).not.toBe("");

package/templates/starter/src/app/starter-acceptance.product-worklog.test.ts

@@ -2,20 +2,141 @@ import { existsSync, readFileSync } from "node:fs";
 
 import { describe, expect, it } from "vitest";
 
-import { starterProductReadiness } from "./starter-acceptance";
+import {
+  starterProductReadiness,
+  starterTransferMode,
+} from "./starter-acceptance";
+import type { ToolcraftTransferMode } from "./starter-acceptance";
+import {
+  createMotionReferenceBehavior,
+  createMotionReferenceInput,
+  createOrdinalMotionReferenceStudy,
+  createTimedMotionReferenceStudy,
+} from "./starter-acceptance.motion-reference-test-utils";
 import { schemaHasProductSurface } from "./starter-acceptance.schema-test-utils";
 import {
   agentWorklogPath,
   getAgentWorklogValidationErrors,
+  type WorklogMotionReference,
 } from "./starter-acceptance.worklog-test-utils";
 
+function getWorklogMotionReferences(
+  transferMode: ToolcraftTransferMode,
+): readonly WorklogMotionReference[] {
+  return transferMode.referenceInputs.flatMap((referenceInput) =>
+    referenceInput.studies.map((study) => {
+      const requiresRealTimeReview =
+        study.evidence.timingMode === "seconds";
+      const requiresSlowedReview =
+        requiresRealTimeReview &&
+        (study.events.some(
+          ({ classification }) => classification === "product-behavior",
+        ) ||
+          referenceInput.behaviors.some((behavior) =>
+            behavior.timingClaims.some(
+              (claim) => claim.studyId === study.studyId,
+            ),
+          ));
+
+      return {
+        contactSheetPath: study.evidence.contactSheet.path,
+        referenceId: referenceInput.referenceId,
+        requiresRealTimeReview,
+        requiresSlowedReview,
+        sourceSha256: study.evidence.sourceSha256,
+        studyId: study.studyId,
+        timingMode: study.evidence.timingMode,
+      } satisfies WorklogMotionReference;
+    }),
+  );
+}
+
+const worklogMotionReferences = getWorklogMotionReferences(starterTransferMode);
+
 describe("Toolcraft product worklog", () => {
+  it("derives real-time, slowed, and ordered-frame review requirements per nested study", () => {
+    const transferMode: ToolcraftTransferMode = {
+      animationIntent: { mode: "none" },
+      mode: "new-toolcraft-app",
+      referenceInputs: [
+        createMotionReferenceInput({
+          behaviors: [
+            createMotionReferenceBehavior({
+              timingClaims: [{ claim: "duration", studyId: "study-claim" }],
+            }),
+          ],
+          studies: [
+            createTimedMotionReferenceStudy({
+              pathId: "study-event",
+              studyId: "study-event",
+            }),
+            createTimedMotionReferenceStudy({
+              pathId: "study-claim",
+              studyId: "study-claim",
+              withEvent: false,
+            }),
+            createTimedMotionReferenceStudy({
+              pathId: "study-quiet",
+              studyId: "study-quiet",
+              withEvent: false,
+            }),
+            createOrdinalMotionReferenceStudy({
+              pathId: "study-ordinal",
+              studyId: "study-ordinal",
+            }),
+          ],
+        }),
+      ],
+    };
+
+    expect(
+      getWorklogMotionReferences(transferMode).map(
+        ({ requiresRealTimeReview, requiresSlowedReview, studyId, timingMode }) =>
+          ({
+            requiresRealTimeReview,
+            requiresSlowedReview,
+            studyId,
+            timingMode,
+          }),
+      ),
+    ).toEqual([
+      {
+        requiresRealTimeReview: true,
+        requiresSlowedReview: true,
+        studyId: "study-event",
+        timingMode: "seconds",
+      },
+      {
+        requiresRealTimeReview: true,
+        requiresSlowedReview: true,
+        studyId: "study-claim",
+        timingMode: "seconds",
+      },
+      {
+        requiresRealTimeReview: true,
+        requiresSlowedReview: false,
+        studyId: "study-quiet",
+        timingMode: "seconds",
+      },
+      {
+        requiresRealTimeReview: false,
+        requiresSlowedReview: false,
+        studyId: "study-ordinal",
+        timingMode: "ordinal",
+      },
+    ]);
+  });
+
   it("requires product apps to replace the starter worklog with decision evidence", () => {
     if (starterProductReadiness.mode !== "product" && !schemaHasProductSurface()) {
       return;
     }
 
     expect(existsSync(agentWorklogPath)).toBe(true);
-    expect(getAgentWorklogValidationErrors(readFileSync(agentWorklogPath, "utf8"))).toEqual([]);
+    expect(
+      getAgentWorklogValidationErrors(readFileSync(agentWorklogPath, "utf8"), {
+        motionReferences: worklogMotionReferences,
+      }),
+    ).toEqual([]);
   });
 });

package/templates/starter/src/app/starter-acceptance.reference-custom-timeline.test.ts

@@ -19,6 +19,7 @@ describe("starter acceptance custom reference timeline contract", () => {
         transferMode: {
           behaviorCoverage: ["canvas-sizing", "control-mapping", "renderer-state"],
           mode: "reference-runtime-clone",
+          referenceInputs: [],
           referenceName: "legacy state timeline",
           referenceTimeline: {
             behaviorCoverage: ["state-jump", "trim-range"],
@@ -117,6 +118,7 @@ describe("starter acceptance custom reference timeline contract", () => {
         transferMode: {
           behaviorCoverage: ["canvas-sizing", "control-mapping", "renderer-state"],
           mode: "reference-runtime-clone",
+          referenceInputs: [],
           referenceFeatureInventory: makeReferenceFeatureInventory([
             {
               acceptanceId: "reference.timeline.stateJump",

package/templates/starter/src/app/starter-acceptance.reference-foundation.test.ts

@@ -27,6 +27,7 @@ describe("starter acceptance reference-runtime foundation", () => {
             "renderer-loop",
           ],
           mode: "reference-runtime-clone",
+          referenceInputs: [],
           referenceName: "legacy badge wall",
           sourceOfTruth: "reference-runtime",
         } as never,
@@ -57,6 +58,7 @@ describe("starter acceptance reference-runtime foundation", () => {
         transferMode: {
           behaviorCoverage: ["canvas-sizing", "control-mapping", "renderer-state"],
           mode: "reference-runtime-clone",
+          referenceInputs: [],
           referenceName: "legacy badge wall",
           referenceTimeline: { behaviorCoverage: [], mode: "none" },
           sourceOfTruth: "reference-runtime",
@@ -86,6 +88,7 @@ describe("starter acceptance reference-runtime foundation", () => {
         transferMode: {
           behaviorCoverage: ["canvas-sizing", "control-mapping", "renderer-state"],
           mode: "reference-runtime-clone",
+          referenceInputs: [],
           referenceFeatureInventory: makeReferenceFeatureInventory(),
           referenceName: "legacy badge wall",
           referenceTimeline: { behaviorCoverage: [], mode: "none" },
@@ -110,6 +113,7 @@ describe("starter acceptance reference-runtime foundation", () => {
         transferMode: {
           behaviorCoverage: ["canvas-sizing", "control-mapping", "renderer-state"],
           mode: "reference-runtime-clone",
+          referenceInputs: [],
           referenceFeatureInventory: makeReferenceFeatureInventory(),
           referenceName: "legacy badge wall",
           referenceStudy: {
@@ -141,6 +145,7 @@ describe("starter acceptance reference-runtime foundation", () => {
         transferMode: {
           behaviorCoverage: ["canvas-sizing", "control-mapping", "renderer-state"],
           mode: "reference-runtime-clone",
+          referenceInputs: [],
           referenceFeatureInventory: [
             {
               acceptanceId: "appearance.opacity",
@@ -180,6 +185,7 @@ describe("starter acceptance reference-runtime foundation", () => {
         transferMode: {
           behaviorCoverage: ["canvas-sizing", "control-mapping", "renderer-state"],
           mode: "reference-runtime-clone",
+          referenceInputs: [],
           referenceFeatureInventory: [
             { ...makeReferenceFeatureInventory()[0], behaviorEvidence: "" },
             ...makeReferenceFeatureInventory().slice(1),
@@ -208,6 +214,7 @@ describe("starter acceptance reference-runtime foundation", () => {
         transferMode: {
           behaviorCoverage: ["canvas-sizing", "control-mapping", "renderer-state"],
           mode: "reference-runtime-clone",
+          referenceInputs: [],
           referenceFeatureInventory: [
             {
               ...makeReferenceFeatureInventory()[0],
@@ -292,6 +299,7 @@ describe("starter acceptance reference-runtime foundation", () => {
         transferMode: {
           behaviorCoverage: ["canvas-sizing", "control-mapping", "renderer-state"],
           mode: "reference-runtime-clone",
+          referenceInputs: [],
           referenceName: "legacy iframe shell",
           referenceTimeline: { behaviorCoverage: [], mode: "none" },
           sourceOfTruth: "reference-runtime",

package/templates/starter/src/app/starter-acceptance.reference-timeline.test.ts

@@ -67,6 +67,7 @@ describe("starter acceptance reference timeline contract", () => {
         transferMode: {
           behaviorCoverage: ["canvas-sizing", "control-mapping", "renderer-state"],
           mode: "reference-runtime-clone",
+          referenceInputs: [],
           referenceFeatureInventory: makeReferenceFeatureInventory(),
           referenceName: "legacy badge wall",
           referenceStudy: referenceStudyEvidence,
@@ -90,6 +91,7 @@ describe("starter acceptance reference timeline contract", () => {
             "pause-resume",
           ],
           mode: "reference-runtime-clone",
+          referenceInputs: [],
           referenceName: "legacy pause animation",
           referenceTimeline: { behaviorCoverage: [], mode: "none" },
           sourceOfTruth: "reference-runtime",
@@ -114,6 +116,7 @@ describe("starter acceptance reference timeline contract", () => {
             "time-progress",
           ],
           mode: "reference-runtime-clone",
+          referenceInputs: [],
           referenceName: "legacy restart animation",
           referenceTimeline: { behaviorCoverage: [], mode: "none" },
           sourceOfTruth: "reference-runtime",
@@ -132,6 +135,7 @@ describe("starter acceptance reference timeline contract", () => {
         transferMode: {
           behaviorCoverage: ["canvas-sizing", "control-mapping", "renderer-state"],
           mode: "reference-runtime-clone",
+          referenceInputs: [],
           referenceName: "legacy playback animation",
           referenceTimeline: { behaviorCoverage: [], mode: "toolcraft-playback" },
           sourceOfTruth: "reference-runtime",
@@ -170,6 +174,7 @@ describe("starter acceptance reference timeline contract", () => {
             "pause-resume",
           ],
           mode: "reference-runtime-clone",
+          referenceInputs: [],
           referenceName: "legacy playback animation",
           referenceTimeline: { behaviorCoverage: ["playback"], mode: "toolcraft-playback" },
           sourceOfTruth: "reference-runtime",
@@ -208,6 +213,7 @@ describe("starter acceptance reference timeline contract", () => {
             "pause-resume",
           ],
           mode: "reference-runtime-clone",
+          referenceInputs: [],
           referenceName: "legacy playback animation",
           referenceTimeline: {
             behaviorCoverage: ["playback"],
@@ -255,6 +261,7 @@ describe("starter acceptance reference timeline contract", () => {
             "time-progress",
           ],
           mode: "reference-runtime-clone",
+          referenceInputs: [],
           referenceName: "legacy keyframe animation",
           referenceTimeline: { behaviorCoverage: ["keyframes"], mode: "toolcraft-keyframes" },
           sourceOfTruth: "reference-runtime",

package/templates/starter/src/app/starter-acceptance.section-cohesion.test.ts

@@ -162,6 +162,7 @@ describe("starter acceptance section cohesion contract", () => {
           reason: "The flow speed is a decorative self-running effect and does not expose product time transport.",
         },
         mode: "new-toolcraft-app",
+        referenceInputs: [],
       },
     });
 
@@ -247,6 +248,7 @@ describe("starter acceptance section cohesion contract", () => {
             reason: "The flow speed is a decorative self-running effect and does not expose product time transport.",
           },
           mode: "new-toolcraft-app",
+          referenceInputs: [],
         },
       }),
     ).toEqual([]);
@@ -311,7 +313,7 @@ describe("starter acceptance section cohesion contract", () => {
       }),
     ).toEqual(
       expect.arrayContaining([
-        'Controls for product entity "squares.right" are split across sections: Square 1 (Right), Appearance. Keep controls for the same product entity in one semantic section unless the Control Section Inventory declares workflowStage and splitReason for every split section.',
+        'Controls for target family "squares.right" are split across sections: Square 1 (Right), Appearance. Assign one shared entityId when the sections edit one logical entity; the entity cohesion validator decides whether that split is allowed.',
       ]),
     );
   });