@milpa/comal 0.1.6 → 0.2.0

package/src/workflows/chrome-task.mjs

@@ -1,4 +1,4 @@
-import { readFile, realpath } from 'node:fs/promises';
+import { readFile, realpath, stat, lstat } from 'node:fs/promises';
 import path from 'node:path';
 import Ajv from 'ajv';
 import { createHash, randomUUID } from 'node:crypto';
@@ -6,27 +6,37 @@ 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';
+import { CHROME_SOURCE_NAMES, bindChromeSource } from './chrome-source.mjs';
+import { PAGE_PREVIEW_RECOVERY_V13 } from './chrome-page-recovery-v13.mjs';
+import { suppliedInputsSchema, normalizeSuppliedInputs, verifySuppliedInputs, isSuppliedPath, assertSuppliedSnapshot } from './chrome-supplied-inputs.mjs';
+import { safeRelative, snapshotProject, chromeProjectNameSchema } 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 PUBLIC = new Set(['Read', 'Edit', 'Write', 'ChromePublish', 'ChromeVerify', 'ChromeTest', 'ChromeFinish', 'ChromeRecover', 'ChromeInspect', 'ChromeDeliver']);
+const OWN = ['ChromePublish', 'ChromeVerify', 'ChromeTest', 'ChromeFinish', 'ChromeRecover', 'ChromeInspect', 'ChromeDeliver'];
 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}$' },
+export const chromeTaskSchema = { type: 'object', additionalProperties: false, required: ['project','directory'], properties: {
+  surface: { const: 'page' },
+  publication_recovery: {const:PAGE_PREVIEW_RECOVERY_V13},
+  verification: { type: 'object', required: ['implementation_sha256', 'contract_digest', 'criteria_digest', 'criteria'], additionalProperties: false, properties: { implementation_sha256: { type: 'string', pattern: '^[a-f0-9]{64}$' }, contract_digest: { type: 'string', pattern: '^[a-f0-9]{64}$' }, criteria_digest: { type: 'string', pattern: '^[a-f0-9]{64}$' }, criteria: { type: 'object' }, cases: { type: 'array', minItems: 1, maxItems: 24, uniqueItems: true, items: { type: 'string', pattern: '^[a-z][a-z0-9_-]{0,95}$' } } } },
+  project: chromeProjectNameSchema,
   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 }
+  fixture: {type:'object',additionalProperties:false,required:['file','selector','equals'],properties:{file:{type:'string',minLength:1,maxLength:220},selector:{type:'string',minLength:1,maxLength:1000},equals:{type:'string',maxLength:2000}},description:'An existing immutable HTML test page served on Win11 localhost. The house binds its exact target and checks content-script behavior; residents cannot edit the fixture.'},
+  supplied_inputs: suppliedInputsSchema,
+  baseline: {type:'boolean',description:'Only when the user requests an initial observation before edits. The house publishes and observes the accepted initial bytes first; this grants no permission.'},
+  tests: { type: 'array', minItems: 1, maxItems: 32, items: { type: 'object', additionalProperties: false, required: ['action'], properties: {
+    surface:{enum:['popup','page']}, action: { enum: ['click','fill','reload','assert','message'] }, request:{type:'string',minLength:1,maxLength:128}, 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: 'message' } } }, then: { required: ['request','equals'] } },
     { if: { properties: { action: { const: 'assert' } } }, then: { anyOf: [{ required: ['equals'] }, { required: ['count'] }] } }
   ] } }
