@pixel-point/toolcraft 0.0.16 → 0.0.17

package/src/generate-test-product-iteration.mjs

@@ -21,6 +21,7 @@ export const generatedProductMaterialIterationFixturePaths = Object.freeze([
   "public/material-sprinkles.svg",
   "src/app/app-acceptance-data.ts",
   "src/app/app-verification-impact.json",
+  "src/app/material-acceptance-data.ts",
   "src/app/material-output.test.tsx",
   "src/app/material-output.tsx",
   "src/app/material-schema.ts",

package/src/generate-test-product-iteration.test.mjs

@@ -18,6 +18,7 @@ const expectedPaths = [
   "public/material-sprinkles.svg",
   "src/app/app-acceptance-data.ts",
   "src/app/app-verification-impact.json",
+  "src/app/material-acceptance-data.ts",
   "src/app/material-output.test.tsx",
   "src/app/material-output.tsx",
   "src/app/material-schema.ts",

package/src/generate-test-standalone-delivery-stages.mjs

@@ -6,7 +6,7 @@ import {
   assertGeneratedExecutionLedger,
   runGeneratedDeliveryWithLedger,
 } from "./generate-test-browser-execution-ledger.mjs";
-import { runGeneratedScript } from "./generate-test-dependency-sandbox.mjs";
+import { runGeneratedExecutable } from "./generate-test-dependency-sandbox.mjs";
 
 export async function assertGeneratedRuntimeProbe({
   execFileAsync,
@@ -15,8 +15,11 @@ export async function assertGeneratedRuntimeProbe({
   const productTestPath = path.join(targetDir, "src/app/app-schema.test.ts");
   const productTestSource = await fs.readFile(productTestPath, "utf8");
   const failingSource = productTestSource.replace(
-    'it("ambient speed changes product output"',
-    'it.fails("ambient speed changes product output"',
+    'it("ambient speed changes product output", () => {',
+    [
+      'it.fails("ambient speed changes product output", () => {',
+      '    throw new Error("runtime evidence probe failure");',
+    ].join("\n"),
   );
   assert.notEqual(
     failingSource,
@@ -26,14 +29,19 @@ export async function assertGeneratedRuntimeProbe({
   await fs.writeFile(productTestPath, failingSource);
   try {
     await assert.rejects(
-      runGeneratedScript(execFileAsync, targetDir, "test"),
+      runGeneratedExecutable(execFileAsync, targetDir, "vitest", [
+        "run",
+        "src",
+        "--passWithNoTests",
+        "--reporter=default",
+        "--reporter=./scripts/toolcraft-vitest-runtime-evidence-reporter.mjs",
+      ]),
       (error) => {
         const output = `${String(error.stdout)}\n${String(error.stderr)}`;
         assert.match(
-          output.slice(-12_000),
+          output,
           /Toolcraft automated runtime coverage failed:[\s\S]*must not use expected-failure mode/u,
         );
-        assert.match(output, /TOOLCRAFT_GENERATED_SCRIPT_TEST_EXECUTED/u);
         return true;
       },
     );

package/src/generate.test.mjs

@@ -64,6 +64,20 @@ describe("generateToolcraft", () => {
     );
     assert.match(performanceSource, /workloadEnvelope:\s*\{\s*dimensions:\s*\[\]\s*\}/u);
     assert.doesNotMatch(performanceSource, /\bworkloadTargets\s*:/u);
+
+    assert.ok(
+      await fs.stat(
+        path.join(
+          targetDir,
+          "src/toolcraft/runtime/schema/canvas-render-scale.ts",
+        ),
+      ),
+    );
+    const gitignoreSource = await fs.readFile(
+      path.join(targetDir, ".gitignore"),
+      "utf8",
+    );
+    assert.match(gitignoreSource, /^\.playwright-mcp$/mu);
   });
 
   it("tests, typechecks, and builds a non-neutral generated product in isolation", async () => {

package/templates/runtime/contracts/component-contracts.choices.test.ts

@@ -216,10 +216,10 @@ describe("Toolcraft template component contracts: choices and actions", () => {
       "Do not use panelActions for resetting controls; the controls panel header owns Reset controls.",
     );
     expect(contract.aiUsageRules).toContain(
-      "Handle product-specific panelActions through ToolcraftApp onPanelAction.",
+      "Handle product-specific non-export panelActions through ToolcraftApp onPanelAction. Typed export-image and export-video actions are runtime-owned and consume ToolcraftAppComposition.exportRenderer.",
     );
     expect(contract.aiUsageRules).toContain(
-      "Async product actions such as Export, Download, Copy, Generate, or Apply must return the real Promise from onPanelAction and report progress through the onPanelAction reportProgress callback.",
+      "Async non-export product actions such as Download, Copy, Generate, or Apply must return the real Promise from onPanelAction and report progress through the onPanelAction reportProgress callback.",
     );
     expect(contract.aiUsageRules).toContain(
       "The sticky footer top accent indicator is determinate when reportProgress receives 0..1 values and falls back to pending state only when progress is unavailable.",
@@ -249,7 +249,7 @@ describe("Toolcraft template component contracts: choices and actions", () => {
       "Image Export format and resolution render as one compact two-column inline Select pair, matching the Video Export settings structure.",
     );
     expect(contract.aiUsageRules).toContain(
-      "Image Export resolution controls the actual exported image long edge: 2K = 2048px, 4K = 4096px, 8K = 8192px. Pass the selected runtime value to createToolcraftPngExportCanvas resolution and prove decoded image width/height in browser acceptance.",
+      "Image Export resolution controls the actual exported image long edge: 2K = 2048px, 4K = 4096px, 8K = 8192px. Runtime resolves the selected value and protected browser acceptance proves decoded image width and height.",
     );
     expect(contract.aiUsageRules).toContain(
       "Apps that deliver animation include Export Video as the primary footer action and Export PNG as a secondary footer action; timeline playback alone does not invent video delivery.",
@@ -285,16 +285,16 @@ describe("Toolcraft template component contracts: choices and actions", () => {
       'Baseline browser video formats are "mp4" and "webm"; MOV or ProRes require an explicit custom encoder/transcoder and dedicated acceptance plus performance coverage.',
     );
     expect(contract.aiUsageRules).toContain(
-      "Video export code must choose the actual MIME/container through MediaRecorder.isTypeSupported or an equivalent encoder capability check, then fall back safely.",
+      "Runtime video export chooses the actual MIME, container, and codec through the timestamped Mediabunny encoder capability check, then returns the real supported format or a typed visible failure.",
     );
     expect(contract.aiUsageRules).toContain(
       "Video export must use getToolcraftVideoExportSize for current and 4K dimensions. Current video export uses the current canvas/output size with even encoder-safe rounding; 4K video fits inside an encoder-safe 3840x2160 box, preserves canvas aspect ratio, and uses even pixel dimensions. Do not hand-roll 4096px long-edge video sizing.",
     );
     expect(contract.aiUsageRules).toContain(
-      "Video export must set recording canvas dimensions before captureStream, MediaRecorder, VideoEncoder, or equivalent encoder setup, and must reject recorder/encoder errors instead of returning corrupt blobs.",
+      "Runtime video export allocates the selected recording canvas dimensions before timestamped encoder setup and rejects renderer, encoder, muxer, and output-limit errors instead of returning corrupt blobs.",
     );
     expect(contract.aiUsageRules).toContain(
-      "Offline video export duration must be encoded from runtime timeline timestamps. Do not rely on canvas.captureStream plus MediaRecorder wall-clock recording time as the only duration mechanism for rendered-frame export.",
+      "Offline video export duration is encoded from the fixed runtime 30 FPS timeline schedule. Product code must not use canvas.captureStream, MediaRecorder, or wall-clock time as a fallback.",
     );
     expect(contract.aiUsageRules).toContain(
       'Video resolution must control exported dimensions. Use "current" output size by default; "4K" is an export resolution target, not a hardcoded 3840x2160 canvas lock.',
@@ -309,13 +309,16 @@ describe("Toolcraft template component contracts: choices and actions", () => {
       'Product-output apps declare the standard background pair in an authored "Background" source section. Runtime removes that visible section and places Background plus Infinity canvas, then Background color, in Setup; Timeline is the final Setup control.',
     );
     expect(contract.aiUsageRules).toContain(
-      "Product-output apps pass the includeBackground runtime value to createToolcraftPngExportCanvas for PNG alpha and call shouldIncludeToolcraftPreviewBackground(state) for bounded live preview background. In Infinity mode CanvasShell owns the selected full-viewport background color, and Background off restores finite mode and disables Infinity.",
+      "Product-output apps call shouldIncludeToolcraftPreviewBackground(state) for bounded live preview background. Runtime artifact export owns Background semantics: PNG may be transparent, JPEG and video remain opaque, Infinity uses the full-viewport color, and Background off restores finite mode and disables Infinity.",
     );
     expect(contract.aiUsageRules).toContain(
-      "PNG export must use createToolcraftPngExportCanvas so background transparency and selected image dimensions or retina fallback are applied consistently; turning Background off makes preview product background and PNG alpha transparent without hiding the Toolcraft canvas backing or video background.",
+      "ToolcraftAppComposition.exportRenderer draws one deterministic product frame in scene coordinates for both image and video. Runtime owns canvas allocation, background, runtime media/model compositing, selected dimensions, encoding, download, progress, and typed failures.",
     );
     expect(contract.aiUsageRules).toContain(
-      "Video export must keep product background and use getToolcraftVideoExportSize for current/4K output dimensions.",
+      "Product modules must not encode or download export canvases directly and must not instantiate MediaRecorder or VideoEncoder; the generated-source boundary rejects those duplicate export paths.",
+    );
+    expect(contract.aiUsageRules).toContain(
+      "Runtime video export keeps the selected background and uses getToolcraftVideoExportSize for current/4K output dimensions.",
     );
     expect(contract.aiUsageRules).toContain(
       "Copy PNG can be a secondary action when clipboard output is useful, but copy does not replace export.",

package/templates/runtime/contracts/component-contracts.choices.ts

@@ -319,8 +319,8 @@ export const TOOLCRAFT_CHOICE_COMPONENT_CONTRACTS = {
     aiUsageRules: [
       "Use panelActions only for sticky footer product actions such as Generate, Export, Copy, or Download.",
       "Do not use panelActions for resetting controls; the controls panel header owns Reset controls.",
-      "Handle product-specific panelActions through ToolcraftApp onPanelAction.",
-      "Async product actions such as Export, Download, Copy, Generate, or Apply must return the real Promise from onPanelAction and report progress through the onPanelAction reportProgress callback.",
+      "Handle product-specific non-export panelActions through ToolcraftApp onPanelAction. Typed export-image and export-video actions are runtime-owned and consume ToolcraftAppComposition.exportRenderer.",
+      "Async non-export product actions such as Download, Copy, Generate, or Apply must return the real Promise from onPanelAction and report progress through the onPanelAction reportProgress callback.",
       "The sticky footer top accent indicator is determinate when reportProgress receives 0..1 values and falls back to pending state only when progress is unavailable.",
       "defineToolcraft hoists panelActions into the controls panel sticky footer automatically.",
       "Product-output apps must always include export in panelActions.",
@@ -330,7 +330,7 @@ export const TOOLCRAFT_CHOICE_COMPONENT_CONTRACTS = {
       'The Image Export section must include "export.image.format" as a Select control with PNG and JPG choices, defaulting to "png".',
       'The Image Export section must include "export.image.resolution" as a Select control with 2K, 4K, and 8K choices, defaulting to "4k".',
       "Image Export format and resolution render as one compact two-column inline Select pair, matching the Video Export settings structure.",
-      "Image Export resolution controls the actual exported image long edge: 2K = 2048px, 4K = 4096px, 8K = 8192px. Pass the selected runtime value to createToolcraftPngExportCanvas resolution and prove decoded image width/height in browser acceptance.",
+      "Image Export resolution controls the actual exported image long edge: 2K = 2048px, 4K = 4096px, 8K = 8192px. Runtime resolves the selected value and protected browser acceptance proves decoded image width and height.",
       "Apps that deliver animation include Export Video as the primary footer action and Export PNG as a secondary footer action; timeline playback alone does not invent video delivery.",
       "Any app with Export Video must enable the top Toolcraft timeline; video duration, loop, and rendered timestamps come from runtime timeline state.",
       'Apps with Export Video must expose a separate "Video Export" controls section.',
@@ -342,17 +342,18 @@ export const TOOLCRAFT_CHOICE_COMPONENT_CONTRACTS = {
       'Video Export resolution defaults to "current"; keep "4k" available as the high-resolution alternate.',
       "Video Export format and resolution are a compact semantic pair and should use a two-column inline layout by default; use stacked rows only when labels or selected values do not fit without clipping.",
       'Baseline browser video formats are "mp4" and "webm"; MOV or ProRes require an explicit custom encoder/transcoder and dedicated acceptance plus performance coverage.',
-      "Video export code must choose the actual MIME/container through MediaRecorder.isTypeSupported or an equivalent encoder capability check, then fall back safely.",
+      "Runtime video export chooses the actual MIME, container, and codec through the timestamped Mediabunny encoder capability check, then returns the real supported format or a typed visible failure.",
       "Video export must use getToolcraftVideoExportSize for current and 4K dimensions. Current video export uses the current canvas/output size with even encoder-safe rounding; 4K video fits inside an encoder-safe 3840x2160 box, preserves canvas aspect ratio, and uses even pixel dimensions. Do not hand-roll 4096px long-edge video sizing.",
-      "Video export must set recording canvas dimensions before captureStream, MediaRecorder, VideoEncoder, or equivalent encoder setup, and must reject recorder/encoder errors instead of returning corrupt blobs.",
-      "Offline video export duration must be encoded from runtime timeline timestamps. Do not rely on canvas.captureStream plus MediaRecorder wall-clock recording time as the only duration mechanism for rendered-frame export.",
+      "Runtime video export allocates the selected recording canvas dimensions before timestamped encoder setup and rejects renderer, encoder, muxer, and output-limit errors instead of returning corrupt blobs.",
+      "Offline video export duration is encoded from the fixed runtime 30 FPS timeline schedule. Product code must not use canvas.captureStream, MediaRecorder, or wall-clock time as a fallback.",
       'Video resolution must control exported dimensions. Use "current" output size by default; "4K" is an export resolution target, not a hardcoded 3840x2160 canvas lock.',
       "Video export browser coverage must load the exported blob metadata and prove video.duration matches the edited runtime timeline duration; blobSize/blobType checks alone are not enough.",
       "Video export must report frame-based progress through reportProgress during render/encode steps. PNG export should report phase progress for render, blob, and handoff when those phases are asynchronous.",
       'Product-output apps declare the standard background pair in an authored "Background" source section. Runtime removes that visible section and places Background plus Infinity canvas, then Background color, in Setup; Timeline is the final Setup control.',
-      "Product-output apps pass the includeBackground runtime value to createToolcraftPngExportCanvas for PNG alpha and call shouldIncludeToolcraftPreviewBackground(state) for bounded live preview background. In Infinity mode CanvasShell owns the selected full-viewport background color, and Background off restores finite mode and disables Infinity.",
-      "PNG export must use createToolcraftPngExportCanvas so background transparency and selected image dimensions or retina fallback are applied consistently; turning Background off makes preview product background and PNG alpha transparent without hiding the Toolcraft canvas backing or video background.",
-      "Video export must keep product background and use getToolcraftVideoExportSize for current/4K output dimensions.",
+      "Product-output apps call shouldIncludeToolcraftPreviewBackground(state) for bounded live preview background. Runtime artifact export owns Background semantics: PNG may be transparent, JPEG and video remain opaque, Infinity uses the full-viewport color, and Background off restores finite mode and disables Infinity.",
+      "ToolcraftAppComposition.exportRenderer draws one deterministic product frame in scene coordinates for both image and video. Runtime owns canvas allocation, background, runtime media/model compositing, selected dimensions, encoding, download, progress, and typed failures.",
+      "Product modules must not encode or download export canvases directly and must not instantiate MediaRecorder or VideoEncoder; the generated-source boundary rejects those duplicate export paths.",
+      "Runtime video export keeps the selected background and uses getToolcraftVideoExportSize for current/4K output dimensions.",
       "Copy PNG can be a secondary action when clipboard output is useful, but copy does not replace export.",
       "Add Copy PNG as a secondary action only when the prompt/reference includes clipboard output or the product clearly benefits from paste/share workflows.",
       "Footer actions must be one compact horizontal group; do not split them into stacked full-width sections.",

package/templates/runtime/contracts/component-contracts.runtime-acceptance.test.ts

@@ -82,10 +82,22 @@ describe("Toolcraft template component contracts: runtime and composition", () =
     );
     expect(rules).toContain("performance-iteration");
     expect(rules).toContain(
-      "one exact authority-selected targeted performance iteration",
+      "Only a localized complaint or a post-clarification targeted choice creates performance-iteration intent",
     );
     expect(rules).toContain(
-      "Complaint wording and repetition never select the complete performance matrix",
+      "Classifier output establishes complaint authority only and never path localization",
+    );
+    expect(rules).toContain(
+      "Regardless of whether the classifier returned high-confidence performance-iteration or needs-agent-judgment, unresolved localization creates neither performance-iteration intent nor canonical path authority",
+    );
+    expect(rules).toContain(
+      "repetition alone never expands scope or selects the complete performance matrix",
+    );
+    expect(rules).not.toContain(
+      "One complaint maps to one exact authority-selected targeted performance iteration",
+    );
+    expect(rules).not.toContain(
+      "Direct and repeated performance complaints each start one bounded targeted iteration",
     );
     expect(rules).toContain(
       "After two consecutive compatible protected performance iterations, the agent must offer a slower complete audit",
@@ -135,6 +147,9 @@ describe("Toolcraft template component contracts: runtime and composition", () =
     expect(rules).toContain(
       TOOLCRAFT_PERFORMANCE_VERIFICATION_POLICY.renderScaleFidelity,
     );
+    expect(rules).toContain(
+      TOOLCRAFT_PERFORMANCE_VERIFICATION_POLICY.complaintRouting,
+    );
     expect(contract.aiUsageRules).toContain(
       "Every export performance scenario must declare the exact panelActions actionValue, visible controlLabel, and completionEvidence it exercises; selectors, unrelated export actions, and injectable completion callbacks are not output evidence. The named browser scenario must resolve to test or it imported from @playwright/test, be statically registered at module scope or inside an executable test.describe, test.describe.serial, or test.describe.parallel suite, and directly await the matching unshadowed protected output-action helper in its root callback block without focus, skip, condition, or nesting; local test runners, uncalled or conditional test declarations, skipped/fixme suites, and runtime skip/fixme/fail annotations are invalid, and generated integrity protects the focused-test Playwright config.",
     );

package/templates/runtime/contracts/component-contracts.runtime-panels.test.ts

@@ -62,7 +62,7 @@ describe("Toolcraft template component contracts: runtime and composition", () =
       'Any product app with Export Video must enable the top Toolcraft timeline: use panels.timeline mode "playback" for product animation transport, or mode "keyframes" when exported animation is driven by keyframes.',
     );
     expect(TOOLCRAFT_COMPONENT_CONTRACTS.timelinePanel.aiUsageRules).toContain(
-      "Video export renderers must render deterministic frames from runtime timeline timestamps and duration; do not treat autonomous wall-clock time or captureStream recording time as the source of product duration.",
+      "Video export frames are rendered deterministically from the runtime-owned 30 FPS timeline schedule; product code must not use autonomous wall-clock time, captureStream, or MediaRecorder as the source or fallback for product duration.",
     );
     expect(TOOLCRAFT_COMPONENT_CONTRACTS.timelinePanel.aiUsageRules).toContain(
       "Playback renderers must consume runtime timeline state; pause freezes output, scrubbing renders a deterministic frame, and the full animation cycle maps to state.timeline.durationSeconds instead of a local fixed duration.",

package/templates/runtime/contracts/component-contracts.runtime-shell.test.ts

@@ -58,7 +58,7 @@ describe("Toolcraft template component contracts: runtime and composition", () =
       "When the standard Background pair exists, disabling Background atomically restores finite mode and disables Infinity canvas; re-enabling Background restores switch availability without enabling Infinity automatically.",
     );
     expect(contract.aiUsageRules).toContain(
-      "Infinite exports use canonical world-space scene frames: ToolcraftAppComposition.sceneBoundsProvider contributes product bounds, runtime image and model bounds are unioned once, hidden or suppressed content is excluded, PNG crops tightly, and video uses one time-range envelope.",
+      "Infinite exports use canonical world-space scene frames: ToolcraftAppComposition.sceneBoundsProvider contributes exact-state product bounds, runtime image and model bounds are unioned, hidden or suppressed content is excluded, PNG crops tightly, and runtime video unions every scheduled frame state into one envelope.",
     );
     expect(contract.aiUsageRules).toContain(
       "Do not let canvas.upload choose intrinsic-media by default. Upload without explicit sizing resolves to editable-output so source/background images do not own product output size.",

package/templates/runtime/contracts/component-contracts.runtime.ts

@@ -26,7 +26,7 @@ export const TOOLCRAFT_RUNTIME_COMPONENT_CONTRACTS = {
       "Infinity canvas removes finite artboard bounds and clipping, hides Aspect ratio, Canvas width, and Canvas height, and preserves the dormant finite canvas size for exact restoration when disabled.",
       "Infinity canvas suppresses the bounded product-rendered preview background so the dormant finite output does not appear as a second canvas; when the standard Background pair is enabled, CanvasShell fills the complete infinite viewport with the selected Background color.",
       "When the standard Background pair exists, disabling Background atomically restores finite mode and disables Infinity canvas; re-enabling Background restores switch availability without enabling Infinity automatically.",
-      "Infinite exports use canonical world-space scene frames: ToolcraftAppComposition.sceneBoundsProvider contributes product bounds, runtime image and model bounds are unioned once, hidden or suppressed content is excluded, PNG crops tightly, and video uses one time-range envelope.",
+      "Infinite exports use canonical world-space scene frames: ToolcraftAppComposition.sceneBoundsProvider contributes exact-state product bounds, runtime image and model bounds are unioned, hidden or suppressed content is excluded, PNG crops tightly, and runtime video unions every scheduled frame state into one envelope.",
       "Do not let canvas.upload choose intrinsic-media by default. Upload without explicit sizing resolves to editable-output so source/background images do not own product output size.",
       "Use intrinsic-media only for true media-viewer or source-native apps where the natural uploaded/generated media size is the product output; record the reason and prove it with intrinsic-media-size acceptance.",
       "Use editable-output for generated, exportable, shader, poster, badge, wall, banner, thumbnail, procedural, reference-clone, and product-output apps so users always see Aspect ratio, Canvas width, and Canvas height.",
@@ -104,6 +104,7 @@ export const TOOLCRAFT_RUNTIME_COMPONENT_CONTRACTS = {
       runtimeSetupModeRowRule,
       runtimeSetupModeHelpRule,
       "Keep sticky footer panelActions for product delivery actions only, such as Export PNG, Export Video, Copy, Generate, Apply, or Download.",
+      "Typed Export PNG and Export Video actions are runtime-owned and consume one ToolcraftAppComposition.exportRenderer; use onPanelAction only for non-export product actions.",
     ],
     capabilities: ["settings-import-export"],
     commands: ["controls.setValue", "timeline.setCurrentTime", "timeline.setDuration"],
@@ -324,7 +325,7 @@ export const TOOLCRAFT_RUNTIME_COMPONENT_CONTRACTS = {
       "When the product has a known loop duration, declare it as panels.timeline.defaultDurationSeconds; the runtime timeline duration starts from that loop duration instead of an unrelated 8s default.",
       'Timeline animation intent must declare loopDuration with source "reference", "user-request", or "product-derived", plus seconds and evidence; runtime/template fallback 8s is not a valid source.',
       "panels.timeline.defaultDurationSeconds must match animationIntent.loopDuration.seconds for playback/keyframe animation, so the initial timeline UI shows the declared product loop instead of a generic default.",
-      "Video export renderers must render deterministic frames from runtime timeline timestamps and duration; do not treat autonomous wall-clock time or captureStream recording time as the source of product duration.",
+      "Video export frames are rendered deterministically from the runtime-owned 30 FPS timeline schedule; product code must not use autonomous wall-clock time, captureStream, or MediaRecorder as the source or fallback for product duration.",
       "Playback renderers may compute an initial loop duration default during app initialization or reset, but must not watch state.timeline.durationSeconds and dispatch timeline.setDuration back to a computed local duration. User-edited timeline duration becomes the loop duration source of truth after initialization or reset.",
       "Playback renderers should use getToolcraftTimelineLoopTime or getToolcraftTimelineLoopProgress to derive product loop phase from state.timeline.currentTimeSeconds and state.timeline.durationSeconds; do not hand-roll wall-clock, fixed-duration, mirror, yoyo, ping-pong, or reverse phase math.",
       "Product animation loop means a seamless forward-only cycle by default: motion advances in one direction, first and last frames stitch without a visible jump, and mirror/yoyo/ping-pong/reverse loops require explicit user request.",

package/templates/runtime/contracts/decision-contracts.test.ts

@@ -54,8 +54,8 @@ describe("Toolcraft template decision contract", () => {
 
     expect(rule?.level).toBe("invariant");
     expect(rule?.desiredBehavior).toMatch(/sceneBoundsProvider/i);
-    expect(rule?.desiredBehavior).toMatch(/visible scene elements/i);
-    expect(rule?.desiredBehavior).toMatch(/time-range envelope/i);
+    expect(rule?.desiredBehavior).toMatch(/one exact state/i);
+    expect(rule?.desiredBehavior).toMatch(/runtime-owned timestamp schedule/i);
     expect(rule?.desiredBehavior).toMatch(/finite canvas size/i);
     expect(rule?.enforcement).toContain("acceptance-validator");
     expect(rule?.enforcement).toContain("browser-helper");
@@ -228,10 +228,28 @@ describe("Toolcraft template decision contract", () => {
     expect(rule?.desiredBehavior).toMatch(/performance-iteration/i);
     expect(rule?.desiredBehavior).toMatch(/bounded targeted iteration/i);
     expect(rule?.desiredBehavior).toMatch(
-      /one complaint maps to one exact authority-selected targeted performance iteration over canonical affected path IDs/i,
+      /only a localized complaint or a post-clarification targeted choice creates performance-iteration intent and one bounded iteration over exact canonical affected paths/iu,
     );
     expect(rule?.desiredBehavior).toMatch(
-      /complaint wording and repetition never select the complete performance matrix/i,
+      /classifier output establishes complaint authority only and never path localization/iu,
+    );
+    expect(rule?.desiredBehavior).toMatch(
+      /regardless of whether the classifier returned high-confidence performance-iteration or needs-agent-judgment, unresolved localization creates neither performance-iteration intent nor canonical path authority/iu,
+    );
+    expect(rule?.desiredBehavior).not.toMatch(
+      /one complaint maps to one exact authority-selected targeted performance iteration/iu,
+    );
+    expect(rule?.desiredBehavior).not.toMatch(
+      /direct and repeated performance complaints each start one bounded targeted iteration/iu,
+    );
+    expect(rule?.desiredBehavior).toMatch(
+      /localized complaint[\s\S]*without asking the user/iu,
+    );
+    expect(rule?.desiredBehavior).toMatch(
+      /ambiguous or unresolved localization[\s\S]*one user-facing clarification[\s\S]*targeted diagnosis or a complete review/iu,
+    );
+    expect(rule?.desiredBehavior).toMatch(
+      /repetition alone never expands scope or selects the complete performance matrix/i,
     );
     expect(rule?.desiredBehavior).toMatch(
       /explicit natural-language request for the complete audit/i,
@@ -244,6 +262,9 @@ describe("Toolcraft template decision contract", () => {
     expect(rule?.desiredBehavior).toMatch(
       /renderScaleCoverage "selected-backing-pixels" for interaction and steady, plus playback when timeline is enabled/i,
     );
+    expect(rule?.desiredBehavior).toMatch(
+      /every measured path[\s\S]*devicePixelRatio × 2[\s\S]*each measured phase/iu,
+    );
     expect(rule?.desiredBehavior).toMatch(
       /never downsample[\s\S]*clamp the selected render scale to pass a performance budget/i,
     );

package/templates/runtime/contracts/decision-contracts.ts

@@ -58,7 +58,7 @@ export const TOOLCRAFT_DECISION_CONTRACT = [
     area: "runtime-shell",
     currentConstraint: "Apps must assemble through defineToolcraft and ToolcraftApp.",
     desiredBehavior:
-      "Generated apps use the Toolcraft runtime shell and keep product-specific rendering inside supported extension points: schema controls, canvasContent product output, controlRenderers for true custom controls, ToolcraftApp onPanelAction, and runtime commands. App-specific code must not import or render low-level runtime surfaces or built-in control components directly.",
+      "Generated apps use the Toolcraft runtime shell and keep product-specific rendering inside supported extension points: schema controls, canvasContent product output, controlRenderers for true custom controls, one shared ToolcraftAppComposition.exportRenderer for typed image/video actions, ToolcraftApp onPanelAction for non-export product actions, and runtime commands. App-specific code must not import or render low-level runtime surfaces or built-in control components directly, instantiate encoders, or own artifact download mechanics.",
     enforcement: [
       "cli-integrity-check",
       "acceptance-validator",
@@ -99,7 +99,7 @@ export const TOOLCRAFT_DECISION_CONTRACT = [
     currentConstraint:
       "Editable output can switch from a finite artboard to an unbounded workspace, but product renderers and export actions still need one canonical world-space frame contract.",
     desiredBehavior:
-      "Editable-output apps expose one runtime-owned Infinity canvas mode. Enabling it removes finite artboard clipping and size controls while preserving the dormant finite canvas size for exact restoration. When the standard Background pair exists, its selected color fills the complete infinite viewport and Background off atomically resolves finite mode and disables Infinity. Runtime image and model assets retain explicit world-space frames. ToolcraftAppComposition.sceneBoundsProvider supplies product-renderer bounds through one direct composition boundary; image export crops to the union of visible scene elements and video export uses one provider time-range envelope for all rendered frames. Hidden layers, suppressed default consumers, and editor-only UI do not expand output bounds. Finite mode continues to export the full finite canvas size, while empty, unavailable, and unsafe oversized infinite exports return typed visible failures.",
+      "Editable-output apps expose one runtime-owned Infinity canvas mode. Enabling it removes finite artboard clipping and size controls while preserving the dormant finite canvas size for exact restoration. When the standard Background pair exists, its selected color fills the complete infinite viewport and Background off atomically resolves finite mode and disables Infinity. Runtime image and model assets retain explicit world-space frames. ToolcraftAppComposition.sceneBoundsProvider supplies product-renderer bounds for one exact state through one direct composition boundary; image export resolves the current frame and video export unions every state from the runtime-owned timestamp schedule. Hidden layers, suppressed default consumers, and editor-only UI do not expand output bounds. Finite mode continues to export the full finite canvas size, while empty, unavailable, and unsafe oversized infinite exports return typed visible failures.",
     enforcement: [
       "acceptance-validator",
       "browser-helper",
@@ -217,7 +217,7 @@ export const TOOLCRAFT_DECISION_CONTRACT = [
     currentConstraint:
       "Product-output apps expose final output delivery through sticky footer panelActions.",
     desiredBehavior:
-      'Product apps include Export PNG plus an "Image Export" section for format and 2K/4K/8K resolution. Apps whose requested delivery includes animation also include Export Video plus "Video Export" settings; a playback or keyframe timeline may exist for interactive preview without inventing video delivery. Copy can be secondary, but it does not replace export. Product apps declare the standard background pair and runtime places it in Setup: Background beside Infinity canvas, Color below, and Timeline last. Standard helpers own runtime PNG transparency, live preview product-background visibility, infinite viewport color, the Background-to-Infinity finite fallback, and selected image dimensions or retina fallback, while video keeps the background.',
+      'Product apps include Export PNG plus an "Image Export" section for format and 2K/4K/8K resolution. Apps whose requested delivery includes animation also include Export Video plus "Video Export" settings; a playback or keyframe timeline may exist for interactive preview without inventing video delivery. Copy can be secondary, but it does not replace export. Product apps declare the standard background pair and runtime places it in Setup: Background beside Infinity canvas, Color below, and Timeline last. One shared product exportRenderer draws deterministic scene-coordinate frames; runtime owns settings, scene crop, PNG/JPEG/video background semantics, visible runtime media/model composition, exact timestamped encoding, download, progress, and typed failures.',
     enforcement: ["acceptance-validator", "performance-validator", "browser-helper", "starter-agents"],
     id: "output-export-required",
     level: "invariant",

package/templates/runtime/contracts/performance-verification-policy.test.ts

@@ -26,6 +26,8 @@ describe("Toolcraft canonical performance verification policy", () => {
     expect(TOOLCRAFT_PERFORMANCE_VERIFICATION_POLICY).toEqual({
       agentBrowser:
         "Agent-controlled browser checks are limited to diagnosis and targeted visual investigation; they do not mint durable performance baselines or receipts.",
+      complaintRouting:
+        "Performance authority and path localization are separate decisions. Classifier output establishes complaint authority only and never path localization. A localized complaint lets the agent select canonical affected paths and run one targeted iteration without asking the user. An ambiguous or unresolved localization requires one user-facing clarification naming visible operations and offering targeted diagnosis or a complete review; never ask the user for internal path ids. Regardless of whether the classifier returned high-confidence performance-iteration or needs-agent-judgment, unresolved localization creates neither performance-iteration intent nor canonical path authority. A broad or honestly unlocalizable problem may justify recommending the complete review immediately, but only the user's explicit request or acceptance authorizes it. A direct request for a complete review runs the full audit without another clarification.",
       deliveryBatch:
         "Classify and verify one coherent user-visible delivery batch instead of treating each internal implementation pass or steering correction as a separate aggregate verification boundary.",
       deliveryCommand:
@@ -37,13 +39,13 @@ describe("Toolcraft canonical performance verification policy", () => {
       fullAuditDiscovery:
         "The complete performance matrix remains outside conversational delivery. Complaints, repetition, tier, filename, and touched subsystem never launch it automatically. After two consecutive compatible protected performance iterations, the agent must offer a slower complete audit if the user remains unsatisfied; a demonstrably broad or unlocalizable cross-system problem may justify the same offer earlier. An explicit natural-language request for the complete audit, or explicit acceptance of the agent's offer, authorizes the agent acting as operator to run pnpm verify:perf; the user does not need to know the command name. After the audit, repair and rerun failed paths with focused checks, then run the complete matrix only once at the requested certification boundary.",
       performanceIterationDelivery:
-        "The runtime request classifier is a tri-state guard, not a replacement for AI semantic judgment: high-confidence runtime complaints, responsiveness optimization, or excessive CPU, GPU, memory, or resource use classify as performance-iteration; high-confidence product motion, speed, freeze, terminology, or locally negated complaint commands classify as ordinary-product-work; ambiguous or unrecognized wording classifies as needs-agent-judgment and the AI decides from the actual user request. Ordinary work is rejected only for a high-confidence performance iteration. Every performance-iteration worklog intent quotes a nontrivial exact raw substring of Request; whitespace and Unicode code units must match before normalized tri-state classification. Invented, whitespace-collapsed, NFKC-equivalent, or mismatched evidence is rejected; high-confidence ordinary evidence is rejected; exact high-confidence performance-iteration or needs-agent-judgment evidence is accepted under agent ownership. Each performance iteration requires an exact reachable development fixture and fails with a configuration error instead of falling back to maximum. One complaint maps to one exact authority-selected targeted performance iteration over canonical affected path IDs. Direct and repeated performance complaints each start one bounded targeted iteration over affected paths. Complaint wording and repetition never select the complete performance matrix, create or refresh a durable baseline, or grant full-performance certification authority.",
+        "The runtime request classifier is a tri-state guard, not a replacement for AI semantic judgment: high-confidence runtime complaints, responsiveness optimization, or excessive CPU, GPU, memory, or resource use classify as performance-iteration; high-confidence product motion, speed, freeze, terminology, or locally negated complaint commands classify as ordinary-product-work; ambiguous or unrecognized wording classifies as needs-agent-judgment and the AI decides from the actual user request. Ordinary work is rejected only for a high-confidence performance iteration. Every performance-iteration worklog intent quotes a nontrivial exact raw substring of Request; whitespace and Unicode code units must match before normalized tri-state classification. Invented, whitespace-collapsed, NFKC-equivalent, or mismatched evidence is rejected; high-confidence ordinary evidence is rejected; exact high-confidence performance-iteration evidence, or needs-agent-judgment evidence after semantic resolution, is accepted under agent ownership. Classifier output establishes complaint authority only and never path localization. Each performance iteration requires an exact reachable development fixture and fails with a configuration error instead of falling back to maximum. Only a localized complaint or a post-clarification targeted choice creates performance-iteration intent and one bounded iteration over exact canonical affected paths. Regardless of whether the classifier returned high-confidence performance-iteration or needs-agent-judgment, unresolved localization creates neither performance-iteration intent nor canonical path authority. Each repeated localized request may create one new bounded targeted iteration over its affected paths; repetition alone never expands scope or selects the complete performance matrix, creates or refreshes a durable baseline, or grants full-performance certification authority.",
       functionalInitialDelivery:
         'A functional delivery plan with basis "initial" runs complete functional proof and no measured performance. It preserves any independent full-performance baseline and cannot claim targeted or full performance evidence.',
       functionalTargetedDelivery:
         'A functional delivery plan with basis "changed" runs exact affected ownership-derived functional proof and no measured performance. Functional delivery cannot silently invoke targeted performance, the full performance matrix, or create or refresh a performance baseline.',
       renderScaleFidelity:
-        'canvas.renderScale is visible functional fidelity. Raster products declare typed renderScaleCoverage "selected-backing-pixels" for interaction and steady, plus playback when timeline is enabled, and prove real canvas backing pixels in every declared state. Never downsample, stretch a lower-resolution backing canvas, blur output, or clamp the selected render scale to pass a performance budget.',
+        'canvas.renderScale is visible functional fidelity. Raster products declare typed renderScaleCoverage "selected-backing-pixels" for interaction and steady, plus playback when timeline is enabled, and prove real canvas backing pixels in every declared state. Every measured path in a render-scale-enabled raster product proves actual CSS × devicePixelRatio × 2 backing after each measured phase. Never downsample, stretch a lower-resolution backing canvas, blur output, or clamp the selected render scale to pass a performance budget.',
     });
     expect(TOOLCRAFT_PERFORMANCE_VERIFICATION_LIFECYCLE).toEqual({
       delivery: {
@@ -87,7 +89,7 @@ describe("Toolcraft canonical performance verification policy", () => {
       /ambiguous or unrecognized wording classifies as needs-agent-judgment/i,
     );
     expect(TOOLCRAFT_PERFORMANCE_VERIFICATION_POLICY_TEXT).toMatch(
-      /high-confidence performance-iteration or needs-agent-judgment evidence is accepted under agent ownership/i,
+      /exact high-confidence performance-iteration evidence, or needs-agent-judgment evidence after semantic resolution, is accepted under agent ownership/i,
     );
     expect(TOOLCRAFT_PERFORMANCE_VERIFICATION_POLICY_TEXT).toMatch(
       /whitespace and Unicode code units must match/i,
@@ -96,13 +98,31 @@ describe("Toolcraft canonical performance verification policy", () => {
       /performance iteration requires an exact reachable development fixture/i,
     );
     expect(TOOLCRAFT_PERFORMANCE_VERIFICATION_POLICY_TEXT).toMatch(
-      /direct and repeated performance complaints each start one bounded targeted iteration/i,
+      /only a localized complaint or a post-clarification targeted choice creates performance-iteration intent and one bounded iteration over exact canonical affected paths/iu,
     );
     expect(TOOLCRAFT_PERFORMANCE_VERIFICATION_POLICY_TEXT).toMatch(
-      /one complaint maps to one exact authority-selected targeted performance iteration over canonical affected path IDs/i,
+      /regardless of whether the classifier returned high-confidence performance-iteration or needs-agent-judgment, unresolved localization creates neither performance-iteration intent nor canonical path authority/iu,
     );
     expect(TOOLCRAFT_PERFORMANCE_VERIFICATION_POLICY_TEXT).toMatch(
-      /complaint wording and repetition never select the complete performance matrix/i,
+      /each repeated localized request may create one new bounded targeted iteration/iu,
+    );
+    expect(TOOLCRAFT_PERFORMANCE_VERIFICATION_POLICY_TEXT).not.toMatch(
+      /one complaint maps to one exact authority-selected targeted performance iteration/iu,
+    );
+    expect(TOOLCRAFT_PERFORMANCE_VERIFICATION_POLICY_TEXT).not.toMatch(
+      /direct and repeated performance complaints each start one bounded targeted iteration/iu,
+    );
+    expect(TOOLCRAFT_PERFORMANCE_VERIFICATION_POLICY_TEXT).toMatch(
+      /localized complaint[\s\S]*without asking the user/iu,
+    );
+    expect(TOOLCRAFT_PERFORMANCE_VERIFICATION_POLICY_TEXT).toMatch(
+      /ambiguous or unresolved localization[\s\S]*one user-facing clarification[\s\S]*targeted diagnosis or a complete review/iu,
+    );
+    expect(TOOLCRAFT_PERFORMANCE_VERIFICATION_POLICY_TEXT).toMatch(
+      /direct request for a complete review[\s\S]*without another clarification/iu,
+    );
+    expect(TOOLCRAFT_PERFORMANCE_VERIFICATION_POLICY_TEXT).toMatch(
+      /repetition alone never expands scope or selects the complete performance matrix/i,
     );
     expect(TOOLCRAFT_PERFORMANCE_VERIFICATION_POLICY_TEXT).toMatch(
       /two consecutive compatible protected performance iterations[\s\S]*must offer/i,
@@ -122,8 +142,41 @@ describe("Toolcraft canonical performance verification policy", () => {
     expect(TOOLCRAFT_PERFORMANCE_VERIFICATION_POLICY_TEXT).toMatch(
       /typed renderScaleCoverage "selected-backing-pixels" for interaction and steady, plus playback when timeline is enabled/i,
     );
+    expect(TOOLCRAFT_PERFORMANCE_VERIFICATION_POLICY_TEXT).toMatch(
+      /every measured path[\s\S]*devicePixelRatio × 2[\s\S]*each measured phase/iu,
+    );
     expect(TOOLCRAFT_PERFORMANCE_VERIFICATION_POLICY_TEXT).toMatch(
       /never downsample[\s\S]*clamp the selected render scale to pass a performance budget/i,
     );
   });
+
+  it.each([
+    {
+      axis: "high-confidence but unlocalized complaint",
+      expected:
+        /classifier output establishes complaint authority only and never path localization[\s\S]*regardless of whether the classifier returned high-confidence performance-iteration[\s\S]*unresolved localization creates neither performance-iteration intent nor canonical path authority/iu,
+    },
+    {
+      axis: "localized complaint",
+      expected:
+        /localized complaint[\s\S]*one targeted iteration without asking the user/iu,
+    },
+    {
+      axis: "needs-agent-judgment with unresolved localization",
+      expected:
+        /regardless of whether the classifier returned[\s\S]*needs-agent-judgment[\s\S]*unresolved localization creates neither performance-iteration intent nor canonical path authority/iu,
+    },
+    {
+      axis: "post-clarification targeted choice",
+      expected:
+        /post-clarification targeted choice creates performance-iteration intent and one bounded iteration over exact canonical affected paths/iu,
+    },
+  ])("routes $axis without coupling authority to localization", ({ expected }) => {
+    const canonicalRoutingPolicy = [
+      TOOLCRAFT_PERFORMANCE_VERIFICATION_POLICY.complaintRouting,
+      TOOLCRAFT_PERFORMANCE_VERIFICATION_POLICY.performanceIterationDelivery,
+    ].join(" ");
+
+    expect(canonicalRoutingPolicy).toMatch(expected);
+  });
 });

package/templates/runtime/contracts/performance-verification-policy.ts

@@ -3,6 +3,8 @@ export * from "./performance-request-classifier";
 export const TOOLCRAFT_PERFORMANCE_VERIFICATION_POLICY = {
   agentBrowser:
     "Agent-controlled browser checks are limited to diagnosis and targeted visual investigation; they do not mint durable performance baselines or receipts.",
+  complaintRouting:
+    "Performance authority and path localization are separate decisions. Classifier output establishes complaint authority only and never path localization. A localized complaint lets the agent select canonical affected paths and run one targeted iteration without asking the user. An ambiguous or unresolved localization requires one user-facing clarification naming visible operations and offering targeted diagnosis or a complete review; never ask the user for internal path ids. Regardless of whether the classifier returned high-confidence performance-iteration or needs-agent-judgment, unresolved localization creates neither performance-iteration intent nor canonical path authority. A broad or honestly unlocalizable problem may justify recommending the complete review immediately, but only the user's explicit request or acceptance authorizes it. A direct request for a complete review runs the full audit without another clarification.",
   deliveryBatch:
     "Classify and verify one coherent user-visible delivery batch instead of treating each internal implementation pass or steering correction as a separate aggregate verification boundary.",
   deliveryCommand:
@@ -14,13 +16,13 @@ export const TOOLCRAFT_PERFORMANCE_VERIFICATION_POLICY = {
   fullAuditDiscovery:
     "The complete performance matrix remains outside conversational delivery. Complaints, repetition, tier, filename, and touched subsystem never launch it automatically. After two consecutive compatible protected performance iterations, the agent must offer a slower complete audit if the user remains unsatisfied; a demonstrably broad or unlocalizable cross-system problem may justify the same offer earlier. An explicit natural-language request for the complete audit, or explicit acceptance of the agent's offer, authorizes the agent acting as operator to run pnpm verify:perf; the user does not need to know the command name. After the audit, repair and rerun failed paths with focused checks, then run the complete matrix only once at the requested certification boundary.",
   performanceIterationDelivery:
-    "The runtime request classifier is a tri-state guard, not a replacement for AI semantic judgment: high-confidence runtime complaints, responsiveness optimization, or excessive CPU, GPU, memory, or resource use classify as performance-iteration; high-confidence product motion, speed, freeze, terminology, or locally negated complaint commands classify as ordinary-product-work; ambiguous or unrecognized wording classifies as needs-agent-judgment and the AI decides from the actual user request. Ordinary work is rejected only for a high-confidence performance iteration. Every performance-iteration worklog intent quotes a nontrivial exact raw substring of Request; whitespace and Unicode code units must match before normalized tri-state classification. Invented, whitespace-collapsed, NFKC-equivalent, or mismatched evidence is rejected; high-confidence ordinary evidence is rejected; exact high-confidence performance-iteration or needs-agent-judgment evidence is accepted under agent ownership. Each performance iteration requires an exact reachable development fixture and fails with a configuration error instead of falling back to maximum. One complaint maps to one exact authority-selected targeted performance iteration over canonical affected path IDs. Direct and repeated performance complaints each start one bounded targeted iteration over affected paths. Complaint wording and repetition never select the complete performance matrix, create or refresh a durable baseline, or grant full-performance certification authority.",
+    "The runtime request classifier is a tri-state guard, not a replacement for AI semantic judgment: high-confidence runtime complaints, responsiveness optimization, or excessive CPU, GPU, memory, or resource use classify as performance-iteration; high-confidence product motion, speed, freeze, terminology, or locally negated complaint commands classify as ordinary-product-work; ambiguous or unrecognized wording classifies as needs-agent-judgment and the AI decides from the actual user request. Ordinary work is rejected only for a high-confidence performance iteration. Every performance-iteration worklog intent quotes a nontrivial exact raw substring of Request; whitespace and Unicode code units must match before normalized tri-state classification. Invented, whitespace-collapsed, NFKC-equivalent, or mismatched evidence is rejected; high-confidence ordinary evidence is rejected; exact high-confidence performance-iteration evidence, or needs-agent-judgment evidence after semantic resolution, is accepted under agent ownership. Classifier output establishes complaint authority only and never path localization. Each performance iteration requires an exact reachable development fixture and fails with a configuration error instead of falling back to maximum. Only a localized complaint or a post-clarification targeted choice creates performance-iteration intent and one bounded iteration over exact canonical affected paths. Regardless of whether the classifier returned high-confidence performance-iteration or needs-agent-judgment, unresolved localization creates neither performance-iteration intent nor canonical path authority. Each repeated localized request may create one new bounded targeted iteration over its affected paths; repetition alone never expands scope or selects the complete performance matrix, creates or refreshes a durable baseline, or grants full-performance certification authority.",
   functionalInitialDelivery:
     'A functional delivery plan with basis "initial" runs complete functional proof and no measured performance. It preserves any independent full-performance baseline and cannot claim targeted or full performance evidence.',
   functionalTargetedDelivery:
     'A functional delivery plan with basis "changed" runs exact affected ownership-derived functional proof and no measured performance. Functional delivery cannot silently invoke targeted performance, the full performance matrix, or create or refresh a performance baseline.',
   renderScaleFidelity:
-    'canvas.renderScale is visible functional fidelity. Raster products declare typed renderScaleCoverage "selected-backing-pixels" for interaction and steady, plus playback when timeline is enabled, and prove real canvas backing pixels in every declared state. Never downsample, stretch a lower-resolution backing canvas, blur output, or clamp the selected render scale to pass a performance budget.',
+    'canvas.renderScale is visible functional fidelity. Raster products declare typed renderScaleCoverage "selected-backing-pixels" for interaction and steady, plus playback when timeline is enabled, and prove real canvas backing pixels in every declared state. Every measured path in a render-scale-enabled raster product proves actual CSS × devicePixelRatio × 2 backing after each measured phase. Never downsample, stretch a lower-resolution backing canvas, blur output, or clamp the selected render scale to pass a performance budget.',
 } as const;
 
 export const TOOLCRAFT_PERFORMANCE_VERIFICATION_LIFECYCLE = {
@@ -37,6 +39,7 @@ export const TOOLCRAFT_PERFORMANCE_VERIFICATION_LIFECYCLE = {
 
 export const TOOLCRAFT_PERFORMANCE_VERIFICATION_POLICY_TEXT = [
   TOOLCRAFT_PERFORMANCE_VERIFICATION_POLICY.agentBrowser,
+  TOOLCRAFT_PERFORMANCE_VERIFICATION_POLICY.complaintRouting,
   TOOLCRAFT_PERFORMANCE_VERIFICATION_POLICY.deliveryBatch,
   TOOLCRAFT_PERFORMANCE_VERIFICATION_POLICY.deliveryCommand,
   TOOLCRAFT_PERFORMANCE_VERIFICATION_POLICY.demandOnlyPerformance,