@milpa/comal 0.1.7 → 0.2.0

package/src/workflows/chrome-page-task.mjs

@@ -0,0 +1,429 @@
+// Existing-page coordinator. Historical popup workflows keep their original code/law.
+import { readFile, realpath } from 'node:fs/promises';
+import { createHash, randomUUID } from 'node:crypto';
+import path from 'node:path';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { compileGovernance } from '../governance.mjs';
+import { digest } from '../operations.mjs';
+import { registerWorkOperations, workProjection } from '../work-plan.mjs';
+import { validateTaskDirectory, chromeFixtureDigest } from './chrome-task.mjs';
+import { verifySuppliedInputs, isSuppliedPath, assertSuppliedSnapshot } from './chrome-supplied-inputs.mjs';
+import { snapshotProject } from '../plugins/chrome-lab/project.mjs';
+import { CHROME_SOURCE_NAMES, bindChromeSource } from './chrome-source.mjs';
+import { PAGE_BEHAVIOR_OPERATION, PAGE_VERIFIER_CONTRACT, assertPageVerifier, pageBehaviorDefinition } from './chrome-page-verifier.mjs';
+import { PAGE_CASE_OPERATION, PAGE_CASE_INPUT, PAGE_CASE_IMPLEMENTATION_DIGEST, createPageCaseCoordinator } from './chrome-page-cases.mjs';
+import { createPageLawBinding } from './chrome-page-law.mjs';
+import {createPagePreviewRecoveryV13,assertPageRecoveryV13Admission} from './chrome-page-recovery-v13.mjs';
+import {selectChromePageCheckpointReader} from './chrome-page-checkpoint-reader.mjs';
+import { nativePageFailure, nativeClosureRefusal } from '../native-refusal.mjs';
+import { pagePublicationDiagnostic, markPagePublicationDiagnostic } from './chrome-page-diagnostics.mjs';
+
+const prefix = 'plugin__chrome-lab__', own = ['ChromePublish', 'ChromeVerify', 'ChromeTest', 'ChromeFinish', 'ChromeDeliver', 'ChromeRecover', 'ChromeInspect'];
+const publicNames = new Set(['Read', 'Write', 'Edit', ...own, ...CHROME_SOURCE_NAMES]);
+const empty = { type: 'object', properties: {}, additionalProperties: false };
+const error = (message, code = 'CHROME_TASK_CONFLICT') => nativePageFailure(message,code);
+const sourceHash = value => digest(value.files.map(({ path, sha256 }) => ({ path, sha256 })));
+const physicalHash = value => createHash('sha256').update(JSON.stringify(value.files.map(({ path, sha256 }) => ({ path, sha256 })))).digest('hex');
+const accepted = book => book.rows.findLast(row => row.type === 'chrome_task_accepted' && row.source === 'workflow_host');
+// Only host-owned, bounded diagnoses cross the close mechanism boundary. An
+// arbitrary plugin/verifier exception remains subject to House's fail-closed
+// generic error; neither its message nor its stack is projected here.
+const closeRefusals = Object.freeze({
+  CHROME_TASK_CASE_BUDGET: 'A required original case-series time or native-call budget is unavailable or exhausted; no additional phase or Work closure is authorized.',
+  CHROME_TASK_UNCERTAIN: 'Original page effects or case settlement are uncertain; they cannot replay to close Work.',
+  CHROME_TASK_STALE_EVIDENCE: 'Original verification evidence no longer matches the current page or source.',
+  CHROME_TASK_STALE_SOURCE: 'Published source no longer matches the current source.',
+  CHROME_TASK_TARGET_CHANGED: 'The exact accepted page target is missing or changed.',
+  CHROME_TASK_DOCUMENT_CHANGED: 'The exact accepted page document changed.',
+  CHROME_TASK_FIXTURE_CHANGED: 'The immutable accepted page fixture changed.',
+  CHROME_VERIFIER_CHANGED: 'The original verifier or its bounded native port contract is unavailable or changed.',
+  HOUSE_REFUSED: 'An original native operation was denied; earlier successful reads do not authorize closure.',
+  HOUSE_GUARD: 'An original native guard denied a current closure check.',
+  HOUSE_AUTHORITY_CHANGED: 'Original authority changed before the current closure check.',
+  HOUSE_SURFACE_CHANGED: 'The original native tool surface changed before closure.',
+  HOUSE_STALE: 'The original native operation contract changed before closure.',
+  AUDIT_INVALID: 'The original native journal does not verify.',
+});
+
+export async function prepareChromePageTask({ cwd, house, store, sessionId, executor, policy, task: brief, verifier, source = 'explicit_cli_file', provenance, caseRevision, caseImplementation, publicationRecoveryGuard, checkpointProjection }) {
+  const recoverySelected=Object.hasOwn(brief,'publication_recovery');
+  if(recoverySelected)assertPageRecoveryV13Admission(brief,publicationRecoveryGuard);
+  if (caseRevision !== undefined && (!/^[a-f0-9]{64}$/.test(caseRevision) || caseImplementation !== PAGE_CASE_IMPLEMENTATION_DIGEST)) throw error('Host-reserved page Case implementation changed.', 'CHROME_VERIFIER_CHANGED');
+  const taskDigest = digest(brief), directory = await validateTaskDirectory(cwd, brief.directory);
+  assertPageVerifier(verifier, brief.verification); await verifier.assertCurrent(directory);
+  const fixtureDigest = await chromeFixtureDigest(cwd, brief), suppliedDigest = digest(brief.supplied_inputs);
+  await verifySuppliedInputs(directory, brief.supplied_inputs);
+  const loaded = await store.load(sessionId), saved = accepted(loaded);
+  if (!loaded.journalAudit.consistent) throw error('Invalid native journal.', 'AUDIT_INVALID');
+  if (saved && (saved.task_digest !== taskDigest || saved.fixture_source_digest !== fixtureDigest || saved.supplied_inputs_digest !== suppliedDigest)) throw error('Accepted page task or input identity changed.');
+  if (provenance?.fixture_source_digest && provenance.fixture_source_digest !== fixtureDigest || provenance?.supplied_inputs_digest && provenance.supplied_inputs_digest !== suppliedDigest) throw error('Page input provenance changed.');
+  const mechanisms = ['runtime:chrome-task.scope', 'runtime:chrome-task.close', 'runtime:chrome-task.artifact-hash'], casePlan = brief.verification.cases;
+  const plan = compileGovernance(JSON.parse(await readFile(new URL(`../../governance/chrome-task-v${recoverySelected ? 13 : casePlan ? 12 : 11}.json`, import.meta.url))), mechanisms);
+  if (saved && saved.governance_plan_hash !== plan.plan_hash) throw error('Page task requires its original accepted policy.');
+  const pageLaw = createPageLawBinding({ house, store, sessionId, cwd, taskDigest, plan });
+  await verifier.prepare(directory, brief.verification);
+  for (const name of ['Status', 'Deploy', 'Deployment', 'Preview', 'Targets', 'Contexts', 'Assert', 'ReadDOM', 'Console', 'InspectValue']) if (!house.registry.get(prefix + name)) throw error('Required native Chrome operation unavailable: ' + name);
+  const hashOp = house.registry.get('FileInfo');
+  if (!hashOp || hashOp.contract.origin !== null || hashOp.contract.steps || hashOp.contract.permission !== 'FileInfo' || hashOp.contract.effects.workspace !== 'read' || ['external', 'process', 'authority'].some(key => hashOp.contract.effects[key] !== 'none')) throw error('Native artifact hash capability unavailable.');
+  const artifact = brief.directory + '/manifest.json';
+  const declaredTask = { id: 'chrome-task', title: 'Implement and verify accepted existing-page extension', criterion: `Accepted page task ${taskDigest}; native verifier ${brief.verification.implementation_sha256}; see chrome_task_accepted.`, phase: 'implementation', artifacts: [artifact], checks: [{ step_id: 'browser', operation: 'ChromeTest', arguments: {}, assertions: [{ kind: 'json_equals', pointer: '/status', value: 'verified' }] }] };
+  const work = workProjection(loaded);
+  if (!saved && work) throw error('Use a fresh session to accept a page task.');
+  if (work) {
+    const definitions = loaded.rows[work.plan.ref]?.tasks;
+    const definition = definitions?.length === 1 ? Object.fromEntries(Object.entries(definitions[0]).filter(([key]) => !['definition_digest', 'work_digest'].includes(key))) : null;
+    if (work.plan.version !== 1 || digest(definition) !== digest({ ...declaredTask, depends_on: [] })) throw error('Saved work does not match the page task.');
+  }
+  const selectedStateReader=selectChromePageCheckpointReader(store,checkpointProjection);
+  // v13 returned recovery needs the original complete book, never an index tuple.
+  const pageStateReader=recoverySelected?undefined:selectedStateReader;
+  let publicationRecovery;
+  const state = async () => {
+    if(pageStateReader){
+      const projection=await pageStateReader.readPageState(sessionId,taskDigest);
+      if(!projection.journalAudit.consistent||projection.accepted?.task_digest!==taskDigest)throw error('Accepted page task journal changed.','AUDIT_INVALID');
+      return projection.state;
+    }
+    const book = await store.load(sessionId);
+    if (!book.journalAudit.consistent || accepted(book)?.task_digest !== taskDigest) throw error('Accepted page task journal changed.', 'AUDIT_INVALID');
+    const current=structuredClone(book.rows.findLast(row => row.type === 'chrome_task_checkpoint' && row.task_digest === taskDigest)?.state || { stage: 'new', status: 'ready' });
+    if(publicationRecovery)await publicationRecovery.assertReturnedRecovery(current,book);
+    return current;
+  };
+  const save = (options, value) => options.recordWork({ type: 'chrome_task_checkpoint', source: 'workflow_host', task_digest: taskDigest, state: value });
+  const snapshot = async signal => {
+    assertPageVerifier(verifier, brief.verification); await verifier.assertCurrent(directory); await verifySuppliedInputs(directory, brief.supplied_inputs, { signal });
+    const result = await snapshotProject(cwd, brief.directory, { signal }); assertSuppliedSnapshot(result, brief.supplied_inputs);
+    if (result.files.find(file => file.path === brief.fixture.file)?.sha256 !== fixtureDigest) throw error('Immutable page fixture changed.', 'CHROME_TASK_FIXTURE_CHANGED');
+    return result;
+  };
+  const assertReady = value => {
+    if (value.stage.endsWith('_pending') || value.status === 'uncertain') {
+      const failure = error('An interrupted page effect cannot be replayed.', 'CHROME_TASK_UNCERTAIN');
+      if (casePlan && value.stage === 'case_pending') failure.details = { recovery_call: { name: 'ChromeRecover', input: {} }, next_action: 'Read-only reconciliation can settle only an original returned Case owner and native receipt. Missing owners or uncertain effects stay blocked; do not repeat the case.' };
+      throw failure;
+    }
+  };
+  const invoke = async (options, name, input = {}) => JSON.parse(await options.invoke(prefix + name, input, { signal: options.signal }));
+  if(recoverySelected)publicationRecovery=createPagePreviewRecoveryV13({house,store,sessionId,cwd,task:brief,taskDigest,plan,policy,transportGuard:publicationRecoveryGuard,snapshot,state,save,invoke});
+  let behaviorOperation;
+  const context = async () => {
+    if (behaviorOperation && house.registry.get(PAGE_BEHAVIOR_OPERATION) !== behaviorOperation) throw error('Native verifier operation was replaced.', 'CHROME_VERIFIER_CHANGED');
+    const value = await state();
+    if (!value.binding?.identity || sourceHash(await snapshot()) !== value.source_digest) throw error('Page/source binding is unavailable or stale.', 'CHROME_TASK_STALE_SOURCE');
+    return { task_digest: taskDigest, source_digest: value.source_digest, publication: { attempt_id: value.attempt_id, file_manifest_sha256: value.file_manifest_sha256, extension_id: value.deployment.extension_id }, binding: value.binding, verification: brief.verification, ...(casePlan ? { case: value.case_cursor || null } : {}) };
+  };
+  const freshBinding = async (options, value) => {
+    const targets = (await invoke(options, 'Targets')).targets;
+    if (!value.binding || !targets.some(target => target.target_id === value.binding.target_id && target.type === 'page' && target.url === value.binding.url)) throw error('The exact accepted page is missing or changed.', 'CHROME_TASK_TARGET_CHANGED');
+    const observed = await invoke(options, 'Contexts', { target_id: value.binding.target_id });
+    if (!observed.identity?.context_unique_id || value.binding.identity && digest(observed.identity) !== digest(value.binding.identity)) throw error('The accepted page document changed.', 'CHROME_TASK_DOCUMENT_CHANGED');
+    value.binding.identity = observed.identity;
+    if (sourceHash(await snapshot(options.signal)) !== value.source_digest) throw error('Source changed since publication.', 'CHROME_TASK_STALE_SOURCE');
+    return observed.identity;
+  };
+  let behaviorFrame = null, sourceAccess, caseCoordinator;
+  if (casePlan) caseCoordinator = createPageCaseCoordinator({
+    cases: casePlan, taskDigest, plan, store, sessionId, state, save, context, getOperation: name => house.registry.get(name), receiptLaw: pageLaw.receiptLaw,
+    async fresh(options, value) {
+      await freshBinding(options, value);
+      const remote = await invoke(options, 'Deployment', { project: brief.project, reconnect: false });
+      if (remote.status !== 'observed' || remote.attempt_id !== value.attempt_id || remote.file_manifest_sha256 !== value.file_manifest_sha256 || remote.extension_id !== value.deployment.extension_id) throw error('Physical case publication changed.', 'CHROME_TASK_STALE_SOURCE');
+    },
+    async runBehavior(options, input) {
+      behaviorFrame = { input, operation: house.registry.get(PAGE_BEHAVIOR_OPERATION) };
+      try {
+        const result = JSON.parse(await options.invoke(PAGE_BEHAVIOR_OPERATION, input, { signal: options.signal })), book = await store.load(sessionId);
+        const receipt = book.rows.findLast(row => row.type === 'house_receipt' && row.parent_invocation_id === options.invocation_id && row.operation === PAGE_BEHAVIOR_OPERATION && row.status === 'returned');
+        if (!receipt || receipt.output_truncated || receipt.output_digest !== digest(receipt.output) || result.context_digest !== digest(await context())) throw error('Case native evidence changed before settlement.');
+        return { result, receipt_id: receipt.invocation_id, output_digest: receipt.output_digest };
+      } finally { behaviorFrame = null; }
+    },
+  });
+  const previousRun = async value => {
+    if (!value.behavior_receipt_id) return null;
+    const book = await store.load(sessionId);
+    const owner = book.rows.findLast(row => row.type === 'house_receipt' && row.invocation_id === (value.test_owner || value.behavior_owner) && row.operation === 'ChromeTest');
+    if (!owner || owner.status !== 'returned') throw error('The previous behavior coordinator did not complete; do not replay its effects.', 'CHROME_TASK_UNCERTAIN');
+    const receipt = book.rows.findLast(row => row.type === 'house_receipt' && row.invocation_id === value.behavior_receipt_id && row.operation === PAGE_BEHAVIOR_OPERATION);
+    const expectedLaw = pageLaw.receiptLaw(book, value.behavior_receipt_id);
+    if (!receipt || receipt.status !== 'returned' || receipt.parent_invocation_id !== value.behavior_owner || receipt.contract_digest !== behaviorOperation.digest || receipt.governance_plan_hash !== (typeof expectedLaw === 'string' ? expectedLaw : expectedLaw.plan_hash) || typeof expectedLaw !== 'string' && (receipt.mechanism_stamp !== expectedLaw.mechanism_stamp || receipt.governance_activation_id !== expectedLaw.activation_id) || receipt.output_truncated || receipt.output_digest !== digest(receipt.output)) throw error('The native behavior receipt is unavailable.', 'CHROME_TASK_UNCERTAIN');
+    const result = JSON.parse(receipt.output);
+    if (result.phase !== 'run' || result.context_digest !== digest(result.context) || digest(result.verifier) !== digest(verifier.descriptor) || digest(result.context) !== digest(await context())) throw error('Behavior source/document identity changed; publish a fresh candidate.', 'CHROME_TASK_STALE_EVIDENCE');
+    return { receipt_id: receipt.invocation_id, ...result };
+  };
+  const verify = async (options, semantic = false) => {
+    let value = await state(); assertReady(value);
+    if (!value.deployment) throw error('Publish the complete candidate first.');
+    await freshBinding(options, value);
+    const remote = await invoke(options, 'Deployment', { project: brief.project, reconnect: false });
+    if (remote.status !== 'observed' || remote.attempt_id !== value.attempt_id || remote.file_manifest_sha256 !== value.file_manifest_sha256 || remote.extension_id !== value.deployment.extension_id) throw error('Physical publication changed.', 'CHROME_TASK_STALE_SOURCE');
+    const primary = await invoke(options, 'Assert', { target_id: value.binding.target_id, selector: brief.fixture.selector, equals: brief.fixture.equals, timeout_ms: 0 });
+    if (primary.observed?.url !== value.binding.url) throw error('Primary observation belongs to another page.');
+    if (!semantic || !primary.passed) {
+      if (!primary.passed) { value.status = 'needs_correction'; value.verified_scope = null; await save(options, value); }
+      return { status: primary.passed ? 'verified' : 'needs_correction', scope: 'declared_page_dom', task_digest: taskDigest, source_digest: value.source_digest, binding: value.binding, observed: primary.observed, asked: 'unjudged' };
+    }
+    if (caseCoordinator) {
+      const result = await caseCoordinator.verify(options), current = await state();
+      return { ...result, task_digest: taskDigest, source_digest: current.source_digest, binding: current.binding };
+    }
+    const previous = await previousRun(value), phase = previous ? 'validate_final' : 'run';
+    if (previous?.status !== undefined && previous.status !== 'verified') return { status: 'needs_correction', scope: 'declared_page_behavior', behavior: previous, next_action: 'Correct application source and publish a new complete candidate. The failed test sequence is not replayed.', asked: 'unjudged' };
+    const input = { phase, context: await context(), previous };
+    behaviorFrame = { input, operation: house.registry.get(PAGE_BEHAVIOR_OPERATION) };
+    value.stage = 'behavior_pending'; value.status = 'ready'; await save(options, value);
+    let result, receipt;
+    try {
+      result = JSON.parse(await options.invoke(PAGE_BEHAVIOR_OPERATION, input, { signal: options.signal }));
+      const book = await store.load(sessionId);
+      receipt = book.rows.findLast(row => row.type === 'house_receipt' && row.parent_invocation_id === options.invocation_id && row.operation === PAGE_BEHAVIOR_OPERATION && row.status === 'returned');
+      if (!receipt || receipt.output_truncated || receipt.output_digest !== digest(receipt.output) || result.context_digest !== digest(await context())) throw error('Behavior evidence changed before acceptance.');
+    } finally { behaviorFrame = null; }
+    value = await state(); await freshBinding(options, value);
+    value.stage = 'checked'; value.status = result.status; value.verified_scope = result.status === 'verified' ? 'declared_page_behavior' : null;
+    if (phase === 'run') { value.behavior_receipt_id = receipt.invocation_id; value.behavior_owner = options.invocation_id; }
+    value.test_owner = options.invocation_id;
+    value.final_validation_receipt_id = phase === 'validate_final' && result.status === 'verified' ? receipt.invocation_id : null;
+    // A known failed run must be corrected by a new publication, not rerun against
+    // its already changed page. Keep its receipt for diagnosis in the checkpoint.
+    await save(options, value);
+    return { status: result.status, scope: 'declared_page_behavior', task_digest: taskDigest, source_digest: value.source_digest, binding: value.binding, verifier: verifier.descriptor, phase, behavior: result, receipt_id: receipt.invocation_id, asked: 'unjudged' };
+  };
+  const diagnosticOperations = new Map(['Deploy', 'Preview', 'Contexts'].map(name => [name, house.registry.get(prefix + name)]));
+  const publicationFailure = async (failure, options) => {
+    // v13 retains its original prospective proof/admission and error behavior.
+    // A failed diagnostic must never replace the original error or native mark.
+    if (recoverySelected || options.signal?.aborted) return;
+    try {
+      const book = await store.load(sessionId), currentSource = sourceHash(await snapshot(options.signal));
+      const facts = pagePublicationDiagnostic({ book, house, cwd, sessionId, task: brief, taskDigest, plan, sourceDigest: currentSource, operations: diagnosticOperations, activeOwner: options.invocation_id });
+      if (facts) markPagePublicationDiagnostic(failure, facts, { ...options, cwd });
+    } catch { /* Original failure remains authoritative; evidence is unavailable. */ }
+  };
+  const operationFrames = new AsyncLocalStorage(); let activeFrame = null;
+  const operation = (name, description, run, external = 'read', input_schema = empty) => ({ name, description, input_schema, ...(name === PAGE_CASE_OPERATION && caseRevision !== undefined ? { revision: caseRevision } : {}), steps: true, effects: { workspace: 'read', external, process: 'spawn', authority: 'none' }, async run(input, options) {
+    if (options.sessionId !== sessionId) throw error('Operation belongs to another page task.');
+    const inherited = operationFrames.getStore();
+    if (activeFrame && inherited !== activeFrame) throw error('Another page task operation is active; no effect was started.', 'CHROME_TASK_BUSY');
+    const dispatch = async () => {
+      try { return await (name === 'ChromeTest' && house.governance(sessionId)?.source_stamp ? pageLaw.bind(options).then(() => run(options, input)) : run(options, input)); }
+      catch (failure) { if (['ChromePublish', 'ChromeRecover'].includes(name)) await publicationFailure(failure, options); throw failure; }
+    };
+    if (inherited) return dispatch();
+    const frame = { id: options.invocation_id, signal: options.signal }; activeFrame = frame;
+    try { return await operationFrames.run(frame, dispatch); }
+    finally { if (activeFrame === frame) activeFrame = null; }
+  } });
+  house.registry.replace([...own, PAGE_BEHAVIOR_OPERATION, PAGE_CASE_OPERATION], [
+    pageBehaviorDefinition({ verifier, store, sessionId, directory, currentContext: context, async observeContext(identity, allowRenewal, receiptId, options) {
+      const value = await state(), before = value.binding.identity;
+      if (!identity?.context_unique_id || identity.connection_id !== before.connection_id || identity.browser_endpoint_id !== before.browser_endpoint_id || identity.frame_id !== before.frame_id) throw error('Verifier page identity changed unexpectedly.');
+      if (identity.context_unique_id === before.context_unique_id) return false;
+      if (!allowRenewal) throw error('Unexpected verifier document renewal.');
+      value.binding.identity = identity; await save(options, value);
+      await options.recordWork({ type: 'chrome_page_document_renewed', task_digest: taskDigest, before, after: identity, receipt_id: receiptId }); return true;
+    } }),
+    ...(caseCoordinator ? [operation(PAGE_CASE_OPERATION, 'Internal accepted bounded page case; only its original native coordinator supplies the phase/index. No resident administration or uncertain replay.', (options, input) => caseCoordinator.executeCase(input, options), 'write', PAGE_CASE_INPUT)] : []),
+    operation('ChromePublish', 'Publish the complete accepted extension and open/renew only its immutable existing page. No popup. Children retain original authority; uncertain effects never replay.', async options => {
+      const old = await state(); assertReady(old); const before = await snapshot(options.signal);
+      if (old.deployment && sourceHash(before) === old.source_digest && ['published', 'checked'].includes(old.stage)) return verify(options);
+      const continuing = old.stage === 'reconciled';
+      if (continuing && sourceHash(before) !== old.source_digest) throw error('Recovered candidate changed.', 'CHROME_TASK_STALE_SOURCE');
+      const namespace = await invoke(options, 'Status');
+      const previewLease=publicationRecovery?await publicationRecovery.capture(options,namespace):undefined;
+      const value = continuing ? { ...old } : { stage: 'deploy_pending', status: 'ready', source_digest: sourceHash(before), file_manifest_sha256: physicalHash(before), attempt_id: randomUUID(), create_only: !namespace.extensions_truncated && !namespace.extensions.some(item => item.project === brief.project) };
+      await save(options, value);
+      if (!continuing) {
+        try { value.deployment = await invoke(options, 'Deploy', { project: brief.project, directory: brief.directory, attempt_id: value.attempt_id, expected_manifest_sha256: value.file_manifest_sha256, ...(value.create_only ? { create_only: true } : {}) }); }
+        catch (caught) { if (caught.code === 'CHROME_DEPLOY_PRECONDITION') { value.stage = 'source_rejected'; await save(options, value); } throw caught; }
+      }
+      if (value.deployment.project !== brief.project || value.deployment.attempt_id !== value.attempt_id || value.deployment.file_manifest_sha256 !== value.file_manifest_sha256) throw error('Deployment is not the accepted exact candidate.');
+      // A new publication gets a fresh owned page. Reuse/refresh only the exact old
+      // target; a lost acknowledgement remains pending and cannot be replayed.
+      // Preview servers live only for their original plugin connection. A new
+      // explicit source publication after restart opens a fresh owned fixture;
+      // it cannot reload the dead server or reuse the old semantic receipt.
+      if (old.binding && namespace.connection_id && namespace.connection_id === old.binding.identity?.connection_id) {
+        value.binding = structuredClone(old.binding); await save(options, value); await freshBinding(options, value);
+        value.stage = 'page_reload_pending'; await save(options, value);
+        const dispatched = await invoke(options, 'Interact', { target_id: value.binding.target_id, action: 'reload' });
+        if (dispatched.dispatched !== true) throw error('Page reload dispatch is unknown.', 'CHROME_TASK_UNCERTAIN');
+        const previous = value.binding.identity;
+        let observed; const until = Date.now() + 3000;
+        do {
+          try { observed = await invoke(options, 'Contexts', { target_id: value.binding.target_id }); }
+          catch (caught) { let detail; try { detail = JSON.parse(caught.message); } catch {} if (detail?.code !== 'CHROME_TARGET_NAVIGATING') throw caught; }
+          if (observed?.identity?.context_unique_id && observed.identity.context_unique_id !== previous.context_unique_id) break;
+          await new Promise(resolve => setTimeout(resolve, 50));
+        } while (Date.now() < until);
+        if (!observed?.identity?.context_unique_id || observed.identity.context_unique_id === previous.context_unique_id || observed.identity.connection_id !== previous.connection_id || observed.identity.browser_endpoint_id !== previous.browser_endpoint_id) throw error('New page document was not observed.', 'CHROME_TASK_UNCERTAIN');
+        value.binding.identity = observed.identity;
+      } else {
+        value.stage = 'page_open_pending'; await save(options, value);
+        const opened = await invoke(options, 'Preview', { project: brief.project, file: brief.fixture.file });
+        const url = new URL(opened.url);
+        if (url.protocol !== 'http:' || url.hostname !== '127.0.0.1' || decodeURIComponent(url.pathname) !== '/' + brief.fixture.file) throw error('Preview returned another resource.');
+        value.binding = { target_id: opened.target_id, url: opened.url, project: brief.project, fixture_source_digest: fixtureDigest };
+        if(publicationRecovery)await publicationRecovery.acknowledge(options,value,opened,namespace,previewLease);
+        await save(options, value); await freshBinding(options, value);
+        if (old.binding) await options.recordWork({ type: 'chrome_page_publication_rebound', task_digest: taskDigest, previous: old.binding, binding: value.binding, reason: 'new_complete_source_publication_on_new_connection_no_old_semantic_credit' });
+      }
+      delete value.behavior_receipt_id; delete value.behavior_owner; delete value.test_owner; delete value.final_validation_receipt_id; delete value.verified_scope;
+      if (caseCoordinator) { delete value.case_series; delete value.case_progress; delete value.case_pending; delete value.case_cursor; delete value.case_final_owner; }
+      value.stage = 'published'; value.status = 'ready'; await save(options, value); return verify(options);
+    }, 'write'),
+    operation('ChromeVerify', 'Read the accepted page readiness criterion; this alone never closes semantic work.', options => verify(options)),
+    operation('ChromeTest', 'Run the pinned native page verifier once per publication; later calls only validate its completed terminal state by read-only ports. Known failures require corrected publication; unknown effects never replay.', options => verify(options, true), 'write'),
+    operation('ChromeFinish', 'Close only after native semantic evidence and fresh read-only terminal validation of this exact page/source/verifier.', async options => {
+      const current = workProjection(await store.load(sessionId));
+      if (current?.counts.done === 1) { const result = JSON.parse(await options.invoke('ChromeTest', {}, { signal: options.signal })); if (result.status !== 'verified') throw error('Current semantic state failed.', 'WORK_UNVERIFIED'); return { status: 'done', asked: 'unjudged' }; }
+      if (!(await state()).behavior_receipt_id) { const result = JSON.parse(await options.invoke('ChromeTest', {}, { signal: options.signal })); if (result.status !== 'verified') throw error('Semantic behavior failed.', 'WORK_UNVERIFIED'); }
+      await options.invoke('WorkStepRun', { task_id: 'chrome-task', plan_version: current.plan.version, step_id: 'browser', recheck: true }, { signal: options.signal });
+      await options.invoke('WorkTaskUpdate', { task_id: 'chrome-task', plan_version: current.plan.version, status: 'done' }, { signal: options.signal }); return { status: 'done', asked: 'unjudged' };
+    }),
+    operation('ChromeDeliver', 'Publish this complete page extension, return bounded failed native facts for correction, and close only after semantic acceptance plus read-only final validation.', async options => {
+      const publication = JSON.parse(await options.invoke('ChromePublish', {}, { signal: options.signal }));
+      if (publication.status !== 'verified') return { status: 'needs_correction', stage: 'page_readiness', publication, asked: 'unjudged' };
+      const check = JSON.parse(await options.invoke('ChromeTest', {}, { signal: options.signal }));
+      if (check.status !== 'verified') return { status: 'needs_correction', stage: 'declared_page_behavior', check, next_action: 'Correct only application source from these native facts, then publish the complete candidate with ChromeDeliver.', asked: 'unjudged' };
+      await options.invoke('ChromeFinish', {}, { signal: options.signal });
+      const value = await state(); return { status: 'done', scope: 'declared_page_behavior_and_source_snapshot', task_digest: taskDigest, source_digest: value.source_digest, binding: value.binding, receipt_id: value.final_validation_receipt_id, asked: 'unjudged' };
+    }, 'write'),
+    operation('ChromeInspect', 'Read bounded live DOM on the one accepted published page. Publish the complete candidate first with ChromePublish or ChromeDeliver. Missing prerequisites return without opening a page; interrupted effects remain blocked. No target/expression arguments and no verification credit.', async options => {
+      const value = await state(); assertReady(value);
+      if (!value.deployment && !value.binding) return { status: 'not_published', next_action: 'ChromePublish', asked: 'unjudged' };
+      if (value.stage === 'reconciled' && value.deployment && !value.binding) return { status: 'unavailable', reason: 'page_not_opened', next_action: 'ChromePublish', asked: 'unjudged' };
+      await freshBinding(options, value);
+      return { status: 'observed', scope: 'untrusted_owned_page', observation: await invoke(options, 'ReadDOM', { target_id: value.binding.target_id, selector: 'body' }) };
+    }),
+    operation('ChromeRecover', 'Before any publication attempt, return not_published without native work. Otherwise read-only reconciliation of a known Deploy attempt before any page open/reload. Later uncertain page/test effects stay blocked; never replays them.' + (recoverySelected?' Explicit v13 may reconcile an acknowledged Preview/read failure on its original live transport and unchanged authority, with bounded metadata reads and no reconnect/replay or semantic credit.':'') + (caseCoordinator ? ' An original returned Case owner may be settled by reads after a checkpoint failure; a returned native child without its owner is insufficient.' : ''), async options => {
+      const old = await state();
+      if (old.stage === 'new' && old.status === 'ready' && Object.keys(old).length === 2) {
+        const book = await store.load(sessionId), start = book.rows.findLastIndex(row => row.type === 'chrome_task_accepted' && row.source === 'workflow_host');
+        if (!book.journalAudit.consistent || book.rows[start]?.task_digest !== taskDigest) throw error('Accepted page task journal changed.', 'AUDIT_INVALID');
+        // State can still default to new after an interrupted first checkpoint.
+        // Only an untouched publication history establishes this prerequisite.
+        const attempted = book.rows.slice(start + 1).some(row => row.type === 'chrome_task_checkpoint' || row.type.startsWith('chrome_page_') || row.type === 'house_proposal' && (['ChromePublish', 'ChromeDeliver', PAGE_CASE_OPERATION, PAGE_BEHAVIOR_OPERATION].includes(row.operation) || row.operation.startsWith(prefix)));
+        if (!attempted) return { status: 'not_published', next_action: 'ChromePublish', asked: 'unjudged' };
+      }
+      if(publicationRecovery&&old.stage==='page_open_pending')return publicationRecovery.recover(options,old);
+      if (caseCoordinator && old.stage === 'case_pending') return caseCoordinator.recover(options, old);
+      if (!['deploy_pending', 'reconciled'].includes(old.stage) || !old.attempt_id || sourceHash(await snapshot(options.signal)) !== old.source_digest) throw error('This page checkpoint cannot be replayed or automatically recovered.', 'CHROME_TASK_UNCERTAIN');
+      const remote = await invoke(options, 'Deployment', { project: brief.project });
+      if (remote.status !== 'observed' || remote.project !== brief.project || remote.attempt_id !== old.attempt_id || remote.file_manifest_sha256 !== old.file_manifest_sha256 || !remote.extension_id) throw error('Exact publication is unavailable.', 'CHROME_TASK_UNCERTAIN');
+      const value = { ...old, deployment: remote, stage: 'reconciled', status: 'ready' }; await save(options, value);
+      return { status: 'recovered', next_action: 'ChromePublish', claim: 'publication_only_not_functional_delivery', asked: 'unjudged' };
+    }),
+  ]);
+  behaviorOperation = house.registry.get(PAGE_BEHAVIOR_OPERATION);
+  caseCoordinator?.bind(house.registry.get(PAGE_CASE_OPERATION), behaviorOperation);
+  registerWorkOperations({ store, house, artifactObservation: { sessionId, operation: 'FileInfo' } });
+  if (!saved) await store.append(sessionId, { type: 'chrome_task_accepted', source: 'workflow_host', acceptance: source, ...(provenance ? { provenance } : {}), task: brief, task_digest: taskDigest, governance_plan_hash: plan.plan_hash, governance_profile: plan.profile, fixture_source_digest: fixtureDigest, supplied_inputs_digest: suppliedDigest, artifact_observation: { operation: 'FileInfo', hash: true, paths: [artifact] } });
+  const sourcePath = async (file, mutable) => {
+    const absolute = path.resolve(cwd, file), relative = path.relative(directory, absolute);
+    if (!relative || path.isAbsolute(relative) || relative.split(path.sep).some(part => part === '..' || ['.git', '.comal', '.harness', '.ssh', 'node_modules'].includes(part) || /^\.env(?:\.|$)/i.test(part))) return false;
+    if (absolute === path.join(directory, brief.fixture.file) || mutable && isSuppliedPath(relative, brief.supplied_inputs)) return false;
+    await validateTaskDirectory(cwd, brief.directory); await verifySuppliedInputs(directory, brief.supplied_inputs);
+    let ancestor = absolute;
+    for (;;) { try { return await realpath(ancestor) === ancestor; } catch (caught) { if (caught.code !== 'ENOENT') throw caught; ancestor = path.dirname(ancestor); } }
+  };
+  // Keep original host catalogue/shutdown lifecycles available without making
+  // every human/internal operation an exception to accepted page authority.
+  const runtimeControls = new Map(['McpSync', 'McpClose', 'PluginClose'].map(name => [name, house.registry.get(name)]).filter(([, op]) => op?.contract.origin === null));
+  const scope = async view => {
+    if (policy.denied.has(view.operation)) return false;
+    const control = runtimeControls.get(view.operation);
+    if (view.surface === 'internal' && control && house.registry.get(view.operation) === control && view.contract_digest === control.digest) return true;
+    if (view.operation === PAGE_CASE_OPERATION) return Boolean(caseCoordinator?.admit(view));
+    if (view.operation === PAGE_BEHAVIOR_OPERATION) return Boolean(behaviorFrame && view.parent_operation === (caseCoordinator ? PAGE_CASE_OPERATION : 'ChromeTest') && view.contract_digest === behaviorFrame.operation.digest && digest(view.input) === digest(behaviorFrame.input));
+    if (view.parent_operation === PAGE_BEHAVIOR_OPERATION) {
+      const frame = behaviorFrame, name = view.operation.startsWith(prefix) ? view.operation.slice(prefix.length) : null;
+      return Boolean(frame && PAGE_VERIFIER_CONTRACT[frame.input.phase === 'run' ? 'run_ports' : 'final_ports'].includes(name) && view.input.target_id === (await state()).binding?.target_id && (name !== 'InspectValue' || view.input.context_unique_id === (await state()).binding.identity.context_unique_id));
+    }
+    if (['WorkPlanSet', 'WorkCheckRepair'].includes(view.operation)) return false;
+    if (['Read', 'Write', 'Edit'].includes(view.operation)) return sourcePath(view.input.file_path, view.operation !== 'Read');
+    if (CHROME_SOURCE_NAMES.includes(view.operation)) return Boolean(sourceAccess?.active() && await sourceAccess.admit(view));
+    if (view.operation === 'FileInfo') return true; // Separate narrow artifact gate.
+    if (own.includes(view.operation)) return true;
+    if (['WorkStepRun', 'WorkTaskUpdate'].includes(view.operation)) return ['ChromeFinish', 'WorkTaskUpdate'].includes(view.parent_operation);
+    if (!view.operation.startsWith(prefix) || !(own.includes(view.parent_operation) || caseCoordinator && view.parent_operation === PAGE_CASE_OPERATION)) return false;
+    const value = await state(), name = view.operation.slice(prefix.length), input = view.input;
+    if(publicationRecovery&&view.parent_operation==='ChromeRecover'&&value.stage==='page_open_pending')return publicationRecovery.admit(view);
+    if (name === 'Status') return view.parent_operation === 'ChromePublish';
+    if (name === 'Deploy') return view.parent_operation === 'ChromePublish' && input.project === brief.project && input.directory === brief.directory && input.attempt_id === value.attempt_id && input.expected_manifest_sha256 === value.file_manifest_sha256 && Boolean(input.create_only) === Boolean(value.create_only);
+    if (name === 'Deployment') return [...['ChromePublish', 'ChromeVerify', 'ChromeTest', 'ChromeRecover'], ...(caseCoordinator ? [PAGE_CASE_OPERATION] : [])].includes(view.parent_operation) && input.project === brief.project;
+    if (name === 'Preview') return view.parent_operation === 'ChromePublish' && value.stage === 'page_open_pending' && input.project === brief.project && input.file === brief.fixture.file;
+    if (name === 'Targets') return true;
+    if (input.target_id !== value.binding?.target_id) return false;
+    if (name === 'Contexts') return true;
+    if (name === 'Assert') return input.selector === brief.fixture.selector && input.equals === brief.fixture.equals;
+    if (name === 'ReadDOM') return view.parent_operation === 'ChromeInspect' && input.selector === 'body';
+    if (name === 'Interact') return view.parent_operation === 'ChromePublish' && value.stage === 'page_reload_pending' && input.action === 'reload' && !input.selector && !input.text;
+    return false;
+  };
+  const close = async view => {
+    if (view.input.status !== 'done') return true;
+    const value = await state();
+    if (view.parent_operation !== 'ChromeFinish' || value.status !== 'verified' || value.verified_scope !== 'declared_page_behavior' || !value.final_validation_receipt_id || sourceHash(await snapshot()) !== value.source_digest) return false;
+    // The page can change after WorkStepRun, including within the same document.
+    // Reuse the completed run through the original executor: ChromeTest now only
+    // reads terminal semantics and never replays the run's native mutations.
+    let current;
+    try { current = JSON.parse(await executor.execute('ChromeTest', {}, { signal: activeFrame?.signal })); }
+    catch (failure) {
+      const code = failure?.code;
+      if (typeof code !== 'string' || !Object.hasOwn(closeRefusals, code)) throw failure;
+      return nativeClosureRefusal(failure,{ allowed: false, reason: `Fresh page closure refused (${code}): ${closeRefusals[code]}` });
+    }
+    return current.status === 'verified' && current.phase === 'validate_final' && current.source_digest === value.source_digest && sourceHash(await snapshot()) === value.source_digest;
+  };
+  if (!workProjection(await store.load(sessionId))) await executor.execute('WorkPlanSet', { objective: `Verify existing-page task ${brief.project} (${taskDigest})`, expected_version: 0, tasks: [declaredTask] });
+  const initial = workProjection(await store.load(sessionId));
+  if (initial.current?.status === 'pending') await executor.execute('WorkTaskUpdate', { task_id: 'chrome-task', plan_version: initial.plan.version, status: 'in_progress' });
+  sourceAccess = bindChromeSource({ executor, store, sessionId, cwd, plan, taskDigest, pathAllowed: sourcePath, directory: brief.directory });
+  await house.activateGovernance({ sessionId, plan, bindings: {
+    'runtime:chrome-task.scope': { revision: 'chrome-page-scope-v1', operations: ['*'], configuration_digest: taskDigest, check: scope },
+    'runtime:chrome-task.close': { revision: 'chrome-page-close-v1', operations: ['WorkTaskUpdate'], configuration_digest: taskDigest, check: close },
+    'runtime:chrome-task.artifact-hash': { revision: 'chrome-page-artifact-v1', operations: ['FileInfo'], configuration_digest: digest({ taskDigest, artifact, contract_digest: hashOp.digest }), check: async view => !policy.denied.has('FileInfo') && view.contract_digest === hashOp.digest && (['WorkStepRun', 'WorkTaskUpdate'].includes(view.parent_operation) && digest(view.input) === digest({ file_path: artifact, hash: true }) || await sourceAccess.inspection(view)) },
+  } });
+  const project = frame => {
+    const definitions = frame.definitions().filter(tool => publicNames.has(tool.name)).map(tool => {
+      if (!['Read', 'Write', 'Edit', 'SourceDraft'].includes(tool.name)) return tool;
+      const view = structuredClone(tool);
+      // Accepted path facts are bounded by the task schema. They describe the
+      // existing coordinate system; schemas and native source authority stay intact.
+      view.description += '\nPage-task path facts: ' + JSON.stringify({ accepted_directory: brief.directory }) + '. Use workspace-relative file paths under that directory; a bare filename is not relative to it. Equivalent native-valid absolute/relative paths remain valid. The fixture and verifier/oracle data are not source Read targets. Supplied inputs are read-only: do not Write, Edit or SourceDraft them.';
+      if (tool.name === 'Read') {
+        const calls = brief.supplied_inputs.filter(item => item.file.toLowerCase() !== brief.fixture.file.toLowerCase()).map(item => ({ name: 'Read', input: { file_path: path.posix.join(brief.directory, item.file) } }));
+        view.description += ' Read takes a file, not a directory. Exact supplied-file Read calls: ' + JSON.stringify(calls) + '.';
+      } else view.description += ' Exact supplied-file paths are shown as Read calls on Read.';
+      return view;
+    }), names = new Set(definitions.map(tool => tool.name));
+    return { ...frame, definitions: () => definitions, execute(name, input, options = {}) { if (options.modelProposed && !names.has(name)) throw error('Only accepted page-task tools are offered.', 'HOUSE_SURFACE_CHANGED'); return frame.execute(name, input, options.modelProposed ? { ...options, modelSurface: [...names].filter(item => !options.modelSurface || options.modelSurface.includes(item)) } : options); } };
+  };
+  return {
+    task: brief, taskDigest, plan, pinnedSchemas: [...CHROME_SOURCE_NAMES],
+    checkpointProjectionStatus:()=>({requested:Boolean(selectedStateReader),effective:Boolean(pageStateReader),fallback:recoverySelected?'v13_original_full_book':null,reader:selectedStateReader?.status()??null}),
+    system: `Host-managed existing-page Chrome task ${JSON.stringify(brief)}. No popup is required. Implement only mutable extension application source; the fixture is hidden/read-only and supplied assets are immutable. SourceDraft/Retain/Read/Publish retain bounded proposals without regeneration. Prefer ChromeDeliver after complete source edits. It returns native failed semantic facts while work stays open; correct source and deliver again. ChromeVerify readiness alone is not acceptance. Final validation reads only; interrupted test effects are never replayed. ${casePlan ? 'The house owns ordered bounded cases and their native receipts; no case IDs or work administration need to be supplied. ChromeRecover may read-reconcile a returned original Case owner; missing owners remain blocked. ' : ''}${recoverySelected?'Explicit v13 ChromeRecover may reconcile only an acknowledged Preview/read failure on the original live transport and unchanged authority. publication_ready_unverified has no semantic credit; continue with ChromeTest or ChromeDeliver. This bounded workflow has a fixed host catalogue; MCP tools/catalogue refresh are unavailable. ':''}No raw browser target or JavaScript tool is offered. Report delivery only after ChromeDeliver/Finish returns done; human acceptance remains unjudged.`,
+    wrap: tools => ({ ...tools, house, policy, workflow: 'chrome-task', definitions: () => project(tools.snapshot()).definitions(), snapshot: () => project(tools.snapshot()), execute: (name, input, options) => project(tools.snapshot()).execute(name, input, options) }),
+    async completedResult(calls = []) {
+      if (!calls.some(call => call.name === 'ChromeDeliver')) return null;
+      const book = await store.load(sessionId), receipt = book.rows.findLast(row => row.type === 'house_receipt' && row.operation === 'ChromeDeliver' && row.status === 'returned' && calls.some(call => call.id === row.call_id && call.name === 'ChromeDeliver'));
+      if (!receipt || !book.journalAudit.verified || workProjection(book)?.counts.done !== 1) return null;
+      const result = JSON.parse(receipt.output);
+      if (result.status !== 'done' || result.task_digest !== taskDigest || sourceHash(await snapshot()) !== result.source_digest) return null;
+      return { terminal: true, result: `Existing-page extension verified: ${brief.directory}. Native semantic evidence ${result.receipt_id}; source ${result.source_digest}. Human acceptance remains unjudged.`, receipt_id: receipt.invocation_id };
+    },
+    async finishResult(final, baseline) {
+      let delivery = { status: 'open', task_digest: taskDigest, governance_plan_hash: plan.plan_hash, asked: 'unjudged' };
+      const book = await store.load(sessionId), closed = book.rows.slice(baseline.baseline).findLast(row => row.type === 'house_receipt' && row.operation === 'ChromeFinish' && row.status === 'returned');
+      if (!final.is_error && !final.work_stop_reason && closed) {
+        try { const value = JSON.parse(await executor.execute('ChromeTest', {}, { signal: baseline.signal })); if (value.status !== 'verified') throw error('Final page semantics failed.'); delivery = { ...delivery, status: 'verified', scope: 'declared_page_behavior_and_source_snapshot', receipt_id: value.receipt_id, source_digest: value.source_digest, binding: value.binding }; }
+        catch (caught) { delivery = { ...delivery, status: 'needs_verification', code: caught.code || 'CHROME_TASK_FINAL_CHECK' }; final.is_error = true; final.work_stop_reason = 'verification_failed'; }
+      }
+      final.delivery = delivery; await store.append(sessionId, { type: 'chrome_task_delivery', source: 'workflow_host', ...delivery });
+    },
+    dispose() { sourceAccess.dispose(); house.retireGovernance(sessionId); house.registry.replace([...own, PAGE_BEHAVIOR_OPERATION, PAGE_CASE_OPERATION], []); },
+  };
+}

