@milpa/comal 0.1.7 → 0.2.0

package/src/source-ownership.mjs

@@ -0,0 +1,73 @@
+import {mkdir,lstat,realpath,readFile,stat} from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import {createHash} from 'node:crypto';
+import {acquireProcessLock,processIdentity} from './process-lock.mjs';
+import {auditExecution} from './audit.mjs';
+import {digest} from './operations.mjs';
+import {ensurePrivateDirectory,assertPrivateDirectory} from './private-fs.mjs';
+
+const fail=(message,code='SOURCE_LOCK_UNRESOLVED')=>Object.assign(new Error(message),{code});
+const normal=file=>process.platform==='win32'?file.toLowerCase():file;
+export const defaultSourceLockDirectory=()=>path.join(os.homedir(),'.comal','source-locks');
+export function sourceLockFile(file,directory=defaultSourceLockDirectory()){
+  return path.join(directory,createHash('sha256').update(normal(file)).digest('hex')+'.lock');
+}
+
+// Same OS user + shared registry + canonical path. This is cooperative native
+// ownership, not exclusion of Bash, arbitrary editors or other OS accounts.
+export class SourceOwnership {
+  constructor({cwd,store,directory=defaultSourceLockDirectory()}){
+    this.cwd=cwd;this.store=store;this.directory=path.resolve(directory);this.held=new Map();this.paths=new Map();
+  }
+  contains(file){const r=path.relative(this.directory,file);return r===''||r!=='..'&&!r.startsWith('..'+path.sep)&&!path.isAbsolute(r);}
+  async prepareDirectory(){
+    const parent=path.dirname(this.directory);
+    await mkdir(parent,{recursive:true,mode:0o700});
+    if(await realpath(parent)!==parent)throw fail('Native source lock registry has a noncanonical parent.');
+    try{await ensurePrivateDirectory(this.directory);}catch(error){if(error.code==='PRIVATE_STATE_UNSAFE')throw fail('Native source lock registry is not private.');throw error;}
+    const info=await lstat(this.directory);
+    try{await assertPrivateDirectory(this.directory,info);}catch{throw fail('Native source lock registry is not a private canonical directory.');}
+  }
+  async acquire(file,{invocation_id,sessionId,actor,operation,signal,recordWork}){
+    signal?.throwIfAborted();await this.prepareDirectory();
+    const resource={kind:'native-source-v1',file,cwd:this.cwd,session_id:sessionId??null,actor,invocation_id,operation,journal:this.store&&sessionId?this.store.file(sessionId):null};
+    let lock;
+    try{lock=await acquireProcessLock(sourceLockFile(file,this.directory),{resource,validate:owner=>this.validateSettledOwner(owner,file)});}
+    catch(error){if(error.code==='SESSION_IN_USE')throw fail('Another native source operation owns this file. No replacement was started. Propose again after it settles, preserving your expected source version.','SOURCE_BUSY');throw error;}
+    const state={file,lock,signal,beforeHash:undefined};this.held.set(invocation_id,state);this.paths.set(normal(file),state);
+    await recordWork({type:'source_ownership_acquired',source:'workspace_host',resource,resource_digest:digest(resource)});
+    signal?.throwIfAborted();return state;
+  }
+  transaction(file){return this.paths.get(normal(file));}
+  async settle({invocation_id,receiptRecorded}){
+    const state=this.held.get(invocation_id);if(!state)return;
+    if(!receiptRecorded){
+      // Keep the marker after a lost durable outcome. Even when the process
+      // later dies, reclamation still requires a verified settlement/recovery.
+      await state.lock.file.close();this.held.delete(invocation_id);this.paths.delete(normal(state.file));return;
+    }
+    await state.lock.release();this.held.delete(invocation_id);this.paths.delete(normal(state.file));
+  }
+  async validateSettledOwner(owner,file){
+    const r=owner.resource;
+    if(r?.kind!=='native-source-v1'||normal(r.file||'')!==normal(file)||!['Write','Edit'].includes(r.operation)||typeof r.journal!=='string'||!r.session_id||!r.invocation_id)throw fail('Dead source owner has no verifiable native journal; ownership was preserved.');
+    try{
+      const info=await stat(r.journal);if(!info.isFile()||info.size>64*1024*1024)throw fail('Source owner journal is unavailable or exceeds the recovery inspection bound.');
+      const bytes=await readFile(r.journal),rows=bytes.toString('utf8').trim().split('\n').map(JSON.parse);
+      if(rows[0]?.type!=='session'||rows[0].id!==r.session_id||rows[0].cwd!==r.cwd)throw fail('Source owner journal identity does not match.');
+      const audit=auditExecution({rows,id:r.session_id,cwd:r.cwd});
+      if(!audit.journal.verified||audit.violations.length||audit.unverified.some(x=>x.invocation_id===r.invocation_id))throw fail('Source owner journal does not verify.');
+      const proposal=rows.find(x=>x.type==='house_proposal'&&x.invocation_id===r.invocation_id),receipts=rows.filter(x=>x.type==='house_receipt'&&x.invocation_id===r.invocation_id),receipt=receipts[0];
+      if(!proposal||receipts.length!==1||!['returned','failed','refused'].includes(receipt?.status)||proposal.operation!==r.operation||proposal.house!==r.cwd||digest(proposal.actor)!==digest(r.actor)||proposal.session_id!==r.session_id)throw fail('Source invocation has no verified durable outcome; reconcile it without replay before writing.');
+      for(const key of Object.keys(processIdentity))if(digest(proposal.execution_process?.[key]??null)!==digest(owner[key]??null))throw fail('Source owner process does not match its native proposal.');
+      const acquired=rows.filter(x=>x.type==='source_ownership_acquired'&&x.invocation_id===r.invocation_id);
+      if(acquired.length!==1||acquired[0].source!=='workspace_host'||acquired[0].house!==r.cwd||acquired[0].session_id!==r.session_id||digest(acquired[0].actor)!==digest(r.actor)||acquired[0].resource_digest!==digest(r)||digest(acquired[0].resource)!==digest(r))throw fail('Source ownership is not bound to its native invocation journal.');
+      const contract=rows.find(x=>x.type==='house_contract'&&x.contract_digest===proposal.contract_digest)?.contract;
+      if(contract?.origin!==null||contract.name!==r.operation||contract.permission!==r.operation||contract.steps||contract.effects?.workspace!=='write'||contract.effects?.external!=='none'||contract.effects?.process!=='none')throw fail('Source owner is not a native file operation.');
+      if(audit.unresolved.some(x=>x.invocation_id===r.invocation_id))throw fail('Source owner remains unresolved.');
+      // A durable failed outcome still retains its unknown/partial attribution.
+      // Releasing exclusion never retries it or certifies its requested effect.
+    }catch(error){if(error.code==='SOURCE_LOCK_UNRESOLVED')throw error;throw fail('Source owner journal could not be verified; ownership was preserved.');}
+  }
+}

package/src/source-proposal-proof.mjs

