deadbyte-mcp 0.13.0 → 0.14.0

package/scripts/verify-r42-parent.mjs

@@ -0,0 +1,101 @@
+import { createHash, createPublicKey, verify as cryptoVerify } from 'node:crypto';
+import { lstat, readFile, readdir } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { canonicalJson } from '../src/canonical-json.mjs';
+
+const root=path.resolve(path.dirname(fileURLToPath(import.meta.url)),'..');
+const stateRoot=path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp'));
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const sha1=bytes=>createHash('sha1').update(bytes).digest('hex');
+const insist=(ok,message)=>{if(!ok)throw new Error(message);};
+const CLOSURE_DOMAIN=Buffer.from('DEADBYTE-R41-FINAL-CLOSURE-V1\0','utf8');
+
+function parseManifest(bytes,label){
+  const entries=new Map();
+  for(const [index,line] of bytes.toString('utf8').split(/\r?\n/).entries()){
+    if(!line)continue;
+    const match=/^([0-9a-f]{64})  ([^\0]+)$/.exec(line);insist(match,`${label} line ${index+1} malformed`);
+    const rel=match[2];
+    insist(!path.posix.isAbsolute(rel)&&!rel.split('/').includes('..')&&!entries.has(rel),`unsafe/duplicate ${label} path ${rel}`);
+    entries.set(rel,match[1]);
+  }
+  return entries;
+}
+async function walk(dir,rel=''){
+  const out=[];
+  for(const name of (await readdir(path.join(dir,...(rel?rel.split('/'):[])))).sort((a,b)=>a.localeCompare(b,'en'))){
+    const child=rel?`${rel}/${name}`:name;
+    const full=path.join(dir,...child.split('/'));
+    const st=await lstat(full);
+    insist(!st.isSymbolicLink(),`parent tree symlink forbidden: ${child}`);
+    if(st.isDirectory())out.push(...await walk(dir,child));
+    else{insist(st.isFile(),`parent tree non-file forbidden: ${child}`);out.push(child);}
+  }
+  return out;
+}
+async function verifyTree(dir,manifestName,expectedManifest,{exact}){
+  const bytes=await readFile(path.join(dir,manifestName));
+  insist(sha256(bytes)===expectedManifest,`${manifestName} digest mismatch: ${dir}`);
+  const entries=parseManifest(bytes,manifestName);
+  if(exact){
+    const actual=(await walk(dir)).filter(rel=>rel!==manifestName);
+    insist(actual.length===entries.size&&actual.every(rel=>entries.has(rel)),`${manifestName} exact tree mismatch: ${dir}`);
+  }
+  for(const [rel,digest] of entries){
+    insist(sha256(await readFile(path.join(dir,...rel.split('/'))))===digest,`${manifestName} file hash mismatch: ${dir} :: ${rel}`);
+  }
+  return entries.size;
+}
+function verifySignedClosure(envelope,record,publicPem){
+  insist(envelope?.body?.schema==='deadbyte.r41-final-closure.v1','R41 parent closure schema mismatch');
+  insist(envelope.body.version==='0.13.0','R41 parent closure version mismatch');
+  const pointer=envelope.body.active_pointer;
+  insist(pointer?.release_id===record.parent_release_id&&pointer?.manifest_sha256===record.parent_manifest_sha256,'R41 parent closure release identity mismatch');
+  insist(pointer?.generation_manifest_sha256===record.parent_generation_manifest_sha256,'R41 parent closure generation identity mismatch');
+  const bodyBytes=Buffer.from(canonicalJson(envelope.body),'utf8');
+  insist(sha256(bodyBytes)===envelope.body_sha256,'R41 parent closure body hash mismatch');
+  const {closure_sha256,...unsigned}=envelope;
+  insist(sha256(Buffer.from(canonicalJson(unsigned),'utf8'))===closure_sha256,'R41 parent closure envelope hash mismatch');
+  const key=createPublicKey(publicPem);insist(key.asymmetricKeyType==='ed25519','R41 parent closure key must be Ed25519');
+  const der=Buffer.from(key.export({type:'spki',format:'der'}));
+  const keyId=sha256(der);
+  insist(envelope.attestation?.algorithm==='ed25519'&&envelope.attestation?.domain==='DEADBYTE-R41-FINAL-CLOSURE-V1','R41 parent closure attestation contract mismatch');
+  insist(envelope.attestation.key_id===keyId,'R41 parent closure signer mismatch');
+  insist(cryptoVerify(null,Buffer.concat([CLOSURE_DOMAIN,bodyBytes]),key,Buffer.from(envelope.attestation.signature_base64,'base64')),'R41 parent closure signature invalid');
+  return pointer;
+}
+
+export async function verifyR42Parent(file=path.join(root,'R42-PARENT.json')){
+  const record=JSON.parse(await readFile(path.resolve(file),'utf8'));
+  insist(record.schema==='deadbyte.r42-parent.v1','R42 parent schema mismatch');
+  insist(record.parent_version==='0.13.0'&&record.parent_release_id==='v0.13.0-3255be10de4daf08','R42 parent identity mismatch');
+  insist(record.parent_manifest_sha256==='3255be10de4daf0837d67d1ab1913b785b8b8215bc7405823c2ff46968c4b98f','R42 parent manifest mismatch');
+  insist(record.parent_generation_manifest_sha256==='143d2d98b675b4ed68cce2bfb1cda76ec22633035b49746e445140fee58b25cd','R42 parent generation mismatch');
+  const [sourceFiles,releaseFiles]=await Promise.all([
+    verifyTree(path.resolve(record.parent_source_root),'MANIFEST.SHA256',record.parent_manifest_sha256,{exact:false}),
+    verifyTree(path.resolve(record.parent_release_root),'MANIFEST.SHA256',record.parent_manifest_sha256,{exact:true})
+  ]);
+  insist(sourceFiles===record.parent_manifest_file_count&&releaseFiles===record.parent_manifest_file_count,'R42 parent file count mismatch');
+
+  const closureBytes=await readFile(path.resolve(record.parent_final_closure_path));
+  insist(sha256(closureBytes)===record.parent_final_closure_sha256,'R41 parent final closure raw hash mismatch');
+  const closure=JSON.parse(closureBytes.toString('utf8').replace(/^\uFEFF/,''));
+  const pointer=verifySignedClosure(closure,record,await readFile(path.join(stateRoot,'trust','ed25519-public.pem')));
+  const generationFiles=await verifyTree(path.resolve(pointer.generation_root),'GENERATION.SHA256',record.parent_generation_manifest_sha256,{exact:true});
+
+  const tarball=await readFile(path.resolve(record.parent_public_tarball_path));
+  insist(sha256(tarball)===record.parent_public_tarball_sha256,'R41 parent public tarball SHA-256 mismatch');
+  insist(sha1(tarball)===record.parent_public_tarball_sha1,'R41 parent public tarball SHA-1 mismatch');
+
+  return {status:'passed',parent_release_id:record.parent_release_id,parent_manifest_sha256:record.parent_manifest_sha256,
+    parent_generation_manifest_sha256:record.parent_generation_manifest_sha256,source_files:sourceFiles,release_files:releaseFiles,
+    generation_files:generationFiles,parent_final_closure_sha256:record.parent_final_closure_sha256,
+    parent_public_tarball_sha256:record.parent_public_tarball_sha256,parent_public_tarball_sha1:record.parent_public_tarball_sha1};
+}
+
+if(process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url)){
+  verifyR42Parent(process.argv[2]).then(value=>console.log(JSON.stringify(value,null,2)))
+    .catch(error=>{console.error(error instanceof Error?error.stack:String(error));process.exitCode=1;});
+}

