deadbyte-mcp 0.11.3 → 0.12.0

package/scripts/init-desktop-policy-r40.ps1

@@ -0,0 +1,79 @@
+[CmdletBinding()]
+param(
+    [string]$RuntimeRoot = '',
+    [string]$OutputPath = '',
+    [string[]]$AllowedActions = @('pointer_move','click_primary','click_secondary','double_click_primary','scroll','key_chord','text_input')
+)
+$ErrorActionPreference='Stop'
+Set-StrictMode -Version Latest
+
+$Root=Split-Path -Parent $PSScriptRoot
+$Controller=Join-Path $Root 'controller'
+if([string]::IsNullOrWhiteSpace($RuntimeRoot)){ $RuntimeRoot=Join-Path $Controller 'runtime' }
+if([string]::IsNullOrWhiteSpace($OutputPath)){ $OutputPath=Join-Path $Controller 'deadbyte-desktop-policy.json' }
+$RuntimeRoot=[System.IO.Path]::GetFullPath($RuntimeRoot)
+$OutputPath=[System.IO.Path]::GetFullPath($OutputPath)
+$Observer=[System.IO.Path]::GetFullPath((Join-Path $Root 'bin\deadbyte-desktop-observer-r40.exe'))
+$Input=[System.IO.Path]::GetFullPath((Join-Path $Root 'bin\deadbyte-desktop-input-r40.exe'))
+$Grounder=[System.IO.Path]::GetFullPath((Join-Path $Root 'bin\deadbyte-desktop-uia-r40.exe'))
+if(-not (Test-Path -LiteralPath $Observer -PathType Leaf)){throw "observer binary missing: $Observer"}
+if(-not (Test-Path -LiteralPath $Input -PathType Leaf)){throw "input binary missing: $Input"}
+if(-not (Test-Path -LiteralPath $Grounder -PathType Leaf)){throw "UIA grounder binary missing: $Grounder"}
+$Known=@('pointer_move','click_primary','click_secondary','double_click_primary','scroll','key_chord','text_input')
+if($AllowedActions.Count -lt 1){throw 'AllowedActions cannot be empty'}
+$Unique=@($AllowedActions | Sort-Object -Unique)
+if($Unique.Count -ne $AllowedActions.Count -or @($AllowedActions | Where-Object { $_ -notin $Known }).Count -gt 0){throw 'AllowedActions invalid'}
+New-Item -ItemType Directory -Force -Path $RuntimeRoot | Out-Null
+$Evidence=Join-Path $RuntimeRoot 'desktop-evidence'
+New-Item -ItemType Directory -Force -Path $Evidence | Out-Null
+$Grant=Join-Path $RuntimeRoot 'desktop-grant.json'
+Remove-Item -LiteralPath $Grant -Force -ErrorAction SilentlyContinue
+$Policy=[ordered]@{
+    schema='deadbyte.desktop-policy.v1'
+    enabled=$true
+    grant_file=$Grant
+    evidence_dir=$Evidence
+    observer=[ordered]@{
+        executable=$Observer
+        sha256=(Get-FileHash -LiteralPath $Observer -Algorithm SHA256).Hash.ToLowerInvariant()
+        backend='gdi-bitblt-fallback'
+    }
+    input=[ordered]@{
+        executable=$Input
+        sha256=(Get-FileHash -LiteralPath $Input -Algorithm SHA256).Hash.ToLowerInvariant()
+    }
+    grounder=[ordered]@{
+        executable=$Grounder
+        sha256=(Get-FileHash -LiteralPath $Grounder -Algorithm SHA256).Hash.ToLowerInvariant()
+    }
+    allowed_input_desktops=@('Default')
+    allowed_actions=@($AllowedActions)
+    limits=[ordered]@{
+        max_frame_age_ms=2000
+        max_frame_bytes=134217728
+        capture_timeout_ms=10000
+        input_timeout_ms=5000
+        ground_timeout_ms=5000
+        post_observe_timeout_ms=10000
+        max_preview_bytes=1048576
+        max_text_bytes=4096
+    }
+}
+$Parent=Split-Path -Parent $OutputPath
+New-Item -ItemType Directory -Force -Path $Parent | Out-Null
+$Json=$Policy | ConvertTo-Json -Depth 8
+$Utf8=New-Object System.Text.UTF8Encoding($false)
+$Tmp=$OutputPath+'.tmp'
+[System.IO.File]::WriteAllText($Tmp,$Json,$Utf8)
+Move-Item -LiteralPath $Tmp -Destination $OutputPath -Force
+[pscustomobject]@{
+    status='created'
+    policy_path=$OutputPath
+    policy_sha256=(Get-FileHash -LiteralPath $OutputPath -Algorithm SHA256).Hash.ToLowerInvariant()
+    observer_sha256=$Policy.observer.sha256
+    input_sha256=$Policy.input.sha256
+    grounder_sha256=$Policy.grounder.sha256
+    grant_file=$Grant
+    grant_state='DISARMED'
+    action_kinds=@($AllowedActions)
+}|ConvertTo-Json -Depth 6