@@ -0,0 +1,55 @@
+import {createHash} from 'node:crypto';
+import {digest} from './operations.mjs';
+export const sourceSHA=value=>createHash('sha256').update(value).digest('hex');
+export const sourceContract=contract=>{const {revision,...semantic}=contract;return digest(semantic);};
+export const sourceOwn=(a,b)=>['session_id','house','surface','actor'].every(k=>digest(a[k]??null)===digest(b[k]??null));
+const contractFor=(rows,p)=>rows.findLast(r=>r.type==='house_contract'&&r.contract_digest===p?.contract_digest)?.contract;
+export function nativeSourceParent(rows,p){const c=contractFor(rows,p);return ['SourceDraft','SourceRetain','SourcePublish'].includes(p?.operation)&&c?.name===p.operation&&c.origin===null&&c.permission===p.operation&&c.steps===true&&c.effects?.external==='none'&&c.effects?.process==='none'&&c.effects?.authority==='none'&&c.effects?.workspace===(p.operation==='SourcePublish'?'write':'read');}
+export function sourceInput(rows,p){
+ const facts=rows.slice(0,rows.indexOf(p)).filter(r=>r.type==='message'&&r.message?.role==='assistant').flatMap(r=>r.message.content||[]).filter(c=>c.type==='tool_use'&&c.id===p.call_id&&c.name===p.operation&&digest(c.input)===p.arguments_digest);
+ return facts.length===1?facts[0].input:null;
+}
+export function sourcePartValid(rows,row){try{
+ if(row.type!=='source_part'||row.source!=='source_host'||!Number.isSafeInteger(row.index)||row.index<0)return false;
+ const parent=rows.find(p=>p.type==='house_proposal'&&p.invocation_id===row.invocation_id);
+ if(!nativeSourceParent(rows,parent)||!sourceOwn(parent,row))return false;
+ const data=row.data;if(digest(data)!==row.data_digest||data.version!==1||data.file_path!==row.file_path||typeof row.content!=='string')return false;
+ if(!rows.some(r=>r.type==='house_started'&&r.invocation_id===parent.invocation_id&&sourceOwn(r,parent))||rows.indexOf(parent)>=rows.indexOf(row))return false;
+ if(parent.operation==='SourceRetain'){
+  const original=rows.find(p=>p.type==='house_proposal'&&p.invocation_id===data.original_invocation),input=original&&sourceInput(rows,original),receipt=original&&rows.findLast(r=>r.type==='house_receipt'&&r.invocation_id===original.invocation_id),c=contractFor(rows,original);
+  if(!original||!sourceOwn(original,row)||!['Write','Edit'].includes(original.operation)||c?.origin!==null||c.permission!==original.operation||c.steps||c.effects?.workspace!=='write'||['external','process','authority'].some(k=>c.effects?.[k]!=='none')||!input||receipt?.status!=='refused'||receipt.code!=='MODEL_STEP_TOO_LARGE'||receipt.effects_observed!=='none'||!sourceOwn(receipt,row))return false;
+  if(data.operation!==original.operation||digest(row.retained_input)!==original.arguments_digest||digest(input)!==digest(row.retained_input)||row.content!=='')return false;
+ }else if(parent.operation==='SourceDraft'){
+  if(data.operation!=='Write'||row.retained_input!==undefined||Buffer.byteLength(row.content)>64000)return false;
+  if(parent.arguments_digest!==digest(row.draft_input)||row.draft_input.draft_id!==row.draft_id||row.draft_input.part_id!==row.part_id||row.draft_input.content!==row.content||Boolean(row.draft_input.final)!==row.final)return false;
+ }else return false;
+ const info=rows.findLast(r=>r.type==='house_receipt'&&r.invocation_id===data.inspection_id),ip=rows.find(r=>r.type==='house_proposal'&&r.invocation_id===data.inspection_id),ic=contractFor(rows,ip);
+ if(!info||!ip||!sourceOwn(info,row)||info.operation!=='FileInfo'||info.status!=='returned'||info.output_truncated||info.output_digest!==digest(info.output)||ic?.origin!==null||ic.permission!=='FileInfo'||ic.steps)return false;
+ if(rows.indexOf(info)>=rows.indexOf(row)||rows.indexOf(ip)>=rows.indexOf(info))return false;
+ const snapshot=JSON.parse(info.output);
+ const expected=parent.operation==='SourceRetain'?row.retained_input.expected_sha256??data.inspected_sha256:row.index===0?row.draft_input.expected_sha256??data.inspected_sha256:data.expected_sha256;
+ if(data.expected_sha256!==expected||ip.arguments_digest!==digest({file_path:data.requested_path,hash:true,allow_missing:true,max_bytes:1048576})||info.parent_invocation_id!==rows.find(r=>r.type==='source_part'&&r.draft_id===row.draft_id&&sourceOwn(r,row))?.invocation_id)return false;
+ return snapshot.file_path===row.file_path&&snapshot.type==='file'&&snapshot.sha256===data.inspected_sha256||snapshot.file_path===row.file_path&&snapshot.type==='absent'&&data.inspected_sha256==='absent';
+}catch{return false;}}
+export function sourceMaterial(rows,ref){
+ const last=rows.find(r=>r.type==='source_part'&&r.ref===ref);if(!last)return null;
+ const parts=rows.filter(r=>r.type==='source_part'&&r.draft_id===last.draft_id&&sourceOwn(r,last)&&digest(r.data)===digest(last.data)&&rows.indexOf(r)<=rows.indexOf(last));
+ if(!parts.length||parts.some((r,i)=>r.index!==i||i<parts.length-1&&r.final||!sourcePartValid(rows,r))||new Set(parts.map(p=>p.part_id)).size!==parts.length)return null;
+ const input=last.data.original_invocation?last.retained_input:{file_path:last.file_path,content:parts.map(r=>r.content).join('')};
+ const resolved={...input,file_path:last.file_path,expected_sha256:last.data.expected_sha256};
+ if(parts.some(r=>r.ref!=='source:'+digest({data:r.data,parts:parts.slice(0,r.index+1).map(p=>({part_id:p.part_id,content:p.content,final:p.final,...(p.retained_input?{retained_input:p.retained_input}:{})}))})))return null;
+ return {last,parts,input:resolved,complete:last.final,bytes:Buffer.byteLength(last.data.operation==='Write'?resolved.content:resolved.new_string),sha256:sourceSHA(last.data.operation==='Write'?resolved.content:resolved.new_string)};
+}
+export function sourcePublicationLeafValid(rows,p){try{
+ const parent=rows.find(r=>r.type==='house_proposal'&&r.invocation_id===p.parent_invocation_id),dispatch=rows.find(r=>r.type==='source_dispatch'&&r.invocation_id===parent?.invocation_id&&r.call_id===p.call_id),intent=dispatch&&rows.find(r=>r.type==='source_publication_intent'&&r.intent_id===dispatch.intent_id),material=intent&&sourceMaterial(rows,intent.ref);
+ const original=intent&&rows.find(r=>r.type==='house_proposal'&&r.invocation_id===intent.invocation_id),writer=contractFor(rows,p);
+ return Boolean(nativeSourceParent(rows,original)&&original.operation==='SourcePublish'&&original.arguments_digest===digest({ref:intent.ref,publication_id:intent.publication_id})&&sourceOwn(original,intent)&&writer&&sourceContract(writer)===material?.last.data.contract&&rows.indexOf(intent)<rows.indexOf(dispatch)&&rows.indexOf(dispatch)<rows.indexOf(p)&&nativeSourceParent(rows,parent)&&parent.operation==='SourcePublish'&&dispatch?.source==='source_host'&&intent?.source==='source_host'&&sourceOwn(parent,p)&&sourceOwn(dispatch,p)&&sourceOwn(intent,p)&&material?.complete&&sourceOwn(material.last,p)&&intent.operation===p.operation&&intent.arguments_digest===digest(material.input)&&p.arguments_digest===intent.arguments_digest&&intent.call_id===p.call_id&&parent.arguments_digest===digest({ref:intent.ref,publication_id:intent.publication_id}));
+}catch{return false;}}
+export function sourceRecoveryPlan(rows,p){
+ if(!nativeSourceParent(rows,p))return null;
+ const children=rows.filter(r=>r.type==='house_proposal'&&r.parent_invocation_id===p.invocation_id);
+ if(children.some(c=>!rows.some(r=>r.type==='house_receipt'&&r.invocation_id===c.invocation_id)))return null;
+ if(children.some(c=>!['FileInfo','Write','Edit'].includes(c.operation)||['Write','Edit'].includes(c.operation)&&!sourcePublicationLeafValid(rows,c)))return null;
+ return {kind:'source_recorded',code:'HOUSE_RECOVERY_SOURCE_CONTINUE',error:'The source operation was interrupted. SourceRead exposes retained data and recorded native outcomes. No publication was replayed; source effects do not establish task acceptance.',effects_observed:'recorded_source_children_not_delivery',child_refs:children.map(c=>rows.findIndex(r=>r.type==='house_receipt'&&r.invocation_id===c.invocation_id))};
+}
+export function sourceRecoveryValid(rows,index,row){const plan=sourceRecoveryPlan(rows.slice(0,index),rows[row.recovery.proposal_ref]);return Boolean(plan&&row.status==='refused'&&row.code===plan.code&&row.error===plan.error&&row.effects_observed===plan.effects_observed&&row.recovery.plan_digest===digest(plan));}