package/scripts/windows-gate-evidence-r42.mjs

@@ -0,0 +1,64 @@
+import { createHash } from 'node:crypto';
+import { mkdir, open, readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { canonicalJson } from '../src/canonical-json.mjs';
+import { readAndVerifyR42EvalEvidence } from '../src/agent-eval-runner-r42.mjs';
+
+const here=path.dirname(fileURLToPath(import.meta.url));
+const root=path.resolve(here,'..');
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const marker='DEADBYTE V0.14.0 / R42 WINDOWS BATCH GATE: PASS';
+function insist(ok,message){if(!ok) throw new Error(message);}
+
+export async function writeWindowsGateEvidence({
+  candidateRoot=root,
+  stateRoot=path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp')),
+  clock=()=>new Date()
+}={}){
+  const candidate=path.resolve(candidateRoot);
+  const manifestBytes=await readFile(path.join(candidate,'MANIFEST.SHA256'));
+  const manifestSha256=sha256(manifestBytes);
+  const pkg=JSON.parse(await readFile(path.join(candidate,'package.json'),'utf8'));
+  insist(pkg.version==='0.14.0',`Windows gate evidence requires V0.14.0, found ${pkg.version}`);
+
+  const suite=JSON.parse(await readFile(path.join(candidate,'harness','r42-agent-evals.json'),'utf8'));
+  const suiteSha256=sha256(Buffer.from(canonicalJson(suite),'utf8'));
+  const evalId=`r42-${manifestSha256.slice(0,16)}-${suiteSha256.slice(0,16)}`;
+  const evalPath=path.join(path.resolve(stateRoot),'evidence','release','r42-agent-evals','agent_eval',`${evalId}.json`);
+  const evalVerified=await readAndVerifyR42EvalEvidence(evalPath,{subjectManifestSha256:manifestSha256,suiteSha256});
+
+  const completed=clock();
+  insist(completed instanceof Date&&!Number.isNaN(completed.getTime()),'Windows gate evidence clock invalid');
+  const evidence={
+    schema:'deadbyte.r42-windows-gate.v1',status:'passed',exit_code:0,version:'0.14.0',
+    marker,completed_at_utc:completed.toISOString(),manifest_sha256:manifestSha256,
+    model_eval:{path:evalPath,evidence_sha256:evalVerified.evidence_sha256,payload_sha256:evalVerified.payload_sha256,
+      suite_sha256:suiteSha256,case_count:evalVerified.payload.case_count}
+  };
+  const bytes=Buffer.from(`${JSON.stringify(evidence,null,2)}\n`,'utf8');
+  const dir=path.join(path.resolve(stateRoot),'evidence','release');
+  await mkdir(dir,{recursive:true});
+  const file=path.join(dir,`r42-windows-gate-${manifestSha256.slice(0,16)}.json`);
+  try{
+    const handle=await open(file,'wx',0o600);
+    try{await handle.writeFile(bytes);await handle.sync();}finally{await handle.close();}
+    return {status:'written',path:file,sha256:sha256(bytes),manifest_sha256:manifestSha256,model_eval:evidence.model_eval};
+  }catch(error){
+    if(error?.code!=='EEXIST') throw error;
+    const existingBytes=await readFile(file);
+    const existing=JSON.parse(existingBytes.toString('utf8').replace(/^\uFEFF/,''));
+    insist(existing.schema===evidence.schema&&existing.status==='passed'&&existing.exit_code===0,'existing R42 Windows gate evidence invalid');
+    insist(existing.version==='0.14.0'&&existing.marker===marker&&existing.manifest_sha256===manifestSha256,'existing R42 Windows gate identity mismatch');
+    insist(existing.model_eval?.evidence_sha256===evidence.model_eval.evidence_sha256&&existing.model_eval?.suite_sha256===suiteSha256,'existing R42 Windows gate model-eval mismatch');
+    return {status:'existing',path:file,sha256:sha256(existingBytes),manifest_sha256:manifestSha256,model_eval:existing.model_eval};
+  }
+}
+
+const invoked=process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url);
+if(invoked){
+  writeWindowsGateEvidence()
+    .then(result=>console.log(JSON.stringify(result)))
+    .catch(error=>{console.error(error instanceof Error?error.stack:String(error));process.exitCode=1;});
+}