package/scripts/r40-compact-ledger-probe.mjs

@@ -0,0 +1,4 @@
+import { R36_CAPABILITY_LEDGER } from '../src/capability-ledger.mjs';
+const names=new Set(['capability_manifest']);
+for(const item of R36_CAPABILITY_LEDGER.entries) if(item.compact_tool) names.add(item.compact_tool);
+console.log(JSON.stringify({count:names.size,names:[...names].sort(),ledger_sha256:R36_CAPABILITY_LEDGER.ledger_sha256},null,2));

package/scripts/release-parity-r40.mjs

@@ -0,0 +1,212 @@
+import { createHash } from 'node:crypto';
+import { mkdir, readFile, realpath, writeFile } from 'node:fs/promises';
+import { loadPowerShellDataFile } from '../src/runtime-update.mjs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { probeR40FullSurface } from '../src/r40-full-surface-probe.mjs';
+import { runR40CompactParity } from '../src/remote-mcp-r40-parity-client.mjs';
+import { probeR40CompactDisarmed } from '../src/r40-compact-disarmed-probe.mjs';
+import { probeR36CompactDisarmed } from '../src/r36-compact-disarmed-probe.mjs';
+import { runR40DesktopGuardedSmoke } from '../src/remote-mcp-desktop-r40-smoke-client.mjs';
+
+const here=path.dirname(fileURLToPath(import.meta.url));
+const root=path.resolve(here,'..');
+const stateRoot=path.resolve(process.env.DEADBYTE_STATE_ROOT||path.join(os.homedir(),'.deadbyte-mcp'));
+const deferred=path.join(root,'scripts','deferred-slot-operation-r40.mjs');
+const ps='C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe';
+const launcher=path.join(stateRoot,'bin','DEADBYTE-MCP.ps1');
+const sleep=ms=>new Promise(resolve=>setTimeout(resolve,ms));
+const sha256=bytes=>createHash('sha256').update(bytes).digest('hex');
+
+export const R40_PREDECESSOR_RELEASE_ID='v0.11.3-ce761dd6e014d42e';
+export const R40_PREDECESSOR_MANIFEST='ce761dd6e014d42eddb635855038e0ce049c63c6e3af7e63c3005bbe198bcf7b';
+
+function assert(condition,message){if(!condition) throw new Error(message);}
+function parseFrozenManifest(text){
+  const entries=[];const seen=new Set();
+  for(const [index,line] of text.split(/\r?\n/).entries()){
+    if(!line) continue;
+    const match=/^([0-9a-f]{64})  ([^\0]+)$/.exec(line);
+    assert(match,`frozen manifest line ${index+1} malformed`);
+    const rel=match[2];
+    assert(!path.posix.isAbsolute(rel)&&!rel.split('/').includes('..')&&!seen.has(rel),`unsafe/duplicate frozen manifest path: ${rel}`);
+    seen.add(rel);entries.push({sha256:match[1],path:rel});
+  }
+  return entries;
+}
+// Restore the mutable development stage from the immutable active release after live parity work may drift it.
+export async function restoreFrozenStage({developmentRoot,releaseRoot,expectedManifestSha256}){
+  const dev=path.resolve(developmentRoot);const release=path.resolve(releaseRoot);
+  const manifestBytes=await readFile(path.join(release,'MANIFEST.SHA256'));
+  const manifestSha256=sha256(manifestBytes);
+  assert(manifestSha256===expectedManifestSha256,`immutable release manifest drift: ${manifestSha256}`);
+  const entries=parseFrozenManifest(manifestBytes.toString('utf8'));
+  for(const entry of entries){
+    const source=path.join(release,...entry.path.split('/'));const bytes=await readFile(source);
+    assert(sha256(bytes)===entry.sha256,`immutable release file drift: ${entry.path}`);
+    const destination=path.join(dev,...entry.path.split('/'));await mkdir(path.dirname(destination),{recursive:true});
+    await writeFile(destination,bytes);assert(sha256(await readFile(destination))===entry.sha256,`development restore verification failed: ${entry.path}`);
+  }
+  await writeFile(path.join(dev,'MANIFEST.SHA256'),manifestBytes);
+  assert(sha256(await readFile(path.join(dev,'MANIFEST.SHA256')))===expectedManifestSha256,'development manifest restore verification failed');
+  return {status:'restored',file_count:entries.length,manifest_sha256:manifestSha256};
+}
+function parseJsonOutput(text,label){
+  const trimmed=String(text).trim();const starts=[...trimmed.matchAll(/\{/g)].map(match=>match.index);
+  for(const start of starts){try{return JSON.parse(trimmed.slice(start));}catch{}}
+  throw new Error(`${label} did not emit JSON`);
+}
+function run(command,args,{timeoutMs=900000,env=process.env,cwd=root}={}){
+  return new Promise((resolve,reject)=>{
+    const child=spawn(command,args,{cwd,shell:false,windowsHide:true,env,stdio:['ignore','pipe','pipe']});
+    const out=[],err=[];const timer=setTimeout(()=>{child.kill();reject(new Error(`command timeout: ${path.basename(command)}`));},timeoutMs);
+    child.stdout.on('data',chunk=>out.push(Buffer.from(chunk)));child.stderr.on('data',chunk=>err.push(Buffer.from(chunk)));
+    child.on('error',error=>{clearTimeout(timer);reject(error);});child.on('exit',code=>{
+      clearTimeout(timer);const stdout=Buffer.concat(out).toString('utf8');const stderr=Buffer.concat(err).toString('utf8');
+      if(code!==0) reject(new Error(`command failed exit=${code}: ${stderr||stdout}`));else resolve({stdout,stderr,exitCode:code});
+    });
+  });
+}
+async function publicUrl(){
+  const value=(await readFile(path.join(stateRoot,'bridge','mcp-url.txt'),'utf8')).trim();const url=new URL(value);
+  if(url.protocol!=='https:') throw new Error('public MCP URL must be HTTPS');return value;
+}
+async function pointer(){return JSON.parse(await readFile(path.join(stateRoot,'active-release.json'),'utf8'));}
+async function disarmAll(){
+  for(const command of ['disarmdesktop','disarmautonomous','disarmcoding','disarmprocess','disarmhost']){
+    await run(ps,['-NoLogo','-NoProfile','-ExecutionPolicy','Bypass','-File',launcher,command],{timeoutMs:60000});
+  }
+}
+async function waitDeferred(statePath,timeoutMs=180000){
+  const deadline=Date.now()+timeoutMs;
+  while(Date.now()<deadline){const state=JSON.parse(await readFile(statePath,'utf8'));if(state.state==='completed') return state;if(state.state==='failed') throw new Error(`deferred ${state.mode} failed: ${state.error}`);await sleep(500);}
+  throw new Error(`deferred operation timeout: ${statePath}`);
+}
+async function scheduleDeferred(mode,value,{bridgeRoot=null,bridgeScriptSha256=null}={}){
+  if((bridgeRoot===null)!==(bridgeScriptSha256===null)) throw new Error('deferred bridge override requires exact root + SHA pair');
+  const args=[deferred,mode,value];
+  if(bridgeRoot!==null) args.push('--bridge-root',bridgeRoot,'--bridge-script-sha256',bridgeScriptSha256);
+  const scheduled=parseJsonOutput((await run(process.execPath,args,{timeoutMs:30000})).stdout,`deferred ${mode}`);
+  assert(scheduled.status==='scheduled',`deferred ${mode} was not scheduled`);
+  assert(scheduled.execution_provider==='deadbyte_mcp'&&scheduled.rdc_operation_count===0,'deferred operation provider mismatch');
+  return {scheduled,completed:await waitDeferred(scheduled.state_path)};
+}
+async function publicR40PredecessorDisarmed(url){
+  const result=await probeR36CompactDisarmed(url);
+  assert(result.status==='passed'&&result.tool_count<=42&&result.capability_closure===true,'R40 predecessor public compact catalog mismatch');
+  assert(result.release_id===R40_PREDECESSOR_RELEASE_ID&&result.release_manifest_sha256===R40_PREDECESSOR_MANIFEST,'R40 predecessor machine binding mismatch');
+  assert(result.coding_armed===false&&result.autonomous_armed===false,'R40 predecessor authority remained armed');
+  return result;
+}
+async function mutableCore(pointerValue){
+  const policy=JSON.parse(await readFile(path.join(pointerValue.generation_root,'coding-policy.json'),'utf8'));
+  const raw=policy?.roots?.core?.path??policy?.roots?.core?.real_path;
+  assert(typeof raw==='string'&&raw,'R40 generation missing coding core root');
+  const core=path.resolve(raw);const release=path.resolve(pointerValue.release_root);
+  assert(core.toLowerCase()!==release.toLowerCase(),'R40 coding core must not point at immutable active release slot');
+  return core;
+}
+
+export function validateParityEvidence(value){
+  assert(value?.schema==='deadbyte.r40-parity.v1','R40 parity schema mismatch');
+  assert(value.status==='passed','R40 parity status is not passed');
+  assert(value.rdc_operation_count===0&&value.execution_provider==='deadbyte_mcp','R40 parity used non-DEADBYTE execution');
+  assert(value.candidate?.version==='0.12.0'&&/^[0-9a-f]{64}$/.test(value.candidate?.manifest_sha256??''),'R40 candidate identity missing');
+  assert(value.local_full?.status==='passed'&&value.local_full?.tool_count===80&&value.local_full?.strict_output_schemas===true,'R40 local full 80-tool proof missing');
+  assert(value.public_compact?.status==='passed'&&value.public_compact?.tool_count===42&&value.public_compact?.capability_closure===true&&value.public_compact?.gateway_count===6&&value.public_compact?.desktop_armed===false&&value.public_compact?.desktop_observation_receipt_verified===true&&value.public_compact?.desktop_grounding_receipt_verified===true,'R40 public compact/Desktop closure missing');
+  assert(value.desktop_guarded?.status==='passed'&&value.desktop_guarded?.native_injected===true&&value.desktop_guarded?.replay_performed===false&&
+    Number.isInteger(value.desktop_guarded?.predispatch_retry_count)&&value.desktop_guarded.predispatch_retry_count>=0&&value.desktop_guarded.predispatch_retry_count<=2&&
+    value.desktop_guarded?.observation_receipts_verified===value.desktop_guarded.predispatch_retry_count+1&&value.desktop_guarded?.action_receipts_verified===3,
+    'R40 guarded Desktop proof missing');
+  assert(value.autonomous?.status==='passed'&&value.autonomous?.signed_release_verified===true,'R40 autonomous live proof missing');
+  assert(value.before_rollback_disarmed?.status==='passed'&&value.before_rollback_disarmed?.capability_closure===true&&value.before_rollback_disarmed?.coding_armed===false&&value.before_rollback_disarmed?.autonomous_armed===false&&value.before_rollback_disarmed?.desktop_armed===false,'R40 pre-rollback disarm proof missing');
+  assert(value.rollback?.state==='completed'&&value.restore?.state==='completed','R40 rollback/restore not completed');
+  assert(value.stage_restore?.status==='restored'&&value.stage_restore?.manifest_sha256===value.candidate.manifest_sha256,'R40 stage restore proof missing');
+  assert(value.predecessor?.release_id===R40_PREDECESSOR_RELEASE_ID&&value.predecessor?.manifest_sha256===R40_PREDECESSOR_MANIFEST&&value.predecessor?.version==='0.11.3','R40 exact predecessor identity mismatch');
+  assert(value.predecessor_disarmed?.status==='passed'&&value.predecessor_disarmed?.tool_count<=42&&value.predecessor_disarmed?.capability_closure===true,'R40 predecessor public proof missing');
+  assert(value.successor?.version==='0.12.0'&&value.successor?.manifest_sha256===value.candidate.manifest_sha256,'R40 exact successor restore identity mismatch');
+  assert(value.successor_disarmed?.status==='passed'&&value.successor_disarmed?.capability_closure===true&&value.successor_disarmed?.coding_armed===false&&value.successor_disarmed?.autonomous_armed===false&&value.successor_disarmed?.desktop_armed===false,'R40 successor disarmed proof missing');
+  assert(value.immutable_slot?.protected===true&&value.immutable_slot?.development_root!==value.immutable_slot?.release_root,'R40 immutable-slot separation missing');
+  for(const key of ['tree_read','precondition_mutation','search','owned_process','observation','coding_loop','autonomy','interrupted_recovery','evidence_verification','compact_closure','full_surface','desktop_readonly','desktop_guarded_input']) assert(value.requirements?.[key]===true,`R40 parity requirement not proven: ${key}`);
+  return true;
+}
+
+export async function runReleaseParity(activationReceiptPath){
+  const active=await pointer();const candidateManifest=sha256(await readFile(path.join(root,'MANIFEST.SHA256')));
+  assert(active.version==='0.12.0','R40 parity requires active 0.12.0 candidate');
+  assert(active.manifest_sha256===candidateManifest,'active release is not canonical R40 candidate');
+  const activeConfig=await loadPowerShellDataFile(active.config_path);
+  const successorBridgeRootRaw=activeConfig?.Bridge?.WorkingDirectory;
+  const successorBridgeConfiguredSha=activeConfig?.Bridge?.ScriptSha256;
+  assert(typeof successorBridgeRootRaw==='string'&&path.isAbsolute(successorBridgeRootRaw),'R40 active bridge root missing');
+  assert(typeof successorBridgeConfiguredSha==='string'&&/^[0-9a-f]{64}$/.test(successorBridgeConfiguredSha),'R40 active bridge SHA missing');
+  const successorBridgeRoot=await realpath(path.resolve(successorBridgeRootRaw));
+  const successorBridgeActualSha=sha256(await readFile(path.join(successorBridgeRoot,'src','bridge.mjs')));
+  assert(successorBridgeActualSha===successorBridgeConfiguredSha,'R40 active bridge bytes do not match generation pin');
+  const successorBridge={root:successorBridgeRoot,sha256:successorBridgeActualSha};
+  const developmentRoot=await mutableCore(active);
+  const localFull=await probeR40FullSurface({packageRoot:active.release_root,generationRoot:active.generation_root,stateRoot});
+  const url=await publicUrl();
+  let publicCompact,autonomous,desktopGuarded;
+  try{
+    publicCompact=await runR40CompactParity(url);
+    autonomous=parseJsonOutput((await run(process.execPath,[path.join(root,'src','remote-mcp-autonomous-smoke-client.mjs'),url],{timeoutMs:900000})).stdout,'R40 autonomous compact parity');
+    assert(autonomous.status==='passed'&&autonomous.signed_release_verified===true,'R40 autonomous compact parity failed');
+    await run(ps,['-NoLogo','-NoProfile','-ExecutionPolicy','Bypass','-File',launcher,'armdesktop'],{timeoutMs:60000});
+    try{desktopGuarded=await runR40DesktopGuardedSmoke(url);}
+    finally{await run(ps,['-NoLogo','-NoProfile','-ExecutionPolicy','Bypass','-File',launcher,'disarmdesktop'],{timeoutMs:60000}).catch(()=>{});}
+    assert(desktopGuarded.status==='passed'&&desktopGuarded.native_injected===true&&desktopGuarded.action_receipts_verified===3,'R40 guarded Desktop public smoke failed');
+  }catch(error){await disarmAll().catch(()=>{});throw error;}
+
+  await disarmAll();
+  const beforeRollback=await probeR40CompactDisarmed(url);
+  const rollbackPair=await scheduleDeferred('rollback',path.resolve(activationReceiptPath));
+  const predecessor=await pointer();
+  assert(predecessor.release_id===R40_PREDECESSOR_RELEASE_ID&&predecessor.manifest_sha256===R40_PREDECESSOR_MANIFEST&&predecessor.version==='0.11.3','rollback did not reach exact sealed R40 predecessor');
+  const predecessorDisarmed=await publicR40PredecessorDisarmed(url);
+  const stageRestore=await restoreFrozenStage({developmentRoot,releaseRoot:active.release_root,expectedManifestSha256:candidateManifest});
+  const restorePair=await scheduleDeferred('activate',candidateManifest,{bridgeRoot:successorBridge.root,bridgeScriptSha256:successorBridge.sha256});
+  const successor=await pointer();
+  assert(successor.version==='0.12.0'&&successor.manifest_sha256===candidateManifest,'restore did not return exact R40 candidate');
+  const successorDisarmed=await probeR40CompactDisarmed(url);
+  await disarmAll();
+
+  const evidence={
+    schema:'deadbyte.r40-parity.v1',status:'passed',completed_at_utc:new Date().toISOString(),execution_provider:'deadbyte_mcp',rdc_operation_count:0,
+    candidate:{release_id:active.release_id,version:active.version,manifest_sha256:candidateManifest},
+    immutable_slot:{protected:true,release_root:path.resolve(active.release_root),development_root:developmentRoot},
+    local_full:localFull,public_compact:publicCompact,autonomous,desktop_guarded:desktopGuarded,before_rollback_disarmed:beforeRollback,
+    rollback:{...rollbackPair.completed,scheduled_operation_id:rollbackPair.scheduled.operation_id},
+    predecessor:{release_id:predecessor.release_id,version:predecessor.version,manifest_sha256:predecessor.manifest_sha256},predecessor_disarmed:predecessorDisarmed,
+    stage_restore:stageRestore,
+    restore:{...restorePair.completed,scheduled_operation_id:restorePair.scheduled.operation_id},
+    successor:{release_id:successor.release_id,version:successor.version,manifest_sha256:successor.manifest_sha256},successor_disarmed:successorDisarmed,
+    requirements:{
+      tree_read:publicCompact.tree_entries>=0&&publicCompact.coding_stat_verified===true,
+      precondition_mutation:publicCompact.machine_fs_receipts_verified>=3,
+      search:publicCompact.coding_search_result_count>=1&&publicCompact.observation_search_result_count>=1,
+      owned_process:typeof publicCompact.process_session_id==='string'&&publicCompact.process_output_bytes>0,
+      observation:publicCompact.observation_receipts_verified>=2,
+      coding_loop:publicCompact.coding_receipts_verified===2,
+      autonomy:autonomous.signed_release_verified===true&&autonomous.observed_failure_before_replan===true,
+      interrupted_recovery:rollbackPair.completed.state==='completed'&&restorePair.completed.state==='completed',
+      evidence_verification:publicCompact.machine_fs_receipts_verified>=3&&autonomous.signed_release_verified===true,
+      compact_closure:publicCompact.capability_closure===true&&successorDisarmed.capability_closure===true,
+      full_surface:localFull.tool_count===80&&localFull.strict_output_schemas===true,
+      desktop_readonly:publicCompact.desktop_armed===false&&publicCompact.desktop_observation_receipt_verified===true&&publicCompact.desktop_grounding_receipt_verified===true,
+      desktop_guarded_input:desktopGuarded.native_injected===true&&desktopGuarded.replay_performed===false&&desktopGuarded.action_receipts_verified===3
+    }
+  };
+  validateParityEvidence(evidence);
+  const evidenceDir=path.join(stateRoot,'evidence','release');await mkdir(evidenceDir,{recursive:true});
+  const evidencePath=path.join(evidenceDir,`r40-parity-${candidateManifest.slice(0,16)}.json`);
+  const bytes=Buffer.from(`${JSON.stringify(evidence,null,2)}\n`,'utf8');await writeFile(evidencePath,bytes);
+  return {evidence,evidence_path:evidencePath,evidence_sha256:sha256(bytes)};
+}
+
+if(process.argv[1]&&path.resolve(process.argv[1])===fileURLToPath(import.meta.url)){
+  const receipt=process.argv[2];if(!receipt) throw new Error('usage: node scripts/release-parity-r40.mjs <activation-receipt.json>');
+  runReleaseParity(receipt).then(result=>console.log(JSON.stringify({status:'passed',...result},null,2))).catch(error=>{console.error(error instanceof Error?error.stack:String(error));process.exitCode=1;});
+}

package/scripts/release-parity-tests-r40.ps1

@@ -0,0 +1,9 @@
+$ErrorActionPreference = 'Stop'
+Set-StrictMode -Version 2.0
+$root = Split-Path -Parent $PSScriptRoot
+Push-Location $root
+try {
+    & node.exe --test test\controller.test.mjs test\controller-desktop-r40.test.mjs test\r40-finalization.test.mjs test\release-version.test.mjs test\desktop-contract-r40.test.mjs test\desktop-policy-r40.test.mjs test\desktop-observer-r40.test.mjs test\desktop-input-r40.test.mjs test\desktop-uia-r40.test.mjs test\desktop-runtime-r40.test.mjs test\desktop-memory-r40.test.mjs test\desktop-mcp-tools-r40.test.mjs test\desktop-adversarial-r40.test.mjs test\autonomous-desktop-r40.test.mjs test\release-generation.test.mjs test\runtime-self-update.test.mjs test\r37-0110-history.test.mjs test\r37-agent-fabric.test.mjs test\remote-live-log-r37.test.mjs test\remote-session-cli.test.mjs test\r36-finalization.test.mjs test\r36-release-identity.test.mjs test\deferred-slot-operation.test.mjs
+    if ($LASTEXITCODE -ne 0) { throw "R40 release parity tests failed with exit code $LASTEXITCODE" }
+    Write-Output 'R40 RELEASE PARITY TEST PASS'
+} finally { Pop-Location }

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

@@ -0,0 +1,52 @@
+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';
+
+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.12.0 / R40 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.12.0',`Windows gate evidence requires V0.12.0, found ${pkg.version}`);
+  const completed=clock();
+  insist(completed instanceof Date&&!Number.isNaN(completed.getTime()),'Windows gate evidence clock invalid');
+  const evidence={
+    schema:'deadbyte.r40-windows-gate.v1',status:'passed',exit_code:0,version:'0.12.0',
+    marker,completed_at_utc:completed.toISOString(),manifest_sha256:manifestSha256
+  };
+  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,`r40-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};
+  }catch(error){
+    if(error?.code!=='EEXIST') throw error;
+    const existingBytes=await readFile(file);
+    const existing=JSON.parse(existingBytes.toString('utf8'));
+    insist(existing.schema===evidence.schema&&existing.status==='passed'&&existing.exit_code===0,'existing Windows gate evidence invalid');
+    insist(existing.version==='0.12.0'&&existing.marker===marker&&existing.manifest_sha256===manifestSha256,'existing Windows gate evidence binding mismatch');
+    return {status:'existing',path:file,sha256:sha256(existingBytes),manifest_sha256:manifestSha256};
+  }
+}
+
+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/autonomous-context-engine.mjs

@@ -213,7 +213,7 @@ function historicalEvidence({ contexts, observations, loopState }) {
   };
 }
 
-export function buildLoopContext({ goal, policy, loopState = {}, tree = [], contexts = [], observations = [], decisions = [], projectMemory = null, capabilities = null }) {
+export function buildLoopContext({ goal, policy, loopState = {}, tree = [], contexts = [], observations = [], decisions = [], projectMemory = null, desktopMemory = 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});
@@ -249,6 +249,7 @@ 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),
     capabilities:capabilities===null?null:structuredClone(capabilities),
     profiles
   };

package/src/autonomous-planner-contracts.mjs

@@ -92,6 +92,14 @@ const r34PatchOperationSchema = z.discriminatedUnion('kind',[
 const plannerCursor=z.string().max(4096).nullable().default(null);
 const plannerFiles=z.array(z.strictObject({path:relPath,encoding:z.enum(['utf8','base64']).default('utf8')})).min(1).max(32);
 const plannerSemanticPosition={path:relPath,line:z.number().int().min(0),column:z.number().int().min(0)};
+const plannerDesktopPoint=z.strictObject({x:z.number().int().min(-131072).max(131072),y:z.number().int().min(-131072).max(131072)});
+const plannerDesktopKey=z.string().regex(/^(?:[A-Z0-9]|F(?:[1-9]|1[0-2])|ENTER|ESC|TAB|SPACE|BACKSPACE|DELETE|INSERT|HOME|END|PAGEUP|PAGEDOWN|LEFT|RIGHT|UP|DOWN|CTRL|ALT|SHIFT|WIN)$/);
+const plannerDesktopActionKind=z.enum(['pointer_move','click_primary','click_secondary','double_click_primary','scroll','key_chord','text_input']);
+const plannerDesktopQuery=z.strictObject({
+  kind:z.enum(['root','name_exact','name_contains','automation_id_exact','control_type']),
+  value:z.string().max(512).default(''),max_results:z.number().int().min(1).max(16).default(8),
+  ordinal:z.number().int().min(0).max(15).default(0)
+});
 const r36TypedActionSchemas=[
   z.strictObject({kind:z.literal('search'),path:relPath.default('.'),target:z.enum(['content','path']).default('content'),mode:z.enum(['literal','regex']).default('literal'),pattern:z.string().min(1).max(256),case_sensitive:z.boolean().default(false),max_results:z.number().int().min(1).max(1000).default(200),max_file_bytes:z.number().int().min(1).max(4194304).default(262144),max_scan_bytes:z.number().int().min(1).max(67108864).default(4194304),page_size:z.number().int().min(1).max(500).default(100),cursor:plannerCursor}),
   z.strictObject({kind:z.literal('stat'),path:relPath.default('.'),hash:z.boolean().default(false)}),
@@ -121,7 +129,17 @@ const r36TypedActionSchemas=[
   z.strictObject({kind:z.literal('observation_search_page'),search_id:z.string().regex(HEX64),cursor:plannerCursor,limit:z.number().int().min(1).max(500).default(100)}),
   z.strictObject({kind:z.literal('observation_search_cancel'),search_id:z.string().regex(HEX64)}),
   z.strictObject({kind:z.literal('observation_process_list'),include_external:z.boolean().default(false),cursor:plannerCursor,limit:z.number().int().min(1).max(256).default(100)}),
-  z.strictObject({kind:z.literal('observation_system_status')})
+  z.strictObject({kind:z.literal('observation_system_status')}),
+  z.strictObject({kind:z.literal('desktop_status')}),
+  z.strictObject({kind:z.literal('desktop_observe')}),
+  z.strictObject({kind:z.literal('desktop_target'),frame_id:z.string().regex(HEX64),uia_query:plannerDesktopQuery}),
+  z.strictObject({
+    kind:z.literal('desktop_action'),action_kind:plannerDesktopActionKind,expected_frame_id:z.string().regex(HEX64),
+    target_id:z.string().regex(HEX64).nullable().default(null),point:plannerDesktopPoint.nullable().default(null),
+    scroll_delta:z.number().int().min(-12000).max(12000).nullable().default(null),
+    key_chord:z.array(plannerDesktopKey).min(1).max(5).nullable().default(null),
+    text:z.string().min(1).max(4096).refine(value=>!value.includes('\u0000'),'desktop text contains NUL').nullable().default(null)
+  })
 ];
 const r34ActionSchema = z.discriminatedUnion('kind',[
   z.strictObject({kind:z.literal('patch'),operations:z.array(r34PatchOperationSchema).min(1).max(32)}),

package/src/autonomous-planner.mjs

@@ -134,6 +134,26 @@ function validateR36TypedAction(action) {
   if (typeof action.destination_path === 'string') pathFields.push(action.destination_path);
   for (const item of action.files ?? []) if (typeof item?.path === 'string') pathFields.push(item.path);
   for (const candidate of pathFields) validatePortableRelativePath(candidate);
+  if(action.kind==='desktop_target'){
+    const q=action.uia_query;
+    if(q.kind==='root'&&q.value!=='') throw new Error('desktop root query value must be empty');
+    if(q.kind!=='root'&&q.value.length<1) throw new Error('desktop UIA query value required');
+    if(q.ordinal>=q.max_results) throw new Error('desktop UIA ordinal must be below max_results');
+  }
+  if(action.kind==='desktop_action'){
+    const pointer=['pointer_move','click_primary','click_secondary','double_click_primary','scroll'].includes(action.action_kind);
+    if(pointer&&((action.target_id===null)===(action.point===null))) throw new Error('desktop pointer action requires exactly one of target_id or point');
+    if(!pointer&&(action.target_id!==null||action.point!==null)) throw new Error('desktop non-pointer action cannot carry target_id or point');
+    if(action.action_kind==='scroll'){
+      if(action.scroll_delta===null||action.scroll_delta===0) throw new Error('desktop scroll requires non-zero scroll_delta');
+    }else if(action.scroll_delta!==null) throw new Error('desktop non-scroll action cannot carry scroll_delta');
+    if(action.action_kind==='key_chord'){
+      if(action.key_chord===null||new Set(action.key_chord).size!==action.key_chord.length) throw new Error('desktop key_chord missing or duplicate');
+    }else if(action.key_chord!==null) throw new Error('desktop non-key action cannot carry key_chord');
+    if(action.action_kind==='text_input'){
+      if(action.text===null) throw new Error('desktop text_input requires text');
+    }else if(action.text!==null) throw new Error('desktop non-text action cannot carry text');
+  }
   return action;
 }
 function normalizeR36TypedAction(action) {
@@ -334,6 +354,7 @@ export function buildPlannerPrompt({ goal, policy, view }) {
     observations:view.observations ?? [],
     decisions:view.recent_decisions ?? [],
     projectMemory:view.project_memory ?? null,
+    desktopMemory:view.desktop_memory ?? null,
     capabilities:view.capabilities ?? null
   });
   const stateJson = canonicalJson(state);
@@ -350,6 +371,7 @@ export function buildPlannerPrompt({ goal, policy, view }) {
     'patch: operations are DEADBYTE Native Diff operations (write, replace, delete) and MUST use exact SHA-256 preconditions from supplied context.',
     'run_profile: profile_id must be one of the policy profile ids in state.',
     'delegate: operation is one bounded existing-runtime action. Allowed kinds: machine_stat, machine_list, machine_read, observation_search_start, observation_search_status, observation_search_page, observation_search_cancel, observation_process_list, observation_system_status, process_start, process_read, process_status, process_list, process_action, process_terminate.',
+    'When Desktop capabilities are present, use typed desktop_status, desktop_observe, desktop_target with one bounded UIA query, and desktop_action. desktop_action requires separate Desktop authority; Autonomous authority never implies Desktop authority. After stale or unknown Desktop evidence, observe again and replan; never blindly repeat an action.',
     'Delegate paths are relative to the goal root. Process start accepts only profile_id and cwd; process_action accepts only session_id and fixed action_id. Never emit raw stdin, executable, PID, environment, shell command, or process arguments.',
     'finish only when the goal is actually satisfied. Required release profiles are enforced by the engine and cannot be bypassed.',
     'Never invent a file SHA. If content is elided or the current SHA/content is missing, choose inspect first.',