@pixel-point/toolcraft 0.0.17 → 0.0.19

package/src/generate-test-doc-assertions.test.mjs

@@ -5,11 +5,54 @@ import path from "node:path";
 import test from "node:test";
 
 import {
+  assertGeneratedExportIntentDocsDoNotInferVideo,
   collectGeneratedAgentFacingDocs,
   getMissingGeneratedPerformanceLifecycleMarkers,
   getStaleAgentPerformanceWorkflowFailures,
 } from "./generate-test-doc-assertions.mjs";
 
+test("rejects animation-derived video rules without rejecting explicit authority", () => {
+  for (const source of [
+    [
+      "Products whose requested delivery includes",
+      "animation also expose",
+      "`Export Video`.",
+    ].join(" "),
+    ["Animated apps automatically show", "Export Video."].join(" "),
+    ["Animation also", "requires", "Export Video."].join(" "),
+    "Timeline playback enables Export Video.",
+    "Animated apps automatically expose video export.",
+    "Timeline playback enables video export.",
+    "Animation implies video delivery.",
+  ]) {
+    assert.throws(
+      () =>
+        assertGeneratedExportIntentDocsDoNotInferVideo([
+          { docPath: "docs/toolcraft/stale.md", source },
+        ]),
+      /docs\/toolcraft\/stale\.md contains animation-derived video export guidance/,
+    );
+  }
+
+  assert.doesNotThrow(() =>
+    assertGeneratedExportIntentDocsDoNotInferVideo([
+      {
+        docPath: "docs/toolcraft/allowed.md",
+        source: [
+          "Do not infer video from animation, playback, keyframes, or timeline.",
+          "Animation, playback, keyframes, and timeline presence never add Export Video.",
+          "Animated apps do not automatically expose video export.",
+          "Timeline playback never enables video export.",
+          "Animation does not imply video delivery.",
+          "An animated app includes Export Video because the user explicitly requested video delivery.",
+          "An animated app exposes video export because the user explicitly requested video delivery.",
+          "Any app with Export Video must enable the top Toolcraft timeline.",
+        ].join("\n"),
+      },
+    ]),
+  );
+});
+
 test("scans every generated agent-facing Markdown source independently", async (t) => {
   const targetDir = await fs.mkdtemp(path.join(os.tmpdir(), "toolcraft-doc-scan-"));
   t.after(() => fs.rm(targetDir, { force: true, recursive: true }));
@@ -47,7 +90,7 @@ test("requires adaptive routing in every generated performance lifecycle documen
   const routingMarker =
     "<!-- toolcraft-performance-routing: localized=agent-targeted; ambiguous=one-user-facing-choice; broad=offer-targeted-or-full; full=explicit-only -->";
   const existingMarkers = [
-    "<!-- toolcraft-performance-lifecycle: first-delivery=functional; later-delivery=functional-targeted; complaint=one-authority-targeted-performance-iteration; full-audit=explicit-only -->",
+    "<!-- toolcraft-performance-lifecycle: first-delivery=functional-complete; later-edits=focused-only; complaint=one-authority-targeted-performance-iteration; full-audit=explicit-only -->",
     "<!-- toolcraft-performance-iteration: authority=exact-request-evidence+canonical-path-ids; fixture=reachable-development; after-pass=return-app-to-user+stop -->",
     "<!-- toolcraft-performance-full-authority: automatic=forbidden; recommendation=two-compatible-iterations-or-broad-unlocalizable-problem; command=pnpm verify:perf; authority=explicit-user-request-or-accepted-offer -->",
   ].join("\n");

package/src/generate-test-doc-policy-assertions.mjs

@@ -0,0 +1,92 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import path from "node:path";
+
+const staleAgentPerformanceWorkflowPattern =
+  /app-performance-impact|explicit-performance-work|test:browser:perf|verify:(?:final|quick|ui)|verify:perf:(?:playwright|record-iteration|refresh)|--reason=performance-iteration|--performance-test/iu;
+
+const exportIntentSentencePatternSource = String.raw`[^\n.!?]`;
+const videoArtifactTargetPatternSource = String.raw`(?:Export Video|video\s+(?:export|delivery))`;
+const explicitVideoAuthorityPatternSource = String.raw`(?:explicit(?:ly)?\s+(?:(?:user[- ]?)?request(?:ed|s)?\s+)?${videoArtifactTargetPatternSource}|user\s+explicitly\s+request(?:ed|s)?\s+${videoArtifactTargetPatternSource}|user[- ]request(?:ed|s)?\s+${videoArtifactTargetPatternSource})`;
+const animationInferenceVerbPatternSource = String.raw`(?:exposes?|includes?|shows?|adds?|enables?|implies?|has|needs?|requires?|produces?|proves?)`;
+const staleAnimationInferencePatternSource = [
+  String.raw`products?\s+whose\s+requested\s+delivery\s+includes\s+animation`,
+  String.raw`animated\s+apps?\b(?!${exportIntentSentencePatternSource}{0,100}\b(?:do(?:es)?\s+not|never)\b)${exportIntentSentencePatternSource}{0,100}\b${animationInferenceVerbPatternSource}\b${exportIntentSentencePatternSource}{0,60}\b${videoArtifactTargetPatternSource}\b`,
+  String.raw`(?:animation|playback|keyframes?|timeline(?:\s+playback)?)\b\s+(?:also\s+)?${animationInferenceVerbPatternSource}\b${exportIntentSentencePatternSource}{0,60}\b${videoArtifactTargetPatternSource}\b`,
+].join("|");
+
+export const staleAnimationDerivedVideoPattern = new RegExp(
+  String.raw`(?:^|[\n.!?]\s*)(?!${exportIntentSentencePatternSource}{0,240}\b${explicitVideoAuthorityPatternSource}\b)${exportIntentSentencePatternSource}{0,240}(?:${staleAnimationInferencePatternSource})`,
+  "iu",
+);
+
+const generatedPerformanceLifecycleMarkers = [
+  "<!-- toolcraft-performance-lifecycle: first-delivery=functional-complete; later-edits=focused-only; complaint=one-authority-targeted-performance-iteration; full-audit=explicit-only -->",
+  "<!-- toolcraft-performance-iteration: authority=exact-request-evidence+canonical-path-ids; fixture=reachable-development; after-pass=return-app-to-user+stop -->",
+  "<!-- toolcraft-performance-full-authority: automatic=forbidden; recommendation=two-compatible-iterations-or-broad-unlocalizable-problem; command=pnpm verify:perf; authority=explicit-user-request-or-accepted-offer -->",
+  "<!-- toolcraft-performance-routing: localized=agent-targeted; ambiguous=one-user-facing-choice; broad=offer-targeted-or-full; full=explicit-only -->",
+];
+
+export function getMissingGeneratedPerformanceLifecycleMarkers(sources) {
+  return sources.flatMap(({ docPath, source }) =>
+    generatedPerformanceLifecycleMarkers.flatMap((marker) =>
+      source.includes(marker)
+        ? []
+        : [`docs/toolcraft/${docPath} must include canonical marker: ${marker}`],
+    ),
+  );
+}
+
+async function collectMarkdownPaths(rootDir, relativeDir = "") {
+  const currentDir = path.join(rootDir, relativeDir);
+  const entries = await fs.readdir(currentDir, { withFileTypes: true });
+  const markdownPaths = [];
+
+  for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+    const relativePath = path.join(relativeDir, entry.name);
+    if (entry.isDirectory()) {
+      markdownPaths.push(...(await collectMarkdownPaths(rootDir, relativePath)));
+    } else if (entry.isFile() && entry.name.endsWith(".md")) {
+      markdownPaths.push(relativePath);
+    }
+  }
+
+  return markdownPaths;
+}
+
+export async function collectGeneratedAgentFacingDocs(targetDir) {
+  const docsRoot = path.join(targetDir, "docs/toolcraft");
+  const docPaths = await collectMarkdownPaths(docsRoot);
+  const docs = await Promise.all(
+    docPaths.map(async (docPath) => ({
+      docPath: path.posix.join("docs/toolcraft", docPath.split(path.sep).join("/")),
+      source: await fs.readFile(path.join(docsRoot, docPath), "utf8"),
+    })),
+  );
+
+  return [
+    {
+      docPath: "AGENTS.md",
+      source: await fs.readFile(path.join(targetDir, "AGENTS.md"), "utf8"),
+    },
+    ...docs,
+  ];
+}
+
+export function getStaleAgentPerformanceWorkflowFailures(sources) {
+  return sources.flatMap(({ docPath, source }) =>
+    staleAgentPerformanceWorkflowPattern.test(source)
+      ? [`${docPath} contains removed performance workflow guidance`]
+      : [],
+  );
+}
+
+export function assertGeneratedExportIntentDocsDoNotInferVideo(sources) {
+  for (const { docPath, source } of sources) {
+    assert.doesNotMatch(
+      source,
+      staleAnimationDerivedVideoPattern,
+      `${docPath} contains animation-derived video export guidance`,
+    );
+  }
+}

package/src/generate-test-export-doc-assertions.mjs

@@ -0,0 +1,53 @@
+import assert from "node:assert/strict";
+
+export function assertGeneratedExportDocs({
+  agentsSource,
+  coreRuntimeBoundarySource,
+  coreSetupExportSource,
+}) {
+  assert.match(agentsSource, /svgExportRenderer/);
+  assert.match(coreRuntimeBoundarySource, /svgExportRenderer/);
+  assert.match(
+    coreRuntimeBoundarySource,
+    /runtime owns typed image\/SVG\/video actions end to end/i,
+  );
+  assert.match(coreSetupExportSource, /productReadiness\.exportIntent/);
+  assert.match(
+    coreSetupExportSource,
+    /image[^\n]*`toolcraft-default`[^\n]*`user-requested`[^\n]*`user-removed`/i,
+  );
+  assert.match(coreSetupExportSource, /video[^\n]*`not-requested`[^\n]*`user-requested`/i);
+  assert.match(coreSetupExportSource, /SVG[^\n]*`not-requested`[^\n]*`user-requested`/i);
+  assert.match(
+    coreSetupExportSource,
+    /image[^\n]*`user-requested`[^\n]*non-empty[^\n]*evidence/i,
+  );
+  assert.match(
+    coreSetupExportSource,
+    /image[^\n]*`user-removed`[^\n]*non-empty[^\n]*evidence/i,
+  );
+  assert.match(
+    coreSetupExportSource,
+    /video[^\n]*`user-requested`[^\n]*non-empty[^\n]*evidence/i,
+  );
+
+  for (const decisionStep of [
+    "Start every product with image export.",
+    "Add SVG export only when the user explicitly requests SVG delivery.",
+    "Add video export only when the user explicitly requests video delivery.",
+    "Do not infer SVG from an SVG preview renderer, or video from animation, playback, keyframes, or timeline.",
+    "Keep image with requested SVG/video unless the user explicitly requests image removal.",
+    "Record all three decisions in `productReadiness.exportIntent`.",
+  ]) {
+    assert.equal(
+      coreSetupExportSource.split(decisionStep).length - 1,
+      1,
+      `Canonical export-intent step must appear exactly once: ${decisionStep}`,
+    );
+  }
+
+  assert.match(
+    coreSetupExportSource,
+    /Clipboard copy may be an additional product action, but it never changes or substitutes for the recorded artifact intent/,
+  );
+}

package/src/generate-test-file-assertions.mjs

@@ -6,9 +6,10 @@ import {
   assertGeneratedDeliveryArchitecture,
   deliveryArchitecturePaths,
 } from "./generate-test-delivery-architecture-assertions.mjs";
+import { collectFrameworkOwnedGeneratedFiles } from "./generated-integrity-manifest.mjs";
 import { listRelativeFiles, repoRoot } from "./generate-test-fs-utils.mjs";
 import { assertGeneratedPerformanceCanvasBoundary } from "./generate-test-performance-boundary-assertions.mjs";
-import { isGeneratedTestSupportPath } from "./generated-source-policy.mjs";
+import { assertGeneratedRuntimePublicBoundary } from "./generate-test-runtime-boundary-assertions.mjs";
 
 export {
   assertGeneratedRoutesAndStyles,
@@ -44,16 +45,7 @@ export async function assertGeneratedFiles(targetDir) {
     "scripts/toolcraft-targeted-verification-selection.mjs",
   ];
 
-  assert.ok(await fs.stat(path.join(targetDir, "src/toolcraft/ui/index.ts")));
-  assert.ok(await fs.stat(path.join(targetDir, "src/toolcraft/runtime/react/index.ts")));
-  assert.ok(
-    await fs.stat(
-      path.join(
-        targetDir,
-        "src/toolcraft/runtime/model-import/worker/model-import.worker.bundle.js",
-      ),
-    ),
-  );
+  await assertGeneratedRuntimePublicBoundary(targetDir);
   assert.ok(await fs.stat(path.join(targetDir, "playwright.config.ts")));
   await assert.rejects(
     fs.stat(path.join(targetDir, ".toolcraft")),
@@ -61,70 +53,6 @@ export async function assertGeneratedFiles(targetDir) {
     "Fresh generated apps must not inherit starter server ports or verification receipts.",
   );
 
-  const generatedToolcraftFiles = await listRelativeFiles(
-    path.join(targetDir, "src/toolcraft"),
-  );
-  const expectedRuntimeFiles = (await listRelativeFiles(
-    path.join(repoRoot, "packages/toolcraft-runtime/src"),
-  ))
-    .filter((relativePath) => !isGeneratedTestSupportPath(relativePath))
-    .map((relativePath) => `runtime/${relativePath}`);
-  assert.deepEqual(
-    generatedToolcraftFiles.filter((relativePath) => relativePath.startsWith("runtime/")),
-    expectedRuntimeFiles,
-    "Generated standalone runtime must contain every production runtime module.",
-  );
-  for (const relativePath of [
-    "runtime/export/artifact-export-settings.ts",
-    "runtime/export/artifact-export-request.ts",
-    "runtime/export/artifact-frame-renderer.ts",
-    "runtime/export/artifact-frame-state.ts",
-    "runtime/export/artifact-scene-frame.ts",
-    "runtime/export/image-artifact-export.ts",
-    "runtime/export/product-export-renderer.ts",
-    "runtime/export/video-artifact-export.ts",
-    "runtime/export/video-encoding-backend.ts",
-    "runtime/export/video-frame-schedule.ts",
-  ]) {
-    assert.ok(
-      generatedToolcraftFiles.includes(relativePath),
-      `Generated runtime must contain ${relativePath}.`,
-    );
-  }
-  assert.equal(
-    generatedToolcraftFiles.includes("runtime/export/export.ts"),
-    false,
-    "Generated runtime must not copy the removed legacy export helper.",
-  );
-  for (const relativePath of [
-    "e2e/browser-media-export-evidence.ts",
-    "e2e/decoded-pixel-observation.ts",
-    "e2e/image-artifact-inspection.ts",
-    "e2e/video-artifact-inspection.ts",
-  ]) {
-    assert.ok(
-      await fs.stat(path.join(targetDir, relativePath)),
-      `Generated output must contain ${relativePath}.`,
-    );
-  }
-  for (const relativePath of generatedToolcraftFiles) {
-    assert.equal(
-      isGeneratedTestSupportPath(relativePath),
-      false,
-      `Generated runtime contains test support: ${relativePath}`,
-    );
-  }
-
-  const removedRuntimeTestHelpers = [
-    "runtime/react/canvas/canvas-shell-test-utils.tsx",
-    "runtime/react/controls-panel/testing/controls-panel-test-utils.tsx",
-    "runtime/react/layers/layers-panel-test-utils.tsx",
-    "runtime/react/timeline/timeline-panel-test-utils.tsx",
-  ];
-  for (const relativePath of removedRuntimeTestHelpers) {
-    assert.equal(generatedToolcraftFiles.includes(relativePath), false);
-  }
-
   const playwrightConfigSource = await fs.readFile(
     path.join(targetDir, "playwright.config.ts"),
     "utf8",
@@ -144,15 +72,60 @@ export async function assertGeneratedFiles(targetDir) {
   assert.ok(await fs.stat(path.join(targetDir, "src/app/app-acceptance-data.ts")));
   assert.ok(await fs.stat(path.join(targetDir, "src/app/app-composition.tsx")));
   assert.ok(await fs.stat(path.join(targetDir, "src/app/app-acceptance.base-coverage.test.ts")));
+  assert.ok(
+    await fs.stat(
+      path.join(
+        targetDir,
+        "src/app/acceptance/control-section-entity-cohesion.ts",
+      ),
+    ),
+  );
+  const generatedApplicabilityValidatorSource = await fs.readFile(
+    path.join(targetDir, "src/app/acceptance/control-applicability.ts"),
+    "utf8",
+  );
+  assert.match(
+    generatedApplicabilityValidatorSource,
+    /getToolcraftControlApplicabilityErrors/,
+  );
+  for (const relativePath of [
+    "src/app/acceptance/selection-scope.ts",
+    "e2e/app-browser-selection-scope-evidence.spec.ts",
+    "e2e/browser-product-raster-snapshot.ts",
+    "e2e/browser-proof-session.ts",
+    "e2e/browser-proof-surface-action.ts",
+    "e2e/browser-proof-types.ts",
+    "e2e/browser-selection-scope-evidence.ts",
+  ]) {
+    assert.ok(
+      await fs.stat(path.join(targetDir, relativePath)),
+      `Generated output must contain ${relativePath}.`,
+    );
+  }
+  const generatedSelectionValidatorSource = await fs.readFile(
+    path.join(targetDir, "src/app/acceptance/selection-scope.ts"),
+    "utf8",
+  );
+  assert.match(generatedSelectionValidatorSource, /two-entity-isolation/);
+  const generatedRuntimeEvidenceSource = await fs.readFile(
+    path.join(targetDir, "e2e/browser-runtime-evidence-requirements.ts"),
+    "utf8",
+  );
+  assert.match(generatedRuntimeEvidenceSource, /selection-scoped-control/);
   const appAcceptanceSource = await fs.readFile(
     path.join(targetDir, "src/app/app-acceptance.ts"),
     "utf8",
   );
   assert.match(appAcceptanceSource, /from "\.\/app-acceptance-data"/);
-  assert.ok(await fs.stat(path.join(targetDir, "src/app/app-performance.ts")));
-  assert.ok(
-    await fs.stat(path.join(targetDir, "src/app/app-verification-impact.json")),
+  const generatedValidationPipeline = await fs.readFile(
+    path.join(targetDir, "src/app/acceptance/validate-coverage.ts"),
+    "utf8",
+  );
+  assert.match(
+    generatedValidationPipeline,
+    /validate:\s*\(\{ sectionInventory \}\)\s*=>\s*getToolcraftControlSectionEntityCohesionErrors\(sectionInventory\)/,
   );
+  assert.ok(await fs.stat(path.join(targetDir, "src/app/app-performance.ts")));
   assert.ok(await fs.stat(path.join(targetDir, "src/app/app-performance.gates.test.ts")));
   assert.equal(
     generatedAppSourceFiles.some((file) => path.basename(file).startsWith("starter-")),
@@ -166,6 +139,10 @@ export async function assertGeneratedFiles(targetDir) {
   );
   assert.ok(await fs.stat(path.join(targetDir, "e2e/performance-helpers.ts")));
   for (const relativePath of [
+    "e2e/toolcraft-feature-verification-reporter.ts",
+    "scripts/run-feature-verification.mjs",
+    "scripts/toolcraft-feature-verification-plan.mjs",
+    "src/app/acceptance/feature-verification-selection.ts",
     "e2e/browser-execution-ledger.ts",
     "e2e/browser-performance-measurement-evidence.ts",
     "e2e/browser-performance-measurement-report.ts",
@@ -178,7 +155,6 @@ export async function assertGeneratedFiles(targetDir) {
     "e2e/toolcraft-delivery-catalog-reporter.ts",
     "scripts/toolcraft-performance-report.mjs",
     "scripts/toolcraft-kernel-benchmark-receipt.mjs",
-    "scripts/toolcraft-verification-impact.mjs",
     "scripts/toolcraft-targeted-performance-report.mjs",
     "scripts/run-kernel-benchmarks.mjs",
     "src/app/test-evidence/browser-performance-measurement-contract.ts",
@@ -274,11 +250,19 @@ export async function assertGeneratedFiles(targetDir) {
   assert.ok(await fs.stat(manifestPath));
 
   const manifest = JSON.parse(await fs.readFile(manifestPath, "utf8"));
+  const expectedFrameworkInventory = await collectFrameworkOwnedGeneratedFiles(
+    path.join(repoRoot, "starter"),
+  );
   const generatedPackageJson = JSON.parse(
     await fs.readFile(path.join(targetDir, "package.json"), "utf8"),
   );
   assert.equal(manifest.version, 3);
   assert.match(manifest.signature, /^[A-Za-z0-9+/]+={0,2}$/);
+  assert.deepEqual(
+    Object.keys(manifest.protectedFiles).sort(),
+    expectedFrameworkInventory,
+    "Generated protected files must equal the canonical starter framework inventory.",
+  );
   assert.deepEqual(
     manifest.packageScripts,
     Object.fromEntries(Object.entries(generatedPackageJson.scripts).sort()),
@@ -291,10 +275,18 @@ export async function assertGeneratedFiles(targetDir) {
     manifest.packageScripts["verify:delivery"],
     "node scripts/run-delivery-verification.mjs",
   );
+  assert.equal(
+    manifest.packageScripts["test:feature"],
+    "node scripts/run-feature-verification.mjs",
+  );
   assert.equal(
     manifest.packageScripts["verify:perf"],
     "node scripts/run-browser-performance.mjs",
   );
+  assert.equal(
+    manifest.packageScripts["reference:study"],
+    "node scripts/create-toolcraft-motion-reference-study.mjs",
+  );
   assert.notEqual(
     manifest.packageScripts["verify:delivery"],
     manifest.packageScripts["verify:perf"],
@@ -359,6 +351,12 @@ export async function assertGeneratedFiles(targetDir) {
   assert.ok(
     manifest.protectedFiles["e2e/toolcraft-delivery-catalog-reporter.ts"],
   );
+  assertSignedProtectedFiles(manifest, [
+    "e2e/toolcraft-feature-verification-reporter.ts",
+    "scripts/run-feature-verification.mjs",
+    "scripts/toolcraft-feature-verification-plan.mjs",
+    "src/app/acceptance/feature-verification-selection.ts",
+  ], "focused feature verification infrastructure");
   assert.ok(manifest.protectedFiles["e2e/browser-runtime-evidence.ts"]);
   assert.ok(manifest.protectedFiles["e2e/app-performance.spec.ts"]);
   assertSignedProtectedFiles(manifest, [
@@ -449,8 +447,4 @@ export async function assertGeneratedFiles(targetDir) {
     manifest.protectedFiles["e2e/app-kernel-benchmarks.ts"],
     undefined,
   );
-  assert.equal(
-    manifest.protectedFiles["src/app/app-verification-impact.json"],
-    undefined,
-  );
 }

package/src/generate-test-integrity-assertions.mjs

@@ -51,10 +51,13 @@ export async function assertGeneratedAppPerformance(targetDir) {
   );
   assert.match(
     verificationPolicySource,
-    /modes:\s*\[\s*"functional",\s*"performance-iteration"\s*\]/,
+    /modes:\s*\[\s*"initial-functional",\s*"performance-iteration"\s*\]/,
   );
   assert.match(verificationPolicySource, /command:\s*"verify:delivery"/);
-  assert.match(verificationPolicySource, /selectors:\s*"automatic"/);
+  assert.match(
+    verificationPolicySource,
+    /selectors:\s*"initial-complete-or-authority-exact"/,
+  );
   assert.match(verificationPolicySource, /fullPerformance:\s*\{/);
   assert.match(
     verificationPolicySource,

package/src/generate-test-integrity-manifest-assertions.mjs

@@ -59,9 +59,17 @@ export async function assertGeneratedManifestIntegrity(context) {
     "e2e/app-browser-render-scale-evidence.spec.ts",
     "e2e/app-browser-render-scale-requirements.spec.ts",
     "e2e/browser-execution-ledger.ts",
+    "e2e/app-browser-selection-scope-evidence.spec.ts",
+    "e2e/browser-proof-session.ts",
+    "e2e/browser-proof-surface-action.ts",
+    "e2e/browser-proof-types.ts",
     "e2e/browser-render-scale-evidence.ts",
+    "e2e/browser-product-raster-snapshot.ts",
+    "e2e/browser-selection-scope-evidence.ts",
     "e2e/toolcraft-delivery-catalog-reporter.ts",
+    "e2e/toolcraft-feature-verification-reporter.ts",
     "src/app/acceptance/types.ts",
+    "src/app/acceptance/selection-scope.ts",
     "src/app/app-acceptance.render-scale.test.ts",
     "scripts/toolcraft-delivery-anchor.mjs",
     "scripts/toolcraft-delivery-executor.mjs",
@@ -74,11 +82,9 @@ export async function assertGeneratedManifestIntegrity(context) {
     "scripts/toolcraft-functional-proof-primitives.d.mts",
     "scripts/toolcraft-functional-proof-primitives.mjs",
     "scripts/toolcraft-proof-process.mjs",
-    "scripts/toolcraft-verification-impact-inventory.d.mts",
-    "scripts/toolcraft-verification-impact-inventory.mjs",
-    "scripts/toolcraft-verification-impact.mjs",
-    "scripts/toolcraft-verification-input-roles.d.mts",
-    "scripts/toolcraft-verification-input-roles.mjs",
+    "scripts/run-feature-verification.mjs",
+    "scripts/toolcraft-feature-verification-plan.mjs",
+    "src/app/acceptance/feature-verification-selection.ts",
   ]) {
     assert.ok(
       manifest.protectedFiles[relativePath],
@@ -94,6 +100,11 @@ export async function assertGeneratedManifestIntegrity(context) {
     manifest.packageScripts.test,
     "Generated integrity manifest must protect the generated test command.",
   );
+  assert.equal(
+    manifest.packageScripts["test:feature"],
+    "node scripts/run-feature-verification.mjs",
+    "Generated integrity manifest must protect the focused product feature command.",
+  );
   assert.equal(
     manifest.packageScripts["verify:delivery"],
     "node scripts/run-delivery-verification.mjs",

package/src/generate-test-integrity-ownership-assertions.mjs

@@ -33,6 +33,42 @@ export async function assertGeneratedOwnershipBoundaries(context) {
       await assertIntegrityFailure(/modified package script test/);
     },
   );
+
+  for (const relativePath of [
+    "scripts/create-toolcraft-motion-reference-study.mjs",
+    "src/app/acceptance/motion-reference-evidence.mjs",
+    "scripts/toolcraft-motion-reference-group-inventory.mjs",
+    "scripts/toolcraft-motion-reference-publication-journal.mjs",
+  ]) {
+    const filePath = path.join(targetDir, relativePath);
+    const source = await fs.readFile(filePath, "utf8");
+    await withTemporaryFileSource(
+      filePath,
+      `${source}\n// integrity mutation proof\n`,
+      async () => {
+        await assertIntegrityFailure(
+          new RegExp(`modified ${relativePath.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")}`),
+        );
+      },
+    );
+  }
+  await withTemporaryFileSource(
+    packageJsonPath,
+    `${JSON.stringify(
+      {
+        ...packageJson,
+        scripts: {
+          ...packageJson.scripts,
+          "reference:study": "echo skipped",
+        },
+      },
+      null,
+      2,
+    )}\n`,
+    async () => {
+      await assertIntegrityFailure(/modified package script reference:study/);
+    },
+  );
   await withTemporaryFileSource(
     packageJsonPath,
     `${JSON.stringify(
@@ -108,10 +144,6 @@ export async function assertGeneratedOwnershipBoundaries(context) {
       relativePath: "src/app/app-performance.ts",
       suffix: "\n// product performance evidence stays editable\n",
     },
-    {
-      relativePath: "src/app/app-verification-impact.json",
-      transform: (source) => source.replace(/\n\}$/u, ',\n  "note": "product ownership stays editable"\n}\n'),
-    },
     {
       relativePath: "e2e/app-controls.spec.ts",
       suffix: "\n// product browser scenarios stay editable\n",

package/src/generate-test-package-assertions.mjs

@@ -54,6 +54,10 @@ export async function assertGeneratedPackageJson(targetDir) {
     'playwright install chromium && playwright test --grep-invert "browser perf:|toolcraft kernel:"',
   );
   assert.equal(packageJson.scripts["test:browser:perf"], undefined);
+  assert.equal(
+    packageJson.scripts["test:feature"],
+    "node scripts/run-feature-verification.mjs",
+  );
   assert.equal(packageJson.scripts["verify:quick"], undefined);
   assert.equal(
     packageJson.scripts["verify:delivery"],

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

@@ -15,7 +15,6 @@ const generatedProductFixtureDir = path.resolve(
 
 export const generatedProductAuthorityFixturePaths = Object.freeze([
   "docs/toolcraft/agent-worklog.md",
-  "src/app/app-verification-impact.json",
 ]);
 
 export const generatedProductPresentationResourcePath =
@@ -54,6 +53,7 @@ export const generatedProductFixturePaths = Object.freeze([
   "src/app/material-output.tsx",
   "src/app/material-schema.ts",
   generatedProductPerformanceOwnerPath,
+  "src/app/svg-export-renderer.test.ts",
 ]);
 
 function compareCodeUnits(left, right) {