@pixel-point/toolcraft 0.0.13 → 0.0.15

package/templates/starter/e2e/performance-slider-helpers.ts

@@ -0,0 +1,271 @@
+import { expect, type Locator, type Page } from "@playwright/test";
+
+import type { ToolcraftPerformanceConfig } from "@repo/toolcraft-runtime";
+
+import {
+  expectToolcraftPerformanceBudget,
+  getToolcraftPerformanceStressValue,
+} from "./performance-budget-helpers";
+import { attachToolcraftBrowserRuntimeEvidence } from "./browser-runtime-evidence";
+import { getToolcraftControlFieldByTarget } from "./browser-control-target-helpers";
+import { getToolcraftFieldByLabel } from "./performance-control-layout-helpers";
+import { measureToolcraftInteraction } from "./performance-interaction-measurement";
+import type {
+  ToolcraftInteractionOptions,
+  ToolcraftInteractionResult,
+} from "./performance-measurement-evidence";
+
+async function dragToolcraftSliderInField(
+  page: Page,
+  field: Locator,
+  description: string,
+  targetRatio: number,
+): Promise<void> {
+  const slider = field.locator('[data-slot="slider"]').first();
+  const sliderValues = field.getByRole("slider");
+
+  await expect(slider, `Toolcraft slider "${description}" should be visible`).toBeVisible();
+
+  const box = await slider.boundingBox();
+  if (!box) {
+    throw new Error(`Could not measure slider "${description}".`);
+  }
+
+  const startX = box.x + box.width * 0.15;
+  const endX = box.x + box.width * targetRatio;
+  const y = box.y + box.height / 2;
+  const valuesBefore = await sliderValues.evaluateAll((elements) =>
+    elements.map((element) =>
+      element.getAttribute("aria-valuenow") ??
+      (element instanceof HTMLInputElement ? element.value : null),
+    ),
+  );
+
+  await page.mouse.move(startX, y);
+  await page.mouse.down();
+  await page.mouse.move(endX, y, { steps: 12 });
+  await page.mouse.up();
+
+  const valuesAfter = await sliderValues.evaluateAll((elements) =>
+    elements.map((element) =>
+      element.getAttribute("aria-valuenow") ??
+      (element instanceof HTMLInputElement ? element.value : null),
+    ),
+  );
+  expect(
+    valuesAfter,
+    `Toolcraft slider "${description}" must expose a changed value after its drag interaction.`,
+  ).not.toEqual(valuesBefore);
+}
+
+export async function dragToolcraftSliderByLabel(
+  page: Page,
+  label: string,
+  targetRatio: number,
+  options: { scenarioId?: string } = {},
+): Promise<void> {
+  if (options.scenarioId) {
+    throw new Error(
+      "Performance slider evidence must use dragToolcraftSliderByTarget(schemaTarget), not a visible label.",
+    );
+  }
+  const field = await getToolcraftFieldByLabel(page, label);
+  await dragToolcraftSliderInField(page, field, label, targetRatio);
+}
+
+export async function dragToolcraftSliderByTarget(
+  page: Page,
+  target: string,
+  targetRatio: number,
+  options: { scenarioId?: string } = {},
+): Promise<void> {
+  const field = await getToolcraftControlFieldByTarget(page, target);
+  await dragToolcraftSliderInField(page, field, target, targetRatio);
+  if (options.scenarioId) {
+    await attachToolcraftBrowserRuntimeEvidence({
+      evidenceType: "performance-control-drag",
+      requirementId: options.scenarioId,
+      target,
+    });
+  }
+}
+
+export async function dragToolcraftSliderToValue(
+  page: Page,
+  label: string,
+  value: number,
+  options: { scenarioId?: string } = {},
+): Promise<void> {
+  const field = await getToolcraftFieldByLabel(page, label);
+  const slider = field.getByRole("slider").first();
+
+  await expect(slider, `Toolcraft slider "${label}" should be visible`).toBeVisible();
+
+  const range = await slider.evaluate((element) => {
+    const htmlElement = element as HTMLElement;
+    const min = Number(
+      htmlElement.getAttribute("aria-valuemin") ??
+        (htmlElement as HTMLInputElement).min ??
+        "0",
+    );
+    const max = Number(
+      htmlElement.getAttribute("aria-valuemax") ??
+        (htmlElement as HTMLInputElement).max ??
+        "100",
+    );
+
+    return {
+      max: Number.isFinite(max) ? max : 100,
+      min: Number.isFinite(min) ? min : 0,
+    };
+  });
+  const denominator = range.max - range.min;
+  const ratio = denominator === 0 ? 0 : (value - range.min) / denominator;
+
+  await dragToolcraftSliderByLabel(
+    page,
+    label,
+    Math.min(1, Math.max(0, ratio)),
+    options,
+  );
+}
+
+export async function dragToolcraftSliderTargetToValue(
+  page: Page,
+  target: string,
+  value: number,
+  options: { scenarioId?: string } = {},
+): Promise<void> {
+  const field = await getToolcraftControlFieldByTarget(page, target);
+  const slider = field.getByRole("slider").first();
+  const range = await slider.evaluate((element) => {
+    const htmlElement = element as HTMLElement;
+    const min = Number(
+      htmlElement.getAttribute("aria-valuemin") ??
+        (htmlElement as HTMLInputElement).min ??
+        "0",
+    );
+    const max = Number(
+      htmlElement.getAttribute("aria-valuemax") ??
+        (htmlElement as HTMLInputElement).max ??
+        "100",
+    );
+    return {
+      max: Number.isFinite(max) ? max : 100,
+      min: Number.isFinite(min) ? min : 0,
+    };
+  });
+  const denominator = range.max - range.min;
+  const ratio = denominator === 0 ? 0 : (value - range.min) / denominator;
+  await dragToolcraftSliderByTarget(
+    page,
+    target,
+    Math.min(1, Math.max(0, ratio)),
+    options,
+  );
+}
+
+export async function dragToolcraftSliderToPerformanceStressValue(
+  page: Page,
+  label: string,
+  config: ToolcraftPerformanceConfig,
+  scenarioId: string,
+): Promise<void> {
+  const value = getToolcraftPerformanceStressValue(config, scenarioId);
+  const scenario = config.scenarios.find((item) => item.id === scenarioId);
+
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(
+      `Toolcraft performance scenario "${scenarioId}" must provide a numeric stressFixture.value for slider "${label}".`,
+    );
+  }
+  if (!scenario?.target) {
+    throw new Error(
+      `Toolcraft slider performance scenario "${scenarioId}" must declare its schema target.`,
+    );
+  }
+
+  await dragToolcraftSliderTargetToValue(page, scenario.target, value, { scenarioId });
+  const field = await getToolcraftControlFieldByTarget(page, scenario.target);
+  const observedValues = await field.getByRole("slider").evaluateAll((elements) =>
+    elements.map((element) =>
+      Number(
+        element.getAttribute("aria-valuenow") ??
+          (element instanceof HTMLInputElement ? element.value : Number.NaN),
+      ),
+    ),
+  );
+  expect(
+    observedValues.some((observedValue) => Math.abs(observedValue - value) < 0.000_001),
+    `Toolcraft performance scenario "${scenarioId}" must visibly apply stressFixture.value ${value} to slider "${label}".`,
+  ).toBe(true);
+  await attachToolcraftBrowserRuntimeEvidence({
+    evidenceType: "performance-stress-fixture",
+    requirementId: scenarioId,
+    target: scenario.target,
+  });
+}
+
+export async function expectToolcraftDiscreteSliderDragSmoothness(
+  page: Page,
+  label: string,
+  options: ToolcraftInteractionOptions & {
+    expectMarkers?: boolean;
+    maxFrameGapMs?: number;
+    maxInteractionMs?: number;
+    requirementId?: string;
+    target?: string;
+  } = {},
+): Promise<ToolcraftInteractionResult> {
+  const field = options.target
+    ? await getToolcraftControlFieldByTarget(page, options.target)
+    : await getToolcraftFieldByLabel(page, label);
+  const slider = field.locator('[data-slot="slider"][data-variant="discrete"]').first();
+
+  await expect(
+    slider,
+    `Toolcraft discrete slider "${label}" should render the discrete variant.`,
+  ).toBeVisible();
+
+  const markers = field.locator('[data-slot="slider-marker"]');
+  if (options.expectMarkers === false) {
+    await expect(
+      markers,
+      `Toolcraft half-width discrete slider "${label}" should hide over-budget tick markers.`,
+    ).toHaveCount(0);
+  } else {
+    await expect(
+      markers.first(),
+      `Toolcraft discrete slider "${label}" should render tick markers.`,
+    ).toBeVisible();
+  }
+
+  const result = await measureToolcraftInteraction(
+    page,
+    async () => {
+      if (options.target) {
+        await dragToolcraftSliderByTarget(page, options.target, 0.85);
+      } else {
+        await dragToolcraftSliderByLabel(page, label, 0.85);
+      }
+    },
+    options,
+  );
+
+  expectToolcraftPerformanceBudget(result, {
+    maxFrameGapMs: options.maxFrameGapMs ?? 80,
+    maxInteractionMs: options.maxInteractionMs ?? 500,
+  });
+  if (options.requirementId) {
+    if (!options.target) {
+      throw new Error("Discrete-slider runtime evidence requires a schema target.");
+    }
+    await attachToolcraftBrowserRuntimeEvidence({
+      evidenceType: "discrete-slider-layout",
+      requirementId: options.requirementId,
+      target: options.target,
+    });
+  }
+
+  return result;
+}

