@pixel-point/toolcraft 0.0.13 → 0.0.15

package/src/generate.test.mjs

@@ -6,6 +6,11 @@ import path from "node:path";
 import { promisify } from "node:util";
 import { after, describe, it } from "node:test";
 
+import { assertGeneratedStandaloneApp } from "./generate-test-assertions.mjs";
+import {
+  assertGeneratedProductStandalone,
+  assertGeneratedTypechecks,
+} from "./generate-test-standalone-assertions.mjs";
 import { generateToolcraft } from "./generate.mjs";
 
 const tempRoots = [];
@@ -17,36 +22,6 @@ after(async () => {
   );
 });
 
-async function readTextFiles(rootDir) {
-  const files = [];
-
-  async function visit(currentDir) {
-    const entries = await fs.readdir(currentDir, { withFileTypes: true });
-
-    for (const entry of entries) {
-      const filePath = path.join(currentDir, entry.name);
-
-      if (entry.isDirectory()) {
-        if (!["dist", "node_modules"].includes(entry.name)) {
-          await visit(filePath);
-        }
-        continue;
-      }
-
-      if (entry.name === "check-toolcraft-docs.mjs") {
-        continue;
-      }
-
-      if (entry.isFile() && /\.(css|html|json|md|mjs|ts|tsx)$/.test(entry.name)) {
-        files.push(await fs.readFile(filePath, "utf8"));
-      }
-    }
-  }
-
-  await visit(rootDir);
-  return files.join("\n");
-}
-
 describe("generateToolcraft", () => {
   it("creates a standalone app with copied local toolcraft sources", async () => {
     const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "toolcraft-cli-"));
@@ -62,298 +37,269 @@ describe("generateToolcraft", () => {
 
     assert.equal(result.targetDir, targetDir);
     assert.equal(result.packageName, "generated-app");
-    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")),
-    );
+    await assertGeneratedStandaloneApp({ execFileAsync, targetDir });
+  });
 
-    const packageJson = JSON.parse(await fs.readFile(path.join(targetDir, "package.json"), "utf8"));
-    assert.equal(packageJson.license, "SEE LICENSE IN LICENSE.md");
-    assert.equal(packageJson.dependencies["@repo/ui"], undefined);
-    assert.equal(packageJson.dependencies["@repo/toolcraft-runtime"], undefined);
-    assert.equal(packageJson.dependencies["@tanstack/react-router"], "1.170.6");
-    assert.equal(packageJson.dependencies.cmdk, "^1.1.1");
-    assert.equal(packageJson.dependencies["cross-spawn"], "^7.0.6");
-    assert.equal(packageJson.dependencies["react-resizable-panels"], "^4.10.0");
-    assert.equal(packageJson.dependencies.sonner, "^2.0.7");
-    assert.equal(packageJson.devDependencies["@repo/typescript-config"], undefined);
-    assert.equal(packageJson.devDependencies["@playwright/test"], "^1.51.1");
-    assert.equal(packageJson.scripts["ai:check"], "node scripts/check-ai-skills.mjs");
-    assert.equal(packageJson.scripts.dev, "node scripts/run-vite-on-free-port.mjs dev");
-    assert.equal(
-      packageJson.scripts["dev:restart"],
-      "node scripts/run-vite-on-free-port.mjs dev --toolcraft-restart",
-    );
-    assert.equal(packageJson.scripts.preview, "node scripts/run-vite-on-free-port.mjs preview");
-    assert.equal(
-      packageJson.scripts["preview:restart"],
-      "node scripts/run-vite-on-free-port.mjs preview --toolcraft-restart",
-    );
-    assert.equal(packageJson.scripts["docs:check"], "node scripts/check-toolcraft-docs.mjs");
-    assert.equal(
-      packageJson.scripts.test,
-      "node scripts/check-toolcraft-docs.mjs && node scripts/check-toolcraft-integrity.mjs && node --test scripts/*.test.mjs && vitest run src --passWithNoTests",
-    );
-    assert.equal(
-      packageJson.scripts["test:browser"],
-      'playwright install chromium && playwright test --grep-invert "browser perf:"',
-    );
-    assert.equal(
-      packageJson.scripts["test:browser:perf"],
-      "playwright install chromium && playwright test --grep \"browser perf:\" --workers=1 --pass-with-no-tests",
-    );
-    assert.equal(packageJson.scripts["verify:quick"], "npm run ai:check && npm run test");
-    assert.equal(packageJson.scripts["verify:ui"], "npm run test:browser");
-    assert.equal(packageJson.scripts["verify:perf"], "npm run test:browser:perf");
-    assert.equal(packageJson.scripts["verify:perf:playwright"], "npm run test:browser:perf");
-    assert.equal(
-      packageJson.scripts["verify:final"],
-      "npm run ai:check && npm run test && npm run build && npm run test:browser",
-    );
+  it("tests, typechecks, and builds a non-neutral generated product in isolation", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "toolcraft-cli-"));
+    tempRoots.push(tempRoot);
+    const targetDir = path.join(tempRoot, "generated-product");
 