package/src/source-proposals.mjs

@@ -0,0 +1,118 @@
+import path from 'node:path';
+import {randomUUID} from 'node:crypto';
+import {digest} from './operations.mjs';
+import {workProjection} from './work-plan.mjs';
+import {auditExecution} from './audit.mjs';
+import {acquireProcessLock} from './process-lock.mjs';
+import {ensurePrivateDirectory} from './private-fs.mjs';
+import {sourceContract,sourceOwn,sourceInput,sourceMaterial,sourcePublicationLeafValid} from './source-proposal-proof.mjs';
+const id={type:'string',pattern:'^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}$'},ref={type:'string',pattern:'^source:[a-f0-9]{64}$'},version={type:'string',pattern:'^(?:absent|[a-f0-9]{64})$'};
+const schema=(name,description,properties,required,write=false)=>({name,description,input_schema:{type:'object',properties,required,additionalProperties:false},steps:name!=='SourceRead',effects:{workspace:write?'write':'read',external:'none',process:'none',authority:'none'}});
+export const sourceDefinitions=[
+ schema('SourceDraft','Append UTF-8 source data without a work plan. Stable part_id retries reuse identical bytes; host assigns order. First part freezes destination/version; final:true seals it. Does not write the source file or grant publication permission.',{draft_id:id,file_path:{type:'string',minLength:1,maxLength:4096},part_id:id,content:{type:'string',maxLength:64000},final:{type:'boolean'},expected_sha256:version},['draft_id','file_path','part_id','content']),
+ schema('SourceRetain','Reuse your own earlier MODEL_STEP_TOO_LARGE Write/Edit without regenerating its content. call_id identifies the refused tool call. This NEW retention intent inspects/fixes the current destination baseline unless the original supplied expected_sha256; that original is never refreshed. No file is written.',{call_id:{type:'string',minLength:1,maxLength:256}},['call_id']),
+ schema('SourceRead','Read own retained source status, exact publish calls, dated outcomes, or a bounded content page. No ref/draft_id lists the latest 12 own drafts. Retention and successful file effects do not establish functional or human acceptance.',{ref,draft_id:id,offset:{type:'integer',minimum:0},limit:{type:'integer',minimum:1,maximum:12000}},[]),
+ schema('SourcePublish','Publish sealed retained bytes via the ORIGINAL native Write/Edit and frozen expected_sha256 under CURRENT permissions, task/goal and contract. Stable publication_id never repeats a dispatched mutation; uncertain outcomes require inspection. Returns dated native evidence, not task acceptance.',{ref,publication_id:id},['ref','publication_id'],true),
+];
+const fail=(message,code='SOURCE_PROPOSAL_INVALID',details)=>Object.assign(new Error(message),{code,...(details?{details}:{})});
+export class SourceProposals {
+ constructor(workspace){this.workspace=workspace;this.locks=new Map();this.scopes=new Map();}
+ bindScope(sessionId,accept){
+  const binding={accept};this.scopes.set(sessionId,binding);
+  return {active:()=>this.scopes.get(sessionId)===binding,dispose:()=>{if(this.scopes.get(sessionId)===binding)this.scopes.delete(sessionId);}};
+ }
+ async access(data,o,s,binding=this.scopes.get(o.sessionId)){
+  if(this.scopes.get(o.sessionId)!==binding)return false;
+  if(!binding)return true;
+  const accepted=await binding.accept(data,o,s);
+  return accepted&&this.scopes.get(o.sessionId)===binding;
+ }
+ async requireAccess(data,o,s,binding=this.scopes.get(o.sessionId)){if(!await this.access(data,o,s,binding))throw fail('Retained source is outside the active native source scope.','SOURCE_SCOPE_CHANGED');}
+ async settle({invocation_id,receiptRecorded}){const lock=this.locks.get(invocation_id);if(!lock)return;this.locks.delete(invocation_id);if(receiptRecorded)await lock.release();else await lock.file.close();}
+ async session(o){const w=this.workspace;if(!w.store||!w.house.hasRecorder||!o.sessionId)throw fail('Retained source requires this native durable session.');const s=await w.store.load(o.sessionId),a=auditExecution(s,w.house.stateContext());if(!a.journal.consistent||a.violations.length)throw fail('The source journal does not verify.','AUDIT_INVALID');return s;}
+ scope(s){const work=workProjection(s,this.workspace.house.stateContext());return {reset_ref:s.rows.findLastIndex(r=>r.type==='reset'),goal_id:s.goal?.id??null,task_id:work?.current?.id??null,work_digest:work?.current?.work_digest??null};}
+ async lock(key,o){const store=this.workspace.store;await ensurePrivateDirectory(store.dir);const lock=await acquireProcessLock(path.join(store.dir,`.source-${digest([o.sessionId,o.actor,key])}.lock`),{resource:{session_id:o.sessionId,actor:o.actor,invocation_id:o.invocation_id},validate:async owner=>{
+  const s=await this.session(o),resource=owner.resource;
+  if(resource?.session_id!==o.sessionId||digest(resource.actor)!==digest(o.actor)||!s.rows.some(r=>r.type==='house_receipt'&&r.invocation_id===resource.invocation_id))throw fail('The earlier source owner has no settled native outcome. Recover the session before continuing.','SOURCE_PUBLICATION_UNCERTAIN');
+ }}).catch(error=>{if(error.code==='SESSION_IN_USE')throw fail('This source intent is already in progress; it was not replayed.','SOURCE_BUSY');throw error;});this.locks.set(o.invocation_id,lock);}
+ parent(s,o){const p=s.rows.findLast(r=>r.type==='house_proposal'&&r.invocation_id===o.invocation_id);if(!p||p.session_id!==o.sessionId||digest(p.actor)!==digest(o.actor))throw fail('Missing native source invocation identity.');return p;}
+ own(s,o){return this.parent(s,o);}
+ summary(m){return {ref:m.last.ref,draft_id:m.last.draft_id,file_path:m.last.file_path,operation:m.last.data.operation,bytes:m.bytes,content_sha256:m.sha256,expected_sha256:m.last.data.expected_sha256,complete:m.complete,next_index:m.parts.length,part_ids:m.parts.slice(-4).map(p=>p.part_id),scope:m.last.data.scope,...(m.complete?{publish_call:{name:'SourcePublish',input:{ref:m.last.ref,publication_id:'publish-'+m.last.ref.slice(7,23)}}}:{}),authority:'data_only',acceptance:'unjudged'};}
+ material(s,reference,owner){const m=sourceMaterial(s.rows,reference);if(!m||!sourceOwn(m.last,owner))throw fail('No valid retained source belongs to this actor/session/ref.','SOURCE_NOT_FOUND');return m;}
+ async frameState(m,o,binding){
+  if(await this.workspace.resolve(m.last.data.requested_path,{create:true})!==path.resolve(this.workspace.cwd,m.last.file_path))throw fail('The original source alias changed; its replacement was not targeted.','SOURCE_CHANGED');
+  const s=await this.session(o);await this.requireAccess(m.last.data,o,s,binding);
+  if(digest(this.scope(s))!==digest(m.last.data.scope)||s.goal&&['cleared','met','failed','budget'].includes(s.goal.status))throw fail('The original task, goal or reset scope changed. Start an explicit new draft; saved data remains readable.','SOURCE_SCOPE_CHANGED');
+  const op=this.workspace.house.registry.get(m.last.data.operation);if(!this.workspace.isNativeOperation(m.last.data.operation)||sourceContract(op.contract)!==m.last.data.contract)throw fail('The original native writer contract changed; retained data grants no replacement authority.','SOURCE_CONTRACT_CHANGED');
+  return s;
+ }
+ async frame(m,o){const binding=this.scopes.get(o.sessionId);await this.frameState(m,o,binding);await o.revalidate();return this.frameState(m,o,binding);}
+ async readFrame(materials,o,binding){
+  if(this.scopes.get(o.sessionId)!==binding)throw fail('The native source scope binding changed.','SOURCE_SCOPE_CHANGED');
+  if(!binding)return;
+  await o.revalidate();const s=await this.session(o);
+  if(this.scopes.get(o.sessionId)!==binding)throw fail('The native source scope binding changed.','SOURCE_SCOPE_CHANGED');
+  for(const m of materials)await this.requireAccess(m.last.data,o,s,binding);
+ }
+ async baseline(file,expected,o){
+  if(!this.workspace.isNativeOperation('FileInfo'))throw fail('Native bounded FileInfo is required to retain source.','SOURCE_CONTRACT_CHANGED');
+  const input={file_path:file,hash:true,allow_missing:true,max_bytes:1048576};
+  await o.recordWork({type:'source_inspection_intent',source:'source_host',input,input_digest:digest(input)});
+  const callId=randomUUID(),output=await o.invoke('FileInfo',input,{signal:o.signal,callId}),info=JSON.parse(output),s=await this.session(o),r=s.rows.findLast(r=>r.type==='house_receipt'&&r.call_id===callId&&r.operation==='FileInfo'&&r.status==='returned');
+  if(!r||!['file','absent'].includes(info.type))throw fail('A regular UTF-8 destination or absent path is required.');
+  const actual=info.type==='absent'?'absent':info.sha256;return {file_path:info.file_path,inspected_sha256:actual,expected_sha256:expected??actual,inspection_id:r.invocation_id};
+ }
+ async execute(name,input,o){
+  let s=await this.session(o);const owner=this.own(s,o);
+  if(name==='SourceRead'){
+   const binding=this.scopes.get(o.sessionId);
+   const items=s.rows.filter(r=>r.type==='source_part'&&sourceOwn(r,owner));let last=input.ref?items.find(r=>r.ref===input.ref):input.draft_id?items.findLast(r=>r.draft_id===input.draft_id):null;
+   if(!input.ref&&!input.draft_id){const latest=new Map();for(const row of items)latest.set(row.draft_id,row);const materials=[];for(const row of latest.values()){const m=this.material(s,row.ref,owner);if(await this.access(m.last.data,o,s,binding))materials.push(m);}const selected=materials.slice(-12);await this.readFrame(selected,o,binding);return JSON.stringify({drafts:selected.map(m=>this.summary(m)),authority:'data_only'});}
+   if(!last)throw fail('Retained source not found.','SOURCE_NOT_FOUND');const m=this.material(s,last.ref,owner);if(!await this.access(m.last.data,o,s,binding))throw fail('Retained source is outside the active native source scope.','SOURCE_SCOPE_CHANGED');const text=m.last.data.operation==='Write'?m.input.content:m.input.new_string;
+   const publications=s.rows.filter(r=>r.type==='source_publication_intent'&&sourceOwn(r,owner)&&r.ref===last.ref).map(r=>({publication_id:r.publication_id,call_id:r.call_id,attempts:s.rows.filter(p=>p.type==='house_proposal'&&p.call_id===r.call_id).map(p=>{const receipt=s.rows.findLast(e=>e.type==='house_receipt'&&e.invocation_id===p.invocation_id);return{receipt_id:p.invocation_id,status:receipt?.status??'uncertain',code:receipt?.code??null,attribution:receipt?.recovery?'observed_postcondition_not_handler_return':'dated_native_receipt'};})}));
+   await this.readFrame([m],o,binding);return JSON.stringify({...this.summary(m),publications,...(input.offset!==undefined?{offset:input.offset,content:text.slice(input.offset,input.offset+(input.limit??4000)),truncated:input.offset+(input.limit??4000)<text.length}:{}),historical:true});
+  }
+  if(name==='SourcePublish')return this.publish(input,o,s,owner);
+  const original=name==='SourceRetain'?s.rows.filter(p=>p.type==='house_proposal'&&p.call_id===input.call_id&&sourceOwn(p,owner)):null;
+  if(original&&(original.length!==1||!['Write','Edit'].includes(original[0].operation)))throw fail('Identify one exact native refused Write/Edit from your own session.','SOURCE_NOT_FOUND');
+  const old=original?.[0],retained=old&&sourceInput(s.rows,old),ending=old&&s.rows.findLast(r=>r.type==='house_receipt'&&r.invocation_id===old.invocation_id);
+  if(old&&(!retained||ending?.status!=='refused'||ending.code!=='MODEL_STEP_TOO_LARGE'||ending.effects_observed!=='none'))throw fail('The original bytes and noneffect oversize refusal do not verify.','SOURCE_NOT_FOUND');
+  const scope=this.scope(s),draft_id=old?'retained-'+digest([old.invocation_id,scope]).slice(0,32):input.draft_id;
+  await this.requireAccess({requested_path:old?retained.file_path:input.file_path,scope,...(old?{original_invocation:old.invocation_id}:{})},o,s);
+  await this.lock(['draft',draft_id],o);s=await this.session(o);
+  const existing=s.rows.filter(r=>r.type==='source_part'&&sourceOwn(r,owner)&&r.draft_id===draft_id),prior=existing.at(-1),part_id=old?'original':input.part_id,content=old?'':input.content,final=old?true:Boolean(input.final);
+  if(prior){const m=this.material(s,prior.ref,owner),same=existing.find(r=>r.part_id===part_id);await this.frame(m,o);
+   if(same){if(same.content!==content||same.final!==final||!old&&(same.draft_input.file_path!==input.file_path||same.draft_input.expected_sha256!==input.expected_sha256))throw fail('part_id already names different bytes or arguments.','SOURCE_PART_CONFLICT');return JSON.stringify({...this.summary(m),reused:true});}
+   if(m.complete)throw fail('The draft is sealed; use a new draft_id for a new proposal.','SOURCE_SEALED');
+   if(input.file_path!==m.last.data.requested_path||input.expected_sha256!==undefined&&input.expected_sha256!==m.last.data.expected_sha256)throw fail('A source draft cannot retarget or refresh its baseline.','SOURCE_PART_CONFLICT');
+  }
+  const operation=old?.operation??'Write',op=this.workspace.house.registry.get(operation);
+  if(!this.workspace.isNativeOperation(operation))throw fail('The original native writer is unavailable.','SOURCE_CONTRACT_CHANGED');
+  if(old){const c=s.rows.findLast(r=>r.type==='house_contract'&&r.contract_digest===old.contract_digest)?.contract;if(!c||sourceContract(c)!==sourceContract(op.contract))throw fail('The original refused writer contract changed.','SOURCE_CONTRACT_CHANGED');}
+  if(!prior&&s.rows.filter(r=>r.type==='source_part'&&sourceOwn(r,owner)&&r.index===0&&r.data.scope.reset_ref===scope.reset_ref).length>=32)throw fail('This reset scope already retains 32 source proposals.','SOURCE_LIMIT');
+  const snapshot=prior?.data??await this.baseline(old?retained.file_path:input.file_path,old?retained.expected_sha256:input.expected_sha256,o);
+  const data=prior?.data??{version:1,...snapshot,operation,requested_path:old?retained.file_path:input.file_path,scope,contract:sourceContract(op.contract),...(old?{original_invocation:old.invocation_id}:{})};
+  if(Buffer.byteLength(content)>64000&&!old||existing.length>=128||existing.reduce((n,r)=>n+Buffer.byteLength(r.content),0)+Buffer.byteLength(old?JSON.stringify(retained):content)>1048576)throw fail('Retained source exceeds its 64 KB part, 128 part or 1 MiB proposal bound.','SOURCE_LIMIT');
+  const parts=[...existing.map(r=>({part_id:r.part_id,content:r.content,final:r.final,...(r.retained_input?{retained_input:r.retained_input}:{})})),{part_id,content,final,...(old?{retained_input:retained}:{})}],reference='source:'+digest({data,parts});
+  await o.revalidate();const current=await this.session(o);await this.requireAccess(data,o,current);if(digest(this.scope(current))!==digest(scope))throw fail('Source scope changed during inspection.','SOURCE_SCOPE_CHANGED');
+  await o.recordWork({type:'source_part',source:'source_host',draft_id,part_id,index:existing.length,file_path:data.file_path,content,final,data,data_digest:digest(data),ref:reference,...(old?{retained_input:retained}:{draft_input:input})});
+  s=await this.session(o);return JSON.stringify(this.summary(this.material(s,reference,owner)));
+ }
+ async publish(input,o,s,owner){
+  const m=this.material(s,input.ref,owner);if(!m.complete)throw fail('The source draft is not final.','SOURCE_INCOMPLETE');
+  await this.lock(['publication',input.publication_id],o);s=await this.frame(m,o);
+  let intent=s.rows.find(r=>r.type==='source_publication_intent'&&sourceOwn(r,owner)&&r.publication_id===input.publication_id);
+  if(intent&&intent.ref!==input.ref)throw fail('publication_id already names another immutable source proposal.','SOURCE_PUBLICATION_CONFLICT');
+  if(!intent){intent={type:'source_publication_intent',source:'source_host',intent_id:randomUUID(),publication_id:input.publication_id,ref:input.ref,operation:m.last.data.operation,arguments_digest:digest(m.input),call_id:randomUUID()};await o.recordWork(intent);}
+  s=await this.session(o);const attempts=s.rows.filter(r=>r.type==='house_proposal'&&r.call_id===intent.call_id);
+  if(attempts.length){const p=attempts[0],r=s.rows.findLast(r=>r.type==='house_receipt'&&r.invocation_id===p.invocation_id);
+   if(attempts.length!==1||!r||!sourcePublicationLeafValid(s.rows,p)||r.arguments_digest!==p.arguments_digest||!sourceOwn(r,p)||r.status==='returned'&&(r.output_truncated||r.output_digest!==digest(r.output)))throw fail('A native publication was dispatched without a settled outcome. Recover/inspect it; no mutation was replayed.','SOURCE_PUBLICATION_UNCERTAIN');
+   if(r.status!=='returned')throw fail('This publication has a recorded refusal/failure. Inspect it and use a NEW publication_id for new corrective intent; the frozen baseline remains.','SOURCE_PUBLICATION_CLOSED',{receipt_id:r.invocation_id,code:r.code??null});
+   return JSON.stringify({ref:input.ref,publication_id:input.publication_id,receipt_id:r.invocation_id,reused:true,output:r.output,scope:'dated_native_source_outcome_not_current_file_or_acceptance',acceptance:'unjudged'});
+  }
+  await o.recordWork({type:'source_dispatch',source:'source_host',intent_id:intent.intent_id,call_id:intent.call_id});
+  const output=await o.invoke(intent.operation,m.input,{signal:o.signal,callId:intent.call_id,beforeEffect:()=>this.frame(m,o)});
+  s=await this.session(o);const receipt=s.rows.findLast(r=>r.type==='house_receipt'&&r.call_id===intent.call_id&&r.status==='returned');if(!receipt)throw fail('The native source outcome was not recorded.','SOURCE_PUBLICATION_UNCERTAIN');
+  return JSON.stringify({ref:input.ref,publication_id:input.publication_id,receipt_id:receipt.invocation_id,output,reused:false,scope:'dated_native_source_outcome_not_current_file_or_acceptance',acceptance:'unjudged'});
+ }
+}