-} };
-const validate = new Ajv({ strict: false }).compile(schema);
+}, allOf: [{ if: { required: ['surface'], properties: { surface: { const: 'page' } } }, then: { required: ['fixture', 'supplied_inputs', 'verification'], not: { anyOf: ['popup', 'selector', 'equals', 'tests', 'baseline'].map(key => ({ required: [key] })) } }, else: { required: ['popup', 'selector', 'equals'], not: { anyOf:[{required:['verification']},{required:['publication_recovery']}] } } }] };
+const validate = new Ajv({ strict: false }).compile(chromeTaskSchema);
 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) {
@@ -34,32 +44,81 @@ export async function readChromeTask(file) {
   let task; try { task = JSON.parse(bytes); } catch { throw failure('Chrome task must be JSON.'); }
   return normalizeTask(task);
 }
-function normalizeTask(task) {
+export function normalizeTask(task) {
+  if (Buffer.byteLength(JSON.stringify(task)) > 16384) throw failure('Chrome task exceeds 16 KiB. Keep the contract bounded; preserve its functional criteria.');
   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);
+  const value = structuredClone(task); value.directory = safeRelative(value.directory); if(value.popup)value.popup = safeRelative(value.popup); if(value.fixture)value.fixture.file=safeRelative(value.fixture.file);if(value.supplied_inputs)normalizeSuppliedInputs(value.supplied_inputs); if(value.tests?.some(t=>t.surface==='page')&&!value.fixture)throw failure('Page steps require an immutable fixture.'); if(value.tests?.some(t=>t.surface==='page'&&t.action==='message'))throw failure('Typed worker messages require the popup surface.');
+  if (value.surface === 'page' && (value.verification.criteria_digest !== digest(value.verification.criteria) || Buffer.byteLength(JSON.stringify(value.verification.criteria)) > 4000)) throw failure('Page criteria identity changed or exceeds 4 KiB.');
   return immutable(value);
 }
+export async function validateTaskDirectory(cwd, relative) {
+  const directory = path.resolve(cwd, safeRelative(relative));
+  if (path.relative(cwd, directory).split(path.sep).includes('..')) throw failure('Task directory must stay inside the workspace.');
+  let ancestor = directory;
+  for (;;) {
+    try {
+      if (await realpath(ancestor) !== ancestor || !(await stat(ancestor)).isDirectory()) throw failure('Task directory must use real directories inside the workspace.');
+      break;
+    } catch (error) { if (error.code !== 'ENOENT' || ancestor === cwd) throw error; ancestor = path.dirname(ancestor); }
+  }
+  if (path.relative(cwd, directory).split(path.sep).some(part => ['.git','.comal','.harness','.ssh','node_modules'].includes(part) || /^\.env(?:\.|$)/i.test(part))) throw failure('Protected task directory.');
+  return directory;
+}
+
+// A fixture can predate the extension. Reading its identity must not require
+// manifest.json or a complete publishable candidate at conversational entry.
+export async function chromeFixtureDigest(cwd, task) {
+  const directory = await validateTaskDirectory(cwd, task.directory);
+  const file = path.join(directory, safeRelative(task.fixture.file));
+  const before = await lstat(file);
+  if (!before.isFile() || await realpath(file) !== file || before.size > 10000000) throw failure('The immutable fixture must be a bounded regular file without symlink aliases.', 'CHROME_TASK_FIXTURE_CHANGED');
+  const bytes = await readFile(file), after = await lstat(file);
+  if (!after.isFile() || await realpath(file) !== file || before.ino !== after.ino || before.size !== after.size || before.mtimeMs !== after.mtimeMs || bytes.length !== before.size) throw failure('The immutable fixture changed while reading.', 'CHROME_TASK_FIXTURE_CHANGED');
+  return createHash('sha256').update(bytes).digest('hex');
+}
 
 // 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 }) {
+export async function prepareChromeTask({ cwd, house, store, sessionId, executor, policy, task, source = 'explicit_cli_file', provenance, observeIdentity = true, sourceEditFacts = false, verifier, publicationRecoveryGuard, checkpointProjection }) {
   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);
+  if (brief.surface === 'page') return (await import('./chrome-page-task.mjs')).prepareChromePageTask({ cwd, house, store, sessionId, executor, policy, task: brief, source, provenance, verifier, publicationRecoveryGuard, checkpointProjection });
   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 directory = await validateTaskDirectory(cwd, brief.directory);
   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;
+  const currentPlan = await compile(brief.supplied_inputs?10:9), historical = saved ? await Promise.all([compile(1), compile(2), compile(3), compile(4), compile(5), compile(6), compile(7), compile(8), compile(9), compile(10)]) : [];
+  const plan = historical.find(plan => saved?.governance_plan_hash === plan.plan_hash) || currentPlan;
+  const legacy = plan.profile.version === '1', inspection = Number(plan.profile.version) >= 3, currency = Number(plan.profile.version) >= 4, pipeline = Number(plan.profile.version) >= 5, pages = Number(plan.profile.version) >= 6, documentProof=Number(plan.profile.version)>=7, workerInspection=Number(plan.profile.version)>=8, retainedSource=Number(plan.profile.version)>=9,suppliedInputs=Number(plan.profile.version)>=10;
+  if(brief.supplied_inputs&&!suppliedInputs)throw failure('Supplied inputs require their original v10 task policy.');
+  const suppliedDigest=brief.supplied_inputs?digest(brief.supplied_inputs):null;
+  if(suppliedDigest){
+    if(saved&&saved.supplied_inputs_digest!==suppliedDigest||provenance?.supplied_inputs_digest&&provenance.supplied_inputs_digest!==suppliedDigest)throw failure('The accepted supplied-input manifest changed.','CHROME_TASK_INPUT_CHANGED');
+    await verifySuppliedInputs(directory,brief.supplied_inputs);
+  }
+  let fixtureSource=null;
+  if(brief.fixture){
+    if(!pages||!house.registry.get(prefix+'Preview')||!house.registry.get(prefix+'CloseTab'))throw failure('Fixture coordination requires the current policy and Preview/CloseTab operations.');
+    fixtureSource=await chromeFixtureDigest(cwd,brief);
+    if(saved&&saved.fixture_source_digest!==fixtureSource || provenance?.fixture_source_digest&&provenance.fixture_source_digest!==fixtureSource)throw failure('The immutable test fixture changed.','CHROME_TASK_FIXTURE_CHANGED');
+  }
+  let baselineSource = null;
+  if(brief.baseline){
+    if(!pipeline)throw failure('Initial baseline coordination requires the current task policy.');
+    baselineSource=saved?.baseline_source_digest || provenance?.baseline_source_digest || manifestHash(await snapshotProject(cwd,brief.directory));
+    if(!/^[a-f0-9]{64}$/.test(baselineSource)||!saved&&manifestHash(await snapshotProject(cwd,brief.directory))!==baselineSource)throw failure('The original baseline candidate changed before adoption.','CHROME_TASK_STALE_SOURCE');
+  }
+  if (brief.tests?.some(step=>step.action==='message') && (!pipeline || !house.registry.get(prefix+'Message'))) throw failure('Typed worker messaging requires the current Chrome task policy and Message operation.');
+  if (inspection && ['ReadDOM', 'Console'].some(name => !house.registry.get(prefix + name))) throw failure('Chrome Lab DOM/console observations are unavailable.');
+  if(workerInspection&&!house.registry.get(prefix+'WorkerDiagnostics'))throw failure('Scoped native worker diagnostics are unavailable.');
   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
+  // Existing task semantics retain their original policy; supplied inputs explicitly opt into v10. Historical approvals keep their original policy.
+  // 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');
@@ -84,73 +143,188 @@ export async function prepareChromeTask({ cwd, house, store, sessionId, executor
     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 snapshot = async signal => {if(suppliedDigest)await verifySuppliedInputs(directory,brief.supplied_inputs,{signal});const result=await snapshotProject(cwd, brief.directory, { signal }); if(fixtureSource&&result.files.find(f=>f.path===brief.fixture.file)?.sha256!==fixtureSource)throw failure('The immutable test fixture changed.','CHROME_TASK_FIXTURE_CHANGED');if(suppliedDigest)assertSuppliedSnapshot(result,brief.supplied_inputs); return result;};
   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 observeDocument = async (options,binding,previousIdentity) => {
+    if(!observeIdentity)return;
+    const started=Date.now();let observed;
+    for(;;){
+      try{observed=await invoke(options,'Contexts',{target_id:binding.target_id});}catch(error){let detail;try{detail=JSON.parse(error.message);}catch{}if(detail?.code!=='CHROME_TARGET_NAVIGATING')throw error;}
+      const identity=observed?.identity;
+      if(identity?.context_unique_id&&identity?.connection_id&&(!previousIdentity||identity.context_unique_id!==previousIdentity.context_unique_id)){
+        if(previousIdentity&&(identity.connection_id!==previousIdentity.connection_id||identity.browser_endpoint_id!==previousIdentity.browser_endpoint_id))throw failure('The connection changed during document renewal.','CHROME_TASK_RELOAD_UNCERTAIN');
+        binding.identity=identity;return;
+      }
+      if(Date.now()-started>=3000)throw failure(previousIdentity?'Reload was dispatched but a new document was not observed; do not replay it.':'Document/connection identity unavailable.',previousIdentity?'CHROME_TASK_RELOAD_UNCERTAIN':'CHROME_TASK_UNCERTAIN');
+      await delay(100,undefined,{signal:options.signal});
+    }
+  };
+  const fixtureBinding = async (options,value,previousIdentity) => {
+    if(!brief.fixture)return;
+    const bound=value.fixture_binding;if(!bound)throw failure('No recorded fixture target. Publish the complete candidate.','CHROME_TASK_FIXTURE_MISSING');
+    const started=Date.now();for(;;){const live=(await invoke(options,'Targets',{})).targets,target=live.find(t=>t.target_id===bound.target_id);
+      if(target?.type==='page'&&target.url===bound.url)break;
+      if(!previousIdentity||target?.url&&target.url!=='about:blank'||Date.now()-started>=3000)throw failure('The exact owned fixture target changed.','CHROME_TASK_TARGET_CHANGED');
+      await delay(100,undefined,{signal:options.signal});
+    }
+    await observeDocument(options,bound,previousIdentity);await save(options,value);
+  };
+  const publishFixture = async (options,value,old) => {
+    if(!brief.fixture)return;
+    if(old.fixture_binding){
+      value.fixture_binding=old.fixture_binding;await save(options,value);
+      const found=(await invoke(options,'Targets',{})).targets.find(t=>t.target_id===old.fixture_binding.target_id);
+      if(found){
+        if(found.url!==old.fixture_binding.url)throw failure('Fixture navigation changed; cannot refresh a different resource.','CHROME_TASK_TARGET_CHANGED');
+        await fixtureBinding(options,value);const previousIdentity=documentProof?value.fixture_binding.identity:undefined;value.stage='fixture_reload_pending';await save(options,value);
+        await invoke(options,'Interact',{target_id:found.target_id,action:'reload'});
+        await fixtureBinding(options,value,previousIdentity);value.fixture_document_transition={before:previousIdentity,after:value.fixture_binding.identity};await save(options,value);return;
+      }
+    }
+    value.stage='fixture_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 failure('Preview returned a different fixture resource.','CHROME_TASK_TARGET_CHANGED');
+    value.fixture_binding={target_id:opened.target_id,url:opened.url,project:brief.project,fixture_source_digest:fixtureSource};await save(options,value);await fixtureBinding(options,value);
+  };
+  const verify = async (options, runTests = false, rerun = 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.');
+    const resolve = async previousIdentity => {
+      let targets;const started=Date.now();for(;;){targets=(await invoke(options,'Targets',{})).targets.filter(t=>t.project===brief.project&&t.type==='page'&&t.url===url);if(targets.length===1)break;if(targets.length>1||!previousIdentity||Date.now()-started>=3000)throw failure('Popup propio ausente o ambiguo; no se abre ni elige otra pestaña.');await delay(100,undefined,{signal:options.signal});}
       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 observeDocument(options,value.binding,previousIdentity);await save(options,value);
     };
     await resolve();
+    await fixtureBinding(options,value);
+    const initialBindings=value.fixture_binding?structuredClone({popup:value.binding,page:value.fixture_binding}):null;
+    let publicationObservation;
+    if (currency && runTests) {
+      const observed = await invoke(options, 'Deployment', { project: brief.project, reconnect: false });
+      if (observed.status !== 'observed' || observed.project !== brief.project || observed.attempt_id !== value.attempt_id || observed.file_manifest_sha256 !== value.file_manifest_sha256 || observed.extension_id !== value.deployment.extension_id) throw failure('The physical publication no longer matches this candidate. Publish the accepted source before testing; no interaction executed.', 'CHROME_TASK_REMOTE_CHANGED');
+      publicationObservation = (await store.load(sessionId)).rows.findLast(row => row.type === 'house_receipt' && row.parent_invocation_id === options.invocation_id && row.operation === prefix + 'Deployment' && row.status === 'returned')?.invocation_id;
+    }
+    let evidenceReuse;
+    if (currency && runTests && observeIdentity && value.behavior_invocation_id) {
+      const book = await store.load(sessionId);
+      const receipt = book.rows.findLast(row => row.type === 'house_receipt' && row.invocation_id === value.behavior_invocation_id && row.operation === 'ChromeTest');
+      if (!receipt || receipt.status !== 'returned') throw failure('The previous behavior execution has no successful durable receipt; uncertain tests cannot be repeated or credited.', 'CHROME_TASK_UNCERTAIN');
+      const previous = JSON.parse(receipt.output);
+      const lastEffect = brief.tests.findLastIndex(step => step.action !== 'assert');
+      if (!rerun && lastEffect < brief.tests.length - 1 && receipt.governance_plan_hash === plan.plan_hash && receipt.output_digest === digest(receipt.output) && previous.status === 'verified' && previous.scope === 'declared_behavior' && !previous.evidence_reuse && previous.task_digest === taskDigest && previous.source_digest === value.source_digest && digest(previous.binding) === digest(value.binding) && (!brief.fixture || digest(previous.bindings)===digest(initialBindings)) && previous.tests?.length === brief.tests.length && previous.tests.every((test,index) => test.index === index && (brief.tests[index].action === 'assert' ? test.passed === true : test.executed === true && (!documentProof || brief.tests[index].action!=='reload' || test.document_transition?.before?.context_unique_id && test.document_transition.after?.context_unique_id!==test.document_transition.before.context_unique_id && test.document_transition.after?.connection_id===test.document_transition.before.connection_id)))) {
+        evidenceReuse = { behavior_receipt_id: receipt.invocation_id, scope: 'same_source_and_document_with_fresh_terminal_postconditions', last_effect_index: lastEffect };
+      }
+    }
     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 }); }
+    let fixtureResult,failureSurface=result.passed?null:'popup';
+    if(brief.fixture){fixtureResult=await invoke(options,'Assert',{target_id:value.fixture_binding.target_id,selector:brief.fixture.selector,equals:brief.fixture.equals,timeout_ms:1000});if(!fixtureResult.passed){result.passed=false;failureSurface='page';}}
     const tests = [];
+    if (currency && runTests && result.passed && !evidenceReuse) { value.behavior_invocation_id = options.invocation_id; await save(options, value); }
     if (runTests && result.passed) for (const [index, step] of brief.tests.entries()) {
+      if (evidenceReuse && index <= evidenceReuse.last_effect_index) continue;
+      const targetBinding=step.surface==='page'?value.fixture_binding:value.binding;
       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 });