-    const indexHtmlSource = await fs.readFile(path.join(targetDir, "index.html"), "utf8");
-    assert.match(indexHtmlSource, /<title>Generated App<\/title>/);
-    assert.match(indexHtmlSource, /<meta name="toolcraft-app-title" content="Generated App" \/>/);
+    await generateToolcraft({
+      cwd: tempRoot,
+      force: true,
+      name: "Generated Product",
+      packageManager: "pnpm",
+      targetDir: "generated-product",
+    });
 
-    assert.ok(await fs.stat(path.join(targetDir, "playwright.config.ts")));
-    const playwrightConfigSource = await fs.readFile(
-      path.join(targetDir, "playwright.config.ts"),
-      "utf8",
-    );
-    assert.match(playwrightConfigSource, /reuseExistingServer:\s*false/);
-    assert.ok(await fs.stat(path.join(targetDir, "e2e/app-browser-acceptance.spec.ts")));
-    assert.ok(await fs.stat(path.join(targetDir, "e2e/app-controls.spec.ts")));
-    assert.ok(await fs.stat(path.join(targetDir, "src/app/app-schema.ts")));
-    assert.ok(await fs.stat(path.join(targetDir, "src/app/app-schema.test.ts")));
-    assert.ok(await fs.stat(path.join(targetDir, "src/app/app-acceptance.ts")));
-    assert.ok(await fs.stat(path.join(targetDir, "src/app/app-acceptance.test.ts")));
-    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.test.ts")));
-    assert.ok(await fs.stat(path.join(targetDir, "e2e/app-performance.spec.ts")));
-    assert.ok(await fs.stat(path.join(targetDir, "e2e/performance-helpers.ts")));
-    assert.ok(await fs.stat(path.join(targetDir, "e2e/product-observable-helpers.ts")));
-    assert.ok(await fs.stat(path.join(targetDir, "e2e/canvas-handle-helpers.ts")));
-    const gitignoreSource = await fs.readFile(path.join(targetDir, ".gitignore"), "utf8");
-    assert.match(gitignoreSource, /node_modules/);
-    assert.match(gitignoreSource, /dist/);
-    assert.match(gitignoreSource, /playwright-report/);
-    assert.match(gitignoreSource, /\.env\.\*/);
-    assert.match(gitignoreSource, /\.toolcraft/);
-    await assert.rejects(() => fs.stat(path.join(targetDir, "gitignore")), /ENOENT/);
-    assert.ok(await fs.stat(path.join(targetDir, "scripts/check-ai-skills.mjs")));
-    assert.ok(await fs.stat(path.join(targetDir, "scripts/toolcraft-port.mjs")));
-    assert.ok(await fs.stat(path.join(targetDir, "scripts/toolcraft-port.test.mjs")));
-    assert.ok(await fs.stat(path.join(targetDir, "scripts/check-toolcraft-docs.mjs")));
-    assert.ok(await fs.stat(path.join(targetDir, "scripts/check-toolcraft-integrity.mjs")));
-    assert.ok(await fs.stat(path.join(targetDir, "scripts/run-vite-on-free-port.mjs")));
-    const runViteSource = await fs.readFile(
-      path.join(targetDir, "scripts/run-vite-on-free-port.mjs"),
-      "utf8",
-    );
-    assert.match(runViteSource, /node_modules/);
-    assert.match(runViteSource, /\.bin/);
-    assert.match(runViteSource, /vite\.cmd/);
-    assert.match(runViteSource, /from "cross-spawn"/);
-    assert.doesNotMatch(runViteSource, /pnpmCommand|pnpm\.cmd|pnpm",/);
-    assert.ok(await fs.stat(path.join(targetDir, "LICENSE.md")));
-    assert.ok(await fs.stat(path.join(targetDir, "NOTICE.md")));
-    assert.ok(await fs.stat(path.join(targetDir, "docs/toolcraft/README.md")));
-    assert.ok(await fs.stat(path.join(targetDir, "docs/toolcraft/assembly-workflow.md")));
-    assert.ok(await fs.stat(path.join(targetDir, "docs/toolcraft/decision-contract.md")));
-    assert.ok(await fs.stat(path.join(targetDir, "docs/toolcraft/schema-reference.md")));
-    assert.ok(await fs.stat(path.join(targetDir, "docs/toolcraft/acceptance-testing.md")));
-    assert.ok(await fs.stat(path.join(targetDir, "docs/toolcraft/performance.md")));
-    assert.ok(await fs.stat(path.join(targetDir, "docs/toolcraft/renderer-technique.md")));
-    assert.ok(await fs.stat(path.join(targetDir, "docs/toolcraft/custom-controls.md")));
-    assert.ok(await fs.stat(path.join(targetDir, "docs/toolcraft/component-rules.md")));
-    assert.ok(await fs.stat(path.join(targetDir, "src/toolcraft/.toolcraft-manifest.json")));
-
-    const appPerformanceSource = await fs.readFile(
-      path.join(targetDir, "src/app/app-performance.ts"),
-      "utf8",
-    );
-    assert.match(appPerformanceSource, /defineToolcraftPerformance/);
-    assert.match(appPerformanceSource, /preferredRunner:\s*"agent-browser"/);
-    assert.match(appPerformanceSource, /fallbackRunner:\s*"playwright"/);
-    assert.match(appPerformanceSource, /agent-browser-unavailable/);
-    assert.doesNotMatch(appPerformanceSource, /function\s+validateToolcraftPerformanceCoverage/);
-    assert.doesNotMatch(
-      appPerformanceSource,
-      /function\s+collectToolcraftPerformanceSensitiveControls/,
-    );
-    assert.doesNotMatch(appPerformanceSource, /maxPerformanceBudgetCaps/);
+    await assertGeneratedProductStandalone({ execFileAsync, targetDir });
+  });
 