package/src/source-requests.mjs

@@ -0,0 +1,148 @@
+// Experimental native source-data admission. No public ports or permission grants.
+import path from 'node:path';
+import { lstat, realpath } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+import { digest } from './operations.mjs';
+import { auditExecution } from './audit.mjs';
+import { sourceInput, sourceOwn, sourceContract } from './source-proposal-proof.mjs';
+import { workProjection } from './work-plan.mjs';
+
+const managers = new WeakMap(), tokens = new WeakMap();
+export const SOURCE_REQUEST_LIMITS = Object.freeze({ version: 1, max_bytes: 1048576, max_path: 4096, max_call_id: 256, max_active: 8, max_ancestors: 128 });
+const fail = (message, code = 'SOURCE_REQUEST_INVALID') => Object.assign(new Error(message), { code });
+const scope = (book, context) => {
+  const work = workProjection(book, context);
+  return { reset_ref: book.rows.findLastIndex(row => row.type === 'reset'), goal_id: book.goal?.id ?? null, goal_status: book.goal?.status ?? null,
+    task_id: work?.current?.id ?? null, work_digest: work?.current?.work_digest ?? null, task_status: work?.current?.status ?? null,
+    chrome_task: book.rows.findLast(row => row.type === 'chrome_task_accepted' && row.source === 'workflow_host')?.task_digest ?? null,
+    source_task: book.rows.findLast(row => row.type === 'source_task_accepted' && row.source === 'source_task_host')?.task_digest ?? null };
+};
+const terminalGoal = book => book.goal && ['cleared', 'met', 'failed', 'budget'].includes(book.goal.status);
+const nativeWriter = (contract, name) => contract?.name === name && contract.origin === null && contract.permission === name && !contract.steps && contract.effects?.workspace === 'write' && ['external', 'process', 'authority'].every(key => contract.effects?.[key] === 'none');
+const same = (a, b) => digest(a) === digest(b);
+
+function inspection(book, audit, owner, file, isNative, registry) {
+  const tip = audit.state.find(item => item.path === file);
+  if (!tip || tip.operation_status !== 'returned') return null;
+  const row = audit.receipts.findLast(row => sourceOwn(row, owner) && row.status === 'returned' && !row.output_truncated && ['Read', 'Write', 'Edit'].includes(row.operation) &&
+    !audit.unverified.some(item => item.invocation_id === row.invocation_id) && isNative(row.operation) &&
+    row.observations?.some(item => item.file_path === file && (item.kind === 'file_read' && row.operation === 'Read' && item.sha256 === tip.sha256 || item.kind === 'file_write' && row.operation !== 'Read' && item.matches_requested === true && item.after_sha256 === tip.sha256)));
+  if (!row) return null;
+  const contract = book.rows.findLast(item => item.type === 'house_contract' && item.contract_digest === row.contract_digest)?.contract;
+  if (!contract || contract.origin !== null || contract.permission !== row.operation || contract.steps || sourceContract(contract) !== sourceContract(registry.get(row.operation).contract)) return null;
+  return { receipt_id: row.invocation_id, receipt_row: book.rows.findIndex(item => item.type === 'house_receipt' && item.invocation_id === row.invocation_id), operation: row.operation,
+    file_path: file, sha256: tip.sha256, contract_digest: row.contract_digest, arguments_digest: row.arguments_digest, output_digest: row.output_digest };
+}
+
+async function canonical(workspace, requested, name) {
+  // Metadata only: no content read, absence claim, Read cache or FileInfo bypass.
+  let candidate = path.resolve(workspace.cwd, requested), depth = 0;
+  if (!workspace.inside(candidate)) throw fail('Source request is outside the workspace.', 'SOURCE_REQUEST_PATH');
+  for (let part = candidate; part !== workspace.cwd; part = path.dirname(part)) {
+    if (++depth > SOURCE_REQUEST_LIMITS.max_ancestors) throw fail('Source request path exceeds its metadata bound.', 'SOURCE_REQUEST_PATH');
+    try { if ((await lstat(part)).isSymbolicLink()) await realpath(part); }
+    catch (error) { if (error.code !== 'ENOENT') throw error; try { if ((await lstat(part)).isSymbolicLink()) throw fail('A dangling source alias is not a create target.', 'SOURCE_REQUEST_PATH'); } catch (again) { if (again.code !== 'ENOENT') throw again; } }
+  }
+  return workspace.resolve(requested, { create: name === 'Write' });
+}
+
+// Called only by WorkspaceTools construction; this is an in-process host boundary,
+// not an OS sandbox against arbitrary trusted Node code importing host modules.
+export function registerNativeSourceRequests(workspace, { enabled = false, isNative }) {
+  const active = new Map();
+  managers.set(workspace, { workspace, enabled: enabled === true, isNative, active });
+}
+export function nativeSourceRequestStatus(workspace) {
+  const manager = managers.get(workspace);
+  return { enabled: Boolean(manager?.enabled), active: manager?.active.size ?? 0, max_active: SOURCE_REQUEST_LIMITS.max_active };
+}
+export function nativeSourceRequestCapability(workspace, name, catalogue) {
+  const manager = managers.get(workspace), op = workspace.house.registry.get(name);
+  if (!manager?.enabled || typeof workspace.store?.load !== 'function' || typeof workspace.store?.file !== 'function' || !workspace.house.hasRecorder || !workspace.executor?.identity().session_id || !manager.isNative(name) || !nativeWriter(op?.contract, name) || catalogue && !catalogue.some(item => item.name === name && item.contract_digest === op.digest)) return null;
+  return Object.freeze({ protocol: 'comal-native-source-request/1', max_bytes: SOURCE_REQUEST_LIMITS.max_bytes, byte_basis: 'UTF-8 JSON arguments', max_path_utf16: SOURCE_REQUEST_LIMITS.max_path, max_active: SOURCE_REQUEST_LIMITS.max_active });
+}
+export function prepareNativeSourceRequest(workspace, frame) {
+  const manager = managers.get(workspace);
+  if (!manager?.enabled) return;
+  return prepare(manager, frame);
+}
+async function prepare(manager, frame) {
+  const { workspace: w, isNative, active } = manager, { house, context, op, input, proposal, signal, recordWork } = frame;
+  if (w.house !== house || !isNative(proposal.operation) || house.registry.get(proposal.operation) !== op || !nativeWriter(op.contract, proposal.operation)) return;
+  if (!w.store || !house.hasRecorder || !context.sessionId || typeof proposal.call_id !== 'string' || !proposal.call_id.length || proposal.call_id.length > SOURCE_REQUEST_LIMITS.max_call_id || typeof input.file_path !== 'string' || input.file_path.length > SOURCE_REQUEST_LIMITS.max_path || Buffer.byteLength(JSON.stringify(input)) > SOURCE_REQUEST_LIMITS.max_bytes) return;
+  if (active.size >= SOURCE_REQUEST_LIMITS.max_active) throw fail('Too many native source requests are active.', 'SOURCE_REQUEST_LIMIT');
+  const authority = house.authority(context);
+  const load = async () => {
+    signal?.throwIfAborted(); const book = await w.store.load(context.sessionId), audit = auditExecution(book, house.stateContext());
+    if (book.id !== context.sessionId || book.cwd !== w.cwd || !audit.journal.consistent || audit.violations.length || audit.unresolved.length) throw fail('The original source-request book is unavailable.', 'AUDIT_INVALID');
+    return { book, audit };
+  };
+  const { book, audit } = await load(), originals = book.rows.filter(row => row.type === 'house_proposal' && row.call_id === proposal.call_id && sourceOwn(row, { ...context, session_id: context.sessionId, house: w.cwd }));
+  if (originals.length !== 1 || originals[0].invocation_id !== proposal.invocation_id || book.rows.some(row => row.type === 'source_request_prepared' && row.call_id === proposal.call_id && sourceOwn(row, originals[0]))) throw fail('This original source call already has an invocation; it cannot replay.', 'SOURCE_REQUEST_REPLAY');
+  const original = originals[0], retained = sourceInput(book.rows, original);
+  if (!retained || !same(retained, input) || original.contract_digest !== op.digest || original.operation !== proposal.operation || !same(original.actor, context.actor) || original.surface !== context.surface) return;
+  const inputReference = book.rows.flatMap((row, rowIndex) => row.type === 'message' && row.message?.role === 'assistant' && Array.isArray(row.message.content) ? row.message.content.flatMap((block, blockIndex) => block.type === 'tool_use' && block.id === proposal.call_id && block.name === proposal.operation && same(block.input, input) ? [{ row: rowIndex, block: blockIndex }] : []) : []);
+  if (inputReference.length !== 1 || inputReference[0].row >= book.rows.indexOf(original) || terminalGoal(book)) return;
+  const file = await canonical(w, input.file_path, proposal.operation), relative = path.relative(w.cwd, file);
+  const proof = inspection(book, audit, original, relative, isNative, house.registry);
+  if (proposal.operation === 'Edit' && !proof) return;
+  const expected = input.expected_sha256 ?? proof?.sha256 ?? 'absent';
+  const data = { format: 'comal-native-source-request/1', request_id: randomUUID(), call_id: proposal.call_id, operation: proposal.operation,
+    arguments_digest: proposal.arguments_digest, contract_digest: op.digest, input_ref: inputReference[0], input_bytes: Buffer.byteLength(JSON.stringify(input)),
+    requested_path: input.file_path, canonical_path: relative, expected_sha256: expected,
+    baseline_basis: input.expected_sha256 !== undefined ? 'explicit_precondition' : proof ? 'own_dated_native_content_proof' : 'create_only_intent_not_observed_absence',
+    inspection: proof, scope: w.sourceProposals.scope(book), request_scope: scope(book, house.stateContext()), authority_stamp: authority, limits: SOURCE_REQUEST_LIMITS };
+  const binding = w.sourceProposals.scopes.get(context.sessionId);
+  await w.sourceProposals.requireAccess(data, { ...context, invocation_id: proposal.invocation_id, signal }, book, binding);
+  if (active.size >= SOURCE_REQUEST_LIMITS.max_active) throw fail('Too many native source requests are active.', 'SOURCE_REQUEST_LIMIT');
+  const token = Object.freeze({}), entry = { manager, frame, data, digest: digest(data), file, authority, scope: data.request_scope, binding, token, consumed: false, retired: false };
+  active.set(proposal.invocation_id, entry); tokens.set(token, entry);
+  await recordWork({ type: 'source_request_prepared', source: 'workspace_host', call_id: proposal.call_id, request: data, request_digest: entry.digest });
+  await verify(entry, false);
+  return token;
+}
+async function verify(entry, requireActive = true) {
+  const { manager, frame, data, file } = entry, { workspace: w, isNative } = manager, { house, context, op, input, proposal, signal } = frame;
+  signal?.throwIfAborted();
+  if (entry.retired || manager.active.get(proposal.invocation_id) !== entry || !isNative(proposal.operation) || house.registry.get(proposal.operation) !== op || house.authority(context) !== entry.authority || requireActive && !house.stateContext().active.has(proposal.invocation_id)) throw fail('The original source request or authority changed.', 'HOUSE_AUTHORITY_CHANGED');
+  if (await canonical(w, input.file_path, proposal.operation) !== file) throw fail('The source-request alias changed; no replacement target was adopted.', 'SOURCE_CHANGED');
+  const book = await w.store.load(context.sessionId), audit = auditExecution(book, house.stateContext());
+  if (book.id !== context.sessionId || book.cwd !== w.cwd || !audit.journal.consistent || audit.violations.length || audit.unresolved.length) throw fail('The native source request no longer verifies.', 'AUDIT_INVALID');
+  durable(book, entry);
+  if (!same(scope(book, house.stateContext()), entry.scope) || terminalGoal(book)) throw fail('The original source-request task, goal or reset scope changed.', 'SOURCE_SCOPE_CHANGED');
+  if (w.sourceProposals.scopes.get(context.sessionId) !== entry.binding) throw fail('The original native source binding changed.', 'SOURCE_SCOPE_CHANGED');
+  await w.sourceProposals.requireAccess(data, { ...context, invocation_id: proposal.invocation_id, signal }, book, entry.binding);
+  // The host scope callback may itself await or append. Its old book cannot
+  // certify the task/goal/reset after that boundary.
+  const latest = await w.store.load(context.sessionId), finalAudit = auditExecution(latest, house.stateContext());
+  if (latest.id !== context.sessionId || latest.cwd !== w.cwd || !finalAudit.journal.consistent || finalAudit.violations.length || finalAudit.unresolved.length) throw fail('The current source-request journal does not verify.', 'AUDIT_INVALID');
+  durable(latest, entry);
+  if (!same(scope(latest, house.stateContext()), entry.scope) || terminalGoal(latest) || w.sourceProposals.scopes.get(context.sessionId) !== entry.binding) throw fail('The original source-request scope changed during validation.', 'SOURCE_SCOPE_CHANGED');
+  if (await canonical(w, input.file_path, proposal.operation) !== file) throw fail('The source-request alias changed during validation.', 'SOURCE_CHANGED');
+  signal?.throwIfAborted();
+  if (house.authority(context) !== entry.authority || entry.retired || house.registry.get(proposal.operation) !== op) throw fail('The original source request changed during validation.', 'HOUSE_AUTHORITY_CHANGED');
+}
+function durable(book, entry) {
+  const { frame: { context, proposal, input }, manager: { workspace: w }, data } = entry;
+  const records = book.rows.filter(row => row.type === 'source_request_prepared' && row.invocation_id === proposal.invocation_id);
+  const originals = book.rows.filter(row => row.type === 'house_proposal' && row.invocation_id === proposal.invocation_id);
+  const original = originals[0], block = book.rows[data.input_ref.row]?.message?.content?.[data.input_ref.block];
+  if (records.length !== 1 || records[0].request_digest !== entry.digest || !same(records[0].request, data) || !sourceOwn(records[0], { ...context, session_id: context.sessionId, house: w.cwd }) || originals.length !== 1 || original.arguments_digest !== data.arguments_digest || original.contract_digest !== data.contract_digest || original.operation !== data.operation || original.call_id !== data.call_id || !sourceOwn(original, records[0]) || !same(sourceInput(book.rows, original), input) || block?.id !== data.call_id || block?.name !== data.operation || !same(block.input, input)) throw fail('The durable original source request changed.');
+  if (data.inspection) {
+    const proof = data.inspection, row = book.rows[proof.receipt_row];
+    if (row?.type !== 'house_receipt' || row.invocation_id !== proof.receipt_id || row.status !== 'returned' || row.operation !== proof.operation || row.contract_digest !== proof.contract_digest || row.arguments_digest !== proof.arguments_digest || row.output_digest !== proof.output_digest || !sourceOwn(row, original)) throw fail('The original source inspection changed.');
+  }
+}
+export function consumeNativeSourceRequest(workspace, token, { operation, input, invocation_id, actor, sessionId }) {
+  if (token === undefined) return null;
+  const entry = tokens.get(token), frame = entry?.frame;
+  if (!entry || entry.retired || entry.consumed || entry.manager.workspace !== workspace || frame.proposal.operation !== operation || frame.proposal.invocation_id !== invocation_id || frame.context.sessionId !== sessionId || !same(frame.context.actor, actor) || !same(frame.input, input) || !workspace.house.stateContext().active.has(invocation_id)) throw fail('No genuine active native source request belongs to this writer.');
+  entry.consumed = true;
+  return { expected_sha256: entry.data.expected_sha256, file: entry.file, request_digest: entry.digest, request_id: entry.data.request_id,
+    async validate(beforeHash) { await verify(entry); if (beforeHash !== undefined && entry.data.expected_sha256 !== (beforeHash ?? 'absent')) throw fail('The original source-request version changed; it was not refreshed.', 'SOURCE_CHANGED'); if (beforeHash !== undefined && beforeHash !== null && !entry.data.inspection) throw fail('The original source request has no durable own inspected-content proof.', 'SOURCE_REQUEST_INSPECTION'); },
+    revalidate: () => verify(entry) };
+}
+export function settleNativeSourceRequest(workspace, { invocation_id }) {
+  const manager = managers.get(workspace), entry = manager?.active.get(invocation_id);
+  if (entry) { entry.retired = true; manager.active.delete(invocation_id); tokens.delete(entry.token); }
+}