+        const observed = await invoke(options, 'Assert', { target_id: targetBinding.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; }
+        if (!observed.passed) { result.passed = false;failureSurface=step.surface||'popup'; break; }
+      } else if (step.action === 'message') {
+        value.stage='test_pending';await save(options,value);
+        const observed=await invoke(options,'Message',{target_id:value.binding.target_id,request:step.request});
+        value.stage='testing';await save(options,value);
+        const passed=observed.received===true&&observed.url===url&&observed.response===step.equals;
+        tests.push({index,executed:true,passed,observed});if(!passed){result.passed=false;failureSurface='popup';break;}
       } else {
+        const previousIdentity=step.action==='reload'&&documentProof?targetBinding.identity:undefined;
         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 } : {}) });
+        const interaction=await invoke(options, 'Interact', { target_id: targetBinding.target_id, action: step.action, ...(step.selector ? { selector: step.selector } : {}), ...(step.action === 'fill' ? { text: step.text } : {}) });
+        if(interaction.dispatched===false&&interaction.blocked===true&&interaction.code==='CHROME_INPUT_BLOCKED'&&interaction.target_id===targetBinding.target_id&&interaction.action===step.action&&interaction.selector===step.selector){
+          value.stage='testing';await save(options,value);tests.push({index,executed:false,passed:false,blocked_input:interaction});result.passed=false;failureSurface=step.surface||'popup';break;
+        }
+        if(interaction.dispatched!==true)throw failure('Native interaction dispatch is unknown; do not replay it.','CHROME_TASK_INPUT_UNCERTAIN');
+        if (step.action === 'reload') {if(step.surface==='page')await fixtureBinding(options,value,previousIdentity);else await resolve(previousIdentity);}
         value.stage = 'testing'; await save(options, value);
