@pixel-point/toolcraft 0.0.15 → 0.0.17

package/templates/runtime/contracts/decision-contracts.test.ts

@@ -10,6 +10,7 @@ import {
   getToolcraftDecisionRulesByArea,
   TOOLCRAFT_DECISION_CONTRACT,
 } from "./decision-contracts";
+import { TOOLCRAFT_PERFORMANCE_VERIFICATION_POLICY_TEXT } from "./performance-verification-policy";
 
 const contractsDir = dirname(fileURLToPath(import.meta.url));
 const repoRoot = resolve(contractsDir, "../../../..");
@@ -48,6 +49,19 @@ describe("Toolcraft template decision contract", () => {
     expect(rule?.currentConstraint).toMatch(/uploaded\/imported source-material flows/i);
   });
 
+  it("requires infinite canvas exports to use canonical scene bounds", () => {
+    const rule = getToolcraftDecisionRule("infinity-canvas-scene-bounds");
+
+    expect(rule?.level).toBe("invariant");
+    expect(rule?.desiredBehavior).toMatch(/sceneBoundsProvider/i);
+    expect(rule?.desiredBehavior).toMatch(/one exact state/i);
+    expect(rule?.desiredBehavior).toMatch(/runtime-owned timestamp schedule/i);
+    expect(rule?.desiredBehavior).toMatch(/finite canvas size/i);
+    expect(rule?.enforcement).toContain("acceptance-validator");
+    expect(rule?.enforcement).toContain("browser-helper");
+    expect(rule?.enforcement).toContain("runtime");
+  });
+
   it("keeps runtime shell bypass prevention in validators, not only docs", () => {
     const rule = getToolcraftDecisionRule("runtime-shell-required");
 
@@ -110,6 +124,44 @@ describe("Toolcraft template decision contract", () => {
     expect(rule?.enforcement).toContain("performance-validator");
   });
 
+  it("requires typed spatial view intent before renderer implementation", () => {
+    const rule = getToolcraftDecisionRule("renderer-view-interaction");
+
+    expect(rule?.level).toBe("invariant");
+    expect(rule?.desiredBehavior).toMatch(/typed viewInteraction intent/i);
+    expect(rule?.desiredBehavior).toMatch(/defaults to orbit/i);
+    expect(rule?.desiredBehavior).toMatch(/explicit user request or inspected reference/i);
+    expect(rule?.enforcement).toContain("acceptance-validator");
+  });
+
+  it("keeps model appearance and presentation runtime-owned", () => {
+    const rule = getToolcraftDecisionRule("model-appearance-presentation");
+
+    expect(rule?.level).toBe("invariant");
+    expect(rule?.desiredBehavior).toMatch(/standalone files, folders, and bounded ZIP/i);
+    expect(rule?.desiredBehavior).toMatch(/first normalized root deterministically/i);
+    expect(rule?.desiredBehavior).toMatch(/fallback material only when authored appearance is absent/i);
+    expect(rule?.desiredBehavior).toMatch(/original source package remains durable and immutable/i);
+    expect(rule?.desiredBehavior).toMatch(/modelPresentation: runtime/i);
+    expect(rule?.desiredBehavior).toMatch(/checked consumer/i);
+    expect(rule?.desiredBehavior).toMatch(/renderDefaultCanvasMedia controls generic image\/file/i);
+    expect(rule?.desiredBehavior).toMatch(/orientationGizmo/i);
+    expect(rule?.enforcement).toContain("runtime");
+    expect(rule?.enforcement).toContain("cli-integrity-check");
+  });
+
+  it("requires one evidence-backed surface owner per user operation", () => {
+    const rule = getToolcraftDecisionRule("interaction-surface-ownership");
+
+    expect(rule?.level).toBe("invariant");
+    expect(rule?.desiredBehavior).toMatch(/typed interactionOwnership/i);
+    expect(rule?.desiredBehavior).toMatch(/user request, inspected reference/i);
+    expect(rule?.desiredBehavior).toMatch(/product usability/i);
+    expect(rule?.desiredBehavior).toMatch(/complementary operations/i);
+    expect(rule?.desiredBehavior).toMatch(/cannot be mirrored/i);
+    expect(rule?.enforcement).toContain("acceptance-validator");
+  });
+
   it("requires reference clone functionality to be inventoried and acceptance-backed", () => {
     const rule = getToolcraftDecisionRule("reference-clone-source-of-truth");
 
@@ -148,21 +200,85 @@ describe("Toolcraft template decision contract", () => {
     expect(rule?.desiredBehavior).toMatch(/responsiveness/i);
     expect(rule?.desiredBehavior).toMatch(/canvas drag, pan, pinch, zoom, and radar\/center/i);
     expect(rule?.desiredBehavior).toMatch(/playback state/i);
-    expect(rule?.desiredBehavior).toMatch(/first working version/i);
-    expect(rule?.desiredBehavior).toMatch(/agent's controlled browser/i);
-    expect(rule?.desiredBehavior).toMatch(/Playwright is only the fallback runner/i);
-    expect(rule?.desiredBehavior).toMatch(/optimize performance/i);
-    expect(rule?.desiredBehavior).toMatch(/otherwise complains about performance/i);
-    expect(rule?.desiredBehavior).toMatch(/targeted functional\/browser checks/i);
-    expect(rule?.desiredBehavior).toMatch(/touched workload\/viewport\/export paths/i);
-    expect(rule?.desiredBehavior).toMatch(/full performance checkpoint/i);
+    expect(rule?.desiredBehavior).toContain(
+      TOOLCRAFT_PERFORMANCE_VERIFICATION_POLICY_TEXT,
+    );
+    expect(rule?.desiredBehavior).toMatch(
+      /functional delivery plan with basis "initial"[\s\S]*complete functional proof[\s\S]*no measured performance/i,
+    );
+    expect(rule?.desiredBehavior).toMatch(
+      /functional delivery plan with basis "changed"[\s\S]*exact affected ownership-derived functional proof[\s\S]*no measured performance/i,
+    );
+    expect(rule?.desiredBehavior).toMatch(/development fixture/i);
+    expect(rule?.desiredBehavior).toMatch(
+      /complete performance matrix[\s\S]*never launch it automatically/i,
+    );
+    expect(rule?.desiredBehavior).toMatch(
+      /cannot claim targeted or full performance evidence/i,
+    );
+    expect(rule?.desiredBehavior).toMatch(/verify:delivery/);
+    expect(rule?.desiredBehavior).toMatch(/coherent user-visible delivery batch/i);
+    expect(rule?.desiredBehavior).toMatch(
+      /tier, filename, subsystem, complaint repetition, and command selectors cannot authorize proof/i,
+    );
+    expect(rule?.desiredBehavior).toMatch(/ordinary-product-work/i);
+    expect(rule?.desiredBehavior).toMatch(
+      /cannot silently invoke targeted performance, the full performance matrix/i,
+    );
+    expect(rule?.desiredBehavior).toMatch(/performance-iteration/i);
+    expect(rule?.desiredBehavior).toMatch(/bounded targeted iteration/i);
+    expect(rule?.desiredBehavior).toMatch(
+      /only a localized complaint or a post-clarification targeted choice creates performance-iteration intent and one bounded iteration over exact canonical affected paths/iu,
+    );
+    expect(rule?.desiredBehavior).toMatch(
+      /classifier output establishes complaint authority only and never path localization/iu,
+    );
+    expect(rule?.desiredBehavior).toMatch(
+      /regardless of whether the classifier returned high-confidence performance-iteration or needs-agent-judgment, unresolved localization creates neither performance-iteration intent nor canonical path authority/iu,
+    );
+    expect(rule?.desiredBehavior).not.toMatch(
+      /one complaint maps to one exact authority-selected targeted performance iteration/iu,
+    );
+    expect(rule?.desiredBehavior).not.toMatch(
+      /direct and repeated performance complaints each start one bounded targeted iteration/iu,
+    );
+    expect(rule?.desiredBehavior).toMatch(
+      /localized complaint[\s\S]*without asking the user/iu,
+    );
+    expect(rule?.desiredBehavior).toMatch(
+      /ambiguous or unresolved localization[\s\S]*one user-facing clarification[\s\S]*targeted diagnosis or a complete review/iu,
+    );
+    expect(rule?.desiredBehavior).toMatch(
+      /repetition alone never expands scope or selects the complete performance matrix/i,
+    );
+    expect(rule?.desiredBehavior).toMatch(
+      /explicit natural-language request for the complete audit/i,
+    );
+    expect(rule?.desiredBehavior).toMatch(/user does not need to know the command name/i);
+    expect(rule?.desiredBehavior).toMatch(/targeted functional\/browser evidence/i);
+    expect(rule?.desiredBehavior).toMatch(
+      /those changes never authorize measured performance/i,
+    );
+    expect(rule?.desiredBehavior).toMatch(
+      /renderScaleCoverage "selected-backing-pixels" for interaction and steady, plus playback when timeline is enabled/i,
+    );
+    expect(rule?.desiredBehavior).toMatch(
+      /every measured path[\s\S]*devicePixelRatio × 2[\s\S]*each measured phase/iu,
+    );
+    expect(rule?.desiredBehavior).toMatch(
+      /never downsample[\s\S]*clamp the selected render scale to pass a performance budget/i,
+    );
+    expect(rule?.desiredBehavior).toMatch(/durable baseline/i);
   });
 
-  it("requires persistence reload coverage when localStorage is enabled", () => {
+  it("requires default local persistence with exact reload coverage", () => {
     const rule = getToolcraftDecisionRule("persistence-policy-explicit");
 
-    expect(rule?.desiredBehavior).toMatch(/localStorage persistence/i);
-    expect(rule?.desiredBehavior).toMatch(/reloading the page/i);
+    expect(rule?.desiredBehavior).toMatch(/enabled by default/i);
+    expect(rule?.desiredBehavior).toMatch(/storage none.*recorded reason/i);
+    expect(rule?.desiredBehavior).toMatch(/binary repository.*IndexedDB/i);
+    expect(rule?.desiredBehavior).toMatch(/every resolved slice/i);
+    expect(rule?.desiredBehavior).toMatch(/reloads the page/i);
     expect(rule?.desiredBehavior).toMatch(/settings import\/export is not a substitute/i);
     expect(rule?.enforcement).toContain("acceptance-validator");
     expect(rule?.enforcement).toContain("browser-helper");

package/templates/runtime/contracts/decision-contracts.ts

@@ -1,3 +1,5 @@
+import { TOOLCRAFT_PERFORMANCE_VERIFICATION_POLICY_TEXT } from "./performance-verification-policy";
+
 export type ToolcraftDecisionArea =
   | "acceptance"
   | "canvas"
@@ -56,7 +58,7 @@ export const TOOLCRAFT_DECISION_CONTRACT = [
     area: "runtime-shell",
     currentConstraint: "Apps must assemble through defineToolcraft and ToolcraftApp.",
     desiredBehavior:
-      "Generated apps use the Toolcraft runtime shell and keep product-specific rendering inside supported extension points: schema controls, canvasContent product output, controlRenderers for true custom controls, ToolcraftApp onPanelAction, and runtime commands. App-specific code must not import or render low-level runtime surfaces or built-in control components directly.",
+      "Generated apps use the Toolcraft runtime shell and keep product-specific rendering inside supported extension points: schema controls, canvasContent product output, controlRenderers for true custom controls, one shared ToolcraftAppComposition.exportRenderer for typed image/video actions, ToolcraftApp onPanelAction for non-export product actions, and runtime commands. App-specific code must not import or render low-level runtime surfaces or built-in control components directly, instantiate encoders, or own artifact download mechanics.",
     enforcement: [
       "cli-integrity-check",
       "acceptance-validator",
@@ -85,13 +87,31 @@ export const TOOLCRAFT_DECISION_CONTRACT = [
     currentConstraint:
       "The Toolcraft canvas shell owns the visible workspace backing behind product output.",
     desiredBehavior:
-      "Generated apps preserve the runtime canvas surface and do not replace, hide, or make the shell backing transparent when product renderers customize their own background.",
+      "Generated apps preserve the runtime canvas surface and do not replace or hide it when product renderers customize their own background. In infinite mode the shell fills the complete viewport with the selected standard Background color, while bounded product background pixels remain suppressed.",
     enforcement: ["browser-helper", "starter-agents", "spec-checklist"],
     id: "canvas-surface-preserved",
     level: "invariant",
     title: "Canvas backing stays runtime-owned",
     verdict: "move-to-validator",
   },
+  {
+    area: "canvas",
+    currentConstraint:
+      "Editable output can switch from a finite artboard to an unbounded workspace, but product renderers and export actions still need one canonical world-space frame contract.",
+    desiredBehavior:
+      "Editable-output apps expose one runtime-owned Infinity canvas mode. Enabling it removes finite artboard clipping and size controls while preserving the dormant finite canvas size for exact restoration. When the standard Background pair exists, its selected color fills the complete infinite viewport and Background off atomically resolves finite mode and disables Infinity. Runtime image and model assets retain explicit world-space frames. ToolcraftAppComposition.sceneBoundsProvider supplies product-renderer bounds for one exact state through one direct composition boundary; image export resolves the current frame and video export unions every state from the runtime-owned timestamp schedule. Hidden layers, suppressed default consumers, and editor-only UI do not expand output bounds. Finite mode continues to export the full finite canvas size, while empty, unavailable, and unsafe oversized infinite exports return typed visible failures.",
+    enforcement: [
+      "acceptance-validator",
+      "browser-helper",
+      "docs",
+      "runtime",
+      "starter-agents",
+    ],
+    id: "infinity-canvas-scene-bounds",
+    level: "invariant",
+    title: "Infinity canvas uses canonical scene bounds",
+    verdict: "keep-hard",
+  },
   {
     area: "canvas",
     currentConstraint:
@@ -104,6 +124,23 @@ export const TOOLCRAFT_DECISION_CONTRACT = [
     title: "Canvas handle placement is product-dependent",
     verdict: "keep-but-clarify",
   },
+  {
+    area: "controls",
+    currentConstraint:
+      "Panel controls and canvas editing handles are validated independently, so the same user operation can be recreated on both surfaces.",
+    desiredBehavior:
+      "Every operation that can plausibly live on canvas or in the panel declares typed interactionOwnership before implementation. User request, inspected reference, or product usability selects one primary surface. Related state may expose complementary operations on the other surface, but the same target and operation capability cannot be mirrored across canvas and panel.",
+    enforcement: [
+      "acceptance-validator",
+      "docs",
+      "starter-agents",
+      "spec-checklist",
+    ],
+    id: "interaction-surface-ownership",
+    level: "invariant",
+    title: "Each user operation has one primary interaction surface",
+    verdict: "move-to-validator",
+  },
   {
     area: "panels",
     currentConstraint: "PanelHost owns drag, snap, and double-click reset behavior.",
@@ -180,7 +217,7 @@ export const TOOLCRAFT_DECISION_CONTRACT = [
     currentConstraint:
       "Product-output apps expose final output delivery through sticky footer panelActions.",
     desiredBehavior:
-      'Static products include Export PNG plus an "Image Export" section for format and 2K/4K/8K resolution; animated products include Export Video and Export PNG plus "Video Export" settings. Copy can be secondary, but it does not replace export. Product apps expose a required "Background" section directly before export settings, with a Switch labeled "Include" and a background color control with label false in one equal-width row. Standard helpers own runtime PNG transparency, live preview product-background visibility, and selected image dimensions or retina fallback, while Toolcraft canvas backing and video keep the background.',
+      'Product apps include Export PNG plus an "Image Export" section for format and 2K/4K/8K resolution. Apps whose requested delivery includes animation also include Export Video plus "Video Export" settings; a playback or keyframe timeline may exist for interactive preview without inventing video delivery. Copy can be secondary, but it does not replace export. Product apps declare the standard background pair and runtime places it in Setup: Background beside Infinity canvas, Color below, and Timeline last. One shared product exportRenderer draws deterministic scene-coordinate frames; runtime owns settings, scene crop, PNG/JPEG/video background semantics, visible runtime media/model composition, exact timestamped encoding, download, progress, and typed failures.',
     enforcement: ["acceptance-validator", "performance-validator", "browser-helper", "starter-agents"],
     id: "output-export-required",
     level: "invariant",
@@ -235,6 +272,43 @@ export const TOOLCRAFT_DECISION_CONTRACT = [
     title: "Renderer technique is a typed decision",
     verdict: "keep-but-clarify",
   },
+  {
+    area: "renderer",
+    currentConstraint:
+      "A spatial scene can omit orientationGizmo by silently choosing a fixed camera before the existing rotatable-model rule applies.",
+    desiredBehavior:
+      "Every generated product declares typed viewInteraction intent before controls or renderer code. A visible editable three-dimensional scene defaults to orbit and requires matching orientationGizmo targets. Fixed or timeline-owned cameras are evidence-backed escape hatches allowed only when an explicit user request or inspected reference owns that behavior.",
+    enforcement: [
+      "acceptance-validator",
+      "docs",
+      "starter-agents",
+      "spec-checklist",
+    ],
+    id: "renderer-view-interaction",
+    level: "invariant",
+    title: "Spatial view interaction is an explicit typed decision",
+    verdict: "move-to-validator",
+  },
+  {
+    area: "renderer",
+    currentConstraint:
+      "Model upload and presentation can be described as geometry-only, hidden through renderDefaultCanvasMedia, or reimplemented by a custom renderer without a checked presentation consumer.",
+    desiredBehavior:
+      "Runtime model import preserves the supported authored appearance subset from standalone files, folders, and bounded ZIP packages, chooses the first normalized root deterministically, and uses the Blender-compatible fallback material only when authored appearance is absent. The original source package remains durable and immutable; canonicalization is derived data, and geometry repair never becomes appearance repair. ToolcraftAppComposition declares modelPresentation: runtime owns standard preview/export by default, while custom mode suppresses only its declared model targets and requires one mounted checked consumer per target. renderDefaultCanvasMedia controls generic image/file preview only and never disables runtime model presentation. Preview, export, orientationGizmo, and direct model drag share one presentation document, appearance lease, and camera pose.",
+    enforcement: [
+      "acceptance-validator",
+      "browser-helper",
+      "cli-integrity-check",
+      "docs",
+      "performance-validator",
+      "runtime",
+      "starter-agents",
+    ],
+    id: "model-appearance-presentation",
+    level: "invariant",
+    title: "Model appearance and presentation stay runtime-owned",
+    verdict: "keep-hard",
+  },
   {
     area: "reference-clone",
     currentConstraint:
@@ -275,8 +349,11 @@ export const TOOLCRAFT_DECISION_CONTRACT = [
     area: "performance",
     currentConstraint:
       "Performance coverage currently asks every visible non-action control for a performance scenario.",
-    desiredBehavior:
-      "Heavy workload controls get min/default/max workload coverage; ordinary controls get lightweight responsiveness coverage so they cannot hang or break input. Animated previews suspend or coalesce non-essential animation work during canvas drag, pan, pinch, zoom, and radar/center interactions without changing user playback state. A full performance checkpoint is required only when the first working version of an app exists, or whenever the user explicitly asks to optimize performance, fix lag, remove jank, speed up animation, stabilize drag/zoom, or otherwise complains about performance. The checkpoint uses the current AI agent's controlled browser first; Playwright is only the fallback runner when no agent browser is available or in CI/non-agent automation. Renderer, canvas, animation, export, timeline, layers, canvas.renderScale, bug fixes, and performance-sensitive controls need targeted functional/browser checks first and targeted performance scenarios only for touched workload/viewport/export paths. Performance fixes must preserve the selected render scale and must not pass budgets by silently downsampling, stretching a lower-resolution backing canvas, blurring output, or clamping canvas.renderScale below the user's chosen value. Browser performance checks read budgets from typed performance config and run sequentially for stable measurements.",
+    desiredBehavior: [
+      "Heavy workload controls get min/default/max workload coverage; ordinary controls get lightweight responsiveness coverage so they cannot hang or break input. Animated previews suspend or coalesce non-essential animation work during canvas drag, pan, pinch, zoom, and radar/center interactions without changing user playback state.",
+      TOOLCRAFT_PERFORMANCE_VERIFICATION_POLICY_TEXT,
+      "Request-authorized browser performance checks read budgets from typed performance config and run sequentially for stable measurements.",
+    ].join(" "),
     enforcement: ["performance-validator", "browser-helper", "starter-agents"],
     id: "performance-coverage-levels",
     level: "invariant",
@@ -286,9 +363,9 @@ export const TOOLCRAFT_DECISION_CONTRACT = [
   {
     area: "persistence",
     currentConstraint:
-      "Persistence policy must be deliberate; generated apps should not write runtime state to localStorage directly.",
+      "Generated apps persist runtime workspace state by default; product code must not write localStorage or IndexedDB directly.",
     desiredBehavior:
-      "AI states whether persistence exists, what is persisted, and how reset, import, clear, and new media affect stored state. Apps with localStorage persistence must include browser acceptance for changing a user setting, reloading the page, and observing the restored value or product output; settings import/export is not a substitute for persistence.",
+      "Local persistence is enabled by default for values, canvas, and panels; enabled timeline, layers, and media join the resolved plan. The only opt-out is persistence.storage none with a recorded reason. localStorage stores small versioned JSON metadata while the Toolcraft binary repository stores media bytes in IndexedDB. Reload acceptance declares every resolved slice, uses persistence-state evidence, changes real user state, reloads the page, and observes the restored workspace or product output; settings import/export is not a substitute for persistence.",
     enforcement: ["starter-agents", "spec-checklist", "acceptance-validator", "browser-helper"],
     id: "persistence-policy-explicit",
     level: "default",

package/templates/runtime/contracts/index.ts

@@ -1,3 +1,5 @@
 export * from "./component-contracts";
 export * from "./decision-contracts";
+export * from "./performance-verification-policy";
+export * from "./segmented-control-fit";
 export * from "./types";

package/templates/runtime/contracts/performance-request-classifier-descriptions.ts

@@ -0,0 +1,39 @@
+import type {
+  ToolcraftPerformanceRequestEvidenceFailureReason,
+  ToolcraftPerformanceRequestReason,
+} from "./performance-request-classifier-types";
+
+export function describeToolcraftPerformanceRequestReason(
+  reason:
+    | ToolcraftPerformanceRequestReason
+    | ToolcraftPerformanceRequestEvidenceFailureReason,
+): string {
+  switch (reason) {
+    case "strong-direct-complaint":
+      return "The request contains a high-confidence performance complaint.";
+    case "software-optimization-request":
+      return "The request ties optimization language to software responsiveness.";
+    case "resource-pressure-complaint":
+      return "The request reports excessive runtime resource use.";
+    case "product-speed-command":
+      return "The request changes product motion speed without reporting performance.";
+    case "product-freeze-command":
+      return "The request uses freeze as a product behavior command.";
+    case "product-terminology-command":
+      return "The request uses performance-like words as product terminology.";
+    case "generic-product-command":
+      return "The request is a high-confidence product implementation command without a performance signal.";
+    case "negated-performance-complaint":
+      return "The request locally negates a performance complaint.";
+    case "needs-semantic-judgment":
+      return "The request needs semantic agent judgment.";
+    case "request-high-confidence-ordinary":
+      return "The full Request is a high-confidence product behavior command.";
+    case "evidence-too-short":
+      return "Request evidence must be a nontrivial quote.";
+    case "evidence-not-in-request":
+      return "Request evidence is not an exact normalized substring of Request.";
+    case "evidence-high-confidence-ordinary":
+      return "Request evidence is a high-confidence product behavior command.";
+  }
+}

package/templates/runtime/contracts/performance-request-classifier-rules.ts

@@ -0,0 +1,181 @@
+import type { ToolcraftPerformanceRequestReason } from "./performance-request-classifier-types";
+
+type ClauseClassificationRule = Readonly<{
+  patterns: readonly RegExp[];
+  reason: ToolcraftPerformanceRequestReason;
+}>;
+
+export const englishRuntimeSubject =
+  "(?:it|this|everything|app|application|editor|runtime|ui|interface|browser|input|controls?|buttons?|canvas|preview|renders?|rendering|uploads?|imports?|exports?|timeline|zoom|dragging|drag)";
+export const russianRuntimeSubject =
+  "(?:приложен(?:ие|ия)?|редактор|рантайм|интерфейс|браузер|ввод|контролы?|кнопк[а-я]*|канвас|превью|рендер|загрузк[а-я]*|импорт|экспорт|таймлайн|масштаб|перетаскиван[а-я]*|всё)";
+
+const englishVerbNegator =
+  "(?:does\\s+not|doesn['’]t|do\\s+not|don['’]t)";
+const englishCopulaNegator =
+  "(?:is\\s+not|isn['’]t|are\\s+not|aren['’]t|was\\s+not|wasn['’]t|were\\s+not|weren['’]t)";
+const englishComplaintVerb = "(?:lag|stutter|freeze|hang)";
+const englishComplaintState =
+  "(?:slow|laggy|janky|frozen|freezing|hanging|delayed|unresponsive)";
+const englishComplaintNoun =
+  "(?:performance\\s+(?:issue|problem)s?|lag|jank|stutter|freez[\\p{L}]*|hang[\\p{L}]*|latency)";
+const russianComplaintVerb =
+  "(?:лагает|тормозит|фризит|зависает|зависло)";
+const russianComplaintNoun =
+  "(?:(?:проблем[\\p{L}]*\\s+с\\s+)?(?:производительн|лаг|тормоз|фриз|завис|задерж)[\\p{L}]*)";
+
+function coordinatedNegationPattern(
+  negator: string,
+  complaint: string,
+  conjunction: string,
+): RegExp {
+  return new RegExp(
+    `(?:^|\\s)${negator}\\s+${complaint}(?:\\s+(?:${conjunction})\\s+(?:${negator}\\s+)?${complaint})*`,
+    "giu",
+  );
+}
+
+export const negatedComplaintSpanPatterns = [
+  coordinatedNegationPattern(
+    englishVerbNegator,
+    englishComplaintVerb,
+    "and|or",
+  ),
+  coordinatedNegationPattern(
+    englishCopulaNegator,
+    englishComplaintState,
+    "and|or",
+  ),
+  coordinatedNegationPattern("(?:no|without)", englishComplaintNoun, "and|or"),
+  coordinatedNegationPattern("(?:нет|без)", russianComplaintNoun, "и|или"),
+  new RegExp(
+    `(?:^|\\s)не\\s+${russianComplaintVerb}(?:\\s+(?:и|или)\\s+не\\s+${russianComplaintVerb})*`,
+    "giu",
+  ),
+] as const;
+
+export const explicitComplaintRules: readonly ClauseClassificationRule[] = [
+  {
+    reason: "resource-pressure-complaint",
+    patterns: [
+      /\b(?:high|heavy|excessive)\s+(?:cpu|gpu|memory|resource)(?:\s+(?:use|usage|pressure|load))?\b/iu,
+      /\b(?:cpu|gpu|memory|resource)\s+(?:use|usage|pressure|load)\s+(?:is\s+)?(?:high|heavy|excessive)\b/iu,
+      /(?:высок|чрезмерн|больш)[\p{L}]*.*(?:использ|расход|нагруз).*(?:памят|процессор|cpu|gpu|ресурс)/iu,
+      /(?:памят|процессор|cpu|gpu|ресурс).*(?:использ|расход|нагруз).*(?:высок|чрезмерн|больш)/iu,
+    ],
+  },
+  {
+    reason: "strong-direct-complaint",
+    patterns: [
+      new RegExp(
+        `\\b${englishRuntimeSubject}\\s+(?:(?:is|feels|keeps|gets|becomes|runs|renders|exports|works)\\s+)?(?:very\\s+)?(?:laggy|janky|frozen|freezing|hanging|delayed|unresponsive|slow)\\b`,
+        "iu",
+      ),
+      new RegExp(
+        `\\b${englishRuntimeSubject}\\s+(?:is\\s+)?not\\s+responsive\\b`,
+        "iu",
+      ),
+      new RegExp(
+        `\\b${englishRuntimeSubject}\\s+(?:lags?|stutters?|freezes?|hangs?)\\b`,
+        "iu",
+      ),
+      /\b(?:interaction|dragging|drag|input|controls?)\s+(?:has|have|shows?|suffers?\s+from)\s+(?:noticeable\s+)?(?:delay|latency|lag)\b/iu,
+      /\b(?:delay|latency|lag)\s+(?:during|when|while|on|after|under)\s+(?:interaction|dragging|drag|input|control\w*)\b/iu,
+      /\bslow\s+(?:app|application|editor|browser|runtime|render|rendering|upload|import|export)\b/iu,
+      /\bperformance\s+(?:is|feels|seems|became)?\s*(?:bad|poor|slow|low)\b/iu,
+      /\b(?:lag|jank|stutter)\s+(?:during|when|while|on|after|under)\b/iu,
+      /\b(?:laggy|janky|unresponsive)\b/iu,
+      /\b(?:bad|poor)\s+responsiveness\b/iu,
+      /\b(?:high|bad|poor|excessive)\s+latency\b|\blatency\s+(?:is\s+)?(?:high|bad|poor|excessive)\b/iu,
+      /\b(?:low|unstable|dropping)\s+(?:fps|frame\s+rate)\b|\b(?:fps|frame\s+rate)\s+(?:is\s+)?(?:low|unstable|dropping|bad|poor)\b/iu,
+      new RegExp(
+        `${russianRuntimeSubject}\\s+(?:(?:работает|стал|остаётся|остается)\\s+)?(?:медленно|лагает|тормозит|фризит|зависает|зависло|не\\s+отвечает|не\\s+отзывчив[а-я]*)`,
+        "iu",
+      ),
+      /(?:лагает|тормозит|фризит|зависает|зависло)(?:\s|[,.!?;]|$)/iu,
+      /(?:лаг|тормоз|фриз|зависан|рывк)(?:и|ов|ами|ах)?\s+(?:при|во\s+время|после|на)/iu,
+      /(?:медленно)\s+(?:работает|рендерит|экспортирует|отвечает|обновляется)/iu,
+      /(?:медленн)[\p{L}]*\s+(?:приложен[\p{L}]*|редактор|рендер|загрузк[\p{L}]*|импорт|экспорт)/iu,
+      /(?:плох|низк|медленн)[\p{L}]*\s+(?:перф|производительн|отклик|отзывчив)/iu,
+      /(?:низк|нестабил|пада)[\p{L}]*\s+(?:фпс|fps|частот[\p{L}]*\s+кадр[\p{L}]*)/iu,
+    ],
+  },
+  {
+    reason: "software-optimization-request",
+    patterns: [
+      /\b(?:improve|optimize|optimise|fix|address|investigate|stabilize)\b.*\b(?:performance|responsiveness|latency|frame\s+rate|fps|cpu|gpu|memory|resource\s+(?:use|usage))\b/iu,
+      /\b(?:performance|responsiveness|latency)\s+(?:optimization|optimisation|improvement|regression|issue|problem)\b/iu,
+      /\b(?:improve|optimize|optimise|fix|address|investigate|stabilize)\b.*\b(?:app|application|editor|runtime|ui|interface|input|controls?|canvas|preview|render|rendering|upload|import|export)\b.*\b(?:faster|more\s+responsive|less\s+latency|lower\s+latency)\b/iu,
+      /\breduce\b.*\b(?:latency|delay|cpu|gpu|memory|resource\s+(?:use|usage))\b/iu,
+      /\bspeed\s+up\b.*\b(?:app|application|editor|runtime|ui|interface|controls?|canvas|preview|render|rendering|upload|import|export)\b/iu,
+      /\bmake\b.*\b(?:app|application|editor|runtime|render|rendering|upload|import|export)\b.*\bfaster\b/iu,
+      new RegExp(
+        `\\b${englishRuntimeSubject}\\b.*\\b(?:should|must|needs?\\s+to)\\b.*\\b(?:faster|more\\s+responsive)\\b`,
+        "iu",
+      ),
+      /(?:улучш|оптимиз|исправ|стабилиз).*(?:перф|производительн|отзывчив|отклик|задерж|фпс|частот[а-я]*\s+кадр[а-я]*|памят|процессор|cpu|gpu|ресурс)/iu,
+      /(?:сниз|уменьш).*(?:задерж|нагруз|расход|использ).*(?:памят|процессор|cpu|gpu|ресурс)?/iu,
+      /(?:улучш|оптимиз|исправ|стабилиз).*(?:приложен|редактор|рантайм|интерфейс|канвас|превью|рендер|загрузк|импорт|экспорт).*(?:быстр|отзывчив|меньш[а-я]*\s+задерж)/iu,
+      /(?:ускор).*(?:приложен|редактор|рантайм|интерфейс|канвас|превью|рендер|экспорт)/iu,
+      new RegExp(
+        `${russianRuntimeSubject}.*(?:долж[а-я]*|нужно|надо).*(?:быстр|отзывчив)`,
+        "iu",
+      ),
+    ],
+  },
+] as const;
+
+export const productCommandRules: readonly ClauseClassificationRule[] = [
+  {
+    reason: "product-freeze-command",
+    patterns: [
+      /^\s*(?:please\s+)?freeze\s+(?:the\s+)?(?:camera|object|position|animation|motion|frame)\b/iu,
+      /^\s*(?:add|apply|create|make)\b.*\b(?:freeze|frozen|freezing)\s+(?:effect|frame|state)\b/iu,
+      /^\s*(?:замороз|зафиксир)[\p{L}]*.*(?:камер|объект|позиц|анимац|кадр)/iu,
+      /(?:^|\s)фриз[-\s]?эффект(?:\s|$)/iu,
+    ],
+  },
+  {
+    reason: "product-speed-command",
+    patterns: [
+      /\b(?:make|let)\b.*\b(?:animation|motion|object|transition|playback)\b.*\b(?:faster|quicker)\b/iu,
+      /\bincrease\b.*\b(?:animation|motion|playback)\b.*\bspeed\b/iu,
+      /\b(?:move|animate)\b.*\bobject\b.*\b(?:faster|quicker)\b/iu,
+      /\bspeed\s+up\b.*\b(?:animation|motion|transition|playback)\b/iu,
+      /(?:сделай|пусть).*(?:анимац|движен|объект).*(?:быстр)/iu,
+      /(?:увелич).*(?:скорост).*(?:анимац|движен)/iu,
+      /(?:ускор).*(?:анимац|движен|переход|воспроизвед)/iu,
+      /(?:двига|движет).*(?:объект).*(?:быстр)/iu,
+    ],
+  },
+  {
+    reason: "product-terminology-command",
+    patterns: [
+      /\b(?:rename|name|label)\b.*\b(?:performance|frozen|freeze|slow|fast|cpu|gpu|memory|fps|frame\s+rate)\b/iu,
+      /\badd\b.*\b(?:label|legend|preset|mode|option|button)\b/iu,
+      /\b(?:preset|mode|option|button)\b.*\b(?:named|called|label(?:ed)?)\b/iu,
+      /(?:переимен|назва|подпис).*(?:перф|производительн|заморож|фриз|быстр|медлен|памят|процессор|cpu|gpu|фпс|кадр)/iu,
+      /(?:добав).*(?:подпис|легенд|пресет|режим|опци|кнопк)/iu,
+    ],
+  },
+  {
+    reason: "generic-product-command",
+    patterns: [
+      /^\s*(?:please\s+)?(?:build|create|add|change|update|rename|remove|delete|implement|refactor)\b/iu,
+      /^\s*(?:please\s+)?(?:improve|optimize|optimise|fix|address|investigate|stabilize)\b.*\b(?:architecture|structure|layout|copy|labels?|controls?|canvas|app|application|editor|runtime|ui|interface)\b/iu,
+      /^\s*(?:пожалуйста[,\s]+)?(?:сделай|создай|добавь|измени|обнови|переименуй|удали|реализуй|отрефактори)\b/iu,
+      /^(?:улучш|оптимиз|исправ|стабилиз).*(?:архитектур|структур|лейаут|текст|лейбл|контрол|канвас|приложен|редактор|рантайм|интерфейс)/iu,
+    ],
+  },
+] as const;
+
+function matchesAny(value: string, patterns: readonly RegExp[]): boolean {
+  return patterns.some((pattern) => pattern.test(value));
+}
+
+export function matchPerformanceRequestRule(
+  value: string,
+  rules: readonly ClauseClassificationRule[],
+): ToolcraftPerformanceRequestReason | null {
+  return rules.find((rule) => matchesAny(value, rule.patterns))?.reason ?? null;
+}

package/templates/runtime/contracts/performance-request-classifier-types.ts

@@ -0,0 +1,50 @@
+export type ToolcraftPerformanceIntent =
+  | "ordinary-product-work"
+  | "performance-iteration"
+  | "needs-agent-judgment";
+
+export type ToolcraftPerformanceRequestConfidence = "high" | "ambiguous";
+
+export type ToolcraftPerformanceRequestReason =
+  | "strong-direct-complaint"
+  | "software-optimization-request"
+  | "resource-pressure-complaint"
+  | "product-speed-command"
+  | "product-freeze-command"
+  | "product-terminology-command"
+  | "generic-product-command"
+  | "negated-performance-complaint"
+  | "needs-semantic-judgment";
+
+export type ToolcraftPerformanceRequestClassification = Readonly<{
+  confidence: ToolcraftPerformanceRequestConfidence;
+  intent: ToolcraftPerformanceIntent;
+  matchedClause: string | null;
+  reason: ToolcraftPerformanceRequestReason;
+}>;
+
+export type ToolcraftPerformanceRequestEvidenceFailureReason =
+  | "request-high-confidence-ordinary"
+  | "evidence-too-short"
+  | "evidence-not-in-request"
+  | "evidence-high-confidence-ordinary";
+
+export type ToolcraftPerformanceRequestEvidenceResult =
+  | Readonly<{
+      evidenceClassification: ToolcraftPerformanceRequestClassification;
+      normalizedEvidence: string;
+      normalizedRequest: string;
+      reason:
+        | "valid-performance-iteration-evidence"
+        | "valid-agent-judgment-evidence";
+      requestClassification: ToolcraftPerformanceRequestClassification;
+      valid: true;
+    }>
+  | Readonly<{
+      evidenceClassification?: ToolcraftPerformanceRequestClassification;
+      normalizedEvidence: string;
+      normalizedRequest: string;
+      reason: ToolcraftPerformanceRequestEvidenceFailureReason;
+      requestClassification?: ToolcraftPerformanceRequestClassification;
+      valid: false;
+    }>;