@pixel-point/toolcraft 0.0.15 → 0.0.17

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

@@ -0,0 +1,299 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  clearPerformanceSignalError,
+  createPerformanceIterationWorklogFixture as renderPerformanceIterationWorklogFixture,
+  fixturePerformancePathId,
+} from "./starter-acceptance.worklog-performance-intent-test-utils";
+import {
+  createAgentWorklogFixture,
+  getAgentWorklogValidationErrors,
+} from "./starter-acceptance.worklog-test-utils";
+
+const createPerformanceIterationWorklogFixture = (
+  options: Parameters<typeof renderPerformanceIterationWorklogFixture>[1],
+) =>
+  renderPerformanceIterationWorklogFixture(
+    createAgentWorklogFixture,
+    options,
+  );
+
+describe("starter acceptance worklog performance intent", () => {
+  it("rejects trivial single-character Request evidence", () => {
+    const worklog = createPerformanceIterationWorklogFixture({
+      evidence: "x",
+      request: "x",
+    });
+
+    expect(getAgentWorklogValidationErrors(worklog)).not.toEqual([]);
+  });
+
+  it("preserves exact whitespace and Unicode code units in Request evidence", () => {
+    const exactRequest = "The café  preview is unresponsive.";
+    const normalizedWhitespace = createPerformanceIterationWorklogFixture({
+      evidence: "The café preview is unresponsive.",
+      request: exactRequest,
+    });
+    const normalizedUnicode = createPerformanceIterationWorklogFixture({
+      evidence: "The cafe\u0301  preview is unresponsive.",
+      request: exactRequest,
+    });
+
+    expect(
+      getAgentWorklogValidationErrors(
+        createPerformanceIterationWorklogFixture({ request: exactRequest }),
+      ),
+    ).toEqual([]);
+    expect(getAgentWorklogValidationErrors(normalizedWhitespace)).not.toEqual([]);
+    expect(getAgentWorklogValidationErrors(normalizedUnicode)).not.toEqual([]);
+  });
+
+  it("requires exactly one performance intent in every Decision Trail iteration", () => {
+    const missing = createAgentWorklogFixture({
+      omitDecisionTrailFields: ["Performance intent"],
+    });
+    const duplicate = createAgentWorklogFixture().replace(
+      "- Performance intent: ordinary-product-work",
+      "- Performance intent: ordinary-product-work\n- Performance intent: ordinary-product-work",
+    );
+
+    expect(getAgentWorklogValidationErrors(missing)).toContain(
+      'agent-worklog.md Decision Trail iteration "Delivery 1 - Product build" must include exactly one "Performance intent:".',
+    );
+    expect(getAgentWorklogValidationErrors(duplicate)).toContain(
+      'agent-worklog.md Decision Trail iteration "Delivery 1 - Product build" must include exactly one "Performance intent:".',
+    );
+  });
+
+  it("accepts separate domain-shaped performance authority fields", () => {
+    const worklog = createPerformanceIterationWorklogFixture({
+      evidence: "The canvas is delayed and unresponsive.",
+      request: "Please fix this. The canvas is delayed and unresponsive.",
+    });
+
+    expect(getAgentWorklogValidationErrors(worklog)).toEqual([]);
+  });
+
+  it.each([
+    ["Performance request evidence", "- Performance request evidence:"],
+    ["Performance paths", "- Performance paths:"],
+  ])("requires exactly one %s field for performance intent", (field, prefix) => {
+    const fixture = createPerformanceIterationWorklogFixture({
+      request: "The canvas lags while dragging.",
+    });
+    const renderedField = fixture
+      .split("\n")
+      .find((line) => line.startsWith(prefix));
+    if (!renderedField) throw new Error(`Expected ${field} fixture field.`);
+    const missing = fixture
+      .split("\n")
+      .filter((line) => line !== renderedField)
+      .join("\n");
+    const duplicate = fixture.replace(
+      renderedField,
+      `${renderedField}\n${renderedField}`,
+    );
+
+    expect(getAgentWorklogValidationErrors(missing)).toContain(
+      `agent-worklog.md Decision Trail iteration "Delivery 1 - Product build" must include exactly one "${field}:".`,
+    );
+    expect(getAgentWorklogValidationErrors(duplicate)).toContain(
+      `agent-worklog.md Decision Trail iteration "Delivery 1 - Product build" must include exactly one "${field}:".`,
+    );
+  });
+
+  it.each([
+    ["not JSON", "performance-path:unknown"],
+    ["empty", "[]"],
+    ["duplicate", JSON.stringify([fixturePerformancePathId, fixturePerformancePathId])],
+    ["noncanonical", JSON.stringify(["performance-path:unknown"])],
+  ])("rejects %s Performance paths", (_case, paths) => {
+    const worklog = createPerformanceIterationWorklogFixture({
+      request: "The canvas lags while dragging.",
+    }).replace(
+      `- Performance paths: ${JSON.stringify([fixturePerformancePathId])}`,
+      `- Performance paths: ${paths}`,
+    );
+
+    expect(getAgentWorklogValidationErrors(worklog)).not.toEqual([]);
+  });
+
+  it.each([
+    [
+      "unknown profile",
+      ["unknown-profile", "control-change", ["composite"], ["main"], []],
+    ],
+    [
+      "unknown interaction",
+      ["interactive-discrete", "unknown-interaction", ["composite"], ["main"], []],
+    ],
+    [
+      "mismatched profile",
+      ["interactive-continuous", "control-change", ["composite"], ["main"], []],
+    ],
+    [
+      "duplicate signature members",
+      [
+        "interactive-discrete",
+        "control-change",
+        ["composite", "composite"],
+        ["main"],
+        [],
+      ],
+    ],
+    [
+      "unsorted signature members",
+      [
+        "interactive-discrete",
+        "control-change",
+        ["source", "composite"],
+        ["main"],
+        [],
+      ],
+    ],
+  ])("rejects %s in canonical path signatures", (_case, signature) => {
+    const pathId = `performance-path:${encodeURIComponent(
+      JSON.stringify(signature),
+    )}`;
+    const worklog = createPerformanceIterationWorklogFixture({
+      pathIds: [pathId],
+      request: "The canvas lags while dragging.",
+    });
+
+    expect(getAgentWorklogValidationErrors(worklog)).not.toEqual([]);
+  });
+
+  it.each([
+    ["Build a poster.", "It lags."],
+    ["The app lags.", "The app freezes."],
+    ["THE APP LAGS.", "The app lags."],
+    ["Increase animation speed.", "Increase animation speed."],
+  ])("rejects iteration evidence not proven by the raw Request: %s", (request, evidence) => {
+    const worklog = createPerformanceIterationWorklogFixture({
+      evidence,
+      request,
+    });
+
+    expect(getAgentWorklogValidationErrors(worklog)).not.toEqual([]);
+  });
+
+  it("accepts exact ambiguous Request evidence under agent semantic judgment", () => {
+    const worklog = createPerformanceIterationWorklogFixture({
+      request: "The controls feel sticky.",
+    });
+
+    expect(getAgentWorklogValidationErrors(worklog)).toEqual([]);
+  });
+
+  it("does not force an ambiguous Request out of ordinary agent judgment", () => {
+    const worklog = createAgentWorklogFixture({
+      trailFields: { Request: "The controls feel sticky." },
+    });
+
+    expect(getAgentWorklogValidationErrors(worklog)).toEqual([]);
+  });
+
+  it.each([
+    "The app is not slow or unresponsive.",
+    "The app isn’t slow or unresponsive.",
+    "The app does not lag and does not freeze.",
+    "No lag and no freezing.",
+    "Приложение не тормозит и не зависает.",
+    "Нет лагов и нет зависаний.",
+  ])("keeps coordinated performance negation ordinary: %s", (request) => {
+    expect(
+      getAgentWorklogValidationErrors(
+        createAgentWorklogFixture({ trailFields: { Request: request } }),
+      ),
+    ).toEqual([]);
+  });
+
+  it.each([
+    "The app does not lag but it freezes.",
+    "The app is not slow, but the editor hangs.",
+    "Приложение не тормозит, но редактор зависает.",
+  ])("requires performance intent for an independent complaint: %s", (request) => {
+    expect(
+      getAgentWorklogValidationErrors(
+        createAgentWorklogFixture({ trailFields: { Request: request } }),
+      ),
+    ).toContain(clearPerformanceSignalError);
+  });
+
+  it("maps clear semantic performance requests to one performance iteration", () => {
+    const signals = [
+      "Improve application performance under normal use.",
+      "Optimize performance and fix the performance regression.",
+      "Speed up rendering because the preview is slow.",
+      "Reduce input latency and delayed control updates.",
+      "The app is laggy, janky, and stutters.",
+      "Fix low FPS and unstable frame rate.",
+      "Reduce high CPU, GPU, memory, and resource use.",
+      "Исправить проблемы с перфом и производительностью приложения.",
+      "Оптимизировать и ускорить медленный рендер.",
+      "Уменьшить задержку и улучшить отклик интерфейса.",
+      "Приложение лагает, тормозит, фризит и зависает.",
+    ];
+
+    for (const signal of signals) {
+      expect(
+        getAgentWorklogValidationErrors(
+          createAgentWorklogFixture({ trailFields: { Request: signal } }),
+        ),
+        `ordinary intent should reject: ${signal}`,
+      ).toContain(clearPerformanceSignalError);
+      expect(
+        getAgentWorklogValidationErrors(
+          createPerformanceIterationWorklogFixture({ request: signal }),
+        ),
+        `performance iteration should accept: ${signal}`,
+      ).toEqual([]);
+    }
+  });
+
+  it("keeps non-performance uses of similar words ordinary", () => {
+    const requests = [
+      "Rename the preset to Frozen and the mode to Performance.",
+      "Make the animation play faster and add a Slow timing option.",
+      "Increase animation speed.",
+      "Smooth the gradient and optimize its color-stop distribution.",
+      "Add CPU, GPU, and Memory labels to the hardware legend.",
+      "Назвать пресеты Быстрый, Медленный и Фриз.",
+    ];
+
+    for (const request of requests) {
+      expect(
+        getAgentWorklogValidationErrors(
+          createAgentWorklogFixture({ trailFields: { Request: request } }),
+        ),
+      ).toEqual([]);
+    }
+  });
+
+  it.each([
+    ["request evidence", '- Performance request evidence: "Build a poster."'],
+    ["performance paths", `- Performance paths: ${JSON.stringify([fixturePerformancePathId])}`],
+  ])("rejects ordinary intent carrying %s authority", (_case, field) => {
+    const worklog = createAgentWorklogFixture().replace(
+      "- Performance intent: ordinary-product-work",
+      `- Performance intent: ordinary-product-work\n${field}`,
+    );
+
+    expect(getAgentWorklogValidationErrors(worklog)).toContain(
+      'agent-worklog.md Decision Trail iteration "Delivery 1 - Product build" ordinary-product-work cannot carry performance request authority.',
+    );
+  });
+
+  it("rejects duplicate Request fields before classification", () => {
+    const worklog = createPerformanceIterationWorklogFixture({
+      request: "The app lags while dragging.",
+    }).replace(
+      "- Request: The app lags while dragging.",
+      "- Request: The app lags while dragging.\n- Request: A conflicting request.",
+    );
+
+    expect(getAgentWorklogValidationErrors(worklog)).toContain(
+      'agent-worklog.md Decision Trail iteration "Delivery 1 - Product build" must include exactly one "Request:" before performance authority can be evaluated.',
+    );
+  });
+});

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