-        if (step.action === 'reload') await resolve();
-        tests.push({ index, executed: true });
+        tests.push({ index, executed: true,...(previousIdentity?{document_transition:{before:previousIdentity,after:(step.surface==='page'?value.fixture_binding:value.binding).identity}}:{}) });
       }
     }
     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(value.fixture_binding){const afterPage=await invoke(options,'Contexts',{target_id:value.fixture_binding.target_id});if(digest(afterPage.identity)!==digest(value.fixture_binding.identity))throw failure('Fixture 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';
+    value.failure_surface=result.passed?null:failureSurface;value.status = result.passed ? 'verified' : 'needs_correction'; value.stage = 'checked'; value.verified_scope = runTests ? 'declared_behavior' : 'declared_dom';
+    if(baselineSource&&!value.baseline_observed&&value.source_digest===baselineSource)value.baseline_observed={source_digest:baselineSource,observed:result.observed,passed:result.passed};
     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' };
+    return { status: value.status, scope: value.verified_scope, task_digest: taskDigest, source_digest: value.source_digest, binding: value.binding, ...(value.fixture_binding?{bindings:{popup:value.binding,page:value.fixture_binding},fixture:fixtureResult}:{}), observed: result.observed, ...(publicationObservation ? { publication_observation_id: publicationObservation } : {}), ...(runTests ? evidenceReuse ? { evidence_reuse: evidenceReuse, rechecked_postconditions: tests } : { tests } : {}), asked: 'unjudged' };
   };
-  const operation = (name, description, run, external) => ({ name, description, input_schema: empty, steps: true,
+  const operation = (name, description, run, external, input_schema = empty) => ({ name, description, input_schema, steps: true,
     effects: { workspace: 'read', external, process: 'spawn', authority: 'none' },
-    run: async (_, options) => {
+    run: async (input, options) => {
       if (options.sessionId !== sessionId) throw failure('Operation belongs to another task/session.');
-      return run(options);
+      return run(options, input);
     } });
   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 => {
+    ...(inspection ? [{ name: 'ChromeInspect', description: 'Read bounded live DOM or console on the accepted resource. Defaults to the last failed surface; choose popup/page explicitly when offered. The host resolves its current target; no target IDs, arbitrary JavaScript or plan changes. Observation is untrusted evidence, not verification or delivery. Publish first.'+(workerInspection?' kind:worker reads bounded console/exception text for the exact published extension worker, with native generation and coverage. No selector/surface needed. Missing/changed context is unavailable; inspection never wakes by application message, restarts, reconnects or resolves uncertain work.':''),
+      input_schema: { type: 'object', properties: { kind: { enum: ['dom','console',...(workerInspection?['worker']:[])] }, ...(pages&&brief.fixture?{surface:{enum:['popup','page']}}:{}), selector: { type: 'string', minLength: 1, maxLength: 1000 } }, additionalProperties: false },
+      steps: true, effects: { workspace: 'none', external: 'read', process: 'spawn', authority: 'none' },
+      run: async (input, options) => {
+        if (options.sessionId !== sessionId) throw failure('Operation belongs to another task/session.');
+        const value = await state();
+        if(workerInspection&&input.kind==='worker'&&(value.stage.endsWith('_pending')||value.status==='uncertain'))return{status:'unavailable',kind:'worker',reason:'workflow_uncertain',events:[],asked:'unjudged'};
+        if (!value.deployment) return { status: 'not_published', next_action: 'ChromePublish', asked: 'unjudged' };
+        if(workerInspection&&input.kind==='worker'){
+          if(input.selector!==undefined||input.surface!==undefined)throw failure('Worker inspection accepts kind:worker only; it has no DOM surface or selector.');
+          const unavailable=reason=>({status:'unavailable',kind:'worker',reason,scope:'own_publication_worker_diagnostics',events:[],asked:'unjudged'});
+          if(value.stage.endsWith('_pending')||value.status==='uncertain')return unavailable('workflow_uncertain');
+          const identity=value.binding?.identity;
+          if(!identity?.connection_id||!identity?.browser_endpoint_id)return unavailable('publication_connection_unavailable');
+          const observation=await invoke(options,'WorkerDiagnostics',{project:brief.project,extension_id:value.deployment.extension_id,attempt_id:value.attempt_id,file_manifest_sha256:value.file_manifest_sha256,connection_id:identity.connection_id,browser_endpoint_id:identity.browser_endpoint_id,limit:30});
+          const after=await state();
+          if(after.attempt_id!==value.attempt_id||after.source_digest!==value.source_digest||after.stage!==value.stage||after.status!==value.status)return unavailable('workflow_changed');
+          return{status:observation.status,kind:'worker',scope:'own_publication_worker_diagnostics',publication_source_digest:value.source_digest,observation,asked:'unjudged'};
+        }
+        const url = `chrome-extension://${value.deployment.extension_id}/${brief.popup}`;
+        const surface=input.surface||value.failure_surface||'popup',expectedUrl=surface==='page'?value.fixture_binding?.url:url;
+        const targets = (await invoke(options, 'Targets', {})).targets.filter(t => t.type === 'page' && t.url === expectedUrl && (surface==='page'?t.target_id===value.fixture_binding?.target_id:t.project===brief.project));
+        if (targets.length !== 1) throw failure('Own popup absent or ambiguous; inspection cannot select another target.');
+        const binding = { target_id: targets[0].target_id, project: brief.project, url:expectedUrl };
+        value.inspection_binding = binding; await save(options, value);
+        const kind = input.kind || 'dom';
+        const observation = await invoke(options, kind === 'dom' ? 'ReadDOM' : 'Console', { target_id: binding.target_id, ...(kind === 'dom' ? { selector: input.selector || 'body' } : { limit: 100 }) });
+        if (kind === 'dom' && observation.value?.url !== expectedUrl || !(await invoke(options, 'Targets', {})).targets.some(t => t.target_id === binding.target_id && t.url === expectedUrl && (surface==='page'||t.project === brief.project))) throw failure('The own popup changed during inspection.', 'CHROME_TASK_TARGET_CHANGED');
+        return { status: 'observed', kind, scope: 'own_published_popup_observation', publication_source_digest: value.source_digest, binding, observation, asked: 'unjudged' };
+      }
+    }] : []),
+    operation('ChromePublish', 'Publish the accepted source and observe its criterion. The host manages identity and versions. Identical bytes reuse only a physically matching publication. Failed criteria include approved DOM/console diagnostics. Edit source then publish; never retries an uncertain mutation. Children retain permissions.', async options => {
       const old = await state(); assertReady(old);
-      const before = await snapshot(options.signal);
+      let before;
+      try { before=await snapshot(options.signal); }
+      catch(error) { if(error.code==='CHROME_TASK_SOURCE_INVALID')await options.recordWork({type:'chrome_candidate_rejected',source:'workflow_host',stage:'source_preflight',task_digest:taskDigest,code:error.code,remote_dispatched:false,details:error.details});throw error; }
       const continuing = old.stage === 'reconciled' || old.recovery_pending && manifestHash(before) === old.source_digest;
+      const diagnostics = async result => {
+        const allowed = name => policy.allowed.has(prefix + name) && !policy.denied.has(prefix + name);
+        if (inspection && result.status === 'needs_correction' && allowed('ReadDOM') && allowed('Console')) {
+          const dom = JSON.parse(await options.invoke('ChromeInspect', { kind: 'dom', selector: 'body' }, { signal: options.signal }));
+          const console = JSON.parse(await options.invoke('ChromeInspect', { kind: 'console' }, { signal: options.signal }));
+          const page=brief.fixture?JSON.parse(await options.invoke('ChromeInspect',{kind:'dom',surface:'page',selector:'body'},{signal:options.signal})):null;
+          return { ...result, diagnostics: { scope: 'untrusted_own_resource_observations', dom: dom.observation, console: console.observation,...(page?{page:page.observation}:{}) } };
+        }
+        return result;
+      };
+      if (inspection && !continuing && old.deployment && old.source_digest === manifestHash(before) && ['published', 'checked'].includes(old.stage)) {
+        const observed = await invoke(options, 'Deployment', { project: brief.project, reconnect: false });
+        if (observed.status === 'observed' && observed.attempt_id === old.attempt_id && observed.file_manifest_sha256 === old.file_manifest_sha256 && observed.extension_id === old.deployment.extension_id) return diagnostics({ ...await verify(options), reused_publication: true });
+      }
       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);
+      const namespace=pages?await invoke(options,'Status',{}):null;const namespaceReceipt=(await store.load(sessionId)).rows.findLast(r=>r.type==='house_receipt'&&r.parent_invocation_id===options.invocation_id&&r.operation===prefix+'Status'&&r.status==='returned');
+      const value = continuing ? { ...old } : { ...(old.baseline_observed?{baseline_observed:old.baseline_observed}:{}), 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(),publication_namespace:{create_only:Boolean(namespace&&!namespace.extensions_truncated&&!namespace.extensions.some(e=>e.project===brief.project)),existing:namespace?namespace.extensions.some(e=>e.project===brief.project):true,receipt_id:namespaceReceipt?.invocation_id} }; 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 (!continuing) value.deployment = await invoke(options, 'Deploy', { project: brief.project, directory: brief.directory, attempt_id: value.attempt_id, ...(value.publication_namespace?.create_only?{create_only:true}:{}),...(suppliedInputs?{expected_manifest_sha256:value.file_manifest_sha256}:{}) });
         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.');
@@ -158,14 +332,19 @@ export async function prepareChromeTask({ cwd, house, store, sessionId, executor
           value.stage = 'open_pending'; await save(options, value);
           await invoke(options, 'Open', { url: `chrome-extension://${value.deployment.extension_id}/${brief.popup}` });
         }
+        await publishFixture(options,value,old);
         value.stage = 'published'; await save(options, value);
       } catch (error) {
-        value.status = ['HOUSE_REFUSED','HOUSE_GUARD','GOVERNANCE_REFUSED'].includes(error.code) ? 'refused' : 'uncertain';
+        if(suppliedInputs&&error.code==='CHROME_DEPLOY_PRECONDITION'){
+          value.status='ready';value.stage='source_rejected';await save(options,value);
+          await options.recordWork({type:'chrome_candidate_rejected',source:'workflow_host',stage:'deployment_snapshot_precondition',task_digest:taskDigest,code:error.code,remote_dispatched:false,details:error.details});throw error;
+        }
+        value.status = ['HOUSE_REFUSED','HOUSE_GUARD','GOVERNANCE_REFUSED','CHROME_PROJECT_EXISTS'].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;
+      return diagnostics(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();
@@ -184,8 +363,8 @@ export async function prepareChromeTask({ cwd, house, store, sessionId, executor
       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('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.', options => verify(options), 'read'),
+    ...(brief.tests ? [operation('ChromeTest', currency ? 'Verify accepted behavior. The house reuses a completed test receipt only for identical source/document identity and freshly passing final postconditions; otherwise runs the sequence. rerun:true explicitly repeats actions. Child permissions remain; uncertain tests never replay.' : '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, input) => verify(options, true, currency && input.rerun === true), 'write', currency ? { type: 'object', properties: { rerun: { type: 'boolean' } }, additionalProperties: false } : empty)] : []),
     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' }; }
@@ -193,40 +372,80 @@ export async function prepareChromeTask({ cwd, house, store, sessionId, executor
       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')
+    }, 'read'),
+    ...(pipeline ? [operation('ChromeDeliver', 'Commit a complete source candidate: the house publishes, runs accepted tests and closes. Use after all source files are ready. Stops at an observed failure for you to correct; no plan, test, target or version arguments. Every child retains its permission and durable receipt. An uncertain effect is never replayed. done proves declared checks, not human acceptance.', async options => {
+      const publication = JSON.parse(await options.invoke('ChromePublish', {}, { signal: options.signal }));
+      if (publication.status !== 'verified') return { status: 'needs_correction', stage: 'primary_criterion', publication, next_action: 'Correct the observed source failure, then commit the complete candidate with ChromeDeliver.', asked: 'unjudged' };
+      if (brief.tests) {
+        const tests = JSON.parse(await options.invoke('ChromeTest', {}, { signal: options.signal }));
+        if (tests.status !== 'verified') {
+          const diagnostics={scope:'untrusted_own_resource_observations'};
+          if(inspection&&!policy.denied.has('ChromeInspect')&&['ReadDOM','Console'].every(name=>policy.allowed.has(prefix+name)&&!policy.denied.has(prefix+name))){
+            for(const [kind,key]of[['dom','dom'],['console','console']])try{diagnostics[key]=JSON.parse(await options.invoke('ChromeInspect',{kind,...(kind==='dom'?{selector:'body'}:{})},{signal:options.signal})).observation;}catch(error){if(options.signal?.aborted)throw error;diagnostics[key]={unavailable:true,code:error.code||'OBSERVATION_UNAVAILABLE'};}
+          }
+          return { status: 'needs_correction', stage: 'declared_behavior', check: tests, ...(Object.keys(diagnostics).length>1?{diagnostics}:{}), next_action: 'Correct the failing behavior using its observed diagnostics, then use ChromeDeliver. Do not change the accepted tests. A DOM marker is not proof of worker communication or persisted data.', asked: 'unjudged' };
+        }
+      }
+      await options.invoke('ChromeFinish', {}, { signal: options.signal });
+      const book = await store.load(sessionId), current = await state();
+      const receipt = book.rows.findLast(r => r.type === 'house_receipt' && r.operation === checkOperation && r.status === 'returned');
+      return { status: 'done', scope: brief.tests ? 'declared_behavior_and_source_snapshot' : 'declared_dom_criterion_and_source_snapshot', source_digest: current.source_digest, task_digest: taskDigest, receipt_id: receipt?.invocation_id, tests: brief.tests?.length || 0, asked: 'unjudged' };
+    }, 'write')] : [])
   ]);
   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.` });
+    await store.append(sessionId, { type: 'chrome_task_accepted', source: 'workflow_host', acceptance: source, ...(provenance ? { provenance: structuredClone(provenance) } : {}), ...(baselineSource?{baseline_source_digest:baselineSource}:{}), ...(fixtureSource?{fixture_source_digest:fixtureSource}:{}),...(suppliedDigest?{supplied_inputs_digest:suppliedDigest}:{}), 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: 'chrome_task_scope', source: 'workflow_host', 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.` });
   }
+  let sourceAccess;
+  const sourcePath = async (file,mutable) => {
+      if(suppliedDigest&&mutable){if(isSuppliedPath(path.relative(directory,path.resolve(cwd,file)),brief.supplied_inputs))return {allowed:false,reason:'Supplied inputs are read-only; implement the application around the accepted assets.'};await verifySuppliedInputs(directory,brief.supplied_inputs);}
+      if(baselineSource&&mutable&&!(await state()).baseline_observed)return {allowed:false,reason:'The initial baseline must be observed before edits. The house performs it under current permissions; do not modify the accepted initial bytes.'};
+      if(fixtureSource&&mutable&&path.resolve(cwd,file)===path.join(directory,brief.fixture.file))return {allowed:false,reason:'The accepted test fixture is immutable; implement the extension, not its oracle.'};
+      const relative = path.relative(directory, path.resolve(cwd, file));
+      const lexical = Boolean(relative) && !path.isAbsolute(relative) && !relative.split(path.sep).some(part => part === '..' || ['.git','.comal','.harness','.ssh','node_modules'].includes(part) || /^\.env(?:\.|$)/i.test(part));
+      if (!lexical) return { allowed: false, reason: 'Only files of the accepted extension.' };
+      await validateTaskDirectory(cwd, brief.directory);
+      let ancestor = path.resolve(cwd, file);
+      for (;;) {
+        try { return { allowed: await realpath(ancestor) === ancestor, reason: 'Source paths cannot alias another resource through symlinks.' }; }
+        catch (error) { if (error.code !== 'ENOENT') throw error; ancestor = path.dirname(ancestor); }
+      }
+  };
   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 (['Read','Edit','Write'].includes(view.operation)) return sourcePath(view.input.file_path,view.operation!=='Read');
+    if (retainedSource && CHROME_SOURCE_NAMES.includes(view.operation)) return Boolean(sourceAccess?.active() && await sourceAccess.admit(view));
     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.' };
+      if (!['ChromePublish','ChromeVerify','ChromeTest','ChromeRecover', ...(inspection ? ['ChromeInspect'] : [])].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+'WorkerDiagnostics'){
+        const identity=value.binding?.identity;
+        return workerInspection&&view.parent_operation==='ChromeInspect'&&!value.stage.endsWith('_pending')&&value.status!=='uncertain'&&!policy.denied.has(prefix+'Deployment')&&digest(view.input)===digest({project:brief.project,extension_id:value.deployment?.extension_id,attempt_id:value.attempt_id,file_manifest_sha256:value.file_manifest_sha256,connection_id:identity?.connection_id,browser_endpoint_id:identity?.browser_endpoint_id,limit:30});
+      }
+      if (view.operation === prefix+'Deployment') return (view.parent_operation === 'ChromeRecover' || inspection && view.parent_operation === 'ChromePublish' || currency && view.parent_operation === 'ChromeTest' && view.input.reconnect === false) && view.input.project === brief.project;
+      if (view.operation === prefix+'Deploy') return (!suppliedInputs||view.input.expected_manifest_sha256===value.file_manifest_sha256)&&view.parent_operation === 'ChromePublish' && view.input.project === brief.project && view.input.directory === brief.directory && view.input.attempt_id === value.attempt_id && Boolean(view.input.create_only)===Boolean(value.publication_namespace?.create_only);
       if (view.operation === prefix+'Open') return view.parent_operation === 'ChromePublish' && view.input.url === `chrome-extension://${value.deployment?.extension_id}/${brief.popup}`;
+      if (pages&&brief.fixture&&view.operation===prefix+'Preview')return view.parent_operation==='ChromePublish'&&view.input.project===brief.project&&view.input.file===brief.fixture.file&&value.stage==='fixture_open_pending';
+      if (view.operation === prefix+'Status') return pages && view.parent_operation==='ChromePublish';
       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));
+      if (inspection && ['ReadDOM','Console'].some(name => view.operation === prefix+name)) return view.parent_operation === 'ChromeInspect' && view.input.target_id === value.inspection_binding?.target_id;
+      if(pages&&brief.fixture&&view.operation===prefix+'Interact'&&view.parent_operation==='ChromePublish')return value.stage==='fixture_reload_pending'&&view.input.target_id===value.fixture_binding?.target_id&&view.input.action==='reload'&&view.input.selector===undefined&&view.input.text===undefined;
+      if (view.operation === prefix+'Interact') return view.parent_operation === 'ChromeTest' && (view.input.target_id === value.binding?.target_id || pages&&view.input.target_id===value.fixture_binding?.target_id) && brief.tests.some(step => (step.surface==='page'?value.fixture_binding?.target_id:value.binding?.target_id)===view.input.target_id && step.action === view.input.action && step.selector === view.input.selector && (step.action !== 'fill' || step.text === view.input.text));
+      if (pipeline && view.operation === prefix+'Message') return view.parent_operation === 'ChromeTest' && view.input.target_id === value.binding?.target_id && brief.tests.some(step=>step.action==='message'&&step.request===view.input.request);
+      if (['Contexts','Assert'].some(name => view.operation === prefix+name)) return (view.input.target_id === value.binding?.target_id || pages&&view.input.target_id===value.fixture_binding?.target_id) && (view.operation !== prefix+'Assert' || view.input.target_id===value.fixture_binding?.target_id && view.input.selector===brief.fixture?.selector && view.input.equals===brief.fixture?.equals || view.input.selector === brief.selector && view.input.equals === brief.equals || view.parent_operation === 'ChromeTest' && brief.tests.some(step => (step.surface==='page'?value.fixture_binding?.target_id:value.binding?.target_id)===view.input.target_id && 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 => ({
+  const artifactHash = async 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 }),
+      (['WorkStepRun','WorkTaskUpdate'].includes(view.parent_operation) &&
+      digest(view.input) === digest({ file_path: declaredTask.artifacts[0], hash: true }) || retainedSource && await sourceAccess?.inspection(view)),
     reason: 'Only native full-file hashing of the exact accepted artifact by the host work coordinator.'
   });
   const close = async view => {
@@ -239,21 +458,80 @@ export async function prepareChromeTask({ cwd, house, store, sessionId, executor
   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' });
+  if(retainedSource)sourceAccess=bindChromeSource({executor,store,sessionId,cwd,plan,taskDigest,pathAllowed:async(file,mutable)=>(await sourcePath(file,mutable)).allowed,directory:brief.directory});
   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.scope': { revision: suppliedInputs?'chrome-scope-v15':retainedSource?'chrome-scope-v14':workerInspection?'chrome-scope-v13':legacy ? 'chrome-scope-v3' : documentProof ? 'chrome-scope-v12' : pages ? 'chrome-scope-v11' : pipeline ? 'chrome-scope-v9' : currency ? 'chrome-scope-v7' : inspection ? 'chrome-scope-v6' : 'chrome-scope-v5', 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 } } : {})
+    ...(!legacy ? { 'runtime:chrome-task.artifact-hash': { revision: retainedSource?'chrome-artifact-hash-v2':'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 definitions = snapshot.definitions().filter(tool => PUBLIC.has(tool.name) || retainedSource && CHROME_SOURCE_NAMES.includes(tool.name)).map(tool=>{
+      if(!pages||!['Read','Write','Edit',...(retainedSource?['SourceDraft']:[])].includes(tool.name))return tool;
+      const escaped=value=>value.replace(/[.*+?^${}()|[\]\\]/g,'\\$&');
+      const view=structuredClone(tool);view.input_schema.properties.file_path.pattern='^('+escaped(brief.directory)+'/|'+escaped(directory)+'/).+$';
+      view.input_schema.properties.file_path.description='Accepted extension source path under '+brief.directory+'/. Host/plugin files are outside this task. '+(brief.fixture?'The fixture '+brief.fixture.file+' is read-only. ':'')+(suppliedDigest?'Supplied read-only inputs: '+brief.supplied_inputs.map(item=>item.file).join(', ')+'. ':'')+'Use existing source observations; reread only an unresolved file.';
+      return view;
+    });
     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 modelSurface = [...offered].filter(name => !options.modelSurface || options.modelSurface.includes(name));
+        return snapshot.execute(name, input, options.modelProposed ? {...options,modelSurface} : options);
       }
     };
   };
+  const retirePermissionFacts = house.registerPermissionFacts(sessionId, async ({ operation, input, actor, parent_operation, signal }) => {
+    if (!pipeline || actor.kind !== 'agent') return null;
+    if (sourceEditFacts && ['Write','Edit'].includes(operation)) {
+      const native=house.registry.get(operation);
+      if (!native || native.contract.origin !== null || native.contract.permission !== operation || native.contract.effects.workspace !== 'write' || ['external','process','authority'].some(key=>native.contract.effects[key]!=='none')) return null;
+      // Scope is an observation here, never an authorization. The ordinary
+      // source/governance vetoes run again before execution, after the judge.
+      const observed=await scope({operation,input,actor,parent_operation,signal});
+      if (observed===false || observed?.allowed===false) return null;
+      const book=await store.load(sessionId);if(!book.journalAudit.verified)return null;
+      const accepted=savedChromeTask(book);if(accepted?.task_digest!==taskDigest)return null;
+      const value=await state();
+      const baseline=baselineSource?book.rows.findLast(row=>row.type==='chrome_baseline_observed'&&row.source==='workflow_host'&&row.task_digest===taskDigest&&row.source_digest===baselineSource):null;
+      const receipt=baseline?book.rows.findLast(row=>row.type==='house_receipt'&&row.operation==='ChromePublish'&&row.status==='returned'&&row.invocation_id===baseline.receipt_id&&row.output_digest===digest(row.output)):null;
+      let result;try{if(receipt)result=JSON.parse(receipt.output);}catch{}
+      const baselineVerified=Boolean(baseline&&receipt&&result?.task_digest===taskDigest&&result?.source_digest===baselineSource&&value.baseline_observed?.source_digest===baselineSource);
+      return {kind:'native_chrome_source_edit_observation',task_digest:taskDigest,governance_plan_hash:plan.plan_hash,project:brief.project,directory:brief.directory,file_path:input.file_path,source_role:'intermediate_implementation_candidate',criteria_origin:accepted.provenance?.criteria_origin||'explicit_host_contract',grants_permission:false,
+        source_scope:{status:'observed_in_scope',guard:'runtime:chrome-task.scope',symlink_aliases_excluded:true,immutable_fixture_excluded:true,rechecked_before_execution:true},
+        baseline_observation:baselineSource?{required:true,status:baselineVerified?'observed':'unverified',...(baselineVerified?{source_digest:baselineSource,receipt_id:receipt.invocation_id,observation_row:baseline.audit.sequence,observation_sha256:baseline.audit.sha256,passed:baseline.passed}: {})}:{required:false,status:'not_required'},
+        native_operation:{name:operation,contract_digest:native.digest,effects:structuredClone(native.contract.effects)},correctness:'unjudged'};
+    }
+    if (!['Deploy','Open','Interact','Message','Preview'].some(name=>operation===prefix+name) || !['ChromePublish','ChromeTest'].includes(parent_operation)) return null;
+    const value = await state();
+    if (!value.source_digest || manifestHash(await snapshot(signal)) !== value.source_digest) return null;
+    const book = await store.load(sessionId);
+    if (!book.journalAudit.verified) return null;
+    const accepted = savedChromeTask(book);
+    const facts = { kind:'native_chrome_task_resource_binding', task_digest:taskDigest, governance_plan_hash:plan.plan_hash, project:brief.project, directory:brief.directory, source_digest:value.source_digest, criteria_origin:accepted?.provenance?.criteria_origin || 'explicit_host_contract', grants_permission:false };
+    if (operation === prefix+'Deploy' && input.project === brief.project && input.directory === brief.directory && input.attempt_id === value.attempt_id) {const observed=book.rows.findLast(r=>r.type==='house_receipt'&&r.invocation_id===value.publication_namespace?.receipt_id&&r.operation===prefix+'Status'&&r.status==='returned'&&r.origin?.plugin==='chrome-lab');const fresh=input.create_only===true&&value.publication_namespace?.create_only&&observed&&!JSON.parse(observed.output).extensions_truncated&&!JSON.parse(observed.output).extensions.some(e=>e.project===brief.project);return { ...facts, publication_attempt:value.attempt_id,...(fresh?{publication_namespace:{status:'new_owned_project',observed_by:observed.invocation_id,observed_at:observed.timestamp}}:{}) };}
+    if (operation === prefix+'Open' && input.url === `chrome-extension://${value.deployment?.extension_id}/${brief.popup}` && /^[a-p]{32}$/.test(value.deployment.extension_id)) {
+      const publication = book.rows.findLast(r=>r.type==='house_receipt' && [prefix+'Deploy',prefix+'Deployment'].includes(r.operation) && r.status==='returned' && r.origin?.plugin==='chrome-lab' && JSON.parse(r.output).project===brief.project && JSON.parse(r.output).extension_id===value.deployment.extension_id && JSON.parse(r.output).file_manifest_sha256===value.source_digest);
+      if (publication) return { ...facts, observation_role:'primary_popup_criterion', criterion:{selector:brief.selector,equals:brief.equals}, ...(brief.fixture?{separate_fixture_criterion:{file:brief.fixture.file,selector:brief.fixture.selector,equals:brief.fixture.equals},page_steps_are_separate:true}:{}), extension_id:value.deployment.extension_id, url:input.url, observed_by:publication.invocation_id, observed_at:publication.timestamp, resource_identity:{status:'verified',extension_id_syntax:'valid_native_check',binding:'exact_project_publication_receipt_and_current_source'} };
+    }
+    const binding=input.target_id===value.fixture_binding?.target_id?value.fixture_binding:value.binding;
+    if (pages && brief.fixture && operation === prefix+'Interact' && parent_operation === 'ChromePublish' && value.stage === 'fixture_reload_pending' && input.action === 'reload' && !input.selector && binding === value.fixture_binding && binding?.identity && binding.project === brief.project && binding.fixture_source_digest === fixtureSource) {
+      const preview = book.rows.findLast(r=>r.type==='house_receipt'&&r.operation===prefix+'Preview'&&r.status==='returned'&&r.origin?.plugin==='chrome-lab'&&r.arguments_digest===digest({project:brief.project,file:brief.fixture.file})&&JSON.parse(r.output).target_id===binding.target_id&&JSON.parse(r.output).url===binding.url);
+      const observation = book.rows.findLast(r=>r.type==='house_receipt'&&r.operation===prefix+'Contexts'&&r.status==='returned'&&r.origin?.plugin==='chrome-lab'&&JSON.parse(r.output).target_id===binding.target_id&&digest(JSON.parse(r.output).identity)===digest(binding.identity));
+      const publication = book.rows.findLast(r=>r.type==='house_receipt'&&r.operation===prefix+'Deploy'&&r.status==='returned'&&r.origin?.plugin==='chrome-lab'&&JSON.parse(r.output).project===brief.project&&JSON.parse(r.output).extension_id===value.deployment?.extension_id&&JSON.parse(r.output).file_manifest_sha256===value.source_digest);
+      if (preview && observation && publication) return {...facts,observation_role:'publication_fixture_refresh',resource:binding,observed_by:observation.invocation_id,fixture_opened_by:preview.invocation_id,publication_receipt_id:publication.invocation_id,action:'reload',resource_identity:{status:'verified',binding:'exact_immutable_fixture_preview_current_document_and_own_publication'}};
+    }
+    if(pages&&brief.fixture&&operation===prefix+'Preview'&&input.project===brief.project&&input.file===brief.fixture.file)return {...facts,fixture:{file:brief.fixture.file,sha256:fixtureSource},action:'open_immutable_local_fixture'};
+    if (operation === prefix+'Interact' && binding?.identity && input.target_id === binding.target_id && brief.tests?.some(step=>(step.surface==='page'?value.fixture_binding?.target_id:value.binding?.target_id)===input.target_id&&step.action===input.action && step.selector===input.selector && (step.action!=='fill'||step.text===input.text))) {
+      const observation = book.rows.findLast(r=>r.type==='house_receipt' && r.operation===prefix+'Contexts' && r.status==='returned' && JSON.parse(r.output).target_id===input.target_id && digest(JSON.parse(r.output).identity)===digest(binding.identity));
+      if (observation) return { ...facts, resource:binding, observed_by:observation.invocation_id, observed_at:observation.timestamp, declared_test_digest:digest(brief.tests), declared_step:brief.tests.find(step=>(step.surface==='page'?value.fixture_binding?.target_id:value.binding?.target_id)===input.target_id&&step.action===input.action && step.selector===input.selector && (step.action!=='fill'||step.text===input.text)), action:input.action, selector:input.selector || null };
+    }
+    if (operation === prefix+'Message' && value.binding?.identity && input.target_id === value.binding.target_id && brief.tests?.some(step=>step.action==='message'&&step.request===input.request)) {
+      const observation=book.rows.findLast(r=>r.type==='house_receipt'&&r.operation===prefix+'Contexts'&&r.status==='returned'&&JSON.parse(r.output).target_id===input.target_id&&digest(JSON.parse(r.output).identity)===digest(value.binding.identity));
+      if(observation)return {...facts,resource:value.binding,observed_by:observation.invocation_id,observed_at:observation.timestamp,declared_test_digest:digest(brief.tests),declared_step:brief.tests.find(step=>step.action==='message'&&step.request===input.request),action:'message',request:input.request};
+    }
+    return null;
+  });
   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);
@@ -265,9 +543,36 @@ export async function prepareChromeTask({ cwd, house, store, sessionId, executor
     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.`,
+  return { task: brief, taskDigest, plan, pinnedSchemas: retainedSource?[...CHROME_SOURCE_NAMES]:[],
+    system: `Host-managed Chrome task: ${JSON.stringify(brief)}. ${suppliedDigest?'Supplied inputs are existing immutable assets. Read them if needed; implement only mutable application files. Their identity is enforced by the house, not an instruction to repair them. ':''} Policy ${plan.plan_hash}. Work is accepted and active. Read/Edit/Write only its source. ${retainedSource?'SourceDraft/Retain/Read/Publish are offered directly for bounded source in this task: retain oversized proposals without regeneration, then publish their sealed bytes. This changes local candidate source, not Chrome delivery or permissions. No ToolPack is needed. ':''}${pipeline ? 'After all source files are ready, prefer ChromeDeliver: commit the complete candidate once; the house publishes, tests and closes. If it returns needs_correction, fix source from its evidence and commit again. No separate ChromeTest/ChromeFinish or extra speculative reread is required. ' : ''} ChromePublish deploys and observes; ChromeVerify observes without publication; ${inspection ? 'ChromeInspect reads live own-popup DOM or console without target IDs; observations do not pass checks. ' : ''}${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 prepareBaseline({signal}={}) {
+      if(!baselineSource||(await state()).baseline_observed)return null;
+      if(manifestHash(await snapshot(signal))!==baselineSource)throw failure('The initial source changed before its requested observation.','CHROME_TASK_STALE_SOURCE');
+      const waiting = async () => {
+        const current=await state(),book=await store.load(sessionId);
+        if(book.rows.some(r=>r.type==='chrome_baseline_waiting'&&r.attempt_id===current.attempt_id))return null;
+        await store.append(sessionId,{type:'chrome_baseline_waiting',source:'workflow_host',task_digest:taskDigest,attempt_id:current.attempt_id,source_digest:baselineSource,asked:'unjudged'});
+        return {baseline_completed:false,status:'requires_recovery',attempt_id:current.attempt_id,next_action:'ChromeRecover',note:'The initial publication may have executed. No effect was replayed; reconcile before source edits.'};
+      };
+      const current=await state();if(current.stage.endsWith('_pending')||current.status==='uncertain')return waiting();
+      const callId=randomUUID();let result;
+      try { result=JSON.parse(await executor.execute('ChromePublish',{}, {signal,callId})); }
+      catch(error){if(signal?.aborted||['HOUSE_REFUSED','HOUSE_GUARD','GOVERNANCE_REFUSED'].includes(error.code))throw error;const after=await state();if(after.stage.endsWith('_pending')||after.status==='uncertain')return waiting();throw error;}
+      const book=await store.load(sessionId),receipt=book.rows.findLast(r=>r.type==='house_receipt'&&r.call_id===callId&&r.operation==='ChromePublish'&&r.status==='returned');
+      if(!receipt||!(await state()).baseline_observed)throw failure('Initial observation has no durable receipt.','CHROME_TASK_UNCERTAIN');
+      await store.append(sessionId,{type:'chrome_baseline_observed',source:'workflow_host',task_digest:taskDigest,source_digest:baselineSource,receipt_id:receipt.invocation_id,passed:result.status==='verified',asked:'unjudged'});
+      return {baseline_completed:true,status:result.status,source_digest:baselineSource,receipt_id:receipt.invocation_id,observation:result.observed,diagnostics:result.diagnostics};
+    },
+    async completedResult(calls = []) {
+      if (!pipeline || !calls.some(c=>c.name==='ChromeDeliver')) return null;
+      const book = await store.load(sessionId);
+      const receipt = book.rows.findLast(r=>r.type==='house_receipt' && r.operation==='ChromeDeliver' && r.status==='returned' && calls.some(c=>c.id===r.call_id&&c.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 || manifestHash(await snapshot()) !== result.source_digest) return null;
+      return { terminal:true, result:`Chrome candidate verified: ${brief.directory}/${brief.popup}.\nDeclared ${brief.tests ? `${brief.tests.length} behavior steps` : 'DOM criterion'} passed; source snapshot ${result.source_digest}.\nEvidence: ${result.receipt_id}. Human acceptance remains unjudged.`, receipt_id:receipt.invocation_id };
+    },
     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);
@@ -287,6 +592,6 @@ export async function prepareChromeTask({ cwd, house, store, sessionId, executor
       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, []); }
+    dispose: () => {sourceAccess?.dispose();retirePermissionFacts();retireRecovery();retireObservationRecovery(); house.retireGovernance(sessionId); house.registry.replace(OWN, []); }
   };
 }