@milpa/comal 0.1.7 → 0.2.1

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

@@ -0,0 +1,156 @@
+// Native case ownership/settlement only. No application criteria or browser logic.
+import { digest } from '../operations.mjs';
+import { PAGE_BEHAVIOR_OPERATION, PAGE_VERIFIER_CONTRACT } from './chrome-page-verifier.mjs';
+import { nativePageFailure, NATIVE_PAGE_FAILURE_KINDS } from '../native-refusal.mjs';
+
+export const PAGE_CASE_OPERATION = 'ChromePageCase';
+export const PAGE_CASE_LIMITS = Object.freeze({ max_cases: 24, max_behavior_calls: 1600, timeout_ms: 180000, max_summary_bytes: 12000 });
+export const PAGE_CASE_INPUT = Object.freeze({ type: 'object', required: ['phase','index'], additionalProperties: false, properties: { phase: { enum: ['run','validate_final'] }, index: { type: 'integer', minimum: 0, maximum: PAGE_CASE_LIMITS.max_cases } } });
+const fail=(message,code='CHROME_TASK_CASE_EVIDENCE')=>nativePageFailure(message,code);
+const basis=context=>Object.fromEntries(Object.entries(context).filter(([key])=>key!=='case'));
+const returned=(book,id,operation,contract,plan)=>{
+  const row=book.rows.find(row=>row.type==='house_receipt'&&row.invocation_id===id);
+  const expected=typeof plan==='string'?{plan_hash:plan}:plan;
+  if(!row||row.operation!==operation||row.status!=='returned'||row.contract_digest!==contract||row.governance_plan_hash!==expected.plan_hash||typeof plan!=='string'&&(row.mechanism_stamp!==expected.mechanism_stamp||row.governance_activation_id!==expected.activation_id)||row.output_truncated||row.output_digest!==digest(row.output))throw fail('Original complete case/native owner receipt is unavailable.','CHROME_TASK_UNCERTAIN');
+  return {row,value:JSON.parse(row.output)};
+};
+
+export function createPageCaseCoordinator({cases,taskDigest,plan,store,sessionId,state,save,context,fresh,runBehavior,getOperation,receiptLaw=()=>plan.plan_hash}){
+  const names=[...cases],planDigest=digest(names);let caseOperation,behaviorOperation,frame=null;
+  const meta=(phase,index)=>({index,id:phase==='run'?names[index]:'$final',plan_digest:planDigest});
+  const pending=value=>value.case_pending;
+  const book=()=>store.load(sessionId);
+  const readCase=(record,journal)=>{
+    const {phase,index,owner_id,receipt_id}=record;
+    if(!['run','validate_final'].includes(phase)||!Number.isInteger(index)||index<0||index>(phase==='run'?names.length-1:names.length)||phase==='validate_final'&&index!==names.length)throw fail('Case receipt index/phase differs from the accepted plan.');
+    if(getOperation(PAGE_CASE_OPERATION)!==caseOperation)throw fail('Original case operation was replaced.');
+    const owner=returned(journal,owner_id,PAGE_CASE_OPERATION,caseOperation.digest,receiptLaw(journal,owner_id)),ownerProposal=journal.rows.find(r=>r.type==='house_proposal'&&r.invocation_id===owner_id);
+    if(!ownerProposal||ownerProposal.arguments_digest!==digest({phase,index})||owner.value.native_receipt_id!==receipt_id||owner.value.phase!==phase||digest(owner.value.case)!==digest(meta(phase,index)))throw fail('Case owner does not bind the expected native result.');
+    const parent=journal.rows.find(r=>r.type==='house_proposal'&&r.invocation_id===ownerProposal.parent_invocation_id);
+    if(parent?.operation!=='ChromeTest')throw fail('Case owner did not originate from the native test coordinator.');
+    const started=journal.rows.filter(r=>r.type==='chrome_page_case_started'&&r.source==='workflow_host'&&r.task_digest===taskDigest&&r.owner_id===owner_id);
+    const observed=journal.rows.filter(r=>r.type==='chrome_page_case_observed'&&r.source==='workflow_host'&&r.task_digest===taskDigest&&r.owner_id===owner_id);
+    if(started.length!==1||observed.length!==1||digest(started[0].case)!==digest(meta(phase,index))||observed[0].receipt_id!==receipt_id)throw fail('Original case start/result settlement is missing or ambiguous.','CHROME_TASK_UNCERTAIN');
+    if(getOperation(PAGE_BEHAVIOR_OPERATION)!==behaviorOperation)throw fail('Original native behavior operation was replaced.');
+    const native=returned(journal,receipt_id,PAGE_BEHAVIOR_OPERATION,behaviorOperation.digest,receiptLaw(journal,receipt_id)),proposal=journal.rows.find(r=>r.type==='house_proposal'&&r.invocation_id===receipt_id);
+    if(native.row.parent_invocation_id!==owner_id||proposal?.arguments_digest!==digest(started[0].input)||native.value.phase!==phase||native.value.context_digest!==digest(native.value.context)||digest(native.value.context.case)!==digest(meta(phase,index))||owner.value.status!==native.value.status)throw fail('Case native receipt/input/context chain changed.');
+    const input=started[0].input;
+    if(input.phase!==phase||digest(input.context.case)!==digest(meta(phase,index))||input.context.task_digest!==taskDigest||digest(input.context.verification.cases)!==planDigest||observed[0].output_digest!==native.row.output_digest)throw fail('Case start does not match the accepted case plan.');
+    return {record,input,result:native.value};
+  };
+  const history=async(value,journal=undefined)=>{
+    const checkpoint=pending(value),isPending=value.stage==='case_pending';
+    if(Boolean(checkpoint)!==isPending||!isPending&&value.case_cursor!=null)throw fail('Case pending metadata contradicts its durable execution stage.','CHROME_TASK_UNCERTAIN');
+    if(isPending&&(!['run','validate_final'].includes(checkpoint.phase)||!Number.isInteger(checkpoint.index)||checkpoint.index<0||checkpoint.index>(checkpoint.phase==='run'?names.length-1:names.length)||checkpoint.phase==='validate_final'&&checkpoint.index!==names.length||typeof checkpoint.owner_id!=='string'||!checkpoint.owner_id||digest(value.case_cursor)!==digest(meta(checkpoint.phase,checkpoint.index))))throw fail('Pending case cursor does not bind its original phase/index owner.','CHROME_TASK_UNCERTAIN');
+    journal ||= await book();const records=value.case_progress||[];
+    if(!Array.isArray(records)||records.length>names.length)throw fail('Case progress exceeds the accepted plan.');
+    const owners=new Set(records.map(r=>r.owner_id)),starts=journal.rows.filter(r=>r.type==='chrome_page_case_started'&&r.task_digest===taskDigest&&r.input?.context?.publication?.attempt_id===value.attempt_id);
+    for(const start of starts){
+      if(start.owner_id===value.case_pending?.owner_id)continue;
+      if(start.input.phase==='run'&&!owners.has(start.owner_id))throw fail('A started case disappeared from its original checkpoint; effects cannot replay.','CHROME_TASK_UNCERTAIN');
+      if(start.input.phase==='validate_final'){
+        const observed=journal.rows.find(r=>r.type==='chrome_page_case_observed'&&r.owner_id===start.owner_id);
+        if(!observed)throw fail('A prior final case has no original settlement.','CHROME_TASK_UNCERTAIN');
+        readCase({phase:'validate_final',index:names.length,owner_id:start.owner_id,receipt_id:observed.receipt_id},journal);
+      }
+    }
+    const entries=records.map((record,index)=>{if(record.phase!=='run'||record.index!==index)throw fail('Skipped or duplicate case history.');return readCase(record,journal);});
+    for(let i=0;i<entries.length;i++){
+      const entry=entries[i],before=digest(basis(entry.input.context));
+      if(entry.input.previous!==null||before!==(i?digest(basis(entries[i-1].result.context)):value.case_series?.base_context_digest)||i<entries.length-1&&entry.result.status!=='verified')throw fail('Case context/lifetime chain or prior failure differs.');
+    }
+    if(entries.length&&!value.case_pending&&digest(basis(entries.at(-1).result.context))!==digest(basis(await context())))throw fail('Completed cases no longer belong to the current source/document.','CHROME_TASK_STALE_EVIDENCE');
+    return entries;
+  };
+  const ensureSeries=async options=>{
+    let value=await state();
+    if(!value.case_series){
+      if((value.case_progress||[]).length||value.case_pending)throw fail('Case progress has no original series owner.');
+      const started_at=new Date().toISOString(),base_context_digest=digest(basis(await context()));
+      value.case_series={started_at,base_context_digest,plan_digest:planDigest};
+      await options.recordWork({type:'chrome_page_case_series_started',source:'workflow_host',task_digest:taskDigest,attempt_id:value.attempt_id,...value.case_series});await save(options,value);
+    }
+    const journal=await book(),births=journal.rows.filter(r=>r.type==='chrome_page_case_series_started'&&r.task_digest===taskDigest&&r.attempt_id===value.attempt_id);
+    if(births.length!==1||digest(Object.fromEntries(['started_at','base_context_digest','plan_digest'].map(k=>[k,births[0][k]])))!==digest(value.case_series)||value.case_series.plan_digest!==planDigest)throw fail('Original case series/budget identity changed.');
+    const elapsed=Date.now()-Date.parse(value.case_series.started_at);
+    if(!Number.isFinite(elapsed)||elapsed<0||elapsed>=PAGE_CASE_LIMITS.timeout_ms)throw fail('Accepted case series wall budget is unavailable or exhausted.','CHROME_TASK_CASE_BUDGET');
+    const owners=new Set(journal.rows.filter(r=>r.type==='chrome_page_case_started'&&r.task_digest===taskDigest&&r.input.context.publication.attempt_id===value.attempt_id).map(r=>r.owner_id));
+    const phases=new Set(journal.rows.filter(r=>r.type==='house_proposal'&&r.operation===PAGE_BEHAVIOR_OPERATION&&owners.has(r.parent_invocation_id)).map(r=>r.invocation_id));
+    const used=journal.rows.filter(r=>r.type==='house_proposal'&&r.operation.startsWith('plugin__chrome-lab__')&&phases.has(r.parent_invocation_id)).length;
+    if(used>PAGE_CASE_LIMITS.max_behavior_calls-PAGE_VERIFIER_CONTRACT.max_calls)throw fail('Insufficient reserved native behavior-call budget for another bounded phase.','CHROME_TASK_CASE_BUDGET');
+    return {remaining:PAGE_CASE_LIMITS.timeout_ms-elapsed,used};
+  };
+  const summary=entries=>{
+    const result={status:'verified',plan_digest:planDigest,cases:entries.map(e=>({id:names[e.record.index],owner_id:e.record.owner_id,receipt_id:e.record.receipt_id,output_digest:digest(e.result),terminal_digest:digest(e.result.terminal)})),terminal:entries.at(-1).result.terminal};
+    if(Buffer.byteLength(JSON.stringify(result))>PAGE_CASE_LIMITS.max_summary_bytes)throw fail('Complete final case summary exceeds its accepted bound.');return result;
+  };
+  const settle=async(options,value)=>{
+    const checkpoint=pending(value);if(!checkpoint)throw fail('No pending case settlement exists.');
+    const journal=await book(),entry=readCase(checkpoint,journal),entries=await history(value,journal);
+    if(checkpoint.phase==='run'&&checkpoint.index!==entries.length||checkpoint.phase==='validate_final'&&entries.length!==names.length)throw fail('Pending case does not follow completed history.');
+    const expectedBefore=entries.length?digest(basis(entries.at(-1).result.context)):value.case_series?.base_context_digest;
+    if(digest(basis(entry.input.context))!==expectedBefore)throw fail('Pending case does not extend the original context chain.');
+    await fresh(options,value);
+    if(digest(entry.result.context)!==digest(await context()))throw fail('Case result is not the current source/document.','CHROME_TASK_STALE_EVIDENCE');
+    if(checkpoint.phase==='run'){
+      value.case_progress=[...(value.case_progress||[]),checkpoint];value.behavior_receipt_id=checkpoint.receipt_id;
+      value.status=entry.result.status==='needs_correction'?'needs_correction':'ready';value.verified_scope=null;value.final_validation_receipt_id=null;
+    }else{
+      if(digest(entry.input.previous)!==digest(summary(entries)))throw fail('Final validation did not bind all original case owners.');
+      value.status=entry.result.status;value.verified_scope=entry.result.status==='verified'?'declared_page_behavior':null;value.final_validation_receipt_id=entry.result.status==='verified'?checkpoint.receipt_id:null;value.case_final_owner=checkpoint.owner_id;
+    }
+    value.stage='checked';value.case_cursor=null;delete value.case_pending;await save(options,value);return entry;
+  };
+  const invoke=async(options,phase,index)=>{
+    await ensureSeries(options);const input={phase,index};frame={input,operation:caseOperation};
+    try{
+      const output=JSON.parse(await options.invoke(PAGE_CASE_OPERATION,input,{signal:options.signal}));
+      const value=await state();if(value.case_pending?.receipt_id!==output.native_receipt_id)throw fail('Case returned without its exact pending result.','CHROME_TASK_UNCERTAIN');
+      return await settle(options,value);
+    }finally{frame=null;}
+  };
+  return {
+    bind(operation,nativeOperation){caseOperation=operation;behaviorOperation=nativeOperation;},
+    admit(view){return Boolean(frame&&getOperation(PAGE_CASE_OPERATION)===caseOperation&&view.parent_operation==='ChromeTest'&&view.contract_digest===frame.operation.digest&&digest(view.input)===digest(frame.input));},
+    async executeCase({phase,index},options){
+      if(!frame||digest(frame.input)!==digest({phase,index}))throw fail('Case phase was not admitted by its original coordinator.');
+      const value=await state(),entries=await history(value);await ensureSeries(options);
+      if(value.stage.endsWith('_pending')||value.status==='uncertain'||phase==='run'&&(index!==entries.length||entries.at(-1)?.result.status==='needs_correction'||index>=names.length)||phase==='validate_final'&&(index!==names.length||entries.length!==names.length||entries.some(e=>e.result.status!=='verified')))throw fail('Case order or execution state is unavailable.','CHROME_TASK_UNCERTAIN');
+      const previous=phase==='run'?null:summary(entries);
+      await fresh(options,value);value.stage='case_pending';value.case_cursor=meta(phase,index);value.case_pending={phase,index,owner_id:options.invocation_id};await save(options,value);
+      const input={phase,context:await context(),previous};
+      await options.recordWork({type:'chrome_page_case_started',source:'workflow_host',task_digest:taskDigest,owner_id:options.invocation_id,case:meta(phase,index),input});
+      const observed=await runBehavior(options,input);value.case_pending.receipt_id=observed.receipt_id;
+      // Store the returned native reference, but keep the phase pending until
+      // the separate Case owner receipt has actually returned and is checked.
+      const current=await state();current.case_pending=value.case_pending;await save(options,current);
+      await options.recordWork({type:'chrome_page_case_observed',source:'workflow_host',task_digest:taskDigest,owner_id:options.invocation_id,receipt_id:observed.receipt_id,output_digest:observed.output_digest});
+      return {status:observed.result.status,phase,case:meta(phase,index),native_receipt_id:observed.receipt_id};
+    },
+    async verify(options){
+      const parentSignal=options.signal,budget=await ensureSeries(options),deadline=AbortSignal.timeout(Math.max(1,budget.remaining)),signal=AbortSignal.any([...(parentSignal?[parentSignal]:[]),deadline]);options={...options,signal};
+      try{
+      let value=await state(),entries=await history(value);
+      while(entries.length<names.length&&entries.at(-1)?.result.status!=='needs_correction'){
+        await invoke(options,'run',entries.length);value=await state();entries=await history(value);
+      }
+      const failed=entries.find(e=>e.result.status!=='verified');
+      if(failed)return {status:'needs_correction',scope:'declared_page_behavior',case:meta('run',failed.record.index),behavior:{status:failed.result.status,facts:failed.result.facts},receipt_id:failed.record.receipt_id,next_action:'Correct application source and publish a new complete candidate. Completed case effects are not replayed.',asked:'unjudged'};
+      summary(entries); // Reject oversized final input before dispatch/checkpoint.
+      const final=await invoke(options,'validate_final',names.length);
+      return {status:final.result.status,scope:'declared_page_behavior',phase:'validate_final',completed_cases:[...names],receipt_id:final.record.receipt_id,behavior:{status:final.result.status,facts:final.result.facts},asked:'unjudged'};
+      }catch(error){
+        if(deadline.aborted&&error===deadline.reason&&!parentSignal?.aborted)throw fail('Accepted case series time budget exhausted; interrupted effects remain uncertain.','CHROME_TASK_CASE_BUDGET');
+        throw error;
+      }
+    },
+    async recover(options,value){
+      if(value.stage!=='case_pending'||!value.case_pending?.receipt_id)throw fail('Original returned case/native owners are unavailable; uncertain effects cannot replay.','CHROME_TASK_UNCERTAIN');
+      await settle(options,value);return {status:'recovered',scope:'original_case_receipt_settlement_only',next_action:'ChromeTest',asked:'unjudged'};
+    },
+  };
+}
+
+// Identity of the actually loaded coordinator functions/constants, not merely a
+// caller-selected contract revision or a later filesystem hash.
+export const PAGE_CASE_IMPLEMENTATION_DIGEST=digest({operation:PAGE_CASE_OPERATION,input:PAGE_CASE_INPUT,limits:PAGE_CASE_LIMITS,verifier_contract:PAGE_VERIFIER_CONTRACT,native_failure_kinds:NATIVE_PAGE_FAILURE_KINDS,functions:[createPageCaseCoordinator,returned,basis,fail,nativePageFailure].map(fn=>Function.prototype.toString.call(fn))});