package/src/source-task-proof.mjs

@@ -0,0 +1,24 @@
+import {digest} from './operations.mjs';
+import {sourceTaskRevisions} from './source-task-revision-proof.mjs';
+export const SOURCE_TASK_MECHANISM='comal-source-task-v1';
+export const SOURCE_TASK_MECHANISM_V2='comal-source-task-v2';
+const own=(a,b)=>['house','session_id','actor','surface'].every(k=>digest(a[k]??null)===digest(b[k]??null));
+export const savedSourceTask=book=>book.rows.slice(book.rows.findLastIndex(r=>r.type==='reset')+1).findLast(r=>r.type==='source_task_accepted'&&r.source==='source_task_host');
+export function sourceTaskFactValid(row){return row?.type==='source_task_accepted'&&row.source==='source_task_host'&&[SOURCE_TASK_MECHANISM,SOURCE_TASK_MECHANISM_V2].includes(row.mechanism)&&row.task_digest===digest(row.task)&&row.binding_digest===digest(row.binding)&&row.binding?.session_id===row.session_id&&row.binding?.cwd===row.house&&digest(row.binding?.actor)===digest(row.actor);}
+export function nativeSourceTask(rows,p){const c=rows.findLast(r=>r.type==='house_contract'&&r.contract_digest===p?.contract_digest)?.contract;if(!c||c.origin!==null||c.name!==p.operation||c.permission!==(p.operation==='SourceEvidence'?'GitIntegrationEvidence':p.operation==='SourceStatus'||p.operation==='SourceVerify'?'GitIntegrationStatus':p.operation))return false;if(['SourceDeliver','SourceRevise','SourceStatus','SourceVerify','SourceEvidence'].includes(p.operation))return [SOURCE_TASK_MECHANISM,SOURCE_TASK_MECHANISM_V2].includes(c.revision)&&(p.operation!=='SourceRevise'||c.revision===SOURCE_TASK_MECHANISM_V2)&&c.steps===['SourceDeliver','SourceRevise'].includes(p.operation);
+ if(p.operation!=='WorkTaskUpdate')return false;const parent=rows.find(r=>r.type==='house_proposal'&&r.invocation_id===p.parent_invocation_id);return ['SourceDeliver','SourceRevise'].includes(parent?.operation)&&own(parent,p)&&nativeSourceTask(rows,parent);
+}
+export function sourceTaskRecoveryPlan(rows,p){
+ if(!nativeSourceTask(rows,p))return null;
+ const call=rows.find(r=>r.type==='source_task_call_prepared'&&r.source==='source_task_host'&&r.invocation_id===p.invocation_id&&r.operation===p.operation&&r.arguments_digest===p.arguments_digest&&own(r,p));
+ const close=p.operation==='WorkTaskUpdate',read=['SourceStatus','SourceVerify','SourceEvidence'].includes(p.operation),proposalIndex=rows.findIndex(r=>r.type==='house_proposal'&&r.invocation_id===p.invocation_id),accepted=rows.slice(0,proposalIndex).findLast(r=>r.type==='source_task_accepted'&&sourceTaskFactValid(r)&&own(r,p)&&(!call||r.task_digest===call.task_digest));if(!accepted)return null;
+ const root=close?rows.find(r=>r.type==='house_proposal'&&r.invocation_id===p.parent_invocation_id):p,contract=rows.findLast(r=>r.type==='house_contract'&&r.contract_digest===root.contract_digest)?.contract;if(accepted.mechanism!==contract?.revision)return null;
+ if(accepted.mechanism===SOURCE_TASK_MECHANISM_V2){try{sourceTaskRevisions(rows,accepted);}catch{return null;}}
+ const children=rows.filter(r=>r.type==='house_proposal'&&r.parent_invocation_id===p.invocation_id);
+ if(!call&&!close&&children.length)return null;
+ if(children.some(c=>!own(c,p)||!rows.some(r=>r.type==='house_receipt'&&r.invocation_id===c.invocation_id)))return null;
+ if(close){const prepared=rows.find(r=>r.type==='work_call_prepared'&&r.operation==='WorkTaskUpdate'&&r.invocation_id===p.invocation_id&&digest(r.input)===p.arguments_digest);if(!prepared||digest(prepared.input)!==digest({task_id:'source-task',plan_version:1,status:'done'}))return null;}
+ if(read&&children.length)return null;
+ return{kind:read?'source_task_read':'source_task_recorded',code:read?'HOUSE_RECOVERY_READ_RETRY':'HOUSE_RECOVERY_SOURCE_TASK',error:read?'Native source-task observation was interrupted. It may be repeated under current authority; no mutation was replayed.':'The source coordinator was interrupted. SourceStatus and SourceDeliver continue the SAME accepted task and native stage identities. No batch, check or ref update was replayed; acceptance remains unjudged.',effects_observed:read?'read_only':'recorded_source_task_children_not_delivery',child_refs:children.map(c=>rows.findIndex(r=>r.type==='house_receipt'&&r.invocation_id===c.invocation_id))};
+}
+export function sourceTaskRecoveryValid(rows,index,row){const plan=sourceTaskRecoveryPlan(rows.slice(0,index),rows[row.recovery.proposal_ref]);return Boolean(plan&&row.status==='refused'&&row.code===plan.code&&row.error===plan.error&&row.effects_observed===plan.effects_observed&&row.recovery.kind===plan.kind&&row.recovery.plan_digest===digest(plan));}