package/templates/starter/e2e/product-observable-helpers.ts

@@ -1,5 +1,18 @@
 import { expect, type Page } from "@playwright/test";
 
+import { attachToolcraftBrowserRuntimeEvidence } from "./browser-runtime-evidence";
+import {
+  assertToolcraftBrowserActionForSession,
+  getToolcraftBrowserActionTarget,
+  getToolcraftBrowserProofPage,
+  isToolcraftBrowserAction,
+  isToolcraftBrowserProofSession,
+  runToolcraftBrowserAction,
+  type ToolcraftBrowserAction,
+  type ToolcraftBrowserProofSession,
+} from "./browser-proof-session";
+import { expectToolcraftPersistentOutcomeAfterAction } from "./stable-outcome-helpers";
+
 const defaultProductObservableSelector = [
   "[data-toolcraft-product-output]",
   "[data-toolcraft-product-text]",
@@ -16,7 +29,12 @@ export type ToolcraftProductObservableSnapshotOptions = {
 
 export type ToolcraftProductObservableChangeOptions =
   ToolcraftProductObservableSnapshotOptions & {
+    baselineStabilityIntervalMs?: number;
+    baselineStabilitySamples?: number;
     message?: string;
+    requirementId?: string;
+    stabilityIntervalMs?: number;
+    stabilitySamples?: number;
   };
 
 export async function getToolcraftProductObservableSnapshot(
@@ -148,23 +166,60 @@ export async function getToolcraftProductObservableSnapshot(
 }
 
 export async function expectToolcraftProductObservableToChange(
-  page: Page,
-  action: () => Promise<void>,
+  pageOrSession: Page | ToolcraftBrowserProofSession,
+  action: (() => Promise<void>) | ToolcraftBrowserAction,
   options: ToolcraftProductObservableChangeOptions = {},
 ): Promise<void> {
-  const before = await getToolcraftProductObservableSnapshot(page, options);
-
-  await action();
-
-  await expect
-    .poll(
-      async () => getToolcraftProductObservableSnapshot(page, options),
-      {
-        message:
-          options.message ??
-          "Product output should change after the visible user interaction.",
-        timeout: options.timeoutMs ?? 5000,
-      },
-    )
-    .not.toBe(before);
+  if (options.requirementId !== undefined && !isToolcraftBrowserProofSession(pageOrSession)) {
+    throw new Error(
+      "Product-observable runtime evidence requires a verified Toolcraft browser proof session; a raw Page may be used only for non-evidence helper checks.",
+    );
+  }
+  const page = isToolcraftBrowserProofSession(pageOrSession)
+    ? await getToolcraftBrowserProofPage(pageOrSession)
+    : pageOrSession;
+  let target: string | undefined;
+  let runAction: () => Promise<void>;
+
+  if (isToolcraftBrowserAction(action)) {
+    if (isToolcraftBrowserProofSession(pageOrSession)) {
+      assertToolcraftBrowserActionForSession(pageOrSession, action);
+    }
+    target = getToolcraftBrowserActionTarget(action);
+    runAction = () => runToolcraftBrowserAction(action);
+  } else {
+    runAction = action;
+  }
+
+  if (options.requirementId !== undefined && target === undefined) {
+    throw new Error(
+      "Product-observable runtime evidence requires a target-scoped proofSession.controlAction(schemaTarget, action).",
+    );
+  }
+
+  await expectToolcraftPersistentOutcomeAfterAction(
+    () => getToolcraftProductObservableSnapshot(page, options),
+    runAction,
+    {
+      baselineStabilityIntervalMs: options.baselineStabilityIntervalMs,
+      baselineStabilitySamples: options.baselineStabilitySamples,
+      message:
+        options.message ??
+        "Product output should change after the visible user interaction.",
+      stabilityIntervalMs: options.stabilityIntervalMs,
+      stabilitySamples: options.stabilitySamples,
+      timeoutMs: options.timeoutMs ?? 5000,
+    },
+  );
+
+  if (options.requirementId !== undefined) {
+    await getToolcraftBrowserProofPage(
+      pageOrSession as ToolcraftBrowserProofSession,
+    );
+    await attachToolcraftBrowserRuntimeEvidence({
+      evidenceType: "product-observable-change",
+      requirementId: options.requirementId,
+      target,
+    });
+  }
 }

package/templates/starter/e2e/stable-outcome-helpers.ts

@@ -0,0 +1,208 @@
+import { expect } from "@playwright/test";
+
+export type ToolcraftStableOutcomeOptions = {
+  baselineStabilityIntervalMs?: number;
+  baselineStabilitySamples?: number;
+  message: string;
+  onFirstChange?: () => Promise<void> | void;
+  pollIntervalMs?: number;
+  stabilityIntervalMs?: number;
+  stabilitySamples?: number;
+  timeoutMs?: number;
+};
+
+type ToolcraftOutcomeChangeOptions = Pick<
+  ToolcraftStableOutcomeOptions,
+  "message" | "onFirstChange" | "pollIntervalMs" | "timeoutMs"
+>;
+
+function delay(durationMs: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, durationMs));
+}
+
+export function snapshotToolcraftOutcome<T>(value: T, message: string): T {
+  try {
+    return structuredClone(value);
+  } catch {
+    throw new Error(
+      `${message} Outcome observations must be structured-cloneable snapshots.`,
+    );
+  }
+}
+
+export async function waitForToolcraftOutcomeChange<T>(
+  observeOutcome: () => Promise<T>,
+  before: T,
+  {
+    message,
+    onFirstChange,
+    pollIntervalMs,
+    timeoutMs = 5_000,
+  }: ToolcraftOutcomeChangeOptions,
+): Promise<T> {
+  const baseline = snapshotToolcraftOutcome(before, message);
+  let current = before;
+
+  await expect
+    .poll(
+      async () => {
+        current = await observeOutcome();
+        return current;
+      },
+      {
+        message,
+        ...(pollIntervalMs === undefined
+          ? {}
+          : { intervals: [Math.max(1, pollIntervalMs)] }),
+        timeout: timeoutMs,
+      },
+    )
+    .not.toEqual(baseline);
+
+  await onFirstChange?.();
+
+  return current;
+}
+
+export async function waitForToolcraftExpectedOutcome<T>(
+  observeOutcome: () => Promise<T>,
+  expected: T,
+  {
+    message,
+    onFirstChange,
+    pollIntervalMs,
+    timeoutMs = 5_000,
+  }: ToolcraftOutcomeChangeOptions,
+): Promise<T> {
+  const expectedSnapshot = snapshotToolcraftOutcome(expected, message);
+  let current = await observeOutcome();
+
+  await expect
+    .poll(
+      async () => {
+        current = await observeOutcome();
+        return current;
+      },
+      {
+        message,
+        ...(pollIntervalMs === undefined
+          ? {}
+          : { intervals: [Math.max(1, pollIntervalMs)] }),
+        timeout: timeoutMs,
+      },
+    )
+    .toEqual(expectedSnapshot);
+
+  await onFirstChange?.();
+  return current;
+}
+
+export async function expectToolcraftStableOutcomeBaseline<T>(
+  observeOutcome: () => Promise<T>,
+  baseline: T,
+  {
+    baselineStabilityIntervalMs,
+    baselineStabilitySamples,
+    message,
+    stabilityIntervalMs = 50,
+    stabilitySamples = 3,
+  }: ToolcraftStableOutcomeOptions,
+): Promise<T> {
+  const baselineSnapshot = snapshotToolcraftOutcome(baseline, message);
+  const intervalMs = Math.max(
+    0,
+    baselineStabilityIntervalMs ?? stabilityIntervalMs,
+  );
+  const sampleCount = Math.max(
+    2,
+    baselineStabilitySamples ?? stabilitySamples,
+  );
+  let current = baselineSnapshot;
+
+  for (let sample = 1; sample < sampleCount; sample += 1) {
+    await delay(intervalMs);
+    current = await observeOutcome();
+    expect(
+      current,
+      `${message} The baseline must remain stable before the action; autonomous output requires an expected semantic observation or a deterministic fixed phase.`,
+    ).toEqual(baselineSnapshot);
+  }
+
+  return current;
+}
+
+export async function expectToolcraftPersistentOutcomeChange<T>(
+  observeOutcome: () => Promise<T>,
+  before: T,
+  {
+    message,
+    onFirstChange,
+    pollIntervalMs,
+    stabilityIntervalMs = 50,
+    stabilitySamples = 3,
+    timeoutMs = 5_000,
+  }: ToolcraftStableOutcomeOptions,
+): Promise<T> {
+  const baseline = snapshotToolcraftOutcome(before, message);
+  let current = await waitForToolcraftOutcomeChange(observeOutcome, baseline, {
+    message,
+    onFirstChange,
+    pollIntervalMs,
+    timeoutMs,
+  });
+
+  for (let sample = 1; sample < Math.max(2, stabilitySamples); sample += 1) {
+    await delay(Math.max(0, stabilityIntervalMs));
+    current = await observeOutcome();
+    expect(
+      current,
+      `${message} The changed outcome must remain different from its baseline throughout the stability window.`,
+    ).not.toEqual(baseline);
+  }
+
+  return current;
+}
+
+export async function expectToolcraftPersistentExpectedOutcome<T>(
+  observeOutcome: () => Promise<T>,
+  expected: T,
+  {
+    message,
+    pollIntervalMs,
+    stabilityIntervalMs = 50,
+    stabilitySamples = 3,
+    timeoutMs = 5_000,
+  }: ToolcraftStableOutcomeOptions,
+): Promise<T> {
+  const expectedSnapshot = snapshotToolcraftOutcome(expected, message);
+  let current = await waitForToolcraftExpectedOutcome(
+    observeOutcome,
+    expectedSnapshot,
+    { message, pollIntervalMs, timeoutMs },
+  );
+
+  for (let sample = 1; sample < Math.max(2, stabilitySamples); sample += 1) {
+    await delay(Math.max(0, stabilityIntervalMs));
+    current = await observeOutcome();
+    expect(
+      current,
+      `${message} The expected outcome must remain stable throughout the verification window.`,
+    ).toEqual(expectedSnapshot);
+  }
+
+  return current;
+}
+
+export async function expectToolcraftPersistentOutcomeAfterAction<T>(
+  observeOutcome: () => Promise<T>,
+  action: () => Promise<void>,
+  options: ToolcraftStableOutcomeOptions,
+): Promise<T> {
+  const before = snapshotToolcraftOutcome(
+    await observeOutcome(),
+    options.message,
+  );
+  await expectToolcraftStableOutcomeBaseline(observeOutcome, before, options);
+  await action();
+  return expectToolcraftPersistentOutcomeChange(observeOutcome, before, options);
+}

package/templates/starter/package.json

@@ -1,25 +1,28 @@
 {
   "name": "toolcraft-starter",
   "private": true,
-  "license": "SEE LICENSE IN LICENSE.md",
+  "license": "MIT",
   "type": "module",
   "scripts": {
-    "ai:check": "node scripts/check-ai-skills.mjs",
+    "ai:check": "node scripts/check-toolcraft-code-health.mjs && node scripts/toolcraft-product-boundary.mjs --allow-missing-compiler && node scripts/check-ai-skills.mjs",
     "dev": "node scripts/run-vite-on-free-port.mjs dev",
     "dev:restart": "node scripts/run-vite-on-free-port.mjs dev --toolcraft-restart",
     "build": "tsc -p tsconfig.json --noEmit && vite build",
     "preview": "node scripts/run-vite-on-free-port.mjs preview",
     "preview:restart": "node scripts/run-vite-on-free-port.mjs preview --toolcraft-restart",
     "docs:check": "node scripts/check-toolcraft-docs.mjs",
-    "test": "node scripts/check-toolcraft-docs.mjs && node scripts/check-toolcraft-integrity.mjs && node --test scripts/*.test.mjs && vitest run src --passWithNoTests",
+    "test": "node scripts/check-toolcraft-docs.mjs && node --test scripts/*.test.mjs && vitest run src --passWithNoTests --reporter=default --reporter=./scripts/toolcraft-vitest-runtime-evidence-reporter.mjs",
+    "test:generated": "node scripts/check-toolcraft-docs.mjs && node scripts/check-toolcraft-integrity.mjs && node --test scripts/*.test.mjs && vitest run src --passWithNoTests --reporter=default --reporter=./scripts/toolcraft-vitest-runtime-evidence-reporter.mjs",
     "test:browser": "playwright install chromium && playwright test --grep-invert \"browser perf:\"",
-    "test:browser:perf": "playwright install chromium && playwright test --grep \"browser perf:\" --workers=1 --pass-with-no-tests",
+    "test:browser:perf": "node scripts/run-browser-performance.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "verify:quick": "pnpm ai:check && pnpm test",
     "verify:ui": "pnpm test:browser",
     "verify:perf": "pnpm test:browser:perf",
     "verify:perf:playwright": "pnpm test:browser:perf",
-    "verify:final": "pnpm ai:check && pnpm test && pnpm build && pnpm test:browser"
+    "verify:perf:record-exemption": "node scripts/toolcraft-verification-receipt.mjs record-exemption",
+    "verify:receipt": "node scripts/toolcraft-verification-receipt.mjs validate",
+    "verify:final": "pnpm ai:check && pnpm test && pnpm build && pnpm test:browser && pnpm verify:receipt"
   },
   "dependencies": {
     "@base-ui/react": "^1.4.1",
@@ -45,6 +48,8 @@
   },
   "devDependencies": {
     "@playwright/test": "^1.51.1",
+    "postcss": "^8.5.6",
+    "postcss-selector-parser": "^7.1.0",
     "@tailwindcss/vite": "^4.1.18",
     "@types/node": "22.19.19",
     "@types/react": "^19.2.14",

package/templates/starter/playwright.config.ts

@@ -15,6 +15,8 @@ const testPort =
     ? resolvedTestPort
     : await findAvailablePort(preferredTestPort);
 const testBaseUrl = `http://localhost:${testPort}`;
+const browserServerMode =
+  process.env.TOOLCRAFT_BROWSER_SERVER_MODE === "preview" ? "preview" : "dev";
 process.env[resolvedTestPortEnvName] = String(testPort);
 
 if (!resolvedTestPort && testPort !== preferredTestPort) {
@@ -22,20 +24,21 @@ if (!resolvedTestPort && testPort !== preferredTestPort) {
 }
 
 export default defineConfig({
+  forbidOnly: true,
   testDir: "./e2e",
   timeout: 30_000,
   expect: {
     timeout: 5_000,
   },
   fullyParallel: false,
-  reporter: [["list"]],
+  reporter: [["list"], ["./e2e/browser-runtime-evidence-reporter.ts"]],
   use: {
     ...devices["Desktop Chrome"],
     baseURL: testBaseUrl,
     trace: "retain-on-failure",
   },
   webServer: {
-    command: `pnpm exec vite dev --host 127.0.0.1 --port ${testPort} --strictPort`,
+    command: `pnpm exec vite ${browserServerMode} --host 127.0.0.1 --port ${testPort} --strictPort`,
     reuseExistingServer: false,
     timeout: 60_000,
     url: testBaseUrl,

package/templates/starter/scripts/check-ai-skills.mjs

@@ -117,14 +117,20 @@ if (missingSkills.length === 0) {
   process.exit(0);
 }
 
-console.error("Missing required AI workflow skills:");
+console.warn("Optional AI workflow skills are not installed:");
 for (const skill of missingSkills) {
-  console.error(`- ${skill.name}: ${skill.purpose}`);
+  console.warn(`- ${skill.name}: ${skill.purpose}`);
 }
 
-console.error("");
-console.error("If your AI environment supports Codex skills, install the missing skills before implementation.");
-console.error("If installation is not available, stop and ask the user to install them.");
-console.error("Checked project and global skill locations for Codex, Claude Code, Cursor, and OpenCode-compatible agents.");
-
-process.exit(1);
+console.warn("");
+console.warn(
+  "Signed local AGENTS.md and docs/toolcraft contracts remain the mandatory workflow authority.",
+);
+console.warn(
+  "Continue with the local Toolcraft workflow; install available external skills when the environment supports them.",
+);
+console.warn(
+  "Checked project and global skill locations for Codex, Claude Code, Cursor, and OpenCode-compatible agents.",
+);
+
+process.exit(0);