package/src/workflows/chrome-page-checkpoint-reader.mjs

@@ -0,0 +1,10 @@
+// Internal host opt-in only. No model tool, task-file field or end-user flag.
+import {createSessionProjectionReader} from '../session-projections.mjs';
+import {SessionJournalCache} from '../session-read-cache.mjs';
+import {auditJournal} from '../audit.mjs';
+import {assertClassifierChannels} from '../event-channels.mjs';
+export function selectChromePageCheckpointReader(store,selection){
+ if(selection===false||selection===undefined)return undefined;
+ if(selection===true)return createSessionProjectionReader({store,JournalCache:SessionJournalCache,auditJournal,assertClassifierChannels});
+ throw new TypeError('Internal checkpointProjection must be true, false or absent.');
+}

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

@@ -0,0 +1,113 @@
+// Historical publication facts only. No native calls, recovery admission or cause inference.
+import { auditExecution } from '../audit.mjs';
+import { digest } from '../operations.mjs';
+
+const diagnoses = new WeakMap();
+const prefix = 'plugin__chrome-lab__';
+const same = (a, b) => digest(a) === digest(b);
+const law = row => ({ plan_hash: row.governance_plan_hash, mechanism_stamp: row.mechanism_stamp, activation_id: row.governance_activation_id });
+const text = (value, max) => typeof value === 'string' && value.length > 0 && value.length <= max;
+const ref = row => ({ operation: row.operation, receipt_id: row.invocation_id });
+
+// Refuse to project convenient row-shaped data from a different task, source,
+// contract, actor or activation. An unavailable diagnosis never replaces the error.
+export function pagePublicationDiagnostic({ book, house, cwd, sessionId, task, taskDigest, plan, sourceDigest, operations, activeOwner }) {
+  const rows = book.rows;
+  if (book.id !== sessionId || book.cwd !== cwd || !book.journalAudit.consistent) return;
+  const audit = auditExecution(book, house.stateContext());
+  if (audit.violations.length || audit.unresolved.length) return;
+  const accepted = rows.findLast(row => row.type === 'chrome_task_accepted' && row.source === 'workflow_host');
+  const checkpoint = rows.findLast(row => row.type === 'chrome_task_checkpoint' && row.task_digest === taskDigest);
+  const value = checkpoint?.state;
+  if (accepted?.task_digest !== taskDigest || !same(accepted.task, task) || accepted.governance_plan_hash !== plan.plan_hash ||
+      !['deploy_pending', 'page_open_pending', 'published', 'checked'].includes(value?.stage) || value.source_digest !== sourceDigest ||
+      checkpoint.source !== 'workflow_host' || checkpoint.house !== cwd || checkpoint.session_id !== sessionId) return;
+  const proposals = id => rows.filter(row => row.type === 'house_proposal' && row.invocation_id === id);
+  const receipts = id => rows.filter(row => row.type === 'house_receipt' && row.invocation_id === id);
+  const publicationCheckpoint = rows.findLast(row => row.type === 'chrome_task_checkpoint' && row.source === 'workflow_host' && row.task_digest === taskDigest && row.state?.attempt_id === value.attempt_id && row.state.source_digest === value.source_digest && proposals(row.invocation_id).some(p => p.operation === 'ChromePublish'));
+  const owners = proposals(publicationCheckpoint?.invocation_id), owner = owners[0], current = house.governance(sessionId);
+  // Forked effective-law publication is not inferred from a local-plan hash.
+  if (owners.length !== 1 || owner.operation !== 'ChromePublish' || owner.house !== cwd || owner.session_id !== sessionId ||
+      owner.arguments_digest !== digest({}) || current?.source_stamp || !current ||
+      !same(law(owner), { plan_hash: current.plan_hash, mechanism_stamp: current.mechanism_stamp, activation_id: current.activation_id }) ||
+      current.plan_hash !== plan.plan_hash || !same(checkpoint.actor, owner.actor)) return;
+  const done = receipts(owner.invocation_id);
+  if (owner.invocation_id !== activeOwner && (done.length !== 1 || !['failed', 'returned'].includes(done[0].status)) || done.length > 1) return;
+  const children = rows.filter(row => row.type === 'house_proposal' && row.parent_invocation_id === owner.invocation_id);
+  const allowed = ['Status', 'Deploy', 'Preview', 'Targets', 'Contexts', 'Deployment', 'Assert'].map(name => prefix + name);
+  if (children.some(row => !allowed.includes(row.operation))) return;
+  const original = name => {
+    const nameRows = children.filter(row => row.operation === prefix + name);
+    if (nameRows.length !== 1) return;
+    const p = nameRows[0], matches = receipts(p.invocation_id), r = matches[0], op = operations.get(name);
+    if (!op || house.registry.get(prefix + name) !== op || matches.length !== 1 || !['returned', 'failed', 'refused'].includes(r.status) ||
+        p.contract_digest !== op.digest || r.contract_digest !== op.digest || r.operation !== p.operation ||
+        p.house !== cwd || r.house !== cwd || p.session_id !== sessionId || r.session_id !== sessionId ||
+        r.parent_invocation_id !== owner.invocation_id || !same(p.actor, owner.actor) || !same(r.actor, owner.actor) ||
+        !same(law(p), law(owner)) || !same(law(r), law(owner)) || p.arguments_digest !== r.arguments_digest ||
+        rows.indexOf(p) <= rows.indexOf(owner) || rows.indexOf(r) <= rows.indexOf(p) ||
+        rows.some(row => row.type === 'house_proposal' && row.parent_invocation_id === p.invocation_id)) return;
+    if (r.status !== 'returned') return { proposal: p, receipt: r };
+    if (r.output_truncated || r.output_digest !== digest(r.output)) return;
+    try { return { proposal: p, receipt: r, output: JSON.parse(r.output) }; } catch { return; }
+  };
+  const deployment = original('Deploy');
+  const deployInput = { project: task.project, directory: task.directory, attempt_id: value.attempt_id, expected_manifest_sha256: value.file_manifest_sha256, ...(value.create_only ? { create_only: true } : {}) };
+  const d = deployment?.output;
+  if (!d || deployment.proposal.arguments_digest !== digest(deployInput) || !same(d, value.deployment) ||
+      d.project !== task.project || d.attempt_id !== value.attempt_id || d.file_manifest_sha256 !== value.file_manifest_sha256 ||
+      !text(d.extension_id, 240) || !text(value.attempt_id, 240)) return;
+  const result = {
+    format: 'comal-page-publication-diagnostic/1', scope: 'original_receipts_current_task_source_and_law',
+    stage: value.stage, publication_owner: owner.invocation_id, source_digest: value.source_digest,
+    deployment: { status: 'acknowledged', ...ref(deployment.receipt), attempt_id: value.attempt_id, extension_id: d.extension_id },
+    preview: { status: 'acknowledgement_unknown' }, document_identity: value.binding?.identity ? 'recorded_not_revalidated' : 'unobserved',
+    automatic_effect_replay: false, recovery_admission: 'unchanged', semantic_credit: false,
+  };
+  const preview = original('Preview'), opened = preview?.output;
+  if (preview && preview.proposal.arguments_digest === digest({ project: task.project, file: task.fixture.file })) {
+    result.preview = { status: 'acknowledgement_unknown', ...ref(preview.receipt) };
+    if (opened && text(opened.target_id, 240) && text(opened.url, 3000) && opened.lifetime === 'plugin_connection' &&
+        rows.indexOf(preview.proposal) > rows.indexOf(deployment.receipt) && value.binding?.target_id === opened.target_id && value.binding?.url === opened.url &&
+        value.binding.project === task.project && value.binding.fixture_source_digest === accepted.fixture_source_digest) {
+      const url = new URL(opened.url);
+      if (url.protocol !== 'http:' || url.hostname !== '127.0.0.1' || decodeURIComponent(url.pathname) !== '/' + task.fixture.file) return;
+      result.preview = { status: 'acknowledged', ...ref(preview.receipt), target_id: opened.target_id, url: opened.url };
+      const read = original('Contexts');
+      if (!value.binding.identity && read && ['failed', 'refused'].includes(read.receipt.status) && read.proposal.arguments_digest === digest({ target_id: opened.target_id }) && rows.indexOf(read.proposal) > rows.indexOf(preview.receipt)) {
+        result.stage = 'awaiting_document_identity';
+        result.read_failure = { ...ref(read.receipt), status: read.receipt.status, cause: 'not_established' };
+      }
+    }
+  }
+  const starts = rows.filter(row => row.type === 'chrome_page_case_started' && row.source === 'workflow_host' && row.task_digest === taskDigest && row.house === cwd && row.session_id === sessionId && row.input?.context?.source_digest === value.source_digest && row.input.context.publication?.attempt_id === value.attempt_id && same(row.actor, owner.actor));
+  const ownersStarted = new Set(starts.map(row => row.owner_id));
+  const observations = rows.filter(row => row.type === 'chrome_page_case_observed' && row.source === 'workflow_host' && row.task_digest === taskDigest && row.house === cwd && row.session_id === sessionId && ownersStarted.has(row.owner_id) && same(row.actor, owner.actor));
+  result.case_activity = { scope: 'audited_original_host_records_not_acceptance', started_records: starts.length, observed_records: observations.length };
+  // The URL and fixed facts fit the ordinary bounded diagnostic surface. Never
+  // truncate IDs or synthesize an executed:false claim to make an envelope fit.
+  if (Buffer.byteLength(JSON.stringify(result), 'utf8') <= 4000) return result;
+}
+
+// Trusted in-process workflow mark, not a plugin-provided details/code convention.
+// The current original House receipt chain must still bind the model call.
+export function markPagePublicationDiagnostic(error, facts, { invocation_id, sessionId, cwd }) {
+  diagnoses.set(error, { facts: structuredClone(facts), invocation_id, sessionId, cwd, code: error.code, message: error.message });
+  error.details = { ...error.details, page_publication: structuredClone(facts) };
+}
+export function pagePublicationDiagnosticForCall(error, { rows, sessionId, callId, operation }) {
+  const mark = diagnoses.get(error);
+  if (!mark || mark.sessionId !== sessionId || mark.code !== error.code || mark.message !== error.message) return;
+  const matches = rows.filter(row => row.type === 'house_receipt' && row.invocation_id === mark.invocation_id);
+  let leaf = matches[0];
+  if (matches.length !== 1 || !['ChromePublish', 'ChromeRecover'].includes(leaf.operation)) return;
+  const seen = new Set();
+  while (leaf) {
+    if (seen.has(leaf.invocation_id) || leaf.house !== mark.cwd || leaf.session_id !== sessionId || leaf.status !== 'failed' || leaf.code !== mark.code || leaf.error !== mark.message) return;
+    seen.add(leaf.invocation_id);
+    if (leaf.call_id === callId && leaf.operation === operation) return structuredClone(mark.facts);
+    const parents = rows.filter(row => row.type === 'house_receipt' && row.invocation_id === leaf.parent_invocation_id);
+    if (parents.length !== 1 || parents[0].operation !== 'ChromeDeliver') return;
+    leaf = parents[0];
+  }
+}

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