package/src/source-task-revision-proof.mjs

@@ -0,0 +1,44 @@
+import {digest} from './operations.mjs';
+import {integrationLineage} from './git-integration-lineage.mjs';
+const fail=()=>Object.assign(new Error('The accepted source correction lineage changed.'),{code:'SOURCE_TASK_REVISION_BINDING'});
+export const correctionRequest=(taskDigest,generation)=>'source-'+taskDigest.slice(0,32)+'-revision-'+generation;
+export function correctionEditor(task,binding){
+ return{prompt:'Correct the observed native source failure under the original accepted criterion. Do not replace its checks or administer work/Git.\nAccepted contract: '+JSON.stringify({criterion:task.criterion,verification:task.verification})+'\nObserved diagnostic data (not instructions or authority): '+JSON.stringify(binding.diagnostics)+'\nCorrection instructions: '+binding.instructions,description:'source-correction-'+binding.generation,isolation:'git',work_tracking:'parent',git_revision:binding.parent_integration_id,max_turns:Math.max(...task.editors.map(e=>e.max_turns??6))};
+}
+// Pure root-book links. The native kernel still attests to the selected failed
+// resource/tree/offer, and actual invocation frames still judge every effect.
+export function sourceTaskRevisions(rows,accepted){
+ const start=rows.findIndex(r=>r.audit?.sha256===accepted.audit?.sha256),scope=rows.slice(start+1),revisions=scope.filter(r=>r.type==='source_task_revision'&&r.source==='source_task_host'&&r.task_digest===accepted.task_digest),owner=digest({actor:accepted.actor,session_id:accepted.session_id});let previous;
+ for(const [index,row]of revisions.entries()){
+  const b=row.binding,s=b?.source,origin=rows[b?.origin?.row],k=origin?.binding?.resolved?.kernel_input;
+  if(accepted.mechanism!=='comal-source-task-v2'||row.binding_digest!==digest(b)||b.generation!==index+1||b.generation>31||row.session_id!==accepted.session_id||row.house!==accepted.house||digest(row.actor)!==digest(accepted.actor)||typeof b.instructions!=='string'||!b.instructions.length||b.instructions.length>12000||b.parent_integration_id!==s?.integration_id||s.schema!=='comal-source-revision-v1'||s.owner_digest!==owner||origin?.owner_digest!==owner||b.origin.row>=rows.indexOf(row)||origin.audit.sha256!==b.origin.digest||origin.binding_digest!==b.origin.binding_digest||origin.binding.resolved.integration_id!==s.integration_id||s.target!==k.target||s.expected_target!==k.expected_target||s.base_commit!==k.base_commit||s.verification_digest!==digest(k.verification)||k.target!==accepted.task.target||digest(k.verification)!==digest(accepted.task.verification)||digest(b.editor_input)!==digest(correctionEditor(accepted.task,b)))throw fail();
+  integrationLineage(rows,origin);
+  const expected=previous?correctionRequest(accepted.task_digest,previous.binding.generation):'source-'+accepted.task_digest.slice(0,40);if(origin.input.request_id!==expected)throw fail();
+  const executions=scope.filter(r=>r.type==='source_task_execution_bound'&&r.source==='source_task_host'&&r.task_digest===accepted.task_digest);if(executions.length!==1||b.goal_owner!==executions[0].goal_owner)throw fail();previous=row;
+ }
+ for(const used of scope.filter(r=>r.type==='source_task_revision_used'&&r.source==='source_task_host'&&r.task_digest===accepted.task_digest)){
+  const revision=revisions.find(r=>r.binding.generation===used.generation),proposal=rows.find(r=>r.type==='house_proposal'&&r.invocation_id===used.invocation_id),contract=proposal&&rows.findLast(r=>r.type==='house_contract'&&r.contract_digest===proposal.contract_digest)?.contract;
+  if(!revision||used.revision_digest!==revision.audit.sha256||rows.indexOf(revision)>=rows.indexOf(used)||used.session_id!==accepted.session_id||used.house!==accepted.house||digest(used.actor)!==digest(accepted.actor)||!['SourceDeliver','SourceRevise'].includes(proposal?.operation)||contract?.origin!==null||contract.revision!==accepted.mechanism)throw fail();
+ }
+ return revisions;
+}
+
+export function auditSourceTaskRevisions(rows){
+ const violations=[];
+ for(let i=0;i<rows.length;i++){const accepted=rows[i];if(accepted.type!=='source_task_accepted'||accepted.source!=='source_task_host'||accepted.mechanism!=='comal-source-task-v2')continue;let end=rows.findIndex((r,n)=>n>i&&(r.type==='reset'||r.type==='source_task_accepted'&&r.source==='source_task_host'));if(end<0)end=rows.length;try{sourceTaskRevisions(rows.slice(0,end),accepted);}catch{violations.push({invocation_id:accepted.invocation_id,operation:'SourceRevise',reason:'source_task_revision_binding_invalid'});}}
+ for(let index=0;index<rows.length;index++){
+  const receipt=rows[index];if(receipt.type!=='house_receipt'||receipt.status!=='returned'||!['SourceDeliver','SourceRevise'].includes(receipt.operation))continue;
+  const prefix=rows.slice(0,index),contract=prefix.findLast(r=>r.type==='house_contract'&&r.contract_digest===receipt.contract_digest)?.contract;if(contract?.origin!==null||contract.revision!=='comal-source-task-v2')continue;
+  const fault=reason=>violations.push({invocation_id:receipt.invocation_id,operation:receipt.operation,reason});
+  try{
+   const accepted=prefix.findLast(r=>r.type==='source_task_accepted'&&r.source==='source_task_host'&&r.session_id===receipt.session_id),revisions=sourceTaskRevisions(prefix,accepted),requests=new Set(['source-'+accepted.task_digest.slice(0,40),...revisions.map(r=>correctionRequest(accepted.task_digest,r.binding.generation))]),original=prefix.findLast(r=>r.type==='git_integration_intent'&&r.operation==='GitIntegrationPrepare'&&requests.has(r.input.request_id)&&r.owner_digest===digest({actor:receipt.actor,session_id:receipt.session_id}));if(!original)continue;
+   const chain=integrationLineage(prefix,original),goal=prefix.findLast(r=>r.type==='goal')?.goal,owner=goal?.status==='active'?goal.id:null,decisions=prefix.filter(r=>r.type==='house_effect_constraint'&&r.source==='scope_host'&&r.invocation_id===receipt.invocation_id&&r.operation===receipt.operation&&r.arguments_digest===receipt.arguments_digest&&r.session_id===receipt.session_id&&r.house===receipt.house&&digest(r.actor)===digest(receipt.actor));
+   for(const intent of chain){
+    if(intent.binding.authority.denied.includes(receipt.operation))fault('source_task_original_controller_permission_refused');if(intent.binding.goal_owner!==owner)fault('source_task_original_controller_goal_changed');
+    const c=intent.binding.ceiling,expected=[...c.guards.map(identity=>({kind:'guard',identity})),...c.laws.flatMap(law=>law.plan.gates.filter(g=>g.tier==='enforced'&&(g.operations.includes('*')||g.operations.includes(receipt.operation))).map(g=>({kind:'law',identity:{house:law.house,session_id:law.session_id,activation_id:law.activation_id,plan_hash:law.plan.plan_hash,mechanism_stamp:law.mechanism_stamp,gate_id:g.id}})))];
+    for(const constraint of expected)if(!decisions.some(r=>r.ceiling_digest===c.digest&&r.kind===constraint.kind&&digest(r.identity)===digest(constraint.identity)&&r.allowed===true))fault('source_task_original_controller_constraint_missing');if(decisions.some(r=>r.ceiling_digest===c.digest&&r.allowed===false))fault('source_task_original_controller_constraint_refused');
+   }
+  }catch{fault('source_task_controller_binding_invalid');}
+ }
+ return{scope:'recorded_correction_lineage_and_controller_constraints_not_live_verification',violations};
+}