package/src/agent-eval-r42.mjs

@@ -0,0 +1,73 @@
+import { createHash } from 'node:crypto';
+import { canonicalJson } from './canonical-json.mjs';
+
+const HEX64=/^[0-9a-f]{64}$/;
+const ID=/^[A-Za-z0-9._-]{1,96}$/;
+const SEVERITY=new Set(['info','low','medium','high','critical']);
+const sha=value=>createHash('sha256').update(Buffer.from(canonicalJson(value),'utf8')).digest('hex');
+function object(value,label){if(!value||typeof value!=='object'||Array.isArray(value))throw new Error(`${label} invalid`);return value;}
+function keys(value,allowed,label){const extra=Object.keys(value).filter(key=>!allowed.includes(key));if(extra.length)throw new Error(`${label} unknown field '${extra[0]}'`);}
+function id(value,label){if(typeof value!=='string'||!ID.test(value))throw new Error(`${label} invalid`);return value;}
+function text(value,label,max=8192){if(typeof value!=='string'||value.length<1||value.length>max||value.includes('\0'))throw new Error(`${label} invalid`);return value;}
+function textList(value,label,maxItems=32,maxLength=1024){if(!Array.isArray(value)||value.length>maxItems||value.some(item=>typeof item!=='string'||item.length<1||item.length>maxLength))throw new Error(`${label} invalid`);return [...value];}
+
+function normalizeCase(raw){
+  const value=object(raw,'agent eval case');keys(value,['schema','case_id','task','allowed_context','hidden_oracle','acceptance'],'agent eval case');
+  if(value.schema!=='deadbyte.agent-eval-case.v1')throw new Error('agent eval case schema invalid');
+  const core={schema:value.schema,case_id:id(value.case_id,'eval case_id'),task:text(value.task,'eval task'),
+    allowed_context:structuredClone(object(value.allowed_context,'eval allowed_context')),
+    hidden_oracle:structuredClone(object(value.hidden_oracle,'eval hidden_oracle')),
+    acceptance:textList(value.acceptance,'eval acceptance')};
+  return Object.freeze({...core,case_sha256:sha(core)});
+}
+
+function normalizeJudgeResult(raw){
+  const value=object(raw,'judge result');keys(value,['schema','verdict','advisory','findings','evidence_refs'],'judge result');
+  if(value.schema!==undefined&&value.schema!=='deadbyte.agent-eval-judge-result.v1')throw new Error('judge result schema invalid');
+  if(!['pass','fail'].includes(value.verdict))throw new Error('judge verdict invalid');
+  if(value.advisory!==undefined&&value.advisory!==true)throw new Error('judge result must remain advisory');
+  if(!Array.isArray(value.findings)||value.findings.length>64)throw new Error('judge findings invalid');
+  const findings=value.findings.map(finding=>{
+    object(finding,'judge finding');keys(finding,['code','severity','evidence'],'judge finding');
+    if(!SEVERITY.has(finding.severity))throw new Error('judge finding severity invalid');
+    return {code:id(finding.code,'judge finding code'),severity:finding.severity,evidence:text(finding.evidence,'judge finding evidence',2048)};
+  });
+  if(!Array.isArray(value.evidence_refs)||value.evidence_refs.length<1||value.evidence_refs.length>64||value.evidence_refs.some(ref=>!HEX64.test(ref)))throw new Error('judge evidence refs invalid');
+  return Object.freeze({schema:'deadbyte.agent-eval-judge-result.v1',verdict:value.verdict,advisory:true,findings,evidence_refs:[...value.evidence_refs]});
+}
+
+export async function runIsolatedEvaluation({caseSpec,generator,judge}){
+  const normalized=normalizeCase(caseSpec);
+  if(typeof generator!=='function'||typeof judge!=='function')throw new Error('eval generator and judge required');
+  const generatorInput=Object.freeze({schema:'deadbyte.agent-eval-generator-input.v1',case_id:normalized.case_id,
+    task:normalized.task,allowed_context:structuredClone(normalized.allowed_context),acceptance:[...normalized.acceptance]});
+  const generated=object(await generator(generatorInput),'generator result');
+  keys(generated,['artifact','trace'],'generator result');
+  const artifact=structuredClone(object(generated.artifact,'generator artifact'));
+  const candidateSha=sha(artifact);
+  const judgeInput=Object.freeze({schema:'deadbyte.agent-eval-judge-input.v1',case_id:normalized.case_id,
+    task:normalized.task,acceptance:[...normalized.acceptance],candidate:artifact,candidate_sha256:candidateSha,
+    hidden_oracle:structuredClone(normalized.hidden_oracle)});
+  const judged=normalizeJudgeResult(await judge(judgeInput));
+  const core={schema:'deadbyte.agent-eval-result.v1',case_id:normalized.case_id,case_sha256:normalized.case_sha256,
+    candidate_sha256:candidateSha,verdict:judged.verdict,advisory:true,findings:judged.findings,evidence_refs:judged.evidence_refs};
+  return Object.freeze({...core,result_sha256:sha(core)});
+}
+
+export function buildFreshCriticContext(raw){
+  const value=object(raw,'fresh critic context');keys(value,['case_id','artifact','evidence','criteria'],'fresh critic context');
+  id(value.case_id,'critic case_id');object(value.artifact,'critic artifact');
+  if(!Array.isArray(value.evidence)||value.evidence.length>128)throw new Error('critic evidence invalid');
+  return Object.freeze({schema:'deadbyte.fresh-critic-context.v1',case_id:value.case_id,
+    artifact:structuredClone(value.artifact),evidence:structuredClone(value.evidence),
+    criteria:textList(value.criteria,'critic criteria',64,1024)});
+}
+
+export function triageJudgeResult(raw,{critical_action,noncritical_action}){
+  const judge=normalizeJudgeResult(raw);
+  if(judge.advisory!==true)throw new Error('judge result must remain advisory');
+  if(!['pause','repair','continue'].includes(critical_action)||!['pause','repair','continue'].includes(noncritical_action))throw new Error('judge triage action invalid');
+  const critical=judge.findings.some(finding=>finding.severity==='critical'||finding.severity==='high');
+  return Object.freeze({action:judge.verdict==='pass'?'continue':(critical?critical_action:noncritical_action),
+    reason_codes:judge.findings.map(finding=>finding.code),judge_advisory:true});
+}

