deadbyte-mcp 0.12.0 → 0.14.0

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}$/;
@@ -213,7 +214,7 @@ function historicalEvidence({ contexts, observations, loopState }) {
   };
 }
 
-export function buildLoopContext({ goal, policy, loopState = {}, tree = [], contexts = [], observations = [], decisions = [], projectMemory = null, desktopMemory = null, capabilities = null }) {
+export function buildLoopContext({ goal, policy, loopState = {}, tree = [], contexts = [], observations = [], decisions = [], projectMemory = null, desktopMemory = null, longTermMemory = null, capabilities = null }) {
   if (!policy?.limits || !Number.isInteger(policy.limits.max_context_bytes)) throw new Error('loop context policy byte limit missing');
   const relevanceEpoch=Number.isInteger(loopState?.mutation_epoch)&&loopState.mutation_epoch>=0?loopState.mutation_epoch:0;
   const retainedContexts=normalizeEvidence(contexts,{kind:'context',relevanceEpoch});
@@ -250,7 +251,9 @@ export function buildLoopContext({ goal, policy, loopState = {}, tree = [], cont
     historical_evidence:historicalEvidence({contexts:retainedContexts,observations:retainedObservations,loopState}),
     project_memory:memory,
     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:

package/src/autonomous-mcp-tools.mjs

@@ -25,6 +25,17 @@ const rmdirOperation = z.strictObject({ kind:z.literal('rmdir'), path:relPath, e
 const nativeOperation = z.union([writeOperation,replaceOperation,deleteOperation,mkdirOperation,moveOperation,rmdirOperation]);
 const plannerResponse = z.strictObject({ request_id:hex64, raw_text:z.string().min(2).max(8*1024*1024),
   model:z.string().min(1).max(128).default('client-model') });
+const taskContract = z.strictObject({
+  schema:z.literal('deadbyte.task-contract.v1'),
+  scope:z.array(z.string().min(1).max(512)).max(32).default([]),
+  non_goals:z.array(z.string().min(1).max(512)).max(24).default([]),
+  constraints:z.array(z.string().min(1).max(512)).max(32).default([]),
+  evidence_requirements:z.array(z.string().min(1).max(512)).max(32).default([]),
+  risk_level:z.enum(['low','medium','high']).default('medium'),
+  clarification_policy:z.enum(['ask_when_blocked','fail_closed']).default('ask_when_blocked'),
+  project_default:z.enum(['lightweight','structured','agentic']).default('structured'),
+  explicit_override:z.enum(['lightweight','structured','agentic']).nullable().default(null)
+});
 function result(schema,value,isError=false) { return autonomousStructuredResult(schema,value,isError); }
 function fail(schema,error,status='failed') { return result(schema,{ status, error:String(error) },true); }
 
@@ -60,11 +71,12 @@ export function registerAutonomousTools(server,{ autonomousRuntime, nativeDiffRu
     description:'Submit one bounded R24 production goal. Execution requires separate live coding and autonomous leases.',
     inputSchema:z.strictObject({ submission_id:id, root_id:id, title:z.string().max(160).default(''),
       goal:z.string().min(1).max(8192), acceptance:z.string().max(4096).default(''),
+      task_contract:taskContract.nullable().default(null),
       max_iterations:z.number().int().min(1).max(64).nullable().default(null) }),
     outputSchema:autonomousGoalSubmitOutputSchema
-  },async({submission_id,root_id,title,goal,acceptance,max_iterations})=>{ try {
+  },async({submission_id,root_id,title,goal,acceptance,task_contract,max_iterations})=>{ try {
       return result(autonomousGoalSubmitOutputSchema,await autonomousRuntime.submit({ submissionId:submission_id,
-        rootId:root_id,title,goal,acceptance,maxIterations:max_iterations })); }
+        rootId:root_id,title,goal,acceptance,taskContract:task_contract,maxIterations:max_iterations })); }
     catch(error){ return fail(autonomousGoalSubmitOutputSchema,error); } });
   server.registerTool('autonomous_goal_run',{
     description:'Advance one autonomous production goal through inspect/native-diff/build/test/benchmark/replan cycles. Client-planner mode returns a typed input_required sentinel for the Bridge MRTR adapter.',
@@ -100,11 +112,14 @@ export function registerAutonomousTools(server,{ autonomousRuntime, nativeDiffRu
     catch(error){ return fail(autonomousGoalCancelOutputSchema,error); } });
 
   server.registerTool('autonomous_goal_approve',{
-    description:'Approve or reject resuming a paused autonomous goal. This never arms or renews any lease and cannot bypass release evidence.',
-    inputSchema:z.strictObject({ goal_id:hex64, decision:z.enum(['approve','reject']).default('approve') }),
+    description:'Approve or reject resuming a paused autonomous goal, optionally supplying the bounded answer required by a typed human clarification. This never arms or renews any lease and cannot bypass release evidence.',
+    inputSchema:z.strictObject({ goal_id:hex64, decision:z.enum(['approve','reject']).default('approve'),
+      answer:z.string().min(1).max(4096).nullable().default(null),
+      approval_subject_sha256:hex64.nullable().default(null),
+      expires_in_ms:z.number().int().min(1000).max(3600000).default(300000) }),
     outputSchema:autonomousGoalApproveOutputSchema
-  },async({goal_id,decision})=>{ try { return result(autonomousGoalApproveOutputSchema,
-      await autonomousRuntime.approve({goalId:goal_id,decision})); }
+  },async({goal_id,decision,answer,approval_subject_sha256,expires_in_ms})=>{ try { return result(autonomousGoalApproveOutputSchema,
+      await autonomousRuntime.approve({goalId:goal_id,decision,answer,approvalSubjectSha256:approval_subject_sha256,expiresInMs:expires_in_ms})); }
     catch(error){ return fail(autonomousGoalApproveOutputSchema,error); } });
 
   server.registerTool('autonomous_goal_verify',{

package/src/autonomous-output-contracts.mjs

@@ -15,12 +15,28 @@ const loopProgress = z.strictObject({
 const loopPendingAction = z.strictObject({
   action_id:hex64, request_sha256:hex64, kind:z.string().regex(/^[A-Za-z0-9._-]{1,64}$/)
 });
+const loopClarification = z.strictObject({
+  question:z.string().min(1).max(1000), choices:z.array(z.string().min(1).max(256)).max(5)
+});
+const loopApprovalSubject = z.strictObject({
+  goal_id:hex64,reviewed_event_seq:z.number().int().min(1),reviewed_event_sha256:hex64,
+  journal_head_sha256:hex64,scope:z.enum(['resume_goal','human_clarification','desktop_resume','interrupted_effect_resume']),
+  subject:z.strictObject({reason:z.string().min(1).max(1024),waiting_payload_sha256:hex64}),approval_subject_sha256:hex64
+});
+const taskDagTask=z.strictObject({task_id:z.string().regex(/^[A-Za-z0-9._-]{1,64}$/),depends_on:z.array(z.string()).max(256),
+  input_artifacts:z.array(z.string()).max(128),output_artifacts:z.array(z.string()).max(128),
+  state:z.enum(['PENDING','RUNNING','COMPLETE','FAILED','STALE'])});
+const taskDag=z.strictObject({schema:z.literal('deadbyte.task-dag.v1'),run_id:z.string().regex(/^[A-Za-z0-9._-]{1,96}$/),
+  goal_id:hex64,tasks:z.array(taskDagTask).min(1).max(256),dag_sha256:hex64});
 const publicLoopSchema = z.strictObject({
   schema:z.literal('deadbyte.autonomous-loop-state.v1'), phase:loopPhase,
   plan_id:hex64.nullable(), plan_version:z.number().int().min(1).nullable(),
   current_step:loopStep.nullable(), replan_count:z.number().int().min(0),
   progress:loopProgress.nullable(), pending_action:loopPendingAction.nullable(),
-  pending_approval:z.boolean(), wait_reason:z.string().min(1).max(1024).nullable()
+  pending_approval:z.boolean(), wait_reason:z.string().min(1).max(1024).nullable(),
+  clarification:loopClarification.nullable().default(null),
+  approval_subject:loopApprovalSubject.nullable().default(null),
+  task_dag:taskDag.nullable().default(null)
 });
 function requireFields(value,ctx,fields) {
   for (const field of fields) if (value[field] === undefined) ctx.addIssue({ code:'custom', path:[field], message:`${field} is required` });
@@ -52,7 +68,7 @@ export const autonomousSessionStatusOutputSchema = statusContract({
   shape:{ configured:z.literal(true).optional(), armed:z.boolean().optional(), autonomous_armed:z.boolean().optional(),
     autonomous_reason:z.string().optional(), autonomous_expires_at_utc:z.string().nullable().optional(),
     coding_armed:z.boolean().optional(), coding_reason:z.string().optional(), root_ids:z.array(z.string()).max(64).optional(),
-    planner_backend:z.enum(['client_sampling','openai_compatible']).optional(), profile_ids:z.array(z.string()).max(128).optional(),
+    planner_backend:z.enum(['client_sampling','openai_compatible','openai_responses']).optional(), profile_ids:z.array(z.string()).max(128).optional(),
     policy_sha256:hex64.optional(), coding_policy_sha256:hex64.optional() }
 });
 

package/src/autonomous-planner-contracts.mjs

@@ -163,6 +163,9 @@ export const r34PlannerDecisionSchema = z.discriminatedUnion('kind',[
     step_id:z.string().regex(ID),evidence:z.array(r34EvidenceSchema).min(1).max(32)}),
   z.strictObject({schema:z.literal('deadbyte.autonomous-decision.v2'),kind:z.literal('replan'),
     reason:z.string().min(1).max(512),steps:z.array(r34PlanStepSchema).min(1).max(24)}),
+  z.strictObject({schema:z.literal('deadbyte.autonomous-decision.v2'),kind:z.literal('clarify'),
+    question:z.string().min(1).max(1000),
+    choices:z.array(z.string().min(1).max(256)).min(2).max(5).default([])}),
   z.strictObject({schema:z.literal('deadbyte.autonomous-decision.v2'),kind:z.literal('pause'),
     reason:z.string().min(1).max(1000)}),
   z.strictObject({schema:z.literal('deadbyte.autonomous-decision.v2'),kind:z.literal('finish'),