@pixel-point/toolcraft 0.0.18 → 0.0.19

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

@@ -37,6 +37,7 @@ describe("starter acceptance worklog contract", () => {
 \`\`\`md
 ### Not a delivery iteration
 - Request: Forged request.
+- Source reviewed: forged-reference.mp4 video reference.
 \`\`\`
 
 ## Evidence`,
@@ -98,7 +99,7 @@ describe("starter acceptance worklog contract", () => {
     expect(acceptanceTesting).toContain("builtInFitCheck");
   });
 
-  it("requires product worklogs to record storyboard evidence for video references", () => {
+  it("reports video wording as an unregistered input when typed references are empty", () => {
     const worklog = createAgentWorklogFixture({
       evidenceLines: [
         "- Source reviewed: user prompt, ref.mp4, src/app/product-renderer.tsx.",
@@ -110,34 +111,169 @@ describe("starter acceptance worklog contract", () => {
       },
     });
 
-    expect(getAgentWorklogValidationErrors(worklog)).toContain(
-      "agent-worklog.md cites a video reference, screen recording, GIF, extracted frames, or contact sheet; record a Video Reference Study with storyboard frames and frame-to-frame transition analysis.",
+    expect(
+      getAgentWorklogValidationErrors(worklog, { motionReferences: [] }),
+    ).toContain(
+      "agent-worklog.md cites a video reference, screen recording, GIF, extracted frames, or contact sheet, but starterTransferMode.referenceInputs registers no motion reference input.",
     );
   });
 
-  it("accepts product worklogs that record video reference storyboard and transition evidence", () => {
+  it("requires one exact typed summary for each timed motion-reference study", () => {
+    const motionReference = {
+      contactSheetPath:
+        "src/app/reference-studies/study-main/contact-sheet.png",
+      referenceId:
+        "motion-reference-v1-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+      requiresRealTimeReview: true,
+      requiresSlowedReview: true,
+      sourceSha256:
+        "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+      studyId: "study-main",
+      timingMode: "seconds" as const,
+    };
     const worklog = createAgentWorklogFixture({
       evidenceLines: [
-        "- Source reviewed: user prompt, ref.mp4, extracted frames, contact sheet, src/app/product-renderer.tsx.",
+        "- Source reviewed: user prompt, ref.mp4, extracted frames, src/app/product-renderer.tsx.",
         "- Contract applied: Toolcraft workflow and video-reference-analysis.",
       ],
-      extraDecisionSections: [
-        [
-          "### Video Reference Study",
-          "- Decision: Implement from storyboard frames and frame-to-frame transition analysis.",
-          "- Reason: The video reference defines behavior, not only a static visual state.",
-          "- Evidence: extracted frames f000/f012/f024/f036 and transition analysis between adjacent frames.",
-        ].join("\n"),
-      ],
       trailFields: {
         "Alternatives rejected": "Single screenshot implementation because the video behavior changes frame to frame.",
         "Contract rules applied": "video-reference-analysis and acceptance-product-observable.",
-        "Reference inputs": "/fixtures/reference-motion/ref.mp4 video reference, extracted frames, contact sheet.",
-        "Source/reference checked": "User prompt, /fixtures/reference-motion/ref.mp4 video, extracted frames, and contact sheet.",
+        "Reference inputs": "/fixtures/reference-motion/ref.mp4 video reference.",
+        "Source/reference checked": "User prompt and /fixtures/reference-motion/ref.mp4 video.",
       },
     });
 
-    expect(getAgentWorklogValidationErrors(worklog)).toEqual([]);
+    expect(
+      getAgentWorklogValidationErrors(worklog, {
+        motionReferences: [motionReference],
+      }),
+    ).toEqual([
+      expect.stringContaining('motion reference study "study-main"'),
+    ]);
+
+    const genericKeywords = worklog.replace(
+      "## Decision Trail",
+      [
+        "### Video Reference Study",
+        "- Evidence: storyboard frames and transition analysis from the contact sheet.",
+        "",
+        "## Decision Trail",
+      ].join("\n"),
+    );
+    expect(
+      getAgentWorklogValidationErrors(genericKeywords, {
+        motionReferences: [motionReference],
+      }),
+    ).toEqual([
+      expect.stringContaining('motion reference study "study-main"'),
+    ]);
+
+    const exactRecord = [
+      "- Motion reference study:",
+      `referenceId=${motionReference.referenceId};`,
+      `studyId=${motionReference.studyId};`,
+      `sourceSha256=${motionReference.sourceSha256};`,
+      `timingMode=${motionReference.timingMode};`,
+      `contactSheetPath=${motionReference.contactSheetPath};`,
+      "review=real-time,slowed.",
+    ].join(" ");
+    for (const inexactRecord of [
+      exactRecord.replace(
+        motionReference.referenceId,
+        `${motionReference.referenceId}x`,
+      ),
+      exactRecord.replace("studyId=study-main", "studyId=study-other"),
+      exactRecord.replace(
+        motionReference.sourceSha256,
+        `c${motionReference.sourceSha256.slice(1)}`,
+      ),
+      exactRecord.replace("timingMode=seconds", "timingMode=ordinal"),
+      exactRecord.replace(
+        motionReference.contactSheetPath,
+        "src/app/reference-studies/study-main/other-sheet.png",
+      ),
+      exactRecord.replace("review=real-time,slowed", "review=real-time"),
+    ]) {
+      expect(
+        getAgentWorklogValidationErrors(`${worklog}\n${inexactRecord}`, {
+          motionReferences: [motionReference],
+        }),
+      ).toEqual([
+        expect.stringContaining('motion reference study "study-main"'),
+      ]);
+    }
+    expect(
+      getAgentWorklogValidationErrors(`${worklog}\n${exactRecord}`, {
+        motionReferences: [motionReference],
+      }),
+    ).toEqual([]);
+  });
+
+  it("requires ordered-frame review for ordinal evidence and rejects timing review wording", () => {
+    const motionReference = {
+      contactSheetPath:
+        "src/app/reference-studies/study-ordinal/contact-sheet.png",
+      referenceId:
+        "motion-reference-v1-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+      requiresRealTimeReview: false,
+      requiresSlowedReview: false,
+      sourceSha256:
+        "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+      studyId: "study-ordinal",
+      timingMode: "ordinal" as const,
+    };
+    const base = createAgentWorklogFixture();
+    const timedWording = `${base}\n- Motion reference study: referenceId=${motionReference.referenceId}; studyId=${motionReference.studyId}; sourceSha256=${motionReference.sourceSha256}; timingMode=ordinal; contactSheetPath=${motionReference.contactSheetPath}; review=real-time,slowed.`;
+    expect(
+      getAgentWorklogValidationErrors(timedWording, {
+        motionReferences: [motionReference],
+      }),
+    ).toEqual([
+      expect.stringContaining('motion reference study "study-ordinal"'),
+    ]);
+
+    const ordinalRecord = timedWording.replace(
+      "review=real-time,slowed",
+      "review=ordered-frames",
+    );
+    expect(
+      getAgentWorklogValidationErrors(ordinalRecord, {
+        motionReferences: [motionReference],
+      }),
+    ).toEqual([]);
+  });
+
+  it("does not let one record satisfy two nested studies", () => {
+    const referenceId =
+      "motion-reference-v1-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+    const sourceSha256 =
+      "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
+    const first = {
+      contactSheetPath:
+        "src/app/reference-studies/study-one/contact-sheet.png",
+      referenceId,
+      requiresRealTimeReview: true,
+      requiresSlowedReview: false,
+      sourceSha256,
+      studyId: "study-one",
+      timingMode: "seconds" as const,
+    };
+    const second = {
+      ...first,
+      contactSheetPath:
+        "src/app/reference-studies/study-two/contact-sheet.png",
+      studyId: "study-two",
+    };
+    const worklog = `${createAgentWorklogFixture()}\n- Motion reference study: referenceId=${referenceId}; studyId=study-one; sourceSha256=${sourceSha256}; timingMode=seconds; contactSheetPath=${first.contactSheetPath}; review=real-time.`;
+
+    expect(
+      getAgentWorklogValidationErrors(worklog, {
+        motionReferences: [first, second],
+      }),
+    ).toEqual([
+      expect.stringContaining('motion reference study "study-two"'),
+    ]);
   });
 
   it("does not treat ordinary video export worklog evidence as a video reference", () => {

package/templates/starter/src/app/starter-performance.gates.test.ts

@@ -20,9 +20,6 @@ import {
   type ToolcraftEnvelopePerformanceConfig,
   validateToolcraftPerformanceCoverage,
 } from "@repo/toolcraft-runtime";
-import {
-  validateToolcraftCurrentPerformanceImpactInventory,
-} from "../../scripts/toolcraft-verification-receipt.mjs";
 import {
   createToolcraftScriptLineBudgetPolicy,
   getToolcraftScriptProductionEntryPaths,
@@ -146,6 +143,9 @@ function collectPerformanceSpecFacts(source: string, fileName: string) {
   });
 }
 
+// Hang-only ceiling: functional gate duration is never product performance evidence.
+const TOOLCRAFT_FUNCTIONAL_GATE_TIMEOUT_MS = 60_000;
+
 describe("Toolcraft starter performance gates", () => {
   it(
     "keeps generated verification scripts within shared recursive budgets",
@@ -153,7 +153,7 @@ describe("Toolcraft starter performance gates", () => {
       const result = await evaluateGeneratedScriptBudgets(projectDir);
       expect(result.lineBudgetViolations).toEqual([]);
     },
-    15_000,
+    TOOLCRAFT_FUNCTIONAL_GATE_TIMEOUT_MS,
   );
 
   it("classifies every script extension and production-looking test by reachability", async () => {
@@ -355,13 +355,27 @@ describe("Toolcraft starter performance gates", () => {
     expect(playwrightConfigForbidsFocusedTests()).toBe(true);
   });
 
+  it("keeps later feature verification product-only and outside proof authority", () => {
+    const source = readFileSync(
+      join(projectDir, "scripts/run-feature-verification.mjs"),
+      "utf8",
+    );
+
+    expect(source).toContain("Promise.all");
+    expect(source).toContain("resolveToolcraftPlaywrightTestTitles");
+    expect(source).toContain("TOOLCRAFT_BROWSER_SERVER_MODE: \"dev\"");
+    expect(source).not.toMatch(
+      /executeToolcraftDeliveryLifecycle|measureToolcraftPerformanceCheckpoint|collectToolcraftVerificationInputs/iu,
+    );
+  });
+
   it("keeps verification lifecycle authority in the runtime contract", () => {
     expect(starterPerformance).not.toHaveProperty("browserCheckPolicy");
     expect(TOOLCRAFT_PERFORMANCE_VERIFICATION_LIFECYCLE).toEqual({
       delivery: {
         command: "verify:delivery",
-        modes: ["functional", "performance-iteration"],
-        selectors: "automatic",
+        modes: ["initial-functional", "performance-iteration"],
+        selectors: "initial-complete-or-authority-exact",
       },
       fullPerformance: {
         command: "verify:perf",
@@ -380,18 +394,6 @@ describe("Toolcraft starter performance gates", () => {
     ).toEqual([]);
   });
 
-  it("maps every product production module to current renderer pass ownership", async () => {
-    const knownPassIds = (starterPerformance.rendererPipeline?.passes ?? []).map(
-      ({ id }) => id,
-    );
-    await expect(
-      validateToolcraftCurrentPerformanceImpactInventory({
-        knownPassIds,
-        rootDir: projectDir,
-      }),
-    ).resolves.toBeDefined();
-  });
-
   it("keeps unresolved kernel decisions pending during functional delivery", () => {
     const performanceConfig: ToolcraftEnvelopePerformanceConfig = starterPerformance;
     const rawAssessment = assessToolcraftRenderPlan(starterSchema, {

package/templates/starter/src/app/starter-performance.lifecycle.test.ts

@@ -12,8 +12,8 @@ import { projectDir } from "./starter-performance-test-utils";
 
 const expectedRequiredPackageScriptNames = [
   "ai:check", "build", "dev", "dev:restart", "docs:check", "preview",
-  "preview:restart", "test", "test:browser", "typecheck", "verify:delivery",
-  "verify:kernel", "verify:perf", "verify:receipt",
+  "preview:restart", "reference:study", "test", "test:browser", "test:feature", "typecheck",
+  "verify:delivery", "verify:kernel", "verify:perf", "verify:receipt",
 ] as const;
 
 describe("Toolcraft starter performance lifecycle", () => {
@@ -59,6 +59,20 @@ describe("Toolcraft starter performance lifecycle", () => {
       'playwright install chromium && playwright test --grep-invert "browser perf:|toolcraft kernel:"',
     );
     expect(packageJson.scripts?.["test:browser:perf"]).toBeUndefined();
+    expect(packageJson.scripts?.["test:feature"]).toBe(
+      "node scripts/run-feature-verification.mjs",
+    );
+    const featureRunner = readFileSync(
+      join(projectDir, "scripts/run-feature-verification.mjs"),
+      "utf8",
+    );
+    expect(featureRunner).toContain(
+      "toolcraft-feature-verification-reporter.ts",
+    );
+    expect(featureRunner).toContain("--workers=1");
+    expect(featureRunner).not.toMatch(
+      /runToolcraftProofPackageScript|verify:delivery|verify:perf|test:browser/iu,
+    );
     const performanceRunner = readFileSync(
       join(projectDir, "scripts/run-browser-performance.mjs"),
       "utf8",
@@ -161,12 +175,12 @@ describe("Toolcraft starter performance lifecycle", () => {
 
     for (const { relativePath, source } of docSources) {
       expect(source, relativePath).toMatch(/first (?:product )?delivery/i);
-      expect(source, relativePath).toMatch(/later[^\n]{0,40}delivery/i);
+      expect(source, relativePath).toMatch(/later[^\n]{0,60}(?:edits|feature work)/i);
       expect(source, relativePath).toMatch(
         /(?:performance complaint|localized complaint)/i,
       );
       expect(source, relativePath).toMatch(
-        /(?:full audit|complete (?:performance )?(?:audit|review))/i,
+        /(?:full[- ]audit|complete (?:performance )?(?:audit|review))/i,
       );
       expect(source, relativePath).toContain(
         TOOLCRAFT_DELIVERY_VERIFICATION_COMMAND,
@@ -241,14 +255,16 @@ describe("Toolcraft starter performance lifecycle", () => {
     expect(documentation).toMatch(
       /first product delivery[^\n]*full functional acceptance[^\n]*no measured performance/i,
     );
-    expect(documentation).toMatch(/later delivery[^\n]*functional-targeted/i);
+    expect(documentation).toMatch(
+      /later(?: ordinary)? edits[^\n]*(?:focused|directly relevant|feature-focused)/i,
+    );
     expect(documentation).toMatch(
       /complaint[^\n]*one-authority-targeted-performance-iteration/i,
     );
     expect(documentation).toMatch(/full-performance/i);
     expect(documentation).toMatch(/needs-agent-judgment/i);
     expect(documentation).toMatch(
-      /later[^\n]{0,40}delivery[^\n]*(?:same )?bare command[^\n]*exact ownership/i,
+      /repeated bare command[^\n]*protected no-op/i,
     );
     expect(documentation).not.toMatch(
       /first stable[^\n]*(?:full performance|full checkpoint|baseline)/i,

package/templates/starter/src/app/test-evidence/browser-runtime-contract.ts

@@ -26,6 +26,7 @@ export const TOOLCRAFT_BROWSER_RUNTIME_EVIDENCE_TYPES = [
   "exported-artifact",
   "infinity-mode-restoration",
   "infinity-scene-bounds-image-export",
+  "infinity-scene-bounds-svg-export",
   "infinity-scene-bounds-video-export",
   "image-export-artifact",
   "layer-grouping",
@@ -73,6 +74,8 @@ export const TOOLCRAFT_BROWSER_RUNTIME_EVIDENCE_TYPES = [
   "product-observable-change",
   "reference-parity",
   "segmented-control-layout",
+  "selection-scoped-control",
+  "svg-export-artifact",
   "timeline-duration",
   "timeline-keyframes",
   "timeline-loop",

package/templates/starter/tsconfig.json

@@ -11,6 +11,7 @@
     "src",
     "scripts/toolcraft-delivery-receipt.types.test.mts",
     "scripts/toolcraft-functional-proof-model.types.test.mts",
+    "scripts/toolcraft-motion-reference-artifacts.types.test.mts",
     "scripts/toolcraft-targeted-performance-report.types.test.mts",
     "vite.config.ts"
   ]

package/templates/starter/scripts/toolcraft-browser-impact-selection.mjs

@@ -1,26 +0,0 @@
-const toRepoTestFile = (file) =>
-  file.startsWith("e2e/") ? file : `e2e/${file}`;
-
-export function selectToolcraftCurrentBrowserImpact({
-  files,
-  model,
-  semanticAcceptanceIds,
-}) {
-  const fileSet = new Set(files);
-  const rows = model.acceptance.filter(({ file }) =>
-    fileSet.has(toRepoTestFile(file)),
-  );
-  const exact =
-    rows.length > 0 &&
-    rows.every(({ acceptanceId }) =>
-      semanticAcceptanceIds.has(acceptanceId),
-    );
-  return Object.freeze({
-    acceptanceIds: Object.freeze(
-      exact ? rows.map(({ acceptanceId }) => acceptanceId) : [],
-    ),
-    domainIds: Object.freeze(
-      exact ? [] : [...new Set(rows.map(({ domainId }) => domainId))],
-    ),
-  });
-}

package/templates/starter/scripts/toolcraft-delivery-framework-refresh.test.mjs

@@ -1,141 +0,0 @@
-import assert from "node:assert/strict";
-import { readFileSync, writeFileSync } from "node:fs";
-import path from "node:path";
-import test from "node:test";
-
-import {
-  evaluateToolcraftIntegrity,
-} from "./check-toolcraft-integrity.mjs";
-import {
-  collectToolcraftDeliveryFunctionalContext,
-} from "./toolcraft-delivery-functional-context.mjs";
-import {
-  loadToolcraftDeliveryPlanningInputs,
-} from "./toolcraft-delivery-lifecycle.mjs";
-import {
-  EMPTY_TOOLCRAFT_DELIVERY_LIFECYCLE_STATE,
-} from "./toolcraft-delivery-lifecycle-state.mjs";
-import {
-  createToolcraftDeliveryPlan,
-} from "./toolcraft-delivery-plan.mjs";
-import {
-  createToolcraftFunctionalProofModelHash,
-} from "./toolcraft-functional-proof-model.mjs";
-import {
-  installToolcraftIntegrityFixture,
-} from "./toolcraft-integrity-test-utils.mjs";
-import {
-  TOOLCRAFT_DELIVERY_VERIFICATION_NARRATIVE,
-} from "./toolcraft-performance-authority-policy.mjs";
-import {
-  collectToolcraftVerificationInputs,
-} from "./toolcraft-verification-inventory.mjs";
-import {
-  createDeliveryFixture,
-  removeDeliveryFixture,
-} from "./run-delivery-verification-test-helpers.mjs";
-
-test("signed framework refresh preserves exact changed product proof", async (t) => {
-  const rootDir = createDeliveryFixture();
-  t.after(() => removeDeliveryFixture(rootDir));
-  await installToolcraftIntegrityFixture(rootDir);
-  writeFileSync(
-    path.join(rootDir, "docs", "toolcraft", "agent-worklog.md"),
-    `# Agent Worklog
-
-## Decision Trail
-
-### Framework refresh
-- Request: Update one product setting after regenerating Toolcraft.
-- Performance intent: ordinary-product-work
-- Verification: ${TOOLCRAFT_DELIVERY_VERIFICATION_NARRATIVE}
-
-## Verification
-Protected receipts own checks and evidence.
-`,
-  );
-  const manifestPath = path.join(
-    rootDir,
-    "src",
-    "toolcraft",
-    ".toolcraft-manifest.json",
-  );
-  const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
-  writeFileSync(
-    manifestPath,
-    `${JSON.stringify({
-      ...manifest,
-      description: "Previous signed generated framework.",
-    }, null, 2)}\n`,
-  );
-  const comparisonInventory =
-    await collectToolcraftVerificationInputs(rootDir);
-  const previousIntegrity = await evaluateToolcraftIntegrity({
-    inventory: comparisonInventory,
-    rootDir,
-  });
-  writeFileSync(
-    manifestPath,
-    `${JSON.stringify({
-      ...manifest,
-      description: "Current signed generated framework.",
-    }, null, 2)}\n`,
-  );
-  writeFileSync(
-    path.join(rootDir, "src", "app", "schema.ts"),
-    "export const schema = 2;\n",
-  );
-  const currentInventory =
-    await collectToolcraftVerificationInputs(rootDir);
-  const integrity = await evaluateToolcraftIntegrity({
-    inventory: currentInventory,
-    rootDir,
-  });
-  const functionalContext =
-    await collectToolcraftDeliveryFunctionalContext(rootDir);
-  const currentModel = functionalContext.currentFunctionalProofModel;
-  const inputs = await loadToolcraftDeliveryPlanningInputs({
-    currentInventory,
-    functionalContext,
-    integrity,
-    previous: {
-      anchor: {
-        files: comparisonInventory.entries,
-        functionalProofModel: currentModel,
-        functionalProofModelHash:
-          createToolcraftFunctionalProofModelHash(currentModel),
-        lifecycle: EMPTY_TOOLCRAFT_DELIVERY_LIFECYCLE_STATE,
-        performance: { kind: "none" },
-        sourceHash: comparisonInventory.sourceHash,
-      },
-      receipt: { version: 7 },
-    },
-    projectDir: rootDir,
-  });
-
-  assert.notEqual(integrity.manifestHash, previousIntegrity.manifestHash);
-  assert.equal(
-    functionalContext.frameworkOwnedPaths.includes(
-      "scripts/run-delivery-verification.mjs",
-    ),
-    true,
-  );
-  assert.equal(inputs.changeSet.frameworkChanged, true);
-  assert.equal(inputs.changeSet.platformChanged, false);
-  assert.deepEqual(
-    inputs.changeSet.impact.browserTestNames,
-    ["browser: focused acceptance"],
-  );
-  const plan = createToolcraftDeliveryPlan(inputs);
-  assert.deepEqual(
-    plan.steps.find(({ kind }) => kind === "browser-functional"),
-    {
-      kind: "browser-functional",
-      testNames: ["browser: focused acceptance"],
-    },
-  );
-  assert.equal(
-    plan.steps.filter(({ kind }) => kind === "browser-functional").length,
-    1,
-  );
-});