package/src/agent-eval-runner-r42.mjs

@@ -0,0 +1,138 @@
+import { createHash } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { canonicalJson } from './canonical-json.mjs';
+import { runIsolatedEvaluation } from './agent-eval-r42.mjs';
+import { publishEvidenceAtomic } from './evidence-publisher-r42.mjs';
+
+const HEX64=/^[0-9a-f]{64}$/;
+const ID=/^[A-Za-z0-9._-]{1,96}$/;
+const sha=value=>createHash('sha256').update(Buffer.from(canonicalJson(value),'utf8')).digest('hex');
+const shaText=value=>createHash('sha256').update(Buffer.from(String(value),'utf8')).digest('hex');
+
+function object(value,label){if(!value||typeof value!=='object'||Array.isArray(value))throw new Error(`${label} invalid`);return value;}
+function keys(value,allowed,label){const extra=Object.keys(value).filter(key=>!allowed.includes(key));if(extra.length)throw new Error(`${label} unknown field '${extra[0]}'`);}
+function parseJson(raw,label){
+  if(typeof raw!=='string'||raw.length<2||raw.length>1024*1024)throw new Error(`${label} response invalid`);
+  let value;try{value=JSON.parse(raw);}catch{throw new Error(`${label} response must be strict JSON`);}
+  return object(value,label);
+}
+function providerMeta(raw){
+  const value=object(raw,'model response');
+  const meta={
+    backend:typeof value.backend==='string'?value.backend:'injected',
+    model:typeof value.model==='string'?value.model.slice(0,128):'injected',
+    response_id:typeof value.response_id==='string'?value.response_id.slice(0,160):null,
+    raw_response_sha256:HEX64.test(value.raw_response_sha256??'')?value.raw_response_sha256:shaText(value.raw_text??''),
+    usage:value.usage&&Number.isInteger(value.usage.input_tokens)&&Number.isInteger(value.usage.output_tokens)&&Number.isInteger(value.usage.total_tokens)
+      ?{input_tokens:value.usage.input_tokens,output_tokens:value.usage.output_tokens,total_tokens:value.usage.total_tokens}:null
+  };
+  return Object.freeze(meta);
+}
+function normalizeSuite(raw){
+  const value=object(raw,'eval suite');keys(value,['schema','suite_id','cases'],'eval suite');
+  if(value.schema!=='deadbyte.agent-eval-suite.v1')throw new Error('eval suite schema invalid');
+  if(typeof value.suite_id!=='string'||!ID.test(value.suite_id))throw new Error('eval suite_id invalid');
+  if(!Array.isArray(value.cases)||value.cases.length<1||value.cases.length>32)throw new Error('eval suite cases invalid');
+  const ids=new Set();
+  for(const item of value.cases){
+    object(item,'eval suite case');
+    if(item.schema!=='deadbyte.agent-eval-case.v1'||typeof item.case_id!=='string'||!ID.test(item.case_id)||ids.has(item.case_id))throw new Error('eval suite case identity invalid');
+    ids.add(item.case_id);
+  }
+  const copy=structuredClone(value);
+  return Object.freeze({...copy,suite_sha256:sha(copy)});
+}
+function generatorPrompt(input){
+  return [
+    'You are the implementation-side evaluator for DEADBYTE R42.',
+    'Return exactly one JSON object with shape {"artifact":{...}} and no Markdown.',
+    'Do not invent authority, credentials, or evidence. Prefer bounded, typed, fail-closed behavior.',
+    `INPUT=${canonicalJson(input)}`
+  ].join('\n');
+}
+function judgePrompt(input){
+  return [
+    'You are an independent advisory judge for DEADBYTE R42.',
+    'Return exactly one JSON object with schema deadbyte.agent-eval-judge-result.v1.',
+    'Shape: {"schema":"deadbyte.agent-eval-judge-result.v1","verdict":"pass|fail","advisory":true,"findings":[{"code":"ID","severity":"info|low|medium|high|critical","evidence":"text"}],"evidence_refs":["64hex"]}.',
+    'Judge only the supplied candidate against acceptance and hidden oracle. Do not assume implementer reasoning.',
+    'Use candidate_sha256 as at least one evidence_refs entry.',
+    `INPUT=${canonicalJson(input)}`
+  ].join('\n');
+}
+
+export function verifyR42EvalPayload(payload,{subjectManifestSha256=null,suiteSha256=null}={}){
+  const value=object(payload,'R42 eval payload');
+  keys(value,['schema','status','subject_manifest_sha256','suite_id','suite_sha256','case_count','cases','completed_at_utc'],'R42 eval payload');
+  if(value.schema!=='deadbyte.r42-model-eval.v1'||value.status!=='passed')throw new Error('R42 eval payload is not passed');
+  if(!HEX64.test(value.subject_manifest_sha256??''))throw new Error('R42 eval manifest invalid');
+  if(subjectManifestSha256!==null&&value.subject_manifest_sha256!==subjectManifestSha256)throw new Error('R42 eval manifest mismatch');
+  if(!HEX64.test(value.suite_sha256??''))throw new Error('R42 eval suite hash invalid');
+  if(suiteSha256!==null&&value.suite_sha256!==suiteSha256)throw new Error('R42 eval suite hash mismatch');
+  if(typeof value.suite_id!=='string'||!ID.test(value.suite_id))throw new Error('R42 eval suite id invalid');
+  if(!Number.isInteger(value.case_count)||value.case_count<1||!Array.isArray(value.cases)||value.cases.length!==value.case_count)throw new Error('R42 eval cases invalid');
+  const seen=new Set();
+  for(const item of value.cases){
+    object(item,'R42 eval case result');keys(item,['case_id','result','generator','judge'],'R42 eval case result');
+    if(typeof item.case_id!=='string'||!ID.test(item.case_id)||seen.has(item.case_id))throw new Error('R42 eval case result identity invalid');
+    seen.add(item.case_id);
+    if(item.result?.schema!=='deadbyte.agent-eval-result.v1'||item.result?.verdict!=='pass'||item.result?.advisory!==true||!HEX64.test(item.result?.result_sha256??''))throw new Error(`R42 eval case did not pass: ${item.case_id}`);
+    for(const role of ['generator','judge']){
+      if(!HEX64.test(item[role]?.raw_response_sha256??''))throw new Error(`R42 eval ${role} provenance invalid`);
+    }
+  }
+  if(typeof value.completed_at_utc!=='string'||!Number.isFinite(Date.parse(value.completed_at_utc)))throw new Error('R42 eval completion time invalid');
+  return true;
+}
+
+export async function runAgentEvalSuiteR42({suite,subjectManifestSha256,requestModel,evidenceRoot=null,clock=()=>new Date()}){
+  const normalized=normalizeSuite(suite);
+  if(!HEX64.test(subjectManifestSha256??''))throw new Error('R42 eval subject manifest invalid');
+  if(typeof requestModel!=='function')throw new Error('R42 eval requestModel required');
+  const rows=[];
+  for(const caseSpec of normalized.cases){
+    let generatorMeta=null,judgeMeta=null;
+    const result=await runIsolatedEvaluation({
+      caseSpec,
+      generator:async input=>{
+        const response=object(await requestModel({role:'generator',case_id:caseSpec.case_id,prompt:generatorPrompt(input)}),'generator model response');
+        generatorMeta=providerMeta(response);
+        const parsed=parseJson(response.raw_text,'generator');
+        keys(parsed,['artifact'],'generator response');
+        return {artifact:object(parsed.artifact,'generator artifact')};
+      },
+      judge:async input=>{
+        const response=object(await requestModel({role:'judge',case_id:caseSpec.case_id,prompt:judgePrompt(input)}),'judge model response');
+        judgeMeta=providerMeta(response);
+        return parseJson(response.raw_text,'judge');
+      }
+    });
+    rows.push({case_id:caseSpec.case_id,result,generator:generatorMeta,judge:judgeMeta});
+  }
+  if(rows.some(row=>row.result.verdict!=='pass'))throw new Error('R42 model-backed eval suite failed');
+  const completed=clock();if(!(completed instanceof Date)||Number.isNaN(completed.getTime()))throw new Error('R42 eval clock invalid');
+  const payload={
+    schema:'deadbyte.r42-model-eval.v1',status:'passed',subject_manifest_sha256:subjectManifestSha256,
+    suite_id:normalized.suite_id,suite_sha256:normalized.suite_sha256,case_count:rows.length,cases:rows,
+    completed_at_utc:completed.toISOString()
+  };
+  verifyR42EvalPayload(payload,{subjectManifestSha256,suiteSha256:normalized.suite_sha256});
+  let publication=null;
+  if(evidenceRoot!==null){
+    if(typeof evidenceRoot!=='string'||!path.isAbsolute(evidenceRoot))throw new Error('R42 eval evidence root must be absolute');
+    const evidenceId=`r42-${subjectManifestSha256.slice(0,16)}-${normalized.suite_sha256.slice(0,16)}`;
+    publication=await publishEvidenceAtomic({root:evidenceRoot,kind:'agent_eval',evidenceId,payload});
+  }
+  return Object.freeze({payload,publication});
+}
+
+export async function readAndVerifyR42EvalEvidence(file,{subjectManifestSha256,suiteSha256}={}){
+  const envelope=JSON.parse(await readFile(path.resolve(file),'utf8'));
+  if(envelope?.schema!=='deadbyte.evidence-publication.v1'||envelope?.kind!=='agent_eval')throw new Error('R42 eval evidence envelope invalid');
+  if(!HEX64.test(envelope.payload_sha256??'')||sha(envelope.payload)!==envelope.payload_sha256)throw new Error('R42 eval payload hash mismatch');
+  const {evidence_sha256,...body}=envelope;
+  if(!HEX64.test(evidence_sha256??'')||sha(body)!==evidence_sha256)throw new Error('R42 eval evidence hash mismatch');
+  verifyR42EvalPayload(envelope.payload,{subjectManifestSha256,suiteSha256});
+  return Object.freeze({status:'passed',evidence_sha256,payload_sha256:envelope.payload_sha256,payload:envelope.payload});
+}