package/src/workflows/chrome-page-verifier.mjs

@@ -0,0 +1,123 @@
+// Trusted startup code, not a sandbox or a model-loadable plugin mechanism.
+import { readFile, realpath, lstat } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import { Script } from 'node:vm';
+import path from 'node:path';
+import { digest, immutable } from '../operations.mjs';
+
+export const PAGE_BEHAVIOR_OPERATION = 'ChromePageBehavior';
+const SHA = /^[a-f0-9]{64}$/, prefix = 'plugin__chrome-lab__';
+const fail = message => Object.assign(new Error(message), { code: 'CHROME_VERIFIER_CHANGED' });
+export const PAGE_VERIFIER_CONTRACT = immutable({ version: 1, operation: PAGE_BEHAVIOR_OPERATION, phases: ['run', 'validate_final'], run_ports: ['Contexts', 'Assert', 'ReadDOM', 'Console', 'Evaluate', 'InspectValue', 'Interact'], final_ports: ['Contexts', 'Console', 'InspectValue'], max_calls: 160, max_result_bytes: 8000, timeout_ms: 60000 });
+export const PAGE_VERIFIER_CONTRACT_DIGEST = digest(PAGE_VERIFIER_CONTRACT);
+const hash = bytes => createHash('sha256').update(bytes).digest('hex');
+const registered = new WeakSet();
+
+// One exact function-expression source owns its closure. Relative imports are not
+// a supported source format. The human trusts all of this Node code explicitly;
+// this does not sandbox dishonest host code or attest ambient external resources.
+export function compileChromePageVerifier(source, { trusted = false, file = null } = {}) {
+  if (!trusted) throw fail('Explicit startup host-code trust is required for a Chrome page verifier.');
+  if (Buffer.byteLength(source) > 262144) throw fail('Chrome verifier source exceeds 256 KiB.');
+  let implementation = null, initializing = null;
+  const implementationSha256 = hash(source), descriptor = immutable({ implementation_sha256: implementationSha256, contract_digest: PAGE_VERIFIER_CONTRACT_DIGEST });
+  const compiled = Object.freeze({
+    descriptor, file,
+    async prepare(directory, verification) {
+      assertPageVerifier(compiled, verification); await compiled.assertCurrent(directory);
+      if (implementation) return;
+      initializing ||= Promise.resolve().then(() => {
+        // Identity and source location have already been admitted. Even evaluating
+        // an outer IIFE from a changed file is forbidden before this point.
+        const factory = new Script('(' + source + '\n)', { filename: file || 'trusted-chrome-page-verifier' }).runInThisContext();
+        if (typeof factory !== 'function') throw fail('Verifier source must be one factory function expression.');
+        const value = factory();
+        if (!value || typeof value.run !== 'function' || typeof value.validate_final !== 'function') throw fail('Verifier factory requires run and validate_final callbacks.');
+        implementation = Object.freeze(value);
+      });
+      await initializing;
+    },
+    async assertCurrent(directory) {
+      if (!file) return;
+      const absolute = path.resolve(file), relative = path.relative(directory, absolute);
+      if (!relative || !relative.startsWith('..' + path.sep) && relative !== '..' && !path.isAbsolute(relative)) throw fail('Host verifier source must be outside resident extension source.');
+      const info = await lstat(absolute);
+      if (!info.isFile() || info.size > 262144 || await realpath(absolute) !== absolute || hash(await readFile(absolute)) !== implementationSha256) throw fail('The accepted verifier source identity changed.');
+    },
+    async execute(phase, context, previous, port) {
+      if (!implementation || !PAGE_VERIFIER_CONTRACT.phases.includes(phase)) throw fail('Verifier was not admitted or its phase is unknown.');
+      return implementation[phase](immutable(structuredClone({ context, criterion: context.verification.criteria, previous })), port);
+    },
+  });
+  registered.add(compiled); return compiled;
+}
+
+export async function loadChromePageVerifier(file, { trusted = false } = {}) {
+  if (!trusted) throw fail('--chrome-verifier executes trusted host code and requires --trust-plugins.');
+  const absolute = path.resolve(file), info = await lstat(absolute);
+  if (!info.isFile() || info.size > 262144 || await realpath(absolute) !== absolute) throw fail('Verifier must be a bounded regular file without symlink aliases.');
+  const source = await readFile(absolute, 'utf8');
+  return compileChromePageVerifier(source, { trusted, file: absolute });
+}
+
+export function assertPageVerifier(verifier, verification) {
+  if (!registered.has(verifier) || !SHA.test(verification.implementation_sha256) || digest(verifier.descriptor) !== digest({ implementation_sha256: verification.implementation_sha256, contract_digest: verification.contract_digest }) || verification.criteria_digest !== digest(verification.criteria)) throw fail('The accepted verifier code/contract/criteria identity is unavailable or changed.');
+}
+
+export function pageBehaviorDefinition({ verifier, store, sessionId, directory, currentContext, observeContext }) {
+  return {
+    name: PAGE_BEHAVIOR_OPERATION, description: 'Internal identity-bound page behavior verifier; only the native task coordinator supplies its resource and phase.',
+    input_schema: { type: 'object', required: ['phase', 'context', 'previous'], properties: { phase: { enum: ['run', 'validate_final'] }, context: { type: 'object' }, previous: { type: ['object', 'null'] } }, additionalProperties: false },
+    steps: true, revision: digest(verifier.descriptor), effects: { workspace: 'read', external: 'write', process: 'spawn', authority: 'none' },
+    async run({ phase, context, previous }, options) {
+      const lease = new AbortController();
+      const signal = AbortSignal.any([lease.signal, ...(options.signal ? [options.signal] : []), AbortSignal.timeout(PAGE_VERIFIER_CONTRACT.timeout_ms)]);
+      if (options.sessionId !== sessionId || digest(context) !== digest(await currentContext())) throw fail('Verifier resource binding changed.');
+      assertPageVerifier(verifier, context.verification); await verifier.assertCurrent(directory);
+      let bound = context, pendingReload = false, calls = 0, active = true, inFlight = 0;
+      const receipts = [], permitted = PAGE_VERIFIER_CONTRACT[phase === 'run' ? 'run_ports' : 'final_ports'];
+      const port = Object.freeze({ signal, context: () => structuredClone(bound), async call(name, input = {}) {
+        if (!active) throw fail('Verifier phase has ended; its child port cannot be reused.');
+        signal.throwIfAborted();
+        inFlight++;
+        try {
+        if (!permitted.includes(name) || ++calls > PAGE_VERIFIER_CONTRACT.max_calls || input.target_id && input.target_id !== bound.binding.target_id || pendingReload && name !== 'Contexts' || name === 'Interact' && !['click', 'fill', 'reload'].includes(input.action)) throw fail('Verifier child exceeds its accepted phase/resource.');
+        if (digest(bound) !== digest(await currentContext())) throw fail('Verifier source or resource changed before a child.');
+        await verifier.assertCurrent(directory);
+        if (!active) throw fail('Verifier callback ended before its native child was dispatched.');
+        signal.throwIfAborted();
+        const args = { ...input, target_id: bound.binding.target_id, ...(name === 'InspectValue' ? { context_unique_id: bound.binding.identity.context_unique_id } : {}) };
+        const output = JSON.parse(await options.invoke(prefix + name, args, { signal }));
+        const book = await store.load(sessionId), receipt = book.rows.findLast(row => row.type === 'house_receipt' && row.parent_invocation_id === options.invocation_id && row.operation === prefix + name && row.status === 'returned');
+        if (!receipt || receipt.arguments_digest !== digest(args) || receipt.output_truncated || receipt.output_digest !== digest(receipt.output)) throw fail('Native verifier child receipt is unavailable or incomplete.');
+        receipts.push(receipt.invocation_id);
+        if (name === 'Interact' && input.action === 'reload') {
+          if (output.dispatched !== true) throw fail('Reload dispatch is unknown; do not replay.'); pendingReload = true;
+        }
+        if (name === 'Contexts') {
+          const renewed = await observeContext(output.identity, phase === 'run' && pendingReload, receipt.invocation_id, options);
+          bound = await currentContext(); if (renewed) pendingReload = false;
+        }
+        return output;
+        } finally { inFlight--; }
+      } });
+      let rejectAborted;
+      const aborted = new Promise((resolve, reject) => { rejectAborted = () => reject(signal.reason); signal.addEventListener('abort', rejectAborted, { once: true }); if (signal.aborted) rejectAborted(); });
+      let result;
+      try {
+      result = await Promise.race([verifier.execute(phase, context, previous, port), aborted]);
+      active = false;
+      if (inFlight) throw fail('Verifier returned with an unawaited native child; effects are uncertain and cannot be credited.');
+      signal.throwIfAborted(); await verifier.assertCurrent(directory);
+      if (pendingReload || digest(bound) !== digest(await currentContext()) || !result || !['verified', 'needs_correction'].includes(result.status) || !receipts.length || Buffer.byteLength(JSON.stringify(result)) > PAGE_VERIFIER_CONTRACT.max_result_bytes) throw fail('Verifier returned unknown, empty, oversized or stale evidence.');
+      const output = { status: result.status, facts: result.facts ?? null, terminal: result.terminal ?? null, phase, context_digest: digest(bound), context: bound, evidence: receipts, verifier: verifier.descriptor };
+      if (Buffer.byteLength(JSON.stringify(output)) > 24000) throw fail('Complete verifier evidence exceeds the native bound.');
+      return output;
+      } finally {
+        active = false;
+        signal.removeEventListener('abort', rejectAborted);
+        lease.abort(fail('Verifier phase ended; no continuing native child authority.'));
+      }
+    },
+  };
+}