@milpa/comal 0.0.0-stage → 0.1.1

package/src/workflows/chrome-task.mjs

@@ -0,0 +1,292 @@
+import { readFile, realpath } from 'node:fs/promises';
+import path from 'node:path';
+import Ajv from 'ajv';
+import { createHash, randomUUID } from 'node:crypto';
+import { setTimeout as delay } from 'node:timers/promises';
+import { compileGovernance } from '../governance.mjs';
+import { digest, immutable } from '../operations.mjs';
+import { registerWorkOperations, workProjection } from '../work-plan.mjs';
+import { safeRelative, snapshotProject } from '../plugins/chrome-lab/project.mjs';
+
+const prefix = 'plugin__chrome-lab__';
+const PUBLIC = new Set(['Read', 'Edit', 'Write', 'ChromePublish', 'ChromeVerify', 'ChromeTest', 'ChromeFinish', 'ChromeRecover']);
+const OWN = ['ChromePublish', 'ChromeVerify', 'ChromeTest', 'ChromeFinish', 'ChromeRecover'];
+const INTERNAL = new Set(['WorkStepRun', 'WorkTaskUpdate']);
+const empty = { type: 'object', properties: {}, additionalProperties: false };
+const failure = (message, code = 'CHROME_TASK_CONFLICT') => Object.assign(new Error(message), { code });
+const schema = { type: 'object', additionalProperties: false, required: ['project','directory','popup','selector','equals'], properties: {
+  project: { type: 'string', pattern: '^[a-z0-9][a-z0-9-]{0,63}$' },
+  directory: { type: 'string', minLength: 1, maxLength: 220 }, popup: { type: 'string', minLength: 1, maxLength: 220 },
+  selector: { type: 'string', minLength: 1, maxLength: 1000 }, equals: { type: 'string', maxLength: 4000 },
+  tests: { type: 'array', minItems: 1, maxItems: 24, items: { type: 'object', additionalProperties: false, required: ['action'], properties: {
+    action: { enum: ['click','fill','reload','assert'] }, selector: { type: 'string', minLength: 1, maxLength: 1000 }, text: { type: 'string', maxLength: 2000 }, equals: { type: 'string', maxLength: 2000 }, count: { type: 'integer', minimum: 0, maximum: 100 }
+  }, allOf: [
+    { if: { properties: { action: { enum: ['click','fill','assert'] } } }, then: { required: ['selector'] } },
+    { if: { properties: { action: { const: 'fill' } } }, then: { required: ['text'] } },
+    { if: { properties: { action: { const: 'assert' } } }, then: { anyOf: [{ required: ['equals'] }, { required: ['count'] }] } }
+  ] } }
+} };
+const validate = new Ajv({ strict: false }).compile(schema);
+const manifestHash = snapshot => digest(snapshot.files.map(({ path, sha256 }) => ({ path, sha256 })));
+export const savedChromeTask = session => session.rows.findLast(row => row.type === 'chrome_task_accepted' && row.source === 'workflow_host');
+export async function readChromeTask(file) {
+  const bytes = await readFile(file); if (bytes.length > 16384) throw failure('Chrome task exceeds 16 KiB.');
+  let task; try { task = JSON.parse(bytes); } catch { throw failure('Chrome task must be JSON.'); }
+  return normalizeTask(task);
+}
+function normalizeTask(task) {
+  if (!validate(task)) throw failure('Invalid Chrome task: '+validate.errors.map(e => e.instancePath+' '+e.message).join('; '));
+  const value = structuredClone(task); value.directory = safeRelative(value.directory); value.popup = safeRelative(value.popup);
+  return immutable(value);
+}
+
+// Host-owned coordinator. No executor or trust-management API is exposed to plugins.
+export async function prepareChromeTask({ cwd, house, store, sessionId, executor, policy, task, source = 'explicit_cli_file', observeIdentity = true }) {
+  const loaded = await store.load(sessionId);
+  if (!loaded.journalAudit.consistent) throw failure('Invalid session journal.', 'AUDIT_INVALID');
+  const saved = savedChromeTask(loaded);
+  if (!task && !saved) return null;
+  const brief = normalizeTask(task || saved.task), taskDigest = digest(brief);
+  const checkOperation = brief.tests ? 'ChromeTest' : 'ChromeVerify';
+  if (saved && saved.task_digest !== taskDigest) throw failure('El encargo guardado es inmutable; usa una sesión nueva para otro criterio.');
+  const directory = path.resolve(cwd, brief.directory);
+  if (await realpath(directory) !== directory || path.relative(cwd, directory).split(path.sep).includes('..')) throw failure('Task directory must be a real directory inside the workspace.');
+  const catalogue = ['Deploy','Deployment','Open','Targets','Assert','Contexts', ...(brief.tests ? ['Interact'] : [])].map(name => prefix+name);
+  if (catalogue.some(name => !house.registry.get(name))) throw failure('chrome-lab no está activo. Usa npm run lab:chrome -- --chrome-task ARCHIVO.json.');
+  const mechanisms = ['runtime:chrome-task.scope','runtime:chrome-task.close','runtime:chrome-task.artifact-hash'];
+  const compile = async version => compileGovernance(JSON.parse(await readFile(new URL(`../../governance/chrome-task-v${version}.json`, import.meta.url), 'utf8')), mechanisms);
+  const currentPlan = await compile(2), legacyPlan = saved ? await compile(1) : null;
+  const legacy = Boolean(saved && saved.governance_plan_hash === legacyPlan.plan_hash);
+  const plan = legacy ? legacyPlan : currentPlan;
+  if (saved && saved.governance_plan_hash !== plan.plan_hash) throw failure('The accepted workflow policy changed; it cannot be reactivated silently.');
+  // A new acceptance explicitly adopts v2. Historical v1 approvals retain native
+  // text Read and never gain FileInfo access just by resuming on a newer client.
+  const artifactOperation = legacy ? 'Read' : 'FileInfo';
+  const hashOperation = house.registry.get('FileInfo');
+  const nativeHash = hashOperation?.contract;
+  if (!legacy && (!nativeHash || nativeHash.origin !== null || nativeHash.permission !== 'FileInfo' || nativeHash.steps || nativeHash.effects?.workspace !== 'read' || ['external','process','authority'].some(key => nativeHash.effects[key] !== 'none'))) throw failure('Native FileInfo artifact hashing is unavailable.');
+  const work = workProjection(loaded);
+  if (!saved && work) throw failure('La sesión ya tiene trabajo. Inicia una sesión nueva para adoptar el flujo Chrome.');
+  const declaredTask = { id: 'chrome-task', title: 'Implement and verify accepted extension',
+    criterion: `Accepted task ${taskDigest}: exact declared DOM criterion and ${brief.tests?.length || 0} behavior steps; see chrome_task_accepted.`,
+    phase: 'implementation', artifacts: [brief.directory+'/'+brief.popup],
+    checks: [{ step_id: 'browser', operation: checkOperation, arguments: {}, assertions: [{ kind: 'json_equals', pointer: '/status', value: 'verified' }] }] };
+  if (work) {
+    const definitions = loaded.rows[work.plan.ref]?.tasks;
+    const savedDefinition = definitions?.length === 1 ? Object.fromEntries(Object.entries(definitions[0]).filter(([key]) => !['definition_digest','work_digest'].includes(key))) : null;
+    if (work.plan.version !== 1 || digest(savedDefinition) !== digest({ ...declaredTask, depends_on: [] })) throw failure('Saved work does not match the accepted Chrome task.');
+  }
+  const state = async () => {
+    const session = await store.load(sessionId);
+    if (!session.journalAudit.consistent) throw failure('Invalid session journal.', 'AUDIT_INVALID');
+    const accepted = savedChromeTask(session);
+    if (!accepted || accepted.task_digest !== taskDigest) throw failure('Accepted task missing or changed.');
+    const checkpoint = session.rows.findLast(row => row.type === 'chrome_task_checkpoint' && row.task_digest === taskDigest);
+    return { ...(checkpoint?.state || { stage: 'new', status: 'ready' }) };
+  };
+  const snapshot = signal => snapshotProject(cwd, brief.directory, { signal });
+  const save = (options, value) => options.recordWork({ type: 'chrome_task_checkpoint', source: 'workflow_host', task_digest: taskDigest, state: value });
+  const invoke = async (options, name, input) => JSON.parse(await options.invoke(prefix+name, input, { signal: options.signal }));
+  const assertReady = value => { if (value.stage.endsWith('_pending') || value.status === 'uncertain') throw failure('Publicación incierta: no se repite. Requiere reconciliación explícita.', 'CHROME_TASK_UNCERTAIN'); };
+  const verify = async (options, runTests = false) => {
+    const value = await state(); assertReady(value);
+    if (!value.deployment) throw failure('Publica primero con ChromePublish; no hay una publicación registrada.');
+    if (manifestHash(await snapshot(options.signal)) !== value.source_digest) throw failure('Los archivos cambiaron desde la publicación. Usa ChromePublish antes de verificar.', 'CHROME_TASK_STALE_SOURCE');
+    const url = `chrome-extension://${value.deployment.extension_id}/${brief.popup}`;
+    const resolve = async () => {
+      const targets = (await invoke(options, 'Targets', {})).targets.filter(t => t.project === brief.project && t.type === 'page' && t.url === url);
+      if (targets.length !== 1) throw failure('Popup propio ausente o ambiguo; no se abre ni elige otra pestaña.');
+      value.binding = { target_id: targets[0].target_id, project: brief.project, url };
+      await save(options, value);
+      if (observeIdentity) {
+        let observed;
+        for (let attempt = 0; attempt < 8; attempt++) {
+          observed = await invoke(options, 'Contexts', { target_id: value.binding.target_id });
+          if (observed.identity?.context_unique_id && observed.identity?.connection_id) break;
+          await delay(100, undefined, { signal: options.signal });
+        }
+        if (!observed.identity?.context_unique_id || !observed.identity?.connection_id) throw failure('Document/connection identity unavailable.');
+        value.binding.identity = observed.identity; await save(options, value);
+      }
+    };
+    await resolve();
+    let result;
+    try { result = await invoke(options, 'Assert', { target_id: value.binding.target_id, selector: brief.selector, equals: brief.equals, timeout_ms: 0 }); }
+    catch (error) { let missing = false; try { missing = JSON.parse(error.message).code === 'CHROME_TARGET_MISSING'; } catch {} if (!missing) throw error; await resolve(); result = await invoke(options, 'Assert', { target_id: value.binding.target_id, selector: brief.selector, equals: brief.equals, timeout_ms: 0 }); }
+    const tests = [];
+    if (runTests && result.passed) for (const [index, step] of brief.tests.entries()) {
+      if (step.action === 'assert') {
+        const observed = await invoke(options, 'Assert', { target_id: value.binding.target_id, selector: step.selector, ...(step.equals !== undefined ? { equals: step.equals } : {}), ...(step.count !== undefined ? { count: step.count } : {}), timeout_ms: 1000 });
+        tests.push({ index, passed: observed.passed, observed: observed.observed });
+        if (!observed.passed) { result.passed = false; break; }
+      } else {
+        value.stage = 'test_pending'; await save(options, value);
+        await invoke(options, 'Interact', { target_id: value.binding.target_id, action: step.action, ...(step.selector ? { selector: step.selector } : {}), ...(step.action === 'fill' ? { text: step.text } : {}) });
+        value.stage = 'testing'; await save(options, value);
+        if (step.action === 'reload') await resolve();
+        tests.push({ index, executed: true });
+      }
+    }
+    if (observeIdentity) {
+      const after = await invoke(options, 'Contexts', { target_id: value.binding.target_id });
+      if (digest(after.identity) !== digest(value.binding.identity)) throw failure('Document/connection changed during verification.');
+    }
+    if (result.observed?.url !== url || manifestHash(await snapshot(options.signal)) !== value.source_digest) throw failure('Evidence no longer matches source/resource.');
+    value.status = result.passed ? 'verified' : 'needs_correction'; value.stage = 'checked'; value.verified_scope = runTests ? 'declared_behavior' : 'declared_dom';
+    await save(options, value);
+    return { status: value.status, scope: value.verified_scope, task_digest: taskDigest, source_digest: value.source_digest, binding: value.binding, observed: result.observed, ...(runTests ? { tests } : {}), asked: 'unjudged' };
+  };
+  const operation = (name, description, run, external) => ({ name, description, input_schema: empty, steps: true,
+    effects: { workspace: 'read', external, process: 'spawn', authority: 'none' },
+    run: async (_, options) => {
+      if (options.sessionId !== sessionId) throw failure('Operation belongs to another task/session.');
+      return run(options);
+    } });
+  house.registry.replace(OWN, [
+    operation('ChromePublish', 'Publish the accepted extension and observe its fixed DOM criterion. The host manages project, target and versions. If needs_correction, edit source then publish again. Never retries an uncertain mutation. Every child retains permissions.', async options => {
+      const old = await state(); assertReady(old);
+      const before = await snapshot(options.signal);
+      const continuing = old.stage === 'reconciled' || old.recovery_pending && manifestHash(before) === old.source_digest;
+      if (continuing && manifestHash(before) !== old.source_digest) throw failure('El candidato reconciliado cambió; conserva su snapshot antes de continuar.', 'CHROME_TASK_STALE_SOURCE');
+      const value = continuing ? { ...old } : { stage: 'deploy_pending', status: 'ready', source_digest: manifestHash(before), file_manifest_sha256: createHash('sha256').update(JSON.stringify(before.files.map(({path,sha256})=>({path,sha256})))).digest('hex'), attempt_id: randomUUID() }; await save(options, value);
+      try {
+        if (!continuing) value.deployment = await invoke(options, 'Deploy', { project: brief.project, directory: brief.directory, attempt_id: value.attempt_id });
+        if (value.deployment.project !== brief.project) throw failure('Deployment returned another project.');
+        if (value.deployment.attempt_id !== value.attempt_id) throw failure('Deployment returned another attempt.');
+        if (!value.deployment.file_manifest_sha256 || value.deployment.file_manifest_sha256 !== createHash('sha256').update(JSON.stringify(before.files.map(({path,sha256})=>({path,sha256})))).digest('hex')) throw failure('Deployment snapshot differs from the accepted local candidate.');
+        if(!continuing || !value.recovery_popup_observed){
+          value.stage = 'open_pending'; await save(options, value);
+          await invoke(options, 'Open', { url: `chrome-extension://${value.deployment.extension_id}/${brief.popup}` });
+        }
+        value.stage = 'published'; await save(options, value);
+      } catch (error) {
+        value.status = ['HOUSE_REFUSED','HOUSE_GUARD','GOVERNANCE_REFUSED'].includes(error.code) ? 'refused' : 'uncertain';
+        if (value.status === 'refused') value.stage = 'refused'; await save(options, value); throw error;
+      }
+      const result=await verify(options);
+      if(continuing){const current=await state();delete current.recovery_pending;delete current.recovery_popup_observed;await save(options,current);}
+      return result;
+    }, 'write'),
+    operation('ChromeRecover', 'Explicit read-only recovery after a publication/connection interruption. Reconnects, matches the durable attempt and physical remote snapshot to the accepted local candidate. Never repeats Deploy/Open/Interact. A missing popup after confirmed Deploy returns recovered with next_action ChromePublish, which opens it without publishing again. Unknown interactions and ambiguous/missing evidence remain blocked.', async options => {
+      const old = await state();
+      if (!old.attempt_id || !old.file_manifest_sha256 || !['deploy_pending','open_pending','reconciled','published','checked'].includes(old.stage)) throw failure('Este checkpoint no permite reconciliar publicación; interacciones inciertas e intentos legacy siguen bloqueados.', 'CHROME_TASK_UNCERTAIN');
+      if (manifestHash(await snapshot(options.signal)) !== old.source_digest) throw failure('El candidato local cambió desde el intento pendiente.', 'CHROME_TASK_STALE_SOURCE');
+      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 failure('La observación remota no coincide con el intento/snapshot pendiente; no se repite ni adopta otra publicación.', 'CHROME_TASK_UNCERTAIN');
+      const url = `chrome-extension://${remote.extension_id}/${brief.popup}`;
+      const targets = (await invoke(options, 'Targets', {})).targets.filter(t=>t.project===brief.project && t.type==='page' && t.url===url);
+      if (targets.length>1 || old.stage==='open_pending' && targets.length!==1 || ['published','checked'].includes(old.stage) && targets.length!==1) throw failure('Popup ausente o ambiguo; una apertura incierta no se repite.', 'CHROME_TASK_UNCERTAIN');
+      if (manifestHash(await snapshot(options.signal)) !== old.source_digest) throw failure('El candidato cambió durante la reconciliación.', 'CHROME_TASK_STALE_SOURCE');
+      const value = { ...old, deployment: remote, status: 'ready', stage: targets.length ? 'published' : 'reconciled',recovery_pending:true,recovery_popup_observed:targets.length===1 };
+      delete value.binding; delete value.verified_scope;
+      await options.recordWork({ type: 'chrome_task_reconciled', source: 'workflow_host', task_digest: taskDigest, attempt_id: old.attempt_id, previous_stage: old.stage, deployment: remote, popup_observed: targets.length===1, claim: 'observed_publication_and_source_not_functional_delivery' });
+      await save(options, value);
+      if (targets.length) return verify(options);
+      return { status: 'recovered', stage: value.stage, attempt_id: value.attempt_id, next_action: 'ChromePublish', note: 'Publicación observada; ChromePublish sólo abrirá el popup y verificará. No repite Deploy.' };
+    }, 'read'),
+    operation('ChromeVerify', 'Read the accepted own popup and check its fixed criterion against the currently published source and fresh document identity. No publication or navigation. Failed criterion means correct source and publish.', verify, 'read'),
+    ...(brief.tests ? [operation('ChromeTest', 'Run the accepted interaction/assertion sequence on the own popup. This writes test data and may reload; each child retains permissions. No test steps or targets to supply. A partial/uncertain interaction stops the sequence.', options => verify(options, true), 'write')] : []),
+    operation('ChromeFinish', 'Verify the declared browser check and close the accepted work with fresh evidence. No versions/IDs/criteria to supply. Returns done only after the host check; does not authorize publishing elsewhere.', async options => {
+      const current = workProjection(await store.load(sessionId));
+      if (current?.counts.done === 1) { const result = JSON.parse(await options.invoke(checkOperation, {}, { signal: options.signal })); if (result.status !== 'verified') throw failure('Current browser criterion failed.', 'WORK_UNVERIFIED'); return { status: 'done', reobserved: true, asked: 'unjudged' }; }
+      if (!current?.current || current.current.id !== 'chrome-task') throw failure('Accepted work unavailable.');
+      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', scope: 'declared_work_checks', asked: 'unjudged' };
+    }, 'read')
+  ]);
+  registerWorkOperations({ store, house, artifactObservation: { sessionId, operation: artifactOperation } });
+  if (!saved) {
+    await store.append(sessionId, { type: 'chrome_task_accepted', source: 'workflow_host', acceptance: source, task: brief, task_digest: taskDigest, governance_plan_hash: plan.plan_hash, governance_profile: plan.profile, artifact_observation: { operation: artifactOperation, hash: true, paths: declaredTask.artifacts } });
+    await store.append(sessionId, { type: 'intent', text: `Accepted Chrome task: ${brief.project}, directory ${brief.directory}, popup ${brief.popup}, ${brief.selector} equals ${JSON.stringify(brief.equals)}. Publish, correct and verify only this own extension; no extra permissions.` });
+  }
+  const scope = async view => {
+    if (policy.denied.has(view.operation)) return { allowed: false, reason: 'Explicit session deny.' };
+    if (view.operation === 'WorkPlanSet' || view.operation === 'WorkCheckRepair') return { allowed: false, reason: 'Accepted task/criterion is immutable in this workflow.' };
+    if (view.actor.kind === 'human' || view.surface === 'internal') return true;
+    if (['Read','Edit','Write'].includes(view.operation)) {
+      const relative = path.relative(directory, path.resolve(cwd, view.input.file_path));
+      return { allowed: Boolean(relative) && !path.isAbsolute(relative) && !relative.split(path.sep).some(part => part === '..' || ['.git','.comal','.harness','.ssh','node_modules'].includes(part) || /^\.env(?:\.|$)/i.test(part)), reason: 'Only files of the accepted extension.' };
+    }
+    if (!legacy && view.operation === 'FileInfo') return { allowed: true, reason: 'Subject to the separately enforced artifact-hash capability.' };
+    if (OWN.includes(view.operation)) return true;
+    if (INTERNAL.has(view.operation)) return { allowed: ['ChromeFinish','WorkTaskUpdate'].includes(view.parent_operation), reason: 'Work administration belongs to the coordinator.' };
+    if (view.operation.startsWith(prefix)) {
+      if (!['ChromePublish','ChromeVerify','ChromeTest','ChromeRecover'].includes(view.parent_operation)) return { allowed: false, reason: 'Use the offered domain action.' };
+      const value = await state();
+      if (view.operation === prefix+'Deployment') return view.parent_operation === 'ChromeRecover' && view.input.project === brief.project;
+      if (view.operation === prefix+'Deploy') return view.parent_operation === 'ChromePublish' && view.input.project === brief.project && view.input.directory === brief.directory && view.input.attempt_id === value.attempt_id;
+      if (view.operation === prefix+'Open') return view.parent_operation === 'ChromePublish' && view.input.url === `chrome-extension://${value.deployment?.extension_id}/${brief.popup}`;
+      if (view.operation === prefix+'Targets') return true;
+      if (view.operation === prefix+'Interact') return view.parent_operation === 'ChromeTest' && view.input.target_id === value.binding?.target_id && brief.tests.some(step => step.action === view.input.action && step.selector === view.input.selector && (step.action !== 'fill' || step.text === view.input.text));
+      if (['Contexts','Assert'].some(name => view.operation === prefix+name)) return view.input.target_id === value.binding?.target_id && (view.operation !== prefix+'Assert' || view.input.selector === brief.selector && view.input.equals === brief.equals || view.parent_operation === 'ChromeTest' && brief.tests.some(step => step.action === 'assert' && step.selector === view.input.selector && step.equals === view.input.equals && step.count === view.input.count));
+    }
+    return { allowed: false, reason: 'Operation outside this accepted workflow surface.' };
+  };
+  const artifactHash = view => ({
+    allowed: !policy.denied.has(view.operation) && view.contract_digest === hashOperation?.digest &&
+      ['WorkStepRun','WorkTaskUpdate'].includes(view.parent_operation) &&
+      digest(view.input) === digest({ file_path: declaredTask.artifacts[0], hash: true }),
+    reason: 'Only native full-file hashing of the exact accepted artifact by the host work coordinator.'
+  });
+  const close = async view => {
+    if (view.input.status !== 'done') return true;
+    const value = await state();
+    return { allowed: view.parent_operation === 'ChromeFinish' && value.status === 'verified' && value.verified_scope === (brief.tests ? 'declared_behavior' : 'declared_dom') && manifestHash(await snapshot()) === value.source_digest, reason: 'Closure requires fresh evidence from the accepted candidate and host coordinator.' };
+  };
+  // Seed only the exact host work before activation. A partial initialization is
+  // recoverable from the accepted declaration; it never republishes an extension.
+  if (!workProjection(await store.load(sessionId))) await executor.execute('WorkPlanSet', { objective: `Verify accepted Chrome 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' });
+  await house.activateGovernance({ sessionId, plan, bindings: {
+    'runtime:chrome-task.scope': { revision: legacy ? 'chrome-scope-v3' : 'chrome-scope-v4', operations: ['*'], configuration_digest: taskDigest, check: scope },
+    'runtime:chrome-task.close': { revision: 'chrome-close-v1', operations: ['WorkTaskUpdate'], configuration_digest: taskDigest, check: close },
+    ...(!legacy ? { 'runtime:chrome-task.artifact-hash': { revision: 'chrome-artifact-hash-v1', operations: ['FileInfo'], configuration_digest: digest({ taskDigest, artifacts: declaredTask.artifacts, contract_digest: hashOperation.digest }), check: artifactHash } } : {})
+  } });
+  const project = snapshot => {
+    const definitions = snapshot.definitions().filter(tool => PUBLIC.has(tool.name));
+    const offered = new Set(definitions.map(tool => tool.name));
+    return { ...snapshot, definitions: () => definitions,
+      execute: (name, input, options = {}) => {
+        if (options.modelProposed && !offered.has(name)) throw failure('Use the offered domain actions; administration belongs to the house.', 'HOUSE_SURFACE_CHANGED');
+        return snapshot.execute(name, input, options);
+      }
+    };
+  };
+  const retireObservationRecovery=house.registerRecovery(sessionId,'ChromeRecover',async()=>({kind:'chrome_observation_retry'}));
+  const retireRecovery=house.registerRecovery(sessionId,'ChromePublish',async({proposal,executor:recoveryExecutor,signal})=>{
+    const before=await store.load(sessionId), checkpointRef=before.rows.findLastIndex(r=>r.type==='chrome_task_checkpoint' && r.source==='workflow_host' && r.task_digest===taskDigest);
+    const checkpoint=before.rows[checkpointRef], original=before.rows.findLast(r=>r.type==='chrome_task_checkpoint' && r.source==='workflow_host' && r.invocation_id===proposal.invocation_id && r.task_digest===taskDigest);
+    if(!original?.state.attempt_id || checkpoint?.state.attempt_id!==original.state.attempt_id || checkpoint.state.source_digest!==original.state.source_digest)throw failure('El intento huérfano no coincide con el checkpoint vigente.', 'CHROME_TASK_UNCERTAIN');
+    const callId=randomUUID();await recoveryExecutor.execute('ChromeRecover',{}, {signal,callId});
+    const after=await store.load(sessionId), observationRef=after.rows.findLastIndex(r=>r.type==='house_receipt' && r.operation==='ChromeRecover' && r.call_id===callId && r.status==='returned'), observation=after.rows[observationRef];
+    const reconciliationRef=after.rows.findLastIndex(r=>r.type==='chrome_task_reconciled' && r.source==='workflow_host' && r.invocation_id===observation?.invocation_id && r.task_digest===taskDigest);
+    if(observationRef<0 || reconciliationRef<0)throw failure('La reconciliación no quedó asentada.', 'CHROME_TASK_UNCERTAIN');
+    return {checkpoint_ref:checkpointRef,observation_ref:observationRef,reconciliation_ref:reconciliationRef};
+  });
+  return { task: brief, taskDigest, plan,
+    system: `Host-managed Chrome task: ${JSON.stringify(brief)}. Policy ${plan.plan_hash}. Work is accepted and active. Read/Edit/Write only its source. ChromePublish deploys and observes; ChromeVerify observes without publication; ${brief.tests ? 'ChromeTest executes the declared behavior tests; ' : ''}ChromeFinish executes the declared check and closes. After a publication/connection interruption, use ChromeRecover to reconcile by reads; never repeat uncertain publication. If it returns recovered, ChromePublish continues without Deploy. Uncertain test interactions remain blocked. No administrative IDs or criteria to supply. Correct failed criteria and publish again. Refusal, uncertainty and pauses are not delivery. Give your final report only after ChromeFinish returns done.`,
+    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 finishResult(final, context) {
+      let delivery = { status: 'open', task_digest: taskDigest, governance_plan_hash: plan.plan_hash, asked: 'unjudged' };
+      const session = await store.load(sessionId);
+      const closed = session.rows.slice(context.baseline).findLast(row => row.type === 'house_receipt' && row.operation === 'ChromeFinish' && row.status === 'returned' && row.governance_plan_hash === plan.plan_hash);
+      if (!final.is_error && !final.work_stop_reason && closed) {
+        try {
+          const result = JSON.parse(await executor.execute(checkOperation, {}, { signal: context.signal }));
+          if (result.status !== 'verified') throw failure('Final criterion failed.');
+          const verified = (await store.load(sessionId)).rows.findLast(row => row.type === 'house_receipt' && row.operation === checkOperation && row.status === 'returned');
+          delivery = { ...delivery, status: 'verified', scope: brief.tests ? 'declared_behavior_and_source_snapshot' : 'declared_dom_criterion_and_source_snapshot', receipt_id: verified.invocation_id, source_digest: result.source_digest, binding: result.binding };
+        } catch (error) {
+          delivery = { ...delivery, status: 'needs_verification', code: error.code || 'CHROME_TASK_FINAL_CHECK' };
+          final.is_error = true; final.work_stop_reason = 'verification_failed';
+          final.result += '\nCasa: la comprobación final falló; entrega sin acreditar.';
+        }
+      }
+      final.delivery = delivery;
+      await store.append(sessionId, { type: 'chrome_task_delivery', source: 'workflow_host', ...delivery });
+    },
+    dispose: () => {retireRecovery();retireObservationRecovery(); house.retireGovernance(sessionId); house.registry.replace(OWN, []); }
+  };
+}