-    await execFileAsync(process.execPath, [path.join(targetDir, "scripts/check-toolcraft-integrity.mjs")], {
-      cwd: targetDir,
-    });
-    await execFileAsync(process.execPath, ["--check", path.join(targetDir, "scripts/toolcraft-port.mjs")], {
-      cwd: targetDir,
-    });
-    await execFileAsync(process.execPath, ["--check", path.join(targetDir, "scripts/run-vite-on-free-port.mjs")], {
-      cwd: targetDir,
-    });
-    await execFileAsync(process.execPath, [path.join(targetDir, "scripts/check-toolcraft-docs.mjs")], {
-      cwd: targetDir,
-    });
+  it("refuses to write into a non-empty directory without force", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "toolcraft-cli-"));
+    tempRoots.push(tempRoot);
+    await fs.writeFile(path.join(tempRoot, "README.md"), "keep me");
 
-    const routePath = path.join(targetDir, "src/routes/index.tsx");
-    const originalRouteSource = await fs.readFile(routePath, "utf8");
-    await fs.writeFile(
-      routePath,
-      'export function AppHome() { return <iframe src="/reference/index.html" />; }\n',
-    );
     await assert.rejects(
       () =>
-        execFileAsync(process.execPath, [path.join(targetDir, "scripts/check-toolcraft-integrity.mjs")], {
-          cwd: targetDir,
+        generateToolcraft({
+          cwd: tempRoot,
         }),
-      /app shell bypass: route files must not render a full-page iframe/,
+      /Target directory is not empty/,
     );
-    await fs.writeFile(routePath, originalRouteSource);
+  });
 
