@entrorove/skill 0.1.62 → 0.1.67

package/cli.mjs

@@ -5,6 +5,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { compareVersions } from './version.mjs';
+import { installPackageIdentity } from './install-identity.mjs';
 import { credentialPath, readCredential, writeCredential } from './local-credential.mjs';
 import { runLocal } from './local-cli.mjs';
 import { runNative } from './native-client.mjs';
@@ -23,8 +24,9 @@ import { assertIdeExecution, ideGuardBinding, settleBreakGlassSession } from './
 import { writeBreakGlass } from './break-glass.mjs';
 import { exitIdeSession } from './ide-exit.mjs';
 import { installOptions } from './ide-command.mjs';
+import { readCliInput } from './cli-input.mjs';
 const markerName = '.entrorove-managed.json';
-const installFiles = ['SKILL.md', 'CAPABILITY-MAP.md', 'AGREEMENT.md', 'manifest.json', 'IDE-EXECUTION.md', 'REUSE-DISCIPLINE.md', 'DELIVERY-BOUNDARIES.md'];
+const installFiles = ['SKILL.md', 'CAPABILITY-MAP.md', 'AGREEMENT.md', 'manifest.json', 'IDE-EXECUTION.md', 'REUSE-DISCIPLINE.md', 'DELIVERY-BOUNDARIES.md', 'DESIGN-GATES.md'];
 const markerSchema = 'entrorove.managed-install/1.0';
 const agreementSchema = 'entrorove.agreement-acceptance/1.0';
 const installLockWaitMs = 10_000;
@@ -62,7 +64,7 @@ async function sourceBundle() {
     throw new Error('entrorove skill instructions have a mismatched version');
   }
   const hashes = Object.fromEntries(installFiles.map((name) => [name, sha256(content.get(name))]));
-  return { manifest, content, hashes };
+  return { manifest, content, hashes, packageDigest: await installPackageIdentity(packageDir, packageMetadata) };
 }
 
 function globalInstallPath(home = os.homedir()) { return path.join(home, '.codex', 'skills', 'entrorove'); }