@@ -2,6 +2,18 @@ import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
+import {
+  getDecisionTrailVerificationErrors,
+  getPerformanceIntentErrors,
+} from "./starter-acceptance.worklog-performance-intent-test-utils";
+import {
+  getToolcraftMarkdownSectionBodies,
+  parseToolcraftDecisionTrail,
+} from "../../scripts/toolcraft-worklog-decision-trail.mjs";
+import {
+  TOOLCRAFT_DELIVERY_VERIFICATION_COMMAND,
+} from "../../scripts/toolcraft-performance-authority-policy.mjs";
+
 const appDir = dirname(fileURLToPath(import.meta.url));
 const projectDir = join(appDir, "../..");
 
@@ -9,6 +21,8 @@ export const agentWorklogPath = join(projectDir, "docs/toolcraft/agent-worklog.m
 
 const requiredAgentWorklogDecisionSections = [
   "Renderer",
+  "View Interaction",
+  "Interaction Ownership",
   "Timeline",
   "Layers",
   "Controls",
@@ -24,6 +38,25 @@ const requiredAgentWorklogSections = [
   "Verification",
   "Risks",
 ] as const;
+const agentWorklogDecisionTrailFieldOrder = [
+  "Request",
+  "Task type",
+  "User-visible result",
+  "Source/reference checked",
+  "Reference inputs",
+  "Docs/contracts read",
+  "Contract rules applied",
+  "View interaction intent",
+  "Interaction ownership",
+  "Decision",
+  "Alternatives rejected",
+  "State/output mapping",
+  "Performance intent",
+  "Performance request evidence",
+  "Performance paths",
+  "Verification",
+  "Risks",
+] as const;
 const requiredAgentWorklogDecisionTrailFields = [
   "Request",
   "Task type",
@@ -32,16 +65,17 @@ const requiredAgentWorklogDecisionTrailFields = [
   "Reference inputs",
   "Docs/contracts read",
   "Contract rules applied",
+  "View interaction intent",
+  "Interaction ownership",
   "Decision",
   "Alternatives rejected",
   "State/output mapping",
-  "Files changed",
+  "Performance intent",
   "Verification",
-  "Skipped checks",
   "Risks",
 ] as const;
 type WorklogDecisionSection = (typeof requiredAgentWorklogDecisionSections)[number];
-type WorklogDecisionTrailField = (typeof requiredAgentWorklogDecisionTrailFields)[number];
+type WorklogDecisionTrailField = (typeof agentWorklogDecisionTrailFieldOrder)[number];
 type WorklogDecisionEvidence = {
   decision: string;
   evidence: string;
@@ -62,13 +96,6 @@ const worklogVideoReferencePattern =
   /\b(?:source\/reference checked|source reviewed|reference inputs):[^\n]*(?:reference\s+(?:video|gif)|screen\s*recording|contact[-\s]*sheet|storyboard|frame[-\s]*by[-\s]*frame|extracted[-\s]*frames?|cleanshot|ffprobe|[^\s]+\.(?:mp4|mov|webm|gif))\b/i;
 const worklogVideoReferenceStudyPattern =
   /\b(video reference study|storyboard|frame[-\s]*by[-\s]*frame|transition analysis|frame[-\s]*to[-\s]*frame|contact[-\s]*sheet|extracted frames?)\b/i;
-const incompleteRequiredCheckPattern =
-  /\b(?:fail(?:ed|s|ing)?|not complete|not completed|incomplete|pending|blocked|planned|todo|to do|to run|will run|not run|not started|not yet|queued)\b/i;
-const requiredCheckNamePattern =
-  /\b(?:(?:pnpm\s+)?(?:verify:final|verify:perf|test:browser:perf|test:browser|verify:quick|test|build)|browser performance checkpoint|agent-browser|playwright-fallback)\b/i;
-const browserPerformanceCheckpointPattern =
-  /\b(?:browser performance checkpoint|performance checkpoint|verify:perf|test:browser:perf|playwright-fallback)\b/i;
-
 export function readToolcraftDoc(relativePath: string): string {
   return readFileSync(join(projectDir, "docs/toolcraft", relativePath), "utf8");
 }
@@ -90,15 +117,26 @@ const defaultDecisionEvidence: Record<WorklogDecisionSection, WorklogDecisionEvi
     reason: "The product edits one output.",
   },
   Performance: {
-    decision: "Record browser performance coverage.",
-    evidence: "pnpm verify:perf automated Playwright checkpoint.",
-    reason: "First working product delivery must prove performance.",
+    decision: "Use lifecycle-aware protected delivery verification.",
+    evidence: `${TOOLCRAFT_DELIVERY_VERIFICATION_COMMAND} protected receipt.`,
+    reason:
+      "The runner chooses complete initial functional proof, exact ownership-derived later functional proof, or one request-backed targeted performance iteration; full certification remains operator-only.",
   },
   Renderer: {
     decision: "Use SVG renderer.",
     evidence: "src/app/product-renderer.tsx.",
     reason: "The product output is vector-native.",
   },
+  "View Interaction": {
+    decision: "Use non-spatial view interaction.",
+    evidence: "appProductReadiness.viewInteraction.",
+    reason: "The product has no visible three-dimensional scene or model.",
+  },
+  "Interaction Ownership": {
+    decision: "Keep each user operation on one evidence-backed primary surface.",
+    evidence: "appProductReadiness.interactionOwnership.",
+    reason: "Canvas and panel interactions remain complementary instead of mirrored.",
+  },
   Timeline: {
     decision: "Do not enable timeline.",
     evidence: "appSchema.panels.timeline is omitted.",
@@ -106,21 +144,25 @@ const defaultDecisionEvidence: Record<WorklogDecisionSection, WorklogDecisionEvi
   },
 };
 
-const defaultDecisionTrailFields: Record<WorklogDecisionTrailField, string> = {
+const defaultDecisionTrailFields: Partial<
+  Record<WorklogDecisionTrailField, string>
+> = {
   "Alternatives rejected": "Canvas output because vector output must stay crisp.",
   "Contract rules applied": "runtime-shell-required and output-export-required.",
   Decision: "Use SVG renderer with Toolcraft controls.",
   "Docs/contracts read": "workflow.md, assembly-workflow.md, and performance.md.",
-  "Files changed": "src/app/app-schema.ts, src/app/product-renderer.tsx, src/app/app-performance.ts.",
+  "Performance intent": "ordinary-product-work",
   "Reference inputs": "None.",
   Request: "Build a still vector poster app.",
   Risks: "None; browser and performance gates cover the touched surfaces.",
-  "Skipped checks": "None.",
   "Source/reference checked": "User prompt.",
   "State/output mapping": "Schema values feed product-renderer.tsx and export uses runtime state.",
   "Task type": "Schema, renderer, export, acceptance, and performance.",
   "User-visible result": "The canvas renders the poster and exports PNG.",
-  Verification: "pnpm verify:quick; pnpm verify:perf.",
+  Verification: `${TOOLCRAFT_DELIVERY_VERIFICATION_COMMAND}.`,
+  "View interaction intent": "non-spatial; the product has no visible three-dimensional scene or model.",
+  "Interaction ownership":
+    "No cross-surface product operations; panel controls own their distinct property edits.",
 };
 
 function renderDecisionSection(
@@ -151,10 +193,9 @@ export function createAgentWorklogFixture({
   omitDecisionTrailFields = [],
   risksLines = ["- None: no known risk."],
   trailFields = {},
-  trailHeading = "Iteration 1 - Product build",
+  trailHeading = "Delivery 1 - Product build",
   verificationLines = [
-    "- Run: pnpm verify:quick",
-    "- Run: pnpm verify:perf",
+    "Protected receipts own commands, selectors, measurements, and pass/fail evidence.",
   ],
 }: AgentWorklogFixtureOptions = {}): string {
   const omittedFields = new Set<WorklogDecisionTrailField>(omitDecisionTrailFields);
@@ -162,9 +203,12 @@ export function createAgentWorklogFixture({
     ...defaultDecisionTrailFields,
     ...trailFields,
   };
-  const decisionTrailLines = requiredAgentWorklogDecisionTrailFields
+  const decisionTrailLines = agentWorklogDecisionTrailFieldOrder
     .filter((field) => !omittedFields.has(field))
-    .map((field) => `- ${field}: ${resolvedTrailFields[field]}`);
+    .flatMap((field) => {
+      const value = resolvedTrailFields[field];
+      return value === undefined ? [] : [`- ${field}: ${value}`];
+    });
 
   return [
     "# Implementation Worklog",
@@ -200,149 +244,14 @@ export function createAgentWorklogFixture({
   ].join("\n");
 }
 
-function getMarkdownHeadingLevel(line: string): number | null {
-  const match = /^(#{1,6})\s+\S/.exec(line.trim());
-
-  return match ? match[1].length : null;
-}
-
 function getMarkdownSectionBody(source: string, heading: string): string {
-  const lines = source.split(/\r?\n/);
-  const headingPattern = new RegExp(`^(#{1,6})\\s+${escapeRegExp(heading)}\\s*$`, "i");
-  const startIndex = lines.findIndex((line) => headingPattern.test(line.trim()));
-
-  if (startIndex < 0) {
-    return "";
-  }
-
-  const startLevel = getMarkdownHeadingLevel(lines[startIndex]);
-  const bodyLines: string[] = [];
-
-  for (let index = startIndex + 1; index < lines.length; index += 1) {
-    const nextLevel = getMarkdownHeadingLevel(lines[index]);
-
-    if (startLevel !== null && nextLevel !== null && nextLevel <= startLevel) {
-      break;
-    }
-
-    bodyLines.push(lines[index]);
-  }
-
-  return bodyLines.join("\n").trim();
-}
-
-function getAgentWorklogDecisionTrailIterations(
-  decisionTrailBody: string,
-): Array<{ body: string; heading: string }> {
-  const iterations: Array<{ body: string; heading: string }> = [];
-  let currentHeading = "";
-  let currentBody: string[] = [];
-
-  for (const line of decisionTrailBody.split(/\r?\n/)) {
-    const headingMatch = /^###\s+(.+?)\s*$/.exec(line.trim());
-
-    if (headingMatch) {
-      if (currentHeading) {
-        iterations.push({ body: currentBody.join("\n").trim(), heading: currentHeading });
-      }
-
-      currentHeading = headingMatch[1];
-      currentBody = [];
-      continue;
-    }
-
-    if (currentHeading) {
-      currentBody.push(line);
-    }
-  }
-
-  if (currentHeading) {
-    iterations.push({ body: currentBody.join("\n").trim(), heading: currentHeading });
-  }
-
-  return iterations;
+  return getToolcraftMarkdownSectionBodies(source, heading)[0] ?? "";
 }
 
 function escapeRegExp(value: string): string {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
-function getWorklogLines(source: string): string[] {
-  return source
-    .split(/\r?\n/)
-    .map((line) => line.trim())
-    .filter(Boolean);
-}
-
-export function isAllowedPerfSkipLine(line: string): boolean {
-  return (
-    browserPerformanceCheckpointPattern.test(line) &&
-    /\bnot required\b/i.test(line) &&
-    /\b(?:post-first|after first|not first|feature loop|non-performance)\b/i.test(line)
-  );
-}
-
-function isIncompleteOrSkippedLine(line: string): boolean {
-  return (
-    /\b(?:skip|skipped|not required)\b/i.test(line) ||
-    incompleteRequiredCheckPattern.test(line)
-  );
-}
-
-function isVerificationEvidenceLine(line: string): boolean {
-  return /\b(?:Run|Verification|Browser):/i.test(line);
-}
-
-export function isPassedPlaywrightFallbackPerfRunLine(line: string): boolean {
-  return (
-    isVerificationEvidenceLine(line) &&
-    (/\bpnpm\s+verify:perf\b/i.test(line) ||
-      (/\bplaywright-fallback\b/i.test(line) &&
-        /\b(?:performance|perf|checkpoint)\b/i.test(line))) &&
-    !isIncompleteOrSkippedLine(line)
-  );
-}
-
-function getAgentWorklogVerificationGateErrors(source: string): string[] {
-  const lines = getWorklogLines(source);
-  const errors: string[] = [];
-  const hasPassedPlaywrightFallbackPerfRun = lines.some(
-    isPassedPlaywrightFallbackPerfRunLine,
-  );
-  const hasPassedPerfRun = hasPassedPlaywrightFallbackPerfRun;
-  const hasAllowedPerfSkip = lines.some(isAllowedPerfSkipLine);
-  const failedRequiredCheckLine = lines.find(
-    (line) => requiredCheckNamePattern.test(line) && incompleteRequiredCheckPattern.test(line),
-  );
-  const skippedRequiredCheckLine = lines.find(
-    (line) =>
-      /^-?\s*(?:Skipped checks|Skip):/i.test(line) &&
-      requiredCheckNamePattern.test(line) &&
-      !/\bnone\b/i.test(line) &&
-      !isAllowedPerfSkipLine(line),
-  );
-
-  if (failedRequiredCheckLine) {
-    errors.push(
-      "agent-worklog.md required checks must be passed before final delivery; do not report failed, incomplete, pending, or blocked verification.",
-    );
-  }
-
-  if (skippedRequiredCheckLine) {
-    errors.push(
-      "agent-worklog.md must not list required checks as skipped unless they are explicitly not required for a post-first-working non-performance edit.",
-    );
-  }
-
-  if (!hasPassedPerfRun && !hasAllowedPerfSkip) {
-    errors.push(
-      "agent-worklog.md Verification must record `pnpm verify:perf` as the automated Playwright performance checkpoint for first working product delivery.",
-    );
-  }
-
-  return errors;
-}
-
 export function getAgentWorklogValidationErrors(source: string): string[] {
   const errors: string[] = [];
 
@@ -378,15 +287,13 @@ export function getAgentWorklogValidationErrors(source: string): string[] {
     }
   }
 
-  const decisionTrailBody = getMarkdownSectionBody(source, "Decision Trail");
-  const decisionTrailIterations = getAgentWorklogDecisionTrailIterations(decisionTrailBody);
+  const decisionTrail = parseToolcraftDecisionTrail(source);
+  errors.push(...decisionTrail.errors);
 
-  if (decisionTrailIterations.length === 0) {
-    errors.push("agent-worklog.md Decision Trail must include at least one iteration heading.");
-  }
-
-  for (const iteration of decisionTrailIterations) {
+  for (const iteration of decisionTrail.iterations) {
     for (const field of requiredAgentWorklogDecisionTrailFields) {
+      if (field === "Performance intent") continue;
+
       const fieldPattern = new RegExp(`\\b${escapeRegExp(field)}:\\s*\\S`, "i");
 
       if (!fieldPattern.test(iteration.body)) {
@@ -395,10 +302,12 @@ export function getAgentWorklogValidationErrors(source: string): string[] {
         );
       }
     }
+
+    errors.push(...getDecisionTrailVerificationErrors(iteration));
+    errors.push(...getPerformanceIntentErrors(iteration));
   }
 
   const evidenceBody = getMarkdownSectionBody(source, "Evidence");
-  const verificationBody = getMarkdownSectionBody(source, "Verification");
   const risksBody = getMarkdownSectionBody(source, "Risks");
 
   if (!/\b(Source reviewed|Contract applied|Evidence):\s*\S/i.test(evidenceBody)) {
@@ -414,15 +323,9 @@ export function getAgentWorklogValidationErrors(source: string): string[] {
     );
   }
 
-  if (!/\bpnpm\s+(verify|test|build|typecheck)|browser|Playwright|perf/i.test(verificationBody)) {
-    errors.push("agent-worklog.md Verification must list concrete test/build/browser/performance checks.");
-  }
-
-  errors.push(...getAgentWorklogVerificationGateErrors(source));
-
   if (!/\b(Risk|None):\s*\S/i.test(risksBody)) {
     errors.push('agent-worklog.md Risks must include either "Risk:" entries or "None:" with a reason.');
   }
 
-  return errors;
+  return [...new Set(errors)];
 }