@@ -0,0 +1,48 @@
+// Bind scoped page receipts to their ORIGINAL effective activation before any
+// child dispatch. Accepted task/corpus identity remains the local page plan.
+import {digest} from '../operations.mjs';
+
+const fail=message=>Object.assign(new Error(message),{code:'CHROME_TASK_UNCERTAIN'});
+const identity=row=>({plan_hash:row.governance_plan_hash,mechanism_stamp:row.mechanism_stamp,activation_id:row.governance_activation_id});
+function activation(book,law,{cwd,sessionId,plan}){
+  const matches=book.rows.filter(r=>r.type==='governance_activated'&&r.source==='governance_host'&&r.house===cwd&&r.session_id===sessionId&&r.plan?.plan_hash===law.plan_hash&&r.mechanism_stamp===law.mechanism_stamp&&r.activation_id===law.activation_id);
+  if(matches.length!==1)throw fail('Original page effective-law activation is unavailable.');
+  const effective=matches[0],refs=effective.inherited_from;
+  if(!Array.isArray(refs)||digest(refs)!==digest(effective.plan.inherited_from))throw fail('Page effective law has no original scoped lineage.');
+  const locals=refs.filter(r=>r.house===cwd&&r.session_id===sessionId&&r.plan_hash===plan.plan_hash);
+  if(locals.length!==1)throw fail('Effective law omits the accepted local page corpus.');
+  const local=book.rows.find(r=>r.type==='governance_activated'&&r.source==='governance_host'&&r.house===cwd&&r.session_id===sessionId&&r.activation_id===locals[0].activation_id&&r.mechanism_stamp===locals[0].mechanism_stamp&&digest(r.plan)===digest(plan));
+  if(!local||book.rows.indexOf(local)>=book.rows.indexOf(effective))throw fail('Original local page activation does not verify.');return effective;
+ }
+export function pageReceiptLaw(book,receiptId,{cwd,sessionId,taskDigest,plan,scoped}){
+   const receipt=book.rows.find(r=>r.type==='house_receipt'&&r.invocation_id===receiptId);
+   const births=book.rows.filter(r=>r.type==='house_scope_bound'&&r.house===cwd&&r.session_id===sessionId);
+   if(!scoped&&!births.length)return plan.plan_hash;
+   if(!scoped||births.length!==1)throw fail('Original forked page scope birth is unavailable.');
+   let p=book.rows.find(r=>r.type==='house_proposal'&&r.invocation_id===receiptId);const descendant=p;
+   for(let depth=0;p&&p.operation!=='ChromeTest'&&depth<4;depth++)p=book.rows.find(r=>r.type==='house_proposal'&&r.invocation_id===p.parent_invocation_id);
+   if(!p||p.operation!=='ChromeTest'||!receipt)throw fail('Scoped page receipt has no original native test owner.');
+   const markers=book.rows.filter(r=>r.type==='chrome_page_effective_law_bound'&&r.invocation_id===p.invocation_id),m=markers[0];
+   if(markers.length!==1||m.source!=='workflow_host'||m.task_digest!==taskDigest||m.local_plan_hash!==plan.plan_hash||m.house!==cwd||m.session_id!==sessionId||digest(m.actor)!==digest(p.actor)||digest(m.effective)!==digest(identity(p))||digest(m.effective)!==digest(identity(receipt))||book.rows.indexOf(m)<=book.rows.indexOf(p)||book.rows.indexOf(m)>=book.rows.indexOf(descendant))throw fail('Scoped page receipt does not match its pre-dispatch effective-law reservation.');
+   if(!book.rows.some(r=>r.type==='house_scope_bound'&&r.scope_id===m.scope_id&&r.house===cwd&&r.session_id===sessionId&&book.rows.indexOf(r)<book.rows.indexOf(m)))throw fail('Page effective-law reservation belongs to another child.');
+   const effective=activation(book,m.effective,{cwd,sessionId,plan});if(book.rows.indexOf(effective)>=book.rows.indexOf(p))throw fail('Effective page law was attached after native dispatch.');return m.effective;
+}
+export function createPageLawBinding({house,store,sessionId,cwd,taskDigest,plan}){
+ return {
+  async bind(options){
+   const current=house.governance(sessionId);
+   // Preserve ordinary, unforked page behavior and its existing raw plan proof.
+   if(!current?.source_stamp)return;
+   await options.revalidate();const book=await store.load(sessionId),p=book.rows.find(r=>r.type==='house_proposal'&&r.invocation_id===options.invocation_id),law={plan_hash:current.plan_hash,mechanism_stamp:current.mechanism_stamp,activation_id:current.activation_id};
+   const live=house.governance(sessionId),liveLaw=live&&{plan_hash:live.plan_hash,mechanism_stamp:live.mechanism_stamp,activation_id:live.activation_id};
+   if(!book.journalAudit.consistent||p?.operation!=='ChromeTest'||p.house!==cwd||p.session_id!==sessionId||digest(identity(p))!==digest(law)||digest(liveLaw)!==digest(law))throw fail('Current effective page law changed before native child reservation.');
+   const effective=activation(book,law,{cwd,sessionId,plan}),birth=book.rows.filter(r=>r.type==='house_scope_bound'&&r.house===cwd&&r.session_id===sessionId);
+   if(birth.length!==1||book.rows.indexOf(effective)>=book.rows.indexOf(p))throw fail('The effective page law is not active in its original child.');
+   const marker={type:'chrome_page_effective_law_bound',source:'workflow_host',task_digest:taskDigest,local_plan_hash:plan.plan_hash,scope_id:birth[0].scope_id,invocation_id:p.invocation_id,actor:p.actor,house:cwd,session_id:sessionId,effective:law};
+   if(book.rows.some(r=>r.type===marker.type&&r.invocation_id===p.invocation_id))throw fail('Page effective-law reservation is duplicated.');
+   await options.recordWork(marker);
+  },
+  receiptLaw:(book,receiptId)=>pageReceiptLaw(book,receiptId,{cwd,sessionId,taskDigest,plan,scoped:Boolean(house.governance(sessionId)?.source_stamp)}),
+ };
+}
+export const PAGE_LAW_IMPLEMENTATION_DIGEST=digest([createPageLawBinding,pageReceiptLaw,activation,identity,fail].map(fn=>Function.prototype.toString.call(fn)));