package/src/agent-governance-r42.mjs

@@ -0,0 +1,142 @@
+import { createHash } from 'node:crypto';
+import { canonicalJson } from './canonical-json.mjs';
+
+const HEX64=/^[0-9a-f]{64}$/;
+const ID=/^[A-Za-z0-9._-]{1,64}$/;
+const RIGOR=Object.freeze({lightweight:0,structured:1,agentic:2});
+const RISK_MINIMUM=Object.freeze({low:'lightweight',medium:'structured',high:'agentic'});
+const EVIDENCE=Object.freeze({assumption:1,source:2,traced_path:3,automated:4,runtime:5});
+
+const sha=value=>createHash('sha256').update(Buffer.from(canonicalJson(value),'utf8')).digest('hex');
+function object(value,label){if(!value||typeof value!=='object'||Array.isArray(value)) throw new Error(`${label} invalid`);return value;}
+function keys(value,allowed,label){const extra=Object.keys(value).filter(key=>!allowed.includes(key));if(extra.length) throw new Error(`${label} unknown field '${extra[0]}'`);}
+function id(value,label){if(typeof value!=='string'||!ID.test(value)) throw new Error(`${label} invalid`);return value;}
+function hex(value,label){if(typeof value!=='string'||!HEX64.test(value)) throw new Error(`${label} invalid`);return value;}
+function text(value,label,max=2048){if(typeof value!=='string'||value.length<1||value.length>max||value.includes('\0')) throw new Error(`${label} invalid`);return value;}
+function idList(value,label,max=128){if(!Array.isArray(value)||value.length>max||value.some(item=>typeof item!=='string'||!ID.test(item))||new Set(value).size!==value.length) throw new Error(`${label} invalid`);return [...value];}
+
+export function bindApprovalSubject(raw){
+  const value=object(raw,'approval subject');
+  keys(value,['goal_id','reviewed_event_seq','reviewed_event_sha256','journal_head_sha256','scope','subject'],'approval subject');
+  hex(value.goal_id,'approval goal_id');
+  if(!Number.isInteger(value.reviewed_event_seq)||value.reviewed_event_seq<1) throw new Error('approval reviewed_event_seq invalid');
+  hex(value.reviewed_event_sha256,'approval reviewed_event_sha256');
+  hex(value.journal_head_sha256,'approval journal_head_sha256');
+  id(value.scope,'approval scope'); object(value.subject,'approval canonical subject');
+  const normalized=structuredClone(value);
+  return Object.freeze({...normalized,approval_subject_sha256:sha({schema:'deadbyte.approval-subject.v1',...normalized})});
+}
+
+export function validateBoundApproval({approval,subject,now=new Date()}){
+  const {approval_subject_sha256:claimedSubjectSha,...subjectBody}=object(subject,'approval subject');
+  const bound=bindApprovalSubject(subjectBody);
+  if(claimedSubjectSha!==undefined&&claimedSubjectSha!==bound.approval_subject_sha256) throw new Error('approval subject hash mismatch');
+  const value=object(approval,'bound approval');
+  keys(value,['schema','approval_subject_sha256','reviewed_event_seq','reviewed_event_sha256','journal_head_sha256','scope','issued_at_utc','expires_at_utc','provenance'],'bound approval');
+  if(value.schema!=='deadbyte.bound-approval.v1') throw new Error('bound approval schema invalid');
+  if(value.approval_subject_sha256!==bound.approval_subject_sha256) throw new Error('bound approval subject mismatch');
+  if(value.reviewed_event_seq!==bound.reviewed_event_seq||value.reviewed_event_sha256!==bound.reviewed_event_sha256) throw new Error('bound approval reviewed event mismatch');
+  if(value.journal_head_sha256!==bound.journal_head_sha256) throw new Error('bound approval journal head mismatch');
+  if(value.scope!==bound.scope) throw new Error('bound approval scope mismatch');
+  if(value.provenance!=='operator_mcp') throw new Error('bound approval provenance invalid');
+  const issued=Date.parse(value.issued_at_utc),expires=Date.parse(value.expires_at_utc),observed=now.getTime();
+  if(!Number.isFinite(issued)||!Number.isFinite(expires)||expires<=issued||expires-issued>3_600_000) throw new Error('bound approval lifetime invalid');
+  if(observed<issued||observed>=expires) throw new Error('bound approval expired or not yet valid');
+  return true;
+}
+
+export function createTaskDag(raw){
+  const value=object(raw,'task DAG'); keys(value,['run_id','goal_id','tasks'],'task DAG');
+  id(value.run_id,'task DAG run_id'); hex(value.goal_id,'task DAG goal_id');
+  if(!Array.isArray(value.tasks)||value.tasks.length<1||value.tasks.length>256) throw new Error('task DAG tasks invalid');
+  const tasks=value.tasks.map(item=>{
+    object(item,'task DAG task');keys(item,['task_id','depends_on','input_artifacts','output_artifacts','state'],'task DAG task');
+    return {task_id:id(item.task_id,'task_id'),depends_on:idList(item.depends_on,'depends_on'),
+      input_artifacts:idList(item.input_artifacts,'input_artifacts'),output_artifacts:idList(item.output_artifacts,'output_artifacts'),
+      state:item.state??'PENDING'};
+  });
+  const ids=new Set(tasks.map(task=>task.task_id)); if(ids.size!==tasks.length) throw new Error('task DAG duplicate task_id');
+  for(const task of tasks) if(task.depends_on.some(dep=>!ids.has(dep))) throw new Error('task DAG dependency missing');
+  if(tasks.some(task=>!['PENDING','RUNNING','COMPLETE','FAILED','STALE'].includes(task.state))) throw new Error('task DAG state invalid');
+  const visiting=new Set(),visited=new Set(),byId=new Map(tasks.map(task=>[task.task_id,task]));
+  const visit=taskId=>{if(visiting.has(taskId)) throw new Error('task DAG cycle detected');if(visited.has(taskId))return;visiting.add(taskId);for(const dep of byId.get(taskId).depends_on)visit(dep);visiting.delete(taskId);visited.add(taskId);};
+  for(const task of tasks) visit(task.task_id);
+  const core={schema:'deadbyte.task-dag.v1',run_id:value.run_id,goal_id:value.goal_id,tasks};
+  return Object.freeze({...core,dag_sha256:sha(core)});
+}
+
+export function invalidateTaskDag(dag,{changed_artifact_ids}){
+  const changed=new Set(idList(changed_artifact_ids,'changed_artifact_ids'));
+  const stale=new Set(dag.tasks.filter(task=>task.input_artifacts.some(artifact=>changed.has(artifact))).map(task=>task.task_id));
+  let grew=true;while(grew){grew=false;for(const task of dag.tasks){if(!stale.has(task.task_id)&&task.depends_on.some(dep=>stale.has(dep))){stale.add(task.task_id);grew=true;}}}
+  return createTaskDag({run_id:dag.run_id,goal_id:dag.goal_id,tasks:dag.tasks.map(task=>({...task,state:stale.has(task.task_id)?'STALE':task.state}))});
+}
+
+export function taskDagFromPlan({run_id,goal_id,plan}){
+  object(plan,'task DAG plan');
+  if(!Array.isArray(plan.steps)||plan.steps.length<1) throw new Error('task DAG plan steps invalid');
+  const tasks=plan.steps.map((step,index)=>{
+    const previous=index===0?null:plan.steps[index-1].step_id;
+    return {task_id:step.step_id,depends_on:previous?[previous]:[],
+      input_artifacts:previous?[`${previous}.result`]:[],output_artifacts:[`${step.step_id}.result`],
+      state:step.status==='completed'?'COMPLETE':step.status==='active'?'RUNNING':'PENDING'};
+  });
+  return createTaskDag({run_id,goal_id,tasks});
+}
+
+export function createEvidenceClaim(raw){
+  const value=object(raw,'evidence claim');keys(value,['claim_id','statement','level','refs'],'evidence claim');
+  id(value.claim_id,'claim_id');text(value.statement,'claim statement',2048);
+  if(!Object.hasOwn(EVIDENCE,value.level)) throw new Error('evidence level invalid');
+  if(!Array.isArray(value.refs)||value.refs.length>64||value.refs.some(ref=>!HEX64.test(ref))) throw new Error('evidence reference invalid');
+  if(value.level!=='assumption'&&value.refs.length<1) throw new Error('evidence reference required');
+  const core={schema:'deadbyte.evidence-claim.v1',claim_id:value.claim_id,statement:value.statement,level:value.level,refs:[...value.refs]};
+  return Object.freeze({...core,claim_sha256:sha(core)});
+}
+export function evidenceSatisfies(claim,minimum){if(!Object.hasOwn(EVIDENCE,minimum)) throw new Error('minimum evidence level invalid');return EVIDENCE[claim.level]>=EVIDENCE[minimum];}
+
+export function deriveEffectiveRigor({project_default,risk_level,explicit_override=null}){
+  if(!Object.hasOwn(RIGOR,project_default)) throw new Error('project default rigor invalid');
+  if(!Object.hasOwn(RISK_MINIMUM,risk_level)) throw new Error('risk level invalid');
+  if(explicit_override!==null&&!Object.hasOwn(RIGOR,explicit_override)) throw new Error('explicit rigor override invalid');
+  const risk_minimum=RISK_MINIMUM[risk_level];
+  const values=[project_default,risk_minimum,...(explicit_override?[explicit_override]:[])];
+  const effective_rigor=values.reduce((best,item)=>RIGOR[item]>RIGOR[best]?item:best,'lightweight');
+  return Object.freeze({project_default,risk_minimum,explicit_override,effective_rigor});
+}
+
+export function createDecisionRecord(raw){
+  const value=object(raw,'decision record');keys(value,['decision_id','decision','reason','evidence_refs','invalidates_if'],'decision record');
+  id(value.decision_id,'decision_id');text(value.decision,'decision',2048);text(value.reason,'decision reason',2048);
+  if(!Array.isArray(value.evidence_refs)||value.evidence_refs.length<1||value.evidence_refs.length>64||value.evidence_refs.some(ref=>!HEX64.test(ref))) throw new Error('decision evidence refs invalid');
+  if(!Array.isArray(value.invalidates_if)||value.invalidates_if.length>32) throw new Error('decision invalidation rules invalid');
+  const rules=value.invalidates_if.map(rule=>{
+    object(rule,'decision invalidation rule');
+    if(rule.kind==='artifact_sha_changed'){
+      keys(rule,['kind','artifact_id','expected_sha256'],'artifact invalidation rule');
+      return {kind:rule.kind,artifact_id:id(rule.artifact_id,'artifact_id'),expected_sha256:hex(rule.expected_sha256,'expected artifact sha256')};
+    }
+    if(rule.kind==='policy_sha_changed'){
+      keys(rule,['kind','expected_sha256'],'policy invalidation rule');
+      return {kind:rule.kind,expected_sha256:hex(rule.expected_sha256,'expected policy sha256')};
+    }
+    throw new Error('decision invalidation rule kind invalid');
+  });
+  const core={schema:'deadbyte.decision-record.v1',decision_id:value.decision_id,decision:value.decision,reason:value.reason,
+    evidence_refs:[...value.evidence_refs],invalidates_if:rules};
+  return Object.freeze({...core,decision_sha256:sha(core)});
+}
+
+export function evaluateDecisionFreshness(record,observed){
+  object(record,'decision record');object(observed,'decision observed state');
+  const invalidated_by=[];
+  for(const rule of record.invalidates_if){
+    if(rule.kind==='artifact_sha_changed'){
+      const actual=observed.artifact_sha256?.[rule.artifact_id]??null;
+      if(actual!==rule.expected_sha256) invalidated_by.push({...rule,observed_sha256:actual});
+    }else if(rule.kind==='policy_sha_changed'&&observed.policy_sha256!==rule.expected_sha256){
+      invalidated_by.push({...rule,observed_sha256:observed.policy_sha256??null});
+    }
+  }
+  return Object.freeze({decision_id:record.decision_id,state:invalidated_by.length?'STALE':'CURRENT',invalidated_by});
+}