@@ -134,6 +136,7 @@ async function managedState(directory) {
     ? Object.keys(marker.files) : [];
   if (marker.schemaVersion !== markerSchema || marker.name !== 'entrorove'
     || typeof marker.version !== 'string' || !/^\d+\.\d+\.\d+$/.test(marker.version)
+    || marker.packageDigest !== undefined && !/^[a-f0-9]{64}$/.test(marker.packageDigest)
     || !markerFiles.includes('SKILL.md') || !markerFiles.includes('manifest.json')
     || markerFiles.some((name) => !installFiles.includes(name) && !(marker.version === '0.1.39' && name === 'DELIVERY-BOUNDARIES.md'))
     || entries.slice().sort().join(',') !== [...markerFiles, markerName].sort().join(',')) {
@@ -154,7 +157,7 @@ async function writeStagedInstall(directory, bundle) {
   for (const name of installFiles) {
     await fs.writeFile(path.join(directory, name), bundle.content.get(name), { flag: 'wx', mode: 0o600 });
   }
-  const marker = { schemaVersion: markerSchema, name: 'entrorove', version: bundle.manifest.version, files: bundle.hashes };
+  const marker = { schemaVersion: markerSchema, name: 'entrorove', version: bundle.manifest.version, files: bundle.hashes, packageDigest: bundle.packageDigest };
   await fs.writeFile(path.join(directory, markerName), JSON.stringify(marker) + '\n', { flag: 'wx', mode: 0o600 });
 }
 
@@ -224,7 +227,12 @@ async function updateGlobalInstall(target, bundle) {
   const previous = await managedState(target);
   if (previous === false) throw new Error('Global entrorove skill is not pristine and managed; refusing overwrite');
   if (previous && compareVersions(previous.version, bundle.manifest.version) > 0) {
-    throw new Error('A newer managed entrorove skill is installed; use the latest package');
+    throw Object.assign(new Error('A newer managed entrorove skill is installed; use the latest package'), { code: 'ENTROROVE_PACKAGE_DOWNGRADE' });
+  }
+  if (previous?.version === bundle.manifest.version
+    && (Object.keys(previous.files).some(name => previous.files[name] !== bundle.hashes[name])
+      || previous.packageDigest && previous.packageDigest !== bundle.packageDigest)) {
+    throw Object.assign(new Error('Same-version managed package has different bytes; refusing overwrite'), { code: 'ENTROROVE_PACKAGE_VERSION_CONFLICT' });
   }
   if (previous?.version === bundle.manifest.version
     && installFiles.every((name) => previous.files[name] === bundle.hashes[name])) return false;
@@ -288,15 +296,8 @@ export async function uninstall({ home = os.homedir() } = {}) {
 }
 
 async function stdinJson() {
-  let raw = '';
-  for await (const chunk of process.stdin) {
-    raw += chunk;
-    if (raw.length > 1_000_000) throw new Error('Input is too large');
-  }
-  let value;
-  try { value = JSON.parse(raw); } catch { throw new Error('Input must be valid JSON'); }
-  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('Input must be a JSON object');
   const args = process.argv.slice(2);
+  const value = await readCliInput(process.stdin, args);
   if (!['configure','agreement','review'].includes(args[0])) await assertIdeExecution(args, value);
   return value;
 }

package/cloud-task-client.mjs

@@ -4,6 +4,7 @@ import { parseTransportResponse, requestTransport, trustedOrigin } from './remot
 import { displayIdeEvent, ideClientHeaders, ideTaskIdentity } from './ide-presentation.mjs';
 import { verifyAutomaticFeedback } from './automatic-feedback-client.mjs';
 import { sandboxTaskNumber } from './task-identity.mjs';
+import { prepareCloudImages } from './cloud-task-images.mjs';
 
 const CLOUD_TASK_SCHEMA = 'entrorove.cloud-task/1.0';
 const CLOUD_STATUS_SCHEMA = 'entrorove.cloud-status/1.0';
@@ -38,7 +39,11 @@ function validateInput(input) {
   if (input.task !== undefined && (!input.task || typeof input.task !== 'object' || Array.isArray(input.task) || input.task.goal !== input.goal)) {
     throw new Error('Cloud task must preserve the original task goal');
   }
+  if (input.images !== undefined && (!Array.isArray(input.images) || input.images.length > 4)) {
+    throw new Error('cloud-task images must be an array of at most four images');
+  }
   return { goal: input.goal, ...(input.ideTaskId === undefined ? {} : { ideTaskId: input.ideTaskId }),
+    ...(input.images === undefined ? {} : { images: input.images }),
     ...(input.task === undefined ? {} : { task: input.task }) };
 }
 
@@ -88,7 +93,7 @@ export async function runCloudTask(input, dependencies) {
   const ideTaskId = ideTaskIdentity(task.ideTaskId);
   if (ideTaskId) task.ideTaskId = ideTaskId;
   validateDependencies(dependencies);
-  const id = requestId(task);
+  let id = requestId(task);
   const choice = input.sandboxChoice ?? input.answer;
   await dependencies.install();
   if (!await dependencies.agreementAccepted(dependencies.home)) {
@@ -99,9 +104,12 @@ export async function runCloudTask(input, dependencies) {
   });
   if (choice === 'local') return envelope(task, 'skipped', {
     reason: 'task', executionIsolation: 'local', message: '已退出云端沙箱，采用本地方案继续当前任务。',
-    continuation: { goal: task.goal,...(task.ideTaskId ? { ideTaskId: task.ideTaskId } : {}) },
+    continuation: { goal: task.goal,...(task.ideTaskId ? { ideTaskId: task.ideTaskId } : {}),
+      ...(task.images === undefined ? {} : { images: task.images }) },
   });
 
+  if (task.images !== undefined) task.images = await prepareCloudImages(task.images);
+  id = requestId(task);
   const token = await dependencies.readCredential(dependencies.home);
   const origin = trustedOrigin(dependencies.apiOrigin());
   const metadata = { kind: 'remote', operation: 'cloud-task', requestId: id };

package/cloud-task-images.mjs

@@ -0,0 +1,39 @@
+import { constants } from 'node:fs';
+import { open } from 'node:fs/promises';
+import { isAbsolute } from 'node:path';
+import { inspectModelImage, MODEL_IMAGE_LIMITS, normalizeModelImages } from './model-images.mjs';
+
+async function readImage(path) {
+  if (typeof path !== 'string' || !isAbsolute(path)) throw new Error('Image path must be an explicit absolute file path');
+  let file;
+  try {
+    file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    const before = await file.stat();
+    if (!before.isFile() || before.size < 26 || before.size > MODEL_IMAGE_LIMITS.perImageBytes) throw new Error();
+    const bytes = Buffer.alloc(before.size);
+    let offset = 0;
+    while (offset < bytes.length) {
+      const result = await file.read(bytes, offset, bytes.length - offset, offset);
+      if (result.bytesRead === 0) throw new Error();
+      offset += result.bytesRead;
+    }
+    const after = await file.stat();
+    if (before.size !== after.size || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs) throw new Error();
+    return bytes;
+  } catch { throw new Error('Input image must be an unchanged readable regular file within the image byte limit'); }
+  finally { await file?.close(); }
+}
+
+/** Only explicitly attached paths are read, after the task's cloud choice. */
+export async function prepareCloudImages(value = []) {
+  if (!Array.isArray(value) || value.length > MODEL_IMAGE_LIMITS.count) throw new Error('At most four input images are supported');
+  const inputs = [];
+  for (const image of value) {
+    if (image && typeof image === 'object' && !Array.isArray(image) && 'path' in image) {
+      if (Object.keys(image).some(key => !['path','detail'].includes(key))) throw new Error('Image path input has unsupported fields');
+      const bytes = await readImage(image.path), { mimeType } = inspectModelImage(bytes);
+      inputs.push({ url: `data:${mimeType};base64,${bytes.toString('base64')}`, ...(image.detail === undefined ? {} : { detail: image.detail }) });
+    } else inputs.push(image);
+  }
+  return normalizeModelImages(inputs).map(({ url, detail }) => ({ url, detail }));
+}

package/design-browser-checks.mjs

@@ -0,0 +1,86 @@
+import { designFail } from './design-policy.mjs';
+
+export async function browserAssertion(page, check) {
+  const locator = page.locator(check.selector);
+  if (check.kind === 'count') return await locator.count() === check.count;
+  if (check.kind === 'hidden') return !await locator.isVisible();
+  if (await locator.count() !== 1 || !await locator.isVisible()) return false;
+  if (check.kind === 'visible') return true;
+  if (check.kind === 'text') return (await locator.innerText()).trim() === check.value;
+  if (check.kind === 'value') return await locator.inputValue() === check.value;
+  if (check.kind === 'style') return await locator.evaluate((node, property) => getComputedStyle(node).getPropertyValue(property), check.property) === check.value;
+  if (check.kind === 'bounds') {
+    const box = await locator.boundingBox();
+    return Boolean(box && ['x', 'y', 'width', 'height'].every(key => Math.abs(box[key] - check.bounds[key]) <= check.bounds.tolerance));
+  }
+  return false;
+}
+export async function browserChecks(page, checks, failures) {
+  for (const check of checks) {
+    try { if (!await browserAssertion(page, check)) failures.push(`assert-${check.kind}`); }
+    catch { failures.push(`assert-${check.kind}`); }
+  }
+}
+export async function publicFieldCheck(page, pageContract, forbidden, failures) {
+  const fields = await page.locator('[data-entrorove-field]').evaluateAll(nodes => nodes.filter(node => {
+    const style = getComputedStyle(node); return style.display !== 'none' && style.visibility !== 'hidden' && node.getClientRects().length;
+  }).map(node => node.getAttribute('data-entrorove-field')));
+  if (fields.some(name => !pageContract.publicFields.includes(name))) failures.push('public-field-projection');
+  const text = await page.locator('body').innerText();
+  if ([...pageContract.internalFields, ...forbidden].some(value => value && text.includes(value))) failures.push('private-field-visible');
+}
+export function networkCheck(actual, expected, failures) {
+  if (actual.length !== expected.reduce((sum, item) => sum + item.count, 0)
+    || expected.some(item => actual.filter(event => event.method === item.method && event.path === item.path && event.status === item.status).length !== item.count)) failures.push('unexpected-http-mutation');
+}
+export async function installSuccessMonitor(page, successSelector) {
+  await page.addInitScript(selector => {
+    const events = [], acknowledgements = [], storage = [], original = window.fetch.bind(window);
+    Object.defineProperty(window, '__entroroveDesignMonitor', { value: { events, acknowledgements, storage } });
+    for (const method of ['setItem', 'removeItem', 'clear']) {
+      const apply = Storage.prototype[method];
+      Storage.prototype[method] = function(...args) {
+        const result = apply.apply(this, args); storage.push({ method, at: performance.now() });
+        acknowledgements.push({ at: performance.now(), ok: true }); return result;
+      };
+    }
+    if (typeof IDBObjectStore !== 'undefined') for (const method of ['add', 'put', 'delete', 'clear']) {
+      const apply = IDBObjectStore.prototype[method];
+      IDBObjectStore.prototype[method] = function(...args) { storage.push({ method: 'indexed-db-write', at: performance.now() }); return apply.apply(this, args); };
+    }
+    window.fetch = async (...args) => {
+      const response = await original(...args);
+      const method = String(args[1]?.method ?? (args[0] instanceof Request ? args[0].method : 'GET')).toUpperCase();
+      if (['POST', 'PUT', 'PATCH', 'DELETE'].includes(method)) acknowledgements.push({ at: performance.now(), ok: response.ok });
+      return response;
+    };
+    const open = XMLHttpRequest.prototype.open;
+    XMLHttpRequest.prototype.open = function(method, ...args) {
+      const mutation = ['POST', 'PUT', 'PATCH', 'DELETE'].includes(String(method).toUpperCase());
+      this.addEventListener('readystatechange', () => {
+        if (mutation && this.readyState === 4) acknowledgements.push({ at: performance.now(), ok: this.status >= 200 && this.status < 300 });
+      });
+      return open.call(this, method, ...args);
+    };
+    let visible = false;
+    const observe = () => {
+      const node = document.querySelector(selector), style = node && getComputedStyle(node);
+      const next = Boolean(node && style.display !== 'none' && style.visibility !== 'hidden' && node.getClientRects().length);
+      if (next && !visible) events.push({ at: performance.now(), successfulAcknowledgement: acknowledgements.some(item => item.ok) });
+      visible = next;
+    };
+    document.addEventListener('DOMContentLoaded', () => {
+      new MutationObserver(observe).observe(document.documentElement, { attributes: true, childList: true, subtree: true, characterData: true }); observe();
+    });
+  }, successSelector);
+}
+export async function monitorSuccess(page, failures, canSucceed) {
+  const observed = await page.evaluate(() => window.__entroroveDesignMonitor?.events ?? []);
+  if (!canSucceed && observed.length || observed.some(event => !event.successfulAcknowledgement)) failures.push('premature-success-message');
+}
+export function previewUrl(value) {
+  let url; try { url = new URL(value); } catch { designFail('PREVIEW', 'Start the approved local preview before browser acceptance'); }
+  if (url.protocol !== 'http:' || url.hostname !== '127.0.0.1' || !url.port || url.username || url.password
+    || url.pathname !== '/' || url.search || url.hash) designFail('PREVIEW', 'Use an isolated HTTP preview on 127.0.0.1 with a specific port, without credentials');
+  return url;
+}

package/design-browser-identity.mjs

@@ -0,0 +1,13 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { repositoryIntegrityFile } from './local-discipline-repository.mjs';
+import { designFail } from './design-policy.mjs';
+
+export async function readDesignBrowserIdentity(input) {
+  if (typeof input.browserExecutablePath !== 'string' || !path.isAbsolute(input.browserExecutablePath)) designFail('BROWSER', 'Configure a local Chromium executable before design confirmation');
+  const executablePath = await fs.realpath(input.browserExecutablePath), stat = await fs.stat(executablePath);
+  if (!stat.isFile() || !(stat.mode & 0o111) || stat.size > 536_870_912
+    || !/^(?:Google Chrome|Chromium|chrome|chromium|chromium-browser|google-chrome|chrome-headless-shell)$/.test(path.basename(executablePath))) designFail('BROWSER', 'Browser checks require an actual configured Chromium executable, without arbitrary command arguments');
+  const { sha256 } = await repositoryIntegrityFile(path.dirname(executablePath), path.basename(executablePath));
+  return { executablePath, sha256 };
+}

package/design-browser-state.mjs

@@ -0,0 +1,41 @@
+import { canonical } from './local-integrity.mjs';
+
+function projected(value, pointer = '') {
+  for (const part of pointer.split('/').slice(1).map(part => part.replace(/~1/g, '/').replace(/~0/g, '~'))) {
+    if (!value || !Object.hasOwn(value, part)) return undefined;
+    value = value[part];
+  }
+  return value;
+}
+export async function checkBrowserState(page, proof, phase, fields, baseUrl, failures) {
+  const expected = proof[phase]; let actual;
+  try {
+    if (proof.kind === 'http') {
+      const response = await page.request.get(new URL(proof.path, baseUrl).href, { maxRedirects: 0, timeout: 5000 });
+      if (response.status() !== proof[phase === 'before' ? 'statusBefore' : 'statusAfter']) failures.push('read-back-http-status');
+      if (expected !== null || response.status() >= 200 && response.status() < 300) {
+        const bytes = await response.body();
+        if (bytes.length > 1_048_576) throw new Error();
+        actual = projected(JSON.parse(bytes.toString('utf8')), proof.jsonPointer);
+      } else actual = null;
+      await response.dispose();
+    } else {
+      const value = await page.evaluate(key => localStorage.getItem(key), proof.key);
+      actual = value === null ? null : projected(JSON.parse(value), proof.jsonPointer);
+    }
+    if (expected === null) { if (actual !== null) failures.push('read-back-state'); }
+    else if (!actual || typeof actual !== 'object' || Array.isArray(actual)
+      || Object.keys(actual).some(key => !fields.includes(key))
+      || Object.keys(expected).some(key => canonical(actual[key] ?? null) !== canonical(expected[key]))) failures.push('read-back-state');
+  } catch { failures.push('read-back-unavailable'); }
+}
+export async function beginBrowserAction(page) {
+  await page.evaluate(() => {
+    const monitor = window.__entroroveDesignMonitor;
+    monitor.storage.length = 0; monitor.acknowledgements.length = 0; monitor.events.length = 0;
+  });
+}
+export async function checkNonCommitStorage(page, commits, failures) {
+  const count = await page.evaluate(() => window.__entroroveDesignMonitor.storage.length);
+  if (!commits && count) failures.push('unexpected-browser-storage-write');
+}

package/design-browser.mjs

@@ -0,0 +1,181 @@
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { promises as fs } from 'node:fs';
+import { chromium } from 'playwright-core';
+import { designFail, validateDesignPolicy, validateDesignReport, designDigest } from './design-policy.mjs';
+import { disciplineApprovedPolicy } from './local-discipline-contracts.mjs';
+import { designDirectory, designSave, assertDesignArtifacts, designSourceManifest, sameDesignBytes, designOriginalSource } from './design-store.mjs';
+import { writeMutationFile14 } from './local-mutation-files.mjs';
+import { sha256 } from './local-integrity.mjs';
+import { assertDesignLint } from './design-lint.mjs';
+import { assertFrozenDesignFrameworks } from './design-research.mjs';
+import { designUiAsset } from './design-ui.mjs';
+import { verifyOriginalWorkflowPlan } from './workflow-local-runner.mjs';
+import { assertBudgetRunnerAllowed } from './local-budget-reads.mjs';
+import { withStateLock } from './local-state-lock.mjs';
+import { designValidationContext, designContextSources } from './design-context.mjs';
+import { readDesignBrowserIdentity } from './design-browser-identity.mjs';
+import { browserChecks, networkCheck, publicFieldCheck, installSuccessMonitor, monitorSuccess, previewUrl } from './design-browser-checks.mjs';
+import { checkBrowserState, beginBrowserAction, checkNonCommitStorage } from './design-browser-state.mjs';
+
+function matchesPage(url, pageContract, base) {
+  const route = pageContract.route.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/:[\w]+/g, '[^/]+');
+  return url.origin === base.origin && new RegExp(`^${route}$`).test(url.pathname);
+}
+
+async function verifySources(input, policy) {
+  const { mutationRead14 } = await import('./local-mutation-files.mjs');
+  for (const name of policy.rules.uiPaths) {
+    const { content } = await mutationRead14(input, input.repositoryRoot, name);
+    const original = await designOriginalSource(policy, name), source = designUiAsset(name) ? '' : new TextDecoder('utf-8', { fatal: true }).decode(content);
+    assertDesignLint(policy, name, original, source, original);
+  }
+  return designSourceManifest(input, policy);
+}
+async function scenarioRun(browser, input, policy, scenario, directory, runId, deadlineAt) {
+  const mockup = policy.mockups[scenario.mockupIndex];
+  let pageContract = policy.site.pages.find(item => item.id === scenario.entryPageId), stateChecks = 0, lastReadBack;
+  const base = previewUrl(input.baseUrl), target = new URL(scenario.route, base);
+  if (!matchesPage(target, pageContract, base)) designFail('PREVIEW', 'Scenario route differs from its approved flow page');
+  const context = await browser.newContext({ viewport: mockup.viewport, colorScheme: mockup.theme,
+    reducedMotion: 'reduce', serviceWorkers: 'block', acceptDownloads: false });
+  const page = await context.newPage(), failures = [], mutations = [], requests = new Map();
+  page.setDefaultTimeout(5000);
+  await context.route('**/*', async handler => {
+    const url = new URL(handler.request().url());
+    if (url.origin !== base.origin) { failures.push('external-network'); await handler.abort(); }
+    else await handler.continue();
+  });
+  page.on('request', request => {
+    if (['POST', 'PUT', 'PATCH', 'DELETE'].includes(request.method())) {
+      const event = { method: request.method(), path: new URL(request.url()).pathname, status: null };
+      mutations.push(event); requests.set(request, event);
+    }
+  });
+  page.on('response', response => { const event = requests.get(response.request()); if (event) event.status = response.status(); });
+  page.on('pageerror', () => failures.push('browser-error'));
+  page.on('dialog', async dialog => { failures.push('unexpected-dialog'); await dialog.dismiss(); });
+  try {
+    await installSuccessMonitor(page, scenario.successSelector);
+    await page.goto(target.href, { waitUntil: 'networkidle', timeout: 15_000 });
+    await page.waitForTimeout(policy.rules.settleMs);
+    networkCheck(mutations.splice(0), [], failures);
+    await monitorSuccess(page, failures, false);
+    await checkNonCommitStorage(page, false, failures);
+    await browserChecks(page, scenario.checks, failures);
+    await publicFieldCheck(page, pageContract, policy.rules.forbiddenVisibleText, failures);
+    for (const step of scenario.steps) {
+      if (Date.now() >= deadlineAt) designFail('TIME_LIMIT', 'Browser acceptance reached its original bounded deadline');
+      await assertBudgetRunnerAllowed(input);
+      const edge = policy.site.edges.find(item => item.id === step.edgeId);
+      pageContract = policy.site.pages.find(item => item.id === edge.to);
+      await beginBrowserAction(page);
+      if (step.readBack) {
+        await checkBrowserState(page, step.readBack, 'before', pageContract.publicFields, base, failures); stateChecks++;
+      }
+      const locator = page.locator(step.selector);
+      if (step.action === 'click') await locator.click();
+      else if (step.action === 'fill') await locator.fill(step.value ?? '');
+      else await locator.press(step.value ?? 'Enter');
+      await page.waitForTimeout(policy.rules.settleMs);
+      networkCheck(mutations.splice(0), step.mutations, failures);
+      const commits = ['save', 'delete'].includes(edge.kind);
+      const canSucceed = commits && (step.readBack?.kind === 'local-storage' || step.mutations.some(item => item.status < 300));
+      await checkNonCommitStorage(page, commits, failures);
+      await monitorSuccess(page, failures, canSucceed);
+      if (step.readBack) {
+        await checkBrowserState(page, step.readBack, 'after', pageContract.publicFields, base, failures); stateChecks++;
+        lastReadBack = step.readBack;
+      }
+      if (!matchesPage(new URL(page.url()), pageContract, base)) failures.push('flow-page-transition');
+      await browserChecks(page, step.checks, failures);
+      await publicFieldCheck(page, pageContract, policy.rules.forbiddenVisibleText, failures);
+    }
+    if (await page.evaluate(() => document.documentElement.scrollWidth > window.innerWidth + 1)) failures.push('horizontal-overflow');
+  } catch { failures.push('browser-scenario-incomplete'); }
+  try {
+    const file = path.join(directory, `${runId}-${scenario.mockupIndex}.png`), bytes = await page.screenshot({ fullPage: true, animations: 'disabled', timeout: 5000 });
+    await writeMutationFile14(file, bytes);
+    if (lastReadBack) {
+      try {
+        await page.reload({ waitUntil: 'networkidle', timeout: 15_000 });
+        await page.waitForTimeout(policy.rules.settleMs);
+        networkCheck(mutations.splice(0), [], failures);
+        await browserChecks(page, lastReadBack.afterReload, failures);
+        await publicFieldCheck(page, pageContract, policy.rules.forbiddenVisibleText, failures); stateChecks++;
+      } catch { failures.push('reload-state-unverified'); }
+    }
+    return { mockupIndex: scenario.mockupIndex,
+      checks: scenario.checks.length + scenario.steps.reduce((count, step) => count + step.checks.length, 0),
+      steps: scenario.steps.length, stateChecks, failures: [...new Set(failures)], screenshot: { path: file, sha256: sha256(bytes), bytes: bytes.length } };
+  } finally { await context.close(); }
+}
+export async function verifyDesignBrowser(input) {
+  await assertBudgetRunnerAllowed(input);
+  const plan = verifyOriginalWorkflowPlan(input.acceptedPlan);
+  const policies = plan.steps.map(step => step.executionPlan.policy.discipline)
+    .filter(policy => policy?.design?.baselineDigest === input.baselineDigest);
+  if (!policies.length || plan.flowId !== input.flowId) designFail('APPROVAL_REQUIRED', 'Use the exact server-signed live original plan and approved design baseline');
+  const discipline = disciplineApprovedPolicy(policies[0]), policy = validateDesignPolicy(discipline.design);
+  const context = await designValidationContext(input, plan, policy);
+  if (policy.flowId !== input.flowId) designFail('BINDING', 'Browser acceptance must retain its original design flow');
+  if (input.baseUrl !== policy.rules.previewOrigin) designFail('PREVIEW', 'Browser tests may use only the exact preview origin approved before UI implementation');
+  const browserIdentity = await readDesignBrowserIdentity(input);
+  if (!sameDesignBytes(browserIdentity, policy.rules.browser)) designFail('BROWSER_CHANGED', 'The executable differs from the browser frozen in this exact approved design');
+  previewUrl(input.baseUrl);
+  await assertDesignArtifacts(policy, input);
+  await assertFrozenDesignFrameworks(input, policy);
+  const sourceManifest = await designContextSources(input, context, await verifySources(input, policy));
+  const directory = await designDirectory({ ...input, designId: policy.designId, revision: policy.revision });
+  return withStateLock(path.join(directory, 'browser-verification.lock'), () => browserAttempt(input, policy, plan, context, sourceManifest, directory));
+}
+async function browserAttempt(input, policy, plan, context, sourceManifest, directory) {
+  const entries = await fs.readdir(directory);
+  for (const name of entries.filter(name => /^browser-[a-f0-9-]+-start\.json$/.test(name))) {
+    const id = name.replace(/-start\.json$/, '');
+    if (!entries.includes(`${id}.json`) && !entries.includes(`${id}-launch-failed.json`)) designFail('OUTCOME_UNKNOWN', 'The original browser attempt has no terminal report. Read design-status and preserve it; do not repeat its preview requests');
+  }
+  const runId = `browser-${randomUUID()}`, startedAt = new Date().toISOString(), results = [];
+  const deadlineAt = Math.min(Date.now() + 300_000, Date.parse(plan.expiresAt), Date.parse(context.expiresAt));
+  await designSave(directory, `${runId}-start.json`, { schemaVersion: 'entrorove.design-attempt/1.0', runId, startedAt,
+    phase: 'running', callerPid: process.pid, baselineDigest: policy.baselineDigest, sourceManifest,
+    planDigest: input.acceptedPlan.authorityReceipt.payloadDigest, deadlineAt: new Date(deadlineAt).toISOString() });
+  let browser;
+  const environment = Object.fromEntries(['PATH', 'HOME', 'TMPDIR', 'TEMP', 'TMP', 'LANG', 'LC_ALL', 'TZ', 'SystemRoot', 'WINDIR']
+    .filter(key => process.env[key] !== undefined).map(key => [key, process.env[key]]));
+  try { browser = await chromium.launch({ executablePath: policy.rules.browser.executablePath, headless: true, env: environment }); }
+  catch {
+    await designSave(directory, `${runId}-launch-failed.json`, { phase: 'launch-failed', previewRequestsIssued: false, failedAt: new Date().toISOString() });
+    designFail('BROWSER_UNAVAILABLE', 'A compatible local Chromium executable is required; install it before acceptance. No preview requests or pass were issued');
+  }
+  const engine = `playwright-core/1.64.1 chromium/${browser.version()}`;
+  try {
+    for (const scenario of policy.rules.scenarios) {
+      if (Date.now() >= deadlineAt) designFail('TIME_LIMIT', 'Browser acceptance reached its original bounded deadline');
+      await assertBudgetRunnerAllowed(input);
+      const result = await scenarioRun(browser, input, policy, scenario, directory, runId, deadlineAt);
+      results.push(result);
+      await designSave(directory, `${runId}-${scenario.mockupIndex}-result.json`, { result, completedAt: new Date().toISOString(), engine });
+    }
+  } catch (error) {
+    await designSave(directory, `${runId}-interrupted.json`, { phase: 'interrupted', effects: 'unknown-preview-effects',
+      code: error.code ?? 'ENTROROVE_DESIGN_INTERRUPTED', completedScenarios: results.length, recordedAt: new Date().toISOString() });
+    throw error;
+  } finally { await browser.close(); }
+  let after;
+  try {
+    await assertBudgetRunnerAllowed(input);
+    if (Date.now() > deadlineAt) designFail('TIME_LIMIT', 'Browser acceptance exceeded its original authority window');
+    after = await designContextSources(input, context, await designSourceManifest(input, policy));
+  } catch { after = null; }
+  if (!after || !sameDesignBytes(sourceManifest, after)) for (const result of results) result.failures.push('source-or-authority-changed-during-acceptance');
+  const body = { schemaVersion: 'entrorove.design-report/1.0', baselineDigest: policy.baselineDigest, flowId: input.flowId,
+    sourceManifest, testsDigest: context.testsDigest, validationContext: input.validationContext,
+    startedAt, finishedAt: new Date().toISOString(), engine, results };
+  const report = { ...body, reportDigest: designDigest(body) };
+  const reportPath = await designSave(directory, `${runId}.json`, report);
+  try { validateDesignReport(report, policy); }
+  catch (error) { error.reportPath = reportPath; error.reportDigest = report.reportDigest; throw error; }
+  return { status: 'needs-visual-confirmation', report, reportPath, nextStep: 'workflow-design-acceptance',
+    claimsIndependentVerification: false, instruction: 'Show actual browser screenshots beside the approved mockups or prototypes. Obtain the original user visual acceptance; automated checks alone cannot decide aesthetic quality.' };
+}

package/design-context.mjs

@@ -0,0 +1,34 @@
+import { verifyOriginalWorkflowAuthority } from './workflow-local-runner.mjs';
+import { repositoryIntegrityFile } from './local-discipline-repository.mjs';
+import { mutationPath14, mutationRoot14 } from './local-mutation-files.mjs';
+import { sha256 } from './local-integrity.mjs';
+import { designFail } from './design-policy.mjs';
+
+export async function designValidationContext(input, plan, policy) {
+  const context = verifyOriginalWorkflowAuthority(input.validationContext), issued = Date.parse(context.issuedAt), expires = Date.parse(context.expiresAt);
+  if (context.schemaVersion !== 'entrorove.design-validation-context/1.0' || context.purpose !== 'browser-verify-approved-design'
+    || context.flowId !== input.flowId || context.ownerId !== plan.ownerId || context.taskDigest !== plan.taskDigest
+    || context.chainDigest !== plan.chainDigest || context.planDigest !== input.acceptedPlan.authorityReceipt.payloadDigest
+    || context.baselineDigest !== policy.baselineDigest || context.previewOrigin !== policy.rules.previewOrigin
+    || context.repositoryDigest !== sha256(await mutationRoot14(input.repositoryRoot)).slice(0, 32)
+    || !/^[a-f0-9]{64}$/.test(context.testsDigest ?? '') || context.grantsWriteAuthority !== false
+    || !Number.isFinite(issued) || !Number.isFinite(expires) || issued > Date.now() || expires <= Date.now()
+    || expires <= issued || expires - issued > 300_000 || expires > Date.parse(plan.expiresAt)
+    || !Array.isArray(context.sourceManifest) || !context.sourceManifest.length || context.sourceManifest.length > 2048
+    || new Set(context.sourceManifest.map(file => file.path)).size !== context.sourceManifest.length) designFail('TEST_CONTEXT', 'Use the exact live server-signed context of the original successful tests; no write or independent verifier authority is granted');
+  for (const file of context.sourceManifest) {
+    mutationPath14(file.path);
+    if (Object.keys(file).sort().join('|') !== 'path|sha256' || !/^[a-f0-9]{64}$/.test(file.sha256 ?? '')) designFail('TEST_CONTEXT', 'Original test inputs require exact safe paths and SHA-256 hashes');
+  }
+  return context;
+}
+export async function designContextSources(input, context, required) {
+  for (const file of required) if (!context.sourceManifest.some(expected => expected.path === file.path && expected.sha256 === file.sha256)) designFail('TEST_CONTEXT', 'Every UI source, dependency and framework configuration must be part of the successful original test inputs');
+  for (const expected of context.sourceManifest) {
+    // Unselected test inputs receive integrity-only observation, never source
+    // disclosure or new semantic read/data-write permission.
+    const actual = await repositoryIntegrityFile(input.repositoryRoot, expected.path);
+    if (actual.sha256 !== expected.sha256) designFail('SOURCE_CHANGED', 'An original test input changed before or during browser acceptance');
+  }
+  return structuredClone(context.sourceManifest);
+}

package/design-contracts.d.mts

@@ -0,0 +1,4 @@
+export const DESIGN_REPORT_SCHEMA: Record<string, any>;
+export const DESIGN_POLICY_SCHEMA: Record<string, any>;
+export const DESIGN_SITE_SCHEMA: Record<string, any>;
+export const DESIGN_RULES_SCHEMA: Record<string, any>;

package/design-contracts.mjs

@@ -0,0 +1,77 @@
+import Ajv from 'ajv';
+import { object, array, text, identifier, relativePath, sha256, integer } from './local-contract-types.mjs';
+
+const list = (item, min = 1, max = 128) => ({ ...array(item, min), maxItems: max });
+const names = (min = 1) => ({ ...list(identifier, min), uniqueItems: true });
+const words = { ...text, maxLength: 2000 };
+const artifact = object({ path: text, sha256, bytes: integer(1, 8_388_608) }, ['path', 'sha256', 'bytes']);
+const page = object({ id: identifier, route: { ...text, pattern: '^/(?!/)' }, title: words, roles: names(),
+  states: names(), publicFields: names(0), internalFields: names(0), entry: { type: 'boolean' } },
+['id', 'route', 'title', 'roles', 'states', 'publicFields', 'internalFields', 'entry']);
+export const DESIGN_SITE_SCHEMA = object({ id: identifier, requirementIds: names(), roles: names(), pages: list(page),
+  edges: list(object({ id: identifier, from: identifier, to: identifier,
+    kind: { enum: ['navigate', 'open', 'edit', 'fill', 'validate', 'save', 'cancel', 'delete'] }, label: words },
+  ['id', 'from', 'to', 'kind', 'label']), 0, 256) }, ['id', 'requirementIds', 'roles', 'pages', 'edges']);
+const source = object({ url: text, finalUrl: text, sha256, bytes: integer(1, 2_097_152), retrievedAt: text,
+  purpose: { enum: ['layout', 'framework'] }, rationale: words },
+['url', 'finalUrl', 'sha256', 'bytes', 'retrievedAt', 'purpose', 'rationale']);
+const framework = object({ packageName: text, version: text, packagePath: relativePath, packageSha256: sha256,
+  lockPath: relativePath, lockSha256: sha256, officialUrls: list(text, 1, 16) },
+['packageName', 'version', 'packagePath', 'packageSha256', 'lockPath', 'lockSha256', 'officialUrls']);
+const mockup = object({ kind: { enum: ['mockup', 'prototype'] }, pageId: identifier, stateId: identifier, theme: { enum: ['light', 'dark'] },
+  viewport: object({ width: integer(240, 3840), height: integer(240, 2160) }, ['width', 'height']),
+  image: artifact, generation: object({ tool: words, requestId: words, promptSha256: sha256,
+    receipt: artifact }, ['tool', 'requestId', 'promptSha256', 'receipt']) },
+['kind', 'pageId', 'stateId', 'theme', 'viewport', 'image', 'generation']);
+const assertion = object({ kind: { enum: ['visible', 'hidden', 'text', 'value', 'count', 'style', 'bounds'] },
+  field: identifier,
+  selector: words, value: { type: 'string', maxLength: 2000 }, count: integer(0, 1000), property: identifier,
+  bounds: object({ x: integer(0, 3840), y: integer(0, 10000), width: integer(1, 3840), height: integer(1, 10000),
+    tolerance: integer(0, 8) }, ['x', 'y', 'width', 'height', 'tolerance']) }, ['kind', 'selector']);
+const network = object({ method: { enum: ['POST', 'PUT', 'PATCH', 'DELETE'] }, path: { ...text, pattern: '^/(?!/)' },
+  count: integer(1, 8), status: integer(200, 599) }, ['method', 'path', 'count', 'status']);
+const projection = { anyOf: [{ type: 'object', minProperties: 1, maxProperties: 64 }, { type: 'null' }] };
+const readBack = object({ kind: { enum: ['http', 'local-storage'] }, path: { ...text, pattern: '^/(?!/)' }, key: identifier,
+  jsonPointer: { type: 'string', maxLength: 512, pattern: '^(?:/.*)?$' },
+  statusBefore: integer(200, 499), statusAfter: integer(200, 499), before: projection, after: projection,
+  afterReload: list(assertion) }, ['kind', 'before', 'after', 'afterReload']);
+const step = object({ edgeId: identifier, action: { enum: ['click', 'fill', 'press'] }, selector: words,
+  value: { type: 'string', maxLength: 2000 }, checks: list(assertion), mutations: list(network, 0, 8), readBack },
+['edgeId', 'action', 'selector', 'checks', 'mutations']);
+const scenario = object({ mockupIndex: integer(0, 511), entryPageId: identifier, route: { ...text, pattern: '^/(?!/)' }, steps: list(step, 0, 32), checks: list(assertion),
+  successSelector: words }, ['mockupIndex', 'entryPageId', 'route', 'steps', 'checks', 'successSelector']);
+export const DESIGN_RULES_SCHEMA = object({ uiPaths: { ...list(relativePath), uniqueItems: true },
+  previewOrigin: { ...text, pattern: '^http://127\\.0\\.0\\.1:[1-9][0-9]{0,4}/$' },
+  browser: object({ executablePath: text, sha256 }, ['executablePath', 'sha256']),
+  verificationPaths: { ...list(relativePath, 1, 2048), uniqueItems: true },
+  componentModules: list(object({ module: text, exports: names() }, ['module', 'exports']), 0, 64),
+  frameworkStyleImports: { ...list(text, 0, 64), uniqueItems: true },
+  nativeTags: names(), replacements: list(object({ native: identifier, component: identifier }, ['native', 'component']), 0, 32),
+  tokenPath: relativePath, stylePaths: { ...list(relativePath), uniqueItems: true },
+  tokens: { type: 'object', minProperties: 1, maxProperties: 128, patternProperties: { '^--[a-z][a-z0-9-]*$': { ...text, maxLength: 100 } }, additionalProperties: false },
+  settleMs: integer(500, 5000),
+  forbiddenVisibleText: list(words, 0, 128), scenarios: list(scenario, 2, 512) },
+['uiPaths', 'previewOrigin', 'browser', 'verificationPaths', 'componentModules', 'nativeTags', 'replacements', 'tokenPath', 'stylePaths', 'tokens', 'settleMs', 'forbiddenVisibleText', 'scenarios']);
+export const DESIGN_POLICY_SCHEMA = object({ schemaVersion: { const: 'entrorove.design-policy/1.0' },
+  designId: identifier, flowId: identifier, revision: integer(1), site: DESIGN_SITE_SCHEMA, flow: artifact, flowDigest: sha256,
+  flowRecordedAt: text, researchRecordedAt: text, mockupsRecordedAt: text,
+  sources: list(source, 2, 32), frameworks: list(framework, 0, 16), mockups: list(mockup, 2, 512),
+  sourceBaseline: list(object({ path: relativePath, original: { anyOf: [{ ...artifact, properties: { ...artifact.properties, bytes: integer(0, 8_388_608) } }, { type: 'null' }] } }, ['path', 'original'])),
+  rules: DESIGN_RULES_SCHEMA, baselineDigest: sha256 },
+['schemaVersion', 'designId', 'flowId', 'revision', 'site', 'flow', 'flowDigest', 'flowRecordedAt', 'researchRecordedAt',
+  'mockupsRecordedAt', 'sources', 'frameworks', 'mockups', 'sourceBaseline', 'rules', 'baselineDigest']);
+export const DESIGN_REPORT_SCHEMA = object({ schemaVersion: { const: 'entrorove.design-report/1.0' },
+  baselineDigest: sha256, flowId: identifier, testsDigest: sha256, validationContext: { type: 'object' }, sourceManifest: list(object({ path: relativePath, sha256 }, ['path', 'sha256']), 1, 2048),
+  startedAt: text, finishedAt: text, engine: text,
+  results: list(object({ mockupIndex: integer(0, 511), checks: integer(1), steps: integer(0), stateChecks: integer(0),
+    failures: list(identifier, 0), screenshot: artifact }, ['mockupIndex', 'checks', 'steps', 'stateChecks', 'failures', 'screenshot']), 2, 512),
+  reportDigest: sha256 }, ['schemaVersion', 'baselineDigest', 'flowId', 'testsDigest', 'validationContext', 'sourceManifest', 'startedAt', 'finishedAt', 'engine', 'results', 'reportDigest']);
+const ajv = new Ajv({ allErrors: true, strict: true });
+const validators = new Map([['site', DESIGN_SITE_SCHEMA], ['rules', DESIGN_RULES_SCHEMA], ['policy', DESIGN_POLICY_SCHEMA],
+  ['report', DESIGN_REPORT_SCHEMA]].map(([key, schema]) => [key, ajv.compile(schema)]));
+export function designSchema(kind, value) {
+  const validate = validators.get(kind);
+  if (!validate?.(value)) throw Object.assign(new Error(`Invalid design ${kind}: ${validate?.errors?.map(e => e.instancePath || e.keyword).join(', ')}`),
+    { code: 'ENTROROVE_DESIGN_INVALID' });
+  return structuredClone(value);
+}

package/design-declaration.mjs

@@ -0,0 +1,17 @@
+import { designFail, validateDesignPolicy } from './design-policy.mjs';
+import { designUiCandidate } from './design-ui.mjs';
+
+const componentRules = { antd: { button: 'Button', input: 'Input', dialog: 'Modal' },
+  'element-plus': { button: 'ElButton', input: 'ElInput', dialog: 'ElDialog' },
+  '@mui/material': { button: 'Button', input: 'TextField', dialog: 'Dialog' } };
+export function assertDesignDeclaration(policy, paths) {
+  const ui = paths.filter(name => designUiCandidate(name));
+  if (!ui.length && !policy?.design) return;
+  if (!policy?.design) designFail('REQUIRED', 'UI implementation requires whole-site flow, actual internet research, mockups or prototypes and the original human confirmation');
+  const design = validateDesignPolicy(policy.design);
+  if (ui.some(name => !design.rules.uiPaths.includes(name))) designFail('SCOPE', 'Every UI write must belong to the exact approved design');
+  for (const framework of design.frameworks) for (const [native, component] of Object.entries(componentRules[framework.packageName] ?? {})) {
+    if (!design.rules.replacements.some(rule => rule.native === native && rule.component === component)
+      || !design.rules.componentModules.some(module => module.module === framework.packageName && module.exports.includes(component))) designFail('FRAMEWORK_RULES', 'Use the declared component library for its standard controls and dialogs');
+  }
+}