package/src/workflows/chrome-page-recovery-host-v13.mjs

@@ -0,0 +1,14 @@
+// Private normal-host binding. Never exposed as a model tool or raw client API.
+import {digest} from '../operations.mjs';
+import {createPreviewTransportGuardV13,PAGE_PREVIEW_RECOVERY_V13} from './chrome-page-recovery-v13.mjs';
+const fail=()=>Object.assign(new Error('Explicit original v13 task and current activated native client binding required.'),{code:'CHROME_PUBLICATION_RECOVERY_REFUSED'});
+export function selectChromePageRecoveryHostV13({explicitTask,saved,trusted=false}){
+ const task=explicitTask??(saved?.source==='workflow_host'&&saved.acceptance==='explicit_cli_file'?saved.task:undefined);
+ if(!task?.publication_recovery)return undefined;
+ if(!trusted||task.surface!=='page'||digest(task.publication_recovery)!==digest(PAGE_PREVIEW_RECOVERY_V13))throw fail();
+ let current;
+ return Object.freeze({
+  bind(client){const guard=createPreviewTransportGuardV13(client);current?.retire();current=guard;return()=>{guard.retire();if(current===guard)current=undefined;};},
+  guard(){if(!current)throw fail();return current;},
+ });
+}

package/src/workflows/chrome-page-recovery-v13.mjs