package/src/autonomous-context-engine.mjs

@@ -1,6 +1,7 @@
 import { createHash } from 'node:crypto';
 import { canonicalJson } from './canonical-json.mjs';
 import { provenanceFor, dedupeEvidence } from './context-provenance.mjs';
+import { taskDagFromPlan } from './agent-governance-r42.mjs';
 
 const SECRET_KEY = /(?:^|[_-])(token|password|secret|authorization|cookie|credential|credentials|api[_-]?key|private[_-]?key|recovery)(?:$|[_-])/i;
 const HEX64 = /^[0-9a-f]{64}$/;
@@ -252,6 +253,7 @@ export function buildLoopContext({ goal, policy, loopState = {}, tree = [], cont
     desktop_memory:desktopMemory===null?null:structuredClone(desktopMemory),
     long_term_memory:longTermMemory===null?null:structuredClone(longTermMemory),
     capabilities:capabilities===null?null:structuredClone(capabilities),
+    task_dag:loopState.plan&&typeof goal?.goal_id==='string' ? taskDagFromPlan({run_id:goal.goal_id,goal_id:goal.goal_id,plan:loopState.plan}) : null,
     profiles
   };
   return compactLoopContext(state,policy.limits.max_context_bytes);

package/src/autonomous-loop-state.mjs

@@ -146,6 +146,7 @@ export function deriveLoopState(goal,events) {
     replan_count:0,
     pending_action:null,
     pending_approval:false,
+    clarification:null,
     progress:null,
     critic:null,
     repair:null,
@@ -223,6 +224,10 @@ export function deriveLoopState(goal,events) {
         state.phase='WAITING';
         state.wait_reason=requireText(payload.reason,'loop wait reason');
         state.pending_approval=payload.requires_approval===true;
+        state.clarification=payload.reason==='human_input_required' ? {
+          question:requireText(payload.question,'loop clarification question',1000),
+          choices:Array.isArray(payload.choices) ? payload.choices.map((choice,index)=>requireText(choice,`loop clarification choice ${index+1}`,256)) : []
+        } : null;
         break;
       case 'waiting_resumed': {
         if (state.phase !== 'WAITING') throw new Error('loop waiting_resumed outside WAITING phase');
@@ -231,6 +236,7 @@ export function deriveLoopState(goal,events) {
         state.phase=resumed;
         state.wait_reason=null;
         state.pending_approval=false;
+        state.clarification=null;
         break;
       }
       case 'planner_requested':
@@ -255,24 +261,28 @@ export function deriveLoopState(goal,events) {
           state.phase='PLAN';
           state.wait_reason=null;
           state.pending_approval=false;
+          state.clarification=null;
         }
         break;
       case 'goal_cancelled':
         state.phase='FAILED';
         state.wait_reason=typeof payload.reason==='string'&&payload.reason.length>0?payload.reason:'cancelled';
         state.pending_approval=false;
+        state.clarification=null;
         state.pending_action=null;
         break;
       case 'goal_failed':
         state.phase='FAILED';
         state.wait_reason=typeof payload.reason==='string'&&payload.reason.length>0?payload.reason:'failed';
         state.pending_approval=false;
+        state.clarification=null;
         state.pending_action=null;
         break;
       case 'release_completed':
         state.phase='SUCCEEDED';
         state.wait_reason=null;
         state.pending_approval=false;
+        state.clarification=null;
         state.pending_action=null;
         break;
       default: