@pixel-point/toolcraft 0.0.18 → 0.0.19

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

@@ -6,6 +6,7 @@ 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 { assertGeneratedRuntimePublicBoundary } from "./generate-test-runtime-boundary-assertions.mjs";
@@ -87,6 +88,30 @@ export async function assertGeneratedFiles(targetDir) {
     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",
@@ -101,9 +126,6 @@ export async function assertGeneratedFiles(targetDir) {
     /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-verification-impact.json")),
-  );
   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-")),
@@ -117,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",
@@ -129,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",
@@ -225,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()),
@@ -242,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"],
@@ -310,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, [
@@ -400,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) {

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

@@ -20,10 +20,44 @@ const generatedProductFixtureRoot = new URL(
   import.meta.url,
 );
 
+const starterPackageJsonUrl = new URL("../../starter/package.json", import.meta.url);
+
+it("keeps generated product fixtures reference-free and motion preprocessing demand-only", async () => {
+  const fixtureSources = await Promise.all([
+    generatedProductFixtureRoot,
+    new URL("../fixtures/generated-product-material-iteration/", import.meta.url),
+  ].map((root) => fs.readFile(
+    new URL("src/app/app-acceptance-data.ts", root),
+    "utf8",
+  )));
+  const packageJson = JSON.parse(await fs.readFile(starterPackageJsonUrl, "utf8"));
+
+  for (const fixtureSource of fixtureSources) {
+    assert.match(fixtureSource, /mode:\s*"new-toolcraft-app",\s*referenceInputs:\s*\[\],/u);
+  }
+  assert.equal(
+    packageJson.scripts["reference:study"],
+    "node scripts/create-toolcraft-motion-reference-study.mjs",
+  );
+  for (const scriptName of [
+    "build",
+    "docs:check",
+    "test",
+    "test:generated",
+    "typecheck",
+    "verify:delivery",
+  ]) {
+    assert.doesNotMatch(
+      packageJson.scripts[scriptName],
+      /reference:study|create-toolcraft-motion-reference-study/u,
+      `${scriptName} must not invoke motion-reference preprocessing implicitly.`,
+    );
+  }
+});
+
 it("rejects unknown and missing product fixture paths", () => {
   assert.deepEqual(generatedProductAuthorityFixturePaths, [
     "docs/toolcraft/agent-worklog.md",
-    "src/app/app-verification-impact.json",
   ]);
   assert.equal(
     generatedProductPresentationResourcePath,
@@ -254,12 +288,6 @@ it("applies only product-owned fixture files and preserves generated infrastruct
       path.join(targetDir, generatedProductPerformanceOwnerPath),
       "utf8",
     );
-    const verificationImpact = JSON.parse(
-      await fs.readFile(
-        path.join(targetDir, "src/app/app-verification-impact.json"),
-        "utf8",
-      ),
-    );
     const worklog = await fs.readFile(
       path.join(targetDir, "docs/toolcraft/agent-worklog.md"),
       "utf8",
@@ -271,37 +299,6 @@ it("applies only product-owned fixture files and preserves generated infrastruct
       /export const productPulseResourcePath = "\/product-pulse\.svg";/u,
     );
     assert.match(productOutput, /src=\{productPulseResourcePath\}/u);
-    assert.deepEqual(
-      verificationImpact.owners.find(
-        ({ path: ownerPath }) =>
-          ownerPath === generatedProductPresentationResourcePath,
-      ),
-      {
-        acceptanceIds: ["animation.speed"],
-        kind: "presentation",
-        path: generatedProductPresentationResourcePath,
-      },
-    );
-    assert.equal(verificationImpact.version, 3);
-    assert.equal(
-      verificationImpact.owners.some(
-        ({ path: ownerPath }) =>
-          ownerPath === "src/app/app-export-performance-workload.ts",
-      ),
-      false,
-    );
-    assert.deepEqual(
-      verificationImpact.owners.map(({ path: ownerPath }) => ownerPath),
-      [
-        "public/product-pulse.svg",
-        "src/app/app-composition.tsx",
-        "src/app/app-renderer-pipeline.ts",
-        "src/app/app-schema.ts",
-        "src/app/material-output.tsx",
-        "src/app/material-schema.ts",
-        "src/app/product-output.tsx",
-      ],
-    );
     const verificationLines = worklog.match(/^- Verification:.*$/gmu) ?? [];
     assert.ok(verificationLines.length > 0);
     assert.ok(

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

@@ -20,7 +20,6 @@ export const generatedProductMaterialIterationFixturePaths = Object.freeze([
   "public/material-frosting.svg",
   "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",

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

@@ -22,7 +22,6 @@ const expectedPaths = [
   "public/material-frosting.svg",
   "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",

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

@@ -50,6 +50,19 @@ const productSafeRuntimeExportIndex = [
   '  ToolcraftProductExportFrameRenderer,',
   '  ToolcraftProductExportRenderer,',
   '} from "./product-export-renderer";',
+  'export type {',
+  '  ToolcraftProductSvgExportFrameContext,',
+  '  ToolcraftProductSvgExportFrameRenderer,',
+  '  ToolcraftProductSvgExportRenderer,',
+  '} from "./product-svg-export-renderer";',
+  'export {',
+  '  TOOLCRAFT_FORBIDDEN_SVG_ELEMENTS,',
+  '  TOOLCRAFT_SVG_BACKGROUND_ATTRIBUTE,',
+  '  TOOLCRAFT_SVG_NAMESPACE,',
+  '  TOOLCRAFT_SVG_NON_RENDERING_CONTAINERS,',
+  '  TOOLCRAFT_SVG_PRODUCT_SCENE_ATTRIBUTE,',
+  '  TOOLCRAFT_SVG_VECTOR_PRIMITIVES,',
+  '} from "./svg-policy";',
   '',
 ].join("\n");
 
@@ -61,15 +74,22 @@ const requiredRuntimeExportImplementationPaths = [
   "runtime/export/artifact-scene-frame.ts",
   "runtime/export/image-artifact-export.ts",
   "runtime/export/product-export-renderer.ts",
+  "runtime/export/product-svg-export-renderer.ts",
+  "runtime/export/svg-artifact-export.ts",
+  "runtime/export/svg-document.ts",
+  "runtime/export/svg-policy.ts",
   "runtime/export/video-artifact-export.ts",
   "runtime/export/video-encoding-backend.ts",
   "runtime/export/video-frame-schedule.ts",
 ];
 
 const generatedMediaExportEvidencePaths = [
+  "e2e/browser-infinity-canvas-svg-evidence.ts",
   "e2e/browser-media-export-evidence.ts",
   "e2e/decoded-pixel-observation.ts",
   "e2e/image-artifact-inspection.ts",
+  "e2e/browser-svg-export-evidence.ts",
+  "e2e/svg-artifact-inspection.ts",
   "e2e/video-artifact-inspection.ts",
 ];
 

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

@@ -97,22 +97,6 @@ export async function assertGeneratedProductStandalone({ execFileAsync, targetDi
   );
   assert.doesNotMatch(appSchemaSource, /visibleWhen\s*:/u);
 
-  const verificationImpact = JSON.parse(
-    await fs.readFile(
-      path.join(targetDir, "src/app/app-verification-impact.json"),
-      "utf8",
-    ),
-  );
-  assert.equal(verificationImpact.version, 3);
-  assert.ok(
-    verificationImpact.owners.every(
-      (owner) =>
-        owner.acceptanceIds.length > 0 &&
-        (owner.kind !== "performance" || owner.passIds.length > 0),
-    ),
-    "Generated fixture verification ownership must name acceptance IDs and exact performance pass IDs.",
-  );
-
   const performanceSource = await fs.readFile(
     path.join(targetDir, "src/app/app-performance.ts"),
     "utf8",

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

@@ -66,8 +66,8 @@ export async function assertGeneratedInitialFunctionalDelivery({
   assert.equal(checkpoint.version, 1);
   assert.equal(checkpoint.delivery.kind, "delivery-verification");
   assert.equal(checkpoint.delivery.runner, "protected-delivery");
-  assert.equal(checkpoint.delivery.version, 7);
-  assert.equal(checkpoint.delivery.planVersion, 4);
+  assert.equal(checkpoint.delivery.version, 8);
+  assert.equal(checkpoint.delivery.planVersion, 6);
   assert.equal(checkpoint.delivery.plan.kind, "functional");
   assert.deepEqual(checkpoint.delivery.plan.basis, { kind: "initial" });
   assert.deepEqual(
@@ -108,87 +108,3 @@ export async function assertGeneratedInitialFunctionalDelivery({
     /ENOENT/u,
   );
 }
-
-export async function assertGeneratedLaterFunctionalDelivery({
-  acceptanceCatalog,
-  browserEnv,
-  checkpointPath,
-  execFileAsync,
-  expectedAcceptanceIds,
-  expectedBrowserTestNames,
-  expectedChangedFiles,
-  expectedProductTestFiles,
-  targetDir,
-}) {
-  const { tests } = await runGeneratedDeliveryWithLedger({
-    env: browserEnv,
-    execFileAsync,
-    targetDir,
-  });
-  const expectedRows = acceptanceCatalog.filter(({ acceptanceId }) =>
-    expectedAcceptanceIds.includes(acceptanceId),
-  );
-  assert.equal(
-    expectedRows.length,
-    expectedAcceptanceIds.length,
-  );
-  const checkpoint = JSON.parse(await fs.readFile(checkpointPath, "utf8"));
-  const receipt = checkpoint.delivery;
-  assert.equal(receipt.version, 7);
-  assert.equal(receipt.planVersion, 4);
-  assert.equal(receipt.plan.kind, "functional");
-  assert.equal(Object.hasOwn(receipt, "verificationTier"), false);
-  assert.deepEqual(receipt.plan.basis.changedFiles, expectedChangedFiles);
-  assert.deepEqual(
-    receipt.plan.steps.map(({ kind }) => kind),
-    [
-      "code-health",
-      "product-tests",
-      "build",
-      "browser-functional",
-    ],
-  );
-  assert.deepEqual(
-    receipt.plan.steps.find(({ kind }) => kind === "product-tests"),
-    {
-      files: expectedProductTestFiles,
-      kind: "product-tests",
-    },
-  );
-  assert.deepEqual(
-    receipt.plan.steps.find(
-      ({ kind }) => kind === "browser-functional",
-    ),
-    {
-      kind: "browser-functional",
-      testNames: expectedBrowserTestNames,
-    },
-  );
-  assert.deepEqual(
-    receipt.evidence.find(
-      ({ kind }) => kind === "browser-functional",
-    ),
-    {
-      kind: "browser-functional",
-      testNames: expectedBrowserTestNames,
-    },
-  );
-  assert.ok(
-    receipt.plan.steps.some(({ kind }) => kind === "browser-functional"),
-  );
-  assert.equal(
-    receipt.plan.steps.some(({ kind }) => kind === "browser-performance"),
-    false,
-  );
-  assert.equal(checkpoint.performanceBaseline, null);
-  assert.equal(checkpoint.currentPerformance, null);
-  assert.equal(
-    receipt.evidence.some(({ kind }) => kind === "browser-performance"),
-    false,
-  );
-  assertGeneratedExecutionLedger({
-    expectedFunctionalRows: expectedRows,
-    expectedPerformanceEvidence: [],
-    tests,
-  });
-}

package/src/generate.test.mjs

@@ -387,6 +387,10 @@ describe("generateToolcraft", () => {
       packageJson.scripts["verify:delivery"],
       "node scripts/run-delivery-verification.mjs",
     );
+    assert.equal(
+      packageJson.scripts["test:feature"],
+      "node scripts/run-feature-verification.mjs",
+    );
     assert.equal(packageJson.scripts["verify:quick"], undefined);
     assert.equal(packageJson.scripts["verify:ui"], undefined);
     assert.equal(

package/src/generated-integrity-manifest.test.mjs

@@ -46,7 +46,6 @@ const independentlyProductOwnedPaths = new Set([
   "e2e/app-performance-path-adapters.ts",
   "src/app/app-acceptance-data.ts",
   "src/app/app-composition.tsx",
-  "src/app/app-verification-impact.json",
   "src/app/app-performance.ts",
   "src/app/app-schema.test.ts",
   "src/app/app-schema.ts",
@@ -117,13 +116,17 @@ describe("collectFrameworkOwnedGeneratedFiles", () => {
       "e2e/browser-execution-ledger.ts",
       "e2e/browser-render-scale-evidence.ts",
       "e2e/toolcraft-delivery-catalog-reporter.ts",
+      "e2e/toolcraft-feature-verification-reporter.ts",
       "src/app/acceptance/types.ts",
       "src/app/app-acceptance.render-scale.test.ts",
       "scripts/toolcraft-delivery-anchor.mjs",
       "scripts/toolcraft-delivery-executor.mjs",
+      "scripts/toolcraft-delivery-lifecycle.mjs",
       "scripts/toolcraft-delivery-plan.mjs",
       "scripts/toolcraft-proof-process.mjs",
-      "scripts/toolcraft-verification-impact.mjs",
+      "scripts/run-feature-verification.mjs",
+      "scripts/toolcraft-feature-verification-plan.mjs",
+      "src/app/acceptance/feature-verification-selection.ts",
     ]) {
       assert.ok(protectedFiles.includes(relativePath));
     }

package/src/generated-source-policy.test.mjs

@@ -17,10 +17,6 @@ describe("isGeneratedTestSupportPath", () => {
       "scripts/toolcraft-functional-proof-primitives.d.mts",
       "scripts/toolcraft-functional-proof-model.mjs",
       "scripts/toolcraft-functional-proof-model.d.mts",
-      "scripts/toolcraft-verification-input-roles.mjs",
-      "scripts/toolcraft-verification-input-roles.d.mts",
-      "scripts/toolcraft-verification-impact-inventory.mjs",
-      "scripts/toolcraft-verification-impact-inventory.d.mts",
       "scripts/toolcraft-delivery-functional-context.mjs",
       "scripts/toolcraft-delivery-functional-context.d.mts",
     ];

package/src/package-json.mjs

@@ -72,6 +72,11 @@ export function createGeneratedPackageJson({
       "starterPackageJson.scripts.verify:perf is required to create a generated package manifest.",
     );
   }
+  if (!starterScripts["test:feature"]) {
+    throw new Error(
+      "starterPackageJson.scripts.test:feature is required to create a generated package manifest.",
+    );
+  }
 
   const packageJson = {
     name: sanitizePackageName(name),

package/src/package-json.test.mjs

@@ -36,6 +36,7 @@ describe("createGeneratedPackageJson", () => {
           dev: "vite dev",
           test: "vitest run",
           "test:generated": "node scripts/check-toolcraft-integrity.mjs && vitest run",
+          "test:feature": "node scripts/run-feature-verification.mjs",
           typecheck: "tsc -p tsconfig.json --noEmit",
           "verify:delivery": "node scripts/run-delivery-verification.mjs",
           "verify:perf": "node scripts/run-browser-performance.mjs",
@@ -64,6 +65,7 @@ describe("createGeneratedPackageJson", () => {
         build: "tsc -p tsconfig.json --noEmit && vite build",
         dev: "vite dev",
         test: "node scripts/check-toolcraft-integrity.mjs && vitest run",
+        "test:feature": "node scripts/run-feature-verification.mjs",
         typecheck: "tsc -p tsconfig.json --noEmit",
         "verify:delivery": "node scripts/run-delivery-verification.mjs",
         "verify:perf": "node scripts/run-browser-performance.mjs",
@@ -130,6 +132,23 @@ describe("createGeneratedPackageJson", () => {
     );
   });
 
+  it("rejects starter manifests without the focused feature verifier", () => {
+    assert.throws(
+      () =>
+        createGeneratedPackageJson({
+          name: "Generated App",
+          starterPackageJson: {
+            scripts: {
+              "test:generated": "node scripts/check-toolcraft-integrity.mjs && vitest run",
+              "verify:delivery": "node scripts/run-delivery-verification.mjs",
+              "verify:perf": "node scripts/run-browser-performance.mjs",
+            },
+          },
+        }),
+      /scripts\.test:feature is required/,
+    );
+  });
+
   for (const packageManager of ["npm", "pnpm"]) {
     it(`preserves direct protected entry points without synthesizing aliases for ${packageManager}`, () => {
       const packageJson = createGeneratedPackageJson({
@@ -141,6 +160,7 @@ describe("createGeneratedPackageJson", () => {
             dev: "vite dev",
             test: "vitest run",
             "test:generated": "node scripts/check-toolcraft-integrity.mjs && vitest run",
+            "test:feature": "node scripts/run-feature-verification.mjs",
             typecheck: "tsc -p tsconfig.json --noEmit",
             "verify:delivery": "node scripts/run-delivery-verification.mjs",
             "verify:perf": "node scripts/run-browser-performance.mjs",
@@ -152,6 +172,7 @@ describe("createGeneratedPackageJson", () => {
         build: "vite build",
         dev: "vite dev",
         test: "node scripts/check-toolcraft-integrity.mjs && vitest run",
+        "test:feature": "node scripts/run-feature-verification.mjs",
         typecheck: "tsc -p tsconfig.json --noEmit",
         "verify:delivery": "node scripts/run-delivery-verification.mjs",
         "verify:perf": "node scripts/run-browser-performance.mjs",