@@ -0,0 +1,104 @@
+// Explicit prospective candidate. Not imported by the production v11/v12 route.
+import {createHash,randomUUID} from 'node:crypto';
+import {digest,immutable} from '../operations.mjs';
+import {auditExecution} from '../audit.mjs';
+import {ChromeLabClient} from '../plugins/chrome-lab/client.mjs';
+const prefix='plugin__chrome-lab__',guards=new WeakSet(),retiredGuards=new WeakSet();
+const limits=Object.freeze({version:13,max_reads:6,timeout_ms:10000,max_attempts:3,max_files:30});
+const fail=(message,code='CHROME_PUBLICATION_RECOVERY_REFUSED')=>Object.assign(new Error(message),{code});
+const exact=(a,b)=>digest(a)===digest(b),sha=v=>createHash('sha256').update(v).digest('hex');
+const tuple=value=>({connection_id:value?.connection_id,browser_endpoint_id:value?.browser_endpoint_id});
+const validTuple=value=>typeof value?.connection_id==='string'&&value.connection_id.length>0&&value.connection_id.length<=256&&typeof value?.browser_endpoint_id==='string'&&value.browser_endpoint_id.length>0&&value.browser_endpoint_id.length<=1500;
+const fileList=snapshot=>snapshot.files.map(({path,sha256})=>({path,sha256}));
+// No connect, reconnect, request, CDP, source read, or asynchronous fallback here.
+export function createPreviewTransportGuardV13(client){
+ if(!(client instanceof ChromeLabClient))throw fail('An actual host-owned ChromeLabClient is required.');
+ const guard={
+  retire(){retiredGuards.add(guard);},
+  capture(expected){if(retiredGuards.has(guard)||!validTuple(expected)||!client.connection||!client.child||!client.info||client.closed||client.failure||client.pending.size||client.attaching.size||!exact(tuple(expected),{connection_id:client.connectionId,browser_endpoint_id:client.info.browser_endpoint_id}))throw fail('Original live publication transport unavailable.');return{tuple:tuple(expected),connection:client.connection,child:client.child,info:client.info};},
+  assert(lease){if(retiredGuards.has(guard)||!lease||client.closed||client.failure||client.reconnecting||client.connection!==lease.connection||client.child!==lease.child||client.info!==lease.info||client.child?.exitCode!=null||client.child?.signalCode!=null||!exact(lease.tuple,{connection_id:client.connectionId,browser_endpoint_id:client.info?.browser_endpoint_id}))throw fail('Original publication connection changed; recovery cannot reconnect.');},
+  identity(lease,target,identity){guard.assert(lease);const observed=client.resourceIdentity(target,{frameId:identity.frame_id,sessionId:client.sessions.get(target),connectionId:lease.tuple.connection_id});if(!exact(observed,identity))throw fail('The newly observed document is no longer current.');},
+ };
+ guards.add(guard);return Object.freeze(guard);
+}
+export function assertPageRecoveryV13Admission(task,transportGuard){if(!guards.has(transportGuard)||retiredGuards.has(transportGuard)||!exact(task?.publication_recovery,PAGE_PREVIEW_RECOVERY_V13))throw fail('Exact explicit v13 descriptor and original host transport guard required before verifier preparation.');}
+export function createPagePreviewRecoveryV13({house,store,sessionId,cwd,task,taskDigest,plan,policy,transportGuard,snapshot,state,save,invoke}){
+ assertPageRecoveryV13Admission(task,transportGuard);
+ const operations=new Map(['Status','Deploy','Deployment','Preview','Targets','Contexts'].map(name=>[prefix+name,house.registry.get(prefix+name)]));
+ if([...operations.values()].some(op=>!op))throw fail('Original native publication/read operations are unavailable.');
+ const leases=new Map();let active=null;
+ const authority=()=>house.authority({policy,sessionId});
+ const epoch=book=>({reset:book.rows.findLast(row=>row.type==='reset')?.audit?.sha256??null,goal:book.goal?{id:book.goal.id,condition:book.goal.condition,status:book.goal.status}:null});
+ const checkOperations=()=>{for(const[name,op]of operations)if(house.registry.get(name)!==op)throw fail('An original native operation was replaced.');};
+ const readBook=async()=>{const book=await store.load(sessionId),audit=auditExecution(book,house.stateContext());if(book.id!==sessionId||book.cwd!==cwd||!book.journalAudit.consistent||audit.violations.length||audit.unresolved.length)throw fail('Original complete native book is unavailable.');return book;};
+ const receipt=(book,id,operation,owner,returned=true)=>{
+  const proposals=book.rows.filter(r=>r.type==='house_proposal'&&r.invocation_id===id),receipts=book.rows.filter(r=>r.type==='house_receipt'&&r.invocation_id===id),starts=book.rows.filter(r=>r.type==='house_started'&&r.invocation_id===id);
+  const p=proposals[0],r=receipts[0],op=operations.get(operation),law=house.governance(sessionId);
+  if(proposals.length!==1||receipts.length!==1||p.operation!==operation||r.operation!==operation||p.parent_invocation_id!==owner||r.parent_invocation_id!==owner||r.session_id!==sessionId||r.house!==cwd||!exact(p.actor,r.actor)||p.arguments_digest!==r.arguments_digest||p.contract_digest!==r.contract_digest||r.governance_plan_hash!==plan.plan_hash||p.governance_plan_hash!==plan.plan_hash||r.mechanism_stamp!==law?.mechanism_stamp||p.mechanism_stamp!==law?.mechanism_stamp||r.governance_activation_id!==law?.activation_id||p.governance_activation_id!==law?.activation_id||op&&r.contract_digest!==op.digest||returned&&(r.status!=='returned'||r.output_truncated||r.output_digest!==digest(r.output))||!returned&&!['failed','refused'].includes(r.status)||r.status!=='refused'&&starts.length!==1||book.rows.indexOf(p)>=book.rows.indexOf(r))throw fail('Original publication owner/child receipt is missing or incompatible.');
+  return{proposal:p,row:r,value:returned?JSON.parse(r.output):null};
+ };
+ const originalProof=(book,value,lease)=>{
+  const a=book.rows.findLast(r=>r.type==='chrome_task_accepted'&&r.source==='workflow_host');
+  if(a?.task_digest!==taskDigest||digest(a.task)!==taskDigest||a.governance_profile?.version!=='13'||a.governance_plan_hash!==plan.plan_hash||!exact(a.task.publication_recovery,PAGE_PREVIEW_RECOVERY_V13))throw fail('Only the original prospectively accepted v13 task can recover.');
+  const obs=value.publication_observation;
+  if(value.stage!=='page_open_pending'||value.status!=='ready'||!obs||!lease||obs.lease_id!==lease.id||obs.owner_id!==lease.owner||!exact(obs.transport,lease.transport.tuple)||!exact(epoch(book),lease.epoch)||!exact(value,lease.checkpoint))throw fail('Original publication checkpoint/lease changed.');
+  const own=book.rows.filter(r=>r.type==='house_receipt'&&r.invocation_id===obs.owner_id),owner=own[0],proposal=book.rows.find(r=>r.type==='house_proposal'&&r.invocation_id===obs.owner_id);
+  if(own.length!==1||owner.operation!=='ChromePublish'||owner.status!=='failed'||proposal?.arguments_digest!==digest({})||owner.session_id!==sessionId||owner.house!==cwd||!exact(owner.actor,lease.actor)||owner.governance_plan_hash!==plan.plan_hash||owner.mechanism_stamp!==lease.law.mechanism_stamp||owner.governance_activation_id!==lease.law.activation_id||owner.contract_digest!==lease.publishContract||proposal.contract_digest!==owner.contract_digest)throw fail('Original failed ChromePublish owner did not settle.');
+  if(proposal.parent_invocation_id){const parent=book.rows.find(r=>r.type==='house_receipt'&&r.invocation_id===proposal.parent_invocation_id);const parentProposal=book.rows.find(r=>r.type==='house_proposal'&&r.invocation_id===proposal.parent_invocation_id);if(parent?.operation!=='ChromeDeliver'||parent.status!=='failed'||parent.parent_invocation_id!==null||parent.session_id!==sessionId||parent.house!==cwd||!exact(parent.actor,lease.actor)||parentProposal?.arguments_digest!==digest({})||book.rows.filter(r=>r.type==='house_proposal'&&r.parent_invocation_id===parent.invocation_id).some(r=>r.invocation_id!==owner.invocation_id))throw fail('Original candidate parent is missing or contains other effects.');}
+  const children=book.rows.filter(r=>r.type==='house_proposal'&&r.parent_invocation_id===obs.owner_id),expected=['Status','Deploy','Preview','Status','Targets','Contexts'];
+  if(children.length!==expected.length||children.some((r,i)=>r.operation!==prefix+expected[i]||!exact(r.actor,lease.actor)||r.session_id!==sessionId||r.house!==cwd)||book.rows.some(r=>r.type==='house_proposal'&&children.some(child=>child.invocation_id===r.parent_invocation_id)))throw fail('Original descendants are not the exact acknowledged-Preview/read-failure sequence.');
+  const parsed=children.map((p,i)=>receipt(book,p.invocation_id,p.operation,obs.owner_id,i<5));
+  if(parsed[0].row.invocation_id!==obs.status_before_id||parsed[1].row.invocation_id!==obs.deploy_id||parsed[2].row.invocation_id!==obs.preview_id||parsed[3].row.invocation_id!==obs.status_after_id||!exact(tuple(parsed[0].value),obs.transport)||!exact(tuple(parsed[3].value),obs.transport)||parsed[0].proposal.arguments_digest!==digest({})||parsed[3].proposal.arguments_digest!==digest({}))throw fail('Original transport observations do not bind Preview.');
+  if(parsed[1].proposal.arguments_digest!==digest({project:task.project,directory:task.directory,attempt_id:value.attempt_id,expected_manifest_sha256:value.file_manifest_sha256,...(value.create_only?{create_only:true}:{})})||parsed[2].proposal.arguments_digest!==digest({project:task.project,file:task.fixture.file})||!exact(parsed[1].value,value.deployment)||parsed[2].value.target_id!==value.binding?.target_id||parsed[2].value.url!==value.binding?.url||parsed[2].value.lifetime!=='plugin_connection'||value.binding.identity||value.binding.project!==task.project)throw fail('Original deployment/Preview acknowledgment differs from its checkpoint.');
+  if(parsed[4].proposal.arguments_digest!==digest({})||parsed[5].proposal.arguments_digest!==digest({target_id:value.binding.target_id})||parsed[4].value.truncated||parsed[4].value.targets.filter(r=>r.target_id===value.binding.target_id&&r.type==='page'&&r.url===value.binding.url).length!==1)throw fail('Original exact target/read suffix is unavailable.');
+  const latest=book.rows.findLast(r=>r.type==='chrome_task_checkpoint'&&r.task_digest===taskDigest);
+  if(!latest||latest.invocation_id!==obs.owner_id||!exact(latest.state,value))throw fail('A different checkpoint superseded the original publication.');
+  const late=book.rows.slice(book.rows.indexOf(owner)+1).filter(r=>r.type==='house_proposal');
+  for(const r of late){
+   if(r.operation==='ChromeRecover'&&r.parent_invocation_id===null&&r.arguments_digest===digest({}))continue;
+   if(['Deployment','Targets','Contexts'].map(n=>prefix+n).includes(r.operation)&&book.rows.some(p=>p.type==='house_proposal'&&p.invocation_id===r.parent_invocation_id&&p.operation==='ChromeRecover'))continue;
+   const done=book.rows.find(p=>p.type==='house_receipt'&&p.invocation_id===r.invocation_id),contract=book.rows.findLast(p=>p.type==='house_contract'&&p.contract_digest===r.contract_digest)?.contract;
+   if(['Read','FileInfo','SourceRead'].includes(r.operation)&&done?.status==='returned'&&contract?.effects?.external==='none'&&contract.effects.process==='none'&&contract.effects.authority==='none')continue;
+   if(['ChromeInspect','ChromeVerify','ChromeTest','ChromePublish','ChromeDeliver'].includes(r.operation)&&['failed','refused'].includes(done?.status)&&done.code==='CHROME_TASK_UNCERTAIN'&&!book.rows.some(p=>p.type==='house_proposal'&&p.parent_invocation_id===r.invocation_id))continue;
+   throw fail('Later application effects or another unknown owner prevent this recovery.');
+  }
+  return{owner_id:owner.invocation_id,preview_id:parsed[2].row.invocation_id,failed_identity_id:parsed[5].row.invocation_id,checkpoint_sha256:latest.audit.sha256};
+ };
+ const stable=(lease,options)=>{options.signal?.throwIfAborted();checkOperations();for(const[name,op]of lease?.ownOperations||[])if(house.registry.get(name)!==op)throw fail('Original page kernel operation was replaced.');transportGuard.assert(lease.transport);if(authority()!==lease.authority)throw fail('Original/current publication authority changed.');};
+ const local=async(lease,options,value)=>{stable(lease,options);const current=await snapshot(options.signal);stable(lease,options);if(digest(fileList(current))!==value.source_digest||sha(JSON.stringify(fileList(current)))!==value.file_manifest_sha256||!exact(fileList(current),value.deployment.files))throw fail('Exact accepted local publication bytes changed.');return current;};
+ const physical=(remote,value,lease)=>{if(remote.status!=='observed'||remote.project!==task.project||remote.attempt_id!==value.attempt_id||remote.extension_id!==value.deployment.extension_id||remote.remote_path!==value.deployment.remote_path||remote.file_manifest_sha256!==value.file_manifest_sha256||remote.files_truncated||remote.file_count!==value.deployment.file_count||remote.file_count>limits.max_files||!exact(remote.files,value.deployment.files)||!exact(tuple(remote),lease.transport.tuple))throw fail('Exact physical publication or transport changed.');};
+ return{
+  async assertReturnedRecovery(value,book){
+   if(!value.recovery)return;
+   const r=value.recovery,owner=book.rows.find(row=>row.type==='house_receipt'&&row.invocation_id===r.owner_id),proposal=book.rows.find(row=>row.type==='house_proposal'&&row.invocation_id===r.owner_id);
+   if(r.format!=='comal-page-publication-recovery/13'||owner?.operation!=='ChromeRecover'||owner.status!=='returned'||owner.output_truncated||owner.output_digest!==digest(owner.output)||owner.session_id!==sessionId||owner.house!==cwd||proposal?.parent_invocation_id!==null||proposal.arguments_digest!==digest({}))throw fail('Recovery owner did not return; its observation cannot advance the page task.');
+   const result=JSON.parse(owner.output),children=book.rows.filter(row=>row.type==='house_proposal'&&row.parent_invocation_id===owner.invocation_id),names=['Deployment','Targets','Contexts','Deployment','Targets','Contexts'];
+   if(result.status!=='publication_ready_unverified'||result.attempt_id!==value.attempt_id||result.source_digest!==value.source_digest||result.observation_digest!==r.observation_digest||result.reads!==limits.max_reads||children.length!==names.length)throw fail('Original returned recovery outcome is incomplete.');
+   for(const[p,index]of children.map((p,i)=>[p,i])){const name=names[index],expected=name==='Deployment'?{project:task.project,reconnect:false}:name==='Targets'?{}:{target_id:value.binding.target_id};if(p.operation!==prefix+name||p.arguments_digest!==digest(expected))throw fail('Recovery owner has another child.');receipt(book,p.invocation_id,p.operation,owner.invocation_id);if(book.rows.some(row=>row.type==='house_proposal'&&row.parent_invocation_id===p.invocation_id))throw fail('Recovery read acquired an unexpected descendant.');}
+  },
+  async capture(options,namespace){const candidate=await snapshot(options.signal);if(candidate.files.length>limits.max_files)throw fail('Complete v13 publication evidence exceeds the explicit file bound.');checkOperations();const transport=transportGuard.capture(namespace),book=await readBook(),id=randomUUID(),lease={id,owner:options.invocation_id,actor:structuredClone(options.actor),authority:authority(),transport,epoch:epoch(book),publishContract:house.registry.get('ChromePublish').digest,law:house.governance(sessionId),ownOperations:new Map(['ChromePublish','ChromeRecover','ChromeDeliver','ChromeTest','ChromeFinish','ChromeVerify','ChromeInspect','ChromePageCase','ChromePageBehavior'].map(name=>[name,house.registry.get(name)]))};leases.set(id,lease);return id;},
+  async acknowledge(options,value,opened,namespace,id){const lease=leases.get(id);stable(lease,options);const observed=await invoke(options,'Status');stable(lease,options);if(!exact(tuple(namespace),tuple(observed)))throw fail('Preview transport changed before its acknowledgment.');const book=await readBook(),children=book.rows.filter(r=>r.type==='house_receipt'&&r.parent_invocation_id===options.invocation_id&&r.status==='returned'),statuses=children.filter(r=>r.operation===prefix+'Status'),deployment=children.find(r=>r.operation===prefix+'Deploy'),preview=children.find(r=>r.operation===prefix+'Preview');if(statuses.length!==2||!deployment||!preview||deployment.output_truncated||preview.output_truncated||!exact(JSON.parse(preview.output),opened)||!validTuple(observed)||value.deployment.files_truncated||value.deployment.file_count>limits.max_files||value.deployment.files.length!==value.deployment.file_count)throw fail('Complete prospective Preview/source evidence unavailable.');value.publication_observation={format:'comal-page-preview-observation/13',owner_id:options.invocation_id,lease_id:id,transport:tuple(observed),status_before_id:statuses[0].invocation_id,deploy_id:deployment.invocation_id,preview_id:preview.invocation_id,status_after_id:statuses[1].invocation_id};lease.checkpoint=structuredClone(value);await options.recordWork({type:'chrome_page_preview_acknowledged',source:'workflow_host',task_digest:taskDigest,...value.publication_observation,authority_stamp:lease.authority,epoch:lease.epoch});},
+  admit(view){if(!active||view.parent_invocation_id!==active.owner||!['Deployment','Targets','Contexts'].map(n=>prefix+n).includes(view.operation))return false;const name=view.operation.slice(prefix.length),input=name==='Deployment'?{project:task.project,reconnect:false}:name==='Targets'?{}:{target_id:active.target};return exact(view.input,input);},
+  async recover(options,value){
+   const lease=leases.get(value.publication_observation?.lease_id);if(!lease)throw fail('Original live publication lease is unavailable; no reconnect is authorized.');stable(lease,options);await local(lease,options,value);const initial=await readBook(),proof=originalProof(initial,value,lease),root=initial.rows.find(r=>r.type==='house_proposal'&&r.invocation_id===options.invocation_id);if(root?.parent_invocation_id!==null||!exact(root.actor,lease.actor))throw fail('Recovery must retain its original actor and root ownership.');
+   if(initial.rows.filter(r=>r.type==='chrome_page_publication_recovery_started'&&r.task_digest===taskDigest&&r.publication_owner===proof.owner_id).length>=limits.max_attempts)throw fail('Original publication recovery attempt budget exhausted.');
+   const signal=AbortSignal.any([...(options.signal?[options.signal]:[]),AbortSignal.timeout(limits.timeout_ms)]),bounded={...options,signal};let reads=0;active={owner:options.invocation_id,target:value.binding.target_id};
+   try{await options.recordWork({type:'chrome_page_publication_recovery_started',source:'workflow_host',task_digest:taskDigest,publication_owner:proof.owner_id,original_proof:proof,limits});stable(lease,bounded);
+    const read=async(name,input={})=>{if(++reads>limits.max_reads)throw fail('Recovery read bound exhausted.');stable(lease,bounded);await options.revalidate();stable(lease,bounded);const result=await invoke(bounded,name,input);stable(lease,bounded);await local(lease,bounded,value);const book=await readBook();originalProof(book,value,lease);return result;};
+    let identity;
+    for(let pass=0;pass<2;pass++){
+     physical(await read('Deployment',{project:task.project,reconnect:false}),value,lease);
+     const targets=await read('Targets');if(targets.truncated||!Array.isArray(targets.targets)||targets.targets.filter(t=>t.target_id===value.binding.target_id&&t.type==='page'&&t.url===value.binding.url).length!==1||targets.targets.some(t=>t.target_id!==value.binding.target_id&&t.type==='page'&&t.url===value.binding.url))throw fail('Exact original target is missing, duplicated or changed.');
+     const contexts=await read('Contexts',{target_id:value.binding.target_id}),next=contexts.identity;
+     if(!next?.context_unique_id||!next.frame_id||!exact(tuple(next),lease.transport.tuple)||identity&&!exact(next,identity))throw fail('A stable exact original document identity was not obtained.');identity=next;transportGuard.identity(lease.transport,value.binding.target_id,identity);
+    }
+    await local(lease,bounded,value);const finalBook=await readBook();originalProof(finalBook,value,lease);stable(lease,bounded);transportGuard.identity(lease.transport,value.binding.target_id,identity);await options.revalidate();stable(lease,bounded);
+    const observation_digest=digest({identity,proof,reads,attempt_id:value.attempt_id,source_digest:value.source_digest});
+    const current={...value,binding:{...value.binding,identity},stage:'published',status:'ready',recovery:{format:'comal-page-publication-recovery/13',owner_id:options.invocation_id,proof,reads,observation_digest,claim:'publication_ready_unverified'}};
+    if(['behavior_receipt_id','behavior_owner','test_owner','final_validation_receipt_id','verified_scope','case_series','case_progress','case_pending','case_cursor','case_final_owner'].some(k=>Object.hasOwn(value,k)))throw fail('Recovery cannot inherit semantic or Case credit.');
+    await save(options,current);stable(lease,bounded);return{status:'publication_ready_unverified',next_action:'ChromeTest',claim:'metadata_only_no_semantic_credit',attempt_id:value.attempt_id,source_digest:value.source_digest,original_publication_owner:proof.owner_id,original_preview:proof.preview_id,observation_digest,reads,asked:'unjudged'};
+   }finally{active=null;}
+  },
+ };
+}
+export const PAGE_PREVIEW_RECOVERY_V13=immutable({format:'comal-page-preview-recovery/13',...limits,implementation_digest:digest({limits,functions:[createPreviewTransportGuardV13,createPagePreviewRecoveryV13,assertPageRecoveryV13Admission,tuple,validTuple,fileList,fail,exact,sha].map(fn=>Function.prototype.toString.call(fn))})});