deadbyte-mcp 0.15.74 → 0.15.76

package/scripts/npm-release-readiness-r206.mjs

@@ -0,0 +1,76 @@
+import {createHash} from 'node:crypto';
+import {lstat,readFile} from 'node:fs/promises';
+import path from 'node:path';
+
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const hex64=value=>typeof value==='string'&&/^[0-9a-f]{64}$/.test(value);
+const fail=message=>{throw new Error(`PUBLISH_BLOCKED R206 ${message}`);};
+const required=(value,message)=>{if(!value)fail(message);};
+
+async function checkedFile(file,expected,{maxBytes=64*1024*1024}={}){
+  required(hex64(expected),'evidence digest missing');
+  let info;try{info=await lstat(file);}catch{fail('evidence file absent');}
+  required(info.isFile()&&!info.isSymbolicLink()&&info.size>0&&info.size<=maxBytes,'evidence file invalid');
+  const bytes=await readFile(file);
+  required(sha256(bytes)===expected,'evidence digest differs');
+  return bytes;
+}
+
+function tapSummary(text,label){
+  const summaries=[...text.matchAll(/^# tests (\d+)\s*\r?\n# suites (\d+)\s*\r?\n# pass (\d+)\s*\r?\n# fail (\d+)\s*\r?\n# cancelled (\d+)\s*\r?\n# skipped (\d+)/gm)];
+  required(summaries.length>0,`${label} TAP summary absent`);
+  const last=summaries.at(-1);
+  return {tests:Number(last[1]),passes:Number(last[3]),fails:Number(last[4]),cancelled:Number(last[5]),skips:Number(last[6])};
+}
+
+export function assertR206PackedIdentity({tarball_sha256,tarball_integrity,tarball_shasum,observedSha256,observedIntegrity,observedShasum}={}){
+  required(hex64(tarball_sha256)&&typeof tarball_integrity==='string'&&tarball_integrity.startsWith('sha512-')&&
+    typeof tarball_shasum==='string'&&/^[0-9a-f]{40}$/.test(tarball_shasum),'verified tarball identity invalid');
+  required(observedSha256===tarball_sha256&&observedIntegrity===tarball_integrity&&observedShasum===tarball_shasum,
+    'repacked tarball differs from verified closure bytes');
+  return true;
+}
+
+export async function assertR206NpmPublishReady(release,{root,closureRoot=process.env.DEADBYTE_R206_CLOSURE_ROOT}={}){
+  required(release?.version==='0.15.75'&&release?.train==='R206'&&
+    release?.r206?.scope==='EVIDENCE_BOUND_CANDIDATE_SELECTION_RELEASE_CLOSURE','candidate metadata invalid');
+  required(release?.r206?.public_tool_delta===0&&release?.r206?.authority_scope_delta===0&&
+    release?.r206?.selector_release_authority===false,'public authority surface widened');
+  required(release?.source_predecessor?.train==='R205'&&
+    release?.source_predecessor?.manifest_sha256==='166eebde18d53a9ec46f738383c289733f9cd37918b3572b7515d1ab9b122c92',
+    'source predecessor mismatch');
+  required(release?.parent?.version==='0.15.74'&&release?.parent?.release_id==='v0.15.74-e84bf4eed16e9443'&&
+    release?.parent?.manifest_sha256==='e84bf4eed16e9443fbd0bf9f0f562e26b01db778647aefcc8b12fd7f48636b47'&&
+    release?.parent?.generation_manifest_sha256==='598f896be9ce65e6b0c618e8c8f6eaa2a9d91617a76a146bf3deb385a56d19e7','lineage mismatch');
+  required(root&&path.isAbsolute(root)&&closureRoot&&path.isAbsolute(closureRoot),'closure root absent');
+  const expected=path.resolve(root,'..','..','testing','r206-final-closure');
+  required(path.resolve(closureRoot).toLowerCase()===expected.toLowerCase(),'closure root outside scoped testing folder');
+  let closure;try{closure=JSON.parse(await readFile(path.join(closureRoot,'closure.json'),'utf8'));}catch{fail('closure unreadable');}
+  required(closure?.schema==='deadbyte.r206-release-closure.v1'&&closure.status==='RELEASE_READY'&&
+    closure.version==='0.15.75'&&closure.train==='R206','closure status mismatch');
+  required(closure.production_release_id===release.parent.release_id&&closure.production_manifest_sha256===release.parent.manifest_sha256&&
+    closure.production_generation_manifest_sha256===release.parent.generation_manifest_sha256,'production predecessor mismatch');
+  required(hex64(closure.manifest_sha256)&&closure.manifest_sha256===sha256(await readFile(path.join(root,'MANIFEST.SHA256'))),'final manifest drift');
+  required(closure.compact_tools===43&&closure.full_tools===117,'catalog count mismatch');
+  required(closure.owner_enrollment==='NOT_RUN'&&closure.production_activation==='NOT_RUN','prepublication closure crossed authority boundary');
+  const receipt=JSON.parse((await checkedFile(path.join(closureRoot,'protected-install-receipt.json'),closure.protected_receipt_sha256)).toString('utf8'));
+  required(receipt?.status==='PASS'&&receipt.package_version==='0.15.75'&&receipt.source_manifest_sha256===closure.manifest_sha256&&
+    receipt.protected_manifest_sha256===closure.manifest_sha256,'protected exact-byte receipt mismatch');
+  const focused=(await checkedFile(path.join(closureRoot,'windows-focused.stdout.log'),closure.focused_stdout_sha256)).toString('utf8');
+  const full=(await checkedFile(path.join(closureRoot,'windows-full.stdout.log'),closure.full_stdout_sha256)).toString('utf8');
+  const verify=(await checkedFile(path.join(closureRoot,'npm-verify.stdout.log'),closure.verify_stdout_sha256)).toString('utf8');
+  required(focused.includes('R206_STAGE_PASS=focused'),'focused protected gate incomplete');
+  const focusedSummary=tapSummary(focused,'focused');
+  required(focusedSummary.fails===0&&focusedSummary.cancelled===0&&focusedSummary.passes>=70&&focusedSummary.skips<=3,'focused regression count mismatch');
+  required(full.includes('R206_STAGE_PASS=full'),'full protected gate incomplete');
+  const summary=tapSummary(full,'full');
+  required(summary.tests>=2200&&summary.passes>=2100&&summary.fails===0&&summary.cancelled===0&&summary.skips<=70&&summary.passes+summary.skips===summary.tests,'full regression count mismatch');
+  required(verify.includes('VERIFY-ONLY PIPELINE PASS')&&verify.includes('Artifact isolation gate PASS')&&verify.includes('VERIFIED_TARBALL '),'npm exact-artifact verification incomplete');
+  const line=verify.split(/\r?\n/).find(value=>value.startsWith('VERIFIED_TARBALL '));
+  let artifact;try{artifact=JSON.parse(line.slice('VERIFIED_TARBALL '.length));}catch{fail('tarball evidence malformed');}
+  required(artifact.filename==='deadbyte-mcp-0.15.75.tgz'&&artifact.bytes>0&&artifact.sha256===closure.tarball_sha256&&
+    artifact.integrity===closure.tarball_integrity&&artifact.shasum===closure.tarball_shasum,'tarball identity mismatch');
+  return Object.freeze({status:'R206_RELEASE_READY_EVIDENCE_BOUND',manifest_sha256:closure.manifest_sha256,
+    tarball_sha256:artifact.sha256,tarball_integrity:artifact.integrity,tarball_shasum:artifact.shasum,
+    tests:summary.tests,passes:summary.passes,skips:summary.skips});
+}

package/scripts/npm-release-readiness-r207.mjs

@@ -0,0 +1,76 @@
+import {createHash} from 'node:crypto';
+import {lstat,readFile} from 'node:fs/promises';
+import path from 'node:path';
+
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+const hex64=value=>typeof value==='string'&&/^[0-9a-f]{64}$/.test(value);
+const fail=message=>{throw new Error(`PUBLISH_BLOCKED R207 ${message}`);};
+const required=(value,message)=>{if(!value)fail(message);};
+
+async function checkedFile(file,expected,{maxBytes=64*1024*1024}={}){
+  required(hex64(expected),'evidence digest missing');
+  let info;try{info=await lstat(file);}catch{fail('evidence file absent');}
+  required(info.isFile()&&!info.isSymbolicLink()&&info.size>0&&info.size<=maxBytes,'evidence file invalid');
+  const bytes=await readFile(file);
+  required(sha256(bytes)===expected,'evidence digest differs');
+  return bytes;
+}
+
+function tapSummary(text,label){
+  const summaries=[...text.matchAll(/^# tests (\d+)\s*\r?\n# suites (\d+)\s*\r?\n# pass (\d+)\s*\r?\n# fail (\d+)\s*\r?\n# cancelled (\d+)\s*\r?\n# skipped (\d+)/gm)];
+  required(summaries.length>0,`${label} TAP summary absent`);
+  const last=summaries.at(-1);
+  return {tests:Number(last[1]),passes:Number(last[3]),fails:Number(last[4]),cancelled:Number(last[5]),skips:Number(last[6])};
+}
+
+export function assertR207PackedIdentity({tarball_sha256,tarball_integrity,tarball_shasum,observedSha256,observedIntegrity,observedShasum}={}){
+  required(hex64(tarball_sha256)&&typeof tarball_integrity==='string'&&tarball_integrity.startsWith('sha512-')&&
+    typeof tarball_shasum==='string'&&/^[0-9a-f]{40}$/.test(tarball_shasum),'verified tarball identity invalid');
+  required(observedSha256===tarball_sha256&&observedIntegrity===tarball_integrity&&observedShasum===tarball_shasum,
+    'repacked tarball differs from verified closure bytes');
+  return true;
+}
+
+export async function assertR207NpmPublishReady(release,{root,closureRoot=process.env.DEADBYTE_R207_CLOSURE_ROOT}={}){
+  required(release?.version==='0.15.76'&&release?.train==='R207'&&
+    release?.r207?.scope==='PROTECTED_OWNER_ENROLLMENT_IO_RECOVERY','candidate metadata invalid');
+  required(release?.r207?.public_tool_delta===0&&release?.r207?.authority_scope_delta===0&&
+    release?.r207?.owner_private_key_access===false&&release?.r207?.r70_weakened===false&&release?.r207?.r89_weakened===false,'public authority surface widened');
+  required(release?.source_predecessor?.train==='R206'&&
+    release?.source_predecessor?.manifest_sha256==='9039fff265696091f9217ba4f19526c6c74a967f9ff48b75ac6e340b5f431248',
+    'source predecessor mismatch');
+  required(release?.parent?.version==='0.15.75'&&release?.parent?.release_id==='v0.15.75-9039fff265696091'&&
+    release?.parent?.manifest_sha256==='9039fff265696091f9217ba4f19526c6c74a967f9ff48b75ac6e340b5f431248'&&
+    release?.parent?.generation_manifest_sha256==='83a212e01173c73f78cff2a6d26e6f3f50f476a8c0ea3cbbf592a466071909e9','lineage mismatch');
+  required(root&&path.isAbsolute(root)&&closureRoot&&path.isAbsolute(closureRoot),'closure root absent');
+  const expected=path.resolve(root,'..','..','testing','r207-final-closure');
+  required(path.resolve(closureRoot).toLowerCase()===expected.toLowerCase(),'closure root outside scoped testing folder');
+  let closure;try{closure=JSON.parse(await readFile(path.join(closureRoot,'closure.json'),'utf8'));}catch{fail('closure unreadable');}
+  required(closure?.schema==='deadbyte.r207-release-closure.v1'&&closure.status==='RELEASE_READY'&&
+    closure.version==='0.15.76'&&closure.train==='R207','closure status mismatch');
+  required(closure.production_release_id===release.parent.release_id&&closure.production_manifest_sha256===release.parent.manifest_sha256&&
+    closure.production_generation_manifest_sha256===release.parent.generation_manifest_sha256,'production predecessor mismatch');
+  required(hex64(closure.manifest_sha256)&&closure.manifest_sha256===sha256(await readFile(path.join(root,'MANIFEST.SHA256'))),'final manifest drift');
+  required(closure.compact_tools===43&&closure.full_tools===117,'catalog count mismatch');
+  required(closure.owner_enrollment==='NOT_RUN'&&closure.production_activation==='NOT_RUN','prepublication closure crossed authority boundary');
+  const receipt=JSON.parse((await checkedFile(path.join(closureRoot,'protected-install-receipt.json'),closure.protected_receipt_sha256)).toString('utf8'));
+  required(receipt?.status==='PASS'&&receipt.package_version==='0.15.76'&&receipt.source_manifest_sha256===closure.manifest_sha256&&
+    receipt.protected_manifest_sha256===closure.manifest_sha256,'protected exact-byte receipt mismatch');
+  const focused=(await checkedFile(path.join(closureRoot,'windows-focused.stdout.log'),closure.focused_stdout_sha256)).toString('utf8');
+  const full=(await checkedFile(path.join(closureRoot,'windows-full.stdout.log'),closure.full_stdout_sha256)).toString('utf8');
+  const verify=(await checkedFile(path.join(closureRoot,'npm-verify.stdout.log'),closure.verify_stdout_sha256)).toString('utf8');
+  required(focused.includes('R207_STAGE_PASS=focused'),'focused protected gate incomplete');
+  const focusedSummary=tapSummary(focused,'focused');
+  required(focusedSummary.tests>=55&&focusedSummary.fails===0&&focusedSummary.cancelled===0&&focusedSummary.passes>=54&&focusedSummary.skips<=1&&focusedSummary.passes+focusedSummary.skips===focusedSummary.tests,'focused regression count mismatch');
+  required(full.includes('R207_STAGE_PASS=full'),'full protected gate incomplete');
+  const summary=tapSummary(full,'full');
+  required(summary.tests>=2200&&summary.passes>=2100&&summary.fails===0&&summary.cancelled===0&&summary.skips<=70&&summary.passes+summary.skips===summary.tests,'full regression count mismatch');
+  required(verify.includes('VERIFY-ONLY PIPELINE PASS')&&verify.includes('Artifact isolation gate PASS')&&verify.includes('VERIFIED_TARBALL '),'npm exact-artifact verification incomplete');
+  const line=verify.split(/\r?\n/).find(value=>value.startsWith('VERIFIED_TARBALL '));
+  let artifact;try{artifact=JSON.parse(line.slice('VERIFIED_TARBALL '.length));}catch{fail('tarball evidence malformed');}
+  required(artifact.filename==='deadbyte-mcp-0.15.76.tgz'&&artifact.bytes>0&&artifact.sha256===closure.tarball_sha256&&
+    artifact.integrity===closure.tarball_integrity&&artifact.shasum===closure.tarball_shasum,'tarball identity mismatch');
+  return Object.freeze({status:'R207_RELEASE_READY_EVIDENCE_BOUND',manifest_sha256:closure.manifest_sha256,
+    tarball_sha256:artifact.sha256,tarball_integrity:artifact.integrity,tarball_shasum:artifact.shasum,
+    tests:summary.tests,passes:summary.passes,skips:summary.skips});
+}

package/scripts/r193-owner-request-live.mjs

@@ -1,7 +1,5 @@
 // Protected, fixed-scope request generation after Limited migration.
 import {createHash} from 'node:crypto';
-import {execFile} from 'node:child_process';
-import {promisify} from 'node:util';
 import {lstat,open,readFile} from 'node:fs/promises';
 import path from 'node:path';
 import {fileURLToPath} from 'node:url';
@@ -10,6 +8,10 @@ import {inspectTrustedInstallation} from '../src/privileged-install-trust-r89.mj
 import {parseManifest,verifyManifestTreeExact} from '../src/release-slot.mjs';
 import {createR188OwnerUacRequest} from '../src/r188-owner-uac.mjs';
 import {createR193LiveMachineEpoch} from '../src/r193-live-owner-subject.mjs';
+import {observeCanonicalController} from '../src/r195-canonical-owner-observation.mjs';
+import {ensureOwnerConsentDirectory} from '../src/r207-owner-enrollment-io.mjs';
+import {execFile} from 'node:child_process';
+import {promisify} from 'node:util';
 const execFileAsync=promisify(execFile);
 const THIS=fileURLToPath(import.meta.url),ROOT=path.resolve(path.dirname(THIS),'..');
 const STATE='C:\\Users\\DEADBYTE\\.deadbyte-mcp',RUNTIME=path.win32.join(STATE,'runtime');
@@ -21,6 +23,7 @@ async function main(){
  const manifestPath=path.join(ROOT,'MANIFEST.SHA256');
  await inspectTrustedInstallation(['C:\\Program Files\\nodejs\\node.exe',THIS,manifestPath,
   path.join(ROOT,'src','r188-owner-uac.mjs'),path.join(ROOT,'src','r193-live-owner-subject.mjs'),
+  path.join(ROOT,'src','r195-canonical-owner-observation.mjs'),
   path.join(ROOT,'src','privileged-install-trust-r89.mjs')]);
  const manifestBytes=await bounded(manifestPath,1024*1024);
  await verifyManifestTreeExact(ROOT,parseManifest(manifestBytes.toString('utf8')));
@@ -32,16 +35,14 @@ async function main(){
  if(!coding.roots?.core?.path||!Array.isArray(autonomous.root_ids)||autonomous.root_ids.length!==1||autonomous.root_ids[0]!=='core')
   throw Error('R193 request policy root is not the bounded core project');
  const env={...process.env,DEADBYTE_CONTROLLER_CONFIG:pointer.config_path,DEADBYTE_CONTROLLER_RUNTIME_ROOT:RUNTIME};
- const controller=path.join(ROOT,'controller','deadbyte-controller.ps1');
- const {stdout}=await execFileAsync(PS,['-NoLogo','-NoProfile','-NonInteractive','-ExecutionPolicy','Bypass','-File',controller,'status','-Json'],
-  {env,windowsHide:true,timeout:20000,maxBuffer:1024*1024,encoding:'utf8'});
- const observation=JSON.parse(stdout);
+ const observation=await observeCanonicalController({stateRoot:STATE,powershell:PS,env,execFileAsync});
  if(observation.state!=='ONLINE'||!observation.supervisor?.running)throw Error('R193 request requires ONLINE Limited runtime');
  const machineEpoch=createR193LiveMachineEpoch({activePointer:pointer,controllerObservation:observation});
  const request=createR188OwnerUacRequest({machineEpoch,releaseManifestSha256:sha(manifestBytes),
   codingPolicySha256:sha(codingBytes),autonomousPolicySha256:sha(autonomousBytes),
   rootId:'core',projectRoot:coding.roots.core.path,maxSeconds:600,now:new Date(),expiresInMs:300000});
- const out=path.win32.join(RUNTIME,'owner-consent','r193-request-'+request.request_sha256+'.json');
+ const consentDir=await ensureOwnerConsentDirectory(RUNTIME);
+ const out=path.win32.join(consentDir,'r193-request-'+request.request_sha256+'.json');
  const handle=await open(out,'wx',0o600);try{await handle.writeFile(canonicalJson(request)+'\n');await handle.sync();}finally{await handle.close();}
  process.stdout.write(JSON.stringify({status:'R193_OWNER_REQUEST_CREATED',request_path:out,
   request_sha256:request.request_sha256,review_phrase:request.review_phrase,

package/scripts/r193-owner-uac-broker.mjs

@@ -15,6 +15,8 @@ import {buildR193LiveOwnerBoundary} from '../src/r193-live-owner-subject.mjs';
 import {approveR193OwnerRequest} from '../src/r193-owner-uac-broker.mjs';
 import {createR186OwnerAnchor} from '../src/r186-owner-anchor.mjs';
 import {inspectR193OwnerSecretAcl} from '../src/r193-owner-secret-acl.mjs';
+import {observeCanonicalController} from '../src/r195-canonical-owner-observation.mjs';
+import {parseOwnerEnrollmentJson} from '../src/r207-owner-enrollment-io.mjs';
 
 const execFileAsync=promisify(execFile);
 const THIS=fileURLToPath(import.meta.url),ROOT=path.resolve(path.dirname(THIS),'..');
@@ -61,6 +63,7 @@ async function live(request){
  const protectedFiles=[NODE,THIS,manifestPath,NATIVE,
   path.join(ROOT,'src','r193-live-owner-subject.mjs'),
   path.join(ROOT,'src','r193-owner-uac-broker.mjs'),
+  path.join(ROOT,'src','r195-canonical-owner-observation.mjs'),
   path.join(ROOT,'src','r193-uac-r70-bridge.mjs'),
   path.join(ROOT,'src','r193-owner-secret-acl.mjs'),
   path.join(ROOT,'src','r188-owner-uac.mjs'),
@@ -77,12 +80,10 @@ async function live(request){
  const codingPath=path.win32.join(generation,'coding-policy.json');
  const autonomousPath=path.win32.join(generation,'autonomous-policy.json');
  const configPath=pointer.config_path;
- const controller=path.join(ROOT,'controller','deadbyte-controller.ps1');
  const env={...process.env,DEADBYTE_CONTROLLER_CONFIG:configPath,
   DEADBYTE_CONTROLLER_RUNTIME_ROOT:RUNTIME};
- const observation=await jsonExec(PS,['-NoLogo','-NoProfile','-NonInteractive',
-  '-ExecutionPolicy','Bypass','-File',controller,'status','-Json'],{env});
- const supervisor=JSON.parse((await bounded(path.win32.join(RUNTIME,'supervisor.instance.json'),64*1024)).toString('utf8'));
+ const observation=await observeCanonicalController({stateRoot:STATE,powershell:PS,env,execFileAsync});
+ const supervisor=parseOwnerEnrollmentJson(await bounded(path.win32.join(RUNTIME,'supervisor.instance.json'),64*1024),'supervisor ledger');
  const sources={bridge:observation.bridge,core:observation.core,cloud:observation.cloud,supervisor};
  const processReports={};
  for(const component of ['bridge','core','cloud','supervisor'])
@@ -101,7 +102,7 @@ async function main(){
  if(!['preflight','approve'].includes(mode)||process.argv.slice(2).length!==2||
     !path.win32.isAbsolute(requestPath))block('usage: <preflight|approve> <absolute-request-json>');
  await inspectTrustedInstallation([NODE,THIS,path.join(ROOT,'MANIFEST.SHA256'),NATIVE]);
- const request=JSON.parse((await bounded(requestPath,64*1024)).toString('utf8'));
+ const request=parseOwnerEnrollmentJson(await bounded(requestPath,64*1024),'owner request');
  const state=await live(request);
  if(mode==='preflight'){
   process.stdout.write(JSON.stringify({status:'READY_FOR_OWNER_GESTURE',

package/scripts/r205-candidate-selection.mjs

@@ -0,0 +1,22 @@
+// Read-only bounded stdin candidate comparison. Does not promote, publish, or grant authority.
+import { evaluateCandidateSelectionR205 } from '../src/candidate-selection-r205.mjs';
+
+const MAX_BYTES=64*1024;
+let length=0;
+const parts=[];
+try{
+  for await (const chunk of process.stdin){
+    length+=chunk.length;
+    if(length>MAX_BYTES)throw Error('R205_INPUT_LIMIT_EXCEEDED');
+    parts.push(chunk);
+  }
+  if(length<1)throw Error('R205_INPUT_EMPTY');
+  const raw=Buffer.concat(parts).toString('utf8');
+  const parsed=JSON.parse(raw);
+  const result=evaluateCandidateSelectionR205(parsed);
+  process.stdout.write(JSON.stringify(result)+'\n');
+  if(result.state!=='PROVISIONAL_CANDIDATE')process.exitCode=2;
+}catch(error){
+  process.stderr.write('R205_SELECTION_REFUSED '+String(error?.message??error)+'\n');
+  process.exitCode=3;
+}

package/src/candidate-selection-evidence-r206.mjs

@@ -0,0 +1,71 @@
+import { createHash } from 'node:crypto';
+import { canonicalJson } from './canonical-json.mjs';
+import { evaluateCandidateSelectionR205 } from './candidate-selection-r205.mjs';
+
+const SHA=/^[0-9a-f]{64}$/;
+const sha=value=>createHash('sha256').update(Buffer.from(canonicalJson(value),'utf8')).digest('hex');
+const insist=(condition,message)=>{if(!condition)throw new Error(message);};
+
+function receiptExpectations(input){
+  const expectations=[];
+  const addCorrectness=(label,artifact,value)=>expectations.push({
+    label,kind:'correctness',receipt_sha256:value.receipt_sha256,artifact_sha256:artifact,
+    fixture_sha256:input.fixture_sha256,status:value.status
+  });
+  const addBenchmark=(label,artifact,value)=>expectations.push({
+    label,kind:'benchmark',receipt_sha256:value.receipt_sha256,artifact_sha256:artifact,
+    fixture_sha256:input.fixture_sha256,environment_sha256:input.environment_sha256,
+    samples_sha256:sha(value.samples_ms)
+  });
+  addCorrectness('baseline correctness',input.baseline.artifact_sha256,input.baseline.correctness);
+  addBenchmark('baseline benchmark',input.baseline.artifact_sha256,input.baseline.benchmark);
+  for(const candidate of input.candidates){
+    addCorrectness(`candidate ${candidate.candidate_id} correctness`,candidate.artifact_sha256,candidate.correctness);
+    if(candidate.benchmark)addBenchmark(`candidate ${candidate.candidate_id} benchmark`,candidate.artifact_sha256,candidate.benchmark);
+  }
+  return expectations;
+}
+
+function verifyFact(expected,actual){
+  insist(actual&&typeof actual==='object'&&!Array.isArray(actual),`${expected.label} receipt verification failed`);
+  insist(actual.verified===true&&actual.receipt_sha256===expected.receipt_sha256,
+    `${expected.label} receipt verification failed`);
+  insist(SHA.test(actual.receipt_sha256),`${expected.label} receipt verification failed`);
+  if(expected.kind==='correctness'){
+    insist(actual.evidence_kind==='correctness'&&actual.signer_role==='independent_correctness_oracle'&&
+      actual.artifact_sha256===expected.artifact_sha256&&actual.fixture_sha256===expected.fixture_sha256&&
+      actual.status===expected.status,`${expected.label} receipt binding mismatch`);
+  }else{
+    insist(actual.evidence_kind==='benchmark'&&actual.signer_role==='independent_benchmark_runner'&&
+      actual.artifact_sha256===expected.artifact_sha256&&actual.fixture_sha256===expected.fixture_sha256&&
+      actual.environment_sha256===expected.environment_sha256&&actual.samples_sha256===expected.samples_sha256,
+      `${expected.label} receipt binding mismatch`);
+  }
+  return Object.freeze({receipt_sha256:actual.receipt_sha256,evidence_kind:actual.evidence_kind,
+    signer_role:actual.signer_role,artifact_sha256:actual.artifact_sha256,fixture_sha256:actual.fixture_sha256,
+    ...(expected.kind==='correctness'?{status:actual.status}:{environment_sha256:actual.environment_sha256,
+      samples_sha256:actual.samples_sha256})});
+}
+
+export async function verifyCandidateSelectionEvidenceR206(input,{verifyReceipt}={}){
+  insist(typeof verifyReceipt==='function','independent receipt verifier required');
+  const provisional=evaluateCandidateSelectionR205(input);
+  const expectations=receiptExpectations(input);
+  const seen=new Set();
+  const verified=[];
+  for(const expected of expectations){
+    insist(SHA.test(expected.receipt_sha256),`${expected.label} receipt hash invalid`);
+    insist(!seen.has(expected.receipt_sha256),`${expected.label} receipt reused`);
+    seen.add(expected.receipt_sha256);
+    let actual;
+    try{actual=await verifyReceipt(expected.receipt_sha256,Object.freeze({...expected}));}
+    catch(error){throw new Error(`${expected.label} receipt verification failed: ${error?.message??error}`);}
+    verified.push(verifyFact(expected,actual));
+  }
+  const binding={schema:'deadbyte.candidate-selection-evidence-binding.r206.v1',
+    selection_report_sha256:provisional.report_sha256,verified_receipts:verified};
+  return Object.freeze({...provisional,schema:'deadbyte.candidate-selection-evidence-verdict.r206.v1',
+    evidence_verified:true,verified_receipt_count:verified.length,release_authorized:false,
+    reason:'Independent decision-bearing receipts verified. Candidate selection remains advisory and cannot authorize release.',
+    evidence_binding_sha256:sha(binding)});
+}

package/src/candidate-selection-r205.mjs

@@ -0,0 +1,96 @@
+import { createHash } from 'node:crypto';
+import { canonicalJson } from './canonical-json.mjs';
+
+export const CANDIDATE_SELECTION_SCHEMA='deadbyte.candidate-selection.r205.v1';
+const H=/^[0-9a-f]{64}$/;
+const ID=/^[A-Za-z0-9._-]{1,96}$/;
+const STATES=new Set(['PASS','FAIL','UNKNOWN','INVALID','UNTESTED']);
+const digest=value=>createHash('sha256').update(Buffer.from(canonicalJson(value),'utf8')).digest('hex');
+
+function object(value,label,allowed){
+  if(!value||typeof value!=='object'||Array.isArray(value))throw Error(label+' invalid');
+  const extra=Object.keys(value).filter(k=>!allowed.includes(k));
+  if(extra.length)throw Error(label+' unexpected field '+extra[0]);
+  return value;
+}
+function hash(value,label){if(typeof value!=='string'||!H.test(value))throw Error(label+' invalid');return value;}
+function sample(value,label){
+  if(!Array.isArray(value)||value.length<7||value.length>31||value.some(x=>typeof x!=='number'||!Number.isFinite(x)||x<=0||x>3_600_000))throw Error(label+' invalid');
+  return [...value];
+}
+const median=xs=>{const a=[...xs].sort((x,y)=>x-y);return a[Math.floor(a.length/2)];};
+const mad=xs=>median(xs.map(x=>Math.abs(x-median(xs))));
+function correctness(raw,label,artifact,fixture){
+  const v=object(raw,label,['status','artifact_sha256','fixture_sha256','receipt_sha256']);
+  if(!STATES.has(v.status))throw Error(label+' status invalid');
+  if(hash(v.artifact_sha256,label+' artifact')!==artifact||hash(v.fixture_sha256,label+' fixture')!==fixture)throw Error(label+' evidence identity mismatch');
+  hash(v.receipt_sha256,label+' receipt');
+  return Object.freeze({...v});
+}
+function benchmark(raw,label,artifact,fixture,environment){
+  const v=object(raw,label,['artifact_sha256','fixture_sha256','environment_sha256','receipt_sha256','samples_ms']);
+  if(hash(v.artifact_sha256,label+' artifact')!==artifact||hash(v.fixture_sha256,label+' fixture')!==fixture||hash(v.environment_sha256,label+' environment')!==environment)throw Error(label+' benchmark identity mismatch');
+  hash(v.receipt_sha256,label+' receipt');
+  return Object.freeze({...v,samples_ms:sample(v.samples_ms,label+' samples')});
+}
+function normalize(raw){
+  const v=object(raw,'candidate selection',['schema','fixture_sha256','environment_sha256','baseline','candidates']);
+  if(v.schema!==CANDIDATE_SELECTION_SCHEMA)throw Error('candidate selection schema invalid');
+  const fixture=hash(v.fixture_sha256,'fixture'),env=hash(v.environment_sha256,'environment');
+  const b=object(v.baseline,'baseline',['artifact_sha256','correctness','benchmark']);
+  const baseHash=hash(b.artifact_sha256,'baseline artifact');
+  const baseCorrect=correctness(b.correctness,'baseline correctness',baseHash,fixture);
+  if(baseCorrect.status!=='PASS')throw Error('baseline correctness not PASS');
+  const baseBench=benchmark(b.benchmark,'baseline benchmark',baseHash,fixture,env);
+  if(!Array.isArray(v.candidates)||v.candidates.length<1||v.candidates.length>8)throw Error('candidate count invalid');
+  const seen=new Set([baseHash]),ids=new Set();
+  const candidates=v.candidates.map((item,i)=>{
+    const c=object(item,'candidate '+i,['candidate_id','artifact_sha256','correctness','benchmark']);
+    if(typeof c.candidate_id!=='string'||!ID.test(c.candidate_id)||ids.has(c.candidate_id))throw Error('candidate id invalid or repeated');
+    ids.add(c.candidate_id);
+    const h=hash(c.artifact_sha256,'candidate artifact');
+    if(seen.has(h))throw Error('candidate artifact duplicated');seen.add(h);
+    const result=correctness(c.correctness,'candidate correctness',h,fixture);
+    const bench=c.benchmark===undefined?null:benchmark(c.benchmark,'candidate benchmark',h,fixture,env);
+    if(result.status==='PASS'&&!bench)throw Error('PASS candidate benchmark missing');
+    if(bench&&bench.samples_ms.length!==baseBench.samples_ms.length)throw Error('paired sample length mismatch');
+    return {candidate_id:c.candidate_id,artifact_sha256:h,correctness:result,benchmark:bench};
+  });
+  return {fixture,environment:env,baseline:{artifact_sha256:baseHash,correctness:baseCorrect,benchmark:baseBench},candidates};
+}
+export function buildBlindCandidateViewR205(input){
+  const v=normalize(input);
+  return Object.freeze({schema:CANDIDATE_SELECTION_SCHEMA,fixture_sha256:v.fixture,environment_sha256:v.environment,
+    baseline:{artifact_sha256:v.baseline.artifact_sha256,correctness:v.baseline.correctness,benchmark:v.baseline.benchmark},
+    candidates:v.candidates.map(c=>({artifact_sha256:c.artifact_sha256,correctness:c.correctness,benchmark:c.benchmark}))
+      .sort((a,b)=>a.artifact_sha256.localeCompare(b.artifact_sha256))});
+}
+export function evaluateCandidateSelectionR205(input,{minimum_gain_pct=5,minimum_win_rate=0.8,max_mad_pct=8,ambiguity_margin_pct=3}={}){
+  for(const [name,v,max] of [['minimum_gain_pct',minimum_gain_pct,100],['minimum_win_rate',minimum_win_rate,1],['max_mad_pct',max_mad_pct,100],['ambiguity_margin_pct',ambiguity_margin_pct,100]]){
+    if(typeof v!=='number'||!Number.isFinite(v)||v<0||v>max)throw Error(name+' invalid');
+  }
+  const parsed=normalize(input);
+  const baseline=parsed.baseline.benchmark.samples_ms;
+  const classified=parsed.candidates.map(c=>{
+    if(c.correctness.status!=='PASS')return {candidate_id:c.candidate_id,artifact_sha256:c.artifact_sha256,verdict:c.correctness.status==='FAIL'?'REJECT_CORRECTNESS':'UNGRADED',correctness_status:c.correctness.status};
+    const changes=c.benchmark.samples_ms.map((time,i)=>100*(baseline[i]-time)/baseline[i]);
+    const gain=median(changes),deviation=mad(changes),wins=changes.filter(x=>x>0).length;
+    const winRate=wins/changes.length;
+    const eligible=gain>=minimum_gain_pct&&winRate>=minimum_win_rate&&deviation<=max_mad_pct;
+    return {candidate_id:c.candidate_id,artifact_sha256:c.artifact_sha256,verdict:eligible?'PERFORMANCE_QUALIFIED':'REJECT_PERFORMANCE',
+      correctness_status:'PASS',median_gain_pct:Number(gain.toFixed(4)),mad_pct:Number(deviation.toFixed(4)),
+      win_rate:Number(winRate.toFixed(4)),sample_count:changes.length};
+  });
+  const ranked=classified.filter(x=>x.verdict==='PERFORMANCE_QUALIFIED').sort((a,b)=>b.median_gain_pct-a.median_gain_pct||a.artifact_sha256.localeCompare(b.artifact_sha256));
+  const ambiguous=ranked.length>1&&ranked[0].median_gain_pct-ranked[1].median_gain_pct<ambiguity_margin_pct;
+  const winner=ranked.length&&!ambiguous?ranked[0]:null;
+  const report={schema:'deadbyte.candidate-selection-verdict.r205.v1',
+    state:ambiguous?'AMBIGUOUS':winner?'PROVISIONAL_CANDIDATE':'NO_QUALIFIED_CANDIDATE',
+    winner_candidate_id:winner?.candidate_id??null,winner_artifact_sha256:winner?.artifact_sha256??null,
+    evidence_verified:false,release_authorized:false,
+    reason:'Claims and receipt hashes are syntax/identity checked only. Signed receipts, independent oracle and benchmark runner must be verified externally before promotion.',
+    fixture_sha256:parsed.fixture,environment_sha256:parsed.environment,baseline_artifact_sha256:parsed.baseline.artifact_sha256,
+    candidates:classified.sort((a,b)=>a.artifact_sha256.localeCompare(b.artifact_sha256)),
+    blind_evaluation_sha256:digest(buildBlindCandidateViewR205(input))};
+  return Object.freeze({...report,report_sha256:digest(report)});
+}

package/src/desktop-postcondition-r196.mjs

@@ -0,0 +1,30 @@
+const SHA256=/^[0-9a-f]{64}$/;
+
+export function validateDesktopPostconditionExpectation(expectation){
+ if(expectation===null)return null;
+ if(!expectation||typeof expectation!=='object'||Array.isArray(expectation)||
+    Object.keys(expectation).sort().join(',')!=='expected_sha256,kind'||
+    expectation.kind!=='frame_image_sha256'||!SHA256.test(expectation.expected_sha256??''))
+  throw new Error('R196 unsupported desktop postcondition expectation');
+ return Object.freeze({kind:expectation.kind,expected_sha256:expectation.expected_sha256});
+}
+
+// An input injection receipt is not evidence that the application accepted it.
+// This verifier only establishes the explicit observable postcondition.
+export function evaluateDesktopPostcondition({expectation=null,beforeFrame,afterFrame}={}){
+ if(!beforeFrame||!afterFrame||!SHA256.test(beforeFrame.image_sha256??'')||
+    !SHA256.test(afterFrame.image_sha256??'')||!SHA256.test(beforeFrame.frame_id??'')||
+    !SHA256.test(afterFrame.frame_id??''))throw new Error('R196 desktop frames invalid');
+ const base={schema:'deadbyte.desktop-postcondition.v1',
+  before_frame_id:beforeFrame.frame_id,after_frame_id:afterFrame.frame_id,
+  before_image_sha256:beforeFrame.image_sha256,after_image_sha256:afterFrame.image_sha256};
+ if(expectation===null)return Object.freeze({...base,status:'unknown',reason:'no_explicit_expectation',kind:null,expected_sha256:null});
+ const verified=validateDesktopPostconditionExpectation(expectation);
+ const expected=verified.expected_sha256;
+ if(beforeFrame.image_sha256===expected)
+  return Object.freeze({...base,status:'unknown',reason:'expected_state_already_present_before_action',
+   kind:expectation.kind,expected_sha256:expected});
+ return Object.freeze({...base,status:afterFrame.image_sha256===expected?'satisfied':'unsatisfied',
+  reason:afterFrame.image_sha256===expected?'exact_post_image_observed':'post_image_differs_from_expected',
+  kind:expectation.kind,expected_sha256:expected});
+}

package/src/desktop-runtime-r40.mjs

@@ -4,6 +4,8 @@ import path from 'node:path';
 import { canonicalJson } from './canonical-json.mjs';
 import { createDesktopAction,createDesktopTarget,guardDesktopAction,bindDesktopPostObservation,bindDesktopActionChain } from './desktop-contract.mjs';
 import { effectIdentity,bindEffectCompletion } from './effect-ledger.mjs';
+import { evaluateDesktopPostcondition,validateDesktopPostconditionExpectation } from './desktop-postcondition-r196.mjs';
+import { bindUiaElementR199,assertFreshUiaElementR199 } from './desktop-uia-identity-r199.mjs';
 import { DESKTOP_ACTION_KINDS,DESKTOP_POLICY_SCHEMA,assertDesktopArmed,desktopSessionStatus } from './desktop-policy-r40.mjs';
 
 export const DESKTOP_RECEIPT_SCHEMA='deadbyte.desktop-receipt.v1';
@@ -82,6 +84,8 @@ export function createDesktopRuntime({
   insist(Number.isInteger(maxTargets)&&maxTargets>=1&&maxTargets<=1024,'maxTargets invalid');
   const receiptPublicKey=publicKey??createPublicKey(privateKey);
   const targets=new Map();
+  const groundedTargets=new Set();
+  const uiaBindings=new Map();
 
   async function receipt(kind,payload,stamp=now()){
     return writeReceipt({policy,privateKey,keyId,evidenceDir,kind,payload,nowUtc:stamp});
@@ -193,15 +197,29 @@ export function createDesktopRuntime({
     const confidence=grounded.query_kind==='name_contains'?0.98:1;
     const created=createDesktopTarget({
       frame:fresh.frame,rect:candidate.rect,source:'uia',confidence,
-      semanticLabelSha256:grounded.query_sha256,windowBinding:fresh.frame.active_window
+      // Hash the ephemeral native identity into the target handle to prevent
+      // old and new elements at identical coordinates sharing one target_id.
+      semanticLabelSha256:Array.isArray(candidate.runtime_id)&&candidate.runtime_id.length>0
+        ?sha256Object({query_sha256:grounded.query_sha256,runtime_id:candidate.runtime_id})
+        :grounded.query_sha256,
+      windowBinding:fresh.frame.active_window
     });
     targets.set(created.target_id,created);
-    while(targets.size>maxTargets)targets.delete(targets.keys().next().value);
+    groundedTargets.add(created.target_id);
+    if(candidate.runtime_id!==null&&candidate.runtime_id!==undefined){
+      const binding=bindUiaElementR199({frame:fresh.frame,grounded,candidate,query});
+      uiaBindings.set(created.target_id,binding);
+    }
+    while(targets.size>maxTargets){
+      const removed=targets.keys().next().value;
+      targets.delete(removed);groundedTargets.delete(removed);uiaBindings.delete(removed);
+    }
     const evidence=await receipt('desktop_grounding',{
       requested_frame_id:expected.frame_id,grounded_frame_id:fresh.frame.frame_id,
       target_id:created.target_id,query_sha256:grounded.query_sha256,query_kind:grounded.query_kind,
       ordinal:grounded.ordinal,match_count:grounded.matches.length,visited:grounded.visited,truncated:grounded.truncated,
-      provider_receipt_sha256:grounded.provider_receipt_sha256,control_type:candidate.control_type
+      provider_receipt_sha256:grounded.provider_receipt_sha256,control_type:candidate.control_type,
+      element_token_sha256:uiaBindings.get(created.target_id)?.token_sha256??null
     },fresh.frame.observed_at_utc);
     return Object.freeze({
       status:'ok',frame:fresh.frame,target:created,
@@ -209,15 +227,18 @@ export function createDesktopRuntime({
         query_sha256:grounded.query_sha256,query_kind:grounded.query_kind,ordinal:grounded.ordinal,
         match_count:grounded.matches.length,visited:grounded.visited,truncated:grounded.truncated,
         control_type:candidate.control_type,provider_receipt_sha256:grounded.provider_receipt_sha256,
+        element_token_sha256:uiaBindings.get(created.target_id)?.token_sha256??null,
         receipt_id:evidence.receipt_id,receipt_sha256:evidence.receipt_sha256
       })
     });
   }
   async function action({
     intentId,kind,expectedFrameId,targetId=null,expectedWindow=undefined,point=null,
-    scrollDelta=null,keyChord=null,text=null,effectContext=null
+    scrollDelta=null,keyChord=null,text=null,effectContext=null,expectedPostcondition=null
   }={}){
     insist(DESKTOP_ACTION_KINDS.includes(kind),'desktop action kind invalid');
+    const postconditionExpectation=validateDesktopPostconditionExpectation(expectedPostcondition);
+    const expectedPostconditionSha256=postconditionExpectation?sha256Object(postconditionExpectation):null;
     const authority=await assertDesktopArmed(policy,kind);
     if(kind==='text_input'){
       insist(typeof text==='string','desktop text input invalid');
@@ -243,6 +264,15 @@ export function createDesktopRuntime({
     // bind it to the same fresh desktop/topology/foreground identity and let the native helper
     // revalidate HWND/PID immediately before SendInput instead of requiring unrelated pixels to freeze.
     if(kind!=='key_chord') insist(pre.frame.image_sha256===expected.image_sha256,'desktop pixels changed before action');
+    // Before any injection, reacquire the same UIA element through a fresh
+    // query bound to the current foreground window and runtime identity.
+    if(chosenTarget&&groundedTargets.has(chosenTarget.target_id)){
+      const identity=uiaBindings.get(chosenTarget.target_id);
+      insist(identity,'R199 UIA target has no RuntimeId binding and is not actionable');
+      insist(typeof grounderProvider==='function','R199 UIA re-ground provider unavailable');
+      const refreshed=await grounderProvider({frame:pre.frame,query:identity.query});
+      assertFreshUiaElementR199(identity,refreshed);
+    }
 
     let actionPoint=point;
     if(chosenTarget&&['pointer_move','click_primary','click_secondary','double_click_primary','scroll'].includes(kind)){
@@ -260,7 +290,8 @@ export function createDesktopRuntime({
     const effectAction=Object.freeze({
       kind:`desktop_${kind}`,action_sha256:actionObject.action_sha256,frame_id:pre.frame.frame_id,
       target_id:actionObject.target_id,point:actionObject.point,scroll_delta:actionObject.scroll_delta,
-      key_chord:actionObject.key_chord,text_sha256:actionObject.text_sha256
+      key_chord:actionObject.key_chord,text_sha256:actionObject.text_sha256,
+      ...(expectedPostconditionSha256?{expected_postcondition_sha256:expectedPostconditionSha256}:{})
     });
     const ctx=effectContext??{};
     const effectLedger=effectIdentity({
@@ -272,7 +303,8 @@ export function createDesktopRuntime({
       intent_id:intentId,kind,expected_frame_id:expected.frame_id,pre_frame_id:pre.frame.frame_id,
       target_id:chosenTarget?.target_id??null,action_sha256:actionObject.action_sha256,
       guard_sha256:guarded.guard_sha256,authority_instance_nonce:authority.instance_nonce,
-      effect_id:effectLedger.effect_id,effect_fingerprint:effectLedger.fingerprint
+      effect_id:effectLedger.effect_id,effect_fingerprint:effectLedger.fingerprint,
+      expected_postcondition_sha256:expectedPostconditionSha256
     });
 
     let effect;
@@ -303,6 +335,9 @@ export function createDesktopRuntime({
     try{
       const post=await observerRuntime.capture();
       const bound=bindDesktopPostObservation({guard:guarded,beforeFrame:pre.frame,action:actionObject,afterFrame:post.frame});
+      const postcondition=evaluateDesktopPostcondition({expectation:postconditionExpectation,
+        beforeFrame:pre.frame,afterFrame:post.frame});
+      const postconditionSha256=sha256Object(postcondition);
       const postEvidence=await receipt('desktop_post_observation',{
         started_receipt_id:started.receipt_id,started_receipt_sha256:started.receipt_sha256,
         effect_id:effectLedger.effect_id,effect_fingerprint:effectLedger.fingerprint,
@@ -329,11 +364,13 @@ export function createDesktopRuntime({
         action_sha256:actionObject.action_sha256,guard_sha256:guarded.guard_sha256,
         effect_id:effectLedger.effect_id,effect_fingerprint:effectLedger.fingerprint,effect_completion:effectCompletion,
         effect:{injected:true,side_effect_state:'confirmed_injected',provider_receipt_sha256:HEX64.test(effect.provider_receipt_sha256??'')?effect.provider_receipt_sha256:null},
-        action_chain:chain,post_observation:bound
+        action_chain:chain,post_observation:bound,
+        postcondition,postcondition_sha256:postconditionSha256
       },post.frame.observed_at_utc);
       return Object.freeze({
         status:'ok',injected:true,task_success:null,side_effect_state:'confirmed_injected',
         action:actionObject,guard:guarded,post_observation:bound,action_chain:chain,
+        postcondition,postcondition_sha256:postconditionSha256,
         effect_id:effectLedger.effect_id,effect_fingerprint:effectLedger.fingerprint,effect_completion:effectCompletion,
         started_receipt_id:started.receipt_id,started_receipt_sha256:started.receipt_sha256,
         post_receipt_id:postEvidence.receipt_id,post_receipt_sha256:postEvidence.receipt_sha256,