-    const copiedUiIndexPath = path.join(targetDir, "src/toolcraft/ui/index.ts");
-    await fs.appendFile(copiedUiIndexPath, "\n// generated app edits should fail integrity checks\n");
-    await assert.rejects(
-      () =>
-        execFileAsync(process.execPath, [path.join(targetDir, "scripts/check-toolcraft-integrity.mjs")], {
-          cwd: targetDir,
-        }),
-      /Toolcraft generated app integrity check failed/,
+  it("keeps non-colliding product tests editable when force creating in an ordinary folder", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "toolcraft-cli-"));
+    tempRoots.push(tempRoot);
+    const targetDir = path.join(tempRoot, "force-app");
+    const productTestPath = path.join(targetDir, "e2e/product-workflow.spec.ts");
+    const productAcceptanceTestPath = path.join(
+      targetDir,
+      "src/app/product-acceptance.compat.test.ts",
     );
-    const agentsSource = await fs.readFile(path.join(targetDir, "AGENTS.md"), "utf8");
-    const licenseSource = await fs.readFile(path.join(targetDir, "LICENSE.md"), "utf8");
-    const noticeSource = await fs.readFile(path.join(targetDir, "NOTICE.md"), "utf8");
-    const localDocPaths = [
-      "assembly-workflow.md",
-      "decision-contract.md",
-      "schema-reference.md",
-      "component-rules.md",
-      "acceptance-testing.md",
-      "performance.md",
-      "renderer-technique.md",
-      "custom-controls.md",
-    ];
-
-    assert.match(agentsSource, /Quick Entry Contract/);
-    assert.match(agentsSource, /Local Reference Docs/);
-    assert.match(agentsSource, /src\/app\/app-schema\.ts/);
-    assert.match(agentsSource, /src\/app\/app-acceptance\.ts/);
-    assert.match(agentsSource, /src\/app\/app-performance\.ts/);
-    assert.match(agentsSource, /Required AI Workflow Skills/);
-    assert.match(agentsSource, /Verification Tier Classifier/);
-    assert.match(agentsSource, /Verification tier: Tier N/);
-    assert.match(agentsSource, /npm run verify:quick/);
-    assert.match(agentsSource, /npm run verify:final/);
-    assert.match(agentsSource, /npm run ai:check/);
-    assert.match(agentsSource, /use `brainstorming`/);
-    assert.match(agentsSource, /use `writing-plans`/);
-    assert.match(agentsSource, /use `systematic-debugging`/);
-    assert.match(agentsSource, /browser` workflow/);
-    assert.match(agentsSource, /npm run test:browser/);
-    assert.match(agentsSource, /Do not silently skip required workflow skills/);
-    assert.match(agentsSource, /Toolcraft app contract overrides generic brainstorming approval/);
-    assert.match(agentsSource, /Do not ask the user to confirm decisions already covered/);
-    assert.match(agentsSource, /Do not ask whether to enable a browser companion/);
-    assert.match(agentsSource, /not git repositories, save spec\/plan files without asking/);
-    assert.match(agentsSource, /defineToolcraft/);
-    assert.match(agentsSource, /ToolcraftApp/);
-    assert.match(agentsSource, /canvasContent/);
-    assert.match(agentsSource, /renderDefaultCanvasMedia=\{false\}/);
-    assert.match(agentsSource, /onPanelAction/);
-    assert.match(agentsSource, /Toolcraft Designer License/);
-    assert.match(agentsSource, /LICENSE\.md/);
-    assert.match(agentsSource, /NOTICE\.md/);
-    assert.match(licenseSource, /Permitted Designer Use/);
-    assert.match(licenseSource, /designer client work/);
-    assert.match(licenseSource, /AI-Assisted Development/);
-    assert.match(licenseSource, /Codex, Claude, ChatGPT, Cursor/);
-    assert.match(licenseSource, /does not, by itself, make your use a prohibited AI software/);
-    assert.match(licenseSource, /Prohibited Uses/);
-    assert.match(licenseSource, /paid AI software/);
-    assert.match(licenseSource, /template marketplaces/);
-    assert.match(noticeSource, /generated with Toolcraft/);
-    assert.match(noticeSource, /governed by `LICENSE\.md`/);
-
-    for (const localDocPath of localDocPaths) {
-      assert.match(agentsSource, new RegExp(`docs/toolcraft/${localDocPath.replace(".", "\\.")}`));
-    }
-
-    const componentRulesSource = await fs.readFile(
-      path.join(targetDir, "docs/toolcraft/component-rules.md"),
-      "utf8",
+    const obsoleteDefaultsPath = path.join(
+      targetDir,
+      "src/app/acceptance/defaults.ts",
     );
-    assert.match(componentRulesSource, /Slider `step` means numeric snapping only/);
-    assert.match(componentRulesSource, /variant: "discrete"/);
-    assert.match(componentRulesSource, /Keep large or precision stepped ranges visually continuous/);
-    assert.match(componentRulesSource, /Segmented Controls/);
-    assert.match(componentRulesSource, /Never generate a section titled `Color` or `Colors`/);
-    assert.match(componentRulesSource, /Use `fileDrop` for source material uploads/);
-    assert.match(componentRulesSource, /Do not show Layers for a single-layer app/);
-    assert.match(componentRulesSource, /Use playback timeline/);
-    assert.match(componentRulesSource, /Still-output product apps include one primary `Export PNG` action/);
-    assert.match(componentRulesSource, /Animated product apps include `Export Video`/);
-    assert.match(componentRulesSource, /Copy never replaces export/);
-
-    const assemblyDocsSource = await fs.readFile(
-      path.join(targetDir, "docs/toolcraft/assembly-workflow.md"),
-      "utf8",
+    const obsoleteAcceptanceTestPath = path.join(
+      targetDir,
+      "src/app/app-acceptance.test.ts",
+    );
+    const obsoleteOutputExportTestPath = path.join(
+      targetDir,
+      "src/app/app-acceptance.output-export.test.ts",
     );
-    assert.match(assemblyDocsSource, /@\/toolcraft\/runtime/);
-    assert.match(assemblyDocsSource, /transferMode: "reference-runtime-clone"/);
-    assert.match(assemblyDocsSource, /`canvasContent` must not contain app UI/);
-    assert.doesNotMatch(assemblyDocsSource, /@repo\/toolcraft-runtime/);
 
-    const acceptanceDocsSource = await fs.readFile(
-      path.join(targetDir, "docs/toolcraft/acceptance-testing.md"),
-      "utf8",
+    await fs.mkdir(path.dirname(productTestPath), { recursive: true });
+    await fs.mkdir(path.dirname(obsoleteDefaultsPath), { recursive: true });
+    await fs.writeFile(productTestPath, "// product-owned browser test\n");
+    await fs.writeFile(
+      productAcceptanceTestPath,
+      [
+        'import { describe, expect, it } from "vitest";',
+        'import { appAcceptance, validateToolcraftAcceptanceCoverage } from "./app-acceptance";',
+        'import { appSchema } from "./app-schema";',
+        "",
+        'describe("product acceptance compatibility", () => {',
+        '  it("keeps the positional validation facade available", () => {',
+        "    expect(validateToolcraftAcceptanceCoverage(appSchema, appAcceptance)).toEqual(",
+        "      expect.any(Array),",
+        "    );",
+        "  });",
+        "});",
+        "",
+      ].join("\n"),
     );
-    assert.match(acceptanceDocsSource, /Every visible product entity must prove it works/);
-    assert.match(acceptanceDocsSource, /automatedTestName/);
-    assert.match(acceptanceDocsSource, /browserTestName/);
+    await fs.writeFile(obsoleteDefaultsPath, "// obsolete acceptance data\n");
+    await fs.writeFile(obsoleteAcceptanceTestPath, "// obsolete template test\n");
+    await fs.writeFile(obsoleteOutputExportTestPath, "// obsolete output test\n");
 
-    const rendererDocsSource = await fs.readFile(
-      path.join(targetDir, "docs/toolcraft/renderer-technique.md"),
-      "utf8",
+    await generateToolcraft({
+      cwd: tempRoot,
+      force: true,
+      name: "Force App",
+      targetDir: "force-app",
+    });
+
+    const manifest = JSON.parse(
+      await fs.readFile(
+        path.join(targetDir, "src/toolcraft/.toolcraft-manifest.json"),
+        "utf8",
+      ),
     );
-    assert.match(rendererDocsSource, /rendererTechnique/);
-    assert.match(rendererDocsSource, /sourceRepresentation/);
-    assert.match(rendererDocsSource, /whyNotAlternativeStrategies/);
-    await assert.rejects(
-      () =>
-        fs.stat(path.join(targetDir, "src/toolcraft/runtime/react/canvas-shell.test.tsx")),
-      /ENOENT/,
+    assert.equal(
+      manifest.protectedFiles["e2e/product-workflow.spec.ts"],
+      undefined,
     );
-
-    const routeSource = await fs.readFile(path.join(targetDir, "src/routes/index.tsx"), "utf8");
-    assert.match(routeSource, /@\/toolcraft\/runtime\/react/);
-    assert.match(routeSource, /\.\.\/app\/app-schema/);
-
-    const stylesSource = await fs.readFile(path.join(targetDir, "src/styles.css"), "utf8");
-    assert.match(stylesSource, /@source "\.\/toolcraft\/ui";/);
-    assert.match(stylesSource, /@import "@\/toolcraft\/ui\/styles\.css";/);
-
-    const allText = await readTextFiles(targetDir);
-    assert.doesNotMatch(allText, /@repo\/ui|@repo\/toolcraft-runtime|workspace:/);
-    assert.doesNotMatch(allText, new RegExp("template" + "-runtime"));
-    assert.doesNotMatch(allText, /packages\/typescript-config/);
-    assert.doesNotMatch(
-      allText,
-      /starterSchema|starter-schema|starterAcceptance|starter-acceptance|starterProductReadiness|starterTransferMode|starterPerformance|starter-performance|StarterHome|Toolcraft Starter/,
+    assert.equal(
+      manifest.protectedFiles["src/app/product-acceptance.compat.test.ts"],
+      undefined,
+    );
+    await assert.rejects(() => fs.stat(obsoleteDefaultsPath), /ENOENT/);
+    await assert.rejects(() => fs.stat(obsoleteAcceptanceTestPath), /ENOENT/);
+    await assert.rejects(() => fs.stat(obsoleteOutputExportTestPath), /ENOENT/);
+
+    await fs.appendFile(productTestPath, "// remains editable after generation\n");
+    await execFileAsync(
+      process.execPath,
+      [
+        path.join(targetDir, "scripts/check-toolcraft-integrity.mjs"),
+        "--platform-only",
+      ],
+      { cwd: targetDir },
     );
+    await assertGeneratedTypechecks({ execFileAsync, targetDir });
   });
 
-  it("refuses to write into a non-empty directory without force", async () => {
+  it("refuses to force regenerate an existing Toolcraft app without changing product files", async () => {
     const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "toolcraft-cli-"));
     tempRoots.push(tempRoot);
-    await fs.writeFile(path.join(tempRoot, "README.md"), "keep me");
+    const targetDir = path.join(tempRoot, "existing-generated-app");
+    const appSchemaPath = path.join(targetDir, "src/app/app-schema.ts");
+    const acceptanceDataPath = path.join(
+      targetDir,
+      "src/app/app-acceptance-data.ts",
+    );
+    const productTestPath = path.join(
+      targetDir,
+      "src/app/product-owned.test.ts",
+    );
+    const sentinels = {
+      acceptance: "export const productAcceptanceSentinel = 'keep acceptance';\n",
+      schema: "export const productSchemaSentinel = 'keep schema';\n",
+      test: "export const productTestSentinel = 'keep test';\n",
+    };
+
+    await generateToolcraft({
+      cwd: tempRoot,
+      force: true,
+      name: "Existing Generated App",
+      targetDir: "existing-generated-app",
+    });
+    await fs.writeFile(appSchemaPath, sentinels.schema);
+    await fs.writeFile(acceptanceDataPath, sentinels.acceptance);
+    await fs.writeFile(productTestPath, sentinels.test);
 
     await assert.rejects(
       () =>
         generateToolcraft({
           cwd: tempRoot,
+          force: true,
+          name: "Existing Generated App",
+          targetDir: "existing-generated-app",
         }),
-      /Target directory is not empty/,
+      /Refusing to regenerate an existing Toolcraft app in place/,
     );
+
+    assert.equal(await fs.readFile(appSchemaPath, "utf8"), sentinels.schema);
+    assert.equal(
+      await fs.readFile(acceptanceDataPath, "utf8"),
+      sentinels.acceptance,
+    );
+    assert.equal(await fs.readFile(productTestPath, "utf8"), sentinels.test);
+  });
+
+  it("refuses to force regenerate damaged generated apps without changing product files", async (t) => {
+    const damageCases = [
+      {
+        damage: async (targetDir) => {
+          await fs.rm(
+            path.join(targetDir, "src/toolcraft/.toolcraft-manifest.json"),
+          );
+        },
+        name: "missing integrity manifest",
+      },
+      {
+        damage: async (targetDir) => {
+          await fs.rm(path.join(targetDir, "src/toolcraft"), {
+            force: true,
+            recursive: true,
+          });
+        },
+        name: "missing copied runtime tree",
+      },
+      {
+        damage: async (targetDir) => {
+          await Promise.all([
+            fs.rm(path.join(targetDir, "src/toolcraft"), {
+              force: true,
+              recursive: true,
+            }),
+            fs.rm(
+              path.join(targetDir, "scripts/check-toolcraft-integrity.mjs"),
+            ),
+          ]);
+        },
+        name: "only generated package command remains",
+      },
+      {
+        damage: async (targetDir) => {
+          await Promise.all([
+            fs.rm(path.join(targetDir, "src/toolcraft"), {
+              force: true,
+              recursive: true,
+            }),
+            fs.rm(
+              path.join(targetDir, "scripts/check-toolcraft-integrity.mjs"),
+            ),
+          ]);
+          await fs.writeFile(
+            path.join(targetDir, "package.json"),
+            '{"scripts":{"test:generated":"node scripts/check-toolcraft-integrity.mjs"',
+          );
+        },
+        name: "only malformed generated package command remains",
+      },
+    ];
+
+    for (const [index, damageCase] of damageCases.entries()) {
+      await t.test(damageCase.name, async () => {
+        const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "toolcraft-cli-"));
+        tempRoots.push(tempRoot);
+        const targetName = `damaged-generated-app-${index}`;
+        const targetDir = path.join(tempRoot, targetName);
+        const productPaths = {
+          acceptance: path.join(targetDir, "src/app/app-acceptance-data.ts"),
+          schema: path.join(targetDir, "src/app/app-schema.ts"),
+          test: path.join(targetDir, "src/app/product-owned.test.ts"),
+        };
+        const sentinels = {
+          acceptance: `export const productAcceptanceSentinel = '${damageCase.name}';\n`,
+          schema: `export const productSchemaSentinel = '${damageCase.name}';\n`,
+          test: `export const productTestSentinel = '${damageCase.name}';\n`,
+        };
+
+        await generateToolcraft({
+          cwd: tempRoot,
+          force: true,
+          name: "Damaged Generated App",
+          targetDir: targetName,
+        });
+        await Promise.all(
+          Object.entries(productPaths).map(([key, filePath]) =>
+            fs.writeFile(filePath, sentinels[key]),
+          ),
+        );
+        await damageCase.damage(targetDir);
+
+        await assert.rejects(
+          () =>
+            generateToolcraft({
+              cwd: tempRoot,
+              force: true,
+              name: "Damaged Generated App",
+              targetDir: targetName,
+            }),
+          /Refusing to regenerate an existing Toolcraft app in place/,
+        );
+
+        for (const [key, filePath] of Object.entries(productPaths)) {
+          assert.equal(await fs.readFile(filePath, "utf8"), sentinels[key]);
+        }
+      });
+    }
   });
 
   it("generates package-manager-specific commands for pnpm apps", async () => {
@@ -376,14 +322,15 @@ describe("generateToolcraft", () => {
     assert.equal(packageJson.scripts["verify:perf:playwright"], "pnpm test:browser:perf");
     assert.equal(
       packageJson.scripts["verify:final"],
-      "pnpm ai:check && pnpm test && pnpm build && pnpm test:browser",
+      "pnpm ai:check && pnpm test && pnpm build && pnpm test:browser && pnpm verify:receipt",
     );
 
     const playwrightConfigSource = await fs.readFile(
       path.join(targetDir, "playwright.config.ts"),
       "utf8",
     );
-    assert.match(playwrightConfigSource, /pnpm exec vite dev/);
+    assert.match(playwrightConfigSource, /pnpm exec vite \$\{browserServerMode\}/);
+    assert.match(playwrightConfigSource, /=== "preview" \? "preview" : "dev"/);
     assert.doesNotMatch(playwrightConfigSource, /npm exec -- vite/);
 
     const agentsSource = await fs.readFile(path.join(targetDir, "AGENTS.md"), "utf8");